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
sequencelengths 1
2.8k
| label
sequencelengths 1
2.8k
| line_no
sequencelengths 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 = &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;",
"}"
] | [
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
],
[
64
]
] |
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)\nsscanf(args, \"%127[^:]:%127[^:]:%1023[^:=]%VAR_1%255c\",\nVAR_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 ||\nframe_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);",
"}"
] | [
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
],
[
55
],
[
57
]
] |
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; VAR_1 < VAR_0->nb_streams; VAR_1++) {",
"OutputStream *os = &c->streams[VAR_1];",
"if (os->ctx && os->ctx_inited)\nav_write_trailer(os->ctx);",
"if (os->ctx && os->ctx->pb)\nffio_free_dyn_buf(&os->ctx->pb);",
"ff_format_io_close(VAR_0, &os->out);",
"if (os->ctx)\navformat_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);",
"}"
] | [
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
],
[
24
],
[
25
],
[
26
],
[
27
]
] |
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->opcode);",
"switch (op2) {",
"case OPC2_32_BO_CACHEA_WI_SHORTOFF:\ncase OPC2_32_BO_CACHEA_W_SHORTOFF:\ncase OPC2_32_BO_CACHEA_I_SHORTOFF:\nbreak;",
"case OPC2_32_BO_CACHEA_WI_POSTINC:\ncase OPC2_32_BO_CACHEA_W_POSTINC:\ncase OPC2_32_BO_CACHEA_I_POSTINC:\ntcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);",
"break;",
"case OPC2_32_BO_CACHEA_WI_PREINC:\ncase OPC2_32_BO_CACHEA_W_PREINC:\ncase OPC2_32_BO_CACHEA_I_PREINC:\ntcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);",
"break;",
"case OPC2_32_BO_CACHEI_WI_SHORTOFF:\ncase OPC2_32_BO_CACHEI_W_SHORTOFF:\nbreak;",
"case OPC2_32_BO_CACHEI_W_POSTINC:\ncase OPC2_32_BO_CACHEI_WI_POSTINC:\nif (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:\ncase OPC2_32_BO_CACHEI_WI_PREINC:\nif (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:\ngen_offset_st(VAR_1, cpu_gpr_a[r1], cpu_gpr_a[r2], off10, MO_LESL);",
"break;",
"case OPC2_32_BO_ST_A_POSTINC:\ntcg_gen_qemu_st_tl(cpu_gpr_a[r1], cpu_gpr_a[r2], VAR_1->mem_idx,\nMO_LESL);",
"tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);",
"break;",
"case OPC2_32_BO_ST_A_PREINC:\ngen_st_preincr(VAR_1, cpu_gpr_a[r1], cpu_gpr_a[r2], off10, MO_LESL);",
"break;",
"case OPC2_32_BO_ST_B_SHORTOFF:\ngen_offset_st(VAR_1, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_UB);",
"break;",
"case OPC2_32_BO_ST_B_POSTINC:\ntcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], VAR_1->mem_idx,\nMO_UB);",
"tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);",
"break;",
"case OPC2_32_BO_ST_B_PREINC:\ngen_st_preincr(VAR_1, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_UB);",
"break;",
"case OPC2_32_BO_ST_D_SHORTOFF:\ngen_offset_st_2regs(cpu_gpr_d[r1+1], cpu_gpr_d[r1], cpu_gpr_a[r2],\noff10, VAR_1);",
"break;",
"case OPC2_32_BO_ST_D_POSTINC:\ngen_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:\ntemp = 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:\ngen_offset_st_2regs(cpu_gpr_a[r1+1], cpu_gpr_a[r1], cpu_gpr_a[r2],\noff10, VAR_1);",
"break;",
"case OPC2_32_BO_ST_DA_POSTINC:\ngen_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:\ntemp = 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:\ngen_offset_st(VAR_1, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);",
"break;",
"case OPC2_32_BO_ST_H_POSTINC:\ntcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], VAR_1->mem_idx,\nMO_LEUW);",
"tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);",
"break;",
"case OPC2_32_BO_ST_H_PREINC:\ngen_st_preincr(VAR_1, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUW);",
"break;",
"case OPC2_32_BO_ST_Q_SHORTOFF:\ntemp = 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:\ntemp = 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,\nMO_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:\ntemp = 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:\ngen_offset_st(VAR_1, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUL);",
"break;",
"case OPC2_32_BO_ST_W_POSTINC:\ntcg_gen_qemu_st_tl(cpu_gpr_d[r1], cpu_gpr_a[r2], VAR_1->mem_idx,\nMO_LEUL);",
"tcg_gen_addi_tl(cpu_gpr_a[r2], cpu_gpr_a[r2], off10);",
"break;",
"case OPC2_32_BO_ST_W_PREINC:\ngen_st_preincr(VAR_1, cpu_gpr_d[r1], cpu_gpr_a[r2], off10, MO_LEUL);",
"break;",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
67,
69,
75
],
[
77,
79,
81
],
[
83
],
[
85
],
[
87
],
[
89,
91,
93
],
[
95
],
[
97
],
[
99
],
[
101,
103
],
[
105
],
[
107,
109,
111
],
[
113
],
[
115
],
[
117,
119
],
[
121
],
[
123,
125
],
[
127
],
[
129,
131,
133
],
[
135
],
[
137
],
[
139,
141
],
[
143
],
[
145,
147,
149
],
[
151
],
[
153,
155
],
[
157
],
[
159
],
[
161,
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175,
177,
179
],
[
181
],
[
183,
185
],
[
187
],
[
189
],
[
191,
193
],
[
195
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205,
207
],
[
209
],
[
211,
213,
215
],
[
217
],
[
219
],
[
221,
223
],
[
225
],
[
227,
229
],
[
231
],
[
233
],
[
235
],
[
237
],
[
239,
241
],
[
243
],
[
245,
247
],
[
249
],
[
251
],
[
253
],
[
255,
257
],
[
259
],
[
261
],
[
263
],
[
265
],
[
267,
269
],
[
271
],
[
273,
275,
277
],
[
279
],
[
281
],
[
283,
285
],
[
287
],
[
289
],
[
291
]
] |
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(VAR_3, VAR_1, VAR_2);",
"if (rtp_asf_fix_header(VAR_3, VAR_2) < 0)\nav_log(VAR_0, AV_LOG_ERROR,\n\"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;",
"}",
"}"
] | [
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 = -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\ntime_t now = time(0);",
"struct tm ltime;",
"uint8_t *buf = dtext->expanded_text;",
"int buf_size = dtext->expanded_text_size;",
"if (!buf)\nbuf_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)\nbreak;",
"buf_size *= 2;",
"}",
"if (!buf)\nreturn AVERROR(ENOMEM);",
"VAR_7 = dtext->expanded_text = buf;",
"dtext->expanded_text_size = buf_size;",
"#endif\nif ((VAR_9 = strlen(VAR_7)) > dtext->nb_positions) {",
"FT_Vector *p = av_realloc(dtext->positions,\nVAR_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)\nVAR_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')\ncontinue;",
"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,\nft_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;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
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
],
[
33,
35
],
[
37
],
[
39
],
[
41
],
[
45,
47
],
[
51
],
[
55
],
[
57
],
[
59,
61
],
[
63
],
[
65
],
[
69,
71
],
[
73
],
[
75
],
[
77,
81
],
[
83,
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
109
],
[
111
],
[
117
],
[
119
],
[
121,
123
],
[
125
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
143
],
[
145
],
[
147
],
[
153,
155
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
177
],
[
179
],
[
181
],
[
187
],
[
189,
191
],
[
193
],
[
195
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
225
],
[
227
],
[
231
],
[
233
],
[
237
],
[
239
]
] |
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_format(&formats, buf->pixel_fmts[VAR_1])) < 0)\nreturn VAR_2;",
"ff_set_common_formats(VAR_0, formats);",
"} else {",
"ff_default_query_formats(VAR_0);",
"}",
"return 0;",
"}"
] | [
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->filter)\ncontinue;",
"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 &&\n!(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))\nret = av_buffersink_read_samples(ost->filter->filter, &picref,\nost->st->codec->VAR_1);",
"else\nret = av_buffersink_read(ost->filter->filter, &picref);",
"if (ret < 0)\nbreak;",
"avfilter_copy_buf_props(filtered_frame, picref);",
"if (picref->pts != AV_NOPTS_VALUE)\nfiltered_frame->pts = av_rescale_q(picref->pts,\nost->filter->filter->inputs[0]->time_base,\nost->st->codec->time_base) -\nav_rescale_q(of->start_time,\nAV_TIME_BASE_Q,\nost->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:\nif (!ost->frame_aspect_ratio)\nost->st->codec->sample_aspect_ratio = picref->video->pixel_aspect;",
"do_video_out(of->ctx, ost, filtered_frame, &VAR_1,\nsame_quant ? ost->last_quality :\nost->st->codec->global_quality);",
"if (vstats_filename && VAR_1)\ndo_video_stats(of->ctx, ost, VAR_1);",
"break;",
"case AVMEDIA_TYPE_AUDIO:\ndo_audio_out(of->ctx, ost, filtered_frame);",
"break;",
"default:\nav_assert0(0);",
"}",
"avfilter_unref_buffer(picref);",
"}",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
57,
59
],
[
63
],
[
65,
67,
69,
71,
73,
75,
77
],
[
81
],
[
83
],
[
85
],
[
87
],
[
91
],
[
93,
95,
97
],
[
101,
103,
105
],
[
107,
109
],
[
111
],
[
113,
115
],
[
117
],
[
119,
123
],
[
125
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
]
] |
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 (!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))\n(*VAR_1)->type = AVIO_ENTRY_DIRECTORY;",
"else if (S_ISFIFO(st.st_mode))\n(*VAR_1)->type = AVIO_ENTRY_NAMED_PIPE;",
"else if (S_ISCHR(st.st_mode))\n(*VAR_1)->type = AVIO_ENTRY_CHARACTER_DEVICE;",
"else if (S_ISBLK(st.st_mode))\n(*VAR_1)->type = AVIO_ENTRY_BLOCK_DEVICE;",
"else if (S_ISLNK(st.st_mode))\n(*VAR_1)->type = AVIO_ENTRY_SYMBOLIC_LINK;",
"else if (S_ISSOCK(st.st_mode))\n(*VAR_1)->type = AVIO_ENTRY_SOCKET;",
"else if (S_ISREG(st.st_mode))\n(*VAR_1)->type = AVIO_ENTRY_FILE;",
"else\n(*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\nreturn AVERROR(ENOSYS);",
"#endif\n}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
49
],
[
51,
53
],
[
55,
57
],
[
59,
61
],
[
63,
65
],
[
67,
69
],
[
71,
73
],
[
75,
77
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103
],
[
105
],
[
107,
109
],
[
111,
113
]
] |
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;",
"case CHR_EVENT_CLOSED:\njson_message_parser_destroy(&mon->qmp.parser);",
"json_message_parser_init(&mon->qmp.parser, handle_qmp_command);",
"mon_refcount--;",
"monitor_fdsets_cleanup();",
"break;",
"}",
"}"
] | [
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_B_SET)) {",
"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_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)\n+ NANOSECONDS_PER_SECOND - guest_nsec;",
"VAR_1 = get_next_alarm(VAR_0);",
"VAR_0->next_alarm_time = next_update_time +\n(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);",
"}",
"}"
] | [
0,
0,
0,
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
],
[
69
],
[
71,
73
],
[
77
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
]
] |
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_nested);",
"validate_test_add(\"/visitor/input-strict/pass/list\",\n&testdata, test_validate_list);",
"validate_test_add(\"/visitor/input-strict/pass/union\",\n&testdata, test_validate_union);",
"validate_test_add(\"/visitor/input-strict/pass/union-flat\",\n&testdata, test_validate_union_flat);",
"validate_test_add(\"/visitor/input-strict/pass/union-anon\",\n&testdata, test_validate_union_anon);",
"validate_test_add(\"/visitor/input-strict/fail/struct\",\n&testdata, test_validate_fail_struct);",
"validate_test_add(\"/visitor/input-strict/fail/struct-nested\",\n&testdata, test_validate_fail_struct_nested);",
"validate_test_add(\"/visitor/input-strict/fail/list\",\n&testdata, test_validate_fail_list);",
"validate_test_add(\"/visitor/input-strict/fail/union\",\n&testdata, test_validate_fail_union);",
"validate_test_add(\"/visitor/input-strict/fail/union-flat\",\n&testdata, test_validate_fail_union_flat);",
"validate_test_add(\"/visitor/input-strict/fail/union-flat-no-discriminator\",\n&testdata, test_validate_fail_union_flat_no_discrim);",
"validate_test_add(\"/visitor/input-strict/fail/union-anon\",\n&testdata, test_validate_fail_union_anon);",
"g_test_run();",
"return 0;",
"}"
] | [
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
],
[
57,
59
],
[
61,
63
],
[
67
],
[
71
],
[
73
]
] |
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;",
"do_slowtimo = 0;",
"QTAILQ_FOREACH(slirp, &slirp_instances, entry) {",
"do_slowtimo |= ((slirp->tcb.VAR_5 != &slirp->tcb) ||\n(&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) &&\n(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;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
79
],
[
91
],
[
93
],
[
95
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
143
],
[
145
],
[
147
],
[
149
],
[
161,
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
183
],
[
185
],
[
187
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
235
],
[
237
],
[
239
],
[
241
],
[
243
],
[
253
],
[
255
],
[
257
],
[
267
],
[
269
],
[
271
],
[
273
],
[
275
],
[
277
],
[
279
],
[
281
],
[
285
],
[
287
],
[
289
],
[
291
],
[
293
],
[
295
],
[
299
],
[
301
]
] |
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 ? 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) ||\nwrite(s->fd, VAR_1, VAR_4) != VAR_4) {",
"qemu_log(\"-net dump write error - stop dump\\n\");",
"close(s->fd);",
"s->fd = -1;",
"}",
"}"
] | [
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
],
[
51
]
] |
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] = {",
"{ 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:\nif (conf.verbose) {",
"dolog (\"Failed to read %ld frames (read zero)\\n\", len);",
"}",
"goto exit;",
"case -EPIPE:\nif (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:\ngoto exit;",
"default:\nalsa_logerr (\nnread,\n\"Failed to read %ld frames from %p\\n\",\nlen,\nVAR_7\n);",
"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:\nVAR_0->wpos = (VAR_0->wpos + read_samples) % VAR_0->samples;",
"return read_samples;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
47
],
[
49
],
[
51
],
[
53
],
[
57
],
[
59
],
[
61
],
[
65
],
[
67
],
[
69
],
[
71
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103
],
[
107
],
[
109
],
[
113
],
[
115
],
[
119
],
[
121
],
[
123,
125
],
[
127
],
[
129
],
[
131
],
[
135,
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
155,
157
],
[
161,
163,
165,
167,
169,
171,
173
],
[
175
],
[
177
],
[
179
],
[
183
],
[
187
],
[
189
],
[
193
],
[
195
],
[
197
],
[
199
],
[
203,
205
],
[
207
],
[
209
]
] |
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(bs, VAR_1[2], 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
]
] |
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_CPU_FLAG_MMX2;",
"int64_t max_src_size = (INT64_MAX/2 / VAR_0->phase_count) / VAR_0->src_incr;",
"if (VAR_0->compensation_distance)\nVAR_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],\nVAR_5, VAR_4, VAR_2, VAR_6+1==VAR_1->ch_count);",
"}",
"if(VAR_9)\nemms_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;",
"}"
] | [
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
],
[
51
],
[
55
],
[
57
]
] |
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_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;",
"}"
] | [
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();",
"qio_channel_set_name(QIO_CHANNEL(nbd_server->listen_ioc),\n\"nbd-listener\");",
"if (qio_channel_socket_listen_sync(\nnbd_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(\nQIO_CHANNEL(nbd_server->listen_ioc),\nG_IO_IN,\nnbd_accept,\nNULL,\nNULL);",
"return;",
"error:\nnbd_server_free(nbd_server);",
"nbd_server = NULL;",
"}"
] | [
0,
0,
0,
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
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65,
67,
69,
71,
73,
75
],
[
79
],
[
83,
85
],
[
87
],
[
89
]
] |
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);",
"if (VAR_5 < 0) {",
"VAR_5 = -errno;",
"}",
"});",
"return VAR_5;",
"}"
] | [
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 features;",
"}"
] | [
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) {",
"error_setg(VAR_3, QERR_INVALID_PARAMETER_VALUE,\nVAR_2 ? VAR_2 : \"null\", \"uint16_t\");",
"return;",
"}",
"*VAR_1 = value;",
"}",
"}"
] | [
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, codec);",
"if (VAR_4 < 0)\nreturn VAR_4;",
"}",
"if(!has_codec_parameters(VAR_0->codec)){",
"switch(VAR_0->codec->codec_type) {",
"case CODEC_TYPE_VIDEO:\nVAR_4 = avcodec_decode_video2(VAR_0->codec, &picture,\n&VAR_2, VAR_1);",
"break;",
"case CODEC_TYPE_AUDIO:\nVAR_3 = FFMAX(VAR_1->size, AVCODEC_MAX_AUDIO_FRAME_SIZE);",
"samples = av_malloc(VAR_3);",
"if (!samples)\ngoto fail;",
"VAR_4 = avcodec_decode_audio3(VAR_0->codec, samples,\n&VAR_3, VAR_1);",
"av_free(samples);",
"break;",
"default:\nbreak;",
"}",
"}",
"fail:\nreturn 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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19,
21
],
[
23
],
[
25,
27
],
[
29
],
[
33
],
[
35
],
[
37,
40,
42
],
[
44
],
[
46,
48
],
[
50
],
[
52,
54
],
[
56,
58
],
[
60
],
[
62
],
[
64,
66
],
[
68
],
[
70
],
[
72,
74
],
[
76
]
] |
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->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)\nret = ff_thread_decode_frame(avctx, picture, got_picture_ptr,\navpkt);",
"else {",
"ret = avctx->codec->decode(avctx, picture, got_picture_ptr,\navpkt);",
"picture->pkt_dts= avpkt->dts;",
"if(!avctx->has_b_frames){",
"picture->pkt_pos= avpkt->pos;",
"}",
"if (!picture->sample_aspect_ratio.num)\npicture->sample_aspect_ratio = avctx->sample_aspect_ratio;",
"if (!picture->width)\npicture->width = avctx->width;",
"if (!picture->height)\npicture->height = avctx->height;",
"if (picture->format == PIX_FMT_NONE)\npicture->format = avctx->pix_fmt;",
"}",
"emms_c();",
"if (*got_picture_ptr){",
"avctx->frame_number++;",
"picture->best_effort_timestamp = guess_correct_pts(avctx,\npicture->pkt_pts,\npicture->pkt_dts);",
"}",
"}else",
"ret= 0;",
"return ret;",
"}"
] | [
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
],
[
57,
59
],
[
61,
63
],
[
65,
67
],
[
69
],
[
73
],
[
79
],
[
81
],
[
83,
85,
87
],
[
89
],
[
91
],
[
93
],
[
97
],
[
99
]
] |
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;",
"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)\nVAR_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);",
"}"
] | [
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
],
[
53
],
[
55
],
[
57
],
[
61
],
[
65
],
[
67
]
] |
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;",
"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);",
"}"
] | [
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
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75
]
] |
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(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));",
"}"
] | [
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->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;",
"}",
"}",
"}"
] | [
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
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
]
] |
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);",
"result |= tmp << 48;",
"return result;",
"}"
] | [
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_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;",
"}"
] | [
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;",
"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 :\nff_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)\nvorbis_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)\ncontinue;",
"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,\nop2->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),\ns->buffer_index);",
"}",
"return VAR_5;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
51
],
[
53
],
[
55
],
[
61
],
[
63
],
[
65
],
[
71
],
[
77,
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
105
],
[
107
],
[
109
],
[
111
],
[
115
],
[
119,
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
133
],
[
135
],
[
137,
139
],
[
141
],
[
145
],
[
147
]
] |
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];",
"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);",
"}",
"}"
] | [
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->type,\n&glock->start, &glock->length, &glock->proc_id,\n&glock->client_id);",
"trace_v9fs_getlock(pdu->tag, pdu->id, fid,\nglock->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,\nglock->start, glock->length, glock->proc_id,\n&glock->client_id);",
"err = offset;",
"out:\nput_fid(pdu, fidp);",
"out_nofid:\ncomplete_pdu(s, pdu, err);",
"v9fs_string_free(&glock->client_id);",
"g_free(glock);",
"}"
] | [
0,
0,
0,
0,
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
],
[
23
],
[
24
],
[
25
],
[
26,
27,
28
],
[
29
],
[
30,
31
],
[
32,
33
],
[
34
],
[
35
],
[
36
]
] |
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];",
"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)\ngoto done;",
"bitstream_read(&bc, 2);",
"VAR_4 = bitstream_read(&bc, 1);",
"VAR_4 |= bitstream_read(&bc, 1) << 1;",
"if (VAR_4 == 3)\nVAR_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,\n\"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,\n\"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)\ngoto done;",
"VAR_2 = av_packet_copy_props(VAR_1, s->cache[s->n_cache - 1]);",
"if (VAR_2 < 0)\ngoto done;",
"for (VAR_7 = 0; VAR_7 < s->n_cache; VAR_7++)",
"av_packet_free(&s->cache[VAR_7]);",
"s->n_cache = 0;",
"done:\nif (VAR_2 < 0)\nav_packet_unref(VAR_1);",
"av_packet_free(&in);",
"return VAR_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,
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,
55
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75,
77
],
[
79
],
[
81
],
[
83
],
[
87
],
[
89
],
[
91
],
[
93,
95
],
[
97
],
[
99
],
[
101
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
123,
125
],
[
129
],
[
131,
133
],
[
137
],
[
139
],
[
141
],
[
145,
147,
149
],
[
151
],
[
153
],
[
155
]
] |
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 = event_notifier_init(notifier, 1);",
"if (VAR_4 < 0) {",
"error_report(\"%s: unable to init event notifier: %d\",\n__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,\ntrue, VAR_1, notifier);",
"} else {",
"memory_region_del_eventfd(&VAR_0->bar, VIRTIO_PCI_QUEUE_NOTIFY, 2,\ntrue, VAR_1, notifier);",
"virtio_queue_set_host_notifier_fd_handler(vq, false, false);",
"event_notifier_cleanup(notifier);",
"}",
"return VAR_4;",
"}"
] | [
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
],
[
49
],
[
51
]
] |
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] + 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(\n\"mov %4, %%\"REG_a\" \\n\\t\"\n\"movq \"MANGLE(mmx_ff)\", %%mm0 \\n\\t\"\n\"movq (%0, %%\"REG_a\"), %%mm4 \\n\\t\"\n\"movq %%mm4, %%mm2 \\n\\t\"\n\"psllq $8, %%mm4 \\n\\t\"\n\"pand %%mm0, %%mm2 \\n\\t\"\n\"por %%mm2, %%mm4 \\n\\t\"\n\"movq (%1, %%\"REG_a\"), %%mm5 \\n\\t\"\n\"movq %%mm5, %%mm3 \\n\\t\"\n\"psllq $8, %%mm5 \\n\\t\"\n\"pand %%mm0, %%mm3 \\n\\t\"\n\"por %%mm3, %%mm5 \\n\\t\"\n\"1: \\n\\t\"\n\"movq (%0, %%\"REG_a\"), %%mm0 \\n\\t\"\n\"movq (%1, %%\"REG_a\"), %%mm1 \\n\\t\"\n\"movq 1(%0, %%\"REG_a\"), %%mm2 \\n\\t\"\n\"movq 1(%1, %%\"REG_a\"), %%mm3 \\n\\t\"\nPAVGB\" %%mm0, %%mm5 \\n\\t\"\nPAVGB\" %%mm0, %%mm3 \\n\\t\"\nPAVGB\" %%mm0, %%mm5 \\n\\t\"\nPAVGB\" %%mm0, %%mm3 \\n\\t\"\nPAVGB\" %%mm1, %%mm4 \\n\\t\"\nPAVGB\" %%mm1, %%mm2 \\n\\t\"\nPAVGB\" %%mm1, %%mm4 \\n\\t\"\nPAVGB\" %%mm1, %%mm2 \\n\\t\"\n\"movq %%mm5, %%mm7 \\n\\t\"\n\"movq %%mm4, %%mm6 \\n\\t\"\n\"punpcklbw %%mm3, %%mm5 \\n\\t\"\n\"punpckhbw %%mm3, %%mm7 \\n\\t\"\n\"punpcklbw %%mm2, %%mm4 \\n\\t\"\n\"punpckhbw %%mm2, %%mm6 \\n\\t\"\nMOVNTQ\" %%mm5, (%2, %%\"REG_a\", 2) \\n\\t\"\nMOVNTQ\" %%mm7, 8(%2, %%\"REG_a\", 2) \\n\\t\"\nMOVNTQ\" %%mm4, (%3, %%\"REG_a\", 2) \\n\\t\"\nMOVNTQ\" %%mm6, 8(%3, %%\"REG_a\", 2) \\n\\t\"\n\"add $8, %%\"REG_a\" \\n\\t\"\n\"movq -1(%0, %%\"REG_a\"), %%mm4 \\n\\t\"\n\"movq -1(%1, %%\"REG_a\"), %%mm5 \\n\\t\"\n\" js 1b \\n\\t\"\n:: \"r\" (src + mmxSize ), \"r\" (src + srcStride + mmxSize ),\n\"r\" (dst + mmxSize*2), \"r\" (dst + dstStride + mmxSize*2),\n\"g\" (-mmxSize)\nNAMED_CONSTRAINTS_ADD(mmx_ff)\n: \"%\"REG_a\n);",
"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\"\nSFENCE\" \\n\\t\"\n:::\"memory\");",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
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,
69,
71,
73,
75,
77,
79,
81,
83,
85,
87,
89,
91,
93,
95,
97,
99,
101,
103,
105,
107,
109,
111,
113,
115,
117,
119,
121,
123,
125
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
147
],
[
149
],
[
151
],
[
157
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
173,
175,
177
],
[
179
]
] |
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 != SEEK_SET)\nreturn AVERROR(EINVAL);",
"if (whence == SEEK_CUR) {",
"offset1 = pos + (s->buf_ptr - s->buffer);",
"if (offset == 0)\nreturn offset1;",
"offset += offset1;",
"}",
"offset1 = offset - pos;",
"if (!s->must_flush &&\noffset1 >= 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) &&\n!s->write_flag && offset1 >= 0 &&\n(whence != SEEK_END || VAR_0)) {",
"while(s->pos < offset && !s->eof_reached)\nfill_buffer(s);",
"if (s->eof_reached)\nreturn 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)\nreturn AVERROR(EPIPE);",
"if ((res = s->seek(s->opaque, offset, SEEK_SET)) < 0)\nreturn res;",
"if (!s->write_flag)\ns->buf_end = s->buffer;",
"s->buf_ptr = s->buffer;",
"s->pos = offset;",
"}",
"s->eof_reached = 0;",
"return offset;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
57,
59
],
[
61,
63
],
[
65,
67
],
[
69
],
[
71
],
[
73
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85,
87
],
[
89,
91
],
[
93,
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
]
] |
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;",
"}",
"if (strcmp(VAR_5, VAR_3) == 0 &&\nstrncmp(VAR_4, VAR_6, strlen(VAR_6)) != 0) {",
"error_report(\"vhost-user requires frontend VAR_4 virtio-net-*\");",
"return -1;",
"}",
"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->sub_descriptors_count * sizeof(UID));",
"if (!VAR_0->sub_descriptors_refs)\nreturn -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:\nget_buffer(VAR_1, VAR_0->essence_container_ul, 16);",
"break;",
"case 0x3006:\nVAR_0->linked_track_id = get_be32(VAR_1);",
"break;",
"case 0x3201:\nget_buffer(VAR_1, VAR_0->essence_codec_ul, 16);",
"break;",
"case 0x3203:\nVAR_0->width = get_be32(VAR_1);",
"break;",
"case 0x3202:\nVAR_0->height = get_be32(VAR_1);",
"break;",
"case 0x320E:\nVAR_0->aspect_ratio.num = get_be32(VAR_1);",
"VAR_0->aspect_ratio.den = get_be32(VAR_1);",
"break;",
"case 0x3D03:\nVAR_0->sample_rate.num = get_be32(VAR_1);",
"VAR_0->sample_rate.den = get_be32(VAR_1);",
"break;",
"case 0x3D06:\nget_buffer(VAR_1, VAR_0->essence_codec_ul, 16);",
"break;",
"case 0x3D07:\nVAR_0->channels = get_be32(VAR_1);",
"break;",
"case 0x3D01:\nVAR_0->bits_per_sample = get_be32(VAR_1);",
"break;",
"case 0x3401:\nmxf_read_pixel_layout(VAR_1, VAR_0);",
"break;",
"default:\nif (IS_KLV_KEY(VAR_4, mxf_sony_mpeg4_extradata)) {",
"VAR_0->extradata = av_malloc(VAR_3);",
"if (!VAR_0->extradata)\nreturn -1;",
"VAR_0->extradata_size = VAR_3;",
"get_buffer(VAR_1, VAR_0->extradata, VAR_3);",
"}",
"break;",
"}",
"return 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
],
[
49
],
[
51,
53
],
[
55
],
[
57,
59
],
[
61
],
[
63
],
[
65,
67
],
[
69
],
[
71
],
[
73,
75
],
[
77
],
[
79,
81
],
[
83
],
[
85,
87
],
[
89
],
[
91,
93
],
[
95
],
[
97,
101
],
[
103
],
[
105,
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
]
] |
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 = reg_conflict(dev);",
"if (other) {",
"error_setg(VAR_1, \"%s and %s devices conflict at address %#x\",\nobject_get_typename(OBJECT(VAR_0)),\nobject_get_typename(OBJECT(&other->VAR_0)),\ndev->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\",\nram_size);",
"memory_region_init_alias(&dev->mrbypass, OBJECT(dev),\n\"iommu-spapr-bypass\", get_system_memory(),\n0, 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,\n0,\nSPAPR_TCE_PAGE_SHIFT,\npc->rtce_window_size >>\nSPAPR_TCE_PAGE_SHIFT, false);",
"dev->tcet->vdev = dev;",
"memory_region_add_subregion_overlap(&dev->mrroot, 0,\nspapr_tce_get_iommu(dev->tcet), 2);",
"}",
"pc->realize(dev, VAR_1);",
"}"
] | [
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
],
[
69
],
[
71
],
[
73
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
89
],
[
91
],
[
95,
97
],
[
99,
101,
103
],
[
105
],
[
107
],
[
111,
113,
115,
117,
119
],
[
121
],
[
123,
125
],
[
127
],
[
131
],
[
133
]
] |
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, VAR_5*8);",
"s->total_frames--;",
"if (!s->total_frames && s->last_frame_length)\nVAR_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)\ns->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)\nreturn -1;",
"if (k) {",
"if (k > MIN_CACHE_BITS)\nreturn -1;",
"value = (unary << k) + get_bits(&s->gb, k);",
"} else",
"value = unary;",
"switch (depth) {",
"case 1:\nrice->sum1 += value - (rice->sum1 >> 4);",
"if (rice->k1 > 0 && rice->sum1 < shift_16[rice->k1])\nrice->k1--;",
"else if(rice->sum1 > shift_16[rice->k1 + 1])\nrice->k1++;",
"value += shift_1[rice->k0];",
"default:\nrice->sum0 += value - (rice->sum0 >> 4);",
"if (rice->k0 > 0 && rice->sum0 < shift_16[rice->k0])\nrice->k0--;",
"else if(rice->sum0 > shift_16[rice->k0 + 1])\nrice->k0++;",
"}",
"#define UNFOLD(x) (((x)&1) ? (++(x)>>1) : (-(x)>>1))\n*p = UNFOLD(value);",
"ttafilter_process(filter, p, 0);",
"#define PRED(x, k) (int32_t)((((uint64_t)x << k) - x) >> k)\nswitch (s->bps) {",
"case 1: *p += PRED(*predictor, 4); break;",
"case 2:\ncase 3: *p += PRED(*predictor, 5); break;",
"case 4: *p += *predictor; break;",
"}",
"*predictor = *p;",
"if (VAR_8 < (s->channels-1))\nVAR_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)\nreturn -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;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
0,
0,
0,
0,
0,
1,
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
],
[
63
],
[
65
],
[
67
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
85
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
107,
109
],
[
113
],
[
115,
117
],
[
119
],
[
121
],
[
123
],
[
129
],
[
131,
133
],
[
135,
137
],
[
139,
141
],
[
143
],
[
145,
147
],
[
149,
151
],
[
153,
155
],
[
157
],
[
163,
165
],
[
171
],
[
177,
179
],
[
181
],
[
183,
185
],
[
187
],
[
189
],
[
191
],
[
197,
199
],
[
201
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
223,
225
],
[
227
],
[
233
],
[
235
],
[
237
],
[
239
],
[
241
],
[
245
],
[
247
],
[
249
],
[
253
],
[
255
],
[
259
],
[
261
],
[
265
],
[
267
]
] |
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;",
"s->VAR_21 = -1;",
"next_byte:\nVAR_0 = ldub_code(s->pc);",
"s->pc++;",
"switch (VAR_0) {",
"case 0xf3:\nVAR_1 |= PREFIX_REPZ;",
"goto next_byte;",
"case 0xf2:\nVAR_1 |= PREFIX_REPNZ;",
"goto next_byte;",
"case 0xf0:\nVAR_1 |= PREFIX_LOCK;",
"goto next_byte;",
"case 0x2e:\ns->VAR_21 = R_CS;",
"goto next_byte;",
"case 0x36:\ns->VAR_21 = R_SS;",
"goto next_byte;",
"case 0x3e:\ns->VAR_21 = R_DS;",
"goto next_byte;",
"case 0x26:\ns->VAR_21 = R_ES;",
"goto next_byte;",
"case 0x64:\ns->VAR_21 = R_FS;",
"goto next_byte;",
"case 0x65:\ns->VAR_21 = R_GS;",
"goto next_byte;",
"case 0x66:\nVAR_1 |= PREFIX_DATA;",
"goto next_byte;",
"case 0x67:\nVAR_1 |= PREFIX_ADR;",
"goto next_byte;",
"}",
"if (VAR_1 & PREFIX_DATA)\nVAR_3 ^= 1;",
"if (VAR_1 & PREFIX_ADR)\nVAR_2 ^= 1;",
"s->prefix = VAR_1;",
"s->VAR_2 = VAR_2;",
"s->VAR_3 = VAR_3;",
"if (VAR_1 & PREFIX_LOCK)\ngen_op_lock();",
"reswitch:\nswitch(VAR_0) {",
"case 0x0f:\nVAR_0 = ldub_code(s->pc++) | 0x100;",
"goto reswitch;",
"case 0x00 ... 0x05:\ncase 0x08 ... 0x0d:\ncase 0x10 ... 0x15:\ncase 0x18 ... 0x1d:\ncase 0x20 ... 0x25:\ncase 0x28 ... 0x2d:\ncase 0x30 ... 0x35:\ncase 0x38 ... 0x3d:\n{",
"int VAR_16, VAR_16, VAR_17;",
"VAR_16 = (VAR_0 >> 3) & 7;",
"VAR_16 = (VAR_0 >> 1) & 3;",
"if ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_5 = VAR_3 ? OT_LONG : OT_WORD;",
"switch(VAR_16) {",
"case 0:\nVAR_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:\ngen_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:\nVAR_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:\nVAR_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:\ncase 0x81:\ncase 0x82:\ncase 0x83:\n{",
"int VAR_17;",
"if ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\ncase 0x80:\ncase 0x81:\ncase 0x82:\nVAR_17 = insn_get(s, VAR_5);",
"break;",
"case 0x83:\nVAR_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:\nVAR_5 = VAR_3 ? OT_LONG : OT_WORD;",
"gen_inc(s, VAR_5, OR_EAX + (VAR_0 & 7), 1);",
"break;",
"case 0x48 ... 0x4f:\nVAR_5 = VAR_3 ? OT_LONG : OT_WORD;",
"gen_inc(s, VAR_5, OR_EAX + (VAR_0 & 7), -1);",
"break;",
"case 0xf6:\ncase 0xf7:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\nVAR_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:\ngen_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:\ngen_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:\nswitch(VAR_5) {",
"case OT_BYTE:\ngen_op_mulb_AL_T0();",
"s->cc_op = CC_OP_MULB;",
"break;",
"case OT_WORD:\ngen_op_mulw_AX_T0();",
"s->cc_op = CC_OP_MULW;",
"break;",
"default:\ncase OT_LONG:\ngen_op_mull_EAX_T0();",
"s->cc_op = CC_OP_MULL;",
"break;",
"}",
"break;",
"case 5:\nswitch(VAR_5) {",
"case OT_BYTE:\ngen_op_imulb_AL_T0();",
"s->cc_op = CC_OP_MULB;",
"break;",
"case OT_WORD:\ngen_op_imulw_AX_T0();",
"s->cc_op = CC_OP_MULW;",
"break;",
"default:\ncase OT_LONG:\ngen_op_imull_EAX_T0();",
"s->cc_op = CC_OP_MULL;",
"break;",
"}",
"break;",
"case 6:\nswitch(VAR_5) {",
"case OT_BYTE:\ngen_op_divb_AL_T0(pc_start - s->cs_base);",
"break;",
"case OT_WORD:\ngen_op_divw_AX_T0(pc_start - s->cs_base);",
"break;",
"default:\ncase OT_LONG:\ngen_op_divl_EAX_T0(pc_start - s->cs_base);",
"break;",
"}",
"break;",
"case 7:\nswitch(VAR_5) {",
"case OT_BYTE:\ngen_op_idivb_AL_T0(pc_start - s->cs_base);",
"break;",
"case OT_WORD:\ngen_op_idivw_AX_T0(pc_start - s->cs_base);",
"break;",
"default:\ncase OT_LONG:\ngen_op_idivl_EAX_T0(pc_start - s->cs_base);",
"break;",
"}",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0xfe:\ncase 0xff:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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)\ngen_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:\nif (VAR_9 != 3)\nVAR_12 = OR_TMP0;",
"else\nVAR_12 = VAR_8;",
"gen_inc(s, VAR_5, VAR_12, 1);",
"break;",
"case 1:\nif (VAR_9 != 3)\nVAR_12 = OR_TMP0;",
"else\nVAR_12 = VAR_8;",
"gen_inc(s, VAR_5, VAR_12, -1);",
"break;",
"case 2:\nif (s->VAR_3 == 0)\ngen_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:\ngen_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:\nif (s->pe && !s->vm86) {",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_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:\nif (s->VAR_3 == 0)\ngen_op_andl_T0_ffff();",
"gen_op_jmp_T0();",
"gen_eob(s);",
"break;",
"case 5:\ngen_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:\nif (s->pe && !s->vm86) {",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_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:\ngen_push_T0(s);",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x84:\ncase 0x85:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\ncase 0xa9:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\nif (VAR_3)\ngen_op_movswl_EAX_AX();",
"else\ngen_op_movsbw_AX_AL();",
"break;",
"case 0x99:\nif (VAR_3)\ngen_op_movslq_EDX_EAX();",
"else\ngen_op_movswl_DX_AX();",
"break;",
"case 0x1af:\ncase 0x69:\ncase 0x6b:\nVAR_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:\ncase 0x1c1:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\ncase 0x1b1:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\nVAR_6 = ldub_code(s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"if (VAR_9 == 3)\ngoto illegal_op;",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_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:\ngen_op_mov_TN_reg[OT_LONG][0][VAR_0 & 7]();",
"gen_push_T0(s);",
"break;",
"case 0x58 ... 0x5f:\nVAR_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:\ngen_pusha(s);",
"break;",
"case 0x61:\ngen_popa(s);",
"break;",
"case 0x68:\ncase 0x6a:\nVAR_5 = VAR_3 ? OT_LONG : OT_WORD;",
"if (VAR_0 == 0x68)\nVAR_17 = insn_get(s, VAR_5);",
"else\nVAR_17 = (int8_t)insn_get(s, OT_BYTE);",
"gen_op_movl_T0_im(VAR_17);",
"gen_push_T0(s);",
"break;",
"case 0x8f:\nVAR_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:\n{",
"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:\nif (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:\ncase 0x0e:\ncase 0x16:\ncase 0x1e:\ngen_op_movl_T0_seg(VAR_0 >> 3);",
"gen_push_T0(s);",
"break;",
"case 0x1a0:\ncase 0x1a8:\ngen_op_movl_T0_seg((VAR_0 >> 3) & 7);",
"gen_push_T0(s);",
"break;",
"case 0x07:\ncase 0x17:\ncase 0x1f:\nVAR_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))\ngen_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:\ncase 0x1a9:\ngen_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:\ncase 0x89:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\ncase 0xc7:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_5 = VAR_3 ? OT_LONG : OT_WORD;",
"VAR_6 = ldub_code(s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"if (VAR_9 != 3)\ngen_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)\ngen_op_st_T0_A0[VAR_5 + s->mem_index]();",
"else\ngen_op_mov_reg_T0[VAR_5][VAR_6 & 7]();",
"break;",
"case 0x8a:\ncase 0x8b:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\nVAR_6 = ldub_code(s->pc++);",
"VAR_7 = (VAR_6 >> 3) & 7;",
"if (VAR_7 >= 6 || VAR_7 == R_CS)\ngoto 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))\ngen_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:\nVAR_6 = ldub_code(s->pc++);",
"VAR_7 = (VAR_6 >> 3) & 7;",
"VAR_9 = (VAR_6 >> 6) & 3;",
"if (VAR_7 >= 6)\ngoto illegal_op;",
"gen_op_movl_T0_seg(VAR_7);",
"VAR_5 = OT_WORD;",
"if (VAR_9 == 3 && VAR_3)\nVAR_5 = OT_LONG;",
"gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 1);",
"break;",
"case 0x1b6:\ncase 0x1b7:\ncase 0x1be:\ncase 0x1bf:\n{",
"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:\ngen_op_movzbl_T0_T0();",
"break;",
"case OT_BYTE | 8:\ngen_op_movsbl_T0_T0();",
"break;",
"case OT_WORD:\ngen_op_movzwl_T0_T0();",
"break;",
"default:\ncase OT_WORD | 8:\ngen_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:\nVAR_5 = VAR_3 ? OT_LONG : OT_WORD;",
"VAR_6 = ldub_code(s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"if (VAR_9 == 3)\ngoto 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:\ncase 0xa1:\ncase 0xa2:\ncase 0xa3:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_5 = VAR_3 ? OT_LONG : OT_WORD;",
"if (s->VAR_2)\nVAR_13 = insn_get(s, OT_LONG);",
"else\nVAR_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:\ngen_op_movl_A0_reg[R_EBX]();",
"gen_op_addl_A0_AL();",
"if (s->VAR_2 == 0)\ngen_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:\nVAR_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:\nVAR_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:\nVAR_5 = VAR_3 ? OT_LONG : OT_WORD;",
"VAR_7 = VAR_0 & 7;",
"VAR_8 = R_EAX;",
"goto do_xchg_reg;",
"case 0x86:\ncase 0x87:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\ngen_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))\ngen_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))\ngen_op_unlock();",
"gen_op_mov_reg_T1[VAR_5][VAR_7]();",
"}",
"break;",
"case 0xc4:\nVAR_16 = R_ES;",
"goto do_lxx;",
"case 0xc5:\nVAR_16 = R_DS;",
"goto do_lxx;",
"case 0x1b2:\nVAR_16 = R_SS;",
"goto do_lxx;",
"case 0x1b4:\nVAR_16 = R_FS;",
"goto do_lxx;",
"case 0x1b5:\nVAR_16 = R_GS;",
"do_lxx:\nVAR_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)\ngoto 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:\ncase 0xc1:\nVAR_4 = 2;",
"grp2:\n{",
"if ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\ncase 0xd1:\nVAR_4 = 1;",
"goto grp2;",
"case 0xd2:\ncase 0xd3:\nVAR_4 = 0;",
"goto grp2;",
"case 0x1a4:\nVAR_16 = 0;",
"VAR_4 = 1;",
"goto do_shiftd;",
"case 0x1a5:\nVAR_16 = 0;",
"VAR_4 = 0;",
"goto do_shiftd;",
"case 0x1ac:\nVAR_16 = 1;",
"VAR_4 = 1;",
"goto do_shiftd;",
"case 0x1ad:\nVAR_16 = 1;",
"VAR_4 = 0;",
"do_shiftd:\nVAR_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)\ngen_op_shiftd_T0_T1_im_cc[VAR_5][VAR_16](VAR_17);",
"else\ngen_op_shiftd_mem_T0_T1_im_cc[VAR_5 + s->mem_index][VAR_16](VAR_17);",
"if (VAR_16 == 0 && VAR_5 != OT_WORD)\ns->cc_op = CC_OP_SHLB + VAR_5;",
"else\ns->cc_op = CC_OP_SARB + VAR_5;",
"}",
"} else {",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"if (VAR_9 == 3)\ngen_op_shiftd_T0_T1_ECX_cc[VAR_5][VAR_16]();",
"else\ngen_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:\nif (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:\ncase 0x10 ... 0x17:\ncase 0x20 ... 0x27:\ncase 0x30 ... 0x37:\n{",
"int VAR_22;",
"VAR_22 = VAR_16 & 7;",
"switch(VAR_16 >> 4) {",
"case 0:\ngen_op_flds_FT0_A0();",
"break;",
"case 1:\ngen_op_fildl_FT0_A0();",
"break;",
"case 2:\ngen_op_fldl_FT0_A0();",
"break;",
"case 3:\ndefault:\ngen_op_fild_FT0_A0();",
"break;",
"}",
"gen_op_fp_arith_ST0_FT0[VAR_22]();",
"if (VAR_22 == 3) {",
"gen_op_fpop();",
"}",
"}",
"break;",
"case 0x08:\ncase 0x0a:\ncase 0x0b:\ncase 0x18:\ncase 0x1a:\ncase 0x1b:\ncase 0x28:\ncase 0x2a:\ncase 0x2b:\ncase 0x38:\ncase 0x3a:\ncase 0x3b:\nswitch(VAR_16 & 7) {",
"case 0:\nswitch(VAR_16 >> 4) {",
"case 0:\ngen_op_flds_ST0_A0();",
"break;",
"case 1:\ngen_op_fildl_ST0_A0();",
"break;",
"case 2:\ngen_op_fldl_ST0_A0();",
"break;",
"case 3:\ndefault:\ngen_op_fild_ST0_A0();",
"break;",
"}",
"break;",
"default:\nswitch(VAR_16 >> 4) {",
"case 0:\ngen_op_fsts_ST0_A0();",
"break;",
"case 1:\ngen_op_fistl_ST0_A0();",
"break;",
"case 2:\ngen_op_fstl_ST0_A0();",
"break;",
"case 3:\ndefault:\ngen_op_fist_ST0_A0();",
"break;",
"}",
"if ((VAR_16 & 7) == 3)\ngen_op_fpop();",
"break;",
"}",
"break;",
"case 0x0c:\ngen_op_fldenv_A0(s->VAR_3);",
"break;",
"case 0x0d:\ngen_op_fldcw_A0();",
"break;",
"case 0x0e:\ngen_op_fnstenv_A0(s->VAR_3);",
"break;",
"case 0x0f:\ngen_op_fnstcw_A0();",
"break;",
"case 0x1d:\ngen_op_fldt_ST0_A0();",
"break;",
"case 0x1f:\ngen_op_fstt_ST0_A0();",
"gen_op_fpop();",
"break;",
"case 0x2c:\ngen_op_frstor_A0(s->VAR_3);",
"break;",
"case 0x2e:\ngen_op_fnsave_A0(s->VAR_3);",
"break;",
"case 0x2f:\ngen_op_fnstsw_A0();",
"break;",
"case 0x3c:\ngen_op_fbld_ST0_A0();",
"break;",
"case 0x3e:\ngen_op_fbst_ST0_A0();",
"gen_op_fpop();",
"break;",
"case 0x3d:\ngen_op_fildll_ST0_A0();",
"break;",
"case 0x3f:\ngen_op_fistll_ST0_A0();",
"gen_op_fpop();",
"break;",
"default:\ngoto illegal_op;",
"}",
"} else {",
"VAR_12 = VAR_8;",
"switch(VAR_16) {",
"case 0x08:\ngen_op_fpush();",
"gen_op_fmov_ST0_STN((VAR_12 + 1) & 7);",
"break;",
"case 0x09:\ngen_op_fxchg_ST0_STN(VAR_12);",
"break;",
"case 0x0a:\nswitch(VAR_8) {",
"case 0:\nbreak;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x0c:\nswitch(VAR_8) {",
"case 0:\ngen_op_fchs_ST0();",
"break;",
"case 1:\ngen_op_fabs_ST0();",
"break;",
"case 4:\ngen_op_fldz_FT0();",
"gen_op_fcom_ST0_FT0();",
"break;",
"case 5:\ngen_op_fxam_ST0();",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x0d:\n{",
"switch(VAR_8) {",
"case 0:\ngen_op_fpush();",
"gen_op_fld1_ST0();",
"break;",
"case 1:\ngen_op_fpush();",
"gen_op_fldl2t_ST0();",
"break;",
"case 2:\ngen_op_fpush();",
"gen_op_fldl2e_ST0();",
"break;",
"case 3:\ngen_op_fpush();",
"gen_op_fldpi_ST0();",
"break;",
"case 4:\ngen_op_fpush();",
"gen_op_fldlg2_ST0();",
"break;",
"case 5:\ngen_op_fpush();",
"gen_op_fldln2_ST0();",
"break;",
"case 6:\ngen_op_fpush();",
"gen_op_fldz_ST0();",
"break;",
"default:\ngoto illegal_op;",
"}",
"}",
"break;",
"case 0x0e:\nswitch(VAR_8) {",
"case 0:\ngen_op_f2xm1();",
"break;",
"case 1:\ngen_op_fyl2x();",
"break;",
"case 2:\ngen_op_fptan();",
"break;",
"case 3:\ngen_op_fpatan();",
"break;",
"case 4:\ngen_op_fxtract();",
"break;",
"case 5:\ngen_op_fprem1();",
"break;",
"case 6:\ngen_op_fdecstp();",
"break;",
"default:\ncase 7:\ngen_op_fincstp();",
"break;",
"}",
"break;",
"case 0x0f:\nswitch(VAR_8) {",
"case 0:\ngen_op_fprem();",
"break;",
"case 1:\ngen_op_fyl2xp1();",
"break;",
"case 2:\ngen_op_fsqrt();",
"break;",
"case 3:\ngen_op_fsincos();",
"break;",
"case 5:\ngen_op_fscale();",
"break;",
"case 4:\ngen_op_frndint();",
"break;",
"case 6:\ngen_op_fsin();",
"break;",
"default:\ncase 7:\ngen_op_fcos();",
"break;",
"}",
"break;",
"case 0x00: case 0x01: case 0x04 ... 0x07:\ncase 0x20: case 0x21: case 0x24 ... 0x27:\ncase 0x30: case 0x31: case 0x34 ... 0x37:\n{",
"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)\ngen_op_fpop();",
"} else {",
"gen_op_fmov_FT0_STN(VAR_12);",
"gen_op_fp_arith_ST0_FT0[VAR_22]();",
"}",
"}",
"break;",
"case 0x02:\ngen_op_fmov_FT0_STN(VAR_12);",
"gen_op_fcom_ST0_FT0();",
"break;",
"case 0x03:\ngen_op_fmov_FT0_STN(VAR_12);",
"gen_op_fcom_ST0_FT0();",
"gen_op_fpop();",
"break;",
"case 0x15:\nswitch(VAR_8) {",
"case 1:\ngen_op_fmov_FT0_STN(1);",
"gen_op_fucom_ST0_FT0();",
"gen_op_fpop();",
"gen_op_fpop();",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x1c:\nswitch(VAR_8) {",
"case 0:\nbreak;",
"case 1:\nbreak;",
"case 2:\ngen_op_fclex();",
"break;",
"case 3:\ngen_op_fninit();",
"break;",
"case 4:\nbreak;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x1d:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_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:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_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:\ngen_op_fmov_STN_ST0(VAR_12);",
"break;",
"case 0x2b:\ngen_op_fmov_STN_ST0(VAR_12);",
"gen_op_fpop();",
"break;",
"case 0x2c:\ngen_op_fmov_FT0_STN(VAR_12);",
"gen_op_fucom_ST0_FT0();",
"break;",
"case 0x2d:\ngen_op_fmov_FT0_STN(VAR_12);",
"gen_op_fucom_ST0_FT0();",
"gen_op_fpop();",
"break;",
"case 0x33:\nswitch(VAR_8) {",
"case 1:\ngen_op_fmov_FT0_STN(1);",
"gen_op_fcom_ST0_FT0();",
"gen_op_fpop();",
"gen_op_fpop();",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x3c:\nswitch(VAR_8) {",
"case 0:\ngen_op_fnstsw_EAX();",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x3d:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_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:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_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:\ncase 0x18 ... 0x1b:\n{",
"int VAR_22;",
"const static uint8_t VAR_22[8] = {",
"(JCC_B << 1),\n(JCC_Z << 1),\n(JCC_BE << 1),\n(JCC_P << 1),\n};",
"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:\ngoto illegal_op;",
"}",
"}",
"#ifdef USE_CODE_COPY\ns->tb->cflags |= CF_TB_FP_USED;",
"#endif\nbreak;",
"case 0xa4:\ncase 0xa5:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\ncase 0xab:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\ncase 0xad:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\ncase 0xaf:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\ncase 0xa7:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\ncase 0x6d:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\ncase 0x6f:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\ncase 0xe5:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\ncase 0xe7:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\ncase 0xed:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\ncase 0xef:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_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:\nVAR_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)\ngen_op_andl_T0_ffff();",
"gen_op_jmp_T0();",
"gen_eob(s);",
"break;",
"case 0xc3:\ngen_pop_T0(s);",
"gen_pop_update(s);",
"if (s->VAR_3 == 0)\ngen_op_andl_T0_ffff();",
"gen_op_jmp_T0();",
"gen_eob(s);",
"break;",
"case 0xca:\nVAR_17 = ldsw_code(s->pc);",
"s->pc += 2;",
"do_lret:\nif (s->pe && !s->vm86) {",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_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)\ngen_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:\nVAR_17 = 0;",
"goto do_lret;",
"case 0xcf:\nif (!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)\ngen_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:\n{",
"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)\nVAR_17 &= 0xffff;",
"gen_op_movl_T0_im(VAR_23);",
"gen_push_T0(s);",
"gen_jmp(s, VAR_17);",
"}",
"break;",
"case 0x9a:\n{",
"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:\nVAR_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)\nVAR_17 = VAR_17 & 0xffff;",
"gen_jmp(s, VAR_17);",
"break;",
"case 0xea:\n{",
"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:\nVAR_17 = (int8_t)insn_get(s, OT_BYTE);",
"VAR_17 += s->pc - s->cs_base;",
"if (s->VAR_3 == 0)\nVAR_17 = VAR_17 & 0xffff;",
"gen_jmp(s, VAR_17);",
"break;",
"case 0x70 ... 0x7f:\nVAR_17 = (int8_t)insn_get(s, OT_BYTE);",
"goto do_jcc;",
"case 0x180 ... 0x18f:\nif (VAR_3) {",
"VAR_17 = insn_get(s, OT_LONG);",
"} else {",
"VAR_17 = (int16_t)insn_get(s, OT_WORD);",
"}",
"do_jcc:\nVAR_23 = s->pc - s->cs_base;",
"VAR_17 += VAR_23;",
"if (s->VAR_3 == 0)\nVAR_17 &= 0xffff;",
"gen_jcc(s, VAR_0, VAR_17, VAR_23);",
"break;",
"case 0x190 ... 0x19f:\nVAR_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:\nVAR_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:\nif (s->vm86 && s->iopl != 3) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"} else {",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_op_movl_T0_eflags();",
"gen_push_T0(s);",
"}",
"break;",
"case 0x9d:\nif (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:\ngen_op_mov_TN_reg[OT_BYTE][0][R_AH]();",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_op_movb_eflags_T0();",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x9f:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_op_movl_T0_eflags();",
"gen_op_mov_reg_T0[OT_BYTE][R_AH]();",
"break;",
"case 0xf5:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_op_cmc();",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0xf8:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_op_clc();",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0xf9:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_op_stc();",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0xfc:\ngen_op_cld();",
"break;",
"case 0xfd:\ngen_op_std();",
"break;",
"case 0x1ba:\nVAR_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)\ngoto 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)\ngen_op_st_T0_A0[VAR_5 + s->mem_index]();",
"else\ngen_op_mov_reg_T0[VAR_5][VAR_8]();",
"gen_op_update_bt_cc();",
"}",
"break;",
"case 0x1a3:\nVAR_16 = 0;",
"goto do_btx;",
"case 0x1ab:\nVAR_16 = 1;",
"goto do_btx;",
"case 0x1b3:\nVAR_16 = 2;",
"goto do_btx;",
"case 0x1bb:\nVAR_16 = 3;",
"do_btx:\nVAR_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)\ngen_op_add_bitw_A0_T1();",
"else\ngen_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)\ngen_op_st_T0_A0[VAR_5 + s->mem_index]();",
"else\ngen_op_mov_reg_T0[VAR_5][VAR_8]();",
"gen_op_update_bt_cc();",
"}",
"break;",
"case 0x1bc:\ncase 0x1bd:\nVAR_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:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_op_daa();",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x2f:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_op_das();",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x37:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_op_aaa();",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x3f:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_op_aas();",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0xd4:\nVAR_17 = ldub_code(s->pc++);",
"gen_op_aam(VAR_17);",
"s->cc_op = CC_OP_LOGICB;",
"break;",
"case 0xd5:\nVAR_17 = ldub_code(s->pc++);",
"gen_op_aad(VAR_17);",
"s->cc_op = CC_OP_LOGICB;",
"break;",
"case 0x90:\nif (VAR_1 & PREFIX_LOCK)\ngoto illegal_op;",
"break;",
"case 0x9b:\nif ((s->flags & (HF_MP_MASK | HF_TS_MASK)) ==\n(HF_MP_MASK | HF_TS_MASK)) {",
"gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);",
"} else {",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_op_jmp_im(pc_start - s->cs_base);",
"gen_op_fwait();",
"}",
"break;",
"case 0xcc:\ngen_interrupt(s, EXCP03_INT3, pc_start - s->cs_base, s->pc - s->cs_base);",
"break;",
"case 0xcd:\nVAR_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:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_op_into(s->pc - s->cs_base);",
"break;",
"case 0xf1:\ngen_debug(s, pc_start - s->cs_base);",
"break;",
"case 0xfa:\nif (!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:\nif (!s->vm86) {",
"if (s->cpl <= s->iopl) {",
"gen_sti:\ngen_op_sti();",
"if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))\ngen_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:\nVAR_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)\ngoto 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)\ngen_op_boundw(pc_start - s->cs_base);",
"else\ngen_op_boundl(pc_start - s->cs_base);",
"break;",
"case 0x1c8 ... 0x1cf:\nVAR_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:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_op_salc();",
"break;",
"case 0xe0:\ncase 0xe1:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"case 0xe2:\ncase 0xe3:\nVAR_17 = (int8_t)insn_get(s, OT_BYTE);",
"VAR_23 = s->pc - s->cs_base;",
"VAR_17 += VAR_23;",
"if (s->VAR_3 == 0)\nVAR_17 &= 0xffff;",
"gen_op_loop[s->VAR_2][VAR_0 & 3](VAR_17, VAR_23);",
"gen_eob(s);",
"break;",
"case 0x130:\ncase 0x132:\nif (s->cpl != 0) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"} else {",
"if (VAR_0 & 2)\ngen_op_rdmsr();",
"else\ngen_op_wrmsr();",
"}",
"break;",
"case 0x131:\ngen_op_rdtsc();",
"break;",
"case 0x1a2:\ngen_op_cpuid();",
"break;",
"case 0xf4:\nif (s->cpl != 0) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"} else {",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_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:\nVAR_6 = ldub_code(s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_16 = (VAR_6 >> 3) & 7;",
"switch(VAR_16) {",
"case 0:\nif (!s->pe || s->vm86)\ngoto illegal_op;",
"gen_op_movl_T0_env(offsetof(CPUX86State,ldt.VAR_25));",
"VAR_5 = OT_WORD;",
"if (VAR_9 == 3)\nVAR_5 += s->VAR_3;",
"gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 1);",
"break;",
"case 2:\nif (!s->pe || s->vm86)\ngoto 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:\nif (!s->pe || s->vm86)\ngoto illegal_op;",
"gen_op_movl_T0_env(offsetof(CPUX86State,tr.VAR_25));",
"VAR_5 = OT_WORD;",
"if (VAR_9 == 3)\nVAR_5 += s->VAR_3;",
"gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 1);",
"break;",
"case 3:\nif (!s->pe || s->vm86)\ngoto 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:\ncase 5:\nif (!s->pe || s->vm86)\ngoto illegal_op;",
"gen_ldst_modrm(s, VAR_6, OT_WORD, OR_TMP0, 0);",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"if (VAR_16 == 4)\ngen_op_verr();",
"else\ngen_op_verw();",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x101:\nVAR_6 = ldub_code(s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_16 = (VAR_6 >> 3) & 7;",
"switch(VAR_16) {",
"case 0:\ncase 1:\nif (VAR_9 == 3)\ngoto illegal_op;",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"if (VAR_16 == 0)\ngen_op_movl_T0_env(offsetof(CPUX86State,gdt.limit));",
"else\ngen_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)\ngen_op_movl_T0_env(offsetof(CPUX86State,gdt.base));",
"else\ngen_op_movl_T0_env(offsetof(CPUX86State,idt.base));",
"if (!s->VAR_3)\ngen_op_andl_T0_im(0xffffff);",
"gen_op_st_T0_A0[OT_LONG + s->mem_index]();",
"break;",
"case 2:\ncase 3:\nif (VAR_9 == 3)\ngoto 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)\ngen_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:\ngen_op_movl_T0_env(offsetof(CPUX86State,cr[0]));",
"gen_ldst_modrm(s, VAR_6, OT_WORD, OR_TMP0, 1);",
"break;",
"case 6:\nif (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:\nif (s->cpl != 0) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"} else {",
"if (VAR_9 == 3)\ngoto 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:\ngoto illegal_op;",
"}",
"break;",
"case 0x108:\ncase 0x109:\nif (s->cpl != 0) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"} else {",
"}",
"break;",
"case 0x63:\nif (!s->pe || s->vm86)\ngoto 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)\ngen_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:\ncase 0x103:\nif (!s->pe || s->vm86)\ngoto 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)\ngen_op_set_cc_op(s->cc_op);",
"if (VAR_0 == 0x102)\ngen_op_lar();",
"else\ngen_op_lsl();",
"s->cc_op = CC_OP_EFLAGS;",
"gen_op_mov_reg_T1[VAR_5][VAR_7]();",
"break;",
"case 0x118:\nVAR_6 = ldub_code(s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_16 = (VAR_6 >> 3) & 7;",
"switch(VAR_16) {",
"case 0:\ncase 1:\ncase 2:\ncase 3:\nif (VAR_9 == 3)\ngoto illegal_op;",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x120:\ncase 0x122:\nif (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)\ngoto illegal_op;",
"VAR_8 = VAR_6 & 7;",
"VAR_7 = (VAR_6 >> 3) & 7;",
"switch(VAR_7) {",
"case 0:\ncase 2:\ncase 3:\ncase 4:\nif (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:\ngoto illegal_op;",
"}",
"}",
"break;",
"case 0x121:\ncase 0x123:\nif (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)\ngoto illegal_op;",
"VAR_8 = VAR_6 & 7;",
"VAR_7 = (VAR_6 >> 3) & 7;",
"if (VAR_7 == 4 || VAR_7 == 5)\ngoto 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:\nif (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:\ngoto illegal_op;",
"}",
"if (s->prefix & PREFIX_LOCK)\ngen_op_unlock();",
"return s->pc;",
"illegal_op:\nif (s->prefix & PREFIX_LOCK)\ngen_op_unlock();",
"gen_exception(s, EXCP06_ILLOP, pc_start - s->cs_base);",
"return s->pc;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
51
],
[
53,
55
],
[
57
],
[
59,
61
],
[
63
],
[
65,
67
],
[
69
],
[
71,
73
],
[
75
],
[
77,
79
],
[
81
],
[
83,
85
],
[
87
],
[
89,
91
],
[
93
],
[
95,
97
],
[
99
],
[
101
],
[
105,
107
],
[
109,
111
],
[
115
],
[
117
],
[
119
],
[
125,
127
],
[
133,
135
],
[
137,
143
],
[
145
],
[
153,
155,
157,
159,
161,
163,
165,
167,
169
],
[
171
],
[
173
],
[
175
],
[
179,
181
],
[
183,
185
],
[
189
],
[
191,
193
],
[
195
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209,
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
233
],
[
235,
237
],
[
239
],
[
241
],
[
243
],
[
245
],
[
247
],
[
249
],
[
251
],
[
253
],
[
255
],
[
257
],
[
259
],
[
261
],
[
263
],
[
265,
267
],
[
269
],
[
271
],
[
273
],
[
275
],
[
277
],
[
279
],
[
283,
285,
287,
289,
291
],
[
293
],
[
297,
299
],
[
301,
303
],
[
307
],
[
309
],
[
311
],
[
313
],
[
317
],
[
319
],
[
321
],
[
323
],
[
325
],
[
327
],
[
331
],
[
333,
335,
337,
339,
341
],
[
343
],
[
345,
347
],
[
349
],
[
351
],
[
353
],
[
355
],
[
357
],
[
359
],
[
367,
369
],
[
371
],
[
373
],
[
375,
377
],
[
379
],
[
381
],
[
383,
385,
387,
389
],
[
391,
393
],
[
397
],
[
399
],
[
401
],
[
403
],
[
405
],
[
407
],
[
409
],
[
411
],
[
413
],
[
415
],
[
419
],
[
421,
423
],
[
425
],
[
427
],
[
429
],
[
431
],
[
433,
435
],
[
437
],
[
439
],
[
441
],
[
443
],
[
445
],
[
447
],
[
449,
451
],
[
453
],
[
455
],
[
457
],
[
459
],
[
461
],
[
463
],
[
465
],
[
467
],
[
469,
471
],
[
473,
475
],
[
477
],
[
479
],
[
481,
483
],
[
485
],
[
487
],
[
489,
491,
493
],
[
495
],
[
497
],
[
499
],
[
501
],
[
503,
505
],
[
507,
509
],
[
511
],
[
513
],
[
515,
517
],
[
519
],
[
521
],
[
523,
525,
527
],
[
529
],
[
531
],
[
533
],
[
535
],
[
537,
539
],
[
541,
543
],
[
545
],
[
547,
549
],
[
551
],
[
553,
555,
557
],
[
559
],
[
561
],
[
563
],
[
565,
567
],
[
569,
571
],
[
573
],
[
575,
577
],
[
579
],
[
581,
583,
585
],
[
587
],
[
589
],
[
591
],
[
593,
595
],
[
597
],
[
599
],
[
603,
605,
607,
609
],
[
611,
613
],
[
617
],
[
619
],
[
621
],
[
623
],
[
625
],
[
627
],
[
629
],
[
631
],
[
633
],
[
635,
637
],
[
639
],
[
641
],
[
643
],
[
647
],
[
649,
651,
653
],
[
655,
657
],
[
659
],
[
661
],
[
663,
665,
667
],
[
669,
671
],
[
673
],
[
675
],
[
677,
681,
683
],
[
685
],
[
687
],
[
689
],
[
691
],
[
693
],
[
695
],
[
697,
699
],
[
701
],
[
703
],
[
705,
707
],
[
709,
711
],
[
713
],
[
715
],
[
717
],
[
719
],
[
721
],
[
723
],
[
725
],
[
727,
729,
731
],
[
733
],
[
735
],
[
737
],
[
739,
741
],
[
743
],
[
745
],
[
747,
749
],
[
751,
753
],
[
755
],
[
757
],
[
759
],
[
761
],
[
763
],
[
765
],
[
767
],
[
769
],
[
771
],
[
773,
775
],
[
777
],
[
779,
781
],
[
783
],
[
785
],
[
789,
791,
793,
795
],
[
797,
799
],
[
803
],
[
805
],
[
807
],
[
809
],
[
813
],
[
815
],
[
817
],
[
819
],
[
821
],
[
825,
827,
829,
831
],
[
833,
835
],
[
837
],
[
841
],
[
843
],
[
845
],
[
847
],
[
849
],
[
853,
855,
857
],
[
859,
861
],
[
863
],
[
865,
867,
869
],
[
871,
873
],
[
875
],
[
877,
879,
881,
883
],
[
885
],
[
887
],
[
889
],
[
891
],
[
893
],
[
895
],
[
897
],
[
899
],
[
901
],
[
903
],
[
905
],
[
907
],
[
911
],
[
913
],
[
915
],
[
917
],
[
919
],
[
921
],
[
923
],
[
925
],
[
927,
929,
931,
933
],
[
935,
937
],
[
939
],
[
941
],
[
943
],
[
945
],
[
947
],
[
949
],
[
951
],
[
953
],
[
955
],
[
957
],
[
959
],
[
961
],
[
963
],
[
965
],
[
967
],
[
969
],
[
971
],
[
973
],
[
975
],
[
977
],
[
979
],
[
981,
983,
985,
987
],
[
989,
991
],
[
993
],
[
995
],
[
997
],
[
999
],
[
1001
],
[
1003
],
[
1005
],
[
1007
],
[
1009
],
[
1011
],
[
1013
],
[
1015
],
[
1017
],
[
1019
],
[
1021
],
[
1023
],
[
1025,
1027
],
[
1029
],
[
1031,
1033
],
[
1035,
1037
],
[
1039
],
[
1041
],
[
1043
],
[
1045
],
[
1053,
1055
],
[
1057
],
[
1059
],
[
1061,
1063
],
[
1065
],
[
1069
],
[
1071
],
[
1073
],
[
1075,
1077
],
[
1079
],
[
1081,
1083
],
[
1085
],
[
1087,
1089,
1091
],
[
1093,
1095
],
[
1097,
1099
],
[
1101
],
[
1103
],
[
1105
],
[
1107,
1109
],
[
1111
],
[
1113
],
[
1115
],
[
1117
],
[
1121
],
[
1123
],
[
1125
],
[
1127
],
[
1131
],
[
1133
],
[
1135
],
[
1137
],
[
1139
],
[
1141
],
[
1143,
1145
],
[
1147
],
[
1149
],
[
1151
],
[
1153
],
[
1155
],
[
1157
],
[
1159
],
[
1161,
1165
],
[
1167
],
[
1169
],
[
1171
],
[
1173
],
[
1175
],
[
1177
],
[
1179
],
[
1181
],
[
1183
],
[
1185
],
[
1187
],
[
1189,
1191,
1193,
1195,
1197
],
[
1199
],
[
1201
],
[
1203,
1205,
1207
],
[
1209
],
[
1211
],
[
1213,
1215,
1217,
1219
],
[
1221
],
[
1223
],
[
1225
],
[
1227
],
[
1235,
1237
],
[
1239
],
[
1241
],
[
1243
],
[
1245
],
[
1247
],
[
1249
],
[
1251
],
[
1253,
1255,
1257
],
[
1259
],
[
1261
],
[
1263
],
[
1265
],
[
1267
],
[
1269
],
[
1271
],
[
1279,
1281,
1283,
1285
],
[
1287,
1289
],
[
1291
],
[
1293
],
[
1299
],
[
1301
],
[
1303,
1305,
1307,
1309
],
[
1311,
1313
],
[
1315
],
[
1317
],
[
1319,
1321
],
[
1323
],
[
1325
],
[
1327,
1329
],
[
1331,
1333
],
[
1335
],
[
1337,
1339,
1341,
1343
],
[
1345,
1347
],
[
1349
],
[
1351
],
[
1355
],
[
1357
],
[
1359
],
[
1361,
1363
],
[
1365
],
[
1367,
1369
],
[
1371
],
[
1373
],
[
1375
],
[
1383,
1385
],
[
1387
],
[
1389
],
[
1391
],
[
1393
],
[
1395
],
[
1397
],
[
1399
],
[
1401,
1403
],
[
1405
],
[
1407
],
[
1409,
1411
],
[
1413
],
[
1415
],
[
1417,
1419
],
[
1421
],
[
1423
],
[
1427,
1429,
1431,
1433,
1435
],
[
1437
],
[
1441
],
[
1445
],
[
1447
],
[
1449
],
[
1451
],
[
1453
],
[
1457
],
[
1459
],
[
1461
],
[
1463,
1465
],
[
1467
],
[
1469,
1471
],
[
1473
],
[
1475,
1477
],
[
1479
],
[
1481,
1483,
1485
],
[
1487
],
[
1489
],
[
1491
],
[
1493
],
[
1495
],
[
1497
],
[
1499
],
[
1501
],
[
1503
],
[
1505
],
[
1507
],
[
1509
],
[
1511
],
[
1513
],
[
1517,
1519
],
[
1521
],
[
1523
],
[
1525,
1527
],
[
1529
],
[
1533
],
[
1535
],
[
1537
],
[
1539
],
[
1541
],
[
1543
],
[
1545
],
[
1549,
1551,
1553,
1555,
1557,
1559
],
[
1561,
1563
],
[
1565,
1567
],
[
1569,
1571
],
[
1573
],
[
1577
],
[
1579
],
[
1581
],
[
1583
],
[
1585
],
[
1587
],
[
1589
],
[
1591
],
[
1593
],
[
1595
],
[
1597
],
[
1599
],
[
1601
],
[
1603
],
[
1605
],
[
1607
],
[
1609
],
[
1611
],
[
1613
],
[
1615
],
[
1617
],
[
1619,
1621
],
[
1623
],
[
1625,
1627
],
[
1631
],
[
1633
],
[
1635
],
[
1637
],
[
1639
],
[
1641
],
[
1643
],
[
1645
],
[
1647
],
[
1649
],
[
1651
],
[
1653
],
[
1655
],
[
1657
],
[
1659
],
[
1661
],
[
1663
],
[
1665,
1667
],
[
1669
],
[
1671
],
[
1673
],
[
1675,
1677
],
[
1679
],
[
1681
],
[
1683
],
[
1685
],
[
1687
],
[
1691,
1693
],
[
1695
],
[
1697
],
[
1699
],
[
1701,
1703,
1705,
1707
],
[
1709,
1711
],
[
1713
],
[
1715
],
[
1717
],
[
1719
],
[
1721
],
[
1723,
1725
],
[
1727
],
[
1729
],
[
1731
],
[
1733
],
[
1735
],
[
1737
],
[
1741,
1743
],
[
1745
],
[
1747
],
[
1749,
1751
],
[
1753
],
[
1755
],
[
1757
],
[
1759,
1761
],
[
1763
],
[
1765,
1767
],
[
1769
],
[
1771,
1773
],
[
1775
],
[
1777,
1779
],
[
1781
],
[
1783,
1785
],
[
1787,
1789
],
[
1791
],
[
1793
],
[
1795
],
[
1797,
1799
],
[
1801
],
[
1803
],
[
1805
],
[
1809
],
[
1811
],
[
1815
],
[
1817
],
[
1819
],
[
1821
],
[
1823
],
[
1825
],
[
1833,
1835,
1839
],
[
1841,
1843
],
[
1845,
1847
],
[
1849,
1851
],
[
1855
],
[
1857
],
[
1859
],
[
1861
],
[
1865
],
[
1867
],
[
1869
],
[
1871
],
[
1873
],
[
1875
],
[
1881
],
[
1883
],
[
1885
],
[
1887
],
[
1889
],
[
1891
],
[
1893
],
[
1895
],
[
1897
],
[
1899
],
[
1901,
1903,
1907
],
[
1909
],
[
1911,
1913,
1917
],
[
1919
],
[
1923,
1925
],
[
1927
],
[
1929
],
[
1931,
1933
],
[
1935
],
[
1937
],
[
1939,
1941
],
[
1943
],
[
1945
],
[
1947,
1949
],
[
1951
],
[
1953,
1955
],
[
1957
],
[
1959
],
[
1961
],
[
1963
],
[
1967
],
[
1969
],
[
1971
],
[
1973
],
[
1975
],
[
1977
],
[
1979
],
[
1983
],
[
1985
],
[
1987
],
[
1989
],
[
1991,
1993
],
[
1995,
1997
],
[
1999,
2001
],
[
2003,
2005
],
[
2007
],
[
2009
],
[
2011,
2013
],
[
2015,
2017
],
[
2019,
2021
],
[
2023
],
[
2025
],
[
2027
],
[
2029
],
[
2031
],
[
2033
],
[
2041,
2043
],
[
2049
],
[
2051
],
[
2053
],
[
2055
],
[
2057
],
[
2059
],
[
2061
],
[
2063
],
[
2067
],
[
2069
],
[
2071,
2073,
2075,
2077,
2079
],
[
2081
],
[
2083
],
[
2087
],
[
2089,
2091
],
[
2093
],
[
2095,
2097
],
[
2099
],
[
2101,
2103
],
[
2105
],
[
2107,
2109,
2111
],
[
2113
],
[
2115
],
[
2119
],
[
2121
],
[
2125
],
[
2127
],
[
2129
],
[
2131
],
[
2133,
2135,
2137,
2139,
2141,
2143,
2145,
2147,
2149,
2151,
2153,
2155,
2159
],
[
2161,
2163
],
[
2165,
2167
],
[
2169
],
[
2171,
2173
],
[
2175
],
[
2177,
2179
],
[
2181
],
[
2183,
2185,
2187
],
[
2189
],
[
2191
],
[
2193
],
[
2195,
2197
],
[
2199,
2201
],
[
2203
],
[
2205,
2207
],
[
2209
],
[
2211,
2213
],
[
2215
],
[
2217,
2219,
2221
],
[
2223
],
[
2225
],
[
2227,
2229
],
[
2231
],
[
2233
],
[
2235
],
[
2237,
2239
],
[
2241
],
[
2243,
2245
],
[
2247
],
[
2249,
2251
],
[
2253
],
[
2255,
2257
],
[
2259
],
[
2261,
2263
],
[
2265
],
[
2267,
2269
],
[
2271
],
[
2273
],
[
2275,
2277
],
[
2279
],
[
2281,
2283
],
[
2285
],
[
2287,
2289
],
[
2291
],
[
2293,
2295
],
[
2297
],
[
2299,
2301
],
[
2303
],
[
2305
],
[
2307,
2309
],
[
2311
],
[
2313,
2315
],
[
2317
],
[
2319
],
[
2321,
2323
],
[
2325
],
[
2327
],
[
2331
],
[
2335
],
[
2337,
2339
],
[
2341
],
[
2343
],
[
2345,
2347
],
[
2349
],
[
2351,
2353
],
[
2355,
2357
],
[
2359,
2361
],
[
2363
],
[
2365
],
[
2367,
2369
],
[
2371,
2373
],
[
2375
],
[
2377,
2379
],
[
2381
],
[
2383,
2385
],
[
2387
],
[
2389
],
[
2391,
2393
],
[
2395
],
[
2397,
2399
],
[
2401
],
[
2403
],
[
2405,
2407
],
[
2409
],
[
2411,
2413
],
[
2415
],
[
2417
],
[
2419,
2421
],
[
2423
],
[
2425
],
[
2427,
2429
],
[
2431
],
[
2433
],
[
2435,
2437
],
[
2439
],
[
2441
],
[
2443,
2445
],
[
2447
],
[
2449
],
[
2451,
2453
],
[
2455
],
[
2457
],
[
2459,
2461
],
[
2463
],
[
2465
],
[
2467,
2469
],
[
2471
],
[
2473
],
[
2475
],
[
2477,
2479
],
[
2481,
2483
],
[
2485
],
[
2487,
2489
],
[
2491
],
[
2493,
2495
],
[
2497
],
[
2499,
2501
],
[
2503
],
[
2505,
2507
],
[
2509
],
[
2511,
2513
],
[
2515
],
[
2517,
2519
],
[
2521
],
[
2523,
2525,
2527
],
[
2529
],
[
2531
],
[
2533
],
[
2535,
2537
],
[
2539,
2541
],
[
2543
],
[
2545,
2547
],
[
2549
],
[
2551,
2553
],
[
2555
],
[
2557,
2559
],
[
2561
],
[
2563,
2565
],
[
2567
],
[
2569,
2571
],
[
2573
],
[
2575,
2577
],
[
2579
],
[
2581,
2583,
2585
],
[
2587
],
[
2589
],
[
2591
],
[
2593,
2595,
2597,
2599
],
[
2601
],
[
2605
],
[
2607
],
[
2609
],
[
2611,
2613
],
[
2615
],
[
2617
],
[
2619
],
[
2621
],
[
2623
],
[
2625
],
[
2627,
2629
],
[
2631
],
[
2633
],
[
2635,
2637
],
[
2639
],
[
2641
],
[
2643
],
[
2645,
2647
],
[
2649,
2651
],
[
2653
],
[
2655
],
[
2657
],
[
2659
],
[
2661,
2663
],
[
2665
],
[
2667
],
[
2669,
2671
],
[
2673,
2675
],
[
2677,
2679
],
[
2681,
2683
],
[
2685
],
[
2687,
2689
],
[
2691
],
[
2693,
2695
],
[
2697,
2699
],
[
2701
],
[
2703
],
[
2705,
2707,
2709
],
[
2711
],
[
2713
],
[
2715
],
[
2717
],
[
2719,
2721,
2723
],
[
2725
],
[
2727
],
[
2729
],
[
2731
],
[
2733,
2735
],
[
2737
],
[
2739,
2741
],
[
2743
],
[
2745
],
[
2747,
2749
],
[
2751
],
[
2753
],
[
2755,
2757
],
[
2759
],
[
2761
],
[
2763
],
[
2765,
2767
],
[
2769,
2771
],
[
2773
],
[
2775
],
[
2777
],
[
2779
],
[
2781,
2783
],
[
2785
],
[
2787
],
[
2789,
2791
],
[
2793,
2795
],
[
2797
],
[
2799,
2801
],
[
2803
],
[
2805
],
[
2807,
2809,
2811
],
[
2813
],
[
2815
],
[
2817
],
[
2819
],
[
2821
],
[
2823,
2825,
2827
],
[
2829
],
[
2831
],
[
2833
],
[
2835
],
[
2837
],
[
2839,
2841,
2843
],
[
2845
],
[
2847
],
[
2849,
2851,
2853,
2855,
2857
],
[
2859
],
[
2861
],
[
2863
],
[
2865
],
[
2867
],
[
2869,
2871
],
[
2873
],
[
2875
],
[
2877,
2879
],
[
2881,
2883
],
[
2891,
2893,
2895,
2897
],
[
2899,
2901
],
[
2905
],
[
2907
],
[
2909
],
[
2911
],
[
2913
],
[
2915
],
[
2919,
2921,
2923,
2925
],
[
2927,
2929
],
[
2933
],
[
2935
],
[
2937
],
[
2939
],
[
2941
],
[
2943
],
[
2945,
2947,
2949,
2951
],
[
2953,
2955
],
[
2957
],
[
2959
],
[
2961
],
[
2963
],
[
2965
],
[
2967
],
[
2969,
2971,
2973,
2975
],
[
2977,
2979
],
[
2981
],
[
2983
],
[
2985
],
[
2987
],
[
2989
],
[
2991
],
[
2993
],
[
2995
],
[
2997
],
[
3001,
3003,
3005,
3007
],
[
3009,
3011
],
[
3013
],
[
3015
],
[
3017
],
[
3019
],
[
3021
],
[
3023
],
[
3025
],
[
3027
],
[
3029
],
[
3031,
3033,
3035,
3037
],
[
3039,
3041
],
[
3043
],
[
3045
],
[
3047
],
[
3049
],
[
3051
],
[
3053
],
[
3055
],
[
3057,
3059,
3061,
3063
],
[
3065,
3067
],
[
3069
],
[
3071
],
[
3073
],
[
3075
],
[
3077
],
[
3079
],
[
3081
],
[
3089,
3091,
3093,
3095
],
[
3097,
3099
],
[
3101
],
[
3103
],
[
3105
],
[
3107
],
[
3109
],
[
3111
],
[
3113,
3115,
3117,
3119
],
[
3121,
3123
],
[
3125
],
[
3127
],
[
3129
],
[
3131
],
[
3133
],
[
3135
],
[
3137,
3139,
3141,
3143
],
[
3145,
3147
],
[
3149
],
[
3151
],
[
3153
],
[
3155
],
[
3157
],
[
3159
],
[
3161,
3163,
3165,
3167
],
[
3169,
3171
],
[
3173
],
[
3175
],
[
3177
],
[
3179
],
[
3181
],
[
3183
],
[
3191,
3193
],
[
3195
],
[
3197
],
[
3199
],
[
3201,
3203
],
[
3205
],
[
3207
],
[
3209
],
[
3211,
3213
],
[
3215
],
[
3217,
3219
],
[
3221
],
[
3223
],
[
3225
],
[
3227,
3229
],
[
3231
],
[
3233,
3235
],
[
3237,
3239
],
[
3241
],
[
3243
],
[
3245
],
[
3247
],
[
3251
],
[
3253,
3255
],
[
3261
],
[
3265
],
[
3267
],
[
3269
],
[
3273
],
[
3275
],
[
3277
],
[
3279
],
[
3281,
3283
],
[
3285
],
[
3287,
3289
],
[
3293
],
[
3295
],
[
3297
],
[
3299
],
[
3301
],
[
3303
],
[
3305
],
[
3307
],
[
3309
],
[
3311
],
[
3313,
3315
],
[
3317
],
[
3319
],
[
3321
],
[
3323
],
[
3325
],
[
3327
],
[
3329,
3331
],
[
3333
],
[
3335
],
[
3337
],
[
3339
],
[
3341
],
[
3343,
3345
],
[
3347
],
[
3349
],
[
3351
],
[
3353
],
[
3355
],
[
3357,
3359
],
[
3361
],
[
3365
],
[
3367
],
[
3369
],
[
3373
],
[
3375
],
[
3377
],
[
3379
],
[
3381,
3383
],
[
3385
],
[
3387
],
[
3389,
3391
],
[
3393
],
[
3395
],
[
3397,
3399
],
[
3401
],
[
3405
],
[
3407
],
[
3409
],
[
3413
],
[
3415
],
[
3417
],
[
3419
],
[
3421,
3423
],
[
3425
],
[
3427,
3429
],
[
3431
],
[
3433
],
[
3435,
3437
],
[
3439
],
[
3441,
3443
],
[
3445
],
[
3447
],
[
3449
],
[
3451
],
[
3453,
3455
],
[
3457
],
[
3459,
3461
],
[
3463
],
[
3465
],
[
3469,
3471
],
[
3473
],
[
3475
],
[
3477
],
[
3479,
3481
],
[
3483
],
[
3485
],
[
3487
],
[
3489
],
[
3491
],
[
3493
],
[
3495
],
[
3497
],
[
3499
],
[
3501
],
[
3503
],
[
3505
],
[
3507
],
[
3515,
3517
],
[
3519
],
[
3521
],
[
3523,
3525
],
[
3527
],
[
3529
],
[
3531
],
[
3533
],
[
3535,
3537
],
[
3539
],
[
3541
],
[
3543
],
[
3545
],
[
3547
],
[
3549
],
[
3551
],
[
3553
],
[
3555
],
[
3557
],
[
3559
],
[
3561
],
[
3563
],
[
3565
],
[
3567
],
[
3569
],
[
3571
],
[
3573
],
[
3575
],
[
3577
],
[
3579
],
[
3581
],
[
3583
],
[
3585
],
[
3587
],
[
3589
],
[
3593
],
[
3595
],
[
3597
],
[
3599
],
[
3601,
3603
],
[
3605,
3607
],
[
3609
],
[
3611
],
[
3613
],
[
3615,
3617,
3619
],
[
3621
],
[
3623
],
[
3625
],
[
3627,
3629,
3631
],
[
3633
],
[
3635
],
[
3637
],
[
3639,
3641,
3643
],
[
3645
],
[
3647
],
[
3649
],
[
3651,
3653,
3655
],
[
3657
],
[
3659
],
[
3661
],
[
3663,
3665
],
[
3667
],
[
3669,
3671
],
[
3673
],
[
3681,
3683
],
[
3685
],
[
3687
],
[
3689
],
[
3691
],
[
3693
],
[
3695
],
[
3697
],
[
3699
],
[
3701
],
[
3703
],
[
3707
],
[
3709
],
[
3711,
3713
],
[
3715
],
[
3717
],
[
3719
],
[
3721
],
[
3723,
3725
],
[
3727,
3729
],
[
3731
],
[
3733
],
[
3735
],
[
3737,
3739
],
[
3741
],
[
3743,
3745
],
[
3747
],
[
3749,
3751
],
[
3753
],
[
3755,
3757
],
[
3759,
3761
],
[
3763
],
[
3765
],
[
3767
],
[
3769
],
[
3771
],
[
3773
],
[
3775
],
[
3779,
3781
],
[
3783,
3785
],
[
3787
],
[
3789
],
[
3791
],
[
3793
],
[
3795
],
[
3797
],
[
3799
],
[
3801,
3803
],
[
3805,
3807
],
[
3809
],
[
3811
],
[
3813
],
[
3815,
3817,
3819
],
[
3821
],
[
3823
],
[
3825
],
[
3827
],
[
3833
],
[
3835
],
[
3837
],
[
3843,
3845,
3847
],
[
3849
],
[
3851
],
[
3853
],
[
3855,
3857,
3859
],
[
3861
],
[
3863
],
[
3865
],
[
3867,
3869,
3871
],
[
3873
],
[
3875
],
[
3877
],
[
3879,
3881,
3883
],
[
3885
],
[
3887
],
[
3889
],
[
3891,
3893
],
[
3895
],
[
3897
],
[
3899
],
[
3901,
3903
],
[
3905
],
[
3907
],
[
3909
],
[
3915,
3919,
3921
],
[
3923
],
[
3925,
3927,
3929
],
[
3931
],
[
3933
],
[
3935,
3937
],
[
3939
],
[
3941
],
[
3943
],
[
3945
],
[
3947,
3949
],
[
3951
],
[
3953,
3955
],
[
3957
],
[
3959
],
[
3961
],
[
3963
],
[
3965
],
[
3967
],
[
3969,
3971,
3973
],
[
3975
],
[
3977
],
[
3979,
3981
],
[
3983
],
[
3985,
3987
],
[
3989
],
[
3991
],
[
3993
],
[
3995
],
[
3997
],
[
3999
],
[
4001
],
[
4003
],
[
4005
],
[
4007
],
[
4009
],
[
4011
],
[
4013
],
[
4015,
4017
],
[
4019
],
[
4021,
4023
],
[
4031,
4033
],
[
4037
],
[
4039
],
[
4041
],
[
4043
],
[
4045
],
[
4047
],
[
4049
],
[
4051
],
[
4053
],
[
4055
],
[
4057
],
[
4059
],
[
4061
],
[
4063,
4065
],
[
4067
],
[
4069
],
[
4071
],
[
4073,
4075
],
[
4077
],
[
4079
],
[
4081,
4083
],
[
4085,
4087
],
[
4089
],
[
4091,
4093
],
[
4095
],
[
4097
],
[
4099
],
[
4101
],
[
4103,
4105,
4107
],
[
4109
],
[
4111
],
[
4113,
4115,
4117,
4119
],
[
4123,
4125,
4127
],
[
4129
],
[
4131
],
[
4133,
4135
],
[
4137
],
[
4139
],
[
4141
],
[
4143,
4145,
4147
],
[
4149
],
[
4151
],
[
4153,
4155
],
[
4157,
4159
],
[
4161
],
[
4163
],
[
4165,
4167
],
[
4169
],
[
4171,
4173
],
[
4175
],
[
4177,
4179
],
[
4181
],
[
4183
],
[
4185,
4187
],
[
4189
],
[
4191
],
[
4193
],
[
4195
],
[
4197
],
[
4199,
4201
],
[
4203
],
[
4205
],
[
4207
],
[
4209,
4211,
4213
],
[
4215
],
[
4217
],
[
4219,
4221
],
[
4223
],
[
4225
],
[
4227,
4229,
4231
],
[
4233
],
[
4235
],
[
4237
],
[
4239
],
[
4241
],
[
4243
],
[
4245
],
[
4247
],
[
4249,
4251,
4253
],
[
4255
],
[
4257
],
[
4259,
4261
],
[
4263
],
[
4265
],
[
4267,
4269,
4271
],
[
4273
],
[
4275
],
[
4277
],
[
4279
],
[
4281
],
[
4283
],
[
4285
],
[
4287
],
[
4289,
4291,
4293,
4295
],
[
4297
],
[
4299,
4301
],
[
4303,
4305
],
[
4307,
4309
],
[
4311
],
[
4313
],
[
4315,
4317
],
[
4319
],
[
4321
],
[
4323,
4325
],
[
4327
],
[
4329
],
[
4331
],
[
4333,
4335,
4337,
4339
],
[
4341
],
[
4343,
4345
],
[
4347,
4349
],
[
4351
],
[
4353
],
[
4355,
4357
],
[
4359,
4361
],
[
4363,
4365
],
[
4367
],
[
4369
],
[
4371,
4373,
4375,
4377
],
[
4379
],
[
4381
],
[
4383
],
[
4385
],
[
4387
],
[
4389
],
[
4391
],
[
4393,
4395
],
[
4397
],
[
4399
],
[
4401
],
[
4403
],
[
4405
],
[
4407
],
[
4409
],
[
4411
],
[
4413
],
[
4415,
4417
],
[
4419
],
[
4421
],
[
4423,
4425
],
[
4427
],
[
4429
],
[
4431
],
[
4433
],
[
4435
],
[
4437
],
[
4439
],
[
4441
],
[
4443,
4445
],
[
4447
],
[
4449
],
[
4451,
4453
],
[
4455
],
[
4457
],
[
4459
],
[
4461
],
[
4463
],
[
4465
],
[
4467,
4469
],
[
4471
],
[
4473
],
[
4475,
4477,
4479
],
[
4481
],
[
4483
],
[
4487
],
[
4489
],
[
4491,
4493,
4495
],
[
4497
],
[
4499
],
[
4501
],
[
4503
],
[
4505
],
[
4507
],
[
4509
],
[
4511
],
[
4513
],
[
4515
],
[
4517
],
[
4519,
4521
],
[
4523
],
[
4525
],
[
4527
],
[
4529
],
[
4531
],
[
4533
],
[
4535
],
[
4537
],
[
4539
],
[
4541,
4543,
4545,
4547
],
[
4549
],
[
4551
],
[
4553
],
[
4555
],
[
4557
],
[
4559,
4561
],
[
4563,
4565
],
[
4567,
4569
],
[
4571
],
[
4573
],
[
4575
],
[
4577,
4579
],
[
4581
],
[
4583
],
[
4585
],
[
4587,
4589,
4591,
4593,
4595,
4597
],
[
4599
],
[
4603
],
[
4605,
4607
],
[
4609
],
[
4611
],
[
4613,
4615,
4617
],
[
4619
],
[
4621
],
[
4623
],
[
4625,
4627
],
[
4629
],
[
4631
],
[
4633
],
[
4635,
4637,
4639,
4641,
4643
],
[
4645
],
[
4647
],
[
4649
],
[
4651
],
[
4653
],
[
4655
],
[
4657
],
[
4659
],
[
4661
],
[
4663,
4665
],
[
4667
],
[
4669
],
[
4671
],
[
4673,
4675,
4677
],
[
4679
],
[
4681
],
[
4683
],
[
4685,
4687
],
[
4689
],
[
4691
],
[
4695,
4697
],
[
4699
],
[
4701
],
[
4703
],
[
4705
],
[
4707
],
[
4709
],
[
4711
],
[
4713
],
[
4715
],
[
4717
],
[
4719
],
[
4721,
4723
],
[
4725
],
[
4727
],
[
4729
],
[
4733
],
[
4735
],
[
4737
],
[
4739
],
[
4741,
4743
],
[
4745
],
[
4749,
4751
],
[
4753
],
[
4755,
4757,
4759
],
[
4763
],
[
4765
],
[
4767
]
] |
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 < 2 && !VAR_1)\nbreak;",
"ogg_write_page(VAR_0, &p->page,\nVAR_1 && oggstream->page_count == 1 ? 4 : 0);",
"next = p->next;",
"av_freep(&p);",
"p = next;",
"}",
"ogg->page_list = p;",
"}"
] | [
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 < 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];",
"}"
] | [
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
],
[
43
],
[
45
]
] |
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->opaque, VAR_1, VAR_2);",
"return;",
"}",
"access_with_adjusted_size(VAR_1, &VAR_2, VAR_3,\nVAR_0->ops->impl.min_access_size,\nVAR_0->ops->impl.max_access_size,\nmemory_region_write_accessor, 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;",
"}",
"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;",
"}"
] | [
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
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
77
],
[
81
],
[
83
]
] |
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(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\",\nVAR_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\",\nVAR_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)\nuse_delta_flag = get_bits1(VAR_0);",
"if (used || use_delta_flag) {",
"if (VAR_9 < VAR_10->num_delta_pocs)\nVAR_5 = VAR_11 + VAR_10->VAR_5[VAR_9];",
"else\nVAR_5 = VAR_11;",
"VAR_2->VAR_5[VAR_8] = VAR_5;",
"if (VAR_5 < 0)\nVAR_6++;",
"else\nVAR_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 ||\nnb_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;"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
23
],
[
24
],
[
25
],
[
26
],
[
27
],
[
28
],
[
29
],
[
30,
31
],
[
32
],
[
33
],
[
34
],
[
35,
36
],
[
37
],
[
38,
39
],
[
40,
41
],
[
42
],
[
43,
44
],
[
45,
46
],
[
47
],
[
48
],
[
49
],
[
51
],
[
52
],
[
53
],
[
54
],
[
55
],
[
56
],
[
57
],
[
58
],
[
59
],
[
60
],
[
61
],
[
62
],
[
63
],
[
64
],
[
65
],
[
67
],
[
68
],
[
69
],
[
70
],
[
71
],
[
72
],
[
73
],
[
74
],
[
75
],
[
76
],
[
77
],
[
78
],
[
79,
80
],
[
81
],
[
82
],
[
83
],
[
84
],
[
85
],
[
86
],
[
87
],
[
88
],
[
89
],
[
90
],
[
91
],
[
92
],
[
93
],
[
94
],
[
95
],
[
96
]
] |
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);",
"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);",
"}"
] | [
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
],
[
45
],
[
47
],
[
49
]
] |
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 = VAR_0->nwindows - 2;",
"VAR_0->pstate = PS_RMO | PS_PEF | PS_IE;",
"VAR_0->asi = 0x82;",
"#endif\n#else\nVAR_0->psret = 0;",
"VAR_0->psrs = 1;",
"VAR_0->psrps = 1;",
"#ifdef TARGET_SPARC64\nVAR_0->pstate = PS_PRIV;",
"VAR_0->hpstate = HS_PRIV;",
"VAR_0->pc = 0x1fff0000020ULL;",
"VAR_0->tsptr = &VAR_0->ts[VAR_0->tl];",
"#else\nVAR_0->pc = 0;",
"VAR_0->mmuregs[0] &= ~(MMU_E | MMU_NF);",
"VAR_0->mmuregs[0] |= VAR_0->mmu_bm;",
"#endif\nVAR_0->npc = VAR_0->pc + 4;",
"#endif\n}"
] | [
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,
49
],
[
51
],
[
53
],
[
55,
57
],
[
59,
61
]
] |
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)) {",
"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);",
"}",
"}"
] | [
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
],
[
51
],
[
53
]
] |
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[(VAR_1*3 + VAR_4 + (VAR_2*3 + VAR_5) * 128*3) * 4 + 1] =\nscale_lcd_color(VAR_3 >> 8);",
"VAR_0->ds->data[(VAR_1*3 + VAR_4 + (VAR_2*3 + VAR_5) * 128*3) * 4 + 2] =\nscale_lcd_color(VAR_3 >> 16);",
"}",
"}"
] | [
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[VAR_0]);",
"}",
"return VAR_1;",
"}"
] | [
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_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));",
"}"
] | [
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_PTC);",
"if (!VAR_0->user_mode_only)\nVAR_0->mvp->CP0_MVPConf0 |= (VAR_0->tlb->nb_tlb << CP0MVPC0_PTLBE);",
"VAR_0->mvp->CP0_MVPConf1 = (1 << CP0MVPC1_CIM) | (1 << CP0MVPC1_CIF) |\n(0x0 << CP0MVPC1_PCX) | (0x0 << CP0MVPC1_PCP2) |\n(0x1 << CP0MVPC1_PCP1);",
"}"
] | [
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 *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,\nVAR_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 ||\n(strcmp(VAR_6, \"FLAT\") && strcmp(VAR_6, \"SPARSE\") &&\nstrcmp(VAR_6, \"VMFS\") && strcmp(VAR_6, \"VMFSSPARSE\")) ||\n(strcmp(VAR_5, \"RW\"))) {",
"goto next_line;",
"}",
"path_combine(VAR_9, sizeof(VAR_9),\nVAR_2, VAR_7);",
"VAR_4 = bdrv_file_open(&extent_file, VAR_9, NULL, VAR_1->open_flags,\nVAR_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,\n0, 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:\nwhile (*VAR_8) {",
"if (*VAR_8 == '\\n') {",
"VAR_8++;",
"break;",
"}",
"VAR_8++;",
"}",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
77,
79,
81,
83
],
[
85
],
[
87
],
[
91,
93
],
[
95,
97
],
[
99
],
[
101
],
[
103
],
[
109
],
[
115,
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153,
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
]
] |
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 = 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\nfor (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)\n| env->DBAT[1][VAR_2];",
"VAR_1.u.s.ppc32.ibat[VAR_2] = ((uint64_t)env->IBAT[0][VAR_2] << 32)\n| env->IBAT[1][VAR_2];",
"}",
"return kvm_vcpu_ioctl(CPU(VAR_0), KVM_SET_SREGS, &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,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
17
],
[
23,
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39,
45
],
[
47
],
[
49
],
[
55
],
[
59,
61
],
[
63,
65
],
[
67
],
[
71
],
[
73
]
] |
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, VAR_0->pc + VAR_4, 1);",
"}"
] | [
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) -1) {",
"pkt->payload_len = payload_len;",
"return true;",
"} else {",
"return false;",
"}",
"}"
] | [
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:\ndiff = 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:\ndiff = 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:\nVAR_4->func_mux_ctrl[VAR_1 >> 2] = VAR_2;",
"return;",
"case 0x0c:\nVAR_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:\ncase 0x14:\ncase 0x18:\ncase 0x1c:\ncase 0x20:\ncase 0x24:\ncase 0x28:\ncase 0x2c:\ncase 0x30:\ncase 0x34:\ncase 0x38:\nVAR_4->func_mux_ctrl[(VAR_1 >> 2) - 1] = VAR_2;",
"return;",
"case 0x40:\ncase 0x44:\ncase 0x48:\ncase 0x4c:\nVAR_4->pull_dwn_ctrl[(VAR_1 & 0xf) >> 2] = VAR_2;",
"return;",
"case 0x50:\nVAR_4->gate_inh_ctrl[0] = VAR_2;",
"return;",
"case 0x60:\nVAR_4->voltage_ctrl[0] = VAR_2;",
"return;",
"case 0x70:\nVAR_4->test_dbg_ctrl[0] = VAR_2;",
"return;",
"case 0x80:\ndiff = 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:\nOMAP_BAD_REG(VAR_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
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23,
25
],
[
27
],
[
29
],
[
31
],
[
35,
37
],
[
39
],
[
41
],
[
43
],
[
47,
49
],
[
51
],
[
55,
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
69,
71,
73,
75,
77,
79,
81,
83,
85,
87,
89,
91
],
[
93
],
[
97,
99,
101,
103,
105
],
[
107
],
[
111,
113
],
[
115
],
[
119,
121
],
[
123
],
[
127,
129
],
[
131
],
[
135,
137
],
[
139
],
[
141
],
[
143
],
[
147,
149
],
[
151
],
[
153
]
] |
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 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 == ',')\nfilename++;",
"}",
"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)\nreturn NULL;",
"dev = usb_create(bus, \"usb-serial\");",
"qdev_prop_set_chr(&dev->qdev, \"chardev\", cdrv);",
"return dev;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
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
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
59
],
[
61
],
[
63,
65
],
[
69
],
[
71
],
[
75
],
[
77
]
] |
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;",
"}",
"if (sch->thinint_active) {",
"uint64_t ind_bit = dev->routes.adapter.ind_offset;",
"virtio_set_ind_atomic(sch, dev->indicators->addr +\n(ind_bit + VAR_1) / 8,\n0x80 >> ((ind_bit + VAR_1) % 8));",
"if (!virtio_set_ind_atomic(sch, dev->summary_indicator->addr,\n0x01)) {",
"css_adapter_interrupt(dev->thinint_isc);",
"}",
"} else {",
"indicators = address_space_ldq(&address_space_memory,\ndev->indicators->addr,\nMEMTXATTRS_UNSPECIFIED,\nNULL);",
"indicators |= 1ULL << VAR_1;",
"address_space_stq(&address_space_memory, dev->indicators->addr,\nindicators, MEMTXATTRS_UNSPECIFIED, NULL);",
"css_conditional_io_interrupt(sch);",
"}",
"} else {",
"if (!dev->indicators2) {",
"return;",
"}",
"VAR_1 = 0;",
"indicators = address_space_ldq(&address_space_memory,\ndev->indicators2->addr,\nMEMTXATTRS_UNSPECIFIED,\nNULL);",
"indicators |= 1ULL << VAR_1;",
"address_space_stq(&address_space_memory, dev->indicators2->addr,\nindicators, MEMTXATTRS_UNSPECIFIED, NULL);",
"css_conditional_io_interrupt(sch);",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
63,
65,
67,
69
],
[
71
],
[
73,
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91,
93,
95,
97
],
[
99
],
[
101,
103
],
[
105
],
[
107
],
[
109
]
] |
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_32bit = 0;",
"env->segs[VAR_1] = VAR_2;",
"} else {",
"load_seg(VAR_1, VAR_2, 0);",
"}",
"env = saved_env;",
"}"
] | [
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);",
"} else if (s->num_pio) {",
"snprintf(VAR_1 + VAR_2, sizeof(VAR_1) - VAR_2, \"@i%04x\", s->pio[0]);",
"}",
"return strdup(VAR_1);",
"}"
] | [
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;",
"if (value) {",
"switch (value->kind) {",
"case MEMORY_DEVICE_INFO_KIND_DIMM:\ndi = value->dimm;",
"monitor_printf(VAR_0, \"Memory device [%s]: \\\"%s\\\"\\n\",\nMemoryDeviceInfoKind_lookup[value->kind],\ndi->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\",\ndi->hotplugged ? \"true\" : \"false\");",
"monitor_printf(VAR_0, \" hotpluggable: %s\\n\",\ndi->hotpluggable ? \"true\" : \"false\");",
"break;",
"default:\nbreak;",
"}",
"}",
"}",
"qapi_free_MemoryDeviceInfoList(info_list);",
"}"
] | [
0,
0,
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
],
[
53,
55
],
[
57
],
[
59,
61
],
[
63
],
[
65
],
[
67
],
[
71
],
[
73
]
] |
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 (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;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
47
],
[
49
],
[
53
],
[
55
],
[
57
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
]
] |
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;",
"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,\nVAR_14, VAR_0->VAR_6 - (VAR_14 - VAR_0->buf) );",
"if (VAR_17[0] == 2)\nxan_unpack(VAR_0->buffer2, &VAR_17[1], VAR_0->buffer2_size);",
"else\nVAR_13 = &VAR_17[1];",
"VAR_9 = VAR_10 = 0;",
"while (VAR_3) {",
"VAR_4 = *VAR_11++;",
"VAR_6 = 0;",
"switch (VAR_4) {",
"case 0:\nVAR_5 ^= 1;",
"continue;",
"case 1:\ncase 2:\ncase 3:\ncase 4:\ncase 5:\ncase 6:\ncase 7:\ncase 8:\nVAR_6 = VAR_4;",
"break;",
"case 12:\ncase 13:\ncase 14:\ncase 15:\ncase 16:\ncase 17:\ncase 18:\nVAR_6 += (VAR_4 - 10);",
"break;",
"case 9:\ncase 19:\nVAR_6 = *VAR_15++;",
"break;",
"case 10:\ncase 20:\nVAR_6 = AV_RB16(&VAR_15[0]);",
"VAR_15 += 2;",
"break;",
"case 11:\ncase 21:\nVAR_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;",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
53,
55
],
[
59,
61
],
[
63,
65
],
[
71
],
[
73
],
[
77
],
[
79
],
[
83
],
[
87,
89
],
[
91
],
[
95,
97,
99,
101,
103,
105,
107,
109,
111
],
[
113
],
[
117,
119,
121,
123,
125,
127,
129,
131
],
[
133
],
[
137,
139,
141
],
[
143
],
[
147,
149,
151
],
[
153
],
[
155
],
[
159,
161,
163
],
[
165
],
[
167
],
[
169
],
[
173
],
[
175
],
[
177
],
[
181
],
[
183
],
[
187
],
[
189
],
[
191
],
[
193
],
[
197
],
[
199
],
[
201
],
[
207
],
[
211
],
[
213
],
[
219
],
[
221
],
[
223
],
[
225
],
[
227
]
] |
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_malloc0(VAR_3);",
"(*VAR_2)->type = qobject_type(qobj);",
"if (VAR_4 && (*VAR_2)->type == QTYPE_QINT) {",
"(*VAR_2)->type = QTYPE_QFLOAT;",
"}",
"}"
] | [
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) {",
"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:\ncase R_U_CTRL:\ns->regs[VAR_1] = VAR_2;",
"update_voices(s);",
"break;",
"case R_AC97_ADDR:\ncase R_AC97_DATAOUT:\ncase R_AC97_DATAIN:\ncase R_D_ADDR:\ncase R_D_REMAINING:\ncase R_U_ADDR:\ncase R_U_REMAINING:\ns->regs[VAR_1] = VAR_2;",
"break;",
"default:\nerror_report(\"milkymist_ac97: write access to unknown register 0x\"\nTARGET_FMT_plx, VAR_1);",
"break;",
"}",
"}"
] | [
0,
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
],
[
57
],
[
59,
61,
63,
65,
67,
69,
71,
73
],
[
75
],
[
79,
81,
83
],
[
85
],
[
87
],
[
91
]
] |
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, 0xa0000, 0x20000);",
"memory_region_add_subregion_overlap(mch->system_memory, 0xa0000,\n&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\",\nmch->ram_memory, 0xa0000, 0x20000);",
"memory_region_add_subregion_overlap(mch->system_memory, 0xfeda0000,\n&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\",\nmch->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\",\nmch->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),\n&tseg_blackhole_ops, NULL,\n\"tseg-blackhole\", 0);",
"memory_region_set_enabled(&mch->tseg_blackhole, false);",
"memory_region_add_subregion_overlap(mch->system_memory,\nmch->below_4g_mem_size,\n&mch->tseg_blackhole, 1);",
"memory_region_init_alias(&mch->tseg_window, OBJECT(mch), \"tseg-window\",\nmch->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,\n&mch->tseg_window);",
"object_property_add_const_link(qdev_get_machine(), \"smram\",\nOBJECT(&mch->smram), &error_abort);",
"init_pam(DEVICE(mch), mch->ram_memory, mch->system_memory,\nmch->pci_address_space, &mch->pam_regions[0],\nPAM_BIOS_BASE, PAM_BIOS_SIZE);",
"for (VAR_2 = 0; VAR_2 < 12; ++VAR_2) {",
"init_pam(DEVICE(mch), mch->ram_memory, mch->system_memory,\nmch->pci_address_space, &mch->pam_regions[VAR_2+1],\nPAM_EXPAN_BASE + VAR_2 * PAM_EXPAN_SIZE, PAM_EXPAN_SIZE);",
"}",
"if (machine_iommu(current_machine)) {",
"mch_init_dmar(mch);",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
63
],
[
65
],
[
69,
71,
73
],
[
75
],
[
77,
79,
81
],
[
85,
87
],
[
89
],
[
91,
93
],
[
95,
97
],
[
101,
103,
105
],
[
107
],
[
109,
111,
113
],
[
115
],
[
119
],
[
121
],
[
123
],
[
125
]
] |
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;",
"return;",
"}",
"#endif\nif (dc->ss_active && !dc->pstate_ss) {",
"assert(dc->base.num_insns == 1);",
"gen_exception(EXCP_UDEF, syn_swstep(dc->ss_same_el, 0, 0),\ndefault_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)\n| ((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 ||\n(dc->pc >= dc->next_page_start - 3 &&\ninsn_crosses_page(env, dc))) {",
"dc->base.is_jmp = DISAS_TOO_MANY;",
"}",
"}",
"dc->base.pc_next = dc->pc;",
"translator_loop_temp_check(&dc->base);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
101
],
[
103
],
[
105
],
[
107
],
[
111
],
[
123,
125,
127
],
[
147
],
[
149
],
[
151
],
[
155
],
[
157
],
[
159
]
] |
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_1, 0);",
"if (VAR_0->id_tlbs == 1) {",
"ppc6xx_tlb_invalidate_virt(VAR_0, VAR_1, 1);",
"}",
"break;",
"case POWERPC_MMU_SOFT_4xx:\ncase POWERPC_MMU_SOFT_4xx_Z:\nppc4xx_tlb_invalidate_virt(VAR_0, VAR_1, VAR_0->spr[SPR_40x_PID]);",
"break;",
"case POWERPC_MMU_REAL:\ncpu_abort(CPU(cpu), \"No TLB for PowerPC 4xx in real mode\\n\");",
"break;",
"case POWERPC_MMU_MPC8xx:\ncpu_abort(CPU(cpu), \"MPC8xx MMU model is not implemented\\n\");",
"break;",
"case POWERPC_MMU_BOOKE:\ncpu_abort(CPU(cpu), \"BookE MMU model is not implemented\\n\");",
"break;",
"case POWERPC_MMU_BOOKE206:\ncpu_abort(CPU(cpu), \"BookE 2.06 MMU model is not implemented\\n\");",
"break;",
"case POWERPC_MMU_32B:\ncase POWERPC_MMU_601:\nVAR_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)\ncase POWERPC_MMU_64B:\ncase POWERPC_MMU_2_03:\ncase POWERPC_MMU_2_06:\ncase POWERPC_MMU_2_06a:\ncase POWERPC_MMU_2_07:\ncase POWERPC_MMU_2_07a:\ntlb_flush(CPU(cpu), 1);",
"break;",
"#endif\ndefault:\ncpu_abort(CPU(cpu), \"Unknown MMU model\\n\");",
"break;",
"}",
"#else\nppc_tlb_invalidate_all(VAR_0);",
"#endif\n}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
53,
57
],
[
59
],
[
61,
65
],
[
67
],
[
69,
71,
75
],
[
77
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119,
121,
123,
125,
127,
129,
131,
143
],
[
145
],
[
147,
149,
153
],
[
155
],
[
157
],
[
159,
161
],
[
163,
165
]
] |
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);",
"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,\ndev);",
"}",
"if (bus->info->hotplug) {",
"bus->info->hotplug(bus, dev);",
"}",
"err:\nreturn VAR_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,
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
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
105
],
[
107
],
[
109
],
[
111,
113
],
[
115
],
[
119
],
[
121
],
[
123
],
[
127,
129
],
[
131
]
] |
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) {",
"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;",
"}"
] | [
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
],
[
47
],
[
49
],
[
51
],
[
53
]
] |
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_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\");",
"}",
"}",
"}",
"}"
] | [
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
],
[
45
],
[
47
],
[
49
]
] |
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]) {",
"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:\nif (error != NULL) {",
"error_propagate(errp, error);",
"if (cpu) {",
"object_unref(OBJECT(cpu));",
"cpu = NULL;",
"}",
"}",
"g_strfreev(model_pieces);",
"return cpu;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
47
],
[
49
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65,
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
]
] |
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 / object_size,\nVAR_5 = DIV_ROUND_UP((VAR_1 + VAR_2) *\nBDRV_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;",
"}"
] | [
0,
0,
0,
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
],
[
49
],
[
51
],
[
53
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
]
] |