instruction stringclasses 1
value | output stringclasses 2
values | input stringlengths 21 96.3k |
|---|---|---|
negative | ssize_t nbd_wr_syncv(QIOChannel *ioc, struct iovec *iov, size_t niov, size_t length, bool do_read, Error **errp){ ssize_t done = 0; struct iovec *local_iov = g_new(struct iovec, niov); struct iovec *local_iov_head = local_iov; unsigned int nlocal_iov = niov; nlocal_iov = iov_copy(local_iov, nlocal_iov, iov, niov, 0, le... | |
negative | void qemu_init_vcpu(void *_env){ CPUState *env = _env; if (kvm_enabled()) kvm_init_vcpu(env); env->nr_cores = smp_cores; env->nr_threads = smp_threads; return;} | |
negative | void kvm_inject_x86_mce(CPUState *cenv, int bank, uint64_t status, uint64_t mcg_status, uint64_t addr, uint64_t misc, int flag){#ifdef KVM_CAP_MCE struct kvm_x86_mce mce = { .bank = bank, .status = status, .mcg_status = mcg_status, .addr = addr, .misc = misc, }; if (flag & MCE_BROADCAST) { kvm_mce_broadcast_rest(cenv);... | |
negative | readv_f(int argc, char **argv){struct timeval t1, t2;int Cflag = 0, qflag = 0, vflag = 0;int c, cnt;char *buf;int64_t offset;int total;int nr_iov;QEMUIOVector qiov;int pattern = 0;int Pflag = 0;while ((c = getopt(argc, argv, "CP:qv")) != EOF) {switch (c) {case 'C':Cflag = 1;break;case 'P':Pflag = 1;pattern = atoi(optar... | |
negative | static int init_directories(BDRVVVFATState* s, const char *dirname, int heads, int secs){ bootsector_t* bootsector; mapping_t* mapping; unsigned int i; unsigned int cluster; memset(&(s->first_sectors[0]),0,0x40*0x200); s->cluster_size=s->sectors_per_cluster*0x200; s->cluster_buffer=g_malloc(s->cluster_size); /* * The f... | |
negative | int kvm_vcpu_ioctl(CPUState *env, int type, ...){ int ret; void *arg; va_list ap; va_start(ap, type); arg = va_arg(ap, void *); va_end(ap); ret = ioctl(env->kvm_fd, type, arg); if (ret == -1) ret = -errno; return ret;} | |
negative | ssize_t qemu_put_compression_data(QEMUFile *f, const uint8_t *p, size_t size, int level){ ssize_t blen = IO_BUF_SIZE - f->buf_index - sizeof(int32_t); if (blen < compressBound(size)) { return 0; } if (compress2(f->buf + f->buf_index + sizeof(int32_t), (uLongf *)&blen, (Bytef *)p, size, level) != Z_OK) { error_report("C... | |
negative | static inline void vc1_pred_mv_intfr(VC1Context *v, int n, int dmv_x, int dmv_y, int mvn, int r_x, int r_y, uint8_t* is_intra, int dir){ MpegEncContext *s = &v->s; int xy, wrap, off = 0; int A[2], B[2], C[2]; int px = 0, py = 0; int a_valid = 0, b_valid = 0, c_valid = 0; int field_a, field_b, field_c; // 0: same, 1: op... | |
positive | static void free_buffers(VP8Context *s){ int i; if (s->thread_data) for (i = 0; i < MAX_THREADS; i++) { av_freep(&s->thread_data[i].filter_strength); av_freep(&s->thread_data[i].edge_emu_buffer); } av_freep(&s->thread_data); av_freep(&s->macroblocks_base); av_freep(&s->intra4x4_pred_mode_top); av_freep(&s->top_nnz); av... | |
positive | static void intel_hda_realize(PCIDevice *pci, Error **errp){ IntelHDAState *d = INTEL_HDA(pci); uint8_t *conf = d->pci.config; d->name = object_get_typename(OBJECT(d)); pci_config_set_interrupt_pin(conf, 1); /* HDCTL off 0x40 bit 0 selects signaling mode (1-HDA, 0 - Ac97) 18.1.19 */ conf[0x40] = 0x01; memory_region_ini... | |
positive | static void vnc_dpy_copy(DisplayChangeListener *dcl, int src_x, int src_y, int dst_x, int dst_y, int w, int h){ VncDisplay *vd = container_of(dcl, VncDisplay, dcl); VncState *vs, *vn; uint8_t *src_row; uint8_t *dst_row; int i, x, y, pitch, inc, w_lim, s; int cmp_bytes; vnc_refresh_server_surface(vd); QTAILQ_FOREACH_SAF... | |
positive | static int write_refcount_block_entries(BlockDriverState *bs, int64_t refcount_block_offset, int first_index, int last_index){ BDRVQcowState *s = bs->opaque; size_t size; int ret; if (cache_refcount_updates) { first_index &= ~(REFCOUNTS_PER_SECTOR - 1); last_index = (last_index + REFCOUNTS_PER_SECTOR) & ~(REFCOUNTS_PER... | |
positive | static int qemu_rdma_source_init(RDMAContext *rdma, Error **errp, bool pin_all){ int ret, idx; Error *local_err = NULL, **temp = &local_err; /* * Will be validated against destination's actual capabilities * after the connect() completes. */ rdma->pin_all = pin_all; ret = qemu_rdma_resolve_host(rdma, temp); if (ret) { ... | |
positive | static int curl_open(BlockDriverState *bs, QDict *options, int flags, Error **errp){ BDRVCURLState *s = bs->opaque; CURLState *state = NULL; QemuOpts *opts; Error *local_err = NULL; const char *file; double d; static int inited = 0; if (flags & BDRV_O_RDWR) { error_setg(errp, "curl block device does not support writes"... | |
positive | static int compute_pkt_fields2(AVFormatContext *s, AVStream *st, AVPacket *pkt){ int delay = FFMAX(st->codec->has_b_frames, st->codec->max_b_frames > 0); int num, den, frame_size, i; av_dlog(s, "compute_pkt_fields2: pts:%s dts:%s cur_dts:%s b:%d size:%d st:%d\n", av_ts2str(pkt->pts), av_ts2str(pkt->dts), av_ts2str(st->... | |
positive | int qemu_get_fd(QEMUFile *f){ if (f->ops->get_fd) { return f->ops->get_fd(f->opaque); } return -1;} | |
positive | static int bdrv_open_common(BlockDriverState *bs, BlockDriverState *file, QDict *options, int flags, BlockDriver *drv, Error **errp){ int ret, open_flags; const char *filename; const char *node_name = NULL; Error *local_err = NULL; assert(drv != NULL); assert(bs->file == NULL); assert(options != NULL && bs->options != ... | |
positive | static int virtio_serial_load(QEMUFile *f, void *opaque, int version_id){ VirtIOSerial *s = opaque; VirtIOSerialPort *port; uint32_t max_nr_ports, nr_active_ports, ports_map; unsigned int i; if (version_id > 3) { /* The virtio device */ virtio_load(&s->vdev, f); if (version_id < 2) { return 0; /* The config space */ qe... | |
positive | static int cdg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; int ret; uint8_t command, inst; uint8_t cdg_data[CDG_DATA_SIZE]; AVFrame *frame = data; CDGraphicsContext *cc = avctx->priv_data; if (buf_size < CDG_MINIMUM_PKT_... | |
positive | static int nut_write_header(AVFormatContext *s){ NUTContext *nut = s->priv_data; ByteIOContext *bc = &s->pb; AVCodecContext *codec; int i, j, tmp_time, tmp_flags,tmp_stream, tmp_mul, tmp_size, tmp_fields; nut->avf= s; nut->stream =av_mallocz(sizeof(StreamContext)*s->nb_streams); put_buffer(bc, ID_STRING, strlen(ID_STRI... | |
positive | static inline int IRQ_testbit(IRQ_queue_t *q, int n_IRQ){ return test_bit(q->queue, n_IRQ);} | |
positive | static int vmdk_write_compressed(BlockDriverState *bs, int64_t sector_num, const uint8_t *buf, int nb_sectors){ BDRVVmdkState *s = bs->opaque; if (s->num_extents == 1 && s->extents[0].compressed) { Coroutine *co; AioContext *aio_context = bdrv_get_aio_context(bs); VmdkWriteCompressedCo data = { .bs = bs, .sector_num = ... | |
positive | static int tight_compress_data(VncState *vs, int stream_id, size_t bytes, int level, int strategy){ z_streamp zstream = &vs->tight.stream[stream_id]; int previous_out; if (bytes < VNC_TIGHT_MIN_TO_COMPRESS) { vnc_write(vs, vs->tight.tight.buffer, vs->tight.tight.offset); return bytes; } if (tight_init_stream(vs, stream... | |
positive | static void do_tb_flush(CPUState *cpu, run_on_cpu_data tb_flush_count){ tb_lock(); /* If it is already been done on request of another CPU, * just retry. */ if (tcg_ctx.tb_ctx.tb_flush_count != tb_flush_count.host_int) { goto done; }#if defined(DEBUG_TB_FLUSH) printf("qemu: flush code_size=%ld nb_tbs=%d avg_tb_size=%ld... | |
positive | int v9fs_co_st_gen(V9fsPDU *pdu, V9fsPath *path, mode_t st_mode, V9fsStatDotl *v9stat){ int err = 0; V9fsState *s = pdu->s; if (v9fs_request_cancelled(pdu)) { return -EINTR; if (s->ctx.exops.get_st_gen) { v9fs_path_read_lock(s); v9fs_co_run_in_worker( { err = s->ctx.exops.get_st_gen(&s->ctx, path, st_mode, &v9stat->st_... | |
negative | int avpicture_fill(AVPicture *picture, uint8_t *ptr, enum AVPixelFormat pix_fmt, int width, int height){ int ret; if ((ret = av_image_check_size(width, height, 0, NULL)) < 0) return ret; if ((ret = av_image_fill_linesizes(picture->linesize, pix_fmt, width)) < 0) return ret; return av_image_fill_pointers(picture->data, ... | |
positive | static int bdrv_open_driver(BlockDriverState *bs, BlockDriver *drv, const char *node_name, QDict *options, int open_flags, Error **errp){ Error *local_err = NULL; int ret; bdrv_assign_node_name(bs, node_name, &local_err); if (local_err) { error_propagate(errp, local_err); return -EINVAL; } bs->drv = drv; bs->read_only ... | |
positive | static int set_params(AVFilterContext *ctx, const char *params){ Frei0rContext *frei0r = ctx->priv; int i; for (i = 0; i < frei0r->plugin_info.num_params; i++) { f0r_param_info_t info; char *param; int ret; frei0r->get_param_info(&info, i); if (*params) { if (!(param = av_get_token(¶ms, "|"))) return AVERROR(ENOMEM... | |
positive | void do_load_fpscr (void){ /* The 32 MSB of the target fpr are undefined. * They'll be zero... */ union { float64 d; struct { uint32_t u[2]; } s; } u; int i;#ifdef WORDS_BIGENDIAN#define WORD0 0#define WORD1 1#else#define WORD0 1#define WORD1 0#endif u.s.u[WORD0] = 0; u.s.u[WORD1] = 0; for (i = 0; i < 8; i++) u.s.u[WOR... | |
negative | static int prepare_sdp_description(FFStream *stream, uint8_t **pbuffer, struct in_addr my_ip){ AVFormatContext *avc; AVStream *avs = NULL; AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL); AVDictionaryEntry *entry = av_dict_get(stream->metadata, "title", NULL, 0); int i; avc = avformat_alloc_context(); i... | |
positive | static void decode_init_vlc(H264Context *h){ static int done = 0; if (!done) { int i; done = 1; init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_BITS, 4*5, &chroma_dc_coeff_token_len [0], 1, 1, &chroma_dc_coeff_token_bits[0], 1, 1); for(i=0; i<4; i++){ init_vlc(&coeff_token_vlc[i], COEFF_TOKEN_VLC_BITS, 4... | |
positive | int av_buffersink_poll_frame(AVFilterContext *ctx){ BufferSinkContext *buf = ctx->priv; AVFilterLink *inlink = ctx->inputs[0]; av_assert0(!strcmp(ctx->filter->name, "buffersink") || !strcmp(ctx->filter->name, "abuffersink")); return av_fifo_size(buf->fifo)/sizeof(AVFilterBufferRef *) + ff_poll_frame(inlink);} | |
positive | int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *avpkt){ const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; MpegEncContext *s = avctx->priv_data; int ret; AVFrame *pict = data;#ifdef PRINT_FRAME_TIMEuint64_t time= rdtsc();#endif s->flags= avctx->flags; s->flags2= avctx->f... | |
positive | static void mmap_release_buffer(AVPacket *pkt){ struct v4l2_buffer buf; int res, fd; struct buff_data *buf_descriptor = pkt->priv; memset(&buf, 0, sizeof(struct v4l2_buffer)); buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; buf.memory = V4L2_MEMORY_MMAP; buf.index = buf_descriptor->index; fd = buf_descriptor->fd; av_free(buf_d... | |
positive | static int configure_video_filters(FilterGraph *fg){ InputStream *ist = fg->inputs[0]->ist; OutputStream *ost = fg->outputs[0]->ost; AVFilterContext *in_filter, *out_filter, *filter; AVCodecContext *codec = ost->st->codec; AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc(); char *pix_fmts; AVRational ... | |
negative | static inline void RET_STOP (DisasContext *ctx){ gen_update_nip(ctx, ctx->nip); ctx->exception = EXCP_MTMSR;} | |
negative | void qdev_property_add_legacy(DeviceState *dev, Property *prop, Error **errp){ gchar *type; type = g_strdup_printf("legacy<%s>", prop->info->name); qdev_property_add(dev, prop->name, type, qdev_get_legacy_property, qdev_set_legacy_property, NULL, prop, errp); g_free(type);} | |
negative | uint64_t helper_fmadd(CPUPPCState *env, uint64_t arg1, uint64_t arg2, uint64_t arg3){ CPU_DoubleU farg1, farg2, farg3; farg1.ll = arg1; farg2.ll = arg2; farg3.ll = arg3; if (unlikely((float64_is_infinity(farg1.d) && float64_is_zero(farg2.d)) || (float64_is_zero(farg1.d) && float64_is_infinity(farg2.d)))) { /* Multiplic... | |
negative | static void tcg_out_andi64(TCGContext *s, TCGReg dst, TCGReg src, uint64_t c){ int mb, me; assert(TCG_TARGET_REG_BITS == 64); if (mask64_operand(c, &mb, &me)) { if (mb == 0) { tcg_out_rld(s, RLDICR, dst, src, 0, me); } else { tcg_out_rld(s, RLDICL, dst, src, 0, mb); } } else if ((c & 0xffff) == c) { tcg_out32(s, ANDI |... | |
negative | static void eth_cleanup(NetClientState *nc){ ETRAXFSEthState *eth = qemu_get_nic_opaque(nc); /* Disconnect the client. */ eth->dma_out->client.push = NULL; eth->dma_out->client.opaque = NULL; eth->dma_in->client.opaque = NULL; eth->dma_in->client.pull = NULL; g_free(eth);} | |
negative | long do_sigreturn(CPUCRISState *env){struct target_signal_frame *frame;abi_ulong frame_addr;target_sigset_t target_set;sigset_t set;int i;frame_addr = env->regs[R_SP];/* Make sure the guest isn't playing games. */if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 1))goto badframe;/* Restore blocked signals */if (__... | |
negative | static inline int epoll_events_from_pfd(int pfd_events){ return (pfd_events & G_IO_IN ? EPOLLIN : 0) | (pfd_events & G_IO_OUT ? EPOLLOUT : 0) | (pfd_events & G_IO_HUP ? EPOLLHUP : 0) | (pfd_events & G_IO_ERR ? EPOLLERR : 0);} | |
negative | static int mov_write_moov_tag(ByteIOContext *pb, MOVContext *mov){ int pos, i; pos = url_ftell(pb); put_be32(pb, 0); /* size placeholder*/ put_tag(pb, "moov"); mov->timescale = globalTimescale; for (i=0; i<MAX_STREAMS; i++) { if(mov->tracks[i].entry <= 0) continue; if(mov->tracks[i].enc->codec_type == CODEC_TYPE_VIDEO)... | |
negative | static void mips_cps_realize(DeviceState *dev, Error **errp){ MIPSCPSState *s = MIPS_CPS(dev); CPUMIPSState *env; MIPSCPU *cpu; int i; Error *err = NULL; target_ulong gcr_base; bool itu_present = false; for (i = 0; i < s->num_vp; i++) { cpu = cpu_mips_init(s->cpu_model); if (cpu == NULL) { error_setg(errp, "%s: CPU ini... | |
negative | void cpu_loop(CPUM68KState *env){ CPUState *cs = CPU(m68k_env_get_cpu(env)); int trapnr; unsigned int n; target_siginfo_t info; TaskState *ts = cs->opaque; for(;;) { cpu_exec_start(cs); trapnr = cpu_m68k_exec(cs); cpu_exec_end(cs); switch(trapnr) { case EXCP_ILLEGAL: { if (ts->sim_syscalls) { uint16_t nr; get_user_u16(... | |
negative | void usb_attach(USBPort *port, USBDevice *dev){ if (dev != NULL) { /* attach */ if (port->dev) { usb_attach(port, NULL); } dev->port = port; port->dev = dev; port->ops->attach(port); usb_send_msg(dev, USB_MSG_ATTACH); } else { /* detach */ dev = port->dev; port->ops->detach(port); if (dev) { usb_send_msg(dev, USB_MSG_D... | |
negative | static void qerror_set_data(QError *qerr, const char *fmt, va_list *va){ QObject *obj; obj = qobject_from_jsonv(fmt, va); if (!obj) { qerror_abort(qerr, "invalid format '%s'", fmt); } if (qobject_type(obj) != QTYPE_QDICT) { qerror_abort(qerr, "error format is not a QDict '%s'", fmt); } qerr->error = qobject_to_qdict(ob... | |
negative | udp_emu(struct socket *so, struct mbuf *m){struct sockaddr_in addr; int addrlen = sizeof(addr);#ifdef EMULATE_TALKCTL_MSG_OLD *omsg;CTL_MSG *nmsg;char buff[sizeof(CTL_MSG)];u_char type;struct talk_request {struct talk_request *next;struct socket *udp_so;struct socket *tcp_so;} *req;static struct talk_request *req_tbl =... | |
negative | static ssize_t usbnet_receive(VLANClientState *nc, const uint8_t *buf, size_t size){ USBNetState *s = DO_UPCAST(NICState, nc, nc)->opaque; struct rndis_packet_msg_type *msg; if (s->rndis) { msg = (struct rndis_packet_msg_type *) s->in_buf; if (!s->rndis_state == RNDIS_DATA_INITIALIZED) return -1; if (size + sizeof(stru... | |
negative | static void mpcore_priv_map_setup(mpcore_priv_state *s){ int i; SysBusDevice *gicbusdev = sysbus_from_qdev(s->gic); SysBusDevice *busdev = sysbus_from_qdev(s->mptimer); memory_region_init(&s->container, "mpcode-priv-container", 0x2000); memory_region_init_io(&s->iomem, &mpcore_scu_ops, s, "mpcore-scu", 0x100); memory_r... | |
negative | static int proxy_readdir_r(FsContext *ctx, V9fsFidOpenState *fs, struct dirent *entry, struct dirent **result){ return readdir_r(fs->dir, entry, result);} | |
negative | int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl){ const SPS *sps; const PPS *pps; unsigned int first_mb_in_slice; unsigned int pps_id; int ret; unsigned int slice_type, tmp, i, j; int last_pic_structure, last_pic_droppable; int needs_reinit = 0; int field_pic_flag, bottom_field_flag; int frame_num,... | |
negative | void virtio_blk_handle_request(VirtIOBlockReq *req, MultiReqBuffer *mrb){ uint32_t type; struct iovec *in_iov = req->elem.in_sg; struct iovec *iov = req->elem.out_sg; unsigned in_num = req->elem.in_num; unsigned out_num = req->elem.out_num; if (req->elem.out_num < 1 || req->elem.in_num < 1) { error_report("virtio-blk m... | |
negative | static void net_vhost_user_event(void *opaque, int event){ VhostUserState *s = opaque; switch (event) { case CHR_EVENT_OPENED: vhost_user_start(s); net_vhost_link_down(s, false); error_report("chardev \"%s\" went up", s->chr->label); break; case CHR_EVENT_CLOSED: net_vhost_link_down(s, true); vhost_user_stop(s); error_... | |
negative | static uint32_t virtio_blk_get_features(VirtIODevice *vdev){ VirtIOBlock *s = to_virtio_blk(vdev); uint32_t features = 0; features |= (1 << VIRTIO_BLK_F_SEG_MAX); features |= (1 << VIRTIO_BLK_F_GEOMETRY); if (bdrv_enable_write_cache(s->bs)) features |= (1 << VIRTIO_BLK_F_WCACHE);#ifdef __linux__ features |= (1 << VIRTI... | |
negative | static void vmsvga_bios_write(void *opaque, uint32_t address, uint32_t data){ printf("%s: what are we supposed to do with (%08x)?\n", __FUNCTION__, data);} | |
negative | static void platform_ioport_map(PCIDevice *pci_dev, int region_num, pcibus_t addr, pcibus_t size, int type){ PCIXenPlatformState *d = DO_UPCAST(PCIXenPlatformState, pci_dev, pci_dev); register_ioport_write(addr, size, 1, xen_platform_ioport_writeb, d); register_ioport_read(addr, size, 1, xen_platform_ioport_readb, d);} | |
negative | static void qemu_chr_fire_open_event(void *opaque){ CharDriverState *s = opaque; qemu_chr_be_event(s, CHR_EVENT_OPENED); qemu_free_timer(s->open_timer); s->open_timer = NULL;} | |
negative | static int sd_snapshot_goto(BlockDriverState *bs, const char *snapshot_id){ BDRVSheepdogState *s = bs->opaque; BDRVSheepdogState *old_s; char vdi[SD_MAX_VDI_LEN], tag[SD_MAX_VDI_TAG_LEN]; char *buf = NULL; uint32_t vid; uint32_t snapid = 0; int ret = 0, fd; old_s = g_malloc(sizeof(BDRVSheepdogState)); memcpy(old_s, s, ... | |
negative | static void ehci_advance_state(EHCIState *ehci, int async){ EHCIQueue *q = NULL; int again; int iter = 0; do { if (ehci_get_state(ehci, async) == EST_FETCHQH) { iter++; /* if we are roaming a lot of QH without executing a qTD * something is wrong with the linked list. TO-DO: why is * this hack needed? */ assert(iter < ... | |
negative | static av_always_inline void mpeg_motion_lowres(MpegEncContext *s, uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, int field_based, int bottom_field, int field_select, uint8_t **ref_picture, h264_chroma_mc_func *pix_op, int motion_x, int motion_y, int h, int mb_y){ uint8_t *ptr_y, *ptr_cb, *ptr_cr; int mx, my, src... | |
negative | static bool run_poll_handlers_once(AioContext *ctx){ bool progress = false; AioHandler *node; QLIST_FOREACH_RCU(node, &ctx->aio_handlers, node) { if (!node->deleted && node->io_poll && aio_node_check(ctx, node->is_external) && node->io_poll(node->opaque)) { progress = true; } /* Caller handles freeing deleted nodes. Do... | |
negative | print_insn_ppi (int field_b, struct disassemble_info *info){ static const char *sx_tab[] = { "x0", "x1", "a0", "a1" }; static const char *sy_tab[] = { "y0", "y1", "m0", "m1" }; fprintf_ftype fprintf_fn = info->fprintf_func; void *stream = info->stream; unsigned int nib1, nib2, nib3; unsigned int altnib1, nib4; const ch... | |
negative | static int monitor_parse(const char *devname){ static int index = 0; char label[32]; if (strcmp(devname, "none") == 0) return 0; if (index == MAX_MONITOR_DEVICES) { fprintf(stderr, "qemu: too many monitor devices\n"); exit(1); } if (index == 0) { snprintf(label, sizeof(label), "monitor"); } else { snprintf(label, sizeo... | |
negative | void ppc_store_sdr1(CPUPPCState *env, target_ulong value){ qemu_log_mask(CPU_LOG_MMU, "%s: " TARGET_FMT_lx "\n", __func__, value); assert(!env->external_htab); env->spr[SPR_SDR1] = value;#if defined(TARGET_PPC64) if (env->mmu_model & POWERPC_MMU_64) { PowerPCCPU *cpu = ppc_env_get_cpu(env); Error *local_err = NULL; ppc... | |
negative | static av_always_inline void idct_internal(uint8_t *dst, DCTELEM *block, int stride, int block_stride, int shift, int add){ int i; uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; block[0] += 1<<(shift-1); for(i=0; i<4; i++){ const int z0= block[0 + block_stride*i] + block[2 + block_stride*i]; const int z1= block[0 + block_str... | |
negative | static int mp_dacl_removexattr(FsContext *ctx, const char *path, const char *name){ int ret; char buffer[PATH_MAX]; ret = lremovexattr(rpath(ctx, path, buffer), MAP_ACL_DEFAULT); if (ret == -1 && errno == ENODATA) { /* * We don't get ENODATA error when trying to remove a * posix acl that is not present. So don't throw ... | |
negative | void *qemu_thread_join(QemuThread *thread){ QemuThreadData *data; void *ret; HANDLE handle; data = thread->data; if (!data) { return NULL; } /* * Because multiple copies of the QemuThread can exist via * qemu_thread_get_self, we need to store a value that cannot * leak there. The simplest, non racy way is to store the ... | |
negative | void OPPROTO op_sti(void){ raise_exception(EXCP0D_GPF);} | |
negative | static void test_pci_spec(void){ AHCIQState *ahci; ahci = ahci_boot(); ahci_test_pci_spec(ahci); ahci_shutdown(ahci);} | |
negative | static uint32_t nvdimm_rw_label_data_check(NVDIMMDevice *nvdimm, uint32_t offset, uint32_t length){ uint32_t ret = 3 /* Invalid Input Parameters */; if (offset + length < offset) { nvdimm_debug("offset %#x + length %#x is overflow.\n", offset, length); return ret; } if (nvdimm->label_size < offset + length) { nvdimm_de... | |
negative | static inline void gen_evmwumia(DisasContext *ctx){ TCGv_i64 tmp; if (unlikely(!ctx->spe_enabled)) { gen_exception(ctx, POWERPC_EXCP_APU); return; } gen_evmwumi(ctx); /* rD := rA * rB */ tmp = tcg_temp_new_i64(); /* acc := rD */ gen_load_gpr64(tmp, rD(ctx->opcode)); tcg_gen_st_i64(tmp, cpu_env, offsetof(CPUState, spe_a... | |
negative | QmpInputVisitor *qmp_input_visitor_new(QObject *obj, bool strict){ QmpInputVisitor *v; v = g_malloc0(sizeof(*v)); v->visitor.type = VISITOR_INPUT; v->visitor.start_struct = qmp_input_start_struct; v->visitor.end_struct = qmp_input_end_struct; v->visitor.start_list = qmp_input_start_list; v->visitor.next_list = qmp_inpu... | |
positive | static int mxf_parse_index(MXFContext *mxf, int track_id, AVStream *st){ int64_t accumulated_offset = 0; int j, k, ret, nb_sorted_segments; MXFIndexTableSegment **sorted_segments; int n_delta = track_id - 1; /* TrackID = 1-based stream index */ if (track_id < 1) { av_log(mxf->fc, AV_LOG_ERROR, "TrackID not positive: %i... | |
positive | static void fill_picture_parameters(const AVCodecContext *avctx, AVDXVAContext *ctx, const HEVCContext *h, DXVA_PicParams_HEVC *pp){ const HEVCFrame *current_picture = h->ref; int i, j, k; memset(pp, 0, sizeof(*pp)); pp->PicWidthInMinCbsY = h->sps->min_cb_width; pp->PicHeightInMinCbsY = h->sps->min_cb_height; pp->wForm... | |
positive | static void isa_ipmi_bmc_check(Object *obj, const char *name, Object *val, Error **errp){ IPMIBmc *bmc = IPMI_BMC(val); if (bmc->intf) error_setg(errp, "BMC object is already in use");} | |
positive | av_cold int ff_yuv2rgb_c_init_tables(SwsContext *c, const int inv_table[4], int fullRange, int brightness, int contrast, int saturation){ const int isRgb = c->dstFormat == AV_PIX_FMT_RGB32 || c->dstFormat == AV_PIX_FMT_RGB32_1 || c->dstFormat == AV_PIX_FMT_BGR24 || c->dstFormat == AV_PIX_FMT_RGB565BE || c->dstFormat ==... | |
positive | abi_long do_syscall(void *cpu_env, int num, abi_long arg1, abi_long arg2, abi_long arg3, abi_long arg4, abi_long arg5, abi_long arg6, abi_long arg7, abi_long arg8){ CPUState *cpu = ENV_GET_CPU(cpu_env); abi_long ret; struct stat st; struct statfs stfs; void *p;#if defined(DEBUG_ERESTARTSYS) /* Debug-only code for exerc... | |
negative | static void build_chunks(MOVTrack *trk){ int i; MOVIentry *chunk= &trk->cluster[0]; uint64_t chunkSize = chunk->size; chunk->chunkNum= 1; trk->chunkCount= 1; for(i=1; i<trk->entry; i++){ if(chunk->pos + chunkSize == trk->cluster[i].pos){ chunkSize += trk->cluster[i].size; chunk->samplesInChunk += trk->cluster[i].entrie... | |
positive | static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic, int *got_packet){ ProresContext *ctx = avctx->priv_data; uint8_t *orig_buf, *buf, *slice_hdr, *slice_sizes, *tmp; uint8_t *picture_size_pos; PutBitContext pb; int x, y, i, mb, q = 0; int sizes[4] = { 0 }; int slice_hdr_size = 2 + 2 * (ctx... | |
positive | void ff_lag_rac_init(lag_rac *l, GetBitContext *gb, int length){ int i, j; /* According to reference decoder "1st byte is garbage", * however, it gets skipped by the call to align_get_bits() */ align_get_bits(gb); l->bytestream_start = l->bytestream = gb->buffer + get_bits_count(gb) / 8; l->bytestream_end = l->bytestre... | |
positive | void vmstate_unregister(DeviceState *dev, const VMStateDescription *vmsd, void *opaque){ SaveStateEntry *se, *new_se; QTAILQ_FOREACH_SAFE(se, &savevm_handlers, entry, new_se) { if (se->vmsd == vmsd && se->opaque == opaque) { QTAILQ_REMOVE(&savevm_handlers, se, entry); qemu_free(se); | |
positive | void iothread_stop_all(void){ Object *container = object_get_objects_root(); BlockDriverState *bs; BdrvNextIterator it; for (bs = bdrv_first(&it); bs; bs = bdrv_next(&it)) { AioContext *ctx = bdrv_get_aio_context(bs); if (ctx == qemu_get_aio_context()) { continue; } aio_context_acquire(ctx); bdrv_set_aio_context(bs, qe... | |
negative | int apic_get_interrupt(DeviceState *d){ APICState *s = DO_UPCAST(APICState, busdev.qdev, d); int intno; /* if the APIC is installed or enabled, we let the 8259 handle the IRQs */ if (!s) return -1; if (!(s->spurious_vec & APIC_SV_ENABLE)) return -1; /* XXX: spurious IRQ handling */ intno = get_highest_priority_int(s->i... | |
negative | static inline void decode_residual_inter(AVSContext *h) { int block; /* get coded block pattern */ h->cbp = cbp_tab[get_ue_golomb(&h->s.gb)][1]; /* get quantizer */ if(h->cbp && !h->qp_fixed) h->qp += get_se_golomb(&h->s.gb); for(block=0;block<4;block++) if(h->cbp & (1<<block)) decode_residual_block(h,&h->s.gb,inter_2d... | |
negative | static void pfpu_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size){ MilkymistPFPUState *s = opaque; trace_milkymist_pfpu_memory_write(addr, value); addr >>= 2; switch (addr) { case R_CTL: if (value & CTL_START_BUSY) { pfpu_start(s); } break; case R_MESHBASE: case R_HMESHLAST: case R_VMESHLAST:... | |
negative | uint32_t vfio_pci_read_config(PCIDevice *pdev, uint32_t addr, int len){ VFIOPCIDevice *vdev = DO_UPCAST(VFIOPCIDevice, pdev, pdev); uint32_t emu_bits = 0, emu_val = 0, phys_val = 0, val; memcpy(&emu_bits, vdev->emulated_config_bits + addr, len); emu_bits = le32_to_cpu(emu_bits); if (emu_bits) { emu_val = pci_default_re... | |
negative | static void pci_device_reset(PCIDevice *dev){ int r; dev->irq_state = 0; pci_update_irq_status(dev); /* Clear all writeable bits */ pci_word_test_and_clear_mask(dev->config + PCI_COMMAND, pci_get_word(dev->wmask + PCI_COMMAND)); dev->config[PCI_CACHE_LINE_SIZE] = 0x0; dev->config[PCI_INTERRUPT_LINE] = 0x0; for (r = 0; ... | |
negative | static void xen_set_memory(struct MemoryListener *listener, MemoryRegionSection *section, bool add){ XenIOState *state = container_of(listener, XenIOState, memory_listener); hwaddr start_addr = section->offset_within_address_space; ram_addr_t size = int128_get64(section->size); bool log_dirty = memory_region_is_logging... | |
negative | static void hmp_mouse_move(Monitor *mon, const QDict *qdict){ int dx, dy, dz, button; const char *dx_str = qdict_get_str(qdict, "dx_str"); const char *dy_str = qdict_get_str(qdict, "dy_str"); const char *dz_str = qdict_get_try_str(qdict, "dz_str"); dx = strtol(dx_str, NULL, 0); dy = strtol(dy_str, NULL, 0); qemu_input_... | |
negative | static void realview_init(ram_addr_t ram_size, const char *boot_device, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, const char *cpu_model, enum realview_board_type board_type){ CPUState *env = NULL; ram_addr_t ram_offset; DeviceState *dev, *sysctl, *gpio2; SysBusDevice *busdev;... | |
negative | static int intel_hda_post_load(void *opaque, int version){ IntelHDAState* d = opaque; int i; dprint(d, 1, "%s\n", __FUNCTION__); for (i = 0; i < ARRAY_SIZE(d->st); i++) { if (d->st[i].ctl & 0x02) { intel_hda_parse_bdl(d, &d->st[i]); } } intel_hda_update_irq(d); return 0;} | |
negative | int cpu_x86_handle_mmu_fault(CPUX86State *env, target_ulong addr, int is_write1, int mmu_idx, int is_softmmu){ uint64_t ptep, pte; target_ulong pde_addr, pte_addr; int error_code, is_dirty, prot, page_size, ret, is_write, is_user; target_phys_addr_t paddr; uint32_t page_offset; target_ulong vaddr, virt_addr; is_user = ... | |
negative | static CharDriverState *qemu_chr_open_ringbuf(const char *id, ChardevBackend *backend, ChardevReturn *ret, Error **errp){ ChardevRingbuf *opts = backend->u.ringbuf; CharDriverState *chr; RingBufCharDriver *d; chr = qemu_chr_alloc(); d = g_malloc(sizeof(*d)); d->size = opts->has_size ? opts->size : 65536; /* The size mu... | |
negative | int avpriv_mpa_decode_header(AVCodecContext *avctx, uint32_t head, int *sample_rate, int *channels, int *frame_size, int *bit_rate){ MPADecodeHeader s1, *s = &s1; if (ff_mpa_check_header(head) != 0) return -1; if (avpriv_mpegaudio_decode_header(s, head) != 0) { return -1; } switch(s->layer) { case 1: avctx->codec_id = ... | |
negative | static inline void gen_speundef (DisasContext *ctx){ RET_INVAL(ctx);} | |
negative | int kqemu_init(CPUState *env){ struct kqemu_init kinit; int ret, version;#ifdef _WIN32 DWORD temp;#endif if (!kqemu_allowed) return -1;#ifdef _WIN32 kqemu_fd = CreateFile(KQEMU_DEVICE, GENERIC_WRITE | GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL); if (kqemu_fd == KQ... | |
negative | POWERPC_FAMILY(POWER9)(ObjectClass *oc, void *data){ DeviceClass *dc = DEVICE_CLASS(oc); PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc); dc->fw_name = "PowerPC,POWER9"; dc->desc = "POWER9"; dc->props = powerpc_servercpu_properties; pcc->pvr_match = ppc_pvr_match_power9; pcc->pcr_mask = PCR_COMPAT_2_05 | PCR_COMPAT_2_06 |... | |
negative | int cpu_get_dump_info(ArchDumpInfo *info, const GuestPhysBlockList *guest_phys_blocks){ bool lma = false; GuestPhysBlock *block;#ifdef TARGET_X86_64 X86CPU *first_x86_cpu = X86_CPU(first_cpu); lma = !!(first_x86_cpu->env.hflags & HF_LMA_MASK);#endif if (lma) { info->d_machine = EM_X86_64; } else { info->d_machine = EM_... | |
negative | static void handler_audit(Monitor *mon, const mon_cmd_t *cmd, int ret){ if (ret && !monitor_has_error(mon)) { /* * If it returns failure, it must have passed on error. * * Action: Report an internal error to the client if in QMP. */ if (monitor_ctrl_mode(mon)) { qerror_report(QERR_UNDEFINED_ERROR); } MON_DEBUG("command... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.