label int64 0 1 | func1 stringlengths 23 97k | id int64 0 27.3k |
|---|---|---|
0 | static av_always_inline void h264_filter_mb_fast_internal(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 pixel_shift) { int chroma = !(CONFIG_GRAY && (h->flags&CODEC_FLAG_GRAY)); int chroma444 = CHROMA444(h)... | 26,125 |
0 | static void pxb_pcie_dev_realize(PCIDevice *dev, Error **errp) { if (!pci_bus_is_express(dev->bus)) { error_setg(errp, "pxb-pcie devices cannot reside on a PCI bus"); return; } pxb_dev_realize_common(dev, true, errp); } | 26,126 |
0 | static int float64_is_unordered(int sig, float64 a, float64 b STATUS_PARAM) { if (float64_is_signaling_nan(a) || float64_is_signaling_nan(b) || (sig && (float64_is_nan(a) || float64_is_nan(b)))) { float_raise(float_flag_invalid, status); return 1; } else if (float64_is_nan(a) || float64_is_nan(b)) { return 1; } else { ... | 26,127 |
0 | static void qmp_input_type_str(Visitor *v, const char *name, char **obj, Error **errp) { QmpInputVisitor *qiv = to_qiv(v); QObject *qobj = qmp_input_get_object(qiv, name, true, errp); QString *qstr; *obj = NULL; if (!qobj) { return; } qstr = qobject_to_qstring(qobj); if (!qstr) { error_setg(errp, QERR_INVALID_PARAMETER... | 26,128 |
0 | static int curl_open(BlockDriverState *bs, const char *filename, int flags) { BDRVCURLState *s = bs->opaque; CURLState *state = NULL; double d; #define RA_OPTSTR ":readahead=" char *file; char *ra; const char *ra_val; int parse_state = 0; static int inited = 0; file = strdup(filename); s->readahead_size = READ_AHEAD_SI... | 26,129 |
0 | static void gen_ldarx(DisasContext *ctx) { TCGv t0; gen_set_access_type(ctx, ACCESS_RES); t0 = tcg_temp_local_new(); gen_addr_reg_index(ctx, t0); gen_check_align(ctx, t0, 0x07); gen_qemu_ld64(ctx, cpu_gpr[rD(ctx->opcode)], t0); tcg_gen_mov_tl(cpu_reserve, t0); tcg_temp_free(t0); } | 26,130 |
0 | static void virtio_scsi_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq) { VirtIOSCSI *s = (VirtIOSCSI *)vdev; VirtIOSCSIReq *req; while ((req = virtio_scsi_pop_req(s, vq))) { int type; if (iov_to_buf(req->elem.out_sg, req->elem.out_num, 0, &type, sizeof(type)) < sizeof(type)) { virtio_scsi_bad_req(); continue; } tswap32... | 26,131 |
1 | void arm_cpu_realize(ARMCPU *cpu) { /* This function is called by cpu_arm_init() because it * needs to do common actions based on feature bits, etc * that have been set by the subclass init functions. * When we have QOM realize support it should become * a true realize function instead. */ CPUARMState *env = &cpu->env;... | 26,132 |
1 | static int mpc7_decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr, AVPacket *avpkt) { const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; MPCContext *c = avctx->priv_data; GetBitContext gb; uint8_t *bits; int i, ch; int mb = -1; Band *bands = c->bands; int off, ret; int bits_used, bits_avail... | 26,133 |
1 | static void replication_start(ReplicationState *rs, ReplicationMode mode, Error **errp) { BlockDriverState *bs = rs->opaque; BDRVReplicationState *s; BlockDriverState *top_bs; int64_t active_length, hidden_length, disk_length; AioContext *aio_context; Error *local_err = NULL; BlockJob *job; aio_context = bdrv_get_aio_c... | 26,134 |
1 | uint8_t* ff_AMediaCodec_getOutputBuffer(FFAMediaCodec* codec, size_t idx, size_t *out_size) { uint8_t *ret = NULL; JNIEnv *env = NULL; jobject buffer = NULL; JNI_GET_ENV_OR_RETURN(env, codec, NULL); if (codec->has_get_i_o_buffer) { buffer = (*env)->CallObjectMethod(env, codec->object, codec->jfields.get_output_buffer_i... | 26,135 |
1 | int cpu_get_dump_info(ArchDumpInfo *info, const struct GuestPhysBlockList *guest_phys_blocks) { PowerPCCPU *cpu = POWERPC_CPU(first_cpu); PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu); info->d_machine = EM_PPC64; info->d_class = ELFCLASS64; if ((*pcc->interrupts_big_endian)(cpu)) { info->d_endian = ELFDATA2MSB; } e... | 26,137 |
1 | static int try_decode_video_frame(AVCodecContext *codec_ctx, AVPacket *pkt, int decode) { int ret = 0; int got_frame = 0; AVFrame *frame = NULL; int skip_frame = codec_ctx->skip_frame; if (!avcodec_is_open(codec_ctx)) { const AVCodec *codec = avcodec_find_decoder(codec_ctx->codec_id); ret = avcodec_open2(codec_ctx, cod... | 26,138 |
0 | static int tiff_decode_tag(TiffContext *s, AVFrame *frame) { unsigned tag, type, count, off, value = 0, value2 = 0; int i, start; int pos; int ret; double *dp; ret = ff_tread_tag(&s->gb, s->le, &tag, &type, &count, &start); if (ret < 0) { goto end; } off = bytestream2_tell(&s->gb); if (count == 1) { switch (type) { cas... | 26,139 |
1 | static int reap_filters(void) { AVFilterBufferRef *picref; AVFrame *filtered_frame = NULL; int i; int64_t frame_pts; /* Reap all buffers present in the buffer sinks */ for (i = 0; i < nb_output_streams; i++) { OutputStream *ost = output_streams[i]; OutputFile *of = output_files[ost->file_index]; int ret = 0; if (!ost->... | 26,140 |
1 | static av_always_inline void hl_decode_mb_predict_luma(H264Context *h, int mb_type, int is_h264, int simple, int transform_bypass, int pixel_shift, int *block_offset, int linesize, uint8_t *dest_y, int p) { MpegEncContext * const s = &h->s; void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride); void (*idct_dc_add)... | 26,142 |
1 | static int adx_read_packet(AVFormatContext *s, AVPacket *pkt) { ADXDemuxerContext *c = s->priv_data; AVCodecContext *avctx = s->streams[0]->codec; int ret, size; size = BLOCK_SIZE * avctx->channels; pkt->pos = avio_tell(s->pb); pkt->stream_index = 0; ret = av_get_packet(s->pb, pkt, size); if (ret != size) { av_free_pac... | 26,143 |
1 | static int execute_command(BlockDriverState *bdrv, SCSIGenericReq *r, int direction, BlockDriverCompletionFunc *complete) { SCSIGenericState *s = DO_UPCAST(SCSIGenericState, qdev, r->req.dev); r->io_header.interface_id = 'S'; r->io_header.dxfer_direction = direction; r->io_header.dxferp = r->buf; r->io_header.dxfer_len... | 26,144 |
1 | static int get_int8(QEMUFile *f, void *pv, size_t size) { int8_t *v = pv; qemu_get_s8s(f, v); return 0; } | 26,145 |
0 | static void handle_msr(DisasContext *s, uint32_t insn, unsigned int op0, unsigned int op1, unsigned int op2, unsigned int crn, unsigned int crm, unsigned int rt) { unsupported_encoding(s, insn); } | 26,146 |
0 | static void validate_teardown(TestInputVisitorData *data, const void *unused) { qobject_decref(data->obj); data->obj = NULL; if (data->qiv) { visit_free(data->qiv); data->qiv = NULL; } } | 26,147 |
0 | int kvm_arch_remove_hw_breakpoint(target_ulong addr, target_ulong len, int type) { int n; n = find_hw_breakpoint(addr, (type == GDB_BREAKPOINT_HW) ? 1 : len, type); if (n < 0) return -ENOENT; nb_hw_breakpoint--; hw_breakpoint[n] = hw_breakpoint[nb_hw_breakpoint]; return 0; } | 26,148 |
0 | void HELPER(cas2l)(CPUM68KState *env, uint32_t regs, uint32_t a1, uint32_t a2) { uint32_t Dc1 = extract32(regs, 9, 3); uint32_t Dc2 = extract32(regs, 6, 3); uint32_t Du1 = extract32(regs, 3, 3); uint32_t Du2 = extract32(regs, 0, 3); uint32_t c1 = env->dregs[Dc1]; uint32_t c2 = env->dregs[Dc2]; uint32_t u1 = env->dregs[... | 26,150 |
0 | static inline hwaddr booke206_page_size_to_tlb(uint64_t size) { return (ffs(size >> 10) - 1) >> 1; } | 26,151 |
0 | sofcantrcvmore(struct socket *so) { if ((so->so_state & SS_NOFDREF) == 0) { shutdown(so->s,0); if(global_writefds) { FD_CLR(so->s,global_writefds); } } so->so_state &= ~(SS_ISFCONNECTING); if (so->so_state & SS_FCANTSENDMORE) { so->so_state &= SS_PERSISTENT_MASK; so->so_state |= SS_NOFDREF; /* Don't select it */ } else... | 26,153 |
0 | void cpu_breakpoint_remove_all(CPUState *env, int mask) { #if defined(TARGET_HAS_ICE) CPUBreakpoint *bp, *next; TAILQ_FOREACH_SAFE(bp, &env->breakpoints, entry, next) { if (bp->flags & mask) cpu_breakpoint_remove_by_ref(env, bp); } #endif } | 26,155 |
0 | static void scsi_destroy(SCSIDevice *d) { SCSIGenericState *s = DO_UPCAST(SCSIGenericState, qdev, d); SCSIGenericReq *r; while (!QTAILQ_EMPTY(&s->qdev.requests)) { r = DO_UPCAST(SCSIGenericReq, req, QTAILQ_FIRST(&s->qdev.requests)); scsi_remove_request(r); } blockdev_mark_auto_del(s->qdev.conf.dinfo->bdrv); } | 26,157 |
0 | static inline void kqemu_save_seg(SegmentCache *sc, const struct kqemu_segment_cache *ksc) { sc->selector = ksc->selector; sc->flags = ksc->flags; sc->limit = ksc->limit; sc->base = ksc->base; } | 26,159 |
0 | static void omap_mpu_timer_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size) { struct omap_mpu_timer_s *s = (struct omap_mpu_timer_s *) opaque; if (size != 4) { return omap_badwidth_write32(opaque, addr, value); } switch (addr) { case 0x00: /* CNTL_TIMER */ omap_timer_sync(s); s->enable = (val... | 26,161 |
0 | bool qemu_peer_has_vnet_hdr(NetClientState *nc) { if (!nc->peer || !nc->peer->info->has_vnet_hdr) { return false; } return nc->peer->info->has_vnet_hdr(nc->peer); } | 26,162 |
0 | static void vmxnet3_cleanup(NetClientState *nc) { VMXNET3State *s = qemu_get_nic_opaque(nc); s->nic = NULL; } | 26,163 |
0 | void op_cp1_enabled(void) { if (!(env->CP0_Status & (1 << CP0St_CU1))) { CALL_FROM_TB2(do_raise_exception_err, EXCP_CpU, 1); } RETURN(); } | 26,164 |
0 | static int put_flac_codecpriv(AVFormatContext *s, ByteIOContext *pb, AVCodecContext *codec) { // if the extradata_size is greater than FLAC_STREAMINFO_SIZE, // assume that it's in Matroska format already if (codec->extradata_size < FLAC_STREAMINFO_SIZE) { av_log(s, AV_LOG_ERROR, "Invalid FLAC extradata\n"); return -1; ... | 26,165 |
0 | static void core_region_add(MemoryListener *listener, MemoryRegionSection *section) { cpu_register_physical_memory_log(section, section->readonly); } | 26,166 |
0 | static void kvm_mce_inj_srao_memscrub(CPUState *env, target_phys_addr_t paddr) { struct kvm_x86_mce mce = { .bank = 9, .status = MCI_STATUS_VAL | MCI_STATUS_UC | MCI_STATUS_EN | MCI_STATUS_MISCV | MCI_STATUS_ADDRV | MCI_STATUS_S | 0xc0, .mcg_status = MCG_STATUS_MCIP | MCG_STATUS_RIPV, .addr = paddr, .misc = (MCM_ADDR_P... | 26,167 |
0 | int avcodec_open(AVCodecContext *avctx, AVCodec *codec) { int ret; if(avctx->codec) return -1; avctx->codec = codec; avctx->codec_id = codec->id; avctx->frame_number = 0; if (codec->priv_data_size > 0) { avctx->priv_data = av_mallocz(codec->priv_data_size); if (!avctx->priv_data) return -ENOMEM; } else { avctx->priv_da... | 26,168 |
0 | static inline void RENAME(yv12touyvy)(const uint8_t *ysrc, const uint8_t *usrc, const uint8_t *vsrc, uint8_t *dst, long width, long height, long lumStride, long chromStride, long dstStride) { //FIXME interpolate chroma RENAME(yuvPlanartouyvy)(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride, 2); ... | 26,169 |
1 | static int decode_block_coeffs_internal(VP56RangeCoder *r, int16_t block[16], uint8_t probs[16][3][NUM_DCT_TOKENS - 1], int i, uint8_t *token_prob, int16_t qmul[2]) { VP56RangeCoder c = *r; goto skip_eob; do { int coeff; if (!vp56_rac_get_prob_branchy(&c, token_prob[0])) // DCT_EOB break; skip_eob: if (!vp56_rac_get_pr... | 26,170 |
1 | static int img_check(int argc, char **argv) { int c, ret; OutputFormat output_format = OFORMAT_HUMAN; const char *filename, *fmt, *output, *cache; BlockBackend *blk; BlockDriverState *bs; int fix = 0; int flags = BDRV_O_FLAGS | BDRV_O_CHECK; ImageCheck *check; bool quiet = false; fmt = NULL; output = NULL; cache = BDRV... | 26,171 |
1 | static void imdct12(INTFLOAT *out, INTFLOAT *in) { INTFLOAT in0, in1, in2, in3, in4, in5, t1, t2; in0 = in[0*3]; in1 = in[1*3] + in[0*3]; in2 = in[2*3] + in[1*3]; in3 = in[3*3] + in[2*3]; in4 = in[4*3] + in[3*3]; in5 = in[5*3] + in[4*3]; in5 += in3; in3 += in1; in2 = MULH3(in2, C3, 2); in3 = MULH3(in3, C3, 4); t1 = in0... | 26,172 |
1 | int qcow2_snapshot_load_tmp(BlockDriverState *bs, const char *snapshot_id, const char *name, Error **errp) { int i, snapshot_index; BDRVQcowState *s = bs->opaque; QCowSnapshot *sn; uint64_t *new_l1_table; int new_l1_bytes; int ret; assert(bs->read_only); /* Search the snapshot */ snapshot_index = find_snapshot_by_id_an... | 26,176 |
1 | static int vdi_create(const char *filename, QEMUOptionParameter *options, Error **errp) { int fd; int result = 0; uint64_t bytes = 0; uint32_t blocks; size_t block_size = DEFAULT_CLUSTER_SIZE; uint32_t image_type = VDI_TYPE_DYNAMIC; VdiHeader header; size_t i; size_t bmap_size; logout("\n"); /* Read out options. */ whi... | 26,177 |
1 | static int dxa_read_header(AVFormatContext *s, AVFormatParameters *ap) { AVIOContext *pb = s->pb; DXAContext *c = s->priv_data; AVStream *st, *ast; uint32_t tag; int32_t fps; int w, h; int num, den; int flags; tag = avio_rl32(pb); if (tag != MKTAG('D', 'E', 'X', 'A')) return -1; flags = avio_r8(pb); c->frames = avio_rb... | 26,178 |
0 | static int get_cv_color_primaries(AVCodecContext *avctx, CFStringRef *primaries) { enum AVColorPrimaries pri = avctx->color_primaries; switch (pri) { case AVCOL_PRI_UNSPECIFIED: *primaries = NULL; break; case AVCOL_PRI_BT709: *primaries = kCVImageBufferColorPrimaries_ITU_R_709_2; break; case AVCOL_PRI_BT2020: *primarie... | 26,179 |
0 | static void avc_wgt_4x4multiple_msa(uint8_t *data, int32_t stride, int32_t height, int32_t log2_denom, int32_t src_weight, int32_t offset_in) { uint8_t cnt; uint32_t data0, data1, data2, data3; v16u8 zero = { 0 }; v16u8 src0, src1, src2, src3; v8u16 temp0, temp1, temp2, temp3; v8i16 wgt, denom, offset; offset_in <<= (l... | 26,181 |
0 | static void FUNC(flac_decorrelate_indep_c)(uint8_t **out, int32_t **in, int channels, int len, int shift) { sample *samples = (sample *) OUT(out); int i, j; for (j = 0; j < len; j++) for (i = 0; i < channels; i++) S(samples, i, j) = in[i][j] << shift; } | 26,182 |
1 | void object_property_add_link(Object *obj, const char *name, const char *type, Object **child, void (*check)(Object *, const char *, Object *, Error **), ObjectPropertyLinkFlags flags, Error **errp) { Error *local_err = NULL; LinkProperty *prop = g_malloc(sizeof(*prop)); gchar *full_type; ObjectProperty *op; prop->chil... | 26,184 |
1 | static int alloc_refcount_block(BlockDriverState *bs, int64_t cluster_index, uint16_t **refcount_block) { BDRVQcowState *s = bs->opaque; unsigned int refcount_table_index; int ret; BLKDBG_EVENT(bs->file, BLKDBG_REFBLOCK_ALLOC); /* Find the refcount block for the given cluster */ refcount_table_index = cluster_index >> ... | 26,185 |
1 | PPC_OP(test_ctrz) { T0 = (regs->ctr == 0); RETURN(); } | 26,186 |
1 | static void usb_net_handle_dataout(USBNetState *s, USBPacket *p) { int sz = sizeof(s->out_buf) - s->out_ptr; struct rndis_packet_msg_type *msg = (struct rndis_packet_msg_type *) s->out_buf; uint32_t len; #ifdef TRAFFIC_DEBUG fprintf(stderr, "usbnet: data out len %zu\n", p->iov.size); iov_hexdump(p->iov.iov, p->iov.niov... | 26,187 |
1 | static void quiesce_class_init(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); SCLPEventClass *k = SCLP_EVENT_CLASS(klass); dc->reset = quiesce_reset; dc->vmsd = &vmstate_sclpquiesce; set_bit(DEVICE_CATEGORY_MISC, dc->categories); k->init = quiesce_init; k->get_send_mask = send_mask; k->get_rec... | 26,188 |
0 | static int mov_open_dref(MOVContext *c, AVIOContext **pb, const char *src, MOVDref *ref, AVIOInterruptCB *int_cb) { AVOpenCallback open_func = c->fc->open_cb; if (!open_func) open_func = ffio_open2_wrapper; /* try relative path, we do not try the absolute because it can leak information about our system to an attacker ... | 26,189 |
0 | static void filter_mb_edgev( H264Context *h, uint8_t *pix, int stride, int16_t bS[4], int qp ) { int i, d; const int index_a = qp + h->slice_alpha_c0_offset; const int alpha = (alpha_table+52)[index_a]; const int beta = (beta_table+52)[qp + h->slice_beta_offset]; if( bS[0] < 4 ) { int8_t tc[4]; for(i=0; i<4; i++) tc[i]... | 26,190 |
0 | int qemu_file_rate_limit(QEMUFile *f) { if (f->ops->rate_limit) return f->ops->rate_limit(f->opaque); return 0; } | 26,192 |
0 | qcrypto_block_luks_create(QCryptoBlock *block, QCryptoBlockCreateOptions *options, const char *optprefix, QCryptoBlockInitFunc initfunc, QCryptoBlockWriteFunc writefunc, void *opaque, Error **errp) { QCryptoBlockLUKS *luks; QCryptoBlockCreateOptionsLUKS luks_opts; Error *local_err = NULL; uint8_t *masterkey = NULL; uin... | 26,193 |
0 | static void pc_cmos_init_late(void *opaque) { pc_cmos_init_late_arg *arg = opaque; ISADevice *s = arg->rtc_state; int16_t cylinders; int8_t heads, sectors; int val; int i, trans; Object *container; CheckFdcState state = { 0 }; val = 0; if (ide_get_geometry(arg->idebus[0], 0, &cylinders, &heads, §ors) >= 0) { cmos_i... | 26,194 |
0 | static void kvm_mce_broadcast_rest(CPUState *env) { CPUState *cenv; int family, model, cpuver = env->cpuid_version; family = (cpuver >> 8) & 0xf; model = ((cpuver >> 12) & 0xf0) + ((cpuver >> 4) & 0xf); /* Broadcast MCA signal for processor version 06H_EH and above */ if ((family == 6 && model >= 14) || family > 6) { f... | 26,195 |
0 | static struct omap_lpg_s *omap_lpg_init(MemoryRegion *system_memory, target_phys_addr_t base, omap_clk clk) { struct omap_lpg_s *s = (struct omap_lpg_s *) g_malloc0(sizeof(struct omap_lpg_s)); s->tm = qemu_new_timer_ms(vm_clock, omap_lpg_tick, s); omap_lpg_reset(s); memory_region_init_io(&s->iomem, &omap_lpg_ops, s, "o... | 26,196 |
0 | static int vapic_enable(VAPICROMState *s, CPUX86State *env) { int cpu_number = get_kpcr_number(env); target_phys_addr_t vapic_paddr; static const uint8_t enabled = 1; if (cpu_number < 0) { return -1; } vapic_paddr = s->vapic_paddr + (((target_phys_addr_t)cpu_number) << VAPIC_CPU_SHIFT); cpu_physical_memory_rw(vapic_pad... | 26,197 |
0 | static void omap_id_write(void *opaque, target_phys_addr_t addr, uint64_t value, unsigned size) { if (size != 4) { return omap_badwidth_write32(opaque, addr, value); } OMAP_BAD_REG(addr); } | 26,198 |
0 | static void scsi_unmap_complete(void *opaque, int ret) { UnmapCBData *data = opaque; SCSIDiskReq *r = data->r; SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev); uint64_t sector_num; uint32_t nb_sectors; r->req.aiocb = NULL; if (r->req.io_canceled) { scsi_req_cancel_complete(&r->req); goto done; } if (ret <... | 26,200 |
0 | static void selfTest(uint8_t *src[4], int stride[4], int w, int h){ enum PixelFormat srcFormat, dstFormat; int srcW, srcH, dstW, dstH; int flags; for (srcFormat = 0; srcFormat < PIX_FMT_NB; srcFormat++) { for (dstFormat = 0; dstFormat < PIX_FMT_NB; dstFormat++) { printf("%s -> %s\n", sws_format_name(srcFormat), sws_for... | 26,201 |
0 | int qemu_strtoi64(const char *nptr, const char **endptr, int base, int64_t *result) { char *ep; int err = 0; if (!nptr) { if (endptr) { *endptr = nptr; } err = -EINVAL; } else { errno = 0; /* FIXME This assumes int64_t is long long */ *result = strtoll(nptr, &ep, base); err = check_strtox_error(nptr, ep, endptr, errno)... | 26,204 |
0 | static int qemu_rdma_exchange_get_response(RDMAContext *rdma, RDMAControlHeader *head, int expecting, int idx) { int ret = qemu_rdma_block_for_wrid(rdma, RDMA_WRID_RECV_CONTROL + idx); if (ret < 0) { fprintf(stderr, "rdma migration: recv polling control error!\n"); return ret; } network_to_control((void *) rdma->wr_dat... | 26,205 |
0 | static void omap_tcmi_init(MemoryRegion *memory, target_phys_addr_t base, struct omap_mpu_state_s *mpu) { memory_region_init_io(&mpu->tcmi_iomem, &omap_tcmi_ops, mpu, "omap-tcmi", 0x100); memory_region_add_subregion(memory, base, &mpu->tcmi_iomem); omap_tcmi_reset(mpu); } | 26,206 |
0 | static void spapr_machine_2_5_class_options(MachineClass *mc) { sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc); mc->alias = "pseries"; mc->is_default = 1; smc->dr_lmb_enabled = true; } | 26,207 |
1 | static int disas_thumb2_insn(CPUState *env, DisasContext *s, uint16_t insn_hw1) { uint32_t insn, imm, shift, offset; uint32_t rd, rn, rm, rs; TCGv tmp; TCGv tmp2; TCGv tmp3; TCGv addr; TCGv_i64 tmp64; int op; int shiftop; int conds; int logic_cc; if (!(arm_feature(env, ARM_FEATURE_THUMB2) || arm_feature (env, ARM_FEATU... | 26,208 |
1 | static void kvm_set_phys_mem(target_phys_addr_t start_addr, ram_addr_t size, ram_addr_t phys_offset, bool log_dirty) { KVMState *s = kvm_state; ram_addr_t flags = phys_offset & ~TARGET_PAGE_MASK; KVMSlot *mem, old; int err; void *ram = NULL; /* kvm works in page size chunks, but the function may be called with sub-page... | 26,209 |
1 | static void v9fs_xattrwalk(void *opaque) { int64_t size; V9fsString name; ssize_t err = 0; size_t offset = 7; int32_t fid, newfid; V9fsFidState *file_fidp; V9fsFidState *xattr_fidp = NULL; V9fsPDU *pdu = opaque; V9fsState *s = pdu->s; pdu_unmarshal(pdu, offset, "dds", &fid, &newfid, &name); file_fidp = get_fid(pdu, fid... | 26,210 |
1 | void ff_eac3_apply_spectral_extension(AC3DecodeContext *s) { int bin, bnd, ch, i; uint8_t wrapflag[SPX_MAX_BANDS]={1,0,}, num_copy_sections, copy_sizes[SPX_MAX_BANDS]; float rms_energy[SPX_MAX_BANDS]; /* Set copy index mapping table. Set wrap flags to apply a notch filter at wrap points later on. */ bin = s->spx_dst_st... | 26,211 |
1 | static int add_crc_to_array(uint32_t crc, int64_t pts) { if (size_of_array <= number_of_elements) { if (size_of_array == 0) size_of_array = 10; size_of_array *= 2; crc_array = av_realloc(crc_array, size_of_array * sizeof(uint32_t)); pts_array = av_realloc(pts_array, size_of_array * sizeof(int64_t)); if ((crc_array == N... | 26,212 |
1 | static void vfio_listener_region_del(MemoryListener *listener, MemoryRegionSection *section) { VFIOContainer *container = container_of(listener, VFIOContainer, iommu_data.listener); hwaddr iova, end; int ret; if (vfio_listener_skipped_section(section)) { DPRINTF("SKIPPING region_del %"HWADDR_PRIx" - %"PRIx64"\n", secti... | 26,213 |
0 | static av_cold void init_mv_penalty_and_fcode(MpegEncContext *s) { int f_code; int mv; for(f_code=1; f_code<=MAX_FCODE; f_code++){ for(mv=-MAX_MV; mv<=MAX_MV; mv++){ int len; if(mv==0) len= ff_mvtab[0][1]; else{ int val, bit_size, code; bit_size = f_code - 1; val=mv; if (val < 0) val = -val; val--; code = (val >> bit_s... | 26,214 |
0 | static av_always_inline int setup_classifs(vorbis_context *vc, vorbis_residue *vr, uint8_t *do_not_decode, unsigned ch_used, int partition_count) { int p, j, i; unsigned c_p_c = vc->codebooks[vr->classbook].dimensions; unsigned inverse_class = ff_inverse[vr->classifications]; unsigned temp, temp2; for (p = 0, j = 0; j ... | 26,215 |
0 | static int qemu_laio_process_requests(void *opaque) { struct qemu_laio_state *s = opaque; struct qemu_laiocb *laiocb, *next; int res = 0; QLIST_FOREACH_SAFE (laiocb, &s->completed_reqs, node, next) { if (laiocb->async_context_id == get_async_context_id()) { qemu_laio_process_completion(s, laiocb); QLIST_REMOVE(laiocb, ... | 26,216 |
0 | static void event_scan(PowerPCCPU *cpu, sPAPRMachineState *spapr, uint32_t token, uint32_t nargs, target_ulong args, uint32_t nret, target_ulong rets) { uint32_t mask, buf, len, event_len; sPAPREventLogEntry *event; struct rtas_error_log *hdr; if (nargs != 4 || nret != 1) { rtas_st(rets, 0, RTAS_OUT_PARAM_ERROR); retur... | 26,217 |
0 | static void sysbus_esp_mem_write(void *opaque, target_phys_addr_t addr, uint64_t val, unsigned int size) { SysBusESPState *sysbus = opaque; uint32_t saddr; saddr = addr >> sysbus->it_shift; esp_reg_write(&sysbus->esp, saddr, val); } | 26,218 |
0 | static uint32_t adler32(uint32_t adler, const uint8_t *buf, unsigned int len) { unsigned long s1 = adler & 0xffff; unsigned long s2 = (adler >> 16) & 0xffff; int k; if (buf == NULL) return 1L; while (len > 0) { k = len < NMAX ? len : NMAX; len -= k; while (k >= 16) { DO16(buf); k -= 16; } if (k != 0) do { DO1(buf); } w... | 26,219 |
0 | static int wm8750_tx(I2CSlave *i2c, uint8_t data) { WM8750State *s = WM8750(i2c); uint8_t cmd; uint16_t value; if (s->i2c_len >= 2) { #ifdef VERBOSE printf("%s: long message (%i bytes)\n", __func__, s->i2c_len); #endif return 1; } s->i2c_data[s->i2c_len ++] = data; if (s->i2c_len != 2) return 0; cmd = s->i2c_data[0] >>... | 26,220 |
0 | static int protocol_client_msg(VncState *vs, uint8_t *data, size_t len) { int i; uint16_t limit; VncDisplay *vd = vs->vd; if (data[0] > 3) { vd->timer_interval = VNC_REFRESH_INTERVAL_BASE; if (!qemu_timer_expired(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval)) qemu_mod_timer(vd->timer, qemu_get_clock(rt_cloc... | 26,221 |
0 | void ppc_cpu_list (FILE *f, int (*cpu_fprintf)(FILE *f, const char *fmt, ...)) { int i, max; max = ARRAY_SIZE(ppc_defs); for (i = 0; i < max; i++) { (*cpu_fprintf)(f, "PowerPC %-16s PVR %08x\n", ppc_defs[i].name, ppc_defs[i].pvr); } } | 26,222 |
0 | static void gic_update(gic_state *s) { int best_irq; int best_prio; int irq; int level; int cpu; int cm; for (cpu = 0; cpu < NUM_CPU(s); cpu++) { cm = 1 << cpu; s->current_pending[cpu] = 1023; if (!s->enabled || !s->cpu_enabled[cpu]) { qemu_irq_lower(s->parent_irq[cpu]); return; } best_prio = 0x100; best_irq = 1023; fo... | 26,224 |
0 | static void *kqemu_vmalloc(size_t size) { static int phys_ram_fd = -1; static int phys_ram_size = 0; void *ptr; /* no need (?) for a dummy file on OpenBSD/FreeBSD */ #if defined(__OpenBSD__) || defined(__FreeBSD__) || defined(__DragonFly__) int map_anon = MAP_ANON; #else int map_anon = 0; const char *tmpdir; char phys_... | 26,228 |
0 | static uint32_t virtio_console_get_features(VirtIODevice *vdev) { return 0; } | 26,229 |
0 | void event_loop(void) { SDL_Event event; double incr, pos, frac; for(;;) { SDL_WaitEvent(&event); switch(event.type) { case SDL_KEYDOWN: switch(event.key.keysym.sym) { case SDLK_ESCAPE: case SDLK_q: do_exit(); break; case SDLK_f: toggle_full_screen(); break; case SDLK_p: case SDLK_SPACE: toggle_pause(); break; case SDL... | 26,231 |
0 | static inline void IRQ_setbit(IRQQueue *q, int n_IRQ) { set_bit(q->queue, n_IRQ); } | 26,232 |
0 | static void sdl_callback (void *opaque, Uint8 *buf, int len) { SDLVoiceOut *sdl = opaque; SDLAudioState *s = &glob_sdl; HWVoiceOut *hw = &sdl->hw; int samples = len >> hw->info.shift; if (s->exit) { return; } while (samples) { int to_mix, decr; /* dolog ("in callback samples=%d\n", samples); */ sdl_wait (s, "sdl_callba... | 26,233 |
0 | static int mov_write_ilst_tag(AVIOContext *pb, MOVMuxContext *mov, AVFormatContext *s) { int64_t pos = avio_tell(pb); avio_wb32(pb, 0); /* size */ ffio_wfourcc(pb, "ilst"); mov_write_string_metadata(s, pb, "\251nam", "title" , 1); mov_write_string_metadata(s, pb, "\251ART", "artist" , 1); mov_write_string_metadata(s, p... | 26,235 |
1 | static int gif_read_close(AVFormatContext *s1) { GifState *s = s1->priv_data; av_free(s->image_buf); return 0; } | 26,236 |
1 | void qemu_thread_get_self(QemuThread *thread) { if (!thread->thread) { /* In the main thread of the process. Initialize the QemuThread pointer in TLS, and use the dummy GetCurrentThread handle as the identifier for qemu_thread_is_self. */ qemu_thread_init(); TlsSetValue(qemu_thread_tls_index, thread); thread->thread = ... | 26,238 |
1 | static void coroutine_fn qemu_co_mutex_lock_slowpath(CoMutex *mutex) { Coroutine *self = qemu_coroutine_self(); CoWaitRecord w; unsigned old_handoff; trace_qemu_co_mutex_lock_entry(mutex, self); w.co = self; push_waiter(mutex, &w); /* This is the "Responsibility Hand-Off" protocol; a lock() picks from * a concurrent un... | 26,239 |
1 | static int pnm_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt) { const uint8_t *buf = avpkt->data; int buf_size = avpkt->size; PNMContext * const s = avctx->priv_data; AVFrame * const p = data; int i, j, n, linesize, h, upgrade = 0, is_mono = 0; unsigned char *ptr; int components, sampl... | 26,240 |
0 | static ssize_t block_crypto_write_func(QCryptoBlock *block, void *opaque, size_t offset, const uint8_t *buf, size_t buflen, Error **errp) { struct BlockCryptoCreateData *data = opaque; ssize_t ret; ret = blk_pwrite(data->blk, offset, buf, buflen, 0); if (ret < 0) { error_setg_errno(errp, -ret, "Could not write encrypti... | 26,241 |
0 | static int qemu_calculate_timeout(void) { #ifndef CONFIG_IOTHREAD int timeout; if (!vm_running) timeout = 5000; else if (tcg_has_work()) timeout = 0; else { /* XXX: use timeout computed from timers */ int64_t add; int64_t delta; /* Advance virtual time to the next event. */ delta = qemu_icount_delta(); if (delta > 0) {... | 26,244 |
0 | static int spice_chr_write(CharDriverState *chr, const uint8_t *buf, int len) { SpiceCharDriver *s = chr->opaque; vmc_register_interface(s); assert(s->datalen == 0); if (s->bufsize < len) { s->bufsize = len; s->buffer = g_realloc(s->buffer, s->bufsize); } memcpy(s->buffer, buf, len); s->datapos = s->buffer; s->datalen ... | 26,246 |
0 | static int net_slirp_init(NetClientState *peer, const char *model, const char *name, int restricted, const char *vnetwork, const char *vhost, const char *vhostname, const char *tftp_export, const char *bootfile, const char *vdhcp_start, const char *vnameserver, const char *smb_export, const char *vsmbserver, const char... | 26,247 |
0 | static int ppce500_load_device_tree(CPUPPCState *env, PPCE500Params *params, hwaddr addr, hwaddr initrd_base, hwaddr initrd_size) { int ret = -1; uint64_t mem_reg_property[] = { 0, cpu_to_be64(params->ram_size) }; int fdt_size; void *fdt; uint8_t hypercall[16]; uint32_t clock_freq = 400000000; uint32_t tb_freq = 400000... | 26,248 |
0 | int ff_audio_mix_get_matrix(AudioMix *am, double *matrix, int stride) { int i, o; if ( am->in_channels <= 0 || am->in_channels > AVRESAMPLE_MAX_CHANNELS || am->out_channels <= 0 || am->out_channels > AVRESAMPLE_MAX_CHANNELS) { av_log(am, AV_LOG_ERROR, "Invalid channel counts\n"); return AVERROR(EINVAL); } #define GET_M... | 26,249 |
0 | DriveInfo *drive_get_by_blockdev(BlockDriverState *bs) { return bs->blk ? blk_legacy_dinfo(bs->blk) : NULL; } | 26,250 |
0 | int kvm_arch_put_registers(CPUState *env, int level) { int ret; assert(cpu_is_stopped(env) || qemu_cpu_self(env)); ret = kvm_getput_regs(env, 1); if (ret < 0) { return ret; } ret = kvm_put_xsave(env); if (ret < 0) { return ret; } ret = kvm_put_xcrs(env); if (ret < 0) { return ret; } ret = kvm_put_sregs(env); if (ret < ... | 26,252 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.