label int64 0 1 | func stringlengths 21 96.3k |
|---|---|
0 | int qemu_set_fd_handler2(int fd, IOCanReadHandler *fd_read_poll, IOHandler *fd_read, IOHandler *fd_write, void *opaque){ IOHandlerRecord *ioh; assert(fd >= 0); if (!fd_read && !fd_write) { QLIST_FOREACH(ioh, &io_handlers, next) { if (ioh->fd == fd) { ioh->deleted = 1; break; } } } else { QLIST_FOREACH(ioh, &io_handlers... |
0 | static int tap_can_send(void *opaque){ TAPState *s = opaque; return qemu_can_send_packet(&s->nc);} |
0 | static void net_slirp_cleanup(VLANClientState *vc){ SlirpState *s = vc->opaque; slirp_cleanup(s->slirp); slirp_smb_cleanup(s); TAILQ_REMOVE(&slirp_stacks, s, entry); qemu_free(s);} |
0 | static int assign_device(AssignedDevice *dev){ uint32_t flags = KVM_DEV_ASSIGN_ENABLE_IOMMU; int r; /* Only pass non-zero PCI segment to capable module */ if (!kvm_check_extension(kvm_state, KVM_CAP_PCI_SEGMENT) && dev->host.domain) { error_report("Can't assign device inside non-zero PCI segment " "as this KVM module d... |
0 | void helper_fdtoq(CPUSPARCState *env, float64 src){ clear_float_exceptions(env); QT0 = float64_to_float128(src, &env->fp_status); check_ieee_exceptions(env);} |
0 | static uint64_t ecc_diag_mem_read(void *opaque, target_phys_addr_t addr, unsigned size){ ECCState *s = opaque; uint32_t ret = s->diag[(int)addr]; trace_ecc_diag_mem_readb(addr, ret); return ret;} |
0 | static void uart_write(void *opaque, target_phys_addr_t offset, uint64_t value, unsigned size){ UartState *s = (UartState *)opaque; DB_PRINT(" offset:%x data:%08x\n", offset, (unsigned)value); offset >>= 2; switch (offset) { case R_IER: /* ier (wts imr) */ s->r[R_IMR] |= value; break; case R_IDR: /* idr (wtc imr) */ s-... |
0 | static inline int handle_cpu_signal(unsigned long pc, unsigned long address, int is_write, sigset_t *old_set){ TranslationBlock *tb; int ret; uint32_t found_pc; #if defined(DEBUG_SIGNAL) printf("qemu: SIGSEGV pc=0x%08lx address=%08lx wr=%d oldset=0x%08lx\n", pc, address, is_write, *(unsigned long *)old_set);#endif /* X... |
0 | START_TEST(qobject_to_qstring_test){ QString *qstring; qstring = qstring_from_str("foo"); fail_unless(qobject_to_qstring(QOBJECT(qstring)) == qstring); QDECREF(qstring);} |
1 | static MachineClass *machine_parse(const char *name){ MachineClass *mc = NULL; GSList *el, *machines = object_class_get_list(TYPE_MACHINE, false); if (name) { mc = find_machine(name); } if (mc) { return mc; } if (name && !is_help_option(name)) { error_report("Unsupported machine type"); error_printf("Use -machine help ... |
1 | static int decode_wmv9(AVCodecContext *avctx, const uint8_t *buf, int buf_size, int x, int y, int w, int h, int wmv9_mask){ MSS2Context *ctx = avctx->priv_data; MSS12Context *c = &ctx->c; VC1Context *v = avctx->priv_data; MpegEncContext *s = &v->s; AVFrame *f; int ret; ff_mpeg_flush(avctx); init_get_bits(&s->gb, buf, b... |
1 | yuv2rgb_1_c_template(SwsContext *c, const int16_t *buf0, const int16_t *ubuf[2], const int16_t *vbuf[2], const int16_t *abuf0, uint8_t *dest, int dstW, int uvalpha, int y, enum PixelFormat target, int hasAlpha){ const int16_t *ubuf0 = ubuf[0], *vbuf0 = vbuf[0]; int i; if (uvalpha < 2048) { for (i = 0; i < (dstW >> 1); ... |
1 | static int pci_qdev_init(DeviceState *qdev, DeviceInfo *base){ PCIDevice *pci_dev = (PCIDevice *)qdev; PCIDeviceInfo *info = container_of(base, PCIDeviceInfo, qdev); PCIBus *bus; int devfn, rc; /* initialize cap_present for pci_is_express() and pci_config_size() */ if (info->is_express) { pci_dev->cap_present |= QEMU_P... |
0 | static AVStream * parse_media_type(AVFormatContext *s, AVStream *st, int sid, ff_asf_guid mediatype, ff_asf_guid subtype, ff_asf_guid formattype, int size){ WtvContext *wtv = s->priv_data; AVIOContext *pb = wtv->pb; if (!ff_guidcmp(subtype, ff_mediasubtype_cpfilters_processed) && !ff_guidcmp(formattype, ff_format_cpfil... |
0 | static void intra_predict_dc_4blk_8x8_msa(uint8_t *src, int32_t stride){ uint8_t lp_cnt; uint32_t src0, src1, src3, src2 = 0; uint32_t out0, out1, out2, out3; v16u8 src_top; v8u16 add; v4u32 sum; src_top = LD_UB(src - stride); add = __msa_hadd_u_h((v16u8) src_top, (v16u8) src_top); sum = __msa_hadd_u_w(add, add); src0 ... |
1 | static int init_poc(H264Context *h){ MpegEncContext * const s = &h->s; const int max_frame_num= 1<<h->sps.log2_max_frame_num; int field_poc[2]; h->frame_num_offset= h->prev_frame_num_offset; if(h->frame_num < h->prev_frame_num) h->frame_num_offset += max_frame_num; if(h->sps.poc_type==0){ const int max_poc_lsb= 1<<h->s... |
1 | static void sdhci_set_inserted(DeviceState *dev, bool level){ SDHCIState *s = (SDHCIState *)dev; DPRINT_L1("Card state changed: %s!\n", level ? "insert" : "eject"); if ((s->norintsts & SDHC_NIS_REMOVE) && level) { /* Give target some time to notice card ejection */ timer_mod(s->insert_timer, qemu_clock_get_ns(QEMU_CLOC... |
1 | static void get_sensor_type(IPMIBmcSim *ibs, uint8_t *cmd, unsigned int cmd_len, uint8_t *rsp, unsigned int *rsp_len, unsigned int max_rsp_len){ IPMISensor *sens; IPMI_CHECK_CMD_LEN(3); if ((cmd[2] > MAX_SENSORS) || !IPMI_SENSOR_GET_PRESENT(ibs->sensors + cmd[2])) { rsp[2] = IPMI_CC_REQ_ENTRY_NOT_PRESENT; return; } sen... |
1 | static int avui_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic, int *got_packet){ uint8_t *dst, *src = pic->data[0]; int i, j, skip, ret, size, interlaced; interlaced = avctx->field_order > AV_FIELD_PROGRESSIVE; if (avctx->height == 486) { skip = 10; } else { skip = 16; } size = 2 * avctx->width ... |
1 | static void sparc_cpu_initfn(Object *obj){ CPUState *cs = CPU(obj); SPARCCPU *cpu = SPARC_CPU(obj); CPUSPARCState *env = &cpu->env; cs->env_ptr = env; cpu_exec_init(cs, &error_abort); if (tcg_enabled()) { gen_intermediate_code_init(env); }} |
1 | static void register_to_network(RDMARegister *reg){ reg->key.current_addr = htonll(reg->key.current_addr); reg->current_index = htonl(reg->current_index); reg->chunks = htonll(reg->chunks);} |
1 | int av_resample(AVResampleContext *c, short *dst, short *src, int *consumed, int src_size, int dst_size, int update_ctx){ int dst_index, i; int index= c->index; int frac= c->frac; int dst_incr_frac= c->dst_incr % c->src_incr; int dst_incr= c->dst_incr / c->src_incr; int compensation_distance= c->compensation_distance; ... |
1 | static void FUNCC(pred4x4_128_dc)(uint8_t *_src, const uint8_t *topright, int _stride){ pixel *src = (pixel*)_src; int stride = _stride/sizeof(pixel); ((pixel4*)(src+0*stride))[0]= ((pixel4*)(src+1*stride))[0]= ((pixel4*)(src+2*stride))[0]= ((pixel4*)(src+3*stride))[0]= PIXEL_SPLAT_X4(1<<(BIT_DEPTH-1));} |
1 | void nand_setio(DeviceState *dev, uint32_t value){ int i; NANDFlashState *s = (NANDFlashState *) dev; if (!s->ce && s->cle) { if (nand_flash_ids[s->chip_id].options & NAND_SAMSUNG_LP) { if (s->cmd == NAND_CMD_READ0 && value == NAND_CMD_LPREAD2) return; if (value == NAND_CMD_RANDOMREAD1) { s->addr &= ~((1 << s->addr_shi... |
1 | static int bdrv_qed_check(BlockDriverState *bs, BdrvCheckResult *result){ return -ENOTSUP;} |
1 | int ff_dirac_golomb_read_16bit(DiracGolombLUT *lut_ctx, const uint8_t *buf, int bytes, uint8_t *_dst, int coeffs){ int i, b, c_idx = 0; int16_t *dst = (int16_t *)_dst; DiracGolombLUT *future[4], *l = &lut_ctx[2*LUT_SIZE + buf[0]]; INIT_RESIDUE(res); for (b = 1; b <= bytes; b++) { future[0] = &lut_ctx[buf[b]]; future[1]... |
1 | static int bdrv_wr_badreq_sectors(BlockDriverState *bs, int64_t sector_num, int nb_sectors){ if (sector_num < 0 || nb_sectors < 0) return 1; if (sector_num > bs->total_sectors - nb_sectors) { if (bs->autogrow) bs->total_sectors = sector_num + nb_sectors; else return 1; } return 0;} |
1 | static int ram_save_complete(QEMUFile *f, void *opaque){ rcu_read_lock(); migration_bitmap_sync(); ram_control_before_iterate(f, RAM_CONTROL_FINISH); /* try transferring iterative blocks of memory */ /* flush all remaining blocks regardless of rate limiting */ while (true) { int pages; pages = ram_find_and_save_block(f... |
1 | void ff_add_pixels_clamped_c(const DCTELEM *block, uint8_t *restrict pixels, int line_size){ int i; uint8_t *cm = ff_cropTbl + MAX_NEG_CROP; /* read the pixels */ for(i=0;i<8;i++) { pixels[0] = cm[pixels[0] + block[0]]; pixels[1] = cm[pixels[1] + block[1]]; pixels[2] = cm[pixels[2] + block[2]]; pixels[3] = cm[pixels[3]... |
1 | static inline int ohci_put_ed(OHCIState *ohci, uint32_t addr, struct ohci_ed *ed){ return put_dwords(ohci, addr, (uint32_t *)ed, sizeof(*ed) >> 2);} |
1 | static int read_cpuinfo(const char *field, char *value, int len){ FILE *f; int ret = -1; int field_len = strlen(field); char line[512]; f = fopen("/proc/cpuinfo", "r"); if (!f) { return -1; } do { if(!fgets(line, sizeof(line), f)) { break; } if (!strncmp(line, field, field_len)) { strncpy(value, line, len); ret = 0; br... |
1 | static void puv3_board_init(CPUUniCore32State *env, ram_addr_t ram_size){ MemoryRegion *ram_memory = g_new(MemoryRegion, 1); /* SDRAM at address zero. */ memory_region_init_ram(ram_memory, NULL, "puv3.ram", ram_size, &error_abort); vmstate_register_ram_global(ram_memory); memory_region_add_subregion(get_system_memory()... |
0 | void show_help(void){ const OptionDef *po; int i, expert; printf("ffmpeg version " FFMPEG_VERSION ", Copyright (c) 2000,2001 Gerard Lantau\n" "usage: ffmpeg [[options] -i input_file]... {[options] outfile}...\n" "Hyper fast MPEG1/MPEG4/H263/RV and AC3/MPEG audio encoder\n" "\n" "Main options are:\n"); for(i=0;i<2;i++) ... |
0 | static int ftp_shutdown(URLContext *h, int flags){ FTPContext *s = h->priv_data; av_dlog(h, "ftp protocol shutdown\n"); if (s->conn_data) return ffurl_shutdown(s->conn_data, flags); return AVERROR(EIO);} |
1 | static inline void RENAME(yuv2yuvX)(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, int dstW, int16_t * lumMmxFilter, int16_t * chrMmxFilter){#ifdef HAVE_MMXif(uDest != NULL){asm volatile(YSCALEYUV2YV12X(0):... |
1 | void enable_kvm_pv_eoi(void){ kvm_default_features |= kvm_pv_eoi_features;} |
1 | iscsi_aio_writev(BlockDriverState *bs, int64_t sector_num, QEMUIOVector *qiov, int nb_sectors, BlockDriverCompletionFunc *cb, void *opaque){ IscsiLun *iscsilun = bs->opaque; IscsiAIOCB *acb; acb = qemu_aio_get(&iscsi_aiocb_info, bs, cb, opaque); trace_iscsi_aio_writev(iscsilun->iscsi, sector_num, nb_sectors, opaque, ac... |
1 | static void qemu_s390_flic_class_init(ObjectClass *oc, void *data){ DeviceClass *dc = DEVICE_CLASS(oc); S390FLICStateClass *fsc = S390_FLIC_COMMON_CLASS(oc); dc->reset = qemu_s390_flic_reset; fsc->register_io_adapter = qemu_s390_register_io_adapter; fsc->io_adapter_map = qemu_s390_io_adapter_map; fsc->add_adapter_route... |
1 | static always_inline void gen_op_subfeo_64 (void){ gen_op_move_T2_T0(); gen_op_subfe_64(); gen_op_check_subfo_64();} |
1 | static ssize_t rtl8139_do_receive(NetClientState *nc, const uint8_t *buf, size_t size_, int do_interrupt){ RTL8139State *s = qemu_get_nic_opaque(nc); PCIDevice *d = PCI_DEVICE(s); /* size is the length of the buffer passed to the driver */ int size = size_; const uint8_t *dot1q_buf = NULL; uint32_t packet_header = 0; u... |
1 | void start_auth_sasl(VncState *vs){ const char *mechlist = NULL; sasl_security_properties_t secprops; int err; char *localAddr, *remoteAddr; int mechlistlen; VNC_DEBUG("Initialize SASL auth %d\n", vs->csock); /* Get local & remote client addresses in form IPADDR;PORT */ if (!(localAddr = vnc_socket_local_addr("%s;%s", ... |
1 | fork_exec(struct socket *so, const char *ex, int do_pty){int s;struct sockaddr_in addr;socklen_t addrlen = sizeof(addr);int opt;const char *argv[256];/* don't want to clobber the original */char *bptr;const char *curarg;int c, i, ret;pid_t pid;DEBUG_CALL("fork_exec");DEBUG_ARG("so = %p", so);DEBUG_ARG("ex = %p", ex);DE... |
1 | static int huff_build12(VLC *vlc, uint8_t *len){ HuffEntry he[4096]; uint32_t codes[4096]; uint8_t bits[4096]; uint16_t syms[4096]; uint32_t code; int i; for (i = 0; i < 4096; i++) { he[i].sym = 4095 - i; he[i].len = len[i]; if (len[i] == 0) return AVERROR_INVALIDDATA; } AV_QSORT(he, 4096, HuffEntry, huff_cmp_len12); c... |
1 | static int vnc_set_x509_credential(VncDisplay *vd, const char *certdir, const char *filename, char **cred, int ignoreMissing){ struct stat sb; g_free(*cred); *cred = g_malloc(strlen(certdir) + strlen(filename) + 2); strcpy(*cred, certdir); strcat(*cred, "/"); strcat(*cred, filename); VNC_DEBUG("Check %s\n", *cred); if ... |
1 | int kvmppc_remove_spapr_tce(void *table, int fd, uint32_t window_size){ long len; if (fd < 0) { return -1; } len = (window_size / SPAPR_VIO_TCE_PAGE_SIZE)*sizeof(VIOsPAPR_RTCE); if ((munmap(table, len) < 0) || (close(fd) < 0)) { fprintf(stderr, "KVM: Unexpected error removing KVM SPAPR TCE " "table: %s", strerror(errno... |
0 | int avcodec_default_get_buffer(AVCodecContext *s, AVFrame *pic){ int i; int w= s->width; int h= s->height; InternalBuffer *buf; int *picture_number; assert(pic->data[0]==NULL); assert(INTERNAL_BUFFER_SIZE > s->internal_buffer_count); if(avcodec_check_dimensions(s,w,h)) return -1; if(s->internal_buffer==NULL){ s->intern... |
1 | iscsi_aio_read16_cb(struct iscsi_context *iscsi, int status, void *command_data, void *opaque){ IscsiAIOCB *acb = opaque; trace_iscsi_aio_read16_cb(iscsi, status, acb, acb->canceled); if (acb->canceled) { qemu_aio_release(acb); return; } acb->status = 0; if (status != 0) { error_report("Failed to read16 data from iSCSI... |
1 | static int uhci_complete_td(UHCIState *s, UHCI_TD *td, UHCIAsync *async, uint32_t *int_mask){ int len = 0, max_len, err, ret; uint8_t pid; max_len = ((td->token >> 21) + 1) & 0x7ff; pid = td->token & 0xff; ret = async->packet.len; if (td->ctrl & TD_CTRL_IOS) td->ctrl &= ~TD_CTRL_ACTIVE; if (ret < 0) goto out; len = asy... |
1 | matroska_add_stream (MatroskaDemuxContext *matroska){ int res = 0; uint32_t id; MatroskaTrack *track; av_log(matroska->ctx, AV_LOG_DEBUG, "parsing track, adding stream..,\n"); /* Allocate a generic track. As soon as we know its type we'll realloc. */ track = av_mallocz(MAX_TRACK_SIZE); matroska->num_tracks++; strcpy(tr... |
1 | static int local_chmod(FsContext *fs_ctx, const char *path, FsCred *credp){ if (fs_ctx->fs_sm == SM_MAPPED) { return local_set_xattr(rpath(fs_ctx, path), credp); } else if (fs_ctx->fs_sm == SM_PASSTHROUGH) { return chmod(rpath(fs_ctx, path), credp->fc_mode); } return -1;} |
1 | static void usb_msd_class_initfn_storage(ObjectClass *klass, void *data){ DeviceClass *dc = DEVICE_CLASS(klass); USBDeviceClass *uc = USB_DEVICE_CLASS(klass); uc->realize = usb_msd_realize_storage; dc->props = msd_properties;} |
1 | void coroutine_fn qemu_co_mutex_unlock(CoMutex *mutex){ Coroutine *self = qemu_coroutine_self(); trace_qemu_co_mutex_unlock_entry(mutex, self); assert(mutex->locked); assert(mutex->holder == self); assert(qemu_in_coroutine()); mutex->holder = NULL; self->locks_held--; if (atomic_fetch_dec(&mutex->locked) == 1) { /* No ... |
1 | inline static void RENAME(hcscale)(uint16_t *dst, int dstWidth,uint8_t *src1, uint8_t *src2, int srcW, int xInc){#ifdef HAVE_MMX// use the new MMX scaler if th mmx2 cant be used (its faster than the x86asm one) if(sws_flags != SWS_FAST_BILINEAR || (!canMMX2BeUsed))#else if(sws_flags != SWS_FAST_BILINEAR)#endif { RENAME... |
1 | static uint32_t nvram_readb (void *opaque, target_phys_addr_t addr) { ds1225y_t *NVRAM = opaque; int64_t pos; pos = addr - NVRAM->mem_base; if (addr >= NVRAM->capacity) addr -= NVRAM->capacity; if (!ds1225y_set_to_mode(NVRAM, readmode, "rb")) return 0; qemu_fseek(NVRAM->file, pos, SEEK_SET); return (uint32_t)qemu_get_b... |
0 | static int decode_plane10(UtvideoContext *c, int plane_no, uint16_t *dst, int step, ptrdiff_t stride, int width, int height, const uint8_t *src, const uint8_t *huff, int use_pred){ int i, j, slice, pix, ret; int sstart, send; VLC vlc; GetBitContext gb; int prev, fsym; if ((ret = build_huff10(huff, &vlc, &fsym)) < 0) { ... |
0 | static int encode_slice(AVCodecContext *avctx, const AVFrame *pic, PutBitContext *pb, int sizes[4], int x, int y, int quant, int mbs_per_slice){ ProresContext *ctx = avctx->priv_data; int i, xp, yp; int total_size = 0; const uint16_t *src; int slice_width_factor = av_log2(mbs_per_slice); int num_cblocks, pwidth; int pl... |
0 | static int ogg_write_header(AVFormatContext *s){ OGGStreamContext *oggstream; int i, j; for (i = 0; i < s->nb_streams; i++) { AVStream *st = s->streams[i]; unsigned serial_num = i; if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { if (st->codec->codec_id == AV_CODEC_ID_OPUS) /* Opus requires a fixed 48kHz clock */ avp... |
0 | static void test_dma_fragmented(void){ AHCIQState *ahci; AHCICommand *cmd; uint8_t px; size_t bufsize = 4096; unsigned char *tx = g_malloc(bufsize); unsigned char *rx = g_malloc0(bufsize); uint64_t ptr; ahci = ahci_boot_and_enable(); px = ahci_port_select(ahci); ahci_port_clear(ahci, px); /* create pattern */ generate_... |
0 | static long do_rt_sigreturn_v1(CPUARMState *env){ abi_ulong frame_addr; struct rt_sigframe_v1 *frame = NULL; sigset_t host_set;/* * Since we stacked the signal on a 64-bit boundary, * then 'sp' should be word aligned here. If it's * not, then the user is trying to mess with us. */ frame_addr = env->regs[13]; if (frame_... |
0 | int qcow2_cache_flush(BlockDriverState *bs, Qcow2Cache *c){ BDRVQcow2State *s = bs->opaque; int result = 0; int ret; int i; trace_qcow2_cache_flush(qemu_coroutine_self(), c == s->l2_table_cache); for (i = 0; i < c->size; i++) { ret = qcow2_cache_entry_flush(bs, c, i); if (ret < 0 && result != -ENOSPC) { result = ret; }... |
0 | MemoryRegion *pci_address_space_io(PCIDevice *dev){ return dev->bus->address_space_io;} |
0 | static void lm32_uclinux_init(QEMUMachineInitArgs *args){ const char *cpu_model = args->cpu_model; const char *kernel_filename = args->kernel_filename; const char *kernel_cmdline = args->kernel_cmdline; const char *initrd_filename = args->initrd_filename; LM32CPU *cpu; CPULM32State *env; DriveInfo *dinfo; MemoryRegion ... |
0 | static void timestamp_put(QDict *qdict){ int err; QObject *obj; qemu_timeval tv; err = qemu_gettimeofday(&tv); if (err < 0) return; obj = qobject_from_jsonf("{ 'seconds': %" PRId64 ", " "'microseconds': %" PRId64 " }", (int64_t) tv.tv_sec, (int64_t) tv.tv_usec); assert(obj != NULL); qdict_put_obj(qdict, "timestamp", ob... |
0 | int av_get_cpu_flags(void){ if (checked) return flags; if (ARCH_AARCH64) flags = ff_get_cpu_flags_aarch64(); if (ARCH_ARM) flags = ff_get_cpu_flags_arm(); if (ARCH_PPC) flags = ff_get_cpu_flags_ppc(); if (ARCH_X86) flags = ff_get_cpu_flags_x86(); checked = 1; return flags;} |
0 | static int target_restore_sigframe(CPUARMState *env, struct target_rt_sigframe *sf){ sigset_t set; int i; struct target_aux_context *aux = (struct target_aux_context *)sf->uc.tuc_mcontext.__reserved; uint32_t magic, size, fpsr, fpcr; uint64_t pstate; target_to_host_sigset(&set, &sf->uc.tuc_sigmask); sigprocmask(SIG_SET... |
0 | static void reclaim_list_el(struct rcu_head *prcu){ struct list_element *el = container_of(prcu, struct list_element, rcu); g_free(el); atomic_add(&n_reclaims, 1);} |
0 | uint64_t helper_ld_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_read; if ((virtaddr & TARGET_PAGE_MASK) == (tlb_addr & (TAR... |
0 | static bool less_than_7(void *opaque, int version_id){ return version_id < 7;} |
0 | static void ppc_hash64_set_isi(CPUState *cs, CPUPPCState *env, uint64_t error_code){ bool vpm; if (msr_ir) { vpm = !!(env->spr[SPR_LPCR] & LPCR_VPM1); } else { vpm = !!(env->spr[SPR_LPCR] & LPCR_VPM0); } if (vpm && !msr_hv) { cs->exception_index = POWERPC_EXCP_HISI; } else { cs->exception_index = POWERPC_EXCP_ISI; } en... |
0 | static int vnc_tls_initialize(void){ static int tlsinitialized = 0; if (tlsinitialized)return 1; if (gnutls_global_init () < 0)return 0; /* XXX ought to re-generate diffie-hellmen params periodically */ if (gnutls_dh_params_init (&dh_params) < 0)return 0; if (gnutls_dh_params_generate2 (dh_params, DH_BITS) < 0)return 0... |
0 | void 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){ slirp_init_once(); link_up = 1; slirp_restrict = restricted; if_init(); ip_init(); /* Initi... |
0 | static void bswap_phdr(struct elf_phdr *phdr){ bswap32s(&phdr->p_type); /* Segment type */ bswaptls(&phdr->p_offset); /* Segment file offset */ bswaptls(&phdr->p_vaddr); /* Segment virtual address */ bswaptls(&phdr->p_paddr); /* Segment physical address */ bswaptls(&phdr->p_filesz); /* Segment size in file */ bswaptls(... |
0 | static uint64_t ahci_idp_read(void *opaque, target_phys_addr_t addr, unsigned size){ AHCIState *s = opaque; if (addr == s->idp_offset) { /* index register */ return s->idp_index; } else if (addr == s->idp_offset + 4) { /* data register - do memory read at location selected by index */ return ahci_mem_read(opaque, s->id... |
0 | int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len){ return s->chr_write(s, buf, len);} |
0 | static inline void gen_efdabs(DisasContext *ctx){ if (unlikely(!ctx->spe_enabled)) { gen_exception(ctx, POWERPC_EXCP_APU); return; }#if defined(TARGET_PPC64) tcg_gen_andi_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], ~0x8000000000000000LL);#else tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]... |
0 | static inline void gen_op_mfspr (DisasContext *ctx){ void (*read_cb)(void *opaque, int sprn); uint32_t sprn = SPR(ctx->opcode);#if !defined(CONFIG_USER_ONLY) if (ctx->supervisor) read_cb = ctx->spr_cb[sprn].oea_read; else#endif read_cb = ctx->spr_cb[sprn].uea_read; if (likely(read_cb != NULL)) { if (likely(read_cb != S... |
0 | static void bdrv_do_release_matching_dirty_bitmap(BlockDriverState *bs, BdrvDirtyBitmap *bitmap, bool only_named){ BdrvDirtyBitmap *bm, *next; QLIST_FOREACH_SAFE(bm, &bs->dirty_bitmaps, list, next) { if ((!bitmap || bm == bitmap) && (!only_named || bm->name)) { assert(!bm->active_iterators); assert(!bdrv_dirty_bitmap_f... |
0 | static uint64_t arm_thistimer_read(void *opaque, target_phys_addr_t addr, unsigned size){ arm_mptimer_state *s = (arm_mptimer_state *)opaque; int id = get_current_cpu(s); return timerblock_read(&s->timerblock[id * 2], addr, size);} |
1 | void ff_snow_pred_block(SnowContext *s, uint8_t *dst, uint8_t *tmp, int stride, int sx, int sy, int b_w, int b_h, BlockNode *block, int plane_index, int w, int h){ if(block->type & BLOCK_INTRA){ int x, y; const unsigned color = block->color[plane_index]; const unsigned color4 = color*0x01010101; if(b_w==32){ for(y=0; y... |
1 | void backup_start(BlockDriverState *bs, BlockDriverState *target, int64_t speed, MirrorSyncMode sync_mode, BlockdevOnError on_source_error, BlockdevOnError on_target_error, BlockCompletionFunc *cb, void *opaque, Error **errp){ int64_t len; assert(bs); assert(target); assert(cb); if (bs == target) { error_setg(errp, "So... |
1 | static int decode_pic_timing(HEVCSEIContext *s, GetBitContext *gb, const HEVCParamSets *ps, void *logctx){ HEVCSEIPictureTiming *h = &s->picture_timing; HEVCSPS *sps; if (!ps->sps_list[s->active_seq_parameter_set_id]) return(AVERROR(ENOMEM)); sps = (HEVCSPS*)ps->sps_list[s->active_seq_parameter_set_id]->data; if (sps->... |
1 | static int film_read_header(AVFormatContext *s){ FilmDemuxContext *film = s->priv_data; AVIOContext *pb = s->pb; AVStream *st; unsigned char scratch[256]; int i; unsigned int data_offset; unsigned int audio_frame_counter; film->sample_table = NULL; film->stereo_buffer = NULL; film->stereo_buffer_size = 0; /* load the m... |
1 | ssize_t nbd_wr_sync(int fd, void *buffer, size_t size, bool do_read){ size_t offset = 0; int err; if (qemu_in_coroutine()) { if (do_read) { return qemu_co_recv(fd, buffer, size); } else { return qemu_co_send(fd, buffer, size); } } while (offset < size) { ssize_t len; if (do_read) { len = qemu_recv(fd, buffer + offset, ... |
0 | static int encode_q_branch(SnowContext *s, int level, int x, int y){ uint8_t p_buffer[1024]; uint8_t i_buffer[1024]; uint8_t p_state[sizeof(s->block_state)]; uint8_t i_state[sizeof(s->block_state)]; RangeCoder pc, ic; uint8_t *pbbak= s->c.bytestream; uint8_t *pbbak_start= s->c.bytestream_start; int score, score2, iscor... |
0 | static inline int decode_cabac_mb_transform_size( H264Context *h ) { return get_cabac( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );} |
1 | static av_always_inline void filter_mb_dir(const H264Context *h, H264SliceContext *sl, 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 a, int b, int chroma, int dir){ int edge; ... |
0 | int ff_h263_decode_frame(AVCodecContext *avctx, void *data, int *data_size, const uint8_t *buf, int buf_size){ MpegEncContext *s = avctx->priv_data; int ret; AVFrame *pict = data;#ifdef PRINT_FRAME_TIMEuint64_t time= rdtsc();#endif#ifdef DEBUG av_log(avctx, AV_LOG_DEBUG, "*****frame %d size=%d\n", avctx->frame_number, ... |
1 | static int dscm1xxxx_attach(PCMCIACardState *card){ MicroDriveState *md = MICRODRIVE(card); PCMCIACardClass *pcc = PCMCIA_CARD_GET_CLASS(card); md->attr_base = pcc->cis[0x74] | (pcc->cis[0x76] << 8); md->io_base = 0x0; device_reset(DEVICE(md)); md_interrupt_update(md); card->slot->card_string = "DSCM-1xxxx Hitachi Micr... |
1 | static av_always_inline int lcg_random(int previous_val){ return previous_val * 1664525 + 1013904223;} |
1 | static void s390_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){ CPUState *env = NULL; ram_addr_t ram_addr; ram_addr_t kernel_size = 0; ram_addr_t initrd_offset; ram_addr_t initrd_size = 0; int i; /* XXX we ... |
1 | static inline uint32_t regime_el(CPUARMState *env, ARMMMUIdx mmu_idx){ switch (mmu_idx) { case ARMMMUIdx_S2NS: case ARMMMUIdx_S1E2: return 2; case ARMMMUIdx_S1E3: return 3; case ARMMMUIdx_S1SE0: return arm_el_is_aa64(env, 3) ? 1 : 3; case ARMMMUIdx_S1SE1: case ARMMMUIdx_S1NSE0: case ARMMMUIdx_S1NSE1: return 1; default:... |
1 | static int open_slave(AVFormatContext *avf, char *slave, TeeSlave *tee_slave){ int i, ret; AVDictionary *options = NULL; AVDictionaryEntry *entry; char *filename; char *format = NULL, *select = NULL; AVFormatContext *avf2 = NULL; AVStream *st, *st2; int stream_count; int fullret; char *subselect = NULL, *next_subselect... |
1 | static uint16_t nvme_del_cq(NvmeCtrl *n, NvmeCmd *cmd){ NvmeDeleteQ *c = (NvmeDeleteQ *)cmd; NvmeCQueue *cq; uint16_t qid = le16_to_cpu(c->qid); if (!qid || nvme_check_cqid(n, qid)) { return NVME_INVALID_CQID | NVME_DNR; } cq = n->cq[qid]; if (!QTAILQ_EMPTY(&cq->sq_list)) { return NVME_INVALID_QUEUE_DEL; } nvme_free_cq... |
1 | static void test_acpi_q35_tcg_cphp(void){ test_data data; memset(&data, 0, sizeof(data)); data.machine = MACHINE_Q35; data.variant = ".cphp"; test_acpi_one(" -smp 2,cores=3,sockets=2,maxcpus=6", &data); free_test_data(&data);} |
1 | TPMVersion tpm_backend_get_tpm_version(TPMBackend *s){ TPMBackendClass *k = TPM_BACKEND_GET_CLASS(s); assert(k->get_tpm_version); return k->get_tpm_version(s);} |
1 | static av_cold int cuvid_decode_init(AVCodecContext *avctx){ CuvidContext *ctx = avctx->priv_data; AVCUDADeviceContext *device_hwctx; AVHWDeviceContext *device_ctx; AVHWFramesContext *hwframe_ctx; CUVIDPARSERPARAMS cuparseinfo; CUVIDEOFORMATEX cuparse_ext; CUVIDSOURCEDATAPACKET seq_pkt; CUdevice device; CUcontext cuda_... |
0 | static int tcp_wait_fd(int fd, int write){ int ev = write ? POLLOUT : POLLIN; struct pollfd p = { .fd = fd, .events = ev, .revents = 0 }; int ret; ret = poll(&p, 1, 100); return ret < 0 ? ff_neterrno() : p.revents & ev ? 0 : AVERROR(EAGAIN);} |
0 | static int file_check(URLContext *h, int mask){#if HAVE_ACCESS && defined(R_OK) int ret = 0; if (access(h->filename, F_OK) < 0) return AVERROR(errno); if (mask&AVIO_FLAG_READ) if (access(h->filename, R_OK) >= 0) ret |= AVIO_FLAG_READ; if (mask&AVIO_FLAG_WRITE) if (access(h->filename, W_OK) >= 0) ret |= AVIO_FLAG_WRITE;... |
0 | int qemu_bh_poll(void){ return aio_bh_poll(qemu_aio_context);} |
0 | static struct omap_sti_s *omap_sti_init(struct omap_target_agent_s *ta, MemoryRegion *sysmem, target_phys_addr_t channel_base, qemu_irq irq, omap_clk clk, CharDriverState *chr){ struct omap_sti_s *s = (struct omap_sti_s *) g_malloc0(sizeof(struct omap_sti_s)); s->irq = irq; omap_sti_reset(s); s->chr = chr ?: qemu_chr_n... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.