id stringlengths 22 26 | content stringlengths 72 142k |
|---|---|
devign_test_set_data_2142 | static inline int *DEC_UQUAD(int *dst, unsigned idx, unsigned sign)
{
unsigned nz = idx >> 12;
dst[0] = (idx & 3) * (1 + (((int)sign >> 31) << 1));
sign <<= nz & 1;
nz >>= 1;
dst[1] = (idx >> 2 & 3) * (1 + (((int)sign >> 31) << 1));
sign <<= nz & 1;
nz >>= 1;
dst[2] = (idx >> ... |
devign_test_set_data_2148 | void hmp_info_block_jobs(Monitor *mon, const QDict *qdict)
{
BlockJobInfoList *list;
Error *err = NULL;
list = qmp_query_block_jobs(&err);
assert(!err);
if (!list) {
monitor_printf(mon, "No active jobs\n");
return;
}
while (list) {
if (strcmp(list->value->type, "strea... |
devign_test_set_data_2157 | static int atrim_filter_frame(AVFilterLink *inlink, AVFrame *frame)
{
AVFilterContext *ctx = inlink->dst;
TrimContext *s = ctx->priv;
int64_t start_sample, end_sample = frame->nb_samples;
int64_t pts;
int drop;
/* drop everything if EOF has already been returned */
if (s->eof... |
devign_test_set_data_2182 | static void tcg_reg_alloc_call(TCGContext *s, int nb_oargs, int nb_iargs,
const TCGArg * const args, uint16_t dead_args,
uint8_t sync_args)
{
int flags, nb_regs, i;
TCGReg reg;
TCGArg arg;
TCGTemp *ts;
intptr_t stack_offset;
... |
devign_test_set_data_2187 | static void curl_multi_do(void *arg)
{
BDRVCURLState *s = (BDRVCURLState *)arg;
int running;
int r;
if (!s->multi) {
return;
}
do {
r = curl_multi_socket_all(s->multi, &running);
} while(r == CURLM_CALL_MULTI_PERFORM);
curl_multi_read(s);
}
The vulnera... |
devign_test_set_data_2188 | static int ffserver_save_avoption(const char *opt, const char *arg, int type, FFServerConfig *config)
{
static int hinted = 0;
int ret = 0;
AVDictionaryEntry *e;
const AVOption *o = NULL;
const char *option = NULL;
const char *codec_name = NULL;
char buff[1024];
AVCodecContext *... |
devign_test_set_data_2190 | static int decode_opc(MoxieCPU *cpu, DisasContext *ctx)
{
CPUMoxieState *env = &cpu->env;
/* Local cache for the instruction opcode. */
int opcode;
/* Set the default instruction length. */
int length = 2;
if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP | CPU_LOG_TB_OP_OPT))) {
... |
devign_test_set_data_2195 | static void tcg_out_opc(TCGContext *s, int opc, int r, int rm, int x)
{
int rex;
if (opc & P_GS) {
tcg_out8(s, 0x65);
}
if (opc & P_DATA16) {
/* We should never be asking for both 16 and 64-bit operation. */
assert((opc & P_REXW) == 0);
tcg_out8(s, 0x66);
... |
devign_test_set_data_2213 | qcow2_co_pwritev_compressed(BlockDriverState *bs, uint64_t offset,
uint64_t bytes, QEMUIOVector *qiov)
{
BDRVQcow2State *s = bs->opaque;
QEMUIOVector hd_qiov;
struct iovec iov;
z_stream strm;
int ret, out_len;
uint8_t *buf, *out_buf;
uint64_t cluster_offs... |
devign_test_set_data_2229 | static void gen_mfrom(DisasContext *ctx)
{
#if defined(CONFIG_USER_ONLY)
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
#else
if (unlikely(ctx->pr)) {
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
return;
}
gen_helper_602_mfrom(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rA(ctx->opco... |
devign_test_set_data_2246 | static inline void RENAME(yuv422ptouyvy)(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)
{
RENAME(yuvPlanartouyvy)(ysrc, usrc,... |
devign_test_set_data_2265 | static gboolean ga_channel_open(GAChannel *c, const gchar *path,
GAChannelMethod method, int fd)
{
int ret;
c->method = method;
switch (c->method) {
case GA_CHANNEL_VIRTIO_SERIAL: {
assert(fd < 0);
fd = qemu_open(path, O_RDWR | O_NONBLOCK
#ifnde... |
devign_test_set_data_2280 | static int ram_save_block(QEMUFile *f)
{
RAMBlock *block = last_block;
ram_addr_t offset = last_offset;
int bytes_sent = -1;
MemoryRegion *mr;
if (!block)
block = QLIST_FIRST(&ram_list.blocks);
do {
mr = block->mr;
if (memory_region_get_dirty(mr, offset, TAR... |
devign_test_set_data_2297 | bool net_tx_pkt_add_raw_fragment(struct NetTxPkt *pkt, hwaddr pa,
size_t len)
{
hwaddr mapped_len = 0;
struct iovec *ventry;
assert(pkt);
assert(pkt->max_raw_frags > pkt->raw_frags);
if (!len) {
return true;
}
ventry = &pkt->raw[pkt->raw_frags];
mapped_len = l... |
devign_test_set_data_2298 | yuv2422_2_c_template(SwsContext *c, const uint16_t *buf0,
const uint16_t *buf1, const uint16_t *ubuf0,
const uint16_t *ubuf1, const uint16_t *vbuf0,
const uint16_t *vbuf1, const uint16_t *abuf0,
const uint16_t *abuf1, uint8_t *dest,... |
devign_test_set_data_2300 | static av_always_inline void emulated_edge_mc(uint8_t *buf, const uint8_t *src,
int linesize,
int block_w, int block_h,
int src_x, int src_y,
... |
devign_test_set_data_2325 | static av_cold int init_bundles(BinkContext *c)
{
int bw, bh, blocks;
int i;
bw = (c->avctx->width + 7) >> 3;
bh = (c->avctx->height + 7) >> 3;
blocks = bw * bh;
for (i = 0; i < BINKB_NB_SRC; i++) {
c->bundle[i].data = av_malloc(blocks * 64);
if (!c->bundle[i].data)... |
devign_test_set_data_2328 | static void quorum_vote(QuorumAIOCB *acb)
{
bool quorum = true;
int i, j, ret;
QuorumVoteValue hash;
BDRVQuorumState *s = acb->common.bs->opaque;
QuorumVoteVersion *winner;
if (quorum_has_too_much_io_failed(acb)) {
return;
}
/* get the index of the first successful ... |
devign_test_set_data_2329 | static void stellaris_init(const char *kernel_filename, const char *cpu_model,
stellaris_board_info *board)
{
static const int uart_irq[] = {5, 6, 33, 34};
static const int timer_irq[] = {19, 21, 23, 35};
static const uint32_t gpio_addr[7] =
{ 0x40004000, 0x40005000, 0... |
devign_test_set_data_2334 | void cpu_exec_init(CPUState *env)
{
CPUState **penv;
int cpu_index;
if (!code_gen_ptr) {
code_gen_ptr = code_gen_buffer;
page_init();
io_mem_init();
}
env->next_cpu = NULL;
penv = &first_cpu;
cpu_index = 0;
while (*penv != NULL) {
penv = (CP... |
devign_test_set_data_2348 | static inline void RENAME(yuv422ptoyuy2)(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)
{
RENAME(yuvPlanartoyuy2)(ysrc, usrc, vsrc, dst, width, height, lumStride, chromStride, dstStride, 1);
}
The vulnerab... |
devign_test_set_data_2349 | static inline bool handler_is_async(const mon_cmd_t *cmd)
{
return cmd->flags & MONITOR_CMD_ASYNC;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_2358 | static int vqa_decode_init(AVCodecContext *avctx)
{
VqaContext *s = (VqaContext *)avctx->priv_data;
unsigned char *vqa_header;
int i, j, codebook_index;;
s->avctx = avctx;
avctx->pix_fmt = PIX_FMT_PAL8;
avctx->has_b_frames = 0;
dsputil_init(&s->dsp, avctx);
/* make sure the ... |
devign_test_set_data_2365 | static int open_output_file(OptionsContext *o, const char *filename)
{
AVFormatContext *oc;
int i, j, err;
AVOutputFormat *file_oformat;
OutputFile *of;
OutputStream *ost;
InputStream *ist;
AVDictionary *unused_opts = NULL;
AVDictionaryEntry *e = NULL;
if (configure_comp... |
devign_test_set_data_2395 | static bool logic_imm_decode_wmask(uint64_t *result, unsigned int immn,
unsigned int imms, unsigned int immr)
{
uint64_t mask;
unsigned e, levels, s, r;
int len;
assert(immn < 2 && imms < 64 && immr < 64);
/* The bit patterns we create here are 64 bit pa... |
devign_test_set_data_2400 | static int add_candidate_ref(HEVCContext *s, RefPicList *list,
int poc, int ref_flag)
{
HEVCFrame *ref = find_ref_idx(s, poc);
if (ref == s->ref)
return AVERROR_INVALIDDATA;
if (!ref) {
ref = generate_missing_ref(s, poc);
if (!ref)
... |
devign_test_set_data_2415 | static inline void t_gen_mov_preg_TN(DisasContext *dc, int r, TCGv tn)
{
if (r < 0 || r > 15) {
fprintf(stderr, "wrong register write $p%d\n", r);
}
if (r == PR_BZ || r == PR_WZ || r == PR_DZ) {
return;
} else if (r == PR_SRS) {
tcg_gen_andi_tl(cpu_PR[r], tn, 3);
} e... |
devign_test_set_data_2424 | static int vorbis_parse_id_hdr(vorbis_context *vc){
GetBitContext *gb=&vc->gb;
uint_fast8_t bl0, bl1;
if ((get_bits(gb, 8)!='v') || (get_bits(gb, 8)!='o') ||
(get_bits(gb, 8)!='r') || (get_bits(gb, 8)!='b') ||
(get_bits(gb, 8)!='i') || (get_bits(gb, 8)!='s')) {
av_log(vc->avccontext,... |
devign_test_set_data_2429 | void ff_avg_h264_qpel4_mc31_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_hv_qrt_and_aver_dst_4x4_msa(src - 2,
src - (stride * 2) +
sizeof(uint8_t), stride, dst, stride);
}
... |
devign_test_set_data_2451 | static int net_vhost_user_init(NetClientState *peer, const char *device,
const char *name, CharDriverState *chr,
int queues)
{
NetClientState *nc;
VhostUserState *s;
int i;
for (i = 0; i < queues; i++) {
nc = qemu_new_net_cl... |
devign_test_set_data_2466 | static int flv_probe(AVProbeData *p)
{
const uint8_t *d;
if (p->buf_size < 6)
return 0;
d = p->buf;
if (d[0] == 'F' && d[1] == 'L' && d[2] == 'V' && d[3] < 5 && d[5]==0) {
return AVPROBE_SCORE_MAX;
}
return 0;
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_2471 | static void scsi_read_data(SCSIDevice *d, uint32_t tag)
{
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, d);
SCSIDiskReq *r;
r = scsi_find_request(s, tag);
if (!r) {
BADF("Bad read tag 0x%x\n", tag);
/* ??? This is the wrong error. */
scsi_command_complete(r, CHECK_... |
devign_test_set_data_2502 | static void opt_output_file(void *optctx, const char *filename)
{
OptionsContext *o = optctx;
AVFormatContext *oc;
int i, err;
AVOutputFormat *file_oformat;
OutputStream *ost;
InputStream *ist;
if (!strcmp(filename, "-"))
filename = "pipe:";
oc = avformat_alloc_con... |
devign_test_set_data_2523 | static int spawn_thread(void)
{
pthread_attr_t attr;
int ret;
cur_threads++;
idle_threads++;
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
ret = pthread_create(&thread_id, &attr, aio_thread, NULL);
pthread_attr_destroy(&attr);
... |
devign_test_set_data_2534 | static int read_gab2_sub(AVStream *st, AVPacket *pkt)
{
if (pkt->size >= 7 &&
!strcmp(pkt->data, "GAB2") && AV_RL16(pkt->data + 5) == 2) {
uint8_t desc[256];
int score = AVPROBE_SCORE_EXTENSION, ret;
AVIStream *ast = st->priv_data;
AVInputFormat *sub_demuxer;
... |
devign_test_set_data_2535 | bool machine_iommu(MachineState *machine)
{
return machine->iommu;
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_2538 | static int disas_cp15_insn(CPUState *env, DisasContext *s, uint32_t insn)
{
uint32_t rd;
TCGv tmp, tmp2;
/* M profile cores use memory mapped registers instead of cp15. */
if (arm_feature(env, ARM_FEATURE_M))
return 1;
if ((insn & (1 << 25)) == 0) {
if (insn & (1 << 20)) {
... |
devign_test_set_data_2564 | static CharDriverState *vc_init(const char *id, ChardevBackend *backend,
ChardevReturn *ret, Error **errp)
{
return vc_handler(backend->u.vc, errp);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_2583 | USBDevice *usb_host_device_open(const char *devname)
{
int fd = -1, ret;
USBHostDevice *dev = NULL;
struct usbdevfs_connectinfo ci;
char buf[1024];
int bus_num, addr;
char product_name[PRODUCT_NAME_SZ];
dev = qemu_mallocz(sizeof(USBHostDevice));
if (!dev)
goto fail;
... |
devign_test_set_data_2594 | uint64_t helper_frsp(CPUPPCState *env, uint64_t arg)
{
CPU_DoubleU farg;
float32 f32;
farg.ll = arg;
if (unlikely(float64_is_signaling_nan(farg.d))) {
/* sNaN square root */
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN);
}
f32 = float64_to_float32(farg.d, &env->... |
devign_test_set_data_2602 | int gen_new_label(void)
{
TCGContext *s = &tcg_ctx;
int idx;
TCGLabel *l;
if (s->nb_labels >= TCG_MAX_LABELS)
tcg_abort();
idx = s->nb_labels++;
l = &s->labels[idx];
l->has_value = 0;
l->u.first_reloc = NULL;
return idx;
}
The vulnerability label is: Non-vulne... |
devign_test_set_data_2604 | void bdrv_round_to_clusters(BlockDriverState *bs,
int64_t sector_num, int nb_sectors,
int64_t *cluster_sector_num,
int *cluster_nb_sectors)
{
BlockDriverInfo bdi;
if (bdrv_get_info(bs, &bdi) < 0 || bdi.cluster_size == 0)... |
devign_test_set_data_2620 | void tlb_reset_dirty(CPUState *cpu, ram_addr_t start1, ram_addr_t length)
{
CPUArchState *env;
int mmu_idx;
assert_cpu_is_self(cpu);
env = cpu->env_ptr;
for (mmu_idx = 0; mmu_idx < NB_MMU_MODES; mmu_idx++) {
unsigned int i;
for (i = 0; i < CPU_TLB_SIZE; i++) {
... |
devign_test_set_data_2622 | blkdebug_co_preadv(BlockDriverState *bs, uint64_t offset, uint64_t bytes,
QEMUIOVector *qiov, int flags)
{
BDRVBlkdebugState *s = bs->opaque;
BlkdebugRule *rule = NULL;
QSIMPLEQ_FOREACH(rule, &s->active_rules, active_next) {
uint64_t inject_offset = rule->options.inject.offset;
... |
devign_test_set_data_2624 | static int idreg_init1(SysBusDevice *dev)
{
IDRegState *s = MACIO_ID_REGISTER(dev);
memory_region_init_ram(&s->mem, OBJECT(s),
"sun4m.idreg", sizeof(idreg_data), &error_abort);
vmstate_register_ram_global(&s->mem);
memory_region_set_readonly(&s->mem, true);
sysbus... |
devign_test_set_data_2628 | static inline void tcg_out_ld_ptr(TCGContext *s, int ret,
tcg_target_long arg)
{
#if defined(__sparc_v9__) && !defined(__sparc_v8plus__)
if (arg != (arg & 0xffffffff))
fprintf(stderr, "unimplemented %s with offset %ld\n", __func__, arg);
if (arg != (arg & 0xfff))
... |
devign_test_set_data_2632 | int xen_config_dev_blk(DriveInfo *disk)
{
char fe[256], be[256];
int vdev = 202 * 256 + 16 * disk->unit;
int cdrom = disk->bdrv->type == BDRV_TYPE_CDROM;
const char *devtype = cdrom ? "cdrom" : "disk";
const char *mode = cdrom ? "r" : "w";
snprintf(disk->bdrv->device_name, sizeof... |
devign_test_set_data_2634 | static inline void gen_intermediate_code_internal(OpenRISCCPU *cpu,
TranslationBlock *tb,
int search_pc)
{
CPUState *cs = CPU(cpu);
struct DisasContext ctx, *dc = &ctx;
uint16_t *gen_opc_end;
uint3... |
devign_test_set_data_2649 | static void pci_ivshmem_realize(PCIDevice *dev, Error **errp)
{
IVShmemState *s = IVSHMEM(dev);
Error *err = NULL;
uint8_t *pci_conf;
uint8_t attr = PCI_BASE_ADDRESS_SPACE_MEMORY |
PCI_BASE_ADDRESS_MEM_PREFETCH;
if (!!s->server_chr + !!s->shmobj + !!s->hostmem != 1) {
error... |
devign_test_set_data_2656 | int print_insn_lm32(bfd_vma memaddr, struct disassemble_info *info)
{
fprintf_function fprintf_fn = info->fprintf_func;
void *stream = info->stream;
int rc;
uint8_t insn[4];
const Lm32OpcodeInfo *opc_info;
uint32_t op;
const char *args_fmt;
rc = info->read_memory_func(memaddr,... |
devign_test_set_data_2665 | static int get_coc(Jpeg2000DecoderContext *s, Jpeg2000CodingStyle *c,
uint8_t *properties)
{
int compno;
if (s->buf_end - s->buf < 2)
return AVERROR(EINVAL);
compno = bytestream_get_byte(&s->buf);
c += compno;
c->csty = bytestream_get_byte(&s->buf);
... |
devign_test_set_data_2673 | static void curses_setup(void)
{
int i, colour_default[8] = {
COLOR_BLACK, COLOR_BLUE, COLOR_GREEN, COLOR_CYAN,
COLOR_RED, COLOR_MAGENTA, COLOR_YELLOW, COLOR_WHITE,
};
/* input as raw as possible, let everything be interpreted
* by the guest system */
initscr(); noecho(); ... |
devign_test_set_data_2677 | static inline void RENAME(hyscale)(uint16_t *dst, int dstWidth, uint8_t *src, 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
... |
devign_test_set_data_2680 | static int get_uint16_equal(QEMUFile *f, void *pv, size_t size)
{
uint16_t *v = pv;
uint16_t v2;
qemu_get_be16s(f, &v2);
if (*v == v2) {
return 0;
}
return -EINVAL;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_2704 | static int h264_handle_packet(AVFormatContext *ctx, PayloadContext *data,
AVStream *st, AVPacket *pkt, uint32_t *timestamp,
const uint8_t *buf, int len, uint16_t seq,
int flags)
{
uint8_t nal;
uint8_t type;
int ... |
devign_test_set_data_2737 | void bdrv_refresh_filename(BlockDriverState *bs)
{
BlockDriver *drv = bs->drv;
QDict *opts;
if (!drv) {
return;
}
/* This BDS's file name will most probably depend on its file's name, so
* refresh that first */
if (bs->file) {
bdrv_refresh_filename(bs->file->bs... |
devign_test_set_data_2762 | static inline bool cpu_handle_exception(CPUState *cpu, int *ret)
{
if (cpu->exception_index >= 0) {
if (cpu->exception_index >= EXCP_INTERRUPT) {
/* exit request from the cpu execution loop */
*ret = cpu->exception_index;
if (*ret == EXCP_DEBUG) {
c... |
devign_test_set_data_2793 | void ff_dnxhdenc_init_x86(DNXHDEncContext *ctx)
{
#if HAVE_INLINE_ASM
if (av_get_cpu_flags() & AV_CPU_FLAG_SSE2) {
if (ctx->cid_table->bit_depth == 8)
ctx->get_pixels_8x4_sym = get_pixels_8x4_sym_sse2;
}
#endif /* HAVE_INLINE_ASM */
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_2806 | uint64_t helper_fdiv(CPUPPCState *env, uint64_t arg1, uint64_t arg2)
{
CPU_DoubleU farg1, farg2;
farg1.ll = arg1;
farg2.ll = arg2;
if (unlikely(float64_is_infinity(farg1.d) &&
float64_is_infinity(farg2.d))) {
/* Division of infinity by infinity */
farg1.ll = ... |
devign_test_set_data_2817 | static void test_io_channel_ipv4(bool async)
{
SocketAddress *listen_addr = g_new0(SocketAddress, 1);
SocketAddress *connect_addr = g_new0(SocketAddress, 1);
listen_addr->type = SOCKET_ADDRESS_KIND_INET;
listen_addr->u.inet = g_new0(InetSocketAddress, 1);
listen_addr->u.inet->host = g_strdup... |
devign_test_set_data_2818 | static void gen_loongson_multimedia(DisasContext *ctx, int rd, int rs, int rt)
{
const char *opn = "loongson_cp2";
uint32_t opc, shift_max;
TCGv_i64 t0, t1;
opc = MASK_LMI(ctx->opcode);
switch (opc) {
case OPC_ADD_CP2:
case OPC_SUB_CP2:
case OPC_DADD_CP2:
case OPC_DSUB_CP... |
devign_test_set_data_2820 | static void v9fs_stat(void *opaque)
{
int32_t fid;
V9fsStat v9stat;
ssize_t err = 0;
size_t offset = 7;
struct stat stbuf;
V9fsFidState *fidp;
V9fsPDU *pdu = opaque;
V9fsState *s = pdu->s;
pdu_unmarshal(pdu, offset, "d", &fid);
trace_v9fs_stat(pdu->tag, pdu->id, fid)... |
devign_test_set_data_2832 | uint64_t helper_addlv (uint64_t op1, uint64_t op2)
{
uint64_t tmp = op1;
op1 = (uint32_t)(op1 + op2);
if (unlikely((tmp ^ op2 ^ (-1UL)) & (tmp ^ op1) & (1UL << 31))) {
arith_excp(env, GETPC(), EXC_M_IOV, 0);
}
return op1;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_2846 | static int of_dpa_cmd_add_l2_flood(OfDpa *of_dpa, OfDpaGroup *group,
RockerTlv **group_tlvs)
{
OfDpaGroup *l2_group;
RockerTlv **tlvs;
int err;
int i;
if (!group_tlvs[ROCKER_TLV_OF_DPA_GROUP_COUNT] ||
!group_tlvs[ROCKER_TLV_OF_DPA_GROUP_IDS]) {
... |
devign_test_set_data_2857 | int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
const uint64_t fuzz_tag = FUZZ_TAG;
FuzzDataBuffer buffer;
const uint8_t *last = data;
const uint8_t *end = data + size;
uint32_t it = 0;
if (!c)
c = AVCodecInitialize(FFMPEG_CODEC); // Done once.
AVCodecCont... |
devign_test_set_data_2880 | void op_cp1_64bitmode(void)
{
if (!(env->CP0_Status & (1 << CP0St_FR))) {
CALL_FROM_TB1(do_raise_exception, EXCP_RI);
}
RETURN();
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_2884 | void disas_a64_insn(CPUARMState *env, DisasContext *s)
{
uint32_t insn;
insn = arm_ldl_code(env, s->pc, s->bswap_code);
s->insn = insn;
s->pc += 4;
switch ((insn >> 24) & 0x1f) {
default:
unallocated_encoding(s);
break;
}
if (unlikely(s->singlestep_enable... |
devign_test_set_data_2895 | static inline void gen_op_mov_v_reg(int ot, TCGv t0, int reg)
{
switch(ot) {
case OT_BYTE:
if (reg < 4 X86_64_DEF( || reg >= 8 || x86_64_hregs)) {
goto std_case;
} else {
tcg_gen_shri_tl(t0, cpu_regs[reg - 4], 8);
tcg_gen_ext8u_tl(t0, t0);
}
... |
devign_test_set_data_2903 | static int hdev_open(BlockDriverState *bs, const char *filename, int flags)
{
BDRVRawState *s = bs->opaque;
int access_flags, create_flags;
DWORD overlapped;
char device_name[64];
if (strstart(filename, "/dev/cdrom", NULL)) {
if (find_cdrom(device_name, sizeof(device_name)) < 0)
... |
devign_test_set_data_2911 | static void sigp_store_adtl_status(CPUState *cs, run_on_cpu_data arg)
{
S390CPU *cpu = S390_CPU(cs);
SigpInfo *si = arg.host_ptr;
if (!s390_has_feat(S390_FEAT_VECTOR)) {
set_sigp_status(si, SIGP_STAT_INVALID_ORDER);
return;
}
/* cpu has to be stopped */
if (s390_cpu_... |
devign_test_set_data_2913 | static int cpu_gdb_write_register(CPUState *env, uint8_t *mem_buf, int n)
{
target_ulong tmp;
tmp = ldtul_p(mem_buf);
if (n < 32) {
env->active_tc.gpr[n] = tmp;
return sizeof(target_ulong);
}
if (env->CP0_Config1 & (1 << CP0C1_FP)
&& n >= 38 && n < 73) {
... |
devign_test_set_data_2914 | QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
{
QEMUBH *bh;
bh = g_malloc0(sizeof(QEMUBH));
bh->ctx = ctx;
bh->cb = cb;
bh->opaque = opaque;
qemu_mutex_lock(&ctx->bh_lock);
bh->next = ctx->first_bh;
/* Make sure that the members are ready before putting bh in... |
devign_test_set_data_2929 | static void audiogen(void *data, enum AVSampleFormat sample_fmt,
int channels, int sample_rate, int nb_samples)
{
int i, ch, k;
double v, f, a, ampa;
double tabf1[SWR_CH_MAX];
double tabf2[SWR_CH_MAX];
double taba[SWR_CH_MAX];
unsigned static rnd;
#define PUT_SAMP... |
devign_test_set_data_2946 | static void paint_mouse_pointer(AVFormatContext *s1, struct gdigrab *gdigrab)
{
CURSORINFO ci = {0};
#define CURSOR_ERROR(str) \
if (!gdigrab->cursor_error_printed) { \
WIN32_API_ERROR(str); \
gdigrab->cursor_error_printed = 1; \
}
ci.cb... |
devign_test_set_data_2950 | static void machine_initfn(Object *obj)
{
MachineState *ms = MACHINE(obj);
ms->kernel_irqchip_allowed = true;
ms->kvm_shadow_mem = -1;
ms->dump_guest_core = true;
object_property_add_str(obj, "accel",
machine_get_accel, machine_set_accel, NULL);
object_pr... |
devign_test_set_data_2958 | void bdrv_delete(BlockDriverState *bs)
{
assert(!bs->peer);
/* remove from list, if necessary */
if (bs->device_name[0] != '\0') {
QTAILQ_REMOVE(&bdrv_states, bs, list);
}
bdrv_close(bs);
if (bs->file != NULL) {
bdrv_delete(bs->file);
}
assert(bs != bs_sn... |
devign_test_set_data_2967 | static void hmp_migrate_status_cb(void *opaque)
{
MigrationStatus *status = opaque;
MigrationInfo *info;
info = qmp_query_migrate(NULL);
if (!info->has_status || strcmp(info->status, "active") == 0) {
if (info->has_disk) {
int progress;
if (info->disk->remaini... |
devign_test_set_data_2996 | int kvm_arch_on_sigbus(int code, void *addr)
{
#ifdef KVM_CAP_MCE
if ((first_cpu->mcg_cap & MCG_SER_P) && addr && code == BUS_MCEERR_AO) {
void *vaddr;
ram_addr_t ram_addr;
target_phys_addr_t paddr;
/* Hope we are lucky for AO MCE */
vaddr = addr;
if (qemu_... |
devign_test_set_data_3001 | coroutine_fn iscsi_co_pdiscard(BlockDriverState *bs, int64_t offset, int bytes)
{
IscsiLun *iscsilun = bs->opaque;
struct IscsiTask iTask;
struct unmap_list list;
int r = 0;
if (!is_byte_request_lun_aligned(offset, bytes, iscsilun)) {
return -ENOTSUP;
}
if (!iscsilun->lb... |
devign_test_set_data_3003 | int mips_cpu_handle_mmu_fault(CPUState *cs, vaddr address, int rw,
int mmu_idx)
{
MIPSCPU *cpu = MIPS_CPU(cs);
CPUMIPSState *env = &cpu->env;
#if !defined(CONFIG_USER_ONLY)
hwaddr physical;
int prot;
int access_type;
#endif
int ret = 0;
#if 0
log_c... |
devign_test_set_data_3020 | static ModuleTypeList *find_type(module_init_type type)
{
ModuleTypeList *l;
init_types();
l = &init_type_list[type];
return l;
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_3040 | static int qemu_suspend_requested(void)
{
int r = suspend_requested;
suspend_requested = 0;
return r;
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_3054 | int opt_cpuflags(const char *opt, const char *arg)
{
#define CPUFLAG_MMX2 (AV_CPU_FLAG_MMX | AV_CPU_FLAG_MMX2)
#define CPUFLAG_3DNOW (AV_CPU_FLAG_3DNOW | AV_CPU_FLAG_MMX)
#define CPUFLAG_3DNOWEXT (AV_CPU_FLAG_3DNOWEXT | CPUFLAG_3DNOW)
#define CPUFLAG_SSE (AV_CPU_FLAG_SSE | CPUFLAG_MMX2)
#... |
devign_test_set_data_3065 | void ff_put_h264_qpel8_mc21_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_midv_qrt_8w_msa(src - (2 * stride) - 2, stride, dst, stride, 8, 0);
}
The vulnerability label is: Non-vulnerable |
devign_test_set_data_3070 | static void serial_tx_done(void *opaque)
{
SerialState *s = opaque;
if (s->tx_burst < 0) {
uint16_t divider;
if (s->divider)
divider = s->divider;
else
divider = 1;
/* We assume 10 bits/char, OK for this purpose. */
s->tx_burst = THROTT... |
devign_test_set_data_3076 | void qemu_spice_create_host_primary(SimpleSpiceDisplay *ssd)
{
QXLDevSurfaceCreate surface;
memset(&surface, 0, sizeof(surface));
dprint(1, "%s/%d: %dx%d\n", __func__, ssd->qxl.id,
surface_width(ssd->ds), surface_height(ssd->ds));
surface.format = SPICE_SURFACE_FMT_32_xRGB;
... |
devign_test_set_data_3082 | static void init_proc_750fx (CPUPPCState *env)
{
gen_spr_ne_601(env);
gen_spr_7xx(env);
/* XXX : not implemented */
spr_register(env, SPR_L2CR, "L2CR",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, NULL,
0x00000000);
/* Time base */
g... |
devign_test_set_data_3098 | void st_print_trace_file_status(FILE *stream, int (*stream_printf)(FILE *stream, const char *fmt, ...))
{
stream_printf(stream, "Trace file \"%s\" %s.\n",
trace_file_name, trace_file_enabled ? "on" : "off");
}
The vulnerability label is: Vulnerable |
devign_test_set_data_3117 | static int mkv_write_header(AVFormatContext *s)
{
MatroskaMuxContext *mkv = s->priv_data;
AVIOContext *pb = s->pb;
ebml_master ebml_header;
AVDictionaryEntry *tag;
int ret, i, version = 2;
int64_t creation_time;
if (!strcmp(s->oformat->name, "webm"))
mkv->mode = MODE_WEBM;... |
devign_test_set_data_3130 | e1000_can_receive(void *opaque)
{
E1000State *s = opaque;
return (!(s->mac_reg[RCTL] & E1000_RCTL_EN) ||
s->mac_reg[RDH] != s->mac_reg[RDT]);
}
The vulnerability label is: Vulnerable |
devign_test_set_data_3153 | av_cold void ff_sws_init_swScale_mmx(SwsContext *c)
{
int cpu_flags = av_get_cpu_flags();
#if HAVE_INLINE_ASM
if (cpu_flags & AV_CPU_FLAG_MMX)
sws_init_swScale_MMX(c);
#if HAVE_MMXEXT_INLINE
if (cpu_flags & AV_CPU_FLAG_MMXEXT)
sws_init_swScale_MMX2(c);
#endif
#endif /* HAVE_INLIN... |
devign_test_set_data_3158 | static unsigned tget(const uint8_t **p, int type, int le)
{
switch (type) {
case TIFF_BYTE:
return *(*p)++;
case TIFF_SHORT:
return tget_short(p, le);
case TIFF_LONG:
return tget_long(p, le);
default:
return UINT_MAX;
}
}
The vulnerability label is: ... |
devign_test_set_data_3160 | static int decode_hq_slice(AVCodecContext *avctx, void *arg)
{
int i, quant, level, orientation, quant_idx;
uint8_t quants[MAX_DWT_LEVELS][4];
DiracContext *s = avctx->priv_data;
DiracSlice *slice = arg;
GetBitContext *gb = &slice->gb;
skip_bits_long(gb, 8*s->highquality.prefix_bytes);
... |
devign_test_set_data_3161 | static av_cold int amr_wb_encode_init(AVCodecContext *avctx)
{
AMRWBContext *s = avctx->priv_data;
if (avctx->sample_rate != 16000) {
av_log(avctx, AV_LOG_ERROR, "Only 16000Hz sample rate supported\n");
return AVERROR(ENOSYS);
}
if (avctx->channels != 1) {
av_log(avct... |
devign_test_set_data_3162 | uint32_t div32(uint32_t *q_ptr, uint64_t num, uint32_t den)
{
*q_ptr = num / den;
return num % den;
}
The vulnerability label is: Vulnerable |
devign_test_set_data_3176 | void ff_fetch_timestamp(AVCodecParserContext *s, int off, int remove)
{
int i;
s->dts =
s->pts = AV_NOPTS_VALUE;
s->pos = -1;
s->offset = 0;
for (i = 0; i < AV_PARSER_PTS_NB; i++) {
if (s->cur_offset + off >= s->cur_frame_offset[i] &&
(s->frame_offset < s-... |
devign_test_set_data_3179 | static void simple_whitespace(void)
{
int i;
struct {
const char *encoded;
LiteralQObject decoded;
} test_cases[] = {
{
.encoded = " [ 43 , 42 ]",
.decoded = QLIT_QLIST(((LiteralQObject[]){
QLIT_QINT(43),
... |
devign_test_set_data_3180 | static void gen_check_sr(DisasContext *dc, uint32_t sr, unsigned access)
{
if (!xtensa_option_bits_enabled(dc->config, sregnames[sr].opt_bits)) {
if (sregnames[sr].name) {
qemu_log("SR %s is not configured\n", sregnames[sr].name);
} else {
qemu_log("SR %d is not impleme... |
devign_test_set_data_3182 | static void gen_lswi(DisasContext *ctx)
{
TCGv t0;
TCGv_i32 t1, t2;
int nb = NB(ctx->opcode);
int start = rD(ctx->opcode);
int ra = rA(ctx->opcode);
int nr;
if (nb == 0)
nb = 32;
nr = (nb + 3) / 4;
if (unlikely(lsw_reg_in_range(start, nr, ra))) {
gen_inv... |
devign_test_set_data_3183 | static int decode_frame(AVCodecContext *avctx, const uint8_t *databuf,
float **out_samples)
{
ATRAC3Context *q = avctx->priv_data;
int ret, i;
uint8_t *ptr1;
if (q->coding_mode == JOINT_STEREO) {
/* channel coupling mode */
/* decode Sound Unit 1 */
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.