label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | void ppc_hash64_unmap_hptes(PowerPCCPU *cpu, const ppc_hash_pte64_t *hptes, hwaddr ptex, int n){ if (cpu->env.external_htab == MMU_HASH64_KVM_MANAGED_HPT) { g_free((void *)hptes); } else if (!cpu->env.external_htab) { address_space_unmap(CPU(cpu)->as, (void *)hptes, n * HASH_PTE_SIZE_64, false, n * HASH_PTE_SIZE_64); }... |
0 | static void tcg_reg_sync(TCGContext *s, TCGReg reg, TCGRegSet allocated_regs){ TCGTemp *ts = s->reg_to_temp[reg]; assert(ts->val_type == TEMP_VAL_REG); if (!ts->mem_coherent && !ts->fixed_reg) { if (!ts->mem_allocated) { temp_allocate_frame(s, temp_idx(s, ts)); } else if (ts->indirect_reg) { tcg_regset_set_reg(allocate... |
0 | static QOSState *pci_test_start(int socket){ const char *cmd = "-netdev socket,fd=%d,id=hs0 -device " "virtio-net-pci,netdev=hs0"; return qtest_pc_boot(cmd, socket);} |
0 | static int spapr_populate_pci_child_dt(PCIDevice *dev, void *fdt, int offset, sPAPRPHBState *sphb){ ResourceProps rp; bool is_bridge = false; int pci_status, err; char *buf = NULL; uint32_t drc_index = spapr_phb_get_pci_drc_index(sphb, dev); uint32_t ccode = pci_default_read_config(dev, PCI_CLASS_PROG, 3); uint32_t max... |
0 | static int v9fs_xattr_write(V9fsState *s, V9fsPDU *pdu, V9fsFidState *fidp, uint64_t off, uint32_t count, struct iovec *sg, int cnt){ int i, to_copy; ssize_t err = 0; int write_count; int64_t xattr_len; size_t offset = 7; xattr_len = fidp->fs.xattr.len; write_count = xattr_len - off; if (write_count > count) { write_co... |
0 | static int x86_cpu_filter_features(X86CPU *cpu){ CPUX86State *env = &cpu->env; FeatureWord w; int rv = 0; for (w = 0; w < FEATURE_WORDS; w++) { uint32_t host_feat = x86_cpu_get_supported_feature_word(w, false); uint32_t requested_features = env->features[w]; env->features[w] &= host_feat; cpu->filtered_features[w] = re... |
0 | static int decode_mb(H264Context *h){ MpegEncContext * const s = &h->s; const int mb_xy= s->mb_x + s->mb_y*s->mb_stride; int mb_type, partition_count, cbp; s->dsp.clear_blocks(h->mb); //FIXME avoid if allready clear (move after skip handlong? tprintf("pic:%d mb:%d/%d\n", h->frame_num, s->mb_x, s->mb_y); cbp = 0; /* avo... |
0 | static void decode_vui(GetBitContext *gb, AVCodecContext *avctx, int apply_defdispwin, HEVCSPS *sps){ VUI *vui = &sps->vui; int sar_present; av_log(avctx, AV_LOG_DEBUG, "Decoding VUI\n"); sar_present = get_bits1(gb); if (sar_present) { uint8_t sar_idx = get_bits(gb, 8); if (sar_idx < FF_ARRAY_ELEMS(vui_sar)) vui->sar =... |
1 | static int ivf_write_trailer(AVFormatContext *s){ AVIOContext *pb = s->pb; if (pb->seekable) { IVFEncContext *ctx = s->priv_data; size_t end = avio_tell(pb); avio_seek(pb, 24, SEEK_SET); avio_wl64(pb, ctx->frame_cnt * ctx->sum_delta_pts / (ctx->frame_cnt - 1)); avio_seek(pb, end, SEEK_SET); } return 0;} |
1 | static int main_loop(void){ int ret, timeout;#ifdef CONFIG_PROFILER int64_t ti;#endif CPUState *env; cur_cpu = first_cpu; next_cpu = cur_cpu->next_cpu ?: first_cpu; for(;;) { if (vm_running) { for(;;) { /* get next cpu */ env = next_cpu;#ifdef CONFIG_PROFILER ti = profile_getclock();#endif if (use_icount) { int64_t cou... |
1 | int acpi_table_add(const QemuOpts *opts){ AcpiTableOptions *hdrs = NULL; Error *err = NULL; char **pathnames = NULL; char **cur; size_t len, start, allen; bool has_header; int changed; int r; struct acpi_table_header hdr; char unsigned *table_start; { OptsVisitor *ov; ov = opts_visitor_new(opts); visit_type_AcpiTableOp... |
1 | static int mov_read_stsz(MOVContext *c, ByteIOContext *pb, MOV_atom_t atom){ AVStream *st = c->fc->streams[c->fc->nb_streams-1]; MOVStreamContext *sc = (MOVStreamContext *)st->priv_data; int entries, i; print_atom("stsz", atom); get_byte(pb); /* version */ get_byte(pb); get_byte(pb); get_byte(pb); /* flags */ sc->sampl... |
1 | CharDriverState *qemu_chr_new_from_opts(QemuOpts *opts, void (*init)(struct CharDriverState *s)){ CharDriverState *chr; int i; int ret; if (qemu_opts_id(opts) == NULL) { fprintf(stderr, "chardev: no id specified\n"); return NULL; } if (qemu_opt_get(opts, "backend") == NULL) { fprintf(stderr, "chardev: \"%s\" missing ba... |
1 | static void bastardized_rice_decompress(ALACContext *alac, int32_t *output_buffer, int output_size, int readsamplesize, /* arg_10 */ int rice_initialhistory, /* arg424->b */ int rice_kmodifier, /* arg424->d */ int rice_historymult, /* arg424->c */ int rice_kmodifier_mask /* arg424->e */ ){ int output_count; unsigned in... |
1 | static int vdadec_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt){ VDADecoderContext *ctx = avctx->priv_data; AVFrame *pic = data; int ret; ret = ff_h264_decoder.decode(avctx, data, got_frame, avpkt); if (*got_frame) { AVBufferRef *buffer = pic->buf[0]; VDABufferContext *context = av_buffer_g... |
1 | static int target_pread(int fd, abi_ulong ptr, abi_ulong len, abi_ulong offset){ void *buf; int ret; buf = lock_user(VERIFY_WRITE, ptr, len, 0); ret = pread(fd, buf, len, offset); unlock_user(buf, ptr, len); return ret; |
0 | void helper_lret_protected(int shift, int addend){ helper_ret_protected(shift, 0, addend);#ifdef CONFIG_KQEMU if (kqemu_is_ok(env)) { env->exception_index = -1; cpu_loop_exit(); }#endif} |
0 | uint32_t gic_acknowledge_irq(GICState *s, int cpu){ int ret, irq, src; int cm = 1 << cpu; irq = s->current_pending[cpu]; if (irq == 1023 || GIC_GET_PRIORITY(irq, cpu) >= s->running_priority[cpu]) { DPRINTF("ACK no pending IRQ\n"); return 1023; } s->last_active[irq][cpu] = s->running_irq[cpu]; if (s->revision == REV_11M... |
0 | av_cold void ff_dsputil_init_ppc(DSPContext *c, AVCodecContext *avctx){ const int high_bit_depth = avctx->bits_per_raw_sample > 8; // Common optimizations whether AltiVec is available or not if (!high_bit_depth) { switch (check_dcbzl_effect()) { case 32: c->clear_blocks = clear_blocks_dcbz32_ppc; break; case 128: c->cl... |
0 | static IOMMUTLBEntry pbm_translate_iommu(MemoryRegion *iommu, hwaddr addr, bool is_write){ IOMMUState *is = container_of(iommu, IOMMUState, iommu); hwaddr baseaddr, offset; uint64_t tte; uint32_t tsbsize; IOMMUTLBEntry ret = { .target_as = &address_space_memory, .iova = 0, .translated_addr = 0, .addr_mask = ~(hwaddr)0,... |
0 | static void coroutine_fn mirror_iteration(MirrorBlockJob *s){ BlockDriverState *source = s->common.bs; int nb_sectors, sectors_per_chunk, nb_chunks; int64_t end, sector_num, next_chunk, next_sector, hbitmap_next_sector; MirrorOp *op; s->sector_num = hbitmap_iter_next(&s->hbi); if (s->sector_num < 0) { bdrv_dirty_iter_i... |
0 | static int s390_cpu_initial_reset(S390CPU *cpu){ CPUState *cs = CPU(cpu); CPUS390XState *env = &cpu->env; int i; s390_del_running_cpu(cpu); if (kvm_vcpu_ioctl(cs, KVM_S390_INITIAL_RESET, NULL) < 0) { perror("cannot init reset vcpu"); } /* Manually zero out all registers */ cpu_synchronize_state(cs); for (i = 0; i < 16;... |
0 | void virtio_setup_block(struct subchannel_id schid){ struct vq_info_block info; struct vq_config_block config = {}; virtio_reset(schid); config.index = 0; if (run_ccw(schid, CCW_CMD_READ_VQ_CONF, &config, sizeof(config))) { virtio_panic("Could not get block device configuration\n"); } vring_init(&block, config.num, (vo... |
0 | static int v9fs_do_open2(V9fsState *s, V9fsString *path, int flags, mode_t mode){ return s->ops->open2(&s->ctx, path->data, flags, mode);} |
0 | udp_listen(Slirp *slirp, uint32_t haddr, u_int hport, uint32_t laddr, u_int lport, int flags){struct sockaddr_in addr;struct socket *so;socklen_t addrlen = sizeof(struct sockaddr_in);so = socreate(slirp);if (!so) { return NULL;}so->s = qemu_socket(AF_INET,SOCK_DGRAM,0);so->so_expire = curtime + SO_EXPIRE;insque(so, &sl... |
0 | blkdebug_co_pwritev(BlockDriverState *bs, uint64_t offset, uint64_t bytes, QEMUIOVector *qiov, int flags){ BDRVBlkdebugState *s = bs->opaque; BlkdebugRule *rule = NULL; /* Sanity check block layer guarantees */ assert(QEMU_IS_ALIGNED(offset, bs->bl.request_alignment)); assert(QEMU_IS_ALIGNED(bytes, bs->bl.request_align... |
0 | static void test_visitor_out_struct_errors(TestOutputVisitorData *data, const void *unused){ EnumOne bad_values[] = { ENUM_ONE_MAX, -1 }; UserDefZero b; UserDefOne u = { .base = &b }, *pu = &u; Error *err; int i; for (i = 0; i < ARRAY_SIZE(bad_values) ; i++) { err = NULL; u.has_enum1 = true; u.enum1 = bad_values[i]; vi... |
0 | static HEVCFrame *find_ref_idx(HEVCContext *s, int poc){ int i; int LtMask = (1 << s->sps->log2_max_poc_lsb) - 1; for (i = 0; i < FF_ARRAY_ELEMS(s->DPB); i++) { HEVCFrame *ref = &s->DPB[i]; if (ref->frame->buf[0] && (ref->sequence == s->seq_decode)) { if ((ref->poc & LtMask) == poc) return ref; } } for (i = 0; i < FF_A... |
0 | void timer_free(QEMUTimer *ts){ g_free(ts);} |
0 | int do_snapshot_blkdev(Monitor *mon, const QDict *qdict, QObject **ret_data){ const char *device = qdict_get_str(qdict, "device"); const char *filename = qdict_get_try_str(qdict, "snapshot-file"); const char *format = qdict_get_try_str(qdict, "format"); BlockDriverState *bs; BlockDriver *drv, *old_drv, *proto_drv; int ... |
0 | static void breakpoint_invalidate(CPUState *env, target_ulong pc){ target_ulong phys_addr; phys_addr = cpu_get_phys_page_debug(env, pc); tb_invalidate_phys_page_range(phys_addr, phys_addr + 1, 0);} |
0 | static void omap_ppm_save(const char *filename, uint8_t *data, int w, int h, int linesize, Error **errp){ FILE *f; uint8_t *d, *d1; unsigned int v; int ret, y, x, bpp; f = fopen(filename, "wb"); if (!f) { error_setg(errp, "failed to open file '%s': %s", filename, strerror(errno)); return; } ret = fprintf(f, "P6\n%d %d\... |
0 | static uint64_t unassigned_mem_read(void *opaque, hwaddr addr, unsigned size){#ifdef DEBUG_UNASSIGNED printf("Unassigned mem read " TARGET_FMT_plx "\n", addr);#endif if (current_cpu != NULL) { cpu_unassigned_access(current_cpu, addr, false, false, 0, size); } return -1ULL;} |
0 | void qemu_set_cloexec(int fd){ int f; f = fcntl(fd, F_GETFD); fcntl(fd, F_SETFD, f | FD_CLOEXEC);} |
0 | static int netmap_can_send(void *opaque){ NetmapState *s = opaque; return qemu_can_send_packet(&s->nc);} |
0 | static int kvm_get_dirty_pages_log_range(MemoryRegionSection *section, unsigned long *bitmap){ unsigned int i, j; unsigned long page_number, c; hwaddr addr, addr1; unsigned int len = ((section->size / TARGET_PAGE_SIZE) + HOST_LONG_BITS - 1) / HOST_LONG_BITS; unsigned long hpratio = getpagesize() / TARGET_PAGE_SIZE; /* ... |
0 | static int decode_residual(H264Context *h, GetBitContext *gb, DCTELEM *block, int n, const uint8_t *scantable, const uint32_t *qmul, int max_coeff){ MpegEncContext * const s = &h->s; static const int coeff_token_table_index[17]= {0, 0, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3}; int level[16]; int zeros_left, coeff_n... |
0 | static void ccw_machine_class_init(ObjectClass *oc, void *data){ MachineClass *mc = MACHINE_CLASS(oc); NMIClass *nc = NMI_CLASS(oc); mc->name = "s390-ccw-virtio"; mc->alias = "s390-ccw"; mc->desc = "VirtIO-ccw based S390 machine"; mc->init = ccw_init; mc->block_default_type = IF_VIRTIO; mc->no_cdrom = 1; mc->no_floppy ... |
0 | static int print_bit(DeviceState *dev, Property *prop, char *dest, size_t len){ uint32_t *p = qdev_get_prop_ptr(dev, prop); return snprintf(dest, len, (*p & qdev_get_prop_mask(prop)) ? "on" : "off");} |
0 | static char *pxb_host_ofw_unit_address(const SysBusDevice *dev){ const PCIHostState *pxb_host; const PCIBus *pxb_bus; const PXBDev *pxb_dev; int position; const DeviceState *pxb_dev_base; const PCIHostState *main_host; const SysBusDevice *main_host_sbd; pxb_host = PCI_HOST_BRIDGE(dev); pxb_bus = pxb_host->bus; pxb_dev ... |
1 | static int openfile(char *name, int flags, QDict *opts){ Error *local_err = NULL; if (qemuio_blk) { fprintf(stderr, "file open already, try 'help close'\n"); QDECREF(opts); return 1; } qemuio_blk = blk_new_open("hda", name, NULL, opts, flags, &local_err); if (!qemuio_blk) { fprintf(stderr, "%s: can't open%s%s: %s\n", p... |
1 | static void calc_slice_sizes(VC2EncContext *s){ int slice_x, slice_y; SliceArgs *enc_args = s->slice_args; for (slice_y = 0; slice_y < s->num_y; slice_y++) { for (slice_x = 0; slice_x < s->num_x; slice_x++) { SliceArgs *args = &enc_args[s->num_x*slice_y + slice_x]; args->ctx = s; args->x = slice_x; args->y = slice_y; a... |
1 | int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, const AVPacket *avpkt){ AVCodecInternal *avci = avctx->internal; int ret; // copy to ensure we do not change avpkt AVPacket tmp = *avpkt; if (avctx->codec->type != AVMEDIA_TYPE_VIDEO) { av_log(avctx, AV_LOG_ERRO... |
1 | static int rdma_delete_block(RDMAContext *rdma, RDMALocalBlock *block){ RDMALocalBlocks *local = &rdma->local_ram_blocks; RDMALocalBlock *old = local->block; int x; if (rdma->blockmap) { g_hash_table_remove(rdma->blockmap, (void *)(uintptr_t)block->offset); } if (block->pmr) { int j; for (j = 0; j < block->nb_chunks; j... |
1 | static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n){#if 1 level+=256; if (n < 4) { /* luminance */ put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]); } else { /* chrominance */ put_bits(s, uni_DCtab_chrom_len[level], uni_DCtab_chrom_bits[level]); }#else int size, v; /* find number of ... |
0 | static int pick_formats(AVFilterGraph *graph){ int i, j, ret; int change; do{ change = 0; for (i = 0; i < graph->filter_count; i++) { AVFilterContext *filter = graph->filters[i]; if (filter->nb_inputs){ for (j = 0; j < filter->nb_inputs; j++){ if(filter->inputs[j]->in_formats && filter->inputs[j]->in_formats->format_co... |
0 | ff_yuv2packedX_altivec(SwsContext *c, const int16_t *lumFilter, const int16_t **lumSrc, int lumFilterSize, const int16_t *chrFilter, const int16_t **chrUSrc, const int16_t **chrVSrc, int chrFilterSize, const int16_t **alpSrc, uint8_t *dest, int dstW, int dstY){ int i,j; vector signed short X,X0,X1,Y0,U0,V0,Y1,U1,V1,U,V... |
1 | static void arm_gic_common_realize(DeviceState *dev, Error **errp){ GICState *s = ARM_GIC_COMMON(dev); int num_irq = s->num_irq; if (s->num_cpu > GIC_NCPU) { error_setg(errp, "requested %u CPUs exceeds GIC maximum %d", s->num_cpu, GIC_NCPU); s->num_irq += GIC_BASE_IRQ; if (s->num_irq > GIC_MAXIRQ) { error_setg(errp, "r... |
1 | static int lance_init(SysBusDevice *sbd){ DeviceState *dev = DEVICE(sbd); SysBusPCNetState *d = SYSBUS_PCNET(dev); PCNetState *s = &d->state; memory_region_init_io(&s->mmio, OBJECT(d), &lance_mem_ops, d, "lance-mmio", 4); qdev_init_gpio_in(dev, parent_lance_reset, 1); sysbus_init_mmio(sbd, &s->mmio); sysbus_init_irq(sb... |
1 | static int vc9_decode_init(AVCodecContext *avctx){ VC9Context *v = avctx->priv_data; MpegEncContext *s = &v->s; GetBitContext gb; if (!avctx->extradata_size || !avctx->extradata) return -1; avctx->pix_fmt = PIX_FMT_YUV420P; v->s.avctx = avctx; if(ff_h263_decode_init(avctx) < 0) return -1; if (vc9_init_common(v) < 0) re... |
1 | yuv2rgb48_2_c_template(SwsContext *c, const int32_t *buf[2], const int32_t *ubuf[2], const int32_t *vbuf[2], const int32_t *abuf[2], uint16_t *dest, int dstW, int yalpha, int uvalpha, int y, enum PixelFormat target){ const int32_t *buf0 = buf[0], *buf1 = buf[1], *ubuf0 = ubuf[0], *ubuf1 = ubuf[1], *vbuf0 = vbuf[0], *vb... |
1 | void memory_region_init_alias(MemoryRegion *mr, Object *owner, const char *name, MemoryRegion *orig, hwaddr offset, uint64_t size){ memory_region_init(mr, owner, name, size); memory_region_ref(orig); mr->destructor = memory_region_destructor_alias; mr->alias = orig; mr->alias_offset = offset;} |
1 | static void monitor_protocol_event_handler(void *opaque){ MonitorEventState *evstate = opaque; int64_t now = qemu_clock_get_ns(QEMU_CLOCK_REALTIME); qemu_mutex_lock(&monitor_event_state_lock); trace_monitor_protocol_event_handler(evstate->event, evstate->data, evstate->last, now); if (evstate->data) { monitor_protocol_... |
1 | static coroutine_fn int qcow2_co_pdiscard(BlockDriverState *bs, int64_t offset, int count){ int ret; BDRVQcow2State *s = bs->opaque; if (!QEMU_IS_ALIGNED(offset | count, s->cluster_size)) { assert(count < s->cluster_size); return -ENOTSUP; } qemu_co_mutex_lock(&s->lock); ret = qcow2_discard_clusters(bs, offset, count >... |
1 | void stb_tce(VIOsPAPRDevice *dev, uint64_t taddr, uint8_t val){ spapr_tce_dma_write(dev, taddr, &val, sizeof(val));} |
1 | static void to_meta_with_crop(AVCodecContext *avctx, AVFrame *p, int *dest){ int blockx, blocky, x, y; int luma = 0; int height = FFMIN(avctx->height, C64YRES); int width = FFMIN(avctx->width , C64XRES); uint8_t *src = p->data[0]; for (blocky = 0; blocky < C64YRES; blocky += 8) { for (blockx = 0; blockx < C64XRES; bloc... |
1 | static int mxf_read_packet_old(AVFormatContext *s, AVPacket *pkt){ KLVPacket klv; MXFContext *mxf = s->priv_data; int ret; while ((ret = klv_read_packet(&klv, s->pb)) == 0) { PRINT_KEY(s, "read packet", klv.key); av_log(s, AV_LOG_TRACE, "size %"PRIu64" offset %#"PRIx64"\n", klv.length, klv.offset); if (IS_KLV_KEY(klv.k... |
0 | static int vorbis_floor1_decode(vorbis_context *vc, vorbis_floor_data *vfu, float *vec){ vorbis_floor1 *vf = &vfu->t1; GetBitContext *gb = &vc->gb; uint16_t range_v[4] = { 256, 128, 86, 64 }; unsigned range = range_v[vf->multiplier - 1]; uint16_t floor1_Y[258]; uint16_t floor1_Y_final[258]; int floor1_flag[258]; unsign... |
0 | static int doTest(uint8_t *ref[4], int refStride[4], int w, int h, enum PixelFormat srcFormat, enum PixelFormat dstFormat, int srcW, int srcH, int dstW, int dstH, int flags){ static enum PixelFormat cur_srcFormat; static int cur_srcW, cur_srcH; static uint8_t *src[4]; static int srcStride[4]; uint8_t *dst[4] = {0}; uin... |
0 | static uint64_t pl061_read(void *opaque, hwaddr offset, unsigned size){ PL061State *s = (PL061State *)opaque; if (offset >= 0xfd0 && offset < 0x1000) { return s->id[(offset - 0xfd0) >> 2]; } if (offset < 0x400) { return s->data & (offset >> 2); } switch (offset) { case 0x400: /* Direction */ return s->dir; case 0x404: ... |
0 | void address_space_unmap(AddressSpace *as, void *buffer, hwaddr len, int is_write, hwaddr access_len){ if (buffer != bounce.buffer) { MemoryRegion *mr; ram_addr_t addr1; mr = qemu_ram_addr_from_host(buffer, &addr1); assert(mr != NULL); if (is_write) { while (access_len) { unsigned l; l = TARGET_PAGE_SIZE; if (l > acces... |
0 | int qemu_savevm_state_complete(Monitor *mon, QEMUFile *f){ SaveStateEntry *se; cpu_synchronize_all_states(); QTAILQ_FOREACH(se, &savevm_handlers, entry) { if (se->save_live_state == NULL) continue; /* Section type */ qemu_put_byte(f, QEMU_VM_SECTION_END); qemu_put_be32(f, se->section_id); se->save_live_state(mon, f, QE... |
0 | clk_setup_cb cpu_ppc_tb_init (CPUState *env, uint32_t freq){ ppc_tb_t *tb_env; tb_env = qemu_mallocz(sizeof(ppc_tb_t)); if (tb_env == NULL) return NULL; env->tb_env = tb_env; /* Create new timer */ tb_env->decr_timer = qemu_new_timer(vm_clock, &cpu_ppc_decr_cb, env);#if defined(TARGET_PPC64H) tb_env->hdecr_timer = qemu... |
0 | bool qemu_clock_has_timers(QEMUClockType type){ return timerlist_has_timers( main_loop_tlg.tl[type]);} |
0 | static uint64_t pxa2xx_i2c_read(void *opaque, hwaddr addr, unsigned size){ PXA2xxI2CState *s = (PXA2xxI2CState *) opaque; I2CSlave *slave; addr -= s->offset; switch (addr) { case ICR: return s->control; case ISR: return s->status | (i2c_bus_busy(s->bus) << 2); case ISAR: slave = I2C_SLAVE(s->slave); return slave->addre... |
0 | uint32_t ide_ioport_read(void *opaque, uint32_t addr1){ IDEBus *bus = opaque; IDEState *s = idebus_active_if(bus); uint32_t addr; int ret, hob; addr = addr1 & 7; /* FIXME: HOB readback uses bit 7, but it's always set right now */ //hob = s->select & (1 << 7); hob = 0; switch(addr) { case 0: ret = 0xff; break; case 1: i... |
0 | static void disas_fp_2src(DisasContext *s, uint32_t insn){ unsupported_encoding(s, insn);} |
0 | static const char *io_port_to_string(uint32_t io_port){ if (io_port >= QXL_IO_RANGE_SIZE) { return "out of range"; } static const char *io_port_to_string[QXL_IO_RANGE_SIZE + 1] = { [QXL_IO_NOTIFY_CMD] = "QXL_IO_NOTIFY_CMD", [QXL_IO_NOTIFY_CURSOR] = "QXL_IO_NOTIFY_CURSOR", [QXL_IO_UPDATE_AREA] = "QXL_IO_UPDATE_AREA", [Q... |
0 | static int timer_load(QEMUFile *f, void *opaque, int version_id){ if (version_id != 1 && version_id != 2) return -EINVAL; if (cpu_ticks_enabled) { return -EINVAL; } cpu_ticks_offset=qemu_get_be64(f); ticks_per_sec=qemu_get_be64(f); if (version_id == 2) { cpu_clock_offset=qemu_get_be64(f); } return 0;} |
0 | void omap_uwire_attach(struct omap_uwire_s *s, uWireSlave *slave, int chipselect){ if (chipselect < 0 || chipselect > 3) { fprintf(stderr, "%s: Bad chipselect %i\n", __FUNCTION__, chipselect); exit(-1); } s->chip[chipselect] = slave;} |
0 | int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max){ AVRational a0={0,1}, a1={1,0}; int sign= (num<0) ^ (den<0); int64_t gcd= av_gcd(FFABS(num), FFABS(den)); if(gcd){ num = FFABS(num)/gcd; den = FFABS(den)/gcd; } if(num<=max && den<=max){ a1= (AVRational){num, den}; den=0; } while(den){ uin... |
0 | static void sigp_cpu_restart(void *arg){ CPUState *cs = arg; S390CPU *cpu = S390_CPU(cs); struct kvm_s390_irq irq = { .type = KVM_S390_RESTART, }; kvm_s390_vcpu_interrupt(cpu, &irq); s390_cpu_set_state(CPU_STATE_OPERATING, cpu);} |
0 | print_insn_arg (const char *d,unsigned char *buffer,unsigned char *p0,bfd_vma addr,disassemble_info *info){ int val = 0; int place = d[1]; unsigned char *p = p0; int regno; const char *regname; unsigned char *p1; double flval; int flt_p; bfd_signed_vma disp; unsigned int uval; switch (*d) { case 'c':/* Cache identifier... |
0 | static bool migration_object_check(MigrationState *ms, Error **errp){ if (!migrate_params_check(&ms->parameters, errp)) { return false; } return true;} |
0 | static MigrationState *migrate_init(Monitor *mon, int detach, int blk, int inc){ MigrationState *s = migrate_get_current(); int64_t bandwidth_limit = s->bandwidth_limit; memset(s, 0, sizeof(*s)); s->bandwidth_limit = bandwidth_limit; s->blk = blk; s->shared = inc; /* s->mon is used for two things: - pass fd in fd migra... |
0 | static int find_pte64(CPUPPCState *env, mmu_ctx_t *ctx, int h, int rw, int type, int target_page_bits){ hwaddr pteg_off; target_ulong pte0, pte1; int i, good = -1; int ret, r; ret = -1; /* No entry found */ pteg_off = get_pteg_offset(env, ctx->hash[h], HASH_PTE_SIZE_64); for (i = 0; i < 8; i++) { if (env->external_htab... |
0 | static int qcow2_mark_dirty(BlockDriverState *bs){ BDRVQcowState *s = bs->opaque; uint64_t val; int ret; assert(s->qcow_version >= 3); if (s->incompatible_features & QCOW2_INCOMPAT_DIRTY) { return 0; /* already dirty */ } val = cpu_to_be64(s->incompatible_features | QCOW2_INCOMPAT_DIRTY); ret = bdrv_pwrite(bs->file, of... |
0 | static void decode_sigpass(Jpeg2000T1Context *t1, int width, int height, int bpno, int bandno){ int mask = 3 << (bpno - 1), y0, x, y; for (y0 = 0; y0 < height; y0 += 4) for (x = 0; x < width; x++) for (y = y0; y < height && y < y0 + 4; y++) if ((t1->flags[y + 1][x + 1] & JPEG2000_T1_SIG_NB) && !(t1->flags[y + 1][x + 1]... |
0 | static uint8_t get_tlm(Jpeg2000DecoderContext *s, int n){ uint8_t Stlm, ST, SP, tile_tlm, i; bytestream_get_byte(&s->buf); /* Ztlm: skipped */ Stlm = bytestream_get_byte(&s->buf); // too complex ? ST = ((Stlm >> 4) & 0x01) + ((Stlm >> 4) & 0x02); ST = (Stlm >> 4) & 0x03; // TODO: Manage case of ST = 0b11 --> raise erro... |
0 | static void esp_pci_io_write(void *opaque, target_phys_addr_t addr, uint64_t val, unsigned int size){ PCIESPState *pci = opaque; if (size < 4 || addr & 3) { /* need to upgrade request: we only support 4-bytes accesses */ uint32_t current = 0, mask; int shift; if (addr < 0x40) { current = pci->esp.wregs[addr >> 2]; } el... |
0 | static void spice_update_buttons(QemuSpicePointer *pointer, int wheel, uint32_t button_mask){ static uint32_t bmap[INPUT_BUTTON__MAX] = { [INPUT_BUTTON_LEFT] = 0x01, [INPUT_BUTTON_MIDDLE] = 0x04, [INPUT_BUTTON_RIGHT] = 0x02, [INPUT_BUTTON_WHEEL_UP] = 0x10, [INPUT_BUTTON_WHEEL_DOWN] = 0x20, }; if (wheel < 0) { button_ma... |
0 | Slirp *slirp_init(int restricted, struct in_addr vnetwork, struct in_addr vnetmask, struct in_addr vhost, const char *vhostname, const char *tftp_path, const char *bootfile, struct in_addr vdhcp_start, struct in_addr vnameserver, void *opaque){ Slirp *slirp = qemu_mallocz(sizeof(Slirp)); slirp_init_once(); slirp->restr... |
0 | BdrvDirtyBitmap *bdrv_create_dirty_bitmap(BlockDriverState *bs, int granularity, Error **errp){ int64_t bitmap_size; BdrvDirtyBitmap *bitmap; assert((granularity & (granularity - 1)) == 0); granularity >>= BDRV_SECTOR_BITS; assert(granularity); bitmap_size = bdrv_nb_sectors(bs); if (bitmap_size < 0) { error_setg_errno(... |
0 | static void mch_update_pciexbar(MCHPCIState *mch){ PCIDevice *pci_dev = PCI_DEVICE(mch); BusState *bus = qdev_get_parent_bus(DEVICE(mch)); PCIExpressHost *pehb = PCIE_HOST_BRIDGE(bus->parent); uint64_t pciexbar; int enable; uint64_t addr; uint64_t addr_mask; uint32_t length; pciexbar = pci_get_quad(pci_dev->config + MC... |
0 | static int get_cluster_duration(MOVTrack *track, int cluster_idx){ int64_t next_dts; if (cluster_idx >= track->entry) return 0; if (cluster_idx + 1 == track->entry) next_dts = track->track_duration + track->start_dts; else next_dts = track->cluster[cluster_idx + 1].dts; return next_dts - track->cluster[cluster_idx].dts... |
0 | static inline int tcg_temp_new_internal(TCGType type, int temp_local){ TCGContext *s = &tcg_ctx; TCGTemp *ts; int idx, k; k = type + (temp_local ? TCG_TYPE_COUNT : 0); idx = find_first_bit(s->free_temps[k].l, TCG_MAX_TEMPS); if (idx < TCG_MAX_TEMPS) { /* There is already an available temp with the right type. */ clear_... |
0 | static void tcg_out_r(TCGContext *s, TCGArg t0){ assert(t0 < TCG_TARGET_NB_REGS); tcg_out8(s, t0);} |
0 | ISADevice *pc_find_fdc0(void){ int i; Object *container; CheckFdcState state = { 0 }; for (i = 0; i < ARRAY_SIZE(fdc_container_path); i++) { container = container_get(qdev_get_machine(), fdc_container_path[i]); object_child_foreach(container, check_fdc, &state); } if (state.multiple) { error_report("warning: multiple f... |
0 | static void qvirtio_scsi_start(const char *extra_opts){ char *cmdline; cmdline = g_strdup_printf( "-drive id=drv0,if=none,file=/dev/null,format=raw " "-device virtio-scsi-pci,id=vs0 " "-device scsi-hd,bus=vs0.0,drive=drv0 %s", extra_opts ? : ""); qtest_start(cmdline); g_free(cmdline);} |
0 | static int kvm_s390_io_adapter_map(S390FLICState *fs, uint32_t id, uint64_t map_addr, bool do_map){ struct kvm_s390_io_adapter_req req = { .id = id, .type = do_map ? KVM_S390_IO_ADAPTER_MAP : KVM_S390_IO_ADAPTER_UNMAP, .addr = map_addr, }; struct kvm_device_attr attr = { .group = KVM_DEV_FLIC_ADAPTER_MODIFY, .addr = (u... |
0 | uint32_t HELPER(get_r13_banked)(CPUState *env, uint32_t mode){ return env->banked_r13[bank_number(mode)];} |
0 | static void usb_msd_set_bootindex(Object *obj, Visitor *v, const char *name, void *opaque, Error **errp){ USBDevice *dev = USB_DEVICE(obj); MSDState *s = USB_STORAGE_DEV(dev); int32_t boot_index; Error *local_err = NULL; visit_type_int32(v, name, &boot_index, &local_err); if (local_err) { goto out; } /* check whether b... |
0 | static void e100_pci_reset(EEPRO100State * s, E100PCIDeviceInfo *e100_device){ uint32_t device = s->device; uint8_t *pci_conf = s->dev.config; TRACE(OTHER, logout("%p\n", s)); /* PCI Vendor ID */ pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_INTEL); /* PCI Device ID */ pci_config_set_device_id(pci_conf, e100_device-... |
1 | int net_init_bridge(const NetClientOptions *opts, const char *name, NetClientState *peer, Error **errp){ /* FIXME error_setg(errp, ...) on failure */ const NetdevBridgeOptions *bridge; const char *helper, *br; TAPState *s; int fd, vnet_hdr; assert(opts->kind == NET_CLIENT_OPTIONS_KIND_BRIDGE); bridge = opts->bridge; he... |
1 | static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al, const uint8_t *mb_bitmask, int mb_bitmask_size, const AVFrame *reference){ int i, mb_x, mb_y; uint8_t *data[MAX_COMPONENTS]; const uint8_t *reference_data[MAX_COMPONENTS]; int linesize[MAX_COMPONENTS]; GetBitContext mb_bitmask_gb = {... |
1 | int kvm_cpu_exec(CPUState *cpu){ struct kvm_run *run = cpu->kvm_run; int ret, run_ret; DPRINTF("kvm_cpu_exec()\n"); if (kvm_arch_process_async_events(cpu)) { cpu->exit_request = 0; return EXCP_HLT; } qemu_mutex_unlock_iothread(); do { MemTxAttrs attrs; if (cpu->kvm_vcpu_dirty) { kvm_arch_put_registers(cpu, KVM_PUT_RUNT... |
0 | static int mkv_write_packet_internal(AVFormatContext *s, AVPacket *pkt){ MatroskaMuxContext *mkv = s->priv_data; AVIOContext *pb = s->pb; AVCodecContext *codec = s->streams[pkt->stream_index]->codec; int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY); int duration = pkt->duration; int ret; int64_t ts = mkv->tracks[pkt->st... |
0 | static int adpcm_decode_frame(AVCodecContext *avctx, void *data, int *data_size, uint8_t *buf, int buf_size){ ADPCMContext *c = avctx->priv_data; ADPCMChannelStatus *cs; int n, m, channel, i; int block_predictor[2]; short *samples; uint8_t *src; int st; /* stereo */ /* DK3 ADPCM accounting variables */ unsigned char la... |
0 | static int jp2_find_codestream(Jpeg2000DecoderContext *s){ int32_t atom_size; int found_codestream = 0, search_range = 10; // Skip JPEG 2000 signature atom. s->buf += 12; while (!found_codestream && search_range) { atom_size = AV_RB32(s->buf); if (AV_RB32(s->buf + 4) == JP2_CODESTREAM) { found_codestream = 1; s->buf +=... |
1 | parallel_ioport_write_sw(void *opaque, uint32_t addr, uint32_t val){ ParallelState *s = opaque; pdebug("write addr=0x%02x val=0x%02x\n", addr, val); addr &= 7; switch(addr) { case PARA_REG_DATA: s->dataw = val; parallel_update_irq(s); break; case PARA_REG_CTR: val |= 0xc0; if ((val & PARA_CTR_INIT) == 0 ) { s->status =... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.