project stringclasses 2
values | commit_id stringlengths 40 40 | target int64 0 1 | func stringlengths 26 142k | idx int64 0 27.3k |
|---|---|---|---|---|
qemu | 6484e422479c93f28e3f8a68258b0eacd3b31e6d | 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) {
... | 23,611 |
qemu | a90a7425cf592a3afeff3eaf32f543b83050ee5c | 0 | static int tap_can_send(void *opaque)
{
TAPState *s = opaque;
return qemu_can_send_packet(&s->nc);
}
| 23,612 |
qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | 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);
}
| 23,614 |
qemu | 6877cff044cdf6da66885eab62363baf98bb39ee | 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 no... | 23,615 |
qemu | 7385aed20db5d83979f683b9d0048674411e963c | 0 | void helper_fdtoq(CPUSPARCState *env, float64 src)
{
clear_float_exceptions(env);
QT0 = float64_to_float128(src, &env->fp_status);
check_ieee_exceptions(env);
}
| 23,617 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 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;
}
| 23,618 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 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) */
... | 23,619 |
qemu | e4533c7a8cdcc79ccdf695f0aaa2e23a5b926ed0 | 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... | 23,620 |
qemu | 0ac7cc2af500b948510f2481c22e84a57b0a2447 | 0 | START_TEST(qobject_to_qstring_test)
{
QString *qstring;
qstring = qstring_from_str("foo");
fail_unless(qobject_to_qstring(QOBJECT(qstring)) == qstring);
QDECREF(qstring);
}
| 23,623 |
qemu | 02f292d9051f616511f482275b571c6153e3a48b | 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_... | 23,624 |
FFmpeg | f6774f905fb3cfdc319523ac640be30b14c1bc55 | 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;
... | 23,625 |
FFmpeg | 9487fb4dea3498eb4711eb023f43199f68701b1e | 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 *ubuf... | 23,628 |
qemu | c364c974d9ab90e25e7887f516da65d2811ba5e3 | 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... | 23,629 |
FFmpeg | 8348bd198ff8ef2ad366ac7ad959193ef845d468 | 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... | 23,630 |
FFmpeg | d6737539e77e78fca9a04914d51996cfd1ccc55c | 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... | 23,631 |
FFmpeg | 357282c6f3c990833d0508c234ac4522d536c4ac | 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.p... | 23,632 |
qemu | 8be487d8f184f2f721cabeac559fb7a6cba18c95 | 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->inse... | 23,633 |
qemu | 73d60fa5fae60c8e07e1f295d8c7fd5d04320160 | 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... | 23,634 |
FFmpeg | 5e268633d17ccfe99955af95f5b60fc4f983a7b2 | 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) {
... | 23,635 |
qemu | ce5b1bbf624b977a55ff7f85bb3871682d03baff | 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);
}
}
| 23,637 |
qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | 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);
}
| 23,638 |
FFmpeg | 1b9ca38d9d06d319fffd61d27e4eb385d6572ba8 | 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_d... | 23,639 |
FFmpeg | 2caf19e90f270abe1e80a3e85acaf0eb5c9d0aac | 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<<(... | 23,640 |
qemu | 1984745ea8ad309a06690a83e91d031d21d709ff | 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;
... | 23,641 |
qemu | 01979a98d75b49c2acbbbb71521c285f8d8f9fb7 | 1 | static int bdrv_qed_check(BlockDriverState *bs, BdrvCheckResult *result)
{
return -ENOTSUP;
}
| 23,642 |
FFmpeg | 46e407554968e7258c874f4caf517172ffa285cf | 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 <= b... | 23,644 |
qemu | b5eff355460643d09e533024360fe0522f368c07 | 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 = s... | 23,645 |
qemu | d09a6fde1590ca3a45b608b6873a680f208dfeb5 | 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) {
... | 23,646 |
FFmpeg | c23acbaed40101c677dfcfbbfe0d2c230a8e8f44 | 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] + b... | 23,647 |
qemu | 86e18cae209f8101ff9a6013a1ff6ae620c06944 | 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);
}
| 23,648 |
qemu | ae2150680190e510dcbcdfdbfb3a54369c75367f | 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;
... | 23,649 |
qemu | f8ed85ac992c48814d916d5df4d44f9a971c5de4 | 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_mem... | 23,650 |
FFmpeg | a38469e1da7b4829a2fba4279d8420a33f96832e | 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"
... | 23,651 |
FFmpeg | 229843aa359ae0c9519977d7fa952688db63f559 | 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);
}
| 23,652 |
FFmpeg | e3d2500fe498289a878b956f6efb4995438c9515 | 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_MMX
if(uDest != NULL... | 23,654 |
qemu | aa87d45855c7b255b451622a84a3e5b9b4393425 | 1 | void enable_kvm_pv_eoi(void)
{
kvm_default_features |= kvm_pv_eoi_features;
}
| 23,655 |
qemu | 91bea4e2bb1a5f7954a3b3a4f2e28e96bd25c458 | 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_... | 23,657 |
qemu | 1622ffd5151ad09c47785a380531ef1ebfc95be8 | 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_adapte... | 23,658 |
qemu | c3e10c7b4377c1cbc0a4fbc12312c2cf41c0cda7 | 1 | static always_inline void gen_op_subfeo_64 (void)
{
gen_op_move_T2_T0();
gen_op_subfe_64();
gen_op_check_subfo_64();
}
| 23,659 |
qemu | 26c4e7ca72d970d120f0f51244bc8d37458512a0 | 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;
... | 23,660 |
qemu | 3e305e4a4752f70c0b5c3cf5b43ec957881714f7 | 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... | 23,661 |
qemu | 12dccfe4f57ead8166567ec8a60d2ce91e266f04 | 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("s... | 23,662 |
FFmpeg | 341f01290c2353669ed2263f56e1a9f4c67cc597 | 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)
... | 23,664 |
qemu | 3e305e4a4752f70c0b5c3cf5b43ec957881714f7 | 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);
... | 23,666 |
qemu | b5aec39672dc6084b43fa3f77764a6f549255a53 | 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 ... | 23,667 |
FFmpeg | 65d999d6cfc4190f26156a0878d1599d9085c7e9 | 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))
... | 23,669 |
qemu | b20909195745c34a819aed14ae996b60ab0f591f | 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->statu... | 23,670 |
qemu | 4f4321c11ff6e98583846bfd6f0e81954924b003 | 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 &= ~T... | 23,671 |
FFmpeg | fe53fa253f4a54f715249f0d88f7320ae0f65df5 | 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... | 23,672 |
qemu | 12848bfc5d719bad536c5448205a3226be1fda47 | 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;
}
| 23,673 |
qemu | cd7bc87868d534f95e928cad98e2a52df7695771 | 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;
} | 23,674 |
qemu | 480cff632221dc4d4889bf72dd0f09cd35096bc1 | 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 ... | 23,675 |
FFmpeg | 28bf81c90d36a55cf76e2be913c5215ebebf61f2 | 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... | 23,676 |
qemu | 30aa5c0d303c334c646e9db1ebadda0c0db8b13f | 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;
qem... | 23,677 |
FFmpeg | 850c6db97d1f78e7607952ab8b854a93a185319e | 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, re... | 23,678 |
FFmpeg | 6d702dc072ffc255cd0f709132e55661698313e7 | 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;
cons... | 23,679 |
FFmpeg | a147c1b2b125c26cd2c5105a7f274a597de37731 | 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 == ... | 23,681 |
qemu | debaaa114a8877a939533ba846e64168fb287b7b | 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);
ahc... | 23,683 |
qemu | 1c275925bfbbc2de84a8f0e09d1dd70bbefb6da3 | 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 u... | 23,684 |
qemu | f3c3b87dae44ac6c82246ceb3953793951800a9a | 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);
... | 23,685 |
qemu | fd56e0612b6454a282fa6a953fdb09281a98c589 | 0 | MemoryRegion *pci_address_space_io(PCIDevice *dev)
{
return dev->bus->address_space_io;
}
| 23,687 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 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;... | 23,690 |
qemu | ba14414174b72fa231997243a9650feaa520d054 | 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 " }",
... | 23,691 |
FFmpeg | 29fb49194bedc74ac9be0b49b6b42dcfeb6222d9 | 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();... | 23,693 |
qemu | 1c275925bfbbc2de84a8f0e09d1dd70bbefb6da3 | 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 pstat... | 23,694 |
qemu | 8a5956ad6392f115521dad774055c737c49fb0dd | 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);
}
| 23,695 |
qemu | 2374e73edafff0586cbfb67c333c5a7588f81fd5 | 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 ((virtadd... | 23,697 |
qemu | 08b277ac46da8b02e50cec455eca7cb2d12ffcf0 | 0 | static bool less_than_7(void *opaque, int version_id)
{
return version_id < 7;
}
| 23,698 |
qemu | 506590836144af7d0de3fc4c691bb5ed49d41645 | 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->ex... | 23,699 |
qemu | 5fb6c7a8b26eab1a22207d24b4784bd2b39ab54b | 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_par... | 23,700 |
qemu | 285f7a62e464eac97e472ba6803ddede1e6c459e | 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(... | 23,701 |
qemu | 991f8f0c91d65cebf51fa931450e02b0d5209012 | 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 */
... | 23,702 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 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 me... | 23,703 |
qemu | 9005b2a7589540a3733b3abdcfbccfe7746cd1a1 | 0 | int qemu_chr_fe_write(CharDriverState *s, const uint8_t *buf, int len)
{
return s->chr_write(s, buf, len);
}
| 23,705 |
qemu | 27a69bb088bee6d4efea254659422fb9c751b3c7 | 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_gp... | 23,706 |
qemu | e1833e1f96456fd8fc17463246fe0b2050e68efb | 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 ... | 23,707 |
qemu | 2119882c7eb7e2c612b24fc0c8d86f5887d6f1c3 | 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) {
... | 23,708 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 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);
}
| 23,709 |
FFmpeg | c341f734e5f9d6af4a8fdcceb6f5d12de6395c76 | 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*0x... | 23,711 |
qemu | c29c1dd312f39ec18a3c6177c6da09a75e095d70 | 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)
{
... | 23,712 |
FFmpeg | f738140807f504c9af7850042067777832f05e88 | 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... | 23,713 |
FFmpeg | 6892d145a0c80249bd61ee7dd31ec851c5076bcd | 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 = ... | 23,715 |
qemu | 7fe7b68b32ba609faeeee03556aac0eb1b187c91 | 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... | 23,716 |
FFmpeg | 5b4da8a38a5ed211df9504c85ce401c30af86b97 | 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.bytestr... | 23,717 |
FFmpeg | 851ded8918c977d8160c6617b69604f758cabf50 | 0 | static inline int decode_cabac_mb_transform_size( H264Context *h ) {
return get_cabac( &h->cabac, &h->cabac_state[399 + h->neighbor_transform_size] );
}
| 23,718 |
FFmpeg | 0574780d7a196f87ddd89d6362f4c47f3532b4c4 | 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... | 23,719 |
FFmpeg | 71a3dff9d56b9ddf3aa8179bc4aed9724724068e | 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_TIME
uint64_t time= rdtsc();
#endif
#i... | 23,720 |
qemu | 7797a73947d5c0e63dd5552b348cf66c384b4555 | 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->s... | 23,721 |
FFmpeg | 386d60f9783ac094dae6c3c9210e0469f98c9147 | 1 | static av_always_inline int lcg_random(int previous_val)
{
return previous_val * 1664525 + 1013904223;
}
| 23,722 |
qemu | 9f953ca0b8ae71f4ea8112a3aac36454a2c4b907 | 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... | 23,723 |
qemu | e7b921c2d9efc249f99b9feb0e7dca82c96aa5c4 | 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:
... | 23,724 |
FFmpeg | f9d7e9feec2a0fd7f7930d01876a70a9b8a4a3b9 | 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 f... | 23,725 |
qemu | 1ee24514aed34760fb2863d98bea3a1b705d9c9f | 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... | 23,726 |
qemu | d6309c170eb99950c9f1d881a5ff7163ae28d353 | 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);
}
| 23,728 |
qemu | ebca2df783a5a742bb93784524336d8cbb9e662b | 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);
}
| 23,729 |
FFmpeg | 1891dfe0130991ee138d01f2877678de717b9e23 | 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_... | 23,730 |
FFmpeg | ebba2b3e2a551ce638d17332761431ba748f178f | 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);
}
| 23,732 |
FFmpeg | 77015443a84bb5dbed38eafc2ea26a2bf2641ed6 | 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)
... | 23,734 |
qemu | 82cbbdc6a0958b49c77639a60906e30d02e6bb7b | 0 | int qemu_bh_poll(void)
{
return aio_bh_poll(qemu_aio_context);
}
| 23,735 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 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 om... | 23,736 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.