label int64 0 1 | func1 stringlengths 23 97k | id int64 0 27.3k |
|---|---|---|
0 | void ff_mqc_init_contexts(MqcState *mqc) { int i; memset(mqc->cx_states, 0, sizeof(mqc->cx_states)); mqc->cx_states[MQC_CX_UNI] = 2 * 46; mqc->cx_states[MQC_CX_RL] = 2 * 3; mqc->cx_states[0] = 2 * 4; for (i = 0; i < 47; i++) { ff_mqc_qe[2 * i] = ff_mqc_qe[2 * i + 1] = cx_states[i].qe; ff_mqc_nlps[2 * i] = 2 * cx_states... | 19,124 |
0 | int monitor_read_bdrv_key(BlockDriverState *bs) { char password[256]; int i; if (!bdrv_is_encrypted(bs)) return 0; term_printf("%s (%s) is encrypted.\n", bdrv_get_device_name(bs), bdrv_get_encrypted_filename(bs)); for(i = 0; i < 3; i++) { monitor_readline("Password: ", 1, password, sizeof(password)); if (bdrv_set_key(b... | 19,125 |
0 | int bdrv_check(BlockDriverState *bs, BdrvCheckResult *res) { if (bs->drv->bdrv_check == NULL) { return -ENOTSUP; } memset(res, 0, sizeof(*res)); return bs->drv->bdrv_check(bs, res); } | 19,127 |
0 | static void vscsi_transfer_data(SCSIRequest *sreq, uint32_t len) { VSCSIState *s = VIO_SPAPR_VSCSI_DEVICE(sreq->bus->qbus.parent); vscsi_req *req = sreq->hba_private; uint8_t *buf; int rc = 0; DPRINTF("VSCSI: SCSI xfer complete tag=0x%x len=0x%x, req=%p\n", sreq->tag, len, req); if (req == NULL) { fprintf(stderr, "VSCS... | 19,131 |
0 | static inline void cris_alu_m_alloc_temps(TCGv *t) { t[0] = tcg_temp_new(TCG_TYPE_TL); t[1] = tcg_temp_new(TCG_TYPE_TL); } | 19,132 |
0 | static void gen_spr_40x (CPUPPCState *env) { /* Cache */ /* XXX : not implemented */ spr_register(env, SPR_40x_DCCR, "DCCR", SPR_NOACCESS, SPR_NOACCESS, &spr_read_generic, &spr_write_generic, 0x00000000); /* XXX : not implemented */ spr_register(env, SPR_40x_DCWR, "DCWR", SPR_NOACCESS, SPR_NOACCESS, &spr_read_generic, ... | 19,134 |
0 | static av_always_inline void filter_mb_dir(H264Context *h, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize, int mb_xy, int mb_type, int mvy_limit, int first_vertical_edge_done, int dir) { MpegEncContext * const s = &h->s; int edge; const int mbm_xy = ... | 19,135 |
0 | static void char_socket_finalize(Object *obj) { Chardev *chr = CHARDEV(obj); SocketChardev *s = SOCKET_CHARDEV(obj); tcp_chr_free_connection(chr); if (s->reconnect_timer) { g_source_remove(s->reconnect_timer); s->reconnect_timer = 0; } qapi_free_SocketAddressLegacy(s->addr); if (s->listen_tag) { g_source_remove(s->list... | 19,136 |
0 | int kvm_sw_breakpoints_active(CPUState *env) { return !TAILQ_EMPTY(&env->kvm_state->kvm_sw_breakpoints); } | 19,138 |
0 | static int usbredir_handle_status(USBRedirDevice *dev, int status, int actual_len) { switch (status) { case usb_redir_success: return actual_len; case usb_redir_stall: return USB_RET_STALL; case usb_redir_cancelled: WARNING("returning cancelled packet to HC?\n"); return USB_RET_NAK; case usb_redir_inval: WARNING("got i... | 19,139 |
0 | void ich9_pm_init(PCIDevice *lpc_pci, ICH9LPCPMRegs *pm, qemu_irq sci_irq, qemu_irq cmos_s3) { memory_region_init(&pm->io, "ich9-pm", ICH9_PMIO_SIZE); memory_region_set_enabled(&pm->io, false); memory_region_add_subregion(pci_address_space_io(lpc_pci), 0, &pm->io); acpi_pm_tmr_init(&pm->acpi_regs, ich9_pm_update_sci_fn... | 19,140 |
0 | static int xen_pt_exp_rom_bar_reg_write(XenPCIPassthroughState *s, XenPTReg *cfg_entry, uint32_t *val, uint32_t dev_value, uint32_t valid_mask) { XenPTRegInfo *reg = cfg_entry->reg; XenPTRegion *base = NULL; PCIDevice *d = (PCIDevice *)&s->dev; uint32_t writable_mask = 0; uint32_t throughable_mask = get_throughable_mas... | 19,141 |
0 | static int tcg_match_xori(TCGType type, tcg_target_long val) { if ((s390_facilities & FACILITY_EXT_IMM) == 0) { return 0; } if (type == TCG_TYPE_I32) { /* All 32-bit XORs can be performed with 1 48-bit insn. */ return 1; } /* Look for negative values. These are best to load with LGHI. */ if (val < 0 && val == (int32_t)... | 19,143 |
0 | static int block_crypto_open_generic(QCryptoBlockFormat format, QemuOptsList *opts_spec, BlockDriverState *bs, QDict *options, int flags, Error **errp) { BlockCrypto *crypto = bs->opaque; QemuOpts *opts = NULL; Error *local_err = NULL; int ret = -EINVAL; QCryptoBlockOpenOptions *open_opts = NULL; unsigned int cflags = ... | 19,144 |
0 | static int dec_21154_initfn(PCIDevice *dev) { int rc; rc = pci_bridge_initfn(dev); if (rc < 0) { return rc; } pci_config_set_vendor_id(dev->config, PCI_VENDOR_ID_DEC); pci_config_set_device_id(dev->config, PCI_DEVICE_ID_DEC_21154); return 0; } | 19,145 |
0 | matroska_ebmlnum_uint (uint8_t *data, uint32_t size, uint64_t *num) { int len_mask = 0x80, read = 1, n = 1, num_ffs = 0; uint64_t total; if (size <= 0) return AVERROR_INVALIDDATA; total = data[0]; while (read <= 8 && !(total & len_mask)) { read++; len_mask >>= 1; } if (read > 8) return AVERROR_INVALIDDATA; if ((total &... | 19,146 |
0 | static PayloadContext *vorbis_new_extradata(void) { return av_mallocz(sizeof(PayloadContext)); } | 19,147 |
1 | static int plot_spectrum_column(AVFilterLink *inlink, AVFrame *insamples) { AVFilterContext *ctx = inlink->dst; AVFilterLink *outlink = ctx->outputs[0]; ShowSpectrumContext *s = ctx->priv; AVFrame *outpicref = s->outpicref; int ret, plane, x, y, z = s->orientation == VERTICAL ? s->h : s->w; /* fill a new spectrum colum... | 19,148 |
1 | init_disasm (struct disassemble_info *info) { const struct s390_opcode *opcode; const struct s390_opcode *opcode_end; memset (opc_index, 0, sizeof (opc_index)); opcode_end = s390_opcodes + s390_num_opcodes; for (opcode = s390_opcodes; opcode < opcode_end; opcode++) { opc_index[(int) opcode->opcode[0]] = opcode - s390_o... | 19,149 |
1 | int attribute_align_arg avcodec_open(AVCodecContext *avctx, AVCodec *codec) { int ret= -1; /* If there is a user-supplied mutex locking routine, call it. */ if (ff_lockmgr_cb) { if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN)) return -1; } entangled_thread_counter++; if(entangled_thread_counter != 1){ av_log(avctx, ... | 19,150 |
1 | static inline void RENAME(rgb15to24)(const uint8_t *src, uint8_t *dst, unsigned src_size) { const uint16_t *end; #ifdef HAVE_MMX const uint16_t *mm_end; #endif uint8_t *d = (uint8_t *)dst; const uint16_t *s = (uint16_t *)src; end = s + src_size/2; #ifdef HAVE_MMX __asm __volatile(PREFETCH" %0"::"m"(*s):"memory"); mm_en... | 19,151 |
1 | static void vfio_rtl8168_window_quirk_write(void *opaque, hwaddr addr, uint64_t data, unsigned size) { VFIOQuirk *quirk = opaque; VFIOPCIDevice *vdev = quirk->vdev; switch (addr) { case 4: /* address */ if ((data & 0x7fff0000) == 0x10000) { if (data & 0x80000000U && vdev->pdev.cap_present & QEMU_PCI_CAP_MSIX) { trace_v... | 19,152 |
1 | void connection_destroy(void *opaque) { Connection *conn = opaque; g_queue_foreach(&conn->primary_list, packet_destroy, NULL); g_queue_free(&conn->primary_list); g_queue_foreach(&conn->secondary_list, packet_destroy, NULL); g_queue_free(&conn->secondary_list); g_slice_free(Connection, conn); } | 19,153 |
1 | static void exynos4210_uart_write(void *opaque, hwaddr offset, uint64_t val, unsigned size) { Exynos4210UartState *s = (Exynos4210UartState *)opaque; uint8_t ch; PRINT_DEBUG_EXTEND("UART%d: <0x%04x> %s <- 0x%08llx\n", s->channel, offset, exynos4210_uart_regname(offset), (long long unsigned int)val); switch (offset) { c... | 19,154 |
1 | static void spitz_i2c_setup(PXA2xxState *cpu) { /* Attach the CPU on one end of our I2C bus. */ I2CBus *bus = pxa2xx_i2c_bus(cpu->i2c[0]); DeviceState *wm; /* Attach a WM8750 to the bus */ wm = i2c_create_slave(bus, "wm8750", 0); spitz_wm8750_addr(wm, 0, 0); qdev_connect_gpio_out(cpu->gpio, SPITZ_GPIO_WM, qemu_allocate... | 19,155 |
1 | static void m5206_mbar_writel(void *opaque, target_phys_addr_t offset, uint32_t value) { m5206_mbar_state *s = (m5206_mbar_state *)opaque; int width; offset &= 0x3ff; if (offset > 0x200) { hw_error("Bad MBAR write offset 0x%x", (int)offset); } width = m5206_mbar_width[offset >> 2]; if (width < 4) { m5206_mbar_writew(op... | 19,157 |
1 | static int adx_decode(ADXContext *c, int16_t *out, int offset, const uint8_t *in, int ch) { ADXChannelState *prev = &c->prev[ch]; GetBitContext gb; int scale = AV_RB16(in); int i; int s0, s1, s2, d; /* check if this is an EOF packet */ if (scale & 0x8000) return -1; init_get_bits(&gb, in + 2, (BLOCK_SIZE - 2) * 8); out... | 19,158 |
1 | static int ff_asf_get_packet(AVFormatContext *s, AVIOContext *pb) { ASFContext *asf = s->priv_data; uint32_t packet_length, padsize; int rsize = 8; int c, d, e, off; // if we do not know packet size, allow skipping up to 32 kB off= 32768; if (s->packet_size > 0) off= (avio_tell(pb) - s->data_offset) % s->packet_size + ... | 19,159 |
0 | static bool bdrv_start_throttled_reqs(BlockDriverState *bs) { bool drained = false; bool enabled = bs->io_limits_enabled; int i; bs->io_limits_enabled = false; for (i = 0; i < 2; i++) { while (qemu_co_enter_next(&bs->throttled_reqs[i])) { drained = true; } } bs->io_limits_enabled = enabled; return drained; } | 19,161 |
0 | static int nbd_co_send_request(BlockDriverState *bs, NBDRequest *request, QEMUIOVector *qiov) { NBDClientSession *s = nbd_get_client_session(bs); int rc, ret, i; qemu_co_mutex_lock(&s->send_mutex); while (s->in_flight == MAX_NBD_REQUESTS) { qemu_co_queue_wait(&s->free_sema, &s->send_mutex); } s->in_flight++; for (i = 0... | 19,162 |
0 | PCIBus *i440fx_init(PCII440FXState **pi440fx_state, int *piix3_devfn, ISABus **isa_bus, qemu_irq *pic, MemoryRegion *address_space_mem, MemoryRegion *address_space_io, ram_addr_t ram_size, hwaddr pci_hole_start, hwaddr pci_hole_size, ram_addr_t above_4g_mem_size, MemoryRegion *pci_address_space, MemoryRegion *ram_memor... | 19,163 |
0 | static int ppc_hash32_pte_update_flags(struct mmu_ctx_hash32 *ctx, target_ulong *pte1p, int ret, int rw) { int store = 0; /* Update page flags */ if (!(*pte1p & HPTE32_R_R)) { /* Update accessed flag */ *pte1p |= HPTE32_R_R; store = 1; } if (!(*pte1p & HPTE32_R_C)) { if (rw == 1 && ret == 0) { /* Update changed flag */... | 19,164 |
0 | static bool cmd_set_features(IDEState *s, uint8_t cmd) { uint16_t *identify_data; if (!s->bs) { ide_abort_command(s); return true; } /* XXX: valid for CDROM ? */ switch (s->feature) { case 0x02: /* write cache enable */ bdrv_set_enable_write_cache(s->bs, true); identify_data = (uint16_t *)s->identify_data; put_le16(ide... | 19,166 |
0 | static void scsi_unrealize(SCSIDevice *dev, Error **errp) { SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev); scsi_device_purge_requests(&s->qdev, SENSE_CODE(NO_SENSE)); blockdev_mark_auto_del(s->qdev.conf.blk); } | 19,167 |
0 | uint32 float64_to_uint32_round_to_zero( float64 a STATUS_PARAM ) { int64_t v; uint32 res; v = float64_to_int64_round_to_zero(a STATUS_VAR); if (v < 0) { res = 0; float_raise( float_flag_invalid STATUS_VAR); } else if (v > 0xffffffff) { res = 0xffffffff; float_raise( float_flag_invalid STATUS_VAR); } else { res = v; } r... | 19,168 |
0 | static int mkv_write_tag(AVFormatContext *s, AVDictionary *m, unsigned int elementid, unsigned int uid, ebml_master *tags) { MatroskaMuxContext *mkv = s->priv_data; ebml_master tag, targets; AVDictionaryEntry *t = NULL; int ret; if (!tags->pos) { ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TAGS, avio_t... | 19,169 |
0 | static int decode_audio_specific_config(AACContext *ac, AVCodecContext *avctx, MPEG4AudioConfig *m4ac, const uint8_t *data, int bit_size, int sync_extension) { GetBitContext gb; int i, ret; av_dlog(avctx, "extradata size %d\n", avctx->extradata_size); for (i = 0; i < avctx->extradata_size; i++) av_dlog(avctx, "%02x ", ... | 19,170 |
0 | static int rv34_set_deblock_coef(RV34DecContext *r) { MpegEncContext *s = &r->s; int mvmask = 0, i, j; int midx = s->mb_x * 2 + s->mb_y * 2 * s->b8_stride; int16_t (*motion_val)[2] = s->current_picture_ptr->motion_val[0][midx]; if(s->pict_type == FF_I_TYPE) return 0; for(j = 0; j < 16; j += 8){ for(i = 0; i < 2; i++){ ... | 19,171 |
0 | static int ppc_hash32_get_bat(CPUPPCState *env, struct mmu_ctx_hash32 *ctx, target_ulong virtual, int rw, int type) { target_ulong *BATlt, *BATut, *BATu, *BATl; target_ulong BEPIl, BEPIu, bl; int i, valid, prot; int ret = -1; LOG_BATS("%s: %cBAT v " TARGET_FMT_lx "\n", __func__, type == ACCESS_CODE ? 'I' : 'D', virtual... | 19,172 |
0 | static uint64_t pl050_read(void *opaque, hwaddr offset, unsigned size) { pl050_state *s = (pl050_state *)opaque; if (offset >= 0xfe0 && offset < 0x1000) return pl050_id[(offset - 0xfe0) >> 2]; switch (offset >> 2) { case 0: /* KMICR */ return s->cr; case 1: /* KMISTAT */ { uint8_t val; uint32_t stat; val = s->last; val... | 19,173 |
0 | BlockdevOnError bdrv_get_on_error(BlockDriverState *bs, bool is_read) { return is_read ? bs->on_read_error : bs->on_write_error; } | 19,174 |
0 | static int openfile(char *name, int flags, int growable, QDict *opts) { Error *local_err = NULL; if (qemuio_bs) { fprintf(stderr, "file open already, try 'help close'\n"); return 1; } if (growable) { if (bdrv_open(&qemuio_bs, name, NULL, opts, flags | BDRV_O_PROTOCOL, NULL, &local_err)) { fprintf(stderr, "%s: can't ope... | 19,175 |
0 | static int usb_hid_handle_control(USBDevice *dev, USBPacket *p, int request, int value, int index, int length, uint8_t *data) { USBHIDState *us = DO_UPCAST(USBHIDState, dev, dev); HIDState *hs = &us->hid; int ret; ret = usb_desc_handle_control(dev, p, request, value, index, length, data); if (ret >= 0) { return ret; } ... | 19,176 |
0 | void gic_set_priority(GICState *s, int cpu, int irq, uint8_t val) { if (irq < GIC_INTERNAL) { s->priority1[irq][cpu] = val; } else { s->priority2[(irq) - GIC_INTERNAL] = val; } } | 19,178 |
0 | static void test_self(void) { Coroutine *coroutine; coroutine = qemu_coroutine_create(verify_self); qemu_coroutine_enter(coroutine, coroutine); } | 19,179 |
0 | void object_unparent(Object *obj) { object_ref(obj); if (obj->parent) { object_property_del_child(obj->parent, obj, NULL); } if (obj->class->unparent) { (obj->class->unparent)(obj); } object_unref(obj); } | 19,180 |
0 | static int decode_header(MPADecodeContext *s, UINT32 header) { int sample_rate, frame_size, mpeg25, padding; int sample_rate_index, bitrate_index; if (header & (1<<20)) { s->lsf = (header & (1<<19)) ? 0 : 1; mpeg25 = 0; } else { s->lsf = 1; mpeg25 = 1; } s->layer = 4 - ((header >> 17) & 3); /* extract frequency */ samp... | 19,182 |
0 | static gboolean gd_focus_out_event(GtkWidget *widget, GdkEventCrossing *crossing, gpointer opaque) { VirtualConsole *vc = opaque; GtkDisplayState *s = vc->s; gtk_release_modifiers(s); return TRUE; } | 19,183 |
0 | void isa_init_irq(ISADevice *dev, qemu_irq *p, int isairq) { assert(dev->nirqs < ARRAY_SIZE(dev->isairq)); if (isabus->assigned & (1 << isairq)) { hw_error("isa irq %d already assigned", isairq); } isabus->assigned |= (1 << isairq); dev->isairq[dev->nirqs] = isairq; *p = isabus->irqs[isairq]; dev->nirqs++; } | 19,185 |
0 | void bdrv_swap(BlockDriverState *bs_new, BlockDriverState *bs_old) { BlockDriverState tmp; /* The code needs to swap the node_name but simply swapping node_list won't * work so first remove the nodes from the graph list, do the swap then * insert them back if needed. */ if (bs_new->node_name[0] != '\0') { QTAILQ_REMOVE... | 19,186 |
0 | static int sigp_set_architecture(S390CPU *cpu, uint32_t param, uint64_t *status_reg) { CPUState *cur_cs; S390CPU *cur_cpu; bool all_stopped = true; CPU_FOREACH(cur_cs) { cur_cpu = S390_CPU(cur_cs); if (cur_cpu == cpu) { continue; } if (s390_cpu_get_state(cur_cpu) != CPU_STATE_STOPPED) { all_stopped = false; } } *status... | 19,187 |
0 | int kvm_s390_cpu_restart(S390CPU *cpu) { kvm_s390_interrupt(cpu, KVM_S390_RESTART, 0); s390_add_running_cpu(cpu); qemu_cpu_kick(CPU(cpu)); DPRINTF("DONE: KVM cpu restart: %p\n", &cpu->env); return 0; } | 19,188 |
0 | float64 uint64_to_float64( uint64 a STATUS_PARAM ) { if ( a == 0 ) return 0; return normalizeRoundAndPackFloat64( 0, 0x43C, a STATUS_VAR ); } | 19,189 |
0 | void gt64120_reset(void *opaque) { GT64120State *s = opaque; /* CPU Configuration */ #ifdef TARGET_WORDS_BIGENDIAN s->regs[GT_CPU] = 0x00000000; #else s->regs[GT_CPU] = 0x00001000; #endif s->regs[GT_MULTI] = 0x00000000; /* CPU Address decode FIXME: not complete*/ s->regs[GT_PCI0IOLD] = 0x00000080; s->regs[GT_PCI0IOHD] ... | 19,190 |
0 | uint64_t helper_fctiw(CPUPPCState *env, uint64_t arg) { CPU_DoubleU farg; farg.ll = arg; if (unlikely(float64_is_signaling_nan(farg.d))) { /* sNaN conversion */ farg.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN | POWERPC_EXCP_FP_VXCVI); } else if (unlikely(float64_is_quiet_nan(farg.d) || float64_is_infinity(f... | 19,191 |
0 | static void vfio_add_ext_cap(VFIOPCIDevice *vdev) { PCIDevice *pdev = &vdev->pdev; uint32_t header; uint16_t cap_id, next, size; uint8_t cap_ver; uint8_t *config; /* Only add extended caps if we have them and the guest can see them */ if (!pci_is_express(pdev) || !pci_bus_is_express(pdev->bus) || !pci_get_long(pdev->co... | 19,192 |
0 | bool tcg_target_deposit_valid(int ofs, int len) { return (facilities & FACILITY_GEN_INST_EXT) != 0; } | 19,193 |
0 | void handle_diag_308(CPUS390XState *env, uint64_t r1, uint64_t r3) { uint64_t addr = env->regs[r1]; uint64_t subcode = env->regs[r3]; IplParameterBlock *iplb; if (env->psw.mask & PSW_MASK_PSTATE) { program_interrupt(env, PGM_PRIVILEGED, ILEN_LATER_INC); return; } if ((subcode & ~0x0ffffULL) || (subcode > 6)) { program_... | 19,194 |
0 | static int avg_bits_per_pixel(int pix_fmt) { int bits; const PixFmtInfo *pf; pf = &pix_fmt_info[pix_fmt]; if (pf->is_packed) { switch(pix_fmt) { case PIX_FMT_RGB24: case PIX_FMT_BGR24: bits = 24; break; case PIX_FMT_RGBA32: bits = 32; break; case PIX_FMT_RGB565: case PIX_FMT_RGB555: bits = 16; break; case PIX_FMT_PAL8:... | 19,195 |
0 | static void tgen_brcond(TCGContext *s, TCGType type, TCGCond c, TCGReg r1, TCGArg c2, int c2const, TCGLabel *l) { int cc; if (facilities & FACILITY_GEN_INST_EXT) { bool is_unsigned = is_unsigned_cond(c); bool in_range; S390Opcode opc; cc = tcg_cond_to_s390_cond[c]; if (!c2const) { opc = (type == TCG_TYPE_I32 ? (is_unsi... | 19,196 |
0 | static int kvm_get_msrs(CPUState *env) { struct { struct kvm_msrs info; struct kvm_msr_entry entries[100]; } msr_data; struct kvm_msr_entry *msrs = msr_data.entries; int ret, i, n; n = 0; msrs[n++].index = MSR_IA32_SYSENTER_CS; msrs[n++].index = MSR_IA32_SYSENTER_ESP; msrs[n++].index = MSR_IA32_SYSENTER_EIP; if (kvm_ha... | 19,197 |
0 | static int protocol_client_msg(VncState *vs, char *data, size_t len) { int i; uint16_t limit; switch (data[0]) { case 0: if (len == 1) return 20; set_pixel_format(vs, read_u8(data, 4), read_u8(data, 5), read_u8(data, 6), read_u8(data, 7), read_u16(data, 8), read_u16(data, 10), read_u16(data, 12), read_u8(data, 14), rea... | 19,199 |
0 | static void mirror_drain(MirrorBlockJob *s) { while (s->in_flight > 0) { mirror_wait_for_io(s); } } | 19,200 |
0 | static inline void ide_abort_command(IDEState *s) { ide_transfer_stop(s); s->status = READY_STAT | ERR_STAT; s->error = ABRT_ERR; } | 19,202 |
0 | static inline void gen_op_addw_ESP_im(int32_t val) { tcg_gen_ld_tl(cpu_tmp0, cpu_env, offsetof(CPUState, regs[R_ESP])); tcg_gen_addi_tl(cpu_tmp0, cpu_tmp0, val); tcg_gen_st16_tl(cpu_tmp0, cpu_env, offsetof(CPUState, regs[R_ESP]) + REG_W_OFFSET); } | 19,203 |
0 | static void sun4m_hw_init(const struct sun4m_hwdef *hwdef, QEMUMachineInitArgs *args) { const char *cpu_model = args->cpu_model; unsigned int i; void *iommu, *espdma, *ledma, *nvram; qemu_irq *cpu_irqs[MAX_CPUS], slavio_irq[32], slavio_cpu_irq[MAX_CPUS], espdma_irq, ledma_irq; qemu_irq esp_reset, dma_enable; qemu_irq f... | 19,205 |
0 | static inline void gen_op_eval_ble(TCGv dst, TCGv_i32 src) { gen_mov_reg_N(cpu_tmp0, src); gen_mov_reg_V(dst, src); tcg_gen_xor_tl(dst, dst, cpu_tmp0); gen_mov_reg_Z(cpu_tmp0, src); tcg_gen_or_tl(dst, dst, cpu_tmp0); } | 19,206 |
0 | static void colo_compare_finalize(Object *obj) { CompareState *s = COLO_COMPARE(obj); qemu_chr_fe_deinit(&s->chr_pri_in, false); qemu_chr_fe_deinit(&s->chr_sec_in, false); qemu_chr_fe_deinit(&s->chr_out, false); g_main_loop_quit(s->compare_loop); qemu_thread_join(&s->thread); /* Release all unhandled packets after comp... | 19,207 |
0 | static int exec_close(MigrationState *s) { int ret = 0; DPRINTF("exec_close\n"); ret = qemu_fclose(s->opaque); s->opaque = NULL; s->fd = -1; if (ret >= 0 && !(WIFEXITED(ret) && WEXITSTATUS(ret) == 0)) { /* close succeeded, but non-zero exit code: */ ret = -EIO; /* fake errno value */ } return ret; } | 19,208 |
0 | static int megasas_handle_abort(MegasasState *s, MegasasCmd *cmd) { uint64_t abort_ctx = le64_to_cpu(cmd->frame->abort.abort_context); target_phys_addr_t abort_addr, addr_hi, addr_lo; MegasasCmd *abort_cmd; addr_hi = le32_to_cpu(cmd->frame->abort.abort_mfi_addr_hi); addr_lo = le32_to_cpu(cmd->frame->abort.abort_mfi_add... | 19,209 |
0 | static bool aio_epoll_enabled(AioContext *ctx) { /* Fall back to ppoll when external clients are disabled. */ return !aio_external_disabled(ctx) && ctx->epoll_enabled; } | 19,210 |
1 | av_cold void ff_h264_decode_init_vlc(void){ static int done = 0; if (!done) { int i; int offset; done = 1; chroma_dc_coeff_token_vlc.table = chroma_dc_coeff_token_vlc_table; chroma_dc_coeff_token_vlc.table_allocated = chroma_dc_coeff_token_vlc_table_size; init_vlc(&chroma_dc_coeff_token_vlc, CHROMA_DC_COEFF_TOKEN_VLC_B... | 19,211 |
1 | static inline void RENAME(yuvPlanartouyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst, unsigned int width, unsigned int height, int lumStride, int chromStride, int dstStride, int vertLumPerChroma) { unsigned y; const unsigned chromWidth= width>>1; for(y=0; y<height; y++) { #ifdef HAVE_M... | 19,212 |
1 | static inline int get_lowest_part_list_y(H264Context *h, Picture *pic, int n, int height, int y_offset, int list) { int raw_my = h->mv_cache[list][scan8[n]][1]; int filter_height = (raw_my & 3) ? 2 : 0; int full_my = (raw_my >> 2) + y_offset; int top = full_my - filter_height; int bottom = full_my + filter_height + hei... | 19,214 |
1 | int avpriv_dv_produce_packet(DVDemuxContext *c, AVPacket *pkt, uint8_t* buf, int buf_size) { int size, i; uint8_t *ppcm[4] = {0}; if (buf_size < DV_PROFILE_BYTES || !(c->sys = avpriv_dv_frame_profile(c->sys, buf, buf_size)) || buf_size < c->sys->frame_size) { return -1; /* Broken frame, or not enough data */ } /* Queue... | 19,215 |
1 | static void fw_cfg_io_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); dc->realize = fw_cfg_io_realize; dc->props = fw_cfg_io_properties; } | 19,217 |
1 | static int net_socket_listen_init(VLANState *vlan, const char *model, const char *name, const char *host_str) { NetSocketListenState *s; int fd, val, ret; struct sockaddr_in saddr; if (parse_host_port(&saddr, host_str) < 0) return -1; s = g_malloc0(sizeof(NetSocketListenState)); fd = qemu_socket(PF_INET, SOCK_STREAM, 0... | 19,218 |
1 | static void e1000e_pci_realize(PCIDevice *pci_dev, Error **errp) { static const uint16_t e1000e_pmrb_offset = 0x0C8; static const uint16_t e1000e_pcie_offset = 0x0E0; static const uint16_t e1000e_aer_offset = 0x100; static const uint16_t e1000e_dsn_offset = 0x140; E1000EState *s = E1000E(pci_dev); uint8_t *macaddr; int... | 19,219 |
1 | int ff_ac3_bit_alloc_calc_mask(AC3BitAllocParameters *s, int16_t *band_psd, int start, int end, int fast_gain, int is_lfe, int dba_mode, int dba_nsegs, uint8_t *dba_offsets, uint8_t *dba_lengths, uint8_t *dba_values, int16_t *mask) { int16_t excite[AC3_CRITICAL_BANDS]; /* excitation */ int band; int band_start, band_en... | 19,220 |
1 | int v9fs_remove_xattr(FsContext *ctx, const char *path, const char *name) { XattrOperations *xops = get_xattr_operations(ctx->xops, name); if (xops) { return xops->removexattr(ctx, path, name); } errno = -EOPNOTSUPP; return -1; } | 19,221 |
1 | static void gen_rfsvc(DisasContext *ctx) { #if defined(CONFIG_USER_ONLY) gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC); #else if (unlikely(ctx->pr)) { gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC); return; } gen_helper_rfsvc(cpu_env); gen_sync_exception(ctx); #endif } | 19,222 |
1 | static void pc_init1(QEMUMachineInitArgs *args, int pci_enabled, int kvmclock_enabled) { MemoryRegion *system_memory = get_system_memory(); MemoryRegion *system_io = get_system_io(); int i; ram_addr_t below_4g_mem_size, above_4g_mem_size; PCIBus *pci_bus; ISABus *isa_bus; PCII440FXState *i440fx_state; int piix3_devfn =... | 19,224 |
1 | static void v9fs_getattr(void *opaque) { int32_t fid; size_t offset = 7; ssize_t retval = 0; struct stat stbuf; V9fsFidState *fidp; uint64_t request_mask; V9fsStatDotl v9stat_dotl; V9fsPDU *pdu = opaque; V9fsState *s = pdu->s; pdu_unmarshal(pdu, offset, "dq", &fid, &request_mask); fidp = get_fid(pdu, fid); if (fidp == ... | 19,225 |
1 | static int parse_audio_var(AVFormatContext *avctx, AVStream *st, const char *name, int size) { AVIOContext *pb = avctx->pb; if (!strcmp(name, "__DIR_COUNT")) { st->nb_frames = var_read_int(pb, size); } else if (!strcmp(name, "AUDIO_FORMAT")) { st->codec->codec_id = var_read_int(pb, size); } else if (!strcmp(name, "COMP... | 19,228 |
1 | static void gmc_mmx(uint8_t *dst, uint8_t *src, int stride, int h, int ox, int oy, int dxx, int dxy, int dyx, int dyy, int shift, int r, int width, int height) { const int w = 8; const int ix = ox >> (16 + shift); const int iy = oy >> (16 + shift); const int oxs = ox >> 4; const int oys = oy >> 4; const int dxxs = dxx ... | 19,229 |
1 | static int decode_band_types(AACContext *ac, enum BandType band_type[120], int band_type_run_end[120], GetBitContext *gb, IndividualChannelStream *ics) { int g, idx = 0; const int bits = (ics->window_sequence[0] == EIGHT_SHORT_SEQUENCE) ? 3 : 5; for (g = 0; g < ics->num_window_groups; g++) { int k = 0; while (k < ics->... | 19,230 |
1 | target_ulong helper_ldr(CPUMIPSState *env, target_ulong arg1, target_ulong arg2, int mem_idx) { uint64_t tmp; tmp = do_lbu(env, arg2, mem_idx); arg1 = (arg1 & 0xFFFFFFFFFFFFFF00ULL) | tmp; if (GET_LMASK64(arg2) >= 1) { tmp = do_lbu(env, GET_OFFSET(arg2, -1), mem_idx); arg1 = (arg1 & 0xFFFFFFFFFFFF00FFULL) | (tmp << 8);... | 19,231 |
1 | int ff_hevc_decode_nal_sps(HEVCContext *s) { const AVPixFmtDescriptor *desc; GetBitContext *gb = &s->HEVClc->gb; int ret = 0; unsigned int sps_id = 0; int log2_diff_max_min_transform_block_size; int bit_depth_chroma, start, vui_present, sublayer_ordering_info; int i; HEVCSPS *sps; AVBufferRef *sps_buf = av_buffer_alloc... | 19,232 |
1 | static BlockDriverAIOCB *quorum_aio_readv(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque) { BDRVQuorumState *s = bs->opaque; QuorumAIOCB *acb = quorum_aio_get(s, bs, qiov, sector_num, nb_sectors, cb, opaque); int i; acb->is_read = true; for (i =... | 19,234 |
1 | static int tgv_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt) { const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; TgvContext *s = avctx->priv_data; const uint8_t *buf_end = buf + buf_size; AVFrame *frame = data; int chunk_type, ret; if (buf_end - buf < EA_PREAMBLE_SIZE) ret... | 19,235 |
1 | void HELPER(ove)(CPUOpenRISCState *env, target_ulong test) { if (unlikely(test)) { OpenRISCCPU *cpu = openrisc_env_get_cpu(env); CPUState *cs = CPU(cpu); cs->exception_index = EXCP_RANGE; cpu_loop_exit_restore(cs, GETPC()); } } | 19,236 |
1 | void net_slirp_smb(const char *exported_dir) { struct in_addr vserver_addr = { .s_addr = 0 }; if (legacy_smb_export) { fprintf(stderr, "-smb given twice\n"); exit(1); } legacy_smb_export = exported_dir; if (!QTAILQ_EMPTY(&slirp_stacks)) { slirp_smb(QTAILQ_FIRST(&slirp_stacks), NULL, exported_dir, vserver_addr); } } | 19,239 |
1 | static int cloop_open(BlockDriverState *bs, QDict *options, int flags, Error **errp) { BDRVCloopState *s = bs->opaque; uint32_t offsets_size, max_compressed_block_size = 1, i; int ret; bs->read_only = 1; /* read header */ ret = bdrv_pread(bs->file, 128, &s->block_size, 4); if (ret < 0) { return ret; s->block_size = be3... | 19,240 |
1 | void monitor_init(CharDriverState *hd, int show_banner) { int i; if (is_first_init) { for (i = 0; i < MAX_MON; i++) { monitor_hd[i] = NULL; } is_first_init = 0; } for (i = 0; i < MAX_MON; i++) { if (monitor_hd[i] == NULL) { monitor_hd[i] = hd; break; } } hide_banner = !show_banner; qemu_chr_add_handlers(hd, term_can_re... | 19,241 |
1 | int ff_h264_decode_slice_header(H264Context *h, H264Context *h0) { 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 must_reinit; int needs_reinit = 0; int field_pic_flag, bottom_field_flag; int first_slice = h == h0 && !h0-... | 19,242 |
1 | static void spatial_compose53i_dy_buffered(dwt_compose_t *cs, slice_buffer * sb, int width, int height, int stride_line){ int y= cs->y; int mirror0 = mirror(y-1, height-1); int mirror1 = mirror(y , height-1); int mirror2 = mirror(y+1, height-1); int mirror3 = mirror(y+2, height-1); DWTELEM *b0= cs->b0; DWTELEM *b1= cs-... | 19,244 |
1 | void virtio_scsi_handle_ctrl_req(VirtIOSCSI *s, VirtIOSCSIReq *req) { VirtIODevice *vdev = (VirtIODevice *)s; uint32_t type; int r = 0; if (iov_to_buf(req->elem.out_sg, req->elem.out_num, 0, &type, sizeof(type)) < sizeof(type)) { virtio_scsi_bad_req(); return; } virtio_tswap32s(vdev, &type); if (type == VIRTIO_SCSI_T_T... | 19,246 |
1 | inline static void RENAME(hcscale)(uint16_t *dst, int dstWidth, uint8_t *src1, uint8_t *src2, int srcW, int xInc, int flags, int canMMX2BeUsed, int16_t *hChrFilter, int16_t *hChrFilterPos, int hChrFilterSize, void *funnyUVCode, int srcFormat, uint8_t *formatConvBuffer) { if(srcFormat==IMGFMT_YUY2) { RENAME(yuy2ToUV)(fo... | 19,247 |
0 | static uint64_t sniff_channel_order(uint8_t (*layout_map)[3], int tags) { int i, n, total_non_cc_elements; struct elem_to_channel e2c_vec[MAX_ELEM_ID] = {{ 0 }}; int num_front_channels, num_side_channels, num_back_channels; uint64_t layout; i = 0; num_front_channels = count_paired_channels(layout_map, tags, AAC_CHANNEL... | 19,249 |
0 | static int film_read_header(AVFormatContext *s) { FilmDemuxContext *film = s->priv_data; AVIOContext *pb = s->pb; AVStream *st; unsigned char scratch[256]; int i, ret; unsigned int data_offset; unsigned int audio_frame_counter; film->sample_table = NULL; film->stereo_buffer = NULL; film->stereo_buffer_size = 0; /* load... | 19,251 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.