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_010344 | CodeXGLUE Defect Detection | public_dataset | train | 12896 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void do_exit(void)
{
if (cur_stream) {
stream_close(cur_stream);
cur_stream = NULL;
}
uninit_opts();
#if CONFIG_AVFILTER
avfilter_uninit();
#endif
avformat_network_deinit();
if (show_status)
printf("\n");
SDL_Quit();
av_log(NULL, AV_LOG_QUIET,... | 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": "fa2a34cd40d124161c748bb0f430dc63c94dd0da",
"normalized_at": "2026-06-20T05:17:39.185492Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015076 | CodeXGLUE Defect Detection | public_dataset | train | 18846 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void spapr_tce_table_finalize(Object *obj)
{
sPAPRTCETable *tcet = SPAPR_TCE_TABLE(obj);
QLIST_REMOVE(tcet, list);
if (!kvm_enabled() ||
(kvmppc_remove_spapr_tce(tcet->table, tcet->fd,
tcet->nb_table) != 0)) {
g_free(tcet->table);
}
}
| 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": "5f9490de566c5b092a6cfedc3c7a37a9c9dee917",
"normalized_at": "2026-06-20T05:17:39.306423Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016981 | CodeXGLUE Defect Detection | public_dataset | train | 21214 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void s390_pci_generate_error_event(uint16_t pec, uint32_t fh,
uint32_t fid, uint64_t faddr,
uint32_t e)
{
s390_pci_generate_event(1, pec, fh, fid, faddr, e);
}
| 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": "5d1abf234462d13bef3617cc2c55b6815703ddf2",
"normalized_at": "2026-06-20T05:17:39.356823Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003945 | CodeXGLUE Defect Detection | public_dataset | train | 4862 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void new_pes_packet(PESContext *pes, AVPacket *pkt)
{
av_init_packet(pkt);
pkt->destruct = av_destruct_packet;
pkt->data = pes->buffer;
pkt->size = pes->data_index;
memset(pkt->data+pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
// Separate out the AC3 substream from an HDMV comb... | 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": "ce9e31655e5b8f8db3bb4f13f436fc836062a514",
"normalized_at": "2026-06-20T05:17:39.024674Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014982 | CodeXGLUE Defect Detection | public_dataset | train | 18729 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void set_algorythm( OPL_CH *CH)
{
INT32 *carrier = &outd[0];
CH->connect1 = CH->CON ? carrier : &feedback2;
CH->connect2 = carrier;
}
| 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": "c11e80e299e57c64934c164b231fa0d4279db445",
"normalized_at": "2026-06-20T05:17:39.303899Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005728 | CodeXGLUE Defect Detection | public_dataset | train | 7117 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void vnc_write_u8(VncState *vs, uint8_t value)
{
vnc_write(vs, (char *)&value, 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": "5fb6c7a8b26eab1a22207d24b4784bd2b39ab54b",
"normalized_at": "2026-06-20T05:17:39.070769Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012902 | CodeXGLUE Defect Detection | public_dataset | train | 16058 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void gmc1_altivec(uint8_t *dst /* align 8 */, uint8_t *src /* align1 */, int stride, int h, int x16, int y16, int rounder)
{
POWERPC_TBL_DECLARE(altivec_gmc1_num, GMC1_PERF_COND);
#ifdef ALTIVEC_USE_REFERENCE_C_CODE
const int A=(16-x16)*(16-y16);
const int B=( x16)*(16-y16);
const int C=(16-x16)*( ... | 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": "e45a2872fafe631c14aee9f79d0963d68c4fc1fd",
"normalized_at": "2026-06-20T05:17:39.251543Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011380 | CodeXGLUE Defect Detection | public_dataset | train | 14167 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void ff_weight_h264_pixels4_8_msa(uint8_t *src, int stride,
int height, int log2_denom,
int weight_src, int offset)
{
avc_wgt_4width_msa(src, stride,
height, log2_denom, weight_src, offset);
}
| 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": "bcd7bf7eeb09a395cc01698842d1b8be9af483fc",
"normalized_at": "2026-06-20T05:17:39.213623Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016466 | CodeXGLUE Defect Detection | public_dataset | train | 20575 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static always_inline int get_bat (CPUState *env, mmu_ctx_t *ctx,
target_ulong virtual, int rw, int type)
{
target_ulong *BATlt, *BATut, *BATu, *BATl;
target_ulong base, BEPIl, BEPIu, bl;
int i, pp, pr;
int ret = -1;
#if defined (DEBUG_BATS)
if (loglevel !=... | 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": "faadf50e2962dd54175647a80bd6fc4319c91973",
"normalized_at": "2026-06-20T05:17:39.343379Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001068 | CodeXGLUE Defect Detection | public_dataset | train | 1305 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | BlockDeviceInfoList *qmp_query_named_block_nodes(Error **errp)
{
return bdrv_named_nodes_list();
}
| 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": "d5a8ee60a0fbc20a2c2d02f3bda1bb1bd365f1ee",
"normalized_at": "2026-06-20T05:17:38.946562Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017720 | CodeXGLUE Defect Detection | public_dataset | train | 22144 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args, bool is64)
{
TCGReg datalo, datahi, addrlo;
TCGReg addrhi __attribute__((unused));
TCGMemOpIdx oi;
TCGMemOp opc;
#if defined(CONFIG_SOFTMMU)
int mem_index;
TCGMemOp s_bits;
tcg_insn_unit *label_ptr[2];
#endif
dat... | 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": "8cc580f6a0d8c0e2f590c1472cf5cd8e51761760",
"normalized_at": "2026-06-20T05:17:39.379460Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015674 | CodeXGLUE Defect Detection | public_dataset | train | 19586 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void helper_fcmpu(CPUPPCState *env, uint64_t arg1, uint64_t arg2,
uint32_t crfD)
{
CPU_DoubleU farg1, farg2;
uint32_t ret = 0;
farg1.ll = arg1;
farg2.ll = arg2;
if (unlikely(float64_is_any_nan(farg1.d) ||
float64_is_any_nan(farg2.d))) {
ret = 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": "59800ec8e52bcfa271fa61fb0aae19205ef1b7f1",
"normalized_at": "2026-06-20T05:17:39.321597Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013867 | CodeXGLUE Defect Detection | public_dataset | train | 17287 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void wdt_ib700_realize(DeviceState *dev, Error **errp)
{
IB700State *s = IB700(dev);
PortioList *port_list = g_new(PortioList, 1);
ib700_debug("watchdog init\n");
s->timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, ib700_timer_expired, s);
portio_list_init(port_list, OBJECT(s), wdt_portio... | 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": "848696bf353750899832c51005f1bd3540da5c29",
"normalized_at": "2026-06-20T05:17:39.274669Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017228 | CodeXGLUE Defect Detection | public_dataset | train | 21524 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void numa_node_parse_cpus(int nodenr, const char *cpus)
{
char *endptr;
unsigned long long value, endvalue;
value = strtoull(cpus, &endptr, 10);
if (*endptr == '-') {
endvalue = strtoull(endptr+1, &endptr, 10);
} else {
endvalue = value;
}
if (!(endvalue ... | 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": "c881e20eed4911ab6f8c674f2b1bf225a2cdde71",
"normalized_at": "2026-06-20T05:17:39.364418Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001775 | CodeXGLUE Defect Detection | public_dataset | train | 2168 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static inline void gen_op_jz_ecx(TCGMemOp size, int label1)
{
tcg_gen_mov_tl(cpu_tmp0, cpu_regs[R_ECX]);
gen_extu(size, cpu_tmp0);
tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, label1);
}
| 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": "42a268c241183877192c376d03bd9b6d527407c7",
"normalized_at": "2026-06-20T05:17:38.965144Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004203 | CodeXGLUE Defect Detection | public_dataset | train | 5200 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static inline void gen_intermediate_code_internal(CPUState *env,
TranslationBlock *tb,
int search_pc)
{
DisasContext ctx, *ctxp = &ctx;
opc_handler_t **table, *handler;
target_ulong pc_start;
uint1... | 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": "6c7123212223eb7f281230e9852f011255d73582",
"normalized_at": "2026-06-20T05:17:39.031201Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018897 | CodeXGLUE Defect Detection | public_dataset | train | 23607 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static CURLState *curl_init_state(BDRVCURLState *s)
{
CURLState *state = NULL;
int i, j;
do {
for (i=0; i<CURL_NUM_STATES; i++) {
for (j=0; j<CURL_NUM_ACB; j++)
if (s->states[i].acb[j])
continue;
if (s->states[i].in_use)
... | 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": "63f0f45f2e89b60ff8245fec81328ddfde42a303",
"normalized_at": "2026-06-20T05:17:39.411342Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007278 | CodeXGLUE Defect Detection | public_dataset | train | 9034 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int check_strtox_error(const char *nptr, char *ep,
const char **endptr, int libc_errno)
{
if (libc_errno == 0 && ep == nptr) {
libc_errno = EINVAL;
}
if (!endptr && *ep) {
return -EINVAL;
}
if (endptr) {
*endptr = ep;
}
... | 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": "4baef2679e029c76707be1e2ed54bf3dd21693fe",
"normalized_at": "2026-06-20T05:17:39.109258Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020448 | CodeXGLUE Defect Detection | public_dataset | train | 25561 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void ff_snow_vertical_compose97i_mmx(IDWTELEM *b0, IDWTELEM *b1, IDWTELEM *b2, IDWTELEM *b3, IDWTELEM *b4, IDWTELEM *b5, int width){
long i = width;
while(i & 15)
{
i--;
b4[i] -= (W_DM*(b3[i] + b5[i])+W_DO)>>W_DS;
b3[i] -= (W_CM*(b2[i] + b4[i])+W_CO)>>W_CS;
b2[i] += (W... | 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": "cefa5999534de75686607891b4c06f5b8bd99991",
"normalized_at": "2026-06-20T05:17:39.452727Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009184 | CodeXGLUE Defect Detection | public_dataset | train | 11425 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int decode_i_block(FourXContext *f, int16_t *block)
{
int code, i, j, level, val;
if (get_bits_left(&f->gb) < 2){
av_log(f->avctx, AV_LOG_ERROR, "%d bits left before decode_i_block()\n", get_bits_left(&f->gb));
return -1;
}
/* DC coef */
val = get_vlc2(&f->pre_gb, ... | 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": "13c56e9a9cf18f33bcbc2dc1a5cf2a5f98ca9702",
"normalized_at": "2026-06-20T05:17:39.155622Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016749 | CodeXGLUE Defect Detection | public_dataset | train | 20928 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int vma_add_mapping(struct mm_struct *mm, abi_ulong start,
abi_ulong end, abi_ulong flags)
{
struct vm_area_struct *vma;
if ((vma = qemu_mallocz(sizeof (*vma))) == NULL)
return (-1);
vma->vma_start = start;
vma->vma_end = end;
vma->vma_flags = flags;
TAILQ_INSER... | 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": "72cf2d4f0e181d0d3a3122e04129c58a95da713e",
"normalized_at": "2026-06-20T05:17:39.350812Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020622 | CodeXGLUE Defect Detection | public_dataset | train | 25790 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
{
MpegEncContext *s = &v->s;
int i;
int mb_height = FFALIGN(s->mb_height, 2);
/* Allocate mb bitplanes */
v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
v->direct_mb_plane = av_malloc (s->mb_stride * mb_height);
... | 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": "01f0e6a0c9270f1d5bef08459a6f167cf55e0596",
"normalized_at": "2026-06-20T05:17:39.456449Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016083 | CodeXGLUE Defect Detection | public_dataset | train | 20100 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int xen_domain_watcher(void)
{
int qemu_running = 1;
int fd[2], i, n, rc;
char byte;
if (pipe(fd) != 0) {
qemu_log("%s: Huh? pipe error: %s\n", __FUNCTION__, strerror(errno));
return -1;
}
if (fork() != 0)
return 0; /* not child */
/* close all 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": false,
"project": "qemu",
"commit_id": "d5b93ddfefe63d5869a8eb97ea3474867d3b105b",
"normalized_at": "2026-06-20T05:17:39.333678Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000329 | OWASP Benchmark Python | public_dataset | processed | 329 | python | generic | security_review | CWE-328 | A02: Cryptographic Failures | medium | true | 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/BenchmarkTest00329.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.695004Z",
"name_fixed_at": "2026-06-20T05:22:49.830909Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018826 | CodeXGLUE Defect Detection | public_dataset | train | 23525 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static inline void gen_cmps(DisasContext *s, int ot)
{
gen_string_movl_A0_ESI(s);
gen_op_ld_T0_A0(ot + s->mem_index);
gen_string_movl_A0_EDI(s);
gen_op_ld_T1_A0(ot + s->mem_index);
gen_op_cmpl_T0_T1_cc();
gen_op_movl_T0_Dshift[ot]();
#ifdef TARGET_X86_64
if (s->aflag == 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": false,
"project": "qemu",
"commit_id": "6e0d8677cb443e7408c0b7a25a93c6596d7fa380",
"normalized_at": "2026-06-20T05:17:39.409389Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016134 | CodeXGLUE Defect Detection | public_dataset | train | 20165 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void guess_mv(ERContext *s)
{
uint8_t *fixed = s->er_temp_buffer;
#define MV_FROZEN 3
#define MV_CHANGED 2
#define MV_UNCHANGED 1
const int mb_stride = s->mb_stride;
const int mb_width = s->mb_width;
const int mb_height = s->mb_height;
int i, depth, num_avail;
int mb_x, mb... | 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": "7cb66ebc0be48489785f7166c9d15eac594b0763",
"normalized_at": "2026-06-20T05:17:39.335365Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010336 | CodeXGLUE Defect Detection | public_dataset | train | 12886 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void spapr_machine_class_init(ObjectClass *oc, void *data)
{
MachineClass *mc = MACHINE_CLASS(oc);
sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(oc);
FWPathProviderClass *fwc = FW_PATH_PROVIDER_CLASS(oc);
NMIClass *nc = NMI_CLASS(oc);
HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(oc);
... | 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": "079019f2e319bd1279681b6c1d7dde785d09e69e",
"normalized_at": "2026-06-20T05:17:39.185315Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012164 | CodeXGLUE Defect Detection | public_dataset | train | 15148 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int mjpeg_decode_app(MJpegDecodeContext *s)
{
int len, id, i;
len = get_bits(&s->gb, 16);
if (len < 6)
return AVERROR_INVALIDDATA;
if (8 * len > get_bits_left(&s->gb))
return AVERROR_INVALIDDATA;
id = get_bits_long(&s->gb, 32);
len -= 6;
if (s->avctx-... | 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": "4acea512f36b96256535b45b1a7e723c61c89c31",
"normalized_at": "2026-06-20T05:17:39.232160Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015804 | CodeXGLUE Defect Detection | public_dataset | train | 19747 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void add_machine_test_cases(void)
{
const char *arch = qtest_get_arch();
QDict *response, *minfo;
QList *list;
const QListEntry *p;
QObject *qobj;
QString *qstr;
const char *mname, *path;
qtest_start("-machine none");
response = qmp("{ 'execute': 'query-machines' }... | 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": "ff1685a3338072be9a94ab8a8f529c12e4265224",
"normalized_at": "2026-06-20T05:17:39.326619Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001385 | CodeXGLUE Defect Detection | public_dataset | train | 1696 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int megasas_cache_flush(MegasasState *s, MegasasCmd *cmd)
{
bdrv_drain_all();
return MFI_STAT_OK;
}
| 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": "4be746345f13e99e468c60acbd3a355e8183e3ce",
"normalized_at": "2026-06-20T05:17:38.955292Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017744 | CodeXGLUE Defect Detection | public_dataset | train | 22171 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void ff_ac3_bit_alloc_calc_psd(int8_t *exp, int start, int end, int16_t *psd,
int16_t *band_psd)
{
int bin, j, k, end1, v;
/* exponent mapping to PSD */
for(bin=start;bin<end;bin++) {
psd[bin]=(3072 - (exp[bin] << 7));
}
/* PSD integration */
j... | 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": "a7e7417c41c2c85495b74074b96989c5d68bae22",
"normalized_at": "2026-06-20T05:17:39.379937Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_000218 | CodeXGLUE Defect Detection | public_dataset | train | 269 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int ff_h264_frame_start(H264Context *h)
{
Picture *pic;
int i, ret;
const int pixel_shift = h->pixel_shift;
int c[4] = {
1<<(h->sps.bit_depth_luma-1),
1<<(h->sps.bit_depth_chroma-1),
1<<(h->sps.bit_depth_chroma-1),
-1
};
if (!ff_thread_can_start_frame... | 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": "259603b9176701410d6edeedbcbde565c767f27b",
"normalized_at": "2026-06-20T05:17:38.921749Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016144 | CodeXGLUE Defect Detection | public_dataset | train | 20176 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void close_decoder(QSVContext *q)
{
QSVFrame *cur;
if (q->session)
MFXVideoDECODE_Close(q->session);
while (q->async_fifo && av_fifo_size(q->async_fifo)) {
QSVFrame *out_frame;
mfxSyncPoint *sync;
av_fifo_generic_read(q->async_fifo, &out_frame, sizeof(out... | 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": "b4054100f675b395204f1a0471fba0b06fe08e9f",
"normalized_at": "2026-06-20T05:17:39.335665Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002572 | CodeXGLUE Defect Detection | public_dataset | train | 3131 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void ide_atapi_cmd_read_dma_cb(void *opaque, int ret)
{
IDEState *s = opaque;
int data_offset, n;
if (ret < 0) {
ide_atapi_io_error(s, ret);
goto eot;
}
if (s->io_buffer_size > 0) {
/*
* For a cdrom read sector command (s->lba != -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": "qemu",
"commit_id": "ece2d05ed4adb9a9aa3ca9da0496be769dfb3a25",
"normalized_at": "2026-06-20T05:17:38.987853Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003929 | CodeXGLUE Defect Detection | public_dataset | train | 4841 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void mainstone_common_init(int ram_size, int vga_ram_size,
DisplayState *ds, const char *kernel_filename,
const char *kernel_cmdline, const char *initrd_filename,
const char *cpu_model, enum mainstone_model_e model, int arm_id)
{
uint32_t mainstone_ram = 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": "8543243c29a60f102d7a3d98027b46bc8cdac421",
"normalized_at": "2026-06-20T05:17:39.024268Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003496 | CodeXGLUE Defect Detection | public_dataset | train | 4292 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int qcrypto_hash_bytesv(QCryptoHashAlgorithm alg,
const struct iovec *iov G_GNUC_UNUSED,
size_t niov G_GNUC_UNUSED,
uint8_t **result G_GNUC_UNUSED,
size_t *resultlen G_GNUC_UNUSED,
Error **errp)
... | 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": "2165477c0f65d20fdfbdb2ddcd4e0e7fe8f61df5",
"normalized_at": "2026-06-20T05:17:39.013014Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005112 | CodeXGLUE Defect Detection | public_dataset | train | 6347 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int bdrv_flush(BlockDriverState *bs)
{
Coroutine *co;
FlushCo flush_co = {
.bs = bs,
.ret = NOT_DONE,
};
if (qemu_in_coroutine()) {
/* Fast-path if already in coroutine context */
bdrv_flush_co_entry(&flush_co);
} else {
co = qemu_coroutine_create... | 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": "e92f0e1910f0655a0edd8d87c5a7262d36517a89",
"normalized_at": "2026-06-20T05:17:39.054251Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011667 | CodeXGLUE Defect Detection | public_dataset | train | 14518 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
{
DNXHDEncContext *ctx = avctx->priv_data;
int mb_y = jobnr, mb_x;
ctx = ctx->thread[threadnr];
if (ctx->cid_table->bit_depth == 8) {
uint8_t *pix = ctx->thread[0]->src[0] + ((mb_y<<4) * ctx->m.linesi... | 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": "d341d5fd2cd7e301a20dcb50f3e1445571765023",
"normalized_at": "2026-06-20T05:17:39.220950Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008183 | CodeXGLUE Defect Detection | public_dataset | train | 10179 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void qtest_quit(QTestState *s)
{
int status;
pid_t pid = qtest_qemu_pid(s);
if (pid != -1) {
kill(pid, SIGTERM);
waitpid(pid, &status, 0);
}
unlink(s->pid_file);
unlink(s->socket_path);
unlink(s->qmp_socket_path);
g_free(s->pid_file);
g_free(s->sock... | 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": "fdd26fca3ce66863e547560fbde1a444fc5d71b7",
"normalized_at": "2026-06-20T05:17:39.130658Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_006645 | CodeXGLUE Defect Detection | public_dataset | train | 8289 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void tcg_out_reloc(TCGContext *s, tcg_insn_unit *code_ptr, int type,
int label_index, intptr_t addend)
{
TCGLabel *l;
TCGRelocation *r;
l = &s->labels[label_index];
if (l->has_value) {
/* FIXME: This may break relocations on RISC targets that
... | 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": "bec1631100323fac0900aea71043d5c4e22fc2fa",
"normalized_at": "2026-06-20T05:17:39.093095Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007511 | CodeXGLUE Defect Detection | public_dataset | train | 9328 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | NEON_TYPE4(s8, int8_t)
NEON_TYPE4(u8, uint8_t)
NEON_TYPE2(s16, int16_t)
NEON_TYPE2(u16, uint16_t)
NEON_TYPE1(s32, int32_t)
NEON_TYPE1(u32, uint32_t)
#undef NEON_TYPE4
#undef NEON_TYPE2
#undef NEON_TYPE1
/* Copy from a uint32_t to a vector structure type. */
#define NEON_UNPACK(vtype, dest, val) do { \
union { \
... | 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": "72902672dc2ed6281cdb205259c1d52ecf01f6b2",
"normalized_at": "2026-06-20T05:17:39.115027Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020074 | CodeXGLUE Defect Detection | public_dataset | train | 25102 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | USBBus *usb_bus_find(int busnr)
{
USBBus *bus;
if (-1 == busnr)
return TAILQ_FIRST(&busses);
TAILQ_FOREACH(bus, &busses, next) {
if (bus->busnr == busnr)
return bus;
}
return 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": "72cf2d4f0e181d0d3a3122e04129c58a95da713e",
"normalized_at": "2026-06-20T05:17:39.443829Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008697 | CodeXGLUE Defect Detection | public_dataset | train | 10827 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static inline int gsm_mult(int a, int b)
{
return (a * b + (1 << 14)) >> 15;
}
| 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": "a59505ca76718549dfc51b9622e2d88cb60f33b5",
"normalized_at": "2026-06-20T05:17:39.142595Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007932 | CodeXGLUE Defect Detection | public_dataset | train | 9878 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int read_uncompressed_sgi(const SGIInfo *si,
AVPicture *pict, ByteIOContext *f)
{
int x, y, z, chan_offset, ret = 0;
uint8_t *dest_row, *tmp_row = NULL;
tmp_row = av_malloc(si->xsize);
/* skip header */
url_fseek(f, SGI_HEADER_SIZE, SEEK_SET);
pict->linesize[0] = 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": "FFmpeg",
"commit_id": "44f110f509d0ab4fc73b9f2363a97c6577d3850f",
"normalized_at": "2026-06-20T05:17:39.125190Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007696 | CodeXGLUE Defect Detection | public_dataset | train | 9564 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void OPPROTO op_addq_ESI_T0(void)
{
ESI = (ESI + T0);
}
| 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.119561Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_021689 | CodeXGLUE Defect Detection | public_dataset | train | 27117 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int oma_read_packet(AVFormatContext *s, AVPacket *pkt)
{
OMAContext *oc = s->priv_data;
AVStream *st = s->streams[0];
int packet_size = st->codec->block_align;
int byte_rate = st->codec->bit_rate >> 3;
int64_t pos = avio_tell(s->pb);
int ret = av_get_packet(s->pb,... | 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": "7c2fa13df9a6130b3f258c7513933cbdca2fe23b",
"normalized_at": "2026-06-20T05:17:39.488916Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016352 | CodeXGLUE Defect Detection | public_dataset | train | 20432 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int dxtory_decode_v2_410(AVCodecContext *avctx, AVFrame *pic,
const uint8_t *src, int src_size)
{
GetByteContext gb;
GetBitContext gb2;
int nslices, slice, slice_height, ref_slice_height;
int cur_y, next_y;
uint32_t off, slice_size;
uint8_t *Y, *U,... | 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": "6a6bc43f5f79587b8936334cc0b3a6616f4807ac",
"normalized_at": "2026-06-20T05:17:39.340630Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_006232 | CodeXGLUE Defect Detection | public_dataset | train | 7748 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void fdt_add_psci_node(const VirtBoardInfo *vbi)
{
void *fdt = vbi->fdt;
ARMCPU *armcpu = ARM_CPU(qemu_get_cpu(0));
/* No PSCI for TCG yet */
if (kvm_enabled()) {
qemu_fdt_add_subnode(fdt, "/psci");
if (armcpu->psci_version == 2) {
const char comp[] = "arm,ps... | 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": "863714ba6cdc09d1a84069815dc67c8da66b0a29",
"normalized_at": "2026-06-20T05:17:39.083032Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005990 | CodeXGLUE Defect Detection | public_dataset | train | 7447 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void generate_new_codebooks(RoqContext *enc, RoqTempdata *tempData)
{
int i,j;
RoqCodebooks *codebooks = &tempData->codebooks;
int max = enc->width*enc->height/16;
uint8_t mb2[3*4];
roq_cell *results4 = av_malloc(sizeof(roq_cell)*MAX_CBS_4x4*4);
uint8_t *yuvClusters=av_malloc(sizeo... | 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": "3beb9cbad35218ed1fb3473eeb3cfc97a931bff4",
"normalized_at": "2026-06-20T05:17:39.077096Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020916 | CodeXGLUE Defect Detection | public_dataset | train | 26142 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static av_always_inline void hl_decode_mb_predict_luma(H264Context *h, int mb_type, int is_h264, int simple, int transform_bypass,
int pixel_shift, int *block_offset, int linesize, uint8_t *dest_y, int p)
{
MpegEncContext * const s = &h->s;
void (*idct_... | 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": "4d1418cd4f620b382106542d0f33d96e33a0fdae",
"normalized_at": "2026-06-20T05:17:39.463531Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018800 | CodeXGLUE Defect Detection | public_dataset | train | 23490 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void tlb_info_32(Monitor *mon, CPUState *env)
{
int l1, l2;
uint32_t pgd, pde, pte;
pgd = env->cr[3] & ~0xfff;
for(l1 = 0; l1 < 1024; l1++) {
cpu_physical_memory_read(pgd + l1 * 4, &pde, 4);
pde = le32_to_cpu(pde);
if (pde & PG_PRESENT_MASK) {
if ((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": false,
"project": "qemu",
"commit_id": "94ac5cd20c6e441e0ed3aec5c98d6cbefb7f503f",
"normalized_at": "2026-06-20T05:17:39.408713Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_001156 | OWASP Benchmark Python | public_dataset | processed | 1156 | python | generic | security_review | CWE-601 | A01: Broken Access Control | medium | false | Open Redirect | '''
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-601"
] | {
"raw_path": "testcode/BenchmarkTest01156.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.732460Z",
"name_fixed_at": "2026-06-20T05:22:49.842735Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011585 | CodeXGLUE Defect Detection | public_dataset | train | 14423 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | START_TEST(qdict_new_test)
{
QDict *qdict;
qdict = qdict_new();
fail_unless(qdict != NULL);
fail_unless(qdict_size(qdict) == 0);
fail_unless(qdict->base.refcnt == 1);
fail_unless(qobject_type(QOBJECT(qdict)) == QTYPE_QDICT);
// destroy doesn't exit yet
free(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": false,
"project": "qemu",
"commit_id": "ac531cb6e542b1e61d668604adf9dc5306a948c0",
"normalized_at": "2026-06-20T05:17:39.218511Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010285 | CodeXGLUE Defect Detection | public_dataset | train | 12826 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int tcp_set_msgfds(CharDriverState *chr, int *fds, int num)
{
TCPCharDriver *s = chr->opaque;
/* clear old pending fd array */
g_free(s->write_msgfds);
if (num) {
s->write_msgfds = g_malloc(num * sizeof(int));
memcpy(s->write_msgfds, fds, num * sizeof(int));
}
... | 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": "2d528d45ecf5ee3c1a566a9f3d664464925ef830",
"normalized_at": "2026-06-20T05:17:39.184249Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015616 | CodeXGLUE Defect Detection | public_dataset | train | 19513 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void qerror_report(const char *fmt, ...)
{
va_list va;
QError *qerror;
va_start(va, fmt);
qerror = qerror_from_info(fmt, &va);
va_end(va);
if (monitor_cur_is_qmp()) {
monitor_set_error(cur_mon, qerror);
} else {
qerror_print(qerror);
QDECREF(qerror);
... | 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": "13f59ae8157e8ec238fa8aefe5309909a1eeb7e2",
"normalized_at": "2026-06-20T05:17:39.320311Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000525 | OWASP Benchmark Python | public_dataset | processed | 525 | python | generic | security_review | CWE-22 | A01: Broken Access Control | medium | false | Path Traversal | '''
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-22"
] | {
"raw_path": "testcode/BenchmarkTest00525.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.703434Z",
"name_fixed_at": "2026-06-20T05:22:49.834169Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018172 | CodeXGLUE Defect Detection | public_dataset | train | 22698 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int decode_update_thread_context(AVCodecContext *dst, const AVCodecContext *src){
H264Context *h= dst->priv_data, *h1= src->priv_data;
MpegEncContext * const s = &h->s, * const s1 = &h1->s;
int inited = s->context_initialized, err;
int i;
if(dst == src || !s1->context_initialized) retu... | 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": "05ebe51e00e900bcef7d3e9bcd6b91d4aab34de7",
"normalized_at": "2026-06-20T05:17:39.392676Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002492 | CodeXGLUE Defect Detection | public_dataset | train | 3034 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void avcodec_get_context_defaults2(AVCodecContext *s, enum AVMediaType codec_type){
int flags=0;
memset(s, 0, sizeof(AVCodecContext));
s->av_class= &av_codec_context_class;
s->codec_type = codec_type;
if(codec_type == AVMEDIA_TYPE_AUDIO)
flags= AV_OPT_FLAG_AUDIO_PARAM;
else if... | 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": "79eff9132581af69fbbd2674337b75fad29aa306",
"normalized_at": "2026-06-20T05:17:38.985595Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011207 | CodeXGLUE Defect Detection | public_dataset | train | 13960 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void test_source_flush_event_notifier(void)
{
EventNotifierTestData data = { .n = 0, .active = 10, .auto_set = true };
event_notifier_init(&data.e, false);
aio_set_event_notifier(ctx, &data.e, event_ready_cb);
g_assert(g_main_context_iteration(NULL, false));
g_assert_cmpint(data.n, ==, ... | 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": "12d69ac03b45156356b240424623719f15d8143e",
"normalized_at": "2026-06-20T05:17:39.208994Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013073 | CodeXGLUE Defect Detection | public_dataset | train | 16284 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static av_cold int init(AVFilterContext *ctx)
{
FormatContext *s = ctx->priv;
char *cur, *sep;
int nb_formats = 1;
int i;
int ret;
/* count the formats */
cur = s->pix_fmts;
while ((cur = strchr(cur, '|'))) {
nb_formats++;
if (*cur)
cur++;
}... | 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": "126524720661a9adddec758e94729007a96f07f7",
"normalized_at": "2026-06-20T05:17:39.255984Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003048 | CodeXGLUE Defect Detection | public_dataset | train | 3727 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void coroutine_fn aio_read_response(void *opaque)
{
SheepdogObjRsp rsp;
BDRVSheepdogState *s = opaque;
int fd = s->fd;
int ret;
AIOReq *aio_req = NULL;
SheepdogAIOCB *acb;
uint64_t idx;
/* read a header */
ret = qemu_co_recv(fd, &rsp, sizeof(rsp));
if (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": true,
"project": "qemu",
"commit_id": "b544c1aba8681c2fe5d6715fbd37cf6caf1bc7bb",
"normalized_at": "2026-06-20T05:17:39.001421Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009414 | CodeXGLUE Defect Detection | public_dataset | train | 11717 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int mkv_write_tracks(AVFormatContext *s)
{
MatroskaMuxContext *mkv = s->priv_data;
AVIOContext *pb = s->pb;
ebml_master tracks;
int i, j, ret;
ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TRACKS, avio_tell(pb));
if (ret < 0) return ret;
tracks = start_ebml_... | 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": "2dbc84b1a8d39e7fa0c7d66a120838fced35f5b4",
"normalized_at": "2026-06-20T05:17:39.162191Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020450 | CodeXGLUE Defect Detection | public_dataset | train | 25563 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void av_thread_message_flush(AVThreadMessageQueue *mq)
{
#if HAVE_THREADS
int used, off;
void *free_func = mq->free_func;
pthread_mutex_lock(&mq->lock);
used = av_fifo_size(mq->fifo);
if (free_func)
for (off = 0; off < used; off += mq->elsize)
av_fifo_generic_peek_at(m... | 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": "bd5c860fdbc33d19d2ff0f6d1f06de07c17560dd",
"normalized_at": "2026-06-20T05:17:39.452772Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008630 | CodeXGLUE Defect Detection | public_dataset | train | 10746 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void quantize_and_encode_band_cost_UQUAD_mips(struct AACEncContext *s,
PutBitContext *pb, const float *in, float *out,
const float *scaled, int size, int scale_idx,
... | 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": "01ecb7172b684f1c4b3e748f95c5a9a494ca36ec",
"normalized_at": "2026-06-20T05:17:39.140921Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_000319 | CodeXGLUE Defect Detection | public_dataset | train | 400 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void dct_unquantize_mpeg1_mmx(MpegEncContext *s,
DCTELEM *block, int n, int qscale)
{
int i, level;
const UINT16 *quant_matrix;
if (s->mb_intra) {
if (n < 4)
block[0] = block[0] * s->y_dc_scale;
else
block[0] = blo... | 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": "f12e206b4737b84afa6071f4b464664a50b0c916",
"normalized_at": "2026-06-20T05:17:38.925190Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017553 | CodeXGLUE Defect Detection | public_dataset | train | 21926 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | av_cold int ff_h264_decode_init(AVCodecContext *avctx)
{
H264Context *h = avctx->priv_data;
int i;
int ret;
h->avctx = avctx;
h->bit_depth_luma = 8;
h->chroma_format_idc = 1;
h->cur_chroma_format_idc = 1;
ff_h264dsp_init(&h->h264dsp, 8, 1);
av_assert0(h->sps.bit_... | 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": "4b7356ce8f2c7902a9b97645f86e0ae09bc2676c",
"normalized_at": "2026-06-20T05:17:39.374570Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020971 | CodeXGLUE Defect Detection | public_dataset | train | 26212 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int add_crc_to_array(uint32_t crc, int64_t pts)
{
if (size_of_array <= number_of_elements) {
if (size_of_array == 0)
size_of_array = 10;
size_of_array *= 2;
crc_array = av_realloc(crc_array, size_of_array * sizeof(uint32_t));
pts_array = av_realloc(pts_array... | 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": "ff17c76e92cd9a9072a8771cad73c96cd620040b",
"normalized_at": "2026-06-20T05:17:39.465198Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011571 | CodeXGLUE Defect Detection | public_dataset | train | 14407 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int mig_save_device_bulk(Monitor *mon, QEMUFile *f,
BlkMigDevState *bmds)
{
int64_t total_sectors = bmds->total_sectors;
int64_t cur_sector = bmds->cur_sector;
BlockDriverState *bs = bmds->bs;
BlkMigBlock *blk;
int nr_sectors;
if (bmds->shared_bas... | 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": "539de1246d355d3b8aa33fb7cde732352d8827c7",
"normalized_at": "2026-06-20T05:17:39.218208Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013515 | CodeXGLUE Defect Detection | public_dataset | train | 16846 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | target_ulong helper_dvpe(CPUMIPSState *env)
{
CPUMIPSState *other_cpu = first_cpu;
target_ulong prev = env->mvp->CP0_MVPControl;
do {
/* Turn off all VPEs except the one executing the dvpe. */
if (other_cpu != env) {
other_cpu->mvp->CP0_MVPControl &= ~(1 << CP0MVPCo_EVP... | 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": "81bad50ec40311797c38a7691844c7d2df9b3823",
"normalized_at": "2026-06-20T05:17:39.265556Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010346 | CodeXGLUE Defect Detection | public_dataset | train | 12898 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void ioinst_handle_schm(S390CPU *cpu, uint64_t reg1, uint64_t reg2,
uint32_t ipb)
{
uint8_t mbk;
int update;
int dct;
CPUS390XState *env = &cpu->env;
trace_ioinst("schm");
if (SCHM_REG1_RES(reg1)) {
program_interrupt(env, PGM_OPERAND, 2);
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": "7e01376daea75e888c370aab521a7d4aeaf2ffd1",
"normalized_at": "2026-06-20T05:17:39.185521Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007535 | CodeXGLUE Defect Detection | public_dataset | train | 9364 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static char *doubles2str(double *dp, int count, const char *sep)
{
int i;
char *ap, *ap0;
int component_len;
if (!sep) sep = ", ";
component_len = 15 + strlen(sep);
ap = av_malloc(component_len * count);
if (!ap)
return NULL;
ap0 = ap;
ap[0] = '\0';
for (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": "e1219cdaf9fb4bc8cea410e1caf802373c1bfe51",
"normalized_at": "2026-06-20T05:17:39.115611Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007222 | CodeXGLUE Defect Detection | public_dataset | train | 8969 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void s390_print_cpu_model_list_entry(gpointer data, gpointer user_data)
{
CPUListState *s = user_data;
const S390CPUClass *scc = S390_CPU_CLASS((ObjectClass *)data);
char *name = g_strdup(object_class_get_name((ObjectClass *)data));
const char *details = "";
if (scc->is_static) {
... | 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": "e555cbe78d59f09f7e7db7703d1e91b95f2743c0",
"normalized_at": "2026-06-20T05:17:39.108041Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012540 | CodeXGLUE Defect Detection | public_dataset | train | 15616 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int ac3_probe(AVProbeData *p)
{
int max_frames, first_frames = 0, frames;
uint8_t *buf, *buf2, *end;
AC3HeaderInfo hdr;
if(p->buf_size < 7)
return 0;
max_frames = 0;
buf = p->buf;
end = buf + p->buf_size;
for(; buf < end; buf++) {
buf2 = 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": "d1a4544de904cc76fea32d9d22252152ebb18edb",
"normalized_at": "2026-06-20T05:17:39.242037Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002214 | CodeXGLUE Defect Detection | public_dataset | train | 2701 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void ff_h264_direct_dist_scale_factor(H264Context * const h){
const int poc = h->cur_pic_ptr->field_poc[h->picture_structure == PICT_BOTTOM_FIELD];
const int poc1 = h->ref_list[1][0].poc;
int i, field;
if (FRAME_MBAFF(h))
for (field = 0; field < 2; field++){
const int poc = ... | 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": "ebd1c505d22ad96e044880755ed9f4cf7cab4f78",
"normalized_at": "2026-06-20T05:17:38.977931Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008449 | CodeXGLUE Defect Detection | public_dataset | train | 10517 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int png_decode_idat(PNGDecContext *s, int length)
{
int ret;
s->zstream.avail_in = FFMIN(length, bytestream2_get_bytes_left(&s->gb));
s->zstream.next_in = (unsigned char *)s->gb.buffer;
bytestream2_skip(&s->gb, length);
/* decode one line if possible */
while (s->zstream.avail_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": "FFmpeg",
"commit_id": "478f1c3d5e5463a284ea7efecfc62d47ba3be11a",
"normalized_at": "2026-06-20T05:17:39.136951Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003810 | CodeXGLUE Defect Detection | public_dataset | train | 4692 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void ff_configure_buffers_for_index(AVFormatContext *s, int64_t time_tolerance)
{
int ist1, ist2;
int64_t pos_delta = 0;
//We could use URLProtocol flags here but as many user applications do not use URLProtocols this would be unreliable
const char *proto = avio_find_protocol_name(s->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": true,
"project": "FFmpeg",
"commit_id": "130a8e0eef2f81e0d853117e417b650c3e16d1b7",
"normalized_at": "2026-06-20T05:17:39.021454Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015794 | CodeXGLUE Defect Detection | public_dataset | train | 19737 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void vmsvga_init(struct vmsvga_state_s *s,
MemoryRegion *address_space, MemoryRegion *io)
{
DisplaySurface *surface;
s->scratch_size = SVGA_SCRATCH_SIZE;
s->scratch = g_malloc(s->scratch_size * 4);
s->vga.con = graphic_console_init(vmsvga_update_display,
... | 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": "eb2f9b024d68884a3b25e63e4dbf90b67f8da236",
"normalized_at": "2026-06-20T05:17:39.326337Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_000897 | CodeXGLUE Defect Detection | public_dataset | train | 1100 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int slirp_is_inited(void)
{
return slirp_inited;
}
| 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": "d918f23efaf486293b96418fe5deaff8a5583304",
"normalized_at": "2026-06-20T05:17:38.942112Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000603 | OWASP Benchmark Python | public_dataset | processed | 603 | python | generic | security_review | CWE-94 | A03: Injection | high | false | Code 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-94"
] | {
"raw_path": "testcode/BenchmarkTest00603.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.706751Z",
"name_fixed_at": "2026-06-20T05:22:49.835489Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015097 | CodeXGLUE Defect Detection | public_dataset | train | 18869 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void nvdimm_dsm_root(NvdimmDsmIn *in, hwaddr dsm_mem_addr)
{
/*
* function 0 is called to inquire which functions are supported by
* OSPM
*/
if (!in->function) {
nvdimm_dsm_function0(0 /* No function supported other than
function 0 */, dsm_... | 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": "c2fa30757a2ba1bb5b053883773a9a61fbdd7082",
"normalized_at": "2026-06-20T05:17:39.306849Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015036 | CodeXGLUE Defect Detection | public_dataset | train | 18794 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void monitor_protocol_emitter(Monitor *mon, QObject *data,
QError *err)
{
QDict *qmp;
trace_monitor_protocol_emitter(mon);
if (!err) {
/* success response */
qmp = qdict_new();
if (data) {
qobject_incref(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": false,
"project": "qemu",
"commit_id": "710aec915d208246891b68e2ba61b54951edc508",
"normalized_at": "2026-06-20T05:17:39.305170Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011131 | CodeXGLUE Defect Detection | public_dataset | train | 13870 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int config_out_props(AVFilterLink *outlink)
{
AVFilterContext *ctx = outlink->src;
AVFilterLink *inlink = outlink->src->inputs[0];
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(outlink->format);
TInterlaceContext *tinterlace = ctx->priv;
int i;
tinterlace->vsub = desc->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": "3af1060319b46005dbfb3b01f9104539caf30146",
"normalized_at": "2026-06-20T05:17:39.206910Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007972 | CodeXGLUE Defect Detection | public_dataset | train | 9932 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int64_t cache_resize(PageCache *cache, int64_t new_num_pages)
{
PageCache *new_cache;
int64_t i;
CacheItem *old_it, *new_it;
g_assert(cache);
/* cache was not inited */
if (cache->page_cache == NULL) {
return -1;
}
/* same size */
if (pow2floor(new_num_page... | 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": "0db65d624e0211a43c011579d6607a50d8f06082",
"normalized_at": "2026-06-20T05:17:39.126094Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015848 | CodeXGLUE Defect Detection | public_dataset | train | 19801 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int img_compare(int argc, char **argv)
{
const char *fmt1 = NULL, *fmt2 = NULL, *cache, *filename1, *filename2;
BlockBackend *blk1, *blk2;
BlockDriverState *bs1, *bs2;
int64_t total_sectors1, total_sectors2;
uint8_t *buf1 = NULL, *buf2 = NULL;
int pnum1, pnum2;
int allocated1,... | 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": "c919297379e9980c2bcc4d2053addbc1fd6d762b",
"normalized_at": "2026-06-20T05:17:39.327693Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018454 | CodeXGLUE Defect Detection | public_dataset | train | 23043 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void ide_flush_cache(IDEState *s)
{
if (s->bs == NULL) {
ide_flush_cb(s, 0);
return;
}
s->status |= BUSY_STAT;
block_acct_start(bdrv_get_stats(s->bs), &s->acct, 0, BLOCK_ACCT_FLUSH);
s->pio_aiocb = bdrv_aio_flush(s->bs, ide_flush_cb, 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": "4be746345f13e99e468c60acbd3a355e8183e3ce",
"normalized_at": "2026-06-20T05:17:39.400143Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012357 | CodeXGLUE Defect Detection | public_dataset | train | 15385 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
{
BC_STATUS ret;
BC_DTS_STATUS decoder_status = { 0, };
CopyRet rec_ret;
CHDContext *priv = avctx->priv_data;
HANDLE dev = priv->dev;
uint8_t *in_data = avpkt->data;
int 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": "FFmpeg",
"commit_id": "b5f45208fbe5373c7f9112a8169933b73a8478e1",
"normalized_at": "2026-06-20T05:17:39.237708Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014509 | CodeXGLUE Defect Detection | public_dataset | train | 18113 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int spapr_allocate_irq_block(int num, bool lsi)
{
int first = -1;
int i;
for (i = 0; i < num; ++i) {
int irq;
irq = spapr_allocate_irq(0, lsi);
if (!irq) {
return -1;
}
if (0 == i) {
first = irq;
}
/* If the... | 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": "f1c2dc7c866a939c39c14729290a21309a1c8a38",
"normalized_at": "2026-06-20T05:17:39.290901Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008197 | CodeXGLUE Defect Detection | public_dataset | train | 10199 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void vnc_dpy_resize(DisplayState *ds)
{
int size_changed;
VncDisplay *vd = ds->opaque;
VncState *vs;
/* server surface */
if (!vd->server)
vd->server = qemu_mallocz(sizeof(*vd->server));
if (vd->server->data)
qemu_free(vd->server->data);
*(vd->server) = *(d... | 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": "1d4b638ad1fc273a19d93c7d4725fecdd7e5182a",
"normalized_at": "2026-06-20T05:17:39.130987Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019805 | CodeXGLUE Defect Detection | public_dataset | train | 24773 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void av_vlog(void* avcl, int level, const char *fmt, va_list vl)
{
if(av_log_callback)
av_log_callback(avcl, level, fmt, vl);
}
| 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": "3ed65d98c616d52e2544c8b81aa3997f28bb88f5",
"normalized_at": "2026-06-20T05:17:39.437536Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000534 | OWASP Benchmark Python | public_dataset | processed | 534 | python | generic | security_review | CWE-643 | A03: Injection | high | true | 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/BenchmarkTest00534.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.703798Z",
"name_fixed_at": "2026-06-20T05:22:49.834323Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008445 | CodeXGLUE Defect Detection | public_dataset | train | 10512 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static av_cold int mdct_init(AVCodecContext *avctx, AC3MDCTContext *mdct,
int nbits)
{
int i, n, n4, ret;
n = 1 << nbits;
n4 = n >> 2;
mdct->nbits = nbits;
ret = fft_init(avctx, mdct, nbits - 2);
if (ret)
return ret;
mdct->window = ff_a... | 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.136767Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020914 | CodeXGLUE Defect Detection | public_dataset | train | 26139 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int tiff_decode_tag(TiffContext *s, AVFrame *frame)
{
unsigned tag, type, count, off, value = 0, value2 = 0;
int i, start;
int pos;
int ret;
double *dp;
ret = ff_tread_tag(&s->gb, s->le, &tag, &type, &count, &start);
if (ret < 0) {
goto end;
}
off = byte... | 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": "e1c0cfaa419aa5d320540d5a1b3f8fd9b82ab7e5",
"normalized_at": "2026-06-20T05:17:39.463428Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003835 | CodeXGLUE Defect Detection | public_dataset | train | 4724 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void ehci_queues_rip_unused(EHCIState *ehci, int async, int flush)
{
EHCIQueueHead *head = async ? &ehci->aqueues : &ehci->pqueues;
uint64_t maxage = FRAME_TIMER_NS * ehci->maxframes * 4;
EHCIQueue *q, *tmp;
QTAILQ_FOREACH_SAFE(q, head, next, tmp) {
if (q->seen) {
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": false,
"project": "qemu",
"commit_id": "9bc3a3a216e2689bfcdd36c3e079333bbdbf3ba0",
"normalized_at": "2026-06-20T05:17:39.021907Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011141 | CodeXGLUE Defect Detection | public_dataset | train | 13880 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void hpet_set_timer(HPETTimer *t)
{
uint64_t diff;
uint32_t wrap_diff; /* how many ticks until we wrap? */
uint64_t cur_tick = hpet_get_ticks();
/* whenever new timer is being set up, make sure wrap_flag is 0 */
t->wrap_flag = 0;
diff = hpet_calculate_diff(t, cur_tick);
/... | 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": "27bb0b2d6f80f058bdb6fcc8fcdfa69b0c8a6d71",
"normalized_at": "2026-06-20T05:17:39.207297Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009643 | CodeXGLUE Defect Detection | public_dataset | train | 12011 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *picref)
{
AVFilterContext *ctx = inlink->dst;
TInterlaceContext *tinterlace = ctx->priv;
if (tinterlace->cur)
avfilter_unref_buffer(tinterlace->cur);
tinterlace->cur = tinterlace->next;
tinterlace->next = picref;
}
| 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": "18c6bd098baba1ace8fea946e4bc0c60098f49d4",
"normalized_at": "2026-06-20T05:17:39.167398Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016488 | CodeXGLUE Defect Detection | public_dataset | train | 20601 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int omap2_gpio_init(SysBusDevice *sbd)
{
DeviceState *dev = DEVICE(sbd);
struct omap2_gpif_s *s = OMAP2_GPIO(dev);
int i;
if (!s->iclk) {
hw_error("omap2-gpio: iclk not connected\n");
}
if (s->mpu_model < omap3430) {
s->modulecount = (s->mpu_model < omap2430) ? ... | 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": "84a3a53cf61ef691478bd91afa455c801696053c",
"normalized_at": "2026-06-20T05:17:39.343971Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002372 | CodeXGLUE Defect Detection | public_dataset | train | 2886 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static bool msix_is_masked(PCIDevice *dev, int vector)
{
return msix_vector_masked(dev, vector, dev->msix_function_masked);
}
| 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": "70f8ee395afda6d96b15cb9a5b311af7720dded0",
"normalized_at": "2026-06-20T05:17:38.982802Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018306 | CodeXGLUE Defect Detection | public_dataset | train | 22862 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
{
AVCodecInternal *avci = avctx->internal;
InternalBuffer *buf;
int buf_size, ret;
buf_size = av_samples_get_buffer_size(NULL, avctx->channels,
frame->nb_samples, avctx->sample_fmt,
... | 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": "e55c3857d20ba015e4914c2e80fcab037af0799d",
"normalized_at": "2026-06-20T05:17:39.396173Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020413 | CodeXGLUE Defect Detection | public_dataset | train | 25517 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void do_screen_dump(int argc, const char **argv)
{
if (argc != 2) {
help_cmd(argv[0]);
return;
}
vga_screen_dump(argv[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": "9307c4c1d93939db9b04117b654253af5113dc21",
"normalized_at": "2026-06-20T05:17:39.451899Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016589 | CodeXGLUE Defect Detection | public_dataset | train | 20732 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int waveformat_to_audio_settings (WAVEFORMATEX *wfx, audsettings_t *as)
{
if (wfx->wFormatTag != WAVE_FORMAT_PCM) {
dolog ("Invalid wave format, tag is not PCM, but %d\n",
wfx->wFormatTag);
return -1;
}
if (!wfx->nSamplesPerSec) {
dolog ("Invalid wave ... | 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": "1ea879e5580f63414693655fcf0328559cdce138",
"normalized_at": "2026-06-20T05:17:39.346709Z",
"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.