id int32 0 27.3k | func stringlengths 26 142k | target bool 2 classes | project stringclasses 2 values | commit_id stringlengths 40 40 | func_clean stringlengths 26 131k | vul_lines dict | normalized_func stringlengths 24 132k | lines listlengths 1 2.8k | label listlengths 1 2.8k | line_no listlengths 1 2.8k |
|---|---|---|---|---|---|---|---|---|---|---|
1,955 | static BlockDriverState *get_bs_snapshots(void)
{
BlockDriverState *bs;
DriveInfo *dinfo;
if (bs_snapshots)
return bs_snapshots;
QTAILQ_FOREACH(dinfo, &drives, next) {
bs = dinfo->bdrv;
if (bdrv_can_snapshot(bs))
goto ok;
}
return NULL;
ok:
bs_snapshots = bs;
return bs;
}
| true | qemu | feeee5aca765606818e00f5a19d19f141f4ae365 | static BlockDriverState *get_bs_snapshots(void)
{
BlockDriverState *bs;
DriveInfo *dinfo;
if (bs_snapshots)
return bs_snapshots;
QTAILQ_FOREACH(dinfo, &drives, next) {
bs = dinfo->bdrv;
if (bdrv_can_snapshot(bs))
goto ok;
}
return NULL;
ok:
bs_snapshots = bs;
return bs;
}
| {
"code": [
" if (bdrv_can_snapshot(bs))"
],
"line_no": [
19
]
} | static BlockDriverState *FUNC_0(void)
{
BlockDriverState *bs;
DriveInfo *dinfo;
if (bs_snapshots)
return bs_snapshots;
QTAILQ_FOREACH(dinfo, &drives, next) {
bs = dinfo->bdrv;
if (bdrv_can_snapshot(bs))
goto ok;
}
return NULL;
ok:
bs_snapshots = bs;
return bs;
}
| [
"static BlockDriverState *FUNC_0(void)\n{",
"BlockDriverState *bs;",
"DriveInfo *dinfo;",
"if (bs_snapshots)\nreturn bs_snapshots;",
"QTAILQ_FOREACH(dinfo, &drives, next) {",
"bs = dinfo->bdrv;",
"if (bdrv_can_snapshot(bs))\ngoto ok;",
"}",
"return NULL;",
"ok:\nbs_snapshots = bs;",
"return bs;"... | [
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11,
13
],
[
15
],
[
17
],
[
19,
21
],
[
23
],
[
25
],
[
27,
29
],
[
31
],
[
33
]
] |
1,957 | opts_visitor_new(const QemuOpts *opts)
{
OptsVisitor *ov;
ov = g_malloc0(sizeof *ov);
ov->visitor.type = VISITOR_INPUT;
ov->visitor.start_struct = &opts_start_struct;
ov->visitor.check_struct = &opts_check_struct;
ov->visitor.end_struct = &opts_end_struct;
ov->visitor.start_list = &opts_start_list;
ov->visitor.next_list = &opts_next_list;
ov->visitor.end_list = &opts_end_list;
ov->visitor.type_int64 = &opts_type_int64;
ov->visitor.type_uint64 = &opts_type_uint64;
ov->visitor.type_size = &opts_type_size;
ov->visitor.type_bool = &opts_type_bool;
ov->visitor.type_str = &opts_type_str;
/* type_number() is not filled in, but this is not the first visitor to
* skip some mandatory methods... */
ov->visitor.optional = &opts_optional;
ov->visitor.free = opts_free;
ov->opts_root = opts;
return &ov->visitor;
} | true | qemu | f332e830e38b3ff3953ef02ac04e409ae53769c5 | opts_visitor_new(const QemuOpts *opts)
{
OptsVisitor *ov;
ov = g_malloc0(sizeof *ov);
ov->visitor.type = VISITOR_INPUT;
ov->visitor.start_struct = &opts_start_struct;
ov->visitor.check_struct = &opts_check_struct;
ov->visitor.end_struct = &opts_end_struct;
ov->visitor.start_list = &opts_start_list;
ov->visitor.next_list = &opts_next_list;
ov->visitor.end_list = &opts_end_list;
ov->visitor.type_int64 = &opts_type_int64;
ov->visitor.type_uint64 = &opts_type_uint64;
ov->visitor.type_size = &opts_type_size;
ov->visitor.type_bool = &opts_type_bool;
ov->visitor.type_str = &opts_type_str;
ov->visitor.optional = &opts_optional;
ov->visitor.free = opts_free;
ov->opts_root = opts;
return &ov->visitor;
} | {
"code": [],
"line_no": []
} | FUNC_0(const QemuOpts *VAR_0)
{
OptsVisitor *ov;
ov = g_malloc0(sizeof *ov);
ov->visitor.type = VISITOR_INPUT;
ov->visitor.start_struct = &opts_start_struct;
ov->visitor.check_struct = &opts_check_struct;
ov->visitor.end_struct = &opts_end_struct;
ov->visitor.start_list = &opts_start_list;
ov->visitor.next_list = &opts_next_list;
ov->visitor.end_list = &opts_end_list;
ov->visitor.type_int64 = &opts_type_int64;
ov->visitor.type_uint64 = &opts_type_uint64;
ov->visitor.type_size = &opts_type_size;
ov->visitor.type_bool = &opts_type_bool;
ov->visitor.type_str = &opts_type_str;
ov->visitor.optional = &opts_optional;
ov->visitor.free = opts_free;
ov->opts_root = VAR_0;
return &ov->visitor;
} | [
"FUNC_0(const QemuOpts *VAR_0)\n{",
"OptsVisitor *ov;",
"ov = g_malloc0(sizeof *ov);",
"ov->visitor.type = VISITOR_INPUT;",
"ov->visitor.start_struct = &opts_start_struct;",
"ov->visitor.check_struct = &opts_check_struct;",
"ov->visitor.end_struct = &opts_end_struct;",
"ov->visitor.start_list = &opt... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
10
],
[
14
],
[
18
],
[
20
],
[
22
],
[
26
],
[
28
],
[
30
],
[
34
],
[
36
],
[
38
],
[
40
],
[
42
],
[
52
],
[
54
],
[
58
],
[
62
],
[
6... |
1,958 | size_t qcrypto_hash_digest_len(QCryptoHashAlgorithm alg)
{
if (alg >= G_N_ELEMENTS(qcrypto_hash_alg_size)) {
return 0;
}
return qcrypto_hash_alg_size[alg];
}
| true | qemu | b35c1f3361ebf6ec9ea5022903af4b559bff6063 | size_t qcrypto_hash_digest_len(QCryptoHashAlgorithm alg)
{
if (alg >= G_N_ELEMENTS(qcrypto_hash_alg_size)) {
return 0;
}
return qcrypto_hash_alg_size[alg];
}
| {
"code": [
" if (alg >= G_N_ELEMENTS(qcrypto_hash_alg_size)) {",
" return 0;"
],
"line_no": [
5,
7
]
} | size_t FUNC_0(QCryptoHashAlgorithm alg)
{
if (alg >= G_N_ELEMENTS(qcrypto_hash_alg_size)) {
return 0;
}
return qcrypto_hash_alg_size[alg];
}
| [
"size_t FUNC_0(QCryptoHashAlgorithm alg)\n{",
"if (alg >= G_N_ELEMENTS(qcrypto_hash_alg_size)) {",
"return 0;",
"}",
"return qcrypto_hash_alg_size[alg];",
"}"
] | [
0,
1,
1,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
]
] |
1,959 | int read_targphys(const char *name,
int fd, target_phys_addr_t dst_addr, size_t nbytes)
{
uint8_t *buf;
size_t did;
buf = g_malloc(nbytes);
did = read(fd, buf, nbytes);
if (did > 0)
rom_add_blob_fixed("read", buf, did, dst_addr);
g_free(buf);
return did;
}
| true | qemu | 725e14e91f80b6b2c07b75b66b7b042a9fa9340c | int read_targphys(const char *name,
int fd, target_phys_addr_t dst_addr, size_t nbytes)
{
uint8_t *buf;
size_t did;
buf = g_malloc(nbytes);
did = read(fd, buf, nbytes);
if (did > 0)
rom_add_blob_fixed("read", buf, did, dst_addr);
g_free(buf);
return did;
}
| {
"code": [
"int read_targphys(const char *name,",
" int fd, target_phys_addr_t dst_addr, size_t nbytes)",
" size_t did;",
"int read_targphys(const char *name,"
],
"line_no": [
1,
3,
9,
1
]
} | int FUNC_0(const char *VAR_0,
int VAR_1, target_phys_addr_t VAR_2, size_t VAR_3)
{
uint8_t *buf;
size_t did;
buf = g_malloc(VAR_3);
did = read(VAR_1, buf, VAR_3);
if (did > 0)
rom_add_blob_fixed("read", buf, did, VAR_2);
g_free(buf);
return did;
}
| [
"int FUNC_0(const char *VAR_0,\nint VAR_1, target_phys_addr_t VAR_2, size_t VAR_3)\n{",
"uint8_t *buf;",
"size_t did;",
"buf = g_malloc(VAR_3);",
"did = read(VAR_1, buf, VAR_3);",
"if (did > 0)\nrom_add_blob_fixed(\"read\", buf, did, VAR_2);",
"g_free(buf);",
"return did;",
"}"
] | [
1,
0,
1,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17,
19
],
[
21
],
[
23
],
[
25
]
] |
1,961 | static inline void RENAME(yuy2ToY)(uint8_t *dst, uint8_t *src, int width)
{
#ifdef HAVE_MMXFIXME
#else
int i;
for(i=0; i<width; i++)
dst[i]= src[2*i];
#endif
}
| false | FFmpeg | 6ff0ad6bfd0f00a3d54705811ee91a7ce3c22cda | static inline void RENAME(yuy2ToY)(uint8_t *dst, uint8_t *src, int width)
{
#ifdef HAVE_MMXFIXME
#else
int i;
for(i=0; i<width; i++)
dst[i]= src[2*i];
#endif
}
| {
"code": [],
"line_no": []
} | static inline void FUNC_0(yuy2ToY)(uint8_t *dst, uint8_t *src, int width)
{
#ifdef HAVE_MMXFIXME
#else
int VAR_0;
for(VAR_0=0; VAR_0<width; VAR_0++)
dst[VAR_0]= src[2*VAR_0];
#endif
}
| [
"static inline void FUNC_0(yuy2ToY)(uint8_t *dst, uint8_t *src, int width)\n{",
"#ifdef HAVE_MMXFIXME\n#else\nint VAR_0;",
"for(VAR_0=0; VAR_0<width; VAR_0++)",
"dst[VAR_0]= src[2*VAR_0];",
"#endif\n}"
] | [
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5,
7,
9
],
[
11
],
[
13
],
[
15,
17
]
] |
1,962 | static av_cold int source_init(AVFilterContext *ctx, const char *args, void *opaque)
{
Frei0rContext *frei0r = ctx->priv;
char dl_name[1024], c;
char frame_size[128] = "";
char frame_rate[128] = "";
AVRational frame_rate_q;
memset(frei0r->params, 0, sizeof(frei0r->params));
if (args)
sscanf(args, "%127[^:]:%127[^:]:%1023[^:=]%c%255c",
frame_size, frame_rate, dl_name, &c, frei0r->params);
if (av_parse_video_size(&frei0r->w, &frei0r->h, frame_size) < 0) {
av_log(ctx, AV_LOG_ERROR, "Invalid frame size: '%s'\n", frame_size);
return AVERROR(EINVAL);
}
if (av_parse_video_rate(&frame_rate_q, frame_rate) < 0 ||
frame_rate_q.den <= 0 || frame_rate_q.num <= 0) {
av_log(ctx, AV_LOG_ERROR, "Invalid frame rate: '%s'\n", frame_rate);
return AVERROR(EINVAL);
}
frei0r->time_base.num = frame_rate_q.den;
frei0r->time_base.den = frame_rate_q.num;
return frei0r_init(ctx, dl_name, F0R_PLUGIN_TYPE_SOURCE);
}
| false | FFmpeg | de0587739011b7636743251a86d48bcd10ab7c22 | static av_cold int source_init(AVFilterContext *ctx, const char *args, void *opaque)
{
Frei0rContext *frei0r = ctx->priv;
char dl_name[1024], c;
char frame_size[128] = "";
char frame_rate[128] = "";
AVRational frame_rate_q;
memset(frei0r->params, 0, sizeof(frei0r->params));
if (args)
sscanf(args, "%127[^:]:%127[^:]:%1023[^:=]%c%255c",
frame_size, frame_rate, dl_name, &c, frei0r->params);
if (av_parse_video_size(&frei0r->w, &frei0r->h, frame_size) < 0) {
av_log(ctx, AV_LOG_ERROR, "Invalid frame size: '%s'\n", frame_size);
return AVERROR(EINVAL);
}
if (av_parse_video_rate(&frame_rate_q, frame_rate) < 0 ||
frame_rate_q.den <= 0 || frame_rate_q.num <= 0) {
av_log(ctx, AV_LOG_ERROR, "Invalid frame rate: '%s'\n", frame_rate);
return AVERROR(EINVAL);
}
frei0r->time_base.num = frame_rate_q.den;
frei0r->time_base.den = frame_rate_q.num;
return frei0r_init(ctx, dl_name, F0R_PLUGIN_TYPE_SOURCE);
}
| {
"code": [],
"line_no": []
} | static av_cold int FUNC_0(AVFilterContext *ctx, const char *args, void *opaque)
{
Frei0rContext *frei0r = ctx->priv;
char VAR_0[1024], VAR_1;
char VAR_2[128] = "";
char VAR_3[128] = "";
AVRational frame_rate_q;
memset(frei0r->params, 0, sizeof(frei0r->params));
if (args)
sscanf(args, "%127[^:]:%127[^:]:%1023[^:=]%VAR_1%255c",
VAR_2, VAR_3, VAR_0, &VAR_1, frei0r->params);
if (av_parse_video_size(&frei0r->w, &frei0r->h, VAR_2) < 0) {
av_log(ctx, AV_LOG_ERROR, "Invalid frame size: '%s'\n", VAR_2);
return AVERROR(EINVAL);
}
if (av_parse_video_rate(&frame_rate_q, VAR_3) < 0 ||
frame_rate_q.den <= 0 || frame_rate_q.num <= 0) {
av_log(ctx, AV_LOG_ERROR, "Invalid frame rate: '%s'\n", VAR_3);
return AVERROR(EINVAL);
}
frei0r->time_base.num = frame_rate_q.den;
frei0r->time_base.den = frame_rate_q.num;
return frei0r_init(ctx, VAR_0, F0R_PLUGIN_TYPE_SOURCE);
}
| [
"static av_cold int FUNC_0(AVFilterContext *ctx, const char *args, void *opaque)\n{",
"Frei0rContext *frei0r = ctx->priv;",
"char VAR_0[1024], VAR_1;",
"char VAR_2[128] = \"\";",
"char VAR_3[128] = \"\";",
"AVRational frame_rate_q;",
"memset(frei0r->params, 0, sizeof(frei0r->params));",
"if (args)\nss... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
21,
23,
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39,
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[... |
1,964 | static void dash_free(AVFormatContext *s)
{
DASHContext *c = s->priv_data;
int i, j;
if (c->as) {
for (i = 0; i < c->nb_as; i++)
av_dict_free(&c->as[i].metadata);
av_freep(&c->as);
c->nb_as = 0;
}
if (!c->streams)
return;
for (i = 0; i < s->nb_streams; i++) {
OutputStream *os = &c->streams[i];
if (os->ctx && os->ctx_inited)
av_write_trailer(os->ctx);
if (os->ctx && os->ctx->pb)
ffio_free_dyn_buf(&os->ctx->pb);
ff_format_io_close(s, &os->out);
if (os->ctx)
avformat_free_context(os->ctx);
for (j = 0; j < os->nb_segments; j++)
av_free(os->segments[j]);
av_free(os->segments);
}
av_freep(&c->streams);
} | true | FFmpeg | 0df9d0f4cbcb18006f9fde0502671f9ef293e2f2 | static void dash_free(AVFormatContext *s)
{
DASHContext *c = s->priv_data;
int i, j;
if (c->as) {
for (i = 0; i < c->nb_as; i++)
av_dict_free(&c->as[i].metadata);
av_freep(&c->as);
c->nb_as = 0;
}
if (!c->streams)
return;
for (i = 0; i < s->nb_streams; i++) {
OutputStream *os = &c->streams[i];
if (os->ctx && os->ctx_inited)
av_write_trailer(os->ctx);
if (os->ctx && os->ctx->pb)
ffio_free_dyn_buf(&os->ctx->pb);
ff_format_io_close(s, &os->out);
if (os->ctx)
avformat_free_context(os->ctx);
for (j = 0; j < os->nb_segments; j++)
av_free(os->segments[j]);
av_free(os->segments);
}
av_freep(&c->streams);
} | {
"code": [],
"line_no": []
} | static void FUNC_0(AVFormatContext *VAR_0)
{
DASHContext *c = VAR_0->priv_data;
int VAR_1, VAR_2;
if (c->as) {
for (VAR_1 = 0; VAR_1 < c->nb_as; VAR_1++)
av_dict_free(&c->as[VAR_1].metadata);
av_freep(&c->as);
c->nb_as = 0;
}
if (!c->streams)
return;
for (VAR_1 = 0; VAR_1 < VAR_0->nb_streams; VAR_1++) {
OutputStream *os = &c->streams[VAR_1];
if (os->ctx && os->ctx_inited)
av_write_trailer(os->ctx);
if (os->ctx && os->ctx->pb)
ffio_free_dyn_buf(&os->ctx->pb);
ff_format_io_close(VAR_0, &os->out);
if (os->ctx)
avformat_free_context(os->ctx);
for (VAR_2 = 0; VAR_2 < os->nb_segments; VAR_2++)
av_free(os->segments[VAR_2]);
av_free(os->segments);
}
av_freep(&c->streams);
} | [
"static void FUNC_0(AVFormatContext *VAR_0)\n{",
"DASHContext *c = VAR_0->priv_data;",
"int VAR_1, VAR_2;",
"if (c->as) {",
"for (VAR_1 = 0; VAR_1 < c->nb_as; VAR_1++)",
"av_dict_free(&c->as[VAR_1].metadata);",
"av_freep(&c->as);",
"c->nb_as = 0;",
"}",
"if (!c->streams)\nreturn;",
"for (VAR_1 =... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
2
],
[
3
],
[
4
],
[
5
],
[
6
],
[
7
],
[
8
],
[
9
],
[
10
],
[
11,
12
],
[
13
],
[
14
],
[
15,
16
],
[
17,
18
],
[
19
],
[
20,
21
],
[
22
],
[
23
],... |
1,965 | static void decode_bo_addrmode_post_pre_base(CPUTriCoreState *env,
DisasContext *ctx)
{
uint32_t op2;
uint32_t off10;
int32_t r1, r2;
TCGv temp;
r1 = MASK_OP_BO_S1D(ctx->opcode);
r2 = MASK_OP_BO_S2(ctx->opcode);
off10 = MASK_OP_BO_OFF10_SEXT(ctx->opcode);
op2 = MASK_OP_BO_OP2(ctx->opcode);
switch (op2) {
case OPC2_32_BO_CACHEA_WI_SHORTOFF:
case OPC2_32_BO_CACHEA_W_SHORTOFF:
case OPC2_32_BO_CACHEA_I_SHORTOFF:
/* instruction to access the cache */
break;
case OPC2_32_BO_CACHEA_WI_POSTINC:
case OPC2_32_BO_CACHEA_W_POSTINC:
case OPC2_32_BO_CACHEA_I_POSTINC:
/* instruction to access the cache, but we still need to handle
the addressing mode */
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_CACHEA_WI_PREINC:
case OPC2_32_BO_CACHEA_W_PREINC:
case OPC2_32_BO_CACHEA_I_PREINC:
/* instruction to access the cache, but we still need to handle
the addressing mode */
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_CACHEI_WI_SHORTOFF:
case OPC2_32_BO_CACHEI_W_SHORTOFF:
/* TODO: Raise illegal opcode trap,
if !tricore_feature(TRICORE_FEATURE_131) */
break;
case OPC2_32_BO_CACHEI_W_POSTINC:
case OPC2_32_BO_CACHEI_WI_POSTINC:
if (tricore_feature(env, TRICORE_FEATURE_131)) {
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
} /* TODO: else raise illegal opcode trap */
break;
case OPC2_32_BO_CACHEI_W_PREINC:
case OPC2_32_BO_CACHEI_WI_PREINC:
if (tricore_feature(env, TRICORE_FEATURE_131)) {
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
} /* TODO: else raise illegal opcode trap */
break;
case OPC2_32_BO_ST_A_SHORTOFF:
gen_offset_st(ctx, cpu_gpr_a[r1], cpu_gpr_a[r2], off10, MO_LESL);
break;
case OPC2_32_BO_ST_A_POSTINC:
tcg_gen_qemu_st_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], ctx->mem_idx,
MO_LESL);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_A_PREINC:
gen_st_preincr(ctx, cpu_gpr_a[r1], cpu_gpr_a[r2], off10, MO_LESL);
break;
case OPC2_32_BO_ST_B_SHORTOFF:
gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_UB);
break;
case OPC2_32_BO_ST_B_POSTINC:
tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
MO_UB);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_B_PREINC:
gen_st_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_UB);
break;
case OPC2_32_BO_ST_D_SHORTOFF:
gen_offset_st_2regs(cpu_gpr_d[r1+1], cpu_gpr_d[r1], cpu_gpr_a[r2],
off10, ctx);
break;
case OPC2_32_BO_ST_D_POSTINC:
gen_st_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], cpu_gpr_a[r2], ctx);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_D_PREINC:
temp = tcg_temp_new();
tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
gen_st_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], temp, ctx);
tcg_gen_mov_tl(cpu_gpr_a[r2], temp);
tcg_temp_free(temp);
break;
case OPC2_32_BO_ST_DA_SHORTOFF:
gen_offset_st_2regs(cpu_gpr_a[r1+1], cpu_gpr_a[r1], cpu_gpr_a[r2],
off10, ctx);
break;
case OPC2_32_BO_ST_DA_POSTINC:
gen_st_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], cpu_gpr_a[r2], ctx);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_DA_PREINC:
temp = tcg_temp_new();
tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
gen_st_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], temp, ctx);
tcg_gen_mov_tl(cpu_gpr_a[r2], temp);
tcg_temp_free(temp);
break;
case OPC2_32_BO_ST_H_SHORTOFF:
gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
break;
case OPC2_32_BO_ST_H_POSTINC:
tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
MO_LEUW);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_H_PREINC:
gen_st_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
break;
case OPC2_32_BO_ST_Q_SHORTOFF:
temp = tcg_temp_new();
tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
gen_offset_st(ctx, temp, cpu_gpr_a[r2], off10, MO_LEUW);
tcg_temp_free(temp);
break;
case OPC2_32_BO_ST_Q_POSTINC:
temp = tcg_temp_new();
tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
tcg_gen_qemu_st_tl(temp, cpu_gpr_a[r2], ctx->mem_idx,
MO_LEUW);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
tcg_temp_free(temp);
break;
case OPC2_32_BO_ST_Q_PREINC:
temp = tcg_temp_new();
tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
gen_st_preincr(ctx, temp, cpu_gpr_a[r2], off10, MO_LEUW);
tcg_temp_free(temp);
break;
case OPC2_32_BO_ST_W_SHORTOFF:
gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUL);
break;
case OPC2_32_BO_ST_W_POSTINC:
tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
MO_LEUL);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_W_PREINC:
gen_st_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUL);
break;
}
}
| true | qemu | f678f671ba654d4610f0e43d175c8c1b2fad10df | static void decode_bo_addrmode_post_pre_base(CPUTriCoreState *env,
DisasContext *ctx)
{
uint32_t op2;
uint32_t off10;
int32_t r1, r2;
TCGv temp;
r1 = MASK_OP_BO_S1D(ctx->opcode);
r2 = MASK_OP_BO_S2(ctx->opcode);
off10 = MASK_OP_BO_OFF10_SEXT(ctx->opcode);
op2 = MASK_OP_BO_OP2(ctx->opcode);
switch (op2) {
case OPC2_32_BO_CACHEA_WI_SHORTOFF:
case OPC2_32_BO_CACHEA_W_SHORTOFF:
case OPC2_32_BO_CACHEA_I_SHORTOFF:
break;
case OPC2_32_BO_CACHEA_WI_POSTINC:
case OPC2_32_BO_CACHEA_W_POSTINC:
case OPC2_32_BO_CACHEA_I_POSTINC:
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_CACHEA_WI_PREINC:
case OPC2_32_BO_CACHEA_W_PREINC:
case OPC2_32_BO_CACHEA_I_PREINC:
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_CACHEI_WI_SHORTOFF:
case OPC2_32_BO_CACHEI_W_SHORTOFF:
break;
case OPC2_32_BO_CACHEI_W_POSTINC:
case OPC2_32_BO_CACHEI_WI_POSTINC:
if (tricore_feature(env, TRICORE_FEATURE_131)) {
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
}
break;
case OPC2_32_BO_CACHEI_W_PREINC:
case OPC2_32_BO_CACHEI_WI_PREINC:
if (tricore_feature(env, TRICORE_FEATURE_131)) {
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
}
break;
case OPC2_32_BO_ST_A_SHORTOFF:
gen_offset_st(ctx, cpu_gpr_a[r1], cpu_gpr_a[r2], off10, MO_LESL);
break;
case OPC2_32_BO_ST_A_POSTINC:
tcg_gen_qemu_st_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], ctx->mem_idx,
MO_LESL);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_A_PREINC:
gen_st_preincr(ctx, cpu_gpr_a[r1], cpu_gpr_a[r2], off10, MO_LESL);
break;
case OPC2_32_BO_ST_B_SHORTOFF:
gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_UB);
break;
case OPC2_32_BO_ST_B_POSTINC:
tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
MO_UB);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_B_PREINC:
gen_st_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_UB);
break;
case OPC2_32_BO_ST_D_SHORTOFF:
gen_offset_st_2regs(cpu_gpr_d[r1+1], cpu_gpr_d[r1], cpu_gpr_a[r2],
off10, ctx);
break;
case OPC2_32_BO_ST_D_POSTINC:
gen_st_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], cpu_gpr_a[r2], ctx);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_D_PREINC:
temp = tcg_temp_new();
tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
gen_st_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], temp, ctx);
tcg_gen_mov_tl(cpu_gpr_a[r2], temp);
tcg_temp_free(temp);
break;
case OPC2_32_BO_ST_DA_SHORTOFF:
gen_offset_st_2regs(cpu_gpr_a[r1+1], cpu_gpr_a[r1], cpu_gpr_a[r2],
off10, ctx);
break;
case OPC2_32_BO_ST_DA_POSTINC:
gen_st_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], cpu_gpr_a[r2], ctx);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_DA_PREINC:
temp = tcg_temp_new();
tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
gen_st_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], temp, ctx);
tcg_gen_mov_tl(cpu_gpr_a[r2], temp);
tcg_temp_free(temp);
break;
case OPC2_32_BO_ST_H_SHORTOFF:
gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
break;
case OPC2_32_BO_ST_H_POSTINC:
tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
MO_LEUW);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_H_PREINC:
gen_st_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
break;
case OPC2_32_BO_ST_Q_SHORTOFF:
temp = tcg_temp_new();
tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
gen_offset_st(ctx, temp, cpu_gpr_a[r2], off10, MO_LEUW);
tcg_temp_free(temp);
break;
case OPC2_32_BO_ST_Q_POSTINC:
temp = tcg_temp_new();
tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
tcg_gen_qemu_st_tl(temp, cpu_gpr_a[r2], ctx->mem_idx,
MO_LEUW);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
tcg_temp_free(temp);
break;
case OPC2_32_BO_ST_Q_PREINC:
temp = tcg_temp_new();
tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
gen_st_preincr(ctx, temp, cpu_gpr_a[r2], off10, MO_LEUW);
tcg_temp_free(temp);
break;
case OPC2_32_BO_ST_W_SHORTOFF:
gen_offset_st(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUL);
break;
case OPC2_32_BO_ST_W_POSTINC:
tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], ctx->mem_idx,
MO_LEUL);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_W_PREINC:
gen_st_preincr(ctx, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUL);
break;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(CPUTriCoreState *VAR_0,
DisasContext *VAR_1)
{
uint32_t op2;
uint32_t off10;
int32_t r1, r2;
TCGv temp;
r1 = MASK_OP_BO_S1D(VAR_1->opcode);
r2 = MASK_OP_BO_S2(VAR_1->opcode);
off10 = MASK_OP_BO_OFF10_SEXT(VAR_1->opcode);
op2 = MASK_OP_BO_OP2(VAR_1->opcode);
switch (op2) {
case OPC2_32_BO_CACHEA_WI_SHORTOFF:
case OPC2_32_BO_CACHEA_W_SHORTOFF:
case OPC2_32_BO_CACHEA_I_SHORTOFF:
break;
case OPC2_32_BO_CACHEA_WI_POSTINC:
case OPC2_32_BO_CACHEA_W_POSTINC:
case OPC2_32_BO_CACHEA_I_POSTINC:
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_CACHEA_WI_PREINC:
case OPC2_32_BO_CACHEA_W_PREINC:
case OPC2_32_BO_CACHEA_I_PREINC:
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_CACHEI_WI_SHORTOFF:
case OPC2_32_BO_CACHEI_W_SHORTOFF:
break;
case OPC2_32_BO_CACHEI_W_POSTINC:
case OPC2_32_BO_CACHEI_WI_POSTINC:
if (tricore_feature(VAR_0, TRICORE_FEATURE_131)) {
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
}
break;
case OPC2_32_BO_CACHEI_W_PREINC:
case OPC2_32_BO_CACHEI_WI_PREINC:
if (tricore_feature(VAR_0, TRICORE_FEATURE_131)) {
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
}
break;
case OPC2_32_BO_ST_A_SHORTOFF:
gen_offset_st(VAR_1, cpu_gpr_a[r1], cpu_gpr_a[r2], off10, MO_LESL);
break;
case OPC2_32_BO_ST_A_POSTINC:
tcg_gen_qemu_st_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], VAR_1->mem_idx,
MO_LESL);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_A_PREINC:
gen_st_preincr(VAR_1, cpu_gpr_a[r1], cpu_gpr_a[r2], off10, MO_LESL);
break;
case OPC2_32_BO_ST_B_SHORTOFF:
gen_offset_st(VAR_1, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_UB);
break;
case OPC2_32_BO_ST_B_POSTINC:
tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], VAR_1->mem_idx,
MO_UB);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_B_PREINC:
gen_st_preincr(VAR_1, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_UB);
break;
case OPC2_32_BO_ST_D_SHORTOFF:
gen_offset_st_2regs(cpu_gpr_d[r1+1], cpu_gpr_d[r1], cpu_gpr_a[r2],
off10, VAR_1);
break;
case OPC2_32_BO_ST_D_POSTINC:
gen_st_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], cpu_gpr_a[r2], VAR_1);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_D_PREINC:
temp = tcg_temp_new();
tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
gen_st_2regs_64(cpu_gpr_d[r1+1], cpu_gpr_d[r1], temp, VAR_1);
tcg_gen_mov_tl(cpu_gpr_a[r2], temp);
tcg_temp_free(temp);
break;
case OPC2_32_BO_ST_DA_SHORTOFF:
gen_offset_st_2regs(cpu_gpr_a[r1+1], cpu_gpr_a[r1], cpu_gpr_a[r2],
off10, VAR_1);
break;
case OPC2_32_BO_ST_DA_POSTINC:
gen_st_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], cpu_gpr_a[r2], VAR_1);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_DA_PREINC:
temp = tcg_temp_new();
tcg_gen_addi_tl(temp, cpu_gpr_a[r2], off10);
gen_st_2regs_64(cpu_gpr_a[r1+1], cpu_gpr_a[r1], temp, VAR_1);
tcg_gen_mov_tl(cpu_gpr_a[r2], temp);
tcg_temp_free(temp);
break;
case OPC2_32_BO_ST_H_SHORTOFF:
gen_offset_st(VAR_1, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
break;
case OPC2_32_BO_ST_H_POSTINC:
tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], VAR_1->mem_idx,
MO_LEUW);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_H_PREINC:
gen_st_preincr(VAR_1, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);
break;
case OPC2_32_BO_ST_Q_SHORTOFF:
temp = tcg_temp_new();
tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
gen_offset_st(VAR_1, temp, cpu_gpr_a[r2], off10, MO_LEUW);
tcg_temp_free(temp);
break;
case OPC2_32_BO_ST_Q_POSTINC:
temp = tcg_temp_new();
tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
tcg_gen_qemu_st_tl(temp, cpu_gpr_a[r2], VAR_1->mem_idx,
MO_LEUW);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
tcg_temp_free(temp);
break;
case OPC2_32_BO_ST_Q_PREINC:
temp = tcg_temp_new();
tcg_gen_shri_tl(temp, cpu_gpr_d[r1], 16);
gen_st_preincr(VAR_1, temp, cpu_gpr_a[r2], off10, MO_LEUW);
tcg_temp_free(temp);
break;
case OPC2_32_BO_ST_W_SHORTOFF:
gen_offset_st(VAR_1, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUL);
break;
case OPC2_32_BO_ST_W_POSTINC:
tcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], VAR_1->mem_idx,
MO_LEUL);
tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);
break;
case OPC2_32_BO_ST_W_PREINC:
gen_st_preincr(VAR_1, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUL);
break;
}
}
| [
"static void FUNC_0(CPUTriCoreState *VAR_0,\nDisasContext *VAR_1)\n{",
"uint32_t op2;",
"uint32_t off10;",
"int32_t r1, r2;",
"TCGv temp;",
"r1 = MASK_OP_BO_S1D(VAR_1->opcode);",
"r2 = MASK_OP_BO_S2(VAR_1->opcode);",
"off10 = MASK_OP_BO_OFF10_SEXT(VAR_1->opcode);",
"op2 = MASK_OP_BO_OP2(VAR_1->opco... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29,
31,
33,
37
],
[
39,
41,
43,
49
],
[
51
],
[
53,
55,
57,
63
],
[
65
... |
1,966 | void ff_wms_parse_sdp_a_line(AVFormatContext *s, const char *p)
{
if (av_strstart(p, "pgmpu:data:application/vnd.ms.wms-hdr.asfv1;base64,", &p)) {
ByteIOContext pb;
RTSPState *rt = s->priv_data;
int len = strlen(p) * 6 / 8;
char *buf = av_mallocz(len);
av_base64_decode(buf, p, len);
if (rtp_asf_fix_header(buf, len) < 0)
av_log(s, AV_LOG_ERROR,
"Failed to fix invalid RTSP-MS/ASF min_pktsize\n");
init_packetizer(&pb, buf, len);
if (rt->asf_ctx) {
av_close_input_stream(rt->asf_ctx);
rt->asf_ctx = NULL;
}
av_open_input_stream(&rt->asf_ctx, &pb, "", &asf_demuxer, NULL);
rt->asf_pb_pos = url_ftell(&pb);
av_free(buf);
rt->asf_ctx->pb = NULL;
}
}
| true | FFmpeg | 0fca8d24ee00284652eecedaa1f922641cdc59b1 | void ff_wms_parse_sdp_a_line(AVFormatContext *s, const char *p)
{
if (av_strstart(p, "pgmpu:data:application/vnd.ms.wms-hdr.asfv1;base64,", &p)) {
ByteIOContext pb;
RTSPState *rt = s->priv_data;
int len = strlen(p) * 6 / 8;
char *buf = av_mallocz(len);
av_base64_decode(buf, p, len);
if (rtp_asf_fix_header(buf, len) < 0)
av_log(s, AV_LOG_ERROR,
"Failed to fix invalid RTSP-MS/ASF min_pktsize\n");
init_packetizer(&pb, buf, len);
if (rt->asf_ctx) {
av_close_input_stream(rt->asf_ctx);
rt->asf_ctx = NULL;
}
av_open_input_stream(&rt->asf_ctx, &pb, "", &asf_demuxer, NULL);
rt->asf_pb_pos = url_ftell(&pb);
av_free(buf);
rt->asf_ctx->pb = NULL;
}
}
| {
"code": [
"void ff_wms_parse_sdp_a_line(AVFormatContext *s, const char *p)",
" av_open_input_stream(&rt->asf_ctx, &pb, \"\", &asf_demuxer, NULL);"
],
"line_no": [
1,
35
]
} | void FUNC_0(AVFormatContext *VAR_0, const char *VAR_1)
{
if (av_strstart(VAR_1, "pgmpu:data:application/vnd.ms.wms-hdr.asfv1;base64,", &VAR_1)) {
ByteIOContext pb;
RTSPState *rt = VAR_0->priv_data;
int VAR_2 = strlen(VAR_1) * 6 / 8;
char *VAR_3 = av_mallocz(VAR_2);
av_base64_decode(VAR_3, VAR_1, VAR_2);
if (rtp_asf_fix_header(VAR_3, VAR_2) < 0)
av_log(VAR_0, AV_LOG_ERROR,
"Failed to fix invalid RTSP-MS/ASF min_pktsize\n");
init_packetizer(&pb, VAR_3, VAR_2);
if (rt->asf_ctx) {
av_close_input_stream(rt->asf_ctx);
rt->asf_ctx = NULL;
}
av_open_input_stream(&rt->asf_ctx, &pb, "", &asf_demuxer, NULL);
rt->asf_pb_pos = url_ftell(&pb);
av_free(VAR_3);
rt->asf_ctx->pb = NULL;
}
}
| [
"void FUNC_0(AVFormatContext *VAR_0, const char *VAR_1)\n{",
"if (av_strstart(VAR_1, \"pgmpu:data:application/vnd.ms.wms-hdr.asfv1;base64,\", &VAR_1)) {",
"ByteIOContext pb;",
"RTSPState *rt = VAR_0->priv_data;",
"int VAR_2 = strlen(VAR_1) * 6 / 8;",
"char *VAR_3 = av_mallocz(VAR_2);",
"av_base64_decode... | [
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19,
21,
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
... |
1,967 | static int dtext_prepare_text(AVFilterContext *ctx)
{
DrawTextContext *dtext = ctx->priv;
uint32_t code = 0, prev_code = 0;
int x = 0, y = 0, i = 0, ret;
int text_height, baseline;
char *text = dtext->text;
uint8_t *p;
int str_w = 0, len;
int y_min = 32000, y_max = -32000;
FT_Vector delta;
Glyph *glyph = NULL, *prev_glyph = NULL;
Glyph dummy = { 0 };
int width = ctx->inputs[0]->w;
int height = ctx->inputs[0]->h;
#if HAVE_LOCALTIME_R
time_t now = time(0);
struct tm ltime;
uint8_t *buf = dtext->expanded_text;
int buf_size = dtext->expanded_text_size;
if (!buf)
buf_size = 2*strlen(dtext->text)+1;
localtime_r(&now, <ime);
while ((buf = av_realloc(buf, buf_size))) {
*buf = 1;
if (strftime(buf, buf_size, dtext->text, <ime) != 0 || *buf == 0)
break;
buf_size *= 2;
}
if (!buf)
return AVERROR(ENOMEM);
text = dtext->expanded_text = buf;
dtext->expanded_text_size = buf_size;
#endif
if ((len = strlen(text)) > dtext->nb_positions) {
FT_Vector *p = av_realloc(dtext->positions,
len * sizeof(*dtext->positions));
if (!p) {
av_freep(dtext->positions);
dtext->nb_positions = 0;
return AVERROR(ENOMEM);
} else {
dtext->positions = p;
dtext->nb_positions = len;
}
}
/* load and cache glyphs */
for (i = 0, p = text; *p; i++) {
GET_UTF8(code, *p++, continue;);
/* get glyph */
dummy.code = code;
glyph = av_tree_find(dtext->glyphs, &dummy, glyph_cmp, NULL);
if (!glyph)
ret = load_glyph(ctx, &glyph, code);
if (ret) return ret;
y_min = FFMIN(glyph->bbox.yMin, y_min);
y_max = FFMAX(glyph->bbox.yMax, y_max);
}
text_height = y_max - y_min;
baseline = y_max;
/* compute and save position for each glyph */
glyph = NULL;
for (i = 0, p = text; *p; i++) {
GET_UTF8(code, *p++, continue;);
/* skip the \n in the sequence \r\n */
if (prev_code == '\r' && code == '\n')
continue;
prev_code = code;
if (is_newline(code)) {
str_w = FFMAX(str_w, x - dtext->x);
y += text_height;
x = 0;
continue;
}
/* get glyph */
prev_glyph = glyph;
dummy.code = code;
glyph = av_tree_find(dtext->glyphs, &dummy, glyph_cmp, NULL);
/* kerning */
if (dtext->use_kerning && prev_glyph && glyph->code) {
FT_Get_Kerning(dtext->face, prev_glyph->code, glyph->code,
ft_kerning_default, &delta);
x += delta.x >> 6;
}
if (x + glyph->bbox.xMax >= width) {
str_w = FFMAX(str_w, x);
y += text_height;
x = 0;
}
/* save position */
dtext->positions[i].x = x + glyph->bitmap_left;
dtext->positions[i].y = y - glyph->bitmap_top + baseline;
if (code == '\t') x = (x / dtext->tabsize + 1)*dtext->tabsize;
else x += glyph->advance;
}
str_w = FFMIN(width - 1, FFMAX(str_w, x));
y = FFMIN(y + text_height, height - 1);
dtext->w = str_w;
dtext->h = y;
return 0;
}
| true | FFmpeg | e7f0bc8c0f1c4a8731eb1c33cb013296a0555538 | static int dtext_prepare_text(AVFilterContext *ctx)
{
DrawTextContext *dtext = ctx->priv;
uint32_t code = 0, prev_code = 0;
int x = 0, y = 0, i = 0, ret;
int text_height, baseline;
char *text = dtext->text;
uint8_t *p;
int str_w = 0, len;
int y_min = 32000, y_max = -32000;
FT_Vector delta;
Glyph *glyph = NULL, *prev_glyph = NULL;
Glyph dummy = { 0 };
int width = ctx->inputs[0]->w;
int height = ctx->inputs[0]->h;
#if HAVE_LOCALTIME_R
time_t now = time(0);
struct tm ltime;
uint8_t *buf = dtext->expanded_text;
int buf_size = dtext->expanded_text_size;
if (!buf)
buf_size = 2*strlen(dtext->text)+1;
localtime_r(&now, <ime);
while ((buf = av_realloc(buf, buf_size))) {
*buf = 1;
if (strftime(buf, buf_size, dtext->text, <ime) != 0 || *buf == 0)
break;
buf_size *= 2;
}
if (!buf)
return AVERROR(ENOMEM);
text = dtext->expanded_text = buf;
dtext->expanded_text_size = buf_size;
#endif
if ((len = strlen(text)) > dtext->nb_positions) {
FT_Vector *p = av_realloc(dtext->positions,
len * sizeof(*dtext->positions));
if (!p) {
av_freep(dtext->positions);
dtext->nb_positions = 0;
return AVERROR(ENOMEM);
} else {
dtext->positions = p;
dtext->nb_positions = len;
}
}
for (i = 0, p = text; *p; i++) {
GET_UTF8(code, *p++, continue;);
dummy.code = code;
glyph = av_tree_find(dtext->glyphs, &dummy, glyph_cmp, NULL);
if (!glyph)
ret = load_glyph(ctx, &glyph, code);
if (ret) return ret;
y_min = FFMIN(glyph->bbox.yMin, y_min);
y_max = FFMAX(glyph->bbox.yMax, y_max);
}
text_height = y_max - y_min;
baseline = y_max;
glyph = NULL;
for (i = 0, p = text; *p; i++) {
GET_UTF8(code, *p++, continue;);
if (prev_code == '\r' && code == '\n')
continue;
prev_code = code;
if (is_newline(code)) {
str_w = FFMAX(str_w, x - dtext->x);
y += text_height;
x = 0;
continue;
}
prev_glyph = glyph;
dummy.code = code;
glyph = av_tree_find(dtext->glyphs, &dummy, glyph_cmp, NULL);
if (dtext->use_kerning && prev_glyph && glyph->code) {
FT_Get_Kerning(dtext->face, prev_glyph->code, glyph->code,
ft_kerning_default, &delta);
x += delta.x >> 6;
}
if (x + glyph->bbox.xMax >= width) {
str_w = FFMAX(str_w, x);
y += text_height;
x = 0;
}
dtext->positions[i].x = x + glyph->bitmap_left;
dtext->positions[i].y = y - glyph->bitmap_top + baseline;
if (code == '\t') x = (x / dtext->tabsize + 1)*dtext->tabsize;
else x += glyph->advance;
}
str_w = FFMIN(width - 1, FFMAX(str_w, x));
y = FFMIN(y + text_height, height - 1);
dtext->w = str_w;
dtext->h = y;
return 0;
}
| {
"code": [
" if (!glyph)",
" if (ret) return ret;"
],
"line_no": [
121,
125
]
} | static int FUNC_0(AVFilterContext *VAR_0)
{
DrawTextContext *dtext = VAR_0->priv;
uint32_t code = 0, prev_code = 0;
int VAR_1 = 0, VAR_2 = 0, VAR_3 = 0, VAR_4;
int VAR_5, VAR_6;
char *VAR_7 = dtext->VAR_7;
uint8_t *p;
int VAR_8 = 0, VAR_9;
int VAR_10 = 32000, VAR_11 = -32000;
FT_Vector delta;
Glyph *glyph = NULL, *prev_glyph = NULL;
Glyph dummy = { 0 };
int VAR_12 = VAR_0->inputs[0]->w;
int VAR_13 = VAR_0->inputs[0]->h;
#if HAVE_LOCALTIME_R
time_t now = time(0);
struct tm ltime;
uint8_t *buf = dtext->expanded_text;
int buf_size = dtext->expanded_text_size;
if (!buf)
buf_size = 2*strlen(dtext->VAR_7)+1;
localtime_r(&now, <ime);
while ((buf = av_realloc(buf, buf_size))) {
*buf = 1;
if (strftime(buf, buf_size, dtext->VAR_7, <ime) != 0 || *buf == 0)
break;
buf_size *= 2;
}
if (!buf)
return AVERROR(ENOMEM);
VAR_7 = dtext->expanded_text = buf;
dtext->expanded_text_size = buf_size;
#endif
if ((VAR_9 = strlen(VAR_7)) > dtext->nb_positions) {
FT_Vector *p = av_realloc(dtext->positions,
VAR_9 * sizeof(*dtext->positions));
if (!p) {
av_freep(dtext->positions);
dtext->nb_positions = 0;
return AVERROR(ENOMEM);
} else {
dtext->positions = p;
dtext->nb_positions = VAR_9;
}
}
for (VAR_3 = 0, p = VAR_7; *p; VAR_3++) {
GET_UTF8(code, *p++, continue;);
dummy.code = code;
glyph = av_tree_find(dtext->glyphs, &dummy, glyph_cmp, NULL);
if (!glyph)
VAR_4 = load_glyph(VAR_0, &glyph, code);
if (VAR_4) return VAR_4;
VAR_10 = FFMIN(glyph->bbox.yMin, VAR_10);
VAR_11 = FFMAX(glyph->bbox.yMax, VAR_11);
}
VAR_5 = VAR_11 - VAR_10;
VAR_6 = VAR_11;
glyph = NULL;
for (VAR_3 = 0, p = VAR_7; *p; VAR_3++) {
GET_UTF8(code, *p++, continue;);
if (prev_code == '\r' && code == '\n')
continue;
prev_code = code;
if (is_newline(code)) {
VAR_8 = FFMAX(VAR_8, VAR_1 - dtext->VAR_1);
VAR_2 += VAR_5;
VAR_1 = 0;
continue;
}
prev_glyph = glyph;
dummy.code = code;
glyph = av_tree_find(dtext->glyphs, &dummy, glyph_cmp, NULL);
if (dtext->use_kerning && prev_glyph && glyph->code) {
FT_Get_Kerning(dtext->face, prev_glyph->code, glyph->code,
ft_kerning_default, &delta);
VAR_1 += delta.VAR_1 >> 6;
}
if (VAR_1 + glyph->bbox.xMax >= VAR_12) {
VAR_8 = FFMAX(VAR_8, VAR_1);
VAR_2 += VAR_5;
VAR_1 = 0;
}
dtext->positions[VAR_3].VAR_1 = VAR_1 + glyph->bitmap_left;
dtext->positions[VAR_3].VAR_2 = VAR_2 - glyph->bitmap_top + VAR_6;
if (code == '\t') VAR_1 = (VAR_1 / dtext->tabsize + 1)*dtext->tabsize;
else VAR_1 += glyph->advance;
}
VAR_8 = FFMIN(VAR_12 - 1, FFMAX(VAR_8, VAR_1));
VAR_2 = FFMIN(VAR_2 + VAR_5, VAR_13 - 1);
dtext->w = VAR_8;
dtext->h = VAR_2;
return 0;
}
| [
"static int FUNC_0(AVFilterContext *VAR_0)\n{",
"DrawTextContext *dtext = VAR_0->priv;",
"uint32_t code = 0, prev_code = 0;",
"int VAR_1 = 0, VAR_2 = 0, VAR_3 = 0, VAR_4;",
"int VAR_5, VAR_6;",
"char *VAR_7 = dtext->VAR_7;",
"uint8_t *p;",
"int VAR_8 = 0, VAR_9;",
"int VAR_10 = 32000, VAR_11 = -3200... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33,
35
],
[
37
],
[
39
],
[
41
],
[
45,
47
... |
1,968 | static int vsink_query_formats(AVFilterContext *ctx)
{
BufferSinkContext *buf = ctx->priv;
AVFilterFormats *formats = NULL;
unsigned i;
int ret;
CHECK_LIST_SIZE(pixel_fmts)
if (buf->pixel_fmts_size) {
for (i = 0; i < NB_ITEMS(buf->pixel_fmts); i++)
if ((ret = ff_add_format(&formats, buf->pixel_fmts[i])) < 0)
return ret;
ff_set_common_formats(ctx, formats);
} else {
ff_default_query_formats(ctx);
}
return 0;
}
| true | FFmpeg | fd7a7e11b94b12259c6f1e375da15298cbc37e83 | static int vsink_query_formats(AVFilterContext *ctx)
{
BufferSinkContext *buf = ctx->priv;
AVFilterFormats *formats = NULL;
unsigned i;
int ret;
CHECK_LIST_SIZE(pixel_fmts)
if (buf->pixel_fmts_size) {
for (i = 0; i < NB_ITEMS(buf->pixel_fmts); i++)
if ((ret = ff_add_format(&formats, buf->pixel_fmts[i])) < 0)
return ret;
ff_set_common_formats(ctx, formats);
} else {
ff_default_query_formats(ctx);
}
return 0;
}
| {
"code": [
" if ((ret = ff_add_format(&formats, buf->pixel_fmts[i])) < 0)"
],
"line_no": [
21
]
} | static int FUNC_0(AVFilterContext *VAR_0)
{
BufferSinkContext *buf = VAR_0->priv;
AVFilterFormats *formats = NULL;
unsigned VAR_1;
int VAR_2;
CHECK_LIST_SIZE(pixel_fmts)
if (buf->pixel_fmts_size) {
for (VAR_1 = 0; VAR_1 < NB_ITEMS(buf->pixel_fmts); VAR_1++)
if ((VAR_2 = ff_add_format(&formats, buf->pixel_fmts[VAR_1])) < 0)
return VAR_2;
ff_set_common_formats(VAR_0, formats);
} else {
ff_default_query_formats(VAR_0);
}
return 0;
}
| [
"static int FUNC_0(AVFilterContext *VAR_0)\n{",
"BufferSinkContext *buf = VAR_0->priv;",
"AVFilterFormats *formats = NULL;",
"unsigned VAR_1;",
"int VAR_2;",
"CHECK_LIST_SIZE(pixel_fmts)\nif (buf->pixel_fmts_size) {",
"for (VAR_1 = 0; VAR_1 < NB_ITEMS(buf->pixel_fmts); VAR_1++)",
"if ((VAR_2 = ff_add_... | [
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15,
17
],
[
19
],
[
21,
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
]
] |
1,969 | static int poll_filters(void)
{
AVFilterBufferRef *picref;
AVFrame *filtered_frame = NULL;
int i, frame_size;
for (i = 0; i < nb_output_streams; i++) {
OutputStream *ost = output_streams[i];
OutputFile *of = output_files[ost->file_index];
int ret = 0;
if (!ost->filter)
continue;
if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
return AVERROR(ENOMEM);
} else
avcodec_get_frame_defaults(ost->filtered_frame);
filtered_frame = ost->filtered_frame;
while (ret >= 0 && !ost->is_past_recording_time) {
if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
!(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
ret = av_buffersink_read_samples(ost->filter->filter, &picref,
ost->st->codec->frame_size);
else
ret = av_buffersink_read(ost->filter->filter, &picref);
if (ret < 0)
break;
avfilter_copy_buf_props(filtered_frame, picref);
if (picref->pts != AV_NOPTS_VALUE)
filtered_frame->pts = av_rescale_q(picref->pts,
ost->filter->filter->inputs[0]->time_base,
ost->st->codec->time_base) -
av_rescale_q(of->start_time,
AV_TIME_BASE_Q,
ost->st->codec->time_base);
if (of->start_time && filtered_frame->pts < of->start_time) {
avfilter_unref_buffer(picref);
continue;
}
switch (ost->filter->filter->inputs[0]->type) {
case AVMEDIA_TYPE_VIDEO:
if (!ost->frame_aspect_ratio)
ost->st->codec->sample_aspect_ratio = picref->video->pixel_aspect;
do_video_out(of->ctx, ost, filtered_frame, &frame_size,
same_quant ? ost->last_quality :
ost->st->codec->global_quality);
if (vstats_filename && frame_size)
do_video_stats(of->ctx, ost, frame_size);
break;
case AVMEDIA_TYPE_AUDIO:
do_audio_out(of->ctx, ost, filtered_frame);
break;
default:
// TODO support subtitle filters
av_assert0(0);
}
avfilter_unref_buffer(picref);
}
}
return 0;
}
| false | FFmpeg | b98c8f4f2bf5879ba5393a439f0fccf76a65e448 | static int poll_filters(void)
{
AVFilterBufferRef *picref;
AVFrame *filtered_frame = NULL;
int i, frame_size;
for (i = 0; i < nb_output_streams; i++) {
OutputStream *ost = output_streams[i];
OutputFile *of = output_files[ost->file_index];
int ret = 0;
if (!ost->filter)
continue;
if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
return AVERROR(ENOMEM);
} else
avcodec_get_frame_defaults(ost->filtered_frame);
filtered_frame = ost->filtered_frame;
while (ret >= 0 && !ost->is_past_recording_time) {
if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
!(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
ret = av_buffersink_read_samples(ost->filter->filter, &picref,
ost->st->codec->frame_size);
else
ret = av_buffersink_read(ost->filter->filter, &picref);
if (ret < 0)
break;
avfilter_copy_buf_props(filtered_frame, picref);
if (picref->pts != AV_NOPTS_VALUE)
filtered_frame->pts = av_rescale_q(picref->pts,
ost->filter->filter->inputs[0]->time_base,
ost->st->codec->time_base) -
av_rescale_q(of->start_time,
AV_TIME_BASE_Q,
ost->st->codec->time_base);
if (of->start_time && filtered_frame->pts < of->start_time) {
avfilter_unref_buffer(picref);
continue;
}
switch (ost->filter->filter->inputs[0]->type) {
case AVMEDIA_TYPE_VIDEO:
if (!ost->frame_aspect_ratio)
ost->st->codec->sample_aspect_ratio = picref->video->pixel_aspect;
do_video_out(of->ctx, ost, filtered_frame, &frame_size,
same_quant ? ost->last_quality :
ost->st->codec->global_quality);
if (vstats_filename && frame_size)
do_video_stats(of->ctx, ost, frame_size);
break;
case AVMEDIA_TYPE_AUDIO:
do_audio_out(of->ctx, ost, filtered_frame);
break;
default:
av_assert0(0);
}
avfilter_unref_buffer(picref);
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(void)
{
AVFilterBufferRef *picref;
AVFrame *filtered_frame = NULL;
int VAR_0, VAR_1;
for (VAR_0 = 0; VAR_0 < nb_output_streams; VAR_0++) {
OutputStream *ost = output_streams[VAR_0];
OutputFile *of = output_files[ost->file_index];
int ret = 0;
if (!ost->filter)
continue;
if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
return AVERROR(ENOMEM);
} else
avcodec_get_frame_defaults(ost->filtered_frame);
filtered_frame = ost->filtered_frame;
while (ret >= 0 && !ost->is_past_recording_time) {
if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
!(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
ret = av_buffersink_read_samples(ost->filter->filter, &picref,
ost->st->codec->VAR_1);
else
ret = av_buffersink_read(ost->filter->filter, &picref);
if (ret < 0)
break;
avfilter_copy_buf_props(filtered_frame, picref);
if (picref->pts != AV_NOPTS_VALUE)
filtered_frame->pts = av_rescale_q(picref->pts,
ost->filter->filter->inputs[0]->time_base,
ost->st->codec->time_base) -
av_rescale_q(of->start_time,
AV_TIME_BASE_Q,
ost->st->codec->time_base);
if (of->start_time && filtered_frame->pts < of->start_time) {
avfilter_unref_buffer(picref);
continue;
}
switch (ost->filter->filter->inputs[0]->type) {
case AVMEDIA_TYPE_VIDEO:
if (!ost->frame_aspect_ratio)
ost->st->codec->sample_aspect_ratio = picref->video->pixel_aspect;
do_video_out(of->ctx, ost, filtered_frame, &VAR_1,
same_quant ? ost->last_quality :
ost->st->codec->global_quality);
if (vstats_filename && VAR_1)
do_video_stats(of->ctx, ost, VAR_1);
break;
case AVMEDIA_TYPE_AUDIO:
do_audio_out(of->ctx, ost, filtered_frame);
break;
default:
av_assert0(0);
}
avfilter_unref_buffer(picref);
}
}
return 0;
}
| [
"static int FUNC_0(void)\n{",
"AVFilterBufferRef *picref;",
"AVFrame *filtered_frame = NULL;",
"int VAR_0, VAR_1;",
"for (VAR_0 = 0; VAR_0 < nb_output_streams; VAR_0++) {",
"OutputStream *ost = output_streams[VAR_0];",
"OutputFile *of = output_files[ost->file_index];",
"int ret = 0;",
"if (!ost->... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23,
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43,
45,
47,
49
],
[
51,
53
],
[... |
1,970 | static int file_read_dir(URLContext *h, AVIODirEntry **next)
{
#if HAVE_DIRENT_H
FileContext *c = h->priv_data;
struct dirent *dir;
char *fullpath = NULL;
*next = ff_alloc_dir_entry();
if (!*next)
return AVERROR(ENOMEM);
do {
errno = 0;
dir = readdir(c->dir);
if (!dir) {
av_freep(next);
return AVERROR(errno);
}
} while (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."));
fullpath = av_append_path_component(h->filename, dir->d_name);
if (fullpath) {
struct stat st;
if (!lstat(fullpath, &st)) {
if (S_ISDIR(st.st_mode))
(*next)->type = AVIO_ENTRY_DIRECTORY;
else if (S_ISFIFO(st.st_mode))
(*next)->type = AVIO_ENTRY_NAMED_PIPE;
else if (S_ISCHR(st.st_mode))
(*next)->type = AVIO_ENTRY_CHARACTER_DEVICE;
else if (S_ISBLK(st.st_mode))
(*next)->type = AVIO_ENTRY_BLOCK_DEVICE;
else if (S_ISLNK(st.st_mode))
(*next)->type = AVIO_ENTRY_SYMBOLIC_LINK;
else if (S_ISSOCK(st.st_mode))
(*next)->type = AVIO_ENTRY_SOCKET;
else if (S_ISREG(st.st_mode))
(*next)->type = AVIO_ENTRY_FILE;
else
(*next)->type = AVIO_ENTRY_UNKNOWN;
(*next)->group_id = st.st_gid;
(*next)->user_id = st.st_uid;
(*next)->size = st.st_size;
(*next)->filemode = st.st_mode & 0777;
(*next)->modification_timestamp = INT64_C(1000000) * st.st_mtime;
(*next)->access_timestamp = INT64_C(1000000) * st.st_atime;
(*next)->status_change_timestamp = INT64_C(1000000) * st.st_ctime;
}
av_free(fullpath);
}
(*next)->name = av_strdup(dir->d_name);
return 0;
#else
return AVERROR(ENOSYS);
#endif /* HAVE_DIRENT_H */
}
| false | FFmpeg | d65b9114f35c1afe2a7061f0a1ec957d33ba02b5 | static int file_read_dir(URLContext *h, AVIODirEntry **next)
{
#if HAVE_DIRENT_H
FileContext *c = h->priv_data;
struct dirent *dir;
char *fullpath = NULL;
*next = ff_alloc_dir_entry();
if (!*next)
return AVERROR(ENOMEM);
do {
errno = 0;
dir = readdir(c->dir);
if (!dir) {
av_freep(next);
return AVERROR(errno);
}
} while (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."));
fullpath = av_append_path_component(h->filename, dir->d_name);
if (fullpath) {
struct stat st;
if (!lstat(fullpath, &st)) {
if (S_ISDIR(st.st_mode))
(*next)->type = AVIO_ENTRY_DIRECTORY;
else if (S_ISFIFO(st.st_mode))
(*next)->type = AVIO_ENTRY_NAMED_PIPE;
else if (S_ISCHR(st.st_mode))
(*next)->type = AVIO_ENTRY_CHARACTER_DEVICE;
else if (S_ISBLK(st.st_mode))
(*next)->type = AVIO_ENTRY_BLOCK_DEVICE;
else if (S_ISLNK(st.st_mode))
(*next)->type = AVIO_ENTRY_SYMBOLIC_LINK;
else if (S_ISSOCK(st.st_mode))
(*next)->type = AVIO_ENTRY_SOCKET;
else if (S_ISREG(st.st_mode))
(*next)->type = AVIO_ENTRY_FILE;
else
(*next)->type = AVIO_ENTRY_UNKNOWN;
(*next)->group_id = st.st_gid;
(*next)->user_id = st.st_uid;
(*next)->size = st.st_size;
(*next)->filemode = st.st_mode & 0777;
(*next)->modification_timestamp = INT64_C(1000000) * st.st_mtime;
(*next)->access_timestamp = INT64_C(1000000) * st.st_atime;
(*next)->status_change_timestamp = INT64_C(1000000) * st.st_ctime;
}
av_free(fullpath);
}
(*next)->name = av_strdup(dir->d_name);
return 0;
#else
return AVERROR(ENOSYS);
#endif
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(URLContext *VAR_0, AVIODirEntry **VAR_1)
{
#if HAVE_DIRENT_H
FileContext *c = VAR_0->priv_data;
struct dirent *dir;
char *fullpath = NULL;
*VAR_1 = ff_alloc_dir_entry();
if (!*VAR_1)
return AVERROR(ENOMEM);
do {
errno = 0;
dir = readdir(c->dir);
if (!dir) {
av_freep(VAR_1);
return AVERROR(errno);
}
} while (!strcmp(dir->d_name, ".") || !strcmp(dir->d_name, ".."));
fullpath = av_append_path_component(VAR_0->filename, dir->d_name);
if (fullpath) {
struct stat st;
if (!lstat(fullpath, &st)) {
if (S_ISDIR(st.st_mode))
(*VAR_1)->type = AVIO_ENTRY_DIRECTORY;
else if (S_ISFIFO(st.st_mode))
(*VAR_1)->type = AVIO_ENTRY_NAMED_PIPE;
else if (S_ISCHR(st.st_mode))
(*VAR_1)->type = AVIO_ENTRY_CHARACTER_DEVICE;
else if (S_ISBLK(st.st_mode))
(*VAR_1)->type = AVIO_ENTRY_BLOCK_DEVICE;
else if (S_ISLNK(st.st_mode))
(*VAR_1)->type = AVIO_ENTRY_SYMBOLIC_LINK;
else if (S_ISSOCK(st.st_mode))
(*VAR_1)->type = AVIO_ENTRY_SOCKET;
else if (S_ISREG(st.st_mode))
(*VAR_1)->type = AVIO_ENTRY_FILE;
else
(*VAR_1)->type = AVIO_ENTRY_UNKNOWN;
(*VAR_1)->group_id = st.st_gid;
(*VAR_1)->user_id = st.st_uid;
(*VAR_1)->size = st.st_size;
(*VAR_1)->filemode = st.st_mode & 0777;
(*VAR_1)->modification_timestamp = INT64_C(1000000) * st.st_mtime;
(*VAR_1)->access_timestamp = INT64_C(1000000) * st.st_atime;
(*VAR_1)->status_change_timestamp = INT64_C(1000000) * st.st_ctime;
}
av_free(fullpath);
}
(*VAR_1)->name = av_strdup(dir->d_name);
return 0;
#else
return AVERROR(ENOSYS);
#endif
}
| [
"static int FUNC_0(URLContext *VAR_0, AVIODirEntry **VAR_1)\n{",
"#if HAVE_DIRENT_H\nFileContext *c = VAR_0->priv_data;",
"struct dirent *dir;",
"char *fullpath = NULL;",
"*VAR_1 = ff_alloc_dir_entry();",
"if (!*VAR_1)\nreturn AVERROR(ENOMEM);",
"do {",
"errno = 0;",
"dir = readdir(c->dir);",
"if ... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5,
7
],
[
9
],
[
11
],
[
15
],
[
17,
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47,... |
1,971 | static void monitor_qmp_event(void *opaque, int event)
{
QObject *data;
Monitor *mon = opaque;
switch (event) {
case CHR_EVENT_OPENED:
mon->qmp.in_command_mode = false;
data = get_qmp_greeting();
monitor_json_emitter(mon, data);
qobject_decref(data);
mon_refcount++;
break;
case CHR_EVENT_CLOSED:
json_message_parser_destroy(&mon->qmp.parser);
json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
mon_refcount--;
monitor_fdsets_cleanup();
break;
}
}
| true | qemu | 635db18f68ded6abec11cd4cf64ebc15c1c6b190 | static void monitor_qmp_event(void *opaque, int event)
{
QObject *data;
Monitor *mon = opaque;
switch (event) {
case CHR_EVENT_OPENED:
mon->qmp.in_command_mode = false;
data = get_qmp_greeting();
monitor_json_emitter(mon, data);
qobject_decref(data);
mon_refcount++;
break;
case CHR_EVENT_CLOSED:
json_message_parser_destroy(&mon->qmp.parser);
json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
mon_refcount--;
monitor_fdsets_cleanup();
break;
}
}
| {
"code": [
" mon->qmp.in_command_mode = false;"
],
"line_no": [
15
]
} | static void FUNC_0(void *VAR_0, int VAR_1)
{
QObject *data;
Monitor *mon = VAR_0;
switch (VAR_1) {
case CHR_EVENT_OPENED:
mon->qmp.in_command_mode = false;
data = get_qmp_greeting();
monitor_json_emitter(mon, data);
qobject_decref(data);
mon_refcount++;
break;
case CHR_EVENT_CLOSED:
json_message_parser_destroy(&mon->qmp.parser);
json_message_parser_init(&mon->qmp.parser, handle_qmp_command);
mon_refcount--;
monitor_fdsets_cleanup();
break;
}
}
| [
"static void FUNC_0(void *VAR_0, int VAR_1)\n{",
"QObject *data;",
"Monitor *mon = VAR_0;",
"switch (VAR_1) {",
"case CHR_EVENT_OPENED:\nmon->qmp.in_command_mode = false;",
"data = get_qmp_greeting();",
"monitor_json_emitter(mon, data);",
"qobject_decref(data);",
"mon_refcount++;",
"break;",
"ca... | [
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13,
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
]
] |
1,972 | void add_user_command(char *optarg)
{
ncmdline++;
cmdline = realloc(cmdline, ncmdline * sizeof(char *));
if (!cmdline) {
perror("realloc");
exit(1);
}
cmdline[ncmdline-1] = optarg;
}
| true | qemu | ba7806ad92a2f6b1625cfa67d44dc1b71e3be44e | void add_user_command(char *optarg)
{
ncmdline++;
cmdline = realloc(cmdline, ncmdline * sizeof(char *));
if (!cmdline) {
perror("realloc");
exit(1);
}
cmdline[ncmdline-1] = optarg;
}
| {
"code": [
" ncmdline++;",
" cmdline = realloc(cmdline, ncmdline * sizeof(char *));",
" if (!cmdline) {",
" perror(\"realloc\");",
" exit(1);"
],
"line_no": [
5,
7,
9,
11,
13
]
} | void FUNC_0(char *VAR_0)
{
ncmdline++;
cmdline = realloc(cmdline, ncmdline * sizeof(char *));
if (!cmdline) {
perror("realloc");
exit(1);
}
cmdline[ncmdline-1] = VAR_0;
}
| [
"void FUNC_0(char *VAR_0)\n{",
"ncmdline++;",
"cmdline = realloc(cmdline, ncmdline * sizeof(char *));",
"if (!cmdline) {",
"perror(\"realloc\");",
"exit(1);",
"}",
"cmdline[ncmdline-1] = VAR_0;",
"}"
] | [
0,
1,
1,
1,
1,
1,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
]
] |
1,974 | static void check_update_timer(RTCState *s)
{
uint64_t next_update_time;
uint64_t guest_nsec;
int next_alarm_sec;
/* From the data sheet: "Holding the dividers in reset prevents
* interrupts from operating, while setting the SET bit allows"
* them to occur. However, it will prevent an alarm interrupt
* from occurring, because the time of day is not updated.
*/
if ((s->cmos_data[RTC_REG_A] & 0x60) == 0x60) {
timer_del(s->update_timer);
return;
}
if ((s->cmos_data[RTC_REG_C] & REG_C_UF) &&
(s->cmos_data[RTC_REG_B] & REG_B_SET)) {
timer_del(s->update_timer);
return;
}
if ((s->cmos_data[RTC_REG_C] & REG_C_UF) &&
(s->cmos_data[RTC_REG_C] & REG_C_AF)) {
timer_del(s->update_timer);
return;
}
guest_nsec = get_guest_rtc_ns(s) % NANOSECONDS_PER_SECOND;
/* if UF is clear, reprogram to next second */
next_update_time = qemu_clock_get_ns(rtc_clock)
+ NANOSECONDS_PER_SECOND - guest_nsec;
/* Compute time of next alarm. One second is already accounted
* for in next_update_time.
*/
next_alarm_sec = get_next_alarm(s);
s->next_alarm_time = next_update_time +
(next_alarm_sec - 1) * NANOSECONDS_PER_SECOND;
if (s->cmos_data[RTC_REG_C] & REG_C_UF) {
/* UF is set, but AF is clear. Program the timer to target
* the alarm time. */
next_update_time = s->next_alarm_time;
}
if (next_update_time != timer_expire_time_ns(s->update_timer)) {
timer_mod(s->update_timer, next_update_time);
}
}
| false | qemu | 6a51d83a17e8213db353dd6756685fd9e3513e13 | static void check_update_timer(RTCState *s)
{
uint64_t next_update_time;
uint64_t guest_nsec;
int next_alarm_sec;
if ((s->cmos_data[RTC_REG_A] & 0x60) == 0x60) {
timer_del(s->update_timer);
return;
}
if ((s->cmos_data[RTC_REG_C] & REG_C_UF) &&
(s->cmos_data[RTC_REG_B] & REG_B_SET)) {
timer_del(s->update_timer);
return;
}
if ((s->cmos_data[RTC_REG_C] & REG_C_UF) &&
(s->cmos_data[RTC_REG_C] & REG_C_AF)) {
timer_del(s->update_timer);
return;
}
guest_nsec = get_guest_rtc_ns(s) % NANOSECONDS_PER_SECOND;
next_update_time = qemu_clock_get_ns(rtc_clock)
+ NANOSECONDS_PER_SECOND - guest_nsec;
next_alarm_sec = get_next_alarm(s);
s->next_alarm_time = next_update_time +
(next_alarm_sec - 1) * NANOSECONDS_PER_SECOND;
if (s->cmos_data[RTC_REG_C] & REG_C_UF) {
next_update_time = s->next_alarm_time;
}
if (next_update_time != timer_expire_time_ns(s->update_timer)) {
timer_mod(s->update_timer, next_update_time);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(RTCState *VAR_0)
{
uint64_t next_update_time;
uint64_t guest_nsec;
int VAR_1;
if ((VAR_0->cmos_data[RTC_REG_A] & 0x60) == 0x60) {
timer_del(VAR_0->update_timer);
return;
}
if ((VAR_0->cmos_data[RTC_REG_C] & REG_C_UF) &&
(VAR_0->cmos_data[RTC_REG_B] & REG_B_SET)) {
timer_del(VAR_0->update_timer);
return;
}
if ((VAR_0->cmos_data[RTC_REG_C] & REG_C_UF) &&
(VAR_0->cmos_data[RTC_REG_C] & REG_C_AF)) {
timer_del(VAR_0->update_timer);
return;
}
guest_nsec = get_guest_rtc_ns(VAR_0) % NANOSECONDS_PER_SECOND;
next_update_time = qemu_clock_get_ns(rtc_clock)
+ NANOSECONDS_PER_SECOND - guest_nsec;
VAR_1 = get_next_alarm(VAR_0);
VAR_0->next_alarm_time = next_update_time +
(VAR_1 - 1) * NANOSECONDS_PER_SECOND;
if (VAR_0->cmos_data[RTC_REG_C] & REG_C_UF) {
next_update_time = VAR_0->next_alarm_time;
}
if (next_update_time != timer_expire_time_ns(VAR_0->update_timer)) {
timer_mod(VAR_0->update_timer, next_update_time);
}
}
| [
"static void FUNC_0(RTCState *VAR_0)\n{",
"uint64_t next_update_time;",
"uint64_t guest_nsec;",
"int VAR_1;",
"if ((VAR_0->cmos_data[RTC_REG_A] & 0x60) == 0x60) {",
"timer_del(VAR_0->update_timer);",
"return;",
"}",
"if ((VAR_0->cmos_data[RTC_REG_C] & REG_C_UF) &&\n(VAR_0->cmos_data[RTC_REG_B] & REG... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31,
33
],
[
35
],
[
37
],
[
39
],
[
41,
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
57,
59
],
[... |
1,975 | int main(int argc, char **argv)
{
TestInputVisitorData testdata;
g_test_init(&argc, &argv, NULL);
validate_test_add("/visitor/input-strict/pass/struct",
&testdata, test_validate_struct);
validate_test_add("/visitor/input-strict/pass/struct-nested",
&testdata, test_validate_struct_nested);
validate_test_add("/visitor/input-strict/pass/list",
&testdata, test_validate_list);
validate_test_add("/visitor/input-strict/pass/union",
&testdata, test_validate_union);
validate_test_add("/visitor/input-strict/pass/union-flat",
&testdata, test_validate_union_flat);
validate_test_add("/visitor/input-strict/pass/union-anon",
&testdata, test_validate_union_anon);
validate_test_add("/visitor/input-strict/fail/struct",
&testdata, test_validate_fail_struct);
validate_test_add("/visitor/input-strict/fail/struct-nested",
&testdata, test_validate_fail_struct_nested);
validate_test_add("/visitor/input-strict/fail/list",
&testdata, test_validate_fail_list);
validate_test_add("/visitor/input-strict/fail/union",
&testdata, test_validate_fail_union);
validate_test_add("/visitor/input-strict/fail/union-flat",
&testdata, test_validate_fail_union_flat);
validate_test_add("/visitor/input-strict/fail/union-flat-no-discriminator",
&testdata, test_validate_fail_union_flat_no_discrim);
validate_test_add("/visitor/input-strict/fail/union-anon",
&testdata, test_validate_fail_union_anon);
g_test_run();
return 0;
}
| false | qemu | 805017b7791200f1b72deef17dc98fd272b941eb | int main(int argc, char **argv)
{
TestInputVisitorData testdata;
g_test_init(&argc, &argv, NULL);
validate_test_add("/visitor/input-strict/pass/struct",
&testdata, test_validate_struct);
validate_test_add("/visitor/input-strict/pass/struct-nested",
&testdata, test_validate_struct_nested);
validate_test_add("/visitor/input-strict/pass/list",
&testdata, test_validate_list);
validate_test_add("/visitor/input-strict/pass/union",
&testdata, test_validate_union);
validate_test_add("/visitor/input-strict/pass/union-flat",
&testdata, test_validate_union_flat);
validate_test_add("/visitor/input-strict/pass/union-anon",
&testdata, test_validate_union_anon);
validate_test_add("/visitor/input-strict/fail/struct",
&testdata, test_validate_fail_struct);
validate_test_add("/visitor/input-strict/fail/struct-nested",
&testdata, test_validate_fail_struct_nested);
validate_test_add("/visitor/input-strict/fail/list",
&testdata, test_validate_fail_list);
validate_test_add("/visitor/input-strict/fail/union",
&testdata, test_validate_fail_union);
validate_test_add("/visitor/input-strict/fail/union-flat",
&testdata, test_validate_fail_union_flat);
validate_test_add("/visitor/input-strict/fail/union-flat-no-discriminator",
&testdata, test_validate_fail_union_flat_no_discrim);
validate_test_add("/visitor/input-strict/fail/union-anon",
&testdata, test_validate_fail_union_anon);
g_test_run();
return 0;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(int VAR_0, char **VAR_1)
{
TestInputVisitorData testdata;
g_test_init(&VAR_0, &VAR_1, NULL);
validate_test_add("/visitor/input-strict/pass/struct",
&testdata, test_validate_struct);
validate_test_add("/visitor/input-strict/pass/struct-nested",
&testdata, test_validate_struct_nested);
validate_test_add("/visitor/input-strict/pass/list",
&testdata, test_validate_list);
validate_test_add("/visitor/input-strict/pass/union",
&testdata, test_validate_union);
validate_test_add("/visitor/input-strict/pass/union-flat",
&testdata, test_validate_union_flat);
validate_test_add("/visitor/input-strict/pass/union-anon",
&testdata, test_validate_union_anon);
validate_test_add("/visitor/input-strict/fail/struct",
&testdata, test_validate_fail_struct);
validate_test_add("/visitor/input-strict/fail/struct-nested",
&testdata, test_validate_fail_struct_nested);
validate_test_add("/visitor/input-strict/fail/list",
&testdata, test_validate_fail_list);
validate_test_add("/visitor/input-strict/fail/union",
&testdata, test_validate_fail_union);
validate_test_add("/visitor/input-strict/fail/union-flat",
&testdata, test_validate_fail_union_flat);
validate_test_add("/visitor/input-strict/fail/union-flat-no-discriminator",
&testdata, test_validate_fail_union_flat_no_discrim);
validate_test_add("/visitor/input-strict/fail/union-anon",
&testdata, test_validate_fail_union_anon);
g_test_run();
return 0;
}
| [
"int FUNC_0(int VAR_0, char **VAR_1)\n{",
"TestInputVisitorData testdata;",
"g_test_init(&VAR_0, &VAR_1, NULL);",
"validate_test_add(\"/visitor/input-strict/pass/struct\",\n&testdata, test_validate_struct);",
"validate_test_add(\"/visitor/input-strict/pass/struct-nested\",\n&testdata, test_validate_struct_n... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
13,
15
],
[
17,
19
],
[
21,
23
],
[
25,
27
],
[
29,
31
],
[
33,
35
],
[
37,
39
],
[
41,
43
],
[
45,
47
],
[
49,
51
],
[
53,
55
],
... |
1,976 | void slirp_select_fill(int *pnfds,
fd_set *readfds, fd_set *writefds, fd_set *xfds)
{
Slirp *slirp;
struct socket *so, *so_next;
int nfds;
if (QTAILQ_EMPTY(&slirp_instances)) {
return;
}
/* fail safe */
global_readfds = NULL;
global_writefds = NULL;
global_xfds = NULL;
nfds = *pnfds;
/*
* First, TCP sockets
*/
do_slowtimo = 0;
QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
/*
* *_slowtimo needs calling if there are IP fragments
* in the fragment queue, or there are TCP connections active
*/
do_slowtimo |= ((slirp->tcb.so_next != &slirp->tcb) ||
(&slirp->ipq.ip_link != slirp->ipq.ip_link.next));
for (so = slirp->tcb.so_next; so != &slirp->tcb;
so = so_next) {
so_next = so->so_next;
/*
* See if we need a tcp_fasttimo
*/
if (time_fasttimo == 0 && so->so_tcpcb->t_flags & TF_DELACK) {
time_fasttimo = curtime; /* Flag when we want a fasttimo */
}
/*
* NOFDREF can include still connecting to local-host,
* newly socreated() sockets etc. Don't want to select these.
*/
if (so->so_state & SS_NOFDREF || so->s == -1) {
continue;
}
/*
* Set for reading sockets which are accepting
*/
if (so->so_state & SS_FACCEPTCONN) {
FD_SET(so->s, readfds);
UPD_NFDS(so->s);
continue;
}
/*
* Set for writing sockets which are connecting
*/
if (so->so_state & SS_ISFCONNECTING) {
FD_SET(so->s, writefds);
UPD_NFDS(so->s);
continue;
}
/*
* Set for writing if we are connected, can send more, and
* we have something to send
*/
if (CONN_CANFSEND(so) && so->so_rcv.sb_cc) {
FD_SET(so->s, writefds);
UPD_NFDS(so->s);
}
/*
* Set for reading (and urgent data) if we are connected, can
* receive more, and we have room for it XXX /2 ?
*/
if (CONN_CANFRCV(so) &&
(so->so_snd.sb_cc < (so->so_snd.sb_datalen/2))) {
FD_SET(so->s, readfds);
FD_SET(so->s, xfds);
UPD_NFDS(so->s);
}
}
/*
* UDP sockets
*/
for (so = slirp->udb.so_next; so != &slirp->udb;
so = so_next) {
so_next = so->so_next;
/*
* See if it's timed out
*/
if (so->so_expire) {
if (so->so_expire <= curtime) {
udp_detach(so);
continue;
} else {
do_slowtimo = 1; /* Let socket expire */
}
}
/*
* When UDP packets are received from over the
* link, they're sendto()'d straight away, so
* no need for setting for writing
* Limit the number of packets queued by this session
* to 4. Note that even though we try and limit this
* to 4 packets, the session could have more queued
* if the packets needed to be fragmented
* (XXX <= 4 ?)
*/
if ((so->so_state & SS_ISFCONNECTED) && so->so_queued <= 4) {
FD_SET(so->s, readfds);
UPD_NFDS(so->s);
}
}
/*
* ICMP sockets
*/
for (so = slirp->icmp.so_next; so != &slirp->icmp;
so = so_next) {
so_next = so->so_next;
/*
* See if it's timed out
*/
if (so->so_expire) {
if (so->so_expire <= curtime) {
icmp_detach(so);
continue;
} else {
do_slowtimo = 1; /* Let socket expire */
}
}
if (so->so_state & SS_ISFCONNECTED) {
FD_SET(so->s, readfds);
UPD_NFDS(so->s);
}
}
}
*pnfds = nfds;
}
| false | qemu | 8917c3bdba37d6fe4393db0fad3fabbde9530d6b | void slirp_select_fill(int *pnfds,
fd_set *readfds, fd_set *writefds, fd_set *xfds)
{
Slirp *slirp;
struct socket *so, *so_next;
int nfds;
if (QTAILQ_EMPTY(&slirp_instances)) {
return;
}
global_readfds = NULL;
global_writefds = NULL;
global_xfds = NULL;
nfds = *pnfds;
do_slowtimo = 0;
QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
do_slowtimo |= ((slirp->tcb.so_next != &slirp->tcb) ||
(&slirp->ipq.ip_link != slirp->ipq.ip_link.next));
for (so = slirp->tcb.so_next; so != &slirp->tcb;
so = so_next) {
so_next = so->so_next;
if (time_fasttimo == 0 && so->so_tcpcb->t_flags & TF_DELACK) {
time_fasttimo = curtime;
}
if (so->so_state & SS_NOFDREF || so->s == -1) {
continue;
}
if (so->so_state & SS_FACCEPTCONN) {
FD_SET(so->s, readfds);
UPD_NFDS(so->s);
continue;
}
if (so->so_state & SS_ISFCONNECTING) {
FD_SET(so->s, writefds);
UPD_NFDS(so->s);
continue;
}
if (CONN_CANFSEND(so) && so->so_rcv.sb_cc) {
FD_SET(so->s, writefds);
UPD_NFDS(so->s);
}
if (CONN_CANFRCV(so) &&
(so->so_snd.sb_cc < (so->so_snd.sb_datalen/2))) {
FD_SET(so->s, readfds);
FD_SET(so->s, xfds);
UPD_NFDS(so->s);
}
}
for (so = slirp->udb.so_next; so != &slirp->udb;
so = so_next) {
so_next = so->so_next;
if (so->so_expire) {
if (so->so_expire <= curtime) {
udp_detach(so);
continue;
} else {
do_slowtimo = 1;
}
}
if ((so->so_state & SS_ISFCONNECTED) && so->so_queued <= 4) {
FD_SET(so->s, readfds);
UPD_NFDS(so->s);
}
}
for (so = slirp->icmp.so_next; so != &slirp->icmp;
so = so_next) {
so_next = so->so_next;
if (so->so_expire) {
if (so->so_expire <= curtime) {
icmp_detach(so);
continue;
} else {
do_slowtimo = 1;
}
}
if (so->so_state & SS_ISFCONNECTED) {
FD_SET(so->s, readfds);
UPD_NFDS(so->s);
}
}
}
*pnfds = nfds;
}
| {
"code": [],
"line_no": []
} | void FUNC_0(int *VAR_0,
fd_set *VAR_1, fd_set *VAR_2, fd_set *VAR_3)
{
Slirp *slirp;
struct socket *VAR_4, *VAR_5;
int VAR_6;
if (QTAILQ_EMPTY(&slirp_instances)) {
return;
}
global_readfds = NULL;
global_writefds = NULL;
global_xfds = NULL;
VAR_6 = *VAR_0;
do_slowtimo = 0;
QTAILQ_FOREACH(slirp, &slirp_instances, entry) {
do_slowtimo |= ((slirp->tcb.VAR_5 != &slirp->tcb) ||
(&slirp->ipq.ip_link != slirp->ipq.ip_link.next));
for (VAR_4 = slirp->tcb.VAR_5; VAR_4 != &slirp->tcb;
VAR_4 = VAR_5) {
VAR_5 = VAR_4->VAR_5;
if (time_fasttimo == 0 && VAR_4->so_tcpcb->t_flags & TF_DELACK) {
time_fasttimo = curtime;
}
if (VAR_4->so_state & SS_NOFDREF || VAR_4->s == -1) {
continue;
}
if (VAR_4->so_state & SS_FACCEPTCONN) {
FD_SET(VAR_4->s, VAR_1);
UPD_NFDS(VAR_4->s);
continue;
}
if (VAR_4->so_state & SS_ISFCONNECTING) {
FD_SET(VAR_4->s, VAR_2);
UPD_NFDS(VAR_4->s);
continue;
}
if (CONN_CANFSEND(VAR_4) && VAR_4->so_rcv.sb_cc) {
FD_SET(VAR_4->s, VAR_2);
UPD_NFDS(VAR_4->s);
}
if (CONN_CANFRCV(VAR_4) &&
(VAR_4->so_snd.sb_cc < (VAR_4->so_snd.sb_datalen/2))) {
FD_SET(VAR_4->s, VAR_1);
FD_SET(VAR_4->s, VAR_3);
UPD_NFDS(VAR_4->s);
}
}
for (VAR_4 = slirp->udb.VAR_5; VAR_4 != &slirp->udb;
VAR_4 = VAR_5) {
VAR_5 = VAR_4->VAR_5;
if (VAR_4->so_expire) {
if (VAR_4->so_expire <= curtime) {
udp_detach(VAR_4);
continue;
} else {
do_slowtimo = 1;
}
}
if ((VAR_4->so_state & SS_ISFCONNECTED) && VAR_4->so_queued <= 4) {
FD_SET(VAR_4->s, VAR_1);
UPD_NFDS(VAR_4->s);
}
}
for (VAR_4 = slirp->icmp.VAR_5; VAR_4 != &slirp->icmp;
VAR_4 = VAR_5) {
VAR_5 = VAR_4->VAR_5;
if (VAR_4->so_expire) {
if (VAR_4->so_expire <= curtime) {
icmp_detach(VAR_4);
continue;
} else {
do_slowtimo = 1;
}
}
if (VAR_4->so_state & SS_ISFCONNECTED) {
FD_SET(VAR_4->s, VAR_1);
UPD_NFDS(VAR_4->s);
}
}
}
*VAR_0 = VAR_6;
}
| [
"void FUNC_0(int *VAR_0,\nfd_set *VAR_1, fd_set *VAR_2, fd_set *VAR_3)\n{",
"Slirp *slirp;",
"struct socket *VAR_4, *VAR_5;",
"int VAR_6;",
"if (QTAILQ_EMPTY(&slirp_instances)) {",
"return;",
"}",
"global_readfds = NULL;",
"global_writefds = NULL;",
"global_xfds = NULL;",
"VAR_6 = *VAR_0;",
"d... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
25
],
[
27
],
[
29
],
[
33
],
[
41
],
[
45
],
[
55,
57
],
[
61
],
[
63
],
[
65
],
[
75
],
[
77
... |
1,977 | static void test_validate_qmp_introspect(TestInputVisitorData *data,
const void *unused)
{
do_test_validate_qmp_introspect(data, test_qmp_schema_json);
do_test_validate_qmp_introspect(data, qmp_schema_json);
}
| false | qemu | b3db211f3c80bb996a704d665fe275619f728bd4 | static void test_validate_qmp_introspect(TestInputVisitorData *data,
const void *unused)
{
do_test_validate_qmp_introspect(data, test_qmp_schema_json);
do_test_validate_qmp_introspect(data, qmp_schema_json);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(TestInputVisitorData *VAR_0,
const void *VAR_1)
{
do_test_validate_qmp_introspect(VAR_0, test_qmp_schema_json);
do_test_validate_qmp_introspect(VAR_0, qmp_schema_json);
}
| [
"static void FUNC_0(TestInputVisitorData *VAR_0,\nconst void *VAR_1)\n{",
"do_test_validate_qmp_introspect(VAR_0, test_qmp_schema_json);",
"do_test_validate_qmp_introspect(VAR_0, qmp_schema_json);",
"}"
] | [
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
]
] |
1,978 | static void dump_receive(void *opaque, const uint8_t *buf, size_t size)
{
DumpState *s = opaque;
struct pcap_sf_pkthdr hdr;
int64_t ts;
int caplen;
/* Early return in case of previous error. */
if (s->fd < 0) {
return;
}
ts = muldiv64(qemu_get_clock(vm_clock), 1000000, ticks_per_sec);
caplen = size > s->pcap_caplen ? s->pcap_caplen : size;
hdr.ts.tv_sec = ts / 1000000;
hdr.ts.tv_usec = ts % 1000000;
hdr.caplen = caplen;
hdr.len = size;
if (write(s->fd, &hdr, sizeof(hdr)) != sizeof(hdr) ||
write(s->fd, buf, caplen) != caplen) {
qemu_log("-net dump write error - stop dump\n");
close(s->fd);
s->fd = -1;
}
}
| false | qemu | e3f5ec2b5e92706e3b807059f79b1fb5d936e567 | static void dump_receive(void *opaque, const uint8_t *buf, size_t size)
{
DumpState *s = opaque;
struct pcap_sf_pkthdr hdr;
int64_t ts;
int caplen;
if (s->fd < 0) {
return;
}
ts = muldiv64(qemu_get_clock(vm_clock), 1000000, ticks_per_sec);
caplen = size > s->pcap_caplen ? s->pcap_caplen : size;
hdr.ts.tv_sec = ts / 1000000;
hdr.ts.tv_usec = ts % 1000000;
hdr.caplen = caplen;
hdr.len = size;
if (write(s->fd, &hdr, sizeof(hdr)) != sizeof(hdr) ||
write(s->fd, buf, caplen) != caplen) {
qemu_log("-net dump write error - stop dump\n");
close(s->fd);
s->fd = -1;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0, const uint8_t *VAR_1, size_t VAR_2)
{
DumpState *s = VAR_0;
struct pcap_sf_pkthdr VAR_3;
int64_t ts;
int VAR_4;
if (s->fd < 0) {
return;
}
ts = muldiv64(qemu_get_clock(vm_clock), 1000000, ticks_per_sec);
VAR_4 = VAR_2 > s->pcap_caplen ? s->pcap_caplen : VAR_2;
VAR_3.ts.tv_sec = ts / 1000000;
VAR_3.ts.tv_usec = ts % 1000000;
VAR_3.VAR_4 = VAR_4;
VAR_3.len = VAR_2;
if (write(s->fd, &VAR_3, sizeof(VAR_3)) != sizeof(VAR_3) ||
write(s->fd, VAR_1, VAR_4) != VAR_4) {
qemu_log("-net dump write error - stop dump\n");
close(s->fd);
s->fd = -1;
}
}
| [
"static void FUNC_0(void *VAR_0, const uint8_t *VAR_1, size_t VAR_2)\n{",
"DumpState *s = VAR_0;",
"struct pcap_sf_pkthdr VAR_3;",
"int64_t ts;",
"int VAR_4;",
"if (s->fd < 0) {",
"return;",
"}",
"ts = muldiv64(qemu_get_clock(vm_clock), 1000000, ticks_per_sec);",
"VAR_4 = VAR_2 > s->pcap_caplen ? ... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39,
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[... |
1,979 | void OPPROTO op_mov_T0_cc(void)
{
T0 = cc_table[CC_OP].compute_all();
}
| false | qemu | 6e0d8677cb443e7408c0b7a25a93c6596d7fa380 | void OPPROTO op_mov_T0_cc(void)
{
T0 = cc_table[CC_OP].compute_all();
}
| {
"code": [],
"line_no": []
} | void VAR_0 op_mov_T0_cc(void)
{
T0 = cc_table[CC_OP].compute_all();
}
| [
"void VAR_0 op_mov_T0_cc(void)\n{",
"T0 = cc_table[CC_OP].compute_all();",
"}"
] | [
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
1,980 | static int alsa_run_in (HWVoiceIn *hw)
{
ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
int hwshift = hw->info.shift;
int i;
int live = audio_pcm_hw_get_live_in (hw);
int dead = hw->samples - live;
int decr;
struct {
int add;
int len;
} bufs[2] = {
{ hw->wpos, 0 },
{ 0, 0 }
};
snd_pcm_sframes_t avail;
snd_pcm_uframes_t read_samples = 0;
if (!dead) {
return 0;
}
avail = alsa_get_avail (alsa->handle);
if (avail < 0) {
dolog ("Could not get number of captured frames\n");
return 0;
}
if (!avail && (snd_pcm_state (alsa->handle) == SND_PCM_STATE_PREPARED)) {
avail = hw->samples;
}
decr = audio_MIN (dead, avail);
if (!decr) {
return 0;
}
if (hw->wpos + decr > hw->samples) {
bufs[0].len = (hw->samples - hw->wpos);
bufs[1].len = (decr - (hw->samples - hw->wpos));
}
else {
bufs[0].len = decr;
}
for (i = 0; i < 2; ++i) {
void *src;
st_sample_t *dst;
snd_pcm_sframes_t nread;
snd_pcm_uframes_t len;
len = bufs[i].len;
src = advance (alsa->pcm_buf, bufs[i].add << hwshift);
dst = hw->conv_buf + bufs[i].add;
while (len) {
nread = snd_pcm_readi (alsa->handle, src, len);
if (nread <= 0) {
switch (nread) {
case 0:
if (conf.verbose) {
dolog ("Failed to read %ld frames (read zero)\n", len);
}
goto exit;
case -EPIPE:
if (alsa_recover (alsa->handle)) {
alsa_logerr (nread, "Failed to read %ld frames\n", len);
goto exit;
}
if (conf.verbose) {
dolog ("Recovering from capture xrun\n");
}
continue;
case -EAGAIN:
goto exit;
default:
alsa_logerr (
nread,
"Failed to read %ld frames from %p\n",
len,
src
);
goto exit;
}
}
hw->conv (dst, src, nread, &nominal_volume);
src = advance (src, nread << hwshift);
dst += nread;
read_samples += nread;
len -= nread;
}
}
exit:
hw->wpos = (hw->wpos + read_samples) % hw->samples;
return read_samples;
}
| false | qemu | 1ea879e5580f63414693655fcf0328559cdce138 | static int alsa_run_in (HWVoiceIn *hw)
{
ALSAVoiceIn *alsa = (ALSAVoiceIn *) hw;
int hwshift = hw->info.shift;
int i;
int live = audio_pcm_hw_get_live_in (hw);
int dead = hw->samples - live;
int decr;
struct {
int add;
int len;
} bufs[2] = {
{ hw->wpos, 0 },
{ 0, 0 }
};
snd_pcm_sframes_t avail;
snd_pcm_uframes_t read_samples = 0;
if (!dead) {
return 0;
}
avail = alsa_get_avail (alsa->handle);
if (avail < 0) {
dolog ("Could not get number of captured frames\n");
return 0;
}
if (!avail && (snd_pcm_state (alsa->handle) == SND_PCM_STATE_PREPARED)) {
avail = hw->samples;
}
decr = audio_MIN (dead, avail);
if (!decr) {
return 0;
}
if (hw->wpos + decr > hw->samples) {
bufs[0].len = (hw->samples - hw->wpos);
bufs[1].len = (decr - (hw->samples - hw->wpos));
}
else {
bufs[0].len = decr;
}
for (i = 0; i < 2; ++i) {
void *src;
st_sample_t *dst;
snd_pcm_sframes_t nread;
snd_pcm_uframes_t len;
len = bufs[i].len;
src = advance (alsa->pcm_buf, bufs[i].add << hwshift);
dst = hw->conv_buf + bufs[i].add;
while (len) {
nread = snd_pcm_readi (alsa->handle, src, len);
if (nread <= 0) {
switch (nread) {
case 0:
if (conf.verbose) {
dolog ("Failed to read %ld frames (read zero)\n", len);
}
goto exit;
case -EPIPE:
if (alsa_recover (alsa->handle)) {
alsa_logerr (nread, "Failed to read %ld frames\n", len);
goto exit;
}
if (conf.verbose) {
dolog ("Recovering from capture xrun\n");
}
continue;
case -EAGAIN:
goto exit;
default:
alsa_logerr (
nread,
"Failed to read %ld frames from %p\n",
len,
src
);
goto exit;
}
}
hw->conv (dst, src, nread, &nominal_volume);
src = advance (src, nread << hwshift);
dst += nread;
read_samples += nread;
len -= nread;
}
}
exit:
hw->wpos = (hw->wpos + read_samples) % hw->samples;
return read_samples;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0 (HWVoiceIn *VAR_0)
{
ALSAVoiceIn *alsa = (ALSAVoiceIn *) VAR_0;
int VAR_1 = VAR_0->info.shift;
int VAR_2;
int VAR_3 = audio_pcm_hw_get_live_in (VAR_0);
int VAR_4 = VAR_0->samples - VAR_3;
int VAR_5;
struct {
int add;
int len;
} VAR_6[2] = {
{ VAR_0->wpos, 0 },
{ 0, 0 }
};
snd_pcm_sframes_t avail;
snd_pcm_uframes_t read_samples = 0;
if (!VAR_4) {
return 0;
}
avail = alsa_get_avail (alsa->handle);
if (avail < 0) {
dolog ("Could not get number of captured frames\n");
return 0;
}
if (!avail && (snd_pcm_state (alsa->handle) == SND_PCM_STATE_PREPARED)) {
avail = VAR_0->samples;
}
VAR_5 = audio_MIN (VAR_4, avail);
if (!VAR_5) {
return 0;
}
if (VAR_0->wpos + VAR_5 > VAR_0->samples) {
VAR_6[0].len = (VAR_0->samples - VAR_0->wpos);
VAR_6[1].len = (VAR_5 - (VAR_0->samples - VAR_0->wpos));
}
else {
VAR_6[0].len = VAR_5;
}
for (VAR_2 = 0; VAR_2 < 2; ++VAR_2) {
void *VAR_7;
st_sample_t *dst;
snd_pcm_sframes_t nread;
snd_pcm_uframes_t len;
len = VAR_6[VAR_2].len;
VAR_7 = advance (alsa->pcm_buf, VAR_6[VAR_2].add << VAR_1);
dst = VAR_0->conv_buf + VAR_6[VAR_2].add;
while (len) {
nread = snd_pcm_readi (alsa->handle, VAR_7, len);
if (nread <= 0) {
switch (nread) {
case 0:
if (conf.verbose) {
dolog ("Failed to read %ld frames (read zero)\n", len);
}
goto exit;
case -EPIPE:
if (alsa_recover (alsa->handle)) {
alsa_logerr (nread, "Failed to read %ld frames\n", len);
goto exit;
}
if (conf.verbose) {
dolog ("Recovering from capture xrun\n");
}
continue;
case -EAGAIN:
goto exit;
default:
alsa_logerr (
nread,
"Failed to read %ld frames from %p\n",
len,
VAR_7
);
goto exit;
}
}
VAR_0->conv (dst, VAR_7, nread, &nominal_volume);
VAR_7 = advance (VAR_7, nread << VAR_1);
dst += nread;
read_samples += nread;
len -= nread;
}
}
exit:
VAR_0->wpos = (VAR_0->wpos + read_samples) % VAR_0->samples;
return read_samples;
}
| [
"static int FUNC_0 (HWVoiceIn *VAR_0)\n{",
"ALSAVoiceIn *alsa = (ALSAVoiceIn *) VAR_0;",
"int VAR_1 = VAR_0->info.shift;",
"int VAR_2;",
"int VAR_3 = audio_pcm_hw_get_live_in (VAR_0);",
"int VAR_4 = VAR_0->samples - VAR_3;",
"int VAR_5;",
"struct {",
"int add;",
"int len;",
"} VAR_6[2] = {",
"... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
45
... |
1,982 | static void do_change(int argc, const char **argv)
{
BlockDriverState *bs;
if (argc != 3) {
help_cmd(argv[0]);
return;
}
bs = bdrv_find(argv[1]);
if (!bs) {
term_printf("device not found\n");
return;
}
if (eject_device(bs, 0) < 0)
return;
bdrv_open(bs, argv[2], 0);
}
| false | qemu | 9307c4c1d93939db9b04117b654253af5113dc21 | static void do_change(int argc, const char **argv)
{
BlockDriverState *bs;
if (argc != 3) {
help_cmd(argv[0]);
return;
}
bs = bdrv_find(argv[1]);
if (!bs) {
term_printf("device not found\n");
return;
}
if (eject_device(bs, 0) < 0)
return;
bdrv_open(bs, argv[2], 0);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(int VAR_0, const char **VAR_1)
{
BlockDriverState *bs;
if (VAR_0 != 3) {
help_cmd(VAR_1[0]);
return;
}
bs = bdrv_find(VAR_1[1]);
if (!bs) {
term_printf("device not found\n");
return;
}
if (eject_device(bs, 0) < 0)
return;
bdrv_open(bs, VAR_1[2], 0);
}
| [
"static void FUNC_0(int VAR_0, const char **VAR_1)\n{",
"BlockDriverState *bs;",
"if (VAR_0 != 3) {",
"help_cmd(VAR_1[0]);",
"return;",
"}",
"bs = bdrv_find(VAR_1[1]);",
"if (!bs) {",
"term_printf(\"device not found\\n\");",
"return;",
"}",
"if (eject_device(bs, 0) < 0)\nreturn;",
"bdrv_open... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27,
29
],
[
31
],
[
33
]
] |
1,984 | static void opt_qscale(const char *arg)
{
video_qscale = atof(arg);
if (video_qscale <= 0 ||
video_qscale > 255) {
fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
ffmpeg_exit(1);
}
}
| false | FFmpeg | dbe94539469b6d5113b37ea45eaf69ddbe34154e | static void opt_qscale(const char *arg)
{
video_qscale = atof(arg);
if (video_qscale <= 0 ||
video_qscale > 255) {
fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
ffmpeg_exit(1);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(const char *VAR_0)
{
video_qscale = atof(VAR_0);
if (video_qscale <= 0 ||
video_qscale > 255) {
fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
ffmpeg_exit(1);
}
}
| [
"static void FUNC_0(const char *VAR_0)\n{",
"video_qscale = atof(VAR_0);",
"if (video_qscale <= 0 ||\nvideo_qscale > 255) {",
"fprintf(stderr, \"qscale must be > 0.0 and <= 255\\n\");",
"ffmpeg_exit(1);",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7,
9
],
[
11
],
[
13
],
[
15
],
[
17
]
] |
1,985 | static int multiple_resample(ResampleContext *c, AudioData *dst, int dst_size, AudioData *src, int src_size, int *consumed){
int i, ret= -1;
int av_unused mm_flags = av_get_cpu_flags();
int need_emms = c->format == AV_SAMPLE_FMT_S16P && ARCH_X86_32 &&
(mm_flags & (AV_CPU_FLAG_MMX2 | AV_CPU_FLAG_SSE2)) == AV_CPU_FLAG_MMX2;
int64_t max_src_size = (INT64_MAX/2 / c->phase_count) / c->src_incr;
if (c->compensation_distance)
dst_size = FFMIN(dst_size, c->compensation_distance);
src_size = FFMIN(src_size, max_src_size);
for(i=0; i<dst->ch_count; i++){
ret= swri_resample(c, dst->ch[i], src->ch[i],
consumed, src_size, dst_size, i+1==dst->ch_count);
}
if(need_emms)
emms_c();
if (c->compensation_distance) {
c->compensation_distance -= ret;
if (!c->compensation_distance) {
c->dst_incr = c->ideal_dst_incr;
c->dst_incr_div = c->dst_incr / c->src_incr;
c->dst_incr_mod = c->dst_incr % c->src_incr;
}
}
return ret;
}
| false | FFmpeg | 2b0112d42d4dfc8976be20b4d9729c0e077146c6 | static int multiple_resample(ResampleContext *c, AudioData *dst, int dst_size, AudioData *src, int src_size, int *consumed){
int i, ret= -1;
int av_unused mm_flags = av_get_cpu_flags();
int need_emms = c->format == AV_SAMPLE_FMT_S16P && ARCH_X86_32 &&
(mm_flags & (AV_CPU_FLAG_MMX2 | AV_CPU_FLAG_SSE2)) == AV_CPU_FLAG_MMX2;
int64_t max_src_size = (INT64_MAX/2 / c->phase_count) / c->src_incr;
if (c->compensation_distance)
dst_size = FFMIN(dst_size, c->compensation_distance);
src_size = FFMIN(src_size, max_src_size);
for(i=0; i<dst->ch_count; i++){
ret= swri_resample(c, dst->ch[i], src->ch[i],
consumed, src_size, dst_size, i+1==dst->ch_count);
}
if(need_emms)
emms_c();
if (c->compensation_distance) {
c->compensation_distance -= ret;
if (!c->compensation_distance) {
c->dst_incr = c->ideal_dst_incr;
c->dst_incr_div = c->dst_incr / c->src_incr;
c->dst_incr_mod = c->dst_incr % c->src_incr;
}
}
return ret;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(ResampleContext *VAR_0, AudioData *VAR_1, int VAR_2, AudioData *VAR_3, int VAR_4, int *VAR_5){
int VAR_6, VAR_7= -1;
int VAR_8 mm_flags = av_get_cpu_flags();
int VAR_9 = VAR_0->format == AV_SAMPLE_FMT_S16P && ARCH_X86_32 &&
(mm_flags & (AV_CPU_FLAG_MMX2 | AV_CPU_FLAG_SSE2)) == AV_CPU_FLAG_MMX2;
int64_t max_src_size = (INT64_MAX/2 / VAR_0->phase_count) / VAR_0->src_incr;
if (VAR_0->compensation_distance)
VAR_2 = FFMIN(VAR_2, VAR_0->compensation_distance);
VAR_4 = FFMIN(VAR_4, max_src_size);
for(VAR_6=0; VAR_6<VAR_1->ch_count; VAR_6++){
VAR_7= swri_resample(VAR_0, VAR_1->ch[VAR_6], VAR_3->ch[VAR_6],
VAR_5, VAR_4, VAR_2, VAR_6+1==VAR_1->ch_count);
}
if(VAR_9)
emms_c();
if (VAR_0->compensation_distance) {
VAR_0->compensation_distance -= VAR_7;
if (!VAR_0->compensation_distance) {
VAR_0->dst_incr = VAR_0->ideal_dst_incr;
VAR_0->dst_incr_div = VAR_0->dst_incr / VAR_0->src_incr;
VAR_0->dst_incr_mod = VAR_0->dst_incr % VAR_0->src_incr;
}
}
return VAR_7;
}
| [
"static int FUNC_0(ResampleContext *VAR_0, AudioData *VAR_1, int VAR_2, AudioData *VAR_3, int VAR_4, int *VAR_5){",
"int VAR_6, VAR_7= -1;",
"int VAR_8 mm_flags = av_get_cpu_flags();",
"int VAR_9 = VAR_0->format == AV_SAMPLE_FMT_S16P && ARCH_X86_32 &&\n(mm_flags & (AV_CPU_FLAG_MMX2 | AV_CPU_FLAG_SSE2)) == AV_... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1
],
[
3
],
[
5
],
[
7,
9
],
[
11
],
[
15,
17
],
[
19
],
[
23
],
[
25,
27
],
[
29
],
[
31,
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[... |
1,986 | static bool run_poll_handlers(AioContext *ctx, int64_t max_ns)
{
bool progress;
int64_t end_time;
assert(ctx->notify_me);
assert(qemu_lockcnt_count(&ctx->list_lock) > 0);
assert(ctx->poll_disable_cnt == 0);
trace_run_poll_handlers_begin(ctx, max_ns);
end_time = qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + max_ns;
do {
progress = run_poll_handlers_once(ctx);
} while (!progress && qemu_clock_get_ns(QEMU_CLOCK_REALTIME) < end_time);
trace_run_poll_handlers_end(ctx, progress);
return progress;
}
| false | qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | static bool run_poll_handlers(AioContext *ctx, int64_t max_ns)
{
bool progress;
int64_t end_time;
assert(ctx->notify_me);
assert(qemu_lockcnt_count(&ctx->list_lock) > 0);
assert(ctx->poll_disable_cnt == 0);
trace_run_poll_handlers_begin(ctx, max_ns);
end_time = qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + max_ns;
do {
progress = run_poll_handlers_once(ctx);
} while (!progress && qemu_clock_get_ns(QEMU_CLOCK_REALTIME) < end_time);
trace_run_poll_handlers_end(ctx, progress);
return progress;
}
| {
"code": [],
"line_no": []
} | static bool FUNC_0(AioContext *ctx, int64_t max_ns)
{
bool progress;
int64_t end_time;
assert(ctx->notify_me);
assert(qemu_lockcnt_count(&ctx->list_lock) > 0);
assert(ctx->poll_disable_cnt == 0);
trace_run_poll_handlers_begin(ctx, max_ns);
end_time = qemu_clock_get_ns(QEMU_CLOCK_REALTIME) + max_ns;
do {
progress = run_poll_handlers_once(ctx);
} while (!progress && qemu_clock_get_ns(QEMU_CLOCK_REALTIME) < end_time);
trace_run_poll_handlers_end(ctx, progress);
return progress;
}
| [
"static bool FUNC_0(AioContext *ctx, int64_t max_ns)\n{",
"bool progress;",
"int64_t end_time;",
"assert(ctx->notify_me);",
"assert(qemu_lockcnt_count(&ctx->list_lock) > 0);",
"assert(ctx->poll_disable_cnt == 0);",
"trace_run_poll_handlers_begin(ctx, max_ns);",
"end_time = qemu_clock_get_ns(QEMU_CLOCK... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
19
],
[
23
],
[
27
],
[
29
],
[
31
],
[
35
],
[
39
],
[
41
]
] |
1,987 | static CharDriverState *qemu_chr_open_win_con(const char *id,
ChardevBackend *backend,
ChardevReturn *ret,
Error **errp)
{
return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
}
| false | qemu | d0d7708ba29cbcc343364a46bff981e0ff88366f | static CharDriverState *qemu_chr_open_win_con(const char *id,
ChardevBackend *backend,
ChardevReturn *ret,
Error **errp)
{
return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
}
| {
"code": [],
"line_no": []
} | static CharDriverState *FUNC_0(const char *id,
ChardevBackend *backend,
ChardevReturn *ret,
Error **errp)
{
return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));
}
| [
"static CharDriverState *FUNC_0(const char *id,\nChardevBackend *backend,\nChardevReturn *ret,\nError **errp)\n{",
"return qemu_chr_open_win_file(GetStdHandle(STD_OUTPUT_HANDLE));",
"}"
] | [
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
]
] |
1,988 | void qmp_nbd_server_start(SocketAddress *addr,
bool has_tls_creds, const char *tls_creds,
Error **errp)
{
if (nbd_server) {
error_setg(errp, "NBD server already running");
return;
}
nbd_server = g_new0(NBDServerData, 1);
nbd_server->watch = -1;
nbd_server->listen_ioc = qio_channel_socket_new();
qio_channel_set_name(QIO_CHANNEL(nbd_server->listen_ioc),
"nbd-listener");
if (qio_channel_socket_listen_sync(
nbd_server->listen_ioc, addr, errp) < 0) {
goto error;
}
if (has_tls_creds) {
nbd_server->tlscreds = nbd_get_tls_creds(tls_creds, errp);
if (!nbd_server->tlscreds) {
goto error;
}
/* TODO SOCKET_ADDRESS_KIND_FD where fd has AF_INET or AF_INET6 */
if (addr->type != SOCKET_ADDRESS_KIND_INET) {
error_setg(errp, "TLS is only supported with IPv4/IPv6");
goto error;
}
}
nbd_server->watch = qio_channel_add_watch(
QIO_CHANNEL(nbd_server->listen_ioc),
G_IO_IN,
nbd_accept,
NULL,
NULL);
return;
error:
nbd_server_free(nbd_server);
nbd_server = NULL;
}
| false | qemu | dfd100f242370886bb6732f70f1f7cbd8eb9fedc | void qmp_nbd_server_start(SocketAddress *addr,
bool has_tls_creds, const char *tls_creds,
Error **errp)
{
if (nbd_server) {
error_setg(errp, "NBD server already running");
return;
}
nbd_server = g_new0(NBDServerData, 1);
nbd_server->watch = -1;
nbd_server->listen_ioc = qio_channel_socket_new();
qio_channel_set_name(QIO_CHANNEL(nbd_server->listen_ioc),
"nbd-listener");
if (qio_channel_socket_listen_sync(
nbd_server->listen_ioc, addr, errp) < 0) {
goto error;
}
if (has_tls_creds) {
nbd_server->tlscreds = nbd_get_tls_creds(tls_creds, errp);
if (!nbd_server->tlscreds) {
goto error;
}
if (addr->type != SOCKET_ADDRESS_KIND_INET) {
error_setg(errp, "TLS is only supported with IPv4/IPv6");
goto error;
}
}
nbd_server->watch = qio_channel_add_watch(
QIO_CHANNEL(nbd_server->listen_ioc),
G_IO_IN,
nbd_accept,
NULL,
NULL);
return;
error:
nbd_server_free(nbd_server);
nbd_server = NULL;
}
| {
"code": [],
"line_no": []
} | void FUNC_0(SocketAddress *VAR_0,
bool VAR_1, const char *VAR_2,
Error **VAR_3)
{
if (nbd_server) {
error_setg(VAR_3, "NBD server already running");
return;
}
nbd_server = g_new0(NBDServerData, 1);
nbd_server->watch = -1;
nbd_server->listen_ioc = qio_channel_socket_new();
qio_channel_set_name(QIO_CHANNEL(nbd_server->listen_ioc),
"nbd-listener");
if (qio_channel_socket_listen_sync(
nbd_server->listen_ioc, VAR_0, VAR_3) < 0) {
goto error;
}
if (VAR_1) {
nbd_server->tlscreds = nbd_get_tls_creds(VAR_2, VAR_3);
if (!nbd_server->tlscreds) {
goto error;
}
if (VAR_0->type != SOCKET_ADDRESS_KIND_INET) {
error_setg(VAR_3, "TLS is only supported with IPv4/IPv6");
goto error;
}
}
nbd_server->watch = qio_channel_add_watch(
QIO_CHANNEL(nbd_server->listen_ioc),
G_IO_IN,
nbd_accept,
NULL,
NULL);
return;
error:
nbd_server_free(nbd_server);
nbd_server = NULL;
}
| [
"void FUNC_0(SocketAddress *VAR_0,\nbool VAR_1, const char *VAR_2,\nError **VAR_3)\n{",
"if (nbd_server) {",
"error_setg(VAR_3, \"NBD server already running\");",
"return;",
"}",
"nbd_server = g_new0(NBDServerData, 1);",
"nbd_server->watch = -1;",
"nbd_server->listen_ioc = qio_channel_socket_new();",
... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25,
27
],
[
29,
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
53
... |
1,989 | int v9fs_co_mkdir(V9fsState *s, char *name, mode_t mode, uid_t uid, gid_t gid)
{
int err;
FsCred cred;
cred_init(&cred);
cred.fc_mode = mode;
cred.fc_uid = uid;
cred.fc_gid = gid;
v9fs_co_run_in_worker(
{
err = s->ops->mkdir(&s->ctx, name, &cred);
if (err < 0) {
err = -errno;
}
});
return err;
}
| false | qemu | 02cb7f3a256517cbf3136caff2863fbafc57b540 | int v9fs_co_mkdir(V9fsState *s, char *name, mode_t mode, uid_t uid, gid_t gid)
{
int err;
FsCred cred;
cred_init(&cred);
cred.fc_mode = mode;
cred.fc_uid = uid;
cred.fc_gid = gid;
v9fs_co_run_in_worker(
{
err = s->ops->mkdir(&s->ctx, name, &cred);
if (err < 0) {
err = -errno;
}
});
return err;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(V9fsState *VAR_0, char *VAR_1, mode_t VAR_2, uid_t VAR_3, gid_t VAR_4)
{
int VAR_5;
FsCred cred;
cred_init(&cred);
cred.fc_mode = VAR_2;
cred.fc_uid = VAR_3;
cred.fc_gid = VAR_4;
v9fs_co_run_in_worker(
{
VAR_5 = VAR_0->ops->mkdir(&VAR_0->ctx, VAR_1, &cred);
if (VAR_5 < 0) {
VAR_5 = -errno;
}
});
return VAR_5;
}
| [
"int FUNC_0(V9fsState *VAR_0, char *VAR_1, mode_t VAR_2, uid_t VAR_3, gid_t VAR_4)\n{",
"int VAR_5;",
"FsCred cred;",
"cred_init(&cred);",
"cred.fc_mode = VAR_2;",
"cred.fc_uid = VAR_3;",
"cred.fc_gid = VAR_4;",
"v9fs_co_run_in_worker(\n{",
"VAR_5 = VAR_0->ops->mkdir(&VAR_0->ctx, VAR_1, &cred);",
... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19,
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
]
] |
1,991 | static uint32_t nam_readw (void *opaque, uint32_t addr)
{
PCIAC97LinkState *d = opaque;
AC97LinkState *s = &d->ac97;
uint32_t val = ~0U;
uint32_t index = addr - s->base[0];
s->cas = 0;
val = mixer_load (s, index);
return val;
}
| false | qemu | 10ee2aaa417d8d8978cdb2bbed55ebb152df5f6b | static uint32_t nam_readw (void *opaque, uint32_t addr)
{
PCIAC97LinkState *d = opaque;
AC97LinkState *s = &d->ac97;
uint32_t val = ~0U;
uint32_t index = addr - s->base[0];
s->cas = 0;
val = mixer_load (s, index);
return val;
}
| {
"code": [],
"line_no": []
} | static uint32_t FUNC_0 (void *opaque, uint32_t addr)
{
PCIAC97LinkState *d = opaque;
AC97LinkState *s = &d->ac97;
uint32_t val = ~0U;
uint32_t index = addr - s->base[0];
s->cas = 0;
val = mixer_load (s, index);
return val;
}
| [
"static uint32_t FUNC_0 (void *opaque, uint32_t addr)\n{",
"PCIAC97LinkState *d = opaque;",
"AC97LinkState *s = &d->ac97;",
"uint32_t val = ~0U;",
"uint32_t index = addr - s->base[0];",
"s->cas = 0;",
"val = mixer_load (s, index);",
"return val;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
]
] |
1,992 | static uint32_t virtio_net_bad_features(VirtIODevice *vdev)
{
uint32_t features = 0;
/* Linux kernel 2.6.25. It understood MAC (as everyone must),
* but also these: */
features |= (1 << VIRTIO_NET_F_MAC);
features |= (1 << VIRTIO_NET_F_CSUM);
features |= (1 << VIRTIO_NET_F_HOST_TSO4);
features |= (1 << VIRTIO_NET_F_HOST_TSO6);
features |= (1 << VIRTIO_NET_F_HOST_ECN);
return features;
}
| false | qemu | 0cd09c3a6cc2230ba38c462fc410b4acce59eb6f | static uint32_t virtio_net_bad_features(VirtIODevice *vdev)
{
uint32_t features = 0;
features |= (1 << VIRTIO_NET_F_MAC);
features |= (1 << VIRTIO_NET_F_CSUM);
features |= (1 << VIRTIO_NET_F_HOST_TSO4);
features |= (1 << VIRTIO_NET_F_HOST_TSO6);
features |= (1 << VIRTIO_NET_F_HOST_ECN);
return features;
}
| {
"code": [],
"line_no": []
} | static uint32_t FUNC_0(VirtIODevice *vdev)
{
uint32_t features = 0;
features |= (1 << VIRTIO_NET_F_MAC);
features |= (1 << VIRTIO_NET_F_CSUM);
features |= (1 << VIRTIO_NET_F_HOST_TSO4);
features |= (1 << VIRTIO_NET_F_HOST_TSO6);
features |= (1 << VIRTIO_NET_F_HOST_ECN);
return features;
}
| [
"static uint32_t FUNC_0(VirtIODevice *vdev)\n{",
"uint32_t features = 0;",
"features |= (1 << VIRTIO_NET_F_MAC);",
"features |= (1 << VIRTIO_NET_F_CSUM);",
"features |= (1 << VIRTIO_NET_F_HOST_TSO4);",
"features |= (1 << VIRTIO_NET_F_HOST_TSO6);",
"features |= (1 << VIRTIO_NET_F_HOST_ECN);",
"return f... | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
]
] |
1,993 | void visit_type_uint16(Visitor *v, uint16_t *obj, const char *name, Error **errp)
{
int64_t value;
if (v->type_uint16) {
v->type_uint16(v, obj, name, errp);
} else {
value = *obj;
v->type_int64(v, &value, name, errp);
if (value < 0 || value > UINT16_MAX) {
/* FIXME questionable reuse of errp if callback changed
value on error */
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
name ? name : "null", "uint16_t");
return;
}
*obj = value;
}
}
| false | qemu | f755dea79dc81b0d6a8f6414e0672e165e28d8ba | void visit_type_uint16(Visitor *v, uint16_t *obj, const char *name, Error **errp)
{
int64_t value;
if (v->type_uint16) {
v->type_uint16(v, obj, name, errp);
} else {
value = *obj;
v->type_int64(v, &value, name, errp);
if (value < 0 || value > UINT16_MAX) {
error_setg(errp, QERR_INVALID_PARAMETER_VALUE,
name ? name : "null", "uint16_t");
return;
}
*obj = value;
}
}
| {
"code": [],
"line_no": []
} | void FUNC_0(Visitor *VAR_0, uint16_t *VAR_1, const char *VAR_2, Error **VAR_3)
{
int64_t value;
if (VAR_0->type_uint16) {
VAR_0->type_uint16(VAR_0, VAR_1, VAR_2, VAR_3);
} else {
value = *VAR_1;
VAR_0->type_int64(VAR_0, &value, VAR_2, VAR_3);
if (value < 0 || value > UINT16_MAX) {
error_setg(VAR_3, QERR_INVALID_PARAMETER_VALUE,
VAR_2 ? VAR_2 : "null", "uint16_t");
return;
}
*VAR_1 = value;
}
}
| [
"void FUNC_0(Visitor *VAR_0, uint16_t *VAR_1, const char *VAR_2, Error **VAR_3)\n{",
"int64_t value;",
"if (VAR_0->type_uint16) {",
"VAR_0->type_uint16(VAR_0, VAR_1, VAR_2, VAR_3);",
"} else {",
"value = *VAR_1;",
"VAR_0->type_int64(VAR_0, &value, VAR_2, VAR_3);",
"if (value < 0 || value > UINT16_MAX)... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
25,
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
]
] |
1,995 | static int try_decode_frame(AVStream *st, AVPacket *avpkt)
{
int16_t *samples;
AVCodec *codec;
int got_picture, data_size, ret=0;
AVFrame picture;
if(!st->codec->codec){
codec = avcodec_find_decoder(st->codec->codec_id);
if (!codec)
return -1;
ret = avcodec_open(st->codec, codec);
if (ret < 0)
return ret;
}
if(!has_codec_parameters(st->codec)){
switch(st->codec->codec_type) {
case CODEC_TYPE_VIDEO:
ret = avcodec_decode_video2(st->codec, &picture,
&got_picture, avpkt);
break;
case CODEC_TYPE_AUDIO:
data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
samples = av_malloc(data_size);
if (!samples)
goto fail;
ret = avcodec_decode_audio3(st->codec, samples,
&data_size, avpkt);
av_free(samples);
break;
default:
break;
}
}
fail:
return ret;
} | true | FFmpeg | 1bd280f73076b7a58371585b95b08379f2445332 | static int try_decode_frame(AVStream *st, AVPacket *avpkt)
{
int16_t *samples;
AVCodec *codec;
int got_picture, data_size, ret=0;
AVFrame picture;
if(!st->codec->codec){
codec = avcodec_find_decoder(st->codec->codec_id);
if (!codec)
return -1;
ret = avcodec_open(st->codec, codec);
if (ret < 0)
return ret;
}
if(!has_codec_parameters(st->codec)){
switch(st->codec->codec_type) {
case CODEC_TYPE_VIDEO:
ret = avcodec_decode_video2(st->codec, &picture,
&got_picture, avpkt);
break;
case CODEC_TYPE_AUDIO:
data_size = FFMAX(avpkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
samples = av_malloc(data_size);
if (!samples)
goto fail;
ret = avcodec_decode_audio3(st->codec, samples,
&data_size, avpkt);
av_free(samples);
break;
default:
break;
}
}
fail:
return ret;
} | {
"code": [],
"line_no": []
} | static int FUNC_0(AVStream *VAR_0, AVPacket *VAR_1)
{
int16_t *samples;
AVCodec *codec;
int VAR_2, VAR_3, VAR_4=0;
AVFrame picture;
if(!VAR_0->codec->codec){
codec = avcodec_find_decoder(VAR_0->codec->codec_id);
if (!codec)
return -1;
VAR_4 = avcodec_open(VAR_0->codec, codec);
if (VAR_4 < 0)
return VAR_4;
}
if(!has_codec_parameters(VAR_0->codec)){
switch(VAR_0->codec->codec_type) {
case CODEC_TYPE_VIDEO:
VAR_4 = avcodec_decode_video2(VAR_0->codec, &picture,
&VAR_2, VAR_1);
break;
case CODEC_TYPE_AUDIO:
VAR_3 = FFMAX(VAR_1->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);
samples = av_malloc(VAR_3);
if (!samples)
goto fail;
VAR_4 = avcodec_decode_audio3(VAR_0->codec, samples,
&VAR_3, VAR_1);
av_free(samples);
break;
default:
break;
}
}
fail:
return VAR_4;
} | [
"static int FUNC_0(AVStream *VAR_0, AVPacket *VAR_1)\n{",
"int16_t *samples;",
"AVCodec *codec;",
"int VAR_2, VAR_3, VAR_4=0;",
"AVFrame picture;",
"if(!VAR_0->codec->codec){",
"codec = avcodec_find_decoder(VAR_0->codec->codec_id);",
"if (!codec)\nreturn -1;",
"VAR_4 = avcodec_open(VAR_0->codec, cod... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19,
21
],
[
23
],
[
25,
27
],
[
29
],
[
33
],
[
35
],
[
37,
40,
42
],
[
44
],
[
46,
48
],
[
50
],
[... |
1,996 | int s390_virtio_hypercall(CPUS390XState *env)
{
s390_virtio_fn fn = s390_diag500_table[env->regs[1]];
if (!fn) {
return -EINVAL;
}
return fn(&env->regs[2]);
}
| true | qemu | f2c55d1735175ab37ab9f69854460087112d2756 | int s390_virtio_hypercall(CPUS390XState *env)
{
s390_virtio_fn fn = s390_diag500_table[env->regs[1]];
if (!fn) {
return -EINVAL;
}
return fn(&env->regs[2]);
}
| {
"code": [
" s390_virtio_fn fn = s390_diag500_table[env->regs[1]];",
" if (!fn) {",
" return -EINVAL;",
" return fn(&env->regs[2]);"
],
"line_no": [
5,
9,
11,
17
]
} | int FUNC_0(CPUS390XState *VAR_0)
{
s390_virtio_fn fn = s390_diag500_table[VAR_0->regs[1]];
if (!fn) {
return -EINVAL;
}
return fn(&VAR_0->regs[2]);
}
| [
"int FUNC_0(CPUS390XState *VAR_0)\n{",
"s390_virtio_fn fn = s390_diag500_table[VAR_0->regs[1]];",
"if (!fn) {",
"return -EINVAL;",
"}",
"return fn(&VAR_0->regs[2]);",
"}"
] | [
0,
1,
1,
1,
0,
1,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
]
] |
1,997 | int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
int *got_picture_ptr,
AVPacket *avpkt)
{
int ret;
*got_picture_ptr= 0;
if((avctx->coded_width||avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))
return -1;
if((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type&FF_THREAD_FRAME)){
av_packet_split_side_data(avpkt);
apply_param_change(avctx, avpkt);
avctx->pkt = avpkt;
if (HAVE_THREADS && avctx->active_thread_type&FF_THREAD_FRAME)
ret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,
avpkt);
else {
ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
avpkt);
picture->pkt_dts= avpkt->dts;
if(!avctx->has_b_frames){
picture->pkt_pos= avpkt->pos;
}
//FIXME these should be under if(!avctx->has_b_frames)
if (!picture->sample_aspect_ratio.num)
picture->sample_aspect_ratio = avctx->sample_aspect_ratio;
if (!picture->width)
picture->width = avctx->width;
if (!picture->height)
picture->height = avctx->height;
if (picture->format == PIX_FMT_NONE)
picture->format = avctx->pix_fmt;
}
emms_c(); //needed to avoid an emms_c() call before every return;
if (*got_picture_ptr){
avctx->frame_number++;
picture->best_effort_timestamp = guess_correct_pts(avctx,
picture->pkt_pts,
picture->pkt_dts);
}
}else
ret= 0;
return ret;
}
| true | FFmpeg | c4ba5198ea48f8f648d85a853ea46e29001c12c8 | int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
int *got_picture_ptr,
AVPacket *avpkt)
{
int ret;
*got_picture_ptr= 0;
if((avctx->coded_width||avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))
return -1;
if((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type&FF_THREAD_FRAME)){
av_packet_split_side_data(avpkt);
apply_param_change(avctx, avpkt);
avctx->pkt = avpkt;
if (HAVE_THREADS && avctx->active_thread_type&FF_THREAD_FRAME)
ret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,
avpkt);
else {
ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
avpkt);
picture->pkt_dts= avpkt->dts;
if(!avctx->has_b_frames){
picture->pkt_pos= avpkt->pos;
}
if (!picture->sample_aspect_ratio.num)
picture->sample_aspect_ratio = avctx->sample_aspect_ratio;
if (!picture->width)
picture->width = avctx->width;
if (!picture->height)
picture->height = avctx->height;
if (picture->format == PIX_FMT_NONE)
picture->format = avctx->pix_fmt;
}
emms_c();
if (*got_picture_ptr){
avctx->frame_number++;
picture->best_effort_timestamp = guess_correct_pts(avctx,
picture->pkt_pts,
picture->pkt_dts);
}
}else
ret= 0;
return ret;
}
| {
"code": [
" AVPacket *avpkt)",
" av_packet_split_side_data(avpkt);",
" apply_param_change(avctx, avpkt);",
" avctx->pkt = avpkt;",
" avpkt);",
" avpkt);"
],
"line_no": [
5,
23,
25,
27,
33,
39
]
} | int VAR_0 avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
int *got_picture_ptr,
AVPacket *avpkt)
{
int ret;
*got_picture_ptr= 0;
if((avctx->coded_width||avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))
return -1;
if((avctx->codec->capabilities & CODEC_CAP_DELAY) || avpkt->size || (avctx->active_thread_type&FF_THREAD_FRAME)){
av_packet_split_side_data(avpkt);
apply_param_change(avctx, avpkt);
avctx->pkt = avpkt;
if (HAVE_THREADS && avctx->active_thread_type&FF_THREAD_FRAME)
ret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,
avpkt);
else {
ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
avpkt);
picture->pkt_dts= avpkt->dts;
if(!avctx->has_b_frames){
picture->pkt_pos= avpkt->pos;
}
if (!picture->sample_aspect_ratio.num)
picture->sample_aspect_ratio = avctx->sample_aspect_ratio;
if (!picture->width)
picture->width = avctx->width;
if (!picture->height)
picture->height = avctx->height;
if (picture->format == PIX_FMT_NONE)
picture->format = avctx->pix_fmt;
}
emms_c();
if (*got_picture_ptr){
avctx->frame_number++;
picture->best_effort_timestamp = guess_correct_pts(avctx,
picture->pkt_pts,
picture->pkt_dts);
}
}else
ret= 0;
return ret;
}
| [
"int VAR_0 avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,\nint *got_picture_ptr,\nAVPacket *avpkt)\n{",
"int ret;",
"*got_picture_ptr= 0;",
"if((avctx->coded_width||avctx->coded_height) && av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx))\nreturn -1;",
"if((avctx->codec... | [
1,
0,
0,
0,
0,
1,
1,
1,
1,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
13
],
[
15,
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29,
31,
33
],
[
35
],
[
37,
39
],
[
41
],
[
45
],
[
47
],
[
49
],
[
53,
55
],
[... |
1,999 | void qemu_thread_create(QemuThread *thread, const char *name,
void *(*start_routine)(void*),
void *arg, int mode)
{
sigset_t set, oldset;
int err;
pthread_attr_t attr;
err = pthread_attr_init(&attr);
if (err) {
error_exit(err, __func__);
}
if (mode == QEMU_THREAD_DETACHED) {
err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if (err) {
error_exit(err, __func__);
}
}
/* Leave signal handling to the iothread. */
sigfillset(&set);
pthread_sigmask(SIG_SETMASK, &set, &oldset);
err = pthread_create(&thread->thread, &attr, start_routine, arg);
if (err)
error_exit(err, __func__);
if (name_threads) {
qemu_thread_set_name(thread, name);
}
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
pthread_attr_destroy(&attr);
}
| true | qemu | 2f75bd73c319a1224a64a1b5ad680b1a37ed2d7a | void qemu_thread_create(QemuThread *thread, const char *name,
void *(*start_routine)(void*),
void *arg, int mode)
{
sigset_t set, oldset;
int err;
pthread_attr_t attr;
err = pthread_attr_init(&attr);
if (err) {
error_exit(err, __func__);
}
if (mode == QEMU_THREAD_DETACHED) {
err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
if (err) {
error_exit(err, __func__);
}
}
sigfillset(&set);
pthread_sigmask(SIG_SETMASK, &set, &oldset);
err = pthread_create(&thread->thread, &attr, start_routine, arg);
if (err)
error_exit(err, __func__);
if (name_threads) {
qemu_thread_set_name(thread, name);
}
pthread_sigmask(SIG_SETMASK, &oldset, NULL);
pthread_attr_destroy(&attr);
}
| {
"code": [
" if (mode == QEMU_THREAD_DETACHED) {",
" err = pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);",
" if (err) {",
" error_exit(err, __func__);"
],
"line_no": [
25,
27,
29,
31
]
} | VAR_3voidVAR_3 VAR_3qemu_thread_createVAR_3(VAR_3QemuThreadVAR_3 *VAR_3VAR_0VAR_3, VAR_3constVAR_3 VAR_3charVAR_3 *VAR_3VAR_1VAR_3,
VAR_3voidVAR_3 *(*VAR_3VAR_2VAR_3)(VAR_3voidVAR_3*),
VAR_3voidVAR_3 *VAR_3argVAR_3, VAR_3intVAR_3 VAR_3modeVAR_3)
{
VAR_3sigset_tVAR_3 VAR_3setVAR_3, VAR_3oldsetVAR_3;
VAR_3intVAR_3 VAR_3errVAR_3;
VAR_3pthread_attr_tVAR_3 VAR_3attrVAR_3;
VAR_3errVAR_3 = VAR_3pthread_attr_initVAR_3(&VAR_3attrVAR_3);
VAR_3ifVAR_3 (VAR_3errVAR_3) {
VAR_3error_exitVAR_3(VAR_3errVAR_3, VAR_3__func__VAR_3);
}
VAR_3ifVAR_3 (VAR_3modeVAR_3 == VAR_3QEMU_THREAD_DETACHEDVAR_3) {
VAR_3errVAR_3 = VAR_3pthread_attr_setdetachstateVAR_3(&VAR_3attrVAR_3, VAR_3PTHREAD_CREATE_DETACHEDVAR_3);
VAR_3ifVAR_3 (VAR_3errVAR_3) {
VAR_3error_exitVAR_3(VAR_3errVAR_3, VAR_3__func__VAR_3);
}
}
VAR_3sigfillsetVAR_3(&VAR_3setVAR_3);
VAR_3pthread_sigmaskVAR_3(VAR_3SIG_SETMASKVAR_3, &VAR_3setVAR_3, &VAR_3oldsetVAR_3);
VAR_3errVAR_3 = VAR_3pthread_createVAR_3(&VAR_3VAR_0VAR_3->VAR_3VAR_0VAR_3, &VAR_3attrVAR_3, VAR_3VAR_2VAR_3, VAR_3argVAR_3);
VAR_3ifVAR_3 (VAR_3errVAR_3)
VAR_3error_exitVAR_3(VAR_3errVAR_3, VAR_3__func__VAR_3);
VAR_3ifVAR_3 (VAR_3name_threadsVAR_3) {
VAR_3qemu_thread_set_nameVAR_3(VAR_3VAR_0VAR_3, VAR_3VAR_1VAR_3);
}
VAR_3pthread_sigmaskVAR_3(VAR_3SIG_SETMASKVAR_3, &VAR_3oldsetVAR_3, VAR_3NULLVAR_3);
VAR_3pthread_attr_destroyVAR_3(&VAR_3attrVAR_3);
}
| [
"VAR_3voidVAR_3 VAR_3qemu_thread_createVAR_3(VAR_3QemuThreadVAR_3 *VAR_3VAR_0VAR_3, VAR_3constVAR_3 VAR_3charVAR_3 *VAR_3VAR_1VAR_3,\nVAR_3voidVAR_3 *(*VAR_3VAR_2VAR_3)(VAR_3voidVAR_3*),\nVAR_3voidVAR_3 *VAR_3argVAR_3, VAR_3intVAR_3 VAR_3modeVAR_3)\n{",
"VAR_3sigset_tVAR_3 VAR_3setVAR_3, VAR_3oldsetVAR_3;",
"VA... | [
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
41
],
[
43
],
[
45
],
[
47,
49
],
[... |
2,000 | static inline void vmsvga_fill_rect(struct vmsvga_state_s *s,
uint32_t c, int x, int y, int w, int h)
{
DisplaySurface *surface = qemu_console_surface(s->vga.con);
int bypl = surface_stride(surface);
int width = surface_bytes_per_pixel(surface) * w;
int line = h;
int column;
uint8_t *fst;
uint8_t *dst;
uint8_t *src;
uint8_t col[4];
col[0] = c;
col[1] = c >> 8;
col[2] = c >> 16;
col[3] = c >> 24;
fst = s->vga.vram_ptr + surface_bytes_per_pixel(surface) * x + bypl * y;
if (line--) {
dst = fst;
src = col;
for (column = width; column > 0; column--) {
*(dst++) = *(src++);
if (src - col == surface_bytes_per_pixel(surface)) {
src = col;
}
}
dst = fst;
for (; line > 0; line--) {
dst += bypl;
memcpy(dst, fst, width);
}
}
vmsvga_update_rect_delayed(s, x, y, w, h);
}
| true | qemu | bd9ccd8517e83b7c33a9167815dbfffb30d70b13 | static inline void vmsvga_fill_rect(struct vmsvga_state_s *s,
uint32_t c, int x, int y, int w, int h)
{
DisplaySurface *surface = qemu_console_surface(s->vga.con);
int bypl = surface_stride(surface);
int width = surface_bytes_per_pixel(surface) * w;
int line = h;
int column;
uint8_t *fst;
uint8_t *dst;
uint8_t *src;
uint8_t col[4];
col[0] = c;
col[1] = c >> 8;
col[2] = c >> 16;
col[3] = c >> 24;
fst = s->vga.vram_ptr + surface_bytes_per_pixel(surface) * x + bypl * y;
if (line--) {
dst = fst;
src = col;
for (column = width; column > 0; column--) {
*(dst++) = *(src++);
if (src - col == surface_bytes_per_pixel(surface)) {
src = col;
}
}
dst = fst;
for (; line > 0; line--) {
dst += bypl;
memcpy(dst, fst, width);
}
}
vmsvga_update_rect_delayed(s, x, y, w, h);
}
| {
"code": [
"static inline void vmsvga_fill_rect(struct vmsvga_state_s *s,"
],
"line_no": [
1
]
} | static inline void FUNC_0(struct vmsvga_state_s *VAR_0,
uint32_t VAR_1, int VAR_2, int VAR_3, int VAR_4, int VAR_5)
{
DisplaySurface *surface = qemu_console_surface(VAR_0->vga.con);
int VAR_6 = surface_stride(surface);
int VAR_7 = surface_bytes_per_pixel(surface) * VAR_4;
int VAR_8 = VAR_5;
int VAR_9;
uint8_t *fst;
uint8_t *dst;
uint8_t *src;
uint8_t col[4];
col[0] = VAR_1;
col[1] = VAR_1 >> 8;
col[2] = VAR_1 >> 16;
col[3] = VAR_1 >> 24;
fst = VAR_0->vga.vram_ptr + surface_bytes_per_pixel(surface) * VAR_2 + VAR_6 * VAR_3;
if (VAR_8--) {
dst = fst;
src = col;
for (VAR_9 = VAR_7; VAR_9 > 0; VAR_9--) {
*(dst++) = *(src++);
if (src - col == surface_bytes_per_pixel(surface)) {
src = col;
}
}
dst = fst;
for (; VAR_8 > 0; VAR_8--) {
dst += VAR_6;
memcpy(dst, fst, VAR_7);
}
}
vmsvga_update_rect_delayed(VAR_0, VAR_2, VAR_3, VAR_4, VAR_5);
}
| [
"static inline void FUNC_0(struct vmsvga_state_s *VAR_0,\nuint32_t VAR_1, int VAR_2, int VAR_3, int VAR_4, int VAR_5)\n{",
"DisplaySurface *surface = qemu_console_surface(VAR_0->vga.con);",
"int VAR_6 = surface_stride(surface);",
"int VAR_7 = surface_bytes_per_pixel(surface) * VAR_4;",
"int VAR_8 = VAR_5;",... | [
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[... |
2,001 | static void IMLT(float *pInput, float *pOutput, int odd_band)
{
int i;
if (odd_band) {
/**
* Reverse the odd bands before IMDCT, this is an effect of the QMF transform
* or it gives better compression to do it this way.
* FIXME: It should be possible to handle this in ff_imdct_calc
* for that to happen a modification of the prerotation step of
* all SIMD code and C code is needed.
* Or fix the functions before so they generate a pre reversed spectrum.
*/
for (i=0; i<128; i++)
FFSWAP(float, pInput[i], pInput[255-i]);
}
ff_imdct_calc(&mdct_ctx,pOutput,pInput);
/* Perform windowing on the output. */
dsp.vector_fmul(pOutput,mdct_window,512);
}
| true | FFmpeg | a28cccf6d62dc770757491510c248ed632a836ce | static void IMLT(float *pInput, float *pOutput, int odd_band)
{
int i;
if (odd_band) {
for (i=0; i<128; i++)
FFSWAP(float, pInput[i], pInput[255-i]);
}
ff_imdct_calc(&mdct_ctx,pOutput,pInput);
dsp.vector_fmul(pOutput,mdct_window,512);
}
| {
"code": [
"static void IMLT(float *pInput, float *pOutput, int odd_band)",
" ff_imdct_calc(&mdct_ctx,pOutput,pInput);"
],
"line_no": [
1,
37
]
} | static void FUNC_0(float *VAR_0, float *VAR_1, int VAR_2)
{
int VAR_3;
if (VAR_2) {
for (VAR_3=0; VAR_3<128; VAR_3++)
FFSWAP(float, VAR_0[VAR_3], VAR_0[255-VAR_3]);
}
ff_imdct_calc(&mdct_ctx,VAR_1,VAR_0);
dsp.vector_fmul(VAR_1,mdct_window,512);
}
| [
"static void FUNC_0(float *VAR_0, float *VAR_1, int VAR_2)\n{",
"int VAR_3;",
"if (VAR_2) {",
"for (VAR_3=0; VAR_3<128; VAR_3++)",
"FFSWAP(float, VAR_0[VAR_3], VAR_0[255-VAR_3]);",
"}",
"ff_imdct_calc(&mdct_ctx,VAR_1,VAR_0);",
"dsp.vector_fmul(VAR_1,mdct_window,512);",
"}"
] | [
1,
0,
0,
0,
0,
0,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
29
],
[
31
],
[
33
],
[
37
],
[
43
],
[
47
]
] |
2,002 | void op_div (void)
{
if (T1 != 0) {
env->LO = (int32_t)((int32_t)T0 / (int32_t)T1);
env->HI = (int32_t)((int32_t)T0 % (int32_t)T1);
}
RETURN();
}
| true | qemu | 80c27194a7be757ef5a9cec978d1d8faaa4cee81 | void op_div (void)
{
if (T1 != 0) {
env->LO = (int32_t)((int32_t)T0 / (int32_t)T1);
env->HI = (int32_t)((int32_t)T0 % (int32_t)T1);
}
RETURN();
}
| {
"code": [
" env->LO = (int32_t)((int32_t)T0 / (int32_t)T1);",
" env->HI = (int32_t)((int32_t)T0 % (int32_t)T1);",
" if (T1 != 0) {",
" RETURN();"
],
"line_no": [
7,
9,
5,
13
]
} | void FUNC_0 (void)
{
if (T1 != 0) {
env->LO = (int32_t)((int32_t)T0 / (int32_t)T1);
env->HI = (int32_t)((int32_t)T0 % (int32_t)T1);
}
RETURN();
}
| [
"void FUNC_0 (void)\n{",
"if (T1 != 0) {",
"env->LO = (int32_t)((int32_t)T0 / (int32_t)T1);",
"env->HI = (int32_t)((int32_t)T0 % (int32_t)T1);",
"}",
"RETURN();",
"}"
] | [
0,
1,
1,
1,
0,
1,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
]
] |
2,003 | static void mxf_write_generic_sound_common(AVFormatContext *s, AVStream *st, const UID key, unsigned size)
{
AVIOContext *pb = s->pb;
mxf_write_generic_desc(s, st, key, size+5+12+8+8);
// audio locked
mxf_write_local_tag(pb, 1, 0x3D02);
avio_w8(pb, 1);
// write audio sampling rate
mxf_write_local_tag(pb, 8, 0x3D03);
avio_wb32(pb, st->codec->sample_rate);
avio_wb32(pb, 1);
mxf_write_local_tag(pb, 4, 0x3D07);
avio_wb32(pb, st->codec->channels);
mxf_write_local_tag(pb, 4, 0x3D01);
avio_wb32(pb, av_get_bits_per_sample(st->codec->codec_id));
}
| true | FFmpeg | 3eae34d50fc52ff7b8367f9ade1cd189bfc1a221 | static void mxf_write_generic_sound_common(AVFormatContext *s, AVStream *st, const UID key, unsigned size)
{
AVIOContext *pb = s->pb;
mxf_write_generic_desc(s, st, key, size+5+12+8+8);
mxf_write_local_tag(pb, 1, 0x3D02);
avio_w8(pb, 1);
mxf_write_local_tag(pb, 8, 0x3D03);
avio_wb32(pb, st->codec->sample_rate);
avio_wb32(pb, 1);
mxf_write_local_tag(pb, 4, 0x3D07);
avio_wb32(pb, st->codec->channels);
mxf_write_local_tag(pb, 4, 0x3D01);
avio_wb32(pb, av_get_bits_per_sample(st->codec->codec_id));
}
| {
"code": [
" avio_wb32(pb, st->codec->channels);"
],
"line_no": [
33
]
} | static void FUNC_0(AVFormatContext *VAR_0, AVStream *VAR_1, const UID VAR_2, unsigned VAR_3)
{
AVIOContext *pb = VAR_0->pb;
mxf_write_generic_desc(VAR_0, VAR_1, VAR_2, VAR_3+5+12+8+8);
mxf_write_local_tag(pb, 1, 0x3D02);
avio_w8(pb, 1);
mxf_write_local_tag(pb, 8, 0x3D03);
avio_wb32(pb, VAR_1->codec->sample_rate);
avio_wb32(pb, 1);
mxf_write_local_tag(pb, 4, 0x3D07);
avio_wb32(pb, VAR_1->codec->channels);
mxf_write_local_tag(pb, 4, 0x3D01);
avio_wb32(pb, av_get_bits_per_sample(VAR_1->codec->codec_id));
}
| [
"static void FUNC_0(AVFormatContext *VAR_0, AVStream *VAR_1, const UID VAR_2, unsigned VAR_3)\n{",
"AVIOContext *pb = VAR_0->pb;",
"mxf_write_generic_desc(VAR_0, VAR_1, VAR_2, VAR_3+5+12+8+8);",
"mxf_write_local_tag(pb, 1, 0x3D02);",
"avio_w8(pb, 1);",
"mxf_write_local_tag(pb, 8, 0x3D03);",
"avio_wb32(p... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
15
],
[
17
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
]
] |
2,004 | static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
{
int i, v, j;
dprintf("matrix extension\n");
if (get_bits1(&s->gb)) {
for(i=0;i<64;i++) {
v = get_bits(&s->gb, 8);
j = zigzag_direct[i];
s->intra_matrix[j] = v;
s->chroma_intra_matrix[j] = v;
}
}
if (get_bits1(&s->gb)) {
for(i=0;i<64;i++) {
v = get_bits(&s->gb, 8);
j = zigzag_direct[i];
s->non_intra_matrix[j] = v;
s->chroma_non_intra_matrix[j] = v;
}
}
if (get_bits1(&s->gb)) {
for(i=0;i<64;i++) {
v = get_bits(&s->gb, 8);
j = zigzag_direct[i];
s->chroma_intra_matrix[j] = v;
}
}
if (get_bits1(&s->gb)) {
for(i=0;i<64;i++) {
v = get_bits(&s->gb, 8);
j = zigzag_direct[i];
s->chroma_non_intra_matrix[j] = v;
}
}
}
| true | FFmpeg | d7e9533aa06f4073a27812349b35ba5fede11ca1 | static void mpeg_decode_quant_matrix_extension(MpegEncContext *s)
{
int i, v, j;
dprintf("matrix extension\n");
if (get_bits1(&s->gb)) {
for(i=0;i<64;i++) {
v = get_bits(&s->gb, 8);
j = zigzag_direct[i];
s->intra_matrix[j] = v;
s->chroma_intra_matrix[j] = v;
}
}
if (get_bits1(&s->gb)) {
for(i=0;i<64;i++) {
v = get_bits(&s->gb, 8);
j = zigzag_direct[i];
s->non_intra_matrix[j] = v;
s->chroma_non_intra_matrix[j] = v;
}
}
if (get_bits1(&s->gb)) {
for(i=0;i<64;i++) {
v = get_bits(&s->gb, 8);
j = zigzag_direct[i];
s->chroma_intra_matrix[j] = v;
}
}
if (get_bits1(&s->gb)) {
for(i=0;i<64;i++) {
v = get_bits(&s->gb, 8);
j = zigzag_direct[i];
s->chroma_non_intra_matrix[j] = v;
}
}
}
| {
"code": [
" s->non_intra_matrix[j] = v;",
" s->chroma_non_intra_matrix[j] = v;",
" s->chroma_non_intra_matrix[j] = v;",
" s->non_intra_matrix[j] = v;",
" s->chroma_non_intra_matrix[j] = v;",
" for(i=0;i<64;i++) {",
" for(i=0;i<64;i++) {"
],
"line_no": [
37,
39,
39,
37,
39,
15,
15
]
} | static void FUNC_0(MpegEncContext *VAR_0)
{
int VAR_1, VAR_2, VAR_3;
dprintf("matrix extension\n");
if (get_bits1(&VAR_0->gb)) {
for(VAR_1=0;VAR_1<64;VAR_1++) {
VAR_2 = get_bits(&VAR_0->gb, 8);
VAR_3 = zigzag_direct[VAR_1];
VAR_0->intra_matrix[VAR_3] = VAR_2;
VAR_0->chroma_intra_matrix[VAR_3] = VAR_2;
}
}
if (get_bits1(&VAR_0->gb)) {
for(VAR_1=0;VAR_1<64;VAR_1++) {
VAR_2 = get_bits(&VAR_0->gb, 8);
VAR_3 = zigzag_direct[VAR_1];
VAR_0->non_intra_matrix[VAR_3] = VAR_2;
VAR_0->chroma_non_intra_matrix[VAR_3] = VAR_2;
}
}
if (get_bits1(&VAR_0->gb)) {
for(VAR_1=0;VAR_1<64;VAR_1++) {
VAR_2 = get_bits(&VAR_0->gb, 8);
VAR_3 = zigzag_direct[VAR_1];
VAR_0->chroma_intra_matrix[VAR_3] = VAR_2;
}
}
if (get_bits1(&VAR_0->gb)) {
for(VAR_1=0;VAR_1<64;VAR_1++) {
VAR_2 = get_bits(&VAR_0->gb, 8);
VAR_3 = zigzag_direct[VAR_1];
VAR_0->chroma_non_intra_matrix[VAR_3] = VAR_2;
}
}
}
| [
"static void FUNC_0(MpegEncContext *VAR_0)\n{",
"int VAR_1, VAR_2, VAR_3;",
"dprintf(\"matrix extension\\n\");",
"if (get_bits1(&VAR_0->gb)) {",
"for(VAR_1=0;VAR_1<64;VAR_1++) {",
"VAR_2 = get_bits(&VAR_0->gb, 8);",
"VAR_3 = zigzag_direct[VAR_1];",
"VAR_0->intra_matrix[VAR_3] = VAR_2;",
"VAR_0->chro... | [
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45... |
2,005 | uint64_t HELPER(neon_abdl_s16)(uint32_t a, uint32_t b)
{
uint64_t tmp;
uint64_t result;
DO_ABD(result, a, b, int8_t);
DO_ABD(tmp, a >> 8, b >> 8, int8_t);
result |= tmp << 16;
DO_ABD(tmp, a >> 16, b >> 16, int8_t);
result |= tmp << 32;
DO_ABD(tmp, a >> 24, b >> 24, int8_t);
result |= tmp << 48;
return result;
}
| true | qemu | 4d9ad7f793605abd9806fc932b3e04e028894565 | uint64_t HELPER(neon_abdl_s16)(uint32_t a, uint32_t b)
{
uint64_t tmp;
uint64_t result;
DO_ABD(result, a, b, int8_t);
DO_ABD(tmp, a >> 8, b >> 8, int8_t);
result |= tmp << 16;
DO_ABD(tmp, a >> 16, b >> 16, int8_t);
result |= tmp << 32;
DO_ABD(tmp, a >> 24, b >> 24, int8_t);
result |= tmp << 48;
return result;
}
| {
"code": [
" DO_ABD(result, a, b, int8_t);",
" DO_ABD(tmp, a >> 8, b >> 8, int8_t);",
" DO_ABD(tmp, a >> 16, b >> 16, int8_t);",
" DO_ABD(tmp, a >> 24, b >> 24, int8_t);"
],
"line_no": [
9,
11,
15,
19
]
} | uint64_t FUNC_0(neon_abdl_s16)(uint32_t a, uint32_t b)
{
uint64_t tmp;
uint64_t result;
DO_ABD(result, a, b, int8_t);
DO_ABD(tmp, a >> 8, b >> 8, int8_t);
result |= tmp << 16;
DO_ABD(tmp, a >> 16, b >> 16, int8_t);
result |= tmp << 32;
DO_ABD(tmp, a >> 24, b >> 24, int8_t);
result |= tmp << 48;
return result;
}
| [
"uint64_t FUNC_0(neon_abdl_s16)(uint32_t a, uint32_t b)\n{",
"uint64_t tmp;",
"uint64_t result;",
"DO_ABD(result, a, b, int8_t);",
"DO_ABD(tmp, a >> 8, b >> 8, int8_t);",
"result |= tmp << 16;",
"DO_ABD(tmp, a >> 16, b >> 16, int8_t);",
"result |= tmp << 32;",
"DO_ABD(tmp, a >> 24, b >> 24, int8_t);... | [
0,
0,
0,
1,
1,
0,
1,
0,
1,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
]
] |
2,006 | int pcie_cap_v1_init(PCIDevice *dev, uint8_t offset, uint8_t type,
uint8_t port)
{
/* PCIe cap v1 init */
int pos;
uint8_t *exp_cap;
assert(pci_is_express(dev));
pos = pci_add_capability(dev, PCI_CAP_ID_EXP, offset, PCI_EXP_VER1_SIZEOF);
if (pos < 0) {
return pos;
}
dev->exp.exp_cap = pos;
exp_cap = dev->config + pos;
pcie_cap_v1_fill(exp_cap, port, type, PCI_EXP_FLAGS_VER1);
return pos;
}
| true | qemu | 6b4495401bdf442457b713b7e3994b465c55af35 | int pcie_cap_v1_init(PCIDevice *dev, uint8_t offset, uint8_t type,
uint8_t port)
{
int pos;
uint8_t *exp_cap;
assert(pci_is_express(dev));
pos = pci_add_capability(dev, PCI_CAP_ID_EXP, offset, PCI_EXP_VER1_SIZEOF);
if (pos < 0) {
return pos;
}
dev->exp.exp_cap = pos;
exp_cap = dev->config + pos;
pcie_cap_v1_fill(exp_cap, port, type, PCI_EXP_FLAGS_VER1);
return pos;
}
| {
"code": [
" uint8_t *exp_cap;",
" exp_cap = dev->config + pos;",
" pcie_cap_v1_fill(exp_cap, port, type, PCI_EXP_FLAGS_VER1);"
],
"line_no": [
11,
29,
33
]
} | int FUNC_0(PCIDevice *VAR_0, uint8_t VAR_1, uint8_t VAR_2,
uint8_t VAR_3)
{
int VAR_4;
uint8_t *exp_cap;
assert(pci_is_express(VAR_0));
VAR_4 = pci_add_capability(VAR_0, PCI_CAP_ID_EXP, VAR_1, PCI_EXP_VER1_SIZEOF);
if (VAR_4 < 0) {
return VAR_4;
}
VAR_0->exp.exp_cap = VAR_4;
exp_cap = VAR_0->config + VAR_4;
pcie_cap_v1_fill(exp_cap, VAR_3, VAR_2, PCI_EXP_FLAGS_VER1);
return VAR_4;
}
| [
"int FUNC_0(PCIDevice *VAR_0, uint8_t VAR_1, uint8_t VAR_2,\nuint8_t VAR_3)\n{",
"int VAR_4;",
"uint8_t *exp_cap;",
"assert(pci_is_express(VAR_0));",
"VAR_4 = pci_add_capability(VAR_0, PCI_CAP_ID_EXP, VAR_1, PCI_EXP_VER1_SIZEOF);",
"if (VAR_4 < 0) {",
"return VAR_4;",
"}",
"VAR_0->exp.exp_cap = VAR_... | [
0,
0,
1,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0
] | [
[
1,
3,
5
],
[
9
],
[
11
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
37
],
[
39
]
] |
2,007 | static int oggvorbis_encode_frame(AVCodecContext *avctx, unsigned char *packets,
int buf_size, void *data)
{
OggVorbisContext *s = avctx->priv_data;
ogg_packet op;
float *audio = data;
int pkt_size;
/* send samples to libvorbis */
if (data) {
const int samples = avctx->frame_size;
float **buffer;
int c, channels = s->vi.channels;
buffer = vorbis_analysis_buffer(&s->vd, samples);
for (c = 0; c < channels; c++) {
int i;
int co = (channels > 8) ? c :
ff_vorbis_encoding_channel_layout_offsets[channels - 1][c];
for (i = 0; i < samples; i++)
buffer[c][i] = audio[i * channels + co];
}
vorbis_analysis_wrote(&s->vd, samples);
} else {
if (!s->eof)
vorbis_analysis_wrote(&s->vd, 0);
s->eof = 1;
}
/* retrieve available packets from libvorbis */
while (vorbis_analysis_blockout(&s->vd, &s->vb) == 1) {
vorbis_analysis(&s->vb, NULL);
vorbis_bitrate_addblock(&s->vb);
/* add any available packets to the output packet buffer */
while (vorbis_bitrate_flushpacket(&s->vd, &op)) {
/* i'd love to say the following line is a hack, but sadly it's
* not, apparently the end of stream decision is in libogg. */
if (op.bytes == 1 && op.e_o_s)
continue;
if (s->buffer_index + sizeof(ogg_packet) + op.bytes > BUFFER_SIZE) {
av_log(avctx, AV_LOG_ERROR, "libvorbis: buffer overflow.");
return -1;
}
memcpy(s->buffer + s->buffer_index, &op, sizeof(ogg_packet));
s->buffer_index += sizeof(ogg_packet);
memcpy(s->buffer + s->buffer_index, op.packet, op.bytes);
s->buffer_index += op.bytes;
}
}
/* output then next packet from the output buffer, if available */
pkt_size = 0;
if (s->buffer_index) {
ogg_packet *op2 = (ogg_packet *)s->buffer;
op2->packet = s->buffer + sizeof(ogg_packet);
pkt_size = op2->bytes;
// FIXME: we should use the user-supplied pts and duration
avctx->coded_frame->pts = ff_samples_to_time_base(avctx,
op2->granulepos);
if (pkt_size > buf_size) {
av_log(avctx, AV_LOG_ERROR, "libvorbis: buffer overflow.");
return -1;
}
memcpy(packets, op2->packet, pkt_size);
s->buffer_index -= pkt_size + sizeof(ogg_packet);
memmove(s->buffer, s->buffer + pkt_size + sizeof(ogg_packet),
s->buffer_index);
}
return pkt_size;
}
| false | FFmpeg | 94025d8a99e8eea72293850e23fffbb6d0c4aaef | static int oggvorbis_encode_frame(AVCodecContext *avctx, unsigned char *packets,
int buf_size, void *data)
{
OggVorbisContext *s = avctx->priv_data;
ogg_packet op;
float *audio = data;
int pkt_size;
if (data) {
const int samples = avctx->frame_size;
float **buffer;
int c, channels = s->vi.channels;
buffer = vorbis_analysis_buffer(&s->vd, samples);
for (c = 0; c < channels; c++) {
int i;
int co = (channels > 8) ? c :
ff_vorbis_encoding_channel_layout_offsets[channels - 1][c];
for (i = 0; i < samples; i++)
buffer[c][i] = audio[i * channels + co];
}
vorbis_analysis_wrote(&s->vd, samples);
} else {
if (!s->eof)
vorbis_analysis_wrote(&s->vd, 0);
s->eof = 1;
}
while (vorbis_analysis_blockout(&s->vd, &s->vb) == 1) {
vorbis_analysis(&s->vb, NULL);
vorbis_bitrate_addblock(&s->vb);
while (vorbis_bitrate_flushpacket(&s->vd, &op)) {
if (op.bytes == 1 && op.e_o_s)
continue;
if (s->buffer_index + sizeof(ogg_packet) + op.bytes > BUFFER_SIZE) {
av_log(avctx, AV_LOG_ERROR, "libvorbis: buffer overflow.");
return -1;
}
memcpy(s->buffer + s->buffer_index, &op, sizeof(ogg_packet));
s->buffer_index += sizeof(ogg_packet);
memcpy(s->buffer + s->buffer_index, op.packet, op.bytes);
s->buffer_index += op.bytes;
}
}
pkt_size = 0;
if (s->buffer_index) {
ogg_packet *op2 = (ogg_packet *)s->buffer;
op2->packet = s->buffer + sizeof(ogg_packet);
pkt_size = op2->bytes;
avctx->coded_frame->pts = ff_samples_to_time_base(avctx,
op2->granulepos);
if (pkt_size > buf_size) {
av_log(avctx, AV_LOG_ERROR, "libvorbis: buffer overflow.");
return -1;
}
memcpy(packets, op2->packet, pkt_size);
s->buffer_index -= pkt_size + sizeof(ogg_packet);
memmove(s->buffer, s->buffer + pkt_size + sizeof(ogg_packet),
s->buffer_index);
}
return pkt_size;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0, unsigned char *VAR_1,
int VAR_2, void *VAR_3)
{
OggVorbisContext *s = VAR_0->priv_data;
ogg_packet op;
float *VAR_4 = VAR_3;
int VAR_5;
if (VAR_3) {
const int VAR_6 = VAR_0->frame_size;
float **VAR_7;
int VAR_8, VAR_9 = s->vi.VAR_9;
VAR_7 = vorbis_analysis_buffer(&s->vd, VAR_6);
for (VAR_8 = 0; VAR_8 < VAR_9; VAR_8++) {
int VAR_10;
int VAR_11 = (VAR_9 > 8) ? VAR_8 :
ff_vorbis_encoding_channel_layout_offsets[VAR_9 - 1][VAR_8];
for (VAR_10 = 0; VAR_10 < VAR_6; VAR_10++)
VAR_7[VAR_8][VAR_10] = VAR_4[VAR_10 * VAR_9 + VAR_11];
}
vorbis_analysis_wrote(&s->vd, VAR_6);
} else {
if (!s->eof)
vorbis_analysis_wrote(&s->vd, 0);
s->eof = 1;
}
while (vorbis_analysis_blockout(&s->vd, &s->vb) == 1) {
vorbis_analysis(&s->vb, NULL);
vorbis_bitrate_addblock(&s->vb);
while (vorbis_bitrate_flushpacket(&s->vd, &op)) {
if (op.bytes == 1 && op.e_o_s)
continue;
if (s->buffer_index + sizeof(ogg_packet) + op.bytes > BUFFER_SIZE) {
av_log(VAR_0, AV_LOG_ERROR, "libvorbis: VAR_7 overflow.");
return -1;
}
memcpy(s->VAR_7 + s->buffer_index, &op, sizeof(ogg_packet));
s->buffer_index += sizeof(ogg_packet);
memcpy(s->VAR_7 + s->buffer_index, op.packet, op.bytes);
s->buffer_index += op.bytes;
}
}
VAR_5 = 0;
if (s->buffer_index) {
ogg_packet *op2 = (ogg_packet *)s->VAR_7;
op2->packet = s->VAR_7 + sizeof(ogg_packet);
VAR_5 = op2->bytes;
VAR_0->coded_frame->pts = ff_samples_to_time_base(VAR_0,
op2->granulepos);
if (VAR_5 > VAR_2) {
av_log(VAR_0, AV_LOG_ERROR, "libvorbis: VAR_7 overflow.");
return -1;
}
memcpy(VAR_1, op2->packet, VAR_5);
s->buffer_index -= VAR_5 + sizeof(ogg_packet);
memmove(s->VAR_7, s->VAR_7 + VAR_5 + sizeof(ogg_packet),
s->buffer_index);
}
return VAR_5;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0, unsigned char *VAR_1,\nint VAR_2, void *VAR_3)\n{",
"OggVorbisContext *s = VAR_0->priv_data;",
"ogg_packet op;",
"float *VAR_4 = VAR_3;",
"int VAR_5;",
"if (VAR_3) {",
"const int VAR_6 = VAR_0->frame_size;",
"float **VAR_7;",
"int VAR_8, VAR_9 = s->vi.VAR_9;... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
35,
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49,... |
2,008 | static void av_always_inline filter_mb_edgev( uint8_t *pix, int stride, const int16_t bS[4], unsigned int qp, H264Context *h, int intra ) {
const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
const unsigned int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset;
const int alpha = alpha_table[index_a];
const int beta = beta_table[qp - qp_bd_offset + h->slice_beta_offset];
if (alpha ==0 || beta == 0) return;
if( bS[0] < 4 || !intra ) {
int8_t tc[4];
tc[0] = tc0_table[index_a][bS[0]];
tc[1] = tc0_table[index_a][bS[1]];
tc[2] = tc0_table[index_a][bS[2]];
tc[3] = tc0_table[index_a][bS[3]];
h->h264dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc);
} else {
h->h264dsp.h264_h_loop_filter_luma_intra(pix, stride, alpha, beta);
}
}
| false | FFmpeg | f6b7f72461673e4d398b1edf9ed2a7fe70d99c47 | static void av_always_inline filter_mb_edgev( uint8_t *pix, int stride, const int16_t bS[4], unsigned int qp, H264Context *h, int intra ) {
const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
const unsigned int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset;
const int alpha = alpha_table[index_a];
const int beta = beta_table[qp - qp_bd_offset + h->slice_beta_offset];
if (alpha ==0 || beta == 0) return;
if( bS[0] < 4 || !intra ) {
int8_t tc[4];
tc[0] = tc0_table[index_a][bS[0]];
tc[1] = tc0_table[index_a][bS[1]];
tc[2] = tc0_table[index_a][bS[2]];
tc[3] = tc0_table[index_a][bS[3]];
h->h264dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc);
} else {
h->h264dsp.h264_h_loop_filter_luma_intra(pix, stride, alpha, beta);
}
}
| {
"code": [],
"line_no": []
} | static void VAR_0 filter_mb_edgev( uint8_t *pix, int stride, const int16_t bS[4], unsigned int qp, H264Context *h, int intra ) {
const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
const unsigned int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset;
const int alpha = alpha_table[index_a];
const int beta = beta_table[qp - qp_bd_offset + h->slice_beta_offset];
if (alpha ==0 || beta == 0) return;
if( bS[0] < 4 || !intra ) {
int8_t tc[4];
tc[0] = tc0_table[index_a][bS[0]];
tc[1] = tc0_table[index_a][bS[1]];
tc[2] = tc0_table[index_a][bS[2]];
tc[3] = tc0_table[index_a][bS[3]];
h->h264dsp.h264_h_loop_filter_luma(pix, stride, alpha, beta, tc);
} else {
h->h264dsp.h264_h_loop_filter_luma_intra(pix, stride, alpha, beta);
}
}
| [
"static void VAR_0 filter_mb_edgev( uint8_t *pix, int stride, const int16_t bS[4], unsigned int qp, H264Context *h, int intra ) {",
"const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);",
"const unsigned int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset;",
"const int alpha = alpha_table[index_a]... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1
],
[
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
]
] |
2,011 | static void v9fs_getlock(void *opaque)
{
size_t offset = 7;
struct stat stbuf;
V9fsFidState *fidp;
V9fsGetlock *glock;
int32_t fid, err = 0;
V9fsPDU *pdu = opaque;
V9fsState *s = pdu->s;
glock = g_malloc(sizeof(*glock));
pdu_unmarshal(pdu, offset, "dbqqds", &fid, &glock->type,
&glock->start, &glock->length, &glock->proc_id,
&glock->client_id);
trace_v9fs_getlock(pdu->tag, pdu->id, fid,
glock->type, glock->start, glock->length);
fidp = get_fid(pdu, fid);
if (fidp == NULL) {
err = -ENOENT;
goto out_nofid;
}
err = v9fs_co_fstat(pdu, fidp->fs.fd, &stbuf);
if (err < 0) {
goto out;
}
glock->type = P9_LOCK_TYPE_UNLCK;
offset += pdu_marshal(pdu, offset, "bqqds", glock->type,
glock->start, glock->length, glock->proc_id,
&glock->client_id);
err = offset;
out:
put_fid(pdu, fidp);
out_nofid:
complete_pdu(s, pdu, err);
v9fs_string_free(&glock->client_id);
g_free(glock);
} | true | qemu | c572f23a3e7180dbeab5e86583e43ea2afed6271 | static void v9fs_getlock(void *opaque)
{
size_t offset = 7;
struct stat stbuf;
V9fsFidState *fidp;
V9fsGetlock *glock;
int32_t fid, err = 0;
V9fsPDU *pdu = opaque;
V9fsState *s = pdu->s;
glock = g_malloc(sizeof(*glock));
pdu_unmarshal(pdu, offset, "dbqqds", &fid, &glock->type,
&glock->start, &glock->length, &glock->proc_id,
&glock->client_id);
trace_v9fs_getlock(pdu->tag, pdu->id, fid,
glock->type, glock->start, glock->length);
fidp = get_fid(pdu, fid);
if (fidp == NULL) {
err = -ENOENT;
goto out_nofid;
}
err = v9fs_co_fstat(pdu, fidp->fs.fd, &stbuf);
if (err < 0) {
goto out;
}
glock->type = P9_LOCK_TYPE_UNLCK;
offset += pdu_marshal(pdu, offset, "bqqds", glock->type,
glock->start, glock->length, glock->proc_id,
&glock->client_id);
err = offset;
out:
put_fid(pdu, fidp);
out_nofid:
complete_pdu(s, pdu, err);
v9fs_string_free(&glock->client_id);
g_free(glock);
} | {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0)
{
size_t offset = 7;
struct stat VAR_1;
V9fsFidState *fidp;
V9fsGetlock *glock;
int32_t fid, err = 0;
V9fsPDU *pdu = VAR_0;
V9fsState *s = pdu->s;
glock = g_malloc(sizeof(*glock));
pdu_unmarshal(pdu, offset, "dbqqds", &fid, &glock->type,
&glock->start, &glock->length, &glock->proc_id,
&glock->client_id);
trace_v9fs_getlock(pdu->tag, pdu->id, fid,
glock->type, glock->start, glock->length);
fidp = get_fid(pdu, fid);
if (fidp == NULL) {
err = -ENOENT;
goto out_nofid;
}
err = v9fs_co_fstat(pdu, fidp->fs.fd, &VAR_1);
if (err < 0) {
goto out;
}
glock->type = P9_LOCK_TYPE_UNLCK;
offset += pdu_marshal(pdu, offset, "bqqds", glock->type,
glock->start, glock->length, glock->proc_id,
&glock->client_id);
err = offset;
out:
put_fid(pdu, fidp);
out_nofid:
complete_pdu(s, pdu, err);
v9fs_string_free(&glock->client_id);
g_free(glock);
} | [
"static void FUNC_0(void *VAR_0)\n{",
"size_t offset = 7;",
"struct stat VAR_1;",
"V9fsFidState *fidp;",
"V9fsGetlock *glock;",
"int32_t fid, err = 0;",
"V9fsPDU *pdu = VAR_0;",
"V9fsState *s = pdu->s;",
"glock = g_malloc(sizeof(*glock));",
"pdu_unmarshal(pdu, offset, \"dbqqds\", &fid, &glock->typ... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
2
],
[
3
],
[
4
],
[
5
],
[
6
],
[
7
],
[
8
],
[
9
],
[
10
],
[
11,
12,
13
],
[
14,
15
],
[
16
],
[
17
],
[
18
],
[
19
],
[
20
],
[
21
],
[
22
],
[
... |
2,012 | static int vp9_superframe_filter(AVBSFContext *ctx, AVPacket *out)
{
BitstreamContext bc;
VP9BSFContext *s = ctx->priv_data;
AVPacket *in;
int res, invisible, profile, marker, uses_superframe_syntax = 0, n;
res = ff_bsf_get_packet(ctx, &in);
if (res < 0)
return res;
marker = in->data[in->size - 1];
if ((marker & 0xe0) == 0xc0) {
int nbytes = 1 + ((marker >> 3) & 0x3);
int n_frames = 1 + (marker & 0x7), idx_sz = 2 + n_frames * nbytes;
uses_superframe_syntax = in->size >= idx_sz && in->data[in->size - idx_sz] == marker;
}
res = bitstream_init8(&bc, in->data, in->size);
if (res < 0)
goto done;
bitstream_read(&bc, 2); // frame marker
profile = bitstream_read(&bc, 1);
profile |= bitstream_read(&bc, 1) << 1;
if (profile == 3)
profile += bitstream_read(&bc, 1);
if (bitstream_read(&bc, 1)) {
invisible = 0;
} else {
bitstream_read(&bc, 1); // keyframe
invisible = !bitstream_read(&bc, 1);
}
if (uses_superframe_syntax && s->n_cache > 0) {
av_log(ctx, AV_LOG_ERROR,
"Mixing of superframe syntax and naked VP9 frames not supported");
res = AVERROR(ENOSYS);
goto done;
} else if ((!invisible || uses_superframe_syntax) && !s->n_cache) {
// passthrough
av_packet_move_ref(out, in);
goto done;
} else if (s->n_cache + 1 >= MAX_CACHE) {
av_log(ctx, AV_LOG_ERROR,
"Too many invisible frames");
res = AVERROR_INVALIDDATA;
goto done;
}
s->cache[s->n_cache++] = in;
in = NULL;
if (invisible) {
res = AVERROR(EAGAIN);
goto done;
}
av_assert0(s->n_cache > 0);
// build superframe
if ((res = merge_superframe(s->cache, s->n_cache, out)) < 0)
goto done;
res = av_packet_copy_props(out, s->cache[s->n_cache - 1]);
if (res < 0)
goto done;
for (n = 0; n < s->n_cache; n++)
av_packet_free(&s->cache[n]);
s->n_cache = 0;
done:
if (res < 0)
av_packet_unref(out);
av_packet_free(&in);
return res;
}
| true | FFmpeg | 5c22c90c1d5050f1206e46494b193320ac2397cb | static int vp9_superframe_filter(AVBSFContext *ctx, AVPacket *out)
{
BitstreamContext bc;
VP9BSFContext *s = ctx->priv_data;
AVPacket *in;
int res, invisible, profile, marker, uses_superframe_syntax = 0, n;
res = ff_bsf_get_packet(ctx, &in);
if (res < 0)
return res;
marker = in->data[in->size - 1];
if ((marker & 0xe0) == 0xc0) {
int nbytes = 1 + ((marker >> 3) & 0x3);
int n_frames = 1 + (marker & 0x7), idx_sz = 2 + n_frames * nbytes;
uses_superframe_syntax = in->size >= idx_sz && in->data[in->size - idx_sz] == marker;
}
res = bitstream_init8(&bc, in->data, in->size);
if (res < 0)
goto done;
bitstream_read(&bc, 2);
profile = bitstream_read(&bc, 1);
profile |= bitstream_read(&bc, 1) << 1;
if (profile == 3)
profile += bitstream_read(&bc, 1);
if (bitstream_read(&bc, 1)) {
invisible = 0;
} else {
bitstream_read(&bc, 1);
invisible = !bitstream_read(&bc, 1);
}
if (uses_superframe_syntax && s->n_cache > 0) {
av_log(ctx, AV_LOG_ERROR,
"Mixing of superframe syntax and naked VP9 frames not supported");
res = AVERROR(ENOSYS);
goto done;
} else if ((!invisible || uses_superframe_syntax) && !s->n_cache) {
av_packet_move_ref(out, in);
goto done;
} else if (s->n_cache + 1 >= MAX_CACHE) {
av_log(ctx, AV_LOG_ERROR,
"Too many invisible frames");
res = AVERROR_INVALIDDATA;
goto done;
}
s->cache[s->n_cache++] = in;
in = NULL;
if (invisible) {
res = AVERROR(EAGAIN);
goto done;
}
av_assert0(s->n_cache > 0);
if ((res = merge_superframe(s->cache, s->n_cache, out)) < 0)
goto done;
res = av_packet_copy_props(out, s->cache[s->n_cache - 1]);
if (res < 0)
goto done;
for (n = 0; n < s->n_cache; n++)
av_packet_free(&s->cache[n]);
s->n_cache = 0;
done:
if (res < 0)
av_packet_unref(out);
av_packet_free(&in);
return res;
}
| {
"code": [
" s->cache[s->n_cache++] = in;",
" in = NULL;",
" av_packet_free(&s->cache[n]);",
" for (n = 0; n < s->n_cache; n++)"
],
"line_no": [
105,
107,
139,
137
]
} | static int FUNC_0(AVBSFContext *VAR_0, AVPacket *VAR_1)
{
BitstreamContext bc;
VP9BSFContext *s = VAR_0->priv_data;
AVPacket *in;
int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6 = 0, VAR_7;
VAR_2 = ff_bsf_get_packet(VAR_0, &in);
if (VAR_2 < 0)
return VAR_2;
VAR_5 = in->data[in->size - 1];
if ((VAR_5 & 0xe0) == 0xc0) {
int VAR_8 = 1 + ((VAR_5 >> 3) & 0x3);
int VAR_9 = 1 + (VAR_5 & 0x7), VAR_10 = 2 + VAR_9 * VAR_8;
VAR_6 = in->size >= VAR_10 && in->data[in->size - VAR_10] == VAR_5;
}
VAR_2 = bitstream_init8(&bc, in->data, in->size);
if (VAR_2 < 0)
goto done;
bitstream_read(&bc, 2);
VAR_4 = bitstream_read(&bc, 1);
VAR_4 |= bitstream_read(&bc, 1) << 1;
if (VAR_4 == 3)
VAR_4 += bitstream_read(&bc, 1);
if (bitstream_read(&bc, 1)) {
VAR_3 = 0;
} else {
bitstream_read(&bc, 1);
VAR_3 = !bitstream_read(&bc, 1);
}
if (VAR_6 && s->n_cache > 0) {
av_log(VAR_0, AV_LOG_ERROR,
"Mixing of superframe syntax and naked VP9 frames not supported");
VAR_2 = AVERROR(ENOSYS);
goto done;
} else if ((!VAR_3 || VAR_6) && !s->n_cache) {
av_packet_move_ref(VAR_1, in);
goto done;
} else if (s->n_cache + 1 >= MAX_CACHE) {
av_log(VAR_0, AV_LOG_ERROR,
"Too many VAR_3 frames");
VAR_2 = AVERROR_INVALIDDATA;
goto done;
}
s->cache[s->n_cache++] = in;
in = NULL;
if (VAR_3) {
VAR_2 = AVERROR(EAGAIN);
goto done;
}
av_assert0(s->n_cache > 0);
if ((VAR_2 = merge_superframe(s->cache, s->n_cache, VAR_1)) < 0)
goto done;
VAR_2 = av_packet_copy_props(VAR_1, s->cache[s->n_cache - 1]);
if (VAR_2 < 0)
goto done;
for (VAR_7 = 0; VAR_7 < s->n_cache; VAR_7++)
av_packet_free(&s->cache[VAR_7]);
s->n_cache = 0;
done:
if (VAR_2 < 0)
av_packet_unref(VAR_1);
av_packet_free(&in);
return VAR_2;
}
| [
"static int FUNC_0(AVBSFContext *VAR_0, AVPacket *VAR_1)\n{",
"BitstreamContext bc;",
"VP9BSFContext *s = VAR_0->priv_data;",
"AVPacket *in;",
"int VAR_2, VAR_3, VAR_4, VAR_5, VAR_6 = 0, VAR_7;",
"VAR_2 = ff_bsf_get_packet(VAR_0, &in);",
"if (VAR_2 < 0)\nreturn VAR_2;",
"VAR_5 = in->data[in->size - 1]... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17,
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
39
],
[
41,
43
],
[
47
],
[
49
],
[
51
],
[
53,... |
2,013 | static int virtio_pci_set_host_notifier_internal(VirtIOPCIProxy *proxy,
int n, bool assign, bool set_handler)
{
VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
VirtQueue *vq = virtio_get_queue(vdev, n);
EventNotifier *notifier = virtio_queue_get_host_notifier(vq);
int r = 0;
if (assign) {
r = event_notifier_init(notifier, 1);
if (r < 0) {
error_report("%s: unable to init event notifier: %d",
__func__, r);
return r;
}
virtio_queue_set_host_notifier_fd_handler(vq, true, set_handler);
memory_region_add_eventfd(&proxy->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2,
true, n, notifier);
} else {
memory_region_del_eventfd(&proxy->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2,
true, n, notifier);
virtio_queue_set_host_notifier_fd_handler(vq, false, false);
event_notifier_cleanup(notifier);
}
return r;
}
| true | qemu | 975acc0ae6d60260859884a9235ae3c62e2969a2 | static int virtio_pci_set_host_notifier_internal(VirtIOPCIProxy *proxy,
int n, bool assign, bool set_handler)
{
VirtIODevice *vdev = virtio_bus_get_device(&proxy->bus);
VirtQueue *vq = virtio_get_queue(vdev, n);
EventNotifier *notifier = virtio_queue_get_host_notifier(vq);
int r = 0;
if (assign) {
r = event_notifier_init(notifier, 1);
if (r < 0) {
error_report("%s: unable to init event notifier: %d",
__func__, r);
return r;
}
virtio_queue_set_host_notifier_fd_handler(vq, true, set_handler);
memory_region_add_eventfd(&proxy->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2,
true, n, notifier);
} else {
memory_region_del_eventfd(&proxy->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2,
true, n, notifier);
virtio_queue_set_host_notifier_fd_handler(vq, false, false);
event_notifier_cleanup(notifier);
}
return r;
}
| {
"code": [
" memory_region_add_eventfd(&proxy->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2,",
" true, n, notifier);",
" memory_region_del_eventfd(&proxy->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2,",
" true, n, notifier);"
],
"line_no": [
33,
35,
39,
35
]
} | static int FUNC_0(VirtIOPCIProxy *VAR_0,
int VAR_1, bool VAR_2, bool VAR_3)
{
VirtIODevice *vdev = virtio_bus_get_device(&VAR_0->bus);
VirtQueue *vq = virtio_get_queue(vdev, VAR_1);
EventNotifier *notifier = virtio_queue_get_host_notifier(vq);
int VAR_4 = 0;
if (VAR_2) {
VAR_4 = event_notifier_init(notifier, 1);
if (VAR_4 < 0) {
error_report("%s: unable to init event notifier: %d",
__func__, VAR_4);
return VAR_4;
}
virtio_queue_set_host_notifier_fd_handler(vq, true, VAR_3);
memory_region_add_eventfd(&VAR_0->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2,
true, VAR_1, notifier);
} else {
memory_region_del_eventfd(&VAR_0->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2,
true, VAR_1, notifier);
virtio_queue_set_host_notifier_fd_handler(vq, false, false);
event_notifier_cleanup(notifier);
}
return VAR_4;
}
| [
"static int FUNC_0(VirtIOPCIProxy *VAR_0,\nint VAR_1, bool VAR_2, bool VAR_3)\n{",
"VirtIODevice *vdev = virtio_bus_get_device(&VAR_0->bus);",
"VirtQueue *vq = virtio_get_queue(vdev, VAR_1);",
"EventNotifier *notifier = virtio_queue_get_host_notifier(vq);",
"int VAR_4 = 0;",
"if (VAR_2) {",
"VAR_4 = eve... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23,
25
],
[
27
],
[
29
],
[
31
],
[
33,
35
],
[
37
],
[
39,
41
],
[
43
],
[
45
],
[
47
... |
2,015 | static inline void RENAME(planar2x)(const uint8_t *src, uint8_t *dst, int srcWidth, int srcHeight, int srcStride, int dstStride)
{
int x,y;
dst[0]= src[0];
// first line
for (x=0; x<srcWidth-1; x++) {
dst[2*x+1]= (3*src[x] + src[x+1])>>2;
dst[2*x+2]= ( src[x] + 3*src[x+1])>>2;
}
dst[2*srcWidth-1]= src[srcWidth-1];
dst+= dstStride;
for (y=1; y<srcHeight; y++) {
const x86_reg mmxSize= srcWidth&~15;
__asm__ volatile(
"mov %4, %%"REG_a" \n\t"
"movq "MANGLE(mmx_ff)", %%mm0 \n\t"
"movq (%0, %%"REG_a"), %%mm4 \n\t"
"movq %%mm4, %%mm2 \n\t"
"psllq $8, %%mm4 \n\t"
"pand %%mm0, %%mm2 \n\t"
"por %%mm2, %%mm4 \n\t"
"movq (%1, %%"REG_a"), %%mm5 \n\t"
"movq %%mm5, %%mm3 \n\t"
"psllq $8, %%mm5 \n\t"
"pand %%mm0, %%mm3 \n\t"
"por %%mm3, %%mm5 \n\t"
"1: \n\t"
"movq (%0, %%"REG_a"), %%mm0 \n\t"
"movq (%1, %%"REG_a"), %%mm1 \n\t"
"movq 1(%0, %%"REG_a"), %%mm2 \n\t"
"movq 1(%1, %%"REG_a"), %%mm3 \n\t"
PAVGB" %%mm0, %%mm5 \n\t"
PAVGB" %%mm0, %%mm3 \n\t"
PAVGB" %%mm0, %%mm5 \n\t"
PAVGB" %%mm0, %%mm3 \n\t"
PAVGB" %%mm1, %%mm4 \n\t"
PAVGB" %%mm1, %%mm2 \n\t"
PAVGB" %%mm1, %%mm4 \n\t"
PAVGB" %%mm1, %%mm2 \n\t"
"movq %%mm5, %%mm7 \n\t"
"movq %%mm4, %%mm6 \n\t"
"punpcklbw %%mm3, %%mm5 \n\t"
"punpckhbw %%mm3, %%mm7 \n\t"
"punpcklbw %%mm2, %%mm4 \n\t"
"punpckhbw %%mm2, %%mm6 \n\t"
MOVNTQ" %%mm5, (%2, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm7, 8(%2, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm4, (%3, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm6, 8(%3, %%"REG_a", 2) \n\t"
"add $8, %%"REG_a" \n\t"
"movq -1(%0, %%"REG_a"), %%mm4 \n\t"
"movq -1(%1, %%"REG_a"), %%mm5 \n\t"
" js 1b \n\t"
:: "r" (src + mmxSize ), "r" (src + srcStride + mmxSize ),
"r" (dst + mmxSize*2), "r" (dst + dstStride + mmxSize*2),
"g" (-mmxSize)
NAMED_CONSTRAINTS_ADD(mmx_ff)
: "%"REG_a
);
for (x=mmxSize-1; x<srcWidth-1; x++) {
dst[2*x +1]= (3*src[x+0] + src[x+srcStride+1])>>2;
dst[2*x+dstStride+2]= ( src[x+0] + 3*src[x+srcStride+1])>>2;
dst[2*x+dstStride+1]= ( src[x+1] + 3*src[x+srcStride ])>>2;
dst[2*x +2]= (3*src[x+1] + src[x+srcStride ])>>2;
}
dst[srcWidth*2 -1 ]= (3*src[srcWidth-1] + src[srcWidth-1 + srcStride])>>2;
dst[srcWidth*2 -1 + dstStride]= ( src[srcWidth-1] + 3*src[srcWidth-1 + srcStride])>>2;
dst+=dstStride*2;
src+=srcStride;
}
// last line
dst[0]= src[0];
for (x=0; x<srcWidth-1; x++) {
dst[2*x+1]= (3*src[x] + src[x+1])>>2;
dst[2*x+2]= ( src[x] + 3*src[x+1])>>2;
}
dst[2*srcWidth-1]= src[srcWidth-1];
__asm__ volatile(EMMS" \n\t"
SFENCE" \n\t"
:::"memory");
}
| false | FFmpeg | c8a9aaab2695e0f9921db946a3b9f14bea880167 | static inline void RENAME(planar2x)(const uint8_t *src, uint8_t *dst, int srcWidth, int srcHeight, int srcStride, int dstStride)
{
int x,y;
dst[0]= src[0];
for (x=0; x<srcWidth-1; x++) {
dst[2*x+1]= (3*src[x] + src[x+1])>>2;
dst[2*x+2]= ( src[x] + 3*src[x+1])>>2;
}
dst[2*srcWidth-1]= src[srcWidth-1];
dst+= dstStride;
for (y=1; y<srcHeight; y++) {
const x86_reg mmxSize= srcWidth&~15;
__asm__ volatile(
"mov %4, %%"REG_a" \n\t"
"movq "MANGLE(mmx_ff)", %%mm0 \n\t"
"movq (%0, %%"REG_a"), %%mm4 \n\t"
"movq %%mm4, %%mm2 \n\t"
"psllq $8, %%mm4 \n\t"
"pand %%mm0, %%mm2 \n\t"
"por %%mm2, %%mm4 \n\t"
"movq (%1, %%"REG_a"), %%mm5 \n\t"
"movq %%mm5, %%mm3 \n\t"
"psllq $8, %%mm5 \n\t"
"pand %%mm0, %%mm3 \n\t"
"por %%mm3, %%mm5 \n\t"
"1: \n\t"
"movq (%0, %%"REG_a"), %%mm0 \n\t"
"movq (%1, %%"REG_a"), %%mm1 \n\t"
"movq 1(%0, %%"REG_a"), %%mm2 \n\t"
"movq 1(%1, %%"REG_a"), %%mm3 \n\t"
PAVGB" %%mm0, %%mm5 \n\t"
PAVGB" %%mm0, %%mm3 \n\t"
PAVGB" %%mm0, %%mm5 \n\t"
PAVGB" %%mm0, %%mm3 \n\t"
PAVGB" %%mm1, %%mm4 \n\t"
PAVGB" %%mm1, %%mm2 \n\t"
PAVGB" %%mm1, %%mm4 \n\t"
PAVGB" %%mm1, %%mm2 \n\t"
"movq %%mm5, %%mm7 \n\t"
"movq %%mm4, %%mm6 \n\t"
"punpcklbw %%mm3, %%mm5 \n\t"
"punpckhbw %%mm3, %%mm7 \n\t"
"punpcklbw %%mm2, %%mm4 \n\t"
"punpckhbw %%mm2, %%mm6 \n\t"
MOVNTQ" %%mm5, (%2, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm7, 8(%2, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm4, (%3, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm6, 8(%3, %%"REG_a", 2) \n\t"
"add $8, %%"REG_a" \n\t"
"movq -1(%0, %%"REG_a"), %%mm4 \n\t"
"movq -1(%1, %%"REG_a"), %%mm5 \n\t"
" js 1b \n\t"
:: "r" (src + mmxSize ), "r" (src + srcStride + mmxSize ),
"r" (dst + mmxSize*2), "r" (dst + dstStride + mmxSize*2),
"g" (-mmxSize)
NAMED_CONSTRAINTS_ADD(mmx_ff)
: "%"REG_a
);
for (x=mmxSize-1; x<srcWidth-1; x++) {
dst[2*x +1]= (3*src[x+0] + src[x+srcStride+1])>>2;
dst[2*x+dstStride+2]= ( src[x+0] + 3*src[x+srcStride+1])>>2;
dst[2*x+dstStride+1]= ( src[x+1] + 3*src[x+srcStride ])>>2;
dst[2*x +2]= (3*src[x+1] + src[x+srcStride ])>>2;
}
dst[srcWidth*2 -1 ]= (3*src[srcWidth-1] + src[srcWidth-1 + srcStride])>>2;
dst[srcWidth*2 -1 + dstStride]= ( src[srcWidth-1] + 3*src[srcWidth-1 + srcStride])>>2;
dst+=dstStride*2;
src+=srcStride;
}
dst[0]= src[0];
for (x=0; x<srcWidth-1; x++) {
dst[2*x+1]= (3*src[x] + src[x+1])>>2;
dst[2*x+2]= ( src[x] + 3*src[x+1])>>2;
}
dst[2*srcWidth-1]= src[srcWidth-1];
__asm__ volatile(EMMS" \n\t"
SFENCE" \n\t"
:::"memory");
}
| {
"code": [],
"line_no": []
} | static inline void FUNC_0(planar2x)(const uint8_t *src, uint8_t *dst, int srcWidth, int srcHeight, int srcStride, int dstStride)
{
int VAR_0,VAR_1;
dst[0]= src[0];
for (VAR_0=0; VAR_0<srcWidth-1; VAR_0++) {
dst[2*VAR_0+1]= (3*src[VAR_0] + src[VAR_0+1])>>2;
dst[2*VAR_0+2]= ( src[VAR_0] + 3*src[VAR_0+1])>>2;
}
dst[2*srcWidth-1]= src[srcWidth-1];
dst+= dstStride;
for (VAR_1=1; VAR_1<srcHeight; VAR_1++) {
const x86_reg mmxSize= srcWidth&~15;
__asm__ volatile(
"mov %4, %%"REG_a" \n\t"
"movq "MANGLE(mmx_ff)", %%mm0 \n\t"
"movq (%0, %%"REG_a"), %%mm4 \n\t"
"movq %%mm4, %%mm2 \n\t"
"psllq $8, %%mm4 \n\t"
"pand %%mm0, %%mm2 \n\t"
"por %%mm2, %%mm4 \n\t"
"movq (%1, %%"REG_a"), %%mm5 \n\t"
"movq %%mm5, %%mm3 \n\t"
"psllq $8, %%mm5 \n\t"
"pand %%mm0, %%mm3 \n\t"
"por %%mm3, %%mm5 \n\t"
"1: \n\t"
"movq (%0, %%"REG_a"), %%mm0 \n\t"
"movq (%1, %%"REG_a"), %%mm1 \n\t"
"movq 1(%0, %%"REG_a"), %%mm2 \n\t"
"movq 1(%1, %%"REG_a"), %%mm3 \n\t"
PAVGB" %%mm0, %%mm5 \n\t"
PAVGB" %%mm0, %%mm3 \n\t"
PAVGB" %%mm0, %%mm5 \n\t"
PAVGB" %%mm0, %%mm3 \n\t"
PAVGB" %%mm1, %%mm4 \n\t"
PAVGB" %%mm1, %%mm2 \n\t"
PAVGB" %%mm1, %%mm4 \n\t"
PAVGB" %%mm1, %%mm2 \n\t"
"movq %%mm5, %%mm7 \n\t"
"movq %%mm4, %%mm6 \n\t"
"punpcklbw %%mm3, %%mm5 \n\t"
"punpckhbw %%mm3, %%mm7 \n\t"
"punpcklbw %%mm2, %%mm4 \n\t"
"punpckhbw %%mm2, %%mm6 \n\t"
MOVNTQ" %%mm5, (%2, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm7, 8(%2, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm4, (%3, %%"REG_a", 2) \n\t"
MOVNTQ" %%mm6, 8(%3, %%"REG_a", 2) \n\t"
"add $8, %%"REG_a" \n\t"
"movq -1(%0, %%"REG_a"), %%mm4 \n\t"
"movq -1(%1, %%"REG_a"), %%mm5 \n\t"
" js 1b \n\t"
:: "r" (src + mmxSize ), "r" (src + srcStride + mmxSize ),
"r" (dst + mmxSize*2), "r" (dst + dstStride + mmxSize*2),
"g" (-mmxSize)
NAMED_CONSTRAINTS_ADD(mmx_ff)
: "%"REG_a
);
for (VAR_0=mmxSize-1; VAR_0<srcWidth-1; VAR_0++) {
dst[2*VAR_0 +1]= (3*src[VAR_0+0] + src[VAR_0+srcStride+1])>>2;
dst[2*VAR_0+dstStride+2]= ( src[VAR_0+0] + 3*src[VAR_0+srcStride+1])>>2;
dst[2*VAR_0+dstStride+1]= ( src[VAR_0+1] + 3*src[VAR_0+srcStride ])>>2;
dst[2*VAR_0 +2]= (3*src[VAR_0+1] + src[VAR_0+srcStride ])>>2;
}
dst[srcWidth*2 -1 ]= (3*src[srcWidth-1] + src[srcWidth-1 + srcStride])>>2;
dst[srcWidth*2 -1 + dstStride]= ( src[srcWidth-1] + 3*src[srcWidth-1 + srcStride])>>2;
dst+=dstStride*2;
src+=srcStride;
}
dst[0]= src[0];
for (VAR_0=0; VAR_0<srcWidth-1; VAR_0++) {
dst[2*VAR_0+1]= (3*src[VAR_0] + src[VAR_0+1])>>2;
dst[2*VAR_0+2]= ( src[VAR_0] + 3*src[VAR_0+1])>>2;
}
dst[2*srcWidth-1]= src[srcWidth-1];
__asm__ volatile(EMMS" \n\t"
SFENCE" \n\t"
:::"memory");
}
| [
"static inline void FUNC_0(planar2x)(const uint8_t *src, uint8_t *dst, int srcWidth, int srcHeight, int srcStride, int dstStride)\n{",
"int VAR_0,VAR_1;",
"dst[0]= src[0];",
"for (VAR_0=0; VAR_0<srcWidth-1; VAR_0++) {",
"dst[2*VAR_0+1]= (3*src[VAR_0] + src[VAR_0+1])>>2;",
"dst[2*VAR_0+2]= ( src[VAR_0] ... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
31
],
[
33
],
[
35,
37,
39,
41,
43,
45,
47,
49,
51,
53,
55,
57,
59,
61,
63,
65,
67... |
2,016 | int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
{
int64_t offset1;
int64_t pos;
int force = whence & AVSEEK_FORCE;
whence &= ~AVSEEK_FORCE;
if(!s)
return AVERROR(EINVAL);
pos = s->pos - (s->write_flag ? 0 : (s->buf_end - s->buffer));
if (whence != SEEK_CUR && whence != SEEK_SET)
return AVERROR(EINVAL);
if (whence == SEEK_CUR) {
offset1 = pos + (s->buf_ptr - s->buffer);
if (offset == 0)
return offset1;
offset += offset1;
}
offset1 = offset - pos;
if (!s->must_flush &&
offset1 >= 0 && offset1 < (s->buf_end - s->buffer)) {
/* can do the seek inside the buffer */
s->buf_ptr = s->buffer + offset1;
} else if ((!s->seekable ||
offset1 <= s->buf_end + SHORT_SEEK_THRESHOLD - s->buffer) &&
!s->write_flag && offset1 >= 0 &&
(whence != SEEK_END || force)) {
while(s->pos < offset && !s->eof_reached)
fill_buffer(s);
if (s->eof_reached)
return AVERROR_EOF;
s->buf_ptr = s->buf_end + offset - s->pos;
} else {
int64_t res;
if (s->write_flag) {
flush_buffer(s);
s->must_flush = 1;
}
if (!s->seek)
return AVERROR(EPIPE);
if ((res = s->seek(s->opaque, offset, SEEK_SET)) < 0)
return res;
if (!s->write_flag)
s->buf_end = s->buffer;
s->buf_ptr = s->buffer;
s->pos = offset;
}
s->eof_reached = 0;
return offset;
}
| false | FFmpeg | 83548fe894cdb455cc127f754d09905b6d23c173 | int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
{
int64_t offset1;
int64_t pos;
int force = whence & AVSEEK_FORCE;
whence &= ~AVSEEK_FORCE;
if(!s)
return AVERROR(EINVAL);
pos = s->pos - (s->write_flag ? 0 : (s->buf_end - s->buffer));
if (whence != SEEK_CUR && whence != SEEK_SET)
return AVERROR(EINVAL);
if (whence == SEEK_CUR) {
offset1 = pos + (s->buf_ptr - s->buffer);
if (offset == 0)
return offset1;
offset += offset1;
}
offset1 = offset - pos;
if (!s->must_flush &&
offset1 >= 0 && offset1 < (s->buf_end - s->buffer)) {
s->buf_ptr = s->buffer + offset1;
} else if ((!s->seekable ||
offset1 <= s->buf_end + SHORT_SEEK_THRESHOLD - s->buffer) &&
!s->write_flag && offset1 >= 0 &&
(whence != SEEK_END || force)) {
while(s->pos < offset && !s->eof_reached)
fill_buffer(s);
if (s->eof_reached)
return AVERROR_EOF;
s->buf_ptr = s->buf_end + offset - s->pos;
} else {
int64_t res;
if (s->write_flag) {
flush_buffer(s);
s->must_flush = 1;
}
if (!s->seek)
return AVERROR(EPIPE);
if ((res = s->seek(s->opaque, offset, SEEK_SET)) < 0)
return res;
if (!s->write_flag)
s->buf_end = s->buffer;
s->buf_ptr = s->buffer;
s->pos = offset;
}
s->eof_reached = 0;
return offset;
}
| {
"code": [],
"line_no": []
} | int64_t FUNC_0(AVIOContext *s, int64_t offset, int whence)
{
int64_t offset1;
int64_t pos;
int VAR_0 = whence & AVSEEK_FORCE;
whence &= ~AVSEEK_FORCE;
if(!s)
return AVERROR(EINVAL);
pos = s->pos - (s->write_flag ? 0 : (s->buf_end - s->buffer));
if (whence != SEEK_CUR && whence != SEEK_SET)
return AVERROR(EINVAL);
if (whence == SEEK_CUR) {
offset1 = pos + (s->buf_ptr - s->buffer);
if (offset == 0)
return offset1;
offset += offset1;
}
offset1 = offset - pos;
if (!s->must_flush &&
offset1 >= 0 && offset1 < (s->buf_end - s->buffer)) {
s->buf_ptr = s->buffer + offset1;
} else if ((!s->seekable ||
offset1 <= s->buf_end + SHORT_SEEK_THRESHOLD - s->buffer) &&
!s->write_flag && offset1 >= 0 &&
(whence != SEEK_END || VAR_0)) {
while(s->pos < offset && !s->eof_reached)
fill_buffer(s);
if (s->eof_reached)
return AVERROR_EOF;
s->buf_ptr = s->buf_end + offset - s->pos;
} else {
int64_t res;
if (s->write_flag) {
flush_buffer(s);
s->must_flush = 1;
}
if (!s->seek)
return AVERROR(EPIPE);
if ((res = s->seek(s->opaque, offset, SEEK_SET)) < 0)
return res;
if (!s->write_flag)
s->buf_end = s->buffer;
s->buf_ptr = s->buffer;
s->pos = offset;
}
s->eof_reached = 0;
return offset;
}
| [
"int64_t FUNC_0(AVIOContext *s, int64_t offset, int whence)\n{",
"int64_t offset1;",
"int64_t pos;",
"int VAR_0 = whence & AVSEEK_FORCE;",
"whence &= ~AVSEEK_FORCE;",
"if(!s)\nreturn AVERROR(EINVAL);",
"pos = s->pos - (s->write_flag ? 0 : (s->buf_end - s->buffer));",
"if (whence != SEEK_CUR && whence ... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15,
17
],
[
21
],
[
25,
27
],
[
31
],
[
33
],
[
35,
37
],
[
39
],
[
41
],
[
43
],
[
45,
47
],
[
51
],
[
53
],
[
55,... |
2,018 | static int net_vhost_check_net(void *opaque, QemuOpts *opts, Error **errp)
{
const char *name = opaque;
const char *driver, *netdev;
const char virtio_name[] = "virtio-net-";
driver = qemu_opt_get(opts, "driver");
netdev = qemu_opt_get(opts, "netdev");
if (!driver || !netdev) {
return 0;
}
if (strcmp(netdev, name) == 0 &&
strncmp(driver, virtio_name, strlen(virtio_name)) != 0) {
error_report("vhost-user requires frontend driver virtio-net-*");
return -1;
}
return 0;
}
| true | qemu | 8190483196148f765c65785876f7b893d64b6cdd | static int net_vhost_check_net(void *opaque, QemuOpts *opts, Error **errp)
{
const char *name = opaque;
const char *driver, *netdev;
const char virtio_name[] = "virtio-net-";
driver = qemu_opt_get(opts, "driver");
netdev = qemu_opt_get(opts, "netdev");
if (!driver || !netdev) {
return 0;
}
if (strcmp(netdev, name) == 0 &&
strncmp(driver, virtio_name, strlen(virtio_name)) != 0) {
error_report("vhost-user requires frontend driver virtio-net-*");
return -1;
}
return 0;
}
| {
"code": [
" error_report(\"vhost-user requires frontend driver virtio-net-*\");"
],
"line_no": [
31
]
} | static int FUNC_0(void *VAR_0, QemuOpts *VAR_1, Error **VAR_2)
{
const char *VAR_3 = VAR_0;
const char *VAR_4, *VAR_5;
const char VAR_6[] = "virtio-net-";
VAR_4 = qemu_opt_get(VAR_1, "VAR_4");
VAR_5 = qemu_opt_get(VAR_1, "VAR_5");
if (!VAR_4 || !VAR_5) {
return 0;
}
if (strcmp(VAR_5, VAR_3) == 0 &&
strncmp(VAR_4, VAR_6, strlen(VAR_6)) != 0) {
error_report("vhost-user requires frontend VAR_4 virtio-net-*");
return -1;
}
return 0;
}
| [
"static int FUNC_0(void *VAR_0, QemuOpts *VAR_1, Error **VAR_2)\n{",
"const char *VAR_3 = VAR_0;",
"const char *VAR_4, *VAR_5;",
"const char VAR_6[] = \"virtio-net-\";",
"VAR_4 = qemu_opt_get(VAR_1, \"VAR_4\");",
"VAR_5 = qemu_opt_get(VAR_1, \"VAR_5\");",
"if (!VAR_4 || !VAR_5) {",
"return 0;",
"}",... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
]
] |
2,019 | static bool tlb_is_dirty_ram(CPUTLBEntry *tlbe)
{
return (tlbe->addr_write & (TLB_INVALID_MASK|TLB_MMIO|TLB_NOTDIRTY)) == 0;
}
| true | qemu | b0706b716769494f321a0d2bfd9fa9893992f995 | static bool tlb_is_dirty_ram(CPUTLBEntry *tlbe)
{
return (tlbe->addr_write & (TLB_INVALID_MASK|TLB_MMIO|TLB_NOTDIRTY)) == 0;
}
| {
"code": [
"static bool tlb_is_dirty_ram(CPUTLBEntry *tlbe)",
" return (tlbe->addr_write & (TLB_INVALID_MASK|TLB_MMIO|TLB_NOTDIRTY)) == 0;"
],
"line_no": [
1,
5
]
} | static bool FUNC_0(CPUTLBEntry *tlbe)
{
return (tlbe->addr_write & (TLB_INVALID_MASK|TLB_MMIO|TLB_NOTDIRTY)) == 0;
}
| [
"static bool FUNC_0(CPUTLBEntry *tlbe)\n{",
"return (tlbe->addr_write & (TLB_INVALID_MASK|TLB_MMIO|TLB_NOTDIRTY)) == 0;",
"}"
] | [
1,
1,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
2,020 | static int mxf_read_generic_descriptor(MXFDescriptor *descriptor, ByteIOContext *pb, int tag, int size, UID uid)
{
switch(tag) {
case 0x3F01:
descriptor->sub_descriptors_count = get_be32(pb);
if (descriptor->sub_descriptors_count >= UINT_MAX / sizeof(UID))
return -1;
descriptor->sub_descriptors_refs = av_malloc(descriptor->sub_descriptors_count * sizeof(UID));
if (!descriptor->sub_descriptors_refs)
return -1;
url_fskip(pb, 4); /* useless size of objects, always 16 according to specs */
get_buffer(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
break;
case 0x3004:
get_buffer(pb, descriptor->essence_container_ul, 16);
break;
case 0x3006:
descriptor->linked_track_id = get_be32(pb);
break;
case 0x3201: /* PictureEssenceCoding */
get_buffer(pb, descriptor->essence_codec_ul, 16);
break;
case 0x3203:
descriptor->width = get_be32(pb);
break;
case 0x3202:
descriptor->height = get_be32(pb);
break;
case 0x320E:
descriptor->aspect_ratio.num = get_be32(pb);
descriptor->aspect_ratio.den = get_be32(pb);
break;
case 0x3D03:
descriptor->sample_rate.num = get_be32(pb);
descriptor->sample_rate.den = get_be32(pb);
break;
case 0x3D06: /* SoundEssenceCompression */
get_buffer(pb, descriptor->essence_codec_ul, 16);
break;
case 0x3D07:
descriptor->channels = get_be32(pb);
break;
case 0x3D01:
descriptor->bits_per_sample = get_be32(pb);
break;
case 0x3401:
mxf_read_pixel_layout(pb, descriptor);
break;
default:
/* Private uid used by SONY C0023S01.mxf */
if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
descriptor->extradata = av_malloc(size);
if (!descriptor->extradata)
return -1;
descriptor->extradata_size = size;
get_buffer(pb, descriptor->extradata, size);
}
break;
}
return 0;
}
| true | FFmpeg | 39bb30f6640fe1faf4bbc779a79786028febc95d | static int mxf_read_generic_descriptor(MXFDescriptor *descriptor, ByteIOContext *pb, int tag, int size, UID uid)
{
switch(tag) {
case 0x3F01:
descriptor->sub_descriptors_count = get_be32(pb);
if (descriptor->sub_descriptors_count >= UINT_MAX / sizeof(UID))
return -1;
descriptor->sub_descriptors_refs = av_malloc(descriptor->sub_descriptors_count * sizeof(UID));
if (!descriptor->sub_descriptors_refs)
return -1;
url_fskip(pb, 4);
get_buffer(pb, (uint8_t *)descriptor->sub_descriptors_refs, descriptor->sub_descriptors_count * sizeof(UID));
break;
case 0x3004:
get_buffer(pb, descriptor->essence_container_ul, 16);
break;
case 0x3006:
descriptor->linked_track_id = get_be32(pb);
break;
case 0x3201:
get_buffer(pb, descriptor->essence_codec_ul, 16);
break;
case 0x3203:
descriptor->width = get_be32(pb);
break;
case 0x3202:
descriptor->height = get_be32(pb);
break;
case 0x320E:
descriptor->aspect_ratio.num = get_be32(pb);
descriptor->aspect_ratio.den = get_be32(pb);
break;
case 0x3D03:
descriptor->sample_rate.num = get_be32(pb);
descriptor->sample_rate.den = get_be32(pb);
break;
case 0x3D06:
get_buffer(pb, descriptor->essence_codec_ul, 16);
break;
case 0x3D07:
descriptor->channels = get_be32(pb);
break;
case 0x3D01:
descriptor->bits_per_sample = get_be32(pb);
break;
case 0x3401:
mxf_read_pixel_layout(pb, descriptor);
break;
default:
if (IS_KLV_KEY(uid, mxf_sony_mpeg4_extradata)) {
descriptor->extradata = av_malloc(size);
if (!descriptor->extradata)
return -1;
descriptor->extradata_size = size;
get_buffer(pb, descriptor->extradata, size);
}
break;
}
return 0;
}
| {
"code": [
"static int mxf_read_generic_descriptor(MXFDescriptor *descriptor, ByteIOContext *pb, int tag, int size, UID uid)"
],
"line_no": [
1
]
} | static int FUNC_0(MXFDescriptor *VAR_0, ByteIOContext *VAR_1, int VAR_2, int VAR_3, UID VAR_4)
{
switch(VAR_2) {
case 0x3F01:
VAR_0->sub_descriptors_count = get_be32(VAR_1);
if (VAR_0->sub_descriptors_count >= UINT_MAX / sizeof(UID))
return -1;
VAR_0->sub_descriptors_refs = av_malloc(VAR_0->sub_descriptors_count * sizeof(UID));
if (!VAR_0->sub_descriptors_refs)
return -1;
url_fskip(VAR_1, 4);
get_buffer(VAR_1, (uint8_t *)VAR_0->sub_descriptors_refs, VAR_0->sub_descriptors_count * sizeof(UID));
break;
case 0x3004:
get_buffer(VAR_1, VAR_0->essence_container_ul, 16);
break;
case 0x3006:
VAR_0->linked_track_id = get_be32(VAR_1);
break;
case 0x3201:
get_buffer(VAR_1, VAR_0->essence_codec_ul, 16);
break;
case 0x3203:
VAR_0->width = get_be32(VAR_1);
break;
case 0x3202:
VAR_0->height = get_be32(VAR_1);
break;
case 0x320E:
VAR_0->aspect_ratio.num = get_be32(VAR_1);
VAR_0->aspect_ratio.den = get_be32(VAR_1);
break;
case 0x3D03:
VAR_0->sample_rate.num = get_be32(VAR_1);
VAR_0->sample_rate.den = get_be32(VAR_1);
break;
case 0x3D06:
get_buffer(VAR_1, VAR_0->essence_codec_ul, 16);
break;
case 0x3D07:
VAR_0->channels = get_be32(VAR_1);
break;
case 0x3D01:
VAR_0->bits_per_sample = get_be32(VAR_1);
break;
case 0x3401:
mxf_read_pixel_layout(VAR_1, VAR_0);
break;
default:
if (IS_KLV_KEY(VAR_4, mxf_sony_mpeg4_extradata)) {
VAR_0->extradata = av_malloc(VAR_3);
if (!VAR_0->extradata)
return -1;
VAR_0->extradata_size = VAR_3;
get_buffer(VAR_1, VAR_0->extradata, VAR_3);
}
break;
}
return 0;
}
| [
"static int FUNC_0(MXFDescriptor *VAR_0, ByteIOContext *VAR_1, int VAR_2, int VAR_3, UID VAR_4)\n{",
"switch(VAR_2) {",
"case 0x3F01:\nVAR_0->sub_descriptors_count = get_be32(VAR_1);",
"if (VAR_0->sub_descriptors_count >= UINT_MAX / sizeof(UID))\nreturn -1;",
"VAR_0->sub_descriptors_refs = av_malloc(VAR_0->... | [
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7,
9
],
[
11,
13
],
[
15
],
[
17,
19
],
[
21
],
[
23
],
[
25
],
[
27,
29
],
[
31
],
[
33,
35
],
[
37
],
[
39,
41
],
[
43
],
[
45,
47
],
[... |
2,021 | static void spapr_vio_busdev_realize(DeviceState *qdev, Error **errp)
{
sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
VIOsPAPRDevice *dev = (VIOsPAPRDevice *)qdev;
VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev);
char *id;
if (dev->reg != -1) {
/*
* Explicitly assigned address, just verify that no-one else
* is using it. other mechanism). We have to open code this
* rather than using spapr_vio_find_by_reg() because sdev
* itself is already in the list.
*/
VIOsPAPRDevice *other = reg_conflict(dev);
if (other) {
error_setg(errp, "%s and %s devices conflict at address %#x",
object_get_typename(OBJECT(qdev)),
object_get_typename(OBJECT(&other->qdev)),
dev->reg);
return;
}
} else {
/* Need to assign an address */
VIOsPAPRBus *bus = SPAPR_VIO_BUS(dev->qdev.parent_bus);
do {
dev->reg = bus->next_reg++;
} while (reg_conflict(dev));
}
/* Don't overwrite ids assigned on the command line */
if (!dev->qdev.id) {
id = spapr_vio_get_dev_name(DEVICE(dev));
dev->qdev.id = id;
}
dev->irq = xics_alloc(spapr->icp, 0, dev->irq, false);
if (!dev->irq) {
error_setg(errp, "can't allocate IRQ");
return;
}
if (pc->rtce_window_size) {
uint32_t liobn = SPAPR_VIO_LIOBN(dev->reg);
memory_region_init(&dev->mrroot, OBJECT(dev), "iommu-spapr-root",
ram_size);
memory_region_init_alias(&dev->mrbypass, OBJECT(dev),
"iommu-spapr-bypass", get_system_memory(),
0, ram_size);
memory_region_add_subregion_overlap(&dev->mrroot, 0, &dev->mrbypass, 1);
address_space_init(&dev->as, &dev->mrroot, qdev->id);
dev->tcet = spapr_tce_new_table(qdev, liobn,
0,
SPAPR_TCE_PAGE_SHIFT,
pc->rtce_window_size >>
SPAPR_TCE_PAGE_SHIFT, false);
dev->tcet->vdev = dev;
memory_region_add_subregion_overlap(&dev->mrroot, 0,
spapr_tce_get_iommu(dev->tcet), 2);
}
pc->realize(dev, errp);
}
| true | qemu | a005b3ef50439b5bc6b2eb0b5bda8e8c7c2368bf | static void spapr_vio_busdev_realize(DeviceState *qdev, Error **errp)
{
sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
VIOsPAPRDevice *dev = (VIOsPAPRDevice *)qdev;
VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev);
char *id;
if (dev->reg != -1) {
VIOsPAPRDevice *other = reg_conflict(dev);
if (other) {
error_setg(errp, "%s and %s devices conflict at address %#x",
object_get_typename(OBJECT(qdev)),
object_get_typename(OBJECT(&other->qdev)),
dev->reg);
return;
}
} else {
VIOsPAPRBus *bus = SPAPR_VIO_BUS(dev->qdev.parent_bus);
do {
dev->reg = bus->next_reg++;
} while (reg_conflict(dev));
}
if (!dev->qdev.id) {
id = spapr_vio_get_dev_name(DEVICE(dev));
dev->qdev.id = id;
}
dev->irq = xics_alloc(spapr->icp, 0, dev->irq, false);
if (!dev->irq) {
error_setg(errp, "can't allocate IRQ");
return;
}
if (pc->rtce_window_size) {
uint32_t liobn = SPAPR_VIO_LIOBN(dev->reg);
memory_region_init(&dev->mrroot, OBJECT(dev), "iommu-spapr-root",
ram_size);
memory_region_init_alias(&dev->mrbypass, OBJECT(dev),
"iommu-spapr-bypass", get_system_memory(),
0, ram_size);
memory_region_add_subregion_overlap(&dev->mrroot, 0, &dev->mrbypass, 1);
address_space_init(&dev->as, &dev->mrroot, qdev->id);
dev->tcet = spapr_tce_new_table(qdev, liobn,
0,
SPAPR_TCE_PAGE_SHIFT,
pc->rtce_window_size >>
SPAPR_TCE_PAGE_SHIFT, false);
dev->tcet->vdev = dev;
memory_region_add_subregion_overlap(&dev->mrroot, 0,
spapr_tce_get_iommu(dev->tcet), 2);
}
pc->realize(dev, errp);
}
| {
"code": [
" dev->irq = xics_alloc(spapr->icp, 0, dev->irq, false);",
" if (!dev->irq) {",
" error_setg(errp, \"can't allocate IRQ\");"
],
"line_no": [
77,
79,
81
]
} | static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)
{
sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
VIOsPAPRDevice *dev = (VIOsPAPRDevice *)VAR_0;
VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev);
char *VAR_2;
if (dev->reg != -1) {
VIOsPAPRDevice *other = reg_conflict(dev);
if (other) {
error_setg(VAR_1, "%s and %s devices conflict at address %#x",
object_get_typename(OBJECT(VAR_0)),
object_get_typename(OBJECT(&other->VAR_0)),
dev->reg);
return;
}
} else {
VIOsPAPRBus *bus = SPAPR_VIO_BUS(dev->VAR_0.parent_bus);
do {
dev->reg = bus->next_reg++;
} while (reg_conflict(dev));
}
if (!dev->VAR_0.VAR_2) {
VAR_2 = spapr_vio_get_dev_name(DEVICE(dev));
dev->VAR_0.VAR_2 = VAR_2;
}
dev->irq = xics_alloc(spapr->icp, 0, dev->irq, false);
if (!dev->irq) {
error_setg(VAR_1, "can't allocate IRQ");
return;
}
if (pc->rtce_window_size) {
uint32_t liobn = SPAPR_VIO_LIOBN(dev->reg);
memory_region_init(&dev->mrroot, OBJECT(dev), "iommu-spapr-root",
ram_size);
memory_region_init_alias(&dev->mrbypass, OBJECT(dev),
"iommu-spapr-bypass", get_system_memory(),
0, ram_size);
memory_region_add_subregion_overlap(&dev->mrroot, 0, &dev->mrbypass, 1);
address_space_init(&dev->as, &dev->mrroot, VAR_0->VAR_2);
dev->tcet = spapr_tce_new_table(VAR_0, liobn,
0,
SPAPR_TCE_PAGE_SHIFT,
pc->rtce_window_size >>
SPAPR_TCE_PAGE_SHIFT, false);
dev->tcet->vdev = dev;
memory_region_add_subregion_overlap(&dev->mrroot, 0,
spapr_tce_get_iommu(dev->tcet), 2);
}
pc->realize(dev, VAR_1);
}
| [
"static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)\n{",
"sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());",
"VIOsPAPRDevice *dev = (VIOsPAPRDevice *)VAR_0;",
"VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev);",
"char *VAR_2;",
"if (dev->reg != -1) {",
"VIOsPAPRDevice *other = r... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
29
],
[
33
],
[
35,
37,
39,
41
],
[
43
],
[
45
],
[
47
],
[
51
],
[
55
],
[
57
],
[
59
],
[
61
],
[
67
],
[... |
2,022 | static int tta_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
TTAContext *s = avctx->priv_data;
int i, ret;
int cur_chan = 0, framelen = s->frame_length;
int32_t *p;
init_get_bits(&s->gb, buf, buf_size*8);
// FIXME: seeking
s->total_frames--;
if (!s->total_frames && s->last_frame_length)
framelen = s->last_frame_length;
/* get output buffer */
s->frame.nb_samples = framelen;
if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
// decode directly to output buffer for 24-bit sample format
if (s->bps == 3)
s->decode_buffer = (int32_t *)s->frame.data[0];
// init per channel states
for (i = 0; i < s->channels; i++) {
s->ch_ctx[i].predictor = 0;
ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]);
rice_init(&s->ch_ctx[i].rice, 10, 10);
}
for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
TTARice *rice = &s->ch_ctx[cur_chan].rice;
uint32_t unary, depth, k;
int32_t value;
unary = tta_get_unary(&s->gb);
if (unary == 0) {
depth = 0;
k = rice->k0;
} else {
depth = 1;
k = rice->k1;
unary--;
}
if (get_bits_left(&s->gb) < k)
return -1;
if (k) {
if (k > MIN_CACHE_BITS)
return -1;
value = (unary << k) + get_bits(&s->gb, k);
} else
value = unary;
// FIXME: copy paste from original
switch (depth) {
case 1:
rice->sum1 += value - (rice->sum1 >> 4);
if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
rice->k1--;
else if(rice->sum1 > shift_16[rice->k1 + 1])
rice->k1++;
value += shift_1[rice->k0];
default:
rice->sum0 += value - (rice->sum0 >> 4);
if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
rice->k0--;
else if(rice->sum0 > shift_16[rice->k0 + 1])
rice->k0++;
}
// extract coded value
#define UNFOLD(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1))
*p = UNFOLD(value);
// run hybrid filter
ttafilter_process(filter, p, 0);
// fixed order prediction
#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
switch (s->bps) {
case 1: *p += PRED(*predictor, 4); break;
case 2:
case 3: *p += PRED(*predictor, 5); break;
case 4: *p += *predictor; break;
}
*predictor = *p;
// flip channels
if (cur_chan < (s->channels-1))
cur_chan++;
else {
// decorrelate in case of stereo integer
if (s->channels > 1) {
int32_t *r = p - 1;
for (*p += *r / 2; r > p - s->channels; r--)
*r = *(r + 1) - *r;
}
cur_chan = 0;
}
}
if (get_bits_left(&s->gb) < 32)
return -1;
skip_bits_long(&s->gb, 32); // frame crc
// convert to output buffer
if (s->bps == 2) {
int16_t *samples = (int16_t *)s->frame.data[0];
for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
*samples++ = *p;
} else {
// shift samples for 24-bit sample format
int32_t *samples = (int32_t *)s->frame.data[0];
for (i = 0; i < framelen * s->channels; i++)
*samples++ <<= 8;
// reset decode buffer
s->decode_buffer = NULL;
}
*got_frame_ptr = 1;
*(AVFrame *)data = s->frame;
return buf_size;
}
| true | FFmpeg | 6ab681a4c1ffc0d5c36ebf13a10e0ecc61c81429 | static int tta_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
TTAContext *s = avctx->priv_data;
int i, ret;
int cur_chan = 0, framelen = s->frame_length;
int32_t *p;
init_get_bits(&s->gb, buf, buf_size*8);
s->total_frames--;
if (!s->total_frames && s->last_frame_length)
framelen = s->last_frame_length;
s->frame.nb_samples = framelen;
if ((ret = avctx->get_buffer(avctx, &s->frame)) < 0) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return ret;
}
if (s->bps == 3)
s->decode_buffer = (int32_t *)s->frame.data[0];
for (i = 0; i < s->channels; i++) {
s->ch_ctx[i].predictor = 0;
ttafilter_init(&s->ch_ctx[i].filter, ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]);
rice_init(&s->ch_ctx[i].rice, 10, 10);
}
for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++) {
int32_t *predictor = &s->ch_ctx[cur_chan].predictor;
TTAFilter *filter = &s->ch_ctx[cur_chan].filter;
TTARice *rice = &s->ch_ctx[cur_chan].rice;
uint32_t unary, depth, k;
int32_t value;
unary = tta_get_unary(&s->gb);
if (unary == 0) {
depth = 0;
k = rice->k0;
} else {
depth = 1;
k = rice->k1;
unary--;
}
if (get_bits_left(&s->gb) < k)
return -1;
if (k) {
if (k > MIN_CACHE_BITS)
return -1;
value = (unary << k) + get_bits(&s->gb, k);
} else
value = unary;
switch (depth) {
case 1:
rice->sum1 += value - (rice->sum1 >> 4);
if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
rice->k1--;
else if(rice->sum1 > shift_16[rice->k1 + 1])
rice->k1++;
value += shift_1[rice->k0];
default:
rice->sum0 += value - (rice->sum0 >> 4);
if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
rice->k0--;
else if(rice->sum0 > shift_16[rice->k0 + 1])
rice->k0++;
}
#define UNFOLD(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1))
*p = UNFOLD(value);
ttafilter_process(filter, p, 0);
#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
switch (s->bps) {
case 1: *p += PRED(*predictor, 4); break;
case 2:
case 3: *p += PRED(*predictor, 5); break;
case 4: *p += *predictor; break;
}
*predictor = *p;
if (cur_chan < (s->channels-1))
cur_chan++;
else {
if (s->channels > 1) {
int32_t *r = p - 1;
for (*p += *r / 2; r > p - s->channels; r--)
*r = *(r + 1) - *r;
}
cur_chan = 0;
}
}
if (get_bits_left(&s->gb) < 32)
return -1;
skip_bits_long(&s->gb, 32);
if (s->bps == 2) {
int16_t *samples = (int16_t *)s->frame.data[0];
for (p = s->decode_buffer; p < s->decode_buffer + (framelen * s->channels); p++)
*samples++ = *p;
} else {
int32_t *samples = (int32_t *)s->frame.data[0];
for (i = 0; i < framelen * s->channels; i++)
*samples++ <<= 8;
s->decode_buffer = NULL;
}
*got_frame_ptr = 1;
*(AVFrame *)data = s->frame;
return buf_size;
}
| {
"code": [
" if (get_bits_left(&s->gb) < k)",
" return -1;",
" if (k > MIN_CACHE_BITS)",
" return -1;",
" if (get_bits_left(&s->gb) < 32)",
" return -1;"
],
"line_no": [
107,
109,
115,
117,
223,
225
]
} | static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,
int *VAR_2, AVPacket *VAR_3)
{
const uint8_t *VAR_4 = VAR_3->VAR_1;
int VAR_5 = VAR_3->size;
TTAContext *s = VAR_0->priv_data;
int VAR_6, VAR_7;
int VAR_8 = 0, VAR_9 = s->frame_length;
int32_t *p;
init_get_bits(&s->gb, VAR_4, VAR_5*8);
s->total_frames--;
if (!s->total_frames && s->last_frame_length)
VAR_9 = s->last_frame_length;
s->frame.nb_samples = VAR_9;
if ((VAR_7 = VAR_0->get_buffer(VAR_0, &s->frame)) < 0) {
av_log(VAR_0, AV_LOG_ERROR, "get_buffer() failed\n");
return VAR_7;
}
if (s->bps == 3)
s->decode_buffer = (int32_t *)s->frame.VAR_1[0];
for (VAR_6 = 0; VAR_6 < s->channels; VAR_6++) {
s->ch_ctx[VAR_6].predictor = 0;
ttafilter_init(&s->ch_ctx[VAR_6].filter, ttafilter_configs[s->bps-1][0], ttafilter_configs[s->bps-1][1]);
rice_init(&s->ch_ctx[VAR_6].rice, 10, 10);
}
for (p = s->decode_buffer; p < s->decode_buffer + (VAR_9 * s->channels); p++) {
int32_t *predictor = &s->ch_ctx[VAR_8].predictor;
TTAFilter *filter = &s->ch_ctx[VAR_8].filter;
TTARice *rice = &s->ch_ctx[VAR_8].rice;
uint32_t unary, depth, k;
int32_t value;
unary = tta_get_unary(&s->gb);
if (unary == 0) {
depth = 0;
k = rice->k0;
} else {
depth = 1;
k = rice->k1;
unary--;
}
if (get_bits_left(&s->gb) < k)
return -1;
if (k) {
if (k > MIN_CACHE_BITS)
return -1;
value = (unary << k) + get_bits(&s->gb, k);
} else
value = unary;
switch (depth) {
case 1:
rice->sum1 += value - (rice->sum1 >> 4);
if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])
rice->k1--;
else if(rice->sum1 > shift_16[rice->k1 + 1])
rice->k1++;
value += shift_1[rice->k0];
default:
rice->sum0 += value - (rice->sum0 >> 4);
if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])
rice->k0--;
else if(rice->sum0 > shift_16[rice->k0 + 1])
rice->k0++;
}
#define UNFOLD(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1))
*p = UNFOLD(value);
ttafilter_process(filter, p, 0);
#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)
switch (s->bps) {
case 1: *p += PRED(*predictor, 4); break;
case 2:
case 3: *p += PRED(*predictor, 5); break;
case 4: *p += *predictor; break;
}
*predictor = *p;
if (VAR_8 < (s->channels-1))
VAR_8++;
else {
if (s->channels > 1) {
int32_t *r = p - 1;
for (*p += *r / 2; r > p - s->channels; r--)
*r = *(r + 1) - *r;
}
VAR_8 = 0;
}
}
if (get_bits_left(&s->gb) < 32)
return -1;
skip_bits_long(&s->gb, 32);
if (s->bps == 2) {
int16_t *samples = (int16_t *)s->frame.VAR_1[0];
for (p = s->decode_buffer; p < s->decode_buffer + (VAR_9 * s->channels); p++)
*samples++ = *p;
} else {
int32_t *samples = (int32_t *)s->frame.VAR_1[0];
for (VAR_6 = 0; VAR_6 < VAR_9 * s->channels; VAR_6++)
*samples++ <<= 8;
s->decode_buffer = NULL;
}
*VAR_2 = 1;
*(AVFrame *)VAR_1 = s->frame;
return VAR_5;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,\nint *VAR_2, AVPacket *VAR_3)\n{",
"const uint8_t *VAR_4 = VAR_3->VAR_1;",
"int VAR_5 = VAR_3->size;",
"TTAContext *s = VAR_0->priv_data;",
"int VAR_6, VAR_7;",
"int VAR_8 = 0, VAR_9 = s->frame_length;",
"int32_t *p;",
"init_get_bits(&s->gb, VAR_4... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
27
],
[
29,
31
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
51,
53
],
[
59
],
[
61
],
[... |
2,023 | uint32_t virtio_config_readl(VirtIODevice *vdev, uint32_t addr)
{
VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
uint32_t val;
k->get_config(vdev, vdev->config);
if (addr > (vdev->config_len - sizeof(val)))
return (uint32_t)-1;
val = ldl_p(vdev->config + addr);
return val;
}
| true | qemu | 5f5a1318653c08e435cfa52f60b6a712815b659d | uint32_t virtio_config_readl(VirtIODevice *vdev, uint32_t addr)
{
VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
uint32_t val;
k->get_config(vdev, vdev->config);
if (addr > (vdev->config_len - sizeof(val)))
return (uint32_t)-1;
val = ldl_p(vdev->config + addr);
return val;
}
| {
"code": [
" k->get_config(vdev, vdev->config);",
" if (addr > (vdev->config_len - sizeof(val)))",
" k->get_config(vdev, vdev->config);",
" if (addr > (vdev->config_len - sizeof(val)))",
" k->get_config(vdev, vdev->config);",
" if (addr > (vdev->config_len - sizeof(val)))",
" if (addr > (vdev->config_len - sizeof(val)))",
" if (addr > (vdev->config_len - sizeof(val)))",
" if (addr > (vdev->config_len - sizeof(val)))"
],
"line_no": [
11,
15,
11,
15,
11,
15,
15,
15,
15
]
} | uint32_t FUNC_0(VirtIODevice *vdev, uint32_t addr)
{
VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);
uint32_t val;
k->get_config(vdev, vdev->config);
if (addr > (vdev->config_len - sizeof(val)))
return (uint32_t)-1;
val = ldl_p(vdev->config + addr);
return val;
}
| [
"uint32_t FUNC_0(VirtIODevice *vdev, uint32_t addr)\n{",
"VirtioDeviceClass *k = VIRTIO_DEVICE_GET_CLASS(vdev);",
"uint32_t val;",
"k->get_config(vdev, vdev->config);",
"if (addr > (vdev->config_len - sizeof(val)))\nreturn (uint32_t)-1;",
"val = ldl_p(vdev->config + addr);",
"return val;",
"}"
] | [
0,
0,
0,
1,
1,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
15,
17
],
[
21
],
[
23
],
[
25
]
] |
2,024 | static uint8_t *disas_insn(DisasContext *s, uint8_t *pc_start)
{
int b, prefixes, aflag, dflag;
int shift, ot;
int modrm, reg, rm, mod, reg_addr, op, opreg, offset_addr, val;
unsigned int next_eip;
s->pc = pc_start;
prefixes = 0;
aflag = s->code32;
dflag = s->code32;
s->override = -1;
next_byte:
b = ldub_code(s->pc);
s->pc++;
/* check prefixes */
switch (b) {
case 0xf3:
prefixes |= PREFIX_REPZ;
goto next_byte;
case 0xf2:
prefixes |= PREFIX_REPNZ;
goto next_byte;
case 0xf0:
prefixes |= PREFIX_LOCK;
goto next_byte;
case 0x2e:
s->override = R_CS;
goto next_byte;
case 0x36:
s->override = R_SS;
goto next_byte;
case 0x3e:
s->override = R_DS;
goto next_byte;
case 0x26:
s->override = R_ES;
goto next_byte;
case 0x64:
s->override = R_FS;
goto next_byte;
case 0x65:
s->override = R_GS;
goto next_byte;
case 0x66:
prefixes |= PREFIX_DATA;
goto next_byte;
case 0x67:
prefixes |= PREFIX_ADR;
goto next_byte;
}
if (prefixes & PREFIX_DATA)
dflag ^= 1;
if (prefixes & PREFIX_ADR)
aflag ^= 1;
s->prefix = prefixes;
s->aflag = aflag;
s->dflag = dflag;
/* lock generation */
if (prefixes & PREFIX_LOCK)
gen_op_lock();
/* now check op code */
reswitch:
switch(b) {
case 0x0f:
/**************************/
/* extended op code */
b = ldub_code(s->pc++) | 0x100;
goto reswitch;
/**************************/
/* arith & logic */
case 0x00 ... 0x05:
case 0x08 ... 0x0d:
case 0x10 ... 0x15:
case 0x18 ... 0x1d:
case 0x20 ... 0x25:
case 0x28 ... 0x2d:
case 0x30 ... 0x35:
case 0x38 ... 0x3d:
{
int op, f, val;
op = (b >> 3) & 7;
f = (b >> 1) & 3;
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
switch(f) {
case 0: /* OP Ev, Gv */
modrm = ldub_code(s->pc++);
reg = ((modrm >> 3) & 7);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
opreg = OR_TMP0;
} else if (op == OP_XORL && rm == reg) {
xor_zero:
/* xor reg, reg optimisation */
gen_op_movl_T0_0();
s->cc_op = CC_OP_LOGICB + ot;
gen_op_mov_reg_T0[ot][reg]();
gen_op_update1_cc();
break;
} else {
opreg = rm;
}
gen_op_mov_TN_reg[ot][1][reg]();
gen_op(s, op, ot, opreg);
break;
case 1: /* OP Gv, Ev */
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
reg = ((modrm >> 3) & 7);
rm = modrm & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T1_A0[ot + s->mem_index]();
} else if (op == OP_XORL && rm == reg) {
goto xor_zero;
} else {
gen_op_mov_TN_reg[ot][1][rm]();
}
gen_op(s, op, ot, reg);
break;
case 2: /* OP A, Iv */
val = insn_get(s, ot);
gen_op_movl_T1_im(val);
gen_op(s, op, ot, OR_EAX);
break;
}
}
break;
case 0x80: /* GRP1 */
case 0x81:
case 0x82:
case 0x83:
{
int val;
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = (modrm >> 3) & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
opreg = OR_TMP0;
} else {
opreg = rm + OR_EAX;
}
switch(b) {
default:
case 0x80:
case 0x81:
case 0x82:
val = insn_get(s, ot);
break;
case 0x83:
val = (int8_t)insn_get(s, OT_BYTE);
break;
}
gen_op_movl_T1_im(val);
gen_op(s, op, ot, opreg);
}
break;
/**************************/
/* inc, dec, and other misc arith */
case 0x40 ... 0x47: /* inc Gv */
ot = dflag ? OT_LONG : OT_WORD;
gen_inc(s, ot, OR_EAX + (b & 7), 1);
break;
case 0x48 ... 0x4f: /* dec Gv */
ot = dflag ? OT_LONG : OT_WORD;
gen_inc(s, ot, OR_EAX + (b & 7), -1);
break;
case 0xf6: /* GRP3 */
case 0xf7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = (modrm >> 3) & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
switch(op) {
case 0: /* test */
val = insn_get(s, ot);
gen_op_movl_T1_im(val);
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + ot;
break;
case 2: /* not */
gen_op_notl_T0();
if (mod != 3) {
gen_op_st_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_reg_T0[ot][rm]();
}
break;
case 3: /* neg */
gen_op_negl_T0();
if (mod != 3) {
gen_op_st_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_reg_T0[ot][rm]();
}
gen_op_update_neg_cc();
s->cc_op = CC_OP_SUBB + ot;
break;
case 4: /* mul */
switch(ot) {
case OT_BYTE:
gen_op_mulb_AL_T0();
s->cc_op = CC_OP_MULB;
break;
case OT_WORD:
gen_op_mulw_AX_T0();
s->cc_op = CC_OP_MULW;
break;
default:
case OT_LONG:
gen_op_mull_EAX_T0();
s->cc_op = CC_OP_MULL;
break;
}
break;
case 5: /* imul */
switch(ot) {
case OT_BYTE:
gen_op_imulb_AL_T0();
s->cc_op = CC_OP_MULB;
break;
case OT_WORD:
gen_op_imulw_AX_T0();
s->cc_op = CC_OP_MULW;
break;
default:
case OT_LONG:
gen_op_imull_EAX_T0();
s->cc_op = CC_OP_MULL;
break;
}
break;
case 6: /* div */
switch(ot) {
case OT_BYTE:
gen_op_divb_AL_T0(pc_start - s->cs_base);
break;
case OT_WORD:
gen_op_divw_AX_T0(pc_start - s->cs_base);
break;
default:
case OT_LONG:
gen_op_divl_EAX_T0(pc_start - s->cs_base);
break;
}
break;
case 7: /* idiv */
switch(ot) {
case OT_BYTE:
gen_op_idivb_AL_T0(pc_start - s->cs_base);
break;
case OT_WORD:
gen_op_idivw_AX_T0(pc_start - s->cs_base);
break;
default:
case OT_LONG:
gen_op_idivl_EAX_T0(pc_start - s->cs_base);
break;
}
break;
default:
goto illegal_op;
}
break;
case 0xfe: /* GRP4 */
case 0xff: /* GRP5 */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = (modrm >> 3) & 7;
if (op >= 2 && b == 0xfe) {
goto illegal_op;
}
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (op >= 2 && op != 3 && op != 5)
gen_op_ld_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
switch(op) {
case 0: /* inc Ev */
if (mod != 3)
opreg = OR_TMP0;
else
opreg = rm;
gen_inc(s, ot, opreg, 1);
break;
case 1: /* dec Ev */
if (mod != 3)
opreg = OR_TMP0;
else
opreg = rm;
gen_inc(s, ot, opreg, -1);
break;
case 2: /* call Ev */
/* XXX: optimize if memory (no 'and' is necessary) */
if (s->dflag == 0)
gen_op_andl_T0_ffff();
next_eip = s->pc - s->cs_base;
gen_op_movl_T1_im(next_eip);
gen_push_T1(s);
gen_op_jmp_T0();
gen_eob(s);
break;
case 3: /* lcall Ev */
gen_op_ld_T1_A0[ot + s->mem_index]();
gen_op_addl_A0_im(1 << (ot - OT_WORD + 1));
gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
do_lcall:
if (s->pe && !s->vm86) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_lcall_protected_T0_T1(dflag, s->pc - s->cs_base);
} else {
gen_op_lcall_real_T0_T1(dflag, s->pc - s->cs_base);
}
gen_eob(s);
break;
case 4: /* jmp Ev */
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_eob(s);
break;
case 5: /* ljmp Ev */
gen_op_ld_T1_A0[ot + s->mem_index]();
gen_op_addl_A0_im(1 << (ot - OT_WORD + 1));
gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
do_ljmp:
if (s->pe && !s->vm86) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_ljmp_protected_T0_T1(s->pc - s->cs_base);
} else {
gen_op_movl_seg_T0_vm(offsetof(CPUX86State,segs[R_CS]));
gen_op_movl_T0_T1();
gen_op_jmp_T0();
}
gen_eob(s);
break;
case 6: /* push Ev */
gen_push_T0(s);
break;
default:
goto illegal_op;
}
break;
case 0x84: /* test Ev, Gv */
case 0x85:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_mov_TN_reg[ot][1][reg + OR_EAX]();
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + ot;
break;
case 0xa8: /* test eAX, Iv */
case 0xa9:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
gen_op_mov_TN_reg[ot][0][OR_EAX]();
gen_op_movl_T1_im(val);
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + ot;
break;
case 0x98: /* CWDE/CBW */
if (dflag)
gen_op_movswl_EAX_AX();
else
gen_op_movsbw_AX_AL();
break;
case 0x99: /* CDQ/CWD */
if (dflag)
gen_op_movslq_EDX_EAX();
else
gen_op_movswl_DX_AX();
break;
case 0x1af: /* imul Gv, Ev */
case 0x69: /* imul Gv, Ev, I */
case 0x6b:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = ((modrm >> 3) & 7) + OR_EAX;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
if (b == 0x69) {
val = insn_get(s, ot);
gen_op_movl_T1_im(val);
} else if (b == 0x6b) {
val = (int8_t)insn_get(s, OT_BYTE);
gen_op_movl_T1_im(val);
} else {
gen_op_mov_TN_reg[ot][1][reg]();
}
if (ot == OT_LONG) {
gen_op_imull_T0_T1();
} else {
gen_op_imulw_T0_T1();
}
gen_op_mov_reg_T0[ot][reg]();
s->cc_op = CC_OP_MULB + ot;
break;
case 0x1c0:
case 0x1c1: /* xadd Ev, Gv */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (mod == 3) {
rm = modrm & 7;
gen_op_mov_TN_reg[ot][0][reg]();
gen_op_mov_TN_reg[ot][1][rm]();
gen_op_addl_T0_T1();
gen_op_mov_reg_T1[ot][reg]();
gen_op_mov_reg_T0[ot][rm]();
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_mov_TN_reg[ot][0][reg]();
gen_op_ld_T1_A0[ot + s->mem_index]();
gen_op_addl_T0_T1();
gen_op_st_T0_A0[ot + s->mem_index]();
gen_op_mov_reg_T1[ot][reg]();
}
gen_op_update2_cc();
s->cc_op = CC_OP_ADDB + ot;
break;
case 0x1b0:
case 0x1b1: /* cmpxchg Ev, Gv */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
gen_op_mov_TN_reg[ot][1][reg]();
if (mod == 3) {
rm = modrm & 7;
gen_op_mov_TN_reg[ot][0][rm]();
gen_op_cmpxchg_T0_T1_EAX_cc[ot]();
gen_op_mov_reg_T0[ot][rm]();
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot + s->mem_index]();
gen_op_cmpxchg_mem_T0_T1_EAX_cc[ot + s->mem_index]();
}
s->cc_op = CC_OP_SUBB + ot;
break;
case 0x1c7: /* cmpxchg8b */
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_cmpxchg8b();
s->cc_op = CC_OP_EFLAGS;
break;
/**************************/
/* push/pop */
case 0x50 ... 0x57: /* push */
gen_op_mov_TN_reg[OT_LONG][0][b & 7]();
gen_push_T0(s);
break;
case 0x58 ... 0x5f: /* pop */
ot = dflag ? OT_LONG : OT_WORD;
gen_pop_T0(s);
/* NOTE: order is important for pop %sp */
gen_pop_update(s);
gen_op_mov_reg_T0[ot][b & 7]();
break;
case 0x60: /* pusha */
gen_pusha(s);
break;
case 0x61: /* popa */
gen_popa(s);
break;
case 0x68: /* push Iv */
case 0x6a:
ot = dflag ? OT_LONG : OT_WORD;
if (b == 0x68)
val = insn_get(s, ot);
else
val = (int8_t)insn_get(s, OT_BYTE);
gen_op_movl_T0_im(val);
gen_push_T0(s);
break;
case 0x8f: /* pop Ev */
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
gen_pop_T0(s);
if (mod == 3) {
/* NOTE: order is important for pop %sp */
gen_pop_update(s);
rm = modrm & 7;
gen_op_mov_reg_T0[ot][rm]();
} else {
/* NOTE: order is important too for MMU exceptions */
s->popl_esp_hack = 2 << dflag;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
s->popl_esp_hack = 0;
gen_pop_update(s);
}
break;
case 0xc8: /* enter */
{
int level;
val = lduw_code(s->pc);
s->pc += 2;
level = ldub_code(s->pc++);
gen_enter(s, val, level);
}
break;
case 0xc9: /* leave */
/* XXX: exception not precise (ESP is updated before potential exception) */
if (s->ss32) {
gen_op_mov_TN_reg[OT_LONG][0][R_EBP]();
gen_op_mov_reg_T0[OT_LONG][R_ESP]();
} else {
gen_op_mov_TN_reg[OT_WORD][0][R_EBP]();
gen_op_mov_reg_T0[OT_WORD][R_ESP]();
}
gen_pop_T0(s);
ot = dflag ? OT_LONG : OT_WORD;
gen_op_mov_reg_T0[ot][R_EBP]();
gen_pop_update(s);
break;
case 0x06: /* push es */
case 0x0e: /* push cs */
case 0x16: /* push ss */
case 0x1e: /* push ds */
gen_op_movl_T0_seg(b >> 3);
gen_push_T0(s);
break;
case 0x1a0: /* push fs */
case 0x1a8: /* push gs */
gen_op_movl_T0_seg((b >> 3) & 7);
gen_push_T0(s);
break;
case 0x07: /* pop es */
case 0x17: /* pop ss */
case 0x1f: /* pop ds */
reg = b >> 3;
gen_pop_T0(s);
gen_movl_seg_T0(s, reg, pc_start - s->cs_base);
gen_pop_update(s);
if (reg == R_SS) {
/* if reg == SS, inhibit interrupts/trace. */
/* If several instructions disable interrupts, only the
_first_ does it */
if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
gen_op_set_inhibit_irq();
s->tf = 0;
}
if (s->is_jmp) {
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x1a1: /* pop fs */
case 0x1a9: /* pop gs */
gen_pop_T0(s);
gen_movl_seg_T0(s, (b >> 3) & 7, pc_start - s->cs_base);
gen_pop_update(s);
if (s->is_jmp) {
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
/**************************/
/* mov */
case 0x88:
case 0x89: /* mov Gv, Ev */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
/* generate a generic store */
gen_ldst_modrm(s, modrm, ot, OR_EAX + reg, 1);
break;
case 0xc6:
case 0xc7: /* mov Ev, Iv */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
if (mod != 3)
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
val = insn_get(s, ot);
gen_op_movl_T0_im(val);
if (mod != 3)
gen_op_st_T0_A0[ot + s->mem_index]();
else
gen_op_mov_reg_T0[ot][modrm & 7]();
break;
case 0x8a:
case 0x8b: /* mov Ev, Gv */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_mov_reg_T0[ot][reg]();
break;
case 0x8e: /* mov seg, Gv */
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
if (reg >= 6 || reg == R_CS)
goto illegal_op;
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
gen_movl_seg_T0(s, reg, pc_start - s->cs_base);
if (reg == R_SS) {
/* if reg == SS, inhibit interrupts/trace */
/* If several instructions disable interrupts, only the
_first_ does it */
if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
gen_op_set_inhibit_irq();
s->tf = 0;
}
if (s->is_jmp) {
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x8c: /* mov Gv, seg */
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (reg >= 6)
goto illegal_op;
gen_op_movl_T0_seg(reg);
ot = OT_WORD;
if (mod == 3 && dflag)
ot = OT_LONG;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
break;
case 0x1b6: /* movzbS Gv, Eb */
case 0x1b7: /* movzwS Gv, Eb */
case 0x1be: /* movsbS Gv, Eb */
case 0x1bf: /* movswS Gv, Eb */
{
int d_ot;
/* d_ot is the size of destination */
d_ot = dflag + OT_WORD;
/* ot is the size of source */
ot = (b & 1) + OT_BYTE;
modrm = ldub_code(s->pc++);
reg = ((modrm >> 3) & 7) + OR_EAX;
mod = (modrm >> 6) & 3;
rm = modrm & 7;
if (mod == 3) {
gen_op_mov_TN_reg[ot][0][rm]();
switch(ot | (b & 8)) {
case OT_BYTE:
gen_op_movzbl_T0_T0();
break;
case OT_BYTE | 8:
gen_op_movsbl_T0_T0();
break;
case OT_WORD:
gen_op_movzwl_T0_T0();
break;
default:
case OT_WORD | 8:
gen_op_movswl_T0_T0();
break;
}
gen_op_mov_reg_T0[d_ot][reg]();
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (b & 8) {
gen_op_lds_T0_A0[ot + s->mem_index]();
} else {
gen_op_ldu_T0_A0[ot + s->mem_index]();
}
gen_op_mov_reg_T0[d_ot][reg]();
}
}
break;
case 0x8d: /* lea */
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
reg = (modrm >> 3) & 7;
/* we must ensure that no segment is added */
s->override = -1;
val = s->addseg;
s->addseg = 0;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
s->addseg = val;
gen_op_mov_reg_A0[ot - OT_WORD][reg]();
break;
case 0xa0: /* mov EAX, Ov */
case 0xa1:
case 0xa2: /* mov Ov, EAX */
case 0xa3:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (s->aflag)
offset_addr = insn_get(s, OT_LONG);
else
offset_addr = insn_get(s, OT_WORD);
gen_op_movl_A0_im(offset_addr);
/* handle override */
{
int override, must_add_seg;
must_add_seg = s->addseg;
if (s->override >= 0) {
override = s->override;
must_add_seg = 1;
} else {
override = R_DS;
}
if (must_add_seg) {
gen_op_addl_A0_seg(offsetof(CPUX86State,segs[override].base));
}
}
if ((b & 2) == 0) {
gen_op_ld_T0_A0[ot + s->mem_index]();
gen_op_mov_reg_T0[ot][R_EAX]();
} else {
gen_op_mov_TN_reg[ot][0][R_EAX]();
gen_op_st_T0_A0[ot + s->mem_index]();
}
break;
case 0xd7: /* xlat */
gen_op_movl_A0_reg[R_EBX]();
gen_op_addl_A0_AL();
if (s->aflag == 0)
gen_op_andl_A0_ffff();
/* handle override */
{
int override, must_add_seg;
must_add_seg = s->addseg;
override = R_DS;
if (s->override >= 0) {
override = s->override;
must_add_seg = 1;
} else {
override = R_DS;
}
if (must_add_seg) {
gen_op_addl_A0_seg(offsetof(CPUX86State,segs[override].base));
}
}
gen_op_ldu_T0_A0[OT_BYTE + s->mem_index]();
gen_op_mov_reg_T0[OT_BYTE][R_EAX]();
break;
case 0xb0 ... 0xb7: /* mov R, Ib */
val = insn_get(s, OT_BYTE);
gen_op_movl_T0_im(val);
gen_op_mov_reg_T0[OT_BYTE][b & 7]();
break;
case 0xb8 ... 0xbf: /* mov R, Iv */
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
reg = OR_EAX + (b & 7);
gen_op_movl_T0_im(val);
gen_op_mov_reg_T0[ot][reg]();
break;
case 0x91 ... 0x97: /* xchg R, EAX */
ot = dflag ? OT_LONG : OT_WORD;
reg = b & 7;
rm = R_EAX;
goto do_xchg_reg;
case 0x86:
case 0x87: /* xchg Ev, Gv */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (mod == 3) {
rm = modrm & 7;
do_xchg_reg:
gen_op_mov_TN_reg[ot][0][reg]();
gen_op_mov_TN_reg[ot][1][rm]();
gen_op_mov_reg_T0[ot][rm]();
gen_op_mov_reg_T1[ot][reg]();
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_mov_TN_reg[ot][0][reg]();
/* for xchg, lock is implicit */
if (!(prefixes & PREFIX_LOCK))
gen_op_lock();
gen_op_ld_T1_A0[ot + s->mem_index]();
gen_op_st_T0_A0[ot + s->mem_index]();
if (!(prefixes & PREFIX_LOCK))
gen_op_unlock();
gen_op_mov_reg_T1[ot][reg]();
}
break;
case 0xc4: /* les Gv */
op = R_ES;
goto do_lxx;
case 0xc5: /* lds Gv */
op = R_DS;
goto do_lxx;
case 0x1b2: /* lss Gv */
op = R_SS;
goto do_lxx;
case 0x1b4: /* lfs Gv */
op = R_FS;
goto do_lxx;
case 0x1b5: /* lgs Gv */
op = R_GS;
do_lxx:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T1_A0[ot + s->mem_index]();
gen_op_addl_A0_im(1 << (ot - OT_WORD + 1));
/* load the segment first to handle exceptions properly */
gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
gen_movl_seg_T0(s, op, pc_start - s->cs_base);
/* then put the data */
gen_op_mov_reg_T1[ot][reg]();
if (s->is_jmp) {
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
/************************/
/* shifts */
case 0xc0:
case 0xc1:
/* shift Ev,Ib */
shift = 2;
grp2:
{
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = (modrm >> 3) & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
opreg = OR_TMP0;
} else {
opreg = rm + OR_EAX;
}
/* simpler op */
if (shift == 0) {
gen_shift(s, op, ot, opreg, OR_ECX);
} else {
if (shift == 2) {
shift = ldub_code(s->pc++);
}
gen_shifti(s, op, ot, opreg, shift);
}
}
break;
case 0xd0:
case 0xd1:
/* shift Ev,1 */
shift = 1;
goto grp2;
case 0xd2:
case 0xd3:
/* shift Ev,cl */
shift = 0;
goto grp2;
case 0x1a4: /* shld imm */
op = 0;
shift = 1;
goto do_shiftd;
case 0x1a5: /* shld cl */
op = 0;
shift = 0;
goto do_shiftd;
case 0x1ac: /* shrd imm */
op = 1;
shift = 1;
goto do_shiftd;
case 0x1ad: /* shrd cl */
op = 1;
shift = 0;
do_shiftd:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
reg = (modrm >> 3) & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
gen_op_mov_TN_reg[ot][1][reg]();
if (shift) {
val = ldub_code(s->pc++);
val &= 0x1f;
if (val) {
if (mod == 3)
gen_op_shiftd_T0_T1_im_cc[ot][op](val);
else
gen_op_shiftd_mem_T0_T1_im_cc[ot + s->mem_index][op](val);
if (op == 0 && ot != OT_WORD)
s->cc_op = CC_OP_SHLB + ot;
else
s->cc_op = CC_OP_SARB + ot;
}
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
if (mod == 3)
gen_op_shiftd_T0_T1_ECX_cc[ot][op]();
else
gen_op_shiftd_mem_T0_T1_ECX_cc[ot + s->mem_index][op]();
s->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */
}
if (mod == 3) {
gen_op_mov_reg_T0[ot][rm]();
}
break;
/************************/
/* floats */
case 0xd8 ... 0xdf:
if (s->flags & (HF_EM_MASK | HF_TS_MASK)) {
/* if CR0.EM or CR0.TS are set, generate an FPU exception */
/* XXX: what to do if illegal op ? */
gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
break;
}
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = ((b & 7) << 3) | ((modrm >> 3) & 7);
if (mod != 3) {
/* memory op */
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
switch(op) {
case 0x00 ... 0x07: /* fxxxs */
case 0x10 ... 0x17: /* fixxxl */
case 0x20 ... 0x27: /* fxxxl */
case 0x30 ... 0x37: /* fixxx */
{
int op1;
op1 = op & 7;
switch(op >> 4) {
case 0:
gen_op_flds_FT0_A0();
break;
case 1:
gen_op_fildl_FT0_A0();
break;
case 2:
gen_op_fldl_FT0_A0();
break;
case 3:
default:
gen_op_fild_FT0_A0();
break;
}
gen_op_fp_arith_ST0_FT0[op1]();
if (op1 == 3) {
/* fcomp needs pop */
gen_op_fpop();
}
}
break;
case 0x08: /* flds */
case 0x0a: /* fsts */
case 0x0b: /* fstps */
case 0x18: /* fildl */
case 0x1a: /* fistl */
case 0x1b: /* fistpl */
case 0x28: /* fldl */
case 0x2a: /* fstl */
case 0x2b: /* fstpl */
case 0x38: /* filds */
case 0x3a: /* fists */
case 0x3b: /* fistps */
switch(op & 7) {
case 0:
switch(op >> 4) {
case 0:
gen_op_flds_ST0_A0();
break;
case 1:
gen_op_fildl_ST0_A0();
break;
case 2:
gen_op_fldl_ST0_A0();
break;
case 3:
default:
gen_op_fild_ST0_A0();
break;
}
break;
default:
switch(op >> 4) {
case 0:
gen_op_fsts_ST0_A0();
break;
case 1:
gen_op_fistl_ST0_A0();
break;
case 2:
gen_op_fstl_ST0_A0();
break;
case 3:
default:
gen_op_fist_ST0_A0();
break;
}
if ((op & 7) == 3)
gen_op_fpop();
break;
}
break;
case 0x0c: /* fldenv mem */
gen_op_fldenv_A0(s->dflag);
break;
case 0x0d: /* fldcw mem */
gen_op_fldcw_A0();
break;
case 0x0e: /* fnstenv mem */
gen_op_fnstenv_A0(s->dflag);
break;
case 0x0f: /* fnstcw mem */
gen_op_fnstcw_A0();
break;
case 0x1d: /* fldt mem */
gen_op_fldt_ST0_A0();
break;
case 0x1f: /* fstpt mem */
gen_op_fstt_ST0_A0();
gen_op_fpop();
break;
case 0x2c: /* frstor mem */
gen_op_frstor_A0(s->dflag);
break;
case 0x2e: /* fnsave mem */
gen_op_fnsave_A0(s->dflag);
break;
case 0x2f: /* fnstsw mem */
gen_op_fnstsw_A0();
break;
case 0x3c: /* fbld */
gen_op_fbld_ST0_A0();
break;
case 0x3e: /* fbstp */
gen_op_fbst_ST0_A0();
gen_op_fpop();
break;
case 0x3d: /* fildll */
gen_op_fildll_ST0_A0();
break;
case 0x3f: /* fistpll */
gen_op_fistll_ST0_A0();
gen_op_fpop();
break;
default:
goto illegal_op;
}
} else {
/* register float ops */
opreg = rm;
switch(op) {
case 0x08: /* fld sti */
gen_op_fpush();
gen_op_fmov_ST0_STN((opreg + 1) & 7);
break;
case 0x09: /* fxchg sti */
gen_op_fxchg_ST0_STN(opreg);
break;
case 0x0a: /* grp d9/2 */
switch(rm) {
case 0: /* fnop */
break;
default:
goto illegal_op;
}
break;
case 0x0c: /* grp d9/4 */
switch(rm) {
case 0: /* fchs */
gen_op_fchs_ST0();
break;
case 1: /* fabs */
gen_op_fabs_ST0();
break;
case 4: /* ftst */
gen_op_fldz_FT0();
gen_op_fcom_ST0_FT0();
break;
case 5: /* fxam */
gen_op_fxam_ST0();
break;
default:
goto illegal_op;
}
break;
case 0x0d: /* grp d9/5 */
{
switch(rm) {
case 0:
gen_op_fpush();
gen_op_fld1_ST0();
break;
case 1:
gen_op_fpush();
gen_op_fldl2t_ST0();
break;
case 2:
gen_op_fpush();
gen_op_fldl2e_ST0();
break;
case 3:
gen_op_fpush();
gen_op_fldpi_ST0();
break;
case 4:
gen_op_fpush();
gen_op_fldlg2_ST0();
break;
case 5:
gen_op_fpush();
gen_op_fldln2_ST0();
break;
case 6:
gen_op_fpush();
gen_op_fldz_ST0();
break;
default:
goto illegal_op;
}
}
break;
case 0x0e: /* grp d9/6 */
switch(rm) {
case 0: /* f2xm1 */
gen_op_f2xm1();
break;
case 1: /* fyl2x */
gen_op_fyl2x();
break;
case 2: /* fptan */
gen_op_fptan();
break;
case 3: /* fpatan */
gen_op_fpatan();
break;
case 4: /* fxtract */
gen_op_fxtract();
break;
case 5: /* fprem1 */
gen_op_fprem1();
break;
case 6: /* fdecstp */
gen_op_fdecstp();
break;
default:
case 7: /* fincstp */
gen_op_fincstp();
break;
}
break;
case 0x0f: /* grp d9/7 */
switch(rm) {
case 0: /* fprem */
gen_op_fprem();
break;
case 1: /* fyl2xp1 */
gen_op_fyl2xp1();
break;
case 2: /* fsqrt */
gen_op_fsqrt();
break;
case 3: /* fsincos */
gen_op_fsincos();
break;
case 5: /* fscale */
gen_op_fscale();
break;
case 4: /* frndint */
gen_op_frndint();
break;
case 6: /* fsin */
gen_op_fsin();
break;
default:
case 7: /* fcos */
gen_op_fcos();
break;
}
break;
case 0x00: case 0x01: case 0x04 ... 0x07: /* fxxx st, sti */
case 0x20: case 0x21: case 0x24 ... 0x27: /* fxxx sti, st */
case 0x30: case 0x31: case 0x34 ... 0x37: /* fxxxp sti, st */
{
int op1;
op1 = op & 7;
if (op >= 0x20) {
gen_op_fp_arith_STN_ST0[op1](opreg);
if (op >= 0x30)
gen_op_fpop();
} else {
gen_op_fmov_FT0_STN(opreg);
gen_op_fp_arith_ST0_FT0[op1]();
}
}
break;
case 0x02: /* fcom */
gen_op_fmov_FT0_STN(opreg);
gen_op_fcom_ST0_FT0();
break;
case 0x03: /* fcomp */
gen_op_fmov_FT0_STN(opreg);
gen_op_fcom_ST0_FT0();
gen_op_fpop();
break;
case 0x15: /* da/5 */
switch(rm) {
case 1: /* fucompp */
gen_op_fmov_FT0_STN(1);
gen_op_fucom_ST0_FT0();
gen_op_fpop();
gen_op_fpop();
break;
default:
goto illegal_op;
}
break;
case 0x1c:
switch(rm) {
case 0: /* feni (287 only, just do nop here) */
break;
case 1: /* fdisi (287 only, just do nop here) */
break;
case 2: /* fclex */
gen_op_fclex();
break;
case 3: /* fninit */
gen_op_fninit();
break;
case 4: /* fsetpm (287 only, just do nop here) */
break;
default:
goto illegal_op;
}
break;
case 0x1d: /* fucomi */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_fmov_FT0_STN(opreg);
gen_op_fucomi_ST0_FT0();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x1e: /* fcomi */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_fmov_FT0_STN(opreg);
gen_op_fcomi_ST0_FT0();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x2a: /* fst sti */
gen_op_fmov_STN_ST0(opreg);
break;
case 0x2b: /* fstp sti */
gen_op_fmov_STN_ST0(opreg);
gen_op_fpop();
break;
case 0x2c: /* fucom st(i) */
gen_op_fmov_FT0_STN(opreg);
gen_op_fucom_ST0_FT0();
break;
case 0x2d: /* fucomp st(i) */
gen_op_fmov_FT0_STN(opreg);
gen_op_fucom_ST0_FT0();
gen_op_fpop();
break;
case 0x33: /* de/3 */
switch(rm) {
case 1: /* fcompp */
gen_op_fmov_FT0_STN(1);
gen_op_fcom_ST0_FT0();
gen_op_fpop();
gen_op_fpop();
break;
default:
goto illegal_op;
}
break;
case 0x3c: /* df/4 */
switch(rm) {
case 0:
gen_op_fnstsw_EAX();
break;
default:
goto illegal_op;
}
break;
case 0x3d: /* fucomip */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_fmov_FT0_STN(opreg);
gen_op_fucomi_ST0_FT0();
gen_op_fpop();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x3e: /* fcomip */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_fmov_FT0_STN(opreg);
gen_op_fcomi_ST0_FT0();
gen_op_fpop();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x10 ... 0x13: /* fcmovxx */
case 0x18 ... 0x1b:
{
int op1;
const static uint8_t fcmov_cc[8] = {
(JCC_B << 1),
(JCC_Z << 1),
(JCC_BE << 1),
(JCC_P << 1),
};
op1 = fcmov_cc[op & 3] | ((op >> 3) & 1);
gen_setcc(s, op1);
gen_op_fcmov_ST0_STN_T0(opreg);
}
break;
default:
goto illegal_op;
}
}
#ifdef USE_CODE_COPY
s->tb->cflags |= CF_TB_FP_USED;
#endif
break;
/************************/
/* string ops */
case 0xa4: /* movsS */
case 0xa5:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
gen_repz_movs(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
} else {
gen_movs(s, ot);
}
break;
case 0xaa: /* stosS */
case 0xab:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
gen_repz_stos(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
} else {
gen_stos(s, ot);
}
break;
case 0xac: /* lodsS */
case 0xad:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
gen_repz_lods(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
} else {
gen_lods(s, ot);
}
break;
case 0xae: /* scasS */
case 0xaf:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPNZ) {
gen_repz_scas(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 1);
} else if (prefixes & PREFIX_REPZ) {
gen_repz_scas(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 0);
} else {
gen_scas(s, ot);
s->cc_op = CC_OP_SUBB + ot;
}
break;
case 0xa6: /* cmpsS */
case 0xa7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPNZ) {
gen_repz_cmps(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 1);
} else if (prefixes & PREFIX_REPZ) {
gen_repz_cmps(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 0);
} else {
gen_cmps(s, ot);
s->cc_op = CC_OP_SUBB + ot;
}
break;
case 0x6c: /* insS */
case 0x6d:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
gen_check_io(s, ot, 1, pc_start - s->cs_base);
if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
gen_repz_ins(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
} else {
gen_ins(s, ot);
}
break;
case 0x6e: /* outsS */
case 0x6f:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
gen_check_io(s, ot, 1, pc_start - s->cs_base);
if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
gen_repz_outs(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
} else {
gen_outs(s, ot);
}
break;
/************************/
/* port I/O */
case 0xe4:
case 0xe5:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
val = ldub_code(s->pc++);
gen_op_movl_T0_im(val);
gen_check_io(s, ot, 0, pc_start - s->cs_base);
gen_op_in[ot]();
gen_op_mov_reg_T1[ot][R_EAX]();
break;
case 0xe6:
case 0xe7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
val = ldub_code(s->pc++);
gen_op_movl_T0_im(val);
gen_check_io(s, ot, 0, pc_start - s->cs_base);
gen_op_mov_TN_reg[ot][1][R_EAX]();
gen_op_out[ot]();
break;
case 0xec:
case 0xed:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
gen_op_andl_T0_ffff();
gen_check_io(s, ot, 0, pc_start - s->cs_base);
gen_op_in[ot]();
gen_op_mov_reg_T1[ot][R_EAX]();
break;
case 0xee:
case 0xef:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
gen_op_andl_T0_ffff();
gen_check_io(s, ot, 0, pc_start - s->cs_base);
gen_op_mov_TN_reg[ot][1][R_EAX]();
gen_op_out[ot]();
break;
/************************/
/* control */
case 0xc2: /* ret im */
val = ldsw_code(s->pc);
s->pc += 2;
gen_pop_T0(s);
gen_stack_update(s, val + (2 << s->dflag));
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_eob(s);
break;
case 0xc3: /* ret */
gen_pop_T0(s);
gen_pop_update(s);
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_eob(s);
break;
case 0xca: /* lret im */
val = ldsw_code(s->pc);
s->pc += 2;
do_lret:
if (s->pe && !s->vm86) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_lret_protected(s->dflag, val);
} else {
gen_stack_A0(s);
/* pop offset */
gen_op_ld_T0_A0[1 + s->dflag + s->mem_index]();
if (s->dflag == 0)
gen_op_andl_T0_ffff();
/* NOTE: keeping EIP updated is not a problem in case of
exception */
gen_op_jmp_T0();
/* pop selector */
gen_op_addl_A0_im(2 << s->dflag);
gen_op_ld_T0_A0[1 + s->dflag + s->mem_index]();
gen_op_movl_seg_T0_vm(offsetof(CPUX86State,segs[R_CS]));
/* add stack offset */
gen_stack_update(s, val + (4 << s->dflag));
}
gen_eob(s);
break;
case 0xcb: /* lret */
val = 0;
goto do_lret;
case 0xcf: /* iret */
if (!s->pe) {
/* real mode */
gen_op_iret_real(s->dflag);
s->cc_op = CC_OP_EFLAGS;
} else if (s->vm86) {
if (s->iopl != 3) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_op_iret_real(s->dflag);
s->cc_op = CC_OP_EFLAGS;
}
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_iret_protected(s->dflag, s->pc - s->cs_base);
s->cc_op = CC_OP_EFLAGS;
}
gen_eob(s);
break;
case 0xe8: /* call im */
{
unsigned int next_eip;
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
next_eip = s->pc - s->cs_base;
val += next_eip;
if (s->dflag == 0)
val &= 0xffff;
gen_op_movl_T0_im(next_eip);
gen_push_T0(s);
gen_jmp(s, val);
}
break;
case 0x9a: /* lcall im */
{
unsigned int selector, offset;
ot = dflag ? OT_LONG : OT_WORD;
offset = insn_get(s, ot);
selector = insn_get(s, OT_WORD);
gen_op_movl_T0_im(selector);
gen_op_movl_T1_im(offset);
}
goto do_lcall;
case 0xe9: /* jmp */
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
val += s->pc - s->cs_base;
if (s->dflag == 0)
val = val & 0xffff;
gen_jmp(s, val);
break;
case 0xea: /* ljmp im */
{
unsigned int selector, offset;
ot = dflag ? OT_LONG : OT_WORD;
offset = insn_get(s, ot);
selector = insn_get(s, OT_WORD);
gen_op_movl_T0_im(selector);
gen_op_movl_T1_im(offset);
}
goto do_ljmp;
case 0xeb: /* jmp Jb */
val = (int8_t)insn_get(s, OT_BYTE);
val += s->pc - s->cs_base;
if (s->dflag == 0)
val = val & 0xffff;
gen_jmp(s, val);
break;
case 0x70 ... 0x7f: /* jcc Jb */
val = (int8_t)insn_get(s, OT_BYTE);
goto do_jcc;
case 0x180 ... 0x18f: /* jcc Jv */
if (dflag) {
val = insn_get(s, OT_LONG);
} else {
val = (int16_t)insn_get(s, OT_WORD);
}
do_jcc:
next_eip = s->pc - s->cs_base;
val += next_eip;
if (s->dflag == 0)
val &= 0xffff;
gen_jcc(s, b, val, next_eip);
break;
case 0x190 ... 0x19f: /* setcc Gv */
modrm = ldub_code(s->pc++);
gen_setcc(s, b);
gen_ldst_modrm(s, modrm, OT_BYTE, OR_TMP0, 1);
break;
case 0x140 ... 0x14f: /* cmov Gv, Ev */
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
gen_setcc(s, b);
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T1_A0[ot + s->mem_index]();
} else {
rm = modrm & 7;
gen_op_mov_TN_reg[ot][1][rm]();
}
gen_op_cmov_reg_T1_T0[ot - OT_WORD][reg]();
break;
/************************/
/* flags */
case 0x9c: /* pushf */
if (s->vm86 && s->iopl != 3) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_movl_T0_eflags();
gen_push_T0(s);
}
break;
case 0x9d: /* popf */
if (s->vm86 && s->iopl != 3) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_pop_T0(s);
if (s->cpl == 0) {
if (s->dflag) {
gen_op_movl_eflags_T0_cpl0();
} else {
gen_op_movw_eflags_T0_cpl0();
}
} else {
if (s->cpl <= s->iopl) {
if (s->dflag) {
gen_op_movl_eflags_T0_io();
} else {
gen_op_movw_eflags_T0_io();
}
} else {
if (s->dflag) {
gen_op_movl_eflags_T0();
} else {
gen_op_movw_eflags_T0();
}
}
}
gen_pop_update(s);
s->cc_op = CC_OP_EFLAGS;
/* abort translation because TF flag may change */
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x9e: /* sahf */
gen_op_mov_TN_reg[OT_BYTE][0][R_AH]();
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_movb_eflags_T0();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x9f: /* lahf */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_movl_T0_eflags();
gen_op_mov_reg_T0[OT_BYTE][R_AH]();
break;
case 0xf5: /* cmc */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_cmc();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xf8: /* clc */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_clc();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xf9: /* stc */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_stc();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xfc: /* cld */
gen_op_cld();
break;
case 0xfd: /* std */
gen_op_std();
break;
/************************/
/* bit operations */
case 0x1ba: /* bt/bts/btr/btc Gv, im */
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
op = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
rm = modrm & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
/* load shift */
val = ldub_code(s->pc++);
gen_op_movl_T1_im(val);
if (op < 4)
goto illegal_op;
op -= 4;
gen_op_btx_T0_T1_cc[ot - OT_WORD][op]();
s->cc_op = CC_OP_SARB + ot;
if (op != 0) {
if (mod != 3)
gen_op_st_T0_A0[ot + s->mem_index]();
else
gen_op_mov_reg_T0[ot][rm]();
gen_op_update_bt_cc();
}
break;
case 0x1a3: /* bt Gv, Ev */
op = 0;
goto do_btx;
case 0x1ab: /* bts */
op = 1;
goto do_btx;
case 0x1b3: /* btr */
op = 2;
goto do_btx;
case 0x1bb: /* btc */
op = 3;
do_btx:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
rm = modrm & 7;
gen_op_mov_TN_reg[OT_LONG][1][reg]();
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
/* specific case: we need to add a displacement */
if (ot == OT_WORD)
gen_op_add_bitw_A0_T1();
else
gen_op_add_bitl_A0_T1();
gen_op_ld_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
gen_op_btx_T0_T1_cc[ot - OT_WORD][op]();
s->cc_op = CC_OP_SARB + ot;
if (op != 0) {
if (mod != 3)
gen_op_st_T0_A0[ot + s->mem_index]();
else
gen_op_mov_reg_T0[ot][rm]();
gen_op_update_bt_cc();
}
break;
case 0x1bc: /* bsf */
case 0x1bd: /* bsr */
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_bsx_T0_cc[ot - OT_WORD][b & 1]();
/* NOTE: we always write back the result. Intel doc says it is
undefined if T0 == 0 */
gen_op_mov_reg_T0[ot][reg]();
s->cc_op = CC_OP_LOGICB + ot;
break;
/************************/
/* bcd */
case 0x27: /* daa */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_daa();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x2f: /* das */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_das();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x37: /* aaa */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_aaa();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x3f: /* aas */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_aas();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xd4: /* aam */
val = ldub_code(s->pc++);
gen_op_aam(val);
s->cc_op = CC_OP_LOGICB;
break;
case 0xd5: /* aad */
val = ldub_code(s->pc++);
gen_op_aad(val);
s->cc_op = CC_OP_LOGICB;
break;
/************************/
/* misc */
case 0x90: /* nop */
/* XXX: correct lock test for all insn */
if (prefixes & PREFIX_LOCK)
goto illegal_op;
break;
case 0x9b: /* fwait */
if ((s->flags & (HF_MP_MASK | HF_TS_MASK)) ==
(HF_MP_MASK | HF_TS_MASK)) {
gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_fwait();
}
break;
case 0xcc: /* int3 */
gen_interrupt(s, EXCP03_INT3, pc_start - s->cs_base, s->pc - s->cs_base);
break;
case 0xcd: /* int N */
val = ldub_code(s->pc++);
if (s->vm86 && s->iopl != 3) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_interrupt(s, val, pc_start - s->cs_base, s->pc - s->cs_base);
}
break;
case 0xce: /* into */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_into(s->pc - s->cs_base);
break;
case 0xf1: /* icebp (undocumented, exits to external debugger) */
gen_debug(s, pc_start - s->cs_base);
break;
case 0xfa: /* cli */
if (!s->vm86) {
if (s->cpl <= s->iopl) {
gen_op_cli();
} else {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
}
} else {
if (s->iopl == 3) {
gen_op_cli();
} else {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
}
}
break;
case 0xfb: /* sti */
if (!s->vm86) {
if (s->cpl <= s->iopl) {
gen_sti:
gen_op_sti();
/* interruptions are enabled only the first insn after sti */
/* If several instructions disable interrupts, only the
_first_ does it */
if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
gen_op_set_inhibit_irq();
/* give a chance to handle pending irqs */
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
} else {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
}
} else {
if (s->iopl == 3) {
goto gen_sti;
} else {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
}
}
break;
case 0x62: /* bound */
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
gen_op_mov_reg_T0[ot][reg]();
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (ot == OT_WORD)
gen_op_boundw(pc_start - s->cs_base);
else
gen_op_boundl(pc_start - s->cs_base);
break;
case 0x1c8 ... 0x1cf: /* bswap reg */
reg = b & 7;
gen_op_mov_TN_reg[OT_LONG][0][reg]();
gen_op_bswapl_T0();
gen_op_mov_reg_T0[OT_LONG][reg]();
break;
case 0xd6: /* salc */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_salc();
break;
case 0xe0: /* loopnz */
case 0xe1: /* loopz */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
/* FALL THRU */
case 0xe2: /* loop */
case 0xe3: /* jecxz */
val = (int8_t)insn_get(s, OT_BYTE);
next_eip = s->pc - s->cs_base;
val += next_eip;
if (s->dflag == 0)
val &= 0xffff;
gen_op_loop[s->aflag][b & 3](val, next_eip);
gen_eob(s);
break;
case 0x130: /* wrmsr */
case 0x132: /* rdmsr */
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
if (b & 2)
gen_op_rdmsr();
else
gen_op_wrmsr();
}
break;
case 0x131: /* rdtsc */
gen_op_rdtsc();
break;
case 0x1a2: /* cpuid */
gen_op_cpuid();
break;
case 0xf4: /* hlt */
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(s->pc - s->cs_base);
gen_op_hlt();
s->is_jmp = 3;
}
break;
case 0x100:
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7;
switch(op) {
case 0: /* sldt */
if (!s->pe || s->vm86)
goto illegal_op;
gen_op_movl_T0_env(offsetof(CPUX86State,ldt.selector));
ot = OT_WORD;
if (mod == 3)
ot += s->dflag;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
break;
case 2: /* lldt */
if (!s->pe || s->vm86)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_lldt_T0();
}
break;
case 1: /* str */
if (!s->pe || s->vm86)
goto illegal_op;
gen_op_movl_T0_env(offsetof(CPUX86State,tr.selector));
ot = OT_WORD;
if (mod == 3)
ot += s->dflag;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
break;
case 3: /* ltr */
if (!s->pe || s->vm86)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_ltr_T0();
}
break;
case 4: /* verr */
case 5: /* verw */
if (!s->pe || s->vm86)
goto illegal_op;
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
if (op == 4)
gen_op_verr();
else
gen_op_verw();
s->cc_op = CC_OP_EFLAGS;
break;
default:
goto illegal_op;
}
break;
case 0x101:
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7;
switch(op) {
case 0: /* sgdt */
case 1: /* sidt */
if (mod == 3)
goto illegal_op;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (op == 0)
gen_op_movl_T0_env(offsetof(CPUX86State,gdt.limit));
else
gen_op_movl_T0_env(offsetof(CPUX86State,idt.limit));
gen_op_st_T0_A0[OT_WORD + s->mem_index]();
gen_op_addl_A0_im(2);
if (op == 0)
gen_op_movl_T0_env(offsetof(CPUX86State,gdt.base));
else
gen_op_movl_T0_env(offsetof(CPUX86State,idt.base));
if (!s->dflag)
gen_op_andl_T0_im(0xffffff);
gen_op_st_T0_A0[OT_LONG + s->mem_index]();
break;
case 2: /* lgdt */
case 3: /* lidt */
if (mod == 3)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T1_A0[OT_WORD + s->mem_index]();
gen_op_addl_A0_im(2);
gen_op_ld_T0_A0[OT_LONG + s->mem_index]();
if (!s->dflag)
gen_op_andl_T0_im(0xffffff);
if (op == 2) {
gen_op_movl_env_T0(offsetof(CPUX86State,gdt.base));
gen_op_movl_env_T1(offsetof(CPUX86State,gdt.limit));
} else {
gen_op_movl_env_T0(offsetof(CPUX86State,idt.base));
gen_op_movl_env_T1(offsetof(CPUX86State,idt.limit));
}
}
break;
case 4: /* smsw */
gen_op_movl_T0_env(offsetof(CPUX86State,cr[0]));
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 1);
break;
case 6: /* lmsw */
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
gen_op_lmsw_T0();
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 7: /* invlpg */
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
if (mod == 3)
goto illegal_op;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_invlpg_A0();
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
default:
goto illegal_op;
}
break;
case 0x108: /* invd */
case 0x109: /* wbinvd */
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
/* nothing to do */
}
break;
case 0x63: /* arpl */
if (!s->pe || s->vm86)
goto illegal_op;
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
rm = modrm & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_arpl();
s->cc_op = CC_OP_EFLAGS;
if (mod != 3) {
gen_op_st_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_reg_T0[ot][rm]();
}
gen_op_arpl_update();
break;
case 0x102: /* lar */
case 0x103: /* lsl */
if (!s->pe || s->vm86)
goto illegal_op;
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_mov_TN_reg[ot][1][reg]();
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
if (b == 0x102)
gen_op_lar();
else
gen_op_lsl();
s->cc_op = CC_OP_EFLAGS;
gen_op_mov_reg_T1[ot][reg]();
break;
case 0x118:
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7;
switch(op) {
case 0: /* prefetchnta */
case 1: /* prefetchnt0 */
case 2: /* prefetchnt0 */
case 3: /* prefetchnt0 */
if (mod == 3)
goto illegal_op;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
/* nothing more to do */
break;
default:
goto illegal_op;
}
break;
case 0x120: /* mov reg, crN */
case 0x122: /* mov crN, reg */
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
modrm = ldub_code(s->pc++);
if ((modrm & 0xc0) != 0xc0)
goto illegal_op;
rm = modrm & 7;
reg = (modrm >> 3) & 7;
switch(reg) {
case 0:
case 2:
case 3:
case 4:
if (b & 2) {
gen_op_mov_TN_reg[OT_LONG][0][rm]();
gen_op_movl_crN_T0(reg);
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
} else {
gen_op_movl_T0_env(offsetof(CPUX86State,cr[reg]));
gen_op_mov_reg_T0[OT_LONG][rm]();
}
break;
default:
goto illegal_op;
}
}
break;
case 0x121: /* mov reg, drN */
case 0x123: /* mov drN, reg */
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
modrm = ldub_code(s->pc++);
if ((modrm & 0xc0) != 0xc0)
goto illegal_op;
rm = modrm & 7;
reg = (modrm >> 3) & 7;
/* XXX: do it dynamically with CR4.DE bit */
if (reg == 4 || reg == 5)
goto illegal_op;
if (b & 2) {
gen_op_mov_TN_reg[OT_LONG][0][rm]();
gen_op_movl_drN_T0(reg);
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
} else {
gen_op_movl_T0_env(offsetof(CPUX86State,dr[reg]));
gen_op_mov_reg_T0[OT_LONG][rm]();
}
}
break;
case 0x106: /* clts */
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_op_clts();
/* abort block because static cpu state changed */
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
default:
goto illegal_op;
}
/* lock generation */
if (s->prefix & PREFIX_LOCK)
gen_op_unlock();
return s->pc;
illegal_op:
if (s->prefix & PREFIX_LOCK)
gen_op_unlock();
/* XXX: ensure that no lock was generated */
gen_exception(s, EXCP06_ILLOP, pc_start - s->cs_base);
return s->pc;
}
| true | qemu | 686f3f266b829b06c7b170db7b4ce97abfbfc517 | static uint8_t *disas_insn(DisasContext *s, uint8_t *pc_start)
{
int b, prefixes, aflag, dflag;
int shift, ot;
int modrm, reg, rm, mod, reg_addr, op, opreg, offset_addr, val;
unsigned int next_eip;
s->pc = pc_start;
prefixes = 0;
aflag = s->code32;
dflag = s->code32;
s->override = -1;
next_byte:
b = ldub_code(s->pc);
s->pc++;
switch (b) {
case 0xf3:
prefixes |= PREFIX_REPZ;
goto next_byte;
case 0xf2:
prefixes |= PREFIX_REPNZ;
goto next_byte;
case 0xf0:
prefixes |= PREFIX_LOCK;
goto next_byte;
case 0x2e:
s->override = R_CS;
goto next_byte;
case 0x36:
s->override = R_SS;
goto next_byte;
case 0x3e:
s->override = R_DS;
goto next_byte;
case 0x26:
s->override = R_ES;
goto next_byte;
case 0x64:
s->override = R_FS;
goto next_byte;
case 0x65:
s->override = R_GS;
goto next_byte;
case 0x66:
prefixes |= PREFIX_DATA;
goto next_byte;
case 0x67:
prefixes |= PREFIX_ADR;
goto next_byte;
}
if (prefixes & PREFIX_DATA)
dflag ^= 1;
if (prefixes & PREFIX_ADR)
aflag ^= 1;
s->prefix = prefixes;
s->aflag = aflag;
s->dflag = dflag;
if (prefixes & PREFIX_LOCK)
gen_op_lock();
reswitch:
switch(b) {
case 0x0f:
b = ldub_code(s->pc++) | 0x100;
goto reswitch;
case 0x00 ... 0x05:
case 0x08 ... 0x0d:
case 0x10 ... 0x15:
case 0x18 ... 0x1d:
case 0x20 ... 0x25:
case 0x28 ... 0x2d:
case 0x30 ... 0x35:
case 0x38 ... 0x3d:
{
int op, f, val;
op = (b >> 3) & 7;
f = (b >> 1) & 3;
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
switch(f) {
case 0:
modrm = ldub_code(s->pc++);
reg = ((modrm >> 3) & 7);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
opreg = OR_TMP0;
} else if (op == OP_XORL && rm == reg) {
xor_zero:
gen_op_movl_T0_0();
s->cc_op = CC_OP_LOGICB + ot;
gen_op_mov_reg_T0[ot][reg]();
gen_op_update1_cc();
break;
} else {
opreg = rm;
}
gen_op_mov_TN_reg[ot][1][reg]();
gen_op(s, op, ot, opreg);
break;
case 1:
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
reg = ((modrm >> 3) & 7);
rm = modrm & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T1_A0[ot + s->mem_index]();
} else if (op == OP_XORL && rm == reg) {
goto xor_zero;
} else {
gen_op_mov_TN_reg[ot][1][rm]();
}
gen_op(s, op, ot, reg);
break;
case 2:
val = insn_get(s, ot);
gen_op_movl_T1_im(val);
gen_op(s, op, ot, OR_EAX);
break;
}
}
break;
case 0x80:
case 0x81:
case 0x82:
case 0x83:
{
int val;
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = (modrm >> 3) & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
opreg = OR_TMP0;
} else {
opreg = rm + OR_EAX;
}
switch(b) {
default:
case 0x80:
case 0x81:
case 0x82:
val = insn_get(s, ot);
break;
case 0x83:
val = (int8_t)insn_get(s, OT_BYTE);
break;
}
gen_op_movl_T1_im(val);
gen_op(s, op, ot, opreg);
}
break;
case 0x40 ... 0x47:
ot = dflag ? OT_LONG : OT_WORD;
gen_inc(s, ot, OR_EAX + (b & 7), 1);
break;
case 0x48 ... 0x4f:
ot = dflag ? OT_LONG : OT_WORD;
gen_inc(s, ot, OR_EAX + (b & 7), -1);
break;
case 0xf6:
case 0xf7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = (modrm >> 3) & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
switch(op) {
case 0:
val = insn_get(s, ot);
gen_op_movl_T1_im(val);
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + ot;
break;
case 2:
gen_op_notl_T0();
if (mod != 3) {
gen_op_st_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_reg_T0[ot][rm]();
}
break;
case 3:
gen_op_negl_T0();
if (mod != 3) {
gen_op_st_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_reg_T0[ot][rm]();
}
gen_op_update_neg_cc();
s->cc_op = CC_OP_SUBB + ot;
break;
case 4:
switch(ot) {
case OT_BYTE:
gen_op_mulb_AL_T0();
s->cc_op = CC_OP_MULB;
break;
case OT_WORD:
gen_op_mulw_AX_T0();
s->cc_op = CC_OP_MULW;
break;
default:
case OT_LONG:
gen_op_mull_EAX_T0();
s->cc_op = CC_OP_MULL;
break;
}
break;
case 5:
switch(ot) {
case OT_BYTE:
gen_op_imulb_AL_T0();
s->cc_op = CC_OP_MULB;
break;
case OT_WORD:
gen_op_imulw_AX_T0();
s->cc_op = CC_OP_MULW;
break;
default:
case OT_LONG:
gen_op_imull_EAX_T0();
s->cc_op = CC_OP_MULL;
break;
}
break;
case 6:
switch(ot) {
case OT_BYTE:
gen_op_divb_AL_T0(pc_start - s->cs_base);
break;
case OT_WORD:
gen_op_divw_AX_T0(pc_start - s->cs_base);
break;
default:
case OT_LONG:
gen_op_divl_EAX_T0(pc_start - s->cs_base);
break;
}
break;
case 7:
switch(ot) {
case OT_BYTE:
gen_op_idivb_AL_T0(pc_start - s->cs_base);
break;
case OT_WORD:
gen_op_idivw_AX_T0(pc_start - s->cs_base);
break;
default:
case OT_LONG:
gen_op_idivl_EAX_T0(pc_start - s->cs_base);
break;
}
break;
default:
goto illegal_op;
}
break;
case 0xfe:
case 0xff:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = (modrm >> 3) & 7;
if (op >= 2 && b == 0xfe) {
goto illegal_op;
}
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (op >= 2 && op != 3 && op != 5)
gen_op_ld_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
switch(op) {
case 0:
if (mod != 3)
opreg = OR_TMP0;
else
opreg = rm;
gen_inc(s, ot, opreg, 1);
break;
case 1:
if (mod != 3)
opreg = OR_TMP0;
else
opreg = rm;
gen_inc(s, ot, opreg, -1);
break;
case 2:
if (s->dflag == 0)
gen_op_andl_T0_ffff();
next_eip = s->pc - s->cs_base;
gen_op_movl_T1_im(next_eip);
gen_push_T1(s);
gen_op_jmp_T0();
gen_eob(s);
break;
case 3:
gen_op_ld_T1_A0[ot + s->mem_index]();
gen_op_addl_A0_im(1 << (ot - OT_WORD + 1));
gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
do_lcall:
if (s->pe && !s->vm86) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_lcall_protected_T0_T1(dflag, s->pc - s->cs_base);
} else {
gen_op_lcall_real_T0_T1(dflag, s->pc - s->cs_base);
}
gen_eob(s);
break;
case 4:
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_eob(s);
break;
case 5:
gen_op_ld_T1_A0[ot + s->mem_index]();
gen_op_addl_A0_im(1 << (ot - OT_WORD + 1));
gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
do_ljmp:
if (s->pe && !s->vm86) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_ljmp_protected_T0_T1(s->pc - s->cs_base);
} else {
gen_op_movl_seg_T0_vm(offsetof(CPUX86State,segs[R_CS]));
gen_op_movl_T0_T1();
gen_op_jmp_T0();
}
gen_eob(s);
break;
case 6:
gen_push_T0(s);
break;
default:
goto illegal_op;
}
break;
case 0x84:
case 0x85:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_mov_TN_reg[ot][1][reg + OR_EAX]();
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + ot;
break;
case 0xa8:
case 0xa9:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
gen_op_mov_TN_reg[ot][0][OR_EAX]();
gen_op_movl_T1_im(val);
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + ot;
break;
case 0x98:
if (dflag)
gen_op_movswl_EAX_AX();
else
gen_op_movsbw_AX_AL();
break;
case 0x99:
if (dflag)
gen_op_movslq_EDX_EAX();
else
gen_op_movswl_DX_AX();
break;
case 0x1af:
case 0x69:
case 0x6b:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = ((modrm >> 3) & 7) + OR_EAX;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
if (b == 0x69) {
val = insn_get(s, ot);
gen_op_movl_T1_im(val);
} else if (b == 0x6b) {
val = (int8_t)insn_get(s, OT_BYTE);
gen_op_movl_T1_im(val);
} else {
gen_op_mov_TN_reg[ot][1][reg]();
}
if (ot == OT_LONG) {
gen_op_imull_T0_T1();
} else {
gen_op_imulw_T0_T1();
}
gen_op_mov_reg_T0[ot][reg]();
s->cc_op = CC_OP_MULB + ot;
break;
case 0x1c0:
case 0x1c1:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (mod == 3) {
rm = modrm & 7;
gen_op_mov_TN_reg[ot][0][reg]();
gen_op_mov_TN_reg[ot][1][rm]();
gen_op_addl_T0_T1();
gen_op_mov_reg_T1[ot][reg]();
gen_op_mov_reg_T0[ot][rm]();
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_mov_TN_reg[ot][0][reg]();
gen_op_ld_T1_A0[ot + s->mem_index]();
gen_op_addl_T0_T1();
gen_op_st_T0_A0[ot + s->mem_index]();
gen_op_mov_reg_T1[ot][reg]();
}
gen_op_update2_cc();
s->cc_op = CC_OP_ADDB + ot;
break;
case 0x1b0:
case 0x1b1:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
gen_op_mov_TN_reg[ot][1][reg]();
if (mod == 3) {
rm = modrm & 7;
gen_op_mov_TN_reg[ot][0][rm]();
gen_op_cmpxchg_T0_T1_EAX_cc[ot]();
gen_op_mov_reg_T0[ot][rm]();
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot + s->mem_index]();
gen_op_cmpxchg_mem_T0_T1_EAX_cc[ot + s->mem_index]();
}
s->cc_op = CC_OP_SUBB + ot;
break;
case 0x1c7:
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_cmpxchg8b();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x50 ... 0x57:
gen_op_mov_TN_reg[OT_LONG][0][b & 7]();
gen_push_T0(s);
break;
case 0x58 ... 0x5f:
ot = dflag ? OT_LONG : OT_WORD;
gen_pop_T0(s);
gen_pop_update(s);
gen_op_mov_reg_T0[ot][b & 7]();
break;
case 0x60:
gen_pusha(s);
break;
case 0x61:
gen_popa(s);
break;
case 0x68:
case 0x6a:
ot = dflag ? OT_LONG : OT_WORD;
if (b == 0x68)
val = insn_get(s, ot);
else
val = (int8_t)insn_get(s, OT_BYTE);
gen_op_movl_T0_im(val);
gen_push_T0(s);
break;
case 0x8f:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
gen_pop_T0(s);
if (mod == 3) {
gen_pop_update(s);
rm = modrm & 7;
gen_op_mov_reg_T0[ot][rm]();
} else {
s->popl_esp_hack = 2 << dflag;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
s->popl_esp_hack = 0;
gen_pop_update(s);
}
break;
case 0xc8:
{
int level;
val = lduw_code(s->pc);
s->pc += 2;
level = ldub_code(s->pc++);
gen_enter(s, val, level);
}
break;
case 0xc9:
if (s->ss32) {
gen_op_mov_TN_reg[OT_LONG][0][R_EBP]();
gen_op_mov_reg_T0[OT_LONG][R_ESP]();
} else {
gen_op_mov_TN_reg[OT_WORD][0][R_EBP]();
gen_op_mov_reg_T0[OT_WORD][R_ESP]();
}
gen_pop_T0(s);
ot = dflag ? OT_LONG : OT_WORD;
gen_op_mov_reg_T0[ot][R_EBP]();
gen_pop_update(s);
break;
case 0x06:
case 0x0e:
case 0x16:
case 0x1e:
gen_op_movl_T0_seg(b >> 3);
gen_push_T0(s);
break;
case 0x1a0:
case 0x1a8:
gen_op_movl_T0_seg((b >> 3) & 7);
gen_push_T0(s);
break;
case 0x07:
case 0x17:
case 0x1f:
reg = b >> 3;
gen_pop_T0(s);
gen_movl_seg_T0(s, reg, pc_start - s->cs_base);
gen_pop_update(s);
if (reg == R_SS) {
if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
gen_op_set_inhibit_irq();
s->tf = 0;
}
if (s->is_jmp) {
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x1a1:
case 0x1a9:
gen_pop_T0(s);
gen_movl_seg_T0(s, (b >> 3) & 7, pc_start - s->cs_base);
gen_pop_update(s);
if (s->is_jmp) {
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x88:
case 0x89:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_EAX + reg, 1);
break;
case 0xc6:
case 0xc7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
if (mod != 3)
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
val = insn_get(s, ot);
gen_op_movl_T0_im(val);
if (mod != 3)
gen_op_st_T0_A0[ot + s->mem_index]();
else
gen_op_mov_reg_T0[ot][modrm & 7]();
break;
case 0x8a:
case 0x8b:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_mov_reg_T0[ot][reg]();
break;
case 0x8e:
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
if (reg >= 6 || reg == R_CS)
goto illegal_op;
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
gen_movl_seg_T0(s, reg, pc_start - s->cs_base);
if (reg == R_SS) {
if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
gen_op_set_inhibit_irq();
s->tf = 0;
}
if (s->is_jmp) {
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x8c:
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (reg >= 6)
goto illegal_op;
gen_op_movl_T0_seg(reg);
ot = OT_WORD;
if (mod == 3 && dflag)
ot = OT_LONG;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
break;
case 0x1b6:
case 0x1b7:
case 0x1be:
case 0x1bf:
{
int d_ot;
d_ot = dflag + OT_WORD;
ot = (b & 1) + OT_BYTE;
modrm = ldub_code(s->pc++);
reg = ((modrm >> 3) & 7) + OR_EAX;
mod = (modrm >> 6) & 3;
rm = modrm & 7;
if (mod == 3) {
gen_op_mov_TN_reg[ot][0][rm]();
switch(ot | (b & 8)) {
case OT_BYTE:
gen_op_movzbl_T0_T0();
break;
case OT_BYTE | 8:
gen_op_movsbl_T0_T0();
break;
case OT_WORD:
gen_op_movzwl_T0_T0();
break;
default:
case OT_WORD | 8:
gen_op_movswl_T0_T0();
break;
}
gen_op_mov_reg_T0[d_ot][reg]();
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (b & 8) {
gen_op_lds_T0_A0[ot + s->mem_index]();
} else {
gen_op_ldu_T0_A0[ot + s->mem_index]();
}
gen_op_mov_reg_T0[d_ot][reg]();
}
}
break;
case 0x8d:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
reg = (modrm >> 3) & 7;
s->override = -1;
val = s->addseg;
s->addseg = 0;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
s->addseg = val;
gen_op_mov_reg_A0[ot - OT_WORD][reg]();
break;
case 0xa0:
case 0xa1:
case 0xa2:
case 0xa3:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (s->aflag)
offset_addr = insn_get(s, OT_LONG);
else
offset_addr = insn_get(s, OT_WORD);
gen_op_movl_A0_im(offset_addr);
{
int override, must_add_seg;
must_add_seg = s->addseg;
if (s->override >= 0) {
override = s->override;
must_add_seg = 1;
} else {
override = R_DS;
}
if (must_add_seg) {
gen_op_addl_A0_seg(offsetof(CPUX86State,segs[override].base));
}
}
if ((b & 2) == 0) {
gen_op_ld_T0_A0[ot + s->mem_index]();
gen_op_mov_reg_T0[ot][R_EAX]();
} else {
gen_op_mov_TN_reg[ot][0][R_EAX]();
gen_op_st_T0_A0[ot + s->mem_index]();
}
break;
case 0xd7:
gen_op_movl_A0_reg[R_EBX]();
gen_op_addl_A0_AL();
if (s->aflag == 0)
gen_op_andl_A0_ffff();
{
int override, must_add_seg;
must_add_seg = s->addseg;
override = R_DS;
if (s->override >= 0) {
override = s->override;
must_add_seg = 1;
} else {
override = R_DS;
}
if (must_add_seg) {
gen_op_addl_A0_seg(offsetof(CPUX86State,segs[override].base));
}
}
gen_op_ldu_T0_A0[OT_BYTE + s->mem_index]();
gen_op_mov_reg_T0[OT_BYTE][R_EAX]();
break;
case 0xb0 ... 0xb7:
val = insn_get(s, OT_BYTE);
gen_op_movl_T0_im(val);
gen_op_mov_reg_T0[OT_BYTE][b & 7]();
break;
case 0xb8 ... 0xbf:
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
reg = OR_EAX + (b & 7);
gen_op_movl_T0_im(val);
gen_op_mov_reg_T0[ot][reg]();
break;
case 0x91 ... 0x97:
ot = dflag ? OT_LONG : OT_WORD;
reg = b & 7;
rm = R_EAX;
goto do_xchg_reg;
case 0x86:
case 0x87:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (mod == 3) {
rm = modrm & 7;
do_xchg_reg:
gen_op_mov_TN_reg[ot][0][reg]();
gen_op_mov_TN_reg[ot][1][rm]();
gen_op_mov_reg_T0[ot][rm]();
gen_op_mov_reg_T1[ot][reg]();
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_mov_TN_reg[ot][0][reg]();
if (!(prefixes & PREFIX_LOCK))
gen_op_lock();
gen_op_ld_T1_A0[ot + s->mem_index]();
gen_op_st_T0_A0[ot + s->mem_index]();
if (!(prefixes & PREFIX_LOCK))
gen_op_unlock();
gen_op_mov_reg_T1[ot][reg]();
}
break;
case 0xc4:
op = R_ES;
goto do_lxx;
case 0xc5:
op = R_DS;
goto do_lxx;
case 0x1b2:
op = R_SS;
goto do_lxx;
case 0x1b4:
op = R_FS;
goto do_lxx;
case 0x1b5:
op = R_GS;
do_lxx:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T1_A0[ot + s->mem_index]();
gen_op_addl_A0_im(1 << (ot - OT_WORD + 1));
gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
gen_movl_seg_T0(s, op, pc_start - s->cs_base);
gen_op_mov_reg_T1[ot][reg]();
if (s->is_jmp) {
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0xc0:
case 0xc1:
shift = 2;
grp2:
{
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = (modrm >> 3) & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
opreg = OR_TMP0;
} else {
opreg = rm + OR_EAX;
}
if (shift == 0) {
gen_shift(s, op, ot, opreg, OR_ECX);
} else {
if (shift == 2) {
shift = ldub_code(s->pc++);
}
gen_shifti(s, op, ot, opreg, shift);
}
}
break;
case 0xd0:
case 0xd1:
shift = 1;
goto grp2;
case 0xd2:
case 0xd3:
shift = 0;
goto grp2;
case 0x1a4:
op = 0;
shift = 1;
goto do_shiftd;
case 0x1a5:
op = 0;
shift = 0;
goto do_shiftd;
case 0x1ac:
op = 1;
shift = 1;
goto do_shiftd;
case 0x1ad:
op = 1;
shift = 0;
do_shiftd:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
reg = (modrm >> 3) & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
gen_op_mov_TN_reg[ot][1][reg]();
if (shift) {
val = ldub_code(s->pc++);
val &= 0x1f;
if (val) {
if (mod == 3)
gen_op_shiftd_T0_T1_im_cc[ot][op](val);
else
gen_op_shiftd_mem_T0_T1_im_cc[ot + s->mem_index][op](val);
if (op == 0 && ot != OT_WORD)
s->cc_op = CC_OP_SHLB + ot;
else
s->cc_op = CC_OP_SARB + ot;
}
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
if (mod == 3)
gen_op_shiftd_T0_T1_ECX_cc[ot][op]();
else
gen_op_shiftd_mem_T0_T1_ECX_cc[ot + s->mem_index][op]();
s->cc_op = CC_OP_DYNAMIC;
}
if (mod == 3) {
gen_op_mov_reg_T0[ot][rm]();
}
break;
case 0xd8 ... 0xdf:
if (s->flags & (HF_EM_MASK | HF_TS_MASK)) {
gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
break;
}
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = ((b & 7) << 3) | ((modrm >> 3) & 7);
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
switch(op) {
case 0x00 ... 0x07:
case 0x10 ... 0x17:
case 0x20 ... 0x27:
case 0x30 ... 0x37:
{
int op1;
op1 = op & 7;
switch(op >> 4) {
case 0:
gen_op_flds_FT0_A0();
break;
case 1:
gen_op_fildl_FT0_A0();
break;
case 2:
gen_op_fldl_FT0_A0();
break;
case 3:
default:
gen_op_fild_FT0_A0();
break;
}
gen_op_fp_arith_ST0_FT0[op1]();
if (op1 == 3) {
gen_op_fpop();
}
}
break;
case 0x08:
case 0x0a:
case 0x0b:
case 0x18:
case 0x1a:
case 0x1b:
case 0x28:
case 0x2a:
case 0x2b:
case 0x38:
case 0x3a:
case 0x3b:
switch(op & 7) {
case 0:
switch(op >> 4) {
case 0:
gen_op_flds_ST0_A0();
break;
case 1:
gen_op_fildl_ST0_A0();
break;
case 2:
gen_op_fldl_ST0_A0();
break;
case 3:
default:
gen_op_fild_ST0_A0();
break;
}
break;
default:
switch(op >> 4) {
case 0:
gen_op_fsts_ST0_A0();
break;
case 1:
gen_op_fistl_ST0_A0();
break;
case 2:
gen_op_fstl_ST0_A0();
break;
case 3:
default:
gen_op_fist_ST0_A0();
break;
}
if ((op & 7) == 3)
gen_op_fpop();
break;
}
break;
case 0x0c:
gen_op_fldenv_A0(s->dflag);
break;
case 0x0d:
gen_op_fldcw_A0();
break;
case 0x0e:
gen_op_fnstenv_A0(s->dflag);
break;
case 0x0f:
gen_op_fnstcw_A0();
break;
case 0x1d:
gen_op_fldt_ST0_A0();
break;
case 0x1f:
gen_op_fstt_ST0_A0();
gen_op_fpop();
break;
case 0x2c:
gen_op_frstor_A0(s->dflag);
break;
case 0x2e:
gen_op_fnsave_A0(s->dflag);
break;
case 0x2f:
gen_op_fnstsw_A0();
break;
case 0x3c:
gen_op_fbld_ST0_A0();
break;
case 0x3e:
gen_op_fbst_ST0_A0();
gen_op_fpop();
break;
case 0x3d:
gen_op_fildll_ST0_A0();
break;
case 0x3f:
gen_op_fistll_ST0_A0();
gen_op_fpop();
break;
default:
goto illegal_op;
}
} else {
opreg = rm;
switch(op) {
case 0x08:
gen_op_fpush();
gen_op_fmov_ST0_STN((opreg + 1) & 7);
break;
case 0x09:
gen_op_fxchg_ST0_STN(opreg);
break;
case 0x0a:
switch(rm) {
case 0:
break;
default:
goto illegal_op;
}
break;
case 0x0c:
switch(rm) {
case 0:
gen_op_fchs_ST0();
break;
case 1:
gen_op_fabs_ST0();
break;
case 4:
gen_op_fldz_FT0();
gen_op_fcom_ST0_FT0();
break;
case 5:
gen_op_fxam_ST0();
break;
default:
goto illegal_op;
}
break;
case 0x0d:
{
switch(rm) {
case 0:
gen_op_fpush();
gen_op_fld1_ST0();
break;
case 1:
gen_op_fpush();
gen_op_fldl2t_ST0();
break;
case 2:
gen_op_fpush();
gen_op_fldl2e_ST0();
break;
case 3:
gen_op_fpush();
gen_op_fldpi_ST0();
break;
case 4:
gen_op_fpush();
gen_op_fldlg2_ST0();
break;
case 5:
gen_op_fpush();
gen_op_fldln2_ST0();
break;
case 6:
gen_op_fpush();
gen_op_fldz_ST0();
break;
default:
goto illegal_op;
}
}
break;
case 0x0e:
switch(rm) {
case 0:
gen_op_f2xm1();
break;
case 1:
gen_op_fyl2x();
break;
case 2:
gen_op_fptan();
break;
case 3:
gen_op_fpatan();
break;
case 4:
gen_op_fxtract();
break;
case 5:
gen_op_fprem1();
break;
case 6:
gen_op_fdecstp();
break;
default:
case 7:
gen_op_fincstp();
break;
}
break;
case 0x0f:
switch(rm) {
case 0:
gen_op_fprem();
break;
case 1:
gen_op_fyl2xp1();
break;
case 2:
gen_op_fsqrt();
break;
case 3:
gen_op_fsincos();
break;
case 5:
gen_op_fscale();
break;
case 4:
gen_op_frndint();
break;
case 6:
gen_op_fsin();
break;
default:
case 7:
gen_op_fcos();
break;
}
break;
case 0x00: case 0x01: case 0x04 ... 0x07:
case 0x20: case 0x21: case 0x24 ... 0x27:
case 0x30: case 0x31: case 0x34 ... 0x37:
{
int op1;
op1 = op & 7;
if (op >= 0x20) {
gen_op_fp_arith_STN_ST0[op1](opreg);
if (op >= 0x30)
gen_op_fpop();
} else {
gen_op_fmov_FT0_STN(opreg);
gen_op_fp_arith_ST0_FT0[op1]();
}
}
break;
case 0x02:
gen_op_fmov_FT0_STN(opreg);
gen_op_fcom_ST0_FT0();
break;
case 0x03:
gen_op_fmov_FT0_STN(opreg);
gen_op_fcom_ST0_FT0();
gen_op_fpop();
break;
case 0x15:
switch(rm) {
case 1:
gen_op_fmov_FT0_STN(1);
gen_op_fucom_ST0_FT0();
gen_op_fpop();
gen_op_fpop();
break;
default:
goto illegal_op;
}
break;
case 0x1c:
switch(rm) {
case 0:
break;
case 1:
break;
case 2:
gen_op_fclex();
break;
case 3:
gen_op_fninit();
break;
case 4:
break;
default:
goto illegal_op;
}
break;
case 0x1d:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_fmov_FT0_STN(opreg);
gen_op_fucomi_ST0_FT0();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x1e:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_fmov_FT0_STN(opreg);
gen_op_fcomi_ST0_FT0();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x2a:
gen_op_fmov_STN_ST0(opreg);
break;
case 0x2b:
gen_op_fmov_STN_ST0(opreg);
gen_op_fpop();
break;
case 0x2c:
gen_op_fmov_FT0_STN(opreg);
gen_op_fucom_ST0_FT0();
break;
case 0x2d:
gen_op_fmov_FT0_STN(opreg);
gen_op_fucom_ST0_FT0();
gen_op_fpop();
break;
case 0x33:
switch(rm) {
case 1:
gen_op_fmov_FT0_STN(1);
gen_op_fcom_ST0_FT0();
gen_op_fpop();
gen_op_fpop();
break;
default:
goto illegal_op;
}
break;
case 0x3c:
switch(rm) {
case 0:
gen_op_fnstsw_EAX();
break;
default:
goto illegal_op;
}
break;
case 0x3d:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_fmov_FT0_STN(opreg);
gen_op_fucomi_ST0_FT0();
gen_op_fpop();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x3e:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_fmov_FT0_STN(opreg);
gen_op_fcomi_ST0_FT0();
gen_op_fpop();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x10 ... 0x13:
case 0x18 ... 0x1b:
{
int op1;
const static uint8_t fcmov_cc[8] = {
(JCC_B << 1),
(JCC_Z << 1),
(JCC_BE << 1),
(JCC_P << 1),
};
op1 = fcmov_cc[op & 3] | ((op >> 3) & 1);
gen_setcc(s, op1);
gen_op_fcmov_ST0_STN_T0(opreg);
}
break;
default:
goto illegal_op;
}
}
#ifdef USE_CODE_COPY
s->tb->cflags |= CF_TB_FP_USED;
#endif
break;
case 0xa4:
case 0xa5:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
gen_repz_movs(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
} else {
gen_movs(s, ot);
}
break;
case 0xaa:
case 0xab:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
gen_repz_stos(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
} else {
gen_stos(s, ot);
}
break;
case 0xac:
case 0xad:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
gen_repz_lods(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
} else {
gen_lods(s, ot);
}
break;
case 0xae:
case 0xaf:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPNZ) {
gen_repz_scas(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 1);
} else if (prefixes & PREFIX_REPZ) {
gen_repz_scas(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 0);
} else {
gen_scas(s, ot);
s->cc_op = CC_OP_SUBB + ot;
}
break;
case 0xa6:
case 0xa7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPNZ) {
gen_repz_cmps(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 1);
} else if (prefixes & PREFIX_REPZ) {
gen_repz_cmps(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 0);
} else {
gen_cmps(s, ot);
s->cc_op = CC_OP_SUBB + ot;
}
break;
case 0x6c:
case 0x6d:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
gen_check_io(s, ot, 1, pc_start - s->cs_base);
if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
gen_repz_ins(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
} else {
gen_ins(s, ot);
}
break;
case 0x6e:
case 0x6f:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
gen_check_io(s, ot, 1, pc_start - s->cs_base);
if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
gen_repz_outs(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
} else {
gen_outs(s, ot);
}
break;
case 0xe4:
case 0xe5:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
val = ldub_code(s->pc++);
gen_op_movl_T0_im(val);
gen_check_io(s, ot, 0, pc_start - s->cs_base);
gen_op_in[ot]();
gen_op_mov_reg_T1[ot][R_EAX]();
break;
case 0xe6:
case 0xe7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
val = ldub_code(s->pc++);
gen_op_movl_T0_im(val);
gen_check_io(s, ot, 0, pc_start - s->cs_base);
gen_op_mov_TN_reg[ot][1][R_EAX]();
gen_op_out[ot]();
break;
case 0xec:
case 0xed:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
gen_op_andl_T0_ffff();
gen_check_io(s, ot, 0, pc_start - s->cs_base);
gen_op_in[ot]();
gen_op_mov_reg_T1[ot][R_EAX]();
break;
case 0xee:
case 0xef:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
gen_op_andl_T0_ffff();
gen_check_io(s, ot, 0, pc_start - s->cs_base);
gen_op_mov_TN_reg[ot][1][R_EAX]();
gen_op_out[ot]();
break;
case 0xc2:
val = ldsw_code(s->pc);
s->pc += 2;
gen_pop_T0(s);
gen_stack_update(s, val + (2 << s->dflag));
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_eob(s);
break;
case 0xc3:
gen_pop_T0(s);
gen_pop_update(s);
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_eob(s);
break;
case 0xca:
val = ldsw_code(s->pc);
s->pc += 2;
do_lret:
if (s->pe && !s->vm86) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_lret_protected(s->dflag, val);
} else {
gen_stack_A0(s);
gen_op_ld_T0_A0[1 + s->dflag + s->mem_index]();
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_op_addl_A0_im(2 << s->dflag);
gen_op_ld_T0_A0[1 + s->dflag + s->mem_index]();
gen_op_movl_seg_T0_vm(offsetof(CPUX86State,segs[R_CS]));
gen_stack_update(s, val + (4 << s->dflag));
}
gen_eob(s);
break;
case 0xcb:
val = 0;
goto do_lret;
case 0xcf:
if (!s->pe) {
gen_op_iret_real(s->dflag);
s->cc_op = CC_OP_EFLAGS;
} else if (s->vm86) {
if (s->iopl != 3) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_op_iret_real(s->dflag);
s->cc_op = CC_OP_EFLAGS;
}
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_iret_protected(s->dflag, s->pc - s->cs_base);
s->cc_op = CC_OP_EFLAGS;
}
gen_eob(s);
break;
case 0xe8:
{
unsigned int next_eip;
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
next_eip = s->pc - s->cs_base;
val += next_eip;
if (s->dflag == 0)
val &= 0xffff;
gen_op_movl_T0_im(next_eip);
gen_push_T0(s);
gen_jmp(s, val);
}
break;
case 0x9a:
{
unsigned int selector, offset;
ot = dflag ? OT_LONG : OT_WORD;
offset = insn_get(s, ot);
selector = insn_get(s, OT_WORD);
gen_op_movl_T0_im(selector);
gen_op_movl_T1_im(offset);
}
goto do_lcall;
case 0xe9:
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
val += s->pc - s->cs_base;
if (s->dflag == 0)
val = val & 0xffff;
gen_jmp(s, val);
break;
case 0xea:
{
unsigned int selector, offset;
ot = dflag ? OT_LONG : OT_WORD;
offset = insn_get(s, ot);
selector = insn_get(s, OT_WORD);
gen_op_movl_T0_im(selector);
gen_op_movl_T1_im(offset);
}
goto do_ljmp;
case 0xeb:
val = (int8_t)insn_get(s, OT_BYTE);
val += s->pc - s->cs_base;
if (s->dflag == 0)
val = val & 0xffff;
gen_jmp(s, val);
break;
case 0x70 ... 0x7f:
val = (int8_t)insn_get(s, OT_BYTE);
goto do_jcc;
case 0x180 ... 0x18f:
if (dflag) {
val = insn_get(s, OT_LONG);
} else {
val = (int16_t)insn_get(s, OT_WORD);
}
do_jcc:
next_eip = s->pc - s->cs_base;
val += next_eip;
if (s->dflag == 0)
val &= 0xffff;
gen_jcc(s, b, val, next_eip);
break;
case 0x190 ... 0x19f:
modrm = ldub_code(s->pc++);
gen_setcc(s, b);
gen_ldst_modrm(s, modrm, OT_BYTE, OR_TMP0, 1);
break;
case 0x140 ... 0x14f:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
gen_setcc(s, b);
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T1_A0[ot + s->mem_index]();
} else {
rm = modrm & 7;
gen_op_mov_TN_reg[ot][1][rm]();
}
gen_op_cmov_reg_T1_T0[ot - OT_WORD][reg]();
break;
case 0x9c:
if (s->vm86 && s->iopl != 3) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_movl_T0_eflags();
gen_push_T0(s);
}
break;
case 0x9d:
if (s->vm86 && s->iopl != 3) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_pop_T0(s);
if (s->cpl == 0) {
if (s->dflag) {
gen_op_movl_eflags_T0_cpl0();
} else {
gen_op_movw_eflags_T0_cpl0();
}
} else {
if (s->cpl <= s->iopl) {
if (s->dflag) {
gen_op_movl_eflags_T0_io();
} else {
gen_op_movw_eflags_T0_io();
}
} else {
if (s->dflag) {
gen_op_movl_eflags_T0();
} else {
gen_op_movw_eflags_T0();
}
}
}
gen_pop_update(s);
s->cc_op = CC_OP_EFLAGS;
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x9e:
gen_op_mov_TN_reg[OT_BYTE][0][R_AH]();
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_movb_eflags_T0();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x9f:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_movl_T0_eflags();
gen_op_mov_reg_T0[OT_BYTE][R_AH]();
break;
case 0xf5:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_cmc();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xf8:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_clc();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xf9:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_stc();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xfc:
gen_op_cld();
break;
case 0xfd:
gen_op_std();
break;
case 0x1ba:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
op = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
rm = modrm & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
val = ldub_code(s->pc++);
gen_op_movl_T1_im(val);
if (op < 4)
goto illegal_op;
op -= 4;
gen_op_btx_T0_T1_cc[ot - OT_WORD][op]();
s->cc_op = CC_OP_SARB + ot;
if (op != 0) {
if (mod != 3)
gen_op_st_T0_A0[ot + s->mem_index]();
else
gen_op_mov_reg_T0[ot][rm]();
gen_op_update_bt_cc();
}
break;
case 0x1a3:
op = 0;
goto do_btx;
case 0x1ab:
op = 1;
goto do_btx;
case 0x1b3:
op = 2;
goto do_btx;
case 0x1bb:
op = 3;
do_btx:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
rm = modrm & 7;
gen_op_mov_TN_reg[OT_LONG][1][reg]();
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (ot == OT_WORD)
gen_op_add_bitw_A0_T1();
else
gen_op_add_bitl_A0_T1();
gen_op_ld_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
gen_op_btx_T0_T1_cc[ot - OT_WORD][op]();
s->cc_op = CC_OP_SARB + ot;
if (op != 0) {
if (mod != 3)
gen_op_st_T0_A0[ot + s->mem_index]();
else
gen_op_mov_reg_T0[ot][rm]();
gen_op_update_bt_cc();
}
break;
case 0x1bc:
case 0x1bd:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_bsx_T0_cc[ot - OT_WORD][b & 1]();
gen_op_mov_reg_T0[ot][reg]();
s->cc_op = CC_OP_LOGICB + ot;
break;
case 0x27:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_daa();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x2f:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_das();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x37:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_aaa();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x3f:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_aas();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xd4:
val = ldub_code(s->pc++);
gen_op_aam(val);
s->cc_op = CC_OP_LOGICB;
break;
case 0xd5:
val = ldub_code(s->pc++);
gen_op_aad(val);
s->cc_op = CC_OP_LOGICB;
break;
case 0x90:
if (prefixes & PREFIX_LOCK)
goto illegal_op;
break;
case 0x9b:
if ((s->flags & (HF_MP_MASK | HF_TS_MASK)) ==
(HF_MP_MASK | HF_TS_MASK)) {
gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_fwait();
}
break;
case 0xcc:
gen_interrupt(s, EXCP03_INT3, pc_start - s->cs_base, s->pc - s->cs_base);
break;
case 0xcd:
val = ldub_code(s->pc++);
if (s->vm86 && s->iopl != 3) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_interrupt(s, val, pc_start - s->cs_base, s->pc - s->cs_base);
}
break;
case 0xce:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_into(s->pc - s->cs_base);
break;
case 0xf1:
gen_debug(s, pc_start - s->cs_base);
break;
case 0xfa:
if (!s->vm86) {
if (s->cpl <= s->iopl) {
gen_op_cli();
} else {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
}
} else {
if (s->iopl == 3) {
gen_op_cli();
} else {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
}
}
break;
case 0xfb:
if (!s->vm86) {
if (s->cpl <= s->iopl) {
gen_sti:
gen_op_sti();
if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
gen_op_set_inhibit_irq();
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
} else {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
}
} else {
if (s->iopl == 3) {
goto gen_sti;
} else {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
}
}
break;
case 0x62:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
gen_op_mov_reg_T0[ot][reg]();
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (ot == OT_WORD)
gen_op_boundw(pc_start - s->cs_base);
else
gen_op_boundl(pc_start - s->cs_base);
break;
case 0x1c8 ... 0x1cf:
reg = b & 7;
gen_op_mov_TN_reg[OT_LONG][0][reg]();
gen_op_bswapl_T0();
gen_op_mov_reg_T0[OT_LONG][reg]();
break;
case 0xd6:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_salc();
break;
case 0xe0:
case 0xe1:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
case 0xe2:
case 0xe3:
val = (int8_t)insn_get(s, OT_BYTE);
next_eip = s->pc - s->cs_base;
val += next_eip;
if (s->dflag == 0)
val &= 0xffff;
gen_op_loop[s->aflag][b & 3](val, next_eip);
gen_eob(s);
break;
case 0x130:
case 0x132:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
if (b & 2)
gen_op_rdmsr();
else
gen_op_wrmsr();
}
break;
case 0x131:
gen_op_rdtsc();
break;
case 0x1a2:
gen_op_cpuid();
break;
case 0xf4:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(s->pc - s->cs_base);
gen_op_hlt();
s->is_jmp = 3;
}
break;
case 0x100:
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7;
switch(op) {
case 0:
if (!s->pe || s->vm86)
goto illegal_op;
gen_op_movl_T0_env(offsetof(CPUX86State,ldt.selector));
ot = OT_WORD;
if (mod == 3)
ot += s->dflag;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
break;
case 2:
if (!s->pe || s->vm86)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_lldt_T0();
}
break;
case 1:
if (!s->pe || s->vm86)
goto illegal_op;
gen_op_movl_T0_env(offsetof(CPUX86State,tr.selector));
ot = OT_WORD;
if (mod == 3)
ot += s->dflag;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
break;
case 3:
if (!s->pe || s->vm86)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_ltr_T0();
}
break;
case 4:
case 5:
if (!s->pe || s->vm86)
goto illegal_op;
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
if (op == 4)
gen_op_verr();
else
gen_op_verw();
s->cc_op = CC_OP_EFLAGS;
break;
default:
goto illegal_op;
}
break;
case 0x101:
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7;
switch(op) {
case 0:
case 1:
if (mod == 3)
goto illegal_op;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (op == 0)
gen_op_movl_T0_env(offsetof(CPUX86State,gdt.limit));
else
gen_op_movl_T0_env(offsetof(CPUX86State,idt.limit));
gen_op_st_T0_A0[OT_WORD + s->mem_index]();
gen_op_addl_A0_im(2);
if (op == 0)
gen_op_movl_T0_env(offsetof(CPUX86State,gdt.base));
else
gen_op_movl_T0_env(offsetof(CPUX86State,idt.base));
if (!s->dflag)
gen_op_andl_T0_im(0xffffff);
gen_op_st_T0_A0[OT_LONG + s->mem_index]();
break;
case 2:
case 3:
if (mod == 3)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T1_A0[OT_WORD + s->mem_index]();
gen_op_addl_A0_im(2);
gen_op_ld_T0_A0[OT_LONG + s->mem_index]();
if (!s->dflag)
gen_op_andl_T0_im(0xffffff);
if (op == 2) {
gen_op_movl_env_T0(offsetof(CPUX86State,gdt.base));
gen_op_movl_env_T1(offsetof(CPUX86State,gdt.limit));
} else {
gen_op_movl_env_T0(offsetof(CPUX86State,idt.base));
gen_op_movl_env_T1(offsetof(CPUX86State,idt.limit));
}
}
break;
case 4:
gen_op_movl_T0_env(offsetof(CPUX86State,cr[0]));
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 1);
break;
case 6:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
gen_op_lmsw_T0();
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 7:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
if (mod == 3)
goto illegal_op;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_invlpg_A0();
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
default:
goto illegal_op;
}
break;
case 0x108:
case 0x109:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
}
break;
case 0x63:
if (!s->pe || s->vm86)
goto illegal_op;
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
rm = modrm & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_arpl();
s->cc_op = CC_OP_EFLAGS;
if (mod != 3) {
gen_op_st_T0_A0[ot + s->mem_index]();
} else {
gen_op_mov_reg_T0[ot][rm]();
}
gen_op_arpl_update();
break;
case 0x102:
case 0x103:
if (!s->pe || s->vm86)
goto illegal_op;
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub_code(s->pc++);
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_mov_TN_reg[ot][1][reg]();
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
if (b == 0x102)
gen_op_lar();
else
gen_op_lsl();
s->cc_op = CC_OP_EFLAGS;
gen_op_mov_reg_T1[ot][reg]();
break;
case 0x118:
modrm = ldub_code(s->pc++);
mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7;
switch(op) {
case 0:
case 1:
case 2:
case 3:
if (mod == 3)
goto illegal_op;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
break;
default:
goto illegal_op;
}
break;
case 0x120:
case 0x122:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
modrm = ldub_code(s->pc++);
if ((modrm & 0xc0) != 0xc0)
goto illegal_op;
rm = modrm & 7;
reg = (modrm >> 3) & 7;
switch(reg) {
case 0:
case 2:
case 3:
case 4:
if (b & 2) {
gen_op_mov_TN_reg[OT_LONG][0][rm]();
gen_op_movl_crN_T0(reg);
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
} else {
gen_op_movl_T0_env(offsetof(CPUX86State,cr[reg]));
gen_op_mov_reg_T0[OT_LONG][rm]();
}
break;
default:
goto illegal_op;
}
}
break;
case 0x121:
case 0x123:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
modrm = ldub_code(s->pc++);
if ((modrm & 0xc0) != 0xc0)
goto illegal_op;
rm = modrm & 7;
reg = (modrm >> 3) & 7;
if (reg == 4 || reg == 5)
goto illegal_op;
if (b & 2) {
gen_op_mov_TN_reg[OT_LONG][0][rm]();
gen_op_movl_drN_T0(reg);
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
} else {
gen_op_movl_T0_env(offsetof(CPUX86State,dr[reg]));
gen_op_mov_reg_T0[OT_LONG][rm]();
}
}
break;
case 0x106:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_op_clts();
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
default:
goto illegal_op;
}
if (s->prefix & PREFIX_LOCK)
gen_op_unlock();
return s->pc;
illegal_op:
if (s->prefix & PREFIX_LOCK)
gen_op_unlock();
gen_exception(s, EXCP06_ILLOP, pc_start - s->cs_base);
return s->pc;
}
| {
"code": [
" gen_op_mov_reg_T0[ot][reg]();"
],
"line_no": [
921
]
} | static uint8_t *FUNC_0(DisasContext *s, uint8_t *pc_start)
{
int VAR_0, VAR_1, VAR_2, VAR_3;
int VAR_4, VAR_5;
int VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_16, VAR_12, VAR_13, VAR_17;
unsigned int VAR_23;
s->pc = pc_start;
VAR_1 = 0;
VAR_2 = s->code32;
VAR_3 = s->code32;
s->VAR_21 = -1;
next_byte:
VAR_0 = ldub_code(s->pc);
s->pc++;
switch (VAR_0) {
case 0xf3:
VAR_1 |= PREFIX_REPZ;
goto next_byte;
case 0xf2:
VAR_1 |= PREFIX_REPNZ;
goto next_byte;
case 0xf0:
VAR_1 |= PREFIX_LOCK;
goto next_byte;
case 0x2e:
s->VAR_21 = R_CS;
goto next_byte;
case 0x36:
s->VAR_21 = R_SS;
goto next_byte;
case 0x3e:
s->VAR_21 = R_DS;
goto next_byte;
case 0x26:
s->VAR_21 = R_ES;
goto next_byte;
case 0x64:
s->VAR_21 = R_FS;
goto next_byte;
case 0x65:
s->VAR_21 = R_GS;
goto next_byte;
case 0x66:
VAR_1 |= PREFIX_DATA;
goto next_byte;
case 0x67:
VAR_1 |= PREFIX_ADR;
goto next_byte;
}
if (VAR_1 & PREFIX_DATA)
VAR_3 ^= 1;
if (VAR_1 & PREFIX_ADR)
VAR_2 ^= 1;
s->prefix = VAR_1;
s->VAR_2 = VAR_2;
s->VAR_3 = VAR_3;
if (VAR_1 & PREFIX_LOCK)
gen_op_lock();
reswitch:
switch(VAR_0) {
case 0x0f:
VAR_0 = ldub_code(s->pc++) | 0x100;
goto reswitch;
case 0x00 ... 0x05:
case 0x08 ... 0x0d:
case 0x10 ... 0x15:
case 0x18 ... 0x1d:
case 0x20 ... 0x25:
case 0x28 ... 0x2d:
case 0x30 ... 0x35:
case 0x38 ... 0x3d:
{
int VAR_16, VAR_16, VAR_17;
VAR_16 = (VAR_0 >> 3) & 7;
VAR_16 = (VAR_0 >> 1) & 3;
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
switch(VAR_16) {
case 0:
VAR_6 = ldub_code(s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = VAR_6 & 7;
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
VAR_12 = OR_TMP0;
} else if (VAR_16 == OP_XORL && VAR_8 == VAR_7) {
xor_zero:
gen_op_movl_T0_0();
s->cc_op = CC_OP_LOGICB + VAR_5;
gen_op_mov_reg_T0[VAR_5][VAR_7]();
gen_op_update1_cc();
break;
} else {
VAR_12 = VAR_8;
}
gen_op_mov_TN_reg[VAR_5][1][VAR_7]();
gen_op(s, VAR_16, VAR_5, VAR_12);
break;
case 1:
VAR_6 = ldub_code(s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_7 = ((VAR_6 >> 3) & 7);
VAR_8 = VAR_6 & 7;
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_op_ld_T1_A0[VAR_5 + s->mem_index]();
} else if (VAR_16 == OP_XORL && VAR_8 == VAR_7) {
goto xor_zero;
} else {
gen_op_mov_TN_reg[VAR_5][1][VAR_8]();
}
gen_op(s, VAR_16, VAR_5, VAR_7);
break;
case 2:
VAR_17 = insn_get(s, VAR_5);
gen_op_movl_T1_im(VAR_17);
gen_op(s, VAR_16, VAR_5, OR_EAX);
break;
}
}
break;
case 0x80:
case 0x81:
case 0x82:
case 0x83:
{
int VAR_17;
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = VAR_6 & 7;
VAR_16 = (VAR_6 >> 3) & 7;
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
VAR_12 = OR_TMP0;
} else {
VAR_12 = VAR_8 + OR_EAX;
}
switch(VAR_0) {
default:
case 0x80:
case 0x81:
case 0x82:
VAR_17 = insn_get(s, VAR_5);
break;
case 0x83:
VAR_17 = (int8_t)insn_get(s, OT_BYTE);
break;
}
gen_op_movl_T1_im(VAR_17);
gen_op(s, VAR_16, VAR_5, VAR_12);
}
break;
case 0x40 ... 0x47:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
gen_inc(s, VAR_5, OR_EAX + (VAR_0 & 7), 1);
break;
case 0x48 ... 0x4f:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
gen_inc(s, VAR_5, OR_EAX + (VAR_0 & 7), -1);
break;
case 0xf6:
case 0xf7:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = VAR_6 & 7;
VAR_16 = (VAR_6 >> 3) & 7;
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_op_ld_T0_A0[VAR_5 + s->mem_index]();
} else {
gen_op_mov_TN_reg[VAR_5][0][VAR_8]();
}
switch(VAR_16) {
case 0:
VAR_17 = insn_get(s, VAR_5);
gen_op_movl_T1_im(VAR_17);
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + VAR_5;
break;
case 2:
gen_op_notl_T0();
if (VAR_9 != 3) {
gen_op_st_T0_A0[VAR_5 + s->mem_index]();
} else {
gen_op_mov_reg_T0[VAR_5][VAR_8]();
}
break;
case 3:
gen_op_negl_T0();
if (VAR_9 != 3) {
gen_op_st_T0_A0[VAR_5 + s->mem_index]();
} else {
gen_op_mov_reg_T0[VAR_5][VAR_8]();
}
gen_op_update_neg_cc();
s->cc_op = CC_OP_SUBB + VAR_5;
break;
case 4:
switch(VAR_5) {
case OT_BYTE:
gen_op_mulb_AL_T0();
s->cc_op = CC_OP_MULB;
break;
case OT_WORD:
gen_op_mulw_AX_T0();
s->cc_op = CC_OP_MULW;
break;
default:
case OT_LONG:
gen_op_mull_EAX_T0();
s->cc_op = CC_OP_MULL;
break;
}
break;
case 5:
switch(VAR_5) {
case OT_BYTE:
gen_op_imulb_AL_T0();
s->cc_op = CC_OP_MULB;
break;
case OT_WORD:
gen_op_imulw_AX_T0();
s->cc_op = CC_OP_MULW;
break;
default:
case OT_LONG:
gen_op_imull_EAX_T0();
s->cc_op = CC_OP_MULL;
break;
}
break;
case 6:
switch(VAR_5) {
case OT_BYTE:
gen_op_divb_AL_T0(pc_start - s->cs_base);
break;
case OT_WORD:
gen_op_divw_AX_T0(pc_start - s->cs_base);
break;
default:
case OT_LONG:
gen_op_divl_EAX_T0(pc_start - s->cs_base);
break;
}
break;
case 7:
switch(VAR_5) {
case OT_BYTE:
gen_op_idivb_AL_T0(pc_start - s->cs_base);
break;
case OT_WORD:
gen_op_idivw_AX_T0(pc_start - s->cs_base);
break;
default:
case OT_LONG:
gen_op_idivl_EAX_T0(pc_start - s->cs_base);
break;
}
break;
default:
goto illegal_op;
}
break;
case 0xfe:
case 0xff:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = VAR_6 & 7;
VAR_16 = (VAR_6 >> 3) & 7;
if (VAR_16 >= 2 && VAR_0 == 0xfe) {
goto illegal_op;
}
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
if (VAR_16 >= 2 && VAR_16 != 3 && VAR_16 != 5)
gen_op_ld_T0_A0[VAR_5 + s->mem_index]();
} else {
gen_op_mov_TN_reg[VAR_5][0][VAR_8]();
}
switch(VAR_16) {
case 0:
if (VAR_9 != 3)
VAR_12 = OR_TMP0;
else
VAR_12 = VAR_8;
gen_inc(s, VAR_5, VAR_12, 1);
break;
case 1:
if (VAR_9 != 3)
VAR_12 = OR_TMP0;
else
VAR_12 = VAR_8;
gen_inc(s, VAR_5, VAR_12, -1);
break;
case 2:
if (s->VAR_3 == 0)
gen_op_andl_T0_ffff();
VAR_23 = s->pc - s->cs_base;
gen_op_movl_T1_im(VAR_23);
gen_push_T1(s);
gen_op_jmp_T0();
gen_eob(s);
break;
case 3:
gen_op_ld_T1_A0[VAR_5 + s->mem_index]();
gen_op_addl_A0_im(1 << (VAR_5 - OT_WORD + 1));
gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
do_lcall:
if (s->pe && !s->vm86) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_lcall_protected_T0_T1(VAR_3, s->pc - s->cs_base);
} else {
gen_op_lcall_real_T0_T1(VAR_3, s->pc - s->cs_base);
}
gen_eob(s);
break;
case 4:
if (s->VAR_3 == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_eob(s);
break;
case 5:
gen_op_ld_T1_A0[VAR_5 + s->mem_index]();
gen_op_addl_A0_im(1 << (VAR_5 - OT_WORD + 1));
gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
do_ljmp:
if (s->pe && !s->vm86) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_ljmp_protected_T0_T1(s->pc - s->cs_base);
} else {
gen_op_movl_seg_T0_vm(offsetof(CPUX86State,segs[R_CS]));
gen_op_movl_T0_T1();
gen_op_jmp_T0();
}
gen_eob(s);
break;
case 6:
gen_push_T0(s);
break;
default:
goto illegal_op;
}
break;
case 0x84:
case 0x85:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = VAR_6 & 7;
VAR_7 = (VAR_6 >> 3) & 7;
gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 0);
gen_op_mov_TN_reg[VAR_5][1][VAR_7 + OR_EAX]();
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + VAR_5;
break;
case 0xa8:
case 0xa9:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_17 = insn_get(s, VAR_5);
gen_op_mov_TN_reg[VAR_5][0][OR_EAX]();
gen_op_movl_T1_im(VAR_17);
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + VAR_5;
break;
case 0x98:
if (VAR_3)
gen_op_movswl_EAX_AX();
else
gen_op_movsbw_AX_AL();
break;
case 0x99:
if (VAR_3)
gen_op_movslq_EDX_EAX();
else
gen_op_movswl_DX_AX();
break;
case 0x1af:
case 0x69:
case 0x6b:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) + OR_EAX;
gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 0);
if (VAR_0 == 0x69) {
VAR_17 = insn_get(s, VAR_5);
gen_op_movl_T1_im(VAR_17);
} else if (VAR_0 == 0x6b) {
VAR_17 = (int8_t)insn_get(s, OT_BYTE);
gen_op_movl_T1_im(VAR_17);
} else {
gen_op_mov_TN_reg[VAR_5][1][VAR_7]();
}
if (VAR_5 == OT_LONG) {
gen_op_imull_T0_T1();
} else {
gen_op_imulw_T0_T1();
}
gen_op_mov_reg_T0[VAR_5][VAR_7]();
s->cc_op = CC_OP_MULB + VAR_5;
break;
case 0x1c0:
case 0x1c1:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_7 = (VAR_6 >> 3) & 7;
VAR_9 = (VAR_6 >> 6) & 3;
if (VAR_9 == 3) {
VAR_8 = VAR_6 & 7;
gen_op_mov_TN_reg[VAR_5][0][VAR_7]();
gen_op_mov_TN_reg[VAR_5][1][VAR_8]();
gen_op_addl_T0_T1();
gen_op_mov_reg_T1[VAR_5][VAR_7]();
gen_op_mov_reg_T0[VAR_5][VAR_8]();
} else {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_op_mov_TN_reg[VAR_5][0][VAR_7]();
gen_op_ld_T1_A0[VAR_5 + s->mem_index]();
gen_op_addl_T0_T1();
gen_op_st_T0_A0[VAR_5 + s->mem_index]();
gen_op_mov_reg_T1[VAR_5][VAR_7]();
}
gen_op_update2_cc();
s->cc_op = CC_OP_ADDB + VAR_5;
break;
case 0x1b0:
case 0x1b1:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_7 = (VAR_6 >> 3) & 7;
VAR_9 = (VAR_6 >> 6) & 3;
gen_op_mov_TN_reg[VAR_5][1][VAR_7]();
if (VAR_9 == 3) {
VAR_8 = VAR_6 & 7;
gen_op_mov_TN_reg[VAR_5][0][VAR_8]();
gen_op_cmpxchg_T0_T1_EAX_cc[VAR_5]();
gen_op_mov_reg_T0[VAR_5][VAR_8]();
} else {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_op_ld_T0_A0[VAR_5 + s->mem_index]();
gen_op_cmpxchg_mem_T0_T1_EAX_cc[VAR_5 + s->mem_index]();
}
s->cc_op = CC_OP_SUBB + VAR_5;
break;
case 0x1c7:
VAR_6 = ldub_code(s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
if (VAR_9 == 3)
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_op_cmpxchg8b();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x50 ... 0x57:
gen_op_mov_TN_reg[OT_LONG][0][VAR_0 & 7]();
gen_push_T0(s);
break;
case 0x58 ... 0x5f:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
gen_pop_T0(s);
gen_pop_update(s);
gen_op_mov_reg_T0[VAR_5][VAR_0 & 7]();
break;
case 0x60:
gen_pusha(s);
break;
case 0x61:
gen_popa(s);
break;
case 0x68:
case 0x6a:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
if (VAR_0 == 0x68)
VAR_17 = insn_get(s, VAR_5);
else
VAR_17 = (int8_t)insn_get(s, OT_BYTE);
gen_op_movl_T0_im(VAR_17);
gen_push_T0(s);
break;
case 0x8f:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
gen_pop_T0(s);
if (VAR_9 == 3) {
gen_pop_update(s);
VAR_8 = VAR_6 & 7;
gen_op_mov_reg_T0[VAR_5][VAR_8]();
} else {
s->popl_esp_hack = 2 << VAR_3;
gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 1);
s->popl_esp_hack = 0;
gen_pop_update(s);
}
break;
case 0xc8:
{
int VAR_17;
VAR_17 = lduw_code(s->pc);
s->pc += 2;
VAR_17 = ldub_code(s->pc++);
gen_enter(s, VAR_17, VAR_17);
}
break;
case 0xc9:
if (s->ss32) {
gen_op_mov_TN_reg[OT_LONG][0][R_EBP]();
gen_op_mov_reg_T0[OT_LONG][R_ESP]();
} else {
gen_op_mov_TN_reg[OT_WORD][0][R_EBP]();
gen_op_mov_reg_T0[OT_WORD][R_ESP]();
}
gen_pop_T0(s);
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
gen_op_mov_reg_T0[VAR_5][R_EBP]();
gen_pop_update(s);
break;
case 0x06:
case 0x0e:
case 0x16:
case 0x1e:
gen_op_movl_T0_seg(VAR_0 >> 3);
gen_push_T0(s);
break;
case 0x1a0:
case 0x1a8:
gen_op_movl_T0_seg((VAR_0 >> 3) & 7);
gen_push_T0(s);
break;
case 0x07:
case 0x17:
case 0x1f:
VAR_7 = VAR_0 >> 3;
gen_pop_T0(s);
gen_movl_seg_T0(s, VAR_7, pc_start - s->cs_base);
gen_pop_update(s);
if (VAR_7 == R_SS) {
if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
gen_op_set_inhibit_irq();
s->tf = 0;
}
if (s->is_jmp) {
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x1a1:
case 0x1a9:
gen_pop_T0(s);
gen_movl_seg_T0(s, (VAR_0 >> 3) & 7, pc_start - s->cs_base);
gen_pop_update(s);
if (s->is_jmp) {
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x88:
case 0x89:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_7 = (VAR_6 >> 3) & 7;
gen_ldst_modrm(s, VAR_6, VAR_5, OR_EAX + VAR_7, 1);
break;
case 0xc6:
case 0xc7:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
if (VAR_9 != 3)
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
VAR_17 = insn_get(s, VAR_5);
gen_op_movl_T0_im(VAR_17);
if (VAR_9 != 3)
gen_op_st_T0_A0[VAR_5 + s->mem_index]();
else
gen_op_mov_reg_T0[VAR_5][VAR_6 & 7]();
break;
case 0x8a:
case 0x8b:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_7 = (VAR_6 >> 3) & 7;
gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 0);
gen_op_mov_reg_T0[VAR_5][VAR_7]();
break;
case 0x8e:
VAR_6 = ldub_code(s->pc++);
VAR_7 = (VAR_6 >> 3) & 7;
if (VAR_7 >= 6 || VAR_7 == R_CS)
goto illegal_op;
gen_ldst_modrm(s, VAR_6, OT_WORD, OR_TMP0, 0);
gen_movl_seg_T0(s, VAR_7, pc_start - s->cs_base);
if (VAR_7 == R_SS) {
if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
gen_op_set_inhibit_irq();
s->tf = 0;
}
if (s->is_jmp) {
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x8c:
VAR_6 = ldub_code(s->pc++);
VAR_7 = (VAR_6 >> 3) & 7;
VAR_9 = (VAR_6 >> 6) & 3;
if (VAR_7 >= 6)
goto illegal_op;
gen_op_movl_T0_seg(VAR_7);
VAR_5 = OT_WORD;
if (VAR_9 == 3 && VAR_3)
VAR_5 = OT_LONG;
gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 1);
break;
case 0x1b6:
case 0x1b7:
case 0x1be:
case 0x1bf:
{
int VAR_18;
VAR_18 = VAR_3 + OT_WORD;
VAR_5 = (VAR_0 & 1) + OT_BYTE;
VAR_6 = ldub_code(s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) + OR_EAX;
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = VAR_6 & 7;
if (VAR_9 == 3) {
gen_op_mov_TN_reg[VAR_5][0][VAR_8]();
switch(VAR_5 | (VAR_0 & 8)) {
case OT_BYTE:
gen_op_movzbl_T0_T0();
break;
case OT_BYTE | 8:
gen_op_movsbl_T0_T0();
break;
case OT_WORD:
gen_op_movzwl_T0_T0();
break;
default:
case OT_WORD | 8:
gen_op_movswl_T0_T0();
break;
}
gen_op_mov_reg_T0[VAR_18][VAR_7]();
} else {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
if (VAR_0 & 8) {
gen_op_lds_T0_A0[VAR_5 + s->mem_index]();
} else {
gen_op_ldu_T0_A0[VAR_5 + s->mem_index]();
}
gen_op_mov_reg_T0[VAR_18][VAR_7]();
}
}
break;
case 0x8d:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
if (VAR_9 == 3)
goto illegal_op;
VAR_7 = (VAR_6 >> 3) & 7;
s->VAR_21 = -1;
VAR_17 = s->addseg;
s->addseg = 0;
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
s->addseg = VAR_17;
gen_op_mov_reg_A0[VAR_5 - OT_WORD][VAR_7]();
break;
case 0xa0:
case 0xa1:
case 0xa2:
case 0xa3:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
if (s->VAR_2)
VAR_13 = insn_get(s, OT_LONG);
else
VAR_13 = insn_get(s, OT_WORD);
gen_op_movl_A0_im(VAR_13);
{
int VAR_21, VAR_21;
VAR_21 = s->addseg;
if (s->VAR_21 >= 0) {
VAR_21 = s->VAR_21;
VAR_21 = 1;
} else {
VAR_21 = R_DS;
}
if (VAR_21) {
gen_op_addl_A0_seg(offsetof(CPUX86State,segs[VAR_21].base));
}
}
if ((VAR_0 & 2) == 0) {
gen_op_ld_T0_A0[VAR_5 + s->mem_index]();
gen_op_mov_reg_T0[VAR_5][R_EAX]();
} else {
gen_op_mov_TN_reg[VAR_5][0][R_EAX]();
gen_op_st_T0_A0[VAR_5 + s->mem_index]();
}
break;
case 0xd7:
gen_op_movl_A0_reg[R_EBX]();
gen_op_addl_A0_AL();
if (s->VAR_2 == 0)
gen_op_andl_A0_ffff();
{
int VAR_21, VAR_21;
VAR_21 = s->addseg;
VAR_21 = R_DS;
if (s->VAR_21 >= 0) {
VAR_21 = s->VAR_21;
VAR_21 = 1;
} else {
VAR_21 = R_DS;
}
if (VAR_21) {
gen_op_addl_A0_seg(offsetof(CPUX86State,segs[VAR_21].base));
}
}
gen_op_ldu_T0_A0[OT_BYTE + s->mem_index]();
gen_op_mov_reg_T0[OT_BYTE][R_EAX]();
break;
case 0xb0 ... 0xb7:
VAR_17 = insn_get(s, OT_BYTE);
gen_op_movl_T0_im(VAR_17);
gen_op_mov_reg_T0[OT_BYTE][VAR_0 & 7]();
break;
case 0xb8 ... 0xbf:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_17 = insn_get(s, VAR_5);
VAR_7 = OR_EAX + (VAR_0 & 7);
gen_op_movl_T0_im(VAR_17);
gen_op_mov_reg_T0[VAR_5][VAR_7]();
break;
case 0x91 ... 0x97:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_7 = VAR_0 & 7;
VAR_8 = R_EAX;
goto do_xchg_reg;
case 0x86:
case 0x87:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_7 = (VAR_6 >> 3) & 7;
VAR_9 = (VAR_6 >> 6) & 3;
if (VAR_9 == 3) {
VAR_8 = VAR_6 & 7;
do_xchg_reg:
gen_op_mov_TN_reg[VAR_5][0][VAR_7]();
gen_op_mov_TN_reg[VAR_5][1][VAR_8]();
gen_op_mov_reg_T0[VAR_5][VAR_8]();
gen_op_mov_reg_T1[VAR_5][VAR_7]();
} else {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_op_mov_TN_reg[VAR_5][0][VAR_7]();
if (!(VAR_1 & PREFIX_LOCK))
gen_op_lock();
gen_op_ld_T1_A0[VAR_5 + s->mem_index]();
gen_op_st_T0_A0[VAR_5 + s->mem_index]();
if (!(VAR_1 & PREFIX_LOCK))
gen_op_unlock();
gen_op_mov_reg_T1[VAR_5][VAR_7]();
}
break;
case 0xc4:
VAR_16 = R_ES;
goto do_lxx;
case 0xc5:
VAR_16 = R_DS;
goto do_lxx;
case 0x1b2:
VAR_16 = R_SS;
goto do_lxx;
case 0x1b4:
VAR_16 = R_FS;
goto do_lxx;
case 0x1b5:
VAR_16 = R_GS;
do_lxx:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_7 = (VAR_6 >> 3) & 7;
VAR_9 = (VAR_6 >> 6) & 3;
if (VAR_9 == 3)
goto illegal_op;
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_op_ld_T1_A0[VAR_5 + s->mem_index]();
gen_op_addl_A0_im(1 << (VAR_5 - OT_WORD + 1));
gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
gen_movl_seg_T0(s, VAR_16, pc_start - s->cs_base);
gen_op_mov_reg_T1[VAR_5][VAR_7]();
if (s->is_jmp) {
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0xc0:
case 0xc1:
VAR_4 = 2;
grp2:
{
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = VAR_6 & 7;
VAR_16 = (VAR_6 >> 3) & 7;
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
VAR_12 = OR_TMP0;
} else {
VAR_12 = VAR_8 + OR_EAX;
}
if (VAR_4 == 0) {
gen_shift(s, VAR_16, VAR_5, VAR_12, OR_ECX);
} else {
if (VAR_4 == 2) {
VAR_4 = ldub_code(s->pc++);
}
gen_shifti(s, VAR_16, VAR_5, VAR_12, VAR_4);
}
}
break;
case 0xd0:
case 0xd1:
VAR_4 = 1;
goto grp2;
case 0xd2:
case 0xd3:
VAR_4 = 0;
goto grp2;
case 0x1a4:
VAR_16 = 0;
VAR_4 = 1;
goto do_shiftd;
case 0x1a5:
VAR_16 = 0;
VAR_4 = 0;
goto do_shiftd;
case 0x1ac:
VAR_16 = 1;
VAR_4 = 1;
goto do_shiftd;
case 0x1ad:
VAR_16 = 1;
VAR_4 = 0;
do_shiftd:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = VAR_6 & 7;
VAR_7 = (VAR_6 >> 3) & 7;
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_op_ld_T0_A0[VAR_5 + s->mem_index]();
} else {
gen_op_mov_TN_reg[VAR_5][0][VAR_8]();
}
gen_op_mov_TN_reg[VAR_5][1][VAR_7]();
if (VAR_4) {
VAR_17 = ldub_code(s->pc++);
VAR_17 &= 0x1f;
if (VAR_17) {
if (VAR_9 == 3)
gen_op_shiftd_T0_T1_im_cc[VAR_5][VAR_16](VAR_17);
else
gen_op_shiftd_mem_T0_T1_im_cc[VAR_5 + s->mem_index][VAR_16](VAR_17);
if (VAR_16 == 0 && VAR_5 != OT_WORD)
s->cc_op = CC_OP_SHLB + VAR_5;
else
s->cc_op = CC_OP_SARB + VAR_5;
}
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
if (VAR_9 == 3)
gen_op_shiftd_T0_T1_ECX_cc[VAR_5][VAR_16]();
else
gen_op_shiftd_mem_T0_T1_ECX_cc[VAR_5 + s->mem_index][VAR_16]();
s->cc_op = CC_OP_DYNAMIC;
}
if (VAR_9 == 3) {
gen_op_mov_reg_T0[VAR_5][VAR_8]();
}
break;
case 0xd8 ... 0xdf:
if (s->flags & (HF_EM_MASK | HF_TS_MASK)) {
gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
break;
}
VAR_6 = ldub_code(s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = VAR_6 & 7;
VAR_16 = ((VAR_0 & 7) << 3) | ((VAR_6 >> 3) & 7);
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
switch(VAR_16) {
case 0x00 ... 0x07:
case 0x10 ... 0x17:
case 0x20 ... 0x27:
case 0x30 ... 0x37:
{
int VAR_22;
VAR_22 = VAR_16 & 7;
switch(VAR_16 >> 4) {
case 0:
gen_op_flds_FT0_A0();
break;
case 1:
gen_op_fildl_FT0_A0();
break;
case 2:
gen_op_fldl_FT0_A0();
break;
case 3:
default:
gen_op_fild_FT0_A0();
break;
}
gen_op_fp_arith_ST0_FT0[VAR_22]();
if (VAR_22 == 3) {
gen_op_fpop();
}
}
break;
case 0x08:
case 0x0a:
case 0x0b:
case 0x18:
case 0x1a:
case 0x1b:
case 0x28:
case 0x2a:
case 0x2b:
case 0x38:
case 0x3a:
case 0x3b:
switch(VAR_16 & 7) {
case 0:
switch(VAR_16 >> 4) {
case 0:
gen_op_flds_ST0_A0();
break;
case 1:
gen_op_fildl_ST0_A0();
break;
case 2:
gen_op_fldl_ST0_A0();
break;
case 3:
default:
gen_op_fild_ST0_A0();
break;
}
break;
default:
switch(VAR_16 >> 4) {
case 0:
gen_op_fsts_ST0_A0();
break;
case 1:
gen_op_fistl_ST0_A0();
break;
case 2:
gen_op_fstl_ST0_A0();
break;
case 3:
default:
gen_op_fist_ST0_A0();
break;
}
if ((VAR_16 & 7) == 3)
gen_op_fpop();
break;
}
break;
case 0x0c:
gen_op_fldenv_A0(s->VAR_3);
break;
case 0x0d:
gen_op_fldcw_A0();
break;
case 0x0e:
gen_op_fnstenv_A0(s->VAR_3);
break;
case 0x0f:
gen_op_fnstcw_A0();
break;
case 0x1d:
gen_op_fldt_ST0_A0();
break;
case 0x1f:
gen_op_fstt_ST0_A0();
gen_op_fpop();
break;
case 0x2c:
gen_op_frstor_A0(s->VAR_3);
break;
case 0x2e:
gen_op_fnsave_A0(s->VAR_3);
break;
case 0x2f:
gen_op_fnstsw_A0();
break;
case 0x3c:
gen_op_fbld_ST0_A0();
break;
case 0x3e:
gen_op_fbst_ST0_A0();
gen_op_fpop();
break;
case 0x3d:
gen_op_fildll_ST0_A0();
break;
case 0x3f:
gen_op_fistll_ST0_A0();
gen_op_fpop();
break;
default:
goto illegal_op;
}
} else {
VAR_12 = VAR_8;
switch(VAR_16) {
case 0x08:
gen_op_fpush();
gen_op_fmov_ST0_STN((VAR_12 + 1) & 7);
break;
case 0x09:
gen_op_fxchg_ST0_STN(VAR_12);
break;
case 0x0a:
switch(VAR_8) {
case 0:
break;
default:
goto illegal_op;
}
break;
case 0x0c:
switch(VAR_8) {
case 0:
gen_op_fchs_ST0();
break;
case 1:
gen_op_fabs_ST0();
break;
case 4:
gen_op_fldz_FT0();
gen_op_fcom_ST0_FT0();
break;
case 5:
gen_op_fxam_ST0();
break;
default:
goto illegal_op;
}
break;
case 0x0d:
{
switch(VAR_8) {
case 0:
gen_op_fpush();
gen_op_fld1_ST0();
break;
case 1:
gen_op_fpush();
gen_op_fldl2t_ST0();
break;
case 2:
gen_op_fpush();
gen_op_fldl2e_ST0();
break;
case 3:
gen_op_fpush();
gen_op_fldpi_ST0();
break;
case 4:
gen_op_fpush();
gen_op_fldlg2_ST0();
break;
case 5:
gen_op_fpush();
gen_op_fldln2_ST0();
break;
case 6:
gen_op_fpush();
gen_op_fldz_ST0();
break;
default:
goto illegal_op;
}
}
break;
case 0x0e:
switch(VAR_8) {
case 0:
gen_op_f2xm1();
break;
case 1:
gen_op_fyl2x();
break;
case 2:
gen_op_fptan();
break;
case 3:
gen_op_fpatan();
break;
case 4:
gen_op_fxtract();
break;
case 5:
gen_op_fprem1();
break;
case 6:
gen_op_fdecstp();
break;
default:
case 7:
gen_op_fincstp();
break;
}
break;
case 0x0f:
switch(VAR_8) {
case 0:
gen_op_fprem();
break;
case 1:
gen_op_fyl2xp1();
break;
case 2:
gen_op_fsqrt();
break;
case 3:
gen_op_fsincos();
break;
case 5:
gen_op_fscale();
break;
case 4:
gen_op_frndint();
break;
case 6:
gen_op_fsin();
break;
default:
case 7:
gen_op_fcos();
break;
}
break;
case 0x00: case 0x01: case 0x04 ... 0x07:
case 0x20: case 0x21: case 0x24 ... 0x27:
case 0x30: case 0x31: case 0x34 ... 0x37:
{
int VAR_22;
VAR_22 = VAR_16 & 7;
if (VAR_16 >= 0x20) {
gen_op_fp_arith_STN_ST0[VAR_22](VAR_12);
if (VAR_16 >= 0x30)
gen_op_fpop();
} else {
gen_op_fmov_FT0_STN(VAR_12);
gen_op_fp_arith_ST0_FT0[VAR_22]();
}
}
break;
case 0x02:
gen_op_fmov_FT0_STN(VAR_12);
gen_op_fcom_ST0_FT0();
break;
case 0x03:
gen_op_fmov_FT0_STN(VAR_12);
gen_op_fcom_ST0_FT0();
gen_op_fpop();
break;
case 0x15:
switch(VAR_8) {
case 1:
gen_op_fmov_FT0_STN(1);
gen_op_fucom_ST0_FT0();
gen_op_fpop();
gen_op_fpop();
break;
default:
goto illegal_op;
}
break;
case 0x1c:
switch(VAR_8) {
case 0:
break;
case 1:
break;
case 2:
gen_op_fclex();
break;
case 3:
gen_op_fninit();
break;
case 4:
break;
default:
goto illegal_op;
}
break;
case 0x1d:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_fmov_FT0_STN(VAR_12);
gen_op_fucomi_ST0_FT0();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x1e:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_fmov_FT0_STN(VAR_12);
gen_op_fcomi_ST0_FT0();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x2a:
gen_op_fmov_STN_ST0(VAR_12);
break;
case 0x2b:
gen_op_fmov_STN_ST0(VAR_12);
gen_op_fpop();
break;
case 0x2c:
gen_op_fmov_FT0_STN(VAR_12);
gen_op_fucom_ST0_FT0();
break;
case 0x2d:
gen_op_fmov_FT0_STN(VAR_12);
gen_op_fucom_ST0_FT0();
gen_op_fpop();
break;
case 0x33:
switch(VAR_8) {
case 1:
gen_op_fmov_FT0_STN(1);
gen_op_fcom_ST0_FT0();
gen_op_fpop();
gen_op_fpop();
break;
default:
goto illegal_op;
}
break;
case 0x3c:
switch(VAR_8) {
case 0:
gen_op_fnstsw_EAX();
break;
default:
goto illegal_op;
}
break;
case 0x3d:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_fmov_FT0_STN(VAR_12);
gen_op_fucomi_ST0_FT0();
gen_op_fpop();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x3e:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_fmov_FT0_STN(VAR_12);
gen_op_fcomi_ST0_FT0();
gen_op_fpop();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x10 ... 0x13:
case 0x18 ... 0x1b:
{
int VAR_22;
const static uint8_t VAR_22[8] = {
(JCC_B << 1),
(JCC_Z << 1),
(JCC_BE << 1),
(JCC_P << 1),
};
VAR_22 = VAR_22[VAR_16 & 3] | ((VAR_16 >> 3) & 1);
gen_setcc(s, VAR_22);
gen_op_fcmov_ST0_STN_T0(VAR_12);
}
break;
default:
goto illegal_op;
}
}
#ifdef USE_CODE_COPY
s->tb->cflags |= CF_TB_FP_USED;
#endif
break;
case 0xa4:
case 0xa5:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
if (VAR_1 & (PREFIX_REPZ | PREFIX_REPNZ)) {
gen_repz_movs(s, VAR_5, pc_start - s->cs_base, s->pc - s->cs_base);
} else {
gen_movs(s, VAR_5);
}
break;
case 0xaa:
case 0xab:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
if (VAR_1 & (PREFIX_REPZ | PREFIX_REPNZ)) {
gen_repz_stos(s, VAR_5, pc_start - s->cs_base, s->pc - s->cs_base);
} else {
gen_stos(s, VAR_5);
}
break;
case 0xac:
case 0xad:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
if (VAR_1 & (PREFIX_REPZ | PREFIX_REPNZ)) {
gen_repz_lods(s, VAR_5, pc_start - s->cs_base, s->pc - s->cs_base);
} else {
gen_lods(s, VAR_5);
}
break;
case 0xae:
case 0xaf:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
if (VAR_1 & PREFIX_REPNZ) {
gen_repz_scas(s, VAR_5, pc_start - s->cs_base, s->pc - s->cs_base, 1);
} else if (VAR_1 & PREFIX_REPZ) {
gen_repz_scas(s, VAR_5, pc_start - s->cs_base, s->pc - s->cs_base, 0);
} else {
gen_scas(s, VAR_5);
s->cc_op = CC_OP_SUBB + VAR_5;
}
break;
case 0xa6:
case 0xa7:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
if (VAR_1 & PREFIX_REPNZ) {
gen_repz_cmps(s, VAR_5, pc_start - s->cs_base, s->pc - s->cs_base, 1);
} else if (VAR_1 & PREFIX_REPZ) {
gen_repz_cmps(s, VAR_5, pc_start - s->cs_base, s->pc - s->cs_base, 0);
} else {
gen_cmps(s, VAR_5);
s->cc_op = CC_OP_SUBB + VAR_5;
}
break;
case 0x6c:
case 0x6d:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
gen_check_io(s, VAR_5, 1, pc_start - s->cs_base);
if (VAR_1 & (PREFIX_REPZ | PREFIX_REPNZ)) {
gen_repz_ins(s, VAR_5, pc_start - s->cs_base, s->pc - s->cs_base);
} else {
gen_ins(s, VAR_5);
}
break;
case 0x6e:
case 0x6f:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
gen_check_io(s, VAR_5, 1, pc_start - s->cs_base);
if (VAR_1 & (PREFIX_REPZ | PREFIX_REPNZ)) {
gen_repz_outs(s, VAR_5, pc_start - s->cs_base, s->pc - s->cs_base);
} else {
gen_outs(s, VAR_5);
}
break;
case 0xe4:
case 0xe5:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_17 = ldub_code(s->pc++);
gen_op_movl_T0_im(VAR_17);
gen_check_io(s, VAR_5, 0, pc_start - s->cs_base);
gen_op_in[VAR_5]();
gen_op_mov_reg_T1[VAR_5][R_EAX]();
break;
case 0xe6:
case 0xe7:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_17 = ldub_code(s->pc++);
gen_op_movl_T0_im(VAR_17);
gen_check_io(s, VAR_5, 0, pc_start - s->cs_base);
gen_op_mov_TN_reg[VAR_5][1][R_EAX]();
gen_op_out[VAR_5]();
break;
case 0xec:
case 0xed:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
gen_op_andl_T0_ffff();
gen_check_io(s, VAR_5, 0, pc_start - s->cs_base);
gen_op_in[VAR_5]();
gen_op_mov_reg_T1[VAR_5][R_EAX]();
break;
case 0xee:
case 0xef:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
gen_op_andl_T0_ffff();
gen_check_io(s, VAR_5, 0, pc_start - s->cs_base);
gen_op_mov_TN_reg[VAR_5][1][R_EAX]();
gen_op_out[VAR_5]();
break;
case 0xc2:
VAR_17 = ldsw_code(s->pc);
s->pc += 2;
gen_pop_T0(s);
gen_stack_update(s, VAR_17 + (2 << s->VAR_3));
if (s->VAR_3 == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_eob(s);
break;
case 0xc3:
gen_pop_T0(s);
gen_pop_update(s);
if (s->VAR_3 == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_eob(s);
break;
case 0xca:
VAR_17 = ldsw_code(s->pc);
s->pc += 2;
do_lret:
if (s->pe && !s->vm86) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_lret_protected(s->VAR_3, VAR_17);
} else {
gen_stack_A0(s);
gen_op_ld_T0_A0[1 + s->VAR_3 + s->mem_index]();
if (s->VAR_3 == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_op_addl_A0_im(2 << s->VAR_3);
gen_op_ld_T0_A0[1 + s->VAR_3 + s->mem_index]();
gen_op_movl_seg_T0_vm(offsetof(CPUX86State,segs[R_CS]));
gen_stack_update(s, VAR_17 + (4 << s->VAR_3));
}
gen_eob(s);
break;
case 0xcb:
VAR_17 = 0;
goto do_lret;
case 0xcf:
if (!s->pe) {
gen_op_iret_real(s->VAR_3);
s->cc_op = CC_OP_EFLAGS;
} else if (s->vm86) {
if (s->iopl != 3) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_op_iret_real(s->VAR_3);
s->cc_op = CC_OP_EFLAGS;
}
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_iret_protected(s->VAR_3, s->pc - s->cs_base);
s->cc_op = CC_OP_EFLAGS;
}
gen_eob(s);
break;
case 0xe8:
{
unsigned int VAR_23;
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_17 = insn_get(s, VAR_5);
VAR_23 = s->pc - s->cs_base;
VAR_17 += VAR_23;
if (s->VAR_3 == 0)
VAR_17 &= 0xffff;
gen_op_movl_T0_im(VAR_23);
gen_push_T0(s);
gen_jmp(s, VAR_17);
}
break;
case 0x9a:
{
unsigned int VAR_25, VAR_25;
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_25 = insn_get(s, VAR_5);
VAR_25 = insn_get(s, OT_WORD);
gen_op_movl_T0_im(VAR_25);
gen_op_movl_T1_im(VAR_25);
}
goto do_lcall;
case 0xe9:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_17 = insn_get(s, VAR_5);
VAR_17 += s->pc - s->cs_base;
if (s->VAR_3 == 0)
VAR_17 = VAR_17 & 0xffff;
gen_jmp(s, VAR_17);
break;
case 0xea:
{
unsigned int VAR_25, VAR_25;
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_25 = insn_get(s, VAR_5);
VAR_25 = insn_get(s, OT_WORD);
gen_op_movl_T0_im(VAR_25);
gen_op_movl_T1_im(VAR_25);
}
goto do_ljmp;
case 0xeb:
VAR_17 = (int8_t)insn_get(s, OT_BYTE);
VAR_17 += s->pc - s->cs_base;
if (s->VAR_3 == 0)
VAR_17 = VAR_17 & 0xffff;
gen_jmp(s, VAR_17);
break;
case 0x70 ... 0x7f:
VAR_17 = (int8_t)insn_get(s, OT_BYTE);
goto do_jcc;
case 0x180 ... 0x18f:
if (VAR_3) {
VAR_17 = insn_get(s, OT_LONG);
} else {
VAR_17 = (int16_t)insn_get(s, OT_WORD);
}
do_jcc:
VAR_23 = s->pc - s->cs_base;
VAR_17 += VAR_23;
if (s->VAR_3 == 0)
VAR_17 &= 0xffff;
gen_jcc(s, VAR_0, VAR_17, VAR_23);
break;
case 0x190 ... 0x19f:
VAR_6 = ldub_code(s->pc++);
gen_setcc(s, VAR_0);
gen_ldst_modrm(s, VAR_6, OT_BYTE, OR_TMP0, 1);
break;
case 0x140 ... 0x14f:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_7 = (VAR_6 >> 3) & 7;
VAR_9 = (VAR_6 >> 6) & 3;
gen_setcc(s, VAR_0);
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_op_ld_T1_A0[VAR_5 + s->mem_index]();
} else {
VAR_8 = VAR_6 & 7;
gen_op_mov_TN_reg[VAR_5][1][VAR_8]();
}
gen_op_cmov_reg_T1_T0[VAR_5 - OT_WORD][VAR_7]();
break;
case 0x9c:
if (s->vm86 && s->iopl != 3) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_movl_T0_eflags();
gen_push_T0(s);
}
break;
case 0x9d:
if (s->vm86 && s->iopl != 3) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_pop_T0(s);
if (s->cpl == 0) {
if (s->VAR_3) {
gen_op_movl_eflags_T0_cpl0();
} else {
gen_op_movw_eflags_T0_cpl0();
}
} else {
if (s->cpl <= s->iopl) {
if (s->VAR_3) {
gen_op_movl_eflags_T0_io();
} else {
gen_op_movw_eflags_T0_io();
}
} else {
if (s->VAR_3) {
gen_op_movl_eflags_T0();
} else {
gen_op_movw_eflags_T0();
}
}
}
gen_pop_update(s);
s->cc_op = CC_OP_EFLAGS;
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x9e:
gen_op_mov_TN_reg[OT_BYTE][0][R_AH]();
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_movb_eflags_T0();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x9f:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_movl_T0_eflags();
gen_op_mov_reg_T0[OT_BYTE][R_AH]();
break;
case 0xf5:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_cmc();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xf8:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_clc();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xf9:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_stc();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xfc:
gen_op_cld();
break;
case 0xfd:
gen_op_std();
break;
case 0x1ba:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_16 = (VAR_6 >> 3) & 7;
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = VAR_6 & 7;
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_op_ld_T0_A0[VAR_5 + s->mem_index]();
} else {
gen_op_mov_TN_reg[VAR_5][0][VAR_8]();
}
VAR_17 = ldub_code(s->pc++);
gen_op_movl_T1_im(VAR_17);
if (VAR_16 < 4)
goto illegal_op;
VAR_16 -= 4;
gen_op_btx_T0_T1_cc[VAR_5 - OT_WORD][VAR_16]();
s->cc_op = CC_OP_SARB + VAR_5;
if (VAR_16 != 0) {
if (VAR_9 != 3)
gen_op_st_T0_A0[VAR_5 + s->mem_index]();
else
gen_op_mov_reg_T0[VAR_5][VAR_8]();
gen_op_update_bt_cc();
}
break;
case 0x1a3:
VAR_16 = 0;
goto do_btx;
case 0x1ab:
VAR_16 = 1;
goto do_btx;
case 0x1b3:
VAR_16 = 2;
goto do_btx;
case 0x1bb:
VAR_16 = 3;
do_btx:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_7 = (VAR_6 >> 3) & 7;
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = VAR_6 & 7;
gen_op_mov_TN_reg[OT_LONG][1][VAR_7]();
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
if (VAR_5 == OT_WORD)
gen_op_add_bitw_A0_T1();
else
gen_op_add_bitl_A0_T1();
gen_op_ld_T0_A0[VAR_5 + s->mem_index]();
} else {
gen_op_mov_TN_reg[VAR_5][0][VAR_8]();
}
gen_op_btx_T0_T1_cc[VAR_5 - OT_WORD][VAR_16]();
s->cc_op = CC_OP_SARB + VAR_5;
if (VAR_16 != 0) {
if (VAR_9 != 3)
gen_op_st_T0_A0[VAR_5 + s->mem_index]();
else
gen_op_mov_reg_T0[VAR_5][VAR_8]();
gen_op_update_bt_cc();
}
break;
case 0x1bc:
case 0x1bd:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_7 = (VAR_6 >> 3) & 7;
gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 0);
gen_op_bsx_T0_cc[VAR_5 - OT_WORD][VAR_0 & 1]();
gen_op_mov_reg_T0[VAR_5][VAR_7]();
s->cc_op = CC_OP_LOGICB + VAR_5;
break;
case 0x27:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_daa();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x2f:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_das();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x37:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_aaa();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x3f:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_aas();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xd4:
VAR_17 = ldub_code(s->pc++);
gen_op_aam(VAR_17);
s->cc_op = CC_OP_LOGICB;
break;
case 0xd5:
VAR_17 = ldub_code(s->pc++);
gen_op_aad(VAR_17);
s->cc_op = CC_OP_LOGICB;
break;
case 0x90:
if (VAR_1 & PREFIX_LOCK)
goto illegal_op;
break;
case 0x9b:
if ((s->flags & (HF_MP_MASK | HF_TS_MASK)) ==
(HF_MP_MASK | HF_TS_MASK)) {
gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_fwait();
}
break;
case 0xcc:
gen_interrupt(s, EXCP03_INT3, pc_start - s->cs_base, s->pc - s->cs_base);
break;
case 0xcd:
VAR_17 = ldub_code(s->pc++);
if (s->vm86 && s->iopl != 3) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_interrupt(s, VAR_17, pc_start - s->cs_base, s->pc - s->cs_base);
}
break;
case 0xce:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_into(s->pc - s->cs_base);
break;
case 0xf1:
gen_debug(s, pc_start - s->cs_base);
break;
case 0xfa:
if (!s->vm86) {
if (s->cpl <= s->iopl) {
gen_op_cli();
} else {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
}
} else {
if (s->iopl == 3) {
gen_op_cli();
} else {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
}
}
break;
case 0xfb:
if (!s->vm86) {
if (s->cpl <= s->iopl) {
gen_sti:
gen_op_sti();
if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
gen_op_set_inhibit_irq();
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
} else {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
}
} else {
if (s->iopl == 3) {
goto gen_sti;
} else {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
}
}
break;
case 0x62:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_7 = (VAR_6 >> 3) & 7;
VAR_9 = (VAR_6 >> 6) & 3;
if (VAR_9 == 3)
goto illegal_op;
gen_op_mov_reg_T0[VAR_5][VAR_7]();
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
if (VAR_5 == OT_WORD)
gen_op_boundw(pc_start - s->cs_base);
else
gen_op_boundl(pc_start - s->cs_base);
break;
case 0x1c8 ... 0x1cf:
VAR_7 = VAR_0 & 7;
gen_op_mov_TN_reg[OT_LONG][0][VAR_7]();
gen_op_bswapl_T0();
gen_op_mov_reg_T0[OT_LONG][VAR_7]();
break;
case 0xd6:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_salc();
break;
case 0xe0:
case 0xe1:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
case 0xe2:
case 0xe3:
VAR_17 = (int8_t)insn_get(s, OT_BYTE);
VAR_23 = s->pc - s->cs_base;
VAR_17 += VAR_23;
if (s->VAR_3 == 0)
VAR_17 &= 0xffff;
gen_op_loop[s->VAR_2][VAR_0 & 3](VAR_17, VAR_23);
gen_eob(s);
break;
case 0x130:
case 0x132:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
if (VAR_0 & 2)
gen_op_rdmsr();
else
gen_op_wrmsr();
}
break;
case 0x131:
gen_op_rdtsc();
break;
case 0x1a2:
gen_op_cpuid();
break;
case 0xf4:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_jmp_im(s->pc - s->cs_base);
gen_op_hlt();
s->is_jmp = 3;
}
break;
case 0x100:
VAR_6 = ldub_code(s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_16 = (VAR_6 >> 3) & 7;
switch(VAR_16) {
case 0:
if (!s->pe || s->vm86)
goto illegal_op;
gen_op_movl_T0_env(offsetof(CPUX86State,ldt.VAR_25));
VAR_5 = OT_WORD;
if (VAR_9 == 3)
VAR_5 += s->VAR_3;
gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 1);
break;
case 2:
if (!s->pe || s->vm86)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_ldst_modrm(s, VAR_6, OT_WORD, OR_TMP0, 0);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_lldt_T0();
}
break;
case 1:
if (!s->pe || s->vm86)
goto illegal_op;
gen_op_movl_T0_env(offsetof(CPUX86State,tr.VAR_25));
VAR_5 = OT_WORD;
if (VAR_9 == 3)
VAR_5 += s->VAR_3;
gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 1);
break;
case 3:
if (!s->pe || s->vm86)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_ldst_modrm(s, VAR_6, OT_WORD, OR_TMP0, 0);
gen_op_jmp_im(pc_start - s->cs_base);
gen_op_ltr_T0();
}
break;
case 4:
case 5:
if (!s->pe || s->vm86)
goto illegal_op;
gen_ldst_modrm(s, VAR_6, OT_WORD, OR_TMP0, 0);
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
if (VAR_16 == 4)
gen_op_verr();
else
gen_op_verw();
s->cc_op = CC_OP_EFLAGS;
break;
default:
goto illegal_op;
}
break;
case 0x101:
VAR_6 = ldub_code(s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_16 = (VAR_6 >> 3) & 7;
switch(VAR_16) {
case 0:
case 1:
if (VAR_9 == 3)
goto illegal_op;
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
if (VAR_16 == 0)
gen_op_movl_T0_env(offsetof(CPUX86State,gdt.limit));
else
gen_op_movl_T0_env(offsetof(CPUX86State,idt.limit));
gen_op_st_T0_A0[OT_WORD + s->mem_index]();
gen_op_addl_A0_im(2);
if (VAR_16 == 0)
gen_op_movl_T0_env(offsetof(CPUX86State,gdt.base));
else
gen_op_movl_T0_env(offsetof(CPUX86State,idt.base));
if (!s->VAR_3)
gen_op_andl_T0_im(0xffffff);
gen_op_st_T0_A0[OT_LONG + s->mem_index]();
break;
case 2:
case 3:
if (VAR_9 == 3)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_op_ld_T1_A0[OT_WORD + s->mem_index]();
gen_op_addl_A0_im(2);
gen_op_ld_T0_A0[OT_LONG + s->mem_index]();
if (!s->VAR_3)
gen_op_andl_T0_im(0xffffff);
if (VAR_16 == 2) {
gen_op_movl_env_T0(offsetof(CPUX86State,gdt.base));
gen_op_movl_env_T1(offsetof(CPUX86State,gdt.limit));
} else {
gen_op_movl_env_T0(offsetof(CPUX86State,idt.base));
gen_op_movl_env_T1(offsetof(CPUX86State,idt.limit));
}
}
break;
case 4:
gen_op_movl_T0_env(offsetof(CPUX86State,cr[0]));
gen_ldst_modrm(s, VAR_6, OT_WORD, OR_TMP0, 1);
break;
case 6:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_ldst_modrm(s, VAR_6, OT_WORD, OR_TMP0, 0);
gen_op_lmsw_T0();
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 7:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
if (VAR_9 == 3)
goto illegal_op;
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_op_invlpg_A0();
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
default:
goto illegal_op;
}
break;
case 0x108:
case 0x109:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
}
break;
case 0x63:
if (!s->pe || s->vm86)
goto illegal_op;
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_7 = (VAR_6 >> 3) & 7;
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = VAR_6 & 7;
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_op_ld_T0_A0[VAR_5 + s->mem_index]();
} else {
gen_op_mov_TN_reg[VAR_5][0][VAR_8]();
}
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_arpl();
s->cc_op = CC_OP_EFLAGS;
if (VAR_9 != 3) {
gen_op_st_T0_A0[VAR_5 + s->mem_index]();
} else {
gen_op_mov_reg_T0[VAR_5][VAR_8]();
}
gen_op_arpl_update();
break;
case 0x102:
case 0x103:
if (!s->pe || s->vm86)
goto illegal_op;
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = ldub_code(s->pc++);
VAR_7 = (VAR_6 >> 3) & 7;
gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 0);
gen_op_mov_TN_reg[VAR_5][1][VAR_7]();
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
if (VAR_0 == 0x102)
gen_op_lar();
else
gen_op_lsl();
s->cc_op = CC_OP_EFLAGS;
gen_op_mov_reg_T1[VAR_5][VAR_7]();
break;
case 0x118:
VAR_6 = ldub_code(s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_16 = (VAR_6 >> 3) & 7;
switch(VAR_16) {
case 0:
case 1:
case 2:
case 3:
if (VAR_9 == 3)
goto illegal_op;
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
break;
default:
goto illegal_op;
}
break;
case 0x120:
case 0x122:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
VAR_6 = ldub_code(s->pc++);
if ((VAR_6 & 0xc0) != 0xc0)
goto illegal_op;
VAR_8 = VAR_6 & 7;
VAR_7 = (VAR_6 >> 3) & 7;
switch(VAR_7) {
case 0:
case 2:
case 3:
case 4:
if (VAR_0 & 2) {
gen_op_mov_TN_reg[OT_LONG][0][VAR_8]();
gen_op_movl_crN_T0(VAR_7);
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
} else {
gen_op_movl_T0_env(offsetof(CPUX86State,cr[VAR_7]));
gen_op_mov_reg_T0[OT_LONG][VAR_8]();
}
break;
default:
goto illegal_op;
}
}
break;
case 0x121:
case 0x123:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
VAR_6 = ldub_code(s->pc++);
if ((VAR_6 & 0xc0) != 0xc0)
goto illegal_op;
VAR_8 = VAR_6 & 7;
VAR_7 = (VAR_6 >> 3) & 7;
if (VAR_7 == 4 || VAR_7 == 5)
goto illegal_op;
if (VAR_0 & 2) {
gen_op_mov_TN_reg[OT_LONG][0][VAR_8]();
gen_op_movl_drN_T0(VAR_7);
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
} else {
gen_op_movl_T0_env(offsetof(CPUX86State,dr[VAR_7]));
gen_op_mov_reg_T0[OT_LONG][VAR_8]();
}
}
break;
case 0x106:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_op_clts();
gen_op_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
default:
goto illegal_op;
}
if (s->prefix & PREFIX_LOCK)
gen_op_unlock();
return s->pc;
illegal_op:
if (s->prefix & PREFIX_LOCK)
gen_op_unlock();
gen_exception(s, EXCP06_ILLOP, pc_start - s->cs_base);
return s->pc;
}
| [
"static uint8_t *FUNC_0(DisasContext *s, uint8_t *pc_start)\n{",
"int VAR_0, VAR_1, VAR_2, VAR_3;",
"int VAR_4, VAR_5;",
"int VAR_6, VAR_7, VAR_8, VAR_9, VAR_10, VAR_16, VAR_12, VAR_13, VAR_17;",
"unsigned int VAR_23;",
"s->pc = pc_start;",
"VAR_1 = 0;",
"VAR_2 = s->code32;",
"VAR_3 = s->code32;",
... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25,
27
],
[
29
],
[
33
],
[
35,
37
],
[
39
],
[
41,
43
],
[
45
],
[
47,
49
... |
2,025 | static void ogg_write_pages(AVFormatContext *s, int flush)
{
OGGContext *ogg = s->priv_data;
OGGPageList *next, *p;
if (!ogg->page_list)
return;
for (p = ogg->page_list; p; ) {
OGGStreamContext *oggstream =
s->streams[p->page.stream_index]->priv_data;
if (oggstream->page_count < 2 && !flush)
break;
ogg_write_page(s, &p->page,
flush && oggstream->page_count == 1 ? 4 : 0); // eos
next = p->next;
av_freep(&p);
p = next;
}
ogg->page_list = p;
}
| true | FFmpeg | 919c320f7226bf873a9148e1db8994745f9d425d | static void ogg_write_pages(AVFormatContext *s, int flush)
{
OGGContext *ogg = s->priv_data;
OGGPageList *next, *p;
if (!ogg->page_list)
return;
for (p = ogg->page_list; p; ) {
OGGStreamContext *oggstream =
s->streams[p->page.stream_index]->priv_data;
if (oggstream->page_count < 2 && !flush)
break;
ogg_write_page(s, &p->page,
flush && oggstream->page_count == 1 ? 4 : 0);
next = p->next;
av_freep(&p);
p = next;
}
ogg->page_list = p;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(AVFormatContext *VAR_0, int VAR_1)
{
OGGContext *ogg = VAR_0->priv_data;
OGGPageList *next, *p;
if (!ogg->page_list)
return;
for (p = ogg->page_list; p; ) {
OGGStreamContext *oggstream =
VAR_0->streams[p->page.stream_index]->priv_data;
if (oggstream->page_count < 2 && !VAR_1)
break;
ogg_write_page(VAR_0, &p->page,
VAR_1 && oggstream->page_count == 1 ? 4 : 0);
next = p->next;
av_freep(&p);
p = next;
}
ogg->page_list = p;
}
| [
"static void FUNC_0(AVFormatContext *VAR_0, int VAR_1)\n{",
"OGGContext *ogg = VAR_0->priv_data;",
"OGGPageList *next, *p;",
"if (!ogg->page_list)\nreturn;",
"for (p = ogg->page_list; p; ) {",
"OGGStreamContext *oggstream =\nVAR_0->streams[p->page.stream_index]->priv_data;",
"if (oggstream->page_count <... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11,
13
],
[
17
],
[
19,
21
],
[
23,
25
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
]
] |
2,026 | static void get_lag(float *buf, const float *new, LongTermPrediction *ltp)
{
int i, j, lag, max_corr = 0;
float max_ratio;
for (i = 0; i < 2048; i++) {
float corr, s0 = 0.0f, s1 = 0.0f;
const int start = FFMAX(0, i - 1024);
for (j = start; j < 2048; j++) {
const int idx = j - i + 1024;
s0 += new[j]*buf[idx];
s1 += buf[idx]*buf[idx];
}
corr = s1 > 0.0f ? s0/sqrt(s1) : 0.0f;
if (corr > max_corr) {
max_corr = corr;
lag = i;
max_ratio = corr/(2048-start);
}
}
ltp->lag = FFMAX(av_clip_uintp2(lag, 11), 0);
ltp->coef_idx = quant_array_idx(max_ratio, ltp_coef, 8);
ltp->coef = ltp_coef[ltp->coef_idx];
}
| true | FFmpeg | 8cd8c8331730fbaac5066bfd66e15b39a85ce537 | static void get_lag(float *buf, const float *new, LongTermPrediction *ltp)
{
int i, j, lag, max_corr = 0;
float max_ratio;
for (i = 0; i < 2048; i++) {
float corr, s0 = 0.0f, s1 = 0.0f;
const int start = FFMAX(0, i - 1024);
for (j = start; j < 2048; j++) {
const int idx = j - i + 1024;
s0 += new[j]*buf[idx];
s1 += buf[idx]*buf[idx];
}
corr = s1 > 0.0f ? s0/sqrt(s1) : 0.0f;
if (corr > max_corr) {
max_corr = corr;
lag = i;
max_ratio = corr/(2048-start);
}
}
ltp->lag = FFMAX(av_clip_uintp2(lag, 11), 0);
ltp->coef_idx = quant_array_idx(max_ratio, ltp_coef, 8);
ltp->coef = ltp_coef[ltp->coef_idx];
}
| {
"code": [
" int i, j, lag, max_corr = 0;",
" float max_ratio;"
],
"line_no": [
5,
7
]
} | static void FUNC_0(float *VAR_0, const float *VAR_1, LongTermPrediction *VAR_2)
{
int VAR_3, VAR_4, VAR_5, VAR_6 = 0;
float VAR_7;
for (VAR_3 = 0; VAR_3 < 2048; VAR_3++) {
float VAR_8, VAR_9 = 0.0f, VAR_10 = 0.0f;
const int VAR_11 = FFMAX(0, VAR_3 - 1024);
for (VAR_4 = VAR_11; VAR_4 < 2048; VAR_4++) {
const int VAR_12 = VAR_4 - VAR_3 + 1024;
VAR_9 += VAR_1[VAR_4]*VAR_0[VAR_12];
VAR_10 += VAR_0[VAR_12]*VAR_0[VAR_12];
}
VAR_8 = VAR_10 > 0.0f ? VAR_9/sqrt(VAR_10) : 0.0f;
if (VAR_8 > VAR_6) {
VAR_6 = VAR_8;
VAR_5 = VAR_3;
VAR_7 = VAR_8/(2048-VAR_11);
}
}
VAR_2->VAR_5 = FFMAX(av_clip_uintp2(VAR_5, 11), 0);
VAR_2->coef_idx = quant_array_idx(VAR_7, ltp_coef, 8);
VAR_2->coef = ltp_coef[VAR_2->coef_idx];
}
| [
"static void FUNC_0(float *VAR_0, const float *VAR_1, LongTermPrediction *VAR_2)\n{",
"int VAR_3, VAR_4, VAR_5, VAR_6 = 0;",
"float VAR_7;",
"for (VAR_3 = 0; VAR_3 < 2048; VAR_3++) {",
"float VAR_8, VAR_9 = 0.0f, VAR_10 = 0.0f;",
"const int VAR_11 = FFMAX(0, VAR_3 - 1024);",
"for (VAR_4 = VAR_11; VAR_4 ... | [
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
... |
2,028 | static void memory_region_dispatch_write(MemoryRegion *mr,
hwaddr addr,
uint64_t data,
unsigned size)
{
if (!memory_region_access_valid(mr, addr, size, true)) {
return; /* FIXME: better signalling */
}
adjust_endianness(mr, &data, size);
if (!mr->ops->write) {
mr->ops->old_mmio.write[bitops_ffsl(size)](mr->opaque, addr, data);
return;
}
/* FIXME: support unaligned access */
access_with_adjusted_size(addr, &data, size,
mr->ops->impl.min_access_size,
mr->ops->impl.max_access_size,
memory_region_write_accessor, mr);
}
| true | qemu | fbeadf50f2f965741def823036b086bbc2999b1f | static void memory_region_dispatch_write(MemoryRegion *mr,
hwaddr addr,
uint64_t data,
unsigned size)
{
if (!memory_region_access_valid(mr, addr, size, true)) {
return;
}
adjust_endianness(mr, &data, size);
if (!mr->ops->write) {
mr->ops->old_mmio.write[bitops_ffsl(size)](mr->opaque, addr, data);
return;
}
access_with_adjusted_size(addr, &data, size,
mr->ops->impl.min_access_size,
mr->ops->impl.max_access_size,
memory_region_write_accessor, mr);
}
| {
"code": [
" mr->ops->old_mmio.write[bitops_ffsl(size)](mr->opaque, addr, data);"
],
"line_no": [
25
]
} | static void FUNC_0(MemoryRegion *VAR_0,
hwaddr VAR_1,
uint64_t VAR_2,
unsigned VAR_3)
{
if (!memory_region_access_valid(VAR_0, VAR_1, VAR_3, true)) {
return;
}
adjust_endianness(VAR_0, &VAR_2, VAR_3);
if (!VAR_0->ops->write) {
VAR_0->ops->old_mmio.write[bitops_ffsl(VAR_3)](VAR_0->opaque, VAR_1, VAR_2);
return;
}
access_with_adjusted_size(VAR_1, &VAR_2, VAR_3,
VAR_0->ops->impl.min_access_size,
VAR_0->ops->impl.max_access_size,
memory_region_write_accessor, VAR_0);
}
| [
"static void FUNC_0(MemoryRegion *VAR_0,\nhwaddr VAR_1,\nuint64_t VAR_2,\nunsigned VAR_3)\n{",
"if (!memory_region_access_valid(VAR_0, VAR_1, VAR_3, true)) {",
"return;",
"}",
"adjust_endianness(VAR_0, &VAR_2, VAR_3);",
"if (!VAR_0->ops->write) {",
"VAR_0->ops->old_mmio.write[bitops_ffsl(VAR_3)](VAR_0->... | [
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
35,
37,
39,
41
],
[
43
]
] |
2,029 | int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data)
{
const char *id = qdict_get_str(qdict, "id");
BlockDriverState *bs;
BlockDriverState **ptr;
Property *prop;
bs = bdrv_find(id);
if (!bs) {
qerror_report(QERR_DEVICE_NOT_FOUND, id);
return -1;
}
if (bdrv_in_use(bs)) {
qerror_report(QERR_DEVICE_IN_USE, id);
return -1;
}
/* quiesce block driver; prevent further io */
qemu_aio_flush();
bdrv_flush(bs);
bdrv_close(bs);
/* clean up guest state from pointing to host resource by
* finding and removing DeviceState "drive" property */
if (bs->peer) {
for (prop = bs->peer->info->props; prop && prop->name; prop++) {
if (prop->info->type == PROP_TYPE_DRIVE) {
ptr = qdev_get_prop_ptr(bs->peer, prop);
if (*ptr == bs) {
bdrv_detach(bs, bs->peer);
*ptr = NULL;
break;
}
}
}
}
/* clean up host side */
drive_uninit(drive_get_by_blockdev(bs));
return 0;
}
| true | qemu | d22b2f41c470067758b3636a01b452dfeda7069f | int do_drive_del(Monitor *mon, const QDict *qdict, QObject **ret_data)
{
const char *id = qdict_get_str(qdict, "id");
BlockDriverState *bs;
BlockDriverState **ptr;
Property *prop;
bs = bdrv_find(id);
if (!bs) {
qerror_report(QERR_DEVICE_NOT_FOUND, id);
return -1;
}
if (bdrv_in_use(bs)) {
qerror_report(QERR_DEVICE_IN_USE, id);
return -1;
}
qemu_aio_flush();
bdrv_flush(bs);
bdrv_close(bs);
if (bs->peer) {
for (prop = bs->peer->info->props; prop && prop->name; prop++) {
if (prop->info->type == PROP_TYPE_DRIVE) {
ptr = qdev_get_prop_ptr(bs->peer, prop);
if (*ptr == bs) {
bdrv_detach(bs, bs->peer);
*ptr = NULL;
break;
}
}
}
}
drive_uninit(drive_get_by_blockdev(bs));
return 0;
}
| {
"code": [
" BlockDriverState **ptr;",
" Property *prop;",
" for (prop = bs->peer->info->props; prop && prop->name; prop++) {",
" if (prop->info->type == PROP_TYPE_DRIVE) {",
" ptr = qdev_get_prop_ptr(bs->peer, prop);",
" if (*ptr == bs) {",
" bdrv_detach(bs, bs->peer);",
" *ptr = NULL;",
" break;",
" drive_uninit(drive_get_by_blockdev(bs));"
],
"line_no": [
9,
11,
51,
53,
55,
57,
59,
61,
63,
77
]
} | int FUNC_0(Monitor *VAR_0, const QDict *VAR_1, QObject **VAR_2)
{
const char *VAR_3 = qdict_get_str(VAR_1, "VAR_3");
BlockDriverState *bs;
BlockDriverState **ptr;
Property *prop;
bs = bdrv_find(VAR_3);
if (!bs) {
qerror_report(QERR_DEVICE_NOT_FOUND, VAR_3);
return -1;
}
if (bdrv_in_use(bs)) {
qerror_report(QERR_DEVICE_IN_USE, VAR_3);
return -1;
}
qemu_aio_flush();
bdrv_flush(bs);
bdrv_close(bs);
if (bs->peer) {
for (prop = bs->peer->info->props; prop && prop->name; prop++) {
if (prop->info->type == PROP_TYPE_DRIVE) {
ptr = qdev_get_prop_ptr(bs->peer, prop);
if (*ptr == bs) {
bdrv_detach(bs, bs->peer);
*ptr = NULL;
break;
}
}
}
}
drive_uninit(drive_get_by_blockdev(bs));
return 0;
}
| [
"int FUNC_0(Monitor *VAR_0, const QDict *VAR_1, QObject **VAR_2)\n{",
"const char *VAR_3 = qdict_get_str(VAR_1, \"VAR_3\");",
"BlockDriverState *bs;",
"BlockDriverState **ptr;",
"Property *prop;",
"bs = bdrv_find(VAR_3);",
"if (!bs) {",
"qerror_report(QERR_DEVICE_NOT_FOUND, VAR_3);",
"return -1;",
... | [
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
37
],
[
39
],
[
41
],
[
49
],
[
51
],
[
53
... |
2,030 | void error_setg_file_open(Error **errp, int os_errno, const char *filename)
{
error_setg_errno(errp, os_errno, "Could not open '%s'", filename);
}
| true | qemu | 1e9b65bb1bad51735cab6c861c29b592dccabf0e | void error_setg_file_open(Error **errp, int os_errno, const char *filename)
{
error_setg_errno(errp, os_errno, "Could not open '%s'", filename);
}
| {
"code": [
"void error_setg_file_open(Error **errp, int os_errno, const char *filename)",
" error_setg_errno(errp, os_errno, \"Could not open '%s'\", filename);"
],
"line_no": [
1,
5
]
} | void FUNC_0(Error **VAR_0, int VAR_1, const char *VAR_2)
{
error_setg_errno(VAR_0, VAR_1, "Could not open '%s'", VAR_2);
}
| [
"void FUNC_0(Error **VAR_0, int VAR_1, const char *VAR_2)\n{",
"error_setg_errno(VAR_0, VAR_1, \"Could not open '%s'\", VAR_2);",
"}"
] | [
1,
1,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
2,031 | int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx,
ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
{
uint8_t rps_predict = 0;
int delta_poc;
int k0 = 0;
int k1 = 0;
int k = 0;
int i;
if (rps != sps->st_rps && sps->nb_st_rps)
rps_predict = get_bits1(gb);
if (rps_predict) {
const ShortTermRPS *rps_ridx;
int delta_rps;
unsigned abs_delta_rps;
uint8_t use_delta_flag = 0;
uint8_t delta_rps_sign;
if (is_slice_header) {
unsigned int delta_idx = get_ue_golomb_long(gb) + 1;
if (delta_idx > sps->nb_st_rps) {
"Invalid value of delta_idx in slice header RPS: %d > %d.\n",
delta_idx, sps->nb_st_rps);
rps_ridx = &sps->st_rps[sps->nb_st_rps - delta_idx];
rps->rps_idx_num_delta_pocs = rps_ridx->num_delta_pocs;
} else
rps_ridx = &sps->st_rps[rps - sps->st_rps - 1];
delta_rps_sign = get_bits1(gb);
abs_delta_rps = get_ue_golomb_long(gb) + 1;
if (abs_delta_rps < 1 || abs_delta_rps > 32768) {
"Invalid value of abs_delta_rps: %d\n",
abs_delta_rps);
delta_rps = (1 - (delta_rps_sign << 1)) * abs_delta_rps;
for (i = 0; i <= rps_ridx->num_delta_pocs; i++) {
int used = rps->used[k] = get_bits1(gb);
if (!used)
use_delta_flag = get_bits1(gb);
if (used || use_delta_flag) {
if (i < rps_ridx->num_delta_pocs)
delta_poc = delta_rps + rps_ridx->delta_poc[i];
else
delta_poc = delta_rps;
rps->delta_poc[k] = delta_poc;
if (delta_poc < 0)
k0++;
else
k1++;
k++;
rps->num_delta_pocs = k;
rps->num_negative_pics = k0;
// sort in increasing order (smallest first)
if (rps->num_delta_pocs != 0) {
int used, tmp;
for (i = 1; i < rps->num_delta_pocs; i++) {
delta_poc = rps->delta_poc[i];
used = rps->used[i];
for (k = i - 1; k >= 0; k--) {
tmp = rps->delta_poc[k];
if (delta_poc < tmp) {
rps->delta_poc[k + 1] = tmp;
rps->used[k + 1] = rps->used[k];
rps->delta_poc[k] = delta_poc;
rps->used[k] = used;
if ((rps->num_negative_pics >> 1) != 0) {
int used;
k = rps->num_negative_pics - 1;
// flip the negative values to largest first
for (i = 0; i < rps->num_negative_pics >> 1; i++) {
delta_poc = rps->delta_poc[i];
used = rps->used[i];
rps->delta_poc[i] = rps->delta_poc[k];
rps->used[i] = rps->used[k];
rps->delta_poc[k] = delta_poc;
rps->used[k] = used;
k--;
} else {
unsigned int prev, nb_positive_pics;
rps->num_negative_pics = get_ue_golomb_long(gb);
nb_positive_pics = get_ue_golomb_long(gb);
if (rps->num_negative_pics >= HEVC_MAX_REFS ||
nb_positive_pics >= HEVC_MAX_REFS) {
av_log(avctx, AV_LOG_ERROR, "Too many refs in a short term RPS.\n");
rps->num_delta_pocs = rps->num_negative_pics + nb_positive_pics;
if (rps->num_delta_pocs) {
prev = 0;
for (i = 0; i < rps->num_negative_pics; i++) {
delta_poc = get_ue_golomb_long(gb) + 1;
prev -= delta_poc;
rps->delta_poc[i] = prev;
rps->used[i] = get_bits1(gb);
prev = 0;
for (i = 0; i < nb_positive_pics; i++) {
delta_poc = get_ue_golomb_long(gb) + 1;
prev += delta_poc;
rps->delta_poc[rps->num_negative_pics + i] = prev;
rps->used[rps->num_negative_pics + i] = get_bits1(gb);
return 0; | true | FFmpeg | 29808fff339da3e0f26131f7a6209b853947a54b | int ff_hevc_decode_short_term_rps(GetBitContext *gb, AVCodecContext *avctx,
ShortTermRPS *rps, const HEVCSPS *sps, int is_slice_header)
{
uint8_t rps_predict = 0;
int delta_poc;
int k0 = 0;
int k1 = 0;
int k = 0;
int i;
if (rps != sps->st_rps && sps->nb_st_rps)
rps_predict = get_bits1(gb);
if (rps_predict) {
const ShortTermRPS *rps_ridx;
int delta_rps;
unsigned abs_delta_rps;
uint8_t use_delta_flag = 0;
uint8_t delta_rps_sign;
if (is_slice_header) {
unsigned int delta_idx = get_ue_golomb_long(gb) + 1;
if (delta_idx > sps->nb_st_rps) {
"Invalid value of delta_idx in slice header RPS: %d > %d.\n",
delta_idx, sps->nb_st_rps);
rps_ridx = &sps->st_rps[sps->nb_st_rps - delta_idx];
rps->rps_idx_num_delta_pocs = rps_ridx->num_delta_pocs;
} else
rps_ridx = &sps->st_rps[rps - sps->st_rps - 1];
delta_rps_sign = get_bits1(gb);
abs_delta_rps = get_ue_golomb_long(gb) + 1;
if (abs_delta_rps < 1 || abs_delta_rps > 32768) {
"Invalid value of abs_delta_rps: %d\n",
abs_delta_rps);
delta_rps = (1 - (delta_rps_sign << 1)) * abs_delta_rps;
for (i = 0; i <= rps_ridx->num_delta_pocs; i++) {
int used = rps->used[k] = get_bits1(gb);
if (!used)
use_delta_flag = get_bits1(gb);
if (used || use_delta_flag) {
if (i < rps_ridx->num_delta_pocs)
delta_poc = delta_rps + rps_ridx->delta_poc[i];
else
delta_poc = delta_rps;
rps->delta_poc[k] = delta_poc;
if (delta_poc < 0)
k0++;
else
k1++;
k++;
rps->num_delta_pocs = k;
rps->num_negative_pics = k0;
if (rps->num_delta_pocs != 0) {
int used, tmp;
for (i = 1; i < rps->num_delta_pocs; i++) {
delta_poc = rps->delta_poc[i];
used = rps->used[i];
for (k = i - 1; k >= 0; k--) {
tmp = rps->delta_poc[k];
if (delta_poc < tmp) {
rps->delta_poc[k + 1] = tmp;
rps->used[k + 1] = rps->used[k];
rps->delta_poc[k] = delta_poc;
rps->used[k] = used;
if ((rps->num_negative_pics >> 1) != 0) {
int used;
k = rps->num_negative_pics - 1;
for (i = 0; i < rps->num_negative_pics >> 1; i++) {
delta_poc = rps->delta_poc[i];
used = rps->used[i];
rps->delta_poc[i] = rps->delta_poc[k];
rps->used[i] = rps->used[k];
rps->delta_poc[k] = delta_poc;
rps->used[k] = used;
k--;
} else {
unsigned int prev, nb_positive_pics;
rps->num_negative_pics = get_ue_golomb_long(gb);
nb_positive_pics = get_ue_golomb_long(gb);
if (rps->num_negative_pics >= HEVC_MAX_REFS ||
nb_positive_pics >= HEVC_MAX_REFS) {
av_log(avctx, AV_LOG_ERROR, "Too many refs in a short term RPS.\n");
rps->num_delta_pocs = rps->num_negative_pics + nb_positive_pics;
if (rps->num_delta_pocs) {
prev = 0;
for (i = 0; i < rps->num_negative_pics; i++) {
delta_poc = get_ue_golomb_long(gb) + 1;
prev -= delta_poc;
rps->delta_poc[i] = prev;
rps->used[i] = get_bits1(gb);
prev = 0;
for (i = 0; i < nb_positive_pics; i++) {
delta_poc = get_ue_golomb_long(gb) + 1;
prev += delta_poc;
rps->delta_poc[rps->num_negative_pics + i] = prev;
rps->used[rps->num_negative_pics + i] = get_bits1(gb);
return 0; | {
"code": [],
"line_no": []
} | int FUNC_0(GetBitContext *VAR_0, AVCodecContext *VAR_1,
ShortTermRPS *VAR_2, const HEVCSPS *VAR_3, int VAR_4)
{
uint8_t rps_predict = 0;
int VAR_5;
int VAR_6 = 0;
int VAR_7 = 0;
int VAR_8 = 0;
int VAR_9;
if (VAR_2 != VAR_3->st_rps && VAR_3->nb_st_rps)
rps_predict = get_bits1(VAR_0);
if (rps_predict) {
const ShortTermRPS *VAR_10;
int VAR_11;
unsigned VAR_12;
uint8_t use_delta_flag = 0;
uint8_t delta_rps_sign;
if (VAR_4) {
unsigned int VAR_13 = get_ue_golomb_long(VAR_0) + 1;
if (VAR_13 > VAR_3->nb_st_rps) {
"Invalid value of VAR_13 in slice header RPS: %d > %d.\n",
VAR_13, VAR_3->nb_st_rps);
VAR_10 = &VAR_3->st_rps[VAR_3->nb_st_rps - VAR_13];
VAR_2->rps_idx_num_delta_pocs = VAR_10->num_delta_pocs;
} else
VAR_10 = &VAR_3->st_rps[VAR_2 - VAR_3->st_rps - 1];
delta_rps_sign = get_bits1(VAR_0);
VAR_12 = get_ue_golomb_long(VAR_0) + 1;
if (VAR_12 < 1 || VAR_12 > 32768) {
"Invalid value of VAR_12: %d\n",
VAR_12);
VAR_11 = (1 - (delta_rps_sign << 1)) * VAR_12;
for (VAR_9 = 0; VAR_9 <= VAR_10->num_delta_pocs; VAR_9++) {
int used = VAR_2->used[VAR_8] = get_bits1(VAR_0);
if (!used)
use_delta_flag = get_bits1(VAR_0);
if (used || use_delta_flag) {
if (VAR_9 < VAR_10->num_delta_pocs)
VAR_5 = VAR_11 + VAR_10->VAR_5[VAR_9];
else
VAR_5 = VAR_11;
VAR_2->VAR_5[VAR_8] = VAR_5;
if (VAR_5 < 0)
VAR_6++;
else
VAR_7++;
VAR_8++;
VAR_2->num_delta_pocs = VAR_8;
VAR_2->num_negative_pics = VAR_6;
if (VAR_2->num_delta_pocs != 0) {
int used, tmp;
for (VAR_9 = 1; VAR_9 < VAR_2->num_delta_pocs; VAR_9++) {
VAR_5 = VAR_2->VAR_5[VAR_9];
used = VAR_2->used[VAR_9];
for (VAR_8 = VAR_9 - 1; VAR_8 >= 0; VAR_8--) {
tmp = VAR_2->VAR_5[VAR_8];
if (VAR_5 < tmp) {
VAR_2->VAR_5[VAR_8 + 1] = tmp;
VAR_2->used[VAR_8 + 1] = VAR_2->used[VAR_8];
VAR_2->VAR_5[VAR_8] = VAR_5;
VAR_2->used[VAR_8] = used;
if ((VAR_2->num_negative_pics >> 1) != 0) {
int used;
VAR_8 = VAR_2->num_negative_pics - 1;
for (VAR_9 = 0; VAR_9 < VAR_2->num_negative_pics >> 1; VAR_9++) {
VAR_5 = VAR_2->VAR_5[VAR_9];
used = VAR_2->used[VAR_9];
VAR_2->VAR_5[VAR_9] = VAR_2->VAR_5[VAR_8];
VAR_2->used[VAR_9] = VAR_2->used[VAR_8];
VAR_2->VAR_5[VAR_8] = VAR_5;
VAR_2->used[VAR_8] = used;
VAR_8--;
} else {
unsigned int prev, nb_positive_pics;
VAR_2->num_negative_pics = get_ue_golomb_long(VAR_0);
nb_positive_pics = get_ue_golomb_long(VAR_0);
if (VAR_2->num_negative_pics >= HEVC_MAX_REFS ||
nb_positive_pics >= HEVC_MAX_REFS) {
av_log(VAR_1, AV_LOG_ERROR, "Too many refs in a short term RPS.\n");
VAR_2->num_delta_pocs = VAR_2->num_negative_pics + nb_positive_pics;
if (VAR_2->num_delta_pocs) {
prev = 0;
for (VAR_9 = 0; VAR_9 < VAR_2->num_negative_pics; VAR_9++) {
VAR_5 = get_ue_golomb_long(VAR_0) + 1;
prev -= VAR_5;
VAR_2->VAR_5[VAR_9] = prev;
VAR_2->used[VAR_9] = get_bits1(VAR_0);
prev = 0;
for (VAR_9 = 0; VAR_9 < nb_positive_pics; VAR_9++) {
VAR_5 = get_ue_golomb_long(VAR_0) + 1;
prev += VAR_5;
VAR_2->VAR_5[VAR_2->num_negative_pics + VAR_9] = prev;
VAR_2->used[VAR_2->num_negative_pics + VAR_9] = get_bits1(VAR_0);
return 0; | [
"int FUNC_0(GetBitContext *VAR_0, AVCodecContext *VAR_1,\nShortTermRPS *VAR_2, const HEVCSPS *VAR_3, int VAR_4)\n{",
"uint8_t rps_predict = 0;",
"int VAR_5;",
"int VAR_6 = 0;",
"int VAR_7 = 0;",
"int VAR_8 = 0;",
"int VAR_9;",
"if (VAR_2 != VAR_3->st_rps && VAR_3->nb_st_rps)\nrps_predict = get_bits1(... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
2,
3
],
[
4
],
[
5
],
[
6
],
[
7
],
[
8
],
[
9
],
[
10,
11
],
[
12
],
[
13
],
[
14
],
[
15
],
[
16
],
[
17
],
[
18
],
[
19
],
[
20
],
[
21,
22
],
[
... |
2,032 | static int qcow_check(BlockDriverState *bs)
{
return qcow2_check_refcounts(bs);
}
| true | qemu | 9ac228e02cf16202547e7025ef300369e0db7781 | static int qcow_check(BlockDriverState *bs)
{
return qcow2_check_refcounts(bs);
}
| {
"code": [
"static int qcow_check(BlockDriverState *bs)",
" return qcow2_check_refcounts(bs);"
],
"line_no": [
1,
5
]
} | static int FUNC_0(BlockDriverState *VAR_0)
{
return qcow2_check_refcounts(VAR_0);
}
| [
"static int FUNC_0(BlockDriverState *VAR_0)\n{",
"return qcow2_check_refcounts(VAR_0);",
"}"
] | [
1,
1,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
2,033 | static void pl061_save(QEMUFile *f, void *opaque)
{
pl061_state *s = (pl061_state *)opaque;
qemu_put_be32(f, s->locked);
qemu_put_be32(f, s->data);
qemu_put_be32(f, s->old_data);
qemu_put_be32(f, s->dir);
qemu_put_be32(f, s->isense);
qemu_put_be32(f, s->ibe);
qemu_put_be32(f, s->iev);
qemu_put_be32(f, s->im);
qemu_put_be32(f, s->istate);
qemu_put_be32(f, s->afsel);
qemu_put_be32(f, s->dr2r);
qemu_put_be32(f, s->dr4r);
qemu_put_be32(f, s->dr8r);
qemu_put_be32(f, s->odr);
qemu_put_be32(f, s->pur);
qemu_put_be32(f, s->pdr);
qemu_put_be32(f, s->slr);
qemu_put_be32(f, s->den);
qemu_put_be32(f, s->cr);
qemu_put_be32(f, s->float_high);
}
| false | qemu | a35faa94c8e8d851a1d07e17c98f4ab2202b8a38 | static void pl061_save(QEMUFile *f, void *opaque)
{
pl061_state *s = (pl061_state *)opaque;
qemu_put_be32(f, s->locked);
qemu_put_be32(f, s->data);
qemu_put_be32(f, s->old_data);
qemu_put_be32(f, s->dir);
qemu_put_be32(f, s->isense);
qemu_put_be32(f, s->ibe);
qemu_put_be32(f, s->iev);
qemu_put_be32(f, s->im);
qemu_put_be32(f, s->istate);
qemu_put_be32(f, s->afsel);
qemu_put_be32(f, s->dr2r);
qemu_put_be32(f, s->dr4r);
qemu_put_be32(f, s->dr8r);
qemu_put_be32(f, s->odr);
qemu_put_be32(f, s->pur);
qemu_put_be32(f, s->pdr);
qemu_put_be32(f, s->slr);
qemu_put_be32(f, s->den);
qemu_put_be32(f, s->cr);
qemu_put_be32(f, s->float_high);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(QEMUFile *VAR_0, void *VAR_1)
{
pl061_state *s = (pl061_state *)VAR_1;
qemu_put_be32(VAR_0, s->locked);
qemu_put_be32(VAR_0, s->data);
qemu_put_be32(VAR_0, s->old_data);
qemu_put_be32(VAR_0, s->dir);
qemu_put_be32(VAR_0, s->isense);
qemu_put_be32(VAR_0, s->ibe);
qemu_put_be32(VAR_0, s->iev);
qemu_put_be32(VAR_0, s->im);
qemu_put_be32(VAR_0, s->istate);
qemu_put_be32(VAR_0, s->afsel);
qemu_put_be32(VAR_0, s->dr2r);
qemu_put_be32(VAR_0, s->dr4r);
qemu_put_be32(VAR_0, s->dr8r);
qemu_put_be32(VAR_0, s->odr);
qemu_put_be32(VAR_0, s->pur);
qemu_put_be32(VAR_0, s->pdr);
qemu_put_be32(VAR_0, s->slr);
qemu_put_be32(VAR_0, s->den);
qemu_put_be32(VAR_0, s->cr);
qemu_put_be32(VAR_0, s->float_high);
}
| [
"static void FUNC_0(QEMUFile *VAR_0, void *VAR_1)\n{",
"pl061_state *s = (pl061_state *)VAR_1;",
"qemu_put_be32(VAR_0, s->locked);",
"qemu_put_be32(VAR_0, s->data);",
"qemu_put_be32(VAR_0, s->old_data);",
"qemu_put_be32(VAR_0, s->dir);",
"qemu_put_be32(VAR_0, s->isense);",
"qemu_put_be32(VAR_0, s->ibe... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43... |
2,035 | void cpu_reset(CPUSPARCState *env)
{
tlb_flush(env, 1);
env->cwp = 0;
env->wim = 1;
env->regwptr = env->regbase + (env->cwp * 16);
#if defined(CONFIG_USER_ONLY)
env->user_mode_only = 1;
#ifdef TARGET_SPARC64
env->cleanwin = env->nwindows - 2;
env->cansave = env->nwindows - 2;
env->pstate = PS_RMO | PS_PEF | PS_IE;
env->asi = 0x82; // Primary no-fault
#endif
#else
env->psret = 0;
env->psrs = 1;
env->psrps = 1;
#ifdef TARGET_SPARC64
env->pstate = PS_PRIV;
env->hpstate = HS_PRIV;
env->pc = 0x1fff0000020ULL; // XXX should be different for system_reset
env->tsptr = &env->ts[env->tl];
#else
env->pc = 0;
env->mmuregs[0] &= ~(MMU_E | MMU_NF);
env->mmuregs[0] |= env->mmu_bm;
#endif
env->npc = env->pc + 4;
#endif
}
| false | qemu | c19148bd8f5c2800265372d3554035efde1c5517 | void cpu_reset(CPUSPARCState *env)
{
tlb_flush(env, 1);
env->cwp = 0;
env->wim = 1;
env->regwptr = env->regbase + (env->cwp * 16);
#if defined(CONFIG_USER_ONLY)
env->user_mode_only = 1;
#ifdef TARGET_SPARC64
env->cleanwin = env->nwindows - 2;
env->cansave = env->nwindows - 2;
env->pstate = PS_RMO | PS_PEF | PS_IE;
env->asi = 0x82;
#endif
#else
env->psret = 0;
env->psrs = 1;
env->psrps = 1;
#ifdef TARGET_SPARC64
env->pstate = PS_PRIV;
env->hpstate = HS_PRIV;
env->pc = 0x1fff0000020ULL;
env->tsptr = &env->ts[env->tl];
#else
env->pc = 0;
env->mmuregs[0] &= ~(MMU_E | MMU_NF);
env->mmuregs[0] |= env->mmu_bm;
#endif
env->npc = env->pc + 4;
#endif
}
| {
"code": [],
"line_no": []
} | void FUNC_0(CPUSPARCState *VAR_0)
{
tlb_flush(VAR_0, 1);
VAR_0->cwp = 0;
VAR_0->wim = 1;
VAR_0->regwptr = VAR_0->regbase + (VAR_0->cwp * 16);
#if defined(CONFIG_USER_ONLY)
VAR_0->user_mode_only = 1;
#ifdef TARGET_SPARC64
VAR_0->cleanwin = VAR_0->nwindows - 2;
VAR_0->cansave = VAR_0->nwindows - 2;
VAR_0->pstate = PS_RMO | PS_PEF | PS_IE;
VAR_0->asi = 0x82;
#endif
#else
VAR_0->psret = 0;
VAR_0->psrs = 1;
VAR_0->psrps = 1;
#ifdef TARGET_SPARC64
VAR_0->pstate = PS_PRIV;
VAR_0->hpstate = HS_PRIV;
VAR_0->pc = 0x1fff0000020ULL;
VAR_0->tsptr = &VAR_0->ts[VAR_0->tl];
#else
VAR_0->pc = 0;
VAR_0->mmuregs[0] &= ~(MMU_E | MMU_NF);
VAR_0->mmuregs[0] |= VAR_0->mmu_bm;
#endif
VAR_0->npc = VAR_0->pc + 4;
#endif
}
| [
"void FUNC_0(CPUSPARCState *VAR_0)\n{",
"tlb_flush(VAR_0, 1);",
"VAR_0->cwp = 0;",
"VAR_0->wim = 1;",
"VAR_0->regwptr = VAR_0->regbase + (VAR_0->cwp * 16);",
"#if defined(CONFIG_USER_ONLY)\nVAR_0->user_mode_only = 1;",
"#ifdef TARGET_SPARC64\nVAR_0->cleanwin = VAR_0->nwindows - 2;",
"VAR_0->cansave = ... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13,
15
],
[
17,
19
],
[
21
],
[
23
],
[
25
],
[
27,
29,
31
],
[
33
],
[
35
],
[
37,
39
],
[
41
],
[
43
],
[
45
],
[... |
2,036 | static void glib_select_poll(fd_set *rfds, fd_set *wfds, fd_set *xfds,
bool err)
{
GMainContext *context = g_main_context_default();
if (!err) {
int i;
for (i = 0; i < n_poll_fds; i++) {
GPollFD *p = &poll_fds[i];
if ((p->events & G_IO_IN) && FD_ISSET(p->fd, rfds)) {
p->revents |= G_IO_IN;
}
if ((p->events & G_IO_OUT) && FD_ISSET(p->fd, wfds)) {
p->revents |= G_IO_OUT;
}
if ((p->events & G_IO_ERR) && FD_ISSET(p->fd, xfds)) {
p->revents |= G_IO_ERR;
}
}
}
if (g_main_context_check(context, max_priority, poll_fds, n_poll_fds)) {
g_main_context_dispatch(context);
}
}
| false | qemu | 48ce11ff972c733afaed3e2a2613a2e56081ec92 | static void glib_select_poll(fd_set *rfds, fd_set *wfds, fd_set *xfds,
bool err)
{
GMainContext *context = g_main_context_default();
if (!err) {
int i;
for (i = 0; i < n_poll_fds; i++) {
GPollFD *p = &poll_fds[i];
if ((p->events & G_IO_IN) && FD_ISSET(p->fd, rfds)) {
p->revents |= G_IO_IN;
}
if ((p->events & G_IO_OUT) && FD_ISSET(p->fd, wfds)) {
p->revents |= G_IO_OUT;
}
if ((p->events & G_IO_ERR) && FD_ISSET(p->fd, xfds)) {
p->revents |= G_IO_ERR;
}
}
}
if (g_main_context_check(context, max_priority, poll_fds, n_poll_fds)) {
g_main_context_dispatch(context);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(fd_set *VAR_0, fd_set *VAR_1, fd_set *VAR_2,
bool VAR_3)
{
GMainContext *context = g_main_context_default();
if (!VAR_3) {
int VAR_4;
for (VAR_4 = 0; VAR_4 < n_poll_fds; VAR_4++) {
GPollFD *p = &poll_fds[VAR_4];
if ((p->events & G_IO_IN) && FD_ISSET(p->fd, VAR_0)) {
p->revents |= G_IO_IN;
}
if ((p->events & G_IO_OUT) && FD_ISSET(p->fd, VAR_1)) {
p->revents |= G_IO_OUT;
}
if ((p->events & G_IO_ERR) && FD_ISSET(p->fd, VAR_2)) {
p->revents |= G_IO_ERR;
}
}
}
if (g_main_context_check(context, max_priority, poll_fds, n_poll_fds)) {
g_main_context_dispatch(context);
}
}
| [
"static void FUNC_0(fd_set *VAR_0, fd_set *VAR_1, fd_set *VAR_2,\nbool VAR_3)\n{",
"GMainContext *context = g_main_context_default();",
"if (!VAR_3) {",
"int VAR_4;",
"for (VAR_4 = 0; VAR_4 < n_poll_fds; VAR_4++) {",
"GPollFD *p = &poll_fds[VAR_4];",
"if ((p->events & G_IO_IN) && FD_ISSET(p->fd, VAR_0))... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
11
],
[
13
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
47
],
[
49
],
... |
2,037 | static void set_lcd_pixel(musicpal_lcd_state *s, int x, int y, int col)
{
int dx, dy;
for (dy = 0; dy < 3; dy++)
for (dx = 0; dx < 3; dx++) {
s->ds->data[(x*3 + dx + (y*3 + dy) * 128*3) * 4 + 0] =
scale_lcd_color(col);
s->ds->data[(x*3 + dx + (y*3 + dy) * 128*3) * 4 + 1] =
scale_lcd_color(col >> 8);
s->ds->data[(x*3 + dx + (y*3 + dy) * 128*3) * 4 + 2] =
scale_lcd_color(col >> 16);
}
}
| false | qemu | 0266f2c733911ca3f70e009e3230c790c800e524 | static void set_lcd_pixel(musicpal_lcd_state *s, int x, int y, int col)
{
int dx, dy;
for (dy = 0; dy < 3; dy++)
for (dx = 0; dx < 3; dx++) {
s->ds->data[(x*3 + dx + (y*3 + dy) * 128*3) * 4 + 0] =
scale_lcd_color(col);
s->ds->data[(x*3 + dx + (y*3 + dy) * 128*3) * 4 + 1] =
scale_lcd_color(col >> 8);
s->ds->data[(x*3 + dx + (y*3 + dy) * 128*3) * 4 + 2] =
scale_lcd_color(col >> 16);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(musicpal_lcd_state *VAR_0, int VAR_1, int VAR_2, int VAR_3)
{
int VAR_4, VAR_5;
for (VAR_5 = 0; VAR_5 < 3; VAR_5++)
for (VAR_4 = 0; VAR_4 < 3; VAR_4++) {
VAR_0->ds->data[(VAR_1*3 + VAR_4 + (VAR_2*3 + VAR_5) * 128*3) * 4 + 0] =
scale_lcd_color(VAR_3);
VAR_0->ds->data[(VAR_1*3 + VAR_4 + (VAR_2*3 + VAR_5) * 128*3) * 4 + 1] =
scale_lcd_color(VAR_3 >> 8);
VAR_0->ds->data[(VAR_1*3 + VAR_4 + (VAR_2*3 + VAR_5) * 128*3) * 4 + 2] =
scale_lcd_color(VAR_3 >> 16);
}
}
| [
"static void FUNC_0(musicpal_lcd_state *VAR_0, int VAR_1, int VAR_2, int VAR_3)\n{",
"int VAR_4, VAR_5;",
"for (VAR_5 = 0; VAR_5 < 3; VAR_5++)",
"for (VAR_4 = 0; VAR_4 < 3; VAR_4++) {",
"VAR_0->ds->data[(VAR_1*3 + VAR_4 + (VAR_2*3 + VAR_5) * 128*3) * 4 + 0] =\nscale_lcd_color(VAR_3);",
"VAR_0->ds->data[(V... | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13,
15
],
[
17,
19
],
[
21,
23
],
[
25
],
[
27
]
] |
2,038 | static inline uint32_t celt_icwrsi(uint32_t N, const int *y)
{
int i, idx = 0, sum = 0;
for (i = N - 1; i >= 0; i--) {
const uint32_t i_s = CELT_PVQ_U(N - i, sum + FFABS(y[i]) + 1);
idx += CELT_PVQ_U(N - i, sum) + (y[i] < 0)*i_s;
sum += FFABS(y[i]);
}
return idx;
}
| false | FFmpeg | 67fa02ed794f9505bd9c3584c14bfb61c895f5bc | static inline uint32_t celt_icwrsi(uint32_t N, const int *y)
{
int i, idx = 0, sum = 0;
for (i = N - 1; i >= 0; i--) {
const uint32_t i_s = CELT_PVQ_U(N - i, sum + FFABS(y[i]) + 1);
idx += CELT_PVQ_U(N - i, sum) + (y[i] < 0)*i_s;
sum += FFABS(y[i]);
}
return idx;
}
| {
"code": [],
"line_no": []
} | static inline uint32_t FUNC_0(uint32_t N, const int *y)
{
int VAR_0, VAR_1 = 0, VAR_2 = 0;
for (VAR_0 = N - 1; VAR_0 >= 0; VAR_0--) {
const uint32_t VAR_3 = CELT_PVQ_U(N - VAR_0, VAR_2 + FFABS(y[VAR_0]) + 1);
VAR_1 += CELT_PVQ_U(N - VAR_0, VAR_2) + (y[VAR_0] < 0)*VAR_3;
VAR_2 += FFABS(y[VAR_0]);
}
return VAR_1;
}
| [
"static inline uint32_t FUNC_0(uint32_t N, const int *y)\n{",
"int VAR_0, VAR_1 = 0, VAR_2 = 0;",
"for (VAR_0 = N - 1; VAR_0 >= 0; VAR_0--) {",
"const uint32_t VAR_3 = CELT_PVQ_U(N - VAR_0, VAR_2 + FFABS(y[VAR_0]) + 1);",
"VAR_1 += CELT_PVQ_U(N - VAR_0, VAR_2) + (y[VAR_0] < 0)*VAR_3;",
"VAR_2 += FFABS(y[V... | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
]
] |
2,039 | static void test_qemu_strtoul_hex(void)
{
const char *str = "0123";
char f = 'X';
const char *endptr = &f;
unsigned long res = 999;
int err;
err = qemu_strtoul(str, &endptr, 16, &res);
g_assert_cmpint(err, ==, 0);
g_assert_cmpint(res, ==, 0x123);
g_assert(endptr == str + strlen(str));
str = "0x123";
res = 999;
endptr = &f;
err = qemu_strtoul(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, 0);
g_assert_cmpint(res, ==, 0x123);
g_assert(endptr == str + strlen(str));
}
| false | qemu | bc7c08a2c375acb7ae4d433054415588b176d34c | static void test_qemu_strtoul_hex(void)
{
const char *str = "0123";
char f = 'X';
const char *endptr = &f;
unsigned long res = 999;
int err;
err = qemu_strtoul(str, &endptr, 16, &res);
g_assert_cmpint(err, ==, 0);
g_assert_cmpint(res, ==, 0x123);
g_assert(endptr == str + strlen(str));
str = "0x123";
res = 999;
endptr = &f;
err = qemu_strtoul(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, 0);
g_assert_cmpint(res, ==, 0x123);
g_assert(endptr == str + strlen(str));
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void)
{
const char *VAR_0 = "0123";
char VAR_1 = 'X';
const char *VAR_2 = &VAR_1;
unsigned long VAR_3 = 999;
int VAR_4;
VAR_4 = qemu_strtoul(VAR_0, &VAR_2, 16, &VAR_3);
g_assert_cmpint(VAR_4, ==, 0);
g_assert_cmpint(VAR_3, ==, 0x123);
g_assert(VAR_2 == VAR_0 + strlen(VAR_0));
VAR_0 = "0x123";
VAR_3 = 999;
VAR_2 = &VAR_1;
VAR_4 = qemu_strtoul(VAR_0, &VAR_2, 0, &VAR_3);
g_assert_cmpint(VAR_4, ==, 0);
g_assert_cmpint(VAR_3, ==, 0x123);
g_assert(VAR_2 == VAR_0 + strlen(VAR_0));
}
| [
"static void FUNC_0(void)\n{",
"const char *VAR_0 = \"0123\";",
"char VAR_1 = 'X';",
"const char *VAR_2 = &VAR_1;",
"unsigned long VAR_3 = 999;",
"int VAR_4;",
"VAR_4 = qemu_strtoul(VAR_0, &VAR_2, 16, &VAR_3);",
"g_assert_cmpint(VAR_4, ==, 0);",
"g_assert_cmpint(VAR_3, ==, 0x123);",
"g_assert(VAR_... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
]
] |
2,040 | static void mvp_init (CPUMIPSState *env, const mips_def_t *def)
{
env->mvp = qemu_mallocz(sizeof(CPUMIPSMVPContext));
/* MVPConf1 implemented, TLB sharable, no gating storage support,
programmable cache partitioning implemented, number of allocatable
and sharable TLB entries, MVP has allocatable TCs, 2 VPEs
implemented, 5 TCs implemented. */
env->mvp->CP0_MVPConf0 = (1 << CP0MVPC0_M) | (1 << CP0MVPC0_TLBS) |
(0 << CP0MVPC0_GS) | (1 << CP0MVPC0_PCP) |
// TODO: actually do 2 VPEs.
// (1 << CP0MVPC0_TCA) | (0x1 << CP0MVPC0_PVPE) |
// (0x04 << CP0MVPC0_PTC);
(1 << CP0MVPC0_TCA) | (0x0 << CP0MVPC0_PVPE) |
(0x04 << CP0MVPC0_PTC);
/* Usermode has no TLB support */
if (!env->user_mode_only)
env->mvp->CP0_MVPConf0 |= (env->tlb->nb_tlb << CP0MVPC0_PTLBE);
/* Allocatable CP1 have media extensions, allocatable CP1 have FP support,
no UDI implemented, no CP2 implemented, 1 CP1 implemented. */
env->mvp->CP0_MVPConf1 = (1 << CP0MVPC1_CIM) | (1 << CP0MVPC1_CIF) |
(0x0 << CP0MVPC1_PCX) | (0x0 << CP0MVPC1_PCP2) |
(0x1 << CP0MVPC1_PCP1);
}
| false | qemu | 932e71cd57bab4e6206e1355c6425290721bbe34 | static void mvp_init (CPUMIPSState *env, const mips_def_t *def)
{
env->mvp = qemu_mallocz(sizeof(CPUMIPSMVPContext));
env->mvp->CP0_MVPConf0 = (1 << CP0MVPC0_M) | (1 << CP0MVPC0_TLBS) |
(0 << CP0MVPC0_GS) | (1 << CP0MVPC0_PCP) |
(1 << CP0MVPC0_TCA) | (0x0 << CP0MVPC0_PVPE) |
(0x04 << CP0MVPC0_PTC);
if (!env->user_mode_only)
env->mvp->CP0_MVPConf0 |= (env->tlb->nb_tlb << CP0MVPC0_PTLBE);
env->mvp->CP0_MVPConf1 = (1 << CP0MVPC1_CIM) | (1 << CP0MVPC1_CIF) |
(0x0 << CP0MVPC1_PCX) | (0x0 << CP0MVPC1_PCP2) |
(0x1 << CP0MVPC1_PCP1);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0 (CPUMIPSState *VAR_0, const mips_def_t *VAR_1)
{
VAR_0->mvp = qemu_mallocz(sizeof(CPUMIPSMVPContext));
VAR_0->mvp->CP0_MVPConf0 = (1 << CP0MVPC0_M) | (1 << CP0MVPC0_TLBS) |
(0 << CP0MVPC0_GS) | (1 << CP0MVPC0_PCP) |
(1 << CP0MVPC0_TCA) | (0x0 << CP0MVPC0_PVPE) |
(0x04 << CP0MVPC0_PTC);
if (!VAR_0->user_mode_only)
VAR_0->mvp->CP0_MVPConf0 |= (VAR_0->tlb->nb_tlb << CP0MVPC0_PTLBE);
VAR_0->mvp->CP0_MVPConf1 = (1 << CP0MVPC1_CIM) | (1 << CP0MVPC1_CIF) |
(0x0 << CP0MVPC1_PCX) | (0x0 << CP0MVPC1_PCP2) |
(0x1 << CP0MVPC1_PCP1);
}
| [
"static void FUNC_0 (CPUMIPSState *VAR_0, const mips_def_t *VAR_1)\n{",
"VAR_0->mvp = qemu_mallocz(sizeof(CPUMIPSMVPContext));",
"VAR_0->mvp->CP0_MVPConf0 = (1 << CP0MVPC0_M) | (1 << CP0MVPC0_TLBS) |\n(0 << CP0MVPC0_GS) | (1 << CP0MVPC0_PCP) |\n(1 << CP0MVPC0_TCA) | (0x0 << CP0MVPC0_PVPE) |\n(0x04 << CP0MVPC0_P... | [
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
17,
19,
27,
29
],
[
33,
35
],
[
43,
45,
47
],
[
49
]
] |
2,041 | static void i440fx_pcihost_get_pci_hole64_start(Object *obj, Visitor *v,
const char *name,
void *opaque, Error **errp)
{
PCIHostState *h = PCI_HOST_BRIDGE(obj);
Range w64;
pci_bus_get_w64_range(h->bus, &w64);
visit_type_uint64(v, name, &w64.begin, errp);
}
| false | qemu | a0efbf16604770b9d805bcf210ec29942321134f | static void i440fx_pcihost_get_pci_hole64_start(Object *obj, Visitor *v,
const char *name,
void *opaque, Error **errp)
{
PCIHostState *h = PCI_HOST_BRIDGE(obj);
Range w64;
pci_bus_get_w64_range(h->bus, &w64);
visit_type_uint64(v, name, &w64.begin, errp);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(Object *VAR_0, Visitor *VAR_1,
const char *VAR_2,
void *VAR_3, Error **VAR_4)
{
PCIHostState *h = PCI_HOST_BRIDGE(VAR_0);
Range w64;
pci_bus_get_w64_range(h->bus, &w64);
visit_type_uint64(VAR_1, VAR_2, &w64.begin, VAR_4);
}
| [
"static void FUNC_0(Object *VAR_0, Visitor *VAR_1,\nconst char *VAR_2,\nvoid *VAR_3, Error **VAR_4)\n{",
"PCIHostState *h = PCI_HOST_BRIDGE(VAR_0);",
"Range w64;",
"pci_bus_get_w64_range(h->bus, &w64);",
"visit_type_uint64(VAR_1, VAR_2, &w64.begin, VAR_4);",
"}"
] | [
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
15
],
[
19
],
[
21
]
] |
2,042 | static void spapr_phb_remove_pci_device(sPAPRDRConnector *drc,
sPAPRPHBState *phb,
PCIDevice *pdev,
Error **errp)
{
sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
drck->detach(drc, DEVICE(pdev), spapr_phb_remove_pci_device_cb, phb, errp);
}
| false | qemu | 318347234d7069b62d38391dd27e269a3107d668 | static void spapr_phb_remove_pci_device(sPAPRDRConnector *drc,
sPAPRPHBState *phb,
PCIDevice *pdev,
Error **errp)
{
sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
drck->detach(drc, DEVICE(pdev), spapr_phb_remove_pci_device_cb, phb, errp);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(sPAPRDRConnector *VAR_0,
sPAPRPHBState *VAR_1,
PCIDevice *VAR_2,
Error **VAR_3)
{
sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(VAR_0);
drck->detach(VAR_0, DEVICE(VAR_2), spapr_phb_remove_pci_device_cb, VAR_1, VAR_3);
}
| [
"static void FUNC_0(sPAPRDRConnector *VAR_0,\nsPAPRPHBState *VAR_1,\nPCIDevice *VAR_2,\nError **VAR_3)\n{",
"sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(VAR_0);",
"drck->detach(VAR_0, DEVICE(VAR_2), spapr_phb_remove_pci_device_cb, VAR_1, VAR_3);",
"}"
] | [
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11
],
[
15
],
[
17
]
] |
2,043 | static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
const char *desc_file_path, Error **errp)
{
int ret;
char access[11];
char type[11];
char fname[512];
const char *p = desc;
int64_t sectors = 0;
int64_t flat_offset;
char extent_path[PATH_MAX];
BlockDriverState *extent_file;
BDRVVmdkState *s = bs->opaque;
VmdkExtent *extent;
while (*p) {
/* parse extent line:
* RW [size in sectors] FLAT "file-name.vmdk" OFFSET
* or
* RW [size in sectors] SPARSE "file-name.vmdk"
*/
flat_offset = -1;
ret = sscanf(p, "%10s %" SCNd64 " %10s \"%511[^\n\r\"]\" %" SCNd64,
access, §ors, type, fname, &flat_offset);
if (ret < 4 || strcmp(access, "RW")) {
goto next_line;
} else if (!strcmp(type, "FLAT")) {
if (ret != 5 || flat_offset < 0) {
error_setg(errp, "Invalid extent lines: \n%s", p);
return -EINVAL;
}
} else if (!strcmp(type, "VMFS")) {
flat_offset = 0;
} else if (ret != 4) {
error_setg(errp, "Invalid extent lines: \n%s", p);
return -EINVAL;
}
if (sectors <= 0 ||
(strcmp(type, "FLAT") && strcmp(type, "SPARSE") &&
strcmp(type, "VMFS") && strcmp(type, "VMFSSPARSE")) ||
(strcmp(access, "RW"))) {
goto next_line;
}
path_combine(extent_path, sizeof(extent_path),
desc_file_path, fname);
ret = bdrv_file_open(&extent_file, extent_path, NULL, bs->open_flags,
errp);
if (ret) {
return ret;
}
/* save to extents array */
if (!strcmp(type, "FLAT") || !strcmp(type, "VMFS")) {
/* FLAT extent */
ret = vmdk_add_extent(bs, extent_file, true, sectors,
0, 0, 0, 0, 0, &extent, errp);
if (ret < 0) {
return ret;
}
extent->flat_start_offset = flat_offset << 9;
} else if (!strcmp(type, "SPARSE") || !strcmp(type, "VMFSSPARSE")) {
/* SPARSE extent and VMFSSPARSE extent are both "COWD" sparse file*/
ret = vmdk_open_sparse(bs, extent_file, bs->open_flags, errp);
if (ret) {
bdrv_unref(extent_file);
return ret;
}
extent = &s->extents[s->num_extents - 1];
} else {
error_setg(errp, "Unsupported extent type '%s'", type);
return -ENOTSUP;
}
extent->type = g_strdup(type);
next_line:
/* move to next line */
while (*p) {
if (*p == '\n') {
p++;
break;
}
p++;
}
}
return 0;
}
| false | qemu | b47053bd0359c68094d7a25a65687c0844771e34 | static int vmdk_parse_extents(const char *desc, BlockDriverState *bs,
const char *desc_file_path, Error **errp)
{
int ret;
char access[11];
char type[11];
char fname[512];
const char *p = desc;
int64_t sectors = 0;
int64_t flat_offset;
char extent_path[PATH_MAX];
BlockDriverState *extent_file;
BDRVVmdkState *s = bs->opaque;
VmdkExtent *extent;
while (*p) {
flat_offset = -1;
ret = sscanf(p, "%10s %" SCNd64 " %10s \"%511[^\n\r\"]\" %" SCNd64,
access, §ors, type, fname, &flat_offset);
if (ret < 4 || strcmp(access, "RW")) {
goto next_line;
} else if (!strcmp(type, "FLAT")) {
if (ret != 5 || flat_offset < 0) {
error_setg(errp, "Invalid extent lines: \n%s", p);
return -EINVAL;
}
} else if (!strcmp(type, "VMFS")) {
flat_offset = 0;
} else if (ret != 4) {
error_setg(errp, "Invalid extent lines: \n%s", p);
return -EINVAL;
}
if (sectors <= 0 ||
(strcmp(type, "FLAT") && strcmp(type, "SPARSE") &&
strcmp(type, "VMFS") && strcmp(type, "VMFSSPARSE")) ||
(strcmp(access, "RW"))) {
goto next_line;
}
path_combine(extent_path, sizeof(extent_path),
desc_file_path, fname);
ret = bdrv_file_open(&extent_file, extent_path, NULL, bs->open_flags,
errp);
if (ret) {
return ret;
}
if (!strcmp(type, "FLAT") || !strcmp(type, "VMFS")) {
ret = vmdk_add_extent(bs, extent_file, true, sectors,
0, 0, 0, 0, 0, &extent, errp);
if (ret < 0) {
return ret;
}
extent->flat_start_offset = flat_offset << 9;
} else if (!strcmp(type, "SPARSE") || !strcmp(type, "VMFSSPARSE")) {
ret = vmdk_open_sparse(bs, extent_file, bs->open_flags, errp);
if (ret) {
bdrv_unref(extent_file);
return ret;
}
extent = &s->extents[s->num_extents - 1];
} else {
error_setg(errp, "Unsupported extent type '%s'", type);
return -ENOTSUP;
}
extent->type = g_strdup(type);
next_line:
while (*p) {
if (*p == '\n') {
p++;
break;
}
p++;
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(const char *VAR_0, BlockDriverState *VAR_1,
const char *VAR_2, Error **VAR_3)
{
int VAR_4;
char VAR_5[11];
char VAR_6[11];
char VAR_7[512];
const char *VAR_8 = VAR_0;
int64_t sectors = 0;
int64_t flat_offset;
char VAR_9[PATH_MAX];
BlockDriverState *extent_file;
BDRVVmdkState *s = VAR_1->opaque;
VmdkExtent *extent;
while (*VAR_8) {
flat_offset = -1;
VAR_4 = sscanf(VAR_8, "%10s %" SCNd64 " %10s \"%511[^\n\r\"]\" %" SCNd64,
VAR_5, §ors, VAR_6, VAR_7, &flat_offset);
if (VAR_4 < 4 || strcmp(VAR_5, "RW")) {
goto next_line;
} else if (!strcmp(VAR_6, "FLAT")) {
if (VAR_4 != 5 || flat_offset < 0) {
error_setg(VAR_3, "Invalid extent lines: \n%s", VAR_8);
return -EINVAL;
}
} else if (!strcmp(VAR_6, "VMFS")) {
flat_offset = 0;
} else if (VAR_4 != 4) {
error_setg(VAR_3, "Invalid extent lines: \n%s", VAR_8);
return -EINVAL;
}
if (sectors <= 0 ||
(strcmp(VAR_6, "FLAT") && strcmp(VAR_6, "SPARSE") &&
strcmp(VAR_6, "VMFS") && strcmp(VAR_6, "VMFSSPARSE")) ||
(strcmp(VAR_5, "RW"))) {
goto next_line;
}
path_combine(VAR_9, sizeof(VAR_9),
VAR_2, VAR_7);
VAR_4 = bdrv_file_open(&extent_file, VAR_9, NULL, VAR_1->open_flags,
VAR_3);
if (VAR_4) {
return VAR_4;
}
if (!strcmp(VAR_6, "FLAT") || !strcmp(VAR_6, "VMFS")) {
VAR_4 = vmdk_add_extent(VAR_1, extent_file, true, sectors,
0, 0, 0, 0, 0, &extent, VAR_3);
if (VAR_4 < 0) {
return VAR_4;
}
extent->flat_start_offset = flat_offset << 9;
} else if (!strcmp(VAR_6, "SPARSE") || !strcmp(VAR_6, "VMFSSPARSE")) {
VAR_4 = vmdk_open_sparse(VAR_1, extent_file, VAR_1->open_flags, VAR_3);
if (VAR_4) {
bdrv_unref(extent_file);
return VAR_4;
}
extent = &s->extents[s->num_extents - 1];
} else {
error_setg(VAR_3, "Unsupported extent VAR_6 '%s'", VAR_6);
return -ENOTSUP;
}
extent->VAR_6 = g_strdup(VAR_6);
next_line:
while (*VAR_8) {
if (*VAR_8 == '\n') {
VAR_8++;
break;
}
VAR_8++;
}
}
return 0;
}
| [
"static int FUNC_0(const char *VAR_0, BlockDriverState *VAR_1,\nconst char *VAR_2, Error **VAR_3)\n{",
"int VAR_4;",
"char VAR_5[11];",
"char VAR_6[11];",
"char VAR_7[512];",
"const char *VAR_8 = VAR_0;",
"int64_t sectors = 0;",
"int64_t flat_offset;",
"char VAR_9[PATH_MAX];",
"BlockDriverState *e... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0... | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
43
],
[
45,
47
],
[
49
],
[
51
],
[
53
],
[
55
... |
2,044 | void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs)
{
bdrv_do_release_matching_dirty_bitmap(bs, NULL, true);
}
| false | qemu | 615b5dcf2decbc5f0abb512d13d7e5db2385fa23 | void bdrv_release_named_dirty_bitmaps(BlockDriverState *bs)
{
bdrv_do_release_matching_dirty_bitmap(bs, NULL, true);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(BlockDriverState *VAR_0)
{
bdrv_do_release_matching_dirty_bitmap(VAR_0, NULL, true);
}
| [
"void FUNC_0(BlockDriverState *VAR_0)\n{",
"bdrv_do_release_matching_dirty_bitmap(VAR_0, NULL, true);",
"}"
] | [
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
2,045 | int kvmppc_put_books_sregs(PowerPCCPU *cpu)
{
CPUPPCState *env = &cpu->env;
struct kvm_sregs sregs;
int i;
sregs.pvr = env->spr[SPR_PVR];
sregs.u.s.sdr1 = env->spr[SPR_SDR1];
/* Sync SLB */
#ifdef TARGET_PPC64
for (i = 0; i < ARRAY_SIZE(env->slb); i++) {
sregs.u.s.ppc64.slb[i].slbe = env->slb[i].esid;
if (env->slb[i].esid & SLB_ESID_V) {
sregs.u.s.ppc64.slb[i].slbe |= i;
}
sregs.u.s.ppc64.slb[i].slbv = env->slb[i].vsid;
}
#endif
/* Sync SRs */
for (i = 0; i < 16; i++) {
sregs.u.s.ppc32.sr[i] = env->sr[i];
}
/* Sync BATs */
for (i = 0; i < 8; i++) {
/* Beware. We have to swap upper and lower bits here */
sregs.u.s.ppc32.dbat[i] = ((uint64_t)env->DBAT[0][i] << 32)
| env->DBAT[1][i];
sregs.u.s.ppc32.ibat[i] = ((uint64_t)env->IBAT[0][i] << 32)
| env->IBAT[1][i];
}
return kvm_vcpu_ioctl(CPU(cpu), KVM_SET_SREGS, &sregs);
}
| false | qemu | 1ec26c757d5996468afcc0dced4fad04139574b3 | int kvmppc_put_books_sregs(PowerPCCPU *cpu)
{
CPUPPCState *env = &cpu->env;
struct kvm_sregs sregs;
int i;
sregs.pvr = env->spr[SPR_PVR];
sregs.u.s.sdr1 = env->spr[SPR_SDR1];
#ifdef TARGET_PPC64
for (i = 0; i < ARRAY_SIZE(env->slb); i++) {
sregs.u.s.ppc64.slb[i].slbe = env->slb[i].esid;
if (env->slb[i].esid & SLB_ESID_V) {
sregs.u.s.ppc64.slb[i].slbe |= i;
}
sregs.u.s.ppc64.slb[i].slbv = env->slb[i].vsid;
}
#endif
for (i = 0; i < 16; i++) {
sregs.u.s.ppc32.sr[i] = env->sr[i];
}
for (i = 0; i < 8; i++) {
sregs.u.s.ppc32.dbat[i] = ((uint64_t)env->DBAT[0][i] << 32)
| env->DBAT[1][i];
sregs.u.s.ppc32.ibat[i] = ((uint64_t)env->IBAT[0][i] << 32)
| env->IBAT[1][i];
}
return kvm_vcpu_ioctl(CPU(cpu), KVM_SET_SREGS, &sregs);
}
| {
"code": [],
"line_no": []
} | int FUNC_0(PowerPCCPU *VAR_0)
{
CPUPPCState *env = &VAR_0->env;
struct kvm_sregs VAR_1;
int VAR_2;
VAR_1.pvr = env->spr[SPR_PVR];
VAR_1.u.s.sdr1 = env->spr[SPR_SDR1];
#ifdef TARGET_PPC64
for (VAR_2 = 0; VAR_2 < ARRAY_SIZE(env->slb); VAR_2++) {
VAR_1.u.s.ppc64.slb[VAR_2].slbe = env->slb[VAR_2].esid;
if (env->slb[VAR_2].esid & SLB_ESID_V) {
VAR_1.u.s.ppc64.slb[VAR_2].slbe |= VAR_2;
}
VAR_1.u.s.ppc64.slb[VAR_2].slbv = env->slb[VAR_2].vsid;
}
#endif
for (VAR_2 = 0; VAR_2 < 16; VAR_2++) {
VAR_1.u.s.ppc32.sr[VAR_2] = env->sr[VAR_2];
}
for (VAR_2 = 0; VAR_2 < 8; VAR_2++) {
VAR_1.u.s.ppc32.dbat[VAR_2] = ((uint64_t)env->DBAT[0][VAR_2] << 32)
| env->DBAT[1][VAR_2];
VAR_1.u.s.ppc32.ibat[VAR_2] = ((uint64_t)env->IBAT[0][VAR_2] << 32)
| env->IBAT[1][VAR_2];
}
return kvm_vcpu_ioctl(CPU(VAR_0), KVM_SET_SREGS, &VAR_1);
}
| [
"int FUNC_0(PowerPCCPU *VAR_0)\n{",
"CPUPPCState *env = &VAR_0->env;",
"struct kvm_sregs VAR_1;",
"int VAR_2;",
"VAR_1.pvr = env->spr[SPR_PVR];",
"VAR_1.u.s.sdr1 = env->spr[SPR_SDR1];",
"#ifdef TARGET_PPC64\nfor (VAR_2 = 0; VAR_2 < ARRAY_SIZE(env->slb); VAR_2++) {",
"VAR_1.u.s.ppc64.slb[VAR_2].slbe = ... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
17
],
[
23,
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39,
45
],
[
47
],
[
49
],
[
55
],
[
59,
61
],
[... |
2,046 | static void gen_brcond(DisasContext *dc, TCGCond cond,
TCGv_i32 t0, TCGv_i32 t1, uint32_t offset)
{
int label = gen_new_label();
gen_advance_ccount(dc);
tcg_gen_brcond_i32(cond, t0, t1, label);
gen_jumpi_check_loop_end(dc, 0);
gen_set_label(label);
gen_jumpi(dc, dc->pc + offset, 1);
}
| false | qemu | 42a268c241183877192c376d03bd9b6d527407c7 | static void gen_brcond(DisasContext *dc, TCGCond cond,
TCGv_i32 t0, TCGv_i32 t1, uint32_t offset)
{
int label = gen_new_label();
gen_advance_ccount(dc);
tcg_gen_brcond_i32(cond, t0, t1, label);
gen_jumpi_check_loop_end(dc, 0);
gen_set_label(label);
gen_jumpi(dc, dc->pc + offset, 1);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DisasContext *VAR_0, TCGCond VAR_1,
TCGv_i32 VAR_2, TCGv_i32 VAR_3, uint32_t VAR_4)
{
int VAR_5 = gen_new_label();
gen_advance_ccount(VAR_0);
tcg_gen_brcond_i32(VAR_1, VAR_2, VAR_3, VAR_5);
gen_jumpi_check_loop_end(VAR_0, 0);
gen_set_label(VAR_5);
gen_jumpi(VAR_0, VAR_0->pc + VAR_4, 1);
}
| [
"static void FUNC_0(DisasContext *VAR_0, TCGCond VAR_1,\nTCGv_i32 VAR_2, TCGv_i32 VAR_3, uint32_t VAR_4)\n{",
"int VAR_5 = gen_new_label();",
"gen_advance_ccount(VAR_0);",
"tcg_gen_brcond_i32(VAR_1, VAR_2, VAR_3, VAR_5);",
"gen_jumpi_check_loop_end(VAR_0, 0);",
"gen_set_label(VAR_5);",
"gen_jumpi(VAR_0,... | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
]
] |
2,048 | static bool net_tx_pkt_rebuild_payload(struct NetTxPkt *pkt)
{
size_t payload_len = iov_size(pkt->raw, pkt->raw_frags) - pkt->hdr_len;
pkt->payload_frags = iov_copy(&pkt->vec[NET_TX_PKT_PL_START_FRAG],
pkt->max_payload_frags,
pkt->raw, pkt->raw_frags,
pkt->hdr_len, payload_len);
if (pkt->payload_frags != (uint32_t) -1) {
pkt->payload_len = payload_len;
return true;
} else {
return false;
}
}
| false | qemu | eb700029c7836798046191d62d595363d92c84d4 | static bool net_tx_pkt_rebuild_payload(struct NetTxPkt *pkt)
{
size_t payload_len = iov_size(pkt->raw, pkt->raw_frags) - pkt->hdr_len;
pkt->payload_frags = iov_copy(&pkt->vec[NET_TX_PKT_PL_START_FRAG],
pkt->max_payload_frags,
pkt->raw, pkt->raw_frags,
pkt->hdr_len, payload_len);
if (pkt->payload_frags != (uint32_t) -1) {
pkt->payload_len = payload_len;
return true;
} else {
return false;
}
}
| {
"code": [],
"line_no": []
} | static bool FUNC_0(struct NetTxPkt *pkt)
{
size_t payload_len = iov_size(pkt->raw, pkt->raw_frags) - pkt->hdr_len;
pkt->payload_frags = iov_copy(&pkt->vec[NET_TX_PKT_PL_START_FRAG],
pkt->max_payload_frags,
pkt->raw, pkt->raw_frags,
pkt->hdr_len, payload_len);
if (pkt->payload_frags != (uint32_t) -1) {
pkt->payload_len = payload_len;
return true;
} else {
return false;
}
}
| [
"static bool FUNC_0(struct NetTxPkt *pkt)\n{",
"size_t payload_len = iov_size(pkt->raw, pkt->raw_frags) - pkt->hdr_len;",
"pkt->payload_frags = iov_copy(&pkt->vec[NET_TX_PKT_PL_START_FRAG],\npkt->max_payload_frags,\npkt->raw, pkt->raw_frags,\npkt->hdr_len, payload_len);",
"if (pkt->payload_frags != (uint32_t)... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9,
11,
13,
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
]
] |
2,050 | static void omap_pin_cfg_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;
uint32_t diff;
if (size != 4) {
return omap_badwidth_write32(opaque, addr, value);
}
switch (addr) {
case 0x00: /* FUNC_MUX_CTRL_0 */
diff = s->func_mux_ctrl[addr >> 2] ^ value;
s->func_mux_ctrl[addr >> 2] = value;
omap_pin_funcmux0_update(s, diff, value);
return;
case 0x04: /* FUNC_MUX_CTRL_1 */
diff = s->func_mux_ctrl[addr >> 2] ^ value;
s->func_mux_ctrl[addr >> 2] = value;
omap_pin_funcmux1_update(s, diff, value);
return;
case 0x08: /* FUNC_MUX_CTRL_2 */
s->func_mux_ctrl[addr >> 2] = value;
return;
case 0x0c: /* COMP_MODE_CTRL_0 */
s->comp_mode_ctrl[0] = value;
s->compat1509 = (value != 0x0000eaef);
omap_pin_funcmux0_update(s, ~0, s->func_mux_ctrl[0]);
omap_pin_funcmux1_update(s, ~0, s->func_mux_ctrl[1]);
return;
case 0x10: /* FUNC_MUX_CTRL_3 */
case 0x14: /* FUNC_MUX_CTRL_4 */
case 0x18: /* FUNC_MUX_CTRL_5 */
case 0x1c: /* FUNC_MUX_CTRL_6 */
case 0x20: /* FUNC_MUX_CTRL_7 */
case 0x24: /* FUNC_MUX_CTRL_8 */
case 0x28: /* FUNC_MUX_CTRL_9 */
case 0x2c: /* FUNC_MUX_CTRL_A */
case 0x30: /* FUNC_MUX_CTRL_B */
case 0x34: /* FUNC_MUX_CTRL_C */
case 0x38: /* FUNC_MUX_CTRL_D */
s->func_mux_ctrl[(addr >> 2) - 1] = value;
return;
case 0x40: /* PULL_DWN_CTRL_0 */
case 0x44: /* PULL_DWN_CTRL_1 */
case 0x48: /* PULL_DWN_CTRL_2 */
case 0x4c: /* PULL_DWN_CTRL_3 */
s->pull_dwn_ctrl[(addr & 0xf) >> 2] = value;
return;
case 0x50: /* GATE_INH_CTRL_0 */
s->gate_inh_ctrl[0] = value;
return;
case 0x60: /* VOLTAGE_CTRL_0 */
s->voltage_ctrl[0] = value;
return;
case 0x70: /* TEST_DBG_CTRL_0 */
s->test_dbg_ctrl[0] = value;
return;
case 0x80: /* MOD_CONF_CTRL_0 */
diff = s->mod_conf_ctrl[0] ^ value;
s->mod_conf_ctrl[0] = value;
omap_pin_modconf1_update(s, diff, value);
return;
default:
OMAP_BAD_REG(addr);
}
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | static void omap_pin_cfg_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;
uint32_t diff;
if (size != 4) {
return omap_badwidth_write32(opaque, addr, value);
}
switch (addr) {
case 0x00:
diff = s->func_mux_ctrl[addr >> 2] ^ value;
s->func_mux_ctrl[addr >> 2] = value;
omap_pin_funcmux0_update(s, diff, value);
return;
case 0x04:
diff = s->func_mux_ctrl[addr >> 2] ^ value;
s->func_mux_ctrl[addr >> 2] = value;
omap_pin_funcmux1_update(s, diff, value);
return;
case 0x08:
s->func_mux_ctrl[addr >> 2] = value;
return;
case 0x0c:
s->comp_mode_ctrl[0] = value;
s->compat1509 = (value != 0x0000eaef);
omap_pin_funcmux0_update(s, ~0, s->func_mux_ctrl[0]);
omap_pin_funcmux1_update(s, ~0, s->func_mux_ctrl[1]);
return;
case 0x10:
case 0x14:
case 0x18:
case 0x1c:
case 0x20:
case 0x24:
case 0x28:
case 0x2c:
case 0x30:
case 0x34:
case 0x38:
s->func_mux_ctrl[(addr >> 2) - 1] = value;
return;
case 0x40:
case 0x44:
case 0x48:
case 0x4c:
s->pull_dwn_ctrl[(addr & 0xf) >> 2] = value;
return;
case 0x50:
s->gate_inh_ctrl[0] = value;
return;
case 0x60:
s->voltage_ctrl[0] = value;
return;
case 0x70:
s->test_dbg_ctrl[0] = value;
return;
case 0x80:
diff = s->mod_conf_ctrl[0] ^ value;
s->mod_conf_ctrl[0] = value;
omap_pin_modconf1_update(s, diff, value);
return;
default:
OMAP_BAD_REG(addr);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,
uint64_t VAR_2, unsigned VAR_3)
{
struct omap_mpu_state_s *VAR_4 = (struct omap_mpu_state_s *) VAR_0;
uint32_t diff;
if (VAR_3 != 4) {
return omap_badwidth_write32(VAR_0, VAR_1, VAR_2);
}
switch (VAR_1) {
case 0x00:
diff = VAR_4->func_mux_ctrl[VAR_1 >> 2] ^ VAR_2;
VAR_4->func_mux_ctrl[VAR_1 >> 2] = VAR_2;
omap_pin_funcmux0_update(VAR_4, diff, VAR_2);
return;
case 0x04:
diff = VAR_4->func_mux_ctrl[VAR_1 >> 2] ^ VAR_2;
VAR_4->func_mux_ctrl[VAR_1 >> 2] = VAR_2;
omap_pin_funcmux1_update(VAR_4, diff, VAR_2);
return;
case 0x08:
VAR_4->func_mux_ctrl[VAR_1 >> 2] = VAR_2;
return;
case 0x0c:
VAR_4->comp_mode_ctrl[0] = VAR_2;
VAR_4->compat1509 = (VAR_2 != 0x0000eaef);
omap_pin_funcmux0_update(VAR_4, ~0, VAR_4->func_mux_ctrl[0]);
omap_pin_funcmux1_update(VAR_4, ~0, VAR_4->func_mux_ctrl[1]);
return;
case 0x10:
case 0x14:
case 0x18:
case 0x1c:
case 0x20:
case 0x24:
case 0x28:
case 0x2c:
case 0x30:
case 0x34:
case 0x38:
VAR_4->func_mux_ctrl[(VAR_1 >> 2) - 1] = VAR_2;
return;
case 0x40:
case 0x44:
case 0x48:
case 0x4c:
VAR_4->pull_dwn_ctrl[(VAR_1 & 0xf) >> 2] = VAR_2;
return;
case 0x50:
VAR_4->gate_inh_ctrl[0] = VAR_2;
return;
case 0x60:
VAR_4->voltage_ctrl[0] = VAR_2;
return;
case 0x70:
VAR_4->test_dbg_ctrl[0] = VAR_2;
return;
case 0x80:
diff = VAR_4->mod_conf_ctrl[0] ^ VAR_2;
VAR_4->mod_conf_ctrl[0] = VAR_2;
omap_pin_modconf1_update(VAR_4, diff, VAR_2);
return;
default:
OMAP_BAD_REG(VAR_1);
}
}
| [
"static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{",
"struct omap_mpu_state_s *VAR_4 = (struct omap_mpu_state_s *) VAR_0;",
"uint32_t diff;",
"if (VAR_3 != 4) {",
"return omap_badwidth_write32(VAR_0, VAR_1, VAR_2);",
"}",
"switch (VAR_1) {",
"case 0x00:\ndif... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23,
25
],
[
27
],
[
29
],
[
31
],
[
35,
37
],
[
39
],
[
41
],
[
43
],
[
47,
49
],
[
51
],
[
55,... |
2,051 | static USBDevice *usb_serial_init(USBBus *bus, const char *filename)
{
USBDevice *dev;
Chardev *cdrv;
char label[32];
static int index;
while (*filename && *filename != ':') {
const char *p;
if (strstart(filename, "vendorid=", &p)) {
error_report("vendorid is not supported anymore");
return NULL;
} else if (strstart(filename, "productid=", &p)) {
error_report("productid is not supported anymore");
return NULL;
} else {
error_report("unrecognized serial USB option %s", filename);
return NULL;
}
while(*filename == ',')
filename++;
}
if (!*filename) {
error_report("character device specification needed");
return NULL;
}
filename++;
snprintf(label, sizeof(label), "usbserial%d", index++);
cdrv = qemu_chr_new(label, filename);
if (!cdrv)
return NULL;
dev = usb_create(bus, "usb-serial");
qdev_prop_set_chr(&dev->qdev, "chardev", cdrv);
return dev;
}
| false | qemu | e14935df26c2c10b3445b1910f4ff76f3fb1a1b1 | static USBDevice *usb_serial_init(USBBus *bus, const char *filename)
{
USBDevice *dev;
Chardev *cdrv;
char label[32];
static int index;
while (*filename && *filename != ':') {
const char *p;
if (strstart(filename, "vendorid=", &p)) {
error_report("vendorid is not supported anymore");
return NULL;
} else if (strstart(filename, "productid=", &p)) {
error_report("productid is not supported anymore");
return NULL;
} else {
error_report("unrecognized serial USB option %s", filename);
return NULL;
}
while(*filename == ',')
filename++;
}
if (!*filename) {
error_report("character device specification needed");
return NULL;
}
filename++;
snprintf(label, sizeof(label), "usbserial%d", index++);
cdrv = qemu_chr_new(label, filename);
if (!cdrv)
return NULL;
dev = usb_create(bus, "usb-serial");
qdev_prop_set_chr(&dev->qdev, "chardev", cdrv);
return dev;
}
| {
"code": [],
"line_no": []
} | static USBDevice *FUNC_0(USBBus *bus, const char *filename)
{
USBDevice *dev;
Chardev *cdrv;
char VAR_0[32];
static int VAR_1;
while (*filename && *filename != ':') {
const char *VAR_2;
if (strstart(filename, "vendorid=", &VAR_2)) {
error_report("vendorid is not supported anymore");
return NULL;
} else if (strstart(filename, "productid=", &VAR_2)) {
error_report("productid is not supported anymore");
return NULL;
} else {
error_report("unrecognized serial USB option %s", filename);
return NULL;
}
while(*filename == ',')
filename++;
}
if (!*filename) {
error_report("character device specification needed");
return NULL;
}
filename++;
snprintf(VAR_0, sizeof(VAR_0), "usbserial%d", VAR_1++);
cdrv = qemu_chr_new(VAR_0, filename);
if (!cdrv)
return NULL;
dev = usb_create(bus, "usb-serial");
qdev_prop_set_chr(&dev->qdev, "chardev", cdrv);
return dev;
}
| [
"static USBDevice *FUNC_0(USBBus *bus, const char *filename)\n{",
"USBDevice *dev;",
"Chardev *cdrv;",
"char VAR_0[32];",
"static int VAR_1;",
"while (*filename && *filename != ':') {",
"const char *VAR_2;",
"if (strstart(filename, \"vendorid=\", &VAR_2)) {",
"error_report(\"vendorid is not supporte... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41,
43
],
[
45
],
[... |
2,052 | static void virtio_ccw_notify(DeviceState *d, uint16_t vector)
{
VirtioCcwDevice *dev = to_virtio_ccw_dev_fast(d);
SubchDev *sch = dev->sch;
uint64_t indicators;
if (vector >= 128) {
return;
}
if (vector < VIRTIO_PCI_QUEUE_MAX) {
if (!dev->indicators) {
return;
}
if (sch->thinint_active) {
/*
* In the adapter interrupt case, indicators points to a
* memory area that may be (way) larger than 64 bit and
* ind_bit indicates the start of the indicators in a big
* endian notation.
*/
uint64_t ind_bit = dev->routes.adapter.ind_offset;
virtio_set_ind_atomic(sch, dev->indicators->addr +
(ind_bit + vector) / 8,
0x80 >> ((ind_bit + vector) % 8));
if (!virtio_set_ind_atomic(sch, dev->summary_indicator->addr,
0x01)) {
css_adapter_interrupt(dev->thinint_isc);
}
} else {
indicators = address_space_ldq(&address_space_memory,
dev->indicators->addr,
MEMTXATTRS_UNSPECIFIED,
NULL);
indicators |= 1ULL << vector;
address_space_stq(&address_space_memory, dev->indicators->addr,
indicators, MEMTXATTRS_UNSPECIFIED, NULL);
css_conditional_io_interrupt(sch);
}
} else {
if (!dev->indicators2) {
return;
}
vector = 0;
indicators = address_space_ldq(&address_space_memory,
dev->indicators2->addr,
MEMTXATTRS_UNSPECIFIED,
NULL);
indicators |= 1ULL << vector;
address_space_stq(&address_space_memory, dev->indicators2->addr,
indicators, MEMTXATTRS_UNSPECIFIED, NULL);
css_conditional_io_interrupt(sch);
}
}
| false | qemu | 8dfbaa6ac450c4ec2646b1ca08a4017052a90c1d | static void virtio_ccw_notify(DeviceState *d, uint16_t vector)
{
VirtioCcwDevice *dev = to_virtio_ccw_dev_fast(d);
SubchDev *sch = dev->sch;
uint64_t indicators;
if (vector >= 128) {
return;
}
if (vector < VIRTIO_PCI_QUEUE_MAX) {
if (!dev->indicators) {
return;
}
if (sch->thinint_active) {
uint64_t ind_bit = dev->routes.adapter.ind_offset;
virtio_set_ind_atomic(sch, dev->indicators->addr +
(ind_bit + vector) / 8,
0x80 >> ((ind_bit + vector) % 8));
if (!virtio_set_ind_atomic(sch, dev->summary_indicator->addr,
0x01)) {
css_adapter_interrupt(dev->thinint_isc);
}
} else {
indicators = address_space_ldq(&address_space_memory,
dev->indicators->addr,
MEMTXATTRS_UNSPECIFIED,
NULL);
indicators |= 1ULL << vector;
address_space_stq(&address_space_memory, dev->indicators->addr,
indicators, MEMTXATTRS_UNSPECIFIED, NULL);
css_conditional_io_interrupt(sch);
}
} else {
if (!dev->indicators2) {
return;
}
vector = 0;
indicators = address_space_ldq(&address_space_memory,
dev->indicators2->addr,
MEMTXATTRS_UNSPECIFIED,
NULL);
indicators |= 1ULL << vector;
address_space_stq(&address_space_memory, dev->indicators2->addr,
indicators, MEMTXATTRS_UNSPECIFIED, NULL);
css_conditional_io_interrupt(sch);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DeviceState *VAR_0, uint16_t VAR_1)
{
VirtioCcwDevice *dev = to_virtio_ccw_dev_fast(VAR_0);
SubchDev *sch = dev->sch;
uint64_t indicators;
if (VAR_1 >= 128) {
return;
}
if (VAR_1 < VIRTIO_PCI_QUEUE_MAX) {
if (!dev->indicators) {
return;
}
if (sch->thinint_active) {
uint64_t ind_bit = dev->routes.adapter.ind_offset;
virtio_set_ind_atomic(sch, dev->indicators->addr +
(ind_bit + VAR_1) / 8,
0x80 >> ((ind_bit + VAR_1) % 8));
if (!virtio_set_ind_atomic(sch, dev->summary_indicator->addr,
0x01)) {
css_adapter_interrupt(dev->thinint_isc);
}
} else {
indicators = address_space_ldq(&address_space_memory,
dev->indicators->addr,
MEMTXATTRS_UNSPECIFIED,
NULL);
indicators |= 1ULL << VAR_1;
address_space_stq(&address_space_memory, dev->indicators->addr,
indicators, MEMTXATTRS_UNSPECIFIED, NULL);
css_conditional_io_interrupt(sch);
}
} else {
if (!dev->indicators2) {
return;
}
VAR_1 = 0;
indicators = address_space_ldq(&address_space_memory,
dev->indicators2->addr,
MEMTXATTRS_UNSPECIFIED,
NULL);
indicators |= 1ULL << VAR_1;
address_space_stq(&address_space_memory, dev->indicators2->addr,
indicators, MEMTXATTRS_UNSPECIFIED, NULL);
css_conditional_io_interrupt(sch);
}
}
| [
"static void FUNC_0(DeviceState *VAR_0, uint16_t VAR_1)\n{",
"VirtioCcwDevice *dev = to_virtio_ccw_dev_fast(VAR_0);",
"SubchDev *sch = dev->sch;",
"uint64_t indicators;",
"if (VAR_1 >= 128) {",
"return;",
"}",
"if (VAR_1 < VIRTIO_PCI_QUEUE_MAX) {",
"if (!dev->indicators) {",
"return;",
"}",
"i... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
43
],
[
47,
49,
51
],
[
53,
55
],
[
57
],
[
59
],
[
61
],
[... |
2,054 | void cpu_x86_load_seg(CPUX86State *s, int seg_reg, int selector)
{
CPUX86State *saved_env;
saved_env = env;
env = s;
if (env->eflags & VM_MASK) {
SegmentCache *sc;
selector &= 0xffff;
sc = &env->seg_cache[seg_reg];
/* NOTE: in VM86 mode, limit and seg_32bit are never reloaded,
so we must load them here */
sc->base = (void *)(selector << 4);
sc->limit = 0xffff;
sc->seg_32bit = 0;
env->segs[seg_reg] = selector;
} else {
load_seg(seg_reg, selector, 0);
}
env = saved_env;
}
| false | qemu | e4533c7a8cdcc79ccdf695f0aaa2e23a5b926ed0 | void cpu_x86_load_seg(CPUX86State *s, int seg_reg, int selector)
{
CPUX86State *saved_env;
saved_env = env;
env = s;
if (env->eflags & VM_MASK) {
SegmentCache *sc;
selector &= 0xffff;
sc = &env->seg_cache[seg_reg];
sc->base = (void *)(selector << 4);
sc->limit = 0xffff;
sc->seg_32bit = 0;
env->segs[seg_reg] = selector;
} else {
load_seg(seg_reg, selector, 0);
}
env = saved_env;
}
| {
"code": [],
"line_no": []
} | void FUNC_0(CPUX86State *VAR_0, int VAR_1, int VAR_2)
{
CPUX86State *saved_env;
saved_env = env;
env = VAR_0;
if (env->eflags & VM_MASK) {
SegmentCache *sc;
VAR_2 &= 0xffff;
sc = &env->seg_cache[VAR_1];
sc->base = (void *)(VAR_2 << 4);
sc->limit = 0xffff;
sc->seg_32bit = 0;
env->segs[VAR_1] = VAR_2;
} else {
load_seg(VAR_1, VAR_2, 0);
}
env = saved_env;
}
| [
"void FUNC_0(CPUX86State *VAR_0, int VAR_1, int VAR_2)\n{",
"CPUX86State *saved_env;",
"saved_env = env;",
"env = VAR_0;",
"if (env->eflags & VM_MASK) {",
"SegmentCache *sc;",
"VAR_2 &= 0xffff;",
"sc = &env->seg_cache[VAR_1];",
"sc->base = (void *)(VAR_2 << 4);",
"sc->limit = 0xffff;",
"sc->seg_... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
]
] |
2,056 | static char *sysbus_get_fw_dev_path(DeviceState *dev)
{
SysBusDevice *s = sysbus_from_qdev(dev);
char path[40];
int off;
off = snprintf(path, sizeof(path), "%s", qdev_fw_name(dev));
if (s->num_mmio) {
snprintf(path + off, sizeof(path) - off, "@"TARGET_FMT_plx,
s->mmio[0].addr);
} else if (s->num_pio) {
snprintf(path + off, sizeof(path) - off, "@i%04x", s->pio[0]);
}
return strdup(path);
}
| false | qemu | a5cf8262e4eb9c4646434e2c6211ef8608db3233 | static char *sysbus_get_fw_dev_path(DeviceState *dev)
{
SysBusDevice *s = sysbus_from_qdev(dev);
char path[40];
int off;
off = snprintf(path, sizeof(path), "%s", qdev_fw_name(dev));
if (s->num_mmio) {
snprintf(path + off, sizeof(path) - off, "@"TARGET_FMT_plx,
s->mmio[0].addr);
} else if (s->num_pio) {
snprintf(path + off, sizeof(path) - off, "@i%04x", s->pio[0]);
}
return strdup(path);
}
| {
"code": [],
"line_no": []
} | static char *FUNC_0(DeviceState *VAR_0)
{
SysBusDevice *s = sysbus_from_qdev(VAR_0);
char VAR_1[40];
int VAR_2;
VAR_2 = snprintf(VAR_1, sizeof(VAR_1), "%s", qdev_fw_name(VAR_0));
if (s->num_mmio) {
snprintf(VAR_1 + VAR_2, sizeof(VAR_1) - VAR_2, "@"TARGET_FMT_plx,
s->mmio[0].addr);
} else if (s->num_pio) {
snprintf(VAR_1 + VAR_2, sizeof(VAR_1) - VAR_2, "@i%04x", s->pio[0]);
}
return strdup(VAR_1);
}
| [
"static char *FUNC_0(DeviceState *VAR_0)\n{",
"SysBusDevice *s = sysbus_from_qdev(VAR_0);",
"char VAR_1[40];",
"int VAR_2;",
"VAR_2 = snprintf(VAR_1, sizeof(VAR_1), \"%s\", qdev_fw_name(VAR_0));",
"if (s->num_mmio) {",
"snprintf(VAR_1 + VAR_2, sizeof(VAR_1) - VAR_2, \"@\"TARGET_FMT_plx,\ns->mmio[0].addr... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
17
],
[
19,
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
]
] |
2,057 | void hmp_info_memory_devices(Monitor *mon, const QDict *qdict)
{
Error *err = NULL;
MemoryDeviceInfoList *info_list = qmp_query_memory_devices(&err);
MemoryDeviceInfoList *info;
MemoryDeviceInfo *value;
PCDIMMDeviceInfo *di;
for (info = info_list; info; info = info->next) {
value = info->value;
if (value) {
switch (value->kind) {
case MEMORY_DEVICE_INFO_KIND_DIMM:
di = value->dimm;
monitor_printf(mon, "Memory device [%s]: \"%s\"\n",
MemoryDeviceInfoKind_lookup[value->kind],
di->id ? di->id : "");
monitor_printf(mon, " addr: 0x%" PRIx64 "\n", di->addr);
monitor_printf(mon, " slot: %" PRId64 "\n", di->slot);
monitor_printf(mon, " node: %" PRId64 "\n", di->node);
monitor_printf(mon, " size: %" PRIu64 "\n", di->size);
monitor_printf(mon, " memdev: %s\n", di->memdev);
monitor_printf(mon, " hotplugged: %s\n",
di->hotplugged ? "true" : "false");
monitor_printf(mon, " hotpluggable: %s\n",
di->hotpluggable ? "true" : "false");
break;
default:
break;
}
}
}
qapi_free_MemoryDeviceInfoList(info_list);
}
| false | qemu | 1fd5d4fea4ba686705fd377c7cffc0f0c9f83f93 | void hmp_info_memory_devices(Monitor *mon, const QDict *qdict)
{
Error *err = NULL;
MemoryDeviceInfoList *info_list = qmp_query_memory_devices(&err);
MemoryDeviceInfoList *info;
MemoryDeviceInfo *value;
PCDIMMDeviceInfo *di;
for (info = info_list; info; info = info->next) {
value = info->value;
if (value) {
switch (value->kind) {
case MEMORY_DEVICE_INFO_KIND_DIMM:
di = value->dimm;
monitor_printf(mon, "Memory device [%s]: \"%s\"\n",
MemoryDeviceInfoKind_lookup[value->kind],
di->id ? di->id : "");
monitor_printf(mon, " addr: 0x%" PRIx64 "\n", di->addr);
monitor_printf(mon, " slot: %" PRId64 "\n", di->slot);
monitor_printf(mon, " node: %" PRId64 "\n", di->node);
monitor_printf(mon, " size: %" PRIu64 "\n", di->size);
monitor_printf(mon, " memdev: %s\n", di->memdev);
monitor_printf(mon, " hotplugged: %s\n",
di->hotplugged ? "true" : "false");
monitor_printf(mon, " hotpluggable: %s\n",
di->hotpluggable ? "true" : "false");
break;
default:
break;
}
}
}
qapi_free_MemoryDeviceInfoList(info_list);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(Monitor *VAR_0, const QDict *VAR_1)
{
Error *err = NULL;
MemoryDeviceInfoList *info_list = qmp_query_memory_devices(&err);
MemoryDeviceInfoList *info;
MemoryDeviceInfo *value;
PCDIMMDeviceInfo *di;
for (info = info_list; info; info = info->next) {
value = info->value;
if (value) {
switch (value->kind) {
case MEMORY_DEVICE_INFO_KIND_DIMM:
di = value->dimm;
monitor_printf(VAR_0, "Memory device [%s]: \"%s\"\n",
MemoryDeviceInfoKind_lookup[value->kind],
di->id ? di->id : "");
monitor_printf(VAR_0, " addr: 0x%" PRIx64 "\n", di->addr);
monitor_printf(VAR_0, " slot: %" PRId64 "\n", di->slot);
monitor_printf(VAR_0, " node: %" PRId64 "\n", di->node);
monitor_printf(VAR_0, " size: %" PRIu64 "\n", di->size);
monitor_printf(VAR_0, " memdev: %s\n", di->memdev);
monitor_printf(VAR_0, " hotplugged: %s\n",
di->hotplugged ? "true" : "false");
monitor_printf(VAR_0, " hotpluggable: %s\n",
di->hotpluggable ? "true" : "false");
break;
default:
break;
}
}
}
qapi_free_MemoryDeviceInfoList(info_list);
}
| [
"void FUNC_0(Monitor *VAR_0, const QDict *VAR_1)\n{",
"Error *err = NULL;",
"MemoryDeviceInfoList *info_list = qmp_query_memory_devices(&err);",
"MemoryDeviceInfoList *info;",
"MemoryDeviceInfo *value;",
"PCDIMMDeviceInfo *di;",
"for (info = info_list; info; info = info->next) {",
"value = info->value... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27,
29
],
[
33,
35,
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49,
51
... |
2,058 | static void v9fs_synth_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
{
V9fsSynthOpenState *synth_open = fs->private;
synth_open->offset = off;
}
| false | qemu | 364031f17932814484657e5551ba12957d993d7e | static void v9fs_synth_seekdir(FsContext *ctx, V9fsFidOpenState *fs, off_t off)
{
V9fsSynthOpenState *synth_open = fs->private;
synth_open->offset = off;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(FsContext *VAR_0, V9fsFidOpenState *VAR_1, off_t VAR_2)
{
V9fsSynthOpenState *synth_open = VAR_1->private;
synth_open->offset = VAR_2;
}
| [
"static void FUNC_0(FsContext *VAR_0, V9fsFidOpenState *VAR_1, off_t VAR_2)\n{",
"V9fsSynthOpenState *synth_open = VAR_1->private;",
"synth_open->offset = VAR_2;",
"}"
] | [
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
]
] |
2,059 | static struct vm_area_struct *vma_first(const struct mm_struct *mm)
{
return (TAILQ_FIRST(&mm->mm_mmap));
}
| false | qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | static struct vm_area_struct *vma_first(const struct mm_struct *mm)
{
return (TAILQ_FIRST(&mm->mm_mmap));
}
| {
"code": [],
"line_no": []
} | static struct vm_area_struct *FUNC_0(const struct mm_struct *VAR_0)
{
return (TAILQ_FIRST(&VAR_0->mm_mmap));
}
| [
"static struct vm_area_struct *FUNC_0(const struct mm_struct *VAR_0)\n{",
"return (TAILQ_FIRST(&VAR_0->mm_mmap));",
"}"
] | [
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
]
] |
2,060 | static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
{
DNXHDEncContext *ctx = avctx->priv_data;
int mb_y = jobnr, mb_x;
ctx = ctx->thread[threadnr];
if (ctx->cid_table->bit_depth == 8) {
uint8_t *pix = ctx->thread[0]->src[0] + ((mb_y<<4) * ctx->m.linesize);
for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x, pix += 16) {
unsigned mb = mb_y * ctx->m.mb_width + mb_x;
int sum = ctx->m.dsp.pix_sum(pix, ctx->m.linesize);
int varc = (ctx->m.dsp.pix_norm1(pix, ctx->m.linesize) - (((unsigned)(sum*sum))>>8)+128)>>8;
ctx->mb_cmp[mb].value = varc;
ctx->mb_cmp[mb].mb = mb;
}
} else { // 10-bit
int const linesize = ctx->m.linesize >> 1;
for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x) {
uint16_t *pix = (uint16_t*)ctx->thread[0]->src[0] + ((mb_y << 4) * linesize) + (mb_x << 4);
unsigned mb = mb_y * ctx->m.mb_width + mb_x;
int sum = 0;
int sqsum = 0;
int mean, sqmean;
// Macroblocks are 16x16 pixels, unlike DCT blocks which are 8x8.
for (int i = 0; i < 16; ++i) {
for (int j = 0; j < 16; ++j) {
// Turn 16-bit pixels into 10-bit ones.
int const sample = (unsigned)pix[j] >> 6;
sum += sample;
sqsum += sample * sample;
// 2^10 * 2^10 * 16 * 16 = 2^28, which is less than INT_MAX
}
pix += linesize;
}
mean = sum >> 8; // 16*16 == 2^8
sqmean = sqsum >> 8;
ctx->mb_cmp[mb].value = sqmean - mean * mean;
ctx->mb_cmp[mb].mb = mb;
}
}
return 0;
}
| false | FFmpeg | e72f3d10f64f5c65a67aa21dcc79a85ee55e912e | static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
{
DNXHDEncContext *ctx = avctx->priv_data;
int mb_y = jobnr, mb_x;
ctx = ctx->thread[threadnr];
if (ctx->cid_table->bit_depth == 8) {
uint8_t *pix = ctx->thread[0]->src[0] + ((mb_y<<4) * ctx->m.linesize);
for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x, pix += 16) {
unsigned mb = mb_y * ctx->m.mb_width + mb_x;
int sum = ctx->m.dsp.pix_sum(pix, ctx->m.linesize);
int varc = (ctx->m.dsp.pix_norm1(pix, ctx->m.linesize) - (((unsigned)(sum*sum))>>8)+128)>>8;
ctx->mb_cmp[mb].value = varc;
ctx->mb_cmp[mb].mb = mb;
}
} else {
int const linesize = ctx->m.linesize >> 1;
for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x) {
uint16_t *pix = (uint16_t*)ctx->thread[0]->src[0] + ((mb_y << 4) * linesize) + (mb_x << 4);
unsigned mb = mb_y * ctx->m.mb_width + mb_x;
int sum = 0;
int sqsum = 0;
int mean, sqmean;
for (int i = 0; i < 16; ++i) {
for (int j = 0; j < 16; ++j) {
int const sample = (unsigned)pix[j] >> 6;
sum += sample;
sqsum += sample * sample;
}
pix += linesize;
}
mean = sum >> 8;
sqmean = sqsum >> 8;
ctx->mb_cmp[mb].value = sqmean - mean * mean;
ctx->mb_cmp[mb].mb = mb;
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int VAR_2, int VAR_3)
{
DNXHDEncContext *ctx = VAR_0->priv_data;
int VAR_4 = VAR_2, VAR_5;
ctx = ctx->thread[VAR_3];
if (ctx->cid_table->bit_depth == 8) {
uint8_t *pix = ctx->thread[0]->src[0] + ((VAR_4<<4) * ctx->m.VAR_6);
for (VAR_5 = 0; VAR_5 < ctx->m.mb_width; ++VAR_5, pix += 16) {
unsigned mb = VAR_4 * ctx->m.mb_width + VAR_5;
int sum = ctx->m.dsp.pix_sum(pix, ctx->m.VAR_6);
int varc = (ctx->m.dsp.pix_norm1(pix, ctx->m.VAR_6) - (((unsigned)(sum*sum))>>8)+128)>>8;
ctx->mb_cmp[mb].value = varc;
ctx->mb_cmp[mb].mb = mb;
}
} else {
int const VAR_6 = ctx->m.VAR_6 >> 1;
for (VAR_5 = 0; VAR_5 < ctx->m.mb_width; ++VAR_5) {
uint16_t *pix = (uint16_t*)ctx->thread[0]->src[0] + ((VAR_4 << 4) * VAR_6) + (VAR_5 << 4);
unsigned mb = VAR_4 * ctx->m.mb_width + VAR_5;
int sum = 0;
int sqsum = 0;
int mean, sqmean;
for (int i = 0; i < 16; ++i) {
for (int j = 0; j < 16; ++j) {
int const sample = (unsigned)pix[j] >> 6;
sum += sample;
sqsum += sample * sample;
}
pix += VAR_6;
}
mean = sum >> 8;
sqmean = sqsum >> 8;
ctx->mb_cmp[mb].value = sqmean - mean * mean;
ctx->mb_cmp[mb].mb = mb;
}
}
return 0;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int VAR_2, int VAR_3)\n{",
"DNXHDEncContext *ctx = VAR_0->priv_data;",
"int VAR_4 = VAR_2, VAR_5;",
"ctx = ctx->thread[VAR_3];",
"if (ctx->cid_table->bit_depth == 8) {",
"uint8_t *pix = ctx->thread[0]->src[0] + ((VAR_4<<4) * ctx->m.VAR_6);",
"for (V... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
... |
2,061 | static void xan_wc3_decode_frame(XanContext *s) {
int width = s->avctx->width;
int height = s->avctx->height;
int total_pixels = width * height;
unsigned char opcode;
unsigned char flag = 0;
int size = 0;
int motion_x, motion_y;
int x, y;
unsigned char *opcode_buffer = s->buffer1;
int opcode_buffer_size = s->buffer1_size;
const unsigned char *imagedata_buffer = s->buffer2;
/* pointers to segments inside the compressed chunk */
const unsigned char *huffman_segment;
const unsigned char *size_segment;
const unsigned char *vector_segment;
const unsigned char *imagedata_segment;
huffman_segment = s->buf + AV_RL16(&s->buf[0]);
size_segment = s->buf + AV_RL16(&s->buf[2]);
vector_segment = s->buf + AV_RL16(&s->buf[4]);
imagedata_segment = s->buf + AV_RL16(&s->buf[6]);
xan_huffman_decode(opcode_buffer, opcode_buffer_size,
huffman_segment, s->size - (huffman_segment - s->buf) );
if (imagedata_segment[0] == 2)
xan_unpack(s->buffer2, &imagedata_segment[1], s->buffer2_size);
else
imagedata_buffer = &imagedata_segment[1];
/* use the decoded data segments to build the frame */
x = y = 0;
while (total_pixels) {
opcode = *opcode_buffer++;
size = 0;
switch (opcode) {
case 0:
flag ^= 1;
continue;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
size = opcode;
break;
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
size += (opcode - 10);
break;
case 9:
case 19:
size = *size_segment++;
break;
case 10:
case 20:
size = AV_RB16(&size_segment[0]);
size_segment += 2;
break;
case 11:
case 21:
size = AV_RB24(size_segment);
size_segment += 3;
break;
}
if (opcode < 12) {
flag ^= 1;
if (flag) {
/* run of (size) pixels is unchanged from last frame */
xan_wc3_copy_pixel_run(s, x, y, size, 0, 0);
} else {
/* output a run of pixels from imagedata_buffer */
xan_wc3_output_pixel_run(s, imagedata_buffer, x, y, size);
imagedata_buffer += size;
}
} else {
/* run-based motion compensation from last frame */
motion_x = sign_extend(*vector_segment >> 4, 4);
motion_y = sign_extend(*vector_segment & 0xF, 4);
vector_segment++;
/* copy a run of pixels from the previous frame */
xan_wc3_copy_pixel_run(s, x, y, size, motion_x, motion_y);
flag = 0;
}
/* coordinate accounting */
total_pixels -= size;
y += (x + size) / width;
x = (x + size) % width;
}
}
| false | FFmpeg | 0872bb23b4bd2d94a8ba91070f706d1bc1c3ced8 | static void xan_wc3_decode_frame(XanContext *s) {
int width = s->avctx->width;
int height = s->avctx->height;
int total_pixels = width * height;
unsigned char opcode;
unsigned char flag = 0;
int size = 0;
int motion_x, motion_y;
int x, y;
unsigned char *opcode_buffer = s->buffer1;
int opcode_buffer_size = s->buffer1_size;
const unsigned char *imagedata_buffer = s->buffer2;
const unsigned char *huffman_segment;
const unsigned char *size_segment;
const unsigned char *vector_segment;
const unsigned char *imagedata_segment;
huffman_segment = s->buf + AV_RL16(&s->buf[0]);
size_segment = s->buf + AV_RL16(&s->buf[2]);
vector_segment = s->buf + AV_RL16(&s->buf[4]);
imagedata_segment = s->buf + AV_RL16(&s->buf[6]);
xan_huffman_decode(opcode_buffer, opcode_buffer_size,
huffman_segment, s->size - (huffman_segment - s->buf) );
if (imagedata_segment[0] == 2)
xan_unpack(s->buffer2, &imagedata_segment[1], s->buffer2_size);
else
imagedata_buffer = &imagedata_segment[1];
x = y = 0;
while (total_pixels) {
opcode = *opcode_buffer++;
size = 0;
switch (opcode) {
case 0:
flag ^= 1;
continue;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
size = opcode;
break;
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
size += (opcode - 10);
break;
case 9:
case 19:
size = *size_segment++;
break;
case 10:
case 20:
size = AV_RB16(&size_segment[0]);
size_segment += 2;
break;
case 11:
case 21:
size = AV_RB24(size_segment);
size_segment += 3;
break;
}
if (opcode < 12) {
flag ^= 1;
if (flag) {
xan_wc3_copy_pixel_run(s, x, y, size, 0, 0);
} else {
xan_wc3_output_pixel_run(s, imagedata_buffer, x, y, size);
imagedata_buffer += size;
}
} else {
motion_x = sign_extend(*vector_segment >> 4, 4);
motion_y = sign_extend(*vector_segment & 0xF, 4);
vector_segment++;
xan_wc3_copy_pixel_run(s, x, y, size, motion_x, motion_y);
flag = 0;
}
total_pixels -= size;
y += (x + size) / width;
x = (x + size) % width;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(XanContext *VAR_0) {
int VAR_1 = VAR_0->avctx->VAR_1;
int VAR_2 = VAR_0->avctx->VAR_2;
int VAR_3 = VAR_1 * VAR_2;
unsigned char VAR_4;
unsigned char VAR_5 = 0;
int VAR_6 = 0;
int VAR_7, VAR_8;
int VAR_9, VAR_10;
unsigned char *VAR_11 = VAR_0->buffer1;
int VAR_12 = VAR_0->buffer1_size;
const unsigned char *VAR_13 = VAR_0->buffer2;
const unsigned char *VAR_14;
const unsigned char *VAR_15;
const unsigned char *VAR_16;
const unsigned char *VAR_17;
VAR_14 = VAR_0->buf + AV_RL16(&VAR_0->buf[0]);
VAR_15 = VAR_0->buf + AV_RL16(&VAR_0->buf[2]);
VAR_16 = VAR_0->buf + AV_RL16(&VAR_0->buf[4]);
VAR_17 = VAR_0->buf + AV_RL16(&VAR_0->buf[6]);
xan_huffman_decode(VAR_11, VAR_12,
VAR_14, VAR_0->VAR_6 - (VAR_14 - VAR_0->buf) );
if (VAR_17[0] == 2)
xan_unpack(VAR_0->buffer2, &VAR_17[1], VAR_0->buffer2_size);
else
VAR_13 = &VAR_17[1];
VAR_9 = VAR_10 = 0;
while (VAR_3) {
VAR_4 = *VAR_11++;
VAR_6 = 0;
switch (VAR_4) {
case 0:
VAR_5 ^= 1;
continue;
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
case 8:
VAR_6 = VAR_4;
break;
case 12:
case 13:
case 14:
case 15:
case 16:
case 17:
case 18:
VAR_6 += (VAR_4 - 10);
break;
case 9:
case 19:
VAR_6 = *VAR_15++;
break;
case 10:
case 20:
VAR_6 = AV_RB16(&VAR_15[0]);
VAR_15 += 2;
break;
case 11:
case 21:
VAR_6 = AV_RB24(VAR_15);
VAR_15 += 3;
break;
}
if (VAR_4 < 12) {
VAR_5 ^= 1;
if (VAR_5) {
xan_wc3_copy_pixel_run(VAR_0, VAR_9, VAR_10, VAR_6, 0, 0);
} else {
xan_wc3_output_pixel_run(VAR_0, VAR_13, VAR_9, VAR_10, VAR_6);
VAR_13 += VAR_6;
}
} else {
VAR_7 = sign_extend(*VAR_16 >> 4, 4);
VAR_8 = sign_extend(*VAR_16 & 0xF, 4);
VAR_16++;
xan_wc3_copy_pixel_run(VAR_0, VAR_9, VAR_10, VAR_6, VAR_7, VAR_8);
VAR_5 = 0;
}
VAR_3 -= VAR_6;
VAR_10 += (VAR_9 + VAR_6) / VAR_1;
VAR_9 = (VAR_9 + VAR_6) % VAR_1;
}
}
| [
"static void FUNC_0(XanContext *VAR_0) {",
"int VAR_1 = VAR_0->avctx->VAR_1;",
"int VAR_2 = VAR_0->avctx->VAR_2;",
"int VAR_3 = VAR_1 * VAR_2;",
"unsigned char VAR_4;",
"unsigned char VAR_5 = 0;",
"int VAR_6 = 0;",
"int VAR_7, VAR_8;",
"int VAR_9, VAR_10;",
"unsigned char *VAR_11 = VAR_0->buffer1;... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49
],
... |
2,062 | static void qmp_input_start_alternate(Visitor *v, const char *name,
GenericAlternate **obj, size_t size,
bool promote_int, Error **errp)
{
QmpInputVisitor *qiv = to_qiv(v);
QObject *qobj = qmp_input_get_object(qiv, name, false, errp);
if (!qobj) {
*obj = NULL;
return;
}
*obj = g_malloc0(size);
(*obj)->type = qobject_type(qobj);
if (promote_int && (*obj)->type == QTYPE_QINT) {
(*obj)->type = QTYPE_QFLOAT;
}
}
| false | qemu | 09e68369a88d7de0f988972bf28eec1b80cc47f9 | static void qmp_input_start_alternate(Visitor *v, const char *name,
GenericAlternate **obj, size_t size,
bool promote_int, Error **errp)
{
QmpInputVisitor *qiv = to_qiv(v);
QObject *qobj = qmp_input_get_object(qiv, name, false, errp);
if (!qobj) {
*obj = NULL;
return;
}
*obj = g_malloc0(size);
(*obj)->type = qobject_type(qobj);
if (promote_int && (*obj)->type == QTYPE_QINT) {
(*obj)->type = QTYPE_QFLOAT;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(Visitor *VAR_0, const char *VAR_1,
GenericAlternate **VAR_2, size_t VAR_3,
bool VAR_4, Error **VAR_5)
{
QmpInputVisitor *qiv = to_qiv(VAR_0);
QObject *qobj = qmp_input_get_object(qiv, VAR_1, false, VAR_5);
if (!qobj) {
*VAR_2 = NULL;
return;
}
*VAR_2 = g_malloc0(VAR_3);
(*VAR_2)->type = qobject_type(qobj);
if (VAR_4 && (*VAR_2)->type == QTYPE_QINT) {
(*VAR_2)->type = QTYPE_QFLOAT;
}
}
| [
"static void FUNC_0(Visitor *VAR_0, const char *VAR_1,\nGenericAlternate **VAR_2, size_t VAR_3,\nbool VAR_4, Error **VAR_5)\n{",
"QmpInputVisitor *qiv = to_qiv(VAR_0);",
"QObject *qobj = qmp_input_get_object(qiv, VAR_1, false, VAR_5);",
"if (!qobj) {",
"*VAR_2 = NULL;",
"return;",
"}",
"*VAR_2 = g_mal... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
]
] |
2,064 | static void ac97_write(void *opaque, target_phys_addr_t addr, uint64_t value,
unsigned size)
{
MilkymistAC97State *s = opaque;
trace_milkymist_ac97_memory_write(addr, value);
addr >>= 2;
switch (addr) {
case R_AC97_CTRL:
/* always raise an IRQ according to the direction */
if (value & AC97_CTRL_RQEN) {
if (value & AC97_CTRL_WRITE) {
trace_milkymist_ac97_pulse_irq_crrequest();
qemu_irq_pulse(s->crrequest_irq);
} else {
trace_milkymist_ac97_pulse_irq_crreply();
qemu_irq_pulse(s->crreply_irq);
}
}
/* RQEN is self clearing */
s->regs[addr] = value & ~AC97_CTRL_RQEN;
break;
case R_D_CTRL:
case R_U_CTRL:
s->regs[addr] = value;
update_voices(s);
break;
case R_AC97_ADDR:
case R_AC97_DATAOUT:
case R_AC97_DATAIN:
case R_D_ADDR:
case R_D_REMAINING:
case R_U_ADDR:
case R_U_REMAINING:
s->regs[addr] = value;
break;
default:
error_report("milkymist_ac97: write access to unknown register 0x"
TARGET_FMT_plx, addr);
break;
}
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | static void ac97_write(void *opaque, target_phys_addr_t addr, uint64_t value,
unsigned size)
{
MilkymistAC97State *s = opaque;
trace_milkymist_ac97_memory_write(addr, value);
addr >>= 2;
switch (addr) {
case R_AC97_CTRL:
if (value & AC97_CTRL_RQEN) {
if (value & AC97_CTRL_WRITE) {
trace_milkymist_ac97_pulse_irq_crrequest();
qemu_irq_pulse(s->crrequest_irq);
} else {
trace_milkymist_ac97_pulse_irq_crreply();
qemu_irq_pulse(s->crreply_irq);
}
}
s->regs[addr] = value & ~AC97_CTRL_RQEN;
break;
case R_D_CTRL:
case R_U_CTRL:
s->regs[addr] = value;
update_voices(s);
break;
case R_AC97_ADDR:
case R_AC97_DATAOUT:
case R_AC97_DATAIN:
case R_D_ADDR:
case R_D_REMAINING:
case R_U_ADDR:
case R_U_REMAINING:
s->regs[addr] = value;
break;
default:
error_report("milkymist_ac97: write access to unknown register 0x"
TARGET_FMT_plx, addr);
break;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1, uint64_t VAR_2,
unsigned VAR_3)
{
MilkymistAC97State *s = VAR_0;
trace_milkymist_ac97_memory_write(VAR_1, VAR_2);
VAR_1 >>= 2;
switch (VAR_1) {
case R_AC97_CTRL:
if (VAR_2 & AC97_CTRL_RQEN) {
if (VAR_2 & AC97_CTRL_WRITE) {
trace_milkymist_ac97_pulse_irq_crrequest();
qemu_irq_pulse(s->crrequest_irq);
} else {
trace_milkymist_ac97_pulse_irq_crreply();
qemu_irq_pulse(s->crreply_irq);
}
}
s->regs[VAR_1] = VAR_2 & ~AC97_CTRL_RQEN;
break;
case R_D_CTRL:
case R_U_CTRL:
s->regs[VAR_1] = VAR_2;
update_voices(s);
break;
case R_AC97_ADDR:
case R_AC97_DATAOUT:
case R_AC97_DATAIN:
case R_D_ADDR:
case R_D_REMAINING:
case R_U_ADDR:
case R_U_REMAINING:
s->regs[VAR_1] = VAR_2;
break;
default:
error_report("milkymist_ac97: write access to unknown register 0x"
TARGET_FMT_plx, VAR_1);
break;
}
}
| [
"static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1, uint64_t VAR_2,\nunsigned VAR_3)\n{",
"MilkymistAC97State *s = VAR_0;",
"trace_milkymist_ac97_memory_write(VAR_1, VAR_2);",
"VAR_1 >>= 2;",
"switch (VAR_1) {",
"case R_AC97_CTRL:\nif (VAR_2 & AC97_CTRL_RQEN) {",
"if (VAR_2 & AC97_CTRL_WRITE) {",... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
11
],
[
15
],
[
17
],
[
19,
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
45
],
[
47
],
[
49,
51,
53
],
[
55... |
2,065 | static void mch_realize(PCIDevice *d, Error **errp)
{
int i;
MCHPCIState *mch = MCH_PCI_DEVICE(d);
/* setup pci memory mapping */
pc_pci_as_mapping_init(OBJECT(mch), mch->system_memory,
mch->pci_address_space);
/* if *disabled* show SMRAM to all CPUs */
memory_region_init_alias(&mch->smram_region, OBJECT(mch), "smram-region",
mch->pci_address_space, 0xa0000, 0x20000);
memory_region_add_subregion_overlap(mch->system_memory, 0xa0000,
&mch->smram_region, 1);
memory_region_set_enabled(&mch->smram_region, true);
memory_region_init_alias(&mch->open_high_smram, OBJECT(mch), "smram-open-high",
mch->ram_memory, 0xa0000, 0x20000);
memory_region_add_subregion_overlap(mch->system_memory, 0xfeda0000,
&mch->open_high_smram, 1);
memory_region_set_enabled(&mch->open_high_smram, false);
/* smram, as seen by SMM CPUs */
memory_region_init(&mch->smram, OBJECT(mch), "smram", 1ull << 32);
memory_region_set_enabled(&mch->smram, true);
memory_region_init_alias(&mch->low_smram, OBJECT(mch), "smram-low",
mch->ram_memory, 0xa0000, 0x20000);
memory_region_set_enabled(&mch->low_smram, true);
memory_region_add_subregion(&mch->smram, 0xa0000, &mch->low_smram);
memory_region_init_alias(&mch->high_smram, OBJECT(mch), "smram-high",
mch->ram_memory, 0xa0000, 0x20000);
memory_region_set_enabled(&mch->high_smram, true);
memory_region_add_subregion(&mch->smram, 0xfeda0000, &mch->high_smram);
memory_region_init_io(&mch->tseg_blackhole, OBJECT(mch),
&tseg_blackhole_ops, NULL,
"tseg-blackhole", 0);
memory_region_set_enabled(&mch->tseg_blackhole, false);
memory_region_add_subregion_overlap(mch->system_memory,
mch->below_4g_mem_size,
&mch->tseg_blackhole, 1);
memory_region_init_alias(&mch->tseg_window, OBJECT(mch), "tseg-window",
mch->ram_memory, mch->below_4g_mem_size, 0);
memory_region_set_enabled(&mch->tseg_window, false);
memory_region_add_subregion(&mch->smram, mch->below_4g_mem_size,
&mch->tseg_window);
object_property_add_const_link(qdev_get_machine(), "smram",
OBJECT(&mch->smram), &error_abort);
init_pam(DEVICE(mch), mch->ram_memory, mch->system_memory,
mch->pci_address_space, &mch->pam_regions[0],
PAM_BIOS_BASE, PAM_BIOS_SIZE);
for (i = 0; i < 12; ++i) {
init_pam(DEVICE(mch), mch->ram_memory, mch->system_memory,
mch->pci_address_space, &mch->pam_regions[i+1],
PAM_EXPAN_BASE + i * PAM_EXPAN_SIZE, PAM_EXPAN_SIZE);
}
/* Intel IOMMU (VT-d) */
if (machine_iommu(current_machine)) {
mch_init_dmar(mch);
}
}
| false | qemu | 1f8431f42d833e8914f2d16ce4a49b7b72b90db0 | static void mch_realize(PCIDevice *d, Error **errp)
{
int i;
MCHPCIState *mch = MCH_PCI_DEVICE(d);
pc_pci_as_mapping_init(OBJECT(mch), mch->system_memory,
mch->pci_address_space);
memory_region_init_alias(&mch->smram_region, OBJECT(mch), "smram-region",
mch->pci_address_space, 0xa0000, 0x20000);
memory_region_add_subregion_overlap(mch->system_memory, 0xa0000,
&mch->smram_region, 1);
memory_region_set_enabled(&mch->smram_region, true);
memory_region_init_alias(&mch->open_high_smram, OBJECT(mch), "smram-open-high",
mch->ram_memory, 0xa0000, 0x20000);
memory_region_add_subregion_overlap(mch->system_memory, 0xfeda0000,
&mch->open_high_smram, 1);
memory_region_set_enabled(&mch->open_high_smram, false);
memory_region_init(&mch->smram, OBJECT(mch), "smram", 1ull << 32);
memory_region_set_enabled(&mch->smram, true);
memory_region_init_alias(&mch->low_smram, OBJECT(mch), "smram-low",
mch->ram_memory, 0xa0000, 0x20000);
memory_region_set_enabled(&mch->low_smram, true);
memory_region_add_subregion(&mch->smram, 0xa0000, &mch->low_smram);
memory_region_init_alias(&mch->high_smram, OBJECT(mch), "smram-high",
mch->ram_memory, 0xa0000, 0x20000);
memory_region_set_enabled(&mch->high_smram, true);
memory_region_add_subregion(&mch->smram, 0xfeda0000, &mch->high_smram);
memory_region_init_io(&mch->tseg_blackhole, OBJECT(mch),
&tseg_blackhole_ops, NULL,
"tseg-blackhole", 0);
memory_region_set_enabled(&mch->tseg_blackhole, false);
memory_region_add_subregion_overlap(mch->system_memory,
mch->below_4g_mem_size,
&mch->tseg_blackhole, 1);
memory_region_init_alias(&mch->tseg_window, OBJECT(mch), "tseg-window",
mch->ram_memory, mch->below_4g_mem_size, 0);
memory_region_set_enabled(&mch->tseg_window, false);
memory_region_add_subregion(&mch->smram, mch->below_4g_mem_size,
&mch->tseg_window);
object_property_add_const_link(qdev_get_machine(), "smram",
OBJECT(&mch->smram), &error_abort);
init_pam(DEVICE(mch), mch->ram_memory, mch->system_memory,
mch->pci_address_space, &mch->pam_regions[0],
PAM_BIOS_BASE, PAM_BIOS_SIZE);
for (i = 0; i < 12; ++i) {
init_pam(DEVICE(mch), mch->ram_memory, mch->system_memory,
mch->pci_address_space, &mch->pam_regions[i+1],
PAM_EXPAN_BASE + i * PAM_EXPAN_SIZE, PAM_EXPAN_SIZE);
}
if (machine_iommu(current_machine)) {
mch_init_dmar(mch);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(PCIDevice *VAR_0, Error **VAR_1)
{
int VAR_2;
MCHPCIState *mch = MCH_PCI_DEVICE(VAR_0);
pc_pci_as_mapping_init(OBJECT(mch), mch->system_memory,
mch->pci_address_space);
memory_region_init_alias(&mch->smram_region, OBJECT(mch), "smram-region",
mch->pci_address_space, 0xa0000, 0x20000);
memory_region_add_subregion_overlap(mch->system_memory, 0xa0000,
&mch->smram_region, 1);
memory_region_set_enabled(&mch->smram_region, true);
memory_region_init_alias(&mch->open_high_smram, OBJECT(mch), "smram-open-high",
mch->ram_memory, 0xa0000, 0x20000);
memory_region_add_subregion_overlap(mch->system_memory, 0xfeda0000,
&mch->open_high_smram, 1);
memory_region_set_enabled(&mch->open_high_smram, false);
memory_region_init(&mch->smram, OBJECT(mch), "smram", 1ull << 32);
memory_region_set_enabled(&mch->smram, true);
memory_region_init_alias(&mch->low_smram, OBJECT(mch), "smram-low",
mch->ram_memory, 0xa0000, 0x20000);
memory_region_set_enabled(&mch->low_smram, true);
memory_region_add_subregion(&mch->smram, 0xa0000, &mch->low_smram);
memory_region_init_alias(&mch->high_smram, OBJECT(mch), "smram-high",
mch->ram_memory, 0xa0000, 0x20000);
memory_region_set_enabled(&mch->high_smram, true);
memory_region_add_subregion(&mch->smram, 0xfeda0000, &mch->high_smram);
memory_region_init_io(&mch->tseg_blackhole, OBJECT(mch),
&tseg_blackhole_ops, NULL,
"tseg-blackhole", 0);
memory_region_set_enabled(&mch->tseg_blackhole, false);
memory_region_add_subregion_overlap(mch->system_memory,
mch->below_4g_mem_size,
&mch->tseg_blackhole, 1);
memory_region_init_alias(&mch->tseg_window, OBJECT(mch), "tseg-window",
mch->ram_memory, mch->below_4g_mem_size, 0);
memory_region_set_enabled(&mch->tseg_window, false);
memory_region_add_subregion(&mch->smram, mch->below_4g_mem_size,
&mch->tseg_window);
object_property_add_const_link(qdev_get_machine(), "smram",
OBJECT(&mch->smram), &error_abort);
init_pam(DEVICE(mch), mch->ram_memory, mch->system_memory,
mch->pci_address_space, &mch->pam_regions[0],
PAM_BIOS_BASE, PAM_BIOS_SIZE);
for (VAR_2 = 0; VAR_2 < 12; ++VAR_2) {
init_pam(DEVICE(mch), mch->ram_memory, mch->system_memory,
mch->pci_address_space, &mch->pam_regions[VAR_2+1],
PAM_EXPAN_BASE + VAR_2 * PAM_EXPAN_SIZE, PAM_EXPAN_SIZE);
}
if (machine_iommu(current_machine)) {
mch_init_dmar(mch);
}
}
| [
"static void FUNC_0(PCIDevice *VAR_0, Error **VAR_1)\n{",
"int VAR_2;",
"MCHPCIState *mch = MCH_PCI_DEVICE(VAR_0);",
"pc_pci_as_mapping_init(OBJECT(mch), mch->system_memory,\nmch->pci_address_space);",
"memory_region_init_alias(&mch->smram_region, OBJECT(mch), \"smram-region\",\nmch->pci_address_space, 0xa0... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
13,
15
],
[
21,
23
],
[
25,
27
],
[
29
],
[
33,
35
],
[
37,
39
],
[
41
],
[
47
],
[
49
],
[
51,
53
],
[
55
],
[
57
],
[
59,
61
],
... |
2,066 | static void arm_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu)
{
DisasContext *dc = container_of(dcbase, DisasContext, base);
CPUARMState *env = cpu->env_ptr;
#ifdef CONFIG_USER_ONLY
/* Intercept jump to the magic kernel page. */
if (dc->pc >= 0xffff0000) {
/* We always get here via a jump, so know we are not in a
conditional execution block. */
gen_exception_internal(EXCP_KERNEL_TRAP);
dc->base.is_jmp = DISAS_NORETURN;
return;
}
#endif
if (dc->ss_active && !dc->pstate_ss) {
/* Singlestep state is Active-pending.
* If we're in this state at the start of a TB then either
* a) we just took an exception to an EL which is being debugged
* and this is the first insn in the exception handler
* b) debug exceptions were masked and we just unmasked them
* without changing EL (eg by clearing PSTATE.D)
* In either case we're going to take a swstep exception in the
* "did not step an insn" case, and so the syndrome ISV and EX
* bits should be zero.
*/
assert(dc->base.num_insns == 1);
gen_exception(EXCP_UDEF, syn_swstep(dc->ss_same_el, 0, 0),
default_exception_el(dc));
dc->base.is_jmp = DISAS_NORETURN;
return;
}
if (dc->thumb) {
disas_thumb_insn(env, dc);
if (dc->condexec_mask) {
dc->condexec_cond = (dc->condexec_cond & 0xe)
| ((dc->condexec_mask >> 4) & 1);
dc->condexec_mask = (dc->condexec_mask << 1) & 0x1f;
if (dc->condexec_mask == 0) {
dc->condexec_cond = 0;
}
}
} else {
unsigned int insn = arm_ldl_code(env, dc->pc, dc->sctlr_b);
dc->pc += 4;
disas_arm_insn(dc, insn);
}
if (dc->condjmp && !dc->base.is_jmp) {
gen_set_label(dc->condlabel);
dc->condjmp = 0;
}
if (dc->base.is_jmp == DISAS_NEXT) {
/* Translation stops when a conditional branch is encountered.
* Otherwise the subsequent code could get translated several times.
* Also stop translation when a page boundary is reached. This
* ensures prefetch aborts occur at the right place. */
if (dc->pc >= dc->next_page_start ||
(dc->pc >= dc->next_page_start - 3 &&
insn_crosses_page(env, dc))) {
/* We want to stop the TB if the next insn starts in a new page,
* or if it spans between this page and the next. This means that
* if we're looking at the last halfword in the page we need to
* see if it's a 16-bit Thumb insn (which will fit in this TB)
* or a 32-bit Thumb insn (which won't).
* This is to avoid generating a silly TB with a single 16-bit insn
* in it at the end of this page (which would execute correctly
* but isn't very efficient).
*/
dc->base.is_jmp = DISAS_TOO_MANY;
}
}
dc->base.pc_next = dc->pc;
translator_loop_temp_check(&dc->base);
}
| false | qemu | 722ef0a562a8cd810297b00516e36380e2f33353 | static void arm_tr_translate_insn(DisasContextBase *dcbase, CPUState *cpu)
{
DisasContext *dc = container_of(dcbase, DisasContext, base);
CPUARMState *env = cpu->env_ptr;
#ifdef CONFIG_USER_ONLY
if (dc->pc >= 0xffff0000) {
gen_exception_internal(EXCP_KERNEL_TRAP);
dc->base.is_jmp = DISAS_NORETURN;
return;
}
#endif
if (dc->ss_active && !dc->pstate_ss) {
assert(dc->base.num_insns == 1);
gen_exception(EXCP_UDEF, syn_swstep(dc->ss_same_el, 0, 0),
default_exception_el(dc));
dc->base.is_jmp = DISAS_NORETURN;
return;
}
if (dc->thumb) {
disas_thumb_insn(env, dc);
if (dc->condexec_mask) {
dc->condexec_cond = (dc->condexec_cond & 0xe)
| ((dc->condexec_mask >> 4) & 1);
dc->condexec_mask = (dc->condexec_mask << 1) & 0x1f;
if (dc->condexec_mask == 0) {
dc->condexec_cond = 0;
}
}
} else {
unsigned int insn = arm_ldl_code(env, dc->pc, dc->sctlr_b);
dc->pc += 4;
disas_arm_insn(dc, insn);
}
if (dc->condjmp && !dc->base.is_jmp) {
gen_set_label(dc->condlabel);
dc->condjmp = 0;
}
if (dc->base.is_jmp == DISAS_NEXT) {
if (dc->pc >= dc->next_page_start ||
(dc->pc >= dc->next_page_start - 3 &&
insn_crosses_page(env, dc))) {
dc->base.is_jmp = DISAS_TOO_MANY;
}
}
dc->base.pc_next = dc->pc;
translator_loop_temp_check(&dc->base);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DisasContextBase *VAR_0, CPUState *VAR_1)
{
DisasContext *dc = container_of(VAR_0, DisasContext, base);
CPUARMState *env = VAR_1->env_ptr;
#ifdef CONFIG_USER_ONLY
if (dc->pc >= 0xffff0000) {
gen_exception_internal(EXCP_KERNEL_TRAP);
dc->base.is_jmp = DISAS_NORETURN;
return;
}
#endif
if (dc->ss_active && !dc->pstate_ss) {
assert(dc->base.num_insns == 1);
gen_exception(EXCP_UDEF, syn_swstep(dc->ss_same_el, 0, 0),
default_exception_el(dc));
dc->base.is_jmp = DISAS_NORETURN;
return;
}
if (dc->thumb) {
disas_thumb_insn(env, dc);
if (dc->condexec_mask) {
dc->condexec_cond = (dc->condexec_cond & 0xe)
| ((dc->condexec_mask >> 4) & 1);
dc->condexec_mask = (dc->condexec_mask << 1) & 0x1f;
if (dc->condexec_mask == 0) {
dc->condexec_cond = 0;
}
}
} else {
unsigned int VAR_2 = arm_ldl_code(env, dc->pc, dc->sctlr_b);
dc->pc += 4;
disas_arm_insn(dc, VAR_2);
}
if (dc->condjmp && !dc->base.is_jmp) {
gen_set_label(dc->condlabel);
dc->condjmp = 0;
}
if (dc->base.is_jmp == DISAS_NEXT) {
if (dc->pc >= dc->next_page_start ||
(dc->pc >= dc->next_page_start - 3 &&
insn_crosses_page(env, dc))) {
dc->base.is_jmp = DISAS_TOO_MANY;
}
}
dc->base.pc_next = dc->pc;
translator_loop_temp_check(&dc->base);
}
| [
"static void FUNC_0(DisasContextBase *VAR_0, CPUState *VAR_1)\n{",
"DisasContext *dc = container_of(VAR_0, DisasContext, base);",
"CPUARMState *env = VAR_1->env_ptr;",
"#ifdef CONFIG_USER_ONLY\nif (dc->pc >= 0xffff0000) {",
"gen_exception_internal(EXCP_KERNEL_TRAP);",
"dc->base.is_jmp = DISAS_NORETURN;",
... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11,
15
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29,
33
],
[
55
],
[
57,
59
],
[
61
],
[
63
],
[
65
],
[
69
],
[
71
],
[
73
],
[
75,
77... |
2,067 | void ppc_tlb_invalidate_one(CPUPPCState *env, target_ulong addr)
{
#if !defined(FLUSH_ALL_TLBS)
PowerPCCPU *cpu = ppc_env_get_cpu(env);
CPUState *cs;
addr &= TARGET_PAGE_MASK;
switch (env->mmu_model) {
case POWERPC_MMU_SOFT_6xx:
case POWERPC_MMU_SOFT_74xx:
ppc6xx_tlb_invalidate_virt(env, addr, 0);
if (env->id_tlbs == 1) {
ppc6xx_tlb_invalidate_virt(env, addr, 1);
}
break;
case POWERPC_MMU_SOFT_4xx:
case POWERPC_MMU_SOFT_4xx_Z:
ppc4xx_tlb_invalidate_virt(env, addr, env->spr[SPR_40x_PID]);
break;
case POWERPC_MMU_REAL:
cpu_abort(CPU(cpu), "No TLB for PowerPC 4xx in real mode\n");
break;
case POWERPC_MMU_MPC8xx:
/* XXX: TODO */
cpu_abort(CPU(cpu), "MPC8xx MMU model is not implemented\n");
break;
case POWERPC_MMU_BOOKE:
/* XXX: TODO */
cpu_abort(CPU(cpu), "BookE MMU model is not implemented\n");
break;
case POWERPC_MMU_BOOKE206:
/* XXX: TODO */
cpu_abort(CPU(cpu), "BookE 2.06 MMU model is not implemented\n");
break;
case POWERPC_MMU_32B:
case POWERPC_MMU_601:
/* tlbie invalidate TLBs for all segments */
addr &= ~((target_ulong)-1ULL << 28);
cs = CPU(cpu);
/* XXX: this case should be optimized,
* giving a mask to tlb_flush_page
*/
tlb_flush_page(cs, addr | (0x0 << 28));
tlb_flush_page(cs, addr | (0x1 << 28));
tlb_flush_page(cs, addr | (0x2 << 28));
tlb_flush_page(cs, addr | (0x3 << 28));
tlb_flush_page(cs, addr | (0x4 << 28));
tlb_flush_page(cs, addr | (0x5 << 28));
tlb_flush_page(cs, addr | (0x6 << 28));
tlb_flush_page(cs, addr | (0x7 << 28));
tlb_flush_page(cs, addr | (0x8 << 28));
tlb_flush_page(cs, addr | (0x9 << 28));
tlb_flush_page(cs, addr | (0xA << 28));
tlb_flush_page(cs, addr | (0xB << 28));
tlb_flush_page(cs, addr | (0xC << 28));
tlb_flush_page(cs, addr | (0xD << 28));
tlb_flush_page(cs, addr | (0xE << 28));
tlb_flush_page(cs, addr | (0xF << 28));
break;
#if defined(TARGET_PPC64)
case POWERPC_MMU_64B:
case POWERPC_MMU_2_03:
case POWERPC_MMU_2_06:
case POWERPC_MMU_2_06a:
case POWERPC_MMU_2_07:
case POWERPC_MMU_2_07a:
/* tlbie invalidate TLBs for all segments */
/* XXX: given the fact that there are too many segments to invalidate,
* and we still don't have a tlb_flush_mask(env, n, mask) in QEMU,
* we just invalidate all TLBs
*/
tlb_flush(CPU(cpu), 1);
break;
#endif /* defined(TARGET_PPC64) */
default:
/* XXX: TODO */
cpu_abort(CPU(cpu), "Unknown MMU model\n");
break;
}
#else
ppc_tlb_invalidate_all(env);
#endif
}
| false | qemu | 041d95f42e39ed1d3a029332cab9966889f0aeb3 | void ppc_tlb_invalidate_one(CPUPPCState *env, target_ulong addr)
{
#if !defined(FLUSH_ALL_TLBS)
PowerPCCPU *cpu = ppc_env_get_cpu(env);
CPUState *cs;
addr &= TARGET_PAGE_MASK;
switch (env->mmu_model) {
case POWERPC_MMU_SOFT_6xx:
case POWERPC_MMU_SOFT_74xx:
ppc6xx_tlb_invalidate_virt(env, addr, 0);
if (env->id_tlbs == 1) {
ppc6xx_tlb_invalidate_virt(env, addr, 1);
}
break;
case POWERPC_MMU_SOFT_4xx:
case POWERPC_MMU_SOFT_4xx_Z:
ppc4xx_tlb_invalidate_virt(env, addr, env->spr[SPR_40x_PID]);
break;
case POWERPC_MMU_REAL:
cpu_abort(CPU(cpu), "No TLB for PowerPC 4xx in real mode\n");
break;
case POWERPC_MMU_MPC8xx:
cpu_abort(CPU(cpu), "MPC8xx MMU model is not implemented\n");
break;
case POWERPC_MMU_BOOKE:
cpu_abort(CPU(cpu), "BookE MMU model is not implemented\n");
break;
case POWERPC_MMU_BOOKE206:
cpu_abort(CPU(cpu), "BookE 2.06 MMU model is not implemented\n");
break;
case POWERPC_MMU_32B:
case POWERPC_MMU_601:
addr &= ~((target_ulong)-1ULL << 28);
cs = CPU(cpu);
tlb_flush_page(cs, addr | (0x0 << 28));
tlb_flush_page(cs, addr | (0x1 << 28));
tlb_flush_page(cs, addr | (0x2 << 28));
tlb_flush_page(cs, addr | (0x3 << 28));
tlb_flush_page(cs, addr | (0x4 << 28));
tlb_flush_page(cs, addr | (0x5 << 28));
tlb_flush_page(cs, addr | (0x6 << 28));
tlb_flush_page(cs, addr | (0x7 << 28));
tlb_flush_page(cs, addr | (0x8 << 28));
tlb_flush_page(cs, addr | (0x9 << 28));
tlb_flush_page(cs, addr | (0xA << 28));
tlb_flush_page(cs, addr | (0xB << 28));
tlb_flush_page(cs, addr | (0xC << 28));
tlb_flush_page(cs, addr | (0xD << 28));
tlb_flush_page(cs, addr | (0xE << 28));
tlb_flush_page(cs, addr | (0xF << 28));
break;
#if defined(TARGET_PPC64)
case POWERPC_MMU_64B:
case POWERPC_MMU_2_03:
case POWERPC_MMU_2_06:
case POWERPC_MMU_2_06a:
case POWERPC_MMU_2_07:
case POWERPC_MMU_2_07a:
tlb_flush(CPU(cpu), 1);
break;
#endif
default:
cpu_abort(CPU(cpu), "Unknown MMU model\n");
break;
}
#else
ppc_tlb_invalidate_all(env);
#endif
}
| {
"code": [],
"line_no": []
} | void FUNC_0(CPUPPCState *VAR_0, target_ulong VAR_1)
{
#if !defined(FLUSH_ALL_TLBS)
PowerPCCPU *cpu = ppc_env_get_cpu(VAR_0);
CPUState *cs;
VAR_1 &= TARGET_PAGE_MASK;
switch (VAR_0->mmu_model) {
case POWERPC_MMU_SOFT_6xx:
case POWERPC_MMU_SOFT_74xx:
ppc6xx_tlb_invalidate_virt(VAR_0, VAR_1, 0);
if (VAR_0->id_tlbs == 1) {
ppc6xx_tlb_invalidate_virt(VAR_0, VAR_1, 1);
}
break;
case POWERPC_MMU_SOFT_4xx:
case POWERPC_MMU_SOFT_4xx_Z:
ppc4xx_tlb_invalidate_virt(VAR_0, VAR_1, VAR_0->spr[SPR_40x_PID]);
break;
case POWERPC_MMU_REAL:
cpu_abort(CPU(cpu), "No TLB for PowerPC 4xx in real mode\n");
break;
case POWERPC_MMU_MPC8xx:
cpu_abort(CPU(cpu), "MPC8xx MMU model is not implemented\n");
break;
case POWERPC_MMU_BOOKE:
cpu_abort(CPU(cpu), "BookE MMU model is not implemented\n");
break;
case POWERPC_MMU_BOOKE206:
cpu_abort(CPU(cpu), "BookE 2.06 MMU model is not implemented\n");
break;
case POWERPC_MMU_32B:
case POWERPC_MMU_601:
VAR_1 &= ~((target_ulong)-1ULL << 28);
cs = CPU(cpu);
tlb_flush_page(cs, VAR_1 | (0x0 << 28));
tlb_flush_page(cs, VAR_1 | (0x1 << 28));
tlb_flush_page(cs, VAR_1 | (0x2 << 28));
tlb_flush_page(cs, VAR_1 | (0x3 << 28));
tlb_flush_page(cs, VAR_1 | (0x4 << 28));
tlb_flush_page(cs, VAR_1 | (0x5 << 28));
tlb_flush_page(cs, VAR_1 | (0x6 << 28));
tlb_flush_page(cs, VAR_1 | (0x7 << 28));
tlb_flush_page(cs, VAR_1 | (0x8 << 28));
tlb_flush_page(cs, VAR_1 | (0x9 << 28));
tlb_flush_page(cs, VAR_1 | (0xA << 28));
tlb_flush_page(cs, VAR_1 | (0xB << 28));
tlb_flush_page(cs, VAR_1 | (0xC << 28));
tlb_flush_page(cs, VAR_1 | (0xD << 28));
tlb_flush_page(cs, VAR_1 | (0xE << 28));
tlb_flush_page(cs, VAR_1 | (0xF << 28));
break;
#if defined(TARGET_PPC64)
case POWERPC_MMU_64B:
case POWERPC_MMU_2_03:
case POWERPC_MMU_2_06:
case POWERPC_MMU_2_06a:
case POWERPC_MMU_2_07:
case POWERPC_MMU_2_07a:
tlb_flush(CPU(cpu), 1);
break;
#endif
default:
cpu_abort(CPU(cpu), "Unknown MMU model\n");
break;
}
#else
ppc_tlb_invalidate_all(VAR_0);
#endif
}
| [
"void FUNC_0(CPUPPCState *VAR_0, target_ulong VAR_1)\n{",
"#if !defined(FLUSH_ALL_TLBS)\nPowerPCCPU *cpu = ppc_env_get_cpu(VAR_0);",
"CPUState *cs;",
"VAR_1 &= TARGET_PAGE_MASK;",
"switch (VAR_0->mmu_model) {",
"case POWERPC_MMU_SOFT_6xx:\ncase POWERPC_MMU_SOFT_74xx:\nppc6xx_tlb_invalidate_virt(VAR_0, VAR... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5,
7
],
[
9
],
[
13
],
[
15
],
[
17,
19,
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31,
33,
35
],
[
37
],
[
39,
41
],
[
43
],
[
45,
49
],
[
51
],
[... |
2,069 | static int scsi_qdev_init(DeviceState *qdev)
{
SCSIDevice *dev = SCSI_DEVICE(qdev);
SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, dev->qdev.parent_bus);
SCSIDevice *d;
int rc = -1;
if (dev->channel > bus->info->max_channel) {
error_report("bad scsi channel id: %d", dev->channel);
goto err;
}
if (dev->id != -1 && dev->id > bus->info->max_target) {
error_report("bad scsi device id: %d", dev->id);
goto err;
}
if (dev->lun != -1 && dev->lun > bus->info->max_lun) {
error_report("bad scsi device lun: %d", dev->lun);
goto err;
}
if (dev->id == -1) {
int id = -1;
if (dev->lun == -1) {
dev->lun = 0;
}
do {
d = scsi_device_find(bus, dev->channel, ++id, dev->lun);
} while (d && d->lun == dev->lun && id < bus->info->max_target);
if (d && d->lun == dev->lun) {
error_report("no free target");
goto err;
}
dev->id = id;
} else if (dev->lun == -1) {
int lun = -1;
do {
d = scsi_device_find(bus, dev->channel, dev->id, ++lun);
} while (d && d->lun == lun && lun < bus->info->max_lun);
if (d && d->lun == lun) {
error_report("no free lun");
goto err;
}
dev->lun = lun;
} else {
d = scsi_device_find(bus, dev->channel, dev->id, dev->lun);
assert(d);
if (d->lun == dev->lun && dev != d) {
error_report("lun already used by '%s'", d->qdev.id);
goto err;
}
}
QTAILQ_INIT(&dev->requests);
rc = scsi_device_init(dev);
if (rc == 0) {
dev->vmsentry = qemu_add_vm_change_state_handler(scsi_dma_restart_cb,
dev);
}
if (bus->info->hotplug) {
bus->info->hotplug(bus, dev);
}
err:
return rc;
}
| false | qemu | a818a4b69d47ca3826dee36878074395aeac2083 | static int scsi_qdev_init(DeviceState *qdev)
{
SCSIDevice *dev = SCSI_DEVICE(qdev);
SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, dev->qdev.parent_bus);
SCSIDevice *d;
int rc = -1;
if (dev->channel > bus->info->max_channel) {
error_report("bad scsi channel id: %d", dev->channel);
goto err;
}
if (dev->id != -1 && dev->id > bus->info->max_target) {
error_report("bad scsi device id: %d", dev->id);
goto err;
}
if (dev->lun != -1 && dev->lun > bus->info->max_lun) {
error_report("bad scsi device lun: %d", dev->lun);
goto err;
}
if (dev->id == -1) {
int id = -1;
if (dev->lun == -1) {
dev->lun = 0;
}
do {
d = scsi_device_find(bus, dev->channel, ++id, dev->lun);
} while (d && d->lun == dev->lun && id < bus->info->max_target);
if (d && d->lun == dev->lun) {
error_report("no free target");
goto err;
}
dev->id = id;
} else if (dev->lun == -1) {
int lun = -1;
do {
d = scsi_device_find(bus, dev->channel, dev->id, ++lun);
} while (d && d->lun == lun && lun < bus->info->max_lun);
if (d && d->lun == lun) {
error_report("no free lun");
goto err;
}
dev->lun = lun;
} else {
d = scsi_device_find(bus, dev->channel, dev->id, dev->lun);
assert(d);
if (d->lun == dev->lun && dev != d) {
error_report("lun already used by '%s'", d->qdev.id);
goto err;
}
}
QTAILQ_INIT(&dev->requests);
rc = scsi_device_init(dev);
if (rc == 0) {
dev->vmsentry = qemu_add_vm_change_state_handler(scsi_dma_restart_cb,
dev);
}
if (bus->info->hotplug) {
bus->info->hotplug(bus, dev);
}
err:
return rc;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(DeviceState *VAR_0)
{
SCSIDevice *dev = SCSI_DEVICE(VAR_0);
SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, dev->VAR_0.parent_bus);
SCSIDevice *d;
int VAR_1 = -1;
if (dev->channel > bus->info->max_channel) {
error_report("bad scsi channel VAR_2: %d", dev->channel);
goto err;
}
if (dev->VAR_2 != -1 && dev->VAR_2 > bus->info->max_target) {
error_report("bad scsi device VAR_2: %d", dev->VAR_2);
goto err;
}
if (dev->VAR_3 != -1 && dev->VAR_3 > bus->info->max_lun) {
error_report("bad scsi device VAR_3: %d", dev->VAR_3);
goto err;
}
if (dev->VAR_2 == -1) {
int VAR_2 = -1;
if (dev->VAR_3 == -1) {
dev->VAR_3 = 0;
}
do {
d = scsi_device_find(bus, dev->channel, ++VAR_2, dev->VAR_3);
} while (d && d->VAR_3 == dev->VAR_3 && VAR_2 < bus->info->max_target);
if (d && d->VAR_3 == dev->VAR_3) {
error_report("no free target");
goto err;
}
dev->VAR_2 = VAR_2;
} else if (dev->VAR_3 == -1) {
int VAR_3 = -1;
do {
d = scsi_device_find(bus, dev->channel, dev->VAR_2, ++VAR_3);
} while (d && d->VAR_3 == VAR_3 && VAR_3 < bus->info->max_lun);
if (d && d->VAR_3 == VAR_3) {
error_report("no free VAR_3");
goto err;
}
dev->VAR_3 = VAR_3;
} else {
d = scsi_device_find(bus, dev->channel, dev->VAR_2, dev->VAR_3);
assert(d);
if (d->VAR_3 == dev->VAR_3 && dev != d) {
error_report("VAR_3 already used by '%s'", d->VAR_0.VAR_2);
goto err;
}
}
QTAILQ_INIT(&dev->requests);
VAR_1 = scsi_device_init(dev);
if (VAR_1 == 0) {
dev->vmsentry = qemu_add_vm_change_state_handler(scsi_dma_restart_cb,
dev);
}
if (bus->info->hotplug) {
bus->info->hotplug(bus, dev);
}
err:
return VAR_1;
}
| [
"static int FUNC_0(DeviceState *VAR_0)\n{",
"SCSIDevice *dev = SCSI_DEVICE(VAR_0);",
"SCSIBus *bus = DO_UPCAST(SCSIBus, qbus, dev->VAR_0.parent_bus);",
"SCSIDevice *d;",
"int VAR_1 = -1;",
"if (dev->channel > bus->info->max_channel) {",
"error_report(\"bad scsi channel VAR_2: %d\", dev->channel);",
"g... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
... |
2,070 | static BusState *qbus_find_recursive(BusState *bus, const char *name,
const BusInfo *info)
{
DeviceState *dev;
BusState *child, *ret;
int match = 1;
if (name && (strcmp(bus->name, name) != 0)) {
match = 0;
}
if (info && (bus->info != info)) {
match = 0;
}
if (match) {
return bus;
}
LIST_FOREACH(dev, &bus->children, sibling) {
LIST_FOREACH(child, &dev->child_bus, sibling) {
ret = qbus_find_recursive(child, name, info);
if (ret) {
return ret;
}
}
}
return NULL;
}
| false | qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | static BusState *qbus_find_recursive(BusState *bus, const char *name,
const BusInfo *info)
{
DeviceState *dev;
BusState *child, *ret;
int match = 1;
if (name && (strcmp(bus->name, name) != 0)) {
match = 0;
}
if (info && (bus->info != info)) {
match = 0;
}
if (match) {
return bus;
}
LIST_FOREACH(dev, &bus->children, sibling) {
LIST_FOREACH(child, &dev->child_bus, sibling) {
ret = qbus_find_recursive(child, name, info);
if (ret) {
return ret;
}
}
}
return NULL;
}
| {
"code": [],
"line_no": []
} | static BusState *FUNC_0(BusState *bus, const char *name,
const BusInfo *info)
{
DeviceState *dev;
BusState *child, *ret;
int VAR_0 = 1;
if (name && (strcmp(bus->name, name) != 0)) {
VAR_0 = 0;
}
if (info && (bus->info != info)) {
VAR_0 = 0;
}
if (VAR_0) {
return bus;
}
LIST_FOREACH(dev, &bus->children, sibling) {
LIST_FOREACH(child, &dev->child_bus, sibling) {
ret = FUNC_0(child, name, info);
if (ret) {
return ret;
}
}
}
return NULL;
}
| [
"static BusState *FUNC_0(BusState *bus, const char *name,\nconst BusInfo *info)\n{",
"DeviceState *dev;",
"BusState *child, *ret;",
"int VAR_0 = 1;",
"if (name && (strcmp(bus->name, name) != 0)) {",
"VAR_0 = 0;",
"}",
"if (info && (bus->info != info)) {",
"VAR_0 = 0;",
"}",
"if (VAR_0) {",
"re... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[... |
2,071 | static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
{
if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
AVDictionaryEntry *tag=NULL;
av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
if(strcmp("language", tag->key)){
const char *p = tag->value;
av_log(ctx, AV_LOG_INFO, "%s %-16s: ", indent, tag->key);
while(*p) {
char tmp[256];
size_t len = strcspn(p, "\xd\xa");
av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
av_log(ctx, AV_LOG_INFO, "%s", tmp);
p += len;
if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
if (*p) p++;
}
av_log(ctx, AV_LOG_INFO, "\n");
}
}
}
}
| false | FFmpeg | b615dbb319fc1748af6ea0ac95b5f89e03c5de0e | static void dump_metadata(void *ctx, AVDictionary *m, const char *indent)
{
if(m && !(m->count == 1 && av_dict_get(m, "language", NULL, 0))){
AVDictionaryEntry *tag=NULL;
av_log(ctx, AV_LOG_INFO, "%sMetadata:\n", indent);
while((tag=av_dict_get(m, "", tag, AV_DICT_IGNORE_SUFFIX))) {
if(strcmp("language", tag->key)){
const char *p = tag->value;
av_log(ctx, AV_LOG_INFO, "%s %-16s: ", indent, tag->key);
while(*p) {
char tmp[256];
size_t len = strcspn(p, "\xd\xa");
av_strlcpy(tmp, p, FFMIN(sizeof(tmp), len+1));
av_log(ctx, AV_LOG_INFO, "%s", tmp);
p += len;
if (*p == 0xd) av_log(ctx, AV_LOG_INFO, " ");
if (*p == 0xa) av_log(ctx, AV_LOG_INFO, "\n%s %-16s: ", indent, "");
if (*p) p++;
}
av_log(ctx, AV_LOG_INFO, "\n");
}
}
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0, AVDictionary *VAR_1, const char *VAR_2)
{
if(VAR_1 && !(VAR_1->count == 1 && av_dict_get(VAR_1, "language", NULL, 0))){
AVDictionaryEntry *tag=NULL;
av_log(VAR_0, AV_LOG_INFO, "%sMetadata:\n", VAR_2);
while((tag=av_dict_get(VAR_1, "", tag, AV_DICT_IGNORE_SUFFIX))) {
if(strcmp("language", tag->key)){
const char *VAR_3 = tag->value;
av_log(VAR_0, AV_LOG_INFO, "%s %-16s: ", VAR_2, tag->key);
while(*VAR_3) {
char VAR_4[256];
size_t len = strcspn(VAR_3, "\xd\xa");
av_strlcpy(VAR_4, VAR_3, FFMIN(sizeof(VAR_4), len+1));
av_log(VAR_0, AV_LOG_INFO, "%s", VAR_4);
VAR_3 += len;
if (*VAR_3 == 0xd) av_log(VAR_0, AV_LOG_INFO, " ");
if (*VAR_3 == 0xa) av_log(VAR_0, AV_LOG_INFO, "\n%s %-16s: ", VAR_2, "");
if (*VAR_3) VAR_3++;
}
av_log(VAR_0, AV_LOG_INFO, "\n");
}
}
}
}
| [
"static void FUNC_0(void *VAR_0, AVDictionary *VAR_1, const char *VAR_2)\n{",
"if(VAR_1 && !(VAR_1->count == 1 && av_dict_get(VAR_1, \"language\", NULL, 0))){",
"AVDictionaryEntry *tag=NULL;",
"av_log(VAR_0, AV_LOG_INFO, \"%sMetadata:\\n\", VAR_2);",
"while((tag=av_dict_get(VAR_1, \"\", tag, AV_DICT_IGNORE_... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43... |
2,072 | X86CPU *cpu_x86_create(const char *cpu_model, Error **errp)
{
X86CPU *cpu = NULL;
ObjectClass *oc;
CPUClass *cc;
gchar **model_pieces;
char *name, *features;
Error *error = NULL;
const char *typename;
model_pieces = g_strsplit(cpu_model, ",", 2);
if (!model_pieces[0]) {
error_setg(&error, "Invalid/empty CPU model name");
goto out;
}
name = model_pieces[0];
features = model_pieces[1];
oc = x86_cpu_class_by_name(name);
if (oc == NULL) {
error_setg(&error, "Unable to find CPU definition: %s", name);
goto out;
}
cc = CPU_CLASS(oc);
typename = object_class_get_name(oc);
cc->parse_features(typename, features, &error);
cpu = X86_CPU(object_new(typename));
if (error) {
goto out;
}
out:
if (error != NULL) {
error_propagate(errp, error);
if (cpu) {
object_unref(OBJECT(cpu));
cpu = NULL;
}
}
g_strfreev(model_pieces);
return cpu;
}
| false | qemu | 6aff24c6a61c6fec31e555c7748ba6085b7b2c06 | X86CPU *cpu_x86_create(const char *cpu_model, Error **errp)
{
X86CPU *cpu = NULL;
ObjectClass *oc;
CPUClass *cc;
gchar **model_pieces;
char *name, *features;
Error *error = NULL;
const char *typename;
model_pieces = g_strsplit(cpu_model, ",", 2);
if (!model_pieces[0]) {
error_setg(&error, "Invalid/empty CPU model name");
goto out;
}
name = model_pieces[0];
features = model_pieces[1];
oc = x86_cpu_class_by_name(name);
if (oc == NULL) {
error_setg(&error, "Unable to find CPU definition: %s", name);
goto out;
}
cc = CPU_CLASS(oc);
typename = object_class_get_name(oc);
cc->parse_features(typename, features, &error);
cpu = X86_CPU(object_new(typename));
if (error) {
goto out;
}
out:
if (error != NULL) {
error_propagate(errp, error);
if (cpu) {
object_unref(OBJECT(cpu));
cpu = NULL;
}
}
g_strfreev(model_pieces);
return cpu;
}
| {
"code": [],
"line_no": []
} | X86CPU *FUNC_0(const char *cpu_model, Error **errp)
{
X86CPU *cpu = NULL;
ObjectClass *oc;
CPUClass *cc;
gchar **model_pieces;
char *VAR_0, *VAR_1;
Error *error = NULL;
const char *VAR_2;
model_pieces = g_strsplit(cpu_model, ",", 2);
if (!model_pieces[0]) {
error_setg(&error, "Invalid/empty CPU model VAR_0");
goto out;
}
VAR_0 = model_pieces[0];
VAR_1 = model_pieces[1];
oc = x86_cpu_class_by_name(VAR_0);
if (oc == NULL) {
error_setg(&error, "Unable to find CPU definition: %s", VAR_0);
goto out;
}
cc = CPU_CLASS(oc);
VAR_2 = object_class_get_name(oc);
cc->parse_features(VAR_2, VAR_1, &error);
cpu = X86_CPU(object_new(VAR_2));
if (error) {
goto out;
}
out:
if (error != NULL) {
error_propagate(errp, error);
if (cpu) {
object_unref(OBJECT(cpu));
cpu = NULL;
}
}
g_strfreev(model_pieces);
return cpu;
}
| [
"X86CPU *FUNC_0(const char *cpu_model, Error **errp)\n{",
"X86CPU *cpu = NULL;",
"ObjectClass *oc;",
"CPUClass *cc;",
"gchar **model_pieces;",
"char *VAR_0, *VAR_1;",
"Error *error = NULL;",
"const char *VAR_2;",
"model_pieces = g_strsplit(cpu_model, \",\", 2);",
"if (!model_pieces[0]) {",
"erro... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
... |
2,073 | static QEMUClock *qemu_new_clock(int type)
{
QEMUClock *clock;
clock = g_malloc0(sizeof(QEMUClock));
clock->type = type;
clock->enabled = true;
clock->last = INT64_MIN;
notifier_list_init(&clock->reset_notifiers);
return clock;
}
| false | qemu | 58ac56b9ad53b006396523639bb7d7043edc56bf | static QEMUClock *qemu_new_clock(int type)
{
QEMUClock *clock;
clock = g_malloc0(sizeof(QEMUClock));
clock->type = type;
clock->enabled = true;
clock->last = INT64_MIN;
notifier_list_init(&clock->reset_notifiers);
return clock;
}
| {
"code": [],
"line_no": []
} | static QEMUClock *FUNC_0(int type)
{
QEMUClock *clock;
clock = g_malloc0(sizeof(QEMUClock));
clock->type = type;
clock->enabled = true;
clock->last = INT64_MIN;
notifier_list_init(&clock->reset_notifiers);
return clock;
}
| [
"static QEMUClock *FUNC_0(int type)\n{",
"QEMUClock *clock;",
"clock = g_malloc0(sizeof(QEMUClock));",
"clock->type = type;",
"clock->enabled = true;",
"clock->last = INT64_MIN;",
"notifier_list_init(&clock->reset_notifiers);",
"return clock;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
]
] |
2,074 | static gboolean gd_enter_event(GtkWidget *widget, GdkEventCrossing *crossing,
gpointer opaque)
{
VirtualConsole *vc = opaque;
GtkDisplayState *s = vc->s;
if (!gd_is_grab_active(s) && gd_grab_on_hover(s)) {
gd_grab_keyboard(vc);
}
return TRUE;
}
| false | qemu | 2884cf5b934808f547b5268a51be631805c25857 | static gboolean gd_enter_event(GtkWidget *widget, GdkEventCrossing *crossing,
gpointer opaque)
{
VirtualConsole *vc = opaque;
GtkDisplayState *s = vc->s;
if (!gd_is_grab_active(s) && gd_grab_on_hover(s)) {
gd_grab_keyboard(vc);
}
return TRUE;
}
| {
"code": [],
"line_no": []
} | static gboolean FUNC_0(GtkWidget *widget, GdkEventCrossing *crossing,
gpointer opaque)
{
VirtualConsole *vc = opaque;
GtkDisplayState *s = vc->s;
if (!gd_is_grab_active(s) && gd_grab_on_hover(s)) {
gd_grab_keyboard(vc);
}
return TRUE;
}
| [
"static gboolean FUNC_0(GtkWidget *widget, GdkEventCrossing *crossing,\ngpointer opaque)\n{",
"VirtualConsole *vc = opaque;",
"GtkDisplayState *s = vc->s;",
"if (!gd_is_grab_active(s) && gd_grab_on_hover(s)) {",
"gd_grab_keyboard(vc);",
"}",
"return TRUE;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
]
] |
2,075 | sd_co_get_block_status(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
int *pnum)
{
BDRVSheepdogState *s = bs->opaque;
SheepdogInode *inode = &s->inode;
uint32_t object_size = (UINT32_C(1) << inode->block_size_shift);
uint64_t offset = sector_num * BDRV_SECTOR_SIZE;
unsigned long start = offset / object_size,
end = DIV_ROUND_UP((sector_num + nb_sectors) *
BDRV_SECTOR_SIZE, object_size);
unsigned long idx;
int64_t ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | offset;
for (idx = start; idx < end; idx++) {
if (inode->data_vdi_id[idx] == 0) {
break;
}
}
if (idx == start) {
/* Get the longest length of unallocated sectors */
ret = 0;
for (idx = start + 1; idx < end; idx++) {
if (inode->data_vdi_id[idx] != 0) {
break;
}
}
}
*pnum = (idx - start) * object_size / BDRV_SECTOR_SIZE;
if (*pnum > nb_sectors) {
*pnum = nb_sectors;
}
return ret;
}
| false | qemu | 67a0fd2a9bca204d2b39f910a97c7137636a0715 | sd_co_get_block_status(BlockDriverState *bs, int64_t sector_num, int nb_sectors,
int *pnum)
{
BDRVSheepdogState *s = bs->opaque;
SheepdogInode *inode = &s->inode;
uint32_t object_size = (UINT32_C(1) << inode->block_size_shift);
uint64_t offset = sector_num * BDRV_SECTOR_SIZE;
unsigned long start = offset / object_size,
end = DIV_ROUND_UP((sector_num + nb_sectors) *
BDRV_SECTOR_SIZE, object_size);
unsigned long idx;
int64_t ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | offset;
for (idx = start; idx < end; idx++) {
if (inode->data_vdi_id[idx] == 0) {
break;
}
}
if (idx == start) {
ret = 0;
for (idx = start + 1; idx < end; idx++) {
if (inode->data_vdi_id[idx] != 0) {
break;
}
}
}
*pnum = (idx - start) * object_size / BDRV_SECTOR_SIZE;
if (*pnum > nb_sectors) {
*pnum = nb_sectors;
}
return ret;
}
| {
"code": [],
"line_no": []
} | FUNC_0(BlockDriverState *VAR_0, int64_t VAR_1, int VAR_2,
int *VAR_3)
{
BDRVSheepdogState *s = VAR_0->opaque;
SheepdogInode *inode = &s->inode;
uint32_t object_size = (UINT32_C(1) << inode->block_size_shift);
uint64_t offset = VAR_1 * BDRV_SECTOR_SIZE;
unsigned long VAR_4 = offset / object_size,
VAR_5 = DIV_ROUND_UP((VAR_1 + VAR_2) *
BDRV_SECTOR_SIZE, object_size);
unsigned long VAR_6;
int64_t ret = BDRV_BLOCK_DATA | BDRV_BLOCK_OFFSET_VALID | offset;
for (VAR_6 = VAR_4; VAR_6 < VAR_5; VAR_6++) {
if (inode->data_vdi_id[VAR_6] == 0) {
break;
}
}
if (VAR_6 == VAR_4) {
ret = 0;
for (VAR_6 = VAR_4 + 1; VAR_6 < VAR_5; VAR_6++) {
if (inode->data_vdi_id[VAR_6] != 0) {
break;
}
}
}
*VAR_3 = (VAR_6 - VAR_4) * object_size / BDRV_SECTOR_SIZE;
if (*VAR_3 > VAR_2) {
*VAR_3 = VAR_2;
}
return ret;
}
| [
"FUNC_0(BlockDriverState *VAR_0, int64_t VAR_1, int VAR_2,\nint *VAR_3)\n{",
"BDRVSheepdogState *s = VAR_0->opaque;",
"SheepdogInode *inode = &s->inode;",
"uint32_t object_size = (UINT32_C(1) << inode->block_size_shift);",
"uint64_t offset = VAR_1 * BDRV_SECTOR_SIZE;",
"unsigned long VAR_4 = offset / obje... | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15,
17,
19
],
[
21
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.