id stringlengths 19 22 | source_name stringclasses 2
values | source_type stringclasses 1
value | source_split stringclasses 2
values | original_id unknown | language stringclasses 2
values | framework stringclasses 1
value | task stringclasses 2
values | cwe_id stringclasses 15
values | owasp_category stringclasses 6
values | severity stringclasses 3
values | is_vulnerable bool 2
classes | vulnerability_name stringclasses 15
values | input_code stringlengths 26 142k | fixed_code stringclasses 1
value | explanation stringclasses 2
values | secure_pattern stringclasses 1
value | tags listlengths 4 4 | metadata unknown |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
codexglue_train_007990 | CodeXGLUE Defect Detection | public_dataset | train | 9952 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void OPPROTO op_addw_ESI_T0(void)
{
ESI = (ESI & ~0xffff) | ((ESI + T0) & 0xffff);
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "6e0d8677cb443e7408c0b7a25a93c6596d7fa380",
"normalized_at": "2026-06-20T05:17:39.126410Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020110 | CodeXGLUE Defect Detection | public_dataset | train | 25145 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void av_opt_freep_ranges(AVOptionRanges **rangesp)
{
int i;
AVOptionRanges *ranges = *rangesp;
if (!ranges)
return;
for (i = 0; i < ranges->nb_ranges * ranges->nb_components; i++) {
AVOptionRange *range = ranges->range[i];
av_freep(&range->str);
av_freep(&ran... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "3aac5fcfa9d3748659d78ab2a66d0ccce22cfd4f",
"normalized_at": "2026-06-20T05:17:39.444694Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007876 | CodeXGLUE Defect Detection | public_dataset | train | 9811 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int av_cold ff_celt_pvq_init(CeltPVQ **pvq, int encode)
{
CeltPVQ *s = av_malloc(sizeof(CeltPVQ));
if (!s)
return AVERROR(ENOMEM);
s->pvq_search = ppp_pvq_search_c;
s->quant_band = encode ? pvq_encode_band : pvq_decode_band;
s->band_cost = pvq_band_cost;
if (ARCH_X86)
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "7b46add7257628bffac96d3002308d1f9e1ed172",
"normalized_at": "2026-06-20T05:17:39.123997Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014604 | CodeXGLUE Defect Detection | public_dataset | train | 18241 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void mips_cpu_do_interrupt(CPUState *cs)
{
#if !defined(CONFIG_USER_ONLY)
MIPSCPU *cpu = MIPS_CPU(cs);
CPUMIPSState *env = &cpu->env;
bool update_badinstr = 0;
target_ulong offset;
int cause = -1;
const char *name;
if (qemu_loglevel_mask(CPU_LOG_INT)
&& cs->exception_inde... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "89777fd10fc3dd573c3b4d1b2efdd10af823c001",
"normalized_at": "2026-06-20T05:17:39.293749Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011338 | CodeXGLUE Defect Detection | public_dataset | train | 14113 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void spr_write_decr (DisasContext *ctx, int sprn, int gprn)
{
if (use_icount) {
gen_io_start();
}
gen_helper_store_decr(cpu_env, cpu_gpr[gprn]);
if (use_icount) {
gen_io_end();
gen_stop_exception(ctx);
}
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "bd79255d2571a3c68820117caf94ea9afe1d527e",
"normalized_at": "2026-06-20T05:17:39.212305Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003760 | CodeXGLUE Defect Detection | public_dataset | train | 4627 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void qcow2_free_any_clusters(BlockDriverState *bs, uint64_t l2_entry,
int nb_clusters, enum qcow2_discard_type type)
{
BDRVQcow2State *s = bs->opaque;
switch (qcow2_get_cluster_type(l2_entry)) {
case QCOW2_CLUSTER_COMPRESSED:
{
int nb_csectors;
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "fdfab37dfeffefbd4533b4158055c9b82d7c3e69",
"normalized_at": "2026-06-20T05:17:39.020123Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_000289 | CodeXGLUE Defect Detection | public_dataset | train | 360 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | BlockJobInfoList *qmp_query_block_jobs(Error **errp)
{
BlockJobInfoList *head = NULL, **p_next = &head;
BlockDriverState *bs;
BdrvNextIterator *it = NULL;
while ((it = bdrv_next(it, &bs))) {
AioContext *aio_context = bdrv_get_aio_context(bs);
aio_context_acquire(aio_context);
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "88be7b4be4aa17c88247e162bdd7577ea79db94f",
"normalized_at": "2026-06-20T05:17:38.924120Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018394 | CodeXGLUE Defect Detection | public_dataset | train | 22968 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int imc_decode_block(AVCodecContext *avctx, IMCContext *q, int ch)
{
int stream_format_code;
int imc_hdr, i, j, ret;
int flag;
int bits, summer;
int counter, bitscount;
IMCChannel *chctx = q->chctx + ch;
/* Check the frame header */
imc_hdr = get_bits(&q->gb, 9);
if (imc_hdr &... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "2f74f8d7dce2baff3a4401130a8e479c2899fd16",
"normalized_at": "2026-06-20T05:17:39.398431Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015561 | CodeXGLUE Defect Detection | public_dataset | train | 19446 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void FUNCC(pred16x16_vertical_add)(uint8_t *pix, const int *block_offset,
const int16_t *block,
ptrdiff_t stride)
{
int i;
for(i=0; i<16; i++)
FUNCC(pred4x4_vertical_add)(pix + block_offset[i], block + i*16*... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "1acd7d594c15aa491729c837ad3519d3469e620a",
"normalized_at": "2026-06-20T05:17:39.318988Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_021716 | CodeXGLUE Defect Detection | public_dataset | train | 27150 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void qemu_coroutine_enter(Coroutine *co, void *opaque)
{
Coroutine *self = qemu_coroutine_self();
CoroutineAction ret;
trace_qemu_coroutine_enter(self, co, opaque);
if (co->caller) {
fprintf(stderr, "Co-routine re-entered recursively\n");
abort();
}
co->caller = se... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "0b8b8753e4d94901627b3e86431230f2319215c4",
"normalized_at": "2026-06-20T05:17:39.490423Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020260 | CodeXGLUE Defect Detection | public_dataset | train | 25330 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void json_message_process_token(JSONLexer *lexer, QString *token, JSONTokenType type, int x, int y)
{
JSONMessageParser *parser = container_of(lexer, JSONMessageParser, lexer);
QDict *dict;
if (type == JSON_OPERATOR) {
switch (qstring_get_str(token)[0]) {
case '{':
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "4f2d31fbc0bfdf41feea7d1be49f4f7ffa005534",
"normalized_at": "2026-06-20T05:17:39.447779Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007159 | CodeXGLUE Defect Detection | public_dataset | train | 8894 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void ehci_update_frindex(EHCIState *ehci, int uframes)
{
int i;
if (!ehci_enabled(ehci) && ehci->pstate == EST_INACTIVE) {
return;
}
for (i = 0; i < uframes; i++) {
ehci->frindex++;
if (ehci->frindex == 0x00002000) {
ehci_raise_irq(ehci, USBSTS_F... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "72aa364b1d9daa889bb5898ea4aded9d27fd1c96",
"normalized_at": "2026-06-20T05:17:39.106846Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009620 | CodeXGLUE Defect Detection | public_dataset | train | 11977 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static av_cold int qdm2_decode_init(AVCodecContext *avctx)
{
QDM2Context *s = avctx->priv_data;
uint8_t *extradata;
int extradata_size;
int tmp_val, tmp, size;
/* extradata parsing
Structure:
wave {
frma (QDM2)
QDCA
QDCP
}
32 size (includin... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "f5be7958e313f3f62505ea7f90007800e8e1dcb5",
"normalized_at": "2026-06-20T05:17:39.166880Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011823 | CodeXGLUE Defect Detection | public_dataset | train | 14712 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void virtio_scsi_command_complete(SCSIRequest *r, uint32_t status,
size_t resid)
{
VirtIOSCSIReq *req = r->hba_private;
uint8_t sense[SCSI_SENSE_BUF_SIZE];
uint32_t sense_len;
if (r->io_canceled) {
return;
}
req->resp.cmd->resp... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "3eff1f46f08a360a4ae9f834ce9fef4c45bf6f0f",
"normalized_at": "2026-06-20T05:17:39.224778Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010849 | CodeXGLUE Defect Detection | public_dataset | train | 13528 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void qht_statistics_init(struct qht *ht, struct qht_stats *stats)
{
struct qht_map *map;
int i;
map = atomic_rcu_read(&ht->map);
stats->head_buckets = map->n_buckets;
stats->used_head_buckets = 0;
stats->entries = 0;
qdist_init(&stats->chain);
qdist_init(&stats->occupancy);
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "7266ae91a111001abda65c79299c9b7e365456b6",
"normalized_at": "2026-06-20T05:17:39.198474Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010876 | CodeXGLUE Defect Detection | public_dataset | train | 13562 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int mp_pacl_removexattr(FsContext *ctx,
const char *path, const char *name)
{
int ret;
char buffer[PATH_MAX];
ret = lremovexattr(rpath(ctx, path, buffer), MAP_ACL_ACCESS);
if (ret == -1 && errno == ENODATA) {
/*
* We don't get ENODATA error... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "4fa4ce7107c6ec432f185307158c5df91ce54308",
"normalized_at": "2026-06-20T05:17:39.199274Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_006992 | CodeXGLUE Defect Detection | public_dataset | train | 8691 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int parse_metadata_ext(DBEContext *s)
{
if (s->mtd_ext_size)
skip_input(s, s->key_present + s->mtd_ext_size + 1);
return 0;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "5e715b583dab85735660b15a8d217a69164675fe",
"normalized_at": "2026-06-20T05:17:39.102186Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007249 | CodeXGLUE Defect Detection | public_dataset | train | 9002 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void qemu_thread_create(QemuThread *thread,
void *(*start_routine)(void *),
void *arg, int mode)
{
HANDLE hThread;
assert(mode == QEMU_THREAD_DETACHED);
struct QemuThreadData *data;
qemu_thread_init();
data = g_malloc(sizeof *data);
data... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "403e633126b7a781ecd48a29e3355770d46bbf1a",
"normalized_at": "2026-06-20T05:17:39.108612Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011450 | CodeXGLUE Defect Detection | public_dataset | train | 14252 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int av_write_trailer(AVFormatContext *s)
{
int ret;
while(s->packet_buffer){
int ret;
AVPacketList *pktl= s->packet_buffer;
//av_log(s, AV_LOG_DEBUG, "write_trailer st:%d dts:%lld\n", pktl->pkt.stream_index, pktl->pkt.dts);
truncate_ts(s->streams[pktl->pkt.stream_index], &... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "fe2d6fe2359b153eee827906140e62f710496a37",
"normalized_at": "2026-06-20T05:17:39.215189Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003013 | CodeXGLUE Defect Detection | public_dataset | train | 3686 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void vhost_dev_cleanup(struct vhost_dev *hdev)
{
int i;
for (i = 0; i < hdev->nvqs; ++i) {
vhost_virtqueue_cleanup(hdev->vqs + i);
}
memory_listener_unregister(&hdev->memory_listener);
if (hdev->migration_blocker) {
migrate_del_blocker(hdev->migration_blocker);
error... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "2ce68e4cf5be9b5176a3c3c372948d6340724d2d",
"normalized_at": "2026-06-20T05:17:39.000485Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020535 | CodeXGLUE Defect Detection | public_dataset | train | 25671 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos,
int *outFilterSize, int xInc, int srcW,
int dstW, int filterAlign, int one,
int flags, int cpu_flags,
SwsVector *srcFilter, ... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "f61bece684d9685b07895508e6c1c733b5564ccf",
"normalized_at": "2026-06-20T05:17:39.454490Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017598 | CodeXGLUE Defect Detection | public_dataset | train | 21983 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int ff_v4l2_m2m_codec_full_reinit(V4L2m2mContext *s)
{
void *log_ctx = s->avctx;
int ret;
av_log(log_ctx, AV_LOG_DEBUG, "%s full reinit\n", s->devname);
/* wait for pending buffer references */
if (atomic_load(&s->refcount))
while(sem_wait(&s->refsync) == -1 && errno == EINTR);
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "a0c624e299730c8c5800375c2f5f3c6c200053ff",
"normalized_at": "2026-06-20T05:17:39.375770Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017796 | CodeXGLUE Defect Detection | public_dataset | train | 22233 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void mips_malta_init(QEMUMachineInitArgs *args)
{
ram_addr_t ram_size = args->ram_size;
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;
char *file... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "cc413a39355ed910f22f8f0be5e233c08a0773a0",
"normalized_at": "2026-06-20T05:17:39.382749Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013630 | CodeXGLUE Defect Detection | public_dataset | train | 16994 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void tcx_invalidate_cursor_position(TCXState *s)
{
int ymin, ymax, start, end;
/* invalidate only near the cursor */
ymin = s->cursy;
if (ymin >= s->height) {
return;
}
ymax = MIN(s->height, ymin + 32);
start = ymin * 1024;
end = ymax * 1024;
memory_re... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "973945804d95878375b487c0c5c9b2556c5e4543",
"normalized_at": "2026-06-20T05:17:39.268523Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005223 | CodeXGLUE Defect Detection | public_dataset | train | 6476 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int ccid_handle_bulk_out(USBCCIDState *s, USBPacket *p)
{
CCID_Header *ccid_header;
if (p->len + s->bulk_out_pos > BULK_OUT_DATA_SIZE) {
return USB_RET_STALL;
}
ccid_header = (CCID_Header *)s->bulk_out_data;
memcpy(s->bulk_out_data + s->bulk_out_pos, p->data, p->len);
s-... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "4f4321c11ff6e98583846bfd6f0e81954924b003",
"normalized_at": "2026-06-20T05:17:39.056996Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016553 | CodeXGLUE Defect Detection | public_dataset | train | 20686 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int qemu_chr_open_msmouse(QemuOpts *opts, CharDriverState **_chr)
{
CharDriverState *chr;
chr = g_malloc0(sizeof(CharDriverState));
chr->chr_write = msmouse_chr_write;
chr->chr_close = msmouse_chr_close;
qemu_add_mouse_event_handler(msmouse_event, chr, 0, "QEMU Microsoft Mouse");
*_... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "1f51470d044852592922f91000e741c381582cdc",
"normalized_at": "2026-06-20T05:17:39.345562Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002235 | CodeXGLUE Defect Detection | public_dataset | train | 2724 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void musicpal_register_devices(void)
{
sysbus_register_dev("mv88w8618_pic", sizeof(mv88w8618_pic_state),
mv88w8618_pic_init);
sysbus_register_dev("mv88w8618_pit", sizeof(mv88w8618_pit_state),
mv88w8618_pit_init);
sysbus_register_dev("mv88w8618_fla... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "c88d6bded69804617f412a60c7375cc93f8687a5",
"normalized_at": "2026-06-20T05:17:38.978387Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017060 | CodeXGLUE Defect Detection | public_dataset | train | 21316 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void icount_adjust_vm(void *opaque)
{
timer_mod(icount_vm_timer,
qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) +
NANOSECONDS_PER_SECOND / 10);
icount_adjust();
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "b39e3f34c9de7ead6a11a74aa2de78baf41d81a7",
"normalized_at": "2026-06-20T05:17:39.359199Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000644 | OWASP Benchmark Python | public_dataset | processed | 644 | python | generic | security_review | CWE-328 | A02: Cryptographic Failures | medium | false | Weak Hashing Algorithm | '''
OWASP Benchmark for Python v0.1
This file is part of the Open Web Application Security Project (OWASP) Benchmark Project.
For details, please see https://owasp.org/www-project-benchmark.
The OWASP Benchmark is free software: you can redistribute it and/or modify it under the terms
of the GNU General Public Licens... | This example was normalized from OWASP Benchmark Python. It is intended for security review and vulnerability detection. A secure repair is not included in this source-specific normalized record. | [
"owasp",
"benchmark-python",
"python",
"cwe-328"
] | {
"raw_path": "testcode/BenchmarkTest00644.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.708695Z",
"name_fixed_at": "2026-06-20T05:22:49.836170Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007208 | CodeXGLUE Defect Detection | public_dataset | train | 8953 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void exynos4210_rtc_write(void *opaque, target_phys_addr_t offset,
uint64_t value, unsigned size)
{
Exynos4210RTCState *s = (Exynos4210RTCState *)opaque;
switch (offset) {
case INTP:
if (value & INTP_ALM_ENABLE) {
qemu_irq_lower(s->alm_irq);
s->reg_in... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "a8170e5e97ad17ca169c64ba87ae2f53850dab4c",
"normalized_at": "2026-06-20T05:17:39.107790Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017217 | CodeXGLUE Defect Detection | public_dataset | train | 21512 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void ff_MPV_encode_init_x86(MpegEncContext *s)
{
int mm_flags = av_get_cpu_flags();
const int dct_algo = s->avctx->dct_algo;
if (dct_algo == FF_DCT_AUTO || dct_algo == FF_DCT_MMX) {
#if HAVE_MMX_INLINE
if (mm_flags & AV_CPU_FLAG_MMX && HAVE_MMX)
s->dct_quantize = dct_quantize_MM... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "e0c6cce44729d94e2a5507a4b6d031f23e8bd7b6",
"normalized_at": "2026-06-20T05:17:39.364224Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010416 | CodeXGLUE Defect Detection | public_dataset | train | 12980 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void hmp_savevm(Monitor *mon, const QDict *qdict)
{
BlockDriverState *bs, *bs1;
QEMUSnapshotInfo sn1, *sn = &sn1, old_sn1, *old_sn = &old_sn1;
int ret;
QEMUFile *f;
int saved_vm_running;
uint64_t vm_state_size;
qemu_timeval tv;
struct tm tm;
const char *name = qdict_get_try_str(qdict... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "560d027b54067ffa4e79c6f7c0a499abb0d749a3",
"normalized_at": "2026-06-20T05:17:39.187370Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002389 | CodeXGLUE Defect Detection | public_dataset | train | 2906 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int v9fs_synth_rename(FsContext *ctx, const char *oldpath,
const char *newpath)
{
errno = EPERM;
return -1;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "364031f17932814484657e5551ba12957d993d7e",
"normalized_at": "2026-06-20T05:17:38.983098Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011734 | CodeXGLUE Defect Detection | public_dataset | train | 14600 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int raw_decode(AVCodecContext *avctx,
void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
int linesize_align = 4;
RawVideoContext *context = avctx->priv_data;
AVFrame * f... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "422e3a74b9d783571bec775af64f75e4915c40cc",
"normalized_at": "2026-06-20T05:17:39.222630Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018028 | CodeXGLUE Defect Detection | public_dataset | train | 22526 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void put_int32(QEMUFile *f, void *pv, size_t size)
{
int32_t *v = pv;
qemu_put_sbe32s(f, v);
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "60fe637bf0e4d7989e21e50f52526444765c63b4",
"normalized_at": "2026-06-20T05:17:39.388933Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018766 | CodeXGLUE Defect Detection | public_dataset | train | 23450 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void ptimer_run(ptimer_state *s, int oneshot)
{
bool was_disabled = !s->enabled;
if (was_disabled && s->period == 0) {
fprintf(stderr, "Timer with period zero, disabling\n");
return;
}
s->enabled = oneshot ? 2 : 1;
if (was_disabled) {
s->next_event = qemu_clock_get... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "2a8b58703e2144c136f6d26f609c6a338a03a3ca",
"normalized_at": "2026-06-20T05:17:39.407738Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016075 | CodeXGLUE Defect Detection | public_dataset | train | 20090 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void ppc_prep_init (int ram_size, int vga_ram_size,
const char *boot_device, DisplayState *ds,
const char *kernel_filename,
const char *kernel_cmdline,
const char *initrd_filename,
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "4018bae91649e8e38e371dc00cb5ac8f9e40089e",
"normalized_at": "2026-06-20T05:17:39.333474Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009869 | CodeXGLUE Defect Detection | public_dataset | train | 12297 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void test_segs(void)
{
struct modify_ldt_ldt_s ldt;
long long ldt_table[3];
int res, res2;
char tmp;
struct {
uint32_t offset;
uint16_t seg;
} __attribute__((packed)) segoff;
ldt.entry_number = 1;
ldt.base_addr = (unsigned long)&seg_data1;
ldt.limit = (s... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "541dc0d47f10973c241e9955afc2aefc96adec51",
"normalized_at": "2026-06-20T05:17:39.173106Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020173 | CodeXGLUE Defect Detection | public_dataset | train | 25224 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static inline void t_gen_add_flag(TCGv d, int flag)
{
TCGv c;
c = tcg_temp_new(TCG_TYPE_TL);
t_gen_mov_TN_preg(c, PR_CCS);
/* Propagate carry into d. */
tcg_gen_andi_tl(c, c, 1 << flag);
if (flag)
tcg_gen_shri_tl(c, c, flag);
tcg_gen_add_tl(d, d, c);
tcg_temp_free(c);
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "a7812ae412311d7d47f8aa85656faadac9d64b56",
"normalized_at": "2026-06-20T05:17:39.446046Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001667 | CodeXGLUE Defect Detection | public_dataset | train | 2036 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void glib_select_poll(fd_set *rfds, fd_set *wfds, fd_set *xfds,
bool err)
{
GMainContext *context = g_main_context_default();
if (!err) {
int i;
for (i = 0; i < n_poll_fds; i++) {
GPollFD *p = &poll_fds[i];
if ((p->events ... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "48ce11ff972c733afaed3e2a2613a2e56081ec92",
"normalized_at": "2026-06-20T05:17:38.962863Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019559 | CodeXGLUE Defect Detection | public_dataset | train | 24440 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int proxy_mknod(FsContext *fs_ctx, V9fsPath *dir_path,
const char *name, FsCred *credp)
{
int retval;
V9fsString fullname;
v9fs_string_init(&fullname);
v9fs_string_sprintf(&fullname, "%s/%s", dir_path->data, name);
retval = v9fs_request(fs_ctx->private, T_MKN... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "494a8ebe713055d3946183f4b395f85a18b43e9e",
"normalized_at": "2026-06-20T05:17:39.430739Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_021247 | CodeXGLUE Defect Detection | public_dataset | train | 26565 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void qemu_event_read(void *opaque)
{
int fd = (intptr_t)opaque;
ssize_t len;
char buffer[512];
/* Drain the notify pipe. For eventfd, only 8 bytes will be read. */
do {
len = read(fd, buffer, sizeof(buffer));
} while ((len == -1 && errno == EINTR) || len == sizeof(buff... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "d3b12f5dec4b27ebab58fb5797cb67bacced773b",
"normalized_at": "2026-06-20T05:17:39.474313Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005037 | CodeXGLUE Defect Detection | public_dataset | train | 6256 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int bdrv_aio_multiwrite(BlockDriverState *bs, BlockRequest *reqs, int num_reqs)
{
MultiwriteCB *mcb;
int i;
/* don't submit writes if we don't have a medium */
if (bs->drv == NULL) {
for (i = 0; i < num_reqs; i++) {
reqs[i].error = -ENOMEDIUM;
}
return -1;
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "61007b316cd71ee7333ff7a0a749a8949527575f",
"normalized_at": "2026-06-20T05:17:39.051387Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001309 | CodeXGLUE Defect Detection | public_dataset | train | 1605 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void *rcu_q_updater(void *arg)
{
int j, target_el;
long long n_updates_local = 0;
long long n_removed_local = 0;
struct list_element *el, *prev_el;
*(struct rcu_reader_data **)arg = &rcu_reader;
atomic_inc(&nthreadsrunning);
while (goflag == GOFLAG_INIT) {
g_usleep(... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "8a5956ad6392f115521dad774055c737c49fb0dd",
"normalized_at": "2026-06-20T05:17:38.953239Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005073 | CodeXGLUE Defect Detection | public_dataset | train | 6301 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int use_gdb_syscalls(void)
{
if (gdb_syscall_mode == GDB_SYS_UNKNOWN) {
gdb_syscall_mode = (gdb_syscall_state ? GDB_SYS_ENABLED
: GDB_SYS_DISABLED);
}
return gdb_syscall_mode == GDB_SYS_ENABLED;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "880a7578381d1c7ed4d41c7599ae3cc06567a824",
"normalized_at": "2026-06-20T05:17:39.053030Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015281 | CodeXGLUE Defect Detection | public_dataset | train | 19096 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void aio_timerlist_notify(void *opaque)
{
aio_notify(opaque);
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "c2b38b277a7882a592f4f2ec955084b2b756daaa",
"normalized_at": "2026-06-20T05:17:39.311586Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010832 | CodeXGLUE Defect Detection | public_dataset | train | 13506 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void parse_numa_opts(MachineState *ms)
{
int i;
const CPUArchIdList *possible_cpus;
MachineClass *mc = MACHINE_GET_CLASS(ms);
for (i = 0; i < MAX_NODES; i++) {
numa_info[i].node_cpu = bitmap_new(max_cpus);
}
if (qemu_opts_foreach(qemu_find_opts("numa"), parse_numa, ms, NULL))... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "1171ae9a5b132dc631728ff17688d05ed4534181",
"normalized_at": "2026-06-20T05:17:39.198074Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_000185 | CodeXGLUE Defect Detection | public_dataset | train | 224 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void kvm_init_irq_routing(KVMState *s)
{
int gsi_count, i;
gsi_count = kvm_check_extension(s, KVM_CAP_IRQ_ROUTING);
if (gsi_count > 0) {
unsigned int gsi_bits, i;
/* Round up so we can search ints using ffs */
gsi_bits = ALIGN(gsi_count, 32);
s->used_gsi_bitmap = ... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "00008418aa22700f6c49e794e79f53aeb157d10f",
"normalized_at": "2026-06-20T05:17:38.921107Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008357 | CodeXGLUE Defect Detection | public_dataset | train | 10403 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void test_ide_none(void)
{
char *argv[256];
setup_common(argv, ARRAY_SIZE(argv));
qtest_start(g_strjoinv(" ", argv));
test_cmos();
qtest_end();
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "2c8f86961b6eaac705be21bc98299f5517eb0b6b",
"normalized_at": "2026-06-20T05:17:39.134335Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_021311 | CodeXGLUE Defect Detection | public_dataset | train | 26648 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int hqx_decode_frame(AVCodecContext *avctx, void *data,
int *got_picture_ptr, AVPacket *avpkt)
{
HQXContext *ctx = avctx->priv_data;
uint8_t *src = avpkt->data;
uint32_t info_tag;
int data_start;
int i, ret;
if (avpkt->size < 4 + 4) {
av_log(... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "9fd2bf09dbc630484d9e88a1d27f7e8508b70a2c",
"normalized_at": "2026-06-20T05:17:39.475985Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020405 | CodeXGLUE Defect Detection | public_dataset | train | 25507 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void commit_active_start(const char *job_id, BlockDriverState *bs,
BlockDriverState *base, int64_t speed,
BlockdevOnError on_error,
BlockCompletionFunc *cb,
void *opaque, Error **errp)
{
int64_t length, base_le... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "b49f7ead8d222bcb8df0388f3177002f3e33d046",
"normalized_at": "2026-06-20T05:17:39.451708Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004263 | CodeXGLUE Defect Detection | public_dataset | train | 5272 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static bool qapi_dealloc_start_union(Visitor *v, bool data_present,
Error **errp)
{
return data_present;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "544a3731591f5d53e15f22de00ce5ac758d490b3",
"normalized_at": "2026-06-20T05:17:39.032691Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008659 | CodeXGLUE Defect Detection | public_dataset | train | 10784 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int concat_read_packet(AVFormatContext *avf, AVPacket *pkt)
{
ConcatContext *cat = avf->priv_data;
int ret;
int64_t delta;
while (1) {
if ((ret = av_read_frame(cat->avf, pkt)) != AVERROR_EOF ||
(ret = open_next_file(avf)) < 0)
break;
}
delta = av_rescale_q(... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "aeccb522ebb6fb0378bccd6393f1d0c1ca40fdd4",
"normalized_at": "2026-06-20T05:17:39.141631Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018239 | CodeXGLUE Defect Detection | public_dataset | train | 22779 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int rom_load_all(void)
{
target_phys_addr_t addr = 0;
MemoryRegionSection section;
Rom *rom;
QTAILQ_FOREACH(rom, &roms, next) {
if (rom->fw_file) {
continue;
}
if (addr > rom->addr) {
fprintf(stderr, "rom: requested regions overlap "
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "a8170e5e97ad17ca169c64ba87ae2f53850dab4c",
"normalized_at": "2026-06-20T05:17:39.394607Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009146 | CodeXGLUE Defect Detection | public_dataset | train | 11379 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int avfilter_graph_add_filter(AVFilterGraph *graph, AVFilterContext *filter)
{
graph->filters = av_realloc(graph->filters,
sizeof(AVFilterContext*) * ++graph->filter_count);
if (!graph->filters)
return AVERROR(ENOMEM);
graph->filters[graph->filter_count - 1]... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "3748b2b8e8bcedba2de7fe826c4094169a885840",
"normalized_at": "2026-06-20T05:17:39.154691Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014042 | CodeXGLUE Defect Detection | public_dataset | train | 17514 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int ff_load_image(uint8_t *data[4], int linesize[4],
int *w, int *h, enum AVPixelFormat *pix_fmt,
const char *filename, void *log_ctx)
{
AVInputFormat *iformat = NULL;
AVFormatContext *format_ctx = NULL;
AVCodec *codec;
AVCodecContext *codec_ctx;
AVFrame *... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "657998b5ee46719ff873ce34ae953385377b0280",
"normalized_at": "2026-06-20T05:17:39.279072Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001332 | CodeXGLUE Defect Detection | public_dataset | train | 1635 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static av_cold int mpc8_decode_init(AVCodecContext * avctx)
{
int i;
MPCContext *c = avctx->priv_data;
GetBitContext gb;
static int vlc_initialized = 0;
int channels;
static VLC_TYPE band_table[542][2];
static VLC_TYPE q1_table[520][2];
static VLC_TYPE q9up_table[524][2];
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "44c10168cff41c200825448b77cb8feff0d316c9",
"normalized_at": "2026-06-20T05:17:38.954110Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012361 | CodeXGLUE Defect Detection | public_dataset | train | 15391 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | bool gs_allowed(void)
{
/* for "none" machine this results in true */
return get_machine_class()->gs_allowed;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "0280b3eb7c0519b43452c05cf51f8777d9e38975",
"normalized_at": "2026-06-20T05:17:39.237883Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003911 | CodeXGLUE Defect Detection | public_dataset | train | 4820 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static inline void RENAME(rgb24to15)(const uint8_t *src, uint8_t *dst, int src_size)
{
const uint8_t *s = src;
const uint8_t *end;
const uint8_t *mm_end;
uint16_t *d = (uint16_t *)dst;
end = s + src_size;
__asm__ volatile(PREFETCH" %0"::"m"(*src):"memory");
__asm__ volatile(
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "90540c2d5ace46a1e9789c75fde0b1f7dbb12a9b",
"normalized_at": "2026-06-20T05:17:39.023867Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016838 | CodeXGLUE Defect Detection | public_dataset | train | 21043 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void aux_init_mmio(AUXSlave *aux_slave, MemoryRegion *mmio)
{
assert(!aux_slave->mmio);
aux_slave->mmio = mmio;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "e0dadc1e9ef1f35208e5d2af9c7740c18a0b769f",
"normalized_at": "2026-06-20T05:17:39.352919Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005695 | CodeXGLUE Defect Detection | public_dataset | train | 7074 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static size_t handle_aiocb_flush(struct qemu_paiocb *aiocb)
{
int ret;
ret = qemu_fdatasync(aiocb->aio_fildes);
if (ret == -1)
return -errno;
return 0;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "6769da29c7a3caa9de4020db87f495de692cf8e2",
"normalized_at": "2026-06-20T05:17:39.070106Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000853 | OWASP Benchmark Python | public_dataset | processed | 853 | python | generic | security_review | CWE-643 | A03: Injection | high | false | XPath Injection | '''
OWASP Benchmark for Python v0.1
This file is part of the Open Web Application Security Project (OWASP) Benchmark Project.
For details, please see https://owasp.org/www-project-benchmark.
The OWASP Benchmark is free software: you can redistribute it and/or modify it under the terms
of the GNU General Public Licens... | This example was normalized from OWASP Benchmark Python. It is intended for security review and vulnerability detection. A secure repair is not included in this source-specific normalized record. | [
"owasp",
"benchmark-python",
"python",
"cwe-643"
] | {
"raw_path": "testcode/BenchmarkTest00853.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.718130Z",
"name_fixed_at": "2026-06-20T05:22:49.839375Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002441 | CodeXGLUE Defect Detection | public_dataset | train | 2972 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | monitor_read_memory (bfd_vma memaddr, bfd_byte *myaddr, int length,
struct disassemble_info *info)
{
CPUDebug *s = container_of(info, CPUDebug, info);
if (monitor_disas_is_physical) {
cpu_physical_memory_read(memaddr, myaddr, length);
} else {
cpu_memory_rw_debu... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "b8d8720892f7912e8a2621b30ebac0e9a48e89e3",
"normalized_at": "2026-06-20T05:17:38.984304Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005814 | CodeXGLUE Defect Detection | public_dataset | train | 7227 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int mov_write_stbl_tag(ByteIOContext *pb, MOVTrack* track)
{
offset_t pos = url_ftell(pb);
put_be32(pb, 0); /* size */
put_tag(pb, "stbl");
mov_write_stsd_tag(pb, track);
mov_write_stts_tag(pb, track);
if (track->enc->codec_type == CODEC_TYPE_VIDEO &&
track->hasKeyframes <... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "b371539a3d9be9b05cb9ea8065e8e3617a45b02f",
"normalized_at": "2026-06-20T05:17:39.072943Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014707 | CodeXGLUE Defect Detection | public_dataset | train | 18376 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int mxf_read_primer_pack(void *arg, AVIOContext *pb, int tag, int size, UID uid)
{
MXFContext *mxf = arg;
int item_num = avio_rb32(pb);
int item_len = avio_rb32(pb);
if (item_len != 18) {
av_log(mxf->fc, AV_LOG_ERROR, "unsupported primer pack item length\n");
return -1;
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "fd34dbea58e097609ff09cf7dcc59f74930195d3",
"normalized_at": "2026-06-20T05:17:39.296141Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020446 | CodeXGLUE Defect Detection | public_dataset | train | 25559 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int ppce500_load_device_tree(MachineState *machine,
PPCE500Params *params,
hwaddr addr,
hwaddr initrd_base,
hwaddr initrd_size,
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "2343dd11a673597aa59813fd0cac2ae42e2e0312",
"normalized_at": "2026-06-20T05:17:39.452649Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_006341 | CodeXGLUE Defect Detection | public_dataset | train | 7891 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame)
{
AVCodecInternal *avci = avctx->internal;
DecodeSimpleContext *ds = &avci->ds;
AVPacket *pkt = ds->in_pkt;
// copy to ensure we do not change pkt
AVPacket tmp;
int got_frame, actual_got_frame, did_split;... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "e813df4fa345684cc5a63da0510c14f197c9b732",
"normalized_at": "2026-06-20T05:17:39.085669Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_006438 | CodeXGLUE Defect Detection | public_dataset | train | 8017 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void ccw_machine_class_init(ObjectClass *oc, void *data)
{
MachineClass *mc = MACHINE_CLASS(oc);
NMIClass *nc = NMI_CLASS(oc);
mc->name = "s390-ccw-virtio";
mc->alias = "s390-ccw";
mc->desc = "VirtIO-ccw based S390 machine";
mc->init = ccw_init;
mc->block_default_type = IF_V... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "c4d3c0a2696c09a884b680d15b03325e46656a6c",
"normalized_at": "2026-06-20T05:17:39.088111Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019772 | CodeXGLUE Defect Detection | public_dataset | train | 24721 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int tta_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
TTAContext *s = avctx->priv_data;
int i;
init_get_bits(&s->gb, buf, buf_size*8);
{
int cur_chan = 0,... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "e6923f683c506cbb581eb7f31288801f1a065fb0",
"normalized_at": "2026-06-20T05:17:39.436287Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017912 | CodeXGLUE Defect Detection | public_dataset | train | 22375 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int decode_frame(AVCodecContext *avctx,
void *data, int *got_frame,
AVPacket *avpkt)
{
PicContext *s = avctx->priv_data;
AVFrame *frame = data;
uint32_t *palette;
int bits_per_plane, bpp, etype, esize, npal, pos_after_pal;
int i, x, y, p... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "8088d6f5f11b9f9188555f4642c940ddc92271a6",
"normalized_at": "2026-06-20T05:17:39.385940Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019281 | CodeXGLUE Defect Detection | public_dataset | train | 24082 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int attribute_align_arg avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options)
{
int ret = 0;
AVDictionary *tmp = NULL;
if (avcodec_is_open(avctx))
return 0;
if ((!codec && !avctx->codec)) {
av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2(... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "fde1bc64adbec49301c665efab2b49b94bb39c23",
"normalized_at": "2026-06-20T05:17:39.422891Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012051 | CodeXGLUE Defect Detection | public_dataset | train | 15006 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static inline void writer_print_string(WriterContext *wctx,
const char *key, const char *val, int opt)
{
const struct section *section = wctx->section[wctx->level];
if (opt && !(wctx->writer->flags & WRITER_FLAG_DISPLAY_OPTIONAL_FIELDS))
return;
if (s... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "e87190f5d20d380608f792ceb14d0def1d80e24b",
"normalized_at": "2026-06-20T05:17:39.229743Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007391 | CodeXGLUE Defect Detection | public_dataset | train | 9179 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int ff_xvmc_field_start(MpegEncContext *s, AVCodecContext *avctx)
{
struct xvmc_pix_fmt *last, *next, *render = (struct xvmc_pix_fmt*)s->current_picture.f.data[2];
const int mb_block_count = 4 + (1 << s->chroma_format);
assert(avctx);
if (!render || render->xvmc_id != AV_XVMC_ID ||
!rend... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "f6774f905fb3cfdc319523ac640be30b14c1bc55",
"normalized_at": "2026-06-20T05:17:39.112219Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014519 | CodeXGLUE Defect Detection | public_dataset | train | 18124 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void init_timetables( FM_OPL *OPL , int ARRATE , int DRRATE )
{
int i;
double rate;
/* make attack rate & decay rate tables */
for (i = 0;i < 4;i++) OPL->AR_TABLE[i] = OPL->DR_TABLE[i] = 0;
for (i = 4;i <= 60;i++){
rate = OPL->freqbase; /* frequency rate */
if( i < 60 ) rate *= 1.0+(i&3)... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "b2bedb214469af55179d907a60cd67fed6b0779e",
"normalized_at": "2026-06-20T05:17:39.291144Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020335 | CodeXGLUE Defect Detection | public_dataset | train | 25421 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void eepro100_cu_command(EEPRO100State * s, uint8_t val)
{
eepro100_tx_t tx;
uint32_t cb_address;
switch (val) {
case CU_NOP:
/* No operation. */
break;
case CU_START:
if (get_cu_state(s) != cu_idle) {
/* Intel documentation says that CU must be i... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "7f1e9d4e138f5baf1e862a1221ba13eee7dcce9e",
"normalized_at": "2026-06-20T05:17:39.449927Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_006655 | CodeXGLUE Defect Detection | public_dataset | train | 8302 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | e1000e_intrmgr_delay_tx_causes(E1000ECore *core, uint32_t *causes)
{
static const uint32_t delayable_causes = E1000_ICR_TXQ0 |
E1000_ICR_TXQ1 |
E1000_ICR_TXQE |
E1000_ICR_TXDW;... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "1ac6c07f4288b0a563310fad0cdabb3a47c85607",
"normalized_at": "2026-06-20T05:17:39.093312Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008236 | CodeXGLUE Defect Detection | public_dataset | train | 10248 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int kvm_has_xsave(void)
{
return kvm_state->xsave;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "28143b409f698210d85165ca518235ac7e7c5ac5",
"normalized_at": "2026-06-20T05:17:39.131833Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_000425 | CodeXGLUE Defect Detection | public_dataset | train | 529 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void decode_rlc_opc(CPUTriCoreState *env, DisasContext *ctx,
uint32_t op1)
{
int32_t const16;
int r1, r2;
const16 = MASK_OP_RLC_CONST16_SEXT(ctx->opcode);
r1 = MASK_OP_RLC_S1(ctx->opcode);
r2 = MASK_OP_RLC_D(ctx->opcode);
switch (op1) {
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "f678f671ba654d4610f0e43d175c8c1b2fad10df",
"normalized_at": "2026-06-20T05:17:38.927937Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001763 | CodeXGLUE Defect Detection | public_dataset | train | 2153 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void assign_storage(SCLPDevice *sclp, SCCB *sccb)
{
MemoryRegion *mr = NULL;
uint64_t this_subregion_size;
AssignStorage *assign_info = (AssignStorage *) sccb;
sclpMemoryHotplugDev *mhd = get_sclp_memory_hotplug_dev();
ram_addr_t assign_addr;
MemoryRegion *sysmem = get_system_memor... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "f8ed85ac992c48814d916d5df4d44f9a971c5de4",
"normalized_at": "2026-06-20T05:17:38.964849Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018093 | CodeXGLUE Defect Detection | public_dataset | train | 22605 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void test_co_queue(void)
{
Coroutine *c1;
Coroutine *c2;
c1 = qemu_coroutine_create(c1_fn);
c2 = qemu_coroutine_create(c2_fn);
qemu_coroutine_enter(c1, c2);
memset(c1, 0xff, sizeof(Coroutine));
qemu_coroutine_enter(c2, NULL);
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "0b8b8753e4d94901627b3e86431230f2319215c4",
"normalized_at": "2026-06-20T05:17:39.390528Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010246 | CodeXGLUE Defect Detection | public_dataset | train | 12770 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void pxb_dev_exitfn(PCIDevice *pci_dev)
{
PXBDev *pxb = PXB_DEV(pci_dev);
pxb_dev_list = g_list_remove(pxb_dev_list, pxb);
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "02b07434bed8360715198b4cbfdfebd17f7cac32",
"normalized_at": "2026-06-20T05:17:39.183223Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013651 | CodeXGLUE Defect Detection | public_dataset | train | 17022 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s)
{
if (!s) {
return;
}
virtio_blk_data_plane_stop(s);
g_free(s->batch_notify_vqs);
qemu_bh_delete(s->bh);
object_unref(OBJECT(s->iothread));
g_free(s);
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "9ffe337c08388d5c587eae1d77db1b0d1a47c7b1",
"normalized_at": "2026-06-20T05:17:39.268955Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012700 | CodeXGLUE Defect Detection | public_dataset | train | 15806 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void swri_resample_dsp_x86_init(ResampleContext *c)
{
int av_unused mm_flags = av_get_cpu_flags();
switch(c->format){
case AV_SAMPLE_FMT_S16P:
if (ARCH_X86_32 && HAVE_MMXEXT_EXTERNAL && mm_flags & AV_CPU_FLAG_MMX2) {
c->dsp.resample = c->linear ? ff_resample_linear_int16_mmxext
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "9937362c54be085e75c90c55dad443329be59e69",
"normalized_at": "2026-06-20T05:17:39.246663Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012504 | CodeXGLUE Defect Detection | public_dataset | train | 15572 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int spapr_h_cas_compose_response(sPAPRMachineState *spapr,
target_ulong addr, target_ulong size,
sPAPROptionVector *ov5_updates)
{
void *fdt, *fdt_skel;
sPAPRDeviceTreeUpdateHeader hdr = { .version_id = 1 };
if (spapr_hotplugged_dev_before_ca... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "827b17c468b0dae69f82f852958d16f4bf6d6bf0",
"normalized_at": "2026-06-20T05:17:39.241034Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001540 | CodeXGLUE Defect Detection | public_dataset | train | 1880 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void pci_bridge_update_mappings(PCIBridge *br)
{
/* Make updates atomic to: handle the case of one VCPU updating the bridge
* while another accesses an unaffected region. */
memory_region_transaction_begin();
pci_bridge_region_cleanup(br);
pci_bridge_region_init(br);
memory_region... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "b308c82cbda44e138ef990af64d44a5613c16092",
"normalized_at": "2026-06-20T05:17:38.959263Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000283 | OWASP Benchmark Python | public_dataset | processed | 283 | python | generic | security_review | CWE-89 | A03: Injection | high | true | SQL Injection | '''
OWASP Benchmark for Python v0.1
This file is part of the Open Web Application Security Project (OWASP) Benchmark Project.
For details, please see https://owasp.org/www-project-benchmark.
The OWASP Benchmark is free software: you can redistribute it and/or modify it under the terms
of the GNU General Public Licens... | This example was normalized from OWASP Benchmark Python. It is intended for security review and vulnerability detection. A secure repair is not included in this source-specific normalized record. | [
"owasp",
"benchmark-python",
"python",
"cwe-89"
] | {
"raw_path": "testcode/BenchmarkTest00283.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.692971Z",
"name_fixed_at": "2026-06-20T05:22:49.830077Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016742 | CodeXGLUE Defect Detection | public_dataset | train | 20921 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int bamboo_load_device_tree(hwaddr addr,
uint32_t ramsize,
hwaddr initrd_base,
hwaddr initrd_size,
const char *kernel_cmdline)
{
int ret = -1;
uint32_... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "fe1479aa251971abd3842dee4a783d4ebace8fb8",
"normalized_at": "2026-06-20T05:17:39.350586Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007786 | CodeXGLUE Defect Detection | public_dataset | train | 9686 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int scsi_bus_legacy_handle_cmdline(SCSIBus *bus)
{
Location loc;
DriveInfo *dinfo;
int res = 0, unit;
loc_push_none(&loc);
for (unit = 0; unit < MAX_SCSI_DEVS; unit++) {
dinfo = drive_get(IF_SCSI, bus->busnr, unit);
if (dinfo == NULL) {
continue;
}
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "622b520fb4ca50b5028485f1d225317ece0a42b9",
"normalized_at": "2026-06-20T05:17:39.121748Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012744 | CodeXGLUE Defect Detection | public_dataset | train | 15863 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void dump_json_image_info(ImageInfo *info)
{
Error *local_err = NULL;
QString *str;
QmpOutputVisitor *ov = qmp_output_visitor_new();
QObject *obj;
visit_type_ImageInfo(qmp_output_get_visitor(ov), NULL, &info, &local_err);
obj = qmp_output_get_qobject(ov);
str = qobject_to_json... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "911ee36d411ee9b3540855642b53219b6a974992",
"normalized_at": "2026-06-20T05:17:39.247674Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018392 | CodeXGLUE Defect Detection | public_dataset | train | 22965 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static ssize_t qemu_fill_buffer(QEMUFile *f)
{
int len;
int pending;
assert(!qemu_file_is_writable(f));
pending = f->buf_size - f->buf_index;
if (pending > 0) {
memmove(f->buf, f->buf + f->buf_index, pending);
}
f->buf_index = 0;
f->buf_size = pending;
len = ... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "60fe637bf0e4d7989e21e50f52526444765c63b4",
"normalized_at": "2026-06-20T05:17:39.398368Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020727 | CodeXGLUE Defect Detection | public_dataset | train | 25910 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int cloop_open(BlockDriverState *bs, QDict *options, int flags,
Error **errp)
{
BDRVCloopState *s = bs->opaque;
uint32_t offsets_size, max_compressed_block_size = 1, i;
int ret;
bs->read_only = 1;
/* read header */
ret = bdrv_pread(bs->file, 128, &s->bloc... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "f56b9bc3ae20fc93815b34aa022be919941406ce",
"normalized_at": "2026-06-20T05:17:39.458925Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018412 | CodeXGLUE Defect Detection | public_dataset | train | 22991 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static av_cold int g722_encode_close(AVCodecContext *avctx)
{
G722Context *c = avctx->priv_data;
int i;
for (i = 0; i < 2; i++) {
av_freep(&c->paths[i]);
av_freep(&c->node_buf[i]);
av_freep(&c->nodep_buf[i]);
}
return 0;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "8e2555d3b1855374707a4d53bf93d3e07d61e05c",
"normalized_at": "2026-06-20T05:17:39.399260Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020189 | CodeXGLUE Defect Detection | public_dataset | train | 25243 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int read_huffman_tables(HYuvContext *s, uint8_t *src, int length){
GetBitContext gb;
int i;
init_get_bits(&gb, src, length);
for(i=0; i<3; i++){
read_len_table(s->len[i], &gb);
if(generate_bits_table(s->bits[i], s->len[i])<0){
return -1;
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "68f593b48433842f3407586679fe07f3e5199ab9",
"normalized_at": "2026-06-20T05:17:39.446390Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003359 | CodeXGLUE Defect Detection | public_dataset | train | 4122 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static av_cold int find_component(OMXContext *omx_context, void *logctx,
const char *role, char *str, int str_size)
{
OMX_U32 i, num = 0;
char **components;
int ret = 0;
#if CONFIG_OMX_RPI
if (av_strstart(role, "video_encoder.", NULL)) {
av_strlcpy(str... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "16a75304fe42d3a007c78126b6370c94ccf891f6",
"normalized_at": "2026-06-20T05:17:39.010085Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014831 | CodeXGLUE Defect Detection | public_dataset | train | 18536 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int ac3_eac3_probe(AVProbeData *p, enum AVCodecID expected_codec_id)
{
int max_frames, first_frames = 0, frames;
const uint8_t *buf, *buf2, *end;
enum AVCodecID codec_id = AV_CODEC_ID_AC3;
max_frames = 0;
buf = p->buf;
end = buf + p->buf_size;
for(; buf < end; buf++) {
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "eb54efc1e1aafe18d0a8a0c72a78314645bccc83",
"normalized_at": "2026-06-20T05:17:39.299590Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011754 | CodeXGLUE Defect Detection | public_dataset | train | 14623 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void apply_mdct(AC3EncodeContext *s)
{
int blk, ch;
for (ch = 0; ch < s->channels; ch++) {
for (blk = 0; blk < AC3_MAX_BLOCKS; blk++) {
AC3Block *block = &s->blocks[blk];
const SampleType *input_samples = &s->planar_samples[ch][blk * AC3_BLOCK_SIZE];
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "79997def65fd2313b48a5f3c3a884c6149ae9b5d",
"normalized_at": "2026-06-20T05:17:39.223116Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001059 | CodeXGLUE Defect Detection | public_dataset | train | 1296 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static inline void float_to_int (float * _f, int16_t * s16, int samples)
{
int32_t * f = (int32_t *) _f; // XXX assumes IEEE float format
int i;
for (i = 0; i < samples; i++) {
s16[i] = blah (f[i]);
}
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "0058584580b87feb47898e60e4b80c7f425882ad",
"normalized_at": "2026-06-20T05:17:38.946417Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017734 | CodeXGLUE Defect Detection | public_dataset | train | 22160 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void apic_reset_common(DeviceState *d)
{
APICCommonState *s = DO_UPCAST(APICCommonState, busdev.qdev, d);
APICCommonClass *info = APIC_COMMON_GET_CLASS(s);
bool bsp;
bsp = cpu_is_bsp(s->cpu_env);
s->apicbase = 0xfee00000 |
(bsp ? MSR_IA32_APICBASE_BSP : 0) | MSR_IA32_APICBASE... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "dd673288a8ff73ad77fcc1c255486d2466a772e1",
"normalized_at": "2026-06-20T05:17:39.379775Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_006685 | CodeXGLUE Defect Detection | public_dataset | train | 8334 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | av_cold int ff_vp8_decode_free(AVCodecContext *avctx)
{
VP8Context *s = avctx->priv_data;
int i;
vp8_decode_flush_impl(avctx, 1);
for (i = 0; i < FF_ARRAY_ELEMS(s->frames); i++)
av_frame_free(&s->frames[i].tf.f);
} | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "a84f0e8d8f293df3c535f9b893730a835bed6520",
"normalized_at": "2026-06-20T05:17:39.093968Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009672 | CodeXGLUE Defect Detection | public_dataset | train | 12046 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static uint64_t cadence_ttc_read(void *opaque, target_phys_addr_t offset,
unsigned size)
{
uint32_t ret = cadence_ttc_read_imp(opaque, offset);
DB_PRINT("addr: %08x data: %08x\n", offset, ret);
return ret;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "a8170e5e97ad17ca169c64ba87ae2f53850dab4c",
"normalized_at": "2026-06-20T05:17:39.168066Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.