instruction stringclasses 1
value | output stringclasses 2
values | input stringlengths 21 96.3k |
|---|---|---|
negative | bool colo_supported(void){ return true;} | |
negative | static uint64_t pxa2xx_i2s_read(void *opaque, hwaddr addr, unsigned size){ PXA2xxI2SState *s = (PXA2xxI2SState *) opaque; switch (addr) { case SACR0: return s->control[0]; case SACR1: return s->control[1]; case SASR0: return s->status; case SAIMR: return s->mask; case SAICR: return 0; case SADIV: return s->clk; case SA... | |
negative | char *desc_get_buf(DescInfo *info, bool read_only){ PCIDevice *dev = PCI_DEVICE(info->ring->r); size_t size = read_only ? le16_to_cpu(info->desc.tlv_size) : le16_to_cpu(info->desc.buf_size); if (size > info->buf_size) { info->buf = g_realloc(info->buf, size); info->buf_size = size; } if (!info->buf) { return NULL; } if... | |
negative | static void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){ int i; memcpy(d->mv, s->mv, 2*4*2*sizeof(int)); memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster then a loop? /* mpeg1 */ d->mb_incr= s->mb_incr; for(i=0; i<3; i++) d->last_dc[i]= s->last_dc[i]; /* statisti... | |
negative | static inline int gen_intermediate_code_internal (CPUState *env, TranslationBlock *tb, int search_pc){ DisasContext ctx, *ctxp = &ctx; opc_handler_t **table, *handler; target_ulong pc_start; uint16_t *gen_opc_end; int j, lj = -1; pc_start = tb->pc; gen_opc_ptr = gen_opc_buf; gen_opc_end = gen_opc_buf + OPC_MAX_SIZE; ge... | |
negative | void *address_space_map(AddressSpace *as, target_phys_addr_t addr, target_phys_addr_t *plen, bool is_write){ AddressSpaceDispatch *d = as->dispatch; target_phys_addr_t len = *plen; target_phys_addr_t todo = 0; int l; target_phys_addr_t page; MemoryRegionSection *section; ram_addr_t raddr = RAM_ADDR_MAX; ram_addr_t rlen... | |
negative | GenericList *visit_next_list(Visitor *v, GenericList **list, size_t size){ assert(list && size >= sizeof(GenericList)); return v->next_list(v, list, size);} | |
negative | static void *vring_map(MemoryRegion **mr, hwaddr phys, hwaddr len, bool is_write){ MemoryRegionSection section = memory_region_find(get_system_memory(), phys, len); if (!section.mr || int128_get64(section.size) < len) { goto out; } if (is_write && section.readonly) { goto out; } if (!memory_region_is_ram(section.mr)) {... | |
negative | uint32_t ldl_be_phys(target_phys_addr_t addr){ return ldl_phys_internal(addr, DEVICE_BIG_ENDIAN);} | |
negative | stream_push(StreamSlave *sink, uint8_t *buf, size_t len, uint32_t *app){ StreamSlaveClass *k = STREAM_SLAVE_GET_CLASS(sink); return k->push(sink, buf, len, app);} | |
negative | static int raw_write(BlockDriverState *bs, int64_t sector_num, const uint8_t *buf, int nb_sectors){ return bdrv_write(bs->file, sector_num, buf, nb_sectors);} | |
negative | static void tftp_handle_rrq(Slirp *slirp, struct tftp_t *tp, int pktlen){ struct tftp_session *spt; int s, k; size_t prefix_len; char *req_fname; /* check if a session already exists and if so terminate it */ s = tftp_session_find(slirp, tp); if (s >= 0) { tftp_session_terminate(&slirp->tftp_sessions[s]); } s = tftp_se... | |
negative | static MegasasCmd *megasas_next_frame(MegasasState *s, target_phys_addr_t frame){ MegasasCmd *cmd = NULL; int num = 0, index; cmd = megasas_lookup_frame(s, frame); if (cmd) { trace_megasas_qf_found(cmd->index, cmd->pa); return cmd; } index = s->reply_queue_head; num = 0; while (num < s->fw_cmds) { if (!s->frames[index]... | |
positive | static int hnm_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ AVFrame *frame = data; Hnm4VideoContext *hnm = avctx->priv_data; int ret; uint16_t chunk_id; if (avpkt->size < 8) { if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) return ret; chunk_id = AV_RL16(avpkt->data + 4); if (chunk_... | |
positive | static void test_nesting(void){ Coroutine *root; NestData nd = { .n_enter = 0, .n_return = 0, .max = 128, }; root = qemu_coroutine_create(nest); qemu_coroutine_enter(root, &nd); /* Must enter and return from max nesting level */ g_assert_cmpint(nd.n_enter, ==, nd.max); g_assert_cmpint(nd.n_return, ==, nd.max);} | |
positive | static int fdctrl_connect_drives(FDCtrl *fdctrl){ unsigned int i; FDrive *drive; for (i = 0; i < MAX_FD; i++) { drive = &fdctrl->drives[i]; drive->fdctrl = fdctrl; if (drive->bs) { if (bdrv_get_on_error(drive->bs, 0) != BLOCK_ERR_STOP_ENOSPC) { error_report("fdc doesn't support drive option werror"); return -1; } if (b... | |
positive | static int ac3_sync(uint64_t state, AACAC3ParseContext *hdr_info, int *need_next_header, int *new_frame_start){ int err; union { uint64_t u64; uint8_t u8[8]; } tmp = { av_be2ne64(state) }; AC3HeaderInfo hdr, *phdr = &hdr; GetBitContext gbc; init_get_bits(&gbc, tmp.u8+8-AC3_HEADER_SIZE, 54); err = avpriv_ac3_parse_heade... | |
positive | static bool use_goto_tb(DisasContext *ctx, target_ulong dest){ /* Suppress goto_tb in the case of single-steping and IO. */ if ((ctx->base.tb->cflags & CF_LAST_IO) || ctx->base.singlestep_enabled) { return false; } return true;} | |
positive | QEMUFile *qemu_bufopen(const char *mode, QEMUSizedBuffer *input){ QEMUBuffer *s; if (mode == NULL || (mode[0] != 'r' && mode[0] != 'w') || mode[1] != '\0') { error_report("qemu_bufopen: Argument validity check failed"); return NULL; } s = g_malloc0(sizeof(QEMUBuffer)); if (mode[0] == 'r') { s->qsb = input; } if (s->qsb... | |
positive | static void mips_cpu_class_init(ObjectClass *c, void *data){ MIPSCPUClass *mcc = MIPS_CPU_CLASS(c); CPUClass *cc = CPU_CLASS(c); DeviceClass *dc = DEVICE_CLASS(c); mcc->parent_realize = dc->realize; dc->realize = mips_cpu_realizefn; mcc->parent_reset = cc->reset; cc->reset = mips_cpu_reset; cc->has_work = mips_cpu_has_... | |
positive | static void check_pointer_type_change(Notifier *notifier, void *data){ VncState *vs = container_of(notifier, VncState, mouse_mode_notifier); int absolute = qemu_input_is_absolute(); if (vnc_has_feature(vs, VNC_FEATURE_POINTER_TYPE_CHANGE) && vs->absolute != absolute) { vnc_lock_output(vs); vnc_write_u8(vs, VNC_MSG_SERV... | |
positive | static MMSSCPacketType get_tcp_server_response(MMSContext *mms){ int read_result; MMSSCPacketType packet_type= -1; for(;;) { if((read_result= url_read_complete(mms->mms_hd, mms->in_buffer, 8))==8) { // handle command packet. if(AV_RL32(mms->in_buffer + 4)==0xb00bface) { mms->incoming_flags= mms->in_buffer[3]; read_resu... | |
positive | get_sigframe(struct emulated_sigaction *ka, CPUX86State *env, size_t frame_size){unsigned long esp;/* Default to using normal stack */esp = env->regs[R_ESP];#if 0/* This is the X/Open sanctioned signal stack switching. */if (ka->sa.sa_flags & SA_ONSTACK) {if (sas_ss_flags(esp) == 0)esp = current->sas_ss_sp + current->s... | |
positive | static uint32_t add_weights(uint32_t w1, uint32_t w2){ uint32_t max = (w1 & 0xFF) > (w2 & 0xFF) ? (w1 & 0xFF) : (w2 & 0xFF); return ((w1 & 0xFFFFFF00) + (w2 & 0xFFFFFF00)) | (1 + max);} | |
positive | static void decode_rlc_opc(CPUTriCoreState *env, DisasContext *ctx, uint32_t op1){ int32_t const16; int r1, r2; const16 = MASK_OP_RLC_CONST16_SEXT(ctx->opcode); r1 = MASK_OP_RLC_S1(ctx->opcode); r2 = MASK_OP_RLC_D(ctx->opcode); switch (op1) { case OPC1_32_RLC_ADDI: gen_addi_d(cpu_gpr_d[r2], cpu_gpr_d[r1], const16); bre... | |
positive | static bool ga_open_pidfile(const char *pidfile){ int pidfd; char pidstr[32]; pidfd = open(pidfile, O_CREAT|O_WRONLY, S_IRUSR|S_IWUSR); if (pidfd == -1 || lockf(pidfd, F_TLOCK, 0)) { g_critical("Cannot lock pid file, %s", strerror(errno)); if (pidfd != -1) { close(pidfd); } return false; } if (ftruncate(pidfd, 0) || ls... | |
positive | static void video_image_display(VideoState *is){ Frame *vp; Frame *sp = NULL; SDL_Rect rect; vp = frame_queue_peek_last(&is->pictq); if (vp->bmp) { if (is->subtitle_st) { if (frame_queue_nb_remaining(&is->subpq) > 0) { sp = frame_queue_peek(&is->subpq); if (vp->pts >= sp->pts + ((float) sp->sub.start_display_time / 100... | |
negative | static int rtmp_server_handshake(URLContext *s, RTMPContext *rt){ uint8_t buffer[RTMP_HANDSHAKE_PACKET_SIZE]; uint32_t hs_epoch; uint32_t hs_my_epoch; uint8_t hs_c1[RTMP_HANDSHAKE_PACKET_SIZE]; uint8_t hs_s1[RTMP_HANDSHAKE_PACKET_SIZE]; uint32_t zeroes; uint32_t temp = 0; int randomidx = 0; int inoutsize = 0; int ret; ... | |
negative | int hw_device_setup_for_encode(OutputStream *ost){ enum AVHWDeviceType type; HWDevice *dev; type = hw_device_match_type_in_name(ost->enc->name); if (type != AV_HWDEVICE_TYPE_NONE) { dev = hw_device_get_by_type(type); if (!dev) { av_log(ost->enc_ctx, AV_LOG_WARNING, "No device available " "for encoder (device type %s fo... | |
positive | e1000e_cleanup_msix(E1000EState *s){ if (msix_enabled(PCI_DEVICE(s))) { e1000e_unuse_msix_vectors(s, E1000E_MSIX_VEC_NUM); msix_uninit(PCI_DEVICE(s), &s->msix, &s->msix); }} | |
positive | ASSStyle *ff_ass_style_get(ASSSplitContext *ctx, const char *style){ ASS *ass = &ctx->ass; int i; if (!style || !*style) style = "Default"; for (i=0; i<ass->styles_count; i++) if (!strcmp(ass->styles[i].name, style)) return ass->styles + i; return NULL;} | |
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 inline void RENAME(yuv2yuvX)(SwsContext *c, int16_t *lumFilter, int16_t **lumSrc, int lumFilterSize, int16_t *chrFilter, int16_t **chrSrc, int chrFilterSize, uint8_t *dest, uint8_t *uDest, uint8_t *vDest, long dstW, long chrDstW){#ifdef HAVE_MMX if(c->flags & SWS_ACCURATE_RND){ if(uDest){ YSCALEYUV2YV12X_ACCURAT... | |
positive | static int vorbis_residue_decode(vorbis_context *vc, vorbis_residue *vr, uint_fast8_t ch, uint_fast8_t *do_not_decode, float *vec, uint_fast16_t vlen) { GetBitContext *gb=&vc->gb; uint_fast8_t c_p_c=vc->codebooks[vr->classbook].dimensions; uint_fast16_t n_to_read=vr->end-vr->begin; uint_fast16_t ptns_to_read=n_to_read/... | |
positive | static CharDriverState *qmp_chardev_open_parallel(ChardevHostdev *parallel, Error **errp){#ifdef HAVE_CHARDEV_PARPORT int fd; fd = qmp_chardev_open_file_source(parallel->device, O_RDWR, errp); if (error_is_set(errp)) { return NULL; } return qemu_chr_open_pp_fd(fd);#else error_setg(errp, "character device backend type '... | |
positive | void cpu_exit(CPUArchState *env){ CPUState *cpu = ENV_GET_CPU(env); cpu->exit_request = 1; cpu_unlink_tb(cpu);} | |
negative | static int hdcd_envelope(int32_t *samples, int count, int stride, int gain, int target_gain, int extend){ int i; int32_t *samples_end = samples + stride * count; if (extend) { for (i = 0; i < count; i++) { int32_t sample = samples[i * stride]; int32_t asample = abs(sample) - 0x5981; if (asample >= 0) sample = sample >=... | |
negative | static QObject *parse_array(JSONParserContext *ctxt, va_list *ap){ QList *list = NULL; QObject *token, *peek; token = parser_context_pop_token(ctxt); assert(token && token_get_type(token) == JSON_LSQUARE); list = qlist_new(); peek = parser_context_peek_token(ctxt); if (peek == NULL) { parse_error(ctxt, NULL, "premature... | |
negative | static void raw_aio_unplug(BlockDriverState *bs){#ifdef CONFIG_LINUX_AIO BDRVRawState *s = bs->opaque; if (s->use_aio) { laio_io_unplug(bs, s->aio_ctx, true); }#endif} | |
negative | void hmp_info_tpm(Monitor *mon, const QDict *qdict){ TPMInfoList *info_list, *info; Error *err = NULL; unsigned int c = 0; TPMPassthroughOptions *tpo; info_list = qmp_query_tpm(&err); if (err) { monitor_printf(mon, "TPM device not supported\n"); error_free(err); return; } if (info_list) { monitor_printf(mon, "TPM devic... | |
negative | static void tap_set_sndbuf(TAPState *s, int sndbuf, Monitor *mon){#ifdef TUNSETSNDBUF if (ioctl(s->fd, TUNSETSNDBUF, &sndbuf) == -1) { config_error(mon, "TUNSETSNDBUF ioctl failed: %s\n", strerror(errno)); }#else config_error(mon, "No '-net tap,sndbuf=<nbytes>' support available\n");#endif} | |
negative | ssize_t pcnet_receive(VLANClientState *nc, const uint8_t *buf, size_t size_){ PCNetState *s = DO_UPCAST(NICState, nc, nc)->opaque; int is_padr = 0, is_bcast = 0, is_ladr = 0; uint8_t buf1[60]; int remaining; int crc_err = 0; int size = size_; if (CSR_DRX(s) || CSR_STOP(s) || CSR_SPND(s) || !size) return -1;#ifdef PCNET... | |
negative | static void gen_stda_asi(DisasContext *dc, TCGv hi, TCGv addr, int insn, int rd){ TCGv_i32 r_asi, r_size; TCGv lo = gen_load_gpr(dc, rd + 1); TCGv_i64 t64 = tcg_temp_new_i64(); tcg_gen_concat_tl_i64(t64, lo, hi); r_asi = gen_get_asi(dc, insn); r_size = tcg_const_i32(8); gen_helper_st_asi(cpu_env, addr, t64, r_asi, r_si... | |
negative | void s390_pci_iommu_enable(S390PCIBusDevice *pbdev){ memory_region_init_iommu(&pbdev->iommu_mr, OBJECT(&pbdev->mr), &s390_iommu_ops, "iommu-s390", pbdev->pal + 1); memory_region_add_subregion(&pbdev->mr, 0, &pbdev->iommu_mr); pbdev->iommu_enabled = true;} | |
negative | void vnc_disconnect_finish(VncState *vs){ int i; vnc_jobs_join(vs); /* Wait encoding jobs */ vnc_lock_output(vs); vnc_qmp_event(vs, QAPI_EVENT_VNC_DISCONNECTED); buffer_free(&vs->input); buffer_free(&vs->output);#ifdef CONFIG_VNC_WS buffer_free(&vs->ws_input); buffer_free(&vs->ws_output);#endif /* CONFIG_VNC_WS */ qapi... | |
negative | void msix_write_config(PCIDevice *dev, uint32_t addr, uint32_t val, int len){ unsigned enable_pos = dev->msix_cap + MSIX_CONTROL_OFFSET; if (addr + len <= enable_pos || addr > enable_pos) return; if (msix_enabled(dev)) qemu_set_irq(dev->irq[0], 0);} | |
negative | type_init(pflash_cfi02_register_types)pflash_t *pflash_cfi02_register(hwaddr base, DeviceState *qdev, const char *name, hwaddr size, BlockDriverState *bs, uint32_t sector_len, int nb_blocs, int nb_mappings, int width, uint16_t id0, uint16_t id1, uint16_t id2, uint16_t id3, uint16_t unlock_addr0, uint16_t unlock_addr1, ... | |
negative | static void akita_init(int ram_size, int vga_ram_size, int boot_device, DisplayState *ds, const char **fd_filename, int snapshot, const char *kernel_filename, const char *kernel_cmdline, const char *initrd_filename, const char *cpu_model){ spitz_common_init(ram_size, vga_ram_size, ds, kernel_filename, kernel_cmdline, i... | |
negative | static void tcg_out_qemu_ld(TCGContext *s, TCGReg data, TCGReg addr, TCGMemOpIdx oi, bool is_64){ TCGMemOp memop = get_memop(oi);#ifdef CONFIG_SOFTMMU unsigned memi = get_mmuidx(oi); TCGReg addrz, param; tcg_insn_unit *func; tcg_insn_unit *label_ptr; addrz = tcg_out_tlb_load(s, addr, memi, memop & MO_SIZE, offsetof(CPU... | |
negative | petalogix_ml605_init(QEMUMachineInitArgs *args){ ram_addr_t ram_size = args->ram_size; const char *cpu_model = args->cpu_model; MemoryRegion *address_space_mem = get_system_memory(); DeviceState *dev, *dma, *eth0; Object *peer; MicroBlazeCPU *cpu; SysBusDevice *busdev; CPUMBState *env; DriveInfo *dinfo; int i; hwaddr d... | |
negative | void virtio_queue_set_num(VirtIODevice *vdev, int n, int num){ if (num <= VIRTQUEUE_MAX_SIZE) { vdev->vq[n].vring.num = num; virtqueue_init(&vdev->vq[n]); }} | |
negative | static void arm_cpu_realizefn(DeviceState *dev, Error **errp){ CPUState *cs = CPU(dev); ARMCPU *cpu = ARM_CPU(dev); ARMCPUClass *acc = ARM_CPU_GET_CLASS(dev); CPUARMState *env = &cpu->env; int pagebits; Error *local_err = NULL; cpu_exec_realizefn(cs, &local_err); if (local_err != NULL) { error_propagate(errp, local_err... | |
negative | static bool nbd_process_legacy_socket_options(QDict *output_options, QemuOpts *legacy_opts, Error **errp){ const char *path = qemu_opt_get(legacy_opts, "path"); const char *host = qemu_opt_get(legacy_opts, "host"); const char *port = qemu_opt_get(legacy_opts, "port"); const QDictEntry *e; if (!path && !host && !port) {... | |
negative | static void cirrus_linear_bitblt_write(void *opaque, target_phys_addr_t addr, uint64_t val, unsigned size){ CirrusVGAState *s = opaque; if (s->cirrus_srcptr != s->cirrus_srcptr_end) {/* bitblt */*s->cirrus_srcptr++ = (uint8_t) val;if (s->cirrus_srcptr >= s->cirrus_srcptr_end) { cirrus_bitblt_cputovideo_next(s);} }} | |
negative | static int default_monitor_get_fd(Monitor *mon, const char *name, Error **errp){ error_setg(errp, "only QEMU supports file descriptor passing"); return -1;} | |
negative | uint64_t helper_st_virt_to_phys (uint64_t virtaddr){ uint64_t tlb_addr, physaddr; int index, mmu_idx; void *retaddr; mmu_idx = cpu_mmu_index(env); index = (virtaddr >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1); redo: tlb_addr = env->tlb_table[mmu_idx][index].addr_write; if ((virtaddr & TARGET_PAGE_MASK) == (tlb_addr & (TA... | |
negative | static int decode_recovery_point(H264Context *h){ h->sei_recovery_frame_cnt = get_ue_golomb(&h->gb); /* 1b exact_match_flag, * 1b broken_link_flag, * 2b changing_slice_group_idc */ skip_bits(&h->gb, 4); if (h->avctx->debug & FF_DEBUG_PICT_INFO) av_log(h->avctx, AV_LOG_DEBUG, "sei_recovery_frame_cnt: %d\n", h->sei_recov... | |
positive | static int mkv_write_header(AVFormatContext *s){ MatroskaMuxContext *mkv = s->priv_data; AVIOContext *pb = s->pb; ebml_master ebml_header; AVDictionaryEntry *tag; int ret, i, version = 2; int64_t creation_time; if (!strcmp(s->oformat->name, "webm")) mkv->mode = MODE_WEBM; else mkv->mode = MODE_MATROSKAv2; if (mkv->mode... | |
positive | static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n){ uint32_t tmp; if (n < CPU_NB_REGS) { env->regs[gpr_map[n]] = ldtul_p(mem_buf); return sizeof(target_ulong); } else if (n >= IDX_FP_REGS && n < IDX_FP_REGS + 8) {#ifdef USE_X86LDOUBLE /* FIXME: byteswap float values - after fixing fpregs layout. ... | |
positive | static void setup_rt_frame(int sig, struct target_sigaction *ka, target_siginfo_t *info, target_sigset_t *set, CPUS390XState *env){ int i; rt_sigframe *frame; abi_ulong frame_addr; frame_addr = get_sigframe(ka, env, sizeof *frame); qemu_log("%s: frame_addr 0x%llx\n", __FUNCTION__, (unsigned long long)frame_addr); if (!... | |
positive | static int dxv_decompress_dxt5(AVCodecContext *avctx){ DXVContext *ctx = avctx->priv_data; GetByteContext *gbc = &ctx->gbc; uint32_t value, op; int idx, prev, state = 0; int pos = 4; int run = 0; int probe, check; /* Copy the first four elements */ AV_WL32(ctx->tex_data + 0, bytestream2_get_le32(gbc)); AV_WL32(ctx->tex... | |
positive | static void gd_update_geometry_hints(VirtualConsole *vc){ GtkDisplayState *s = vc->s; GdkWindowHints mask = 0; GdkGeometry geo = {}; GtkWidget *geo_widget = NULL; GtkWindow *geo_window; if (vc->type == GD_VC_GFX) { if (!vc->gfx.ds) { return; } if (s->free_scale) { geo.min_width = surface_width(vc->gfx.ds) * VC_SCALE_MI... | |
positive | static uint32_t cc_calc_abs_64(int64_t dst){ if ((uint64_t)dst == 0x8000000000000000ULL) { return 3; } else if (dst) { return 1; } else { return 0; }} | |
positive | static void virtio_serial_device_unrealize(DeviceState *dev, Error **errp){ VirtIODevice *vdev = VIRTIO_DEVICE(dev); VirtIOSerial *vser = VIRTIO_SERIAL(dev); QLIST_REMOVE(vser, next); g_free(vser->ivqs); g_free(vser->ovqs); g_free(vser->ports_map); if (vser->post_load) { g_free(vser->post_load->connected); timer_del(vs... | |
positive | static int flashsv2_prime(FlashSVContext *s, uint8_t *src, int size){ z_stream zs; int zret; // Zlib return code zs.zalloc = NULL; zs.zfree = NULL; zs.opaque = NULL; s->zstream.next_in = src; s->zstream.avail_in = size; s->zstream.next_out = s->tmpblock; s->zstream.avail_out = s->block_size * 3; inflate(&s->zstream, Z_... | |
positive | static void sbr_hf_assemble(int Y1[38][64][2], const int X_high[64][40][2], SpectralBandReplication *sbr, SBRData *ch_data, const int e_a[2]){ int e, i, j, m; const int h_SL = 4 * !sbr->bs_smoothing_mode; const int kx = sbr->kx[1]; const int m_max = sbr->m[1]; static const SoftFloat h_smooth[5] = { { 715827883, -1 }, {... | |
negative | static int vid_probe(AVProbeData *p){ // little endian VID tag, file starts with "VID\0" if (p->buf_size < 4 || AV_RL32(p->buf) != MKTAG('V', 'I', 'D', 0)) return 0; return AVPROBE_SCORE_MAX;} | |
positive | static inline void gen_intermediate_code_internal(X86CPU *cpu, TranslationBlock *tb, bool search_pc){ CPUState *cs = CPU(cpu); CPUX86State *env = &cpu->env; DisasContext dc1, *dc = &dc1; target_ulong pc_ptr; uint16_t *gen_opc_end; CPUBreakpoint *bp; int j, lj; uint64_t flags; target_ulong pc_start; target_ulong cs_base... | |
positive | static always_inline void gen_op_subfo (void){ gen_op_move_T2_T0(); gen_op_subf(); gen_op_check_subfo();} | |
positive | static void fd_accept_incoming_migration(void *opaque){ QEMUFile *f = opaque; qemu_set_fd_handler2(qemu_get_fd(f), NULL, NULL, NULL, NULL); process_incoming_migration(f);} | |
positive | hwaddr ppc_hash64_get_phys_page_debug(PowerPCCPU *cpu, target_ulong addr){ CPUPPCState *env = &cpu->env; ppc_slb_t *slb; hwaddr pte_offset; ppc_hash_pte64_t pte; unsigned apshift; if (msr_dr == 0) { /* In real mode the top 4 effective address bits are ignored */ return addr & 0x0FFFFFFFFFFFFFFFULL; } slb = slb_lookup(c... | |
positive | static int adx_read_header(AVFormatContext *s){ ADXDemuxerContext *c = s->priv_data; AVCodecParameters *par; AVStream *st = avformat_new_stream(s, NULL); if (!st) return AVERROR(ENOMEM); par = s->streams[0]->codecpar; if (avio_rb16(s->pb) != 0x8000) return AVERROR_INVALIDDATA; c->header_size = avio_rb16(s->pb) + 4; avi... | |
positive | static void virgl_cmd_get_capset(VirtIOGPU *g, struct virtio_gpu_ctrl_command *cmd){ struct virtio_gpu_get_capset gc; struct virtio_gpu_resp_capset *resp; uint32_t max_ver, max_size; VIRTIO_GPU_FILL_CMD(gc); virgl_renderer_get_cap_set(gc.capset_id, &max_ver, &max_size); if (!max_size) { cmd->error = VIRTIO_GPU_RESP_ERR... | |
positive | static int qcow2_open(BlockDriverState *bs, QDict *options, int flags){ BDRVQcowState *s = bs->opaque; int len, i, ret = 0; QCowHeader header; QemuOpts *opts; Error *local_err = NULL; uint64_t ext_end; uint64_t l1_vm_state_index; ret = bdrv_pread(bs->file, 0, &header, sizeof(header)); if (ret < 0) { be32_to_cpus(&heade... | |
positive | static void decode_subband(DiracContext *s, GetBitContext *gb, int quant, int slice_x, int slice_y, int bits_end, SubBand *b1, SubBand *b2){ int left = b1->width * slice_x / s->num_x; int right = b1->width *(slice_x+1) / s->num_x; int top = b1->height * slice_y / s->num_y; int bottom = b1->height *(slice_y+1) / s->num_... | |
negative | int spapr_h_cas_compose_response(sPAPRMachineState *spapr, target_ulong addr, target_ulong size, bool cpu_update, sPAPROptionVector *ov5_updates){ void *fdt, *fdt_skel; sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 }; size -= sizeof(hdr); /* Create sceleton */ fdt_skel = g_malloc0(size); _FDT((fdt_create(fdt_skel... | |
negative | void kvmppc_hash64_write_pte(CPUPPCState *env, target_ulong pte_index, target_ulong pte0, target_ulong pte1){ int htab_fd; struct kvm_get_htab_fd ghf; struct kvm_get_htab_buf hpte_buf; ghf.flags = 0; ghf.start_index = 0; /* Ignored */ htab_fd = kvm_vm_ioctl(kvm_state, KVM_PPC_GET_HTAB_FD, &ghf); if (htab_fd < 0) { goto... | |
negative | int tcp_start_outgoing_migration(MigrationState *s, const char *host_port, Error **errp){ s->get_error = socket_errno; s->write = socket_write; s->close = tcp_close; s->fd = inet_connect(host_port, false, errp); if (!error_is_set(errp)) { migrate_fd_connect(s); } else if (error_is_type(*errp, QERR_SOCKET_CONNECT_IN_PRO... | |
negative | static void virtio_9p_device_realize(DeviceState *dev, Error **errp){ VirtIODevice *vdev = VIRTIO_DEVICE(dev); V9fsVirtioState *v = VIRTIO_9P(dev); V9fsState *s = &v->state; if (v9fs_device_realize_common(s, errp)) { goto out; } v->config_size = sizeof(struct virtio_9p_config) + strlen(s->fsconf.tag); virtio_init(vdev,... | |
negative | static void trigger_access_exception(CPUS390XState *env, uint32_t type, uint32_t ilen, uint64_t tec){ S390CPU *cpu = s390_env_get_cpu(env); if (kvm_enabled()) { kvm_s390_access_exception(cpu, type, tec); } else { CPUState *cs = CPU(cpu); stq_phys(cs->as, env->psa + offsetof(LowCore, trans_exc_code), tec); trigger_pgm_e... | |
negative | static void spapr_memory_unplug_request(HotplugHandler *hotplug_dev, DeviceState *dev, Error **errp){ sPAPRMachineState *spapr = SPAPR_MACHINE(hotplug_dev); Error *local_err = NULL; PCDIMMDevice *dimm = PC_DIMM(dev); PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm); MemoryRegion *mr = ddc->get_memory_region(dimm); uint... | |
negative | static void l2x0_priv_write(void *opaque, target_phys_addr_t offset, uint64_t value, unsigned size){ l2x0_state *s = (l2x0_state *)opaque; offset &= 0xfff; if (offset >= 0x730 && offset < 0x800) { /* ignore */ return; } switch (offset) { case 0x100: s->ctrl = value & 1; break; case 0x104: s->aux_ctrl = value; break; ca... | |
negative | static void json_emit_element(QJSON *json, const char *name){ /* Check whether we need to print a , before an element */ if (json->omit_comma) { json->omit_comma = false; } else { qstring_append(json->str, ", "); } if (name) { qstring_append(json->str, "\""); qstring_append(json->str, name); qstring_append(json->str, "... | |
negative | static bool vfio_pci_host_match(PCIHostDeviceAddress *host1, PCIHostDeviceAddress *host2){ return (host1->domain == host2->domain && host1->bus == host2->bus && host1->slot == host2->slot && host1->function == host2->function);} | |
negative | int ff_ivi_dec_huff_desc(GetBitContext *gb, int desc_coded, int which_tab, IVIHuffTab *huff_tab, AVCodecContext *avctx){ int i, result; IVIHuffDesc new_huff; if (!desc_coded) { /* select default table */ huff_tab->tab = (which_tab) ? &ff_ivi_blk_vlc_tabs[7] : &ff_ivi_mb_vlc_tabs [7]; } else { huff_tab->tab_sel = get_bi... | |
negative | int check_params(char *buf, int buf_size, const char * const *params, const char *str){ const char *p; int i; p = str; while (*p != '\0') { p = get_opt_name(buf, buf_size, p, '='); if (*p != '=') { return -1; } p++; for (i = 0; params[i] != NULL; i++) { if (!strcmp(params[i], buf)) { break; } } if (params[i] == NULL) {... | |
negative | static void memory_region_update_container_subregions(MemoryRegion *subregion){ hwaddr offset = subregion->addr; MemoryRegion *mr = subregion->container; MemoryRegion *other; memory_region_transaction_begin(); memory_region_ref(subregion); QTAILQ_FOREACH(other, &mr->subregions, subregions_link) { if (subregion->may_ove... | |
negative | static int64_t coroutine_fn bdrv_qed_co_get_block_status(BlockDriverState *bs, int64_t sector_num, int nb_sectors, int *pnum){ BDRVQEDState *s = bs->opaque; size_t len = (size_t)nb_sectors * BDRV_SECTOR_SIZE; QEDIsAllocatedCB cb = { .bs = bs, .pos = (uint64_t)sector_num * BDRV_SECTOR_SIZE, .status = BDRV_BLOCK_OFFSET_M... | |
negative | static sPAPRPHBState *find_phb(sPAPREnvironment *spapr, uint64_t buid){ sPAPRPHBState *sphb; QLIST_FOREACH(sphb, &spapr->phbs, list) { if (sphb->buid != buid) { continue; } return sphb; } return NULL;} | |
negative | static void ahci_mem_write(void *opaque, target_phys_addr_t addr, uint64_t val, unsigned size){ AHCIState *s = opaque; /* Only aligned reads are allowed on AHCI */ if (addr & 3) { fprintf(stderr, "ahci: Mis-aligned write to addr 0x" TARGET_FMT_plx "\n", addr); return; } if (addr < AHCI_GENERIC_HOST_CONTROL_REGS_MAX_ADD... | |
negative | static void jpeg_term_destination(j_compress_ptr cinfo){ VncState *vs = cinfo->client_data; Buffer *buffer = &vs->tight_jpeg; buffer->offset = buffer->capacity - cinfo->dest->free_in_buffer;} | |
negative | static void qdict_destroy_obj(QObject *obj){ int i; QDict *qdict; assert(obj != NULL); qdict = qobject_to_qdict(obj); for (i = 0; i < QDICT_BUCKET_MAX; i++) { QDictEntry *entry = QLIST_FIRST(&qdict->table[i]); while (entry) { QDictEntry *tmp = QLIST_NEXT(entry, next); QLIST_REMOVE(entry, next); qentry_destroy(entry); e... | |
negative | static int pte64_check (mmu_ctx_t *ctx, target_ulong pte0, target_ulong pte1, int h, int rw){ return _pte_check(ctx, 1, pte0, pte1, h, rw);} | |
negative | static GenericList *qobject_input_next_list(Visitor *v, GenericList *tail, size_t size){ QObjectInputVisitor *qiv = to_qiv(v); StackObject *so = QSLIST_FIRST(&qiv->stack); if (!so->entry) { return NULL; } tail->next = g_malloc0(size); return tail->next;} | |
negative | static int coroutine_fn v9fs_do_readdir_with_stat(V9fsPDU *pdu, V9fsFidState *fidp, uint32_t max_count){ V9fsPath path; V9fsStat v9stat; int len, err = 0; int32_t count = 0; struct stat stbuf; off_t saved_dir_pos; struct dirent *dent; /* save the directory position */ saved_dir_pos = v9fs_co_telldir(pdu, fidp); if (sav... | |
negative | static int decode_block_refinement(MJpegDecodeContext *s, DCTELEM *block, uint8_t *last_nnz, int ac_index, int16_t *quant_matrix, int ss, int se, int Al, int *EOBRUN){ int code, i=ss, j, sign, val, run; int last = FFMIN(se, *last_nnz); OPEN_READER(re, &s->gb); if(*EOBRUN) (*EOBRUN)--; else { for(;;i++) { UPDATE_CACHE(r... | |
positive | static void destroy_buffers(SANMVideoContext *ctx){ av_freep(&ctx->frm0); av_freep(&ctx->frm1); av_freep(&ctx->frm2); av_freep(&ctx->stored_frame); av_freep(&ctx->rle_buf); ctx->frm0_size = ctx->frm1_size = ctx->frm2_size = 0;} | |
positive | void cpu_state_reset(CPUMIPSState *env){ MIPSCPU *cpu = mips_env_get_cpu(env); CPUState *cs = CPU(cpu); /* Reset registers to their default values */ env->CP0_PRid = env->cpu_model->CP0_PRid; env->CP0_Config0 = env->cpu_model->CP0_Config0;#ifdef TARGET_WORDS_BIGENDIAN env->CP0_Config0 |= (1 << CP0C0_BE);#endif env->CP0... | |
positive | static void spapr_vio_quiesce_one(VIOsPAPRDevice *dev){ dev->flags &= ~VIO_PAPR_FLAG_DMA_BYPASS; if (dev->rtce_table) { size_t size = (dev->rtce_window_size >> SPAPR_VIO_TCE_PAGE_SHIFT) * sizeof(VIOsPAPR_RTCE); memset(dev->rtce_table, 0, size); } dev->crq.qladdr = 0; dev->crq.qsize = 0; dev->crq.qnext = 0;} | |
positive | int av_image_alloc(uint8_t *pointers[4], int linesizes[4], int w, int h, enum AVPixelFormat pix_fmt, int align){ const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt); int i, ret; uint8_t *buf; if (!desc) return AVERROR(EINVAL); if ((ret = av_image_check_size(w, h, 0, NULL)) < 0) return ret; if ((ret = av_image... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.