id stringlengths 22 26 | content stringlengths 72 142k |
|---|---|
devign_test_set_data_21135 | static void qio_channel_command_finalize(Object *obj)
{
QIOChannelCommand *ioc = QIO_CHANNEL_COMMAND(obj);
if (ioc->readfd != -1) {
close(ioc->readfd);
ioc->readfd = -1;
}
if (ioc->writefd != -1) {
close(ioc->writefd);
ioc->writefd = -1;
}
if (ioc->pid ... |
devign_test_set_data_21155 | static int read_gab2_sub(AVStream *st, AVPacket *pkt) {
if (!strcmp(pkt->data, "GAB2") && AV_RL16(pkt->data+5) == 2) {
uint8_t desc[256];
int score = AVPROBE_SCORE_MAX / 2, ret;
AVIStream *ast = st->priv_data;
AVInputFormat *sub_demuxer;
AVRational time_base;
A... |
devign_test_set_data_21166 | int av_set_string3(void *obj, const char *name, const char *val, int alloc, const AVOption **o_out)
{
int ret;
const AVOption *o = av_opt_find(obj, name, NULL, 0, 0);
if (o_out)
*o_out = o;
if (!o)
return AVERROR_OPTION_NOT_FOUND;
if (!val || o->offset<=0)
return AVE... |
devign_test_set_data_21168 | void ff_h264_h_lpf_chroma_inter_msa(uint8_t *data, int img_width,
int alpha, int beta, int8_t *tc)
{
uint8_t bs0 = 1;
uint8_t bs1 = 1;
uint8_t bs2 = 1;
uint8_t bs3 = 1;
if (tc[0] < 0)
bs0 = 0;
if (tc[1] < 0)
bs1 = 0;
if (tc[2] ... |
devign_test_set_data_21202 | void slirp_select_poll(fd_set *readfds, fd_set *writefds, fd_set *xfds,
int select_error)
{
Slirp *slirp;
struct socket *so, *so_next;
int ret;
if (QTAILQ_EMPTY(&slirp_instances)) {
return;
}
global_readfds = readfds;
global_writefds = writefds;
... |
devign_test_set_data_21218 | uint64_t helper_cmpbge (uint64_t op1, uint64_t op2)
{
uint8_t opa, opb, res;
int i;
res = 0;
for (i = 0; i < 7; i++) {
opa = op1 >> (i * 8);
opb = op2 >> (i * 8);
if (opa >= opb)
res |= 1 << i;
}
return res;
}
The vulnerability label is: Non-vu... |
devign_test_set_data_21219 | static int s390_ipl_init(SysBusDevice *dev)
{
S390IPLState *ipl = S390_IPL(dev);
uint64_t pentry = KERN_IMAGE_START;
int kernel_size;
int bios_size;
char *bios_filename;
/*
* Always load the bios if it was enforced,
* even if an external kernel has been defined.
*/
... |
devign_test_set_data_21250 | static int virtcon_parse(const char *devname)
{
QemuOptsList *device = qemu_find_opts("device");
static int index = 0;
char label[32];
QemuOpts *bus_opts, *dev_opts;
if (strcmp(devname, "none") == 0)
return 0;
if (index == MAX_VIRTIO_CONSOLES) {
fprintf(stderr, "qemu: ... |
devign_test_set_data_21256 | static void monitor_puts(Monitor *mon, const char *str)
{
char c;
for(;;) {
c = *str++;
if (c == '\0')
break;
if (c == '\n') {
qstring_append_chr(mon->outbuf, '\r');
}
qstring_append_chr(mon->outbuf, c);
if (c == '\n') {
... |
devign_test_set_data_21261 | static void gen_movl_seg_T0(DisasContext *s, int seg_reg)
{
if (s->pe && !s->vm86) {
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T0);
gen_helper_load_seg(cpu_env, tcg_const_i32(seg_reg), cpu_tmp2_i32);
/* abort translation because the addseg value may change or
because ss32 may c... |
devign_test_set_data_21267 | void gen_intermediate_code_a64(ARMCPU *cpu, TranslationBlock *tb)
{
CPUState *cs = CPU(cpu);
CPUARMState *env = &cpu->env;
DisasContext dc1, *dc = &dc1;
target_ulong pc_start;
target_ulong next_page_start;
int num_insns;
int max_insns;
pc_start = tb->pc;
dc->tb = tb;
... |
devign_test_set_data_21281 | static int mov_read_stsc(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
AVStream *st;
MOVStreamContext *sc;
unsigned int i, entries;
if (c->fc->nb_streams < 1)
return 0;
st = c->fc->streams[c->fc->nb_streams-1];
sc = st->priv_data;
avio_r8(pb); /* version */
avio_r... |
devign_test_set_data_21284 | static int decode_copy(uint8_t *frame, int width, int height,
const uint8_t *src, const uint8_t *src_end)
{
const int size = width * height;
if (src_end - src < size)
return -1;
bytestream_get_buffer(&src, frame, size);
return 0;
}
The vulnerability label is: V... |
devign_test_set_data_21296 | static uint16_t nvme_io_cmd(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
{
NvmeNamespace *ns;
uint32_t nsid = le32_to_cpu(cmd->nsid);
if (nsid == 0 || nsid > n->num_namespaces) {
return NVME_INVALID_NSID | NVME_DNR;
}
ns = &n->namespaces[nsid - 1];
switch (cmd->opcode) {
... |
devign_test_set_data_21302 | void avfilter_link_free(AVFilterLink **link)
{
if (!*link)
return;
if ((*link)->pool) {
int i;
for (i = 0; i < POOL_SIZE; i++) {
if ((*link)->pool->pic[i]) {
AVFilterBufferRef *picref = (*link)->pool->pic[i];
/* free buffer: picrefs ... |
devign_test_set_data_21306 | static uint64_t pl110_read(void *opaque, hwaddr offset,
unsigned size)
{
pl110_state *s = (pl110_state *)opaque;
if (offset >= 0xfe0 && offset < 0x1000) {
return idregs[s->version][(offset - 0xfe0) >> 2];
}
if (offset >= 0x200 && offset < 0x400) {
ret... |
devign_test_set_data_21311 | static void fill_coding_method_array (sb_int8_array tone_level_idx, sb_int8_array tone_level_idx_temp,
sb_int8_array coding_method, int nb_channels,
int c, int superblocktype_2_3, int cm_table_select)
{
int ch, sb, j;
int tmp, acc, esp_40, comp;
int add1, add2, add3, ad... |
devign_test_set_data_21324 | void arm_cpu_dump_state(CPUState *cs, FILE *f, fprintf_function cpu_fprintf,
int flags)
{
ARMCPU *cpu = ARM_CPU(cs);
CPUARMState *env = &cpu->env;
int i;
if (is_a64(env)) {
aarch64_cpu_dump_state(cs, f, cpu_fprintf, flags);
return;
}
for(i=0;... |
devign_test_set_data_21335 | int vmstate_load_state(QEMUFile *f, const VMStateDescription *vmsd,
void *opaque, int version_id)
{
VMStateField *field = vmsd->fields;
int ret = 0;
trace_vmstate_load_state(vmsd->name, version_id);
if (version_id > vmsd->version_id) {
error_report("%s: incoming v... |
devign_test_set_data_21348 | static void xen_log_start(MemoryListener *listener,
MemoryRegionSection *section)
{
XenIOState *state = container_of(listener, XenIOState, memory_listener);
xen_sync_dirty_bitmap(state, section->offset_within_address_space,
int128_get64(section->size));... |
devign_test_set_data_21374 | static void mpegvideo_extract_headers(AVCodecParserContext *s,
AVCodecContext *avctx,
const uint8_t *buf, int buf_size)
{
ParseContext1 *pc = s->priv_data;
const uint8_t *buf_end;
uint32_t start_code;
int frame_rate_inde... |
devign_test_set_data_21383 | static void test_smbios_ep_address(test_data *data)
{
uint32_t off;
/* find smbios entry point structure */
for (off = 0xf0000; off < 0x100000; off += 0x10) {
uint8_t sig[] = "_SM_";
int i;
for (i = 0; i < sizeof sig - 1; ++i) {
sig[i] = readb(off + i);
... |
devign_test_set_data_21385 | static void mov_update_dts_shift(MOVStreamContext *sc, int duration)
{
if (duration < 0) {
sc->dts_shift = FFMAX(sc->dts_shift, -duration);
The vulnerability label is: Vulnerable |
devign_test_set_data_21386 | static void fft_calc_c(FFTContext *s, FFTComplex *z) {
int nbits, i, n, num_transforms, offset, step;
int n4, n2, n34;
FFTSample tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7, tmp8;
FFTComplex *tmpz;
const int fft_size = (1 << s->nbits);
int64_t accu;
num_transforms = (0x2aab >> (16 - ... |
devign_test_set_data_21387 | int cpu_ppc_handle_mmu_fault(CPUPPCState *env, target_ulong address, int rw,
int mmu_idx)
{
mmu_ctx_t ctx;
int access_type;
int ret = 0;
if (rw == 2) {
/* code access */
rw = 0;
access_type = ACCESS_CODE;
} else {
/* data acce... |
devign_test_set_data_21392 | void qemu_spice_display_init(DisplayState *ds)
{
assert(sdpy.ds == NULL);
qemu_spice_display_init_common(&sdpy, ds);
register_displaychangelistener(ds, &display_listener);
sdpy.qxl.base.sif = &dpy_interface.base;
qemu_spice_add_interface(&sdpy.qxl.base);
assert(sdpy.worker);
qemu... |
devign_test_set_data_21411 | static int qcow2_is_allocated(BlockDriverState *bs, int64_t sector_num,
int nb_sectors, int *pnum)
{
uint64_t cluster_offset;
int ret;
*pnum = nb_sectors;
/* FIXME We can get errors here, but the bdrv_is_allocated interface can't
* pass them on today */
r... |
devign_test_set_data_21413 | static void migrate_params_test_apply(MigrateSetParameters *params,
MigrationParameters *dest)
{
*dest = migrate_get_current()->parameters;
/* TODO use QAPI_CLONE() instead of duplicating it inline */
if (params->has_compress_level) {
dest->compress_le... |
devign_test_set_data_21427 | void cpu_state_reset(CPUMIPSState *env)
{
if (qemu_loglevel_mask(CPU_LOG_RESET)) {
qemu_log("CPU Reset (CPU %d)\n", env->cpu_index);
log_cpu_state(env, 0);
}
memset(env, 0, offsetof(CPUMIPSState, breakpoints));
tlb_flush(env, 1);
/* Reset registers to their default values... |
devign_test_set_data_21430 | bool bdrv_op_is_blocked(BlockDriverState *bs, BlockOpType op, Error **errp)
{
BdrvOpBlocker *blocker;
assert((int) op >= 0 && op < BLOCK_OP_TYPE_MAX);
if (!QLIST_EMPTY(&bs->op_blockers[op])) {
blocker = QLIST_FIRST(&bs->op_blockers[op]);
if (errp) {
*errp = error_copy(bloc... |
devign_test_set_data_21435 | static BlockJob *find_block_job(const char *device, AioContext **aio_context,
Error **errp)
{
BlockBackend *blk;
BlockDriverState *bs;
*aio_context = NULL;
blk = blk_by_name(device);
if (!blk) {
goto notfound;
}
*aio_context = blk_get_a... |
devign_test_set_data_21450 | static int bt_hci_parse(const char *str)
{
struct HCIInfo *hci;
bdaddr_t bdaddr;
if (nb_hcis >= MAX_NICS) {
fprintf(stderr, "qemu: Too many bluetooth HCIs (max %i).\n", MAX_NICS);
return -1;
}
hci = hci_init(str);
if (!hci)
return -1;
bdaddr.b[0] = 0x... |
devign_test_set_data_21459 | static int cris_mmu_translate_page(struct cris_mmu_result *res,
CPUState *env, uint32_t vaddr,
int rw, int usermode, int debug)
{
unsigned int vpage;
unsigned int idx;
uint32_t pid, lo, hi;
uint32_t tlb_vpn, tlb_pfn = 0;
int tlb_pid, tlb_g, tlb_v, tlb_k, tlb_w, tlb_x;
int cfg_v, cfg_k, cfg_... |
devign_test_set_data_21466 | static void gen_dst(DisasContext *ctx)
{
if (rA(ctx->opcode) == 0) {
gen_inval_exception(ctx, POWERPC_EXCP_INVAL_LSWX);
} else {
/* interpreted as no-op */
}
}
The vulnerability label is: Vulnerable |
devign_test_set_data_21473 | static void x86_cpu_enable_xsave_components(X86CPU *cpu)
{
CPUX86State *env = &cpu->env;
int i;
if (!(env->features[FEAT_1_ECX] & CPUID_EXT_XSAVE)) {
return;
}
env->xsave_components = (XSTATE_FP_MASK | XSTATE_SSE_MASK);
for (i = 2; i < ARRAY_SIZE(x86_ext_save_areas); i++) {
... |
devign_test_set_data_21487 | int mmu_translate_real(CPUS390XState *env, target_ulong raddr, int rw,
target_ulong *addr, int *flags)
{
/* TODO: low address protection once we flush the tlb on cr changes */
*flags = PAGE_READ | PAGE_WRITE;
*addr = mmu_real2abs(env, raddr);
/* TODO: storage key handling ... |
devign_test_set_data_21492 | static void nic_selective_reset(EEPRO100State * s)
{
size_t i;
uint16_t *eeprom_contents = eeprom93xx_data(s->eeprom);
//~ eeprom93xx_reset(s->eeprom);
memcpy(eeprom_contents, s->conf.macaddr.a, 6);
eeprom_contents[0xa] = 0x4000;
if (s->device == i82557B || s->device == i82557C)
... |
devign_test_set_data_21508 | void pci_bridge_reset_reg(PCIDevice *dev)
{
uint8_t *conf = dev->config;
conf[PCI_PRIMARY_BUS] = 0;
conf[PCI_SECONDARY_BUS] = 0;
conf[PCI_SUBORDINATE_BUS] = 0;
conf[PCI_SEC_LATENCY_TIMER] = 0;
conf[PCI_IO_BASE] = 0;
conf[PCI_IO_LIMIT] = 0;
pci_set_word(conf + PCI_MEMORY_BASE... |
devign_test_set_data_21511 | static int kvm_client_sync_dirty_bitmap(struct CPUPhysMemoryClient *client,
target_phys_addr_t start_addr,
target_phys_addr_t end_addr)
{
return kvm_physical_sync_dirty_bitmap(start_addr, end_addr);
}
The vulnerability label is: ... |
devign_test_set_data_21513 | static uint32_t bonito_readl(void *opaque, target_phys_addr_t addr)
{
PCIBonitoState *s = opaque;
uint32_t saddr;
saddr = (addr - BONITO_REGBASE) >> 2;
DPRINTF("bonito_readl "TARGET_FMT_plx" \n", addr);
switch (saddr) {
case BONITO_INTISR:
return s->regs[saddr];
default... |
devign_test_set_data_21538 | struct omap_mpu_state_s *omap310_mpu_init(MemoryRegion *system_memory,
unsigned long sdram_size,
const char *core)
{
int i;
struct omap_mpu_state_s *s = (struct omap_mpu_state_s *)
g_malloc0(sizeof(struct omap_mpu_state_s));
qemu_irq dma_irqs[6];
Drive... |
devign_test_set_data_21549 | void nbd_client_close(NBDClient *client)
{
if (client->closing) {
return;
}
client->closing = true;
/* Force requests to finish. They will drop their own references,
* then we'll close the socket and free the NBDClient.
*/
shutdown(client->sock, 2);
/* Also tel... |
devign_test_set_data_21567 | static bool find_dirty_block(RAMState *rs, PageSearchStatus *pss,
bool *again, ram_addr_t *ram_addr_abs)
{
pss->offset = migration_bitmap_find_dirty(rs, pss->block, pss->offset,
ram_addr_abs);
if (pss->complete_round && pss->block =... |
devign_test_set_data_21569 | void OPPROTO op_POWER_doz (void)
{
if (Ts1 > Ts0)
T0 = T1 - T0;
else
T0 = 0;
RETURN();
}
The vulnerability label is: Vulnerable |
devign_test_set_data_21576 | int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)
{
Wmv2Context *const w = (Wmv2Context *) s;
if (s->pict_type == AV_PICTURE_TYPE_I) {
if (w->j_type_bit)
w->j_type = get_bits1(&s->gb);
else
w->j_type = 0; // FIXME check
if (!w->j_type) {
... |
devign_test_set_data_21583 | static void fill_table(uint8_t* table[256 + 2*YUVRGB_TABLE_HEADROOM], const int elemsize,
const int inc, void *y_tab)
{
int i;
uint8_t *y_table = y_tab;
y_table -= elemsize * (inc >> 9);
for (i = 0; i < 256 + 2*YUVRGB_TABLE_HEADROOM; i++) {
int64_t cb = av_clip(... |
devign_test_set_data_21584 | static int allocate_buffers(ALACContext *alac)
{
int ch;
for (ch = 0; ch < FFMIN(alac->channels, 2); ch++) {
int buf_size = alac->max_samples_per_frame * sizeof(int32_t);
FF_ALLOC_OR_GOTO(alac->avctx, alac->predict_error_buffer[ch],
buf_size, buf_alloc_fail);
... |
devign_test_set_data_21585 | static int put_cod(Jpeg2000EncoderContext *s)
{
Jpeg2000CodingStyle *codsty = &s->codsty;
if (s->buf_end - s->buf < 14)
return -1;
bytestream_put_be16(&s->buf, JPEG2000_COD);
bytestream_put_be16(&s->buf, 12); // Lcod
bytestream_put_byte(&s->buf, 0); // Scod
// SGcod
byt... |
devign_test_set_data_21612 | bool memory_region_test_and_clear_dirty(MemoryRegion *mr, hwaddr addr,
hwaddr size, unsigned client)
{
assert(mr->terminates);
return cpu_physical_memory_test_and_clear_dirty(mr->ram_addr + addr,
size, client);
}
... |
devign_test_set_data_21622 | static int bdrv_get_cluster_size(BlockDriverState *bs)
{
BlockDriverInfo bdi;
int ret;
ret = bdrv_get_info(bs, &bdi);
if (ret < 0 || bdi.cluster_size == 0) {
return bs->request_alignment;
} else {
return bdi.cluster_size;
}
}
The vulnerability label is: Non-vulnerab... |
devign_test_set_data_21641 | static int libschroedinger_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *frame, int *got_packet)
{
int enc_size = 0;
SchroEncoderParams *p_schro_params = avctx->priv_data;
SchroEncoder *encoder = p_schro_params->encoder;
struct FFSchroEnc... |
devign_test_set_data_21665 | static int fill_default_ref_list(H264Context *h){
MpegEncContext * const s = &h->s;
int i;
int smallest_poc_greater_than_current = -1;
int structure_sel;
Picture sorted_short_ref[32];
Picture field_entry_list[2][32];
Picture *frame_list[2];
if (FIELD_PICTURE) {
structu... |
devign_test_set_data_21670 | void qemu_savevm_state_complete(QEMUFile *f)
{
QJSON *vmdesc;
int vmdesc_len;
SaveStateEntry *se;
int ret;
trace_savevm_state_complete();
cpu_synchronize_all_states();
QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
if (!se->ops || !se->ops->save_live_complete) {
... |
devign_test_set_data_21694 | static void mvp_init (CPUMIPSState *env, const mips_def_t *def)
{
env->mvp = g_malloc0(sizeof(CPUMIPSMVPContext));
/* MVPConf1 implemented, TLB sharable, no gating storage support,
programmable cache partitioning implemented, number of allocatable
and sharable TLB entries, MVP has allocatab... |
devign_test_set_data_21708 | static int decode_band(IVI45DecContext *ctx, int plane_num,
IVIBandDesc *band, AVCodecContext *avctx)
{
int result, i, t, idx1, idx2, pos;
IVITile *tile;
band->buf = band->bufs[ctx->dst_buf];
if (!band->buf) {
av_log(avctx, AV_LOG_ERROR, "Band buff... |
devign_test_set_data_21723 | static int s390_virtio_device_init(VirtIOS390Device *dev, VirtIODevice *vdev)
{
VirtIOS390Bus *bus;
int dev_len;
bus = DO_UPCAST(VirtIOS390Bus, bus, dev->qdev.parent_bus);
dev->vdev = vdev;
dev->dev_offs = bus->dev_offs;
dev->feat_len = sizeof(uint32_t); /* always keep 32 bits features ... |
devign_test_set_data_21731 | RAMBlock *qemu_ram_alloc_internal(ram_addr_t size, ram_addr_t max_size,
void (*resized)(const char*,
uint64_t length,
void *host),
void *host, bool ... |
devign_test_set_data_21739 | static inline void tcg_out_movi(TCGContext *s, TCGType type,
int ret, tcg_target_long arg)
{
#if defined(__sparc_v9__) && !defined(__sparc_v8plus__)
if (arg != (arg & 0xffffffff))
fprintf(stderr, "unimplemented %s with constant %ld\n", __func__, arg);
#endif
if (ar... |
devign_test_set_data_21740 | qcrypto_block_luks_create(QCryptoBlock *block,
QCryptoBlockCreateOptions *options,
QCryptoBlockInitFunc initfunc,
QCryptoBlockWriteFunc writefunc,
void *opaque,
Error **errp)
{
QC... |
devign_test_set_data_21750 | static int swf_write_trailer(AVFormatContext *s)
{
SWFContext *swf = s->priv_data;
ByteIOContext *pb = &s->pb;
AVCodecContext *enc, *video_enc;
int file_size, i;
video_enc = NULL;
for(i=0;i<s->nb_streams;i++) {
enc = &s->streams[i]->codec;
if (enc->codec_type == CODEC_... |
devign_test_set_data_21762 | static int xpm_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame, AVPacket *avpkt)
{
XPMDecContext *x = avctx->priv_data;
AVFrame *p=data;
const uint8_t *end, *ptr = avpkt->data;
int ncolors, cpp, ret, i, j;
int64_t size;
uint32_t *dst;
avc... |
devign_test_set_data_21766 | static void ripemd160_transform(uint32_t *state, const uint8_t buffer[64], int ext)
{
uint32_t a, b, c, d, e, f, g, h, i, j;
uint32_t block[16];
int n;
if (ext) {
a = state[0]; b = state[1]; c = state[2]; d = state[3]; e = state[4];
f = state[5]; g = state[6]; h = state[7]; i = ... |
devign_test_set_data_21767 | static void opt_frame_size(const char *arg)
{
if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
fprintf(stderr, "Incorrect frame size\n");
av_exit(1);
}
if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
fprintf(stderr, "Frame size must be a multiple... |
devign_test_set_data_21776 | static int sdl_write_trailer(AVFormatContext *s)
{
SDLContext *sdl = s->priv_data;
sdl->quit = 1;
if (sdl->overlay)
SDL_FreeYUVOverlay(sdl->overlay);
if (sdl->event_thread)
SDL_WaitThread(sdl->event_thread, NULL);
if (sdl->mutex)
SDL_DestroyMutex(sdl->mutex);
... |
devign_test_set_data_21779 | void MPV_decode_mb(MpegEncContext *s, DCTELEM block[6][64])
{
int mb_x, mb_y;
int dct_linesize, dct_offset;
op_pixels_func *op_pix;
qpel_mc_func *op_qpix;
mb_x = s->mb_x;
mb_y = s->mb_y;
#ifdef FF_POSTPROCESS
quant_store[mb_y][mb_x]=s->qscale;
//printf("[%02d][%02d] %d\n",m... |
devign_test_set_data_21794 | static void kvm_hwpoison_page_add(ram_addr_t ram_addr)
{
HWPoisonPage *page;
QLIST_FOREACH(page, &hwpoison_page_list, list) {
if (page->ram_addr == ram_addr) {
return;
}
}
page = g_malloc(sizeof(HWPoisonPage));
page->ram_addr = ram_addr;
QLIST_INSERT_HEAD(... |
devign_test_set_data_21796 | static int decode_i_picture_primary_header(VC9Context *v)
{
GetBitContext *gb = &v->s.gb;
int pqindex;
/* Prolog common to all frametypes should be done in caller */
//BF = Buffer Fullness
if (v->profile <= PROFILE_MAIN && get_bits(gb, 7))
{
av_log(v->s.avctx, AV_LOG_DEBUG, "I ... |
devign_test_set_data_21820 | static void pcie_mmcfg_data_write(PCIBus *s,
uint32_t mmcfg_addr, uint32_t val, int len)
{
PCIDevice *pci_dev = pcie_dev_find_by_mmcfg_addr(s, mmcfg_addr);
if (!pci_dev) {
return;
}
pci_host_config_write_common(pci_dev, PCIE_MMCFG_CONFOFFSET(mmcfg_addr)... |
devign_test_set_data_21822 | static int get_bits(Jpeg2000DecoderContext *s, int n)
{
int res = 0;
if (s->buf_end - s->buf < ((n - s->bit_index) >> 8))
return AVERROR_INVALIDDATA;
while (--n >= 0) {
res <<= 1;
if (s->bit_index == 0) {
s->bit_index = 7 + (*s->buf != 0xff);
s->buf++... |
devign_test_set_data_21828 | static int mov_read_udta_string(MOVContext *c, ByteIOContext *pb, MOVAtom atom)
{
char *str = NULL;
int size;
uint16_t str_size;
if (c->itunes_metadata) {
int data_size = get_be32(pb);
int tag = get_le32(pb);
if (tag == MKTAG('d','a','t','a')) {
get_be32(pb... |
devign_test_set_data_21836 | void aio_context_setup(AioContext *ctx, Error **errp)
{
#ifdef CONFIG_EPOLL
assert(!ctx->epollfd);
ctx->epollfd = epoll_create1(EPOLL_CLOEXEC);
if (ctx->epollfd == -1) {
ctx->epoll_available = false;
} else {
ctx->epoll_available = true;
}
#endif
}
The vulnerability labe... |
devign_test_set_data_21841 | static int dvbsub_display_end_segment(AVCodecContext *avctx, const uint8_t *buf,
int buf_size, AVSubtitle *sub)
{
DVBSubContext *ctx = avctx->priv_data;
DVBSubDisplayDefinition *display_def = ctx->display_definition;
DVBSubRegion *region;
DVBSubRegionDispl... |
devign_test_set_data_21851 | static QUANT_FN(pvq_encode_band)
{
return quant_band_template(pvq, f, rc, band, X, Y, N, b, blocks, lowband, duration,
lowband_out, level, gain, lowband_scratch, fill, 1);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_21863 | static void kvm_set_phys_mem(target_phys_addr_t start_addr,
ram_addr_t size,
ram_addr_t phys_offset)
{
KVMState *s = kvm_state;
ram_addr_t flags = phys_offset & ~TARGET_PAGE_MASK;
KVMSlot *mem, old;
int err;
/* kvm works in page size chunks, but the function may be called
... |
devign_test_set_data_21889 | static void master_abort_mem_write(void *opaque, hwaddr addr, uint64_t val,
unsigned size)
{
}
The vulnerability label is: Vulnerable |
devign_test_set_data_21899 | void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height){
int w_align= 1;
int h_align= 1;
switch(s->pix_fmt){
case PIX_FMT_YUV420P:
case PIX_FMT_YUYV422:
case PIX_FMT_UYVY422:
case PIX_FMT_YUV422P:
case PIX_FMT_YUV444P:
case PIX_FMT_GRAY8:
case PIX_FM... |
devign_test_set_data_21919 | void ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size){
c->bytestream_start=
c->bytestream= buf;
c->bytestream_end= buf + buf_size;
#if CABAC_BITS == 16
c->low = (*c->bytestream++)<<18;
c->low+= (*c->bytestream++)<<10;
#else
c->low = (*c->bytestream++)<<10;
#... |
devign_test_set_data_21925 | static int hls_read_header(AVFormatContext *s)
{
void *u = (s->flags & AVFMT_FLAG_CUSTOM_IO) ? NULL : s->pb;
HLSContext *c = s->priv_data;
int ret = 0, i;
int highest_cur_seq_no = 0;
c->ctx = s;
c->interrupt_callback = &s->interrupt_callback;
c->strict_std_compliance... |
devign_test_set_data_21938 | AVBitStreamFilterContext *av_bitstream_filter_init(const char *name)
{
AVBitStreamFilter *bsf = first_bitstream_filter;
while (bsf) {
if (!strcmp(name, bsf->name)) {
AVBitStreamFilterContext *bsfc =
av_mallocz(sizeof(AVBitStreamFilterContext));
bsfc->filt... |
devign_test_set_data_21957 | PPC_OP(divw)
{
if ((Ts0 == INT32_MIN && Ts1 == -1) || Ts1 == 0) {
T0 = (int32_t)((-1) * (T0 >> 31));
} else {
T0 = (Ts0 / Ts1);
}
RETURN();
}
The vulnerability label is: Vulnerable |
devign_test_set_data_21958 | BlockInterfaceErrorAction drive_get_onerror(BlockDriverState *bdrv)
{
int index;
for (index = 0; index < nb_drives; index++)
if (drives_table[index].bdrv == bdrv)
return drives_table[index].onerror;
return BLOCK_ERR_REPORT;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_21962 | static void netfilter_finalize(Object *obj)
{
NetFilterState *nf = NETFILTER(obj);
NetFilterClass *nfc = NETFILTER_GET_CLASS(obj);
if (nfc->cleanup) {
nfc->cleanup(nf);
}
if (nf->netdev && !QTAILQ_EMPTY(&nf->netdev->filters)) {
QTAILQ_REMOVE(&nf->netdev->filters, nf, next... |
devign_test_set_data_21967 | static void pc_compat_1_4(QEMUMachineInitArgs *args)
{
pc_compat_1_5(args);
has_pvpanic = false;
x86_cpu_compat_set_features("n270", FEAT_1_ECX, 0, CPUID_EXT_MOVBE);
x86_cpu_compat_set_features("Westmere", FEAT_1_ECX, 0, CPUID_EXT_PCLMULQDQ);
}
The vulnerability label is: Vulnerable |
devign_test_set_data_21969 | static void amdvi_realize(DeviceState *dev, Error **err)
{
int ret = 0;
AMDVIState *s = AMD_IOMMU_DEVICE(dev);
X86IOMMUState *x86_iommu = X86_IOMMU_DEVICE(dev);
PCIBus *bus = PC_MACHINE(qdev_get_machine())->bus;
s->iotlb = g_hash_table_new_full(amdvi_uint64_hash,
... |
devign_test_set_data_21971 | int avio_close_dyn_buf(AVIOContext *s, uint8_t **pbuffer)
{
DynBuffer *d = s->opaque;
int size;
static const char padbuf[FF_INPUT_BUFFER_PADDING_SIZE] = {0};
int padding = 0;
if (!s) {
*pbuffer = NULL;
return 0;
}
/* don't attempt to pad fixed-size packet buffer... |
devign_test_set_data_21995 | static void qemu_net_queue_append(NetQueue *queue,
NetClientState *sender,
unsigned flags,
const uint8_t *buf,
size_t size,
NetPacketSent *sent_c... |
devign_test_set_data_22003 | static void decode_subframe_lpc(ShortenContext *s, int channel, int residual_size, int pred_order)
{
int sum, i, j;
int coeffs[pred_order];
for (i=0; i<pred_order; i++)
coeffs[i] = get_sr_golomb_shorten(&s->gb, LPCQUANT);
for (i=0; i < s->blocksize; i++) {
sum = s->lpcqoffset;... |
devign_test_set_data_22006 | bool timerlist_expired(QEMUTimerList *timer_list)
{
int64_t expire_time;
if (!atomic_read(&timer_list->active_timers)) {
return false;
}
qemu_mutex_lock(&timer_list->active_timers_lock);
if (!timer_list->active_timers) {
qemu_mutex_unlock(&timer_list->active_timers_lock);... |
devign_test_set_data_22009 | static int pxr24_uncompress(EXRContext *s, const uint8_t *src,
int compressed_size, int uncompressed_size,
EXRThreadData *td)
{
unsigned long dest_len, expected_len = 0;
const uint8_t *in = td->tmp;
uint8_t *out;
int c, i, j;
for (i =... |
devign_test_set_data_22013 | static int mov_read_default(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
int64_t total_size = 0;
MOVAtom a;
int i;
if (atom.size < 0)
atom.size = INT64_MAX;
while (total_size + 8 <= atom.size && !avio_feof(pb)) {
int (*parse)(MOVContext*, AVIOContext*, MOVAtom) = NULL;
... |
devign_test_set_data_22016 | static int ahci_populate_sglist(AHCIDevice *ad, QEMUSGList *sglist,
AHCICmdHdr *cmd, int64_t limit, int32_t offset)
{
uint16_t opts = le16_to_cpu(cmd->opts);
uint16_t prdtl = le16_to_cpu(cmd->prdtl);
uint64_t cfis_addr = le64_to_cpu(cmd->tbl_addr);
uint64_t prdt_add... |
devign_test_set_data_22034 | static void dwt_encode97_int(DWTContext *s, int *t)
{
int lev,
w = s->linelen[s->ndeclevels-1][0];
int *line = s->i_linebuf;
line += 5;
for (lev = s->ndeclevels-1; lev >= 0; lev--){
int lh = s->linelen[lev][0],
lv = s->linelen[lev][1],
mh = s->mod[lev][... |
devign_test_set_data_22037 | static void decode_postinit(H264Context *h){
MpegEncContext * const s = &h->s;
Picture *out = s->current_picture_ptr;
Picture *cur = s->current_picture_ptr;
int i, pics, out_of_order, out_idx;
s->current_picture_ptr->qscale_type= FF_QSCALE_TYPE_H264;
s->current_picture_ptr->pict_type= s-... |
devign_test_set_data_22047 | void error_propagate(Error **dst_errp, Error *local_err)
{
if (local_err && dst_errp == &error_abort) {
error_report_err(local_err);
abort();
} else if (dst_errp && !*dst_errp) {
*dst_errp = local_err;
} else if (local_err) {
error_free(local_err);
}
}
The vul... |
devign_test_set_data_22058 | gen_msub32_q(TCGv ret, TCGv arg1, TCGv arg2, TCGv arg3, uint32_t n,
uint32_t up_shift, CPUTriCoreState *env)
{
TCGv temp = tcg_temp_new();
TCGv temp2 = tcg_temp_new();
TCGv temp3 = tcg_temp_new();
TCGv_i64 t1 = tcg_temp_new_i64();
TCGv_i64 t2 = tcg_temp_new_i64();
TCGv_i64 t... |
devign_test_set_data_22065 | int32 float64_to_int32_round_to_zero( float64 a STATUS_PARAM )
{
flag aSign;
int16 aExp, shiftCount;
uint64_t aSig, savedASig;
int32 z;
a = float64_squash_input_denormal(a STATUS_VAR);
aSig = extractFloat64Frac( a );
aExp = extractFloat64Exp( a );
aSign = extractFloat64Sign( a... |
devign_test_set_data_22082 | BlockReopenQueue *bdrv_reopen_queue(BlockReopenQueue *bs_queue,
BlockDriverState *bs, int flags)
{
assert(bs != NULL);
BlockReopenQueueEntry *bs_entry;
if (bs_queue == NULL) {
bs_queue = g_new0(BlockReopenQueue, 1);
QSIMPLEQ_INIT(bs_queue);
}... |
devign_test_set_data_22086 | static void format_line(void *ptr, int level, const char *fmt, va_list vl,
AVBPrint part[3], int *print_prefix, int type[2])
{
AVClass* avc = ptr ? *(AVClass **) ptr : NULL;
av_bprint_init(part+0, 0, 1);
av_bprint_init(part+1, 0, 1);
av_bprint_init(part+2, 0, 65536);
... |
devign_test_set_data_22089 | static int dnxhd_init_vlc(DNXHDContext *ctx, uint32_t cid)
{
if (cid != ctx->cid) {
int index;
if ((index = ff_dnxhd_get_cid_table(cid)) < 0) {
av_log(ctx->avctx, AV_LOG_ERROR, "unsupported cid %d\n", cid);
return AVERROR(ENOSYS);
}
if (ff_dnxhd_cid_... |
devign_test_set_data_22093 | static void check_default_settings(AVCodecContext *avctx)
{
X264Context *x4 = avctx->priv_data;
int score = 0;
score += x4->params.analyse.i_me_range == 0;
score += x4->params.rc.i_qp_step == 3;
score += x4->params.i_keyint_max == 12;
score += x4->params.rc.i_qp_min == 2;
score += ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.