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_016318 | CodeXGLUE Defect Detection | public_dataset | train | 20389 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int eval_refl(int *refl, const int16_t *coefs, RA144Context *ractx)
{
int b, c, i;
unsigned int u;
int buffer1[10];
int buffer2[10];
int *bp1 = buffer1;
int *bp2 = buffer2;
for (i=0; i < 10; i++)
buffer2[i] = coefs[i];
refl[9] = bp2[9];
if ((unsigned) ... | 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": "b888abe1be9f0b3c75273c28e9a7b58fe47d5ec4",
"normalized_at": "2026-06-20T05:17:39.339926Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004140 | CodeXGLUE Defect Detection | public_dataset | train | 5115 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int coroutine_fn qcow2_co_is_allocated(BlockDriverState *bs,
int64_t sector_num, int nb_sectors, int *pnum)
{
BDRVQcowState *s = bs->opaque;
uint64_t cluster_offset;
int ret;
*pnum = nb_sectors;
/* FIXME We can get errors here, but the bdrv_co_is_allocated interface
* c... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "381b487d54ba18c73df9db8452028a330058c505",
"normalized_at": "2026-06-20T05:17:39.029100Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017369 | CodeXGLUE Defect Detection | public_dataset | train | 21696 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void *qpa_thread_in (void *arg)
{
PAVoiceIn *pa = arg;
HWVoiceIn *hw = &pa->hw;
if (audio_pt_lock (&pa->pt, AUDIO_FUNC)) {
return NULL;
}
for (;;) {
int incr, to_grab, wpos;
for (;;) {
if (pa->done) {
goto exit;
... | 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": "ea9ebc2ce69198f7aca4b43652824c5d621ac978",
"normalized_at": "2026-06-20T05:17:39.369164Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008080 | CodeXGLUE Defect Detection | public_dataset | train | 10058 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void spapr_cpu_core_register(const SPAPRCoreInfo *info)
{
TypeInfo type_info = {
.parent = TYPE_SPAPR_CPU_CORE,
.instance_size = sizeof(sPAPRCPUCore),
.instance_init = info->initfn,
};
type_info.name = g_strdup_printf("%s-" TYPE_SPAPR_CPU_CORE, info->name);
type_... | 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": "7ebaf7955603cc50988e0eafd5e6074320fefc70",
"normalized_at": "2026-06-20T05:17:39.128361Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002878 | CodeXGLUE Defect Detection | public_dataset | train | 3520 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int v9fs_synth_name_to_path(FsContext *ctx, V9fsPath *dir_path,
const char *name, V9fsPath *target)
{
V9fsSynthNode *node;
V9fsSynthNode *dir_node;
/* "." and ".." are not allowed */
if (!strcmp(name, ".") || !strcmp(name, "..")) {
errno = EINVA... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "364031f17932814484657e5551ba12957d993d7e",
"normalized_at": "2026-06-20T05:17:38.996108Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012353 | CodeXGLUE Defect Detection | public_dataset | train | 15381 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int mov_read_wave(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
AVStream *st;
if (c->fc->nb_streams < 1)
return 0;
st = c->fc->streams[c->fc->nb_streams-1];
if ((uint64_t)atom.size > (1<<30))
return AVERROR_INVALIDDATA;
if (st->codec->codec_id == AV_CODEC_ID_QD... | 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": "5c720657c23afd798ae0db7c7362eb859a89ab3d",
"normalized_at": "2026-06-20T05:17:39.237644Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014793 | CodeXGLUE Defect Detection | public_dataset | train | 18486 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static CodeBook unpack_codebook(GetBitContext* gb, unsigned depth,
unsigned size)
{
unsigned i, j;
CodeBook cb = { 0 };
if (!can_safely_read(gb, size * 34))
return cb;
if (size >= INT_MAX / sizeof(MacroBlock))
return cb;
cb.blocks = av_ma... | 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": "3d7817048cb387de87600f2152075f78b37b60a6",
"normalized_at": "2026-06-20T05:17:39.298260Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016282 | CodeXGLUE Defect Detection | public_dataset | train | 20346 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int parse_pci_devfn(DeviceState *dev, Property *prop, const char *str)
{
uint32_t *ptr = qdev_get_prop_ptr(dev, prop);
unsigned int slot, fn, n;
if (sscanf(str, "%x.%x%n", &slot, &fn, &n) != 2) {
fn = 0;
if (sscanf(str, "%x%n", &slot, &n) != 1) {
return -EINVAL;
... | 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": "768a9ebe188bd0a6172a9a4e64777d21fff7f014",
"normalized_at": "2026-06-20T05:17:39.338971Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010952 | CodeXGLUE Defect Detection | public_dataset | train | 13652 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | QGuestAllocator *pc_alloc_init(void)
{
PCAlloc *s = g_malloc0(sizeof(*s));
uint64_t ram_size;
QFWCFG *fw_cfg = pc_fw_cfg_init();
s->alloc.alloc = pc_alloc;
s->alloc.free = pc_free;
ram_size = qfw_cfg_get_u64(fw_cfg, FW_CFG_RAM_SIZE);
/* Start at 1MB */
s->start = 1 << 20;
/* Respect ... | 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": "f3cdcbaee16d32b52d5015a8b1e8ddf5a27f7089",
"normalized_at": "2026-06-20T05:17:39.201616Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002212 | CodeXGLUE Defect Detection | public_dataset | train | 2699 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static BusState *qbus_find(const char *path)
{
DeviceState *dev;
BusState *bus;
char elem[128];
int pos, len;
/* find start element */
if (path[0] == '/') {
bus = sysbus_get_default();
pos = 0;
} else {
if (sscanf(path, "%127[^/]%n", elem, &len) != 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": "ed238ba2a0239368dd0cec9bfaf3300a5bd303ce",
"normalized_at": "2026-06-20T05:17:38.977896Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017551 | CodeXGLUE Defect Detection | public_dataset | train | 21923 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static CharDriverState *qemu_chr_open_pty(const char *id,
ChardevReturn *ret)
{
CharDriverState *chr;
PtyCharDriver *s;
int master_fd, slave_fd;
char pty_name[PATH_MAX];
master_fd = qemu_openpty_raw(&slave_fd, pty_name);
if (master_fd < 0) {
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "2d528d45ecf5ee3c1a566a9f3d664464925ef830",
"normalized_at": "2026-06-20T05:17:39.374535Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002163 | CodeXGLUE Defect Detection | public_dataset | train | 2638 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | VirtIODevice *virtio_blk_init(DeviceState *dev, DriveInfo *dinfo)
{
VirtIOBlock *s;
int cylinders, heads, secs;
static int virtio_blk_id;
char *ps;
s = (VirtIOBlock *)virtio_common_init("virtio-blk", VIRTIO_ID_BLOCK,
sizeof(struct virtio_blk_config)... | 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": "711bf3d954371abffc07e397fc868a9c9e7e5585",
"normalized_at": "2026-06-20T05:17:38.975474Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004876 | CodeXGLUE Defect Detection | public_dataset | train | 6052 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | fetchline(void)
{
char *p, *line = malloc(MAXREADLINESZ);
if (!line)
return NULL;
printf("%s", get_prompt());
fflush(stdout);
if (!fgets(line, MAXREADLINESZ, stdin)) {
free(line);
return NULL;
}
p = line + strlen(line);
if (p != line && p[-1] == '\n')
p[-1] = '\0';
return line;
}
| 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": "7d7d975c67aaa48a6aaf1630c143a453606567b1",
"normalized_at": "2026-06-20T05:17:39.047672Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019553 | CodeXGLUE Defect Detection | public_dataset | train | 24434 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int amovie_get_samples(AVFilterLink *outlink)
{
MovieContext *movie = outlink->src->priv;
AVPacket pkt;
int ret, got_frame = 0;
if (!movie->pkt.size && movie->is_done == 1)
return AVERROR_EOF;
/* check for another frame, in case the previous one was completely consumed */
... | 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": "ac726a4f0cd2fb8619b478af51312a4282215f0e",
"normalized_at": "2026-06-20T05:17:39.430614Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020306 | CodeXGLUE Defect Detection | public_dataset | train | 25387 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static inline void qpel_motion(MpegEncContext *s,
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
int field_based, int bottom_field, int field_select,
uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
... | 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": "c341f734e5f9d6af4a8fdcceb6f5d12de6395c76",
"normalized_at": "2026-06-20T05:17:39.448932Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019191 | CodeXGLUE Defect Detection | public_dataset | train | 23975 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void vc1_mc_4mv_luma(VC1Context *v, int n, int dir, int avg)
{
MpegEncContext *s = &v->s;
uint8_t *srcY;
int dxy, mx, my, src_x, src_y;
int off;
int fieldmv = (v->fcm == ILACE_FRAME) ? v->blk_mv_type[s->block_index[n]] : 0;
int v_edge_pos = s->v_edge_pos >> v->field_mode;
uint... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "f6774f905fb3cfdc319523ac640be30b14c1bc55",
"normalized_at": "2026-06-20T05:17:39.419311Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016798 | CodeXGLUE Defect Detection | public_dataset | train | 20988 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | uint32_t ssi_transfer(SSIBus *bus, uint32_t val)
{
DeviceState *dev;
SSISlave *slave;
dev = LIST_FIRST(&bus->qbus.children);
if (!dev) {
return 0;
}
slave = SSI_SLAVE_FROM_QDEV(dev);
return slave->info->transfer(slave, val);
}
| 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.352275Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004760 | CodeXGLUE Defect Detection | public_dataset | train | 5901 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void revert_cdlms(WmallDecodeCtx *s, int ch,
int coef_begin, int coef_end)
{
int icoef, pred, ilms, num_lms, residue, input;
num_lms = s->cdlms_ttl[ch];
for (ilms = num_lms - 1; ilms >= 0; ilms--) {
for (icoef = coef_begin; icoef < coef_end; icoef++) {
... | 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": "49bf712a892901bd6a2e8815d085487180894d8c",
"normalized_at": "2026-06-20T05:17:39.044399Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014172 | CodeXGLUE Defect Detection | public_dataset | train | 17686 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void draw_slice(AVFilterLink *inlink, int y, int h, int slice_dir)
{
FadeContext *fade = inlink->dst->priv;
AVFilterBufferRef *outpic = inlink->cur_buf;
uint8_t *p;
int i, j, plane;
if (fade->factor < 65536) {
/* luma or rgb plane */
for (i = 0; i < h; 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": "1527e689cfe3d1f0062f7d3935bad6ed027b3bc8",
"normalized_at": "2026-06-20T05:17:39.282171Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002313 | CodeXGLUE Defect Detection | public_dataset | train | 2816 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | float64 helper_fabs_DT(float64 t0)
{
return float64_abs(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": "57f5c1b093e1c3ec185770d2a180259205f980be",
"normalized_at": "2026-06-20T05:17:38.980147Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_001025 | OWASP Benchmark Python | public_dataset | processed | 1025 | python | generic | security_review | CWE-611 | A05: Security Misconfiguration | high | false | XML External Entity 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-611"
] | {
"raw_path": "testcode/BenchmarkTest01025.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.726091Z",
"name_fixed_at": "2026-06-20T05:22:49.841298Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012345 | CodeXGLUE Defect Detection | public_dataset | train | 15372 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int smacker_decode_header_tree(SmackVContext *smk, GetBitContext *gb, int **recodes, int *last, int size)
{
int res;
HuffContext huff;
HuffContext tmp1, tmp2;
VLC vlc[2];
int escapes[3];
DBCtx ctx;
tmp1.length = 256;
tmp1.maxlength = 0;
tmp1.current = 0;
tmp1.bits = av_mal... | 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": "3a1a7e32ace7af47de74e8ae779cb4e04c89aa97",
"normalized_at": "2026-06-20T05:17:39.237476Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013184 | CodeXGLUE Defect Detection | public_dataset | train | 16423 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void test_qga_invalid_args(gconstpointer fix)
{
const TestFixture *fixture = fix;
QDict *ret, *error;
const gchar *class, *desc;
ret = qmp_fd(fixture->fd, "{'execute': 'guest-ping', "
"'arguments': {'foo': 42 }}");
g_assert_nonnull(ret);
error = qdict_get_qdic... | 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": "910f738b851a263396fc85b2052e47f884ffead3",
"normalized_at": "2026-06-20T05:17:39.258713Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003940 | CodeXGLUE Defect Detection | public_dataset | train | 4856 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int mips_cpu_gdb_write_register(CPUState *cs, uint8_t *mem_buf, int n)
{
MIPSCPU *cpu = MIPS_CPU(cs);
CPUMIPSState *env = &cpu->env;
target_ulong tmp;
tmp = ldtul_p(mem_buf);
if (n < 32) {
env->active_tc.gpr[n] = tmp;
return sizeof(target_ulong);
}
if (env->CP0_... | 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": "800675f11742b6080e40d17b8d5f35d3a5fc5724",
"normalized_at": "2026-06-20T05:17:39.024561Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014934 | CodeXGLUE Defect Detection | public_dataset | train | 18671 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int xen_pt_msgaddr64_reg_write(XenPCIPassthroughState *s,
XenPTReg *cfg_entry, uint32_t *val,
uint32_t dev_value, uint32_t valid_mask)
{
XenPTRegInfo *reg = cfg_entry->reg;
uint32_t writable_mask = 0;
uint32_t old_addr ... | 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": "e2779de053b64f023de382fd87b3596613d47d1e",
"normalized_at": "2026-06-20T05:17:39.302662Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_006668 | CodeXGLUE Defect Detection | public_dataset | train | 8317 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void ffm_seek1(AVFormatContext *s, int64_t pos1)
{
FFMContext *ffm = s->priv_data;
ByteIOContext *pb = s->pb;
int64_t pos;
pos = pos1 + ffm->write_index;
if (pos >= ffm->file_size)
pos -= (ffm->file_size - FFM_PACKET_SIZE);
#ifdef DEBUG_SEEK
av_log(s, AV_LOG_DEBUG, "see... | 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": "92a0f338786b629c5661f5b552e32c6154c3389d",
"normalized_at": "2026-06-20T05:17:39.093565Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020412 | CodeXGLUE Defect Detection | public_dataset | train | 25516 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | char *qmp_human_monitor_command(const char *command_line, bool has_cpu_index,
int64_t cpu_index, Error **errp)
{
char *output = NULL;
Monitor *old_mon, hmp;
memset(&hmp, 0, sizeof(hmp));
hmp.outbuf = qstring_new();
hmp.skip_flush = true;
old_mon = 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": "qemu",
"commit_id": "b01fe89e91268c6b02720735643020746610e6d8",
"normalized_at": "2026-06-20T05:17:39.451885Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014157 | CodeXGLUE Defect Detection | public_dataset | train | 17667 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static inline int get_phys_addr(CPUARMState *env, uint32_t address,
int access_type, int is_user,
hwaddr *phys_ptr, int *prot,
target_ulong *page_size)
{
/* Fast Context Switch Extension. */
if (address < 0x02... | 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": "76e3e1bcaefe0da394f328854cb72f9449f23732",
"normalized_at": "2026-06-20T05:17:39.281916Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001720 | CodeXGLUE Defect Detection | public_dataset | train | 2100 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int mp_dacl_removexattr(FsContext *ctx,
const char *path, const char *name)
{
int ret;
char *buffer;
buffer = rpath(ctx, path);
ret = lremovexattr(buffer, MAP_ACL_DEFAULT);
if (ret == -1 && errno == ENODATA) {
/*
* We don't get ENODA... | 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": "72f0d0bf51362011c4d841a89fb8f5cfb16e0bf3",
"normalized_at": "2026-06-20T05:17:38.963953Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001761 | CodeXGLUE Defect Detection | public_dataset | train | 2151 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void pdu_submit(V9fsPDU *pdu)
{
Coroutine *co;
CoroutineEntry *handler;
V9fsState *s = pdu->s;
if (pdu->id >= ARRAY_SIZE(pdu_co_handlers) ||
(pdu_co_handlers[pdu->id] == NULL)) {
handler = v9fs_op_not_supp;
} else {
handler = pdu_co_handlers[pdu->id];
}
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "0b8b8753e4d94901627b3e86431230f2319215c4",
"normalized_at": "2026-06-20T05:17:38.964822Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013146 | CodeXGLUE Defect Detection | public_dataset | train | 16373 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int ff_h264_execute_decode_slices(H264Context *h, unsigned context_count)
{
AVCodecContext *const avctx = h->avctx;
H264SliceContext *sl;
int i;
av_assert0(context_count && h->slice_ctx[context_count - 1].mb_y < h->mb_height);
if (h->avctx->hwaccel ||
h->avctx->codec->capabilities... | 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": "43b434210e597d484aef57c4139c3126d22b7e2b",
"normalized_at": "2026-06-20T05:17:39.257777Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009474 | CodeXGLUE Defect Detection | public_dataset | train | 11786 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void visit_type_any(Visitor *v, const char *name, QObject **obj, Error **errp)
{
v->type_any(v, name, obj, 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": true,
"project": "qemu",
"commit_id": "e58d695e6c3a5cfa0aa2fc91b87ade017ef28b05",
"normalized_at": "2026-06-20T05:17:39.163485Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_021844 | CodeXGLUE Defect Detection | public_dataset | train | 27305 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void scsi_generic_realize(SCSIDevice *s, Error **errp)
{
int rc;
int sg_version;
struct sg_scsi_id scsiid;
if (!s->conf.bs) {
error_setg(errp, "drive property not set");
return;
}
if (bdrv_get_on_error(s->conf.bs, 0) != BLOCKDEV_ON_ERROR_ENOSPC) {
err... | 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.494641Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002738 | CodeXGLUE Defect Detection | public_dataset | train | 3349 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void HELPER(wsr_ibreaka)(uint32_t i, uint32_t v)
{
if (env->sregs[IBREAKENABLE] & (1 << i) && env->sregs[IBREAKA + i] != v) {
tb_invalidate_phys_page_range(
env->sregs[IBREAKA + i], env->sregs[IBREAKA + i] + 1, 0);
tb_invalidate_phys_page_range(v, v + 1, 0);
}
env->sre... | 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": "3d0be8a5c135dadcfbd68ed354007a8cece98849",
"normalized_at": "2026-06-20T05:17:38.992805Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007322 | CodeXGLUE Defect Detection | public_dataset | train | 9093 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int shorten_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
ShortenContext *s = avctx->priv_data;
int i, input_buf_size = 0;
int16_t *samples = data;
int 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": "FFmpeg",
"commit_id": "882dafe9b666a7333d1b256fafe63e35dc582e3f",
"normalized_at": "2026-06-20T05:17:39.110446Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018550 | CodeXGLUE Defect Detection | public_dataset | train | 23170 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | uint32_t HELPER(mvcs)(CPUS390XState *env, uint64_t l, uint64_t a1, uint64_t a2)
{
HELPER_LOG("%s: %16" PRIx64 " %16" PRIx64 " %16" PRIx64 "\n",
__func__, l, a1, a2);
return mvc_asc(env, l, a1, PSW_ASC_SECONDARY, a2, PSW_ASC_PRIMARY);
}
| 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": "a3084e8055067b3fe8ed653a609021d2ab368564",
"normalized_at": "2026-06-20T05:17:39.402006Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003228 | CodeXGLUE Defect Detection | public_dataset | train | 3950 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void text_console_resize(QemuConsole *s)
{
TextCell *cells, *c, *c1;
int w1, x, y, last_width;
last_width = s->width;
s->width = surface_width(s->surface) / FONT_WIDTH;
s->height = surface_height(s->surface) / FONT_HEIGHT;
w1 = last_width;
if (s->width < w1)
w1 = ... | 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": "fedf0d35aafc4f1f1e5f6dbc80cb23ae1ae49f0b",
"normalized_at": "2026-06-20T05:17:39.005961Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016353 | CodeXGLUE Defect Detection | public_dataset | train | 20435 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int kvm_irqchip_update_msi_route(KVMState *s, int virq, MSIMessage msg)
{
struct kvm_irq_routing_entry kroute;
if (!kvm_irqchip_in_kernel()) {
return -ENOSYS;
}
kroute.gsi = virq;
kroute.type = KVM_IRQ_ROUTING_MSI;
kroute.flags = 0;
kroute.u.msi.address_lo = (uint32_t)ms... | 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": "d07cc1f12d8e15c167857852c39190d770763824",
"normalized_at": "2026-06-20T05:17:39.340653Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010621 | CodeXGLUE Defect Detection | public_dataset | train | 13240 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)
{
Wmv2Context *const w = (Wmv2Context *) s;
if (s->pict_type == AV_PICTURE_TYPE_I) {
if (w->j_type_bit)
w->j_type = get_bits1(&s->gb);
else
w->j_type = 0; // FIXME check
if (!w->j_type) {
... | 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": "65e0a7c473f23f1833538ffecf53c81fe500b5e4",
"normalized_at": "2026-06-20T05:17:39.193092Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019100 | CodeXGLUE Defect Detection | public_dataset | train | 23860 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void qxl_blit(PCIQXLDevice *qxl, QXLRect *rect)
{
DisplaySurface *surface = qemu_console_surface(qxl->vga.con);
uint8_t *dst = surface_data(surface);
uint8_t *src;
int len, i;
if (is_buffer_shared(surface)) {
return;
}
if (!qxl->guest_primary.data) {
trace_... | 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": "c58c7b959b93b864a27fd6b3646ee1465ab8832b",
"normalized_at": "2026-06-20T05:17:39.417127Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012652 | CodeXGLUE Defect Detection | public_dataset | train | 15749 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int refresh_thread(void *opaque)
{
VideoState *is= opaque;
while (!is->abort_request) {
SDL_Event event;
event.type = FF_REFRESH_EVENT;
event.user.data1 = opaque;
if (!is->refresh && (!is->paused || is->force_refresh)) {
is->refresh = 1;
SD... | 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": "b853cfe7eaf13b7d4ff3ceba7098544ccc049df8",
"normalized_at": "2026-06-20T05:17:39.245035Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007561 | CodeXGLUE Defect Detection | public_dataset | train | 9393 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | iscsi_co_writev_flags(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
QEMUIOVector *iov, int flags)
{
IscsiLun *iscsilun = bs->opaque;
struct IscsiTask iTask;
uint64_t lba;
uint32_t num_sectors;
bool fua = flags & BDRV_REQ_FUA;
if (fua) {
assert... | 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": "5def6b80e1eca696c1fc6099e7f4d36729686402",
"normalized_at": "2026-06-20T05:17:39.116020Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008998 | CodeXGLUE Defect Detection | public_dataset | train | 11203 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void migration_incoming_state_destroy(void)
{
struct MigrationIncomingState *mis = migration_incoming_get_current();
qemu_event_destroy(&mis->main_thread_load_event); | 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": "3482655bbc21d158ed0daaa294c890997238cc23",
"normalized_at": "2026-06-20T05:17:39.150570Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012643 | CodeXGLUE Defect Detection | public_dataset | train | 15739 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static always_inline void gen_sradi (DisasContext *ctx, int n)
{
int sh = SH(ctx->opcode) + (n << 5);
if (sh != 0) {
int l1, l2;
TCGv t0;
l1 = gen_new_label();
l2 = gen_new_label();
tcg_gen_brcondi_tl(TCG_COND_GE, cpu_gpr[rS(ctx->opcode)], 0, l1);
t0 = tc... | 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": "a973001797221b0fd7be55cb6513c72a01f4b639",
"normalized_at": "2026-06-20T05:17:39.244898Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001327 | CodeXGLUE Defect Detection | public_dataset | train | 1630 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int dirac_decode_data_unit(AVCodecContext *avctx, const uint8_t *buf, int size)
{
DiracContext *s = avctx->priv_data;
DiracFrame *pic = NULL;
int ret, i, parse_code = buf[4];
unsigned tmp;
if (size < DATA_UNIT_HEADER_SIZE)
return -1;
init_get_bits(&s->gb, &buf[13],... | 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": "5a455dd011151fd7e3f8aced745b206ca1413d29",
"normalized_at": "2026-06-20T05:17:38.953970Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002219 | CodeXGLUE Defect Detection | public_dataset | train | 2707 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int vc1_decode_i_block_adv(VC1Context *v, int16_t block[64], int n,
int coded, int codingset, int mquant)
{
GetBitContext *gb = &v->s.gb;
MpegEncContext *s = &v->s;
int dc_pred_dir = 0; /* Direction of the DC prediction used */
int i;
int16_t *dc_val;
... | 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": "63c61f0be03624fbd9e352d8393122beb3ddcc1a",
"normalized_at": "2026-06-20T05:17:38.978031Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008342 | CodeXGLUE Defect Detection | public_dataset | train | 10384 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | int css_do_rchp(uint8_t cssid, uint8_t chpid)
{
uint8_t real_cssid;
if (cssid > channel_subsys.max_cssid) {
return -EINVAL;
}
if (channel_subsys.max_cssid == 0) {
real_cssid = channel_subsys.default_cssid;
} else {
real_cssid = cssid;
}
if (!channel_subsy... | 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": "5c8d6f008c0555b54cf10550fa86199a2cfabbca",
"normalized_at": "2026-06-20T05:17:39.134100Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018493 | CodeXGLUE Defect Detection | public_dataset | train | 23092 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | void memory_region_add_eventfd(MemoryRegion *mr,
hwaddr addr,
unsigned size,
bool match_data,
uint64_t data,
EventNotifier *e)
{
MemoryRegionIoeventfd mrfd = {
... | 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": "8c56c1a592b5092d91da8d8943c17777d6462a6f",
"normalized_at": "2026-06-20T05:17:39.400974Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018781 | CodeXGLUE Defect Detection | public_dataset | train | 23467 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void avc_biwgt_4width_msa(uint8_t *src,
int32_t src_stride,
uint8_t *dst,
int32_t dst_stride,
int32_t height,
int32_t log2_denom,
... | 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.408059Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008394 | CodeXGLUE Defect Detection | public_dataset | train | 10450 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int x86_cpu_handle_mmu_fault(CPUState *cs, vaddr addr,
int is_write1, int mmu_idx)
{
X86CPU *cpu = X86_CPU(cs);
CPUX86State *env = &cpu->env;
uint64_t ptep, pte;
target_ulong pde_addr, pte_addr;
int error_code = 0;
int is_dirty, prot, page_size, is_write, is_... | 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": "b09481de91cce94342bac3327bb7633c39ff8bf6",
"normalized_at": "2026-06-20T05:17:39.135344Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017372 | CodeXGLUE Defect Detection | public_dataset | train | 21699 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int pcx_encode_frame(AVCodecContext *avctx,
unsigned char *buf, int buf_size, void *data)
{
PCXContext *s = avctx->priv_data;
AVFrame *const pict = &s->picture;
const uint8_t *buf_start = buf;
const uint8_t *buf_end = buf + buf_size;
int bpp, nplanes, 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": "ad1c50255735c20bd86572d3e8b3c88a5ca6c8f1",
"normalized_at": "2026-06-20T05:17:39.369228Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020249 | CodeXGLUE Defect Detection | public_dataset | train | 25317 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void gt64120_write_config(PCIDevice *d, uint32_t address, uint32_t val,
int len)
{
#ifdef TARGET_WORDS_BIGENDIAN
val = bswap32(val);
#endif
pci_default_write_config(d, address, val, 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": false,
"project": "qemu",
"commit_id": "1931e26054fdf2b1b84091f0b9662979eb6931ec",
"normalized_at": "2026-06-20T05:17:39.447637Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019071 | CodeXGLUE Defect Detection | public_dataset | train | 23825 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void pc_dimm_unplug(HotplugHandler *hotplug_dev,
DeviceState *dev, Error **errp)
{
PCMachineState *pcms = PC_MACHINE(hotplug_dev);
PCDIMMDevice *dimm = PC_DIMM(dev);
PCDIMMDeviceClass *ddc = PC_DIMM_GET_CLASS(dimm);
MemoryRegion *mr = ddc->get_memory_region(dimm);... | 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": "3e8522e23f6ab3c2b89ebb962ec4c2227d88aca6",
"normalized_at": "2026-06-20T05:17:39.416358Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_006050 | CodeXGLUE Defect Detection | public_dataset | train | 7529 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void disas_ldst_reg_imm9(DisasContext *s, uint32_t insn,
int opc,
int size,
int rt,
bool is_vector)
{
int rn = extract32(insn, 5, 5);
int imm9 = sextract32(insn, 12, 9);
... | 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": "5ca66278c859bb1ded243755aeead2be6992ce73",
"normalized_at": "2026-06-20T05:17:39.078608Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007329 | CodeXGLUE Defect Detection | public_dataset | train | 9103 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int test_vector_dmac_scalar(AVFloatDSPContext *fdsp, AVFloatDSPContext *cdsp,
const double *v1, const double *src0, double scale)
{
LOCAL_ALIGNED(32, double, cdst, [LEN]);
LOCAL_ALIGNED(32, double, odst, [LEN]);
int ret;
memcpy(cdst, v1, LEN * sizeof(*v1... | 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": "e53c9065ca08a9153ecc73a6a8940bcc6d667e58",
"normalized_at": "2026-06-20T05:17:39.110596Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014637 | CodeXGLUE Defect Detection | public_dataset | train | 18281 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void scsi_disk_unit_attention_reported(SCSIDevice *dev)
{
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
if (s->media_changed) {
s->media_changed = false;
s->qdev.unit_attention = SENSE_CODE(MEDIUM_CHANGED);
}
}
| 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": "e48e84ea80cb2e7fe6e48196ce187cfba6e3eb2c",
"normalized_at": "2026-06-20T05:17:39.294482Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_003807 | CodeXGLUE Defect Detection | public_dataset | train | 4689 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | AVFrameSideData *av_frame_new_side_data(AVFrame *frame,
enum AVFrameSideDataType type,
int size)
{
AVFrameSideData *ret, **tmp;
if (frame->nb_side_data > INT_MAX / sizeof(*frame->side_data) - 1)
return NULL;
t... | 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": "5804201cbac2de8824013a8294e381e93bbe45f2",
"normalized_at": "2026-06-20T05:17:39.021284Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_006534 | CodeXGLUE Defect Detection | public_dataset | train | 8138 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void dma_mem_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
{
DMAState *s = opaque;
uint32_t saddr;
saddr = (addr & DMA_MASK) >> 2;
DPRINTF("write dmareg " TARGET_FMT_plx ": 0x%8.8x -> 0x%8.8x\n", addr,
s->dmaregs[saddr], val);
switch (saddr) {
case 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": "65899fe34b09ab4af4b045977460b531ec5c1f73",
"normalized_at": "2026-06-20T05:17:39.090490Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014174 | CodeXGLUE Defect Detection | public_dataset | train | 17689 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static uint32_t memory_region_read_thunk_n(void *_mr,
target_phys_addr_t addr,
unsigned size)
{
MemoryRegion *mr = _mr;
uint64_t data = 0;
if (!memory_region_access_valid(mr, addr, size)) {
return -1U; /* ... | 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": "897fa7cff21a98b260a5b3e73eae39273fa60272",
"normalized_at": "2026-06-20T05:17:39.282209Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_017338 | CodeXGLUE Defect Detection | public_dataset | train | 21658 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static inline bool check_lba_range(SCSIDiskState *s,
uint64_t sector_num, uint32_t nb_sectors)
{
/*
* The first line tests that no overflow happens when computing the last
* sector. The second line tests that the last accessed sector is in
* range.
*/
... | 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": "12ca76fc48081b3a0ad1a70546abfcf198aedfc4",
"normalized_at": "2026-06-20T05:17:39.368290Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005858 | CodeXGLUE Defect Detection | public_dataset | train | 7278 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int load_apply_palette(FFFrameSync *fs)
{
AVFilterContext *ctx = fs->parent;
AVFilterLink *inlink = ctx->inputs[0];
PaletteUseContext *s = ctx->priv;
AVFrame *master, *second, *out;
int ret;
// writable for error diffusal dithering
ret = ff_framesync_dualinput_get_writable(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": "FFmpeg",
"commit_id": "6470abc740367cc881c181db866891f8dd1d342f",
"normalized_at": "2026-06-20T05:17:39.074017Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000310 | OWASP Benchmark Python | public_dataset | processed | 310 | python | generic | security_review | CWE-330 | A02: Cryptographic Failures | medium | false | Use of Insufficiently Random Values | '''
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-330"
] | {
"raw_path": "testcode/BenchmarkTest00310.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.694150Z",
"name_fixed_at": "2026-06-20T05:22:49.830581Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_020631 | CodeXGLUE Defect Detection | public_dataset | train | 25799 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int dvbsub_parse(AVCodecParserContext *s,
AVCodecContext *avctx,
const uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size)
{
DVBSubParseContext *pc = s->priv_data;
uint8_t *p, *p_end;
int i, len, buf_po... | 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": "de41d5372faa4ad7ad439e71975fc6f4ea0c0efc",
"normalized_at": "2026-06-20T05:17:39.456600Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007400 | CodeXGLUE Defect Detection | public_dataset | train | 9188 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int kvmppc_get_hypercall(CPUPPCState *env, uint8_t *buf, int buf_len)
{
uint32_t *hc = (uint32_t*)buf;
struct kvm_ppc_pvinfo pvinfo;
if (!kvmppc_get_pvinfo(env, &pvinfo)) {
memcpy(buf, pvinfo.hcall, buf_len);
return 0;
}
/*
* Fallback to always fail hypercalls regar... | 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": "0ddbd0536296f5a36c8f225edd4d14441be6b153",
"normalized_at": "2026-06-20T05:17:39.112382Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000544 | OWASP Benchmark Python | public_dataset | processed | 544 | python | generic | security_review | CWE-643 | A03: Injection | high | false | XPath Injection | '''
OWASP Benchmark for Python v0.1
This file is part of the Open Web Application Security Project (OWASP) Benchmark Project.
For details, please see https://owasp.org/www-project-benchmark.
The OWASP Benchmark is free software: you can redistribute it and/or modify it under the terms
of the GNU General Public Licens... | This example was normalized from OWASP Benchmark Python. It is intended for security review and vulnerability detection. A secure repair is not included in this source-specific normalized record. | [
"owasp",
"benchmark-python",
"python",
"cwe-643"
] | {
"raw_path": "testcode/BenchmarkTest00544.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.704262Z",
"name_fixed_at": "2026-06-20T05:22:49.834481Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
owasp_python_000253 | OWASP Benchmark Python | public_dataset | processed | 253 | python | generic | security_review | CWE-328 | A02: Cryptographic Failures | medium | false | Weak Hashing Algorithm | '''
OWASP Benchmark for Python v0.1
This file is part of the Open Web Application Security Project (OWASP) Benchmark Project.
For details, please see https://owasp.org/www-project-benchmark.
The OWASP Benchmark is free software: you can redistribute it and/or modify it under the terms
of the GNU General Public Licens... | This example was normalized from OWASP Benchmark Python. It is intended for security review and vulnerability detection. A secure repair is not included in this source-specific normalized record. | [
"owasp",
"benchmark-python",
"python",
"cwe-328"
] | {
"raw_path": "testcode/BenchmarkTest00253.py",
"label_source": "data/raw/owasp_benchmark_python/expectedresults-0.1.csv",
"normalized_at": "2026-06-20T05:21:00.691558Z",
"name_fixed_at": "2026-06-20T05:22:49.829582Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_001358 | CodeXGLUE Defect Detection | public_dataset | train | 1663 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static av_cold int v410_decode_init(AVCodecContext *avctx)
{
avctx->pix_fmt = PIX_FMT_YUV444P10;
avctx->bits_per_raw_sample = 10;
if (avctx->width & 1) {
av_log(avctx, AV_LOG_ERROR, "v410 requires width to be even.\n");
return AVERROR_INVALIDDATA;
}
avctx->cod... | 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": "6ed3565f08abf3b1c2a1d2d7fac768b18753530c",
"normalized_at": "2026-06-20T05:17:38.954797Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_000306 | CodeXGLUE Defect Detection | public_dataset | train | 382 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static coroutine_fn void test_multi_co_schedule_entry(void *opaque)
{
g_assert(to_schedule[id] == NULL);
atomic_mb_set(&to_schedule[id], qemu_coroutine_self());
while (!atomic_mb_read(&now_stopping)) {
int n;
n = g_test_rand_int_range(0, NUM_CONTEXTS);
schedule_next(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": true,
"project": "qemu",
"commit_id": "fb0c43f34eed8b18678c6e1f481d8564b35c99ed",
"normalized_at": "2026-06-20T05:17:38.924754Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_021220 | CodeXGLUE Defect Detection | public_dataset | train | 26529 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int parse_numa(void *opaque, QemuOpts *opts, Error **errp)
{
NumaOptions *object = NULL;
Error *err = NULL;
{
Visitor *v = opts_visitor_new(opts);
visit_type_NumaOptions(v, NULL, &object, &err);
visit_free(v);
}
if (err) {
goto error;
}
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "qemu",
"commit_id": "157e94e8a2f7d3e14060d833bd1519a83099eaa9",
"normalized_at": "2026-06-20T05:17:39.473777Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008286 | CodeXGLUE Defect Detection | public_dataset | train | 10312 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void pcie_port_init_reg(PCIDevice *d)
{
/* Unlike pci bridge,
66MHz and fast back to back don't apply to pci express port. */
pci_set_word(d->config + PCI_STATUS, 0);
pci_set_word(d->config + PCI_SEC_STATUS, 0);
/* Unlike conventional pci bridge, some bits are hardwired to 0. */
#define ... | 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": "45eb768c706d3a5fbe55224c589e8b4e252781d9",
"normalized_at": "2026-06-20T05:17:39.132885Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012385 | CodeXGLUE Defect Detection | public_dataset | train | 15419 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | envlist_setenv(envlist_t *envlist, const char *env)
{
struct envlist_entry *entry = NULL;
const char *eq_sign;
size_t envname_len;
if ((envlist == NULL) || (env == NULL))
return (EINVAL);
/* find out first equals sign in given env */
if ((eq_sign = strchr(env, '=')) == NULL)
return (EINVAL);
en... | 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.238253Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_007252 | CodeXGLUE Defect Detection | public_dataset | train | 9005 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int mpl2_probe(AVProbeData *p)
{
int i;
char c;
int64_t start, end;
const unsigned char *ptr = p->buf;
const unsigned char *ptr_end = ptr + p->buf_size;
for (i = 0; i < 2; i++) {
if (sscanf(ptr, "[%"SCNd64"][%"SCNd64"]%c", &start, &end, &c) != 3 &&
sscanf(pt... | 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": "90fc00a623de44e137fe1601b91356e8cd8bdd54",
"normalized_at": "2026-06-20T05:17:39.108657Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002947 | CodeXGLUE Defect Detection | public_dataset | train | 3607 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void FUNC(hevc_v_loop_filter_luma)(uint8_t *pix, ptrdiff_t stride,
int *beta, int *tc, uint8_t *no_p,
uint8_t *no_q)
{
FUNC(hevc_loop_filter_luma)(pix, sizeof(pixel), stride,
beta, tc, no_... | 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": "73bb8f61d48dbf7237df2e9cacd037f12b84b00a",
"normalized_at": "2026-06-20T05:17:38.998889Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_009336 | CodeXGLUE Defect Detection | public_dataset | train | 11618 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int posix_aio_flush(void *opaque)
{
PosixAioState *s = opaque;
return !!s->first_aio;
}
| 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": "9ef91a677110ec200d7b2904fc4bcae5a77329ad",
"normalized_at": "2026-06-20T05:17:39.160331Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002681 | CodeXGLUE Defect Detection | public_dataset | train | 3272 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void dec_barrel(DisasContext *dc)
{
TCGv t0;
unsigned int s, t;
if ((dc->tb_flags & MSR_EE_FLAG)
&& !(dc->env->pvr.regs[2] & PVR2_ILL_OPCODE_EXC_MASK)
&& !(dc->env->pvr.regs[0] & PVR0_USE_BARREL_MASK)) {
tcg_gen_movi_tl(cpu_SR[SR_ESR], ESR_EC_ILLEGAL_OP);
... | 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": "97f90cbfe810bb153fc44bde732d9639610783bb",
"normalized_at": "2026-06-20T05:17:38.991102Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016705 | CodeXGLUE Defect Detection | public_dataset | train | 20871 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void bit_prop_set(DeviceState *dev, Property *props, bool val)
{
uint32_t *p = qdev_get_prop_ptr(dev, props);
uint32_t mask = qdev_get_prop_mask(props);
if (val)
*p |= ~mask;
else
*p &= ~mask;
}
| 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": "dbd483242c2e6dfaacb9fd3d20c333bbdad87243",
"normalized_at": "2026-06-20T05:17:39.349686Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_010472 | CodeXGLUE Defect Detection | public_dataset | train | 13055 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void stream_set_speed(BlockJob *job, int64_t speed, Error **errp)
{
StreamBlockJob *s = container_of(job, StreamBlockJob, common);
if (speed < 0) {
error_set(errp, QERR_INVALID_PARAMETER, "speed");
return;
}
ratelimit_set_speed(&s->limit, speed / BDRV_SECTOR_SIZE);
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "6ef228fc0de1d5fb43ebfef039563d39a3a37067",
"normalized_at": "2026-06-20T05:17:39.188790Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_012280 | CodeXGLUE Defect Detection | public_dataset | train | 15295 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static av_cold int XAVS_close(AVCodecContext *avctx)
{
XavsContext *x4 = avctx->priv_data;
av_freep(&avctx->extradata);
av_free(x4->sei);
av_freep(&x4->pts_buffer);
if (x4->enc)
xavs_encoder_close(x4->enc);
av_frame_free(&avctx->coded_frame);
return 0;
}
| This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "FFmpeg",
"commit_id": "d6604b29ef544793479d7fb4e05ef6622bb3e534",
"normalized_at": "2026-06-20T05:17:39.235798Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014534 | CodeXGLUE Defect Detection | public_dataset | train | 18145 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static bool append_open_options(QDict *d, BlockDriverState *bs)
{
const QDictEntry *entry;
QemuOptDesc *desc;
bool found_any = false;
for (entry = qdict_first(bs->options); entry;
entry = qdict_next(bs->options, entry))
{
/* Only take options for this level */
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": "qemu",
"commit_id": "260fecf13b0d30621dc88da03dc1b502b7358c6b",
"normalized_at": "2026-06-20T05:17:39.291406Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_008883 | CodeXGLUE Defect Detection | public_dataset | train | 11060 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void swap_sample_fmts_on_filter(AVFilterContext *filter)
{
AVFilterLink *link = NULL;
int format, bps;
int i, j;
for (i = 0; i < filter->nb_inputs; i++) {
link = filter->inputs[i];
if (link->type == AVMEDIA_TYPE_AUDIO &&
link->out_formats->format_count == 1... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": true,
"project": "FFmpeg",
"commit_id": "61d158c321a82ec7bfc46ce480997797e8048b85",
"normalized_at": "2026-06-20T05:17:39.147751Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_000015 | CodeXGLUE Defect Detection | public_dataset | train | 19 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | av_cold void ff_af_queue_init(AVCodecContext *avctx, AudioFrameQueue *afq)
{
afq->avctx = avctx;
afq->next_pts = AV_NOPTS_VALUE;
afq->remaining_delay = avctx->delay;
afq->remaining_samples = avctx->delay;
afq->frame_queue = 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": "FFmpeg",
"commit_id": "2df0c32ea12ddfa72ba88309812bfb13b674130f",
"normalized_at": "2026-06-20T05:17:38.915048Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019555 | CodeXGLUE Defect Detection | public_dataset | train | 24436 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static uint32_t nvic_readl(NVICState *s, uint32_t offset)
{
ARMCPU *cpu = s->cpu;
uint32_t val;
switch (offset) {
case 4: /* Interrupt Control Type. */
return ((s->num_irq - NVIC_FIRST_IRQ) / 32) - 1;
case 0xd00: /* CPUID Base. */
return cpu->midr;
case 0xd04: /* 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": false,
"project": "qemu",
"commit_id": "45db7ba681ede57113a67499840e69ee586bcdf2",
"normalized_at": "2026-06-20T05:17:39.430665Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005361 | CodeXGLUE Defect Detection | public_dataset | train | 6662 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void h264_h_loop_filter_chroma_c(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
{
h264_loop_filter_chroma_c(pix, 1, stride, alpha, beta, tc0);
}
| 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": "dd561441b1e849df7d8681c6f32af82d4088dafd",
"normalized_at": "2026-06-20T05:17:39.060398Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_019076 | CodeXGLUE Defect Detection | public_dataset | train | 23830 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void test_sanity(void)
{
AHCIQState *ahci;
ahci = ahci_boot();
ahci_shutdown(ahci);
}
| 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": "debaaa114a8877a939533ba846e64168fb287b7b",
"normalized_at": "2026-06-20T05:17:39.416469Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_002965 | CodeXGLUE Defect Detection | public_dataset | train | 3631 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static void xen_init_pv(QEMUMachineInitArgs *args)
{
const char *cpu_model = args->cpu_model;
const char *kernel_filename = args->kernel_filename;
const char *kernel_cmdline = args->kernel_cmdline;
const char *initrd_filename = args->initrd_filename;
X86CPU *cpu;
CPUState *cs;
DriveI... | 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": "58ee9b0ae05d81c74d6869a25ce4263fc22ed809",
"normalized_at": "2026-06-20T05:17:38.999494Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016575 | CodeXGLUE Defect Detection | public_dataset | train | 20711 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int a64multi_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *pict, int *got_packet)
{
A64Context *c = avctx->priv_data;
AVFrame *const p = (AVFrame *) & c->picture;
int frame;
int x, y;
int b_height;
int b_width;
int req_... | 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": "3d3b603f7f834dad919a3334506a1e5414d7368a",
"normalized_at": "2026-06-20T05:17:39.346114Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013203 | CodeXGLUE Defect Detection | public_dataset | train | 16447 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int query_formats(AVFilterGraph *graph, AVClass *log_ctx)
{
int i, j, ret;
int scaler_count = 0, resampler_count = 0;
int count_queried = 0; /* successful calls to query_formats() */
int count_merged = 0; /* successful merge of formats lists */
int count_already_merged = ... | 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": "23c9ebffb5e2e9a525d19a8b9c31879ec7012fc9",
"normalized_at": "2026-06-20T05:17:39.259064Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014133 | CodeXGLUE Defect Detection | public_dataset | train | 17632 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static uint64_t spapr_io_read(void *opaque, hwaddr addr,
unsigned size)
{
switch (size) {
case 1:
return cpu_inb(addr);
case 2:
return cpu_inw(addr);
case 4:
return cpu_inl(addr);
}
assert(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": "a178274efabcbbc5d44805b51def874e47051325",
"normalized_at": "2026-06-20T05:17:39.281403Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_005570 | CodeXGLUE Defect Detection | public_dataset | train | 6915 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void RENAME(uyvytoyuv422)(uint8_t *ydst, uint8_t *udst, uint8_t *vdst, const uint8_t *src,
long width, long height,
long lumStride, long chromStride, long srcStride)
{
long y;
const long chromWidth= -((-width)>>1);
fo... | 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": "d1adad3cca407f493c3637e20ecd4f7124e69212",
"normalized_at": "2026-06-20T05:17:39.066018Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004305 | CodeXGLUE Defect Detection | public_dataset | train | 5326 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int h261_decode_gob_header(H261Context *h){
unsigned int val;
MpegEncContext * const s = &h->s;
/* Check for GOB Start Code */
val = show_bits(&s->gb, 15);
if(val)
return -1;
/* We have a GBSC */
skip_bits(&s->gb, 16);
h->gob_number = get_bits(&s->gb, 4)... | 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": "49e5dcbce5f9e08ec375fd54c413148beb81f1d7",
"normalized_at": "2026-06-20T05:17:39.033560Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011682 | CodeXGLUE Defect Detection | public_dataset | train | 14537 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | void pc_init_pci64_hole(PcPciInfo *pci_info, uint64_t pci_hole64_start,
uint64_t pci_hole64_size)
{
if ((sizeof(hwaddr) == 4) || (!pci_hole64_size)) {
return;
}
/*
* BIOS does not set MTRR entries for the 64 bit window, so no need to
* align address to power... | 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": "83d08f2673504a299194dcac1657a13754b5932a",
"normalized_at": "2026-06-20T05:17:39.221643Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_016938 | CodeXGLUE Defect Detection | public_dataset | train | 21162 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static inline void RENAME(rgb32tobgr32)(const uint8_t *src, uint8_t *dst, long src_size)
{
#ifdef HAVE_MMX
/* TODO: unroll this loop */
asm volatile (
"xor %%"REG_a", %%"REG_a" \n\t"
ASMALIGN16
"1: \n\t"
PREFETCH" 32(%0, %%"REG_a") \n\t"
"movq (%0, %%"REG_a"), %%mm0 \n\t"
"movq %%mm0, %%mm1 \... | 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": "4bff9ef9d0781c4de228bf1f85634d2706fc589b",
"normalized_at": "2026-06-20T05:17:39.355856Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011878 | CodeXGLUE Defect Detection | public_dataset | train | 14782 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void memory_region_add_subregion_common(MemoryRegion *mr,
hwaddr offset,
MemoryRegion *subregion)
{
MemoryRegion *other;
memory_region_transaction_begin();
assert(!subregion->parent);
memory_r... | 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": "0598701a4947ddbc19391e008cf753f8f22f3c25",
"normalized_at": "2026-06-20T05:17:39.225864Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_018072 | CodeXGLUE Defect Detection | public_dataset | train | 22580 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | int qcow2_alloc_cluster_offset(BlockDriverState *bs, uint64_t offset,
int n_start, int n_end, int *num, QCowL2Meta *m)
{
BDRVQcowState *s = bs->opaque;
int l2_index, ret, sectors;
uint64_t *l2_table;
unsigned int nb_clusters, keep_clusters;
uint64_t cluster_offset;
trace_qcow2_allo... | 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": "54e6814360ab2110ed3ed07b2b9a3f9907e1202a",
"normalized_at": "2026-06-20T05:17:39.389826Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_011483 | CodeXGLUE Defect Detection | public_dataset | train | 14291 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void q35_host_get_pci_hole_end(Object *obj, Visitor *v,
const char *name, void *opaque,
Error **errp)
{
Q35PCIHost *s = Q35_HOST_DEVICE(obj);
uint32_t value = s->mch.pci_hole.end;
visit_type_uint32(v, name, &value, er... | 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": "a0efbf16604770b9d805bcf210ec29942321134f",
"normalized_at": "2026-06-20T05:17:39.215901Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_015686 | CodeXGLUE Defect Detection | public_dataset | train | 19600 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static int hls_transform_unit(HEVCContext *s, int x0, int y0,
int xBase, int yBase, int cb_xBase, int cb_yBase,
int log2_cb_size, int log2_trafo_size,
int trafo_depth, int blk_idx,
int cbf_luma, 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": "9a3653c9ecc4bbbbb502513a70bccd4090ed12b0",
"normalized_at": "2026-06-20T05:17:39.321956Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_004971 | CodeXGLUE Defect Detection | public_dataset | train | 6172 | c | generic | vulnerability_detection | unknown | unknown | unknown | true | unknown_defect_or_vulnerability | static int filter_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)
{
AVFilterContext *ctx = inlink->dst;
AlphaMergeContext *merge = ctx->priv;
int is_alpha = (inlink == ctx->inputs[1]);
struct FFBufQueue *queue =
(is_alpha ? &merge->queue_alpha : &merge->queue_main);
ff_bufqueue_... | 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": "255be0734d9293309b42d8029d2004ec3732c8bc",
"normalized_at": "2026-06-20T05:17:39.049904Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_014612 | CodeXGLUE Defect Detection | public_dataset | train | 18249 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void omap_clkdsp_write(void *opaque, target_phys_addr_t addr,
uint64_t value, unsigned size)
{
struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
uint16_t diff;
if (size != 2) {
return omap_badwidth_write16(opaque, addr, value);
}
... | This example comes from CodeXGLUE defect detection. The original dataset provides a binary target label but does not provide a specific CWE label or secure fix. | [
"codexglue",
"defect-detection",
"c-language",
"binary-label"
] | {
"original_target": false,
"project": "qemu",
"commit_id": "a8170e5e97ad17ca169c64ba87ae2f53850dab4c",
"normalized_at": "2026-06-20T05:17:39.293984Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_021021 | CodeXGLUE Defect Detection | public_dataset | train | 26276 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | pvscsi_command_complete(SCSIRequest *req, uint32_t status, size_t resid)
{
PVSCSIRequest *pvscsi_req = req->hba_private;
PVSCSIState *s = pvscsi_req->dev;
if (!pvscsi_req) {
trace_pvscsi_command_complete_not_found(req->tag);
return;
}
if (resid) {
/* Short transf... | 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": "b0f49d138777fb6609aa2ea96d2c59fb872d2c2d",
"normalized_at": "2026-06-20T05:17:39.466790Z",
"combined_dataset_split": "train",
"combined_at": "2026-06-20T05:23:08.742901Z"
} | ||
codexglue_train_013047 | CodeXGLUE Defect Detection | public_dataset | train | 16242 | c | generic | vulnerability_detection | unknown | unknown | unknown | false | unknown_defect_or_vulnerability | static void test_dispatch_cmd(void)
{
QDict *req = qdict_new();
QObject *resp;
qdict_put_obj(req, "execute", QOBJECT(qstring_from_str("user_def_cmd")));
resp = qmp_dispatch(QOBJECT(req));
assert(resp != NULL);
assert(!qdict_haskey(qobject_to_qdict(resp), "error"));
g_print("\nres... | 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": "151c5693258f594541fa9ea585547a0a8dd68abc",
"normalized_at": "2026-06-20T05:17:39.255202Z",
"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.