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
|
|---|---|---|---|---|---|---|---|---|---|---|
23,985 | static void check_suspend_mode(GuestSuspendMode mode, Error **errp)
{
SYSTEM_POWER_CAPABILITIES sys_pwr_caps;
Error *local_err = NULL;
if (error_is_set(errp)) {
return;
}
ZeroMemory(&sys_pwr_caps, sizeof(sys_pwr_caps));
if (!GetPwrCapabilities(&sys_pwr_caps)) {
error_set(&local_err, QERR_QGA_COMMAND_FAILED,
"failed to determine guest suspend capabilities");
goto out;
}
switch (mode) {
case GUEST_SUSPEND_MODE_DISK:
if (!sys_pwr_caps.SystemS4) {
error_set(&local_err, QERR_QGA_COMMAND_FAILED,
"suspend-to-disk not supported by OS");
}
break;
case GUEST_SUSPEND_MODE_RAM:
if (!sys_pwr_caps.SystemS3) {
error_set(&local_err, QERR_QGA_COMMAND_FAILED,
"suspend-to-ram not supported by OS");
}
break;
default:
error_set(&local_err, QERR_INVALID_PARAMETER_VALUE, "mode",
"GuestSuspendMode");
}
out:
if (local_err) {
error_propagate(errp, local_err);
}
}
| true | qemu | 5e54769c921a3d8cd8858444f5a3fa62cc44260e | static void check_suspend_mode(GuestSuspendMode mode, Error **errp)
{
SYSTEM_POWER_CAPABILITIES sys_pwr_caps;
Error *local_err = NULL;
if (error_is_set(errp)) {
return;
}
ZeroMemory(&sys_pwr_caps, sizeof(sys_pwr_caps));
if (!GetPwrCapabilities(&sys_pwr_caps)) {
error_set(&local_err, QERR_QGA_COMMAND_FAILED,
"failed to determine guest suspend capabilities");
goto out;
}
switch (mode) {
case GUEST_SUSPEND_MODE_DISK:
if (!sys_pwr_caps.SystemS4) {
error_set(&local_err, QERR_QGA_COMMAND_FAILED,
"suspend-to-disk not supported by OS");
}
break;
case GUEST_SUSPEND_MODE_RAM:
if (!sys_pwr_caps.SystemS3) {
error_set(&local_err, QERR_QGA_COMMAND_FAILED,
"suspend-to-ram not supported by OS");
}
break;
default:
error_set(&local_err, QERR_INVALID_PARAMETER_VALUE, "mode",
"GuestSuspendMode");
}
out:
if (local_err) {
error_propagate(errp, local_err);
}
}
| {
"code": [
" if (error_is_set(errp)) {",
" if (error_is_set(errp)) {",
" if (error_is_set(errp)) {"
],
"line_no": [
11,
11,
11
]
} | static void FUNC_0(GuestSuspendMode VAR_0, Error **VAR_1)
{
SYSTEM_POWER_CAPABILITIES sys_pwr_caps;
Error *local_err = NULL;
if (error_is_set(VAR_1)) {
return;
}
ZeroMemory(&sys_pwr_caps, sizeof(sys_pwr_caps));
if (!GetPwrCapabilities(&sys_pwr_caps)) {
error_set(&local_err, QERR_QGA_COMMAND_FAILED,
"failed to determine guest suspend capabilities");
goto out;
}
switch (VAR_0) {
case GUEST_SUSPEND_MODE_DISK:
if (!sys_pwr_caps.SystemS4) {
error_set(&local_err, QERR_QGA_COMMAND_FAILED,
"suspend-to-disk not supported by OS");
}
break;
case GUEST_SUSPEND_MODE_RAM:
if (!sys_pwr_caps.SystemS3) {
error_set(&local_err, QERR_QGA_COMMAND_FAILED,
"suspend-to-ram not supported by OS");
}
break;
default:
error_set(&local_err, QERR_INVALID_PARAMETER_VALUE, "VAR_0",
"GuestSuspendMode");
}
out:
if (local_err) {
error_propagate(VAR_1, local_err);
}
}
| [
"static void FUNC_0(GuestSuspendMode VAR_0, Error **VAR_1)\n{",
"SYSTEM_POWER_CAPABILITIES sys_pwr_caps;",
"Error *local_err = NULL;",
"if (error_is_set(VAR_1)) {",
"return;",
"}",
"ZeroMemory(&sys_pwr_caps, sizeof(sys_pwr_caps));",
"if (!GetPwrCapabilities(&sys_pwr_caps)) {",
"error_set(&local_err, QERR_QGA_COMMAND_FAILED,\n\"failed to determine guest suspend capabilities\");",
"goto out;",
"}",
"switch (VAR_0) {",
"case GUEST_SUSPEND_MODE_DISK:\nif (!sys_pwr_caps.SystemS4) {",
"error_set(&local_err, QERR_QGA_COMMAND_FAILED,\n\"suspend-to-disk not supported by OS\");",
"}",
"break;",
"case GUEST_SUSPEND_MODE_RAM:\nif (!sys_pwr_caps.SystemS3) {",
"error_set(&local_err, QERR_QGA_COMMAND_FAILED,\n\"suspend-to-ram not supported by OS\");",
"}",
"break;",
"default:\nerror_set(&local_err, QERR_INVALID_PARAMETER_VALUE, \"VAR_0\",\n\"GuestSuspendMode\");",
"}",
"out:\nif (local_err) {",
"error_propagate(VAR_1, local_err);",
"}",
"}"
] | [
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
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21,
23
],
[
25
],
[
27
],
[
31
],
[
33,
35
],
[
37,
39
],
[
41
],
[
43
],
[
45,
47
],
[
49,
51
],
[
53
],
[
55
],
[
57,
59,
61
],
[
63
],
[
67,
69
],
[
71
],
[
73
],
[
75
]
] |
23,986 | static gint range_compare(gconstpointer a, gconstpointer b)
{
Range *ra = (Range *)a, *rb = (Range *)b;
if (ra->begin == rb->begin && ra->end == rb->end) {
return 0;
} else if (range_get_last(ra->begin, ra->end) <
range_get_last(rb->begin, rb->end)) {
return -1;
} else {
return 1;
}
}
| true | qemu | db486cc334aafd3dbdaf107388e37fc3d6d3e171 | static gint range_compare(gconstpointer a, gconstpointer b)
{
Range *ra = (Range *)a, *rb = (Range *)b;
if (ra->begin == rb->begin && ra->end == rb->end) {
return 0;
} else if (range_get_last(ra->begin, ra->end) <
range_get_last(rb->begin, rb->end)) {
return -1;
} else {
return 1;
}
}
| {
"code": [
"static gint range_compare(gconstpointer a, gconstpointer b)",
" Range *ra = (Range *)a, *rb = (Range *)b;",
" if (ra->begin == rb->begin && ra->end == rb->end) {",
" return 0;",
" } else if (range_get_last(ra->begin, ra->end) <",
" range_get_last(rb->begin, rb->end)) {",
" } else {"
],
"line_no": [
1,
5,
7,
9,
11,
13,
17
]
} | static gint FUNC_0(gconstpointer a, gconstpointer b)
{
Range *ra = (Range *)a, *rb = (Range *)b;
if (ra->begin == rb->begin && ra->end == rb->end) {
return 0;
} else if (range_get_last(ra->begin, ra->end) <
range_get_last(rb->begin, rb->end)) {
return -1;
} else {
return 1;
}
}
| [
"static gint FUNC_0(gconstpointer a, gconstpointer b)\n{",
"Range *ra = (Range *)a, *rb = (Range *)b;",
"if (ra->begin == rb->begin && ra->end == rb->end) {",
"return 0;",
"} else if (range_get_last(ra->begin, ra->end) <",
"range_get_last(rb->begin, rb->end)) {",
"return -1;",
"} else {",
"return 1;",
"}",
"}"
] | [
1,
1,
1,
1,
1,
1,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
]
] |
23,987 | static void report_unsupported_feature(BlockDriverState *bs,
Error **errp, Qcow2Feature *table, uint64_t mask)
{
while (table && table->name[0] != '\0') {
if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) {
if (mask & (1 << table->bit)) {
report_unsupported(bs, errp, "%.46s", table->name);
mask &= ~(1 << table->bit);
}
}
table++;
}
if (mask) {
report_unsupported(bs, errp, "Unknown incompatible feature: %" PRIx64,
mask);
}
}
| true | qemu | 12ac6d3db721a288c8953c5c253230aa0949a0e1 | static void report_unsupported_feature(BlockDriverState *bs,
Error **errp, Qcow2Feature *table, uint64_t mask)
{
while (table && table->name[0] != '\0') {
if (table->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) {
if (mask & (1 << table->bit)) {
report_unsupported(bs, errp, "%.46s", table->name);
mask &= ~(1 << table->bit);
}
}
table++;
}
if (mask) {
report_unsupported(bs, errp, "Unknown incompatible feature: %" PRIx64,
mask);
}
}
| {
"code": [
" if (mask & (1 << table->bit)) {",
" report_unsupported(bs, errp, \"%.46s\", table->name);",
" mask &= ~(1 << table->bit);",
" report_unsupported(bs, errp, \"Unknown incompatible feature: %\" PRIx64,",
" mask);"
],
"line_no": [
11,
13,
15,
29,
31
]
} | static void FUNC_0(BlockDriverState *VAR_0,
Error **VAR_1, Qcow2Feature *VAR_2, uint64_t VAR_3)
{
while (VAR_2 && VAR_2->name[0] != '\0') {
if (VAR_2->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) {
if (VAR_3 & (1 << VAR_2->bit)) {
report_unsupported(VAR_0, VAR_1, "%.46s", VAR_2->name);
VAR_3 &= ~(1 << VAR_2->bit);
}
}
VAR_2++;
}
if (VAR_3) {
report_unsupported(VAR_0, VAR_1, "Unknown incompatible feature: %" PRIx64,
VAR_3);
}
}
| [
"static void FUNC_0(BlockDriverState *VAR_0,\nError **VAR_1, Qcow2Feature *VAR_2, uint64_t VAR_3)\n{",
"while (VAR_2 && VAR_2->name[0] != '\\0') {",
"if (VAR_2->type == QCOW2_FEAT_TYPE_INCOMPATIBLE) {",
"if (VAR_3 & (1 << VAR_2->bit)) {",
"report_unsupported(VAR_0, VAR_1, \"%.46s\", VAR_2->name);",
"VAR_3 &= ~(1 << VAR_2->bit);",
"}",
"}",
"VAR_2++;",
"}",
"if (VAR_3) {",
"report_unsupported(VAR_0, VAR_1, \"Unknown incompatible feature: %\" PRIx64,\nVAR_3);",
"}",
"}"
] | [
0,
0,
0,
1,
1,
1,
0,
0,
0,
0,
0,
1,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29,
31
],
[
33
],
[
35
]
] |
23,988 | void qemu_ram_free(ram_addr_t addr)
{
RAMBlock *block;
QLIST_FOREACH(block, &ram_list.blocks, next) {
if (addr == block->offset) {
QLIST_REMOVE(block, next);
if (block->flags & RAM_PREALLOC_MASK) {
;
} else if (mem_path) {
#if defined (__linux__) && !defined(TARGET_S390X)
if (block->fd) {
munmap(block->host, block->length);
close(block->fd);
} else {
qemu_vfree(block->host);
}
#endif
} else {
#if defined(TARGET_S390X) && defined(CONFIG_KVM)
munmap(block->host, block->length);
qemu_vfree(block->host);
#endif
}
qemu_free(block);
return;
}
}
} | true | qemu | fd28aa132362320f9f3a30b23f634bb14dee528e | void qemu_ram_free(ram_addr_t addr)
{
RAMBlock *block;
QLIST_FOREACH(block, &ram_list.blocks, next) {
if (addr == block->offset) {
QLIST_REMOVE(block, next);
if (block->flags & RAM_PREALLOC_MASK) {
;
} else if (mem_path) {
#if defined (__linux__) && !defined(TARGET_S390X)
if (block->fd) {
munmap(block->host, block->length);
close(block->fd);
} else {
qemu_vfree(block->host);
}
#endif
} else {
#if defined(TARGET_S390X) && defined(CONFIG_KVM)
munmap(block->host, block->length);
qemu_vfree(block->host);
#endif
}
qemu_free(block);
return;
}
}
} | {
"code": [],
"line_no": []
} | void FUNC_0(ram_addr_t VAR_0)
{
RAMBlock *block;
QLIST_FOREACH(block, &ram_list.blocks, next) {
if (VAR_0 == block->offset) {
QLIST_REMOVE(block, next);
if (block->flags & RAM_PREALLOC_MASK) {
;
} else if (mem_path) {
#if defined (__linux__) && !defined(TARGET_S390X)
if (block->fd) {
munmap(block->host, block->length);
close(block->fd);
} else {
qemu_vfree(block->host);
}
#endif
} else {
#if defined(TARGET_S390X) && defined(CONFIG_KVM)
munmap(block->host, block->length);
qemu_vfree(block->host);
#endif
}
qemu_free(block);
return;
}
}
} | [
"void FUNC_0(ram_addr_t VAR_0)\n{",
"RAMBlock *block;",
"QLIST_FOREACH(block, &ram_list.blocks, next) {",
"if (VAR_0 == block->offset) {",
"QLIST_REMOVE(block, next);",
"if (block->flags & RAM_PREALLOC_MASK) {",
";",
"} else if (mem_path) {",
"#if defined (__linux__) && !defined(TARGET_S390X)\nif (block->fd) {",
"munmap(block->host, block->length);",
"close(block->fd);",
"} else {",
"qemu_vfree(block->host);",
"}",
"#endif\n} else {",
"#if defined(TARGET_S390X) && defined(CONFIG_KVM)\nmunmap(block->host, block->length);",
"qemu_vfree(block->host);",
"#endif\n}",
"qemu_free(block);",
"return;",
"}",
"}",
"}"
] | [
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
],
[
37,
39
],
[
41,
43
],
[
46
],
[
48,
50
],
[
52
],
[
54
],
[
56
],
[
58
],
[
62
]
] |
23,989 | static int rocker_msix_init(Rocker *r)
{
PCIDevice *dev = PCI_DEVICE(r);
int err;
err = msix_init(dev, ROCKER_MSIX_VEC_COUNT(r->fp_ports),
&r->msix_bar,
ROCKER_PCI_MSIX_BAR_IDX, ROCKER_PCI_MSIX_TABLE_OFFSET,
&r->msix_bar,
ROCKER_PCI_MSIX_BAR_IDX, ROCKER_PCI_MSIX_PBA_OFFSET,
0);
if (err) {
return err;
}
err = rocker_msix_vectors_use(r, ROCKER_MSIX_VEC_COUNT(r->fp_ports));
if (err) {
goto err_msix_vectors_use;
}
return 0;
err_msix_vectors_use:
msix_uninit(dev, &r->msix_bar, &r->msix_bar);
return err;
}
| true | qemu | ee640c625e190a0c0e6b8966adc0e4720fb75200 | static int rocker_msix_init(Rocker *r)
{
PCIDevice *dev = PCI_DEVICE(r);
int err;
err = msix_init(dev, ROCKER_MSIX_VEC_COUNT(r->fp_ports),
&r->msix_bar,
ROCKER_PCI_MSIX_BAR_IDX, ROCKER_PCI_MSIX_TABLE_OFFSET,
&r->msix_bar,
ROCKER_PCI_MSIX_BAR_IDX, ROCKER_PCI_MSIX_PBA_OFFSET,
0);
if (err) {
return err;
}
err = rocker_msix_vectors_use(r, ROCKER_MSIX_VEC_COUNT(r->fp_ports));
if (err) {
goto err_msix_vectors_use;
}
return 0;
err_msix_vectors_use:
msix_uninit(dev, &r->msix_bar, &r->msix_bar);
return err;
}
| {
"code": [
" 0);",
" 0);"
],
"line_no": [
21,
21
]
} | static int FUNC_0(Rocker *VAR_0)
{
PCIDevice *dev = PCI_DEVICE(VAR_0);
int VAR_1;
VAR_1 = msix_init(dev, ROCKER_MSIX_VEC_COUNT(VAR_0->fp_ports),
&VAR_0->msix_bar,
ROCKER_PCI_MSIX_BAR_IDX, ROCKER_PCI_MSIX_TABLE_OFFSET,
&VAR_0->msix_bar,
ROCKER_PCI_MSIX_BAR_IDX, ROCKER_PCI_MSIX_PBA_OFFSET,
0);
if (VAR_1) {
return VAR_1;
}
VAR_1 = rocker_msix_vectors_use(VAR_0, ROCKER_MSIX_VEC_COUNT(VAR_0->fp_ports));
if (VAR_1) {
goto err_msix_vectors_use;
}
return 0;
err_msix_vectors_use:
msix_uninit(dev, &VAR_0->msix_bar, &VAR_0->msix_bar);
return VAR_1;
}
| [
"static int FUNC_0(Rocker *VAR_0)\n{",
"PCIDevice *dev = PCI_DEVICE(VAR_0);",
"int VAR_1;",
"VAR_1 = msix_init(dev, ROCKER_MSIX_VEC_COUNT(VAR_0->fp_ports),\n&VAR_0->msix_bar,\nROCKER_PCI_MSIX_BAR_IDX, ROCKER_PCI_MSIX_TABLE_OFFSET,\n&VAR_0->msix_bar,\nROCKER_PCI_MSIX_BAR_IDX, ROCKER_PCI_MSIX_PBA_OFFSET,\n0);",
"if (VAR_1) {",
"return VAR_1;",
"}",
"VAR_1 = rocker_msix_vectors_use(VAR_0, ROCKER_MSIX_VEC_COUNT(VAR_0->fp_ports));",
"if (VAR_1) {",
"goto err_msix_vectors_use;",
"}",
"return 0;",
"err_msix_vectors_use:\nmsix_uninit(dev, &VAR_0->msix_bar, &VAR_0->msix_bar);",
"return VAR_1;",
"}"
] | [
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11,
13,
15,
17,
19,
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
45,
47
],
[
49
],
[
51
]
] |
23,990 | static void avc_wgt_4width_msa(uint8_t *data,
int32_t stride,
int32_t height,
int32_t log2_denom,
int32_t src_weight,
int32_t offset_in)
{
if (2 == height) {
avc_wgt_4x2_msa(data, stride, log2_denom, src_weight, offset_in);
} else {
avc_wgt_4x4multiple_msa(data, stride, height, log2_denom,
src_weight, offset_in);
}
}
| false | FFmpeg | bcd7bf7eeb09a395cc01698842d1b8be9af483fc | static void avc_wgt_4width_msa(uint8_t *data,
int32_t stride,
int32_t height,
int32_t log2_denom,
int32_t src_weight,
int32_t offset_in)
{
if (2 == height) {
avc_wgt_4x2_msa(data, stride, log2_denom, src_weight, offset_in);
} else {
avc_wgt_4x4multiple_msa(data, stride, height, log2_denom,
src_weight, offset_in);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(uint8_t *VAR_0,
int32_t VAR_1,
int32_t VAR_2,
int32_t VAR_3,
int32_t VAR_4,
int32_t VAR_5)
{
if (2 == VAR_2) {
avc_wgt_4x2_msa(VAR_0, VAR_1, VAR_3, VAR_4, VAR_5);
} else {
avc_wgt_4x4multiple_msa(VAR_0, VAR_1, VAR_2, VAR_3,
VAR_4, VAR_5);
}
}
| [
"static void FUNC_0(uint8_t *VAR_0,\nint32_t VAR_1,\nint32_t VAR_2,\nint32_t VAR_3,\nint32_t VAR_4,\nint32_t VAR_5)\n{",
"if (2 == VAR_2) {",
"avc_wgt_4x2_msa(VAR_0, VAR_1, VAR_3, VAR_4, VAR_5);",
"} else {",
"avc_wgt_4x4multiple_msa(VAR_0, VAR_1, VAR_2, VAR_3,\nVAR_4, VAR_5);",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9,
11,
13
],
[
15
],
[
17
],
[
19
],
[
21,
23
],
[
25
],
[
27
]
] |
23,991 | static void do_apply_filter(APEContext *ctx, int version, APEFilter *f,
int32_t *data, int count, int order, int fracbits)
{
int res;
int absres;
while (count--) {
/* round fixedpoint scalar product */
res = ctx->adsp.scalarproduct_and_madd_int16(f->coeffs,
f->delay - order,
f->adaptcoeffs - order,
order, APESIGN(*data));
res = (res + (1 << (fracbits - 1))) >> fracbits;
res += *data;
*data++ = res;
/* Update the output history */
*f->delay++ = av_clip_int16(res);
if (version < 3980) {
/* Version ??? to < 3.98 files (untested) */
f->adaptcoeffs[0] = (res == 0) ? 0 : ((res >> 28) & 8) - 4;
f->adaptcoeffs[-4] >>= 1;
f->adaptcoeffs[-8] >>= 1;
} else {
/* Version 3.98 and later files */
/* Update the adaption coefficients */
absres = FFABS(res);
if (absres)
*f->adaptcoeffs = ((res & (-1<<31)) ^ (-1<<30)) >>
(25 + (absres <= f->avg*3) + (absres <= f->avg*4/3));
else
*f->adaptcoeffs = 0;
f->avg += (absres - f->avg) / 16;
f->adaptcoeffs[-1] >>= 1;
f->adaptcoeffs[-2] >>= 1;
f->adaptcoeffs[-8] >>= 1;
}
f->adaptcoeffs++;
/* Have we filled the history buffer? */
if (f->delay == f->historybuffer + HISTORY_SIZE + (order * 2)) {
memmove(f->historybuffer, f->delay - (order * 2),
(order * 2) * sizeof(*f->historybuffer));
f->delay = f->historybuffer + order * 2;
f->adaptcoeffs = f->historybuffer + order;
}
}
}
| false | FFmpeg | d3e5fbb1406995e07fccbff3ca8c1e24f57a1f7b | static void do_apply_filter(APEContext *ctx, int version, APEFilter *f,
int32_t *data, int count, int order, int fracbits)
{
int res;
int absres;
while (count--) {
res = ctx->adsp.scalarproduct_and_madd_int16(f->coeffs,
f->delay - order,
f->adaptcoeffs - order,
order, APESIGN(*data));
res = (res + (1 << (fracbits - 1))) >> fracbits;
res += *data;
*data++ = res;
*f->delay++ = av_clip_int16(res);
if (version < 3980) {
f->adaptcoeffs[0] = (res == 0) ? 0 : ((res >> 28) & 8) - 4;
f->adaptcoeffs[-4] >>= 1;
f->adaptcoeffs[-8] >>= 1;
} else {
absres = FFABS(res);
if (absres)
*f->adaptcoeffs = ((res & (-1<<31)) ^ (-1<<30)) >>
(25 + (absres <= f->avg*3) + (absres <= f->avg*4/3));
else
*f->adaptcoeffs = 0;
f->avg += (absres - f->avg) / 16;
f->adaptcoeffs[-1] >>= 1;
f->adaptcoeffs[-2] >>= 1;
f->adaptcoeffs[-8] >>= 1;
}
f->adaptcoeffs++;
if (f->delay == f->historybuffer + HISTORY_SIZE + (order * 2)) {
memmove(f->historybuffer, f->delay - (order * 2),
(order * 2) * sizeof(*f->historybuffer));
f->delay = f->historybuffer + order * 2;
f->adaptcoeffs = f->historybuffer + order;
}
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(APEContext *VAR_0, int VAR_1, APEFilter *VAR_2,
int32_t *VAR_3, int VAR_4, int VAR_5, int VAR_6)
{
int VAR_7;
int VAR_8;
while (VAR_4--) {
VAR_7 = VAR_0->adsp.scalarproduct_and_madd_int16(VAR_2->coeffs,
VAR_2->delay - VAR_5,
VAR_2->adaptcoeffs - VAR_5,
VAR_5, APESIGN(*VAR_3));
VAR_7 = (VAR_7 + (1 << (VAR_6 - 1))) >> VAR_6;
VAR_7 += *VAR_3;
*VAR_3++ = VAR_7;
*VAR_2->delay++ = av_clip_int16(VAR_7);
if (VAR_1 < 3980) {
VAR_2->adaptcoeffs[0] = (VAR_7 == 0) ? 0 : ((VAR_7 >> 28) & 8) - 4;
VAR_2->adaptcoeffs[-4] >>= 1;
VAR_2->adaptcoeffs[-8] >>= 1;
} else {
VAR_8 = FFABS(VAR_7);
if (VAR_8)
*VAR_2->adaptcoeffs = ((VAR_7 & (-1<<31)) ^ (-1<<30)) >>
(25 + (VAR_8 <= VAR_2->avg*3) + (VAR_8 <= VAR_2->avg*4/3));
else
*VAR_2->adaptcoeffs = 0;
VAR_2->avg += (VAR_8 - VAR_2->avg) / 16;
VAR_2->adaptcoeffs[-1] >>= 1;
VAR_2->adaptcoeffs[-2] >>= 1;
VAR_2->adaptcoeffs[-8] >>= 1;
}
VAR_2->adaptcoeffs++;
if (VAR_2->delay == VAR_2->historybuffer + HISTORY_SIZE + (VAR_5 * 2)) {
memmove(VAR_2->historybuffer, VAR_2->delay - (VAR_5 * 2),
(VAR_5 * 2) * sizeof(*VAR_2->historybuffer));
VAR_2->delay = VAR_2->historybuffer + VAR_5 * 2;
VAR_2->adaptcoeffs = VAR_2->historybuffer + VAR_5;
}
}
}
| [
"static void FUNC_0(APEContext *VAR_0, int VAR_1, APEFilter *VAR_2,\nint32_t *VAR_3, int VAR_4, int VAR_5, int VAR_6)\n{",
"int VAR_7;",
"int VAR_8;",
"while (VAR_4--) {",
"VAR_7 = VAR_0->adsp.scalarproduct_and_madd_int16(VAR_2->coeffs,\nVAR_2->delay - VAR_5,\nVAR_2->adaptcoeffs - VAR_5,\nVAR_5, APESIGN(*VAR_3));",
"VAR_7 = (VAR_7 + (1 << (VAR_6 - 1))) >> VAR_6;",
"VAR_7 += *VAR_3;",
"*VAR_3++ = VAR_7;",
"*VAR_2->delay++ = av_clip_int16(VAR_7);",
"if (VAR_1 < 3980) {",
"VAR_2->adaptcoeffs[0] = (VAR_7 == 0) ? 0 : ((VAR_7 >> 28) & 8) - 4;",
"VAR_2->adaptcoeffs[-4] >>= 1;",
"VAR_2->adaptcoeffs[-8] >>= 1;",
"} else {",
"VAR_8 = FFABS(VAR_7);",
"if (VAR_8)\n*VAR_2->adaptcoeffs = ((VAR_7 & (-1<<31)) ^ (-1<<30)) >>\n(25 + (VAR_8 <= VAR_2->avg*3) + (VAR_8 <= VAR_2->avg*4/3));",
"else\n*VAR_2->adaptcoeffs = 0;",
"VAR_2->avg += (VAR_8 - VAR_2->avg) / 16;",
"VAR_2->adaptcoeffs[-1] >>= 1;",
"VAR_2->adaptcoeffs[-2] >>= 1;",
"VAR_2->adaptcoeffs[-8] >>= 1;",
"}",
"VAR_2->adaptcoeffs++;",
"if (VAR_2->delay == VAR_2->historybuffer + HISTORY_SIZE + (VAR_5 * 2)) {",
"memmove(VAR_2->historybuffer, VAR_2->delay - (VAR_5 * 2),\n(VAR_5 * 2) * sizeof(*VAR_2->historybuffer));",
"VAR_2->delay = VAR_2->historybuffer + VAR_5 * 2;",
"VAR_2->adaptcoeffs = VAR_2->historybuffer + 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
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
17,
19,
21,
23
],
[
25
],
[
27
],
[
29
],
[
35
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49
],
[
57
],
[
59,
61,
63
],
[
65,
67
],
[
71
],
[
75
],
[
77
],
[
79
],
[
81
],
[
85
],
[
91
],
[
93,
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
]
] |
23,992 | static int ffm2_read_header(AVFormatContext *s)
{
FFMContext *ffm = s->priv_data;
AVStream *st;
AVIOContext *pb = s->pb;
AVCodecContext *codec;
const AVCodecDescriptor *codec_desc;
int ret, i;
int f_main = 0, f_cprv = -1, f_stvi = -1, f_stau = -1;
AVCodec *enc;
char *buffer;
ffm->packet_size = avio_rb32(pb);
if (ffm->packet_size != FFM_PACKET_SIZE) {
av_log(s, AV_LOG_ERROR, "Invalid packet size %d, expected size was %d\n",
ffm->packet_size, FFM_PACKET_SIZE);
ret = AVERROR_INVALIDDATA;
ffm->write_index = avio_rb64(pb);
/* get also filesize */
if (pb->seekable) {
ffm->file_size = avio_size(pb);
if (ffm->write_index && 0)
adjust_write_index(s);
} else {
ffm->file_size = (UINT64_C(1) << 63) - 1;
while(!avio_feof(pb)) {
unsigned id = avio_rb32(pb);
unsigned size = avio_rb32(pb);
int64_t next = avio_tell(pb) + size;
char rc_eq_buf[128];
if(!id)
break;
switch(id) {
case MKBETAG('M', 'A', 'I', 'N'):
if (f_main++) {
ret = AVERROR(EINVAL);
avio_rb32(pb); /* nb_streams */
avio_rb32(pb); /* total bitrate */
break;
case MKBETAG('C', 'O', 'M', 'M'):
f_cprv = f_stvi = f_stau = 0;
st = avformat_new_stream(s, NULL);
if (!st) {
ret = AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, 1, 1000000);
codec = st->codec;
/* generic info */
codec->codec_id = avio_rb32(pb);
codec_desc = avcodec_descriptor_get(codec->codec_id);
if (!codec_desc) {
av_log(s, AV_LOG_ERROR, "Invalid codec id: %d\n", codec->codec_id);
codec->codec_id = AV_CODEC_ID_NONE;
codec->codec_type = avio_r8(pb);
if (codec->codec_type != codec_desc->type) {
av_log(s, AV_LOG_ERROR, "Codec type mismatch: expected %d, found %d\n",
codec_desc->type, codec->codec_type);
codec->codec_id = AV_CODEC_ID_NONE;
codec->codec_type = AVMEDIA_TYPE_UNKNOWN;
codec->bit_rate = avio_rb32(pb);
codec->flags = avio_rb32(pb);
codec->flags2 = avio_rb32(pb);
codec->debug = avio_rb32(pb);
if (codec->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
int size = avio_rb32(pb);
codec->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!codec->extradata)
return AVERROR(ENOMEM);
codec->extradata_size = size;
avio_read(pb, codec->extradata, size);
break;
case MKBETAG('S', 'T', 'V', 'I'):
if (f_stvi++) {
ret = AVERROR(EINVAL);
codec->time_base.num = avio_rb32(pb);
codec->time_base.den = avio_rb32(pb);
if (codec->time_base.num <= 0 || codec->time_base.den <= 0) {
av_log(s, AV_LOG_ERROR, "Invalid time base %d/%d\n",
codec->time_base.num, codec->time_base.den);
ret = AVERROR_INVALIDDATA;
codec->width = avio_rb16(pb);
codec->height = avio_rb16(pb);
codec->gop_size = avio_rb16(pb);
codec->pix_fmt = avio_rb32(pb);
codec->qmin = avio_r8(pb);
codec->qmax = avio_r8(pb);
codec->max_qdiff = avio_r8(pb);
codec->qcompress = avio_rb16(pb) / 10000.0;
codec->qblur = avio_rb16(pb) / 10000.0;
codec->bit_rate_tolerance = avio_rb32(pb);
avio_get_str(pb, INT_MAX, rc_eq_buf, sizeof(rc_eq_buf));
codec->rc_eq = av_strdup(rc_eq_buf);
codec->rc_max_rate = avio_rb32(pb);
codec->rc_min_rate = avio_rb32(pb);
codec->rc_buffer_size = avio_rb32(pb);
codec->i_quant_factor = av_int2double(avio_rb64(pb));
codec->b_quant_factor = av_int2double(avio_rb64(pb));
codec->i_quant_offset = av_int2double(avio_rb64(pb));
codec->b_quant_offset = av_int2double(avio_rb64(pb));
codec->dct_algo = avio_rb32(pb);
codec->strict_std_compliance = avio_rb32(pb);
codec->max_b_frames = avio_rb32(pb);
codec->mpeg_quant = avio_rb32(pb);
codec->intra_dc_precision = avio_rb32(pb);
codec->me_method = avio_rb32(pb);
codec->mb_decision = avio_rb32(pb);
codec->nsse_weight = avio_rb32(pb);
codec->frame_skip_cmp = avio_rb32(pb);
codec->rc_buffer_aggressivity = av_int2double(avio_rb64(pb));
codec->codec_tag = avio_rb32(pb);
codec->thread_count = avio_r8(pb);
codec->coder_type = avio_rb32(pb);
codec->me_cmp = avio_rb32(pb);
codec->me_subpel_quality = avio_rb32(pb);
codec->me_range = avio_rb32(pb);
codec->keyint_min = avio_rb32(pb);
codec->scenechange_threshold = avio_rb32(pb);
codec->b_frame_strategy = avio_rb32(pb);
codec->qcompress = av_int2double(avio_rb64(pb));
codec->qblur = av_int2double(avio_rb64(pb));
codec->max_qdiff = avio_rb32(pb);
codec->refs = avio_rb32(pb);
break;
case MKBETAG('S', 'T', 'A', 'U'):
if (f_stau++) {
ret = AVERROR(EINVAL);
codec->sample_rate = avio_rb32(pb);
codec->channels = avio_rl16(pb);
codec->frame_size = avio_rl16(pb);
break;
case MKBETAG('C', 'P', 'R', 'V'):
if (f_cprv++) {
ret = AVERROR(EINVAL);
enc = avcodec_find_encoder(codec->codec_id);
if (enc && enc->priv_data_size && enc->priv_class) {
buffer = av_malloc(size + 1);
if (!buffer) {
ret = AVERROR(ENOMEM);
avio_get_str(pb, size, buffer, size + 1);
if ((ret = ffm_append_recommended_configuration(st, &buffer)) < 0)
break;
case MKBETAG('S', '2', 'V', 'I'):
if (f_stvi++ || !size) {
ret = AVERROR(EINVAL);
buffer = av_malloc(size);
if (!buffer) {
ret = AVERROR(ENOMEM);
avio_get_str(pb, INT_MAX, buffer, size);
av_set_options_string(codec, buffer, "=", ",");
if ((ret = ffm_append_recommended_configuration(st, &buffer)) < 0)
break;
case MKBETAG('S', '2', 'A', 'U'):
if (f_stau++ || !size) {
ret = AVERROR(EINVAL);
buffer = av_malloc(size);
if (!buffer) {
ret = AVERROR(ENOMEM);
avio_get_str(pb, INT_MAX, buffer, size);
av_set_options_string(codec, buffer, "=", ",");
if ((ret = ffm_append_recommended_configuration(st, &buffer)) < 0)
break;
avio_seek(pb, next, SEEK_SET);
for (i = 0; i < s->nb_streams; i++)
avcodec_parameters_from_context(s->streams[i]->codecpar, s->streams[i]->codec);
/* get until end of block reached */
while ((avio_tell(pb) % ffm->packet_size) != 0 && !pb->eof_reached)
avio_r8(pb);
/* init packet demux */
ffm->packet_ptr = ffm->packet;
ffm->packet_end = ffm->packet;
ffm->frame_offset = 0;
ffm->dts = 0;
ffm->read_state = READ_HEADER;
ffm->first_packet = 1;
return 0;
fail:
ffm_close(s);
return ret;
| true | FFmpeg | 78baa450d9939957f52d5187beb95d763d2f1f18 | static int ffm2_read_header(AVFormatContext *s)
{
FFMContext *ffm = s->priv_data;
AVStream *st;
AVIOContext *pb = s->pb;
AVCodecContext *codec;
const AVCodecDescriptor *codec_desc;
int ret, i;
int f_main = 0, f_cprv = -1, f_stvi = -1, f_stau = -1;
AVCodec *enc;
char *buffer;
ffm->packet_size = avio_rb32(pb);
if (ffm->packet_size != FFM_PACKET_SIZE) {
av_log(s, AV_LOG_ERROR, "Invalid packet size %d, expected size was %d\n",
ffm->packet_size, FFM_PACKET_SIZE);
ret = AVERROR_INVALIDDATA;
ffm->write_index = avio_rb64(pb);
if (pb->seekable) {
ffm->file_size = avio_size(pb);
if (ffm->write_index && 0)
adjust_write_index(s);
} else {
ffm->file_size = (UINT64_C(1) << 63) - 1;
while(!avio_feof(pb)) {
unsigned id = avio_rb32(pb);
unsigned size = avio_rb32(pb);
int64_t next = avio_tell(pb) + size;
char rc_eq_buf[128];
if(!id)
break;
switch(id) {
case MKBETAG('M', 'A', 'I', 'N'):
if (f_main++) {
ret = AVERROR(EINVAL);
avio_rb32(pb);
avio_rb32(pb);
break;
case MKBETAG('C', 'O', 'M', 'M'):
f_cprv = f_stvi = f_stau = 0;
st = avformat_new_stream(s, NULL);
if (!st) {
ret = AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, 1, 1000000);
codec = st->codec;
codec->codec_id = avio_rb32(pb);
codec_desc = avcodec_descriptor_get(codec->codec_id);
if (!codec_desc) {
av_log(s, AV_LOG_ERROR, "Invalid codec id: %d\n", codec->codec_id);
codec->codec_id = AV_CODEC_ID_NONE;
codec->codec_type = avio_r8(pb);
if (codec->codec_type != codec_desc->type) {
av_log(s, AV_LOG_ERROR, "Codec type mismatch: expected %d, found %d\n",
codec_desc->type, codec->codec_type);
codec->codec_id = AV_CODEC_ID_NONE;
codec->codec_type = AVMEDIA_TYPE_UNKNOWN;
codec->bit_rate = avio_rb32(pb);
codec->flags = avio_rb32(pb);
codec->flags2 = avio_rb32(pb);
codec->debug = avio_rb32(pb);
if (codec->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
int size = avio_rb32(pb);
codec->extradata = av_mallocz(size + AV_INPUT_BUFFER_PADDING_SIZE);
if (!codec->extradata)
return AVERROR(ENOMEM);
codec->extradata_size = size;
avio_read(pb, codec->extradata, size);
break;
case MKBETAG('S', 'T', 'V', 'I'):
if (f_stvi++) {
ret = AVERROR(EINVAL);
codec->time_base.num = avio_rb32(pb);
codec->time_base.den = avio_rb32(pb);
if (codec->time_base.num <= 0 || codec->time_base.den <= 0) {
av_log(s, AV_LOG_ERROR, "Invalid time base %d/%d\n",
codec->time_base.num, codec->time_base.den);
ret = AVERROR_INVALIDDATA;
codec->width = avio_rb16(pb);
codec->height = avio_rb16(pb);
codec->gop_size = avio_rb16(pb);
codec->pix_fmt = avio_rb32(pb);
codec->qmin = avio_r8(pb);
codec->qmax = avio_r8(pb);
codec->max_qdiff = avio_r8(pb);
codec->qcompress = avio_rb16(pb) / 10000.0;
codec->qblur = avio_rb16(pb) / 10000.0;
codec->bit_rate_tolerance = avio_rb32(pb);
avio_get_str(pb, INT_MAX, rc_eq_buf, sizeof(rc_eq_buf));
codec->rc_eq = av_strdup(rc_eq_buf);
codec->rc_max_rate = avio_rb32(pb);
codec->rc_min_rate = avio_rb32(pb);
codec->rc_buffer_size = avio_rb32(pb);
codec->i_quant_factor = av_int2double(avio_rb64(pb));
codec->b_quant_factor = av_int2double(avio_rb64(pb));
codec->i_quant_offset = av_int2double(avio_rb64(pb));
codec->b_quant_offset = av_int2double(avio_rb64(pb));
codec->dct_algo = avio_rb32(pb);
codec->strict_std_compliance = avio_rb32(pb);
codec->max_b_frames = avio_rb32(pb);
codec->mpeg_quant = avio_rb32(pb);
codec->intra_dc_precision = avio_rb32(pb);
codec->me_method = avio_rb32(pb);
codec->mb_decision = avio_rb32(pb);
codec->nsse_weight = avio_rb32(pb);
codec->frame_skip_cmp = avio_rb32(pb);
codec->rc_buffer_aggressivity = av_int2double(avio_rb64(pb));
codec->codec_tag = avio_rb32(pb);
codec->thread_count = avio_r8(pb);
codec->coder_type = avio_rb32(pb);
codec->me_cmp = avio_rb32(pb);
codec->me_subpel_quality = avio_rb32(pb);
codec->me_range = avio_rb32(pb);
codec->keyint_min = avio_rb32(pb);
codec->scenechange_threshold = avio_rb32(pb);
codec->b_frame_strategy = avio_rb32(pb);
codec->qcompress = av_int2double(avio_rb64(pb));
codec->qblur = av_int2double(avio_rb64(pb));
codec->max_qdiff = avio_rb32(pb);
codec->refs = avio_rb32(pb);
break;
case MKBETAG('S', 'T', 'A', 'U'):
if (f_stau++) {
ret = AVERROR(EINVAL);
codec->sample_rate = avio_rb32(pb);
codec->channels = avio_rl16(pb);
codec->frame_size = avio_rl16(pb);
break;
case MKBETAG('C', 'P', 'R', 'V'):
if (f_cprv++) {
ret = AVERROR(EINVAL);
enc = avcodec_find_encoder(codec->codec_id);
if (enc && enc->priv_data_size && enc->priv_class) {
buffer = av_malloc(size + 1);
if (!buffer) {
ret = AVERROR(ENOMEM);
avio_get_str(pb, size, buffer, size + 1);
if ((ret = ffm_append_recommended_configuration(st, &buffer)) < 0)
break;
case MKBETAG('S', '2', 'V', 'I'):
if (f_stvi++ || !size) {
ret = AVERROR(EINVAL);
buffer = av_malloc(size);
if (!buffer) {
ret = AVERROR(ENOMEM);
avio_get_str(pb, INT_MAX, buffer, size);
av_set_options_string(codec, buffer, "=", ",");
if ((ret = ffm_append_recommended_configuration(st, &buffer)) < 0)
break;
case MKBETAG('S', '2', 'A', 'U'):
if (f_stau++ || !size) {
ret = AVERROR(EINVAL);
buffer = av_malloc(size);
if (!buffer) {
ret = AVERROR(ENOMEM);
avio_get_str(pb, INT_MAX, buffer, size);
av_set_options_string(codec, buffer, "=", ",");
if ((ret = ffm_append_recommended_configuration(st, &buffer)) < 0)
break;
avio_seek(pb, next, SEEK_SET);
for (i = 0; i < s->nb_streams; i++)
avcodec_parameters_from_context(s->streams[i]->codecpar, s->streams[i]->codec);
while ((avio_tell(pb) % ffm->packet_size) != 0 && !pb->eof_reached)
avio_r8(pb);
ffm->packet_ptr = ffm->packet;
ffm->packet_end = ffm->packet;
ffm->frame_offset = 0;
ffm->dts = 0;
ffm->read_state = READ_HEADER;
ffm->first_packet = 1;
return 0;
fail:
ffm_close(s);
return ret;
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0)
{
FFMContext *ffm = VAR_0->priv_data;
AVStream *st;
AVIOContext *pb = VAR_0->pb;
AVCodecContext *codec;
const AVCodecDescriptor *VAR_1;
int VAR_2, VAR_3;
int VAR_4 = 0, VAR_5 = -1, VAR_6 = -1, VAR_7 = -1;
AVCodec *enc;
char *VAR_8;
ffm->packet_size = avio_rb32(pb);
if (ffm->packet_size != FFM_PACKET_SIZE) {
av_log(VAR_0, AV_LOG_ERROR, "Invalid packet VAR_12 %d, expected VAR_12 was %d\n",
ffm->packet_size, FFM_PACKET_SIZE);
VAR_2 = AVERROR_INVALIDDATA;
ffm->write_index = avio_rb64(pb);
if (pb->seekable) {
ffm->file_size = avio_size(pb);
if (ffm->write_index && 0)
adjust_write_index(VAR_0);
} else {
ffm->file_size = (UINT64_C(1) << 63) - 1;
while(!avio_feof(pb)) {
unsigned VAR_9 = avio_rb32(pb);
unsigned VAR_12 = avio_rb32(pb);
int64_t next = avio_tell(pb) + VAR_12;
char VAR_11[128];
if(!VAR_9)
break;
switch(VAR_9) {
case MKBETAG('M', 'A', 'I', 'N'):
if (VAR_4++) {
VAR_2 = AVERROR(EINVAL);
avio_rb32(pb);
avio_rb32(pb);
break;
case MKBETAG('C', 'O', 'M', 'M'):
VAR_5 = VAR_6 = VAR_7 = 0;
st = avformat_new_stream(VAR_0, NULL);
if (!st) {
VAR_2 = AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, 1, 1000000);
codec = st->codec;
codec->codec_id = avio_rb32(pb);
VAR_1 = avcodec_descriptor_get(codec->codec_id);
if (!VAR_1) {
av_log(VAR_0, AV_LOG_ERROR, "Invalid codec VAR_9: %d\n", codec->codec_id);
codec->codec_id = AV_CODEC_ID_NONE;
codec->codec_type = avio_r8(pb);
if (codec->codec_type != VAR_1->type) {
av_log(VAR_0, AV_LOG_ERROR, "Codec type mismatch: expected %d, found %d\n",
VAR_1->type, codec->codec_type);
codec->codec_id = AV_CODEC_ID_NONE;
codec->codec_type = AVMEDIA_TYPE_UNKNOWN;
codec->bit_rate = avio_rb32(pb);
codec->flags = avio_rb32(pb);
codec->flags2 = avio_rb32(pb);
codec->debug = avio_rb32(pb);
if (codec->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {
int VAR_12 = avio_rb32(pb);
codec->extradata = av_mallocz(VAR_12 + AV_INPUT_BUFFER_PADDING_SIZE);
if (!codec->extradata)
return AVERROR(ENOMEM);
codec->extradata_size = VAR_12;
avio_read(pb, codec->extradata, VAR_12);
break;
case MKBETAG('S', 'T', 'V', 'I'):
if (VAR_6++) {
VAR_2 = AVERROR(EINVAL);
codec->time_base.num = avio_rb32(pb);
codec->time_base.den = avio_rb32(pb);
if (codec->time_base.num <= 0 || codec->time_base.den <= 0) {
av_log(VAR_0, AV_LOG_ERROR, "Invalid time base %d/%d\n",
codec->time_base.num, codec->time_base.den);
VAR_2 = AVERROR_INVALIDDATA;
codec->width = avio_rb16(pb);
codec->height = avio_rb16(pb);
codec->gop_size = avio_rb16(pb);
codec->pix_fmt = avio_rb32(pb);
codec->qmin = avio_r8(pb);
codec->qmax = avio_r8(pb);
codec->max_qdiff = avio_r8(pb);
codec->qcompress = avio_rb16(pb) / 10000.0;
codec->qblur = avio_rb16(pb) / 10000.0;
codec->bit_rate_tolerance = avio_rb32(pb);
avio_get_str(pb, INT_MAX, VAR_11, sizeof(VAR_11));
codec->rc_eq = av_strdup(VAR_11);
codec->rc_max_rate = avio_rb32(pb);
codec->rc_min_rate = avio_rb32(pb);
codec->rc_buffer_size = avio_rb32(pb);
codec->i_quant_factor = av_int2double(avio_rb64(pb));
codec->b_quant_factor = av_int2double(avio_rb64(pb));
codec->i_quant_offset = av_int2double(avio_rb64(pb));
codec->b_quant_offset = av_int2double(avio_rb64(pb));
codec->dct_algo = avio_rb32(pb);
codec->strict_std_compliance = avio_rb32(pb);
codec->max_b_frames = avio_rb32(pb);
codec->mpeg_quant = avio_rb32(pb);
codec->intra_dc_precision = avio_rb32(pb);
codec->me_method = avio_rb32(pb);
codec->mb_decision = avio_rb32(pb);
codec->nsse_weight = avio_rb32(pb);
codec->frame_skip_cmp = avio_rb32(pb);
codec->rc_buffer_aggressivity = av_int2double(avio_rb64(pb));
codec->codec_tag = avio_rb32(pb);
codec->thread_count = avio_r8(pb);
codec->coder_type = avio_rb32(pb);
codec->me_cmp = avio_rb32(pb);
codec->me_subpel_quality = avio_rb32(pb);
codec->me_range = avio_rb32(pb);
codec->keyint_min = avio_rb32(pb);
codec->scenechange_threshold = avio_rb32(pb);
codec->b_frame_strategy = avio_rb32(pb);
codec->qcompress = av_int2double(avio_rb64(pb));
codec->qblur = av_int2double(avio_rb64(pb));
codec->max_qdiff = avio_rb32(pb);
codec->refs = avio_rb32(pb);
break;
case MKBETAG('S', 'T', 'A', 'U'):
if (VAR_7++) {
VAR_2 = AVERROR(EINVAL);
codec->sample_rate = avio_rb32(pb);
codec->channels = avio_rl16(pb);
codec->frame_size = avio_rl16(pb);
break;
case MKBETAG('C', 'P', 'R', 'V'):
if (VAR_5++) {
VAR_2 = AVERROR(EINVAL);
enc = avcodec_find_encoder(codec->codec_id);
if (enc && enc->priv_data_size && enc->priv_class) {
VAR_8 = av_malloc(VAR_12 + 1);
if (!VAR_8) {
VAR_2 = AVERROR(ENOMEM);
avio_get_str(pb, VAR_12, VAR_8, VAR_12 + 1);
if ((VAR_2 = ffm_append_recommended_configuration(st, &VAR_8)) < 0)
break;
case MKBETAG('S', '2', 'V', 'I'):
if (VAR_6++ || !VAR_12) {
VAR_2 = AVERROR(EINVAL);
VAR_8 = av_malloc(VAR_12);
if (!VAR_8) {
VAR_2 = AVERROR(ENOMEM);
avio_get_str(pb, INT_MAX, VAR_8, VAR_12);
av_set_options_string(codec, VAR_8, "=", ",");
if ((VAR_2 = ffm_append_recommended_configuration(st, &VAR_8)) < 0)
break;
case MKBETAG('S', '2', 'A', 'U'):
if (VAR_7++ || !VAR_12) {
VAR_2 = AVERROR(EINVAL);
VAR_8 = av_malloc(VAR_12);
if (!VAR_8) {
VAR_2 = AVERROR(ENOMEM);
avio_get_str(pb, INT_MAX, VAR_8, VAR_12);
av_set_options_string(codec, VAR_8, "=", ",");
if ((VAR_2 = ffm_append_recommended_configuration(st, &VAR_8)) < 0)
break;
avio_seek(pb, next, SEEK_SET);
for (VAR_3 = 0; VAR_3 < VAR_0->nb_streams; VAR_3++)
avcodec_parameters_from_context(VAR_0->streams[VAR_3]->codecpar, VAR_0->streams[VAR_3]->codec);
while ((avio_tell(pb) % ffm->packet_size) != 0 && !pb->eof_reached)
avio_r8(pb);
ffm->packet_ptr = ffm->packet;
ffm->packet_end = ffm->packet;
ffm->frame_offset = 0;
ffm->dts = 0;
ffm->read_state = READ_HEADER;
ffm->first_packet = 1;
return 0;
fail:
ffm_close(VAR_0);
return VAR_2;
| [
"static int FUNC_0(AVFormatContext *VAR_0)\n{",
"FFMContext *ffm = VAR_0->priv_data;",
"AVStream *st;",
"AVIOContext *pb = VAR_0->pb;",
"AVCodecContext *codec;",
"const AVCodecDescriptor *VAR_1;",
"int VAR_2, VAR_3;",
"int VAR_4 = 0, VAR_5 = -1, VAR_6 = -1, VAR_7 = -1;",
"AVCodec *enc;",
"char *VAR_8;",
"ffm->packet_size = avio_rb32(pb);",
"if (ffm->packet_size != FFM_PACKET_SIZE) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Invalid packet VAR_12 %d, expected VAR_12 was %d\\n\",\nffm->packet_size, FFM_PACKET_SIZE);",
"VAR_2 = AVERROR_INVALIDDATA;",
"ffm->write_index = avio_rb64(pb);",
"if (pb->seekable) {",
"ffm->file_size = avio_size(pb);",
"if (ffm->write_index && 0)\nadjust_write_index(VAR_0);",
"} else {",
"ffm->file_size = (UINT64_C(1) << 63) - 1;",
"while(!avio_feof(pb)) {",
"unsigned VAR_9 = avio_rb32(pb);",
"unsigned VAR_12 = avio_rb32(pb);",
"int64_t next = avio_tell(pb) + VAR_12;",
"char VAR_11[128];",
"if(!VAR_9)\nbreak;",
"switch(VAR_9) {",
"case MKBETAG('M', 'A', 'I', 'N'):\nif (VAR_4++) {",
"VAR_2 = AVERROR(EINVAL);",
"avio_rb32(pb);",
"avio_rb32(pb);",
"break;",
"case MKBETAG('C', 'O', 'M', 'M'):\nVAR_5 = VAR_6 = VAR_7 = 0;",
"st = avformat_new_stream(VAR_0, NULL);",
"if (!st) {",
"VAR_2 = AVERROR(ENOMEM);",
"avpriv_set_pts_info(st, 64, 1, 1000000);",
"codec = st->codec;",
"codec->codec_id = avio_rb32(pb);",
"VAR_1 = avcodec_descriptor_get(codec->codec_id);",
"if (!VAR_1) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Invalid codec VAR_9: %d\\n\", codec->codec_id);",
"codec->codec_id = AV_CODEC_ID_NONE;",
"codec->codec_type = avio_r8(pb);",
"if (codec->codec_type != VAR_1->type) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Codec type mismatch: expected %d, found %d\\n\",\nVAR_1->type, codec->codec_type);",
"codec->codec_id = AV_CODEC_ID_NONE;",
"codec->codec_type = AVMEDIA_TYPE_UNKNOWN;",
"codec->bit_rate = avio_rb32(pb);",
"codec->flags = avio_rb32(pb);",
"codec->flags2 = avio_rb32(pb);",
"codec->debug = avio_rb32(pb);",
"if (codec->flags & AV_CODEC_FLAG_GLOBAL_HEADER) {",
"int VAR_12 = avio_rb32(pb);",
"codec->extradata = av_mallocz(VAR_12 + AV_INPUT_BUFFER_PADDING_SIZE);",
"if (!codec->extradata)\nreturn AVERROR(ENOMEM);",
"codec->extradata_size = VAR_12;",
"avio_read(pb, codec->extradata, VAR_12);",
"break;",
"case MKBETAG('S', 'T', 'V', 'I'):\nif (VAR_6++) {",
"VAR_2 = AVERROR(EINVAL);",
"codec->time_base.num = avio_rb32(pb);",
"codec->time_base.den = avio_rb32(pb);",
"if (codec->time_base.num <= 0 || codec->time_base.den <= 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Invalid time base %d/%d\\n\",\ncodec->time_base.num, codec->time_base.den);",
"VAR_2 = AVERROR_INVALIDDATA;",
"codec->width = avio_rb16(pb);",
"codec->height = avio_rb16(pb);",
"codec->gop_size = avio_rb16(pb);",
"codec->pix_fmt = avio_rb32(pb);",
"codec->qmin = avio_r8(pb);",
"codec->qmax = avio_r8(pb);",
"codec->max_qdiff = avio_r8(pb);",
"codec->qcompress = avio_rb16(pb) / 10000.0;",
"codec->qblur = avio_rb16(pb) / 10000.0;",
"codec->bit_rate_tolerance = avio_rb32(pb);",
"avio_get_str(pb, INT_MAX, VAR_11, sizeof(VAR_11));",
"codec->rc_eq = av_strdup(VAR_11);",
"codec->rc_max_rate = avio_rb32(pb);",
"codec->rc_min_rate = avio_rb32(pb);",
"codec->rc_buffer_size = avio_rb32(pb);",
"codec->i_quant_factor = av_int2double(avio_rb64(pb));",
"codec->b_quant_factor = av_int2double(avio_rb64(pb));",
"codec->i_quant_offset = av_int2double(avio_rb64(pb));",
"codec->b_quant_offset = av_int2double(avio_rb64(pb));",
"codec->dct_algo = avio_rb32(pb);",
"codec->strict_std_compliance = avio_rb32(pb);",
"codec->max_b_frames = avio_rb32(pb);",
"codec->mpeg_quant = avio_rb32(pb);",
"codec->intra_dc_precision = avio_rb32(pb);",
"codec->me_method = avio_rb32(pb);",
"codec->mb_decision = avio_rb32(pb);",
"codec->nsse_weight = avio_rb32(pb);",
"codec->frame_skip_cmp = avio_rb32(pb);",
"codec->rc_buffer_aggressivity = av_int2double(avio_rb64(pb));",
"codec->codec_tag = avio_rb32(pb);",
"codec->thread_count = avio_r8(pb);",
"codec->coder_type = avio_rb32(pb);",
"codec->me_cmp = avio_rb32(pb);",
"codec->me_subpel_quality = avio_rb32(pb);",
"codec->me_range = avio_rb32(pb);",
"codec->keyint_min = avio_rb32(pb);",
"codec->scenechange_threshold = avio_rb32(pb);",
"codec->b_frame_strategy = avio_rb32(pb);",
"codec->qcompress = av_int2double(avio_rb64(pb));",
"codec->qblur = av_int2double(avio_rb64(pb));",
"codec->max_qdiff = avio_rb32(pb);",
"codec->refs = avio_rb32(pb);",
"break;",
"case MKBETAG('S', 'T', 'A', 'U'):\nif (VAR_7++) {",
"VAR_2 = AVERROR(EINVAL);",
"codec->sample_rate = avio_rb32(pb);",
"codec->channels = avio_rl16(pb);",
"codec->frame_size = avio_rl16(pb);",
"break;",
"case MKBETAG('C', 'P', 'R', 'V'):\nif (VAR_5++) {",
"VAR_2 = AVERROR(EINVAL);",
"enc = avcodec_find_encoder(codec->codec_id);",
"if (enc && enc->priv_data_size && enc->priv_class) {",
"VAR_8 = av_malloc(VAR_12 + 1);",
"if (!VAR_8) {",
"VAR_2 = AVERROR(ENOMEM);",
"avio_get_str(pb, VAR_12, VAR_8, VAR_12 + 1);",
"if ((VAR_2 = ffm_append_recommended_configuration(st, &VAR_8)) < 0)\nbreak;",
"case MKBETAG('S', '2', 'V', 'I'):\nif (VAR_6++ || !VAR_12) {",
"VAR_2 = AVERROR(EINVAL);",
"VAR_8 = av_malloc(VAR_12);",
"if (!VAR_8) {",
"VAR_2 = AVERROR(ENOMEM);",
"avio_get_str(pb, INT_MAX, VAR_8, VAR_12);",
"av_set_options_string(codec, VAR_8, \"=\", \",\");",
"if ((VAR_2 = ffm_append_recommended_configuration(st, &VAR_8)) < 0)\nbreak;",
"case MKBETAG('S', '2', 'A', 'U'):\nif (VAR_7++ || !VAR_12) {",
"VAR_2 = AVERROR(EINVAL);",
"VAR_8 = av_malloc(VAR_12);",
"if (!VAR_8) {",
"VAR_2 = AVERROR(ENOMEM);",
"avio_get_str(pb, INT_MAX, VAR_8, VAR_12);",
"av_set_options_string(codec, VAR_8, \"=\", \",\");",
"if ((VAR_2 = ffm_append_recommended_configuration(st, &VAR_8)) < 0)\nbreak;",
"avio_seek(pb, next, SEEK_SET);",
"for (VAR_3 = 0; VAR_3 < VAR_0->nb_streams; VAR_3++)",
"avcodec_parameters_from_context(VAR_0->streams[VAR_3]->codecpar, VAR_0->streams[VAR_3]->codec);",
"while ((avio_tell(pb) % ffm->packet_size) != 0 && !pb->eof_reached)\navio_r8(pb);",
"ffm->packet_ptr = ffm->packet;",
"ffm->packet_end = ffm->packet;",
"ffm->frame_offset = 0;",
"ffm->dts = 0;",
"ffm->read_state = READ_HEADER;",
"ffm->first_packet = 1;",
"return 0;",
"fail:\nffm_close(VAR_0);",
"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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
25
],
[
27
],
[
29,
31
],
[
33
],
[
39
],
[
43
],
[
45
],
[
47,
49
],
[
51
],
[
53
],
[
58
],
[
60
],
[
62
],
[
64
],
[
66
],
[
70,
72
],
[
76
],
[
78,
80
],
[
82
],
[
86
],
[
88
],
[
90
],
[
92,
94
],
[
96
],
[
98
],
[
100
],
[
106
],
[
110
],
[
114
],
[
116
],
[
118
],
[
120
],
[
122
],
[
126
],
[
128
],
[
130,
132
],
[
134
],
[
136
],
[
140
],
[
142
],
[
144
],
[
146
],
[
148
],
[
150
],
[
152
],
[
154,
156
],
[
158
],
[
160
],
[
163
],
[
165,
167
],
[
169
],
[
173
],
[
175
],
[
177
],
[
179,
181
],
[
183
],
[
187
],
[
189
],
[
191
],
[
193
],
[
200
],
[
202
],
[
204
],
[
206
],
[
208
],
[
210
],
[
212
],
[
214
],
[
216
],
[
218
],
[
220
],
[
222
],
[
224
],
[
226
],
[
228
],
[
230
],
[
232
],
[
234
],
[
236
],
[
238
],
[
240
],
[
242
],
[
244
],
[
246
],
[
248
],
[
250
],
[
252
],
[
254
],
[
256
],
[
258
],
[
260
],
[
262
],
[
264
],
[
266
],
[
268
],
[
270
],
[
272
],
[
274
],
[
276
],
[
278,
280
],
[
282
],
[
286
],
[
288
],
[
290
],
[
292
],
[
294,
296
],
[
298
],
[
302
],
[
304
],
[
306
],
[
308
],
[
310
],
[
314
],
[
316,
320
],
[
322,
324
],
[
326
],
[
330
],
[
332
],
[
334
],
[
338
],
[
340
],
[
342,
345
],
[
347,
349
],
[
351
],
[
355
],
[
357
],
[
359
],
[
363
],
[
365
],
[
367,
370
],
[
373
],
[
378
],
[
380
],
[
386,
388
],
[
394
],
[
396
],
[
398
],
[
400
],
[
402
],
[
404
],
[
406
],
[
408,
410
],
[
412
]
] |
23,993 | static int h263p_decode_umotion(MpegEncContext * s, int pred)
{
int code = 0, sign;
if (get_bits1(&s->gb)) /* Motion difference = 0 */
return pred;
code = 2 + get_bits1(&s->gb);
while (get_bits1(&s->gb))
{
code <<= 1;
code += get_bits1(&s->gb);
if (code >= 32768) {
avpriv_request_sample(s->avctx, "Huge DMV");
return AVERROR_INVALIDDATA;
}
}
sign = code & 1;
code >>= 1;
code = (sign) ? (pred - code) : (pred + code);
ff_tlog(s->avctx,"H.263+ UMV Motion = %d\n", code);
return code;
}
| true | FFmpeg | 12c3e120fe8f8d6881001eade390d8a5c185783d | static int h263p_decode_umotion(MpegEncContext * s, int pred)
{
int code = 0, sign;
if (get_bits1(&s->gb))
return pred;
code = 2 + get_bits1(&s->gb);
while (get_bits1(&s->gb))
{
code <<= 1;
code += get_bits1(&s->gb);
if (code >= 32768) {
avpriv_request_sample(s->avctx, "Huge DMV");
return AVERROR_INVALIDDATA;
}
}
sign = code & 1;
code >>= 1;
code = (sign) ? (pred - code) : (pred + code);
ff_tlog(s->avctx,"H.263+ UMV Motion = %d\n", code);
return code;
}
| {
"code": [
" return AVERROR_INVALIDDATA;"
],
"line_no": [
31
]
} | static int FUNC_0(MpegEncContext * VAR_0, int VAR_1)
{
int VAR_2 = 0, VAR_3;
if (get_bits1(&VAR_0->gb))
return VAR_1;
VAR_2 = 2 + get_bits1(&VAR_0->gb);
while (get_bits1(&VAR_0->gb))
{
VAR_2 <<= 1;
VAR_2 += get_bits1(&VAR_0->gb);
if (VAR_2 >= 32768) {
avpriv_request_sample(VAR_0->avctx, "Huge DMV");
return AVERROR_INVALIDDATA;
}
}
VAR_3 = VAR_2 & 1;
VAR_2 >>= 1;
VAR_2 = (VAR_3) ? (VAR_1 - VAR_2) : (VAR_1 + VAR_2);
ff_tlog(VAR_0->avctx,"H.263+ UMV Motion = %d\n", VAR_2);
return VAR_2;
}
| [
"static int FUNC_0(MpegEncContext * VAR_0, int VAR_1)\n{",
"int VAR_2 = 0, VAR_3;",
"if (get_bits1(&VAR_0->gb))\nreturn VAR_1;",
"VAR_2 = 2 + get_bits1(&VAR_0->gb);",
"while (get_bits1(&VAR_0->gb))\n{",
"VAR_2 <<= 1;",
"VAR_2 += get_bits1(&VAR_0->gb);",
"if (VAR_2 >= 32768) {",
"avpriv_request_sample(VAR_0->avctx, \"Huge DMV\");",
"return AVERROR_INVALIDDATA;",
"}",
"}",
"VAR_3 = VAR_2 & 1;",
"VAR_2 >>= 1;",
"VAR_2 = (VAR_3) ? (VAR_1 - VAR_2) : (VAR_1 + VAR_2);",
"ff_tlog(VAR_0->avctx,\"H.263+ UMV Motion = %d\\n\", VAR_2);",
"return VAR_2;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9,
11
],
[
15
],
[
19,
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
51
]
] |
23,994 | static void stream_pause(VideoState *is)
{
is->paused = !is->paused;
if (!is->paused) {
if(is->read_pause_return != AVERROR(ENOSYS)){
is->video_current_pts = get_video_clock(is);
}
is->frame_timer += (av_gettime() - is->video_current_pts_time) / 1000000.0;
is->video_current_pts_time= av_gettime();
}
}
| true | FFmpeg | 68aefbe81cb3b9dd002108782bb8d798e1c12806 | static void stream_pause(VideoState *is)
{
is->paused = !is->paused;
if (!is->paused) {
if(is->read_pause_return != AVERROR(ENOSYS)){
is->video_current_pts = get_video_clock(is);
}
is->frame_timer += (av_gettime() - is->video_current_pts_time) / 1000000.0;
is->video_current_pts_time= av_gettime();
}
}
| {
"code": [
" is->paused = !is->paused;",
" if (!is->paused) {",
" is->video_current_pts = get_video_clock(is);",
" is->frame_timer += (av_gettime() - is->video_current_pts_time) / 1000000.0;",
" is->video_current_pts_time= av_gettime();"
],
"line_no": [
5,
7,
11,
17,
19
]
} | static void FUNC_0(VideoState *VAR_0)
{
VAR_0->paused = !VAR_0->paused;
if (!VAR_0->paused) {
if(VAR_0->read_pause_return != AVERROR(ENOSYS)){
VAR_0->video_current_pts = get_video_clock(VAR_0);
}
VAR_0->frame_timer += (av_gettime() - VAR_0->video_current_pts_time) / 1000000.0;
VAR_0->video_current_pts_time= av_gettime();
}
}
| [
"static void FUNC_0(VideoState *VAR_0)\n{",
"VAR_0->paused = !VAR_0->paused;",
"if (!VAR_0->paused) {",
"if(VAR_0->read_pause_return != AVERROR(ENOSYS)){",
"VAR_0->video_current_pts = get_video_clock(VAR_0);",
"}",
"VAR_0->frame_timer += (av_gettime() - VAR_0->video_current_pts_time) / 1000000.0;",
"VAR_0->video_current_pts_time= av_gettime();",
"}",
"}"
] | [
0,
1,
1,
0,
1,
0,
1,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
]
] |
23,995 | static void gen_tlbia(DisasContext *ctx)
{
#if defined(CONFIG_USER_ONLY)
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
#else
if (unlikely(ctx->pr)) {
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
return;
}
gen_helper_tlbia(cpu_env);
#endif
}
| true | qemu | 1c7336c5d1f720e8d320cb36f9d747ad24663e0d | static void gen_tlbia(DisasContext *ctx)
{
#if defined(CONFIG_USER_ONLY)
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
#else
if (unlikely(ctx->pr)) {
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
return;
}
gen_helper_tlbia(cpu_env);
#endif
}
| {
"code": [
" if (unlikely(ctx->pr)) {"
],
"line_no": [
11
]
} | static void FUNC_0(DisasContext *VAR_0)
{
#if defined(CONFIG_USER_ONLY)
gen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_OPC);
#else
if (unlikely(VAR_0->pr)) {
gen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_OPC);
return;
}
gen_helper_tlbia(cpu_env);
#endif
}
| [
"static void FUNC_0(DisasContext *VAR_0)\n{",
"#if defined(CONFIG_USER_ONLY)\ngen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_OPC);",
"#else\nif (unlikely(VAR_0->pr)) {",
"gen_inval_exception(VAR_0, POWERPC_EXCP_PRIV_OPC);",
"return;",
"}",
"gen_helper_tlbia(cpu_env);",
"#endif\n}"
] | [
0,
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5,
7
],
[
9,
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21,
23
]
] |
23,996 | int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *pic_arg, int *got_packet)
{
MpegEncContext *s = avctx->priv_data;
int i, stuffing_count, ret;
int context_count = s->slice_context_count;
s->picture_in_gop_number++;
if (load_input_picture(s, pic_arg) < 0)
return -1;
if (select_input_picture(s) < 0) {
return -1;
}
/* output? */
if (s->new_picture.f.data[0]) {
if (!pkt->data &&
(ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
return ret;
if (s->mb_info) {
s->mb_info_ptr = av_packet_new_side_data(pkt,
AV_PKT_DATA_H263_MB_INFO,
s->mb_width*s->mb_height*12);
s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
}
for (i = 0; i < context_count; i++) {
int start_y = s->thread_context[i]->start_mb_y;
int end_y = s->thread_context[i]-> end_mb_y;
int h = s->mb_height;
uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
init_put_bits(&s->thread_context[i]->pb, start, end - start);
}
s->pict_type = s->new_picture.f.pict_type;
//emms_c();
//printf("qs:%f %f %d\n", s->new_picture.quality,
// s->current_picture.quality, s->qscale);
ff_MPV_frame_start(s, avctx);
vbv_retry:
if (encode_picture(s, s->picture_number) < 0)
return -1;
avctx->header_bits = s->header_bits;
avctx->mv_bits = s->mv_bits;
avctx->misc_bits = s->misc_bits;
avctx->i_tex_bits = s->i_tex_bits;
avctx->p_tex_bits = s->p_tex_bits;
avctx->i_count = s->i_count;
// FIXME f/b_count in avctx
avctx->p_count = s->mb_num - s->i_count - s->skip_count;
avctx->skip_count = s->skip_count;
ff_MPV_frame_end(s);
if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
ff_mjpeg_encode_picture_trailer(s);
if (avctx->rc_buffer_size) {
RateControlContext *rcc = &s->rc_context;
int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
if (put_bits_count(&s->pb) > max_size &&
s->lambda < s->avctx->lmax) {
s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
(s->qscale + 1) / s->qscale);
if (s->adaptive_quant) {
int i;
for (i = 0; i < s->mb_height * s->mb_stride; i++)
s->lambda_table[i] =
FFMAX(s->lambda_table[i] + 1,
s->lambda_table[i] * (s->qscale + 1) /
s->qscale);
}
s->mb_skipped = 0; // done in MPV_frame_start()
// done in encode_picture() so we must undo it
if (s->pict_type == AV_PICTURE_TYPE_P) {
if (s->flipflop_rounding ||
s->codec_id == AV_CODEC_ID_H263P ||
s->codec_id == AV_CODEC_ID_MPEG4)
s->no_rounding ^= 1;
}
if (s->pict_type != AV_PICTURE_TYPE_B) {
s->time_base = s->last_time_base;
s->last_non_b_time = s->time - s->pp_time;
}
//av_log(NULL, AV_LOG_ERROR, "R:%d ", s->next_lambda);
for (i = 0; i < context_count; i++) {
PutBitContext *pb = &s->thread_context[i]->pb;
init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
}
goto vbv_retry;
}
assert(s->avctx->rc_max_rate);
}
if (s->flags & CODEC_FLAG_PASS1)
ff_write_pass1_stats(s);
for (i = 0; i < 4; i++) {
s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
avctx->error[i] += s->current_picture_ptr->f.error[i];
}
if (s->flags & CODEC_FLAG_PASS1)
assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
avctx->i_tex_bits + avctx->p_tex_bits ==
put_bits_count(&s->pb));
flush_put_bits(&s->pb);
s->frame_bits = put_bits_count(&s->pb);
stuffing_count = ff_vbv_update(s, s->frame_bits);
if (stuffing_count) {
if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
stuffing_count + 50) {
av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
return -1;
}
switch (s->codec_id) {
case AV_CODEC_ID_MPEG1VIDEO:
case AV_CODEC_ID_MPEG2VIDEO:
while (stuffing_count--) {
put_bits(&s->pb, 8, 0);
}
break;
case AV_CODEC_ID_MPEG4:
put_bits(&s->pb, 16, 0);
put_bits(&s->pb, 16, 0x1C3);
stuffing_count -= 4;
while (stuffing_count--) {
put_bits(&s->pb, 8, 0xFF);
}
break;
default:
av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
}
flush_put_bits(&s->pb);
s->frame_bits = put_bits_count(&s->pb);
}
/* update mpeg1/2 vbv_delay for CBR */
if (s->avctx->rc_max_rate &&
s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
s->out_format == FMT_MPEG1 &&
90000LL * (avctx->rc_buffer_size - 1) <=
s->avctx->rc_max_rate * 0xFFFFLL) {
int vbv_delay, min_delay;
double inbits = s->avctx->rc_max_rate *
av_q2d(s->avctx->time_base);
int minbits = s->frame_bits - 8 *
(s->vbv_delay_ptr - s->pb.buf - 1);
double bits = s->rc_context.buffer_index + minbits - inbits;
if (bits < 0)
av_log(s->avctx, AV_LOG_ERROR,
"Internal error, negative bits\n");
assert(s->repeat_first_field == 0);
vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
s->avctx->rc_max_rate;
vbv_delay = FFMAX(vbv_delay, min_delay);
assert(vbv_delay < 0xFFFF);
s->vbv_delay_ptr[0] &= 0xF8;
s->vbv_delay_ptr[0] |= vbv_delay >> 13;
s->vbv_delay_ptr[1] = vbv_delay >> 5;
s->vbv_delay_ptr[2] &= 0x07;
s->vbv_delay_ptr[2] |= vbv_delay << 3;
avctx->vbv_delay = vbv_delay * 300;
}
s->total_bits += s->frame_bits;
avctx->frame_bits = s->frame_bits;
pkt->pts = s->current_picture.f.pts;
if (!s->low_delay) {
if (!s->current_picture.f.coded_picture_number)
pkt->dts = pkt->pts - s->dts_delta;
else
pkt->dts = s->reordered_pts;
s->reordered_pts = s->input_picture[0]->f.pts;
} else
pkt->dts = pkt->pts;
if (s->current_picture.f.key_frame)
pkt->flags |= AV_PKT_FLAG_KEY;
if (s->mb_info)
av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
} else {
assert((put_bits_ptr(&s->pb) == s->pb.buf));
s->frame_bits = 0;
}
assert((s->frame_bits & 7) == 0);
pkt->size = s->frame_bits / 8;
*got_packet = !!pkt->size;
return 0;
}
| true | FFmpeg | 19000122a4cc7551cef19ccc6ce4db82d7d290bd | int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *pic_arg, int *got_packet)
{
MpegEncContext *s = avctx->priv_data;
int i, stuffing_count, ret;
int context_count = s->slice_context_count;
s->picture_in_gop_number++;
if (load_input_picture(s, pic_arg) < 0)
return -1;
if (select_input_picture(s) < 0) {
return -1;
}
if (s->new_picture.f.data[0]) {
if (!pkt->data &&
(ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
return ret;
if (s->mb_info) {
s->mb_info_ptr = av_packet_new_side_data(pkt,
AV_PKT_DATA_H263_MB_INFO,
s->mb_width*s->mb_height*12);
s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
}
for (i = 0; i < context_count; i++) {
int start_y = s->thread_context[i]->start_mb_y;
int end_y = s->thread_context[i]-> end_mb_y;
int h = s->mb_height;
uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
uint8_t *end = pkt->data + (size_t)(((int64_t) pkt->size) * end_y / h);
init_put_bits(&s->thread_context[i]->pb, start, end - start);
}
s->pict_type = s->new_picture.f.pict_type;
ff_MPV_frame_start(s, avctx);
vbv_retry:
if (encode_picture(s, s->picture_number) < 0)
return -1;
avctx->header_bits = s->header_bits;
avctx->mv_bits = s->mv_bits;
avctx->misc_bits = s->misc_bits;
avctx->i_tex_bits = s->i_tex_bits;
avctx->p_tex_bits = s->p_tex_bits;
avctx->i_count = s->i_count;
avctx->p_count = s->mb_num - s->i_count - s->skip_count;
avctx->skip_count = s->skip_count;
ff_MPV_frame_end(s);
if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
ff_mjpeg_encode_picture_trailer(s);
if (avctx->rc_buffer_size) {
RateControlContext *rcc = &s->rc_context;
int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
if (put_bits_count(&s->pb) > max_size &&
s->lambda < s->avctx->lmax) {
s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
(s->qscale + 1) / s->qscale);
if (s->adaptive_quant) {
int i;
for (i = 0; i < s->mb_height * s->mb_stride; i++)
s->lambda_table[i] =
FFMAX(s->lambda_table[i] + 1,
s->lambda_table[i] * (s->qscale + 1) /
s->qscale);
}
s->mb_skipped = 0;
if (s->pict_type == AV_PICTURE_TYPE_P) {
if (s->flipflop_rounding ||
s->codec_id == AV_CODEC_ID_H263P ||
s->codec_id == AV_CODEC_ID_MPEG4)
s->no_rounding ^= 1;
}
if (s->pict_type != AV_PICTURE_TYPE_B) {
s->time_base = s->last_time_base;
s->last_non_b_time = s->time - s->pp_time;
}
for (i = 0; i < context_count; i++) {
PutBitContext *pb = &s->thread_context[i]->pb;
init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
}
goto vbv_retry;
}
assert(s->avctx->rc_max_rate);
}
if (s->flags & CODEC_FLAG_PASS1)
ff_write_pass1_stats(s);
for (i = 0; i < 4; i++) {
s->current_picture_ptr->f.error[i] = s->current_picture.f.error[i];
avctx->error[i] += s->current_picture_ptr->f.error[i];
}
if (s->flags & CODEC_FLAG_PASS1)
assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
avctx->i_tex_bits + avctx->p_tex_bits ==
put_bits_count(&s->pb));
flush_put_bits(&s->pb);
s->frame_bits = put_bits_count(&s->pb);
stuffing_count = ff_vbv_update(s, s->frame_bits);
if (stuffing_count) {
if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
stuffing_count + 50) {
av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
return -1;
}
switch (s->codec_id) {
case AV_CODEC_ID_MPEG1VIDEO:
case AV_CODEC_ID_MPEG2VIDEO:
while (stuffing_count--) {
put_bits(&s->pb, 8, 0);
}
break;
case AV_CODEC_ID_MPEG4:
put_bits(&s->pb, 16, 0);
put_bits(&s->pb, 16, 0x1C3);
stuffing_count -= 4;
while (stuffing_count--) {
put_bits(&s->pb, 8, 0xFF);
}
break;
default:
av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
}
flush_put_bits(&s->pb);
s->frame_bits = put_bits_count(&s->pb);
}
if (s->avctx->rc_max_rate &&
s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
s->out_format == FMT_MPEG1 &&
90000LL * (avctx->rc_buffer_size - 1) <=
s->avctx->rc_max_rate * 0xFFFFLL) {
int vbv_delay, min_delay;
double inbits = s->avctx->rc_max_rate *
av_q2d(s->avctx->time_base);
int minbits = s->frame_bits - 8 *
(s->vbv_delay_ptr - s->pb.buf - 1);
double bits = s->rc_context.buffer_index + minbits - inbits;
if (bits < 0)
av_log(s->avctx, AV_LOG_ERROR,
"Internal error, negative bits\n");
assert(s->repeat_first_field == 0);
vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
s->avctx->rc_max_rate;
vbv_delay = FFMAX(vbv_delay, min_delay);
assert(vbv_delay < 0xFFFF);
s->vbv_delay_ptr[0] &= 0xF8;
s->vbv_delay_ptr[0] |= vbv_delay >> 13;
s->vbv_delay_ptr[1] = vbv_delay >> 5;
s->vbv_delay_ptr[2] &= 0x07;
s->vbv_delay_ptr[2] |= vbv_delay << 3;
avctx->vbv_delay = vbv_delay * 300;
}
s->total_bits += s->frame_bits;
avctx->frame_bits = s->frame_bits;
pkt->pts = s->current_picture.f.pts;
if (!s->low_delay) {
if (!s->current_picture.f.coded_picture_number)
pkt->dts = pkt->pts - s->dts_delta;
else
pkt->dts = s->reordered_pts;
s->reordered_pts = s->input_picture[0]->f.pts;
} else
pkt->dts = pkt->pts;
if (s->current_picture.f.key_frame)
pkt->flags |= AV_PKT_FLAG_KEY;
if (s->mb_info)
av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
} else {
assert((put_bits_ptr(&s->pb) == s->pb.buf));
s->frame_bits = 0;
}
assert((s->frame_bits & 7) == 0);
pkt->size = s->frame_bits / 8;
*got_packet = !!pkt->size;
return 0;
}
| {
"code": [
" assert((put_bits_ptr(&s->pb) == s->pb.buf));"
],
"line_no": [
395
]
} | int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1,
const AVFrame *VAR_2, int *VAR_3)
{
MpegEncContext *s = VAR_0->priv_data;
int VAR_12, VAR_5, VAR_6;
int VAR_7 = s->slice_context_count;
s->picture_in_gop_number++;
if (load_input_picture(s, VAR_2) < 0)
return -1;
if (select_input_picture(s) < 0) {
return -1;
}
if (s->new_picture.f.data[0]) {
if (!VAR_1->data &&
(VAR_6 = ff_alloc_packet(VAR_1, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
return VAR_6;
if (s->mb_info) {
s->mb_info_ptr = av_packet_new_side_data(VAR_1,
AV_PKT_DATA_H263_MB_INFO,
s->mb_width*s->mb_height*12);
s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
}
for (VAR_12 = 0; VAR_12 < VAR_7; VAR_12++) {
int VAR_8 = s->thread_context[VAR_12]->start_mb_y;
int VAR_9 = s->thread_context[VAR_12]-> end_mb_y;
int VAR_10 = s->mb_height;
uint8_t *start = VAR_1->data + (size_t)(((int64_t) VAR_1->size) * VAR_8 / VAR_10);
uint8_t *end = VAR_1->data + (size_t)(((int64_t) VAR_1->size) * VAR_9 / VAR_10);
init_put_bits(&s->thread_context[VAR_12]->pb, start, end - start);
}
s->pict_type = s->new_picture.f.pict_type;
ff_MPV_frame_start(s, VAR_0);
vbv_retry:
if (encode_picture(s, s->picture_number) < 0)
return -1;
VAR_0->header_bits = s->header_bits;
VAR_0->mv_bits = s->mv_bits;
VAR_0->misc_bits = s->misc_bits;
VAR_0->i_tex_bits = s->i_tex_bits;
VAR_0->p_tex_bits = s->p_tex_bits;
VAR_0->i_count = s->i_count;
VAR_0->p_count = s->mb_num - s->i_count - s->skip_count;
VAR_0->skip_count = s->skip_count;
ff_MPV_frame_end(s);
if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
ff_mjpeg_encode_picture_trailer(s);
if (VAR_0->rc_buffer_size) {
RateControlContext *rcc = &s->rc_context;
int VAR_11 = rcc->buffer_index * VAR_0->rc_max_available_vbv_use;
if (put_bits_count(&s->pb) > VAR_11 &&
s->lambda < s->VAR_0->lmax) {
s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
(s->qscale + 1) / s->qscale);
if (s->adaptive_quant) {
int VAR_12;
for (VAR_12 = 0; VAR_12 < s->mb_height * s->mb_stride; VAR_12++)
s->lambda_table[VAR_12] =
FFMAX(s->lambda_table[VAR_12] + 1,
s->lambda_table[VAR_12] * (s->qscale + 1) /
s->qscale);
}
s->mb_skipped = 0;
if (s->pict_type == AV_PICTURE_TYPE_P) {
if (s->flipflop_rounding ||
s->codec_id == AV_CODEC_ID_H263P ||
s->codec_id == AV_CODEC_ID_MPEG4)
s->no_rounding ^= 1;
}
if (s->pict_type != AV_PICTURE_TYPE_B) {
s->time_base = s->last_time_base;
s->last_non_b_time = s->time - s->pp_time;
}
for (VAR_12 = 0; VAR_12 < VAR_7; VAR_12++) {
PutBitContext *pb = &s->thread_context[VAR_12]->pb;
init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
}
goto vbv_retry;
}
assert(s->VAR_0->rc_max_rate);
}
if (s->flags & CODEC_FLAG_PASS1)
ff_write_pass1_stats(s);
for (VAR_12 = 0; VAR_12 < 4; VAR_12++) {
s->current_picture_ptr->f.error[VAR_12] = s->current_picture.f.error[VAR_12];
VAR_0->error[VAR_12] += s->current_picture_ptr->f.error[VAR_12];
}
if (s->flags & CODEC_FLAG_PASS1)
assert(VAR_0->header_bits + VAR_0->mv_bits + VAR_0->misc_bits +
VAR_0->i_tex_bits + VAR_0->p_tex_bits ==
put_bits_count(&s->pb));
flush_put_bits(&s->pb);
s->frame_bits = put_bits_count(&s->pb);
VAR_5 = ff_vbv_update(s, s->frame_bits);
if (VAR_5) {
if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
VAR_5 + 50) {
av_log(s->VAR_0, AV_LOG_ERROR, "stuffing too large\n");
return -1;
}
switch (s->codec_id) {
case AV_CODEC_ID_MPEG1VIDEO:
case AV_CODEC_ID_MPEG2VIDEO:
while (VAR_5--) {
put_bits(&s->pb, 8, 0);
}
break;
case AV_CODEC_ID_MPEG4:
put_bits(&s->pb, 16, 0);
put_bits(&s->pb, 16, 0x1C3);
VAR_5 -= 4;
while (VAR_5--) {
put_bits(&s->pb, 8, 0xFF);
}
break;
default:
av_log(s->VAR_0, AV_LOG_ERROR, "vbv buffer overflow\n");
}
flush_put_bits(&s->pb);
s->frame_bits = put_bits_count(&s->pb);
}
if (s->VAR_0->rc_max_rate &&
s->VAR_0->rc_min_rate == s->VAR_0->rc_max_rate &&
s->out_format == FMT_MPEG1 &&
90000LL * (VAR_0->rc_buffer_size - 1) <=
s->VAR_0->rc_max_rate * 0xFFFFLL) {
int VAR_12, VAR_13;
double VAR_14 = s->VAR_0->rc_max_rate *
av_q2d(s->VAR_0->time_base);
int VAR_15 = s->frame_bits - 8 *
(s->vbv_delay_ptr - s->pb.buf - 1);
double VAR_16 = s->rc_context.buffer_index + VAR_15 - VAR_14;
if (VAR_16 < 0)
av_log(s->VAR_0, AV_LOG_ERROR,
"Internal error, negative VAR_16\n");
assert(s->repeat_first_field == 0);
VAR_12 = VAR_16 * 90000 / s->VAR_0->rc_max_rate;
VAR_13 = (VAR_15 * 90000LL + s->VAR_0->rc_max_rate - 1) /
s->VAR_0->rc_max_rate;
VAR_12 = FFMAX(VAR_12, VAR_13);
assert(VAR_12 < 0xFFFF);
s->vbv_delay_ptr[0] &= 0xF8;
s->vbv_delay_ptr[0] |= VAR_12 >> 13;
s->vbv_delay_ptr[1] = VAR_12 >> 5;
s->vbv_delay_ptr[2] &= 0x07;
s->vbv_delay_ptr[2] |= VAR_12 << 3;
VAR_0->VAR_12 = VAR_12 * 300;
}
s->total_bits += s->frame_bits;
VAR_0->frame_bits = s->frame_bits;
VAR_1->pts = s->current_picture.f.pts;
if (!s->low_delay) {
if (!s->current_picture.f.coded_picture_number)
VAR_1->dts = VAR_1->pts - s->dts_delta;
else
VAR_1->dts = s->reordered_pts;
s->reordered_pts = s->input_picture[0]->f.pts;
} else
VAR_1->dts = VAR_1->pts;
if (s->current_picture.f.key_frame)
VAR_1->flags |= AV_PKT_FLAG_KEY;
if (s->mb_info)
av_packet_shrink_side_data(VAR_1, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
} else {
assert((put_bits_ptr(&s->pb) == s->pb.buf));
s->frame_bits = 0;
}
assert((s->frame_bits & 7) == 0);
VAR_1->size = s->frame_bits / 8;
*VAR_3 = !!VAR_1->size;
return 0;
}
| [
"int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1,\nconst AVFrame *VAR_2, int *VAR_3)\n{",
"MpegEncContext *s = VAR_0->priv_data;",
"int VAR_12, VAR_5, VAR_6;",
"int VAR_7 = s->slice_context_count;",
"s->picture_in_gop_number++;",
"if (load_input_picture(s, VAR_2) < 0)\nreturn -1;",
"if (select_input_picture(s) < 0) {",
"return -1;",
"}",
"if (s->new_picture.f.data[0]) {",
"if (!VAR_1->data &&\n(VAR_6 = ff_alloc_packet(VAR_1, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)\nreturn VAR_6;",
"if (s->mb_info) {",
"s->mb_info_ptr = av_packet_new_side_data(VAR_1,\nAV_PKT_DATA_H263_MB_INFO,\ns->mb_width*s->mb_height*12);",
"s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;",
"}",
"for (VAR_12 = 0; VAR_12 < VAR_7; VAR_12++) {",
"int VAR_8 = s->thread_context[VAR_12]->start_mb_y;",
"int VAR_9 = s->thread_context[VAR_12]-> end_mb_y;",
"int VAR_10 = s->mb_height;",
"uint8_t *start = VAR_1->data + (size_t)(((int64_t) VAR_1->size) * VAR_8 / VAR_10);",
"uint8_t *end = VAR_1->data + (size_t)(((int64_t) VAR_1->size) * VAR_9 / VAR_10);",
"init_put_bits(&s->thread_context[VAR_12]->pb, start, end - start);",
"}",
"s->pict_type = s->new_picture.f.pict_type;",
"ff_MPV_frame_start(s, VAR_0);",
"vbv_retry:\nif (encode_picture(s, s->picture_number) < 0)\nreturn -1;",
"VAR_0->header_bits = s->header_bits;",
"VAR_0->mv_bits = s->mv_bits;",
"VAR_0->misc_bits = s->misc_bits;",
"VAR_0->i_tex_bits = s->i_tex_bits;",
"VAR_0->p_tex_bits = s->p_tex_bits;",
"VAR_0->i_count = s->i_count;",
"VAR_0->p_count = s->mb_num - s->i_count - s->skip_count;",
"VAR_0->skip_count = s->skip_count;",
"ff_MPV_frame_end(s);",
"if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)\nff_mjpeg_encode_picture_trailer(s);",
"if (VAR_0->rc_buffer_size) {",
"RateControlContext *rcc = &s->rc_context;",
"int VAR_11 = rcc->buffer_index * VAR_0->rc_max_available_vbv_use;",
"if (put_bits_count(&s->pb) > VAR_11 &&\ns->lambda < s->VAR_0->lmax) {",
"s->next_lambda = FFMAX(s->lambda + 1, s->lambda *\n(s->qscale + 1) / s->qscale);",
"if (s->adaptive_quant) {",
"int VAR_12;",
"for (VAR_12 = 0; VAR_12 < s->mb_height * s->mb_stride; VAR_12++)",
"s->lambda_table[VAR_12] =\nFFMAX(s->lambda_table[VAR_12] + 1,\ns->lambda_table[VAR_12] * (s->qscale + 1) /\ns->qscale);",
"}",
"s->mb_skipped = 0;",
"if (s->pict_type == AV_PICTURE_TYPE_P) {",
"if (s->flipflop_rounding ||\ns->codec_id == AV_CODEC_ID_H263P ||\ns->codec_id == AV_CODEC_ID_MPEG4)\ns->no_rounding ^= 1;",
"}",
"if (s->pict_type != AV_PICTURE_TYPE_B) {",
"s->time_base = s->last_time_base;",
"s->last_non_b_time = s->time - s->pp_time;",
"}",
"for (VAR_12 = 0; VAR_12 < VAR_7; VAR_12++) {",
"PutBitContext *pb = &s->thread_context[VAR_12]->pb;",
"init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);",
"}",
"goto vbv_retry;",
"}",
"assert(s->VAR_0->rc_max_rate);",
"}",
"if (s->flags & CODEC_FLAG_PASS1)\nff_write_pass1_stats(s);",
"for (VAR_12 = 0; VAR_12 < 4; VAR_12++) {",
"s->current_picture_ptr->f.error[VAR_12] = s->current_picture.f.error[VAR_12];",
"VAR_0->error[VAR_12] += s->current_picture_ptr->f.error[VAR_12];",
"}",
"if (s->flags & CODEC_FLAG_PASS1)\nassert(VAR_0->header_bits + VAR_0->mv_bits + VAR_0->misc_bits +\nVAR_0->i_tex_bits + VAR_0->p_tex_bits ==\nput_bits_count(&s->pb));",
"flush_put_bits(&s->pb);",
"s->frame_bits = put_bits_count(&s->pb);",
"VAR_5 = ff_vbv_update(s, s->frame_bits);",
"if (VAR_5) {",
"if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <\nVAR_5 + 50) {",
"av_log(s->VAR_0, AV_LOG_ERROR, \"stuffing too large\\n\");",
"return -1;",
"}",
"switch (s->codec_id) {",
"case AV_CODEC_ID_MPEG1VIDEO:\ncase AV_CODEC_ID_MPEG2VIDEO:\nwhile (VAR_5--) {",
"put_bits(&s->pb, 8, 0);",
"}",
"break;",
"case AV_CODEC_ID_MPEG4:\nput_bits(&s->pb, 16, 0);",
"put_bits(&s->pb, 16, 0x1C3);",
"VAR_5 -= 4;",
"while (VAR_5--) {",
"put_bits(&s->pb, 8, 0xFF);",
"}",
"break;",
"default:\nav_log(s->VAR_0, AV_LOG_ERROR, \"vbv buffer overflow\\n\");",
"}",
"flush_put_bits(&s->pb);",
"s->frame_bits = put_bits_count(&s->pb);",
"}",
"if (s->VAR_0->rc_max_rate &&\ns->VAR_0->rc_min_rate == s->VAR_0->rc_max_rate &&\ns->out_format == FMT_MPEG1 &&\n90000LL * (VAR_0->rc_buffer_size - 1) <=\ns->VAR_0->rc_max_rate * 0xFFFFLL) {",
"int VAR_12, VAR_13;",
"double VAR_14 = s->VAR_0->rc_max_rate *\nav_q2d(s->VAR_0->time_base);",
"int VAR_15 = s->frame_bits - 8 *\n(s->vbv_delay_ptr - s->pb.buf - 1);",
"double VAR_16 = s->rc_context.buffer_index + VAR_15 - VAR_14;",
"if (VAR_16 < 0)\nav_log(s->VAR_0, AV_LOG_ERROR,\n\"Internal error, negative VAR_16\\n\");",
"assert(s->repeat_first_field == 0);",
"VAR_12 = VAR_16 * 90000 / s->VAR_0->rc_max_rate;",
"VAR_13 = (VAR_15 * 90000LL + s->VAR_0->rc_max_rate - 1) /\ns->VAR_0->rc_max_rate;",
"VAR_12 = FFMAX(VAR_12, VAR_13);",
"assert(VAR_12 < 0xFFFF);",
"s->vbv_delay_ptr[0] &= 0xF8;",
"s->vbv_delay_ptr[0] |= VAR_12 >> 13;",
"s->vbv_delay_ptr[1] = VAR_12 >> 5;",
"s->vbv_delay_ptr[2] &= 0x07;",
"s->vbv_delay_ptr[2] |= VAR_12 << 3;",
"VAR_0->VAR_12 = VAR_12 * 300;",
"}",
"s->total_bits += s->frame_bits;",
"VAR_0->frame_bits = s->frame_bits;",
"VAR_1->pts = s->current_picture.f.pts;",
"if (!s->low_delay) {",
"if (!s->current_picture.f.coded_picture_number)\nVAR_1->dts = VAR_1->pts - s->dts_delta;",
"else\nVAR_1->dts = s->reordered_pts;",
"s->reordered_pts = s->input_picture[0]->f.pts;",
"} else",
"VAR_1->dts = VAR_1->pts;",
"if (s->current_picture.f.key_frame)\nVAR_1->flags |= AV_PKT_FLAG_KEY;",
"if (s->mb_info)\nav_packet_shrink_side_data(VAR_1, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);",
"} else {",
"assert((put_bits_ptr(&s->pb) == s->pb.buf));",
"s->frame_bits = 0;",
"}",
"assert((s->frame_bits & 7) == 0);",
"VAR_1->size = s->frame_bits / 8;",
"*VAR_3 = !!VAR_1->size;",
"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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
19,
21
],
[
25
],
[
27
],
[
29
],
[
35
],
[
37,
39,
41
],
[
43
],
[
45,
47,
49
],
[
51
],
[
53
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
71
],
[
73
],
[
77
],
[
85
],
[
87,
89,
91
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
109
],
[
111
],
[
115
],
[
119,
121
],
[
125
],
[
127
],
[
129
],
[
133,
135
],
[
137,
139
],
[
141
],
[
143
],
[
145
],
[
147,
149,
151,
153
],
[
155
],
[
157
],
[
161
],
[
163,
165,
167,
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
183
],
[
185
],
[
187
],
[
189
],
[
191
],
[
193
],
[
197
],
[
199
],
[
203,
205
],
[
209
],
[
211
],
[
213
],
[
215
],
[
219,
221,
223,
225
],
[
227
],
[
229
],
[
233
],
[
235
],
[
237,
239
],
[
241
],
[
243
],
[
245
],
[
249
],
[
251,
253,
255
],
[
257
],
[
259
],
[
261
],
[
263,
265
],
[
267
],
[
269
],
[
271
],
[
273
],
[
275
],
[
277
],
[
279,
281
],
[
283
],
[
285
],
[
287
],
[
289
],
[
295,
297,
299,
301,
303
],
[
305
],
[
307,
309
],
[
311,
313
],
[
315
],
[
319,
321,
323
],
[
327
],
[
331
],
[
333,
335
],
[
339
],
[
343
],
[
347
],
[
349
],
[
351
],
[
353
],
[
355
],
[
357
],
[
359
],
[
361
],
[
363
],
[
367
],
[
369
],
[
371,
373
],
[
375,
377
],
[
379
],
[
381
],
[
383
],
[
385,
387
],
[
389,
391
],
[
393
],
[
395
],
[
397
],
[
399
],
[
401
],
[
405
],
[
407
],
[
409
],
[
411
]
] |
23,997 | static inline void RENAME(rgb32tobgr15)(const uint8_t *src, uint8_t *dst, unsigned src_size)
{
const uint8_t *s = src;
const uint8_t *end;
#ifdef HAVE_MMX
const uint8_t *mm_end;
#endif
uint16_t *d = (uint16_t *)dst;
end = s + src_size;
#ifdef HAVE_MMX
__asm __volatile(PREFETCH" %0"::"m"(*src):"memory");
__asm __volatile(
"movq %0, %%mm7\n\t"
"movq %1, %%mm6\n\t"
::"m"(red_15mask),"m"(green_15mask));
mm_end = end - 15;
while(s < mm_end)
{
__asm __volatile(
PREFETCH" 32%1\n\t"
"movd %1, %%mm0\n\t"
"movd 4%1, %%mm3\n\t"
"punpckldq 8%1, %%mm0\n\t"
"punpckldq 12%1, %%mm3\n\t"
"movq %%mm0, %%mm1\n\t"
"movq %%mm0, %%mm2\n\t"
"movq %%mm3, %%mm4\n\t"
"movq %%mm3, %%mm5\n\t"
"psllq $7, %%mm0\n\t"
"psllq $7, %%mm3\n\t"
"pand %%mm7, %%mm0\n\t"
"pand %%mm7, %%mm3\n\t"
"psrlq $6, %%mm1\n\t"
"psrlq $6, %%mm4\n\t"
"pand %%mm6, %%mm1\n\t"
"pand %%mm6, %%mm4\n\t"
"psrlq $19, %%mm2\n\t"
"psrlq $19, %%mm5\n\t"
"pand %2, %%mm2\n\t"
"pand %2, %%mm5\n\t"
"por %%mm1, %%mm0\n\t"
"por %%mm4, %%mm3\n\t"
"por %%mm2, %%mm0\n\t"
"por %%mm5, %%mm3\n\t"
"psllq $16, %%mm3\n\t"
"por %%mm3, %%mm0\n\t"
MOVNTQ" %%mm0, %0\n\t"
:"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");
d += 4;
s += 16;
}
__asm __volatile(SFENCE:::"memory");
__asm __volatile(EMMS:::"memory");
#endif
while(s < end)
{
const int src= *((uint32_t*)s)++;
*d++ = ((src&0xF8)<<7) + ((src&0xF800)>>6) + ((src&0xF80000)>>19);
}
}
| false | FFmpeg | ae4cffd9fc5bc495692920d646d7d1462315cfa6 | static inline void RENAME(rgb32tobgr15)(const uint8_t *src, uint8_t *dst, unsigned src_size)
{
const uint8_t *s = src;
const uint8_t *end;
#ifdef HAVE_MMX
const uint8_t *mm_end;
#endif
uint16_t *d = (uint16_t *)dst;
end = s + src_size;
#ifdef HAVE_MMX
__asm __volatile(PREFETCH" %0"::"m"(*src):"memory");
__asm __volatile(
"movq %0, %%mm7\n\t"
"movq %1, %%mm6\n\t"
::"m"(red_15mask),"m"(green_15mask));
mm_end = end - 15;
while(s < mm_end)
{
__asm __volatile(
PREFETCH" 32%1\n\t"
"movd %1, %%mm0\n\t"
"movd 4%1, %%mm3\n\t"
"punpckldq 8%1, %%mm0\n\t"
"punpckldq 12%1, %%mm3\n\t"
"movq %%mm0, %%mm1\n\t"
"movq %%mm0, %%mm2\n\t"
"movq %%mm3, %%mm4\n\t"
"movq %%mm3, %%mm5\n\t"
"psllq $7, %%mm0\n\t"
"psllq $7, %%mm3\n\t"
"pand %%mm7, %%mm0\n\t"
"pand %%mm7, %%mm3\n\t"
"psrlq $6, %%mm1\n\t"
"psrlq $6, %%mm4\n\t"
"pand %%mm6, %%mm1\n\t"
"pand %%mm6, %%mm4\n\t"
"psrlq $19, %%mm2\n\t"
"psrlq $19, %%mm5\n\t"
"pand %2, %%mm2\n\t"
"pand %2, %%mm5\n\t"
"por %%mm1, %%mm0\n\t"
"por %%mm4, %%mm3\n\t"
"por %%mm2, %%mm0\n\t"
"por %%mm5, %%mm3\n\t"
"psllq $16, %%mm3\n\t"
"por %%mm3, %%mm0\n\t"
MOVNTQ" %%mm0, %0\n\t"
:"=m"(*d):"m"(*s),"m"(blue_15mask):"memory");
d += 4;
s += 16;
}
__asm __volatile(SFENCE:::"memory");
__asm __volatile(EMMS:::"memory");
#endif
while(s < end)
{
const int src= *((uint32_t*)s)++;
*d++ = ((src&0xF8)<<7) + ((src&0xF800)>>6) + ((src&0xF80000)>>19);
}
}
| {
"code": [],
"line_no": []
} | static inline void FUNC_0(rgb32tobgr15)(const uint8_t *VAR_2, uint8_t *dst, unsigned src_size)
{
const uint8_t *VAR_0 = VAR_2;
const uint8_t *VAR_1;
#ifdef HAVE_MMX
const uint8_t *mm_end;
#endif
uint16_t *d = (uint16_t *)dst;
VAR_1 = VAR_0 + src_size;
#ifdef HAVE_MMX
__asm __volatile(PREFETCH" %0"::"m"(*VAR_2):"memory");
__asm __volatile(
"movq %0, %%mm7\n\t"
"movq %1, %%mm6\n\t"
::"m"(red_15mask),"m"(green_15mask));
mm_end = VAR_1 - 15;
while(VAR_0 < mm_end)
{
__asm __volatile(
PREFETCH" 32%1\n\t"
"movd %1, %%mm0\n\t"
"movd 4%1, %%mm3\n\t"
"punpckldq 8%1, %%mm0\n\t"
"punpckldq 12%1, %%mm3\n\t"
"movq %%mm0, %%mm1\n\t"
"movq %%mm0, %%mm2\n\t"
"movq %%mm3, %%mm4\n\t"
"movq %%mm3, %%mm5\n\t"
"psllq $7, %%mm0\n\t"
"psllq $7, %%mm3\n\t"
"pand %%mm7, %%mm0\n\t"
"pand %%mm7, %%mm3\n\t"
"psrlq $6, %%mm1\n\t"
"psrlq $6, %%mm4\n\t"
"pand %%mm6, %%mm1\n\t"
"pand %%mm6, %%mm4\n\t"
"psrlq $19, %%mm2\n\t"
"psrlq $19, %%mm5\n\t"
"pand %2, %%mm2\n\t"
"pand %2, %%mm5\n\t"
"por %%mm1, %%mm0\n\t"
"por %%mm4, %%mm3\n\t"
"por %%mm2, %%mm0\n\t"
"por %%mm5, %%mm3\n\t"
"psllq $16, %%mm3\n\t"
"por %%mm3, %%mm0\n\t"
MOVNTQ" %%mm0, %0\n\t"
:"=m"(*d):"m"(*VAR_0),"m"(blue_15mask):"memory");
d += 4;
VAR_0 += 16;
}
__asm __volatile(SFENCE:::"memory");
__asm __volatile(EMMS:::"memory");
#endif
while(VAR_0 < VAR_1)
{
const int VAR_2= *((uint32_t*)VAR_0)++;
*d++ = ((VAR_2&0xF8)<<7) + ((VAR_2&0xF800)>>6) + ((VAR_2&0xF80000)>>19);
}
}
| [
"static inline void FUNC_0(rgb32tobgr15)(const uint8_t *VAR_2, uint8_t *dst, unsigned src_size)\n{",
"const uint8_t *VAR_0 = VAR_2;",
"const uint8_t *VAR_1;",
"#ifdef HAVE_MMX\nconst uint8_t *mm_end;",
"#endif\nuint16_t *d = (uint16_t *)dst;",
"VAR_1 = VAR_0 + src_size;",
"#ifdef HAVE_MMX\n__asm __volatile(PREFETCH\"\t%0\"::\"m\"(*VAR_2):\"memory\");",
"__asm __volatile(\n\"movq\t%0, %%mm7\\n\\t\"\n\"movq\t%1, %%mm6\\n\\t\"\n::\"m\"(red_15mask),\"m\"(green_15mask));",
"mm_end = VAR_1 - 15;",
"while(VAR_0 < mm_end)\n{",
"__asm __volatile(\nPREFETCH\" 32%1\\n\\t\"\n\"movd\t%1, %%mm0\\n\\t\"\n\"movd\t4%1, %%mm3\\n\\t\"\n\"punpckldq 8%1, %%mm0\\n\\t\"\n\"punpckldq 12%1, %%mm3\\n\\t\"\n\"movq\t%%mm0, %%mm1\\n\\t\"\n\"movq\t%%mm0, %%mm2\\n\\t\"\n\"movq\t%%mm3, %%mm4\\n\\t\"\n\"movq\t%%mm3, %%mm5\\n\\t\"\n\"psllq\t$7, %%mm0\\n\\t\"\n\"psllq\t$7, %%mm3\\n\\t\"\n\"pand\t%%mm7, %%mm0\\n\\t\"\n\"pand\t%%mm7, %%mm3\\n\\t\"\n\"psrlq\t$6, %%mm1\\n\\t\"\n\"psrlq\t$6, %%mm4\\n\\t\"\n\"pand\t%%mm6, %%mm1\\n\\t\"\n\"pand\t%%mm6, %%mm4\\n\\t\"\n\"psrlq\t$19, %%mm2\\n\\t\"\n\"psrlq\t$19, %%mm5\\n\\t\"\n\"pand\t%2, %%mm2\\n\\t\"\n\"pand\t%2, %%mm5\\n\\t\"\n\"por\t%%mm1, %%mm0\\n\\t\"\n\"por\t%%mm4, %%mm3\\n\\t\"\n\"por\t%%mm2, %%mm0\\n\\t\"\n\"por\t%%mm5, %%mm3\\n\\t\"\n\"psllq\t$16, %%mm3\\n\\t\"\n\"por\t%%mm3, %%mm0\\n\\t\"\nMOVNTQ\"\t%%mm0, %0\\n\\t\"\n:\"=m\"(*d):\"m\"(*VAR_0),\"m\"(blue_15mask):\"memory\");",
"d += 4;",
"VAR_0 += 16;",
"}",
"__asm __volatile(SFENCE:::\"memory\");",
"__asm __volatile(EMMS:::\"memory\");",
"#endif\nwhile(VAR_0 < VAR_1)\n{",
"const int VAR_2= *((uint32_t*)VAR_0)++;",
"*d++ = ((VAR_2&0xF8)<<7) + ((VAR_2&0xF800)>>6) + ((VAR_2&0xF80000)>>19);",
"}",
"}"
] | [
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
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107,
109,
111
],
[
113
],
[
115
],
[
117
],
[
119
]
] |
23,998 | static void FUNC(hevc_loop_filter_chroma)(uint8_t *_pix, ptrdiff_t _xstride,
ptrdiff_t _ystride, int *_tc,
uint8_t *_no_p, uint8_t *_no_q)
{
int d, j, no_p, no_q;
pixel *pix = (pixel *)_pix;
ptrdiff_t xstride = _xstride / sizeof(pixel);
ptrdiff_t ystride = _ystride / sizeof(pixel);
for (j = 0; j < 2; j++) {
const int tc = _tc[j] << (BIT_DEPTH - 8);
if (tc <= 0) {
pix += 4 * ystride;
continue;
}
no_p = _no_p[j];
no_q = _no_q[j];
for (d = 0; d < 4; d++) {
int delta0;
const int p1 = P1;
const int p0 = P0;
const int q0 = Q0;
const int q1 = Q1;
delta0 = av_clip((((q0 - p0) << 2) + p1 - q1 + 4) >> 3, -tc, tc);
if (!no_p)
P0 = av_clip_pixel(p0 + delta0);
if (!no_q)
Q0 = av_clip_pixel(q0 - delta0);
pix += ystride;
}
}
}
| false | FFmpeg | 8eeacf31c5ea37baf6b222dc38d20cf4fd33c455 | static void FUNC(hevc_loop_filter_chroma)(uint8_t *_pix, ptrdiff_t _xstride,
ptrdiff_t _ystride, int *_tc,
uint8_t *_no_p, uint8_t *_no_q)
{
int d, j, no_p, no_q;
pixel *pix = (pixel *)_pix;
ptrdiff_t xstride = _xstride / sizeof(pixel);
ptrdiff_t ystride = _ystride / sizeof(pixel);
for (j = 0; j < 2; j++) {
const int tc = _tc[j] << (BIT_DEPTH - 8);
if (tc <= 0) {
pix += 4 * ystride;
continue;
}
no_p = _no_p[j];
no_q = _no_q[j];
for (d = 0; d < 4; d++) {
int delta0;
const int p1 = P1;
const int p0 = P0;
const int q0 = Q0;
const int q1 = Q1;
delta0 = av_clip((((q0 - p0) << 2) + p1 - q1 + 4) >> 3, -tc, tc);
if (!no_p)
P0 = av_clip_pixel(p0 + delta0);
if (!no_q)
Q0 = av_clip_pixel(q0 - delta0);
pix += ystride;
}
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(hevc_loop_filter_chroma)(uint8_t *_pix, ptrdiff_t _xstride,
ptrdiff_t _ystride, int *_tc,
uint8_t *_no_p, uint8_t *_no_q)
{
int VAR_0, VAR_1, VAR_2, VAR_3;
pixel *pix = (pixel *)_pix;
ptrdiff_t xstride = _xstride / sizeof(pixel);
ptrdiff_t ystride = _ystride / sizeof(pixel);
for (VAR_1 = 0; VAR_1 < 2; VAR_1++) {
const int VAR_4 = _tc[VAR_1] << (BIT_DEPTH - 8);
if (VAR_4 <= 0) {
pix += 4 * ystride;
continue;
}
VAR_2 = _no_p[VAR_1];
VAR_3 = _no_q[VAR_1];
for (VAR_0 = 0; VAR_0 < 4; VAR_0++) {
int VAR_5;
const int VAR_6 = P1;
const int VAR_7 = P0;
const int VAR_8 = Q0;
const int VAR_9 = Q1;
VAR_5 = av_clip((((VAR_8 - VAR_7) << 2) + VAR_6 - VAR_9 + 4) >> 3, -VAR_4, VAR_4);
if (!VAR_2)
P0 = av_clip_pixel(VAR_7 + VAR_5);
if (!VAR_3)
Q0 = av_clip_pixel(VAR_8 - VAR_5);
pix += ystride;
}
}
}
| [
"static void FUNC_0(hevc_loop_filter_chroma)(uint8_t *_pix, ptrdiff_t _xstride,\nptrdiff_t _ystride, int *_tc,\nuint8_t *_no_p, uint8_t *_no_q)\n{",
"int VAR_0, VAR_1, VAR_2, VAR_3;",
"pixel *pix = (pixel *)_pix;",
"ptrdiff_t xstride = _xstride / sizeof(pixel);",
"ptrdiff_t ystride = _ystride / sizeof(pixel);",
"for (VAR_1 = 0; VAR_1 < 2; VAR_1++) {",
"const int VAR_4 = _tc[VAR_1] << (BIT_DEPTH - 8);",
"if (VAR_4 <= 0) {",
"pix += 4 * ystride;",
"continue;",
"}",
"VAR_2 = _no_p[VAR_1];",
"VAR_3 = _no_q[VAR_1];",
"for (VAR_0 = 0; VAR_0 < 4; VAR_0++) {",
"int VAR_5;",
"const int VAR_6 = P1;",
"const int VAR_7 = P0;",
"const int VAR_8 = Q0;",
"const int VAR_9 = Q1;",
"VAR_5 = av_clip((((VAR_8 - VAR_7) << 2) + VAR_6 - VAR_9 + 4) >> 3, -VAR_4, VAR_4);",
"if (!VAR_2)\nP0 = av_clip_pixel(VAR_7 + VAR_5);",
"if (!VAR_3)\nQ0 = av_clip_pixel(VAR_8 - VAR_5);",
"pix += ystride;",
"}",
"}",
"}"
] | [
0,
0,
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
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51,
53
],
[
55,
57
],
[
59
],
[
61
],
[
63
],
[
65
]
] |
23,999 | static inline void xchg_mb_border(H264Context *h, uint8_t *src_y,
uint8_t *src_cb, uint8_t *src_cr,
int linesize, int uvlinesize,
int xchg, int simple, int pixel_shift){
MpegEncContext * const s = &h->s;
int deblock_left;
int deblock_top;
int top_idx = 1;
uint8_t *top_border_m1;
uint8_t *top_border;
if(!simple && FRAME_MBAFF){
if(s->mb_y&1){
if(!MB_MBAFF)
return;
}else{
top_idx = MB_MBAFF ? 0 : 1;
}
}
if(h->deblocking_filter == 2) {
deblock_left = h->left_type[0];
deblock_top = h->top_type;
} else {
deblock_left = (s->mb_x > 0);
deblock_top = (s->mb_y > !!MB_FIELD);
}
src_y -= linesize + 1 + pixel_shift;
src_cb -= uvlinesize + 1 + pixel_shift;
src_cr -= uvlinesize + 1 + pixel_shift;
top_border_m1 = h->top_borders[top_idx][s->mb_x-1];
top_border = h->top_borders[top_idx][s->mb_x];
#define XCHG(a,b,xchg)\
if (pixel_shift) {\
if (xchg) {\
AV_SWAP64(b+0,a+0);\
AV_SWAP64(b+8,a+8);\
} else {\
AV_COPY128(b,a); \
}\
} else \
if (xchg) AV_SWAP64(b,a);\
else AV_COPY64(b,a);
if(deblock_top){
if(deblock_left){
XCHG(top_border_m1 + (8 << pixel_shift), src_y - (7 << pixel_shift), 1);
}
XCHG(top_border + (0 << pixel_shift), src_y + (1 << pixel_shift), xchg);
XCHG(top_border + (8 << pixel_shift), src_y + (9 << pixel_shift), 1);
if(s->mb_x+1 < s->mb_width){
XCHG(h->top_borders[top_idx][s->mb_x+1], src_y + (17 << pixel_shift), 1);
}
}
if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
if(deblock_top){
if(deblock_left){
XCHG(top_border_m1 + (16 << pixel_shift), src_cb - (7 << pixel_shift), 1);
XCHG(top_border_m1 + (24 << pixel_shift), src_cr - (7 << pixel_shift), 1);
}
XCHG(top_border + (16 << pixel_shift), src_cb+1+pixel_shift, 1);
XCHG(top_border + (24 << pixel_shift), src_cr+1+pixel_shift, 1);
}
}
}
| false | FFmpeg | 4e987f8282ff7658a6f804b9db39954bb59fa72e | static inline void xchg_mb_border(H264Context *h, uint8_t *src_y,
uint8_t *src_cb, uint8_t *src_cr,
int linesize, int uvlinesize,
int xchg, int simple, int pixel_shift){
MpegEncContext * const s = &h->s;
int deblock_left;
int deblock_top;
int top_idx = 1;
uint8_t *top_border_m1;
uint8_t *top_border;
if(!simple && FRAME_MBAFF){
if(s->mb_y&1){
if(!MB_MBAFF)
return;
}else{
top_idx = MB_MBAFF ? 0 : 1;
}
}
if(h->deblocking_filter == 2) {
deblock_left = h->left_type[0];
deblock_top = h->top_type;
} else {
deblock_left = (s->mb_x > 0);
deblock_top = (s->mb_y > !!MB_FIELD);
}
src_y -= linesize + 1 + pixel_shift;
src_cb -= uvlinesize + 1 + pixel_shift;
src_cr -= uvlinesize + 1 + pixel_shift;
top_border_m1 = h->top_borders[top_idx][s->mb_x-1];
top_border = h->top_borders[top_idx][s->mb_x];
#define XCHG(a,b,xchg)\
if (pixel_shift) {\
if (xchg) {\
AV_SWAP64(b+0,a+0);\
AV_SWAP64(b+8,a+8);\
} else {\
AV_COPY128(b,a); \
}\
} else \
if (xchg) AV_SWAP64(b,a);\
else AV_COPY64(b,a);
if(deblock_top){
if(deblock_left){
XCHG(top_border_m1 + (8 << pixel_shift), src_y - (7 << pixel_shift), 1);
}
XCHG(top_border + (0 << pixel_shift), src_y + (1 << pixel_shift), xchg);
XCHG(top_border + (8 << pixel_shift), src_y + (9 << pixel_shift), 1);
if(s->mb_x+1 < s->mb_width){
XCHG(h->top_borders[top_idx][s->mb_x+1], src_y + (17 << pixel_shift), 1);
}
}
if(simple || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
if(deblock_top){
if(deblock_left){
XCHG(top_border_m1 + (16 << pixel_shift), src_cb - (7 << pixel_shift), 1);
XCHG(top_border_m1 + (24 << pixel_shift), src_cr - (7 << pixel_shift), 1);
}
XCHG(top_border + (16 << pixel_shift), src_cb+1+pixel_shift, 1);
XCHG(top_border + (24 << pixel_shift), src_cr+1+pixel_shift, 1);
}
}
}
| {
"code": [],
"line_no": []
} | static inline void FUNC_0(H264Context *VAR_0, uint8_t *VAR_1,
uint8_t *VAR_2, uint8_t *VAR_3,
int VAR_4, int VAR_5,
int VAR_6, int VAR_7, int VAR_8){
MpegEncContext * const s = &VAR_0->s;
int VAR_9;
int VAR_10;
int VAR_11 = 1;
uint8_t *top_border_m1;
uint8_t *top_border;
if(!VAR_7 && FRAME_MBAFF){
if(s->mb_y&1){
if(!MB_MBAFF)
return;
}else{
VAR_11 = MB_MBAFF ? 0 : 1;
}
}
if(VAR_0->deblocking_filter == 2) {
VAR_9 = VAR_0->left_type[0];
VAR_10 = VAR_0->top_type;
} else {
VAR_9 = (s->mb_x > 0);
VAR_10 = (s->mb_y > !!MB_FIELD);
}
VAR_1 -= VAR_4 + 1 + VAR_8;
VAR_2 -= VAR_5 + 1 + VAR_8;
VAR_3 -= VAR_5 + 1 + VAR_8;
top_border_m1 = VAR_0->top_borders[VAR_11][s->mb_x-1];
top_border = VAR_0->top_borders[VAR_11][s->mb_x];
#define XCHG(a,b,VAR_6)\
if (VAR_8) {\
if (VAR_6) {\
AV_SWAP64(b+0,a+0);\
AV_SWAP64(b+8,a+8);\
} else {\
AV_COPY128(b,a); \
}\
} else \
if (VAR_6) AV_SWAP64(b,a);\
else AV_COPY64(b,a);
if(VAR_10){
if(VAR_9){
XCHG(top_border_m1 + (8 << VAR_8), VAR_1 - (7 << VAR_8), 1);
}
XCHG(top_border + (0 << VAR_8), VAR_1 + (1 << VAR_8), VAR_6);
XCHG(top_border + (8 << VAR_8), VAR_1 + (9 << VAR_8), 1);
if(s->mb_x+1 < s->mb_width){
XCHG(VAR_0->top_borders[VAR_11][s->mb_x+1], VAR_1 + (17 << VAR_8), 1);
}
}
if(VAR_7 || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
if(VAR_10){
if(VAR_9){
XCHG(top_border_m1 + (16 << VAR_8), VAR_2 - (7 << VAR_8), 1);
XCHG(top_border_m1 + (24 << VAR_8), VAR_3 - (7 << VAR_8), 1);
}
XCHG(top_border + (16 << VAR_8), VAR_2+1+VAR_8, 1);
XCHG(top_border + (24 << VAR_8), VAR_3+1+VAR_8, 1);
}
}
}
| [
"static inline void FUNC_0(H264Context *VAR_0, uint8_t *VAR_1,\nuint8_t *VAR_2, uint8_t *VAR_3,\nint VAR_4, int VAR_5,\nint VAR_6, int VAR_7, int VAR_8){",
"MpegEncContext * const s = &VAR_0->s;",
"int VAR_9;",
"int VAR_10;",
"int VAR_11 = 1;",
"uint8_t *top_border_m1;",
"uint8_t *top_border;",
"if(!VAR_7 && FRAME_MBAFF){",
"if(s->mb_y&1){",
"if(!MB_MBAFF)\nreturn;",
"}else{",
"VAR_11 = MB_MBAFF ? 0 : 1;",
"}",
"}",
"if(VAR_0->deblocking_filter == 2) {",
"VAR_9 = VAR_0->left_type[0];",
"VAR_10 = VAR_0->top_type;",
"} else {",
"VAR_9 = (s->mb_x > 0);",
"VAR_10 = (s->mb_y > !!MB_FIELD);",
"}",
"VAR_1 -= VAR_4 + 1 + VAR_8;",
"VAR_2 -= VAR_5 + 1 + VAR_8;",
"VAR_3 -= VAR_5 + 1 + VAR_8;",
"top_border_m1 = VAR_0->top_borders[VAR_11][s->mb_x-1];",
"top_border = VAR_0->top_borders[VAR_11][s->mb_x];",
"#define XCHG(a,b,VAR_6)\\\nif (VAR_8) {\\",
"if (VAR_6) {\\",
"AV_SWAP64(b+0,a+0);\\",
"AV_SWAP64(b+8,a+8);\\",
"} else {\\",
"AV_COPY128(b,a); \\",
"}\\",
"} else \\",
"if (VAR_6) AV_SWAP64(b,a);\\",
"else AV_COPY64(b,a);",
"if(VAR_10){",
"if(VAR_9){",
"XCHG(top_border_m1 + (8 << VAR_8), VAR_1 - (7 << VAR_8), 1);",
"}",
"XCHG(top_border + (0 << VAR_8), VAR_1 + (1 << VAR_8), VAR_6);",
"XCHG(top_border + (8 << VAR_8), VAR_1 + (9 << VAR_8), 1);",
"if(s->mb_x+1 < s->mb_width){",
"XCHG(VAR_0->top_borders[VAR_11][s->mb_x+1], VAR_1 + (17 << VAR_8), 1);",
"}",
"}",
"if(VAR_7 || !CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){",
"if(VAR_10){",
"if(VAR_9){",
"XCHG(top_border_m1 + (16 << VAR_8), VAR_2 - (7 << VAR_8), 1);",
"XCHG(top_border_m1 + (24 << VAR_8), VAR_3 - (7 << VAR_8), 1);",
"}",
"XCHG(top_border + (16 << VAR_8), VAR_2+1+VAR_8, 1);",
"XCHG(top_border + (24 << VAR_8), VAR_3+1+VAR_8, 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
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
57
],
[
59
],
[
61
],
[
65
],
[
67
],
[
71,
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
]
] |
24,000 | static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
AVPacket *avpkt)
{
int ret;
HEVCContext *s = avctx->priv_data;
if (!avpkt->size) {
ret = ff_hevc_output_frame(s, data, 1);
if (ret < 0)
return ret;
*got_output = ret;
return 0;
}
s->ref = NULL;
ret = decode_nal_units(s, avpkt->data, avpkt->size);
if (ret < 0)
return ret;
/* verify the SEI checksum */
if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
avctx->err_recognition & AV_EF_EXPLODE &&
s->is_md5) {
ret = verify_md5(s, s->ref->frame);
if (ret < 0) {
ff_hevc_unref_frame(s, s->ref, ~0);
return ret;
}
}
s->is_md5 = 0;
if (s->is_decoded) {
av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
s->is_decoded = 0;
}
if (s->output_frame->buf[0]) {
av_frame_move_ref(data, s->output_frame);
*got_output = 1;
}
return avpkt->size;
}
| false | FFmpeg | f1783c05f1398b7a08f16f6aafbcf38a5323e770 | static int hevc_decode_frame(AVCodecContext *avctx, void *data, int *got_output,
AVPacket *avpkt)
{
int ret;
HEVCContext *s = avctx->priv_data;
if (!avpkt->size) {
ret = ff_hevc_output_frame(s, data, 1);
if (ret < 0)
return ret;
*got_output = ret;
return 0;
}
s->ref = NULL;
ret = decode_nal_units(s, avpkt->data, avpkt->size);
if (ret < 0)
return ret;
if (avctx->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
avctx->err_recognition & AV_EF_EXPLODE &&
s->is_md5) {
ret = verify_md5(s, s->ref->frame);
if (ret < 0) {
ff_hevc_unref_frame(s, s->ref, ~0);
return ret;
}
}
s->is_md5 = 0;
if (s->is_decoded) {
av_log(avctx, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
s->is_decoded = 0;
}
if (s->output_frame->buf[0]) {
av_frame_move_ref(data, s->output_frame);
*got_output = 1;
}
return avpkt->size;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,
AVPacket *VAR_3)
{
int VAR_4;
HEVCContext *s = VAR_0->priv_data;
if (!VAR_3->size) {
VAR_4 = ff_hevc_output_frame(s, VAR_1, 1);
if (VAR_4 < 0)
return VAR_4;
*VAR_2 = VAR_4;
return 0;
}
s->ref = NULL;
VAR_4 = decode_nal_units(s, VAR_3->VAR_1, VAR_3->size);
if (VAR_4 < 0)
return VAR_4;
if (VAR_0->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&
VAR_0->err_recognition & AV_EF_EXPLODE &&
s->is_md5) {
VAR_4 = verify_md5(s, s->ref->frame);
if (VAR_4 < 0) {
ff_hevc_unref_frame(s, s->ref, ~0);
return VAR_4;
}
}
s->is_md5 = 0;
if (s->is_decoded) {
av_log(VAR_0, AV_LOG_DEBUG, "Decoded frame with POC %d.\n", s->poc);
s->is_decoded = 0;
}
if (s->output_frame->buf[0]) {
av_frame_move_ref(VAR_1, s->output_frame);
*VAR_2 = 1;
}
return VAR_3->size;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2,\nAVPacket *VAR_3)\n{",
"int VAR_4;",
"HEVCContext *s = VAR_0->priv_data;",
"if (!VAR_3->size) {",
"VAR_4 = ff_hevc_output_frame(s, VAR_1, 1);",
"if (VAR_4 < 0)\nreturn VAR_4;",
"*VAR_2 = VAR_4;",
"return 0;",
"}",
"s->ref = NULL;",
"VAR_4 = decode_nal_units(s, VAR_3->VAR_1, VAR_3->size);",
"if (VAR_4 < 0)\nreturn VAR_4;",
"if (VAR_0->err_recognition & AV_EF_CRCCHECK && s->is_decoded &&\nVAR_0->err_recognition & AV_EF_EXPLODE &&\ns->is_md5) {",
"VAR_4 = verify_md5(s, s->ref->frame);",
"if (VAR_4 < 0) {",
"ff_hevc_unref_frame(s, s->ref, ~0);",
"return VAR_4;",
"}",
"}",
"s->is_md5 = 0;",
"if (s->is_decoded) {",
"av_log(VAR_0, AV_LOG_DEBUG, \"Decoded frame with POC %d.\\n\", s->poc);",
"s->is_decoded = 0;",
"}",
"if (s->output_frame->buf[0]) {",
"av_frame_move_ref(VAR_1, s->output_frame);",
"*VAR_2 = 1;",
"}",
"return VAR_3->size;",
"}"
] | [
0,
0,
0,
0,
0,
0,
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
],
[
27
],
[
31
],
[
33
],
[
35,
37
],
[
43,
45,
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65
],
[
67
],
[
69
],
[
71
],
[
75
],
[
77
],
[
79
],
[
81
],
[
85
],
[
87
]
] |
24,001 | static uint16_t nvme_get_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
{
uint32_t dw10 = le32_to_cpu(cmd->cdw10);
uint32_t result;
switch (dw10) {
case NVME_VOLATILE_WRITE_CACHE:
result = blk_enable_write_cache(n->conf.blk);
break;
case NVME_NUMBER_OF_QUEUES:
result = cpu_to_le32((n->num_queues - 1) | ((n->num_queues - 1) << 16));
break;
default:
return NVME_INVALID_FIELD | NVME_DNR;
}
req->cqe.result = result;
return NVME_SUCCESS;
}
| true | qemu | cdd346371e09709be8e46398bb097dc690a746f2 | static uint16_t nvme_get_feature(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
{
uint32_t dw10 = le32_to_cpu(cmd->cdw10);
uint32_t result;
switch (dw10) {
case NVME_VOLATILE_WRITE_CACHE:
result = blk_enable_write_cache(n->conf.blk);
break;
case NVME_NUMBER_OF_QUEUES:
result = cpu_to_le32((n->num_queues - 1) | ((n->num_queues - 1) << 16));
break;
default:
return NVME_INVALID_FIELD | NVME_DNR;
}
req->cqe.result = result;
return NVME_SUCCESS;
}
| {
"code": [
" result = cpu_to_le32((n->num_queues - 1) | ((n->num_queues - 1) << 16));"
],
"line_no": [
21
]
} | static uint16_t FUNC_0(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)
{
uint32_t dw10 = le32_to_cpu(cmd->cdw10);
uint32_t result;
switch (dw10) {
case NVME_VOLATILE_WRITE_CACHE:
result = blk_enable_write_cache(n->conf.blk);
break;
case NVME_NUMBER_OF_QUEUES:
result = cpu_to_le32((n->num_queues - 1) | ((n->num_queues - 1) << 16));
break;
default:
return NVME_INVALID_FIELD | NVME_DNR;
}
req->cqe.result = result;
return NVME_SUCCESS;
}
| [
"static uint16_t FUNC_0(NvmeCtrl *n, NvmeCmd *cmd, NvmeRequest *req)\n{",
"uint32_t dw10 = le32_to_cpu(cmd->cdw10);",
"uint32_t result;",
"switch (dw10) {",
"case NVME_VOLATILE_WRITE_CACHE:\nresult = blk_enable_write_cache(n->conf.blk);",
"break;",
"case NVME_NUMBER_OF_QUEUES:\nresult = cpu_to_le32((n->num_queues - 1) | ((n->num_queues - 1) << 16));",
"break;",
"default:\nreturn NVME_INVALID_FIELD | NVME_DNR;",
"}",
"req->cqe.result = result;",
"return NVME_SUCCESS;",
"}"
] | [
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13,
15
],
[
17
],
[
19,
21
],
[
23
],
[
25,
27
],
[
29
],
[
33
],
[
35
],
[
37
]
] |
24,002 | static int decode_subframe(TAKDecContext *s, int32_t *decoded,
int subframe_size, int prev_subframe_size)
{
GetBitContext *gb = &s->gb;
int x, y, i, j, ret = 0;
int dshift, size, filter_quant, filter_order, filter_order16;
int tfilter[MAX_PREDICTORS];
if (!get_bits1(gb))
return decode_residues(s, decoded, subframe_size);
filter_order = predictor_sizes[get_bits(gb, 4)];
if (prev_subframe_size > 0 && get_bits1(gb)) {
if (filter_order > prev_subframe_size)
return AVERROR_INVALIDDATA;
decoded -= filter_order;
subframe_size += filter_order;
if (filter_order > subframe_size)
return AVERROR_INVALIDDATA;
} else {
int lpc_mode;
if (filter_order > subframe_size)
return AVERROR_INVALIDDATA;
lpc_mode = get_bits(gb, 2);
if (lpc_mode > 2)
return AVERROR_INVALIDDATA;
if ((ret = decode_residues(s, decoded, filter_order)) < 0)
return ret;
if (lpc_mode)
decode_lpc(decoded, lpc_mode, filter_order);
}
dshift = get_bits_esc4(gb);
size = get_bits1(gb) + 6;
filter_quant = 10;
if (get_bits1(gb)) {
filter_quant -= get_bits(gb, 3) + 1;
if (filter_quant < 3)
return AVERROR_INVALIDDATA;
}
s->predictors[0] = get_sbits(gb, 10);
s->predictors[1] = get_sbits(gb, 10);
s->predictors[2] = get_sbits(gb, size) << (10 - size);
s->predictors[3] = get_sbits(gb, size) << (10 - size);
if (filter_order > 4) {
int tmp = size - get_bits1(gb);
for (i = 4; i < filter_order; i++) {
if (!(i & 3))
x = tmp - get_bits(gb, 2);
s->predictors[i] = get_sbits(gb, x) << (10 - size);
}
}
tfilter[0] = s->predictors[0] << 6;
for (i = 1; i < filter_order; i++) {
int32_t *p1 = &tfilter[0];
int32_t *p2 = &tfilter[i - 1];
for (j = 0; j < (i + 1) / 2; j++) {
x = *p1 + (s->predictors[i] * *p2 + 256 >> 9);
*p2 += s->predictors[i] * *p1 + 256 >> 9;
*p1++ = x;
p2--;
}
tfilter[i] = s->predictors[i] << 6;
}
filter_order16 = FFALIGN(filter_order, 16);
AV_ZERO128(s->filter + filter_order16 - 16);
AV_ZERO128(s->filter + filter_order16 - 8);
x = 1 << (32 - (15 - filter_quant));
y = 1 << ((15 - filter_quant) - 1);
for (i = 0, j = filter_order - 1; i < filter_order / 2; i++, j--) {
s->filter[j] = x - ((tfilter[i] + y) >> (15 - filter_quant));
s->filter[i] = x - ((tfilter[j] + y) >> (15 - filter_quant));
}
if ((ret = decode_residues(s, &decoded[filter_order],
subframe_size - filter_order)) < 0)
return ret;
for (i = 0; i < filter_order; i++)
s->residues[i] = *decoded++ >> dshift;
y = FF_ARRAY_ELEMS(s->residues) - filter_order;
x = subframe_size - filter_order;
while (x > 0) {
int tmp = FFMIN(y, x);
for (i = 0; i < tmp; i++) {
int v = 1 << (filter_quant - 1);
v += s->adsp.scalarproduct_int16(&s->residues[i], s->filter,
filter_order16);
v = (av_clip_intp2(v >> filter_quant, 13) << dshift) - *decoded;
*decoded++ = v;
s->residues[filter_order + i] = v >> dshift;
}
x -= tmp;
if (x > 0)
memcpy(s->residues, &s->residues[y], 2 * filter_order);
}
emms_c();
return 0;
}
| true | FFmpeg | 03616af2c91309d58f9419becf45d292cb93e625 | static int decode_subframe(TAKDecContext *s, int32_t *decoded,
int subframe_size, int prev_subframe_size)
{
GetBitContext *gb = &s->gb;
int x, y, i, j, ret = 0;
int dshift, size, filter_quant, filter_order, filter_order16;
int tfilter[MAX_PREDICTORS];
if (!get_bits1(gb))
return decode_residues(s, decoded, subframe_size);
filter_order = predictor_sizes[get_bits(gb, 4)];
if (prev_subframe_size > 0 && get_bits1(gb)) {
if (filter_order > prev_subframe_size)
return AVERROR_INVALIDDATA;
decoded -= filter_order;
subframe_size += filter_order;
if (filter_order > subframe_size)
return AVERROR_INVALIDDATA;
} else {
int lpc_mode;
if (filter_order > subframe_size)
return AVERROR_INVALIDDATA;
lpc_mode = get_bits(gb, 2);
if (lpc_mode > 2)
return AVERROR_INVALIDDATA;
if ((ret = decode_residues(s, decoded, filter_order)) < 0)
return ret;
if (lpc_mode)
decode_lpc(decoded, lpc_mode, filter_order);
}
dshift = get_bits_esc4(gb);
size = get_bits1(gb) + 6;
filter_quant = 10;
if (get_bits1(gb)) {
filter_quant -= get_bits(gb, 3) + 1;
if (filter_quant < 3)
return AVERROR_INVALIDDATA;
}
s->predictors[0] = get_sbits(gb, 10);
s->predictors[1] = get_sbits(gb, 10);
s->predictors[2] = get_sbits(gb, size) << (10 - size);
s->predictors[3] = get_sbits(gb, size) << (10 - size);
if (filter_order > 4) {
int tmp = size - get_bits1(gb);
for (i = 4; i < filter_order; i++) {
if (!(i & 3))
x = tmp - get_bits(gb, 2);
s->predictors[i] = get_sbits(gb, x) << (10 - size);
}
}
tfilter[0] = s->predictors[0] << 6;
for (i = 1; i < filter_order; i++) {
int32_t *p1 = &tfilter[0];
int32_t *p2 = &tfilter[i - 1];
for (j = 0; j < (i + 1) / 2; j++) {
x = *p1 + (s->predictors[i] * *p2 + 256 >> 9);
*p2 += s->predictors[i] * *p1 + 256 >> 9;
*p1++ = x;
p2--;
}
tfilter[i] = s->predictors[i] << 6;
}
filter_order16 = FFALIGN(filter_order, 16);
AV_ZERO128(s->filter + filter_order16 - 16);
AV_ZERO128(s->filter + filter_order16 - 8);
x = 1 << (32 - (15 - filter_quant));
y = 1 << ((15 - filter_quant) - 1);
for (i = 0, j = filter_order - 1; i < filter_order / 2; i++, j--) {
s->filter[j] = x - ((tfilter[i] + y) >> (15 - filter_quant));
s->filter[i] = x - ((tfilter[j] + y) >> (15 - filter_quant));
}
if ((ret = decode_residues(s, &decoded[filter_order],
subframe_size - filter_order)) < 0)
return ret;
for (i = 0; i < filter_order; i++)
s->residues[i] = *decoded++ >> dshift;
y = FF_ARRAY_ELEMS(s->residues) - filter_order;
x = subframe_size - filter_order;
while (x > 0) {
int tmp = FFMIN(y, x);
for (i = 0; i < tmp; i++) {
int v = 1 << (filter_quant - 1);
v += s->adsp.scalarproduct_int16(&s->residues[i], s->filter,
filter_order16);
v = (av_clip_intp2(v >> filter_quant, 13) << dshift) - *decoded;
*decoded++ = v;
s->residues[filter_order + i] = v >> dshift;
}
x -= tmp;
if (x > 0)
memcpy(s->residues, &s->residues[y], 2 * filter_order);
}
emms_c();
return 0;
}
| {
"code": [
" int dshift, size, filter_quant, filter_order, filter_order16;",
" filter_order16 = FFALIGN(filter_order, 16);",
" AV_ZERO128(s->filter + filter_order16 - 16);",
" AV_ZERO128(s->filter + filter_order16 - 8);",
" v += s->adsp.scalarproduct_int16(&s->residues[i], s->filter,",
" filter_order16);"
],
"line_no": [
11,
157,
159,
161,
207,
209
]
} | static int FUNC_0(TAKDecContext *VAR_0, int32_t *VAR_1,
int VAR_2, int VAR_3)
{
GetBitContext *gb = &VAR_0->gb;
int VAR_4, VAR_5, VAR_6, VAR_7, VAR_8 = 0;
int VAR_9, VAR_10, VAR_11, VAR_12, VAR_13;
int VAR_14[MAX_PREDICTORS];
if (!get_bits1(gb))
return decode_residues(VAR_0, VAR_1, VAR_2);
VAR_12 = predictor_sizes[get_bits(gb, 4)];
if (VAR_3 > 0 && get_bits1(gb)) {
if (VAR_12 > VAR_3)
return AVERROR_INVALIDDATA;
VAR_1 -= VAR_12;
VAR_2 += VAR_12;
if (VAR_12 > VAR_2)
return AVERROR_INVALIDDATA;
} else {
int VAR_15;
if (VAR_12 > VAR_2)
return AVERROR_INVALIDDATA;
VAR_15 = get_bits(gb, 2);
if (VAR_15 > 2)
return AVERROR_INVALIDDATA;
if ((VAR_8 = decode_residues(VAR_0, VAR_1, VAR_12)) < 0)
return VAR_8;
if (VAR_15)
decode_lpc(VAR_1, VAR_15, VAR_12);
}
VAR_9 = get_bits_esc4(gb);
VAR_10 = get_bits1(gb) + 6;
VAR_11 = 10;
if (get_bits1(gb)) {
VAR_11 -= get_bits(gb, 3) + 1;
if (VAR_11 < 3)
return AVERROR_INVALIDDATA;
}
VAR_0->predictors[0] = get_sbits(gb, 10);
VAR_0->predictors[1] = get_sbits(gb, 10);
VAR_0->predictors[2] = get_sbits(gb, VAR_10) << (10 - VAR_10);
VAR_0->predictors[3] = get_sbits(gb, VAR_10) << (10 - VAR_10);
if (VAR_12 > 4) {
int VAR_17 = VAR_10 - get_bits1(gb);
for (VAR_6 = 4; VAR_6 < VAR_12; VAR_6++) {
if (!(VAR_6 & 3))
VAR_4 = VAR_17 - get_bits(gb, 2);
VAR_0->predictors[VAR_6] = get_sbits(gb, VAR_4) << (10 - VAR_10);
}
}
VAR_14[0] = VAR_0->predictors[0] << 6;
for (VAR_6 = 1; VAR_6 < VAR_12; VAR_6++) {
int32_t *p1 = &VAR_14[0];
int32_t *p2 = &VAR_14[VAR_6 - 1];
for (VAR_7 = 0; VAR_7 < (VAR_6 + 1) / 2; VAR_7++) {
VAR_4 = *p1 + (VAR_0->predictors[VAR_6] * *p2 + 256 >> 9);
*p2 += VAR_0->predictors[VAR_6] * *p1 + 256 >> 9;
*p1++ = VAR_4;
p2--;
}
VAR_14[VAR_6] = VAR_0->predictors[VAR_6] << 6;
}
VAR_13 = FFALIGN(VAR_12, 16);
AV_ZERO128(VAR_0->filter + VAR_13 - 16);
AV_ZERO128(VAR_0->filter + VAR_13 - 8);
VAR_4 = 1 << (32 - (15 - VAR_11));
VAR_5 = 1 << ((15 - VAR_11) - 1);
for (VAR_6 = 0, VAR_7 = VAR_12 - 1; VAR_6 < VAR_12 / 2; VAR_6++, VAR_7--) {
VAR_0->filter[VAR_7] = VAR_4 - ((VAR_14[VAR_6] + VAR_5) >> (15 - VAR_11));
VAR_0->filter[VAR_6] = VAR_4 - ((VAR_14[VAR_7] + VAR_5) >> (15 - VAR_11));
}
if ((VAR_8 = decode_residues(VAR_0, &VAR_1[VAR_12],
VAR_2 - VAR_12)) < 0)
return VAR_8;
for (VAR_6 = 0; VAR_6 < VAR_12; VAR_6++)
VAR_0->residues[VAR_6] = *VAR_1++ >> VAR_9;
VAR_5 = FF_ARRAY_ELEMS(VAR_0->residues) - VAR_12;
VAR_4 = VAR_2 - VAR_12;
while (VAR_4 > 0) {
int VAR_17 = FFMIN(VAR_5, VAR_4);
for (VAR_6 = 0; VAR_6 < VAR_17; VAR_6++) {
int VAR_17 = 1 << (VAR_11 - 1);
VAR_17 += VAR_0->adsp.scalarproduct_int16(&VAR_0->residues[VAR_6], VAR_0->filter,
VAR_13);
VAR_17 = (av_clip_intp2(VAR_17 >> VAR_11, 13) << VAR_9) - *VAR_1;
*VAR_1++ = VAR_17;
VAR_0->residues[VAR_12 + VAR_6] = VAR_17 >> VAR_9;
}
VAR_4 -= VAR_17;
if (VAR_4 > 0)
memcpy(VAR_0->residues, &VAR_0->residues[VAR_5], 2 * VAR_12);
}
emms_c();
return 0;
}
| [
"static int FUNC_0(TAKDecContext *VAR_0, int32_t *VAR_1,\nint VAR_2, int VAR_3)\n{",
"GetBitContext *gb = &VAR_0->gb;",
"int VAR_4, VAR_5, VAR_6, VAR_7, VAR_8 = 0;",
"int VAR_9, VAR_10, VAR_11, VAR_12, VAR_13;",
"int VAR_14[MAX_PREDICTORS];",
"if (!get_bits1(gb))\nreturn decode_residues(VAR_0, VAR_1, VAR_2);",
"VAR_12 = predictor_sizes[get_bits(gb, 4)];",
"if (VAR_3 > 0 && get_bits1(gb)) {",
"if (VAR_12 > VAR_3)\nreturn AVERROR_INVALIDDATA;",
"VAR_1 -= VAR_12;",
"VAR_2 += VAR_12;",
"if (VAR_12 > VAR_2)\nreturn AVERROR_INVALIDDATA;",
"} else {",
"int VAR_15;",
"if (VAR_12 > VAR_2)\nreturn AVERROR_INVALIDDATA;",
"VAR_15 = get_bits(gb, 2);",
"if (VAR_15 > 2)\nreturn AVERROR_INVALIDDATA;",
"if ((VAR_8 = decode_residues(VAR_0, VAR_1, VAR_12)) < 0)\nreturn VAR_8;",
"if (VAR_15)\ndecode_lpc(VAR_1, VAR_15, VAR_12);",
"}",
"VAR_9 = get_bits_esc4(gb);",
"VAR_10 = get_bits1(gb) + 6;",
"VAR_11 = 10;",
"if (get_bits1(gb)) {",
"VAR_11 -= get_bits(gb, 3) + 1;",
"if (VAR_11 < 3)\nreturn AVERROR_INVALIDDATA;",
"}",
"VAR_0->predictors[0] = get_sbits(gb, 10);",
"VAR_0->predictors[1] = get_sbits(gb, 10);",
"VAR_0->predictors[2] = get_sbits(gb, VAR_10) << (10 - VAR_10);",
"VAR_0->predictors[3] = get_sbits(gb, VAR_10) << (10 - VAR_10);",
"if (VAR_12 > 4) {",
"int VAR_17 = VAR_10 - get_bits1(gb);",
"for (VAR_6 = 4; VAR_6 < VAR_12; VAR_6++) {",
"if (!(VAR_6 & 3))\nVAR_4 = VAR_17 - get_bits(gb, 2);",
"VAR_0->predictors[VAR_6] = get_sbits(gb, VAR_4) << (10 - VAR_10);",
"}",
"}",
"VAR_14[0] = VAR_0->predictors[0] << 6;",
"for (VAR_6 = 1; VAR_6 < VAR_12; VAR_6++) {",
"int32_t *p1 = &VAR_14[0];",
"int32_t *p2 = &VAR_14[VAR_6 - 1];",
"for (VAR_7 = 0; VAR_7 < (VAR_6 + 1) / 2; VAR_7++) {",
"VAR_4 = *p1 + (VAR_0->predictors[VAR_6] * *p2 + 256 >> 9);",
"*p2 += VAR_0->predictors[VAR_6] * *p1 + 256 >> 9;",
"*p1++ = VAR_4;",
"p2--;",
"}",
"VAR_14[VAR_6] = VAR_0->predictors[VAR_6] << 6;",
"}",
"VAR_13 = FFALIGN(VAR_12, 16);",
"AV_ZERO128(VAR_0->filter + VAR_13 - 16);",
"AV_ZERO128(VAR_0->filter + VAR_13 - 8);",
"VAR_4 = 1 << (32 - (15 - VAR_11));",
"VAR_5 = 1 << ((15 - VAR_11) - 1);",
"for (VAR_6 = 0, VAR_7 = VAR_12 - 1; VAR_6 < VAR_12 / 2; VAR_6++, VAR_7--) {",
"VAR_0->filter[VAR_7] = VAR_4 - ((VAR_14[VAR_6] + VAR_5) >> (15 - VAR_11));",
"VAR_0->filter[VAR_6] = VAR_4 - ((VAR_14[VAR_7] + VAR_5) >> (15 - VAR_11));",
"}",
"if ((VAR_8 = decode_residues(VAR_0, &VAR_1[VAR_12],\nVAR_2 - VAR_12)) < 0)\nreturn VAR_8;",
"for (VAR_6 = 0; VAR_6 < VAR_12; VAR_6++)",
"VAR_0->residues[VAR_6] = *VAR_1++ >> VAR_9;",
"VAR_5 = FF_ARRAY_ELEMS(VAR_0->residues) - VAR_12;",
"VAR_4 = VAR_2 - VAR_12;",
"while (VAR_4 > 0) {",
"int VAR_17 = FFMIN(VAR_5, VAR_4);",
"for (VAR_6 = 0; VAR_6 < VAR_17; VAR_6++) {",
"int VAR_17 = 1 << (VAR_11 - 1);",
"VAR_17 += VAR_0->adsp.scalarproduct_int16(&VAR_0->residues[VAR_6], VAR_0->filter,\nVAR_13);",
"VAR_17 = (av_clip_intp2(VAR_17 >> VAR_11, 13) << VAR_9) - *VAR_1;",
"*VAR_1++ = VAR_17;",
"VAR_0->residues[VAR_12 + VAR_6] = VAR_17 >> VAR_9;",
"}",
"VAR_4 -= VAR_17;",
"if (VAR_4 > 0)\nmemcpy(VAR_0->residues, &VAR_0->residues[VAR_5], 2 * VAR_12);",
"}",
"emms_c();",
"return 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,
1,
1,
1,
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
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17,
19
],
[
23
],
[
27
],
[
29,
31
],
[
35
],
[
37
],
[
41,
43
],
[
45
],
[
47
],
[
51,
53
],
[
57
],
[
59,
61
],
[
65,
67
],
[
71,
73
],
[
75
],
[
79
],
[
81
],
[
85
],
[
87
],
[
89
],
[
91,
93
],
[
95
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
113
],
[
115,
117
],
[
119
],
[
121
],
[
123
],
[
127
],
[
129
],
[
131
],
[
133
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
151
],
[
153
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
177,
179,
181
],
[
185
],
[
187
],
[
191
],
[
193
],
[
195
],
[
197
],
[
201
],
[
203
],
[
207,
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
221
],
[
223,
225
],
[
227
],
[
231
],
[
235
],
[
237
]
] |
24,003 | iscsi_allocmap_update(IscsiLun *iscsilun, int64_t sector_num,
int nb_sectors, bool allocated, bool valid)
{
int64_t cl_num_expanded, nb_cls_expanded, cl_num_shrunk, nb_cls_shrunk;
if (iscsilun->allocmap == NULL) {
return;
}
/* expand to entirely contain all affected clusters */
cl_num_expanded = sector_num / iscsilun->cluster_sectors;
nb_cls_expanded = DIV_ROUND_UP(sector_num + nb_sectors,
iscsilun->cluster_sectors) - cl_num_expanded;
/* shrink to touch only completely contained clusters */
cl_num_shrunk = DIV_ROUND_UP(sector_num, iscsilun->cluster_sectors);
nb_cls_shrunk = (sector_num + nb_sectors) / iscsilun->cluster_sectors
- cl_num_shrunk;
if (allocated) {
bitmap_set(iscsilun->allocmap, cl_num_expanded, nb_cls_expanded);
} else {
bitmap_clear(iscsilun->allocmap, cl_num_shrunk, nb_cls_shrunk);
}
if (iscsilun->allocmap_valid == NULL) {
return;
}
if (valid) {
bitmap_set(iscsilun->allocmap_valid, cl_num_shrunk, nb_cls_shrunk);
} else {
bitmap_clear(iscsilun->allocmap_valid, cl_num_expanded,
nb_cls_expanded);
}
}
| true | qemu | 1da45e0c4cf4719fa75898d019e0874b9b2bc774 | iscsi_allocmap_update(IscsiLun *iscsilun, int64_t sector_num,
int nb_sectors, bool allocated, bool valid)
{
int64_t cl_num_expanded, nb_cls_expanded, cl_num_shrunk, nb_cls_shrunk;
if (iscsilun->allocmap == NULL) {
return;
}
cl_num_expanded = sector_num / iscsilun->cluster_sectors;
nb_cls_expanded = DIV_ROUND_UP(sector_num + nb_sectors,
iscsilun->cluster_sectors) - cl_num_expanded;
cl_num_shrunk = DIV_ROUND_UP(sector_num, iscsilun->cluster_sectors);
nb_cls_shrunk = (sector_num + nb_sectors) / iscsilun->cluster_sectors
- cl_num_shrunk;
if (allocated) {
bitmap_set(iscsilun->allocmap, cl_num_expanded, nb_cls_expanded);
} else {
bitmap_clear(iscsilun->allocmap, cl_num_shrunk, nb_cls_shrunk);
}
if (iscsilun->allocmap_valid == NULL) {
return;
}
if (valid) {
bitmap_set(iscsilun->allocmap_valid, cl_num_shrunk, nb_cls_shrunk);
} else {
bitmap_clear(iscsilun->allocmap_valid, cl_num_expanded,
nb_cls_expanded);
}
}
| {
"code": [
" bitmap_clear(iscsilun->allocmap, cl_num_shrunk, nb_cls_shrunk);",
" bitmap_set(iscsilun->allocmap_valid, cl_num_shrunk, nb_cls_shrunk);"
],
"line_no": [
39,
53
]
} | FUNC_0(IscsiLun *VAR_0, int64_t VAR_1,
int VAR_2, bool VAR_3, bool VAR_4)
{
int64_t cl_num_expanded, nb_cls_expanded, cl_num_shrunk, nb_cls_shrunk;
if (VAR_0->allocmap == NULL) {
return;
}
cl_num_expanded = VAR_1 / VAR_0->cluster_sectors;
nb_cls_expanded = DIV_ROUND_UP(VAR_1 + VAR_2,
VAR_0->cluster_sectors) - cl_num_expanded;
cl_num_shrunk = DIV_ROUND_UP(VAR_1, VAR_0->cluster_sectors);
nb_cls_shrunk = (VAR_1 + VAR_2) / VAR_0->cluster_sectors
- cl_num_shrunk;
if (VAR_3) {
bitmap_set(VAR_0->allocmap, cl_num_expanded, nb_cls_expanded);
} else {
bitmap_clear(VAR_0->allocmap, cl_num_shrunk, nb_cls_shrunk);
}
if (VAR_0->allocmap_valid == NULL) {
return;
}
if (VAR_4) {
bitmap_set(VAR_0->allocmap_valid, cl_num_shrunk, nb_cls_shrunk);
} else {
bitmap_clear(VAR_0->allocmap_valid, cl_num_expanded,
nb_cls_expanded);
}
}
| [
"FUNC_0(IscsiLun *VAR_0, int64_t VAR_1,\nint VAR_2, bool VAR_3, bool VAR_4)\n{",
"int64_t cl_num_expanded, nb_cls_expanded, cl_num_shrunk, nb_cls_shrunk;",
"if (VAR_0->allocmap == NULL) {",
"return;",
"}",
"cl_num_expanded = VAR_1 / VAR_0->cluster_sectors;",
"nb_cls_expanded = DIV_ROUND_UP(VAR_1 + VAR_2,\nVAR_0->cluster_sectors) - cl_num_expanded;",
"cl_num_shrunk = DIV_ROUND_UP(VAR_1, VAR_0->cluster_sectors);",
"nb_cls_shrunk = (VAR_1 + VAR_2) / VAR_0->cluster_sectors\n- cl_num_shrunk;",
"if (VAR_3) {",
"bitmap_set(VAR_0->allocmap, cl_num_expanded, nb_cls_expanded);",
"} else {",
"bitmap_clear(VAR_0->allocmap, cl_num_shrunk, nb_cls_shrunk);",
"}",
"if (VAR_0->allocmap_valid == NULL) {",
"return;",
"}",
"if (VAR_4) {",
"bitmap_set(VAR_0->allocmap_valid, cl_num_shrunk, nb_cls_shrunk);",
"} else {",
"bitmap_clear(VAR_0->allocmap_valid, cl_num_expanded,\nnb_cls_expanded);",
"}",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21,
23
],
[
27
],
[
29,
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57,
59
],
[
61
],
[
63
]
] |
24,004 | static int dca_decode_frame(AVCodecContext * avctx,
void *data, int *data_size,
const uint8_t * buf, int buf_size)
{
int i, j, k;
int16_t *samples = data;
DCAContext *s = avctx->priv_data;
int channels;
s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
if (s->dca_buffer_size == -1) {
av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
return -1;
}
init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
if (dca_parse_frame_header(s) < 0) {
//seems like the frame is corrupt, try with the next one
*data_size=0;
return buf_size;
}
//set AVCodec values with parsed data
avctx->sample_rate = s->sample_rate;
avctx->bit_rate = s->bit_rate;
channels = s->prim_channels + !!s->lfe;
if(avctx->request_channels == 2 && s->prim_channels > 2) {
channels = 2;
s->output = DCA_STEREO;
}
avctx->channels = channels;
if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
return -1;
*data_size = 0;
for (i = 0; i < (s->sample_blocks / 8); i++) {
dca_decode_block(s);
s->dsp.float_to_int16(s->tsamples, s->samples, 256 * channels);
/* interleave samples */
for (j = 0; j < 256; j++) {
for (k = 0; k < channels; k++)
samples[k] = s->tsamples[j + k * 256];
samples += channels;
}
*data_size += 256 * sizeof(int16_t) * channels;
}
return buf_size;
}
| true | FFmpeg | 4a24837e07c4782658d1475b77506bccc3d0b5e2 | static int dca_decode_frame(AVCodecContext * avctx,
void *data, int *data_size,
const uint8_t * buf, int buf_size)
{
int i, j, k;
int16_t *samples = data;
DCAContext *s = avctx->priv_data;
int channels;
s->dca_buffer_size = dca_convert_bitstream(buf, buf_size, s->dca_buffer, DCA_MAX_FRAME_SIZE);
if (s->dca_buffer_size == -1) {
av_log(avctx, AV_LOG_ERROR, "Not a valid DCA frame\n");
return -1;
}
init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
if (dca_parse_frame_header(s) < 0) {
*data_size=0;
return buf_size;
}
avctx->sample_rate = s->sample_rate;
avctx->bit_rate = s->bit_rate;
channels = s->prim_channels + !!s->lfe;
if(avctx->request_channels == 2 && s->prim_channels > 2) {
channels = 2;
s->output = DCA_STEREO;
}
avctx->channels = channels;
if(*data_size < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * channels)
return -1;
*data_size = 0;
for (i = 0; i < (s->sample_blocks / 8); i++) {
dca_decode_block(s);
s->dsp.float_to_int16(s->tsamples, s->samples, 256 * channels);
for (j = 0; j < 256; j++) {
for (k = 0; k < channels; k++)
samples[k] = s->tsamples[j + k * 256];
samples += channels;
}
*data_size += 256 * sizeof(int16_t) * channels;
}
return buf_size;
}
| {
"code": [
" avctx->channels = channels;"
],
"line_no": [
67
]
} | static int FUNC_0(AVCodecContext * VAR_0,
void *VAR_1, int *VAR_2,
const uint8_t * VAR_3, int VAR_4)
{
int VAR_5, VAR_6, VAR_7;
int16_t *samples = VAR_1;
DCAContext *s = VAR_0->priv_data;
int VAR_8;
s->dca_buffer_size = dca_convert_bitstream(VAR_3, VAR_4, s->dca_buffer, DCA_MAX_FRAME_SIZE);
if (s->dca_buffer_size == -1) {
av_log(VAR_0, AV_LOG_ERROR, "Not a valid DCA frame\n");
return -1;
}
init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);
if (dca_parse_frame_header(s) < 0) {
*VAR_2=0;
return VAR_4;
}
VAR_0->sample_rate = s->sample_rate;
VAR_0->bit_rate = s->bit_rate;
VAR_8 = s->prim_channels + !!s->lfe;
if(VAR_0->request_channels == 2 && s->prim_channels > 2) {
VAR_8 = 2;
s->output = DCA_STEREO;
}
VAR_0->VAR_8 = VAR_8;
if(*VAR_2 < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * VAR_8)
return -1;
*VAR_2 = 0;
for (VAR_5 = 0; VAR_5 < (s->sample_blocks / 8); VAR_5++) {
dca_decode_block(s);
s->dsp.float_to_int16(s->tsamples, s->samples, 256 * VAR_8);
for (VAR_6 = 0; VAR_6 < 256; VAR_6++) {
for (VAR_7 = 0; VAR_7 < VAR_8; VAR_7++)
samples[VAR_7] = s->tsamples[VAR_6 + VAR_7 * 256];
samples += VAR_8;
}
*VAR_2 += 256 * sizeof(int16_t) * VAR_8;
}
return VAR_4;
}
| [
"static int FUNC_0(AVCodecContext * VAR_0,\nvoid *VAR_1, int *VAR_2,\nconst uint8_t * VAR_3, int VAR_4)\n{",
"int VAR_5, VAR_6, VAR_7;",
"int16_t *samples = VAR_1;",
"DCAContext *s = VAR_0->priv_data;",
"int VAR_8;",
"s->dca_buffer_size = dca_convert_bitstream(VAR_3, VAR_4, s->dca_buffer, DCA_MAX_FRAME_SIZE);",
"if (s->dca_buffer_size == -1) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Not a valid DCA frame\\n\");",
"return -1;",
"}",
"init_get_bits(&s->gb, s->dca_buffer, s->dca_buffer_size * 8);",
"if (dca_parse_frame_header(s) < 0) {",
"*VAR_2=0;",
"return VAR_4;",
"}",
"VAR_0->sample_rate = s->sample_rate;",
"VAR_0->bit_rate = s->bit_rate;",
"VAR_8 = s->prim_channels + !!s->lfe;",
"if(VAR_0->request_channels == 2 && s->prim_channels > 2) {",
"VAR_8 = 2;",
"s->output = DCA_STEREO;",
"}",
"VAR_0->VAR_8 = VAR_8;",
"if(*VAR_2 < (s->sample_blocks / 8) * 256 * sizeof(int16_t) * VAR_8)\nreturn -1;",
"*VAR_2 = 0;",
"for (VAR_5 = 0; VAR_5 < (s->sample_blocks / 8); VAR_5++) {",
"dca_decode_block(s);",
"s->dsp.float_to_int16(s->tsamples, s->samples, 256 * VAR_8);",
"for (VAR_6 = 0; VAR_6 < 256; VAR_6++) {",
"for (VAR_7 = 0; VAR_7 < VAR_8; VAR_7++)",
"samples[VAR_7] = s->tsamples[VAR_6 + VAR_7 * 256];",
"samples += VAR_8;",
"}",
"*VAR_2 += 256 * sizeof(int16_t) * VAR_8;",
"}",
"return VAR_4;",
"}"
] | [
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
] | [
[
1,
3,
5,
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
49
],
[
51
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69,
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
99
],
[
101
]
] |
24,005 | static int teletext_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *pkt)
{
TeletextContext *ctx = avctx->priv_data;
AVSubtitle *sub = data;
int ret = 0;
if (!ctx->vbi) {
if (!(ctx->vbi = vbi_decoder_new()))
return AVERROR(ENOMEM);
if (!vbi_event_handler_add(ctx->vbi, VBI_EVENT_TTX_PAGE, handler, ctx)) {
vbi_decoder_delete(ctx->vbi);
ctx->vbi = NULL;
return AVERROR(ENOMEM);
}
}
if (avctx->pkt_timebase.den && pkt->pts != AV_NOPTS_VALUE)
ctx->pts = av_rescale_q(pkt->pts, avctx->pkt_timebase, AV_TIME_BASE_Q);
if (pkt->size) {
int lines;
const int full_pes_size = pkt->size + 45; /* PES header is 45 bytes */
// We allow unreasonably big packets, even if the standard only allows a max size of 1472
if (full_pes_size < 184 || full_pes_size > 65504 || full_pes_size % 184 != 0)
return AVERROR_INVALIDDATA;
ctx->handler_ret = pkt->size;
if (data_identifier_is_teletext(*pkt->data)) {
if ((lines = slice_to_vbi_lines(ctx, pkt->data + 1, pkt->size - 1)) < 0)
return lines;
av_dlog(avctx, "ctx=%p buf_size=%d lines=%u pkt_pts=%7.3f\n",
ctx, pkt->size, lines, (double)pkt->pts/90000.0);
if (lines > 0) {
#ifdef DEBUG
int i;
av_log(avctx, AV_LOG_DEBUG, "line numbers:");
for(i = 0; i < lines; i++)
av_log(avctx, AV_LOG_DEBUG, " %d", ctx->sliced[i].line);
av_log(avctx, AV_LOG_DEBUG, "\n");
#endif
vbi_decode(ctx->vbi, ctx->sliced, lines, 0.0);
ctx->lines_processed += lines;
}
}
ctx->pts = AV_NOPTS_VALUE;
ret = ctx->handler_ret;
}
if (ret < 0)
return ret;
// is there a subtitle to pass?
if (ctx->nb_pages) {
int i;
sub->format = ctx->format_id;
sub->start_display_time = 0;
sub->end_display_time = ctx->sub_duration;
sub->num_rects = 0;
sub->pts = ctx->pages->pts;
if (ctx->pages->sub_rect->type != SUBTITLE_NONE) {
sub->rects = av_malloc(sizeof(*sub->rects));
if (sub->rects) {
sub->num_rects = 1;
sub->rects[0] = ctx->pages->sub_rect;
} else {
ret = AVERROR(ENOMEM);
}
} else {
av_log(avctx, AV_LOG_DEBUG, "sending empty sub\n");
sub->rects = NULL;
}
if (!sub->rects) // no rect was passed
subtitle_rect_free(&ctx->pages->sub_rect);
for (i = 0; i < ctx->nb_pages - 1; i++)
ctx->pages[i] = ctx->pages[i + 1];
ctx->nb_pages--;
if (ret >= 0)
*data_size = 1;
} else
*data_size = 0;
return ret;
}
| false | FFmpeg | 229843aa359ae0c9519977d7fa952688db63f559 | static int teletext_decode_frame(AVCodecContext *avctx, void *data, int *data_size, AVPacket *pkt)
{
TeletextContext *ctx = avctx->priv_data;
AVSubtitle *sub = data;
int ret = 0;
if (!ctx->vbi) {
if (!(ctx->vbi = vbi_decoder_new()))
return AVERROR(ENOMEM);
if (!vbi_event_handler_add(ctx->vbi, VBI_EVENT_TTX_PAGE, handler, ctx)) {
vbi_decoder_delete(ctx->vbi);
ctx->vbi = NULL;
return AVERROR(ENOMEM);
}
}
if (avctx->pkt_timebase.den && pkt->pts != AV_NOPTS_VALUE)
ctx->pts = av_rescale_q(pkt->pts, avctx->pkt_timebase, AV_TIME_BASE_Q);
if (pkt->size) {
int lines;
const int full_pes_size = pkt->size + 45;
if (full_pes_size < 184 || full_pes_size > 65504 || full_pes_size % 184 != 0)
return AVERROR_INVALIDDATA;
ctx->handler_ret = pkt->size;
if (data_identifier_is_teletext(*pkt->data)) {
if ((lines = slice_to_vbi_lines(ctx, pkt->data + 1, pkt->size - 1)) < 0)
return lines;
av_dlog(avctx, "ctx=%p buf_size=%d lines=%u pkt_pts=%7.3f\n",
ctx, pkt->size, lines, (double)pkt->pts/90000.0);
if (lines > 0) {
#ifdef DEBUG
int i;
av_log(avctx, AV_LOG_DEBUG, "line numbers:");
for(i = 0; i < lines; i++)
av_log(avctx, AV_LOG_DEBUG, " %d", ctx->sliced[i].line);
av_log(avctx, AV_LOG_DEBUG, "\n");
#endif
vbi_decode(ctx->vbi, ctx->sliced, lines, 0.0);
ctx->lines_processed += lines;
}
}
ctx->pts = AV_NOPTS_VALUE;
ret = ctx->handler_ret;
}
if (ret < 0)
return ret;
if (ctx->nb_pages) {
int i;
sub->format = ctx->format_id;
sub->start_display_time = 0;
sub->end_display_time = ctx->sub_duration;
sub->num_rects = 0;
sub->pts = ctx->pages->pts;
if (ctx->pages->sub_rect->type != SUBTITLE_NONE) {
sub->rects = av_malloc(sizeof(*sub->rects));
if (sub->rects) {
sub->num_rects = 1;
sub->rects[0] = ctx->pages->sub_rect;
} else {
ret = AVERROR(ENOMEM);
}
} else {
av_log(avctx, AV_LOG_DEBUG, "sending empty sub\n");
sub->rects = NULL;
}
if (!sub->rects)
subtitle_rect_free(&ctx->pages->sub_rect);
for (i = 0; i < ctx->nb_pages - 1; i++)
ctx->pages[i] = ctx->pages[i + 1];
ctx->nb_pages--;
if (ret >= 0)
*data_size = 1;
} else
*data_size = 0;
return ret;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2, AVPacket *VAR_3)
{
TeletextContext *ctx = VAR_0->priv_data;
AVSubtitle *sub = VAR_1;
int VAR_4 = 0;
if (!ctx->vbi) {
if (!(ctx->vbi = vbi_decoder_new()))
return AVERROR(ENOMEM);
if (!vbi_event_handler_add(ctx->vbi, VBI_EVENT_TTX_PAGE, handler, ctx)) {
vbi_decoder_delete(ctx->vbi);
ctx->vbi = NULL;
return AVERROR(ENOMEM);
}
}
if (VAR_0->pkt_timebase.den && VAR_3->pts != AV_NOPTS_VALUE)
ctx->pts = av_rescale_q(VAR_3->pts, VAR_0->pkt_timebase, AV_TIME_BASE_Q);
if (VAR_3->size) {
int VAR_5;
const int VAR_6 = VAR_3->size + 45;
if (VAR_6 < 184 || VAR_6 > 65504 || VAR_6 % 184 != 0)
return AVERROR_INVALIDDATA;
ctx->handler_ret = VAR_3->size;
if (data_identifier_is_teletext(*VAR_3->VAR_1)) {
if ((VAR_5 = slice_to_vbi_lines(ctx, VAR_3->VAR_1 + 1, VAR_3->size - 1)) < 0)
return VAR_5;
av_dlog(VAR_0, "ctx=%p buf_size=%d VAR_5=%u pkt_pts=%7.3f\n",
ctx, VAR_3->size, VAR_5, (double)VAR_3->pts/90000.0);
if (VAR_5 > 0) {
#ifdef DEBUG
int VAR_7;
av_log(VAR_0, AV_LOG_DEBUG, "line numbers:");
for(VAR_7 = 0; VAR_7 < VAR_5; VAR_7++)
av_log(VAR_0, AV_LOG_DEBUG, " %d", ctx->sliced[VAR_7].line);
av_log(VAR_0, AV_LOG_DEBUG, "\n");
#endif
vbi_decode(ctx->vbi, ctx->sliced, VAR_5, 0.0);
ctx->lines_processed += VAR_5;
}
}
ctx->pts = AV_NOPTS_VALUE;
VAR_4 = ctx->handler_ret;
}
if (VAR_4 < 0)
return VAR_4;
if (ctx->nb_pages) {
int VAR_7;
sub->format = ctx->format_id;
sub->start_display_time = 0;
sub->end_display_time = ctx->sub_duration;
sub->num_rects = 0;
sub->pts = ctx->pages->pts;
if (ctx->pages->sub_rect->type != SUBTITLE_NONE) {
sub->rects = av_malloc(sizeof(*sub->rects));
if (sub->rects) {
sub->num_rects = 1;
sub->rects[0] = ctx->pages->sub_rect;
} else {
VAR_4 = AVERROR(ENOMEM);
}
} else {
av_log(VAR_0, AV_LOG_DEBUG, "sending empty sub\n");
sub->rects = NULL;
}
if (!sub->rects)
subtitle_rect_free(&ctx->pages->sub_rect);
for (VAR_7 = 0; VAR_7 < ctx->nb_pages - 1; VAR_7++)
ctx->pages[VAR_7] = ctx->pages[VAR_7 + 1];
ctx->nb_pages--;
if (VAR_4 >= 0)
*VAR_2 = 1;
} else
*VAR_2 = 0;
return VAR_4;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1, int *VAR_2, AVPacket *VAR_3)\n{",
"TeletextContext *ctx = VAR_0->priv_data;",
"AVSubtitle *sub = VAR_1;",
"int VAR_4 = 0;",
"if (!ctx->vbi) {",
"if (!(ctx->vbi = vbi_decoder_new()))\nreturn AVERROR(ENOMEM);",
"if (!vbi_event_handler_add(ctx->vbi, VBI_EVENT_TTX_PAGE, handler, ctx)) {",
"vbi_decoder_delete(ctx->vbi);",
"ctx->vbi = NULL;",
"return AVERROR(ENOMEM);",
"}",
"}",
"if (VAR_0->pkt_timebase.den && VAR_3->pts != AV_NOPTS_VALUE)\nctx->pts = av_rescale_q(VAR_3->pts, VAR_0->pkt_timebase, AV_TIME_BASE_Q);",
"if (VAR_3->size) {",
"int VAR_5;",
"const int VAR_6 = VAR_3->size + 45;",
"if (VAR_6 < 184 || VAR_6 > 65504 || VAR_6 % 184 != 0)\nreturn AVERROR_INVALIDDATA;",
"ctx->handler_ret = VAR_3->size;",
"if (data_identifier_is_teletext(*VAR_3->VAR_1)) {",
"if ((VAR_5 = slice_to_vbi_lines(ctx, VAR_3->VAR_1 + 1, VAR_3->size - 1)) < 0)\nreturn VAR_5;",
"av_dlog(VAR_0, \"ctx=%p buf_size=%d VAR_5=%u pkt_pts=%7.3f\\n\",\nctx, VAR_3->size, VAR_5, (double)VAR_3->pts/90000.0);",
"if (VAR_5 > 0) {",
"#ifdef DEBUG\nint VAR_7;",
"av_log(VAR_0, AV_LOG_DEBUG, \"line numbers:\");",
"for(VAR_7 = 0; VAR_7 < VAR_5; VAR_7++)",
"av_log(VAR_0, AV_LOG_DEBUG, \" %d\", ctx->sliced[VAR_7].line);",
"av_log(VAR_0, AV_LOG_DEBUG, \"\\n\");",
"#endif\nvbi_decode(ctx->vbi, ctx->sliced, VAR_5, 0.0);",
"ctx->lines_processed += VAR_5;",
"}",
"}",
"ctx->pts = AV_NOPTS_VALUE;",
"VAR_4 = ctx->handler_ret;",
"}",
"if (VAR_4 < 0)\nreturn VAR_4;",
"if (ctx->nb_pages) {",
"int VAR_7;",
"sub->format = ctx->format_id;",
"sub->start_display_time = 0;",
"sub->end_display_time = ctx->sub_duration;",
"sub->num_rects = 0;",
"sub->pts = ctx->pages->pts;",
"if (ctx->pages->sub_rect->type != SUBTITLE_NONE) {",
"sub->rects = av_malloc(sizeof(*sub->rects));",
"if (sub->rects) {",
"sub->num_rects = 1;",
"sub->rects[0] = ctx->pages->sub_rect;",
"} else {",
"VAR_4 = AVERROR(ENOMEM);",
"}",
"} else {",
"av_log(VAR_0, AV_LOG_DEBUG, \"sending empty sub\\n\");",
"sub->rects = NULL;",
"}",
"if (!sub->rects)\nsubtitle_rect_free(&ctx->pages->sub_rect);",
"for (VAR_7 = 0; VAR_7 < ctx->nb_pages - 1; VAR_7++)",
"ctx->pages[VAR_7] = ctx->pages[VAR_7 + 1];",
"ctx->nb_pages--;",
"if (VAR_4 >= 0)\n*VAR_2 = 1;",
"} else",
"*VAR_2 = 0;",
"return VAR_4;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
33,
35
],
[
39
],
[
41
],
[
43
],
[
49,
51
],
[
55
],
[
59
],
[
61,
63
],
[
65,
67
],
[
69
],
[
71,
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83,
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
101,
103
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149,
151
],
[
155
],
[
157
],
[
159
],
[
163,
165
],
[
167
],
[
169
],
[
173
],
[
175
]
] |
24,006 | static void pc_init_pci_1_5(QEMUMachineInitArgs *args)
{
has_pci_info = false;
pc_init_pci(args);
}
| true | qemu | 9604f70fdf8e21ec0dbf6eac5e59a0eb8beadd64 | static void pc_init_pci_1_5(QEMUMachineInitArgs *args)
{
has_pci_info = false;
pc_init_pci(args);
}
| {
"code": [
"static void pc_init_pci_1_5(QEMUMachineInitArgs *args)"
],
"line_no": [
1
]
} | static void FUNC_0(QEMUMachineInitArgs *VAR_0)
{
has_pci_info = false;
pc_init_pci(VAR_0);
}
| [
"static void FUNC_0(QEMUMachineInitArgs *VAR_0)\n{",
"has_pci_info = false;",
"pc_init_pci(VAR_0);",
"}"
] | [
1,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
]
] |
24,007 | static int usbnet_can_receive(NetClientState *nc)
{
USBNetState *s = qemu_get_nic_opaque(nc);
if (is_rndis(s) && s->rndis_state != RNDIS_DATA_INITIALIZED) {
return 1;
return !s->in_len; | true | qemu | 278412d0e710e2e848c6e510f8308e5b1ed4d03e | static int usbnet_can_receive(NetClientState *nc)
{
USBNetState *s = qemu_get_nic_opaque(nc);
if (is_rndis(s) && s->rndis_state != RNDIS_DATA_INITIALIZED) {
return 1;
return !s->in_len; | {
"code": [],
"line_no": []
} | static int FUNC_0(NetClientState *VAR_0)
{
USBNetState *s = qemu_get_nic_opaque(VAR_0);
if (is_rndis(s) && s->rndis_state != RNDIS_DATA_INITIALIZED) {
return 1;
return !s->in_len; | [
"static int FUNC_0(NetClientState *VAR_0)\n{",
"USBNetState *s = qemu_get_nic_opaque(VAR_0);",
"if (is_rndis(s) && s->rndis_state != RNDIS_DATA_INITIALIZED) {",
"return 1;",
"return !s->in_len;"
] | [
0,
0,
0,
0,
0
] | [
[
1,
2
],
[
3
],
[
4
],
[
5
],
[
6
]
] |
24,008 | static inline int hpel_motion_lowres(MpegEncContext *s,
uint8_t *dest, uint8_t *src,
int field_based, int field_select,
int src_x, int src_y,
int width, int height, int stride,
int h_edge_pos, int v_edge_pos,
int w, int h, h264_chroma_mc_func *pix_op,
int motion_x, int motion_y)
{
const int lowres = s->avctx->lowres;
const int op_index = FFMIN(lowres, 3);
const int s_mask = (2 << lowres) - 1;
int emu = 0;
int sx, sy;
if (s->quarter_sample) {
motion_x /= 2;
motion_y /= 2;
}
sx = motion_x & s_mask;
sy = motion_y & s_mask;
src_x += motion_x >> lowres + 1;
src_y += motion_y >> lowres + 1;
src += src_y * stride + src_x;
if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
(unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
(h + 1) << field_based, src_x,
src_y << field_based,
h_edge_pos,
v_edge_pos);
src = s->edge_emu_buffer;
emu = 1;
}
sx = (sx << 2) >> lowres;
sy = (sy << 2) >> lowres;
if (field_select)
src += s->linesize;
pix_op[op_index](dest, src, stride, h, sx, sy);
return emu;
}
| true | FFmpeg | c341f734e5f9d6af4a8fdcceb6f5d12de6395c76 | static inline int hpel_motion_lowres(MpegEncContext *s,
uint8_t *dest, uint8_t *src,
int field_based, int field_select,
int src_x, int src_y,
int width, int height, int stride,
int h_edge_pos, int v_edge_pos,
int w, int h, h264_chroma_mc_func *pix_op,
int motion_x, int motion_y)
{
const int lowres = s->avctx->lowres;
const int op_index = FFMIN(lowres, 3);
const int s_mask = (2 << lowres) - 1;
int emu = 0;
int sx, sy;
if (s->quarter_sample) {
motion_x /= 2;
motion_y /= 2;
}
sx = motion_x & s_mask;
sy = motion_y & s_mask;
src_x += motion_x >> lowres + 1;
src_y += motion_y >> lowres + 1;
src += src_y * stride + src_x;
if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w, 0) ||
(unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
(h + 1) << field_based, src_x,
src_y << field_based,
h_edge_pos,
v_edge_pos);
src = s->edge_emu_buffer;
emu = 1;
}
sx = (sx << 2) >> lowres;
sy = (sy << 2) >> lowres;
if (field_select)
src += s->linesize;
pix_op[op_index](dest, src, stride, h, sx, sy);
return emu;
}
| {
"code": [
" int width, int height, int stride,"
],
"line_no": [
9
]
} | static inline int FUNC_0(MpegEncContext *VAR_0,
uint8_t *VAR_1, uint8_t *VAR_2,
int VAR_3, int VAR_4,
int VAR_5, int VAR_6,
int VAR_7, int VAR_8, int VAR_9,
int VAR_10, int VAR_11,
int VAR_12, int VAR_13, h264_chroma_mc_func *VAR_14,
int VAR_15, int VAR_16)
{
const int VAR_17 = VAR_0->avctx->VAR_17;
const int VAR_18 = FFMIN(VAR_17, 3);
const int VAR_19 = (2 << VAR_17) - 1;
int VAR_20 = 0;
int VAR_21, VAR_22;
if (VAR_0->quarter_sample) {
VAR_15 /= 2;
VAR_16 /= 2;
}
VAR_21 = VAR_15 & VAR_19;
VAR_22 = VAR_16 & VAR_19;
VAR_5 += VAR_15 >> VAR_17 + 1;
VAR_6 += VAR_16 >> VAR_17 + 1;
VAR_2 += VAR_6 * VAR_9 + VAR_5;
if ((unsigned)VAR_5 > FFMAX( VAR_10 - (!!VAR_21) - VAR_12, 0) ||
(unsigned)VAR_6 > FFMAX((VAR_11 >> VAR_3) - (!!VAR_22) - VAR_13, 0)) {
VAR_0->vdsp.emulated_edge_mc(VAR_0->edge_emu_buffer, VAR_2, VAR_0->linesize, VAR_12 + 1,
(VAR_13 + 1) << VAR_3, VAR_5,
VAR_6 << VAR_3,
VAR_10,
VAR_11);
VAR_2 = VAR_0->edge_emu_buffer;
VAR_20 = 1;
}
VAR_21 = (VAR_21 << 2) >> VAR_17;
VAR_22 = (VAR_22 << 2) >> VAR_17;
if (VAR_4)
VAR_2 += VAR_0->linesize;
VAR_14[VAR_18](VAR_1, VAR_2, VAR_9, VAR_13, VAR_21, VAR_22);
return VAR_20;
}
| [
"static inline int FUNC_0(MpegEncContext *VAR_0,\nuint8_t *VAR_1, uint8_t *VAR_2,\nint VAR_3, int VAR_4,\nint VAR_5, int VAR_6,\nint VAR_7, int VAR_8, int VAR_9,\nint VAR_10, int VAR_11,\nint VAR_12, int VAR_13, h264_chroma_mc_func *VAR_14,\nint VAR_15, int VAR_16)\n{",
"const int VAR_17 = VAR_0->avctx->VAR_17;",
"const int VAR_18 = FFMIN(VAR_17, 3);",
"const int VAR_19 = (2 << VAR_17) - 1;",
"int VAR_20 = 0;",
"int VAR_21, VAR_22;",
"if (VAR_0->quarter_sample) {",
"VAR_15 /= 2;",
"VAR_16 /= 2;",
"}",
"VAR_21 = VAR_15 & VAR_19;",
"VAR_22 = VAR_16 & VAR_19;",
"VAR_5 += VAR_15 >> VAR_17 + 1;",
"VAR_6 += VAR_16 >> VAR_17 + 1;",
"VAR_2 += VAR_6 * VAR_9 + VAR_5;",
"if ((unsigned)VAR_5 > FFMAX( VAR_10 - (!!VAR_21) - VAR_12, 0) ||\n(unsigned)VAR_6 > FFMAX((VAR_11 >> VAR_3) - (!!VAR_22) - VAR_13, 0)) {",
"VAR_0->vdsp.emulated_edge_mc(VAR_0->edge_emu_buffer, VAR_2, VAR_0->linesize, VAR_12 + 1,\n(VAR_13 + 1) << VAR_3, VAR_5,\nVAR_6 << VAR_3,\nVAR_10,\nVAR_11);",
"VAR_2 = VAR_0->edge_emu_buffer;",
"VAR_20 = 1;",
"}",
"VAR_21 = (VAR_21 << 2) >> VAR_17;",
"VAR_22 = (VAR_22 << 2) >> VAR_17;",
"if (VAR_4)\nVAR_2 += VAR_0->linesize;",
"VAR_14[VAR_18](VAR_1, VAR_2, VAR_9, VAR_13, VAR_21, VAR_22);",
"return VAR_20;",
"}"
] | [
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9,
11,
13,
15,
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51
],
[
55,
57
],
[
59,
61,
63,
65,
67
],
[
69
],
[
71
],
[
73
],
[
77
],
[
79
],
[
81,
83
],
[
85
],
[
87
],
[
89
]
] |
24,010 | int qemu_devtree_add_subnode(void *fdt, const char *name)
{
int offset;
char *dupname = g_strdup(name);
char *basename = strrchr(dupname, '/');
int retval;
if (!basename) {
return -1;
}
basename[0] = '\0';
basename++;
offset = fdt_path_offset(fdt, dupname);
if (offset < 0) {
return offset;
}
retval = fdt_add_subnode(fdt, offset, basename);
g_free(dupname);
return retval;
}
| true | qemu | ccbcfedd17fd2d13521fcee66810d0df464ec1cc | int qemu_devtree_add_subnode(void *fdt, const char *name)
{
int offset;
char *dupname = g_strdup(name);
char *basename = strrchr(dupname, '/');
int retval;
if (!basename) {
return -1;
}
basename[0] = '\0';
basename++;
offset = fdt_path_offset(fdt, dupname);
if (offset < 0) {
return offset;
}
retval = fdt_add_subnode(fdt, offset, basename);
g_free(dupname);
return retval;
}
| {
"code": [
" return offset;",
" int offset;",
" return offset;",
" int offset;",
" return offset;",
" int offset;",
" return offset;",
" int offset;",
" offset = fdt_path_offset(fdt, dupname);",
" if (offset < 0) {",
" return offset;",
" retval = fdt_add_subnode(fdt, offset, basename);"
],
"line_no": [
33,
5,
33,
5,
33,
5,
33,
5,
29,
31,
33,
39
]
} | int FUNC_0(void *VAR_0, const char *VAR_1)
{
int VAR_2;
char *VAR_3 = g_strdup(VAR_1);
char *VAR_4 = strrchr(VAR_3, '/');
int VAR_5;
if (!VAR_4) {
return -1;
}
VAR_4[0] = '\0';
VAR_4++;
VAR_2 = fdt_path_offset(VAR_0, VAR_3);
if (VAR_2 < 0) {
return VAR_2;
}
VAR_5 = fdt_add_subnode(VAR_0, VAR_2, VAR_4);
g_free(VAR_3);
return VAR_5;
}
| [
"int FUNC_0(void *VAR_0, const char *VAR_1)\n{",
"int VAR_2;",
"char *VAR_3 = g_strdup(VAR_1);",
"char *VAR_4 = strrchr(VAR_3, '/');",
"int VAR_5;",
"if (!VAR_4) {",
"return -1;",
"}",
"VAR_4[0] = '\\0';",
"VAR_4++;",
"VAR_2 = fdt_path_offset(VAR_0, VAR_3);",
"if (VAR_2 < 0) {",
"return VAR_2;",
"}",
"VAR_5 = fdt_add_subnode(VAR_0, VAR_2, VAR_4);",
"g_free(VAR_3);",
"return VAR_5;",
"}"
] | [
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
1,
1,
1,
0,
1,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
]
] |
24,011 | av_cold void ff_mlz_init_dict(void* context, MLZ *mlz) {
mlz->dict = av_malloc_array(TABLE_SIZE, sizeof(*mlz->dict));
mlz->flush_code = FLUSH_CODE;
mlz->current_dic_index_max = DIC_INDEX_INIT;
mlz->dic_code_bit = CODE_BIT_INIT;
mlz->bump_code = (DIC_INDEX_INIT - 1);
mlz->next_code = FIRST_CODE;
mlz->freeze_flag = 0;
mlz->context = context;
}
| true | FFmpeg | 2f7a12fab5a2ea17bd78b155e9af965669fb9b52 | av_cold void ff_mlz_init_dict(void* context, MLZ *mlz) {
mlz->dict = av_malloc_array(TABLE_SIZE, sizeof(*mlz->dict));
mlz->flush_code = FLUSH_CODE;
mlz->current_dic_index_max = DIC_INDEX_INIT;
mlz->dic_code_bit = CODE_BIT_INIT;
mlz->bump_code = (DIC_INDEX_INIT - 1);
mlz->next_code = FIRST_CODE;
mlz->freeze_flag = 0;
mlz->context = context;
}
| {
"code": [
" mlz->dict = av_malloc_array(TABLE_SIZE, sizeof(*mlz->dict));"
],
"line_no": [
3
]
} | av_cold void FUNC_0(void* context, MLZ *mlz) {
mlz->dict = av_malloc_array(TABLE_SIZE, sizeof(*mlz->dict));
mlz->flush_code = FLUSH_CODE;
mlz->current_dic_index_max = DIC_INDEX_INIT;
mlz->dic_code_bit = CODE_BIT_INIT;
mlz->bump_code = (DIC_INDEX_INIT - 1);
mlz->next_code = FIRST_CODE;
mlz->freeze_flag = 0;
mlz->context = context;
}
| [
"av_cold void FUNC_0(void* context, MLZ *mlz) {",
"mlz->dict = av_malloc_array(TABLE_SIZE, sizeof(*mlz->dict));",
"mlz->flush_code = FLUSH_CODE;",
"mlz->current_dic_index_max = DIC_INDEX_INIT;",
"mlz->dic_code_bit = CODE_BIT_INIT;",
"mlz->bump_code = (DIC_INDEX_INIT - 1);",
"mlz->next_code = FIRST_CODE;",
"mlz->freeze_flag = 0;",
"mlz->context = context;",
"}"
] | [
0,
1,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1
],
[
3
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
]
] |
24,012 | static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice,
uint16_t *dst, int dst_stride,
const uint8_t *buf, unsigned buf_size,
const int16_t *qmat, int log2_blocks_per_mb)
{
ProresContext *ctx = avctx->priv_data;
LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]);
int16_t *block;
GetBitContext gb;
int i, j, blocks_per_slice = slice->mb_count << log2_blocks_per_mb;
int ret;
for (i = 0; i < blocks_per_slice; i++)
ctx->bdsp.clear_block(blocks+(i<<6));
init_get_bits(&gb, buf, buf_size << 3);
decode_dc_coeffs(&gb, blocks, blocks_per_slice);
if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)
return ret;
block = blocks;
for (i = 0; i < slice->mb_count; i++) {
for (j = 0; j < log2_blocks_per_mb; j++) {
ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat);
ctx->prodsp.idct_put(dst+4*dst_stride, dst_stride, block+(1<<6), qmat);
block += 2*64;
dst += 8;
}
}
return 0;
}
| true | FFmpeg | 4f5eaf0b5956e492ee5023929669b1d09aaf6299 | static int decode_slice_chroma(AVCodecContext *avctx, SliceContext *slice,
uint16_t *dst, int dst_stride,
const uint8_t *buf, unsigned buf_size,
const int16_t *qmat, int log2_blocks_per_mb)
{
ProresContext *ctx = avctx->priv_data;
LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]);
int16_t *block;
GetBitContext gb;
int i, j, blocks_per_slice = slice->mb_count << log2_blocks_per_mb;
int ret;
for (i = 0; i < blocks_per_slice; i++)
ctx->bdsp.clear_block(blocks+(i<<6));
init_get_bits(&gb, buf, buf_size << 3);
decode_dc_coeffs(&gb, blocks, blocks_per_slice);
if ((ret = decode_ac_coeffs(avctx, &gb, blocks, blocks_per_slice)) < 0)
return ret;
block = blocks;
for (i = 0; i < slice->mb_count; i++) {
for (j = 0; j < log2_blocks_per_mb; j++) {
ctx->prodsp.idct_put(dst, dst_stride, block+(0<<6), qmat);
ctx->prodsp.idct_put(dst+4*dst_stride, dst_stride, block+(1<<6), qmat);
block += 2*64;
dst += 8;
}
}
return 0;
}
| {
"code": [
" decode_dc_coeffs(&gb, blocks, blocks_per_slice);",
" decode_dc_coeffs(&gb, blocks, blocks_per_slice);"
],
"line_no": [
35,
35
]
} | static int FUNC_0(AVCodecContext *VAR_0, SliceContext *VAR_1,
uint16_t *VAR_2, int VAR_3,
const uint8_t *VAR_4, unsigned VAR_5,
const int16_t *VAR_6, int VAR_7)
{
ProresContext *ctx = VAR_0->priv_data;
LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]);
int16_t *block;
GetBitContext gb;
int VAR_8, VAR_9, VAR_10 = VAR_1->mb_count << VAR_7;
int VAR_11;
for (VAR_8 = 0; VAR_8 < VAR_10; VAR_8++)
ctx->bdsp.clear_block(blocks+(VAR_8<<6));
init_get_bits(&gb, VAR_4, VAR_5 << 3);
decode_dc_coeffs(&gb, blocks, VAR_10);
if ((VAR_11 = decode_ac_coeffs(VAR_0, &gb, blocks, VAR_10)) < 0)
return VAR_11;
block = blocks;
for (VAR_8 = 0; VAR_8 < VAR_1->mb_count; VAR_8++) {
for (VAR_9 = 0; VAR_9 < VAR_7; VAR_9++) {
ctx->prodsp.idct_put(VAR_2, VAR_3, block+(0<<6), VAR_6);
ctx->prodsp.idct_put(VAR_2+4*VAR_3, VAR_3, block+(1<<6), VAR_6);
block += 2*64;
VAR_2 += 8;
}
}
return 0;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0, SliceContext *VAR_1,\nuint16_t *VAR_2, int VAR_3,\nconst uint8_t *VAR_4, unsigned VAR_5,\nconst int16_t *VAR_6, int VAR_7)\n{",
"ProresContext *ctx = VAR_0->priv_data;",
"LOCAL_ALIGNED_16(int16_t, blocks, [8*4*64]);",
"int16_t *block;",
"GetBitContext gb;",
"int VAR_8, VAR_9, VAR_10 = VAR_1->mb_count << VAR_7;",
"int VAR_11;",
"for (VAR_8 = 0; VAR_8 < VAR_10; VAR_8++)",
"ctx->bdsp.clear_block(blocks+(VAR_8<<6));",
"init_get_bits(&gb, VAR_4, VAR_5 << 3);",
"decode_dc_coeffs(&gb, blocks, VAR_10);",
"if ((VAR_11 = decode_ac_coeffs(VAR_0, &gb, blocks, VAR_10)) < 0)\nreturn VAR_11;",
"block = blocks;",
"for (VAR_8 = 0; VAR_8 < VAR_1->mb_count; VAR_8++) {",
"for (VAR_9 = 0; VAR_9 < VAR_7; VAR_9++) {",
"ctx->prodsp.idct_put(VAR_2, VAR_3, block+(0<<6), VAR_6);",
"ctx->prodsp.idct_put(VAR_2+4*VAR_3, VAR_3, block+(1<<6), VAR_6);",
"block += 2*64;",
"VAR_2 += 8;",
"}",
"}",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
31
],
[
35
],
[
37,
39
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
]
] |
24,014 | static int mxf_write_footer(AVFormatContext *s)
{
MXFContext *mxf = s->priv_data;
AVIOContext *pb = s->pb;
mxf->duration = mxf->last_indexed_edit_unit + mxf->edit_units_count;
mxf_write_klv_fill(s);
mxf->footer_partition_offset = avio_tell(pb);
if (mxf->edit_unit_byte_count) { // no need to repeat index
mxf_write_partition(s, 0, 0, footer_partition_key, 0);
} else {
mxf_write_partition(s, 0, 2, footer_partition_key, 0);
mxf_write_klv_fill(s);
mxf_write_index_table_segment(s);
}
mxf_write_klv_fill(s);
mxf_write_random_index_pack(s);
if (s->pb->seekable) {
avio_seek(pb, 0, SEEK_SET);
if (mxf->edit_unit_byte_count) {
mxf_write_partition(s, 1, 2, header_closed_partition_key, 1);
mxf_write_klv_fill(s);
mxf_write_index_table_segment(s);
} else {
mxf_write_partition(s, 0, 0, header_closed_partition_key, 1);
}
}
ff_audio_interleave_close(s);
av_freep(&mxf->index_entries);
av_freep(&mxf->body_partition_offset);
av_freep(&mxf->timecode_track->priv_data);
av_freep(&mxf->timecode_track);
mxf_free(s);
return 0;
}
| false | FFmpeg | 7684a36113fa12c88ba80b5498f05849a6b58632 | static int mxf_write_footer(AVFormatContext *s)
{
MXFContext *mxf = s->priv_data;
AVIOContext *pb = s->pb;
mxf->duration = mxf->last_indexed_edit_unit + mxf->edit_units_count;
mxf_write_klv_fill(s);
mxf->footer_partition_offset = avio_tell(pb);
if (mxf->edit_unit_byte_count) {
mxf_write_partition(s, 0, 0, footer_partition_key, 0);
} else {
mxf_write_partition(s, 0, 2, footer_partition_key, 0);
mxf_write_klv_fill(s);
mxf_write_index_table_segment(s);
}
mxf_write_klv_fill(s);
mxf_write_random_index_pack(s);
if (s->pb->seekable) {
avio_seek(pb, 0, SEEK_SET);
if (mxf->edit_unit_byte_count) {
mxf_write_partition(s, 1, 2, header_closed_partition_key, 1);
mxf_write_klv_fill(s);
mxf_write_index_table_segment(s);
} else {
mxf_write_partition(s, 0, 0, header_closed_partition_key, 1);
}
}
ff_audio_interleave_close(s);
av_freep(&mxf->index_entries);
av_freep(&mxf->body_partition_offset);
av_freep(&mxf->timecode_track->priv_data);
av_freep(&mxf->timecode_track);
mxf_free(s);
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0)
{
MXFContext *mxf = VAR_0->priv_data;
AVIOContext *pb = VAR_0->pb;
mxf->duration = mxf->last_indexed_edit_unit + mxf->edit_units_count;
mxf_write_klv_fill(VAR_0);
mxf->footer_partition_offset = avio_tell(pb);
if (mxf->edit_unit_byte_count) {
mxf_write_partition(VAR_0, 0, 0, footer_partition_key, 0);
} else {
mxf_write_partition(VAR_0, 0, 2, footer_partition_key, 0);
mxf_write_klv_fill(VAR_0);
mxf_write_index_table_segment(VAR_0);
}
mxf_write_klv_fill(VAR_0);
mxf_write_random_index_pack(VAR_0);
if (VAR_0->pb->seekable) {
avio_seek(pb, 0, SEEK_SET);
if (mxf->edit_unit_byte_count) {
mxf_write_partition(VAR_0, 1, 2, header_closed_partition_key, 1);
mxf_write_klv_fill(VAR_0);
mxf_write_index_table_segment(VAR_0);
} else {
mxf_write_partition(VAR_0, 0, 0, header_closed_partition_key, 1);
}
}
ff_audio_interleave_close(VAR_0);
av_freep(&mxf->index_entries);
av_freep(&mxf->body_partition_offset);
av_freep(&mxf->timecode_track->priv_data);
av_freep(&mxf->timecode_track);
mxf_free(VAR_0);
return 0;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0)\n{",
"MXFContext *mxf = VAR_0->priv_data;",
"AVIOContext *pb = VAR_0->pb;",
"mxf->duration = mxf->last_indexed_edit_unit + mxf->edit_units_count;",
"mxf_write_klv_fill(VAR_0);",
"mxf->footer_partition_offset = avio_tell(pb);",
"if (mxf->edit_unit_byte_count) {",
"mxf_write_partition(VAR_0, 0, 0, footer_partition_key, 0);",
"} else {",
"mxf_write_partition(VAR_0, 0, 2, footer_partition_key, 0);",
"mxf_write_klv_fill(VAR_0);",
"mxf_write_index_table_segment(VAR_0);",
"}",
"mxf_write_klv_fill(VAR_0);",
"mxf_write_random_index_pack(VAR_0);",
"if (VAR_0->pb->seekable) {",
"avio_seek(pb, 0, SEEK_SET);",
"if (mxf->edit_unit_byte_count) {",
"mxf_write_partition(VAR_0, 1, 2, header_closed_partition_key, 1);",
"mxf_write_klv_fill(VAR_0);",
"mxf_write_index_table_segment(VAR_0);",
"} else {",
"mxf_write_partition(VAR_0, 0, 0, header_closed_partition_key, 1);",
"}",
"}",
"ff_audio_interleave_close(VAR_0);",
"av_freep(&mxf->index_entries);",
"av_freep(&mxf->body_partition_offset);",
"av_freep(&mxf->timecode_track->priv_data);",
"av_freep(&mxf->timecode_track);",
"mxf_free(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
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65
],
[
69
],
[
71
],
[
73
],
[
75
],
[
79
],
[
83
],
[
85
]
] |
24,015 | static void pxa2xx_pcmcia_initfn(Object *obj)
{
SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
PXA2xxPCMCIAState *s = PXA2XX_PCMCIA(obj);
memory_region_init(&s->container_mem, obj, "container", 0x10000000);
sysbus_init_mmio(sbd, &s->container_mem);
/* Socket I/O Memory Space */
memory_region_init_io(&s->iomem, NULL, &pxa2xx_pcmcia_io_ops, s,
"pxa2xx-pcmcia-io", 0x04000000);
memory_region_add_subregion(&s->container_mem, 0x00000000,
&s->iomem);
/* Then next 64 MB is reserved */
/* Socket Attribute Memory Space */
memory_region_init_io(&s->attr_iomem, NULL, &pxa2xx_pcmcia_attr_ops, s,
"pxa2xx-pcmcia-attribute", 0x04000000);
memory_region_add_subregion(&s->container_mem, 0x08000000,
&s->attr_iomem);
/* Socket Common Memory Space */
memory_region_init_io(&s->common_iomem, NULL, &pxa2xx_pcmcia_common_ops, s,
"pxa2xx-pcmcia-common", 0x04000000);
memory_region_add_subregion(&s->container_mem, 0x0c000000,
&s->common_iomem);
s->slot.irq = qemu_allocate_irqs(pxa2xx_pcmcia_set_irq, s, 1)[0];
object_property_add_link(obj, "card", TYPE_PCMCIA_CARD,
(Object **)&s->card,
NULL, /* read-only property */
0, NULL);
}
| true | qemu | f3c7d0389fe8a2792fd4c1cf151b885de03c8f62 | static void pxa2xx_pcmcia_initfn(Object *obj)
{
SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
PXA2xxPCMCIAState *s = PXA2XX_PCMCIA(obj);
memory_region_init(&s->container_mem, obj, "container", 0x10000000);
sysbus_init_mmio(sbd, &s->container_mem);
memory_region_init_io(&s->iomem, NULL, &pxa2xx_pcmcia_io_ops, s,
"pxa2xx-pcmcia-io", 0x04000000);
memory_region_add_subregion(&s->container_mem, 0x00000000,
&s->iomem);
memory_region_init_io(&s->attr_iomem, NULL, &pxa2xx_pcmcia_attr_ops, s,
"pxa2xx-pcmcia-attribute", 0x04000000);
memory_region_add_subregion(&s->container_mem, 0x08000000,
&s->attr_iomem);
memory_region_init_io(&s->common_iomem, NULL, &pxa2xx_pcmcia_common_ops, s,
"pxa2xx-pcmcia-common", 0x04000000);
memory_region_add_subregion(&s->container_mem, 0x0c000000,
&s->common_iomem);
s->slot.irq = qemu_allocate_irqs(pxa2xx_pcmcia_set_irq, s, 1)[0];
object_property_add_link(obj, "card", TYPE_PCMCIA_CARD,
(Object **)&s->card,
NULL,
0, NULL);
}
| {
"code": [
" s->slot.irq = qemu_allocate_irqs(pxa2xx_pcmcia_set_irq, s, 1)[0];"
],
"line_no": [
57
]
} | static void FUNC_0(Object *VAR_0)
{
SysBusDevice *sbd = SYS_BUS_DEVICE(VAR_0);
PXA2xxPCMCIAState *s = PXA2XX_PCMCIA(VAR_0);
memory_region_init(&s->container_mem, VAR_0, "container", 0x10000000);
sysbus_init_mmio(sbd, &s->container_mem);
memory_region_init_io(&s->iomem, NULL, &pxa2xx_pcmcia_io_ops, s,
"pxa2xx-pcmcia-io", 0x04000000);
memory_region_add_subregion(&s->container_mem, 0x00000000,
&s->iomem);
memory_region_init_io(&s->attr_iomem, NULL, &pxa2xx_pcmcia_attr_ops, s,
"pxa2xx-pcmcia-attribute", 0x04000000);
memory_region_add_subregion(&s->container_mem, 0x08000000,
&s->attr_iomem);
memory_region_init_io(&s->common_iomem, NULL, &pxa2xx_pcmcia_common_ops, s,
"pxa2xx-pcmcia-common", 0x04000000);
memory_region_add_subregion(&s->container_mem, 0x0c000000,
&s->common_iomem);
s->slot.irq = qemu_allocate_irqs(pxa2xx_pcmcia_set_irq, s, 1)[0];
object_property_add_link(VAR_0, "card", TYPE_PCMCIA_CARD,
(Object **)&s->card,
NULL,
0, NULL);
}
| [
"static void FUNC_0(Object *VAR_0)\n{",
"SysBusDevice *sbd = SYS_BUS_DEVICE(VAR_0);",
"PXA2xxPCMCIAState *s = PXA2XX_PCMCIA(VAR_0);",
"memory_region_init(&s->container_mem, VAR_0, \"container\", 0x10000000);",
"sysbus_init_mmio(sbd, &s->container_mem);",
"memory_region_init_io(&s->iomem, NULL, &pxa2xx_pcmcia_io_ops, s,\n\"pxa2xx-pcmcia-io\", 0x04000000);",
"memory_region_add_subregion(&s->container_mem, 0x00000000,\n&s->iomem);",
"memory_region_init_io(&s->attr_iomem, NULL, &pxa2xx_pcmcia_attr_ops, s,\n\"pxa2xx-pcmcia-attribute\", 0x04000000);",
"memory_region_add_subregion(&s->container_mem, 0x08000000,\n&s->attr_iomem);",
"memory_region_init_io(&s->common_iomem, NULL, &pxa2xx_pcmcia_common_ops, s,\n\"pxa2xx-pcmcia-common\", 0x04000000);",
"memory_region_add_subregion(&s->container_mem, 0x0c000000,\n&s->common_iomem);",
"s->slot.irq = qemu_allocate_irqs(pxa2xx_pcmcia_set_irq, s, 1)[0];",
"object_property_add_link(VAR_0, \"card\", TYPE_PCMCIA_CARD,\n(Object **)&s->card,\nNULL,\n0, NULL);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
19,
21
],
[
23,
25
],
[
35,
37
],
[
39,
41
],
[
47,
49
],
[
51,
53
],
[
57
],
[
61,
63,
65,
67
],
[
69
]
] |
24,016 | static int mirror_cow_align(MirrorBlockJob *s, int64_t *offset,
uint64_t *bytes)
{
bool need_cow;
int ret = 0;
int64_t align_offset = *offset;
unsigned int align_bytes = *bytes;
int max_bytes = s->granularity * s->max_iov;
assert(*bytes < INT_MAX);
need_cow = !test_bit(*offset / s->granularity, s->cow_bitmap);
need_cow |= !test_bit((*offset + *bytes - 1) / s->granularity,
s->cow_bitmap);
if (need_cow) {
bdrv_round_to_clusters(blk_bs(s->target), *offset, *bytes,
&align_offset, &align_bytes);
}
if (align_bytes > max_bytes) {
align_bytes = max_bytes;
if (need_cow) {
align_bytes = QEMU_ALIGN_DOWN(align_bytes, s->target_cluster_size);
}
}
/* Clipping may result in align_bytes unaligned to chunk boundary, but
* that doesn't matter because it's already the end of source image. */
align_bytes = mirror_clip_bytes(s, align_offset, align_bytes);
ret = align_offset + align_bytes - (*offset + *bytes);
*offset = align_offset;
*bytes = align_bytes;
assert(ret >= 0);
return ret;
}
| true | qemu | 7cfd527525a7d6b1c904890a6b84c1227846415e | static int mirror_cow_align(MirrorBlockJob *s, int64_t *offset,
uint64_t *bytes)
{
bool need_cow;
int ret = 0;
int64_t align_offset = *offset;
unsigned int align_bytes = *bytes;
int max_bytes = s->granularity * s->max_iov;
assert(*bytes < INT_MAX);
need_cow = !test_bit(*offset / s->granularity, s->cow_bitmap);
need_cow |= !test_bit((*offset + *bytes - 1) / s->granularity,
s->cow_bitmap);
if (need_cow) {
bdrv_round_to_clusters(blk_bs(s->target), *offset, *bytes,
&align_offset, &align_bytes);
}
if (align_bytes > max_bytes) {
align_bytes = max_bytes;
if (need_cow) {
align_bytes = QEMU_ALIGN_DOWN(align_bytes, s->target_cluster_size);
}
}
align_bytes = mirror_clip_bytes(s, align_offset, align_bytes);
ret = align_offset + align_bytes - (*offset + *bytes);
*offset = align_offset;
*bytes = align_bytes;
assert(ret >= 0);
return ret;
}
| {
"code": [
" unsigned int align_bytes = *bytes;",
" assert(*bytes < INT_MAX);"
],
"line_no": [
13,
19
]
} | static int FUNC_0(MirrorBlockJob *VAR_0, int64_t *VAR_1,
uint64_t *VAR_2)
{
bool need_cow;
int VAR_3 = 0;
int64_t align_offset = *VAR_1;
unsigned int VAR_4 = *VAR_2;
int VAR_5 = VAR_0->granularity * VAR_0->max_iov;
assert(*VAR_2 < INT_MAX);
need_cow = !test_bit(*VAR_1 / VAR_0->granularity, VAR_0->cow_bitmap);
need_cow |= !test_bit((*VAR_1 + *VAR_2 - 1) / VAR_0->granularity,
VAR_0->cow_bitmap);
if (need_cow) {
bdrv_round_to_clusters(blk_bs(VAR_0->target), *VAR_1, *VAR_2,
&align_offset, &VAR_4);
}
if (VAR_4 > VAR_5) {
VAR_4 = VAR_5;
if (need_cow) {
VAR_4 = QEMU_ALIGN_DOWN(VAR_4, VAR_0->target_cluster_size);
}
}
VAR_4 = mirror_clip_bytes(VAR_0, align_offset, VAR_4);
VAR_3 = align_offset + VAR_4 - (*VAR_1 + *VAR_2);
*VAR_1 = align_offset;
*VAR_2 = VAR_4;
assert(VAR_3 >= 0);
return VAR_3;
}
| [
"static int FUNC_0(MirrorBlockJob *VAR_0, int64_t *VAR_1,\nuint64_t *VAR_2)\n{",
"bool need_cow;",
"int VAR_3 = 0;",
"int64_t align_offset = *VAR_1;",
"unsigned int VAR_4 = *VAR_2;",
"int VAR_5 = VAR_0->granularity * VAR_0->max_iov;",
"assert(*VAR_2 < INT_MAX);",
"need_cow = !test_bit(*VAR_1 / VAR_0->granularity, VAR_0->cow_bitmap);",
"need_cow |= !test_bit((*VAR_1 + *VAR_2 - 1) / VAR_0->granularity,\nVAR_0->cow_bitmap);",
"if (need_cow) {",
"bdrv_round_to_clusters(blk_bs(VAR_0->target), *VAR_1, *VAR_2,\n&align_offset, &VAR_4);",
"}",
"if (VAR_4 > VAR_5) {",
"VAR_4 = VAR_5;",
"if (need_cow) {",
"VAR_4 = QEMU_ALIGN_DOWN(VAR_4, VAR_0->target_cluster_size);",
"}",
"}",
"VAR_4 = mirror_clip_bytes(VAR_0, align_offset, VAR_4);",
"VAR_3 = align_offset + VAR_4 - (*VAR_1 + *VAR_2);",
"*VAR_1 = align_offset;",
"*VAR_2 = VAR_4;",
"assert(VAR_3 >= 0);",
"return VAR_3;",
"}"
] | [
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
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23,
25
],
[
27
],
[
29,
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
53
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
]
] |
24,017 | static void GCC_FMT_ATTR(2, 3) blkverify_err(BlkverifyAIOCB *acb,
const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
fprintf(stderr, "blkverify: %s sector_num=%" PRId64 " nb_sectors=%d ",
acb->is_write ? "write" : "read", acb->sector_num,
acb->nb_sectors);
vfprintf(stderr, fmt, ap);
fprintf(stderr, "\n");
va_end(ap);
exit(1);
}
| true | qemu | 44b6789299a8acca3f25331bc411055cafc7bb06 | static void GCC_FMT_ATTR(2, 3) blkverify_err(BlkverifyAIOCB *acb,
const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
fprintf(stderr, "blkverify: %s sector_num=%" PRId64 " nb_sectors=%d ",
acb->is_write ? "write" : "read", acb->sector_num,
acb->nb_sectors);
vfprintf(stderr, fmt, ap);
fprintf(stderr, "\n");
va_end(ap);
exit(1);
}
| {
"code": [
"static void GCC_FMT_ATTR(2, 3) blkverify_err(BlkverifyAIOCB *acb,",
" fprintf(stderr, \"blkverify: %s sector_num=%\" PRId64 \" nb_sectors=%d \",",
" acb->is_write ? \"write\" : \"read\", acb->sector_num,",
" acb->nb_sectors);"
],
"line_no": [
1,
13,
15,
17
]
} | static void GCC_FMT_ATTR(2, 3) blkverify_err(BlkverifyAIOCB *acb,
const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
fprintf(stderr, "blkverify: %s sector_num=%" PRId64 " nb_sectors=%d ",
acb->is_write ? "write" : "read", acb->sector_num,
acb->nb_sectors);
vfprintf(stderr, fmt, ap);
fprintf(stderr, "\n");
va_end(ap);
exit(1);
}
| [
"static void GCC_FMT_ATTR(2, 3) blkverify_err(BlkverifyAIOCB *acb,\nconst char *fmt, ...)\n{",
"va_list ap;",
"va_start(ap, fmt);",
"fprintf(stderr, \"blkverify: %s sector_num=%\" PRId64 \" nb_sectors=%d \",\nacb->is_write ? \"write\" : \"read\", acb->sector_num,\nacb->nb_sectors);",
"vfprintf(stderr, fmt, ap);",
"fprintf(stderr, \"\\n\");",
"va_end(ap);",
"exit(1);",
"}"
] | [
1,
0,
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
11
],
[
13,
15,
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
]
] |
24,019 | static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
{
MatroskaMuxContext *mkv = s->priv_data;
int codec_type = s->streams[pkt->stream_index]->codec->codec_type;
int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
int cluster_size;
int cluster_size_limit;
int64_t cluster_time;
int64_t cluster_time_limit;
AVIOContext *pb;
int ret;
if (mkv->tracks[pkt->stream_index].write_dts)
cluster_time = pkt->dts - mkv->cluster_pts;
else
cluster_time = pkt->pts - mkv->cluster_pts;
// start a new cluster every 5 MB or 5 sec, or 32k / 1 sec for streaming or
// after 4k and on a keyframe
if (s->pb->seekable) {
pb = s->pb;
cluster_size = avio_tell(pb) - mkv->cluster_pos;
cluster_time_limit = 5000;
cluster_size_limit = 5 * 1024 * 1024;
} else {
pb = mkv->dyn_bc;
cluster_size = avio_tell(pb);
cluster_time_limit = 1000;
cluster_size_limit = 32 * 1024;
}
if (mkv->cluster_pos &&
(cluster_size > cluster_size_limit ||
cluster_time > cluster_time_limit ||
(codec_type == AVMEDIA_TYPE_VIDEO && keyframe &&
cluster_size > 4 * 1024))) {
av_log(s, AV_LOG_DEBUG, "Starting new cluster at offset %" PRIu64
" bytes, pts %" PRIu64 "dts %" PRIu64 "\n",
avio_tell(pb), pkt->pts, pkt->dts);
end_ebml_master(pb, mkv->cluster);
mkv->cluster_pos = 0;
if (mkv->dyn_bc)
mkv_flush_dynbuf(s);
}
// check if we have an audio packet cached
if (mkv->cur_audio_pkt.size > 0) {
ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt);
av_free_packet(&mkv->cur_audio_pkt);
if (ret < 0) {
av_log(s, AV_LOG_ERROR, "Could not write cached audio packet ret:%d\n", ret);
return ret;
}
}
// buffer an audio packet to ensure the packet containing the video
// keyframe's timecode is contained in the same cluster for WebM
if (codec_type == AVMEDIA_TYPE_AUDIO) {
mkv->cur_audio_pkt = *pkt;
if (pkt->buf) {
mkv->cur_audio_pkt.buf = av_buffer_ref(pkt->buf);
ret = mkv->cur_audio_pkt.buf ? 0 : AVERROR(ENOMEM);
} else
ret = av_dup_packet(&mkv->cur_audio_pkt);
} else
ret = mkv_write_packet_internal(s, pkt);
return ret;
}
| false | FFmpeg | 98308bd44face14ea3142b501d16226eec23b75a | static int mkv_write_packet(AVFormatContext *s, AVPacket *pkt)
{
MatroskaMuxContext *mkv = s->priv_data;
int codec_type = s->streams[pkt->stream_index]->codec->codec_type;
int keyframe = !!(pkt->flags & AV_PKT_FLAG_KEY);
int cluster_size;
int cluster_size_limit;
int64_t cluster_time;
int64_t cluster_time_limit;
AVIOContext *pb;
int ret;
if (mkv->tracks[pkt->stream_index].write_dts)
cluster_time = pkt->dts - mkv->cluster_pts;
else
cluster_time = pkt->pts - mkv->cluster_pts;
if (s->pb->seekable) {
pb = s->pb;
cluster_size = avio_tell(pb) - mkv->cluster_pos;
cluster_time_limit = 5000;
cluster_size_limit = 5 * 1024 * 1024;
} else {
pb = mkv->dyn_bc;
cluster_size = avio_tell(pb);
cluster_time_limit = 1000;
cluster_size_limit = 32 * 1024;
}
if (mkv->cluster_pos &&
(cluster_size > cluster_size_limit ||
cluster_time > cluster_time_limit ||
(codec_type == AVMEDIA_TYPE_VIDEO && keyframe &&
cluster_size > 4 * 1024))) {
av_log(s, AV_LOG_DEBUG, "Starting new cluster at offset %" PRIu64
" bytes, pts %" PRIu64 "dts %" PRIu64 "\n",
avio_tell(pb), pkt->pts, pkt->dts);
end_ebml_master(pb, mkv->cluster);
mkv->cluster_pos = 0;
if (mkv->dyn_bc)
mkv_flush_dynbuf(s);
}
if (mkv->cur_audio_pkt.size > 0) {
ret = mkv_write_packet_internal(s, &mkv->cur_audio_pkt);
av_free_packet(&mkv->cur_audio_pkt);
if (ret < 0) {
av_log(s, AV_LOG_ERROR, "Could not write cached audio packet ret:%d\n", ret);
return ret;
}
}
if (codec_type == AVMEDIA_TYPE_AUDIO) {
mkv->cur_audio_pkt = *pkt;
if (pkt->buf) {
mkv->cur_audio_pkt.buf = av_buffer_ref(pkt->buf);
ret = mkv->cur_audio_pkt.buf ? 0 : AVERROR(ENOMEM);
} else
ret = av_dup_packet(&mkv->cur_audio_pkt);
} else
ret = mkv_write_packet_internal(s, pkt);
return ret;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)
{
MatroskaMuxContext *mkv = VAR_0->priv_data;
int VAR_2 = VAR_0->streams[VAR_1->stream_index]->codec->VAR_2;
int VAR_3 = !!(VAR_1->flags & AV_PKT_FLAG_KEY);
int VAR_4;
int VAR_5;
int64_t cluster_time;
int64_t cluster_time_limit;
AVIOContext *pb;
int VAR_6;
if (mkv->tracks[VAR_1->stream_index].write_dts)
cluster_time = VAR_1->dts - mkv->cluster_pts;
else
cluster_time = VAR_1->pts - mkv->cluster_pts;
if (VAR_0->pb->seekable) {
pb = VAR_0->pb;
VAR_4 = avio_tell(pb) - mkv->cluster_pos;
cluster_time_limit = 5000;
VAR_5 = 5 * 1024 * 1024;
} else {
pb = mkv->dyn_bc;
VAR_4 = avio_tell(pb);
cluster_time_limit = 1000;
VAR_5 = 32 * 1024;
}
if (mkv->cluster_pos &&
(VAR_4 > VAR_5 ||
cluster_time > cluster_time_limit ||
(VAR_2 == AVMEDIA_TYPE_VIDEO && VAR_3 &&
VAR_4 > 4 * 1024))) {
av_log(VAR_0, AV_LOG_DEBUG, "Starting new cluster at offset %" PRIu64
" bytes, pts %" PRIu64 "dts %" PRIu64 "\n",
avio_tell(pb), VAR_1->pts, VAR_1->dts);
end_ebml_master(pb, mkv->cluster);
mkv->cluster_pos = 0;
if (mkv->dyn_bc)
mkv_flush_dynbuf(VAR_0);
}
if (mkv->cur_audio_pkt.size > 0) {
VAR_6 = mkv_write_packet_internal(VAR_0, &mkv->cur_audio_pkt);
av_free_packet(&mkv->cur_audio_pkt);
if (VAR_6 < 0) {
av_log(VAR_0, AV_LOG_ERROR, "Could not write cached audio packet VAR_6:%d\n", VAR_6);
return VAR_6;
}
}
if (VAR_2 == AVMEDIA_TYPE_AUDIO) {
mkv->cur_audio_pkt = *VAR_1;
if (VAR_1->buf) {
mkv->cur_audio_pkt.buf = av_buffer_ref(VAR_1->buf);
VAR_6 = mkv->cur_audio_pkt.buf ? 0 : AVERROR(ENOMEM);
} else
VAR_6 = av_dup_packet(&mkv->cur_audio_pkt);
} else
VAR_6 = mkv_write_packet_internal(VAR_0, VAR_1);
return VAR_6;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{",
"MatroskaMuxContext *mkv = VAR_0->priv_data;",
"int VAR_2 = VAR_0->streams[VAR_1->stream_index]->codec->VAR_2;",
"int VAR_3 = !!(VAR_1->flags & AV_PKT_FLAG_KEY);",
"int VAR_4;",
"int VAR_5;",
"int64_t cluster_time;",
"int64_t cluster_time_limit;",
"AVIOContext *pb;",
"int VAR_6;",
"if (mkv->tracks[VAR_1->stream_index].write_dts)\ncluster_time = VAR_1->dts - mkv->cluster_pts;",
"else\ncluster_time = VAR_1->pts - mkv->cluster_pts;",
"if (VAR_0->pb->seekable) {",
"pb = VAR_0->pb;",
"VAR_4 = avio_tell(pb) - mkv->cluster_pos;",
"cluster_time_limit = 5000;",
"VAR_5 = 5 * 1024 * 1024;",
"} else {",
"pb = mkv->dyn_bc;",
"VAR_4 = avio_tell(pb);",
"cluster_time_limit = 1000;",
"VAR_5 = 32 * 1024;",
"}",
"if (mkv->cluster_pos &&\n(VAR_4 > VAR_5 ||\ncluster_time > cluster_time_limit ||\n(VAR_2 == AVMEDIA_TYPE_VIDEO && VAR_3 &&\nVAR_4 > 4 * 1024))) {",
"av_log(VAR_0, AV_LOG_DEBUG, \"Starting new cluster at offset %\" PRIu64\n\" bytes, pts %\" PRIu64 \"dts %\" PRIu64 \"\\n\",\navio_tell(pb), VAR_1->pts, VAR_1->dts);",
"end_ebml_master(pb, mkv->cluster);",
"mkv->cluster_pos = 0;",
"if (mkv->dyn_bc)\nmkv_flush_dynbuf(VAR_0);",
"}",
"if (mkv->cur_audio_pkt.size > 0) {",
"VAR_6 = mkv_write_packet_internal(VAR_0, &mkv->cur_audio_pkt);",
"av_free_packet(&mkv->cur_audio_pkt);",
"if (VAR_6 < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Could not write cached audio packet VAR_6:%d\\n\", VAR_6);",
"return VAR_6;",
"}",
"}",
"if (VAR_2 == AVMEDIA_TYPE_AUDIO) {",
"mkv->cur_audio_pkt = *VAR_1;",
"if (VAR_1->buf) {",
"mkv->cur_audio_pkt.buf = av_buffer_ref(VAR_1->buf);",
"VAR_6 = mkv->cur_audio_pkt.buf ? 0 : AVERROR(ENOMEM);",
"} else",
"VAR_6 = av_dup_packet(&mkv->cur_audio_pkt);",
"} else",
"VAR_6 = mkv_write_packet_internal(VAR_0, VAR_1);",
"return 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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25,
27
],
[
29,
31
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63,
65,
67,
69,
71
],
[
73,
75,
77
],
[
79
],
[
81
],
[
83,
85
],
[
87
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
]
] |
24,020 | static int64_t getutime(void)
{
#ifdef HAVE_GETRUSAGE
struct rusage rusage;
getrusage(RUSAGE_SELF, &rusage);
return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
#elif defined(__MINGW32__)
return av_gettime();
#endif
}
| false | FFmpeg | 7495c3066d7b67bbc74b1d5565684ff48e430099 | static int64_t getutime(void)
{
#ifdef HAVE_GETRUSAGE
struct rusage rusage;
getrusage(RUSAGE_SELF, &rusage);
return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
#elif defined(__MINGW32__)
return av_gettime();
#endif
}
| {
"code": [],
"line_no": []
} | static int64_t FUNC_0(void)
{
#ifdef HAVE_GETRUSAGE
struct rusage rusage;
getrusage(RUSAGE_SELF, &rusage);
return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
#elif defined(__MINGW32__)
return av_gettime();
#endif
}
| [
"static int64_t FUNC_0(void)\n{",
"#ifdef HAVE_GETRUSAGE\nstruct rusage rusage;",
"getrusage(RUSAGE_SELF, &rusage);",
"return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;",
"#elif defined(__MINGW32__)\nreturn av_gettime();",
"#endif\n}"
] | [
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5,
7
],
[
11
],
[
13
],
[
15,
17
],
[
19,
21
]
] |
24,021 | static void colored_fputs(int level, const char *str)
{
if (!*str)
return;
if (use_color < 0) {
#if HAVE_SETCONSOLETEXTATTRIBUTE
CONSOLE_SCREEN_BUFFER_INFO con_info;
con = GetStdHandle(STD_ERROR_HANDLE);
use_color = (con != INVALID_HANDLE_VALUE) && !getenv("NO_COLOR") &&
!getenv("AV_LOG_FORCE_NOCOLOR");
if (use_color) {
GetConsoleScreenBufferInfo(con, &con_info);
attr_orig = con_info.wAttributes;
background = attr_orig & 0xF0;
}
#elif HAVE_ISATTY
use_color = !getenv("NO_COLOR") && !getenv("AV_LOG_FORCE_NOCOLOR") &&
(getenv("TERM") && isatty(2) ||
getenv("AV_LOG_FORCE_COLOR"));
if (getenv("AV_LOG_FORCE_256COLOR"))
use_color *= 256;
#else
use_color = getenv("AV_LOG_FORCE_COLOR") && !getenv("NO_COLOR") &&
!getenv("AV_LOG_FORCE_NOCOLOR");
#endif
}
#if HAVE_SETCONSOLETEXTATTRIBUTE
if (use_color && level != AV_LOG_INFO/8)
SetConsoleTextAttribute(con, background | color[level]);
fputs(str, stderr);
if (use_color && level != AV_LOG_INFO/8)
SetConsoleTextAttribute(con, attr_orig);
#else
if (use_color == 1 && level != AV_LOG_INFO/8) {
fprintf(stderr,
"\033[%d;3%dm%s\033[0m",
(color[level] >> 4) & 15,
color[level] & 15,
str);
} else if (use_color == 256 && level != AV_LOG_INFO/8) {
fprintf(stderr,
"\033[48;5;%dm\033[38;5;%dm%s\033[0m",
(color[level] >> 16) & 0xff,
(color[level] >> 8) & 0xff,
str);
} else
fputs(str, stderr);
#endif
}
| false | FFmpeg | 061e340c05bde91ac988677e47bc562b04be5c20 | static void colored_fputs(int level, const char *str)
{
if (!*str)
return;
if (use_color < 0) {
#if HAVE_SETCONSOLETEXTATTRIBUTE
CONSOLE_SCREEN_BUFFER_INFO con_info;
con = GetStdHandle(STD_ERROR_HANDLE);
use_color = (con != INVALID_HANDLE_VALUE) && !getenv("NO_COLOR") &&
!getenv("AV_LOG_FORCE_NOCOLOR");
if (use_color) {
GetConsoleScreenBufferInfo(con, &con_info);
attr_orig = con_info.wAttributes;
background = attr_orig & 0xF0;
}
#elif HAVE_ISATTY
use_color = !getenv("NO_COLOR") && !getenv("AV_LOG_FORCE_NOCOLOR") &&
(getenv("TERM") && isatty(2) ||
getenv("AV_LOG_FORCE_COLOR"));
if (getenv("AV_LOG_FORCE_256COLOR"))
use_color *= 256;
#else
use_color = getenv("AV_LOG_FORCE_COLOR") && !getenv("NO_COLOR") &&
!getenv("AV_LOG_FORCE_NOCOLOR");
#endif
}
#if HAVE_SETCONSOLETEXTATTRIBUTE
if (use_color && level != AV_LOG_INFO/8)
SetConsoleTextAttribute(con, background | color[level]);
fputs(str, stderr);
if (use_color && level != AV_LOG_INFO/8)
SetConsoleTextAttribute(con, attr_orig);
#else
if (use_color == 1 && level != AV_LOG_INFO/8) {
fprintf(stderr,
"\033[%d;3%dm%s\033[0m",
(color[level] >> 4) & 15,
color[level] & 15,
str);
} else if (use_color == 256 && level != AV_LOG_INFO/8) {
fprintf(stderr,
"\033[48;5;%dm\033[38;5;%dm%s\033[0m",
(color[level] >> 16) & 0xff,
(color[level] >> 8) & 0xff,
str);
} else
fputs(str, stderr);
#endif
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(int VAR_0, const char *VAR_1)
{
if (!*VAR_1)
return;
if (use_color < 0) {
#if HAVE_SETCONSOLETEXTATTRIBUTE
CONSOLE_SCREEN_BUFFER_INFO con_info;
con = GetStdHandle(STD_ERROR_HANDLE);
use_color = (con != INVALID_HANDLE_VALUE) && !getenv("NO_COLOR") &&
!getenv("AV_LOG_FORCE_NOCOLOR");
if (use_color) {
GetConsoleScreenBufferInfo(con, &con_info);
attr_orig = con_info.wAttributes;
background = attr_orig & 0xF0;
}
#elif HAVE_ISATTY
use_color = !getenv("NO_COLOR") && !getenv("AV_LOG_FORCE_NOCOLOR") &&
(getenv("TERM") && isatty(2) ||
getenv("AV_LOG_FORCE_COLOR"));
if (getenv("AV_LOG_FORCE_256COLOR"))
use_color *= 256;
#else
use_color = getenv("AV_LOG_FORCE_COLOR") && !getenv("NO_COLOR") &&
!getenv("AV_LOG_FORCE_NOCOLOR");
#endif
}
#if HAVE_SETCONSOLETEXTATTRIBUTE
if (use_color && VAR_0 != AV_LOG_INFO/8)
SetConsoleTextAttribute(con, background | color[VAR_0]);
fputs(VAR_1, stderr);
if (use_color && VAR_0 != AV_LOG_INFO/8)
SetConsoleTextAttribute(con, attr_orig);
#else
if (use_color == 1 && VAR_0 != AV_LOG_INFO/8) {
fprintf(stderr,
"\033[%d;3%dm%s\033[0m",
(color[VAR_0] >> 4) & 15,
color[VAR_0] & 15,
VAR_1);
} else if (use_color == 256 && VAR_0 != AV_LOG_INFO/8) {
fprintf(stderr,
"\033[48;5;%dm\033[38;5;%dm%s\033[0m",
(color[VAR_0] >> 16) & 0xff,
(color[VAR_0] >> 8) & 0xff,
VAR_1);
} else
fputs(VAR_1, stderr);
#endif
}
| [
"static void FUNC_0(int VAR_0, const char *VAR_1)\n{",
"if (!*VAR_1)\nreturn;",
"if (use_color < 0) {",
"#if HAVE_SETCONSOLETEXTATTRIBUTE\nCONSOLE_SCREEN_BUFFER_INFO con_info;",
"con = GetStdHandle(STD_ERROR_HANDLE);",
"use_color = (con != INVALID_HANDLE_VALUE) && !getenv(\"NO_COLOR\") &&\n!getenv(\"AV_LOG_FORCE_NOCOLOR\");",
"if (use_color) {",
"GetConsoleScreenBufferInfo(con, &con_info);",
"attr_orig = con_info.wAttributes;",
"background = attr_orig & 0xF0;",
"}",
"#elif HAVE_ISATTY\nuse_color = !getenv(\"NO_COLOR\") && !getenv(\"AV_LOG_FORCE_NOCOLOR\") &&\n(getenv(\"TERM\") && isatty(2) ||\ngetenv(\"AV_LOG_FORCE_COLOR\"));",
"if (getenv(\"AV_LOG_FORCE_256COLOR\"))\nuse_color *= 256;",
"#else\nuse_color = getenv(\"AV_LOG_FORCE_COLOR\") && !getenv(\"NO_COLOR\") &&\n!getenv(\"AV_LOG_FORCE_NOCOLOR\");",
"#endif\n}",
"#if HAVE_SETCONSOLETEXTATTRIBUTE\nif (use_color && VAR_0 != AV_LOG_INFO/8)\nSetConsoleTextAttribute(con, background | color[VAR_0]);",
"fputs(VAR_1, stderr);",
"if (use_color && VAR_0 != AV_LOG_INFO/8)\nSetConsoleTextAttribute(con, attr_orig);",
"#else\nif (use_color == 1 && VAR_0 != AV_LOG_INFO/8) {",
"fprintf(stderr,\n\"\\033[%d;3%dm%s\\033[0m\",",
"(color[VAR_0] >> 4) & 15,\ncolor[VAR_0] & 15,\nVAR_1);",
"} else if (use_color == 256 && VAR_0 != AV_LOG_INFO/8) {",
"fprintf(stderr,\n\"\\033[48;5;%dm\\033[38;5;%dm%s\\033[0m\",",
"(color[VAR_0] >> 16) & 0xff,\n(color[VAR_0] >> 8) & 0xff,\nVAR_1);",
"} else",
"fputs(VAR_1, stderr);",
"#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
] | [
[
1,
3
],
[
5,
7
],
[
11
],
[
13,
15
],
[
17
],
[
19,
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33,
35,
37,
39
],
[
41,
43
],
[
45,
47,
49
],
[
51,
53
],
[
57,
59,
61
],
[
63
],
[
65,
67
],
[
69,
71
],
[
73,
75
],
[
77,
79,
81
],
[
83
],
[
85,
87
],
[
89,
91,
93
],
[
95
],
[
97
],
[
99,
103
]
] |
24,022 | static int alsa_poll_helper (snd_pcm_t *handle, struct pollhlp *hlp, int mask)
{
int i, count, err;
struct pollfd *pfds;
count = snd_pcm_poll_descriptors_count (handle);
if (count <= 0) {
dolog ("Could not initialize poll mode\n"
"Invalid number of poll descriptors %d\n", count);
return -1;
}
pfds = audio_calloc ("alsa_poll_helper", count, sizeof (*pfds));
if (!pfds) {
dolog ("Could not initialize poll mode\n");
return -1;
}
err = snd_pcm_poll_descriptors (handle, pfds, count);
if (err < 0) {
alsa_logerr (err, "Could not initialize poll mode\n"
"Could not obtain poll descriptors\n");
g_free (pfds);
return -1;
}
for (i = 0; i < count; ++i) {
if (pfds[i].events & POLLIN) {
err = qemu_set_fd_handler (pfds[i].fd, alsa_poll_handler,
NULL, hlp);
}
if (pfds[i].events & POLLOUT) {
if (conf.verbose) {
dolog ("POLLOUT %d %d\n", i, pfds[i].fd);
}
err = qemu_set_fd_handler (pfds[i].fd, NULL,
alsa_poll_handler, hlp);
}
if (conf.verbose) {
dolog ("Set handler events=%#x index=%d fd=%d err=%d\n",
pfds[i].events, i, pfds[i].fd, err);
}
if (err) {
dolog ("Failed to set handler events=%#x index=%d fd=%d err=%d\n",
pfds[i].events, i, pfds[i].fd, err);
while (i--) {
qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL);
}
g_free (pfds);
return -1;
}
}
hlp->pfds = pfds;
hlp->count = count;
hlp->handle = handle;
hlp->mask = mask;
return 0;
}
| true | qemu | be93f216278d84d283187c95cef16c0b60b711b8 | static int alsa_poll_helper (snd_pcm_t *handle, struct pollhlp *hlp, int mask)
{
int i, count, err;
struct pollfd *pfds;
count = snd_pcm_poll_descriptors_count (handle);
if (count <= 0) {
dolog ("Could not initialize poll mode\n"
"Invalid number of poll descriptors %d\n", count);
return -1;
}
pfds = audio_calloc ("alsa_poll_helper", count, sizeof (*pfds));
if (!pfds) {
dolog ("Could not initialize poll mode\n");
return -1;
}
err = snd_pcm_poll_descriptors (handle, pfds, count);
if (err < 0) {
alsa_logerr (err, "Could not initialize poll mode\n"
"Could not obtain poll descriptors\n");
g_free (pfds);
return -1;
}
for (i = 0; i < count; ++i) {
if (pfds[i].events & POLLIN) {
err = qemu_set_fd_handler (pfds[i].fd, alsa_poll_handler,
NULL, hlp);
}
if (pfds[i].events & POLLOUT) {
if (conf.verbose) {
dolog ("POLLOUT %d %d\n", i, pfds[i].fd);
}
err = qemu_set_fd_handler (pfds[i].fd, NULL,
alsa_poll_handler, hlp);
}
if (conf.verbose) {
dolog ("Set handler events=%#x index=%d fd=%d err=%d\n",
pfds[i].events, i, pfds[i].fd, err);
}
if (err) {
dolog ("Failed to set handler events=%#x index=%d fd=%d err=%d\n",
pfds[i].events, i, pfds[i].fd, err);
while (i--) {
qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL);
}
g_free (pfds);
return -1;
}
}
hlp->pfds = pfds;
hlp->count = count;
hlp->handle = handle;
hlp->mask = mask;
return 0;
}
| {
"code": [
" err = qemu_set_fd_handler (pfds[i].fd, alsa_poll_handler,",
" NULL, hlp);",
" err = qemu_set_fd_handler (pfds[i].fd, NULL,",
" alsa_poll_handler, hlp);",
" if (err) {",
" dolog (\"Failed to set handler events=%#x index=%d fd=%d err=%d\\n\",",
" pfds[i].events, i, pfds[i].fd, err);",
" while (i--) {",
" qemu_set_fd_handler (pfds[i].fd, NULL, NULL, NULL);",
" g_free (pfds);",
" return -1;"
],
"line_no": [
57,
59,
71,
73,
87,
89,
81,
95,
97,
101,
103
]
} | static int FUNC_0 (snd_pcm_t *VAR_0, struct pollhlp *VAR_1, int VAR_2)
{
int VAR_3, VAR_4, VAR_5;
struct pollfd *VAR_6;
VAR_4 = snd_pcm_poll_descriptors_count (VAR_0);
if (VAR_4 <= 0) {
dolog ("Could not initialize poll mode\n"
"Invalid number of poll descriptors %d\n", VAR_4);
return -1;
}
VAR_6 = audio_calloc ("FUNC_0", VAR_4, sizeof (*VAR_6));
if (!VAR_6) {
dolog ("Could not initialize poll mode\n");
return -1;
}
VAR_5 = snd_pcm_poll_descriptors (VAR_0, VAR_6, VAR_4);
if (VAR_5 < 0) {
alsa_logerr (VAR_5, "Could not initialize poll mode\n"
"Could not obtain poll descriptors\n");
g_free (VAR_6);
return -1;
}
for (VAR_3 = 0; VAR_3 < VAR_4; ++VAR_3) {
if (VAR_6[VAR_3].events & POLLIN) {
VAR_5 = qemu_set_fd_handler (VAR_6[VAR_3].fd, alsa_poll_handler,
NULL, VAR_1);
}
if (VAR_6[VAR_3].events & POLLOUT) {
if (conf.verbose) {
dolog ("POLLOUT %d %d\n", VAR_3, VAR_6[VAR_3].fd);
}
VAR_5 = qemu_set_fd_handler (VAR_6[VAR_3].fd, NULL,
alsa_poll_handler, VAR_1);
}
if (conf.verbose) {
dolog ("Set handler events=%#x index=%d fd=%d VAR_5=%d\n",
VAR_6[VAR_3].events, VAR_3, VAR_6[VAR_3].fd, VAR_5);
}
if (VAR_5) {
dolog ("Failed to set handler events=%#x index=%d fd=%d VAR_5=%d\n",
VAR_6[VAR_3].events, VAR_3, VAR_6[VAR_3].fd, VAR_5);
while (VAR_3--) {
qemu_set_fd_handler (VAR_6[VAR_3].fd, NULL, NULL, NULL);
}
g_free (VAR_6);
return -1;
}
}
VAR_1->VAR_6 = VAR_6;
VAR_1->VAR_4 = VAR_4;
VAR_1->VAR_0 = VAR_0;
VAR_1->VAR_2 = VAR_2;
return 0;
}
| [
"static int FUNC_0 (snd_pcm_t *VAR_0, struct pollhlp *VAR_1, int VAR_2)\n{",
"int VAR_3, VAR_4, VAR_5;",
"struct pollfd *VAR_6;",
"VAR_4 = snd_pcm_poll_descriptors_count (VAR_0);",
"if (VAR_4 <= 0) {",
"dolog (\"Could not initialize poll mode\\n\"\n\"Invalid number of poll descriptors %d\\n\", VAR_4);",
"return -1;",
"}",
"VAR_6 = audio_calloc (\"FUNC_0\", VAR_4, sizeof (*VAR_6));",
"if (!VAR_6) {",
"dolog (\"Could not initialize poll mode\\n\");",
"return -1;",
"}",
"VAR_5 = snd_pcm_poll_descriptors (VAR_0, VAR_6, VAR_4);",
"if (VAR_5 < 0) {",
"alsa_logerr (VAR_5, \"Could not initialize poll mode\\n\"\n\"Could not obtain poll descriptors\\n\");",
"g_free (VAR_6);",
"return -1;",
"}",
"for (VAR_3 = 0; VAR_3 < VAR_4; ++VAR_3) {",
"if (VAR_6[VAR_3].events & POLLIN) {",
"VAR_5 = qemu_set_fd_handler (VAR_6[VAR_3].fd, alsa_poll_handler,\nNULL, VAR_1);",
"}",
"if (VAR_6[VAR_3].events & POLLOUT) {",
"if (conf.verbose) {",
"dolog (\"POLLOUT %d %d\\n\", VAR_3, VAR_6[VAR_3].fd);",
"}",
"VAR_5 = qemu_set_fd_handler (VAR_6[VAR_3].fd, NULL,\nalsa_poll_handler, VAR_1);",
"}",
"if (conf.verbose) {",
"dolog (\"Set handler events=%#x index=%d fd=%d VAR_5=%d\\n\",\nVAR_6[VAR_3].events, VAR_3, VAR_6[VAR_3].fd, VAR_5);",
"}",
"if (VAR_5) {",
"dolog (\"Failed to set handler events=%#x index=%d fd=%d VAR_5=%d\\n\",\nVAR_6[VAR_3].events, VAR_3, VAR_6[VAR_3].fd, VAR_5);",
"while (VAR_3--) {",
"qemu_set_fd_handler (VAR_6[VAR_3].fd, NULL, NULL, NULL);",
"}",
"g_free (VAR_6);",
"return -1;",
"}",
"}",
"VAR_1->VAR_6 = VAR_6;",
"VAR_1->VAR_4 = VAR_4;",
"VAR_1->VAR_0 = VAR_0;",
"VAR_1->VAR_2 = 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,
1,
0,
0,
0,
0,
0,
1,
0,
0,
1,
0,
1,
1,
1,
1,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15,
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41,
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
55
],
[
57,
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71,
73
],
[
75
],
[
77
],
[
79,
81
],
[
83
],
[
87
],
[
89,
91
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
]
] |
24,023 | AVFilterBufferRef *avfilter_default_get_audio_buffer(AVFilterLink *link, int perms,
enum AVSampleFormat sample_fmt, int size,
int64_t channel_layout, int planar)
{
AVFilterBuffer *samples = av_mallocz(sizeof(AVFilterBuffer));
AVFilterBufferRef *ref = NULL;
int i, sample_size, chans_nb, bufsize, per_channel_size, step_size = 0;
char *buf;
if (!samples || !(ref = av_mallocz(sizeof(AVFilterBufferRef))))
goto fail;
ref->buf = samples;
ref->format = sample_fmt;
ref->audio = av_mallocz(sizeof(AVFilterBufferRefAudioProps));
if (!ref->audio)
goto fail;
ref->audio->channel_layout = channel_layout;
ref->audio->size = size;
ref->audio->planar = planar;
/* make sure the buffer gets read permission or it's useless for output */
ref->perms = perms | AV_PERM_READ;
samples->refcount = 1;
samples->free = ff_avfilter_default_free_buffer;
sample_size = av_get_bytes_per_sample(sample_fmt);
chans_nb = av_get_channel_layout_nb_channels(channel_layout);
per_channel_size = size/chans_nb;
ref->audio->nb_samples = per_channel_size/sample_size;
/* Set the number of bytes to traverse to reach next sample of a particular channel:
* For planar, this is simply the sample size.
* For packed, this is the number of samples * sample_size.
*/
for (i = 0; i < chans_nb; i++)
samples->linesize[i] = planar > 0 ? per_channel_size : sample_size;
memset(&samples->linesize[chans_nb], 0, (8-chans_nb) * sizeof(samples->linesize[0]));
/* Calculate total buffer size, round to multiple of 16 to be SIMD friendly */
bufsize = (size + 15)&~15;
buf = av_malloc(bufsize);
if (!buf)
goto fail;
/* For planar, set the start point of each channel's data within the buffer
* For packed, set the start point of the entire buffer only
*/
samples->data[0] = buf;
if (buf && planar) {
for (i = 1; i < chans_nb; i++) {
step_size += per_channel_size;
samples->data[i] = buf + step_size;
}
} else {
for (i = 1; i < chans_nb; i++)
samples->data[i] = buf;
}
memset(&samples->data[chans_nb], 0, (8-chans_nb) * sizeof(samples->data[0]));
memcpy(ref->data, samples->data, sizeof(ref->data));
memcpy(ref->linesize, samples->linesize, sizeof(ref->linesize));
return ref;
fail:
if (ref)
av_free(ref->audio);
av_free(ref);
av_free(samples);
return NULL;
}
| false | FFmpeg | cc276c85d15272df6e44fb3252657a43cbd49555 | AVFilterBufferRef *avfilter_default_get_audio_buffer(AVFilterLink *link, int perms,
enum AVSampleFormat sample_fmt, int size,
int64_t channel_layout, int planar)
{
AVFilterBuffer *samples = av_mallocz(sizeof(AVFilterBuffer));
AVFilterBufferRef *ref = NULL;
int i, sample_size, chans_nb, bufsize, per_channel_size, step_size = 0;
char *buf;
if (!samples || !(ref = av_mallocz(sizeof(AVFilterBufferRef))))
goto fail;
ref->buf = samples;
ref->format = sample_fmt;
ref->audio = av_mallocz(sizeof(AVFilterBufferRefAudioProps));
if (!ref->audio)
goto fail;
ref->audio->channel_layout = channel_layout;
ref->audio->size = size;
ref->audio->planar = planar;
ref->perms = perms | AV_PERM_READ;
samples->refcount = 1;
samples->free = ff_avfilter_default_free_buffer;
sample_size = av_get_bytes_per_sample(sample_fmt);
chans_nb = av_get_channel_layout_nb_channels(channel_layout);
per_channel_size = size/chans_nb;
ref->audio->nb_samples = per_channel_size/sample_size;
for (i = 0; i < chans_nb; i++)
samples->linesize[i] = planar > 0 ? per_channel_size : sample_size;
memset(&samples->linesize[chans_nb], 0, (8-chans_nb) * sizeof(samples->linesize[0]));
bufsize = (size + 15)&~15;
buf = av_malloc(bufsize);
if (!buf)
goto fail;
samples->data[0] = buf;
if (buf && planar) {
for (i = 1; i < chans_nb; i++) {
step_size += per_channel_size;
samples->data[i] = buf + step_size;
}
} else {
for (i = 1; i < chans_nb; i++)
samples->data[i] = buf;
}
memset(&samples->data[chans_nb], 0, (8-chans_nb) * sizeof(samples->data[0]));
memcpy(ref->data, samples->data, sizeof(ref->data));
memcpy(ref->linesize, samples->linesize, sizeof(ref->linesize));
return ref;
fail:
if (ref)
av_free(ref->audio);
av_free(ref);
av_free(samples);
return NULL;
}
| {
"code": [],
"line_no": []
} | AVFilterBufferRef *FUNC_0(AVFilterLink *link, int perms,
enum AVSampleFormat sample_fmt, int size,
int64_t channel_layout, int planar)
{
AVFilterBuffer *samples = av_mallocz(sizeof(AVFilterBuffer));
AVFilterBufferRef *ref = NULL;
int VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5 = 0;
char *VAR_6;
if (!samples || !(ref = av_mallocz(sizeof(AVFilterBufferRef))))
goto fail;
ref->VAR_6 = samples;
ref->format = sample_fmt;
ref->audio = av_mallocz(sizeof(AVFilterBufferRefAudioProps));
if (!ref->audio)
goto fail;
ref->audio->channel_layout = channel_layout;
ref->audio->size = size;
ref->audio->planar = planar;
ref->perms = perms | AV_PERM_READ;
samples->refcount = 1;
samples->free = ff_avfilter_default_free_buffer;
VAR_1 = av_get_bytes_per_sample(sample_fmt);
VAR_2 = av_get_channel_layout_nb_channels(channel_layout);
VAR_4 = size/VAR_2;
ref->audio->nb_samples = VAR_4/VAR_1;
for (VAR_0 = 0; VAR_0 < VAR_2; VAR_0++)
samples->linesize[VAR_0] = planar > 0 ? VAR_4 : VAR_1;
memset(&samples->linesize[VAR_2], 0, (8-VAR_2) * sizeof(samples->linesize[0]));
VAR_3 = (size + 15)&~15;
VAR_6 = av_malloc(VAR_3);
if (!VAR_6)
goto fail;
samples->data[0] = VAR_6;
if (VAR_6 && planar) {
for (VAR_0 = 1; VAR_0 < VAR_2; VAR_0++) {
VAR_5 += VAR_4;
samples->data[VAR_0] = VAR_6 + VAR_5;
}
} else {
for (VAR_0 = 1; VAR_0 < VAR_2; VAR_0++)
samples->data[VAR_0] = VAR_6;
}
memset(&samples->data[VAR_2], 0, (8-VAR_2) * sizeof(samples->data[0]));
memcpy(ref->data, samples->data, sizeof(ref->data));
memcpy(ref->linesize, samples->linesize, sizeof(ref->linesize));
return ref;
fail:
if (ref)
av_free(ref->audio);
av_free(ref);
av_free(samples);
return NULL;
}
| [
"AVFilterBufferRef *FUNC_0(AVFilterLink *link, int perms,\nenum AVSampleFormat sample_fmt, int size,\nint64_t channel_layout, int planar)\n{",
"AVFilterBuffer *samples = av_mallocz(sizeof(AVFilterBuffer));",
"AVFilterBufferRef *ref = NULL;",
"int VAR_0, VAR_1, VAR_2, VAR_3, VAR_4, VAR_5 = 0;",
"char *VAR_6;",
"if (!samples || !(ref = av_mallocz(sizeof(AVFilterBufferRef))))\ngoto fail;",
"ref->VAR_6 = samples;",
"ref->format = sample_fmt;",
"ref->audio = av_mallocz(sizeof(AVFilterBufferRefAudioProps));",
"if (!ref->audio)\ngoto fail;",
"ref->audio->channel_layout = channel_layout;",
"ref->audio->size = size;",
"ref->audio->planar = planar;",
"ref->perms = perms | AV_PERM_READ;",
"samples->refcount = 1;",
"samples->free = ff_avfilter_default_free_buffer;",
"VAR_1 = av_get_bytes_per_sample(sample_fmt);",
"VAR_2 = av_get_channel_layout_nb_channels(channel_layout);",
"VAR_4 = size/VAR_2;",
"ref->audio->nb_samples = VAR_4/VAR_1;",
"for (VAR_0 = 0; VAR_0 < VAR_2; VAR_0++)",
"samples->linesize[VAR_0] = planar > 0 ? VAR_4 : VAR_1;",
"memset(&samples->linesize[VAR_2], 0, (8-VAR_2) * sizeof(samples->linesize[0]));",
"VAR_3 = (size + 15)&~15;",
"VAR_6 = av_malloc(VAR_3);",
"if (!VAR_6)\ngoto fail;",
"samples->data[0] = VAR_6;",
"if (VAR_6 && planar) {",
"for (VAR_0 = 1; VAR_0 < VAR_2; VAR_0++) {",
"VAR_5 += VAR_4;",
"samples->data[VAR_0] = VAR_6 + VAR_5;",
"}",
"} else {",
"for (VAR_0 = 1; VAR_0 < VAR_2; VAR_0++)",
"samples->data[VAR_0] = VAR_6;",
"}",
"memset(&samples->data[VAR_2], 0, (8-VAR_2) * sizeof(samples->data[0]));",
"memcpy(ref->data, samples->data, sizeof(ref->data));",
"memcpy(ref->linesize, samples->linesize, sizeof(ref->linesize));",
"return ref;",
"fail:\nif (ref)\nav_free(ref->audio);",
"av_free(ref);",
"av_free(samples);",
"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,
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
],
[
25
],
[
27
],
[
31
],
[
33,
35
],
[
39
],
[
41
],
[
43
],
[
49
],
[
53
],
[
55
],
[
59
],
[
61
],
[
65
],
[
67
],
[
79
],
[
81
],
[
83
],
[
89
],
[
91
],
[
93,
95
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
127
],
[
131
],
[
133
],
[
137
],
[
141,
143,
145
],
[
147
],
[
149
],
[
151
],
[
153
]
] |
24,024 | static MigrationState *migrate_init(const MigrationParams *params)
{
MigrationState *s = migrate_get_current();
int64_t bandwidth_limit = s->bandwidth_limit;
bool enabled_capabilities[MIGRATION_CAPABILITY_MAX];
int64_t xbzrle_cache_size = s->xbzrle_cache_size;
memcpy(enabled_capabilities, s->enabled_capabilities,
sizeof(enabled_capabilities));
memset(s, 0, sizeof(*s));
s->params = *params;
memcpy(s->enabled_capabilities, enabled_capabilities,
sizeof(enabled_capabilities));
s->xbzrle_cache_size = xbzrle_cache_size;
s->bandwidth_limit = bandwidth_limit;
s->state = MIG_STATE_SETUP;
trace_migrate_set_state(MIG_STATE_SETUP);
s->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
return s;
}
| true | qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | static MigrationState *migrate_init(const MigrationParams *params)
{
MigrationState *s = migrate_get_current();
int64_t bandwidth_limit = s->bandwidth_limit;
bool enabled_capabilities[MIGRATION_CAPABILITY_MAX];
int64_t xbzrle_cache_size = s->xbzrle_cache_size;
memcpy(enabled_capabilities, s->enabled_capabilities,
sizeof(enabled_capabilities));
memset(s, 0, sizeof(*s));
s->params = *params;
memcpy(s->enabled_capabilities, enabled_capabilities,
sizeof(enabled_capabilities));
s->xbzrle_cache_size = xbzrle_cache_size;
s->bandwidth_limit = bandwidth_limit;
s->state = MIG_STATE_SETUP;
trace_migrate_set_state(MIG_STATE_SETUP);
s->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
return s;
}
| {
"code": [],
"line_no": []
} | static MigrationState *FUNC_0(const MigrationParams *params)
{
MigrationState *s = migrate_get_current();
int64_t bandwidth_limit = s->bandwidth_limit;
bool enabled_capabilities[MIGRATION_CAPABILITY_MAX];
int64_t xbzrle_cache_size = s->xbzrle_cache_size;
memcpy(enabled_capabilities, s->enabled_capabilities,
sizeof(enabled_capabilities));
memset(s, 0, sizeof(*s));
s->params = *params;
memcpy(s->enabled_capabilities, enabled_capabilities,
sizeof(enabled_capabilities));
s->xbzrle_cache_size = xbzrle_cache_size;
s->bandwidth_limit = bandwidth_limit;
s->state = MIG_STATE_SETUP;
trace_migrate_set_state(MIG_STATE_SETUP);
s->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);
return s;
}
| [
"static MigrationState *FUNC_0(const MigrationParams *params)\n{",
"MigrationState *s = migrate_get_current();",
"int64_t bandwidth_limit = s->bandwidth_limit;",
"bool enabled_capabilities[MIGRATION_CAPABILITY_MAX];",
"int64_t xbzrle_cache_size = s->xbzrle_cache_size;",
"memcpy(enabled_capabilities, s->enabled_capabilities,\nsizeof(enabled_capabilities));",
"memset(s, 0, sizeof(*s));",
"s->params = *params;",
"memcpy(s->enabled_capabilities, enabled_capabilities,\nsizeof(enabled_capabilities));",
"s->xbzrle_cache_size = xbzrle_cache_size;",
"s->bandwidth_limit = bandwidth_limit;",
"s->state = MIG_STATE_SETUP;",
"trace_migrate_set_state(MIG_STATE_SETUP);",
"s->total_time = qemu_clock_get_ms(QEMU_CLOCK_REALTIME);",
"return s;",
"}"
] | [
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
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
]
] |
24,025 | static void chr_read(void *opaque, const uint8_t *buf, int size)
{
TestServer *s = opaque;
CharDriverState *chr = s->chr;
VhostUserMsg msg;
uint8_t *p = (uint8_t *) &msg;
int fd;
if (size != VHOST_USER_HDR_SIZE) {
g_test_message("Wrong message size received %d\n", size);
return;
g_mutex_lock(&s->data_mutex);
memcpy(p, buf, VHOST_USER_HDR_SIZE);
if (msg.size) {
p += VHOST_USER_HDR_SIZE;
size = qemu_chr_fe_read_all(chr, p, msg.size);
if (size != msg.size) {
g_test_message("Wrong message size received %d != %d\n",
size, msg.size);
return;
switch (msg.request) {
case VHOST_USER_GET_FEATURES:
/* send back features to qemu */
msg.flags |= VHOST_USER_REPLY_MASK;
msg.size = sizeof(m.payload.u64);
msg.payload.u64 = 0x1ULL << VHOST_F_LOG_ALL |
0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
break;
case VHOST_USER_SET_FEATURES:
g_assert_cmpint(msg.payload.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES),
!=, 0ULL);
break;
case VHOST_USER_GET_PROTOCOL_FEATURES:
/* send back features to qemu */
msg.flags |= VHOST_USER_REPLY_MASK;
msg.size = sizeof(m.payload.u64);
msg.payload.u64 = 1 << VHOST_USER_PROTOCOL_F_LOG_SHMFD;
p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
break;
case VHOST_USER_GET_VRING_BASE:
/* send back vring base to qemu */
msg.flags |= VHOST_USER_REPLY_MASK;
msg.size = sizeof(m.payload.state);
msg.payload.state.num = 0;
p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
assert(msg.payload.state.index < 2);
s->rings &= ~(0x1ULL << msg.payload.state.index);
break;
case VHOST_USER_SET_MEM_TABLE:
/* received the mem table */
memcpy(&s->memory, &msg.payload.memory, sizeof(msg.payload.memory));
s->fds_num = qemu_chr_fe_get_msgfds(chr, s->fds, G_N_ELEMENTS(s->fds));
/* signal the test that it can continue */
g_cond_signal(&s->data_cond);
break;
case VHOST_USER_SET_VRING_KICK:
case VHOST_USER_SET_VRING_CALL:
/* consume the fd */
qemu_chr_fe_get_msgfds(chr, &fd, 1);
/*
* This is a non-blocking eventfd.
* The receive function forces it to be blocking,
* so revert it back to non-blocking.
*/
qemu_set_nonblock(fd);
break;
case VHOST_USER_SET_LOG_BASE:
if (s->log_fd != -1) {
close(s->log_fd);
s->log_fd = -1;
qemu_chr_fe_get_msgfds(chr, &s->log_fd, 1);
msg.flags |= VHOST_USER_REPLY_MASK;
msg.size = 0;
p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE);
g_cond_signal(&s->data_cond);
break;
case VHOST_USER_SET_VRING_BASE:
assert(msg.payload.state.index < 2);
s->rings |= 0x1ULL << msg.payload.state.index;
break;
default:
break;
g_mutex_unlock(&s->data_mutex); | true | qemu | 5d443f5adad6ddd8238602990b7e86404a288d48 | static void chr_read(void *opaque, const uint8_t *buf, int size)
{
TestServer *s = opaque;
CharDriverState *chr = s->chr;
VhostUserMsg msg;
uint8_t *p = (uint8_t *) &msg;
int fd;
if (size != VHOST_USER_HDR_SIZE) {
g_test_message("Wrong message size received %d\n", size);
return;
g_mutex_lock(&s->data_mutex);
memcpy(p, buf, VHOST_USER_HDR_SIZE);
if (msg.size) {
p += VHOST_USER_HDR_SIZE;
size = qemu_chr_fe_read_all(chr, p, msg.size);
if (size != msg.size) {
g_test_message("Wrong message size received %d != %d\n",
size, msg.size);
return;
switch (msg.request) {
case VHOST_USER_GET_FEATURES:
msg.flags |= VHOST_USER_REPLY_MASK;
msg.size = sizeof(m.payload.u64);
msg.payload.u64 = 0x1ULL << VHOST_F_LOG_ALL |
0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
break;
case VHOST_USER_SET_FEATURES:
g_assert_cmpint(msg.payload.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES),
!=, 0ULL);
break;
case VHOST_USER_GET_PROTOCOL_FEATURES:
msg.flags |= VHOST_USER_REPLY_MASK;
msg.size = sizeof(m.payload.u64);
msg.payload.u64 = 1 << VHOST_USER_PROTOCOL_F_LOG_SHMFD;
p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
break;
case VHOST_USER_GET_VRING_BASE:
msg.flags |= VHOST_USER_REPLY_MASK;
msg.size = sizeof(m.payload.state);
msg.payload.state.num = 0;
p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.size);
assert(msg.payload.state.index < 2);
s->rings &= ~(0x1ULL << msg.payload.state.index);
break;
case VHOST_USER_SET_MEM_TABLE:
memcpy(&s->memory, &msg.payload.memory, sizeof(msg.payload.memory));
s->fds_num = qemu_chr_fe_get_msgfds(chr, s->fds, G_N_ELEMENTS(s->fds));
g_cond_signal(&s->data_cond);
break;
case VHOST_USER_SET_VRING_KICK:
case VHOST_USER_SET_VRING_CALL:
qemu_chr_fe_get_msgfds(chr, &fd, 1);
qemu_set_nonblock(fd);
break;
case VHOST_USER_SET_LOG_BASE:
if (s->log_fd != -1) {
close(s->log_fd);
s->log_fd = -1;
qemu_chr_fe_get_msgfds(chr, &s->log_fd, 1);
msg.flags |= VHOST_USER_REPLY_MASK;
msg.size = 0;
p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE);
g_cond_signal(&s->data_cond);
break;
case VHOST_USER_SET_VRING_BASE:
assert(msg.payload.state.index < 2);
s->rings |= 0x1ULL << msg.payload.state.index;
break;
default:
break;
g_mutex_unlock(&s->data_mutex); | {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0, const uint8_t *VAR_1, int VAR_2)
{
TestServer *s = VAR_0;
CharDriverState *chr = s->chr;
VhostUserMsg msg;
uint8_t *p = (uint8_t *) &msg;
int VAR_3;
if (VAR_2 != VHOST_USER_HDR_SIZE) {
g_test_message("Wrong message VAR_2 received %d\n", VAR_2);
return;
g_mutex_lock(&s->data_mutex);
memcpy(p, VAR_1, VHOST_USER_HDR_SIZE);
if (msg.VAR_2) {
p += VHOST_USER_HDR_SIZE;
VAR_2 = qemu_chr_fe_read_all(chr, p, msg.VAR_2);
if (VAR_2 != msg.VAR_2) {
g_test_message("Wrong message VAR_2 received %d != %d\n",
VAR_2, msg.VAR_2);
return;
switch (msg.request) {
case VHOST_USER_GET_FEATURES:
msg.flags |= VHOST_USER_REPLY_MASK;
msg.VAR_2 = sizeof(m.payload.u64);
msg.payload.u64 = 0x1ULL << VHOST_F_LOG_ALL |
0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;
p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.VAR_2);
break;
case VHOST_USER_SET_FEATURES:
g_assert_cmpint(msg.payload.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES),
!=, 0ULL);
break;
case VHOST_USER_GET_PROTOCOL_FEATURES:
msg.flags |= VHOST_USER_REPLY_MASK;
msg.VAR_2 = sizeof(m.payload.u64);
msg.payload.u64 = 1 << VHOST_USER_PROTOCOL_F_LOG_SHMFD;
p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.VAR_2);
break;
case VHOST_USER_GET_VRING_BASE:
msg.flags |= VHOST_USER_REPLY_MASK;
msg.VAR_2 = sizeof(m.payload.state);
msg.payload.state.num = 0;
p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.VAR_2);
assert(msg.payload.state.index < 2);
s->rings &= ~(0x1ULL << msg.payload.state.index);
break;
case VHOST_USER_SET_MEM_TABLE:
memcpy(&s->memory, &msg.payload.memory, sizeof(msg.payload.memory));
s->fds_num = qemu_chr_fe_get_msgfds(chr, s->fds, G_N_ELEMENTS(s->fds));
g_cond_signal(&s->data_cond);
break;
case VHOST_USER_SET_VRING_KICK:
case VHOST_USER_SET_VRING_CALL:
qemu_chr_fe_get_msgfds(chr, &VAR_3, 1);
qemu_set_nonblock(VAR_3);
break;
case VHOST_USER_SET_LOG_BASE:
if (s->log_fd != -1) {
close(s->log_fd);
s->log_fd = -1;
qemu_chr_fe_get_msgfds(chr, &s->log_fd, 1);
msg.flags |= VHOST_USER_REPLY_MASK;
msg.VAR_2 = 0;
p = (uint8_t *) &msg;
qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE);
g_cond_signal(&s->data_cond);
break;
case VHOST_USER_SET_VRING_BASE:
assert(msg.payload.state.index < 2);
s->rings |= 0x1ULL << msg.payload.state.index;
break;
default:
break;
g_mutex_unlock(&s->data_mutex); | [
"static void FUNC_0(void *VAR_0, const uint8_t *VAR_1, int VAR_2)\n{",
"TestServer *s = VAR_0;",
"CharDriverState *chr = s->chr;",
"VhostUserMsg msg;",
"uint8_t *p = (uint8_t *) &msg;",
"int VAR_3;",
"if (VAR_2 != VHOST_USER_HDR_SIZE) {",
"g_test_message(\"Wrong message VAR_2 received %d\\n\", VAR_2);",
"return;",
"g_mutex_lock(&s->data_mutex);",
"memcpy(p, VAR_1, VHOST_USER_HDR_SIZE);",
"if (msg.VAR_2) {",
"p += VHOST_USER_HDR_SIZE;",
"VAR_2 = qemu_chr_fe_read_all(chr, p, msg.VAR_2);",
"if (VAR_2 != msg.VAR_2) {",
"g_test_message(\"Wrong message VAR_2 received %d != %d\\n\",\nVAR_2, msg.VAR_2);",
"return;",
"switch (msg.request) {",
"case VHOST_USER_GET_FEATURES:\nmsg.flags |= VHOST_USER_REPLY_MASK;",
"msg.VAR_2 = sizeof(m.payload.u64);",
"msg.payload.u64 = 0x1ULL << VHOST_F_LOG_ALL |\n0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES;",
"p = (uint8_t *) &msg;",
"qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.VAR_2);",
"break;",
"case VHOST_USER_SET_FEATURES:\ng_assert_cmpint(msg.payload.u64 & (0x1ULL << VHOST_USER_F_PROTOCOL_FEATURES),\n!=, 0ULL);",
"break;",
"case VHOST_USER_GET_PROTOCOL_FEATURES:\nmsg.flags |= VHOST_USER_REPLY_MASK;",
"msg.VAR_2 = sizeof(m.payload.u64);",
"msg.payload.u64 = 1 << VHOST_USER_PROTOCOL_F_LOG_SHMFD;",
"p = (uint8_t *) &msg;",
"qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.VAR_2);",
"break;",
"case VHOST_USER_GET_VRING_BASE:\nmsg.flags |= VHOST_USER_REPLY_MASK;",
"msg.VAR_2 = sizeof(m.payload.state);",
"msg.payload.state.num = 0;",
"p = (uint8_t *) &msg;",
"qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE + msg.VAR_2);",
"assert(msg.payload.state.index < 2);",
"s->rings &= ~(0x1ULL << msg.payload.state.index);",
"break;",
"case VHOST_USER_SET_MEM_TABLE:\nmemcpy(&s->memory, &msg.payload.memory, sizeof(msg.payload.memory));",
"s->fds_num = qemu_chr_fe_get_msgfds(chr, s->fds, G_N_ELEMENTS(s->fds));",
"g_cond_signal(&s->data_cond);",
"break;",
"case VHOST_USER_SET_VRING_KICK:\ncase VHOST_USER_SET_VRING_CALL:\nqemu_chr_fe_get_msgfds(chr, &VAR_3, 1);",
"qemu_set_nonblock(VAR_3);",
"break;",
"case VHOST_USER_SET_LOG_BASE:\nif (s->log_fd != -1) {",
"close(s->log_fd);",
"s->log_fd = -1;",
"qemu_chr_fe_get_msgfds(chr, &s->log_fd, 1);",
"msg.flags |= VHOST_USER_REPLY_MASK;",
"msg.VAR_2 = 0;",
"p = (uint8_t *) &msg;",
"qemu_chr_fe_write_all(chr, p, VHOST_USER_HDR_SIZE);",
"g_cond_signal(&s->data_cond);",
"break;",
"case VHOST_USER_SET_VRING_BASE:\nassert(msg.payload.state.index < 2);",
"s->rings |= 0x1ULL << msg.payload.state.index;",
"break;",
"default:\nbreak;",
"g_mutex_unlock(&s->data_mutex);"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
23
],
[
24
],
[
25,
26
],
[
27
],
[
28
],
[
29
],
[
30,
31,
32
],
[
33
],
[
34,
36
],
[
37
],
[
38
],
[
39
],
[
40
],
[
41
],
[
42,
44
],
[
45
],
[
46
],
[
47
],
[
48
],
[
49
],
[
50
],
[
51
],
[
52,
54
],
[
55
],
[
57
],
[
58
],
[
59,
60,
62
],
[
68
],
[
69
],
[
70,
71
],
[
72
],
[
73
],
[
74
],
[
75
],
[
76
],
[
77
],
[
78
],
[
79
],
[
80
],
[
81,
82
],
[
83
],
[
84
],
[
85,
86
],
[
87
]
] |
24,026 | static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, int precno,
uint8_t *expn, int numgbits)
{
int bandno, empty = 1;
// init bitstream
*s->buf = 0;
s->bit_index = 0;
// header
// is the packet empty?
for (bandno = 0; bandno < rlevel->nbands; bandno++){
if (rlevel->band[bandno].coord[0][0] < rlevel->band[bandno].coord[0][1]
&& rlevel->band[bandno].coord[1][0] < rlevel->band[bandno].coord[1][1]){
empty = 0;
break;
}
}
put_bits(s, !empty, 1);
if (empty){
j2k_flush(s);
return 0;
}
for (bandno = 0; bandno < rlevel->nbands; bandno++){
Jpeg2000Band *band = rlevel->band + bandno;
Jpeg2000Prec *prec = band->prec + precno;
int yi, xi, pos;
int cblknw = prec->nb_codeblocks_width;
if (band->coord[0][0] == band->coord[0][1]
|| band->coord[1][0] == band->coord[1][1])
continue;
for (pos=0, yi = 0; yi < prec->nb_codeblocks_height; yi++){
for (xi = 0; xi < cblknw; xi++, pos++){
prec->cblkincl[pos].val = prec->cblk[yi * cblknw + xi].ninclpasses == 0;
tag_tree_update(prec->cblkincl + pos);
prec->zerobits[pos].val = expn[bandno] + numgbits - 1 - prec->cblk[yi * cblknw + xi].nonzerobits;
tag_tree_update(prec->zerobits + pos);
}
}
for (pos=0, yi = 0; yi < prec->nb_codeblocks_height; yi++){
for (xi = 0; xi < cblknw; xi++, pos++){
int pad = 0, llen, length;
Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;
if (s->buf_end - s->buf < 20) // approximately
return -1;
// inclusion information
tag_tree_code(s, prec->cblkincl + pos, 1);
if (!cblk->ninclpasses)
continue;
// zerobits information
tag_tree_code(s, prec->zerobits + pos, 100);
// number of passes
putnumpasses(s, cblk->ninclpasses);
length = cblk->passes[cblk->ninclpasses-1].rate;
llen = av_log2(length) - av_log2(cblk->ninclpasses) - 2;
if (llen < 0){
pad = -llen;
llen = 0;
}
// length of code block
put_bits(s, 1, llen);
put_bits(s, 0, 1);
put_num(s, length, av_log2(length)+1+pad);
}
}
}
j2k_flush(s);
for (bandno = 0; bandno < rlevel->nbands; bandno++){
Jpeg2000Band *band = rlevel->band + bandno;
Jpeg2000Prec *prec = band->prec + precno;
int yi, cblknw = prec->nb_codeblocks_width;
for (yi =0; yi < prec->nb_codeblocks_height; yi++){
int xi;
for (xi = 0; xi < cblknw; xi++){
Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;
if (cblk->ninclpasses){
if (s->buf_end - s->buf < cblk->passes[cblk->ninclpasses-1].rate)
return -1;
bytestream_put_buffer(&s->buf, cblk->data, cblk->passes[cblk->ninclpasses-1].rate
- cblk->passes[cblk->ninclpasses-1].flushed_len);
bytestream_put_buffer(&s->buf, cblk->passes[cblk->ninclpasses-1].flushed,
cblk->passes[cblk->ninclpasses-1].flushed_len);
}
}
}
}
return 0;
}
| true | FFmpeg | 3d5822d9cf07d08bce82903e4715658f46b01b5c | static int encode_packet(Jpeg2000EncoderContext *s, Jpeg2000ResLevel *rlevel, int precno,
uint8_t *expn, int numgbits)
{
int bandno, empty = 1;
*s->buf = 0;
s->bit_index = 0;
for (bandno = 0; bandno < rlevel->nbands; bandno++){
if (rlevel->band[bandno].coord[0][0] < rlevel->band[bandno].coord[0][1]
&& rlevel->band[bandno].coord[1][0] < rlevel->band[bandno].coord[1][1]){
empty = 0;
break;
}
}
put_bits(s, !empty, 1);
if (empty){
j2k_flush(s);
return 0;
}
for (bandno = 0; bandno < rlevel->nbands; bandno++){
Jpeg2000Band *band = rlevel->band + bandno;
Jpeg2000Prec *prec = band->prec + precno;
int yi, xi, pos;
int cblknw = prec->nb_codeblocks_width;
if (band->coord[0][0] == band->coord[0][1]
|| band->coord[1][0] == band->coord[1][1])
continue;
for (pos=0, yi = 0; yi < prec->nb_codeblocks_height; yi++){
for (xi = 0; xi < cblknw; xi++, pos++){
prec->cblkincl[pos].val = prec->cblk[yi * cblknw + xi].ninclpasses == 0;
tag_tree_update(prec->cblkincl + pos);
prec->zerobits[pos].val = expn[bandno] + numgbits - 1 - prec->cblk[yi * cblknw + xi].nonzerobits;
tag_tree_update(prec->zerobits + pos);
}
}
for (pos=0, yi = 0; yi < prec->nb_codeblocks_height; yi++){
for (xi = 0; xi < cblknw; xi++, pos++){
int pad = 0, llen, length;
Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;
if (s->buf_end - s->buf < 20)
return -1;
tag_tree_code(s, prec->cblkincl + pos, 1);
if (!cblk->ninclpasses)
continue;
tag_tree_code(s, prec->zerobits + pos, 100);
putnumpasses(s, cblk->ninclpasses);
length = cblk->passes[cblk->ninclpasses-1].rate;
llen = av_log2(length) - av_log2(cblk->ninclpasses) - 2;
if (llen < 0){
pad = -llen;
llen = 0;
}
put_bits(s, 1, llen);
put_bits(s, 0, 1);
put_num(s, length, av_log2(length)+1+pad);
}
}
}
j2k_flush(s);
for (bandno = 0; bandno < rlevel->nbands; bandno++){
Jpeg2000Band *band = rlevel->band + bandno;
Jpeg2000Prec *prec = band->prec + precno;
int yi, cblknw = prec->nb_codeblocks_width;
for (yi =0; yi < prec->nb_codeblocks_height; yi++){
int xi;
for (xi = 0; xi < cblknw; xi++){
Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;
if (cblk->ninclpasses){
if (s->buf_end - s->buf < cblk->passes[cblk->ninclpasses-1].rate)
return -1;
bytestream_put_buffer(&s->buf, cblk->data, cblk->passes[cblk->ninclpasses-1].rate
- cblk->passes[cblk->ninclpasses-1].flushed_len);
bytestream_put_buffer(&s->buf, cblk->passes[cblk->ninclpasses-1].flushed,
cblk->passes[cblk->ninclpasses-1].flushed_len);
}
}
}
}
return 0;
}
| {
"code": [
" bytestream_put_buffer(&s->buf, cblk->data, cblk->passes[cblk->ninclpasses-1].rate"
],
"line_no": [
175
]
} | static int FUNC_0(Jpeg2000EncoderContext *VAR_0, Jpeg2000ResLevel *VAR_1, int VAR_2,
uint8_t *VAR_3, int VAR_4)
{
int VAR_5, VAR_6 = 1;
*VAR_0->buf = 0;
VAR_0->bit_index = 0;
for (VAR_5 = 0; VAR_5 < VAR_1->nbands; VAR_5++){
if (VAR_1->band[VAR_5].coord[0][0] < VAR_1->band[VAR_5].coord[0][1]
&& VAR_1->band[VAR_5].coord[1][0] < VAR_1->band[VAR_5].coord[1][1]){
VAR_6 = 0;
break;
}
}
put_bits(VAR_0, !VAR_6, 1);
if (VAR_6){
j2k_flush(VAR_0);
return 0;
}
for (VAR_5 = 0; VAR_5 < VAR_1->nbands; VAR_5++){
Jpeg2000Band *band = VAR_1->band + VAR_5;
Jpeg2000Prec *prec = band->prec + VAR_2;
int yi, xi, pos;
int cblknw = prec->nb_codeblocks_width;
if (band->coord[0][0] == band->coord[0][1]
|| band->coord[1][0] == band->coord[1][1])
continue;
for (pos=0, yi = 0; yi < prec->nb_codeblocks_height; yi++){
for (xi = 0; xi < cblknw; xi++, pos++){
prec->cblkincl[pos].val = prec->cblk[yi * cblknw + xi].ninclpasses == 0;
tag_tree_update(prec->cblkincl + pos);
prec->zerobits[pos].val = VAR_3[VAR_5] + VAR_4 - 1 - prec->cblk[yi * cblknw + xi].nonzerobits;
tag_tree_update(prec->zerobits + pos);
}
}
for (pos=0, yi = 0; yi < prec->nb_codeblocks_height; yi++){
for (xi = 0; xi < cblknw; xi++, pos++){
int pad = 0, llen, length;
Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;
if (VAR_0->buf_end - VAR_0->buf < 20)
return -1;
tag_tree_code(VAR_0, prec->cblkincl + pos, 1);
if (!cblk->ninclpasses)
continue;
tag_tree_code(VAR_0, prec->zerobits + pos, 100);
putnumpasses(VAR_0, cblk->ninclpasses);
length = cblk->passes[cblk->ninclpasses-1].rate;
llen = av_log2(length) - av_log2(cblk->ninclpasses) - 2;
if (llen < 0){
pad = -llen;
llen = 0;
}
put_bits(VAR_0, 1, llen);
put_bits(VAR_0, 0, 1);
put_num(VAR_0, length, av_log2(length)+1+pad);
}
}
}
j2k_flush(VAR_0);
for (VAR_5 = 0; VAR_5 < VAR_1->nbands; VAR_5++){
Jpeg2000Band *band = VAR_1->band + VAR_5;
Jpeg2000Prec *prec = band->prec + VAR_2;
int yi, cblknw = prec->nb_codeblocks_width;
for (yi =0; yi < prec->nb_codeblocks_height; yi++){
int xi;
for (xi = 0; xi < cblknw; xi++){
Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;
if (cblk->ninclpasses){
if (VAR_0->buf_end - VAR_0->buf < cblk->passes[cblk->ninclpasses-1].rate)
return -1;
bytestream_put_buffer(&VAR_0->buf, cblk->data, cblk->passes[cblk->ninclpasses-1].rate
- cblk->passes[cblk->ninclpasses-1].flushed_len);
bytestream_put_buffer(&VAR_0->buf, cblk->passes[cblk->ninclpasses-1].flushed,
cblk->passes[cblk->ninclpasses-1].flushed_len);
}
}
}
}
return 0;
}
| [
"static int FUNC_0(Jpeg2000EncoderContext *VAR_0, Jpeg2000ResLevel *VAR_1, int VAR_2,\nuint8_t *VAR_3, int VAR_4)\n{",
"int VAR_5, VAR_6 = 1;",
"*VAR_0->buf = 0;",
"VAR_0->bit_index = 0;",
"for (VAR_5 = 0; VAR_5 < VAR_1->nbands; VAR_5++){",
"if (VAR_1->band[VAR_5].coord[0][0] < VAR_1->band[VAR_5].coord[0][1]\n&& VAR_1->band[VAR_5].coord[1][0] < VAR_1->band[VAR_5].coord[1][1]){",
"VAR_6 = 0;",
"break;",
"}",
"}",
"put_bits(VAR_0, !VAR_6, 1);",
"if (VAR_6){",
"j2k_flush(VAR_0);",
"return 0;",
"}",
"for (VAR_5 = 0; VAR_5 < VAR_1->nbands; VAR_5++){",
"Jpeg2000Band *band = VAR_1->band + VAR_5;",
"Jpeg2000Prec *prec = band->prec + VAR_2;",
"int yi, xi, pos;",
"int cblknw = prec->nb_codeblocks_width;",
"if (band->coord[0][0] == band->coord[0][1]\n|| band->coord[1][0] == band->coord[1][1])\ncontinue;",
"for (pos=0, yi = 0; yi < prec->nb_codeblocks_height; yi++){",
"for (xi = 0; xi < cblknw; xi++, pos++){",
"prec->cblkincl[pos].val = prec->cblk[yi * cblknw + xi].ninclpasses == 0;",
"tag_tree_update(prec->cblkincl + pos);",
"prec->zerobits[pos].val = VAR_3[VAR_5] + VAR_4 - 1 - prec->cblk[yi * cblknw + xi].nonzerobits;",
"tag_tree_update(prec->zerobits + pos);",
"}",
"}",
"for (pos=0, yi = 0; yi < prec->nb_codeblocks_height; yi++){",
"for (xi = 0; xi < cblknw; xi++, pos++){",
"int pad = 0, llen, length;",
"Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;",
"if (VAR_0->buf_end - VAR_0->buf < 20)\nreturn -1;",
"tag_tree_code(VAR_0, prec->cblkincl + pos, 1);",
"if (!cblk->ninclpasses)\ncontinue;",
"tag_tree_code(VAR_0, prec->zerobits + pos, 100);",
"putnumpasses(VAR_0, cblk->ninclpasses);",
"length = cblk->passes[cblk->ninclpasses-1].rate;",
"llen = av_log2(length) - av_log2(cblk->ninclpasses) - 2;",
"if (llen < 0){",
"pad = -llen;",
"llen = 0;",
"}",
"put_bits(VAR_0, 1, llen);",
"put_bits(VAR_0, 0, 1);",
"put_num(VAR_0, length, av_log2(length)+1+pad);",
"}",
"}",
"}",
"j2k_flush(VAR_0);",
"for (VAR_5 = 0; VAR_5 < VAR_1->nbands; VAR_5++){",
"Jpeg2000Band *band = VAR_1->band + VAR_5;",
"Jpeg2000Prec *prec = band->prec + VAR_2;",
"int yi, cblknw = prec->nb_codeblocks_width;",
"for (yi =0; yi < prec->nb_codeblocks_height; yi++){",
"int xi;",
"for (xi = 0; xi < cblknw; xi++){",
"Jpeg2000Cblk *cblk = prec->cblk + yi * cblknw + xi;",
"if (cblk->ninclpasses){",
"if (VAR_0->buf_end - VAR_0->buf < cblk->passes[cblk->ninclpasses-1].rate)\nreturn -1;",
"bytestream_put_buffer(&VAR_0->buf, cblk->data, cblk->passes[cblk->ninclpasses-1].rate\n- cblk->passes[cblk->ninclpasses-1].flushed_len);",
"bytestream_put_buffer(&VAR_0->buf, cblk->passes[cblk->ninclpasses-1].flushed,\ncblk->passes[cblk->ninclpasses-1].flushed_len);",
"}",
"}",
"}",
"}",
"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,
1,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
13
],
[
15
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65,
67,
69
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
91
],
[
93
],
[
95
],
[
97
],
[
101,
103
],
[
109
],
[
111,
113
],
[
117
],
[
121
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
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
]
] |
24,027 | static int ivi_init_tiles(IVIBandDesc *band, IVITile *ref_tile,
int p, int b, int t_height, int t_width)
{
int x, y;
IVITile *tile = band->tiles;
for (y = 0; y < band->height; y += t_height) {
for (x = 0; x < band->width; x += t_width) {
tile->xpos = x;
tile->ypos = y;
tile->mb_size = band->mb_size;
tile->width = FFMIN(band->width - x, t_width);
tile->height = FFMIN(band->height - y, t_height);
tile->is_empty = tile->data_size = 0;
/* calculate number of macroblocks */
tile->num_MBs = IVI_MBs_PER_TILE(tile->width, tile->height,
band->mb_size);
av_freep(&tile->mbs);
tile->mbs = av_malloc(tile->num_MBs * sizeof(IVIMbInfo));
if (!tile->mbs)
return AVERROR(ENOMEM);
tile->ref_mbs = 0;
if (p || b) {
if (tile->num_MBs != ref_tile->num_MBs) {
av_log(NULL, AV_LOG_DEBUG, "ref_tile mismatch\n");
return AVERROR_INVALIDDATA;
}
tile->ref_mbs = ref_tile->mbs;
ref_tile++;
}
tile++;
}
}
return 0;
}
| true | FFmpeg | d164ad3298c155330e303bea907920643b5d74a3 | static int ivi_init_tiles(IVIBandDesc *band, IVITile *ref_tile,
int p, int b, int t_height, int t_width)
{
int x, y;
IVITile *tile = band->tiles;
for (y = 0; y < band->height; y += t_height) {
for (x = 0; x < band->width; x += t_width) {
tile->xpos = x;
tile->ypos = y;
tile->mb_size = band->mb_size;
tile->width = FFMIN(band->width - x, t_width);
tile->height = FFMIN(band->height - y, t_height);
tile->is_empty = tile->data_size = 0;
tile->num_MBs = IVI_MBs_PER_TILE(tile->width, tile->height,
band->mb_size);
av_freep(&tile->mbs);
tile->mbs = av_malloc(tile->num_MBs * sizeof(IVIMbInfo));
if (!tile->mbs)
return AVERROR(ENOMEM);
tile->ref_mbs = 0;
if (p || b) {
if (tile->num_MBs != ref_tile->num_MBs) {
av_log(NULL, AV_LOG_DEBUG, "ref_tile mismatch\n");
return AVERROR_INVALIDDATA;
}
tile->ref_mbs = ref_tile->mbs;
ref_tile++;
}
tile++;
}
}
return 0;
}
| {
"code": [
" tile->mbs = av_malloc(tile->num_MBs * sizeof(IVIMbInfo));"
],
"line_no": [
39
]
} | static int FUNC_0(IVIBandDesc *VAR_0, IVITile *VAR_1,
int VAR_2, int VAR_3, int VAR_4, int VAR_5)
{
int VAR_6, VAR_7;
IVITile *tile = VAR_0->tiles;
for (VAR_7 = 0; VAR_7 < VAR_0->height; VAR_7 += VAR_4) {
for (VAR_6 = 0; VAR_6 < VAR_0->width; VAR_6 += VAR_5) {
tile->xpos = VAR_6;
tile->ypos = VAR_7;
tile->mb_size = VAR_0->mb_size;
tile->width = FFMIN(VAR_0->width - VAR_6, VAR_5);
tile->height = FFMIN(VAR_0->height - VAR_7, VAR_4);
tile->is_empty = tile->data_size = 0;
tile->num_MBs = IVI_MBs_PER_TILE(tile->width, tile->height,
VAR_0->mb_size);
av_freep(&tile->mbs);
tile->mbs = av_malloc(tile->num_MBs * sizeof(IVIMbInfo));
if (!tile->mbs)
return AVERROR(ENOMEM);
tile->ref_mbs = 0;
if (VAR_2 || VAR_3) {
if (tile->num_MBs != VAR_1->num_MBs) {
av_log(NULL, AV_LOG_DEBUG, "VAR_1 mismatch\n");
return AVERROR_INVALIDDATA;
}
tile->ref_mbs = VAR_1->mbs;
VAR_1++;
}
tile++;
}
}
return 0;
}
| [
"static int FUNC_0(IVIBandDesc *VAR_0, IVITile *VAR_1,\nint VAR_2, int VAR_3, int VAR_4, int VAR_5)\n{",
"int VAR_6, VAR_7;",
"IVITile *tile = VAR_0->tiles;",
"for (VAR_7 = 0; VAR_7 < VAR_0->height; VAR_7 += VAR_4) {",
"for (VAR_6 = 0; VAR_6 < VAR_0->width; VAR_6 += VAR_5) {",
"tile->xpos = VAR_6;",
"tile->ypos = VAR_7;",
"tile->mb_size = VAR_0->mb_size;",
"tile->width = FFMIN(VAR_0->width - VAR_6, VAR_5);",
"tile->height = FFMIN(VAR_0->height - VAR_7, VAR_4);",
"tile->is_empty = tile->data_size = 0;",
"tile->num_MBs = IVI_MBs_PER_TILE(tile->width, tile->height,\nVAR_0->mb_size);",
"av_freep(&tile->mbs);",
"tile->mbs = av_malloc(tile->num_MBs * sizeof(IVIMbInfo));",
"if (!tile->mbs)\nreturn AVERROR(ENOMEM);",
"tile->ref_mbs = 0;",
"if (VAR_2 || VAR_3) {",
"if (tile->num_MBs != VAR_1->num_MBs) {",
"av_log(NULL, AV_LOG_DEBUG, \"VAR_1 mismatch\\n\");",
"return AVERROR_INVALIDDATA;",
"}",
"tile->ref_mbs = VAR_1->mbs;",
"VAR_1++;",
"}",
"tile++;",
"}",
"}",
"return 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
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31,
33
],
[
37
],
[
39
],
[
41,
43
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75
]
] |
24,028 | static av_cold int common_end(AVCodecContext *avctx){
FFV1Context *s = avctx->priv_data;
int i, j;
for(j=0; j<s->slice_count; j++){
FFV1Context *fs= s->slice_context[j];
for(i=0; i<s->plane_count; i++){
PlaneContext *p= &fs->plane[i];
av_freep(&p->state);
av_freep(&p->vlc_state);
av_freep(&fs->sample_buffer);
av_freep(&avctx->stats_out);
for(j=0; j<s->quant_table_count; j++){
av_freep(&s->initial_states[j]);
FFV1Context *sf= s->slice_context[i];
av_freep(&sf->rc_stat2[j]);
av_freep(&s->rc_stat2[j]);
return 0; | true | FFmpeg | a0e7079a207fc38cb3754cf11a29863c81f633e4 | static av_cold int common_end(AVCodecContext *avctx){
FFV1Context *s = avctx->priv_data;
int i, j;
for(j=0; j<s->slice_count; j++){
FFV1Context *fs= s->slice_context[j];
for(i=0; i<s->plane_count; i++){
PlaneContext *p= &fs->plane[i];
av_freep(&p->state);
av_freep(&p->vlc_state);
av_freep(&fs->sample_buffer);
av_freep(&avctx->stats_out);
for(j=0; j<s->quant_table_count; j++){
av_freep(&s->initial_states[j]);
FFV1Context *sf= s->slice_context[i];
av_freep(&sf->rc_stat2[j]);
av_freep(&s->rc_stat2[j]);
return 0; | {
"code": [],
"line_no": []
} | static av_cold int FUNC_0(AVCodecContext *avctx){
FFV1Context *s = avctx->priv_data;
int VAR_0, VAR_1;
for(VAR_1=0; VAR_1<s->slice_count; VAR_1++){
FFV1Context *fs= s->slice_context[VAR_1];
for(VAR_0=0; VAR_0<s->plane_count; VAR_0++){
PlaneContext *p= &fs->plane[VAR_0];
av_freep(&p->state);
av_freep(&p->vlc_state);
av_freep(&fs->sample_buffer);
av_freep(&avctx->stats_out);
for(VAR_1=0; VAR_1<s->quant_table_count; VAR_1++){
av_freep(&s->initial_states[VAR_1]);
FFV1Context *sf= s->slice_context[VAR_0];
av_freep(&sf->rc_stat2[VAR_1]);
av_freep(&s->rc_stat2[VAR_1]);
return 0; | [
"static av_cold int FUNC_0(AVCodecContext *avctx){",
"FFV1Context *s = avctx->priv_data;",
"int VAR_0, VAR_1;",
"for(VAR_1=0; VAR_1<s->slice_count; VAR_1++){",
"FFV1Context *fs= s->slice_context[VAR_1];",
"for(VAR_0=0; VAR_0<s->plane_count; VAR_0++){",
"PlaneContext *p= &fs->plane[VAR_0];",
"av_freep(&p->state);",
"av_freep(&p->vlc_state);",
"av_freep(&fs->sample_buffer);",
"av_freep(&avctx->stats_out);",
"for(VAR_1=0; VAR_1<s->quant_table_count; VAR_1++){",
"av_freep(&s->initial_states[VAR_1]);",
"FFV1Context *sf= s->slice_context[VAR_0];",
"av_freep(&sf->rc_stat2[VAR_1]);",
"av_freep(&s->rc_stat2[VAR_1]);",
"return 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
]
] |
24,029 | unsigned ff_dxva2_get_surface_index(const AVCodecContext *avctx,
const AVDXVAContext *ctx,
const AVFrame *frame)
{
void *surface = ff_dxva2_get_surface(frame);
unsigned i;
for (i = 0; i < DXVA_CONTEXT_COUNT(avctx, ctx); i++)
if (DXVA_CONTEXT_SURFACE(avctx, ctx, i) == surface)
return i;
assert(0);
return 0;
}
| true | FFmpeg | be630b1e08ebe8f766b1798accd6b8e5e096f5aa | unsigned ff_dxva2_get_surface_index(const AVCodecContext *avctx,
const AVDXVAContext *ctx,
const AVFrame *frame)
{
void *surface = ff_dxva2_get_surface(frame);
unsigned i;
for (i = 0; i < DXVA_CONTEXT_COUNT(avctx, ctx); i++)
if (DXVA_CONTEXT_SURFACE(avctx, ctx, i) == surface)
return i;
assert(0);
return 0;
}
| {
"code": [
" if (DXVA_CONTEXT_SURFACE(avctx, ctx, i) == surface)"
],
"line_no": [
17
]
} | unsigned FUNC_0(const AVCodecContext *VAR_0,
const AVDXVAContext *VAR_1,
const AVFrame *VAR_2)
{
void *VAR_3 = ff_dxva2_get_surface(VAR_2);
unsigned VAR_4;
for (VAR_4 = 0; VAR_4 < DXVA_CONTEXT_COUNT(VAR_0, VAR_1); VAR_4++)
if (DXVA_CONTEXT_SURFACE(VAR_0, VAR_1, VAR_4) == VAR_3)
return VAR_4;
assert(0);
return 0;
}
| [
"unsigned FUNC_0(const AVCodecContext *VAR_0,\nconst AVDXVAContext *VAR_1,\nconst AVFrame *VAR_2)\n{",
"void *VAR_3 = ff_dxva2_get_surface(VAR_2);",
"unsigned VAR_4;",
"for (VAR_4 = 0; VAR_4 < DXVA_CONTEXT_COUNT(VAR_0, VAR_1); VAR_4++)",
"if (DXVA_CONTEXT_SURFACE(VAR_0, VAR_1, VAR_4) == VAR_3)\nreturn VAR_4;",
"assert(0);",
"return 0;",
"}"
] | [
0,
0,
0,
0,
1,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
15
],
[
17,
19
],
[
23
],
[
25
],
[
27
]
] |
24,030 | CpuInfoList *qmp_query_cpus(Error **errp)
{
MachineState *ms = MACHINE(qdev_get_machine());
MachineClass *mc = MACHINE_GET_CLASS(ms);
CpuInfoList *head = NULL, *cur_item = NULL;
CPUState *cpu;
CPU_FOREACH(cpu) {
CpuInfoList *info;
#if defined(TARGET_I386)
X86CPU *x86_cpu = X86_CPU(cpu);
CPUX86State *env = &x86_cpu->env;
#elif defined(TARGET_PPC)
PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
CPUPPCState *env = &ppc_cpu->env;
#elif defined(TARGET_SPARC)
SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
CPUSPARCState *env = &sparc_cpu->env;
#elif defined(TARGET_MIPS)
MIPSCPU *mips_cpu = MIPS_CPU(cpu);
CPUMIPSState *env = &mips_cpu->env;
#elif defined(TARGET_TRICORE)
TriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);
CPUTriCoreState *env = &tricore_cpu->env;
#endif
cpu_synchronize_state(cpu);
info = g_malloc0(sizeof(*info));
info->value = g_malloc0(sizeof(*info->value));
info->value->CPU = cpu->cpu_index;
info->value->current = (cpu == first_cpu);
info->value->halted = cpu->halted;
info->value->qom_path = object_get_canonical_path(OBJECT(cpu));
info->value->thread_id = cpu->thread_id;
#if defined(TARGET_I386)
info->value->arch = CPU_INFO_ARCH_X86;
info->value->u.x86.pc = env->eip + env->segs[R_CS].base;
#elif defined(TARGET_PPC)
info->value->arch = CPU_INFO_ARCH_PPC;
info->value->u.ppc.nip = env->nip;
#elif defined(TARGET_SPARC)
info->value->arch = CPU_INFO_ARCH_SPARC;
info->value->u.q_sparc.pc = env->pc;
info->value->u.q_sparc.npc = env->npc;
#elif defined(TARGET_MIPS)
info->value->arch = CPU_INFO_ARCH_MIPS;
info->value->u.q_mips.PC = env->active_tc.PC;
#elif defined(TARGET_TRICORE)
info->value->arch = CPU_INFO_ARCH_TRICORE;
info->value->u.tricore.PC = env->PC;
#else
info->value->arch = CPU_INFO_ARCH_OTHER;
#endif
/* XXX: waiting for the qapi to support GSList */
if (!cur_item) {
head = cur_item = info;
} else {
cur_item->next = info;
cur_item = info;
return head;
| true | qemu | afed5a5a7030a074a181d2a0ce8202de71a6ada4 | CpuInfoList *qmp_query_cpus(Error **errp)
{
MachineState *ms = MACHINE(qdev_get_machine());
MachineClass *mc = MACHINE_GET_CLASS(ms);
CpuInfoList *head = NULL, *cur_item = NULL;
CPUState *cpu;
CPU_FOREACH(cpu) {
CpuInfoList *info;
#if defined(TARGET_I386)
X86CPU *x86_cpu = X86_CPU(cpu);
CPUX86State *env = &x86_cpu->env;
#elif defined(TARGET_PPC)
PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
CPUPPCState *env = &ppc_cpu->env;
#elif defined(TARGET_SPARC)
SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
CPUSPARCState *env = &sparc_cpu->env;
#elif defined(TARGET_MIPS)
MIPSCPU *mips_cpu = MIPS_CPU(cpu);
CPUMIPSState *env = &mips_cpu->env;
#elif defined(TARGET_TRICORE)
TriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);
CPUTriCoreState *env = &tricore_cpu->env;
#endif
cpu_synchronize_state(cpu);
info = g_malloc0(sizeof(*info));
info->value = g_malloc0(sizeof(*info->value));
info->value->CPU = cpu->cpu_index;
info->value->current = (cpu == first_cpu);
info->value->halted = cpu->halted;
info->value->qom_path = object_get_canonical_path(OBJECT(cpu));
info->value->thread_id = cpu->thread_id;
#if defined(TARGET_I386)
info->value->arch = CPU_INFO_ARCH_X86;
info->value->u.x86.pc = env->eip + env->segs[R_CS].base;
#elif defined(TARGET_PPC)
info->value->arch = CPU_INFO_ARCH_PPC;
info->value->u.ppc.nip = env->nip;
#elif defined(TARGET_SPARC)
info->value->arch = CPU_INFO_ARCH_SPARC;
info->value->u.q_sparc.pc = env->pc;
info->value->u.q_sparc.npc = env->npc;
#elif defined(TARGET_MIPS)
info->value->arch = CPU_INFO_ARCH_MIPS;
info->value->u.q_mips.PC = env->active_tc.PC;
#elif defined(TARGET_TRICORE)
info->value->arch = CPU_INFO_ARCH_TRICORE;
info->value->u.tricore.PC = env->PC;
#else
info->value->arch = CPU_INFO_ARCH_OTHER;
#endif
if (!cur_item) {
head = cur_item = info;
} else {
cur_item->next = info;
cur_item = info;
return head;
| {
"code": [],
"line_no": []
} | CpuInfoList *FUNC_0(Error **errp)
{
MachineState *ms = MACHINE(qdev_get_machine());
MachineClass *mc = MACHINE_GET_CLASS(ms);
CpuInfoList *head = NULL, *cur_item = NULL;
CPUState *cpu;
CPU_FOREACH(cpu) {
CpuInfoList *info;
#if defined(TARGET_I386)
X86CPU *x86_cpu = X86_CPU(cpu);
CPUX86State *env = &x86_cpu->env;
#elif defined(TARGET_PPC)
PowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);
CPUPPCState *env = &ppc_cpu->env;
#elif defined(TARGET_SPARC)
SPARCCPU *sparc_cpu = SPARC_CPU(cpu);
CPUSPARCState *env = &sparc_cpu->env;
#elif defined(TARGET_MIPS)
MIPSCPU *mips_cpu = MIPS_CPU(cpu);
CPUMIPSState *env = &mips_cpu->env;
#elif defined(TARGET_TRICORE)
TriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);
CPUTriCoreState *env = &tricore_cpu->env;
#endif
cpu_synchronize_state(cpu);
info = g_malloc0(sizeof(*info));
info->value = g_malloc0(sizeof(*info->value));
info->value->CPU = cpu->cpu_index;
info->value->current = (cpu == first_cpu);
info->value->halted = cpu->halted;
info->value->qom_path = object_get_canonical_path(OBJECT(cpu));
info->value->thread_id = cpu->thread_id;
#if defined(TARGET_I386)
info->value->arch = CPU_INFO_ARCH_X86;
info->value->u.x86.pc = env->eip + env->segs[R_CS].base;
#elif defined(TARGET_PPC)
info->value->arch = CPU_INFO_ARCH_PPC;
info->value->u.ppc.nip = env->nip;
#elif defined(TARGET_SPARC)
info->value->arch = CPU_INFO_ARCH_SPARC;
info->value->u.q_sparc.pc = env->pc;
info->value->u.q_sparc.npc = env->npc;
#elif defined(TARGET_MIPS)
info->value->arch = CPU_INFO_ARCH_MIPS;
info->value->u.q_mips.PC = env->active_tc.PC;
#elif defined(TARGET_TRICORE)
info->value->arch = CPU_INFO_ARCH_TRICORE;
info->value->u.tricore.PC = env->PC;
#else
info->value->arch = CPU_INFO_ARCH_OTHER;
#endif
if (!cur_item) {
head = cur_item = info;
} else {
cur_item->next = info;
cur_item = info;
return head;
| [
"CpuInfoList *FUNC_0(Error **errp)\n{",
"MachineState *ms = MACHINE(qdev_get_machine());",
"MachineClass *mc = MACHINE_GET_CLASS(ms);",
"CpuInfoList *head = NULL, *cur_item = NULL;",
"CPUState *cpu;",
"CPU_FOREACH(cpu) {",
"CpuInfoList *info;",
"#if defined(TARGET_I386)\nX86CPU *x86_cpu = X86_CPU(cpu);",
"CPUX86State *env = &x86_cpu->env;",
"#elif defined(TARGET_PPC)\nPowerPCCPU *ppc_cpu = POWERPC_CPU(cpu);",
"CPUPPCState *env = &ppc_cpu->env;",
"#elif defined(TARGET_SPARC)\nSPARCCPU *sparc_cpu = SPARC_CPU(cpu);",
"CPUSPARCState *env = &sparc_cpu->env;",
"#elif defined(TARGET_MIPS)\nMIPSCPU *mips_cpu = MIPS_CPU(cpu);",
"CPUMIPSState *env = &mips_cpu->env;",
"#elif defined(TARGET_TRICORE)\nTriCoreCPU *tricore_cpu = TRICORE_CPU(cpu);",
"CPUTriCoreState *env = &tricore_cpu->env;",
"#endif\ncpu_synchronize_state(cpu);",
"info = g_malloc0(sizeof(*info));",
"info->value = g_malloc0(sizeof(*info->value));",
"info->value->CPU = cpu->cpu_index;",
"info->value->current = (cpu == first_cpu);",
"info->value->halted = cpu->halted;",
"info->value->qom_path = object_get_canonical_path(OBJECT(cpu));",
"info->value->thread_id = cpu->thread_id;",
"#if defined(TARGET_I386)\ninfo->value->arch = CPU_INFO_ARCH_X86;",
"info->value->u.x86.pc = env->eip + env->segs[R_CS].base;",
"#elif defined(TARGET_PPC)\ninfo->value->arch = CPU_INFO_ARCH_PPC;",
"info->value->u.ppc.nip = env->nip;",
"#elif defined(TARGET_SPARC)\ninfo->value->arch = CPU_INFO_ARCH_SPARC;",
"info->value->u.q_sparc.pc = env->pc;",
"info->value->u.q_sparc.npc = env->npc;",
"#elif defined(TARGET_MIPS)\ninfo->value->arch = CPU_INFO_ARCH_MIPS;",
"info->value->u.q_mips.PC = env->active_tc.PC;",
"#elif defined(TARGET_TRICORE)\ninfo->value->arch = CPU_INFO_ARCH_TRICORE;",
"info->value->u.tricore.PC = env->PC;",
"#else\ninfo->value->arch = CPU_INFO_ARCH_OTHER;",
"#endif\nif (!cur_item) {",
"head = cur_item = info;",
"} else {",
"cur_item->next = info;",
"cur_item = info;",
"return head;"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
39
],
[
41
],
[
43,
45
],
[
47
],
[
49,
53
],
[
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,
120
],
[
122
],
[
124
],
[
126
],
[
128
],
[
134
]
] |
24,031 | static hwaddr ppc_hash64_htab_lookup(PowerPCCPU *cpu,
ppc_slb_t *slb, target_ulong eaddr,
ppc_hash_pte64_t *pte)
{
CPUPPCState *env = &cpu->env;
hwaddr pte_offset;
hwaddr hash;
uint64_t vsid, epnmask, epn, ptem;
/* The SLB store path should prevent any bad page size encodings
* getting in there, so: */
assert(slb->sps);
epnmask = ~((1ULL << slb->sps->page_shift) - 1);
if (slb->vsid & SLB_VSID_B) {
/* 1TB segment */
vsid = (slb->vsid & SLB_VSID_VSID) >> SLB_VSID_SHIFT_1T;
epn = (eaddr & ~SEGMENT_MASK_1T) & epnmask;
hash = vsid ^ (vsid << 25) ^ (epn >> slb->sps->page_shift);
} else {
/* 256M segment */
vsid = (slb->vsid & SLB_VSID_VSID) >> SLB_VSID_SHIFT;
epn = (eaddr & ~SEGMENT_MASK_256M) & epnmask;
hash = vsid ^ (epn >> slb->sps->page_shift);
}
ptem = (slb->vsid & SLB_VSID_PTEM) | ((epn >> 16) & HPTE64_V_AVPN);
/* Page address translation */
qemu_log_mask(CPU_LOG_MMU,
"htab_base " TARGET_FMT_plx " htab_mask " TARGET_FMT_plx
" hash " TARGET_FMT_plx "\n",
env->htab_base, env->htab_mask, hash);
/* Primary PTEG lookup */
qemu_log_mask(CPU_LOG_MMU,
"0 htab=" TARGET_FMT_plx "/" TARGET_FMT_plx
" vsid=" TARGET_FMT_lx " ptem=" TARGET_FMT_lx
" hash=" TARGET_FMT_plx "\n",
env->htab_base, env->htab_mask, vsid, ptem, hash);
pte_offset = ppc_hash64_pteg_search(cpu, hash, slb, 0, ptem, pte);
if (pte_offset == -1) {
/* Secondary PTEG lookup */
qemu_log_mask(CPU_LOG_MMU,
"1 htab=" TARGET_FMT_plx "/" TARGET_FMT_plx
" vsid=" TARGET_FMT_lx " api=" TARGET_FMT_lx
" hash=" TARGET_FMT_plx "\n", env->htab_base,
env->htab_mask, vsid, ptem, ~hash);
pte_offset = ppc_hash64_pteg_search(cpu, ~hash, slb, 1, ptem, pte);
}
return pte_offset;
}
| true | qemu | 073de86aa934d46d596a2367e7501da5500e5b86 | static hwaddr ppc_hash64_htab_lookup(PowerPCCPU *cpu,
ppc_slb_t *slb, target_ulong eaddr,
ppc_hash_pte64_t *pte)
{
CPUPPCState *env = &cpu->env;
hwaddr pte_offset;
hwaddr hash;
uint64_t vsid, epnmask, epn, ptem;
assert(slb->sps);
epnmask = ~((1ULL << slb->sps->page_shift) - 1);
if (slb->vsid & SLB_VSID_B) {
vsid = (slb->vsid & SLB_VSID_VSID) >> SLB_VSID_SHIFT_1T;
epn = (eaddr & ~SEGMENT_MASK_1T) & epnmask;
hash = vsid ^ (vsid << 25) ^ (epn >> slb->sps->page_shift);
} else {
vsid = (slb->vsid & SLB_VSID_VSID) >> SLB_VSID_SHIFT;
epn = (eaddr & ~SEGMENT_MASK_256M) & epnmask;
hash = vsid ^ (epn >> slb->sps->page_shift);
}
ptem = (slb->vsid & SLB_VSID_PTEM) | ((epn >> 16) & HPTE64_V_AVPN);
qemu_log_mask(CPU_LOG_MMU,
"htab_base " TARGET_FMT_plx " htab_mask " TARGET_FMT_plx
" hash " TARGET_FMT_plx "\n",
env->htab_base, env->htab_mask, hash);
qemu_log_mask(CPU_LOG_MMU,
"0 htab=" TARGET_FMT_plx "/" TARGET_FMT_plx
" vsid=" TARGET_FMT_lx " ptem=" TARGET_FMT_lx
" hash=" TARGET_FMT_plx "\n",
env->htab_base, env->htab_mask, vsid, ptem, hash);
pte_offset = ppc_hash64_pteg_search(cpu, hash, slb, 0, ptem, pte);
if (pte_offset == -1) {
qemu_log_mask(CPU_LOG_MMU,
"1 htab=" TARGET_FMT_plx "/" TARGET_FMT_plx
" vsid=" TARGET_FMT_lx " api=" TARGET_FMT_lx
" hash=" TARGET_FMT_plx "\n", env->htab_base,
env->htab_mask, vsid, ptem, ~hash);
pte_offset = ppc_hash64_pteg_search(cpu, ~hash, slb, 1, ptem, pte);
}
return pte_offset;
}
| {
"code": [
" pte_offset = ppc_hash64_pteg_search(cpu, hash, slb, 0, ptem, pte);",
" pte_offset = ppc_hash64_pteg_search(cpu, ~hash, slb, 1, ptem, pte);"
],
"line_no": [
81,
101
]
} | static hwaddr FUNC_0(PowerPCCPU *cpu,
ppc_slb_t *slb, target_ulong eaddr,
ppc_hash_pte64_t *pte)
{
CPUPPCState *env = &cpu->env;
hwaddr pte_offset;
hwaddr hash;
uint64_t vsid, epnmask, epn, ptem;
assert(slb->sps);
epnmask = ~((1ULL << slb->sps->page_shift) - 1);
if (slb->vsid & SLB_VSID_B) {
vsid = (slb->vsid & SLB_VSID_VSID) >> SLB_VSID_SHIFT_1T;
epn = (eaddr & ~SEGMENT_MASK_1T) & epnmask;
hash = vsid ^ (vsid << 25) ^ (epn >> slb->sps->page_shift);
} else {
vsid = (slb->vsid & SLB_VSID_VSID) >> SLB_VSID_SHIFT;
epn = (eaddr & ~SEGMENT_MASK_256M) & epnmask;
hash = vsid ^ (epn >> slb->sps->page_shift);
}
ptem = (slb->vsid & SLB_VSID_PTEM) | ((epn >> 16) & HPTE64_V_AVPN);
qemu_log_mask(CPU_LOG_MMU,
"htab_base " TARGET_FMT_plx " htab_mask " TARGET_FMT_plx
" hash " TARGET_FMT_plx "\n",
env->htab_base, env->htab_mask, hash);
qemu_log_mask(CPU_LOG_MMU,
"0 htab=" TARGET_FMT_plx "/" TARGET_FMT_plx
" vsid=" TARGET_FMT_lx " ptem=" TARGET_FMT_lx
" hash=" TARGET_FMT_plx "\n",
env->htab_base, env->htab_mask, vsid, ptem, hash);
pte_offset = ppc_hash64_pteg_search(cpu, hash, slb, 0, ptem, pte);
if (pte_offset == -1) {
qemu_log_mask(CPU_LOG_MMU,
"1 htab=" TARGET_FMT_plx "/" TARGET_FMT_plx
" vsid=" TARGET_FMT_lx " api=" TARGET_FMT_lx
" hash=" TARGET_FMT_plx "\n", env->htab_base,
env->htab_mask, vsid, ptem, ~hash);
pte_offset = ppc_hash64_pteg_search(cpu, ~hash, slb, 1, ptem, pte);
}
return pte_offset;
}
| [
"static hwaddr FUNC_0(PowerPCCPU *cpu,\nppc_slb_t *slb, target_ulong eaddr,\nppc_hash_pte64_t *pte)\n{",
"CPUPPCState *env = &cpu->env;",
"hwaddr pte_offset;",
"hwaddr hash;",
"uint64_t vsid, epnmask, epn, ptem;",
"assert(slb->sps);",
"epnmask = ~((1ULL << slb->sps->page_shift) - 1);",
"if (slb->vsid & SLB_VSID_B) {",
"vsid = (slb->vsid & SLB_VSID_VSID) >> SLB_VSID_SHIFT_1T;",
"epn = (eaddr & ~SEGMENT_MASK_1T) & epnmask;",
"hash = vsid ^ (vsid << 25) ^ (epn >> slb->sps->page_shift);",
"} else {",
"vsid = (slb->vsid & SLB_VSID_VSID) >> SLB_VSID_SHIFT;",
"epn = (eaddr & ~SEGMENT_MASK_256M) & epnmask;",
"hash = vsid ^ (epn >> slb->sps->page_shift);",
"}",
"ptem = (slb->vsid & SLB_VSID_PTEM) | ((epn >> 16) & HPTE64_V_AVPN);",
"qemu_log_mask(CPU_LOG_MMU,\n\"htab_base \" TARGET_FMT_plx \" htab_mask \" TARGET_FMT_plx\n\" hash \" TARGET_FMT_plx \"\\n\",\nenv->htab_base, env->htab_mask, hash);",
"qemu_log_mask(CPU_LOG_MMU,\n\"0 htab=\" TARGET_FMT_plx \"/\" TARGET_FMT_plx\n\" vsid=\" TARGET_FMT_lx \" ptem=\" TARGET_FMT_lx\n\" hash=\" TARGET_FMT_plx \"\\n\",\nenv->htab_base, env->htab_mask, vsid, ptem, hash);",
"pte_offset = ppc_hash64_pteg_search(cpu, hash, slb, 0, ptem, pte);",
"if (pte_offset == -1) {",
"qemu_log_mask(CPU_LOG_MMU,\n\"1 htab=\" TARGET_FMT_plx \"/\" TARGET_FMT_plx\n\" vsid=\" TARGET_FMT_lx \" api=\" TARGET_FMT_lx\n\" hash=\" TARGET_FMT_plx \"\\n\", env->htab_base,\nenv->htab_mask, vsid, ptem, ~hash);",
"pte_offset = ppc_hash64_pteg_search(cpu, ~hash, slb, 1, ptem, pte);",
"}",
"return pte_offset;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
1,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
23
],
[
27
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
59,
61,
63,
65
],
[
71,
73,
75,
77,
79
],
[
81
],
[
85
],
[
89,
91,
93,
95,
97
],
[
101
],
[
103
],
[
107
],
[
109
]
] |
24,032 | static always_inline void gen_op_neg (DisasContext *ctx, TCGv ret, TCGv arg1, int ov_check)
{
int l1, l2;
l1 = gen_new_label();
l2 = gen_new_label();
#if defined(TARGET_PPC64)
if (ctx->sf_mode) {
tcg_gen_brcondi_tl(TCG_COND_EQ, arg1, INT64_MIN, l1);
} else {
TCGv t0 = tcg_temp_new(TCG_TYPE_TL);
tcg_gen_ext32s_tl(t0, arg1);
tcg_gen_brcondi_tl(TCG_COND_EQ, t0, INT32_MIN, l1);
}
#else
tcg_gen_brcondi_tl(TCG_COND_EQ, arg1, INT32_MIN, l1);
#endif
tcg_gen_neg_tl(ret, arg1);
if (ov_check) {
tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));
}
tcg_gen_br(l2);
gen_set_label(l1);
tcg_gen_mov_tl(ret, arg1);
if (ov_check) {
tcg_gen_ori_tl(cpu_xer, cpu_xer, (1 << XER_OV) | (1 << XER_SO));
}
gen_set_label(l2);
if (unlikely(Rc(ctx->opcode) != 0))
gen_set_Rc0(ctx, ret);
}
| true | qemu | ec6469a3b1da26247bdb3f5dd5276fabcc1b694a | static always_inline void gen_op_neg (DisasContext *ctx, TCGv ret, TCGv arg1, int ov_check)
{
int l1, l2;
l1 = gen_new_label();
l2 = gen_new_label();
#if defined(TARGET_PPC64)
if (ctx->sf_mode) {
tcg_gen_brcondi_tl(TCG_COND_EQ, arg1, INT64_MIN, l1);
} else {
TCGv t0 = tcg_temp_new(TCG_TYPE_TL);
tcg_gen_ext32s_tl(t0, arg1);
tcg_gen_brcondi_tl(TCG_COND_EQ, t0, INT32_MIN, l1);
}
#else
tcg_gen_brcondi_tl(TCG_COND_EQ, arg1, INT32_MIN, l1);
#endif
tcg_gen_neg_tl(ret, arg1);
if (ov_check) {
tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));
}
tcg_gen_br(l2);
gen_set_label(l1);
tcg_gen_mov_tl(ret, arg1);
if (ov_check) {
tcg_gen_ori_tl(cpu_xer, cpu_xer, (1 << XER_OV) | (1 << XER_SO));
}
gen_set_label(l2);
if (unlikely(Rc(ctx->opcode) != 0))
gen_set_Rc0(ctx, ret);
}
| {
"code": [
"static always_inline void gen_op_neg (DisasContext *ctx, TCGv ret, TCGv arg1, int ov_check)",
" int l1, l2;",
" l1 = gen_new_label();",
" l2 = gen_new_label();",
" tcg_gen_brcondi_tl(TCG_COND_EQ, arg1, INT64_MIN, l1);",
" } else {",
" TCGv t0 = tcg_temp_new(TCG_TYPE_TL);",
"\ttcg_gen_ext32s_tl(t0, arg1);",
"#else",
" tcg_gen_brcondi_tl(TCG_COND_EQ, arg1, INT32_MIN, l1);",
"#endif",
" tcg_gen_mov_tl(ret, arg1);"
],
"line_no": [
1,
5,
9,
11,
17,
19,
21,
23,
29,
31,
33,
47
]
} | static always_inline void FUNC_0 (DisasContext *ctx, TCGv ret, TCGv arg1, int ov_check)
{
int VAR_0, VAR_1;
VAR_0 = gen_new_label();
VAR_1 = gen_new_label();
#if defined(TARGET_PPC64)
if (ctx->sf_mode) {
tcg_gen_brcondi_tl(TCG_COND_EQ, arg1, INT64_MIN, VAR_0);
} else {
TCGv t0 = tcg_temp_new(TCG_TYPE_TL);
tcg_gen_ext32s_tl(t0, arg1);
tcg_gen_brcondi_tl(TCG_COND_EQ, t0, INT32_MIN, VAR_0);
}
#else
tcg_gen_brcondi_tl(TCG_COND_EQ, arg1, INT32_MIN, VAR_0);
#endif
tcg_gen_neg_tl(ret, arg1);
if (ov_check) {
tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));
}
tcg_gen_br(VAR_1);
gen_set_label(VAR_0);
tcg_gen_mov_tl(ret, arg1);
if (ov_check) {
tcg_gen_ori_tl(cpu_xer, cpu_xer, (1 << XER_OV) | (1 << XER_SO));
}
gen_set_label(VAR_1);
if (unlikely(Rc(ctx->opcode) != 0))
gen_set_Rc0(ctx, ret);
}
| [
"static always_inline void FUNC_0 (DisasContext *ctx, TCGv ret, TCGv arg1, int ov_check)\n{",
"int VAR_0, VAR_1;",
"VAR_0 = gen_new_label();",
"VAR_1 = gen_new_label();",
"#if defined(TARGET_PPC64)\nif (ctx->sf_mode) {",
"tcg_gen_brcondi_tl(TCG_COND_EQ, arg1, INT64_MIN, VAR_0);",
"} else {",
"TCGv t0 = tcg_temp_new(TCG_TYPE_TL);",
"tcg_gen_ext32s_tl(t0, arg1);",
"tcg_gen_brcondi_tl(TCG_COND_EQ, t0, INT32_MIN, VAR_0);",
"}",
"#else\ntcg_gen_brcondi_tl(TCG_COND_EQ, arg1, INT32_MIN, VAR_0);",
"#endif\ntcg_gen_neg_tl(ret, arg1);",
"if (ov_check) {",
"tcg_gen_andi_tl(cpu_xer, cpu_xer, ~(1 << XER_OV));",
"}",
"tcg_gen_br(VAR_1);",
"gen_set_label(VAR_0);",
"tcg_gen_mov_tl(ret, arg1);",
"if (ov_check) {",
"tcg_gen_ori_tl(cpu_xer, cpu_xer, (1 << XER_OV) | (1 << XER_SO));",
"}",
"gen_set_label(VAR_1);",
"if (unlikely(Rc(ctx->opcode) != 0))\ngen_set_Rc0(ctx, ret);",
"}"
] | [
1,
1,
1,
1,
0,
1,
0,
1,
1,
0,
0,
1,
1,
0,
0,
0,
0,
0,
1,
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
],
[
51
],
[
53
],
[
55
],
[
57,
59
],
[
61
]
] |
24,033 | static int tx_consume(Rocker *r, DescInfo *info)
{
PCIDevice *dev = PCI_DEVICE(r);
char *buf = desc_get_buf(info, true);
RockerTlv *tlv_frag;
RockerTlv *tlvs[ROCKER_TLV_TX_MAX + 1];
struct iovec iov[ROCKER_TX_FRAGS_MAX] = { { 0, }, };
uint32_t pport;
uint32_t port;
uint16_t tx_offload = ROCKER_TX_OFFLOAD_NONE;
uint16_t tx_l3_csum_off = 0;
uint16_t tx_tso_mss = 0;
uint16_t tx_tso_hdr_len = 0;
int iovcnt = 0;
int err = ROCKER_OK;
int rem;
int i;
if (!buf) {
return -ROCKER_ENXIO;
}
rocker_tlv_parse(tlvs, ROCKER_TLV_TX_MAX, buf, desc_tlv_size(info));
if (!tlvs[ROCKER_TLV_TX_FRAGS]) {
return -ROCKER_EINVAL;
}
pport = rocker_get_pport_by_tx_ring(r, desc_get_ring(info));
if (!fp_port_from_pport(pport, &port)) {
return -ROCKER_EINVAL;
}
if (tlvs[ROCKER_TLV_TX_OFFLOAD]) {
tx_offload = rocker_tlv_get_u8(tlvs[ROCKER_TLV_TX_OFFLOAD]);
}
switch (tx_offload) {
case ROCKER_TX_OFFLOAD_L3_CSUM:
if (!tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]) {
return -ROCKER_EINVAL;
}
break;
case ROCKER_TX_OFFLOAD_TSO:
if (!tlvs[ROCKER_TLV_TX_TSO_MSS] ||
!tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]) {
return -ROCKER_EINVAL;
}
break;
}
if (tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]) {
tx_l3_csum_off = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]);
}
if (tlvs[ROCKER_TLV_TX_TSO_MSS]) {
tx_tso_mss = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_TSO_MSS]);
}
if (tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]) {
tx_tso_hdr_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]);
}
rocker_tlv_for_each_nested(tlv_frag, tlvs[ROCKER_TLV_TX_FRAGS], rem) {
hwaddr frag_addr;
uint16_t frag_len;
if (rocker_tlv_type(tlv_frag) != ROCKER_TLV_TX_FRAG) {
err = -ROCKER_EINVAL;
goto err_bad_attr;
}
rocker_tlv_parse_nested(tlvs, ROCKER_TLV_TX_FRAG_ATTR_MAX, tlv_frag);
if (!tlvs[ROCKER_TLV_TX_FRAG_ATTR_ADDR] ||
!tlvs[ROCKER_TLV_TX_FRAG_ATTR_LEN]) {
err = -ROCKER_EINVAL;
goto err_bad_attr;
}
frag_addr = rocker_tlv_get_le64(tlvs[ROCKER_TLV_TX_FRAG_ATTR_ADDR]);
frag_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_FRAG_ATTR_LEN]);
iov[iovcnt].iov_len = frag_len;
iov[iovcnt].iov_base = g_malloc(frag_len);
if (!iov[iovcnt].iov_base) {
err = -ROCKER_ENOMEM;
goto err_no_mem;
}
if (pci_dma_read(dev, frag_addr, iov[iovcnt].iov_base,
iov[iovcnt].iov_len)) {
err = -ROCKER_ENXIO;
goto err_bad_io;
}
if (++iovcnt > ROCKER_TX_FRAGS_MAX) {
goto err_too_many_frags;
}
}
if (iovcnt) {
/* XXX perform Tx offloads */
/* XXX silence compiler for now */
tx_l3_csum_off += tx_tso_mss = tx_tso_hdr_len = 0;
}
err = fp_port_eg(r->fp_port[port], iov, iovcnt);
err_too_many_frags:
err_bad_io:
err_no_mem:
err_bad_attr:
for (i = 0; i < ROCKER_TX_FRAGS_MAX; i++) {
g_free(iov[i].iov_base);
}
return err;
}
| true | qemu | 007cd223de527b5f41278f2d886c1a4beb3e67aa | static int tx_consume(Rocker *r, DescInfo *info)
{
PCIDevice *dev = PCI_DEVICE(r);
char *buf = desc_get_buf(info, true);
RockerTlv *tlv_frag;
RockerTlv *tlvs[ROCKER_TLV_TX_MAX + 1];
struct iovec iov[ROCKER_TX_FRAGS_MAX] = { { 0, }, };
uint32_t pport;
uint32_t port;
uint16_t tx_offload = ROCKER_TX_OFFLOAD_NONE;
uint16_t tx_l3_csum_off = 0;
uint16_t tx_tso_mss = 0;
uint16_t tx_tso_hdr_len = 0;
int iovcnt = 0;
int err = ROCKER_OK;
int rem;
int i;
if (!buf) {
return -ROCKER_ENXIO;
}
rocker_tlv_parse(tlvs, ROCKER_TLV_TX_MAX, buf, desc_tlv_size(info));
if (!tlvs[ROCKER_TLV_TX_FRAGS]) {
return -ROCKER_EINVAL;
}
pport = rocker_get_pport_by_tx_ring(r, desc_get_ring(info));
if (!fp_port_from_pport(pport, &port)) {
return -ROCKER_EINVAL;
}
if (tlvs[ROCKER_TLV_TX_OFFLOAD]) {
tx_offload = rocker_tlv_get_u8(tlvs[ROCKER_TLV_TX_OFFLOAD]);
}
switch (tx_offload) {
case ROCKER_TX_OFFLOAD_L3_CSUM:
if (!tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]) {
return -ROCKER_EINVAL;
}
break;
case ROCKER_TX_OFFLOAD_TSO:
if (!tlvs[ROCKER_TLV_TX_TSO_MSS] ||
!tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]) {
return -ROCKER_EINVAL;
}
break;
}
if (tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]) {
tx_l3_csum_off = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]);
}
if (tlvs[ROCKER_TLV_TX_TSO_MSS]) {
tx_tso_mss = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_TSO_MSS]);
}
if (tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]) {
tx_tso_hdr_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]);
}
rocker_tlv_for_each_nested(tlv_frag, tlvs[ROCKER_TLV_TX_FRAGS], rem) {
hwaddr frag_addr;
uint16_t frag_len;
if (rocker_tlv_type(tlv_frag) != ROCKER_TLV_TX_FRAG) {
err = -ROCKER_EINVAL;
goto err_bad_attr;
}
rocker_tlv_parse_nested(tlvs, ROCKER_TLV_TX_FRAG_ATTR_MAX, tlv_frag);
if (!tlvs[ROCKER_TLV_TX_FRAG_ATTR_ADDR] ||
!tlvs[ROCKER_TLV_TX_FRAG_ATTR_LEN]) {
err = -ROCKER_EINVAL;
goto err_bad_attr;
}
frag_addr = rocker_tlv_get_le64(tlvs[ROCKER_TLV_TX_FRAG_ATTR_ADDR]);
frag_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_FRAG_ATTR_LEN]);
iov[iovcnt].iov_len = frag_len;
iov[iovcnt].iov_base = g_malloc(frag_len);
if (!iov[iovcnt].iov_base) {
err = -ROCKER_ENOMEM;
goto err_no_mem;
}
if (pci_dma_read(dev, frag_addr, iov[iovcnt].iov_base,
iov[iovcnt].iov_len)) {
err = -ROCKER_ENXIO;
goto err_bad_io;
}
if (++iovcnt > ROCKER_TX_FRAGS_MAX) {
goto err_too_many_frags;
}
}
if (iovcnt) {
tx_l3_csum_off += tx_tso_mss = tx_tso_hdr_len = 0;
}
err = fp_port_eg(r->fp_port[port], iov, iovcnt);
err_too_many_frags:
err_bad_io:
err_no_mem:
err_bad_attr:
for (i = 0; i < ROCKER_TX_FRAGS_MAX; i++) {
g_free(iov[i].iov_base);
}
return err;
}
| {
"code": [
" if (++iovcnt > ROCKER_TX_FRAGS_MAX) {",
" goto err_too_many_frags;"
],
"line_no": [
193,
195
]
} | static int FUNC_0(Rocker *VAR_0, DescInfo *VAR_1)
{
PCIDevice *dev = PCI_DEVICE(VAR_0);
char *VAR_2 = desc_get_buf(VAR_1, true);
RockerTlv *tlv_frag;
RockerTlv *tlvs[ROCKER_TLV_TX_MAX + 1];
struct iovec VAR_3[ROCKER_TX_FRAGS_MAX] = { { 0, }, };
uint32_t pport;
uint32_t port;
uint16_t tx_offload = ROCKER_TX_OFFLOAD_NONE;
uint16_t tx_l3_csum_off = 0;
uint16_t tx_tso_mss = 0;
uint16_t tx_tso_hdr_len = 0;
int VAR_4 = 0;
int VAR_5 = ROCKER_OK;
int VAR_6;
int VAR_7;
if (!VAR_2) {
return -ROCKER_ENXIO;
}
rocker_tlv_parse(tlvs, ROCKER_TLV_TX_MAX, VAR_2, desc_tlv_size(VAR_1));
if (!tlvs[ROCKER_TLV_TX_FRAGS]) {
return -ROCKER_EINVAL;
}
pport = rocker_get_pport_by_tx_ring(VAR_0, desc_get_ring(VAR_1));
if (!fp_port_from_pport(pport, &port)) {
return -ROCKER_EINVAL;
}
if (tlvs[ROCKER_TLV_TX_OFFLOAD]) {
tx_offload = rocker_tlv_get_u8(tlvs[ROCKER_TLV_TX_OFFLOAD]);
}
switch (tx_offload) {
case ROCKER_TX_OFFLOAD_L3_CSUM:
if (!tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]) {
return -ROCKER_EINVAL;
}
break;
case ROCKER_TX_OFFLOAD_TSO:
if (!tlvs[ROCKER_TLV_TX_TSO_MSS] ||
!tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]) {
return -ROCKER_EINVAL;
}
break;
}
if (tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]) {
tx_l3_csum_off = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]);
}
if (tlvs[ROCKER_TLV_TX_TSO_MSS]) {
tx_tso_mss = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_TSO_MSS]);
}
if (tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]) {
tx_tso_hdr_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]);
}
rocker_tlv_for_each_nested(tlv_frag, tlvs[ROCKER_TLV_TX_FRAGS], VAR_6) {
hwaddr frag_addr;
uint16_t frag_len;
if (rocker_tlv_type(tlv_frag) != ROCKER_TLV_TX_FRAG) {
VAR_5 = -ROCKER_EINVAL;
goto err_bad_attr;
}
rocker_tlv_parse_nested(tlvs, ROCKER_TLV_TX_FRAG_ATTR_MAX, tlv_frag);
if (!tlvs[ROCKER_TLV_TX_FRAG_ATTR_ADDR] ||
!tlvs[ROCKER_TLV_TX_FRAG_ATTR_LEN]) {
VAR_5 = -ROCKER_EINVAL;
goto err_bad_attr;
}
frag_addr = rocker_tlv_get_le64(tlvs[ROCKER_TLV_TX_FRAG_ATTR_ADDR]);
frag_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_FRAG_ATTR_LEN]);
VAR_3[VAR_4].iov_len = frag_len;
VAR_3[VAR_4].iov_base = g_malloc(frag_len);
if (!VAR_3[VAR_4].iov_base) {
VAR_5 = -ROCKER_ENOMEM;
goto err_no_mem;
}
if (pci_dma_read(dev, frag_addr, VAR_3[VAR_4].iov_base,
VAR_3[VAR_4].iov_len)) {
VAR_5 = -ROCKER_ENXIO;
goto err_bad_io;
}
if (++VAR_4 > ROCKER_TX_FRAGS_MAX) {
goto err_too_many_frags;
}
}
if (VAR_4) {
tx_l3_csum_off += tx_tso_mss = tx_tso_hdr_len = 0;
}
VAR_5 = fp_port_eg(VAR_0->fp_port[port], VAR_3, VAR_4);
err_too_many_frags:
err_bad_io:
err_no_mem:
err_bad_attr:
for (VAR_7 = 0; VAR_7 < ROCKER_TX_FRAGS_MAX; VAR_7++) {
g_free(VAR_3[VAR_7].iov_base);
}
return VAR_5;
}
| [
"static int FUNC_0(Rocker *VAR_0, DescInfo *VAR_1)\n{",
"PCIDevice *dev = PCI_DEVICE(VAR_0);",
"char *VAR_2 = desc_get_buf(VAR_1, true);",
"RockerTlv *tlv_frag;",
"RockerTlv *tlvs[ROCKER_TLV_TX_MAX + 1];",
"struct iovec VAR_3[ROCKER_TX_FRAGS_MAX] = { { 0, }, };",
"uint32_t pport;",
"uint32_t port;",
"uint16_t tx_offload = ROCKER_TX_OFFLOAD_NONE;",
"uint16_t tx_l3_csum_off = 0;",
"uint16_t tx_tso_mss = 0;",
"uint16_t tx_tso_hdr_len = 0;",
"int VAR_4 = 0;",
"int VAR_5 = ROCKER_OK;",
"int VAR_6;",
"int VAR_7;",
"if (!VAR_2) {",
"return -ROCKER_ENXIO;",
"}",
"rocker_tlv_parse(tlvs, ROCKER_TLV_TX_MAX, VAR_2, desc_tlv_size(VAR_1));",
"if (!tlvs[ROCKER_TLV_TX_FRAGS]) {",
"return -ROCKER_EINVAL;",
"}",
"pport = rocker_get_pport_by_tx_ring(VAR_0, desc_get_ring(VAR_1));",
"if (!fp_port_from_pport(pport, &port)) {",
"return -ROCKER_EINVAL;",
"}",
"if (tlvs[ROCKER_TLV_TX_OFFLOAD]) {",
"tx_offload = rocker_tlv_get_u8(tlvs[ROCKER_TLV_TX_OFFLOAD]);",
"}",
"switch (tx_offload) {",
"case ROCKER_TX_OFFLOAD_L3_CSUM:\nif (!tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]) {",
"return -ROCKER_EINVAL;",
"}",
"break;",
"case ROCKER_TX_OFFLOAD_TSO:\nif (!tlvs[ROCKER_TLV_TX_TSO_MSS] ||\n!tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]) {",
"return -ROCKER_EINVAL;",
"}",
"break;",
"}",
"if (tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]) {",
"tx_l3_csum_off = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_L3_CSUM_OFF]);",
"}",
"if (tlvs[ROCKER_TLV_TX_TSO_MSS]) {",
"tx_tso_mss = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_TSO_MSS]);",
"}",
"if (tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]) {",
"tx_tso_hdr_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_TSO_HDR_LEN]);",
"}",
"rocker_tlv_for_each_nested(tlv_frag, tlvs[ROCKER_TLV_TX_FRAGS], VAR_6) {",
"hwaddr frag_addr;",
"uint16_t frag_len;",
"if (rocker_tlv_type(tlv_frag) != ROCKER_TLV_TX_FRAG) {",
"VAR_5 = -ROCKER_EINVAL;",
"goto err_bad_attr;",
"}",
"rocker_tlv_parse_nested(tlvs, ROCKER_TLV_TX_FRAG_ATTR_MAX, tlv_frag);",
"if (!tlvs[ROCKER_TLV_TX_FRAG_ATTR_ADDR] ||\n!tlvs[ROCKER_TLV_TX_FRAG_ATTR_LEN]) {",
"VAR_5 = -ROCKER_EINVAL;",
"goto err_bad_attr;",
"}",
"frag_addr = rocker_tlv_get_le64(tlvs[ROCKER_TLV_TX_FRAG_ATTR_ADDR]);",
"frag_len = rocker_tlv_get_le16(tlvs[ROCKER_TLV_TX_FRAG_ATTR_LEN]);",
"VAR_3[VAR_4].iov_len = frag_len;",
"VAR_3[VAR_4].iov_base = g_malloc(frag_len);",
"if (!VAR_3[VAR_4].iov_base) {",
"VAR_5 = -ROCKER_ENOMEM;",
"goto err_no_mem;",
"}",
"if (pci_dma_read(dev, frag_addr, VAR_3[VAR_4].iov_base,\nVAR_3[VAR_4].iov_len)) {",
"VAR_5 = -ROCKER_ENXIO;",
"goto err_bad_io;",
"}",
"if (++VAR_4 > ROCKER_TX_FRAGS_MAX) {",
"goto err_too_many_frags;",
"}",
"}",
"if (VAR_4) {",
"tx_l3_csum_off += tx_tso_mss = tx_tso_hdr_len = 0;",
"}",
"VAR_5 = fp_port_eg(VAR_0->fp_port[port], VAR_3, VAR_4);",
"err_too_many_frags:\nerr_bad_io:\nerr_no_mem:\nerr_bad_attr:\nfor (VAR_7 = 0; VAR_7 < ROCKER_TX_FRAGS_MAX; VAR_7++) {",
"g_free(VAR_3[VAR_7].iov_base);",
"}",
"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,
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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
45
],
[
49
],
[
51
],
[
53
],
[
57
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69
],
[
71
],
[
75
],
[
77,
79
],
[
81
],
[
83
],
[
85
],
[
87,
89,
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103
],
[
105
],
[
107
],
[
111
],
[
113
],
[
115
],
[
119
],
[
121
],
[
123
],
[
127
],
[
129
],
[
131
],
[
135
],
[
137
],
[
139
],
[
141
],
[
145
],
[
149,
151
],
[
153
],
[
155
],
[
157
],
[
161
],
[
163
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
181,
183
],
[
185
],
[
187
],
[
189
],
[
193
],
[
195
],
[
197
],
[
199
],
[
203
],
[
209
],
[
211
],
[
215
],
[
219,
221,
223,
225,
227
],
[
229
],
[
231
],
[
235
],
[
237
]
] |
24,034 | static void gen_neon_dup_low16(TCGv var)
{
TCGv tmp = new_tmp();
tcg_gen_ext16u_i32(var, var);
tcg_gen_shli_i32(tmp, var, 16);
tcg_gen_or_i32(var, var, tmp);
dead_tmp(tmp);
}
| true | qemu | 7d1b0095bff7157e856d1d0e6c4295641ced2752 | static void gen_neon_dup_low16(TCGv var)
{
TCGv tmp = new_tmp();
tcg_gen_ext16u_i32(var, var);
tcg_gen_shli_i32(tmp, var, 16);
tcg_gen_or_i32(var, var, tmp);
dead_tmp(tmp);
}
| {
"code": [
" TCGv tmp = new_tmp();",
" TCGv tmp = new_tmp();",
" TCGv tmp = new_tmp();",
" dead_tmp(tmp);",
" TCGv tmp = new_tmp();",
" dead_tmp(tmp);",
" TCGv tmp = new_tmp();",
" dead_tmp(tmp);",
" TCGv tmp = new_tmp();",
" dead_tmp(tmp);",
" TCGv tmp = new_tmp();",
" dead_tmp(tmp);",
" dead_tmp(tmp);",
" dead_tmp(tmp);",
" dead_tmp(tmp);",
" TCGv tmp = new_tmp();",
" dead_tmp(tmp);",
" dead_tmp(tmp);",
" TCGv tmp = new_tmp();",
" TCGv tmp = new_tmp();",
" TCGv tmp = new_tmp();",
" TCGv tmp = new_tmp();",
" TCGv tmp = new_tmp();",
" TCGv tmp = new_tmp();",
" TCGv tmp = new_tmp();",
" dead_tmp(tmp);",
" TCGv tmp = new_tmp();",
" dead_tmp(tmp);",
" TCGv tmp = new_tmp();",
" dead_tmp(tmp);",
" TCGv tmp = new_tmp();",
" dead_tmp(tmp);",
" TCGv tmp = new_tmp();",
" dead_tmp(tmp);",
" dead_tmp(tmp);",
" TCGv tmp = new_tmp();",
" dead_tmp(tmp);",
" dead_tmp(tmp);",
" TCGv tmp = new_tmp();",
" dead_tmp(tmp);",
" dead_tmp(tmp);"
],
"line_no": [
5,
5,
5,
13,
5,
13,
5,
13,
5,
13,
5,
13,
13,
13,
13,
5,
13,
13,
5,
5,
5,
5,
5,
5,
5,
13,
5,
13,
5,
13,
5,
13,
5,
13,
13,
5,
13,
13,
5,
13,
13
]
} | static void FUNC_0(TCGv VAR_0)
{
TCGv tmp = new_tmp();
tcg_gen_ext16u_i32(VAR_0, VAR_0);
tcg_gen_shli_i32(tmp, VAR_0, 16);
tcg_gen_or_i32(VAR_0, VAR_0, tmp);
dead_tmp(tmp);
}
| [
"static void FUNC_0(TCGv VAR_0)\n{",
"TCGv tmp = new_tmp();",
"tcg_gen_ext16u_i32(VAR_0, VAR_0);",
"tcg_gen_shli_i32(tmp, VAR_0, 16);",
"tcg_gen_or_i32(VAR_0, VAR_0, tmp);",
"dead_tmp(tmp);",
"}"
] | [
0,
1,
0,
0,
0,
1,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
]
] |
24,035 | static void audio_print_settings (audsettings_t *as)
{
dolog ("frequency=%d nchannels=%d fmt=", as->freq, as->nchannels);
switch (as->fmt) {
case AUD_FMT_S8:
AUD_log (NULL, "S8");
break;
case AUD_FMT_U8:
AUD_log (NULL, "U8");
break;
case AUD_FMT_S16:
AUD_log (NULL, "S16");
break;
case AUD_FMT_U16:
AUD_log (NULL, "U16");
break;
case AUD_FMT_S32:
AUD_log (NULL, "S32");
break;
case AUD_FMT_U32:
AUD_log (NULL, "U32");
break;
default:
AUD_log (NULL, "invalid(%d)", as->fmt);
break;
}
AUD_log (NULL, " endianness=");
switch (as->endianness) {
case 0:
AUD_log (NULL, "little");
break;
case 1:
AUD_log (NULL, "big");
break;
default:
AUD_log (NULL, "invalid");
break;
}
AUD_log (NULL, "\n");
}
| false | qemu | 1ea879e5580f63414693655fcf0328559cdce138 | static void audio_print_settings (audsettings_t *as)
{
dolog ("frequency=%d nchannels=%d fmt=", as->freq, as->nchannels);
switch (as->fmt) {
case AUD_FMT_S8:
AUD_log (NULL, "S8");
break;
case AUD_FMT_U8:
AUD_log (NULL, "U8");
break;
case AUD_FMT_S16:
AUD_log (NULL, "S16");
break;
case AUD_FMT_U16:
AUD_log (NULL, "U16");
break;
case AUD_FMT_S32:
AUD_log (NULL, "S32");
break;
case AUD_FMT_U32:
AUD_log (NULL, "U32");
break;
default:
AUD_log (NULL, "invalid(%d)", as->fmt);
break;
}
AUD_log (NULL, " endianness=");
switch (as->endianness) {
case 0:
AUD_log (NULL, "little");
break;
case 1:
AUD_log (NULL, "big");
break;
default:
AUD_log (NULL, "invalid");
break;
}
AUD_log (NULL, "\n");
}
| {
"code": [],
"line_no": []
} | static void FUNC_0 (audsettings_t *VAR_0)
{
dolog ("frequency=%d nchannels=%d fmt=", VAR_0->freq, VAR_0->nchannels);
switch (VAR_0->fmt) {
case AUD_FMT_S8:
AUD_log (NULL, "S8");
break;
case AUD_FMT_U8:
AUD_log (NULL, "U8");
break;
case AUD_FMT_S16:
AUD_log (NULL, "S16");
break;
case AUD_FMT_U16:
AUD_log (NULL, "U16");
break;
case AUD_FMT_S32:
AUD_log (NULL, "S32");
break;
case AUD_FMT_U32:
AUD_log (NULL, "U32");
break;
default:
AUD_log (NULL, "invalid(%d)", VAR_0->fmt);
break;
}
AUD_log (NULL, " endianness=");
switch (VAR_0->endianness) {
case 0:
AUD_log (NULL, "little");
break;
case 1:
AUD_log (NULL, "big");
break;
default:
AUD_log (NULL, "invalid");
break;
}
AUD_log (NULL, "\n");
}
| [
"static void FUNC_0 (audsettings_t *VAR_0)\n{",
"dolog (\"frequency=%d nchannels=%d fmt=\", VAR_0->freq, VAR_0->nchannels);",
"switch (VAR_0->fmt) {",
"case AUD_FMT_S8:\nAUD_log (NULL, \"S8\");",
"break;",
"case AUD_FMT_U8:\nAUD_log (NULL, \"U8\");",
"break;",
"case AUD_FMT_S16:\nAUD_log (NULL, \"S16\");",
"break;",
"case AUD_FMT_U16:\nAUD_log (NULL, \"U16\");",
"break;",
"case AUD_FMT_S32:\nAUD_log (NULL, \"S32\");",
"break;",
"case AUD_FMT_U32:\nAUD_log (NULL, \"U32\");",
"break;",
"default:\nAUD_log (NULL, \"invalid(%d)\", VAR_0->fmt);",
"break;",
"}",
"AUD_log (NULL, \" endianness=\");",
"switch (VAR_0->endianness) {",
"case 0:\nAUD_log (NULL, \"little\");",
"break;",
"case 1:\nAUD_log (NULL, \"big\");",
"break;",
"default:\nAUD_log (NULL, \"invalid\");",
"break;",
"}",
"AUD_log (NULL, \"\\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
] | [
[
1,
3
],
[
5
],
[
9
],
[
11,
13
],
[
15
],
[
17,
19
],
[
21
],
[
23,
25
],
[
27
],
[
29,
31
],
[
33
],
[
35,
37
],
[
39
],
[
41,
43
],
[
45
],
[
47,
49
],
[
51
],
[
53
],
[
57
],
[
59
],
[
61,
63
],
[
65
],
[
67,
69
],
[
71
],
[
73,
75
],
[
77
],
[
79
],
[
81
],
[
83
]
] |
24,036 | static void vnc_refresh(void *opaque)
{
VncDisplay *vd = opaque;
VncState *vs, *vn;
int has_dirty, rects = 0;
vga_hw_update();
if (vnc_trylock_display(vd)) {
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) +
vd->timer_interval);
return;
}
has_dirty = vnc_refresh_server_surface(vd);
vnc_unlock_display(vd);
QTAILQ_FOREACH_SAFE(vs, &vd->clients, next, vn) {
rects += vnc_update_client(vs, has_dirty);
/* vs might be free()ed here */
}
/* vd->timer could be NULL now if the last client disconnected,
* in this case don't update the timer */
if (vd->timer == NULL)
return;
if (has_dirty && rects) {
vd->timer_interval /= 2;
if (vd->timer_interval < VNC_REFRESH_INTERVAL_BASE)
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
} else {
vd->timer_interval += VNC_REFRESH_INTERVAL_INC;
if (vd->timer_interval > VNC_REFRESH_INTERVAL_MAX)
vd->timer_interval = VNC_REFRESH_INTERVAL_MAX;
}
qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval);
}
| false | qemu | 7bd427d801e1e3293a634d3c83beadaa90ffb911 | static void vnc_refresh(void *opaque)
{
VncDisplay *vd = opaque;
VncState *vs, *vn;
int has_dirty, rects = 0;
vga_hw_update();
if (vnc_trylock_display(vd)) {
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) +
vd->timer_interval);
return;
}
has_dirty = vnc_refresh_server_surface(vd);
vnc_unlock_display(vd);
QTAILQ_FOREACH_SAFE(vs, &vd->clients, next, vn) {
rects += vnc_update_client(vs, has_dirty);
}
if (vd->timer == NULL)
return;
if (has_dirty && rects) {
vd->timer_interval /= 2;
if (vd->timer_interval < VNC_REFRESH_INTERVAL_BASE)
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
} else {
vd->timer_interval += VNC_REFRESH_INTERVAL_INC;
if (vd->timer_interval > VNC_REFRESH_INTERVAL_MAX)
vd->timer_interval = VNC_REFRESH_INTERVAL_MAX;
}
qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0)
{
VncDisplay *vd = VAR_0;
VncState *vs, *vn;
int VAR_1, VAR_2 = 0;
vga_hw_update();
if (vnc_trylock_display(vd)) {
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) +
vd->timer_interval);
return;
}
VAR_1 = vnc_refresh_server_surface(vd);
vnc_unlock_display(vd);
QTAILQ_FOREACH_SAFE(vs, &vd->clients, next, vn) {
VAR_2 += vnc_update_client(vs, VAR_1);
}
if (vd->timer == NULL)
return;
if (VAR_1 && VAR_2) {
vd->timer_interval /= 2;
if (vd->timer_interval < VNC_REFRESH_INTERVAL_BASE)
vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;
} else {
vd->timer_interval += VNC_REFRESH_INTERVAL_INC;
if (vd->timer_interval > VNC_REFRESH_INTERVAL_MAX)
vd->timer_interval = VNC_REFRESH_INTERVAL_MAX;
}
qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval);
}
| [
"static void FUNC_0(void *VAR_0)\n{",
"VncDisplay *vd = VAR_0;",
"VncState *vs, *vn;",
"int VAR_1, VAR_2 = 0;",
"vga_hw_update();",
"if (vnc_trylock_display(vd)) {",
"vd->timer_interval = VNC_REFRESH_INTERVAL_BASE;",
"qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) +\nvd->timer_interval);",
"return;",
"}",
"VAR_1 = vnc_refresh_server_surface(vd);",
"vnc_unlock_display(vd);",
"QTAILQ_FOREACH_SAFE(vs, &vd->clients, next, vn) {",
"VAR_2 += vnc_update_client(vs, VAR_1);",
"}",
"if (vd->timer == NULL)\nreturn;",
"if (VAR_1 && VAR_2) {",
"vd->timer_interval /= 2;",
"if (vd->timer_interval < VNC_REFRESH_INTERVAL_BASE)\nvd->timer_interval = VNC_REFRESH_INTERVAL_BASE;",
"} else {",
"vd->timer_interval += VNC_REFRESH_INTERVAL_INC;",
"if (vd->timer_interval > VNC_REFRESH_INTERVAL_MAX)\nvd->timer_interval = VNC_REFRESH_INTERVAL_MAX;",
"}",
"qemu_mod_timer(vd->timer, qemu_get_clock(rt_clock) + vd->timer_interval);",
"}"
] | [
0,
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
],
[
17
],
[
19
],
[
21,
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
37
],
[
39
],
[
43
],
[
51,
53
],
[
57
],
[
59
],
[
61,
63
],
[
65
],
[
67
],
[
69,
71
],
[
73
],
[
75
],
[
77
]
] |
24,038 | static void set_pointer(Object *obj, Visitor *v, Property *prop,
int (*parse)(DeviceState *dev, const char *str, void **ptr),
const char *name, Error **errp)
{
DeviceState *dev = DEVICE(obj);
Error *local_err = NULL;
void **ptr = qdev_get_prop_ptr(dev, prop);
char *str;
int ret;
if (dev->state != DEV_STATE_CREATED) {
error_set(errp, QERR_PERMISSION_DENIED);
return;
}
visit_type_str(v, &str, name, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return;
}
if (!*str) {
g_free(str);
*ptr = NULL;
return;
}
ret = parse(dev, str, ptr);
error_set_from_qdev_prop_error(errp, ret, dev, prop, str);
g_free(str);
}
| false | qemu | d4d34b0d3f5af5c8e09980da0de2eebe9a27dc71 | static void set_pointer(Object *obj, Visitor *v, Property *prop,
int (*parse)(DeviceState *dev, const char *str, void **ptr),
const char *name, Error **errp)
{
DeviceState *dev = DEVICE(obj);
Error *local_err = NULL;
void **ptr = qdev_get_prop_ptr(dev, prop);
char *str;
int ret;
if (dev->state != DEV_STATE_CREATED) {
error_set(errp, QERR_PERMISSION_DENIED);
return;
}
visit_type_str(v, &str, name, &local_err);
if (local_err) {
error_propagate(errp, local_err);
return;
}
if (!*str) {
g_free(str);
*ptr = NULL;
return;
}
ret = parse(dev, str, ptr);
error_set_from_qdev_prop_error(errp, ret, dev, prop, str);
g_free(str);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(Object *VAR_0, Visitor *VAR_1, Property *VAR_2,
int (*VAR_3)(DeviceState *VAR_4, const char *VAR_9, void **VAR_9),
const char *VAR_7, Error **VAR_8)
{
DeviceState *VAR_4 = DEVICE(VAR_0);
Error *local_err = NULL;
void **VAR_9 = qdev_get_prop_ptr(VAR_4, VAR_2);
char *VAR_9;
int VAR_9;
if (VAR_4->state != DEV_STATE_CREATED) {
error_set(VAR_8, QERR_PERMISSION_DENIED);
return;
}
visit_type_str(VAR_1, &VAR_9, VAR_7, &local_err);
if (local_err) {
error_propagate(VAR_8, local_err);
return;
}
if (!*VAR_9) {
g_free(VAR_9);
*VAR_9 = NULL;
return;
}
VAR_9 = VAR_3(VAR_4, VAR_9, VAR_9);
error_set_from_qdev_prop_error(VAR_8, VAR_9, VAR_4, VAR_2, VAR_9);
g_free(VAR_9);
}
| [
"static void FUNC_0(Object *VAR_0, Visitor *VAR_1, Property *VAR_2,\nint (*VAR_3)(DeviceState *VAR_4, const char *VAR_9, void **VAR_9),\nconst char *VAR_7, Error **VAR_8)\n{",
"DeviceState *VAR_4 = DEVICE(VAR_0);",
"Error *local_err = NULL;",
"void **VAR_9 = qdev_get_prop_ptr(VAR_4, VAR_2);",
"char *VAR_9;",
"int VAR_9;",
"if (VAR_4->state != DEV_STATE_CREATED) {",
"error_set(VAR_8, QERR_PERMISSION_DENIED);",
"return;",
"}",
"visit_type_str(VAR_1, &VAR_9, VAR_7, &local_err);",
"if (local_err) {",
"error_propagate(VAR_8, local_err);",
"return;",
"}",
"if (!*VAR_9) {",
"g_free(VAR_9);",
"*VAR_9 = NULL;",
"return;",
"}",
"VAR_9 = VAR_3(VAR_4, VAR_9, VAR_9);",
"error_set_from_qdev_prop_error(VAR_8, VAR_9, VAR_4, VAR_2, VAR_9);",
"g_free(VAR_9);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
]
] |
24,039 | static int scsi_hd_initfn(SCSIDevice *dev)
{
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
s->qdev.blocksize = s->qdev.conf.logical_block_size;
s->qdev.type = TYPE_DISK;
if (!s->product) {
s->product = g_strdup("QEMU HARDDISK");
}
return scsi_initfn(&s->qdev);
}
| false | qemu | a818a4b69d47ca3826dee36878074395aeac2083 | static int scsi_hd_initfn(SCSIDevice *dev)
{
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
s->qdev.blocksize = s->qdev.conf.logical_block_size;
s->qdev.type = TYPE_DISK;
if (!s->product) {
s->product = g_strdup("QEMU HARDDISK");
}
return scsi_initfn(&s->qdev);
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(SCSIDevice *VAR_0)
{
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, VAR_0);
s->qdev.blocksize = s->qdev.conf.logical_block_size;
s->qdev.type = TYPE_DISK;
if (!s->product) {
s->product = g_strdup("QEMU HARDDISK");
}
return scsi_initfn(&s->qdev);
}
| [
"static int FUNC_0(SCSIDevice *VAR_0)\n{",
"SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, VAR_0);",
"s->qdev.blocksize = s->qdev.conf.logical_block_size;",
"s->qdev.type = TYPE_DISK;",
"if (!s->product) {",
"s->product = g_strdup(\"QEMU HARDDISK\");",
"}",
"return scsi_initfn(&s->qdev);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
]
] |
24,040 | static int local_parse_opts(QemuOpts *opts, struct FsDriverEntry *fse)
{
const char *sec_model = qemu_opt_get(opts, "security_model");
const char *path = qemu_opt_get(opts, "path");
if (!sec_model) {
fprintf(stderr, "security model not specified, "
"local fs needs security model\nvalid options are:"
"\tsecurity_model=[passthrough|mapped|none]\n");
return -1;
}
if (!strcmp(sec_model, "passthrough")) {
fse->export_flags |= V9FS_SM_PASSTHROUGH;
} else if (!strcmp(sec_model, "mapped")) {
fse->export_flags |= V9FS_SM_MAPPED;
} else if (!strcmp(sec_model, "none")) {
fse->export_flags |= V9FS_SM_NONE;
} else {
fprintf(stderr, "Invalid security model %s specified, valid options are"
"\n\t [passthrough|mapped|none]\n", sec_model);
return -1;
}
if (!path) {
fprintf(stderr, "fsdev: No path specified.\n");
return -1;
}
fse->path = g_strdup(path);
return 0;
}
| false | qemu | 2c30dd744aa02d31a8a3b87daaba0b2cb774f346 | static int local_parse_opts(QemuOpts *opts, struct FsDriverEntry *fse)
{
const char *sec_model = qemu_opt_get(opts, "security_model");
const char *path = qemu_opt_get(opts, "path");
if (!sec_model) {
fprintf(stderr, "security model not specified, "
"local fs needs security model\nvalid options are:"
"\tsecurity_model=[passthrough|mapped|none]\n");
return -1;
}
if (!strcmp(sec_model, "passthrough")) {
fse->export_flags |= V9FS_SM_PASSTHROUGH;
} else if (!strcmp(sec_model, "mapped")) {
fse->export_flags |= V9FS_SM_MAPPED;
} else if (!strcmp(sec_model, "none")) {
fse->export_flags |= V9FS_SM_NONE;
} else {
fprintf(stderr, "Invalid security model %s specified, valid options are"
"\n\t [passthrough|mapped|none]\n", sec_model);
return -1;
}
if (!path) {
fprintf(stderr, "fsdev: No path specified.\n");
return -1;
}
fse->path = g_strdup(path);
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(QemuOpts *VAR_0, struct FsDriverEntry *VAR_1)
{
const char *VAR_2 = qemu_opt_get(VAR_0, "security_model");
const char *VAR_3 = qemu_opt_get(VAR_0, "VAR_3");
if (!VAR_2) {
fprintf(stderr, "security model not specified, "
"local fs needs security model\nvalid options are:"
"\tsecurity_model=[passthrough|mapped|none]\n");
return -1;
}
if (!strcmp(VAR_2, "passthrough")) {
VAR_1->export_flags |= V9FS_SM_PASSTHROUGH;
} else if (!strcmp(VAR_2, "mapped")) {
VAR_1->export_flags |= V9FS_SM_MAPPED;
} else if (!strcmp(VAR_2, "none")) {
VAR_1->export_flags |= V9FS_SM_NONE;
} else {
fprintf(stderr, "Invalid security model %s specified, valid options are"
"\n\t [passthrough|mapped|none]\n", VAR_2);
return -1;
}
if (!VAR_3) {
fprintf(stderr, "fsdev: No VAR_3 specified.\n");
return -1;
}
VAR_1->VAR_3 = g_strdup(VAR_3);
return 0;
}
| [
"static int FUNC_0(QemuOpts *VAR_0, struct FsDriverEntry *VAR_1)\n{",
"const char *VAR_2 = qemu_opt_get(VAR_0, \"security_model\");",
"const char *VAR_3 = qemu_opt_get(VAR_0, \"VAR_3\");",
"if (!VAR_2) {",
"fprintf(stderr, \"security model not specified, \"\n\"local fs needs security model\\nvalid options are:\"\n\"\\tsecurity_model=[passthrough|mapped|none]\\n\");",
"return -1;",
"}",
"if (!strcmp(VAR_2, \"passthrough\")) {",
"VAR_1->export_flags |= V9FS_SM_PASSTHROUGH;",
"} else if (!strcmp(VAR_2, \"mapped\")) {",
"VAR_1->export_flags |= V9FS_SM_MAPPED;",
"} else if (!strcmp(VAR_2, \"none\")) {",
"VAR_1->export_flags |= V9FS_SM_NONE;",
"} else {",
"fprintf(stderr, \"Invalid security model %s specified, valid options are\"\n\"\\n\\t [passthrough|mapped|none]\\n\", VAR_2);",
"return -1;",
"}",
"if (!VAR_3) {",
"fprintf(stderr, \"fsdev: No VAR_3 specified.\\n\");",
"return -1;",
"}",
"VAR_1->VAR_3 = g_strdup(VAR_3);",
"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
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13,
15,
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39,
41
],
[
43
],
[
45
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
61
],
[
63
]
] |
24,041 | static void spr_write_dbatl_h (void *opaque, int sprn)
{
DisasContext *ctx = opaque;
gen_op_store_dbatl((sprn - SPR_DBAT4L) / 2);
RET_STOP(ctx);
}
| false | qemu | e1833e1f96456fd8fc17463246fe0b2050e68efb | static void spr_write_dbatl_h (void *opaque, int sprn)
{
DisasContext *ctx = opaque;
gen_op_store_dbatl((sprn - SPR_DBAT4L) / 2);
RET_STOP(ctx);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0 (void *VAR_0, int VAR_1)
{
DisasContext *ctx = VAR_0;
gen_op_store_dbatl((VAR_1 - SPR_DBAT4L) / 2);
RET_STOP(ctx);
}
| [
"static void FUNC_0 (void *VAR_0, int VAR_1)\n{",
"DisasContext *ctx = VAR_0;",
"gen_op_store_dbatl((VAR_1 - SPR_DBAT4L) / 2);",
"RET_STOP(ctx);",
"}"
] | [
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
]
] |
24,043 | static void do_branch_reg(DisasContext *dc, int32_t offset, uint32_t insn,
TCGv r_cond, TCGv r_reg)
{
unsigned int cond = GET_FIELD_SP(insn, 25, 27), a = (insn & (1 << 29));
target_ulong target = dc->pc + offset;
flush_cond(dc, r_cond);
gen_cond_reg(r_cond, cond, r_reg);
if (a) {
gen_branch_a(dc, target, dc->npc, r_cond);
dc->is_br = 1;
} else {
dc->pc = dc->npc;
dc->jump_pc[0] = target;
dc->jump_pc[1] = dc->npc + 4;
dc->npc = JUMP_PC;
}
}
| false | qemu | 548f66db33b91bf305c4e5228bb29585701ab58d | static void do_branch_reg(DisasContext *dc, int32_t offset, uint32_t insn,
TCGv r_cond, TCGv r_reg)
{
unsigned int cond = GET_FIELD_SP(insn, 25, 27), a = (insn & (1 << 29));
target_ulong target = dc->pc + offset;
flush_cond(dc, r_cond);
gen_cond_reg(r_cond, cond, r_reg);
if (a) {
gen_branch_a(dc, target, dc->npc, r_cond);
dc->is_br = 1;
} else {
dc->pc = dc->npc;
dc->jump_pc[0] = target;
dc->jump_pc[1] = dc->npc + 4;
dc->npc = JUMP_PC;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DisasContext *VAR_0, int32_t VAR_1, uint32_t VAR_2,
TCGv VAR_3, TCGv VAR_4)
{
unsigned int VAR_5 = GET_FIELD_SP(VAR_2, 25, 27), VAR_6 = (VAR_2 & (1 << 29));
target_ulong target = VAR_0->pc + VAR_1;
flush_cond(VAR_0, VAR_3);
gen_cond_reg(VAR_3, VAR_5, VAR_4);
if (VAR_6) {
gen_branch_a(VAR_0, target, VAR_0->npc, VAR_3);
VAR_0->is_br = 1;
} else {
VAR_0->pc = VAR_0->npc;
VAR_0->jump_pc[0] = target;
VAR_0->jump_pc[1] = VAR_0->npc + 4;
VAR_0->npc = JUMP_PC;
}
}
| [
"static void FUNC_0(DisasContext *VAR_0, int32_t VAR_1, uint32_t VAR_2,\nTCGv VAR_3, TCGv VAR_4)\n{",
"unsigned int VAR_5 = GET_FIELD_SP(VAR_2, 25, 27), VAR_6 = (VAR_2 & (1 << 29));",
"target_ulong target = VAR_0->pc + VAR_1;",
"flush_cond(VAR_0, VAR_3);",
"gen_cond_reg(VAR_3, VAR_5, VAR_4);",
"if (VAR_6) {",
"gen_branch_a(VAR_0, target, VAR_0->npc, VAR_3);",
"VAR_0->is_br = 1;",
"} else {",
"VAR_0->pc = VAR_0->npc;",
"VAR_0->jump_pc[0] = target;",
"VAR_0->jump_pc[1] = VAR_0->npc + 4;",
"VAR_0->npc = JUMP_PC;",
"}",
"}"
] | [
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
]
] |
24,045 | static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
{
int b, prefixes, aflag, dflag;
int shift, ot;
int modrm, reg, rm, mod, reg_addr, op, opreg, offset_addr, val;
target_ulong next_eip, tval;
int rex_w, rex_r;
if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP | CPU_LOG_TB_OP_OPT))) {
tcg_gen_debug_insn_start(pc_start);
}
s->pc = pc_start;
prefixes = 0;
aflag = s->code32;
dflag = s->code32;
s->override = -1;
rex_w = -1;
rex_r = 0;
#ifdef TARGET_X86_64
s->rex_x = 0;
s->rex_b = 0;
x86_64_hregs = 0;
#endif
s->rip_offset = 0; /* for relative ip address */
next_byte:
b = cpu_ldub_code(cpu_single_env, s->pc);
s->pc++;
/* check prefixes */
#ifdef TARGET_X86_64
if (CODE64(s)) {
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;
case 0x40 ... 0x4f:
/* REX prefix */
rex_w = (b >> 3) & 1;
rex_r = (b & 0x4) << 1;
s->rex_x = (b & 0x2) << 2;
REX_B(s) = (b & 0x1) << 3;
x86_64_hregs = 1; /* select uniform byte register addressing */
goto next_byte;
}
if (rex_w == 1) {
/* 0x66 is ignored if rex.w is set */
dflag = 2;
} else {
if (prefixes & PREFIX_DATA)
dflag ^= 1;
}
if (!(prefixes & PREFIX_ADR))
aflag = 2;
} else
#endif
{
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_helper_lock();
/* now check op code */
reswitch:
switch(b) {
case 0x0f:
/**************************/
/* extended op code */
b = cpu_ldub_code(cpu_single_env, 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_WORD;
switch(f) {
case 0: /* OP Ev, Gv */
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
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 = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
reg = ((modrm >> 3) & 7) | rex_r;
rm = (modrm & 7) | REX_B(s);
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 0x82:
if (CODE64(s))
goto illegal_op;
case 0x80: /* GRP1 */
case 0x81:
case 0x83:
{
int val;
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
op = (modrm >> 3) & 7;
if (mod != 3) {
if (b == 0x83)
s->rip_offset = 1;
else
s->rip_offset = insn_const_size(ot);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
opreg = OR_TMP0;
} else {
opreg = rm;
}
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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
op = (modrm >> 3) & 7;
if (mod != 3) {
if (op == 0)
s->rip_offset = insn_const_size(ot);
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 */
tcg_gen_not_tl(cpu_T[0], cpu_T[0]);
if (mod != 3) {
gen_op_st_T0_A0(ot + s->mem_index);
} else {
gen_op_mov_reg_T0(ot, rm);
}
break;
case 3: /* neg */
tcg_gen_neg_tl(cpu_T[0], cpu_T[0]);
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_mov_TN_reg(OT_BYTE, 1, R_EAX);
tcg_gen_ext8u_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext8u_tl(cpu_T[1], cpu_T[1]);
/* XXX: use 32 bit mul which could be faster */
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_WORD, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_andi_tl(cpu_cc_src, cpu_T[0], 0xff00);
s->cc_op = CC_OP_MULB;
break;
case OT_WORD:
gen_op_mov_TN_reg(OT_WORD, 1, R_EAX);
tcg_gen_ext16u_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext16u_tl(cpu_T[1], cpu_T[1]);
/* XXX: use 32 bit mul which could be faster */
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_WORD, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 16);
gen_op_mov_reg_T0(OT_WORD, R_EDX);
tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);
s->cc_op = CC_OP_MULW;
break;
default:
case OT_LONG:
#ifdef TARGET_X86_64
gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);
tcg_gen_ext32u_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext32u_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_LONG, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 32);
gen_op_mov_reg_T0(OT_LONG, R_EDX);
tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);
#else
{
TCGv_i64 t0, t1;
t0 = tcg_temp_new_i64();
t1 = tcg_temp_new_i64();
gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);
tcg_gen_extu_i32_i64(t0, cpu_T[0]);
tcg_gen_extu_i32_i64(t1, cpu_T[1]);
tcg_gen_mul_i64(t0, t0, t1);
tcg_gen_trunc_i64_i32(cpu_T[0], t0);
gen_op_mov_reg_T0(OT_LONG, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_shri_i64(t0, t0, 32);
tcg_gen_trunc_i64_i32(cpu_T[0], t0);
gen_op_mov_reg_T0(OT_LONG, R_EDX);
tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);
}
#endif
s->cc_op = CC_OP_MULL;
break;
#ifdef TARGET_X86_64
case OT_QUAD:
gen_helper_mulq_EAX_T0(cpu_env, cpu_T[0]);
s->cc_op = CC_OP_MULQ;
break;
#endif
}
break;
case 5: /* imul */
switch(ot) {
case OT_BYTE:
gen_op_mov_TN_reg(OT_BYTE, 1, R_EAX);
tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext8s_tl(cpu_T[1], cpu_T[1]);
/* XXX: use 32 bit mul which could be faster */
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_WORD, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_ext8s_tl(cpu_tmp0, cpu_T[0]);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
s->cc_op = CC_OP_MULB;
break;
case OT_WORD:
gen_op_mov_TN_reg(OT_WORD, 1, R_EAX);
tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext16s_tl(cpu_T[1], cpu_T[1]);
/* XXX: use 32 bit mul which could be faster */
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_WORD, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_ext16s_tl(cpu_tmp0, cpu_T[0]);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 16);
gen_op_mov_reg_T0(OT_WORD, R_EDX);
s->cc_op = CC_OP_MULW;
break;
default:
case OT_LONG:
#ifdef TARGET_X86_64
gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);
tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext32s_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_LONG, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_ext32s_tl(cpu_tmp0, cpu_T[0]);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 32);
gen_op_mov_reg_T0(OT_LONG, R_EDX);
#else
{
TCGv_i64 t0, t1;
t0 = tcg_temp_new_i64();
t1 = tcg_temp_new_i64();
gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);
tcg_gen_ext_i32_i64(t0, cpu_T[0]);
tcg_gen_ext_i32_i64(t1, cpu_T[1]);
tcg_gen_mul_i64(t0, t0, t1);
tcg_gen_trunc_i64_i32(cpu_T[0], t0);
gen_op_mov_reg_T0(OT_LONG, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_sari_tl(cpu_tmp0, cpu_T[0], 31);
tcg_gen_shri_i64(t0, t0, 32);
tcg_gen_trunc_i64_i32(cpu_T[0], t0);
gen_op_mov_reg_T0(OT_LONG, R_EDX);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
}
#endif
s->cc_op = CC_OP_MULL;
break;
#ifdef TARGET_X86_64
case OT_QUAD:
gen_helper_imulq_EAX_T0(cpu_env, cpu_T[0]);
s->cc_op = CC_OP_MULQ;
break;
#endif
}
break;
case 6: /* div */
switch(ot) {
case OT_BYTE:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_divb_AL(cpu_env, cpu_T[0]);
break;
case OT_WORD:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_divw_AX(cpu_env, cpu_T[0]);
break;
default:
case OT_LONG:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_divl_EAX(cpu_env, cpu_T[0]);
break;
#ifdef TARGET_X86_64
case OT_QUAD:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_divq_EAX(cpu_env, cpu_T[0]);
break;
#endif
}
break;
case 7: /* idiv */
switch(ot) {
case OT_BYTE:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_idivb_AL(cpu_env, cpu_T[0]);
break;
case OT_WORD:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_idivw_AX(cpu_env, cpu_T[0]);
break;
default:
case OT_LONG:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_idivl_EAX(cpu_env, cpu_T[0]);
break;
#ifdef TARGET_X86_64
case OT_QUAD:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_idivq_EAX(cpu_env, cpu_T[0]);
break;
#endif
}
break;
default:
goto illegal_op;
}
break;
case 0xfe: /* GRP4 */
case 0xff: /* GRP5 */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
op = (modrm >> 3) & 7;
if (op >= 2 && b == 0xfe) {
goto illegal_op;
}
if (CODE64(s)) {
if (op == 2 || op == 4) {
/* operand size for jumps is 64 bit */
ot = OT_QUAD;
} else if (op == 3 || op == 5) {
ot = dflag ? OT_LONG + (rex_w == 1) : OT_WORD;
} else if (op == 6) {
/* default push size is 64 bit */
ot = dflag ? OT_QUAD : OT_WORD;
}
}
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_movtl_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_add_A0_im(s, 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_jmp_im(pc_start - s->cs_base);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_lcall_protected(cpu_env, cpu_tmp2_i32, cpu_T[1],
tcg_const_i32(dflag),
tcg_const_i32(s->pc - pc_start));
} else {
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_lcall_real(cpu_env, cpu_tmp2_i32, cpu_T[1],
tcg_const_i32(dflag),
tcg_const_i32(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_add_A0_im(s, 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_jmp_im(pc_start - s->cs_base);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_ljmp_protected(cpu_env, cpu_tmp2_i32, cpu_T[1],
tcg_const_i32(s->pc - pc_start));
} else {
gen_op_movl_seg_T0_vm(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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_mov_TN_reg(ot, 1, reg);
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_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 */
#ifdef TARGET_X86_64
if (dflag == 2) {
gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);
tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_QUAD, R_EAX);
} else
#endif
if (dflag == 1) {
gen_op_mov_TN_reg(OT_WORD, 0, R_EAX);
tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_LONG, R_EAX);
} else {
gen_op_mov_TN_reg(OT_BYTE, 0, R_EAX);
tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_WORD, R_EAX);
}
break;
case 0x99: /* CDQ/CWD */
#ifdef TARGET_X86_64
if (dflag == 2) {
gen_op_mov_TN_reg(OT_QUAD, 0, R_EAX);
tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 63);
gen_op_mov_reg_T0(OT_QUAD, R_EDX);
} else
#endif
if (dflag == 1) {
gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);
tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 31);
gen_op_mov_reg_T0(OT_LONG, R_EDX);
} else {
gen_op_mov_TN_reg(OT_WORD, 0, R_EAX);
tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 15);
gen_op_mov_reg_T0(OT_WORD, R_EDX);
}
break;
case 0x1af: /* imul Gv, Ev */
case 0x69: /* imul Gv, Ev, I */
case 0x6b:
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
if (b == 0x69)
s->rip_offset = insn_const_size(ot);
else if (b == 0x6b)
s->rip_offset = 1;
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);
}
#ifdef TARGET_X86_64
if (ot == OT_QUAD) {
gen_helper_imulq_T0_T1(cpu_T[0], cpu_env, cpu_T[0], cpu_T[1]);
} else
#endif
if (ot == OT_LONG) {
#ifdef TARGET_X86_64
tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext32s_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_ext32s_tl(cpu_tmp0, cpu_T[0]);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
#else
{
TCGv_i64 t0, t1;
t0 = tcg_temp_new_i64();
t1 = tcg_temp_new_i64();
tcg_gen_ext_i32_i64(t0, cpu_T[0]);
tcg_gen_ext_i32_i64(t1, cpu_T[1]);
tcg_gen_mul_i64(t0, t0, t1);
tcg_gen_trunc_i64_i32(cpu_T[0], t0);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_sari_tl(cpu_tmp0, cpu_T[0], 31);
tcg_gen_shri_i64(t0, t0, 32);
tcg_gen_trunc_i64_i32(cpu_T[1], t0);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[1], cpu_tmp0);
}
#endif
} else {
tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext16s_tl(cpu_T[1], cpu_T[1]);
/* XXX: use 32 bit mul which could be faster */
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_ext16s_tl(cpu_tmp0, cpu_T[0]);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
}
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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3;
if (mod == 3) {
rm = (modrm & 7) | REX_B(s);
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 */
{
int label1, label2;
TCGv t0, t1, t2, a0;
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3;
t0 = tcg_temp_local_new();
t1 = tcg_temp_local_new();
t2 = tcg_temp_local_new();
a0 = tcg_temp_local_new();
gen_op_mov_v_reg(ot, t1, reg);
if (mod == 3) {
rm = (modrm & 7) | REX_B(s);
gen_op_mov_v_reg(ot, t0, rm);
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
tcg_gen_mov_tl(a0, cpu_A0);
gen_op_ld_v(ot + s->mem_index, t0, a0);
rm = 0; /* avoid warning */
}
label1 = gen_new_label();
tcg_gen_sub_tl(t2, cpu_regs[R_EAX], t0);
gen_extu(ot, t2);
tcg_gen_brcondi_tl(TCG_COND_EQ, t2, 0, label1);
label2 = gen_new_label();
if (mod == 3) {
gen_op_mov_reg_v(ot, R_EAX, t0);
tcg_gen_br(label2);
gen_set_label(label1);
gen_op_mov_reg_v(ot, rm, t1);
} else {
/* perform no-op store cycle like physical cpu; must be
before changing accumulator to ensure idempotency if
the store faults and the instruction is restarted */
gen_op_st_v(ot + s->mem_index, t0, a0);
gen_op_mov_reg_v(ot, R_EAX, t0);
tcg_gen_br(label2);
gen_set_label(label1);
gen_op_st_v(ot + s->mem_index, t1, a0);
}
gen_set_label(label2);
tcg_gen_mov_tl(cpu_cc_src, t0);
tcg_gen_mov_tl(cpu_cc_dst, t2);
s->cc_op = CC_OP_SUBB + ot;
tcg_temp_free(t0);
tcg_temp_free(t1);
tcg_temp_free(t2);
tcg_temp_free(a0);
}
break;
case 0x1c7: /* cmpxchg8b */
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
if ((mod == 3) || ((modrm & 0x38) != 0x8))
goto illegal_op;
#ifdef TARGET_X86_64
if (dflag == 2) {
if (!(s->cpuid_ext_features & CPUID_EXT_CX16))
goto illegal_op;
gen_jmp_im(pc_start - s->cs_base);
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_helper_cmpxchg16b(cpu_env, cpu_A0);
} else
#endif
{
if (!(s->cpuid_features & CPUID_CX8))
goto illegal_op;
gen_jmp_im(pc_start - s->cs_base);
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_helper_cmpxchg8b(cpu_env, cpu_A0);
}
s->cc_op = CC_OP_EFLAGS;
break;
/**************************/
/* push/pop */
case 0x50 ... 0x57: /* push */
gen_op_mov_TN_reg(OT_LONG, 0, (b & 7) | REX_B(s));
gen_push_T0(s);
break;
case 0x58 ... 0x5f: /* pop */
if (CODE64(s)) {
ot = dflag ? OT_QUAD : OT_WORD;
} else {
ot = dflag + 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) | REX_B(s));
break;
case 0x60: /* pusha */
if (CODE64(s))
goto illegal_op;
gen_pusha(s);
break;
case 0x61: /* popa */
if (CODE64(s))
goto illegal_op;
gen_popa(s);
break;
case 0x68: /* push Iv */
case 0x6a:
if (CODE64(s)) {
ot = dflag ? OT_QUAD : OT_WORD;
} else {
ot = dflag + 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 */
if (CODE64(s)) {
ot = dflag ? OT_QUAD : OT_WORD;
} else {
ot = dflag + OT_WORD;
}
modrm = cpu_ldub_code(cpu_single_env, 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) | REX_B(s);
gen_op_mov_reg_T0(ot, rm);
} else {
/* NOTE: order is important too for MMU exceptions */
s->popl_esp_hack = 1 << ot;
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 = cpu_lduw_code(cpu_single_env, s->pc);
s->pc += 2;
level = cpu_ldub_code(cpu_single_env, s->pc++);
gen_enter(s, val, level);
}
break;
case 0xc9: /* leave */
/* XXX: exception not precise (ESP is updated before potential exception) */
if (CODE64(s)) {
gen_op_mov_TN_reg(OT_QUAD, 0, R_EBP);
gen_op_mov_reg_T0(OT_QUAD, R_ESP);
} else 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);
if (CODE64(s)) {
ot = dflag ? OT_QUAD : OT_WORD;
} else {
ot = dflag + 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 */
if (CODE64(s))
goto illegal_op;
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 */
if (CODE64(s))
goto illegal_op;
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_helper_set_inhibit_irq(cpu_env);
s->tf = 0;
}
if (s->is_jmp) {
gen_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_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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
/* generate a generic store */
gen_ldst_modrm(s, modrm, ot, reg, 1);
break;
case 0xc6:
case 0xc7: /* mov Ev, Iv */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
if (mod != 3) {
s->rip_offset = insn_const_size(ot);
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) | REX_B(s));
break;
case 0x8a:
case 0x8b: /* mov Ev, Gv */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = OT_WORD + dflag;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_mov_reg_T0(ot, reg);
break;
case 0x8e: /* mov seg, Gv */
modrm = cpu_ldub_code(cpu_single_env, 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_helper_set_inhibit_irq(cpu_env);
s->tf = 0;
}
if (s->is_jmp) {
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x8c: /* mov Gv, seg */
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (reg >= 6)
goto illegal_op;
gen_op_movl_T0_seg(reg);
if (mod == 3)
ot = OT_WORD + dflag;
else
ot = OT_WORD;
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 = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
if (mod == 3) {
gen_op_mov_TN_reg(ot, 0, rm);
switch(ot | (b & 8)) {
case OT_BYTE:
tcg_gen_ext8u_tl(cpu_T[0], cpu_T[0]);
break;
case OT_BYTE | 8:
tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);
break;
case OT_WORD:
tcg_gen_ext16u_tl(cpu_T[0], cpu_T[0]);
break;
default:
case OT_WORD | 8:
tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
reg = ((modrm >> 3) & 7) | rex_r;
/* 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:
{
target_ulong offset_addr;
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag + OT_WORD;
#ifdef TARGET_X86_64
if (s->aflag == 2) {
offset_addr = cpu_ldq_code(cpu_single_env, s->pc);
s->pc += 8;
gen_op_movq_A0_im(offset_addr);
} else
#endif
{
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);
}
gen_add_A0_ds_seg(s);
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 */
#ifdef TARGET_X86_64
if (s->aflag == 2) {
gen_op_movq_A0_reg(R_EBX);
gen_op_mov_TN_reg(OT_QUAD, 0, R_EAX);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xff);
tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_T[0]);
} else
#endif
{
gen_op_movl_A0_reg(R_EBX);
gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xff);
tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_T[0]);
if (s->aflag == 0)
gen_op_andl_A0_ffff();
else
tcg_gen_andi_tl(cpu_A0, cpu_A0, 0xffffffff);
}
gen_add_A0_ds_seg(s);
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) | REX_B(s));
break;
case 0xb8 ... 0xbf: /* mov R, Iv */
#ifdef TARGET_X86_64
if (dflag == 2) {
uint64_t tmp;
/* 64 bit case */
tmp = cpu_ldq_code(cpu_single_env, s->pc);
s->pc += 8;
reg = (b & 7) | REX_B(s);
gen_movtl_T0_im(tmp);
gen_op_mov_reg_T0(OT_QUAD, reg);
} else
#endif
{
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
reg = (b & 7) | REX_B(s);
gen_op_movl_T0_im(val);
gen_op_mov_reg_T0(ot, reg);
}
break;
case 0x91 ... 0x97: /* xchg R, EAX */
do_xchg_reg_eax:
ot = dflag + OT_WORD;
reg = (b & 7) | REX_B(s);
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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3;
if (mod == 3) {
rm = (modrm & 7) | REX_B(s);
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_helper_lock();
gen_op_ld_T1_A0(ot + s->mem_index);
gen_op_st_T0_A0(ot + s->mem_index);
if (!(prefixes & PREFIX_LOCK))
gen_helper_unlock();
gen_op_mov_reg_T1(ot, reg);
}
break;
case 0xc4: /* les Gv */
if (CODE64(s))
goto illegal_op;
op = R_ES;
goto do_lxx;
case 0xc5: /* lds Gv */
if (CODE64(s))
goto illegal_op;
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 = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
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_add_A0_im(s, 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_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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7;
if (mod != 3) {
if (shift == 2) {
s->rip_offset = 1;
}
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
opreg = OR_TMP0;
} else {
opreg = (modrm & 7) | REX_B(s);
}
/* simpler op */
if (shift == 0) {
gen_shift(s, op, ot, opreg, OR_ECX);
} else {
if (shift == 2) {
shift = cpu_ldub_code(cpu_single_env, 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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
reg = ((modrm >> 3) & 7) | rex_r;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
opreg = OR_TMP0;
} else {
opreg = rm;
}
gen_op_mov_TN_reg(ot, 1, reg);
if (shift) {
val = cpu_ldub_code(cpu_single_env, s->pc++);
tcg_gen_movi_tl(cpu_T3, val);
} else {
tcg_gen_mov_tl(cpu_T3, cpu_regs[R_ECX]);
}
gen_shiftd_rm_T1_T3(s, ot, opreg, op);
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 = cpu_ldub_code(cpu_single_env, 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_ld_T0_A0(OT_LONG + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_flds_FT0(cpu_env, cpu_tmp2_i32);
break;
case 1:
gen_op_ld_T0_A0(OT_LONG + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_fildl_FT0(cpu_env, cpu_tmp2_i32);
break;
case 2:
tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
gen_helper_fldl_FT0(cpu_env, cpu_tmp1_i64);
break;
case 3:
default:
gen_op_lds_T0_A0(OT_WORD + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_fildl_FT0(cpu_env, cpu_tmp2_i32);
break;
}
gen_helper_fp_arith_ST0_FT0(op1);
if (op1 == 3) {
/* fcomp needs pop */
gen_helper_fpop(cpu_env);
}
}
break;
case 0x08: /* flds */
case 0x0a: /* fsts */
case 0x0b: /* fstps */
case 0x18 ... 0x1b: /* fildl, fisttpl, fistl, fistpl */
case 0x28 ... 0x2b: /* fldl, fisttpll, fstl, fstpl */
case 0x38 ... 0x3b: /* filds, fisttps, fists, fistps */
switch(op & 7) {
case 0:
switch(op >> 4) {
case 0:
gen_op_ld_T0_A0(OT_LONG + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_flds_ST0(cpu_env, cpu_tmp2_i32);
break;
case 1:
gen_op_ld_T0_A0(OT_LONG + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_fildl_ST0(cpu_env, cpu_tmp2_i32);
break;
case 2:
tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
gen_helper_fldl_ST0(cpu_env, cpu_tmp1_i64);
break;
case 3:
default:
gen_op_lds_T0_A0(OT_WORD + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_fildl_ST0(cpu_env, cpu_tmp2_i32);
break;
}
break;
case 1:
/* XXX: the corresponding CPUID bit must be tested ! */
switch(op >> 4) {
case 1:
gen_helper_fisttl_ST0(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_LONG + s->mem_index);
break;
case 2:
gen_helper_fisttll_ST0(cpu_tmp1_i64, cpu_env);
tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
break;
case 3:
default:
gen_helper_fistt_ST0(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_WORD + s->mem_index);
break;
}
gen_helper_fpop(cpu_env);
break;
default:
switch(op >> 4) {
case 0:
gen_helper_fsts_ST0(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_LONG + s->mem_index);
break;
case 1:
gen_helper_fistl_ST0(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_LONG + s->mem_index);
break;
case 2:
gen_helper_fstl_ST0(cpu_tmp1_i64, cpu_env);
tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
break;
case 3:
default:
gen_helper_fist_ST0(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_WORD + s->mem_index);
break;
}
if ((op & 7) == 3)
gen_helper_fpop(cpu_env);
break;
}
break;
case 0x0c: /* fldenv mem */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fldenv(cpu_env, cpu_A0, tcg_const_i32(s->dflag));
break;
case 0x0d: /* fldcw mem */
gen_op_ld_T0_A0(OT_WORD + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_fldcw(cpu_env, cpu_tmp2_i32);
break;
case 0x0e: /* fnstenv mem */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fstenv(cpu_env, cpu_A0, tcg_const_i32(s->dflag));
break;
case 0x0f: /* fnstcw mem */
gen_helper_fnstcw(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_WORD + s->mem_index);
break;
case 0x1d: /* fldt mem */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fldt_ST0(cpu_env, cpu_A0);
break;
case 0x1f: /* fstpt mem */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fstt_ST0(cpu_env, cpu_A0);
gen_helper_fpop(cpu_env);
break;
case 0x2c: /* frstor mem */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_frstor(cpu_env, cpu_A0, tcg_const_i32(s->dflag));
break;
case 0x2e: /* fnsave mem */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fsave(cpu_env, cpu_A0, tcg_const_i32(s->dflag));
break;
case 0x2f: /* fnstsw mem */
gen_helper_fnstsw(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_WORD + s->mem_index);
break;
case 0x3c: /* fbld */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fbld_ST0(cpu_env, cpu_A0);
break;
case 0x3e: /* fbstp */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fbst_ST0(cpu_env, cpu_A0);
gen_helper_fpop(cpu_env);
break;
case 0x3d: /* fildll */
tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
gen_helper_fildll_ST0(cpu_env, cpu_tmp1_i64);
break;
case 0x3f: /* fistpll */
gen_helper_fistll_ST0(cpu_tmp1_i64, cpu_env);
tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
gen_helper_fpop(cpu_env);
break;
default:
goto illegal_op;
}
} else {
/* register float ops */
opreg = rm;
switch(op) {
case 0x08: /* fld sti */
gen_helper_fpush(cpu_env);
gen_helper_fmov_ST0_STN(cpu_env,
tcg_const_i32((opreg + 1) & 7));
break;
case 0x09: /* fxchg sti */
case 0x29: /* fxchg4 sti, undocumented op */
case 0x39: /* fxchg7 sti, undocumented op */
gen_helper_fxchg_ST0_STN(cpu_env, tcg_const_i32(opreg));
break;
case 0x0a: /* grp d9/2 */
switch(rm) {
case 0: /* fnop */
/* check exceptions (FreeBSD FPU probe) */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fwait(cpu_env);
break;
default:
goto illegal_op;
}
break;
case 0x0c: /* grp d9/4 */
switch(rm) {
case 0: /* fchs */
gen_helper_fchs_ST0(cpu_env);
break;
case 1: /* fabs */
gen_helper_fabs_ST0(cpu_env);
break;
case 4: /* ftst */
gen_helper_fldz_FT0(cpu_env);
gen_helper_fcom_ST0_FT0(cpu_env);
break;
case 5: /* fxam */
gen_helper_fxam_ST0(cpu_env);
break;
default:
goto illegal_op;
}
break;
case 0x0d: /* grp d9/5 */
{
switch(rm) {
case 0:
gen_helper_fpush(cpu_env);
gen_helper_fld1_ST0(cpu_env);
break;
case 1:
gen_helper_fpush(cpu_env);
gen_helper_fldl2t_ST0(cpu_env);
break;
case 2:
gen_helper_fpush(cpu_env);
gen_helper_fldl2e_ST0(cpu_env);
break;
case 3:
gen_helper_fpush(cpu_env);
gen_helper_fldpi_ST0(cpu_env);
break;
case 4:
gen_helper_fpush(cpu_env);
gen_helper_fldlg2_ST0(cpu_env);
break;
case 5:
gen_helper_fpush(cpu_env);
gen_helper_fldln2_ST0(cpu_env);
break;
case 6:
gen_helper_fpush(cpu_env);
gen_helper_fldz_ST0(cpu_env);
break;
default:
goto illegal_op;
}
}
break;
case 0x0e: /* grp d9/6 */
switch(rm) {
case 0: /* f2xm1 */
gen_helper_f2xm1(cpu_env);
break;
case 1: /* fyl2x */
gen_helper_fyl2x(cpu_env);
break;
case 2: /* fptan */
gen_helper_fptan(cpu_env);
break;
case 3: /* fpatan */
gen_helper_fpatan(cpu_env);
break;
case 4: /* fxtract */
gen_helper_fxtract(cpu_env);
break;
case 5: /* fprem1 */
gen_helper_fprem1(cpu_env);
break;
case 6: /* fdecstp */
gen_helper_fdecstp(cpu_env);
break;
default:
case 7: /* fincstp */
gen_helper_fincstp(cpu_env);
break;
}
break;
case 0x0f: /* grp d9/7 */
switch(rm) {
case 0: /* fprem */
gen_helper_fprem(cpu_env);
break;
case 1: /* fyl2xp1 */
gen_helper_fyl2xp1(cpu_env);
break;
case 2: /* fsqrt */
gen_helper_fsqrt(cpu_env);
break;
case 3: /* fsincos */
gen_helper_fsincos(cpu_env);
break;
case 5: /* fscale */
gen_helper_fscale(cpu_env);
break;
case 4: /* frndint */
gen_helper_frndint(cpu_env);
break;
case 6: /* fsin */
gen_helper_fsin(cpu_env);
break;
default:
case 7: /* fcos */
gen_helper_fcos(cpu_env);
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_helper_fp_arith_STN_ST0(op1, opreg);
if (op >= 0x30)
gen_helper_fpop(cpu_env);
} else {
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fp_arith_ST0_FT0(op1);
}
}
break;
case 0x02: /* fcom */
case 0x22: /* fcom2, undocumented op */
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fcom_ST0_FT0(cpu_env);
break;
case 0x03: /* fcomp */
case 0x23: /* fcomp3, undocumented op */
case 0x32: /* fcomp5, undocumented op */
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fcom_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
break;
case 0x15: /* da/5 */
switch(rm) {
case 1: /* fucompp */
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(1));
gen_helper_fucom_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
gen_helper_fpop(cpu_env);
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_helper_fclex(cpu_env);
break;
case 3: /* fninit */
gen_helper_fninit(cpu_env);
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_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fucomi_ST0_FT0(cpu_env);
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_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fcomi_ST0_FT0(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x28: /* ffree sti */
gen_helper_ffree_STN(cpu_env, tcg_const_i32(opreg));
break;
case 0x2a: /* fst sti */
gen_helper_fmov_STN_ST0(cpu_env, tcg_const_i32(opreg));
break;
case 0x2b: /* fstp sti */
case 0x0b: /* fstp1 sti, undocumented op */
case 0x3a: /* fstp8 sti, undocumented op */
case 0x3b: /* fstp9 sti, undocumented op */
gen_helper_fmov_STN_ST0(cpu_env, tcg_const_i32(opreg));
gen_helper_fpop(cpu_env);
break;
case 0x2c: /* fucom st(i) */
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fucom_ST0_FT0(cpu_env);
break;
case 0x2d: /* fucomp st(i) */
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fucom_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
break;
case 0x33: /* de/3 */
switch(rm) {
case 1: /* fcompp */
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(1));
gen_helper_fcom_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
gen_helper_fpop(cpu_env);
break;
default:
goto illegal_op;
}
break;
case 0x38: /* ffreep sti, undocumented op */
gen_helper_ffree_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fpop(cpu_env);
break;
case 0x3c: /* df/4 */
switch(rm) {
case 0:
gen_helper_fnstsw(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_mov_reg_T0(OT_WORD, R_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_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fucomi_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
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_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fcomi_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x10 ... 0x13: /* fcmovxx */
case 0x18 ... 0x1b:
{
int op1, l1;
static const 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) ^ 1);
l1 = gen_new_label();
gen_jcc1(s, s->cc_op, op1, l1);
gen_helper_fmov_ST0_STN(cpu_env, tcg_const_i32(opreg));
gen_set_label(l1);
}
break;
default:
goto illegal_op;
}
}
break;
/************************/
/* string ops */
case 0xa4: /* movsS */
case 0xa5:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag + 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_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_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_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_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_op_mov_TN_reg(OT_WORD, 0, R_EDX);
gen_op_andl_T0_ffff();
gen_check_io(s, ot, pc_start - s->cs_base,
SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes) | 4);
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);
if (use_icount) {
gen_jmp(s, s->pc - s->cs_base);
}
}
break;
case 0x6e: /* outsS */
case 0x6f:
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, pc_start - s->cs_base,
svm_is_rep(prefixes) | 4);
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);
if (use_icount) {
gen_jmp(s, s->pc - s->cs_base);
}
}
break;
/************************/
/* port I/O */
case 0xe4:
case 0xe5:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
val = cpu_ldub_code(cpu_single_env, s->pc++);
gen_op_movl_T0_im(val);
gen_check_io(s, ot, pc_start - s->cs_base,
SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes));
if (use_icount)
gen_io_start();
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_in_func(ot, cpu_T[1], cpu_tmp2_i32);
gen_op_mov_reg_T1(ot, R_EAX);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
break;
case 0xe6:
case 0xe7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
val = cpu_ldub_code(cpu_single_env, s->pc++);
gen_op_movl_T0_im(val);
gen_check_io(s, ot, pc_start - s->cs_base,
svm_is_rep(prefixes));
gen_op_mov_TN_reg(ot, 1, R_EAX);
if (use_icount)
gen_io_start();
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[1]);
gen_helper_out_func(ot, cpu_tmp2_i32, cpu_tmp3_i32);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
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, pc_start - s->cs_base,
SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes));
if (use_icount)
gen_io_start();
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_in_func(ot, cpu_T[1], cpu_tmp2_i32);
gen_op_mov_reg_T1(ot, R_EAX);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
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, pc_start - s->cs_base,
svm_is_rep(prefixes));
gen_op_mov_TN_reg(ot, 1, R_EAX);
if (use_icount)
gen_io_start();
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[1]);
gen_helper_out_func(ot, cpu_tmp2_i32, cpu_tmp3_i32);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
break;
/************************/
/* control */
case 0xc2: /* ret im */
val = cpu_ldsw_code(cpu_single_env, s->pc);
s->pc += 2;
gen_pop_T0(s);
if (CODE64(s) && s->dflag)
s->dflag = 2;
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 = cpu_ldsw_code(cpu_single_env, 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_jmp_im(pc_start - s->cs_base);
gen_helper_lret_protected(cpu_env, tcg_const_i32(s->dflag),
tcg_const_i32(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(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 */
gen_svm_check_intercept(s, pc_start, SVM_EXIT_IRET);
if (!s->pe) {
/* real mode */
gen_helper_iret_real(cpu_env, tcg_const_i32(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_helper_iret_real(cpu_env, tcg_const_i32(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_jmp_im(pc_start - s->cs_base);
gen_helper_iret_protected(cpu_env, tcg_const_i32(s->dflag),
tcg_const_i32(s->pc - s->cs_base));
s->cc_op = CC_OP_EFLAGS;
}
gen_eob(s);
break;
case 0xe8: /* call im */
{
if (dflag)
tval = (int32_t)insn_get(s, OT_LONG);
else
tval = (int16_t)insn_get(s, OT_WORD);
next_eip = s->pc - s->cs_base;
tval += next_eip;
if (s->dflag == 0)
tval &= 0xffff;
else if(!CODE64(s))
tval &= 0xffffffff;
gen_movtl_T0_im(next_eip);
gen_push_T0(s);
gen_jmp(s, tval);
}
break;
case 0x9a: /* lcall im */
{
unsigned int selector, offset;
if (CODE64(s))
goto illegal_op;
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_imu(offset);
}
goto do_lcall;
case 0xe9: /* jmp im */
if (dflag)
tval = (int32_t)insn_get(s, OT_LONG);
else
tval = (int16_t)insn_get(s, OT_WORD);
tval += s->pc - s->cs_base;
if (s->dflag == 0)
tval &= 0xffff;
else if(!CODE64(s))
tval &= 0xffffffff;
gen_jmp(s, tval);
break;
case 0xea: /* ljmp im */
{
unsigned int selector, offset;
if (CODE64(s))
goto illegal_op;
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_imu(offset);
}
goto do_ljmp;
case 0xeb: /* jmp Jb */
tval = (int8_t)insn_get(s, OT_BYTE);
tval += s->pc - s->cs_base;
if (s->dflag == 0)
tval &= 0xffff;
gen_jmp(s, tval);
break;
case 0x70 ... 0x7f: /* jcc Jb */
tval = (int8_t)insn_get(s, OT_BYTE);
goto do_jcc;
case 0x180 ... 0x18f: /* jcc Jv */
if (dflag) {
tval = (int32_t)insn_get(s, OT_LONG);
} else {
tval = (int16_t)insn_get(s, OT_WORD);
}
do_jcc:
next_eip = s->pc - s->cs_base;
tval += next_eip;
if (s->dflag == 0)
tval &= 0xffff;
gen_jcc(s, b, tval, next_eip);
break;
case 0x190 ... 0x19f: /* setcc Gv */
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
gen_setcc(s, b);
gen_ldst_modrm(s, modrm, OT_BYTE, OR_TMP0, 1);
break;
case 0x140 ... 0x14f: /* cmov Gv, Ev */
{
int l1;
TCGv t0;
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3;
t0 = tcg_temp_local_new();
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_v(ot + s->mem_index, t0, cpu_A0);
} else {
rm = (modrm & 7) | REX_B(s);
gen_op_mov_v_reg(ot, t0, rm);
}
#ifdef TARGET_X86_64
if (ot == OT_LONG) {
/* XXX: specific Intel behaviour ? */
l1 = gen_new_label();
gen_jcc1(s, s->cc_op, b ^ 1, l1);
tcg_gen_mov_tl(cpu_regs[reg], t0);
gen_set_label(l1);
tcg_gen_ext32u_tl(cpu_regs[reg], cpu_regs[reg]);
} else
#endif
{
l1 = gen_new_label();
gen_jcc1(s, s->cc_op, b ^ 1, l1);
gen_op_mov_reg_v(ot, reg, t0);
gen_set_label(l1);
}
tcg_temp_free(t0);
}
break;
/************************/
/* flags */
case 0x9c: /* pushf */
gen_svm_check_intercept(s, pc_start, SVM_EXIT_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_helper_read_eflags(cpu_T[0], cpu_env);
gen_push_T0(s);
}
break;
case 0x9d: /* popf */
gen_svm_check_intercept(s, pc_start, SVM_EXIT_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_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK | AC_MASK |
ID_MASK | NT_MASK |
IF_MASK |
IOPL_MASK)));
} else {
gen_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK | AC_MASK |
ID_MASK | NT_MASK |
IF_MASK | IOPL_MASK)
& 0xffff));
}
} else {
if (s->cpl <= s->iopl) {
if (s->dflag) {
gen_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK |
AC_MASK |
ID_MASK |
NT_MASK |
IF_MASK)));
} else {
gen_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK |
AC_MASK |
ID_MASK |
NT_MASK |
IF_MASK)
& 0xffff));
}
} else {
if (s->dflag) {
gen_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK | AC_MASK |
ID_MASK | NT_MASK)));
} else {
gen_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK | AC_MASK |
ID_MASK | NT_MASK)
& 0xffff));
}
}
}
gen_pop_update(s);
s->cc_op = CC_OP_EFLAGS;
/* abort translation because TF flag may change */
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x9e: /* sahf */
if (CODE64(s) && !(s->cpuid_ext3_features & CPUID_EXT3_LAHF_LM))
goto illegal_op;
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_compute_eflags(cpu_cc_src);
tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, CC_O);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], CC_S | CC_Z | CC_A | CC_P | CC_C);
tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, cpu_T[0]);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x9f: /* lahf */
if (CODE64(s) && !(s->cpuid_ext3_features & CPUID_EXT3_LAHF_LM))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_compute_eflags(cpu_T[0]);
/* Note: gen_compute_eflags() only gives the condition codes */
tcg_gen_ori_tl(cpu_T[0], cpu_T[0], 0x02);
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_compute_eflags(cpu_cc_src);
tcg_gen_xori_tl(cpu_cc_src, cpu_cc_src, CC_C);
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_compute_eflags(cpu_cc_src);
tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, ~CC_C);
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_compute_eflags(cpu_cc_src);
tcg_gen_ori_tl(cpu_cc_src, cpu_cc_src, CC_C);
s->cc_op = CC_OP_EFLAGS;
break;
case 0xfc: /* cld */
tcg_gen_movi_i32(cpu_tmp2_i32, 1);
tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, offsetof(CPUX86State, df));
break;
case 0xfd: /* std */
tcg_gen_movi_i32(cpu_tmp2_i32, -1);
tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, offsetof(CPUX86State, df));
break;
/************************/
/* bit operations */
case 0x1ba: /* bt/bts/btr/btc Gv, im */
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
op = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
if (mod != 3) {
s->rip_offset = 1;
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 = cpu_ldub_code(cpu_single_env, s->pc++);
gen_op_movl_T1_im(val);
if (op < 4)
goto illegal_op;
op -= 4;
goto bt_op;
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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
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 */
gen_exts(ot, cpu_T[1]);
tcg_gen_sari_tl(cpu_tmp0, cpu_T[1], 3 + ot);
tcg_gen_shli_tl(cpu_tmp0, cpu_tmp0, ot);
tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
gen_op_ld_T0_A0(ot + s->mem_index);
} else {
gen_op_mov_TN_reg(ot, 0, rm);
}
bt_op:
tcg_gen_andi_tl(cpu_T[1], cpu_T[1], (1 << (3 + ot)) - 1);
switch(op) {
case 0:
tcg_gen_shr_tl(cpu_cc_src, cpu_T[0], cpu_T[1]);
tcg_gen_movi_tl(cpu_cc_dst, 0);
break;
case 1:
tcg_gen_shr_tl(cpu_tmp4, cpu_T[0], cpu_T[1]);
tcg_gen_movi_tl(cpu_tmp0, 1);
tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);
tcg_gen_or_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
break;
case 2:
tcg_gen_shr_tl(cpu_tmp4, cpu_T[0], cpu_T[1]);
tcg_gen_movi_tl(cpu_tmp0, 1);
tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);
tcg_gen_not_tl(cpu_tmp0, cpu_tmp0);
tcg_gen_and_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
break;
default:
case 3:
tcg_gen_shr_tl(cpu_tmp4, cpu_T[0], cpu_T[1]);
tcg_gen_movi_tl(cpu_tmp0, 1);
tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);
tcg_gen_xor_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
break;
}
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);
tcg_gen_mov_tl(cpu_cc_src, cpu_tmp4);
tcg_gen_movi_tl(cpu_cc_dst, 0);
}
break;
case 0x1bc: /* bsf */
case 0x1bd: /* bsr */
{
int label1;
TCGv t0;
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
gen_ldst_modrm(s,modrm, ot, OR_TMP0, 0);
gen_extu(ot, cpu_T[0]);
t0 = tcg_temp_local_new();
tcg_gen_mov_tl(t0, cpu_T[0]);
if ((b & 1) && (prefixes & PREFIX_REPZ) &&
(s->cpuid_ext3_features & CPUID_EXT3_ABM)) {
switch(ot) {
case OT_WORD: gen_helper_lzcnt(cpu_T[0], t0,
tcg_const_i32(16)); break;
case OT_LONG: gen_helper_lzcnt(cpu_T[0], t0,
tcg_const_i32(32)); break;
case OT_QUAD: gen_helper_lzcnt(cpu_T[0], t0,
tcg_const_i32(64)); break;
}
gen_op_mov_reg_T0(ot, reg);
} else {
label1 = gen_new_label();
tcg_gen_movi_tl(cpu_cc_dst, 0);
tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, label1);
if (b & 1) {
gen_helper_bsr(cpu_T[0], t0);
} else {
gen_helper_bsf(cpu_T[0], t0);
}
gen_op_mov_reg_T0(ot, reg);
tcg_gen_movi_tl(cpu_cc_dst, 1);
gen_set_label(label1);
tcg_gen_discard_tl(cpu_cc_src);
s->cc_op = CC_OP_LOGICB + ot;
}
tcg_temp_free(t0);
}
break;
/************************/
/* bcd */
case 0x27: /* daa */
if (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_helper_daa(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x2f: /* das */
if (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_helper_das(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x37: /* aaa */
if (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_helper_aaa(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x3f: /* aas */
if (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_helper_aas(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0xd4: /* aam */
if (CODE64(s))
goto illegal_op;
val = cpu_ldub_code(cpu_single_env, s->pc++);
if (val == 0) {
gen_exception(s, EXCP00_DIVZ, pc_start - s->cs_base);
} else {
gen_helper_aam(cpu_env, tcg_const_i32(val));
s->cc_op = CC_OP_LOGICB;
}
break;
case 0xd5: /* aad */
if (CODE64(s))
goto illegal_op;
val = cpu_ldub_code(cpu_single_env, s->pc++);
gen_helper_aad(cpu_env, tcg_const_i32(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;
}
/* If REX_B is set, then this is xchg eax, r8d, not a nop. */
if (REX_B(s)) {
goto do_xchg_reg_eax;
}
if (prefixes & PREFIX_REPZ) {
gen_svm_check_intercept(s, pc_start, SVM_EXIT_PAUSE);
}
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_jmp_im(pc_start - s->cs_base);
gen_helper_fwait(cpu_env);
}
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 = cpu_ldub_code(cpu_single_env, 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 (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_into(cpu_env, tcg_const_i32(s->pc - pc_start));
break;
#ifdef WANT_ICEBP
case 0xf1: /* icebp (undocumented, exits to external debugger) */
gen_svm_check_intercept(s, pc_start, SVM_EXIT_ICEBP);
#if 1
gen_debug(s, pc_start - s->cs_base);
#else
/* start debug */
tb_flush(cpu_single_env);
cpu_set_log(CPU_LOG_INT | CPU_LOG_TB_IN_ASM);
#endif
break;
#endif
case 0xfa: /* cli */
if (!s->vm86) {
if (s->cpl <= s->iopl) {
gen_helper_cli(cpu_env);
} else {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
}
} else {
if (s->iopl == 3) {
gen_helper_cli(cpu_env);
} 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_helper_sti(cpu_env);
/* 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_helper_set_inhibit_irq(cpu_env);
/* give a chance to handle pending irqs */
gen_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 */
if (CODE64(s))
goto illegal_op;
ot = dflag ? OT_LONG : OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
gen_op_mov_TN_reg(ot, 0, reg);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_jmp_im(pc_start - s->cs_base);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
if (ot == OT_WORD) {
gen_helper_boundw(cpu_env, cpu_A0, cpu_tmp2_i32);
} else {
gen_helper_boundl(cpu_env, cpu_A0, cpu_tmp2_i32);
}
break;
case 0x1c8 ... 0x1cf: /* bswap reg */
reg = (b & 7) | REX_B(s);
#ifdef TARGET_X86_64
if (dflag == 2) {
gen_op_mov_TN_reg(OT_QUAD, 0, reg);
tcg_gen_bswap64_i64(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_QUAD, reg);
} else
#endif
{
gen_op_mov_TN_reg(OT_LONG, 0, reg);
tcg_gen_ext32u_tl(cpu_T[0], cpu_T[0]);
tcg_gen_bswap32_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_LONG, reg);
}
break;
case 0xd6: /* salc */
if (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_compute_eflags_c(cpu_T[0]);
tcg_gen_neg_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_BYTE, R_EAX);
break;
case 0xe0: /* loopnz */
case 0xe1: /* loopz */
case 0xe2: /* loop */
case 0xe3: /* jecxz */
{
int l1, l2, l3;
tval = (int8_t)insn_get(s, OT_BYTE);
next_eip = s->pc - s->cs_base;
tval += next_eip;
if (s->dflag == 0)
tval &= 0xffff;
l1 = gen_new_label();
l2 = gen_new_label();
l3 = gen_new_label();
b &= 3;
switch(b) {
case 0: /* loopnz */
case 1: /* loopz */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_add_reg_im(s->aflag, R_ECX, -1);
gen_op_jz_ecx(s->aflag, l3);
gen_compute_eflags(cpu_tmp0);
tcg_gen_andi_tl(cpu_tmp0, cpu_tmp0, CC_Z);
if (b == 0) {
tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, l1);
} else {
tcg_gen_brcondi_tl(TCG_COND_NE, cpu_tmp0, 0, l1);
}
break;
case 2: /* loop */
gen_op_add_reg_im(s->aflag, R_ECX, -1);
gen_op_jnz_ecx(s->aflag, l1);
break;
default:
case 3: /* jcxz */
gen_op_jz_ecx(s->aflag, l1);
break;
}
gen_set_label(l3);
gen_jmp_im(next_eip);
tcg_gen_br(l2);
gen_set_label(l1);
gen_jmp_im(tval);
gen_set_label(l2);
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 (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
if (b & 2) {
gen_helper_rdmsr(cpu_env);
} else {
gen_helper_wrmsr(cpu_env);
}
}
break;
case 0x131: /* rdtsc */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
if (use_icount)
gen_io_start();
gen_helper_rdtsc(cpu_env);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
break;
case 0x133: /* rdpmc */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_rdpmc(cpu_env);
break;
case 0x134: /* sysenter */
/* For Intel SYSENTER is valid on 64-bit */
if (CODE64(s) && cpu_single_env->cpuid_vendor1 != CPUID_VENDOR_INTEL_1)
goto illegal_op;
if (!s->pe) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_update_cc_op(s);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_sysenter(cpu_env);
gen_eob(s);
}
break;
case 0x135: /* sysexit */
/* For Intel SYSEXIT is valid on 64-bit */
if (CODE64(s) && cpu_single_env->cpuid_vendor1 != CPUID_VENDOR_INTEL_1)
goto illegal_op;
if (!s->pe) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_update_cc_op(s);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_sysexit(cpu_env, tcg_const_i32(dflag));
gen_eob(s);
}
break;
#ifdef TARGET_X86_64
case 0x105: /* syscall */
/* XXX: is it usable in real mode ? */
gen_update_cc_op(s);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_syscall(cpu_env, tcg_const_i32(s->pc - pc_start));
gen_eob(s);
break;
case 0x107: /* sysret */
if (!s->pe) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_update_cc_op(s);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_sysret(cpu_env, tcg_const_i32(s->dflag));
/* condition codes are modified only in long mode */
if (s->lma)
s->cc_op = CC_OP_EFLAGS;
gen_eob(s);
}
break;
#endif
case 0x1a2: /* cpuid */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_cpuid(cpu_env);
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_jmp_im(pc_start - s->cs_base);
gen_helper_hlt(cpu_env, tcg_const_i32(s->pc - pc_start));
s->is_jmp = DISAS_TB_JUMP;
}
break;
case 0x100:
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7;
switch(op) {
case 0: /* sldt */
if (!s->pe || s->vm86)
goto illegal_op;
gen_svm_check_intercept(s, pc_start, SVM_EXIT_LDTR_READ);
tcg_gen_ld32u_tl(cpu_T[0], cpu_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_svm_check_intercept(s, pc_start, SVM_EXIT_LDTR_WRITE);
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
gen_jmp_im(pc_start - s->cs_base);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_lldt(cpu_env, cpu_tmp2_i32);
}
break;
case 1: /* str */
if (!s->pe || s->vm86)
goto illegal_op;
gen_svm_check_intercept(s, pc_start, SVM_EXIT_TR_READ);
tcg_gen_ld32u_tl(cpu_T[0], cpu_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_svm_check_intercept(s, pc_start, SVM_EXIT_TR_WRITE);
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
gen_jmp_im(pc_start - s->cs_base);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_ltr(cpu_env, cpu_tmp2_i32);
}
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_helper_verr(cpu_env, cpu_T[0]);
} else {
gen_helper_verw(cpu_env, cpu_T[0]);
}
s->cc_op = CC_OP_EFLAGS;
break;
default:
goto illegal_op;
}
break;
case 0x101:
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7;
rm = modrm & 7;
switch(op) {
case 0: /* sgdt */
if (mod == 3)
goto illegal_op;
gen_svm_check_intercept(s, pc_start, SVM_EXIT_GDTR_READ);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, gdt.limit));
gen_op_st_T0_A0(OT_WORD + s->mem_index);
gen_add_A0_im(s, 2);
tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, gdt.base));
if (!s->dflag)
gen_op_andl_T0_im(0xffffff);
gen_op_st_T0_A0(CODE64(s) + OT_LONG + s->mem_index);
break;
case 1:
if (mod == 3) {
switch (rm) {
case 0: /* monitor */
if (!(s->cpuid_ext_features & CPUID_EXT_MONITOR) ||
s->cpl != 0)
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
#ifdef TARGET_X86_64
if (s->aflag == 2) {
gen_op_movq_A0_reg(R_EAX);
} else
#endif
{
gen_op_movl_A0_reg(R_EAX);
if (s->aflag == 0)
gen_op_andl_A0_ffff();
}
gen_add_A0_ds_seg(s);
gen_helper_monitor(cpu_env, cpu_A0);
break;
case 1: /* mwait */
if (!(s->cpuid_ext_features & CPUID_EXT_MONITOR) ||
s->cpl != 0)
goto illegal_op;
gen_update_cc_op(s);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_mwait(cpu_env, tcg_const_i32(s->pc - pc_start));
gen_eob(s);
break;
default:
goto illegal_op;
}
} else { /* sidt */
gen_svm_check_intercept(s, pc_start, SVM_EXIT_IDTR_READ);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, idt.limit));
gen_op_st_T0_A0(OT_WORD + s->mem_index);
gen_add_A0_im(s, 2);
tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, idt.base));
if (!s->dflag)
gen_op_andl_T0_im(0xffffff);
gen_op_st_T0_A0(CODE64(s) + OT_LONG + s->mem_index);
}
break;
case 2: /* lgdt */
case 3: /* lidt */
if (mod == 3) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
switch(rm) {
case 0: /* VMRUN */
if (!(s->flags & HF_SVME_MASK) || !s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_vmrun(cpu_env, tcg_const_i32(s->aflag),
tcg_const_i32(s->pc - pc_start));
tcg_gen_exit_tb(0);
s->is_jmp = DISAS_TB_JUMP;
}
break;
case 1: /* VMMCALL */
if (!(s->flags & HF_SVME_MASK))
goto illegal_op;
gen_helper_vmmcall(cpu_env);
break;
case 2: /* VMLOAD */
if (!(s->flags & HF_SVME_MASK) || !s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_vmload(cpu_env, tcg_const_i32(s->aflag));
}
break;
case 3: /* VMSAVE */
if (!(s->flags & HF_SVME_MASK) || !s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_vmsave(cpu_env, tcg_const_i32(s->aflag));
}
break;
case 4: /* STGI */
if ((!(s->flags & HF_SVME_MASK) &&
!(s->cpuid_ext3_features & CPUID_EXT3_SKINIT)) ||
!s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_stgi(cpu_env);
}
break;
case 5: /* CLGI */
if (!(s->flags & HF_SVME_MASK) || !s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_clgi(cpu_env);
}
break;
case 6: /* SKINIT */
if ((!(s->flags & HF_SVME_MASK) &&
!(s->cpuid_ext3_features & CPUID_EXT3_SKINIT)) ||
!s->pe)
goto illegal_op;
gen_helper_skinit(cpu_env);
break;
case 7: /* INVLPGA */
if (!(s->flags & HF_SVME_MASK) || !s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_invlpga(cpu_env, tcg_const_i32(s->aflag));
}
break;
default:
goto illegal_op;
}
} else if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_svm_check_intercept(s, pc_start,
op==2 ? SVM_EXIT_GDTR_WRITE : SVM_EXIT_IDTR_WRITE);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T1_A0(OT_WORD + s->mem_index);
gen_add_A0_im(s, 2);
gen_op_ld_T0_A0(CODE64(s) + OT_LONG + s->mem_index);
if (!s->dflag)
gen_op_andl_T0_im(0xffffff);
if (op == 2) {
tcg_gen_st_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,gdt.base));
tcg_gen_st32_tl(cpu_T[1], cpu_env, offsetof(CPUX86State,gdt.limit));
} else {
tcg_gen_st_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,idt.base));
tcg_gen_st32_tl(cpu_T[1], cpu_env, offsetof(CPUX86State,idt.limit));
}
}
break;
case 4: /* smsw */
gen_svm_check_intercept(s, pc_start, SVM_EXIT_READ_CR0);
#if defined TARGET_X86_64 && defined HOST_WORDS_BIGENDIAN
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,cr[0]) + 4);
#else
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,cr[0]));
#endif
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_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_CR0);
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
gen_helper_lmsw(cpu_env, cpu_T[0]);
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 7:
if (mod != 3) { /* invlpg */
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_jmp_im(pc_start - s->cs_base);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_helper_invlpg(cpu_env, cpu_A0);
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
} else {
switch (rm) {
case 0: /* swapgs */
#ifdef TARGET_X86_64
if (CODE64(s)) {
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
tcg_gen_ld_tl(cpu_T[0], cpu_env,
offsetof(CPUX86State,segs[R_GS].base));
tcg_gen_ld_tl(cpu_T[1], cpu_env,
offsetof(CPUX86State,kernelgsbase));
tcg_gen_st_tl(cpu_T[1], cpu_env,
offsetof(CPUX86State,segs[R_GS].base));
tcg_gen_st_tl(cpu_T[0], cpu_env,
offsetof(CPUX86State,kernelgsbase));
}
} else
#endif
{
goto illegal_op;
}
break;
case 1: /* rdtscp */
if (!(s->cpuid_ext2_features & CPUID_EXT2_RDTSCP))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
if (use_icount)
gen_io_start();
gen_helper_rdtscp(cpu_env);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
break;
default:
goto illegal_op;
}
}
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 {
gen_svm_check_intercept(s, pc_start, (b & 2) ? SVM_EXIT_INVD : SVM_EXIT_WBINVD);
/* nothing to do */
}
break;
case 0x63: /* arpl or movslS (x86_64) */
#ifdef TARGET_X86_64
if (CODE64(s)) {
int d_ot;
/* d_ot is the size of destination */
d_ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
if (mod == 3) {
gen_op_mov_TN_reg(OT_LONG, 0, rm);
/* sign extend */
if (d_ot == OT_QUAD)
tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(d_ot, reg);
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (d_ot == OT_QUAD) {
gen_op_lds_T0_A0(OT_LONG + s->mem_index);
} else {
gen_op_ld_T0_A0(OT_LONG + s->mem_index);
}
gen_op_mov_reg_T0(d_ot, reg);
}
} else
#endif
{
int label1;
TCGv t0, t1, t2, a0;
if (!s->pe || s->vm86)
goto illegal_op;
t0 = tcg_temp_local_new();
t1 = tcg_temp_local_new();
t2 = tcg_temp_local_new();
ot = OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, 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_v(ot + s->mem_index, t0, cpu_A0);
a0 = tcg_temp_local_new();
tcg_gen_mov_tl(a0, cpu_A0);
} else {
gen_op_mov_v_reg(ot, t0, rm);
TCGV_UNUSED(a0);
}
gen_op_mov_v_reg(ot, t1, reg);
tcg_gen_andi_tl(cpu_tmp0, t0, 3);
tcg_gen_andi_tl(t1, t1, 3);
tcg_gen_movi_tl(t2, 0);
label1 = gen_new_label();
tcg_gen_brcond_tl(TCG_COND_GE, cpu_tmp0, t1, label1);
tcg_gen_andi_tl(t0, t0, ~3);
tcg_gen_or_tl(t0, t0, t1);
tcg_gen_movi_tl(t2, CC_Z);
gen_set_label(label1);
if (mod != 3) {
gen_op_st_v(ot + s->mem_index, t0, a0);
tcg_temp_free(a0);
} else {
gen_op_mov_reg_v(ot, rm, t0);
}
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_compute_eflags(cpu_cc_src);
tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, ~CC_Z);
tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, t2);
s->cc_op = CC_OP_EFLAGS;
tcg_temp_free(t0);
tcg_temp_free(t1);
tcg_temp_free(t2);
}
break;
case 0x102: /* lar */
case 0x103: /* lsl */
{
int label1;
TCGv t0;
if (!s->pe || s->vm86)
goto illegal_op;
ot = dflag ? OT_LONG : OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
t0 = tcg_temp_local_new();
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
if (b == 0x102) {
gen_helper_lar(t0, cpu_env, cpu_T[0]);
} else {
gen_helper_lsl(t0, cpu_env, cpu_T[0]);
}
tcg_gen_andi_tl(cpu_tmp0, cpu_cc_src, CC_Z);
label1 = gen_new_label();
tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, label1);
gen_op_mov_reg_v(ot, reg, t0);
gen_set_label(label1);
s->cc_op = CC_OP_EFLAGS;
tcg_temp_free(t0);
}
break;
case 0x118:
modrm = cpu_ldub_code(cpu_single_env, 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: /* nop (multi byte) */
gen_nop_modrm(s, modrm);
break;
}
break;
case 0x119 ... 0x11f: /* nop (multi byte) */
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
gen_nop_modrm(s, modrm);
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 = cpu_ldub_code(cpu_single_env, s->pc++);
/* Ignore the mod bits (assume (modrm&0xc0)==0xc0).
* AMD documentation (24594.pdf) and testing of
* intel 386 and 486 processors all show that the mod bits
* are assumed to be 1's, regardless of actual values.
*/
rm = (modrm & 7) | REX_B(s);
reg = ((modrm >> 3) & 7) | rex_r;
if (CODE64(s))
ot = OT_QUAD;
else
ot = OT_LONG;
if ((prefixes & PREFIX_LOCK) && (reg == 0) &&
(s->cpuid_ext3_features & CPUID_EXT3_CR8LEG)) {
reg = 8;
}
switch(reg) {
case 0:
case 2:
case 3:
case 4:
case 8:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
if (b & 2) {
gen_op_mov_TN_reg(ot, 0, rm);
gen_helper_write_crN(cpu_env, tcg_const_i32(reg),
cpu_T[0]);
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
} else {
gen_helper_read_crN(cpu_T[0], cpu_env, tcg_const_i32(reg));
gen_op_mov_reg_T0(ot, 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 = cpu_ldub_code(cpu_single_env, s->pc++);
/* Ignore the mod bits (assume (modrm&0xc0)==0xc0).
* AMD documentation (24594.pdf) and testing of
* intel 386 and 486 processors all show that the mod bits
* are assumed to be 1's, regardless of actual values.
*/
rm = (modrm & 7) | REX_B(s);
reg = ((modrm >> 3) & 7) | rex_r;
if (CODE64(s))
ot = OT_QUAD;
else
ot = OT_LONG;
/* XXX: do it dynamically with CR4.DE bit */
if (reg == 4 || reg == 5 || reg >= 8)
goto illegal_op;
if (b & 2) {
gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_DR0 + reg);
gen_op_mov_TN_reg(ot, 0, rm);
gen_helper_movl_drN_T0(cpu_env, tcg_const_i32(reg), cpu_T[0]);
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
} else {
gen_svm_check_intercept(s, pc_start, SVM_EXIT_READ_DR0 + reg);
tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,dr[reg]));
gen_op_mov_reg_T0(ot, rm);
}
}
break;
case 0x106: /* clts */
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_CR0);
gen_helper_clts(cpu_env);
/* abort block because static cpu state changed */
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
/* MMX/3DNow!/SSE/SSE2/SSE3/SSSE3/SSE4 support */
case 0x1c3: /* MOVNTI reg, mem */
if (!(s->cpuid_features & CPUID_SSE2))
goto illegal_op;
ot = s->dflag == 2 ? OT_QUAD : OT_LONG;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
reg = ((modrm >> 3) & 7) | rex_r;
/* generate a generic store */
gen_ldst_modrm(s, modrm, ot, reg, 1);
break;
case 0x1ae:
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7;
switch(op) {
case 0: /* fxsave */
if (mod == 3 || !(s->cpuid_features & CPUID_FXSR) ||
(s->prefix & PREFIX_LOCK))
goto illegal_op;
if ((s->flags & HF_EM_MASK) || (s->flags & HF_TS_MASK)) {
gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
break;
}
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fxsave(cpu_env, cpu_A0, tcg_const_i32((s->dflag == 2)));
break;
case 1: /* fxrstor */
if (mod == 3 || !(s->cpuid_features & CPUID_FXSR) ||
(s->prefix & PREFIX_LOCK))
goto illegal_op;
if ((s->flags & HF_EM_MASK) || (s->flags & HF_TS_MASK)) {
gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
break;
}
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fxrstor(cpu_env, cpu_A0,
tcg_const_i32((s->dflag == 2)));
break;
case 2: /* ldmxcsr */
case 3: /* stmxcsr */
if (s->flags & HF_TS_MASK) {
gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
break;
}
if ((s->flags & HF_EM_MASK) || !(s->flags & HF_OSFXSR_MASK) ||
mod == 3)
goto illegal_op;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (op == 2) {
gen_op_ld_T0_A0(OT_LONG + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_ldmxcsr(cpu_env, cpu_tmp2_i32);
} else {
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, mxcsr));
gen_op_st_T0_A0(OT_LONG + s->mem_index);
}
break;
case 5: /* lfence */
case 6: /* mfence */
if ((modrm & 0xc7) != 0xc0 || !(s->cpuid_features & CPUID_SSE2))
goto illegal_op;
break;
case 7: /* sfence / clflush */
if ((modrm & 0xc7) == 0xc0) {
/* sfence */
/* XXX: also check for cpuid_ext2_features & CPUID_EXT2_EMMX */
if (!(s->cpuid_features & CPUID_SSE))
goto illegal_op;
} else {
/* clflush */
if (!(s->cpuid_features & CPUID_CLFLUSH))
goto illegal_op;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
}
break;
default:
goto illegal_op;
}
break;
case 0x10d: /* 3DNow! prefetch(w) */
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
/* ignore for now */
break;
case 0x1aa: /* rsm */
gen_svm_check_intercept(s, pc_start, SVM_EXIT_RSM);
if (!(s->flags & HF_SMM_MASK))
goto illegal_op;
gen_update_cc_op(s);
gen_jmp_im(s->pc - s->cs_base);
gen_helper_rsm(cpu_env);
gen_eob(s);
break;
case 0x1b8: /* SSE4.2 popcnt */
if ((prefixes & (PREFIX_REPZ | PREFIX_LOCK | PREFIX_REPNZ)) !=
PREFIX_REPZ)
goto illegal_op;
if (!(s->cpuid_ext_features & CPUID_EXT_POPCNT))
goto illegal_op;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7);
if (s->prefix & PREFIX_DATA)
ot = OT_WORD;
else if (s->dflag != 2)
ot = OT_LONG;
else
ot = OT_QUAD;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_helper_popcnt(cpu_T[0], cpu_env, cpu_T[0], tcg_const_i32(ot));
gen_op_mov_reg_T0(ot, reg);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x10e ... 0x10f:
/* 3DNow! instructions, ignore prefixes */
s->prefix &= ~(PREFIX_REPZ | PREFIX_REPNZ | PREFIX_DATA);
case 0x110 ... 0x117:
case 0x128 ... 0x12f:
case 0x138 ... 0x13a:
case 0x150 ... 0x179:
case 0x17c ... 0x17f:
case 0x1c2:
case 0x1c4 ... 0x1c6:
case 0x1d0 ... 0x1fe:
gen_sse(s, b, pc_start, rex_r);
break;
default:
goto illegal_op;
}
/* lock generation */
if (s->prefix & PREFIX_LOCK)
gen_helper_unlock();
return s->pc;
illegal_op:
if (s->prefix & PREFIX_LOCK)
gen_helper_unlock();
/* XXX: ensure that no lock was generated */
gen_exception(s, EXCP06_ILLOP, pc_start - s->cs_base);
return s->pc;
}
| false | qemu | a9321a4d49d65d29c2926a51aedc5b91a01f3591 | static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
{
int b, prefixes, aflag, dflag;
int shift, ot;
int modrm, reg, rm, mod, reg_addr, op, opreg, offset_addr, val;
target_ulong next_eip, tval;
int rex_w, rex_r;
if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP | CPU_LOG_TB_OP_OPT))) {
tcg_gen_debug_insn_start(pc_start);
}
s->pc = pc_start;
prefixes = 0;
aflag = s->code32;
dflag = s->code32;
s->override = -1;
rex_w = -1;
rex_r = 0;
#ifdef TARGET_X86_64
s->rex_x = 0;
s->rex_b = 0;
x86_64_hregs = 0;
#endif
s->rip_offset = 0;
next_byte:
b = cpu_ldub_code(cpu_single_env, s->pc);
s->pc++;
#ifdef TARGET_X86_64
if (CODE64(s)) {
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;
case 0x40 ... 0x4f:
rex_w = (b >> 3) & 1;
rex_r = (b & 0x4) << 1;
s->rex_x = (b & 0x2) << 2;
REX_B(s) = (b & 0x1) << 3;
x86_64_hregs = 1;
goto next_byte;
}
if (rex_w == 1) {
dflag = 2;
} else {
if (prefixes & PREFIX_DATA)
dflag ^= 1;
}
if (!(prefixes & PREFIX_ADR))
aflag = 2;
} else
#endif
{
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_helper_lock();
reswitch:
switch(b) {
case 0x0f:
b = cpu_ldub_code(cpu_single_env, 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_WORD;
switch(f) {
case 0:
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
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 = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
reg = ((modrm >> 3) & 7) | rex_r;
rm = (modrm & 7) | REX_B(s);
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 0x82:
if (CODE64(s))
goto illegal_op;
case 0x80:
case 0x81:
case 0x83:
{
int val;
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
op = (modrm >> 3) & 7;
if (mod != 3) {
if (b == 0x83)
s->rip_offset = 1;
else
s->rip_offset = insn_const_size(ot);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
opreg = OR_TMP0;
} else {
opreg = rm;
}
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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
op = (modrm >> 3) & 7;
if (mod != 3) {
if (op == 0)
s->rip_offset = insn_const_size(ot);
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:
tcg_gen_not_tl(cpu_T[0], cpu_T[0]);
if (mod != 3) {
gen_op_st_T0_A0(ot + s->mem_index);
} else {
gen_op_mov_reg_T0(ot, rm);
}
break;
case 3:
tcg_gen_neg_tl(cpu_T[0], cpu_T[0]);
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_mov_TN_reg(OT_BYTE, 1, R_EAX);
tcg_gen_ext8u_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext8u_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_WORD, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_andi_tl(cpu_cc_src, cpu_T[0], 0xff00);
s->cc_op = CC_OP_MULB;
break;
case OT_WORD:
gen_op_mov_TN_reg(OT_WORD, 1, R_EAX);
tcg_gen_ext16u_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext16u_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_WORD, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 16);
gen_op_mov_reg_T0(OT_WORD, R_EDX);
tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);
s->cc_op = CC_OP_MULW;
break;
default:
case OT_LONG:
#ifdef TARGET_X86_64
gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);
tcg_gen_ext32u_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext32u_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_LONG, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 32);
gen_op_mov_reg_T0(OT_LONG, R_EDX);
tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);
#else
{
TCGv_i64 t0, t1;
t0 = tcg_temp_new_i64();
t1 = tcg_temp_new_i64();
gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);
tcg_gen_extu_i32_i64(t0, cpu_T[0]);
tcg_gen_extu_i32_i64(t1, cpu_T[1]);
tcg_gen_mul_i64(t0, t0, t1);
tcg_gen_trunc_i64_i32(cpu_T[0], t0);
gen_op_mov_reg_T0(OT_LONG, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_shri_i64(t0, t0, 32);
tcg_gen_trunc_i64_i32(cpu_T[0], t0);
gen_op_mov_reg_T0(OT_LONG, R_EDX);
tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);
}
#endif
s->cc_op = CC_OP_MULL;
break;
#ifdef TARGET_X86_64
case OT_QUAD:
gen_helper_mulq_EAX_T0(cpu_env, cpu_T[0]);
s->cc_op = CC_OP_MULQ;
break;
#endif
}
break;
case 5:
switch(ot) {
case OT_BYTE:
gen_op_mov_TN_reg(OT_BYTE, 1, R_EAX);
tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext8s_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_WORD, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_ext8s_tl(cpu_tmp0, cpu_T[0]);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
s->cc_op = CC_OP_MULB;
break;
case OT_WORD:
gen_op_mov_TN_reg(OT_WORD, 1, R_EAX);
tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext16s_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_WORD, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_ext16s_tl(cpu_tmp0, cpu_T[0]);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 16);
gen_op_mov_reg_T0(OT_WORD, R_EDX);
s->cc_op = CC_OP_MULW;
break;
default:
case OT_LONG:
#ifdef TARGET_X86_64
gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);
tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext32s_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_LONG, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_ext32s_tl(cpu_tmp0, cpu_T[0]);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 32);
gen_op_mov_reg_T0(OT_LONG, R_EDX);
#else
{
TCGv_i64 t0, t1;
t0 = tcg_temp_new_i64();
t1 = tcg_temp_new_i64();
gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);
tcg_gen_ext_i32_i64(t0, cpu_T[0]);
tcg_gen_ext_i32_i64(t1, cpu_T[1]);
tcg_gen_mul_i64(t0, t0, t1);
tcg_gen_trunc_i64_i32(cpu_T[0], t0);
gen_op_mov_reg_T0(OT_LONG, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_sari_tl(cpu_tmp0, cpu_T[0], 31);
tcg_gen_shri_i64(t0, t0, 32);
tcg_gen_trunc_i64_i32(cpu_T[0], t0);
gen_op_mov_reg_T0(OT_LONG, R_EDX);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
}
#endif
s->cc_op = CC_OP_MULL;
break;
#ifdef TARGET_X86_64
case OT_QUAD:
gen_helper_imulq_EAX_T0(cpu_env, cpu_T[0]);
s->cc_op = CC_OP_MULQ;
break;
#endif
}
break;
case 6:
switch(ot) {
case OT_BYTE:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_divb_AL(cpu_env, cpu_T[0]);
break;
case OT_WORD:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_divw_AX(cpu_env, cpu_T[0]);
break;
default:
case OT_LONG:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_divl_EAX(cpu_env, cpu_T[0]);
break;
#ifdef TARGET_X86_64
case OT_QUAD:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_divq_EAX(cpu_env, cpu_T[0]);
break;
#endif
}
break;
case 7:
switch(ot) {
case OT_BYTE:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_idivb_AL(cpu_env, cpu_T[0]);
break;
case OT_WORD:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_idivw_AX(cpu_env, cpu_T[0]);
break;
default:
case OT_LONG:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_idivl_EAX(cpu_env, cpu_T[0]);
break;
#ifdef TARGET_X86_64
case OT_QUAD:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_idivq_EAX(cpu_env, cpu_T[0]);
break;
#endif
}
break;
default:
goto illegal_op;
}
break;
case 0xfe:
case 0xff:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
op = (modrm >> 3) & 7;
if (op >= 2 && b == 0xfe) {
goto illegal_op;
}
if (CODE64(s)) {
if (op == 2 || op == 4) {
ot = OT_QUAD;
} else if (op == 3 || op == 5) {
ot = dflag ? OT_LONG + (rex_w == 1) : OT_WORD;
} else if (op == 6) {
ot = dflag ? OT_QUAD : OT_WORD;
}
}
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_movtl_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_add_A0_im(s, 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_jmp_im(pc_start - s->cs_base);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_lcall_protected(cpu_env, cpu_tmp2_i32, cpu_T[1],
tcg_const_i32(dflag),
tcg_const_i32(s->pc - pc_start));
} else {
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_lcall_real(cpu_env, cpu_tmp2_i32, cpu_T[1],
tcg_const_i32(dflag),
tcg_const_i32(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_add_A0_im(s, 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_jmp_im(pc_start - s->cs_base);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_ljmp_protected(cpu_env, cpu_tmp2_i32, cpu_T[1],
tcg_const_i32(s->pc - pc_start));
} else {
gen_op_movl_seg_T0_vm(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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_mov_TN_reg(ot, 1, reg);
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_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:
#ifdef TARGET_X86_64
if (dflag == 2) {
gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);
tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_QUAD, R_EAX);
} else
#endif
if (dflag == 1) {
gen_op_mov_TN_reg(OT_WORD, 0, R_EAX);
tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_LONG, R_EAX);
} else {
gen_op_mov_TN_reg(OT_BYTE, 0, R_EAX);
tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_WORD, R_EAX);
}
break;
case 0x99:
#ifdef TARGET_X86_64
if (dflag == 2) {
gen_op_mov_TN_reg(OT_QUAD, 0, R_EAX);
tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 63);
gen_op_mov_reg_T0(OT_QUAD, R_EDX);
} else
#endif
if (dflag == 1) {
gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);
tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 31);
gen_op_mov_reg_T0(OT_LONG, R_EDX);
} else {
gen_op_mov_TN_reg(OT_WORD, 0, R_EAX);
tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 15);
gen_op_mov_reg_T0(OT_WORD, R_EDX);
}
break;
case 0x1af:
case 0x69:
case 0x6b:
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
if (b == 0x69)
s->rip_offset = insn_const_size(ot);
else if (b == 0x6b)
s->rip_offset = 1;
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);
}
#ifdef TARGET_X86_64
if (ot == OT_QUAD) {
gen_helper_imulq_T0_T1(cpu_T[0], cpu_env, cpu_T[0], cpu_T[1]);
} else
#endif
if (ot == OT_LONG) {
#ifdef TARGET_X86_64
tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext32s_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_ext32s_tl(cpu_tmp0, cpu_T[0]);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
#else
{
TCGv_i64 t0, t1;
t0 = tcg_temp_new_i64();
t1 = tcg_temp_new_i64();
tcg_gen_ext_i32_i64(t0, cpu_T[0]);
tcg_gen_ext_i32_i64(t1, cpu_T[1]);
tcg_gen_mul_i64(t0, t0, t1);
tcg_gen_trunc_i64_i32(cpu_T[0], t0);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_sari_tl(cpu_tmp0, cpu_T[0], 31);
tcg_gen_shri_i64(t0, t0, 32);
tcg_gen_trunc_i64_i32(cpu_T[1], t0);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[1], cpu_tmp0);
}
#endif
} else {
tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext16s_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_ext16s_tl(cpu_tmp0, cpu_T[0]);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
}
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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3;
if (mod == 3) {
rm = (modrm & 7) | REX_B(s);
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:
{
int label1, label2;
TCGv t0, t1, t2, a0;
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3;
t0 = tcg_temp_local_new();
t1 = tcg_temp_local_new();
t2 = tcg_temp_local_new();
a0 = tcg_temp_local_new();
gen_op_mov_v_reg(ot, t1, reg);
if (mod == 3) {
rm = (modrm & 7) | REX_B(s);
gen_op_mov_v_reg(ot, t0, rm);
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
tcg_gen_mov_tl(a0, cpu_A0);
gen_op_ld_v(ot + s->mem_index, t0, a0);
rm = 0;
}
label1 = gen_new_label();
tcg_gen_sub_tl(t2, cpu_regs[R_EAX], t0);
gen_extu(ot, t2);
tcg_gen_brcondi_tl(TCG_COND_EQ, t2, 0, label1);
label2 = gen_new_label();
if (mod == 3) {
gen_op_mov_reg_v(ot, R_EAX, t0);
tcg_gen_br(label2);
gen_set_label(label1);
gen_op_mov_reg_v(ot, rm, t1);
} else {
gen_op_st_v(ot + s->mem_index, t0, a0);
gen_op_mov_reg_v(ot, R_EAX, t0);
tcg_gen_br(label2);
gen_set_label(label1);
gen_op_st_v(ot + s->mem_index, t1, a0);
}
gen_set_label(label2);
tcg_gen_mov_tl(cpu_cc_src, t0);
tcg_gen_mov_tl(cpu_cc_dst, t2);
s->cc_op = CC_OP_SUBB + ot;
tcg_temp_free(t0);
tcg_temp_free(t1);
tcg_temp_free(t2);
tcg_temp_free(a0);
}
break;
case 0x1c7:
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
if ((mod == 3) || ((modrm & 0x38) != 0x8))
goto illegal_op;
#ifdef TARGET_X86_64
if (dflag == 2) {
if (!(s->cpuid_ext_features & CPUID_EXT_CX16))
goto illegal_op;
gen_jmp_im(pc_start - s->cs_base);
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_helper_cmpxchg16b(cpu_env, cpu_A0);
} else
#endif
{
if (!(s->cpuid_features & CPUID_CX8))
goto illegal_op;
gen_jmp_im(pc_start - s->cs_base);
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_helper_cmpxchg8b(cpu_env, cpu_A0);
}
s->cc_op = CC_OP_EFLAGS;
break;
case 0x50 ... 0x57:
gen_op_mov_TN_reg(OT_LONG, 0, (b & 7) | REX_B(s));
gen_push_T0(s);
break;
case 0x58 ... 0x5f:
if (CODE64(s)) {
ot = dflag ? OT_QUAD : OT_WORD;
} else {
ot = dflag + OT_WORD;
}
gen_pop_T0(s);
gen_pop_update(s);
gen_op_mov_reg_T0(ot, (b & 7) | REX_B(s));
break;
case 0x60:
if (CODE64(s))
goto illegal_op;
gen_pusha(s);
break;
case 0x61:
if (CODE64(s))
goto illegal_op;
gen_popa(s);
break;
case 0x68:
case 0x6a:
if (CODE64(s)) {
ot = dflag ? OT_QUAD : OT_WORD;
} else {
ot = dflag + 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:
if (CODE64(s)) {
ot = dflag ? OT_QUAD : OT_WORD;
} else {
ot = dflag + OT_WORD;
}
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
gen_pop_T0(s);
if (mod == 3) {
gen_pop_update(s);
rm = (modrm & 7) | REX_B(s);
gen_op_mov_reg_T0(ot, rm);
} else {
s->popl_esp_hack = 1 << ot;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
s->popl_esp_hack = 0;
gen_pop_update(s);
}
break;
case 0xc8:
{
int level;
val = cpu_lduw_code(cpu_single_env, s->pc);
s->pc += 2;
level = cpu_ldub_code(cpu_single_env, s->pc++);
gen_enter(s, val, level);
}
break;
case 0xc9:
if (CODE64(s)) {
gen_op_mov_TN_reg(OT_QUAD, 0, R_EBP);
gen_op_mov_reg_T0(OT_QUAD, R_ESP);
} else 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);
if (CODE64(s)) {
ot = dflag ? OT_QUAD : OT_WORD;
} else {
ot = dflag + OT_WORD;
}
gen_op_mov_reg_T0(ot, R_EBP);
gen_pop_update(s);
break;
case 0x06:
case 0x0e:
case 0x16:
case 0x1e:
if (CODE64(s))
goto illegal_op;
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:
if (CODE64(s))
goto illegal_op;
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_helper_set_inhibit_irq(cpu_env);
s->tf = 0;
}
if (s->is_jmp) {
gen_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_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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
gen_ldst_modrm(s, modrm, ot, reg, 1);
break;
case 0xc6:
case 0xc7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
if (mod != 3) {
s->rip_offset = insn_const_size(ot);
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) | REX_B(s));
break;
case 0x8a:
case 0x8b:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = OT_WORD + dflag;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_mov_reg_T0(ot, reg);
break;
case 0x8e:
modrm = cpu_ldub_code(cpu_single_env, 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_helper_set_inhibit_irq(cpu_env);
s->tf = 0;
}
if (s->is_jmp) {
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x8c:
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (reg >= 6)
goto illegal_op;
gen_op_movl_T0_seg(reg);
if (mod == 3)
ot = OT_WORD + dflag;
else
ot = OT_WORD;
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 = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
if (mod == 3) {
gen_op_mov_TN_reg(ot, 0, rm);
switch(ot | (b & 8)) {
case OT_BYTE:
tcg_gen_ext8u_tl(cpu_T[0], cpu_T[0]);
break;
case OT_BYTE | 8:
tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);
break;
case OT_WORD:
tcg_gen_ext16u_tl(cpu_T[0], cpu_T[0]);
break;
default:
case OT_WORD | 8:
tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
reg = ((modrm >> 3) & 7) | rex_r;
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:
{
target_ulong offset_addr;
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag + OT_WORD;
#ifdef TARGET_X86_64
if (s->aflag == 2) {
offset_addr = cpu_ldq_code(cpu_single_env, s->pc);
s->pc += 8;
gen_op_movq_A0_im(offset_addr);
} else
#endif
{
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);
}
gen_add_A0_ds_seg(s);
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:
#ifdef TARGET_X86_64
if (s->aflag == 2) {
gen_op_movq_A0_reg(R_EBX);
gen_op_mov_TN_reg(OT_QUAD, 0, R_EAX);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xff);
tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_T[0]);
} else
#endif
{
gen_op_movl_A0_reg(R_EBX);
gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xff);
tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_T[0]);
if (s->aflag == 0)
gen_op_andl_A0_ffff();
else
tcg_gen_andi_tl(cpu_A0, cpu_A0, 0xffffffff);
}
gen_add_A0_ds_seg(s);
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) | REX_B(s));
break;
case 0xb8 ... 0xbf:
#ifdef TARGET_X86_64
if (dflag == 2) {
uint64_t tmp;
tmp = cpu_ldq_code(cpu_single_env, s->pc);
s->pc += 8;
reg = (b & 7) | REX_B(s);
gen_movtl_T0_im(tmp);
gen_op_mov_reg_T0(OT_QUAD, reg);
} else
#endif
{
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
reg = (b & 7) | REX_B(s);
gen_op_movl_T0_im(val);
gen_op_mov_reg_T0(ot, reg);
}
break;
case 0x91 ... 0x97:
do_xchg_reg_eax:
ot = dflag + OT_WORD;
reg = (b & 7) | REX_B(s);
rm = R_EAX;
goto do_xchg_reg;
case 0x86:
case 0x87:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3;
if (mod == 3) {
rm = (modrm & 7) | REX_B(s);
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_helper_lock();
gen_op_ld_T1_A0(ot + s->mem_index);
gen_op_st_T0_A0(ot + s->mem_index);
if (!(prefixes & PREFIX_LOCK))
gen_helper_unlock();
gen_op_mov_reg_T1(ot, reg);
}
break;
case 0xc4:
if (CODE64(s))
goto illegal_op;
op = R_ES;
goto do_lxx;
case 0xc5:
if (CODE64(s))
goto illegal_op;
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 = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
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_add_A0_im(s, 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_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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7;
if (mod != 3) {
if (shift == 2) {
s->rip_offset = 1;
}
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
opreg = OR_TMP0;
} else {
opreg = (modrm & 7) | REX_B(s);
}
if (shift == 0) {
gen_shift(s, op, ot, opreg, OR_ECX);
} else {
if (shift == 2) {
shift = cpu_ldub_code(cpu_single_env, 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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
reg = ((modrm >> 3) & 7) | rex_r;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
opreg = OR_TMP0;
} else {
opreg = rm;
}
gen_op_mov_TN_reg(ot, 1, reg);
if (shift) {
val = cpu_ldub_code(cpu_single_env, s->pc++);
tcg_gen_movi_tl(cpu_T3, val);
} else {
tcg_gen_mov_tl(cpu_T3, cpu_regs[R_ECX]);
}
gen_shiftd_rm_T1_T3(s, ot, opreg, op);
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 = cpu_ldub_code(cpu_single_env, 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_ld_T0_A0(OT_LONG + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_flds_FT0(cpu_env, cpu_tmp2_i32);
break;
case 1:
gen_op_ld_T0_A0(OT_LONG + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_fildl_FT0(cpu_env, cpu_tmp2_i32);
break;
case 2:
tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
gen_helper_fldl_FT0(cpu_env, cpu_tmp1_i64);
break;
case 3:
default:
gen_op_lds_T0_A0(OT_WORD + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_fildl_FT0(cpu_env, cpu_tmp2_i32);
break;
}
gen_helper_fp_arith_ST0_FT0(op1);
if (op1 == 3) {
gen_helper_fpop(cpu_env);
}
}
break;
case 0x08:
case 0x0a:
case 0x0b:
case 0x18 ... 0x1b:
case 0x28 ... 0x2b:
case 0x38 ... 0x3b:
switch(op & 7) {
case 0:
switch(op >> 4) {
case 0:
gen_op_ld_T0_A0(OT_LONG + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_flds_ST0(cpu_env, cpu_tmp2_i32);
break;
case 1:
gen_op_ld_T0_A0(OT_LONG + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_fildl_ST0(cpu_env, cpu_tmp2_i32);
break;
case 2:
tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
gen_helper_fldl_ST0(cpu_env, cpu_tmp1_i64);
break;
case 3:
default:
gen_op_lds_T0_A0(OT_WORD + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_fildl_ST0(cpu_env, cpu_tmp2_i32);
break;
}
break;
case 1:
switch(op >> 4) {
case 1:
gen_helper_fisttl_ST0(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_LONG + s->mem_index);
break;
case 2:
gen_helper_fisttll_ST0(cpu_tmp1_i64, cpu_env);
tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
break;
case 3:
default:
gen_helper_fistt_ST0(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_WORD + s->mem_index);
break;
}
gen_helper_fpop(cpu_env);
break;
default:
switch(op >> 4) {
case 0:
gen_helper_fsts_ST0(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_LONG + s->mem_index);
break;
case 1:
gen_helper_fistl_ST0(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_LONG + s->mem_index);
break;
case 2:
gen_helper_fstl_ST0(cpu_tmp1_i64, cpu_env);
tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
break;
case 3:
default:
gen_helper_fist_ST0(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_WORD + s->mem_index);
break;
}
if ((op & 7) == 3)
gen_helper_fpop(cpu_env);
break;
}
break;
case 0x0c:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fldenv(cpu_env, cpu_A0, tcg_const_i32(s->dflag));
break;
case 0x0d:
gen_op_ld_T0_A0(OT_WORD + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_fldcw(cpu_env, cpu_tmp2_i32);
break;
case 0x0e:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fstenv(cpu_env, cpu_A0, tcg_const_i32(s->dflag));
break;
case 0x0f:
gen_helper_fnstcw(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_WORD + s->mem_index);
break;
case 0x1d:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fldt_ST0(cpu_env, cpu_A0);
break;
case 0x1f:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fstt_ST0(cpu_env, cpu_A0);
gen_helper_fpop(cpu_env);
break;
case 0x2c:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_frstor(cpu_env, cpu_A0, tcg_const_i32(s->dflag));
break;
case 0x2e:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fsave(cpu_env, cpu_A0, tcg_const_i32(s->dflag));
break;
case 0x2f:
gen_helper_fnstsw(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_WORD + s->mem_index);
break;
case 0x3c:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fbld_ST0(cpu_env, cpu_A0);
break;
case 0x3e:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fbst_ST0(cpu_env, cpu_A0);
gen_helper_fpop(cpu_env);
break;
case 0x3d:
tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
gen_helper_fildll_ST0(cpu_env, cpu_tmp1_i64);
break;
case 0x3f:
gen_helper_fistll_ST0(cpu_tmp1_i64, cpu_env);
tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
gen_helper_fpop(cpu_env);
break;
default:
goto illegal_op;
}
} else {
opreg = rm;
switch(op) {
case 0x08:
gen_helper_fpush(cpu_env);
gen_helper_fmov_ST0_STN(cpu_env,
tcg_const_i32((opreg + 1) & 7));
break;
case 0x09:
case 0x29:
case 0x39:
gen_helper_fxchg_ST0_STN(cpu_env, tcg_const_i32(opreg));
break;
case 0x0a:
switch(rm) {
case 0:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fwait(cpu_env);
break;
default:
goto illegal_op;
}
break;
case 0x0c:
switch(rm) {
case 0:
gen_helper_fchs_ST0(cpu_env);
break;
case 1:
gen_helper_fabs_ST0(cpu_env);
break;
case 4:
gen_helper_fldz_FT0(cpu_env);
gen_helper_fcom_ST0_FT0(cpu_env);
break;
case 5:
gen_helper_fxam_ST0(cpu_env);
break;
default:
goto illegal_op;
}
break;
case 0x0d:
{
switch(rm) {
case 0:
gen_helper_fpush(cpu_env);
gen_helper_fld1_ST0(cpu_env);
break;
case 1:
gen_helper_fpush(cpu_env);
gen_helper_fldl2t_ST0(cpu_env);
break;
case 2:
gen_helper_fpush(cpu_env);
gen_helper_fldl2e_ST0(cpu_env);
break;
case 3:
gen_helper_fpush(cpu_env);
gen_helper_fldpi_ST0(cpu_env);
break;
case 4:
gen_helper_fpush(cpu_env);
gen_helper_fldlg2_ST0(cpu_env);
break;
case 5:
gen_helper_fpush(cpu_env);
gen_helper_fldln2_ST0(cpu_env);
break;
case 6:
gen_helper_fpush(cpu_env);
gen_helper_fldz_ST0(cpu_env);
break;
default:
goto illegal_op;
}
}
break;
case 0x0e:
switch(rm) {
case 0:
gen_helper_f2xm1(cpu_env);
break;
case 1:
gen_helper_fyl2x(cpu_env);
break;
case 2:
gen_helper_fptan(cpu_env);
break;
case 3:
gen_helper_fpatan(cpu_env);
break;
case 4:
gen_helper_fxtract(cpu_env);
break;
case 5:
gen_helper_fprem1(cpu_env);
break;
case 6:
gen_helper_fdecstp(cpu_env);
break;
default:
case 7:
gen_helper_fincstp(cpu_env);
break;
}
break;
case 0x0f:
switch(rm) {
case 0:
gen_helper_fprem(cpu_env);
break;
case 1:
gen_helper_fyl2xp1(cpu_env);
break;
case 2:
gen_helper_fsqrt(cpu_env);
break;
case 3:
gen_helper_fsincos(cpu_env);
break;
case 5:
gen_helper_fscale(cpu_env);
break;
case 4:
gen_helper_frndint(cpu_env);
break;
case 6:
gen_helper_fsin(cpu_env);
break;
default:
case 7:
gen_helper_fcos(cpu_env);
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_helper_fp_arith_STN_ST0(op1, opreg);
if (op >= 0x30)
gen_helper_fpop(cpu_env);
} else {
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fp_arith_ST0_FT0(op1);
}
}
break;
case 0x02:
case 0x22:
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fcom_ST0_FT0(cpu_env);
break;
case 0x03:
case 0x23:
case 0x32:
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fcom_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
break;
case 0x15:
switch(rm) {
case 1:
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(1));
gen_helper_fucom_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
gen_helper_fpop(cpu_env);
break;
default:
goto illegal_op;
}
break;
case 0x1c:
switch(rm) {
case 0:
break;
case 1:
break;
case 2:
gen_helper_fclex(cpu_env);
break;
case 3:
gen_helper_fninit(cpu_env);
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_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fucomi_ST0_FT0(cpu_env);
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_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fcomi_ST0_FT0(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x28:
gen_helper_ffree_STN(cpu_env, tcg_const_i32(opreg));
break;
case 0x2a:
gen_helper_fmov_STN_ST0(cpu_env, tcg_const_i32(opreg));
break;
case 0x2b:
case 0x0b:
case 0x3a:
case 0x3b:
gen_helper_fmov_STN_ST0(cpu_env, tcg_const_i32(opreg));
gen_helper_fpop(cpu_env);
break;
case 0x2c:
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fucom_ST0_FT0(cpu_env);
break;
case 0x2d:
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fucom_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
break;
case 0x33:
switch(rm) {
case 1:
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(1));
gen_helper_fcom_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
gen_helper_fpop(cpu_env);
break;
default:
goto illegal_op;
}
break;
case 0x38:
gen_helper_ffree_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fpop(cpu_env);
break;
case 0x3c:
switch(rm) {
case 0:
gen_helper_fnstsw(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_mov_reg_T0(OT_WORD, R_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_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fucomi_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
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_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(opreg));
gen_helper_fcomi_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x10 ... 0x13:
case 0x18 ... 0x1b:
{
int op1, l1;
static const 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) ^ 1);
l1 = gen_new_label();
gen_jcc1(s, s->cc_op, op1, l1);
gen_helper_fmov_ST0_STN(cpu_env, tcg_const_i32(opreg));
gen_set_label(l1);
}
break;
default:
goto illegal_op;
}
}
break;
case 0xa4:
case 0xa5:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag + 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_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_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_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_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_op_mov_TN_reg(OT_WORD, 0, R_EDX);
gen_op_andl_T0_ffff();
gen_check_io(s, ot, pc_start - s->cs_base,
SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes) | 4);
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);
if (use_icount) {
gen_jmp(s, s->pc - s->cs_base);
}
}
break;
case 0x6e:
case 0x6f:
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, pc_start - s->cs_base,
svm_is_rep(prefixes) | 4);
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);
if (use_icount) {
gen_jmp(s, s->pc - s->cs_base);
}
}
break;
case 0xe4:
case 0xe5:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
val = cpu_ldub_code(cpu_single_env, s->pc++);
gen_op_movl_T0_im(val);
gen_check_io(s, ot, pc_start - s->cs_base,
SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes));
if (use_icount)
gen_io_start();
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_in_func(ot, cpu_T[1], cpu_tmp2_i32);
gen_op_mov_reg_T1(ot, R_EAX);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
break;
case 0xe6:
case 0xe7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
val = cpu_ldub_code(cpu_single_env, s->pc++);
gen_op_movl_T0_im(val);
gen_check_io(s, ot, pc_start - s->cs_base,
svm_is_rep(prefixes));
gen_op_mov_TN_reg(ot, 1, R_EAX);
if (use_icount)
gen_io_start();
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[1]);
gen_helper_out_func(ot, cpu_tmp2_i32, cpu_tmp3_i32);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
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, pc_start - s->cs_base,
SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes));
if (use_icount)
gen_io_start();
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_in_func(ot, cpu_T[1], cpu_tmp2_i32);
gen_op_mov_reg_T1(ot, R_EAX);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
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, pc_start - s->cs_base,
svm_is_rep(prefixes));
gen_op_mov_TN_reg(ot, 1, R_EAX);
if (use_icount)
gen_io_start();
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[1]);
gen_helper_out_func(ot, cpu_tmp2_i32, cpu_tmp3_i32);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
break;
case 0xc2:
val = cpu_ldsw_code(cpu_single_env, s->pc);
s->pc += 2;
gen_pop_T0(s);
if (CODE64(s) && s->dflag)
s->dflag = 2;
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 = cpu_ldsw_code(cpu_single_env, 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_jmp_im(pc_start - s->cs_base);
gen_helper_lret_protected(cpu_env, tcg_const_i32(s->dflag),
tcg_const_i32(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(R_CS);
gen_stack_update(s, val + (4 << s->dflag));
}
gen_eob(s);
break;
case 0xcb:
val = 0;
goto do_lret;
case 0xcf:
gen_svm_check_intercept(s, pc_start, SVM_EXIT_IRET);
if (!s->pe) {
gen_helper_iret_real(cpu_env, tcg_const_i32(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_helper_iret_real(cpu_env, tcg_const_i32(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_jmp_im(pc_start - s->cs_base);
gen_helper_iret_protected(cpu_env, tcg_const_i32(s->dflag),
tcg_const_i32(s->pc - s->cs_base));
s->cc_op = CC_OP_EFLAGS;
}
gen_eob(s);
break;
case 0xe8:
{
if (dflag)
tval = (int32_t)insn_get(s, OT_LONG);
else
tval = (int16_t)insn_get(s, OT_WORD);
next_eip = s->pc - s->cs_base;
tval += next_eip;
if (s->dflag == 0)
tval &= 0xffff;
else if(!CODE64(s))
tval &= 0xffffffff;
gen_movtl_T0_im(next_eip);
gen_push_T0(s);
gen_jmp(s, tval);
}
break;
case 0x9a:
{
unsigned int selector, offset;
if (CODE64(s))
goto illegal_op;
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_imu(offset);
}
goto do_lcall;
case 0xe9:
if (dflag)
tval = (int32_t)insn_get(s, OT_LONG);
else
tval = (int16_t)insn_get(s, OT_WORD);
tval += s->pc - s->cs_base;
if (s->dflag == 0)
tval &= 0xffff;
else if(!CODE64(s))
tval &= 0xffffffff;
gen_jmp(s, tval);
break;
case 0xea:
{
unsigned int selector, offset;
if (CODE64(s))
goto illegal_op;
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_imu(offset);
}
goto do_ljmp;
case 0xeb:
tval = (int8_t)insn_get(s, OT_BYTE);
tval += s->pc - s->cs_base;
if (s->dflag == 0)
tval &= 0xffff;
gen_jmp(s, tval);
break;
case 0x70 ... 0x7f:
tval = (int8_t)insn_get(s, OT_BYTE);
goto do_jcc;
case 0x180 ... 0x18f:
if (dflag) {
tval = (int32_t)insn_get(s, OT_LONG);
} else {
tval = (int16_t)insn_get(s, OT_WORD);
}
do_jcc:
next_eip = s->pc - s->cs_base;
tval += next_eip;
if (s->dflag == 0)
tval &= 0xffff;
gen_jcc(s, b, tval, next_eip);
break;
case 0x190 ... 0x19f:
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
gen_setcc(s, b);
gen_ldst_modrm(s, modrm, OT_BYTE, OR_TMP0, 1);
break;
case 0x140 ... 0x14f:
{
int l1;
TCGv t0;
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3;
t0 = tcg_temp_local_new();
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_v(ot + s->mem_index, t0, cpu_A0);
} else {
rm = (modrm & 7) | REX_B(s);
gen_op_mov_v_reg(ot, t0, rm);
}
#ifdef TARGET_X86_64
if (ot == OT_LONG) {
l1 = gen_new_label();
gen_jcc1(s, s->cc_op, b ^ 1, l1);
tcg_gen_mov_tl(cpu_regs[reg], t0);
gen_set_label(l1);
tcg_gen_ext32u_tl(cpu_regs[reg], cpu_regs[reg]);
} else
#endif
{
l1 = gen_new_label();
gen_jcc1(s, s->cc_op, b ^ 1, l1);
gen_op_mov_reg_v(ot, reg, t0);
gen_set_label(l1);
}
tcg_temp_free(t0);
}
break;
case 0x9c:
gen_svm_check_intercept(s, pc_start, SVM_EXIT_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_helper_read_eflags(cpu_T[0], cpu_env);
gen_push_T0(s);
}
break;
case 0x9d:
gen_svm_check_intercept(s, pc_start, SVM_EXIT_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_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK | AC_MASK |
ID_MASK | NT_MASK |
IF_MASK |
IOPL_MASK)));
} else {
gen_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK | AC_MASK |
ID_MASK | NT_MASK |
IF_MASK | IOPL_MASK)
& 0xffff));
}
} else {
if (s->cpl <= s->iopl) {
if (s->dflag) {
gen_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK |
AC_MASK |
ID_MASK |
NT_MASK |
IF_MASK)));
} else {
gen_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK |
AC_MASK |
ID_MASK |
NT_MASK |
IF_MASK)
& 0xffff));
}
} else {
if (s->dflag) {
gen_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK | AC_MASK |
ID_MASK | NT_MASK)));
} else {
gen_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK | AC_MASK |
ID_MASK | NT_MASK)
& 0xffff));
}
}
}
gen_pop_update(s);
s->cc_op = CC_OP_EFLAGS;
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x9e:
if (CODE64(s) && !(s->cpuid_ext3_features & CPUID_EXT3_LAHF_LM))
goto illegal_op;
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_compute_eflags(cpu_cc_src);
tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, CC_O);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], CC_S | CC_Z | CC_A | CC_P | CC_C);
tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, cpu_T[0]);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x9f:
if (CODE64(s) && !(s->cpuid_ext3_features & CPUID_EXT3_LAHF_LM))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_compute_eflags(cpu_T[0]);
tcg_gen_ori_tl(cpu_T[0], cpu_T[0], 0x02);
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_compute_eflags(cpu_cc_src);
tcg_gen_xori_tl(cpu_cc_src, cpu_cc_src, CC_C);
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_compute_eflags(cpu_cc_src);
tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, ~CC_C);
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_compute_eflags(cpu_cc_src);
tcg_gen_ori_tl(cpu_cc_src, cpu_cc_src, CC_C);
s->cc_op = CC_OP_EFLAGS;
break;
case 0xfc:
tcg_gen_movi_i32(cpu_tmp2_i32, 1);
tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, offsetof(CPUX86State, df));
break;
case 0xfd:
tcg_gen_movi_i32(cpu_tmp2_i32, -1);
tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, offsetof(CPUX86State, df));
break;
case 0x1ba:
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
op = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
if (mod != 3) {
s->rip_offset = 1;
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 = cpu_ldub_code(cpu_single_env, s->pc++);
gen_op_movl_T1_im(val);
if (op < 4)
goto illegal_op;
op -= 4;
goto bt_op;
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_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
gen_op_mov_TN_reg(OT_LONG, 1, reg);
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_exts(ot, cpu_T[1]);
tcg_gen_sari_tl(cpu_tmp0, cpu_T[1], 3 + ot);
tcg_gen_shli_tl(cpu_tmp0, cpu_tmp0, ot);
tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
gen_op_ld_T0_A0(ot + s->mem_index);
} else {
gen_op_mov_TN_reg(ot, 0, rm);
}
bt_op:
tcg_gen_andi_tl(cpu_T[1], cpu_T[1], (1 << (3 + ot)) - 1);
switch(op) {
case 0:
tcg_gen_shr_tl(cpu_cc_src, cpu_T[0], cpu_T[1]);
tcg_gen_movi_tl(cpu_cc_dst, 0);
break;
case 1:
tcg_gen_shr_tl(cpu_tmp4, cpu_T[0], cpu_T[1]);
tcg_gen_movi_tl(cpu_tmp0, 1);
tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);
tcg_gen_or_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
break;
case 2:
tcg_gen_shr_tl(cpu_tmp4, cpu_T[0], cpu_T[1]);
tcg_gen_movi_tl(cpu_tmp0, 1);
tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);
tcg_gen_not_tl(cpu_tmp0, cpu_tmp0);
tcg_gen_and_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
break;
default:
case 3:
tcg_gen_shr_tl(cpu_tmp4, cpu_T[0], cpu_T[1]);
tcg_gen_movi_tl(cpu_tmp0, 1);
tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);
tcg_gen_xor_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
break;
}
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);
tcg_gen_mov_tl(cpu_cc_src, cpu_tmp4);
tcg_gen_movi_tl(cpu_cc_dst, 0);
}
break;
case 0x1bc:
case 0x1bd:
{
int label1;
TCGv t0;
ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
gen_ldst_modrm(s,modrm, ot, OR_TMP0, 0);
gen_extu(ot, cpu_T[0]);
t0 = tcg_temp_local_new();
tcg_gen_mov_tl(t0, cpu_T[0]);
if ((b & 1) && (prefixes & PREFIX_REPZ) &&
(s->cpuid_ext3_features & CPUID_EXT3_ABM)) {
switch(ot) {
case OT_WORD: gen_helper_lzcnt(cpu_T[0], t0,
tcg_const_i32(16)); break;
case OT_LONG: gen_helper_lzcnt(cpu_T[0], t0,
tcg_const_i32(32)); break;
case OT_QUAD: gen_helper_lzcnt(cpu_T[0], t0,
tcg_const_i32(64)); break;
}
gen_op_mov_reg_T0(ot, reg);
} else {
label1 = gen_new_label();
tcg_gen_movi_tl(cpu_cc_dst, 0);
tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, label1);
if (b & 1) {
gen_helper_bsr(cpu_T[0], t0);
} else {
gen_helper_bsf(cpu_T[0], t0);
}
gen_op_mov_reg_T0(ot, reg);
tcg_gen_movi_tl(cpu_cc_dst, 1);
gen_set_label(label1);
tcg_gen_discard_tl(cpu_cc_src);
s->cc_op = CC_OP_LOGICB + ot;
}
tcg_temp_free(t0);
}
break;
case 0x27:
if (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_helper_daa(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x2f:
if (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_helper_das(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x37:
if (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_helper_aaa(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x3f:
if (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_helper_aas(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0xd4:
if (CODE64(s))
goto illegal_op;
val = cpu_ldub_code(cpu_single_env, s->pc++);
if (val == 0) {
gen_exception(s, EXCP00_DIVZ, pc_start - s->cs_base);
} else {
gen_helper_aam(cpu_env, tcg_const_i32(val));
s->cc_op = CC_OP_LOGICB;
}
break;
case 0xd5:
if (CODE64(s))
goto illegal_op;
val = cpu_ldub_code(cpu_single_env, s->pc++);
gen_helper_aad(cpu_env, tcg_const_i32(val));
s->cc_op = CC_OP_LOGICB;
break;
case 0x90:
if (prefixes & PREFIX_LOCK) {
goto illegal_op;
}
if (REX_B(s)) {
goto do_xchg_reg_eax;
}
if (prefixes & PREFIX_REPZ) {
gen_svm_check_intercept(s, pc_start, SVM_EXIT_PAUSE);
}
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_jmp_im(pc_start - s->cs_base);
gen_helper_fwait(cpu_env);
}
break;
case 0xcc:
gen_interrupt(s, EXCP03_INT3, pc_start - s->cs_base, s->pc - s->cs_base);
break;
case 0xcd:
val = cpu_ldub_code(cpu_single_env, 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 (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_into(cpu_env, tcg_const_i32(s->pc - pc_start));
break;
#ifdef WANT_ICEBP
case 0xf1:
gen_svm_check_intercept(s, pc_start, SVM_EXIT_ICEBP);
#if 1
gen_debug(s, pc_start - s->cs_base);
#else
tb_flush(cpu_single_env);
cpu_set_log(CPU_LOG_INT | CPU_LOG_TB_IN_ASM);
#endif
break;
#endif
case 0xfa:
if (!s->vm86) {
if (s->cpl <= s->iopl) {
gen_helper_cli(cpu_env);
} else {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
}
} else {
if (s->iopl == 3) {
gen_helper_cli(cpu_env);
} 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_helper_sti(cpu_env);
if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
gen_helper_set_inhibit_irq(cpu_env);
gen_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:
if (CODE64(s))
goto illegal_op;
ot = dflag ? OT_LONG : OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
gen_op_mov_TN_reg(ot, 0, reg);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_jmp_im(pc_start - s->cs_base);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
if (ot == OT_WORD) {
gen_helper_boundw(cpu_env, cpu_A0, cpu_tmp2_i32);
} else {
gen_helper_boundl(cpu_env, cpu_A0, cpu_tmp2_i32);
}
break;
case 0x1c8 ... 0x1cf:
reg = (b & 7) | REX_B(s);
#ifdef TARGET_X86_64
if (dflag == 2) {
gen_op_mov_TN_reg(OT_QUAD, 0, reg);
tcg_gen_bswap64_i64(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_QUAD, reg);
} else
#endif
{
gen_op_mov_TN_reg(OT_LONG, 0, reg);
tcg_gen_ext32u_tl(cpu_T[0], cpu_T[0]);
tcg_gen_bswap32_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_LONG, reg);
}
break;
case 0xd6:
if (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_compute_eflags_c(cpu_T[0]);
tcg_gen_neg_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_BYTE, R_EAX);
break;
case 0xe0:
case 0xe1:
case 0xe2:
case 0xe3:
{
int l1, l2, l3;
tval = (int8_t)insn_get(s, OT_BYTE);
next_eip = s->pc - s->cs_base;
tval += next_eip;
if (s->dflag == 0)
tval &= 0xffff;
l1 = gen_new_label();
l2 = gen_new_label();
l3 = gen_new_label();
b &= 3;
switch(b) {
case 0:
case 1:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_add_reg_im(s->aflag, R_ECX, -1);
gen_op_jz_ecx(s->aflag, l3);
gen_compute_eflags(cpu_tmp0);
tcg_gen_andi_tl(cpu_tmp0, cpu_tmp0, CC_Z);
if (b == 0) {
tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, l1);
} else {
tcg_gen_brcondi_tl(TCG_COND_NE, cpu_tmp0, 0, l1);
}
break;
case 2:
gen_op_add_reg_im(s->aflag, R_ECX, -1);
gen_op_jnz_ecx(s->aflag, l1);
break;
default:
case 3:
gen_op_jz_ecx(s->aflag, l1);
break;
}
gen_set_label(l3);
gen_jmp_im(next_eip);
tcg_gen_br(l2);
gen_set_label(l1);
gen_jmp_im(tval);
gen_set_label(l2);
gen_eob(s);
}
break;
case 0x130:
case 0x132:
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_jmp_im(pc_start - s->cs_base);
if (b & 2) {
gen_helper_rdmsr(cpu_env);
} else {
gen_helper_wrmsr(cpu_env);
}
}
break;
case 0x131:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
if (use_icount)
gen_io_start();
gen_helper_rdtsc(cpu_env);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
break;
case 0x133:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_rdpmc(cpu_env);
break;
case 0x134:
if (CODE64(s) && cpu_single_env->cpuid_vendor1 != CPUID_VENDOR_INTEL_1)
goto illegal_op;
if (!s->pe) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_update_cc_op(s);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_sysenter(cpu_env);
gen_eob(s);
}
break;
case 0x135:
if (CODE64(s) && cpu_single_env->cpuid_vendor1 != CPUID_VENDOR_INTEL_1)
goto illegal_op;
if (!s->pe) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_update_cc_op(s);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_sysexit(cpu_env, tcg_const_i32(dflag));
gen_eob(s);
}
break;
#ifdef TARGET_X86_64
case 0x105:
gen_update_cc_op(s);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_syscall(cpu_env, tcg_const_i32(s->pc - pc_start));
gen_eob(s);
break;
case 0x107:
if (!s->pe) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_update_cc_op(s);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_sysret(cpu_env, tcg_const_i32(s->dflag));
if (s->lma)
s->cc_op = CC_OP_EFLAGS;
gen_eob(s);
}
break;
#endif
case 0x1a2:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_cpuid(cpu_env);
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_jmp_im(pc_start - s->cs_base);
gen_helper_hlt(cpu_env, tcg_const_i32(s->pc - pc_start));
s->is_jmp = DISAS_TB_JUMP;
}
break;
case 0x100:
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7;
switch(op) {
case 0:
if (!s->pe || s->vm86)
goto illegal_op;
gen_svm_check_intercept(s, pc_start, SVM_EXIT_LDTR_READ);
tcg_gen_ld32u_tl(cpu_T[0], cpu_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_svm_check_intercept(s, pc_start, SVM_EXIT_LDTR_WRITE);
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
gen_jmp_im(pc_start - s->cs_base);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_lldt(cpu_env, cpu_tmp2_i32);
}
break;
case 1:
if (!s->pe || s->vm86)
goto illegal_op;
gen_svm_check_intercept(s, pc_start, SVM_EXIT_TR_READ);
tcg_gen_ld32u_tl(cpu_T[0], cpu_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_svm_check_intercept(s, pc_start, SVM_EXIT_TR_WRITE);
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
gen_jmp_im(pc_start - s->cs_base);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_ltr(cpu_env, cpu_tmp2_i32);
}
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_helper_verr(cpu_env, cpu_T[0]);
} else {
gen_helper_verw(cpu_env, cpu_T[0]);
}
s->cc_op = CC_OP_EFLAGS;
break;
default:
goto illegal_op;
}
break;
case 0x101:
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7;
rm = modrm & 7;
switch(op) {
case 0:
if (mod == 3)
goto illegal_op;
gen_svm_check_intercept(s, pc_start, SVM_EXIT_GDTR_READ);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, gdt.limit));
gen_op_st_T0_A0(OT_WORD + s->mem_index);
gen_add_A0_im(s, 2);
tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, gdt.base));
if (!s->dflag)
gen_op_andl_T0_im(0xffffff);
gen_op_st_T0_A0(CODE64(s) + OT_LONG + s->mem_index);
break;
case 1:
if (mod == 3) {
switch (rm) {
case 0:
if (!(s->cpuid_ext_features & CPUID_EXT_MONITOR) ||
s->cpl != 0)
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
#ifdef TARGET_X86_64
if (s->aflag == 2) {
gen_op_movq_A0_reg(R_EAX);
} else
#endif
{
gen_op_movl_A0_reg(R_EAX);
if (s->aflag == 0)
gen_op_andl_A0_ffff();
}
gen_add_A0_ds_seg(s);
gen_helper_monitor(cpu_env, cpu_A0);
break;
case 1:
if (!(s->cpuid_ext_features & CPUID_EXT_MONITOR) ||
s->cpl != 0)
goto illegal_op;
gen_update_cc_op(s);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_mwait(cpu_env, tcg_const_i32(s->pc - pc_start));
gen_eob(s);
break;
default:
goto illegal_op;
}
} else {
gen_svm_check_intercept(s, pc_start, SVM_EXIT_IDTR_READ);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, idt.limit));
gen_op_st_T0_A0(OT_WORD + s->mem_index);
gen_add_A0_im(s, 2);
tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, idt.base));
if (!s->dflag)
gen_op_andl_T0_im(0xffffff);
gen_op_st_T0_A0(CODE64(s) + OT_LONG + s->mem_index);
}
break;
case 2:
case 3:
if (mod == 3) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
switch(rm) {
case 0:
if (!(s->flags & HF_SVME_MASK) || !s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_vmrun(cpu_env, tcg_const_i32(s->aflag),
tcg_const_i32(s->pc - pc_start));
tcg_gen_exit_tb(0);
s->is_jmp = DISAS_TB_JUMP;
}
break;
case 1:
if (!(s->flags & HF_SVME_MASK))
goto illegal_op;
gen_helper_vmmcall(cpu_env);
break;
case 2:
if (!(s->flags & HF_SVME_MASK) || !s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_vmload(cpu_env, tcg_const_i32(s->aflag));
}
break;
case 3:
if (!(s->flags & HF_SVME_MASK) || !s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_vmsave(cpu_env, tcg_const_i32(s->aflag));
}
break;
case 4:
if ((!(s->flags & HF_SVME_MASK) &&
!(s->cpuid_ext3_features & CPUID_EXT3_SKINIT)) ||
!s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_stgi(cpu_env);
}
break;
case 5:
if (!(s->flags & HF_SVME_MASK) || !s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_clgi(cpu_env);
}
break;
case 6:
if ((!(s->flags & HF_SVME_MASK) &&
!(s->cpuid_ext3_features & CPUID_EXT3_SKINIT)) ||
!s->pe)
goto illegal_op;
gen_helper_skinit(cpu_env);
break;
case 7:
if (!(s->flags & HF_SVME_MASK) || !s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_invlpga(cpu_env, tcg_const_i32(s->aflag));
}
break;
default:
goto illegal_op;
}
} else if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_svm_check_intercept(s, pc_start,
op==2 ? SVM_EXIT_GDTR_WRITE : SVM_EXIT_IDTR_WRITE);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T1_A0(OT_WORD + s->mem_index);
gen_add_A0_im(s, 2);
gen_op_ld_T0_A0(CODE64(s) + OT_LONG + s->mem_index);
if (!s->dflag)
gen_op_andl_T0_im(0xffffff);
if (op == 2) {
tcg_gen_st_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,gdt.base));
tcg_gen_st32_tl(cpu_T[1], cpu_env, offsetof(CPUX86State,gdt.limit));
} else {
tcg_gen_st_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,idt.base));
tcg_gen_st32_tl(cpu_T[1], cpu_env, offsetof(CPUX86State,idt.limit));
}
}
break;
case 4:
gen_svm_check_intercept(s, pc_start, SVM_EXIT_READ_CR0);
#if defined TARGET_X86_64 && defined HOST_WORDS_BIGENDIAN
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,cr[0]) + 4);
#else
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,cr[0]));
#endif
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_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_CR0);
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
gen_helper_lmsw(cpu_env, cpu_T[0]);
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 7:
if (mod != 3) {
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_jmp_im(pc_start - s->cs_base);
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_helper_invlpg(cpu_env, cpu_A0);
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
} else {
switch (rm) {
case 0:
#ifdef TARGET_X86_64
if (CODE64(s)) {
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
tcg_gen_ld_tl(cpu_T[0], cpu_env,
offsetof(CPUX86State,segs[R_GS].base));
tcg_gen_ld_tl(cpu_T[1], cpu_env,
offsetof(CPUX86State,kernelgsbase));
tcg_gen_st_tl(cpu_T[1], cpu_env,
offsetof(CPUX86State,segs[R_GS].base));
tcg_gen_st_tl(cpu_T[0], cpu_env,
offsetof(CPUX86State,kernelgsbase));
}
} else
#endif
{
goto illegal_op;
}
break;
case 1:
if (!(s->cpuid_ext2_features & CPUID_EXT2_RDTSCP))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
if (use_icount)
gen_io_start();
gen_helper_rdtscp(cpu_env);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
break;
default:
goto illegal_op;
}
}
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 {
gen_svm_check_intercept(s, pc_start, (b & 2) ? SVM_EXIT_INVD : SVM_EXIT_WBINVD);
}
break;
case 0x63:
#ifdef TARGET_X86_64
if (CODE64(s)) {
int d_ot;
d_ot = dflag + OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
mod = (modrm >> 6) & 3;
rm = (modrm & 7) | REX_B(s);
if (mod == 3) {
gen_op_mov_TN_reg(OT_LONG, 0, rm);
if (d_ot == OT_QUAD)
tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(d_ot, reg);
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (d_ot == OT_QUAD) {
gen_op_lds_T0_A0(OT_LONG + s->mem_index);
} else {
gen_op_ld_T0_A0(OT_LONG + s->mem_index);
}
gen_op_mov_reg_T0(d_ot, reg);
}
} else
#endif
{
int label1;
TCGv t0, t1, t2, a0;
if (!s->pe || s->vm86)
goto illegal_op;
t0 = tcg_temp_local_new();
t1 = tcg_temp_local_new();
t2 = tcg_temp_local_new();
ot = OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, 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_v(ot + s->mem_index, t0, cpu_A0);
a0 = tcg_temp_local_new();
tcg_gen_mov_tl(a0, cpu_A0);
} else {
gen_op_mov_v_reg(ot, t0, rm);
TCGV_UNUSED(a0);
}
gen_op_mov_v_reg(ot, t1, reg);
tcg_gen_andi_tl(cpu_tmp0, t0, 3);
tcg_gen_andi_tl(t1, t1, 3);
tcg_gen_movi_tl(t2, 0);
label1 = gen_new_label();
tcg_gen_brcond_tl(TCG_COND_GE, cpu_tmp0, t1, label1);
tcg_gen_andi_tl(t0, t0, ~3);
tcg_gen_or_tl(t0, t0, t1);
tcg_gen_movi_tl(t2, CC_Z);
gen_set_label(label1);
if (mod != 3) {
gen_op_st_v(ot + s->mem_index, t0, a0);
tcg_temp_free(a0);
} else {
gen_op_mov_reg_v(ot, rm, t0);
}
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_compute_eflags(cpu_cc_src);
tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, ~CC_Z);
tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, t2);
s->cc_op = CC_OP_EFLAGS;
tcg_temp_free(t0);
tcg_temp_free(t1);
tcg_temp_free(t2);
}
break;
case 0x102:
case 0x103:
{
int label1;
TCGv t0;
if (!s->pe || s->vm86)
goto illegal_op;
ot = dflag ? OT_LONG : OT_WORD;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7) | rex_r;
gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
t0 = tcg_temp_local_new();
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
if (b == 0x102) {
gen_helper_lar(t0, cpu_env, cpu_T[0]);
} else {
gen_helper_lsl(t0, cpu_env, cpu_T[0]);
}
tcg_gen_andi_tl(cpu_tmp0, cpu_cc_src, CC_Z);
label1 = gen_new_label();
tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, label1);
gen_op_mov_reg_v(ot, reg, t0);
gen_set_label(label1);
s->cc_op = CC_OP_EFLAGS;
tcg_temp_free(t0);
}
break;
case 0x118:
modrm = cpu_ldub_code(cpu_single_env, 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:
gen_nop_modrm(s, modrm);
break;
}
break;
case 0x119 ... 0x11f:
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
gen_nop_modrm(s, modrm);
break;
case 0x120:
case 0x122:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
rm = (modrm & 7) | REX_B(s);
reg = ((modrm >> 3) & 7) | rex_r;
if (CODE64(s))
ot = OT_QUAD;
else
ot = OT_LONG;
if ((prefixes & PREFIX_LOCK) && (reg == 0) &&
(s->cpuid_ext3_features & CPUID_EXT3_CR8LEG)) {
reg = 8;
}
switch(reg) {
case 0:
case 2:
case 3:
case 4:
case 8:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
if (b & 2) {
gen_op_mov_TN_reg(ot, 0, rm);
gen_helper_write_crN(cpu_env, tcg_const_i32(reg),
cpu_T[0]);
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
} else {
gen_helper_read_crN(cpu_T[0], cpu_env, tcg_const_i32(reg));
gen_op_mov_reg_T0(ot, 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 = cpu_ldub_code(cpu_single_env, s->pc++);
rm = (modrm & 7) | REX_B(s);
reg = ((modrm >> 3) & 7) | rex_r;
if (CODE64(s))
ot = OT_QUAD;
else
ot = OT_LONG;
if (reg == 4 || reg == 5 || reg >= 8)
goto illegal_op;
if (b & 2) {
gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_DR0 + reg);
gen_op_mov_TN_reg(ot, 0, rm);
gen_helper_movl_drN_T0(cpu_env, tcg_const_i32(reg), cpu_T[0]);
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
} else {
gen_svm_check_intercept(s, pc_start, SVM_EXIT_READ_DR0 + reg);
tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,dr[reg]));
gen_op_mov_reg_T0(ot, rm);
}
}
break;
case 0x106:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_CR0);
gen_helper_clts(cpu_env);
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x1c3:
if (!(s->cpuid_features & CPUID_SSE2))
goto illegal_op;
ot = s->dflag == 2 ? OT_QUAD : OT_LONG;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
reg = ((modrm >> 3) & 7) | rex_r;
gen_ldst_modrm(s, modrm, ot, reg, 1);
break;
case 0x1ae:
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
op = (modrm >> 3) & 7;
switch(op) {
case 0:
if (mod == 3 || !(s->cpuid_features & CPUID_FXSR) ||
(s->prefix & PREFIX_LOCK))
goto illegal_op;
if ((s->flags & HF_EM_MASK) || (s->flags & HF_TS_MASK)) {
gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
break;
}
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fxsave(cpu_env, cpu_A0, tcg_const_i32((s->dflag == 2)));
break;
case 1:
if (mod == 3 || !(s->cpuid_features & CPUID_FXSR) ||
(s->prefix & PREFIX_LOCK))
goto illegal_op;
if ((s->flags & HF_EM_MASK) || (s->flags & HF_TS_MASK)) {
gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
break;
}
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fxrstor(cpu_env, cpu_A0,
tcg_const_i32((s->dflag == 2)));
break;
case 2:
case 3:
if (s->flags & HF_TS_MASK) {
gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
break;
}
if ((s->flags & HF_EM_MASK) || !(s->flags & HF_OSFXSR_MASK) ||
mod == 3)
goto illegal_op;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (op == 2) {
gen_op_ld_T0_A0(OT_LONG + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_ldmxcsr(cpu_env, cpu_tmp2_i32);
} else {
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, mxcsr));
gen_op_st_T0_A0(OT_LONG + s->mem_index);
}
break;
case 5:
case 6:
if ((modrm & 0xc7) != 0xc0 || !(s->cpuid_features & CPUID_SSE2))
goto illegal_op;
break;
case 7:
if ((modrm & 0xc7) == 0xc0) {
if (!(s->cpuid_features & CPUID_SSE))
goto illegal_op;
} else {
if (!(s->cpuid_features & CPUID_CLFLUSH))
goto illegal_op;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
}
break;
default:
goto illegal_op;
}
break;
case 0x10d:
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
break;
case 0x1aa:
gen_svm_check_intercept(s, pc_start, SVM_EXIT_RSM);
if (!(s->flags & HF_SMM_MASK))
goto illegal_op;
gen_update_cc_op(s);
gen_jmp_im(s->pc - s->cs_base);
gen_helper_rsm(cpu_env);
gen_eob(s);
break;
case 0x1b8:
if ((prefixes & (PREFIX_REPZ | PREFIX_LOCK | PREFIX_REPNZ)) !=
PREFIX_REPZ)
goto illegal_op;
if (!(s->cpuid_ext_features & CPUID_EXT_POPCNT))
goto illegal_op;
modrm = cpu_ldub_code(cpu_single_env, s->pc++);
reg = ((modrm >> 3) & 7);
if (s->prefix & PREFIX_DATA)
ot = OT_WORD;
else if (s->dflag != 2)
ot = OT_LONG;
else
ot = OT_QUAD;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_helper_popcnt(cpu_T[0], cpu_env, cpu_T[0], tcg_const_i32(ot));
gen_op_mov_reg_T0(ot, reg);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x10e ... 0x10f:
s->prefix &= ~(PREFIX_REPZ | PREFIX_REPNZ | PREFIX_DATA);
case 0x110 ... 0x117:
case 0x128 ... 0x12f:
case 0x138 ... 0x13a:
case 0x150 ... 0x179:
case 0x17c ... 0x17f:
case 0x1c2:
case 0x1c4 ... 0x1c6:
case 0x1d0 ... 0x1fe:
gen_sse(s, b, pc_start, rex_r);
break;
default:
goto illegal_op;
}
if (s->prefix & PREFIX_LOCK)
gen_helper_unlock();
return s->pc;
illegal_op:
if (s->prefix & PREFIX_LOCK)
gen_helper_unlock();
gen_exception(s, EXCP06_ILLOP, pc_start - s->cs_base);
return s->pc;
}
| {
"code": [],
"line_no": []
} | static target_ulong FUNC_0(DisasContext *s, target_ulong 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_17, VAR_12, VAR_13, VAR_18;
target_ulong next_eip, tval;
int VAR_15, VAR_16;
if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP | CPU_LOG_TB_OP_OPT))) {
tcg_gen_debug_insn_start(pc_start);
}
s->pc = pc_start;
VAR_1 = 0;
VAR_2 = s->code32;
VAR_3 = s->code32;
s->override = -1;
VAR_15 = -1;
VAR_16 = 0;
#ifdef TARGET_X86_64
s->rex_x = 0;
s->rex_b = 0;
x86_64_hregs = 0;
#endif
s->rip_offset = 0;
next_byte:
VAR_0 = cpu_ldub_code(cpu_single_env, s->pc);
s->pc++;
#ifdef TARGET_X86_64
if (CODE64(s)) {
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->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:
VAR_1 |= PREFIX_DATA;
goto next_byte;
case 0x67:
VAR_1 |= PREFIX_ADR;
goto next_byte;
case 0x40 ... 0x4f:
VAR_15 = (VAR_0 >> 3) & 1;
VAR_16 = (VAR_0 & 0x4) << 1;
s->rex_x = (VAR_0 & 0x2) << 2;
REX_B(s) = (VAR_0 & 0x1) << 3;
x86_64_hregs = 1;
goto next_byte;
}
if (VAR_15 == 1) {
VAR_3 = 2;
} else {
if (VAR_1 & PREFIX_DATA)
VAR_3 ^= 1;
}
if (!(VAR_1 & PREFIX_ADR))
VAR_2 = 2;
} else
#endif
{
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->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:
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_helper_lock();
reswitch:
switch(VAR_0) {
case 0x0f:
VAR_0 = cpu_ldub_code(cpu_single_env, 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_17, VAR_17, VAR_18;
VAR_17 = (VAR_0 >> 3) & 7;
VAR_17 = (VAR_0 >> 1) & 3;
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 + OT_WORD;
switch(VAR_17) {
case 0:
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = (VAR_6 & 7) | REX_B(s);
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
VAR_12 = OR_TMP0;
} else if (VAR_17 == 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_17, VAR_5, VAR_12);
break;
case 1:
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
VAR_8 = (VAR_6 & 7) | REX_B(s);
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_17 == OP_XORL && VAR_8 == VAR_7) {
goto xor_zero;
} else {
gen_op_mov_TN_reg(VAR_5, 1, VAR_8);
}
gen_op(s, VAR_17, VAR_5, VAR_7);
break;
case 2:
VAR_18 = insn_get(s, VAR_5);
gen_op_movl_T1_im(VAR_18);
gen_op(s, VAR_17, VAR_5, OR_EAX);
break;
}
}
break;
case 0x82:
if (CODE64(s))
goto illegal_op;
case 0x80:
case 0x81:
case 0x83:
{
int VAR_18;
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 + OT_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = (VAR_6 & 7) | REX_B(s);
VAR_17 = (VAR_6 >> 3) & 7;
if (VAR_9 != 3) {
if (VAR_0 == 0x83)
s->rip_offset = 1;
else
s->rip_offset = insn_const_size(VAR_5);
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
VAR_12 = OR_TMP0;
} else {
VAR_12 = VAR_8;
}
switch(VAR_0) {
default:
case 0x80:
case 0x81:
case 0x82:
VAR_18 = insn_get(s, VAR_5);
break;
case 0x83:
VAR_18 = (int8_t)insn_get(s, OT_BYTE);
break;
}
gen_op_movl_T1_im(VAR_18);
gen_op(s, VAR_17, 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_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = (VAR_6 & 7) | REX_B(s);
VAR_17 = (VAR_6 >> 3) & 7;
if (VAR_9 != 3) {
if (VAR_17 == 0)
s->rip_offset = insn_const_size(VAR_5);
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_17) {
case 0:
VAR_18 = insn_get(s, VAR_5);
gen_op_movl_T1_im(VAR_18);
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + VAR_5;
break;
case 2:
tcg_gen_not_tl(cpu_T[0], cpu_T[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);
}
break;
case 3:
tcg_gen_neg_tl(cpu_T[0], cpu_T[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_neg_cc();
s->cc_op = CC_OP_SUBB + VAR_5;
break;
case 4:
switch(VAR_5) {
case OT_BYTE:
gen_op_mov_TN_reg(OT_BYTE, 1, R_EAX);
tcg_gen_ext8u_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext8u_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_WORD, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_andi_tl(cpu_cc_src, cpu_T[0], 0xff00);
s->cc_op = CC_OP_MULB;
break;
case OT_WORD:
gen_op_mov_TN_reg(OT_WORD, 1, R_EAX);
tcg_gen_ext16u_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext16u_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_WORD, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 16);
gen_op_mov_reg_T0(OT_WORD, R_EDX);
tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);
s->cc_op = CC_OP_MULW;
break;
default:
case OT_LONG:
#ifdef TARGET_X86_64
gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);
tcg_gen_ext32u_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext32u_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_LONG, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 32);
gen_op_mov_reg_T0(OT_LONG, R_EDX);
tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);
#else
{
TCGv_i64 t0, t1;
t0 = tcg_temp_new_i64();
t1 = tcg_temp_new_i64();
gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);
tcg_gen_extu_i32_i64(t0, cpu_T[0]);
tcg_gen_extu_i32_i64(t1, cpu_T[1]);
tcg_gen_mul_i64(t0, t0, t1);
tcg_gen_trunc_i64_i32(cpu_T[0], t0);
gen_op_mov_reg_T0(OT_LONG, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_shri_i64(t0, t0, 32);
tcg_gen_trunc_i64_i32(cpu_T[0], t0);
gen_op_mov_reg_T0(OT_LONG, R_EDX);
tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);
}
#endif
s->cc_op = CC_OP_MULL;
break;
#ifdef TARGET_X86_64
case OT_QUAD:
gen_helper_mulq_EAX_T0(cpu_env, cpu_T[0]);
s->cc_op = CC_OP_MULQ;
break;
#endif
}
break;
case 5:
switch(VAR_5) {
case OT_BYTE:
gen_op_mov_TN_reg(OT_BYTE, 1, R_EAX);
tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext8s_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_WORD, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_ext8s_tl(cpu_tmp0, cpu_T[0]);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
s->cc_op = CC_OP_MULB;
break;
case OT_WORD:
gen_op_mov_TN_reg(OT_WORD, 1, R_EAX);
tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext16s_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_WORD, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_ext16s_tl(cpu_tmp0, cpu_T[0]);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 16);
gen_op_mov_reg_T0(OT_WORD, R_EDX);
s->cc_op = CC_OP_MULW;
break;
default:
case OT_LONG:
#ifdef TARGET_X86_64
gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);
tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext32s_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
gen_op_mov_reg_T0(OT_LONG, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_ext32s_tl(cpu_tmp0, cpu_T[0]);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 32);
gen_op_mov_reg_T0(OT_LONG, R_EDX);
#else
{
TCGv_i64 t0, t1;
t0 = tcg_temp_new_i64();
t1 = tcg_temp_new_i64();
gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);
tcg_gen_ext_i32_i64(t0, cpu_T[0]);
tcg_gen_ext_i32_i64(t1, cpu_T[1]);
tcg_gen_mul_i64(t0, t0, t1);
tcg_gen_trunc_i64_i32(cpu_T[0], t0);
gen_op_mov_reg_T0(OT_LONG, R_EAX);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_sari_tl(cpu_tmp0, cpu_T[0], 31);
tcg_gen_shri_i64(t0, t0, 32);
tcg_gen_trunc_i64_i32(cpu_T[0], t0);
gen_op_mov_reg_T0(OT_LONG, R_EDX);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
}
#endif
s->cc_op = CC_OP_MULL;
break;
#ifdef TARGET_X86_64
case OT_QUAD:
gen_helper_imulq_EAX_T0(cpu_env, cpu_T[0]);
s->cc_op = CC_OP_MULQ;
break;
#endif
}
break;
case 6:
switch(VAR_5) {
case OT_BYTE:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_divb_AL(cpu_env, cpu_T[0]);
break;
case OT_WORD:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_divw_AX(cpu_env, cpu_T[0]);
break;
default:
case OT_LONG:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_divl_EAX(cpu_env, cpu_T[0]);
break;
#ifdef TARGET_X86_64
case OT_QUAD:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_divq_EAX(cpu_env, cpu_T[0]);
break;
#endif
}
break;
case 7:
switch(VAR_5) {
case OT_BYTE:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_idivb_AL(cpu_env, cpu_T[0]);
break;
case OT_WORD:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_idivw_AX(cpu_env, cpu_T[0]);
break;
default:
case OT_LONG:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_idivl_EAX(cpu_env, cpu_T[0]);
break;
#ifdef TARGET_X86_64
case OT_QUAD:
gen_jmp_im(pc_start - s->cs_base);
gen_helper_idivq_EAX(cpu_env, cpu_T[0]);
break;
#endif
}
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_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = (VAR_6 & 7) | REX_B(s);
VAR_17 = (VAR_6 >> 3) & 7;
if (VAR_17 >= 2 && VAR_0 == 0xfe) {
goto illegal_op;
}
if (CODE64(s)) {
if (VAR_17 == 2 || VAR_17 == 4) {
VAR_5 = OT_QUAD;
} else if (VAR_17 == 3 || VAR_17 == 5) {
VAR_5 = VAR_3 ? OT_LONG + (VAR_15 == 1) : OT_WORD;
} else if (VAR_17 == 6) {
VAR_5 = VAR_3 ? OT_QUAD : OT_WORD;
}
}
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
if (VAR_17 >= 2 && VAR_17 != 3 && VAR_17 != 5)
gen_op_ld_T0_A0(VAR_5 + s->mem_index);
} else {
gen_op_mov_TN_reg(VAR_5, 0, VAR_8);
}
switch(VAR_17) {
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();
next_eip = s->pc - s->cs_base;
gen_movtl_T1_im(next_eip);
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_add_A0_im(s, 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_jmp_im(pc_start - s->cs_base);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_lcall_protected(cpu_env, cpu_tmp2_i32, cpu_T[1],
tcg_const_i32(VAR_3),
tcg_const_i32(s->pc - pc_start));
} else {
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_lcall_real(cpu_env, cpu_tmp2_i32, cpu_T[1],
tcg_const_i32(VAR_3),
tcg_const_i32(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_add_A0_im(s, 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_jmp_im(pc_start - s->cs_base);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_ljmp_protected(cpu_env, cpu_tmp2_i32, cpu_T[1],
tcg_const_i32(s->pc - pc_start));
} else {
gen_op_movl_seg_T0_vm(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_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 0);
gen_op_mov_TN_reg(VAR_5, 1, VAR_7);
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_WORD;
VAR_18 = insn_get(s, VAR_5);
gen_op_mov_TN_reg(VAR_5, 0, OR_EAX);
gen_op_movl_T1_im(VAR_18);
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + VAR_5;
break;
case 0x98:
#ifdef TARGET_X86_64
if (VAR_3 == 2) {
gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);
tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_QUAD, R_EAX);
} else
#endif
if (VAR_3 == 1) {
gen_op_mov_TN_reg(OT_WORD, 0, R_EAX);
tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_LONG, R_EAX);
} else {
gen_op_mov_TN_reg(OT_BYTE, 0, R_EAX);
tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_WORD, R_EAX);
}
break;
case 0x99:
#ifdef TARGET_X86_64
if (VAR_3 == 2) {
gen_op_mov_TN_reg(OT_QUAD, 0, R_EAX);
tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 63);
gen_op_mov_reg_T0(OT_QUAD, R_EDX);
} else
#endif
if (VAR_3 == 1) {
gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);
tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 31);
gen_op_mov_reg_T0(OT_LONG, R_EDX);
} else {
gen_op_mov_TN_reg(OT_WORD, 0, R_EAX);
tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 15);
gen_op_mov_reg_T0(OT_WORD, R_EDX);
}
break;
case 0x1af:
case 0x69:
case 0x6b:
VAR_5 = VAR_3 + OT_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
if (VAR_0 == 0x69)
s->rip_offset = insn_const_size(VAR_5);
else if (VAR_0 == 0x6b)
s->rip_offset = 1;
gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 0);
if (VAR_0 == 0x69) {
VAR_18 = insn_get(s, VAR_5);
gen_op_movl_T1_im(VAR_18);
} else if (VAR_0 == 0x6b) {
VAR_18 = (int8_t)insn_get(s, OT_BYTE);
gen_op_movl_T1_im(VAR_18);
} else {
gen_op_mov_TN_reg(VAR_5, 1, VAR_7);
}
#ifdef TARGET_X86_64
if (VAR_5 == OT_QUAD) {
gen_helper_imulq_T0_T1(cpu_T[0], cpu_env, cpu_T[0], cpu_T[1]);
} else
#endif
if (VAR_5 == OT_LONG) {
#ifdef TARGET_X86_64
tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext32s_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_ext32s_tl(cpu_tmp0, cpu_T[0]);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
#else
{
TCGv_i64 t0, t1;
t0 = tcg_temp_new_i64();
t1 = tcg_temp_new_i64();
tcg_gen_ext_i32_i64(t0, cpu_T[0]);
tcg_gen_ext_i32_i64(t1, cpu_T[1]);
tcg_gen_mul_i64(t0, t0, t1);
tcg_gen_trunc_i64_i32(cpu_T[0], t0);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_sari_tl(cpu_tmp0, cpu_T[0], 31);
tcg_gen_shri_i64(t0, t0, 32);
tcg_gen_trunc_i64_i32(cpu_T[1], t0);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[1], cpu_tmp0);
}
#endif
} else {
tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
tcg_gen_ext16s_tl(cpu_T[1], cpu_T[1]);
tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
tcg_gen_ext16s_tl(cpu_tmp0, cpu_T[0]);
tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
}
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_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
VAR_9 = (VAR_6 >> 6) & 3;
if (VAR_9 == 3) {
VAR_8 = (VAR_6 & 7) | REX_B(s);
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:
{
int VAR_29, VAR_19;
TCGv t0, t1, t2, a0;
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 + OT_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
VAR_9 = (VAR_6 >> 6) & 3;
t0 = tcg_temp_local_new();
t1 = tcg_temp_local_new();
t2 = tcg_temp_local_new();
a0 = tcg_temp_local_new();
gen_op_mov_v_reg(VAR_5, t1, VAR_7);
if (VAR_9 == 3) {
VAR_8 = (VAR_6 & 7) | REX_B(s);
gen_op_mov_v_reg(VAR_5, t0, VAR_8);
} else {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
tcg_gen_mov_tl(a0, cpu_A0);
gen_op_ld_v(VAR_5 + s->mem_index, t0, a0);
VAR_8 = 0;
}
VAR_29 = gen_new_label();
tcg_gen_sub_tl(t2, cpu_regs[R_EAX], t0);
gen_extu(VAR_5, t2);
tcg_gen_brcondi_tl(TCG_COND_EQ, t2, 0, VAR_29);
VAR_19 = gen_new_label();
if (VAR_9 == 3) {
gen_op_mov_reg_v(VAR_5, R_EAX, t0);
tcg_gen_br(VAR_19);
gen_set_label(VAR_29);
gen_op_mov_reg_v(VAR_5, VAR_8, t1);
} else {
gen_op_st_v(VAR_5 + s->mem_index, t0, a0);
gen_op_mov_reg_v(VAR_5, R_EAX, t0);
tcg_gen_br(VAR_19);
gen_set_label(VAR_29);
gen_op_st_v(VAR_5 + s->mem_index, t1, a0);
}
gen_set_label(VAR_19);
tcg_gen_mov_tl(cpu_cc_src, t0);
tcg_gen_mov_tl(cpu_cc_dst, t2);
s->cc_op = CC_OP_SUBB + VAR_5;
tcg_temp_free(t0);
tcg_temp_free(t1);
tcg_temp_free(t2);
tcg_temp_free(a0);
}
break;
case 0x1c7:
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
if ((VAR_9 == 3) || ((VAR_6 & 0x38) != 0x8))
goto illegal_op;
#ifdef TARGET_X86_64
if (VAR_3 == 2) {
if (!(s->cpuid_ext_features & CPUID_EXT_CX16))
goto illegal_op;
gen_jmp_im(pc_start - s->cs_base);
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_helper_cmpxchg16b(cpu_env, cpu_A0);
} else
#endif
{
if (!(s->cpuid_features & CPUID_CX8))
goto illegal_op;
gen_jmp_im(pc_start - s->cs_base);
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_helper_cmpxchg8b(cpu_env, cpu_A0);
}
s->cc_op = CC_OP_EFLAGS;
break;
case 0x50 ... 0x57:
gen_op_mov_TN_reg(OT_LONG, 0, (VAR_0 & 7) | REX_B(s));
gen_push_T0(s);
break;
case 0x58 ... 0x5f:
if (CODE64(s)) {
VAR_5 = VAR_3 ? OT_QUAD : OT_WORD;
} else {
VAR_5 = VAR_3 + OT_WORD;
}
gen_pop_T0(s);
gen_pop_update(s);
gen_op_mov_reg_T0(VAR_5, (VAR_0 & 7) | REX_B(s));
break;
case 0x60:
if (CODE64(s))
goto illegal_op;
gen_pusha(s);
break;
case 0x61:
if (CODE64(s))
goto illegal_op;
gen_popa(s);
break;
case 0x68:
case 0x6a:
if (CODE64(s)) {
VAR_5 = VAR_3 ? OT_QUAD : OT_WORD;
} else {
VAR_5 = VAR_3 + OT_WORD;
}
if (VAR_0 == 0x68)
VAR_18 = insn_get(s, VAR_5);
else
VAR_18 = (int8_t)insn_get(s, OT_BYTE);
gen_op_movl_T0_im(VAR_18);
gen_push_T0(s);
break;
case 0x8f:
if (CODE64(s)) {
VAR_5 = VAR_3 ? OT_QUAD : OT_WORD;
} else {
VAR_5 = VAR_3 + OT_WORD;
}
VAR_6 = cpu_ldub_code(cpu_single_env, 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) | REX_B(s);
gen_op_mov_reg_T0(VAR_5, VAR_8);
} else {
s->popl_esp_hack = 1 << VAR_5;
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_20;
VAR_18 = cpu_lduw_code(cpu_single_env, s->pc);
s->pc += 2;
VAR_20 = cpu_ldub_code(cpu_single_env, s->pc++);
gen_enter(s, VAR_18, VAR_20);
}
break;
case 0xc9:
if (CODE64(s)) {
gen_op_mov_TN_reg(OT_QUAD, 0, R_EBP);
gen_op_mov_reg_T0(OT_QUAD, R_ESP);
} else 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);
if (CODE64(s)) {
VAR_5 = VAR_3 ? OT_QUAD : OT_WORD;
} else {
VAR_5 = VAR_3 + OT_WORD;
}
gen_op_mov_reg_T0(VAR_5, R_EBP);
gen_pop_update(s);
break;
case 0x06:
case 0x0e:
case 0x16:
case 0x1e:
if (CODE64(s))
goto illegal_op;
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:
if (CODE64(s))
goto illegal_op;
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_helper_set_inhibit_irq(cpu_env);
s->tf = 0;
}
if (s->is_jmp) {
gen_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_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_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
gen_ldst_modrm(s, VAR_6, VAR_5, VAR_7, 1);
break;
case 0xc6:
case 0xc7:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 + OT_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
if (VAR_9 != 3) {
s->rip_offset = insn_const_size(VAR_5);
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
}
VAR_18 = insn_get(s, VAR_5);
gen_op_movl_T0_im(VAR_18);
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) | REX_B(s));
break;
case 0x8a:
case 0x8b:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = OT_WORD + VAR_3;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
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 = cpu_ldub_code(cpu_single_env, 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_helper_set_inhibit_irq(cpu_env);
s->tf = 0;
}
if (s->is_jmp) {
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x8c:
VAR_6 = cpu_ldub_code(cpu_single_env, 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);
if (VAR_9 == 3)
VAR_5 = OT_WORD + VAR_3;
else
VAR_5 = OT_WORD;
gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 1);
break;
case 0x1b6:
case 0x1b7:
case 0x1be:
case 0x1bf:
{
int VAR_21;
VAR_21 = VAR_3 + OT_WORD;
VAR_5 = (VAR_0 & 1) + OT_BYTE;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = (VAR_6 & 7) | REX_B(s);
if (VAR_9 == 3) {
gen_op_mov_TN_reg(VAR_5, 0, VAR_8);
switch(VAR_5 | (VAR_0 & 8)) {
case OT_BYTE:
tcg_gen_ext8u_tl(cpu_T[0], cpu_T[0]);
break;
case OT_BYTE | 8:
tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);
break;
case OT_WORD:
tcg_gen_ext16u_tl(cpu_T[0], cpu_T[0]);
break;
default:
case OT_WORD | 8:
tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
break;
}
gen_op_mov_reg_T0(VAR_21, 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_21, VAR_7);
}
}
break;
case 0x8d:
VAR_5 = VAR_3 + OT_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
if (VAR_9 == 3)
goto illegal_op;
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
s->override = -1;
VAR_18 = s->addseg;
s->addseg = 0;
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
s->addseg = VAR_18;
gen_op_mov_reg_A0(VAR_5 - OT_WORD, VAR_7);
break;
case 0xa0:
case 0xa1:
case 0xa2:
case 0xa3:
{
target_ulong VAR_13;
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 + OT_WORD;
#ifdef TARGET_X86_64
if (s->VAR_2 == 2) {
VAR_13 = cpu_ldq_code(cpu_single_env, s->pc);
s->pc += 8;
gen_op_movq_A0_im(VAR_13);
} else
#endif
{
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);
}
gen_add_A0_ds_seg(s);
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:
#ifdef TARGET_X86_64
if (s->VAR_2 == 2) {
gen_op_movq_A0_reg(R_EBX);
gen_op_mov_TN_reg(OT_QUAD, 0, R_EAX);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xff);
tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_T[0]);
} else
#endif
{
gen_op_movl_A0_reg(R_EBX);
gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xff);
tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_T[0]);
if (s->VAR_2 == 0)
gen_op_andl_A0_ffff();
else
tcg_gen_andi_tl(cpu_A0, cpu_A0, 0xffffffff);
}
gen_add_A0_ds_seg(s);
gen_op_ldu_T0_A0(OT_BYTE + s->mem_index);
gen_op_mov_reg_T0(OT_BYTE, R_EAX);
break;
case 0xb0 ... 0xb7:
VAR_18 = insn_get(s, OT_BYTE);
gen_op_movl_T0_im(VAR_18);
gen_op_mov_reg_T0(OT_BYTE, (VAR_0 & 7) | REX_B(s));
break;
case 0xb8 ... 0xbf:
#ifdef TARGET_X86_64
if (VAR_3 == 2) {
uint64_t tmp;
tmp = cpu_ldq_code(cpu_single_env, s->pc);
s->pc += 8;
VAR_7 = (VAR_0 & 7) | REX_B(s);
gen_movtl_T0_im(tmp);
gen_op_mov_reg_T0(OT_QUAD, VAR_7);
} else
#endif
{
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_18 = insn_get(s, VAR_5);
VAR_7 = (VAR_0 & 7) | REX_B(s);
gen_op_movl_T0_im(VAR_18);
gen_op_mov_reg_T0(VAR_5, VAR_7);
}
break;
case 0x91 ... 0x97:
do_xchg_reg_eax:
VAR_5 = VAR_3 + OT_WORD;
VAR_7 = (VAR_0 & 7) | REX_B(s);
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_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
VAR_9 = (VAR_6 >> 6) & 3;
if (VAR_9 == 3) {
VAR_8 = (VAR_6 & 7) | REX_B(s);
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_helper_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_helper_unlock();
gen_op_mov_reg_T1(VAR_5, VAR_7);
}
break;
case 0xc4:
if (CODE64(s))
goto illegal_op;
VAR_17 = R_ES;
goto do_lxx;
case 0xc5:
if (CODE64(s))
goto illegal_op;
VAR_17 = R_DS;
goto do_lxx;
case 0x1b2:
VAR_17 = R_SS;
goto do_lxx;
case 0x1b4:
VAR_17 = R_FS;
goto do_lxx;
case 0x1b5:
VAR_17 = R_GS;
do_lxx:
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
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_add_A0_im(s, 1 << (VAR_5 - OT_WORD + 1));
gen_op_ldu_T0_A0(OT_WORD + s->mem_index);
gen_movl_seg_T0(s, VAR_17, pc_start - s->cs_base);
gen_op_mov_reg_T1(VAR_5, VAR_7);
if (s->is_jmp) {
gen_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_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_17 = (VAR_6 >> 3) & 7;
if (VAR_9 != 3) {
if (VAR_4 == 2) {
s->rip_offset = 1;
}
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
VAR_12 = OR_TMP0;
} else {
VAR_12 = (VAR_6 & 7) | REX_B(s);
}
if (VAR_4 == 0) {
gen_shift(s, VAR_17, VAR_5, VAR_12, OR_ECX);
} else {
if (VAR_4 == 2) {
VAR_4 = cpu_ldub_code(cpu_single_env, s->pc++);
}
gen_shifti(s, VAR_17, 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_17 = 0;
VAR_4 = 1;
goto do_shiftd;
case 0x1a5:
VAR_17 = 0;
VAR_4 = 0;
goto do_shiftd;
case 0x1ac:
VAR_17 = 1;
VAR_4 = 1;
goto do_shiftd;
case 0x1ad:
VAR_17 = 1;
VAR_4 = 0;
do_shiftd:
VAR_5 = VAR_3 + OT_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = (VAR_6 & 7) | REX_B(s);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
VAR_12 = OR_TMP0;
} else {
VAR_12 = VAR_8;
}
gen_op_mov_TN_reg(VAR_5, 1, VAR_7);
if (VAR_4) {
VAR_18 = cpu_ldub_code(cpu_single_env, s->pc++);
tcg_gen_movi_tl(cpu_T3, VAR_18);
} else {
tcg_gen_mov_tl(cpu_T3, cpu_regs[R_ECX]);
}
gen_shiftd_rm_T1_T3(s, VAR_5, VAR_12, VAR_17);
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 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = VAR_6 & 7;
VAR_17 = ((VAR_0 & 7) << 3) | ((VAR_6 >> 3) & 7);
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
switch(VAR_17) {
case 0x00 ... 0x07:
case 0x10 ... 0x17:
case 0x20 ... 0x27:
case 0x30 ... 0x37:
{
int VAR_23;
VAR_23 = VAR_17 & 7;
switch(VAR_17 >> 4) {
case 0:
gen_op_ld_T0_A0(OT_LONG + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_flds_FT0(cpu_env, cpu_tmp2_i32);
break;
case 1:
gen_op_ld_T0_A0(OT_LONG + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_fildl_FT0(cpu_env, cpu_tmp2_i32);
break;
case 2:
tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
gen_helper_fldl_FT0(cpu_env, cpu_tmp1_i64);
break;
case 3:
default:
gen_op_lds_T0_A0(OT_WORD + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_fildl_FT0(cpu_env, cpu_tmp2_i32);
break;
}
gen_helper_fp_arith_ST0_FT0(VAR_23);
if (VAR_23 == 3) {
gen_helper_fpop(cpu_env);
}
}
break;
case 0x08:
case 0x0a:
case 0x0b:
case 0x18 ... 0x1b:
case 0x28 ... 0x2b:
case 0x38 ... 0x3b:
switch(VAR_17 & 7) {
case 0:
switch(VAR_17 >> 4) {
case 0:
gen_op_ld_T0_A0(OT_LONG + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_flds_ST0(cpu_env, cpu_tmp2_i32);
break;
case 1:
gen_op_ld_T0_A0(OT_LONG + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_fildl_ST0(cpu_env, cpu_tmp2_i32);
break;
case 2:
tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
gen_helper_fldl_ST0(cpu_env, cpu_tmp1_i64);
break;
case 3:
default:
gen_op_lds_T0_A0(OT_WORD + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_fildl_ST0(cpu_env, cpu_tmp2_i32);
break;
}
break;
case 1:
switch(VAR_17 >> 4) {
case 1:
gen_helper_fisttl_ST0(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_LONG + s->mem_index);
break;
case 2:
gen_helper_fisttll_ST0(cpu_tmp1_i64, cpu_env);
tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
break;
case 3:
default:
gen_helper_fistt_ST0(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_WORD + s->mem_index);
break;
}
gen_helper_fpop(cpu_env);
break;
default:
switch(VAR_17 >> 4) {
case 0:
gen_helper_fsts_ST0(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_LONG + s->mem_index);
break;
case 1:
gen_helper_fistl_ST0(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_LONG + s->mem_index);
break;
case 2:
gen_helper_fstl_ST0(cpu_tmp1_i64, cpu_env);
tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
break;
case 3:
default:
gen_helper_fist_ST0(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_WORD + s->mem_index);
break;
}
if ((VAR_17 & 7) == 3)
gen_helper_fpop(cpu_env);
break;
}
break;
case 0x0c:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fldenv(cpu_env, cpu_A0, tcg_const_i32(s->VAR_3));
break;
case 0x0d:
gen_op_ld_T0_A0(OT_WORD + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_fldcw(cpu_env, cpu_tmp2_i32);
break;
case 0x0e:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fstenv(cpu_env, cpu_A0, tcg_const_i32(s->VAR_3));
break;
case 0x0f:
gen_helper_fnstcw(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_WORD + s->mem_index);
break;
case 0x1d:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fldt_ST0(cpu_env, cpu_A0);
break;
case 0x1f:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fstt_ST0(cpu_env, cpu_A0);
gen_helper_fpop(cpu_env);
break;
case 0x2c:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_frstor(cpu_env, cpu_A0, tcg_const_i32(s->VAR_3));
break;
case 0x2e:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fsave(cpu_env, cpu_A0, tcg_const_i32(s->VAR_3));
break;
case 0x2f:
gen_helper_fnstsw(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_st_T0_A0(OT_WORD + s->mem_index);
break;
case 0x3c:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fbld_ST0(cpu_env, cpu_A0);
break;
case 0x3e:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fbst_ST0(cpu_env, cpu_A0);
gen_helper_fpop(cpu_env);
break;
case 0x3d:
tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
gen_helper_fildll_ST0(cpu_env, cpu_tmp1_i64);
break;
case 0x3f:
gen_helper_fistll_ST0(cpu_tmp1_i64, cpu_env);
tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
(s->mem_index >> 2) - 1);
gen_helper_fpop(cpu_env);
break;
default:
goto illegal_op;
}
} else {
VAR_12 = VAR_8;
switch(VAR_17) {
case 0x08:
gen_helper_fpush(cpu_env);
gen_helper_fmov_ST0_STN(cpu_env,
tcg_const_i32((VAR_12 + 1) & 7));
break;
case 0x09:
case 0x29:
case 0x39:
gen_helper_fxchg_ST0_STN(cpu_env, tcg_const_i32(VAR_12));
break;
case 0x0a:
switch(VAR_8) {
case 0:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fwait(cpu_env);
break;
default:
goto illegal_op;
}
break;
case 0x0c:
switch(VAR_8) {
case 0:
gen_helper_fchs_ST0(cpu_env);
break;
case 1:
gen_helper_fabs_ST0(cpu_env);
break;
case 4:
gen_helper_fldz_FT0(cpu_env);
gen_helper_fcom_ST0_FT0(cpu_env);
break;
case 5:
gen_helper_fxam_ST0(cpu_env);
break;
default:
goto illegal_op;
}
break;
case 0x0d:
{
switch(VAR_8) {
case 0:
gen_helper_fpush(cpu_env);
gen_helper_fld1_ST0(cpu_env);
break;
case 1:
gen_helper_fpush(cpu_env);
gen_helper_fldl2t_ST0(cpu_env);
break;
case 2:
gen_helper_fpush(cpu_env);
gen_helper_fldl2e_ST0(cpu_env);
break;
case 3:
gen_helper_fpush(cpu_env);
gen_helper_fldpi_ST0(cpu_env);
break;
case 4:
gen_helper_fpush(cpu_env);
gen_helper_fldlg2_ST0(cpu_env);
break;
case 5:
gen_helper_fpush(cpu_env);
gen_helper_fldln2_ST0(cpu_env);
break;
case 6:
gen_helper_fpush(cpu_env);
gen_helper_fldz_ST0(cpu_env);
break;
default:
goto illegal_op;
}
}
break;
case 0x0e:
switch(VAR_8) {
case 0:
gen_helper_f2xm1(cpu_env);
break;
case 1:
gen_helper_fyl2x(cpu_env);
break;
case 2:
gen_helper_fptan(cpu_env);
break;
case 3:
gen_helper_fpatan(cpu_env);
break;
case 4:
gen_helper_fxtract(cpu_env);
break;
case 5:
gen_helper_fprem1(cpu_env);
break;
case 6:
gen_helper_fdecstp(cpu_env);
break;
default:
case 7:
gen_helper_fincstp(cpu_env);
break;
}
break;
case 0x0f:
switch(VAR_8) {
case 0:
gen_helper_fprem(cpu_env);
break;
case 1:
gen_helper_fyl2xp1(cpu_env);
break;
case 2:
gen_helper_fsqrt(cpu_env);
break;
case 3:
gen_helper_fsincos(cpu_env);
break;
case 5:
gen_helper_fscale(cpu_env);
break;
case 4:
gen_helper_frndint(cpu_env);
break;
case 6:
gen_helper_fsin(cpu_env);
break;
default:
case 7:
gen_helper_fcos(cpu_env);
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_23;
VAR_23 = VAR_17 & 7;
if (VAR_17 >= 0x20) {
gen_helper_fp_arith_STN_ST0(VAR_23, VAR_12);
if (VAR_17 >= 0x30)
gen_helper_fpop(cpu_env);
} else {
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));
gen_helper_fp_arith_ST0_FT0(VAR_23);
}
}
break;
case 0x02:
case 0x22:
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));
gen_helper_fcom_ST0_FT0(cpu_env);
break;
case 0x03:
case 0x23:
case 0x32:
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));
gen_helper_fcom_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
break;
case 0x15:
switch(VAR_8) {
case 1:
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(1));
gen_helper_fucom_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
gen_helper_fpop(cpu_env);
break;
default:
goto illegal_op;
}
break;
case 0x1c:
switch(VAR_8) {
case 0:
break;
case 1:
break;
case 2:
gen_helper_fclex(cpu_env);
break;
case 3:
gen_helper_fninit(cpu_env);
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_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));
gen_helper_fucomi_ST0_FT0(cpu_env);
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_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));
gen_helper_fcomi_ST0_FT0(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x28:
gen_helper_ffree_STN(cpu_env, tcg_const_i32(VAR_12));
break;
case 0x2a:
gen_helper_fmov_STN_ST0(cpu_env, tcg_const_i32(VAR_12));
break;
case 0x2b:
case 0x0b:
case 0x3a:
case 0x3b:
gen_helper_fmov_STN_ST0(cpu_env, tcg_const_i32(VAR_12));
gen_helper_fpop(cpu_env);
break;
case 0x2c:
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));
gen_helper_fucom_ST0_FT0(cpu_env);
break;
case 0x2d:
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));
gen_helper_fucom_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
break;
case 0x33:
switch(VAR_8) {
case 1:
gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(1));
gen_helper_fcom_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
gen_helper_fpop(cpu_env);
break;
default:
goto illegal_op;
}
break;
case 0x38:
gen_helper_ffree_STN(cpu_env, tcg_const_i32(VAR_12));
gen_helper_fpop(cpu_env);
break;
case 0x3c:
switch(VAR_8) {
case 0:
gen_helper_fnstsw(cpu_tmp2_i32, cpu_env);
tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
gen_op_mov_reg_T0(OT_WORD, R_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_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));
gen_helper_fucomi_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
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_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));
gen_helper_fcomi_ST0_FT0(cpu_env);
gen_helper_fpop(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x10 ... 0x13:
case 0x18 ... 0x1b:
{
int VAR_23, VAR_27;
static const uint8_t VAR_24[8] = {
(JCC_B << 1),
(JCC_Z << 1),
(JCC_BE << 1),
(JCC_P << 1),
};
VAR_23 = VAR_24[VAR_17 & 3] | (((VAR_17 >> 3) & 1) ^ 1);
VAR_27 = gen_new_label();
gen_jcc1(s, s->cc_op, VAR_23, VAR_27);
gen_helper_fmov_ST0_STN(cpu_env, tcg_const_i32(VAR_12));
gen_set_label(VAR_27);
}
break;
default:
goto illegal_op;
}
}
break;
case 0xa4:
case 0xa5:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 + 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_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_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_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_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_op_mov_TN_reg(OT_WORD, 0, R_EDX);
gen_op_andl_T0_ffff();
gen_check_io(s, VAR_5, pc_start - s->cs_base,
SVM_IOIO_TYPE_MASK | svm_is_rep(VAR_1) | 4);
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);
if (use_icount) {
gen_jmp(s, s->pc - s->cs_base);
}
}
break;
case 0x6e:
case 0x6f:
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, pc_start - s->cs_base,
svm_is_rep(VAR_1) | 4);
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);
if (use_icount) {
gen_jmp(s, s->pc - s->cs_base);
}
}
break;
case 0xe4:
case 0xe5:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_18 = cpu_ldub_code(cpu_single_env, s->pc++);
gen_op_movl_T0_im(VAR_18);
gen_check_io(s, VAR_5, pc_start - s->cs_base,
SVM_IOIO_TYPE_MASK | svm_is_rep(VAR_1));
if (use_icount)
gen_io_start();
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_in_func(VAR_5, cpu_T[1], cpu_tmp2_i32);
gen_op_mov_reg_T1(VAR_5, R_EAX);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
break;
case 0xe6:
case 0xe7:
if ((VAR_0 & 1) == 0)
VAR_5 = OT_BYTE;
else
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_18 = cpu_ldub_code(cpu_single_env, s->pc++);
gen_op_movl_T0_im(VAR_18);
gen_check_io(s, VAR_5, pc_start - s->cs_base,
svm_is_rep(VAR_1));
gen_op_mov_TN_reg(VAR_5, 1, R_EAX);
if (use_icount)
gen_io_start();
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[1]);
gen_helper_out_func(VAR_5, cpu_tmp2_i32, cpu_tmp3_i32);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
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, pc_start - s->cs_base,
SVM_IOIO_TYPE_MASK | svm_is_rep(VAR_1));
if (use_icount)
gen_io_start();
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_in_func(VAR_5, cpu_T[1], cpu_tmp2_i32);
gen_op_mov_reg_T1(VAR_5, R_EAX);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
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, pc_start - s->cs_base,
svm_is_rep(VAR_1));
gen_op_mov_TN_reg(VAR_5, 1, R_EAX);
if (use_icount)
gen_io_start();
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[1]);
gen_helper_out_func(VAR_5, cpu_tmp2_i32, cpu_tmp3_i32);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
break;
case 0xc2:
VAR_18 = cpu_ldsw_code(cpu_single_env, s->pc);
s->pc += 2;
gen_pop_T0(s);
if (CODE64(s) && s->VAR_3)
s->VAR_3 = 2;
gen_stack_update(s, VAR_18 + (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_18 = cpu_ldsw_code(cpu_single_env, 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_jmp_im(pc_start - s->cs_base);
gen_helper_lret_protected(cpu_env, tcg_const_i32(s->VAR_3),
tcg_const_i32(VAR_18));
} 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(R_CS);
gen_stack_update(s, VAR_18 + (4 << s->VAR_3));
}
gen_eob(s);
break;
case 0xcb:
VAR_18 = 0;
goto do_lret;
case 0xcf:
gen_svm_check_intercept(s, pc_start, SVM_EXIT_IRET);
if (!s->pe) {
gen_helper_iret_real(cpu_env, tcg_const_i32(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_helper_iret_real(cpu_env, tcg_const_i32(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_jmp_im(pc_start - s->cs_base);
gen_helper_iret_protected(cpu_env, tcg_const_i32(s->VAR_3),
tcg_const_i32(s->pc - s->cs_base));
s->cc_op = CC_OP_EFLAGS;
}
gen_eob(s);
break;
case 0xe8:
{
if (VAR_3)
tval = (int32_t)insn_get(s, OT_LONG);
else
tval = (int16_t)insn_get(s, OT_WORD);
next_eip = s->pc - s->cs_base;
tval += next_eip;
if (s->VAR_3 == 0)
tval &= 0xffff;
else if(!CODE64(s))
tval &= 0xffffffff;
gen_movtl_T0_im(next_eip);
gen_push_T0(s);
gen_jmp(s, tval);
}
break;
case 0x9a:
{
unsigned int VAR_27, VAR_27;
if (CODE64(s))
goto illegal_op;
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_27 = insn_get(s, VAR_5);
VAR_27 = insn_get(s, OT_WORD);
gen_op_movl_T0_im(VAR_27);
gen_op_movl_T1_imu(VAR_27);
}
goto do_lcall;
case 0xe9:
if (VAR_3)
tval = (int32_t)insn_get(s, OT_LONG);
else
tval = (int16_t)insn_get(s, OT_WORD);
tval += s->pc - s->cs_base;
if (s->VAR_3 == 0)
tval &= 0xffff;
else if(!CODE64(s))
tval &= 0xffffffff;
gen_jmp(s, tval);
break;
case 0xea:
{
unsigned int VAR_27, VAR_27;
if (CODE64(s))
goto illegal_op;
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_27 = insn_get(s, VAR_5);
VAR_27 = insn_get(s, OT_WORD);
gen_op_movl_T0_im(VAR_27);
gen_op_movl_T1_imu(VAR_27);
}
goto do_ljmp;
case 0xeb:
tval = (int8_t)insn_get(s, OT_BYTE);
tval += s->pc - s->cs_base;
if (s->VAR_3 == 0)
tval &= 0xffff;
gen_jmp(s, tval);
break;
case 0x70 ... 0x7f:
tval = (int8_t)insn_get(s, OT_BYTE);
goto do_jcc;
case 0x180 ... 0x18f:
if (VAR_3) {
tval = (int32_t)insn_get(s, OT_LONG);
} else {
tval = (int16_t)insn_get(s, OT_WORD);
}
do_jcc:
next_eip = s->pc - s->cs_base;
tval += next_eip;
if (s->VAR_3 == 0)
tval &= 0xffff;
gen_jcc(s, VAR_0, tval, next_eip);
break;
case 0x190 ... 0x19f:
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
gen_setcc(s, VAR_0);
gen_ldst_modrm(s, VAR_6, OT_BYTE, OR_TMP0, 1);
break;
case 0x140 ... 0x14f:
{
int VAR_27;
TCGv t0;
VAR_5 = VAR_3 + OT_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
VAR_9 = (VAR_6 >> 6) & 3;
t0 = tcg_temp_local_new();
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_op_ld_v(VAR_5 + s->mem_index, t0, cpu_A0);
} else {
VAR_8 = (VAR_6 & 7) | REX_B(s);
gen_op_mov_v_reg(VAR_5, t0, VAR_8);
}
#ifdef TARGET_X86_64
if (VAR_5 == OT_LONG) {
VAR_27 = gen_new_label();
gen_jcc1(s, s->cc_op, VAR_0 ^ 1, VAR_27);
tcg_gen_mov_tl(cpu_regs[VAR_7], t0);
gen_set_label(VAR_27);
tcg_gen_ext32u_tl(cpu_regs[VAR_7], cpu_regs[VAR_7]);
} else
#endif
{
VAR_27 = gen_new_label();
gen_jcc1(s, s->cc_op, VAR_0 ^ 1, VAR_27);
gen_op_mov_reg_v(VAR_5, VAR_7, t0);
gen_set_label(VAR_27);
}
tcg_temp_free(t0);
}
break;
case 0x9c:
gen_svm_check_intercept(s, pc_start, SVM_EXIT_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_helper_read_eflags(cpu_T[0], cpu_env);
gen_push_T0(s);
}
break;
case 0x9d:
gen_svm_check_intercept(s, pc_start, SVM_EXIT_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->VAR_3) {
gen_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK | AC_MASK |
ID_MASK | NT_MASK |
IF_MASK |
IOPL_MASK)));
} else {
gen_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK | AC_MASK |
ID_MASK | NT_MASK |
IF_MASK | IOPL_MASK)
& 0xffff));
}
} else {
if (s->cpl <= s->iopl) {
if (s->VAR_3) {
gen_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK |
AC_MASK |
ID_MASK |
NT_MASK |
IF_MASK)));
} else {
gen_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK |
AC_MASK |
ID_MASK |
NT_MASK |
IF_MASK)
& 0xffff));
}
} else {
if (s->VAR_3) {
gen_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK | AC_MASK |
ID_MASK | NT_MASK)));
} else {
gen_helper_write_eflags(cpu_env, cpu_T[0],
tcg_const_i32((TF_MASK | AC_MASK |
ID_MASK | NT_MASK)
& 0xffff));
}
}
}
gen_pop_update(s);
s->cc_op = CC_OP_EFLAGS;
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x9e:
if (CODE64(s) && !(s->cpuid_ext3_features & CPUID_EXT3_LAHF_LM))
goto illegal_op;
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_compute_eflags(cpu_cc_src);
tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, CC_O);
tcg_gen_andi_tl(cpu_T[0], cpu_T[0], CC_S | CC_Z | CC_A | CC_P | CC_C);
tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, cpu_T[0]);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x9f:
if (CODE64(s) && !(s->cpuid_ext3_features & CPUID_EXT3_LAHF_LM))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_compute_eflags(cpu_T[0]);
tcg_gen_ori_tl(cpu_T[0], cpu_T[0], 0x02);
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_compute_eflags(cpu_cc_src);
tcg_gen_xori_tl(cpu_cc_src, cpu_cc_src, CC_C);
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_compute_eflags(cpu_cc_src);
tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, ~CC_C);
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_compute_eflags(cpu_cc_src);
tcg_gen_ori_tl(cpu_cc_src, cpu_cc_src, CC_C);
s->cc_op = CC_OP_EFLAGS;
break;
case 0xfc:
tcg_gen_movi_i32(cpu_tmp2_i32, 1);
tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, offsetof(CPUX86State, df));
break;
case 0xfd:
tcg_gen_movi_i32(cpu_tmp2_i32, -1);
tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, offsetof(CPUX86State, df));
break;
case 0x1ba:
VAR_5 = VAR_3 + OT_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_17 = (VAR_6 >> 3) & 7;
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = (VAR_6 & 7) | REX_B(s);
if (VAR_9 != 3) {
s->rip_offset = 1;
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_18 = cpu_ldub_code(cpu_single_env, s->pc++);
gen_op_movl_T1_im(VAR_18);
if (VAR_17 < 4)
goto illegal_op;
VAR_17 -= 4;
goto bt_op;
case 0x1a3:
VAR_17 = 0;
goto do_btx;
case 0x1ab:
VAR_17 = 1;
goto do_btx;
case 0x1b3:
VAR_17 = 2;
goto do_btx;
case 0x1bb:
VAR_17 = 3;
do_btx:
VAR_5 = VAR_3 + OT_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = (VAR_6 & 7) | REX_B(s);
gen_op_mov_TN_reg(OT_LONG, 1, VAR_7);
if (VAR_9 != 3) {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_exts(VAR_5, cpu_T[1]);
tcg_gen_sari_tl(cpu_tmp0, cpu_T[1], 3 + VAR_5);
tcg_gen_shli_tl(cpu_tmp0, cpu_tmp0, VAR_5);
tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
gen_op_ld_T0_A0(VAR_5 + s->mem_index);
} else {
gen_op_mov_TN_reg(VAR_5, 0, VAR_8);
}
bt_op:
tcg_gen_andi_tl(cpu_T[1], cpu_T[1], (1 << (3 + VAR_5)) - 1);
switch(VAR_17) {
case 0:
tcg_gen_shr_tl(cpu_cc_src, cpu_T[0], cpu_T[1]);
tcg_gen_movi_tl(cpu_cc_dst, 0);
break;
case 1:
tcg_gen_shr_tl(cpu_tmp4, cpu_T[0], cpu_T[1]);
tcg_gen_movi_tl(cpu_tmp0, 1);
tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);
tcg_gen_or_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
break;
case 2:
tcg_gen_shr_tl(cpu_tmp4, cpu_T[0], cpu_T[1]);
tcg_gen_movi_tl(cpu_tmp0, 1);
tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);
tcg_gen_not_tl(cpu_tmp0, cpu_tmp0);
tcg_gen_and_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
break;
default:
case 3:
tcg_gen_shr_tl(cpu_tmp4, cpu_T[0], cpu_T[1]);
tcg_gen_movi_tl(cpu_tmp0, 1);
tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);
tcg_gen_xor_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
break;
}
s->cc_op = CC_OP_SARB + VAR_5;
if (VAR_17 != 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);
tcg_gen_mov_tl(cpu_cc_src, cpu_tmp4);
tcg_gen_movi_tl(cpu_cc_dst, 0);
}
break;
case 0x1bc:
case 0x1bd:
{
int VAR_29;
TCGv t0;
VAR_5 = VAR_3 + OT_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
gen_ldst_modrm(s,VAR_6, VAR_5, OR_TMP0, 0);
gen_extu(VAR_5, cpu_T[0]);
t0 = tcg_temp_local_new();
tcg_gen_mov_tl(t0, cpu_T[0]);
if ((VAR_0 & 1) && (VAR_1 & PREFIX_REPZ) &&
(s->cpuid_ext3_features & CPUID_EXT3_ABM)) {
switch(VAR_5) {
case OT_WORD: gen_helper_lzcnt(cpu_T[0], t0,
tcg_const_i32(16)); break;
case OT_LONG: gen_helper_lzcnt(cpu_T[0], t0,
tcg_const_i32(32)); break;
case OT_QUAD: gen_helper_lzcnt(cpu_T[0], t0,
tcg_const_i32(64)); break;
}
gen_op_mov_reg_T0(VAR_5, VAR_7);
} else {
VAR_29 = gen_new_label();
tcg_gen_movi_tl(cpu_cc_dst, 0);
tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, VAR_29);
if (VAR_0 & 1) {
gen_helper_bsr(cpu_T[0], t0);
} else {
gen_helper_bsf(cpu_T[0], t0);
}
gen_op_mov_reg_T0(VAR_5, VAR_7);
tcg_gen_movi_tl(cpu_cc_dst, 1);
gen_set_label(VAR_29);
tcg_gen_discard_tl(cpu_cc_src);
s->cc_op = CC_OP_LOGICB + VAR_5;
}
tcg_temp_free(t0);
}
break;
case 0x27:
if (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_helper_daa(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x2f:
if (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_helper_das(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x37:
if (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_helper_aaa(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x3f:
if (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_helper_aas(cpu_env);
s->cc_op = CC_OP_EFLAGS;
break;
case 0xd4:
if (CODE64(s))
goto illegal_op;
VAR_18 = cpu_ldub_code(cpu_single_env, s->pc++);
if (VAR_18 == 0) {
gen_exception(s, EXCP00_DIVZ, pc_start - s->cs_base);
} else {
gen_helper_aam(cpu_env, tcg_const_i32(VAR_18));
s->cc_op = CC_OP_LOGICB;
}
break;
case 0xd5:
if (CODE64(s))
goto illegal_op;
VAR_18 = cpu_ldub_code(cpu_single_env, s->pc++);
gen_helper_aad(cpu_env, tcg_const_i32(VAR_18));
s->cc_op = CC_OP_LOGICB;
break;
case 0x90:
if (VAR_1 & PREFIX_LOCK) {
goto illegal_op;
}
if (REX_B(s)) {
goto do_xchg_reg_eax;
}
if (VAR_1 & PREFIX_REPZ) {
gen_svm_check_intercept(s, pc_start, SVM_EXIT_PAUSE);
}
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_jmp_im(pc_start - s->cs_base);
gen_helper_fwait(cpu_env);
}
break;
case 0xcc:
gen_interrupt(s, EXCP03_INT3, pc_start - s->cs_base, s->pc - s->cs_base);
break;
case 0xcd:
VAR_18 = cpu_ldub_code(cpu_single_env, s->pc++);
if (s->vm86 && s->iopl != 3) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_interrupt(s, VAR_18, pc_start - s->cs_base, s->pc - s->cs_base);
}
break;
case 0xce:
if (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_into(cpu_env, tcg_const_i32(s->pc - pc_start));
break;
#ifdef WANT_ICEBP
case 0xf1:
gen_svm_check_intercept(s, pc_start, SVM_EXIT_ICEBP);
#if 1
gen_debug(s, pc_start - s->cs_base);
#else
tb_flush(cpu_single_env);
cpu_set_log(CPU_LOG_INT | CPU_LOG_TB_IN_ASM);
#endif
break;
#endif
case 0xfa:
if (!s->vm86) {
if (s->cpl <= s->iopl) {
gen_helper_cli(cpu_env);
} else {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
}
} else {
if (s->iopl == 3) {
gen_helper_cli(cpu_env);
} 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_helper_sti(cpu_env);
if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
gen_helper_set_inhibit_irq(cpu_env);
gen_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:
if (CODE64(s))
goto illegal_op;
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = (VAR_6 >> 3) & 7;
VAR_9 = (VAR_6 >> 6) & 3;
if (VAR_9 == 3)
goto illegal_op;
gen_op_mov_TN_reg(VAR_5, 0, VAR_7);
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_jmp_im(pc_start - s->cs_base);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
if (VAR_5 == OT_WORD) {
gen_helper_boundw(cpu_env, cpu_A0, cpu_tmp2_i32);
} else {
gen_helper_boundl(cpu_env, cpu_A0, cpu_tmp2_i32);
}
break;
case 0x1c8 ... 0x1cf:
VAR_7 = (VAR_0 & 7) | REX_B(s);
#ifdef TARGET_X86_64
if (VAR_3 == 2) {
gen_op_mov_TN_reg(OT_QUAD, 0, VAR_7);
tcg_gen_bswap64_i64(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_QUAD, VAR_7);
} else
#endif
{
gen_op_mov_TN_reg(OT_LONG, 0, VAR_7);
tcg_gen_ext32u_tl(cpu_T[0], cpu_T[0]);
tcg_gen_bswap32_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_LONG, VAR_7);
}
break;
case 0xd6:
if (CODE64(s))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_compute_eflags_c(cpu_T[0]);
tcg_gen_neg_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(OT_BYTE, R_EAX);
break;
case 0xe0:
case 0xe1:
case 0xe2:
case 0xe3:
{
int VAR_27, VAR_27, VAR_28;
tval = (int8_t)insn_get(s, OT_BYTE);
next_eip = s->pc - s->cs_base;
tval += next_eip;
if (s->VAR_3 == 0)
tval &= 0xffff;
VAR_27 = gen_new_label();
VAR_27 = gen_new_label();
VAR_28 = gen_new_label();
VAR_0 &= 3;
switch(VAR_0) {
case 0:
case 1:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_add_reg_im(s->VAR_2, R_ECX, -1);
gen_op_jz_ecx(s->VAR_2, VAR_28);
gen_compute_eflags(cpu_tmp0);
tcg_gen_andi_tl(cpu_tmp0, cpu_tmp0, CC_Z);
if (VAR_0 == 0) {
tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, VAR_27);
} else {
tcg_gen_brcondi_tl(TCG_COND_NE, cpu_tmp0, 0, VAR_27);
}
break;
case 2:
gen_op_add_reg_im(s->VAR_2, R_ECX, -1);
gen_op_jnz_ecx(s->VAR_2, VAR_27);
break;
default:
case 3:
gen_op_jz_ecx(s->VAR_2, VAR_27);
break;
}
gen_set_label(VAR_28);
gen_jmp_im(next_eip);
tcg_gen_br(VAR_27);
gen_set_label(VAR_27);
gen_jmp_im(tval);
gen_set_label(VAR_27);
gen_eob(s);
}
break;
case 0x130:
case 0x132:
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_jmp_im(pc_start - s->cs_base);
if (VAR_0 & 2) {
gen_helper_rdmsr(cpu_env);
} else {
gen_helper_wrmsr(cpu_env);
}
}
break;
case 0x131:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
if (use_icount)
gen_io_start();
gen_helper_rdtsc(cpu_env);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
break;
case 0x133:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_rdpmc(cpu_env);
break;
case 0x134:
if (CODE64(s) && cpu_single_env->cpuid_vendor1 != CPUID_VENDOR_INTEL_1)
goto illegal_op;
if (!s->pe) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_update_cc_op(s);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_sysenter(cpu_env);
gen_eob(s);
}
break;
case 0x135:
if (CODE64(s) && cpu_single_env->cpuid_vendor1 != CPUID_VENDOR_INTEL_1)
goto illegal_op;
if (!s->pe) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_update_cc_op(s);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_sysexit(cpu_env, tcg_const_i32(VAR_3));
gen_eob(s);
}
break;
#ifdef TARGET_X86_64
case 0x105:
gen_update_cc_op(s);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_syscall(cpu_env, tcg_const_i32(s->pc - pc_start));
gen_eob(s);
break;
case 0x107:
if (!s->pe) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_update_cc_op(s);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_sysret(cpu_env, tcg_const_i32(s->VAR_3));
if (s->lma)
s->cc_op = CC_OP_EFLAGS;
gen_eob(s);
}
break;
#endif
case 0x1a2:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_cpuid(cpu_env);
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_jmp_im(pc_start - s->cs_base);
gen_helper_hlt(cpu_env, tcg_const_i32(s->pc - pc_start));
s->is_jmp = DISAS_TB_JUMP;
}
break;
case 0x100:
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_17 = (VAR_6 >> 3) & 7;
switch(VAR_17) {
case 0:
if (!s->pe || s->vm86)
goto illegal_op;
gen_svm_check_intercept(s, pc_start, SVM_EXIT_LDTR_READ);
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,ldt.VAR_27));
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_svm_check_intercept(s, pc_start, SVM_EXIT_LDTR_WRITE);
gen_ldst_modrm(s, VAR_6, OT_WORD, OR_TMP0, 0);
gen_jmp_im(pc_start - s->cs_base);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_lldt(cpu_env, cpu_tmp2_i32);
}
break;
case 1:
if (!s->pe || s->vm86)
goto illegal_op;
gen_svm_check_intercept(s, pc_start, SVM_EXIT_TR_READ);
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,tr.VAR_27));
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_svm_check_intercept(s, pc_start, SVM_EXIT_TR_WRITE);
gen_ldst_modrm(s, VAR_6, OT_WORD, OR_TMP0, 0);
gen_jmp_im(pc_start - s->cs_base);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_ltr(cpu_env, cpu_tmp2_i32);
}
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_17 == 4) {
gen_helper_verr(cpu_env, cpu_T[0]);
} else {
gen_helper_verw(cpu_env, cpu_T[0]);
}
s->cc_op = CC_OP_EFLAGS;
break;
default:
goto illegal_op;
}
break;
case 0x101:
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_17 = (VAR_6 >> 3) & 7;
VAR_8 = VAR_6 & 7;
switch(VAR_17) {
case 0:
if (VAR_9 == 3)
goto illegal_op;
gen_svm_check_intercept(s, pc_start, SVM_EXIT_GDTR_READ);
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, gdt.limit));
gen_op_st_T0_A0(OT_WORD + s->mem_index);
gen_add_A0_im(s, 2);
tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, gdt.base));
if (!s->VAR_3)
gen_op_andl_T0_im(0xffffff);
gen_op_st_T0_A0(CODE64(s) + OT_LONG + s->mem_index);
break;
case 1:
if (VAR_9 == 3) {
switch (VAR_8) {
case 0:
if (!(s->cpuid_ext_features & CPUID_EXT_MONITOR) ||
s->cpl != 0)
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
#ifdef TARGET_X86_64
if (s->VAR_2 == 2) {
gen_op_movq_A0_reg(R_EAX);
} else
#endif
{
gen_op_movl_A0_reg(R_EAX);
if (s->VAR_2 == 0)
gen_op_andl_A0_ffff();
}
gen_add_A0_ds_seg(s);
gen_helper_monitor(cpu_env, cpu_A0);
break;
case 1:
if (!(s->cpuid_ext_features & CPUID_EXT_MONITOR) ||
s->cpl != 0)
goto illegal_op;
gen_update_cc_op(s);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_mwait(cpu_env, tcg_const_i32(s->pc - pc_start));
gen_eob(s);
break;
default:
goto illegal_op;
}
} else {
gen_svm_check_intercept(s, pc_start, SVM_EXIT_IDTR_READ);
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, idt.limit));
gen_op_st_T0_A0(OT_WORD + s->mem_index);
gen_add_A0_im(s, 2);
tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, idt.base));
if (!s->VAR_3)
gen_op_andl_T0_im(0xffffff);
gen_op_st_T0_A0(CODE64(s) + OT_LONG + s->mem_index);
}
break;
case 2:
case 3:
if (VAR_9 == 3) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
switch(VAR_8) {
case 0:
if (!(s->flags & HF_SVME_MASK) || !s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_vmrun(cpu_env, tcg_const_i32(s->VAR_2),
tcg_const_i32(s->pc - pc_start));
tcg_gen_exit_tb(0);
s->is_jmp = DISAS_TB_JUMP;
}
break;
case 1:
if (!(s->flags & HF_SVME_MASK))
goto illegal_op;
gen_helper_vmmcall(cpu_env);
break;
case 2:
if (!(s->flags & HF_SVME_MASK) || !s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_vmload(cpu_env, tcg_const_i32(s->VAR_2));
}
break;
case 3:
if (!(s->flags & HF_SVME_MASK) || !s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_vmsave(cpu_env, tcg_const_i32(s->VAR_2));
}
break;
case 4:
if ((!(s->flags & HF_SVME_MASK) &&
!(s->cpuid_ext3_features & CPUID_EXT3_SKINIT)) ||
!s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_stgi(cpu_env);
}
break;
case 5:
if (!(s->flags & HF_SVME_MASK) || !s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_clgi(cpu_env);
}
break;
case 6:
if ((!(s->flags & HF_SVME_MASK) &&
!(s->cpuid_ext3_features & CPUID_EXT3_SKINIT)) ||
!s->pe)
goto illegal_op;
gen_helper_skinit(cpu_env);
break;
case 7:
if (!(s->flags & HF_SVME_MASK) || !s->pe)
goto illegal_op;
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
break;
} else {
gen_helper_invlpga(cpu_env, tcg_const_i32(s->VAR_2));
}
break;
default:
goto illegal_op;
}
} else if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_svm_check_intercept(s, pc_start,
VAR_17==2 ? SVM_EXIT_GDTR_WRITE : SVM_EXIT_IDTR_WRITE);
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_op_ld_T1_A0(OT_WORD + s->mem_index);
gen_add_A0_im(s, 2);
gen_op_ld_T0_A0(CODE64(s) + OT_LONG + s->mem_index);
if (!s->VAR_3)
gen_op_andl_T0_im(0xffffff);
if (VAR_17 == 2) {
tcg_gen_st_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,gdt.base));
tcg_gen_st32_tl(cpu_T[1], cpu_env, offsetof(CPUX86State,gdt.limit));
} else {
tcg_gen_st_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,idt.base));
tcg_gen_st32_tl(cpu_T[1], cpu_env, offsetof(CPUX86State,idt.limit));
}
}
break;
case 4:
gen_svm_check_intercept(s, pc_start, SVM_EXIT_READ_CR0);
#if defined TARGET_X86_64 && defined HOST_WORDS_BIGENDIAN
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,cr[0]) + 4);
#else
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,cr[0]));
#endif
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_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_CR0);
gen_ldst_modrm(s, VAR_6, OT_WORD, OR_TMP0, 0);
gen_helper_lmsw(cpu_env, cpu_T[0]);
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 7:
if (VAR_9 != 3) {
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_jmp_im(pc_start - s->cs_base);
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
gen_helper_invlpg(cpu_env, cpu_A0);
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
} else {
switch (VAR_8) {
case 0:
#ifdef TARGET_X86_64
if (CODE64(s)) {
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
tcg_gen_ld_tl(cpu_T[0], cpu_env,
offsetof(CPUX86State,segs[R_GS].base));
tcg_gen_ld_tl(cpu_T[1], cpu_env,
offsetof(CPUX86State,kernelgsbase));
tcg_gen_st_tl(cpu_T[1], cpu_env,
offsetof(CPUX86State,segs[R_GS].base));
tcg_gen_st_tl(cpu_T[0], cpu_env,
offsetof(CPUX86State,kernelgsbase));
}
} else
#endif
{
goto illegal_op;
}
break;
case 1:
if (!(s->cpuid_ext2_features & CPUID_EXT2_RDTSCP))
goto illegal_op;
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
if (use_icount)
gen_io_start();
gen_helper_rdtscp(cpu_env);
if (use_icount) {
gen_io_end();
gen_jmp(s, s->pc - s->cs_base);
}
break;
default:
goto illegal_op;
}
}
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 {
gen_svm_check_intercept(s, pc_start, (VAR_0 & 2) ? SVM_EXIT_INVD : SVM_EXIT_WBINVD);
}
break;
case 0x63:
#ifdef TARGET_X86_64
if (CODE64(s)) {
int VAR_21;
VAR_21 = VAR_3 + OT_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
VAR_9 = (VAR_6 >> 6) & 3;
VAR_8 = (VAR_6 & 7) | REX_B(s);
if (VAR_9 == 3) {
gen_op_mov_TN_reg(OT_LONG, 0, VAR_8);
if (VAR_21 == OT_QUAD)
tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
gen_op_mov_reg_T0(VAR_21, VAR_7);
} else {
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
if (VAR_21 == OT_QUAD) {
gen_op_lds_T0_A0(OT_LONG + s->mem_index);
} else {
gen_op_ld_T0_A0(OT_LONG + s->mem_index);
}
gen_op_mov_reg_T0(VAR_21, VAR_7);
}
} else
#endif
{
int VAR_29;
TCGv t0, t1, t2, a0;
if (!s->pe || s->vm86)
goto illegal_op;
t0 = tcg_temp_local_new();
t1 = tcg_temp_local_new();
t2 = tcg_temp_local_new();
VAR_5 = OT_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, 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_v(VAR_5 + s->mem_index, t0, cpu_A0);
a0 = tcg_temp_local_new();
tcg_gen_mov_tl(a0, cpu_A0);
} else {
gen_op_mov_v_reg(VAR_5, t0, VAR_8);
TCGV_UNUSED(a0);
}
gen_op_mov_v_reg(VAR_5, t1, VAR_7);
tcg_gen_andi_tl(cpu_tmp0, t0, 3);
tcg_gen_andi_tl(t1, t1, 3);
tcg_gen_movi_tl(t2, 0);
VAR_29 = gen_new_label();
tcg_gen_brcond_tl(TCG_COND_GE, cpu_tmp0, t1, VAR_29);
tcg_gen_andi_tl(t0, t0, ~3);
tcg_gen_or_tl(t0, t0, t1);
tcg_gen_movi_tl(t2, CC_Z);
gen_set_label(VAR_29);
if (VAR_9 != 3) {
gen_op_st_v(VAR_5 + s->mem_index, t0, a0);
tcg_temp_free(a0);
} else {
gen_op_mov_reg_v(VAR_5, VAR_8, t0);
}
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_compute_eflags(cpu_cc_src);
tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, ~CC_Z);
tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, t2);
s->cc_op = CC_OP_EFLAGS;
tcg_temp_free(t0);
tcg_temp_free(t1);
tcg_temp_free(t2);
}
break;
case 0x102:
case 0x103:
{
int VAR_29;
TCGv t0;
if (!s->pe || s->vm86)
goto illegal_op;
VAR_5 = VAR_3 ? OT_LONG : OT_WORD;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
gen_ldst_modrm(s, VAR_6, OT_WORD, OR_TMP0, 0);
t0 = tcg_temp_local_new();
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
if (VAR_0 == 0x102) {
gen_helper_lar(t0, cpu_env, cpu_T[0]);
} else {
gen_helper_lsl(t0, cpu_env, cpu_T[0]);
}
tcg_gen_andi_tl(cpu_tmp0, cpu_cc_src, CC_Z);
VAR_29 = gen_new_label();
tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, VAR_29);
gen_op_mov_reg_v(VAR_5, VAR_7, t0);
gen_set_label(VAR_29);
s->cc_op = CC_OP_EFLAGS;
tcg_temp_free(t0);
}
break;
case 0x118:
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_17 = (VAR_6 >> 3) & 7;
switch(VAR_17) {
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:
gen_nop_modrm(s, VAR_6);
break;
}
break;
case 0x119 ... 0x11f:
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
gen_nop_modrm(s, VAR_6);
break;
case 0x120:
case 0x122:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_8 = (VAR_6 & 7) | REX_B(s);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
if (CODE64(s))
VAR_5 = OT_QUAD;
else
VAR_5 = OT_LONG;
if ((VAR_1 & PREFIX_LOCK) && (VAR_7 == 0) &&
(s->cpuid_ext3_features & CPUID_EXT3_CR8LEG)) {
VAR_7 = 8;
}
switch(VAR_7) {
case 0:
case 2:
case 3:
case 4:
case 8:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
if (VAR_0 & 2) {
gen_op_mov_TN_reg(VAR_5, 0, VAR_8);
gen_helper_write_crN(cpu_env, tcg_const_i32(VAR_7),
cpu_T[0]);
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
} else {
gen_helper_read_crN(cpu_T[0], cpu_env, tcg_const_i32(VAR_7));
gen_op_mov_reg_T0(VAR_5, 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 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_8 = (VAR_6 & 7) | REX_B(s);
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
if (CODE64(s))
VAR_5 = OT_QUAD;
else
VAR_5 = OT_LONG;
if (VAR_7 == 4 || VAR_7 == 5 || VAR_7 >= 8)
goto illegal_op;
if (VAR_0 & 2) {
gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_DR0 + VAR_7);
gen_op_mov_TN_reg(VAR_5, 0, VAR_8);
gen_helper_movl_drN_T0(cpu_env, tcg_const_i32(VAR_7), cpu_T[0]);
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
} else {
gen_svm_check_intercept(s, pc_start, SVM_EXIT_READ_DR0 + VAR_7);
tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,dr[VAR_7]));
gen_op_mov_reg_T0(VAR_5, VAR_8);
}
}
break;
case 0x106:
if (s->cpl != 0) {
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
} else {
gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_CR0);
gen_helper_clts(cpu_env);
gen_jmp_im(s->pc - s->cs_base);
gen_eob(s);
}
break;
case 0x1c3:
if (!(s->cpuid_features & CPUID_SSE2))
goto illegal_op;
VAR_5 = s->VAR_3 == 2 ? OT_QUAD : OT_LONG;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
if (VAR_9 == 3)
goto illegal_op;
VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;
gen_ldst_modrm(s, VAR_6, VAR_5, VAR_7, 1);
break;
case 0x1ae:
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
VAR_17 = (VAR_6 >> 3) & 7;
switch(VAR_17) {
case 0:
if (VAR_9 == 3 || !(s->cpuid_features & CPUID_FXSR) ||
(s->prefix & PREFIX_LOCK))
goto illegal_op;
if ((s->flags & HF_EM_MASK) || (s->flags & HF_TS_MASK)) {
gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
break;
}
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fxsave(cpu_env, cpu_A0, tcg_const_i32((s->VAR_3 == 2)));
break;
case 1:
if (VAR_9 == 3 || !(s->cpuid_features & CPUID_FXSR) ||
(s->prefix & PREFIX_LOCK))
goto illegal_op;
if ((s->flags & HF_EM_MASK) || (s->flags & HF_TS_MASK)) {
gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
break;
}
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_jmp_im(pc_start - s->cs_base);
gen_helper_fxrstor(cpu_env, cpu_A0,
tcg_const_i32((s->VAR_3 == 2)));
break;
case 2:
case 3:
if (s->flags & HF_TS_MASK) {
gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
break;
}
if ((s->flags & HF_EM_MASK) || !(s->flags & HF_OSFXSR_MASK) ||
VAR_9 == 3)
goto illegal_op;
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
if (VAR_17 == 2) {
gen_op_ld_T0_A0(OT_LONG + s->mem_index);
tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
gen_helper_ldmxcsr(cpu_env, cpu_tmp2_i32);
} else {
tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, mxcsr));
gen_op_st_T0_A0(OT_LONG + s->mem_index);
}
break;
case 5:
case 6:
if ((VAR_6 & 0xc7) != 0xc0 || !(s->cpuid_features & CPUID_SSE2))
goto illegal_op;
break;
case 7:
if ((VAR_6 & 0xc7) == 0xc0) {
if (!(s->cpuid_features & CPUID_SSE))
goto illegal_op;
} else {
if (!(s->cpuid_features & CPUID_CLFLUSH))
goto illegal_op;
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
}
break;
default:
goto illegal_op;
}
break;
case 0x10d:
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_9 = (VAR_6 >> 6) & 3;
if (VAR_9 == 3)
goto illegal_op;
gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);
break;
case 0x1aa:
gen_svm_check_intercept(s, pc_start, SVM_EXIT_RSM);
if (!(s->flags & HF_SMM_MASK))
goto illegal_op;
gen_update_cc_op(s);
gen_jmp_im(s->pc - s->cs_base);
gen_helper_rsm(cpu_env);
gen_eob(s);
break;
case 0x1b8:
if ((VAR_1 & (PREFIX_REPZ | PREFIX_LOCK | PREFIX_REPNZ)) !=
PREFIX_REPZ)
goto illegal_op;
if (!(s->cpuid_ext_features & CPUID_EXT_POPCNT))
goto illegal_op;
VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);
VAR_7 = ((VAR_6 >> 3) & 7);
if (s->prefix & PREFIX_DATA)
VAR_5 = OT_WORD;
else if (s->VAR_3 != 2)
VAR_5 = OT_LONG;
else
VAR_5 = OT_QUAD;
gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 0);
gen_helper_popcnt(cpu_T[0], cpu_env, cpu_T[0], tcg_const_i32(VAR_5));
gen_op_mov_reg_T0(VAR_5, VAR_7);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x10e ... 0x10f:
s->prefix &= ~(PREFIX_REPZ | PREFIX_REPNZ | PREFIX_DATA);
case 0x110 ... 0x117:
case 0x128 ... 0x12f:
case 0x138 ... 0x13a:
case 0x150 ... 0x179:
case 0x17c ... 0x17f:
case 0x1c2:
case 0x1c4 ... 0x1c6:
case 0x1d0 ... 0x1fe:
gen_sse(s, VAR_0, pc_start, VAR_16);
break;
default:
goto illegal_op;
}
if (s->prefix & PREFIX_LOCK)
gen_helper_unlock();
return s->pc;
illegal_op:
if (s->prefix & PREFIX_LOCK)
gen_helper_unlock();
gen_exception(s, EXCP06_ILLOP, pc_start - s->cs_base);
return s->pc;
}
| [
"static target_ulong FUNC_0(DisasContext *s, target_ulong 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_17, VAR_12, VAR_13, VAR_18;",
"target_ulong next_eip, tval;",
"int VAR_15, VAR_16;",
"if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP | CPU_LOG_TB_OP_OPT))) {",
"tcg_gen_debug_insn_start(pc_start);",
"}",
"s->pc = pc_start;",
"VAR_1 = 0;",
"VAR_2 = s->code32;",
"VAR_3 = s->code32;",
"s->override = -1;",
"VAR_15 = -1;",
"VAR_16 = 0;",
"#ifdef TARGET_X86_64\ns->rex_x = 0;",
"s->rex_b = 0;",
"x86_64_hregs = 0;",
"#endif\ns->rip_offset = 0;",
"next_byte:\nVAR_0 = cpu_ldub_code(cpu_single_env, s->pc);",
"s->pc++;",
"#ifdef TARGET_X86_64\nif (CODE64(s)) {",
"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->override = R_CS;",
"goto next_byte;",
"case 0x36:\ns->override = R_SS;",
"goto next_byte;",
"case 0x3e:\ns->override = R_DS;",
"goto next_byte;",
"case 0x26:\ns->override = R_ES;",
"goto next_byte;",
"case 0x64:\ns->override = R_FS;",
"goto next_byte;",
"case 0x65:\ns->override = R_GS;",
"goto next_byte;",
"case 0x66:\nVAR_1 |= PREFIX_DATA;",
"goto next_byte;",
"case 0x67:\nVAR_1 |= PREFIX_ADR;",
"goto next_byte;",
"case 0x40 ... 0x4f:\nVAR_15 = (VAR_0 >> 3) & 1;",
"VAR_16 = (VAR_0 & 0x4) << 1;",
"s->rex_x = (VAR_0 & 0x2) << 2;",
"REX_B(s) = (VAR_0 & 0x1) << 3;",
"x86_64_hregs = 1;",
"goto next_byte;",
"}",
"if (VAR_15 == 1) {",
"VAR_3 = 2;",
"} else {",
"if (VAR_1 & PREFIX_DATA)\nVAR_3 ^= 1;",
"}",
"if (!(VAR_1 & PREFIX_ADR))\nVAR_2 = 2;",
"} else",
"#endif\n{",
"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->override = R_CS;",
"goto next_byte;",
"case 0x36:\ns->override = R_SS;",
"goto next_byte;",
"case 0x3e:\ns->override = R_DS;",
"goto next_byte;",
"case 0x26:\ns->override = R_ES;",
"goto next_byte;",
"case 0x64:\ns->override = R_FS;",
"goto next_byte;",
"case 0x65:\ns->override = 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_helper_lock();",
"reswitch:\nswitch(VAR_0) {",
"case 0x0f:\nVAR_0 = cpu_ldub_code(cpu_single_env, 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_17, VAR_17, VAR_18;",
"VAR_17 = (VAR_0 >> 3) & 7;",
"VAR_17 = (VAR_0 >> 1) & 3;",
"if ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_5 = VAR_3 + OT_WORD;",
"switch(VAR_17) {",
"case 0:\nVAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_8 = (VAR_6 & 7) | REX_B(s);",
"if (VAR_9 != 3) {",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"VAR_12 = OR_TMP0;",
"} else if (VAR_17 == 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_17, VAR_5, VAR_12);",
"break;",
"case 1:\nVAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"VAR_8 = (VAR_6 & 7) | REX_B(s);",
"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_17 == OP_XORL && VAR_8 == VAR_7) {",
"goto xor_zero;",
"} else {",
"gen_op_mov_TN_reg(VAR_5, 1, VAR_8);",
"}",
"gen_op(s, VAR_17, VAR_5, VAR_7);",
"break;",
"case 2:\nVAR_18 = insn_get(s, VAR_5);",
"gen_op_movl_T1_im(VAR_18);",
"gen_op(s, VAR_17, VAR_5, OR_EAX);",
"break;",
"}",
"}",
"break;",
"case 0x82:\nif (CODE64(s))\ngoto illegal_op;",
"case 0x80:\ncase 0x81:\ncase 0x83:\n{",
"int VAR_18;",
"if ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_5 = VAR_3 + OT_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_8 = (VAR_6 & 7) | REX_B(s);",
"VAR_17 = (VAR_6 >> 3) & 7;",
"if (VAR_9 != 3) {",
"if (VAR_0 == 0x83)\ns->rip_offset = 1;",
"else\ns->rip_offset = insn_const_size(VAR_5);",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"VAR_12 = OR_TMP0;",
"} else {",
"VAR_12 = VAR_8;",
"}",
"switch(VAR_0) {",
"default:\ncase 0x80:\ncase 0x81:\ncase 0x82:\nVAR_18 = insn_get(s, VAR_5);",
"break;",
"case 0x83:\nVAR_18 = (int8_t)insn_get(s, OT_BYTE);",
"break;",
"}",
"gen_op_movl_T1_im(VAR_18);",
"gen_op(s, VAR_17, 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_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_8 = (VAR_6 & 7) | REX_B(s);",
"VAR_17 = (VAR_6 >> 3) & 7;",
"if (VAR_9 != 3) {",
"if (VAR_17 == 0)\ns->rip_offset = insn_const_size(VAR_5);",
"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_17) {",
"case 0:\nVAR_18 = insn_get(s, VAR_5);",
"gen_op_movl_T1_im(VAR_18);",
"gen_op_testl_T0_T1_cc();",
"s->cc_op = CC_OP_LOGICB + VAR_5;",
"break;",
"case 2:\ntcg_gen_not_tl(cpu_T[0], cpu_T[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);",
"}",
"break;",
"case 3:\ntcg_gen_neg_tl(cpu_T[0], cpu_T[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_neg_cc();",
"s->cc_op = CC_OP_SUBB + VAR_5;",
"break;",
"case 4:\nswitch(VAR_5) {",
"case OT_BYTE:\ngen_op_mov_TN_reg(OT_BYTE, 1, R_EAX);",
"tcg_gen_ext8u_tl(cpu_T[0], cpu_T[0]);",
"tcg_gen_ext8u_tl(cpu_T[1], cpu_T[1]);",
"tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);",
"gen_op_mov_reg_T0(OT_WORD, R_EAX);",
"tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);",
"tcg_gen_andi_tl(cpu_cc_src, cpu_T[0], 0xff00);",
"s->cc_op = CC_OP_MULB;",
"break;",
"case OT_WORD:\ngen_op_mov_TN_reg(OT_WORD, 1, R_EAX);",
"tcg_gen_ext16u_tl(cpu_T[0], cpu_T[0]);",
"tcg_gen_ext16u_tl(cpu_T[1], cpu_T[1]);",
"tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);",
"gen_op_mov_reg_T0(OT_WORD, R_EAX);",
"tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);",
"tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 16);",
"gen_op_mov_reg_T0(OT_WORD, R_EDX);",
"tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);",
"s->cc_op = CC_OP_MULW;",
"break;",
"default:\ncase OT_LONG:\n#ifdef TARGET_X86_64\ngen_op_mov_TN_reg(OT_LONG, 1, R_EAX);",
"tcg_gen_ext32u_tl(cpu_T[0], cpu_T[0]);",
"tcg_gen_ext32u_tl(cpu_T[1], cpu_T[1]);",
"tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);",
"gen_op_mov_reg_T0(OT_LONG, R_EAX);",
"tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);",
"tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 32);",
"gen_op_mov_reg_T0(OT_LONG, R_EDX);",
"tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);",
"#else\n{",
"TCGv_i64 t0, t1;",
"t0 = tcg_temp_new_i64();",
"t1 = tcg_temp_new_i64();",
"gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);",
"tcg_gen_extu_i32_i64(t0, cpu_T[0]);",
"tcg_gen_extu_i32_i64(t1, cpu_T[1]);",
"tcg_gen_mul_i64(t0, t0, t1);",
"tcg_gen_trunc_i64_i32(cpu_T[0], t0);",
"gen_op_mov_reg_T0(OT_LONG, R_EAX);",
"tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);",
"tcg_gen_shri_i64(t0, t0, 32);",
"tcg_gen_trunc_i64_i32(cpu_T[0], t0);",
"gen_op_mov_reg_T0(OT_LONG, R_EDX);",
"tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);",
"}",
"#endif\ns->cc_op = CC_OP_MULL;",
"break;",
"#ifdef TARGET_X86_64\ncase OT_QUAD:\ngen_helper_mulq_EAX_T0(cpu_env, cpu_T[0]);",
"s->cc_op = CC_OP_MULQ;",
"break;",
"#endif\n}",
"break;",
"case 5:\nswitch(VAR_5) {",
"case OT_BYTE:\ngen_op_mov_TN_reg(OT_BYTE, 1, R_EAX);",
"tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);",
"tcg_gen_ext8s_tl(cpu_T[1], cpu_T[1]);",
"tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);",
"gen_op_mov_reg_T0(OT_WORD, R_EAX);",
"tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);",
"tcg_gen_ext8s_tl(cpu_tmp0, cpu_T[0]);",
"tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);",
"s->cc_op = CC_OP_MULB;",
"break;",
"case OT_WORD:\ngen_op_mov_TN_reg(OT_WORD, 1, R_EAX);",
"tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);",
"tcg_gen_ext16s_tl(cpu_T[1], cpu_T[1]);",
"tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);",
"gen_op_mov_reg_T0(OT_WORD, R_EAX);",
"tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);",
"tcg_gen_ext16s_tl(cpu_tmp0, cpu_T[0]);",
"tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);",
"tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 16);",
"gen_op_mov_reg_T0(OT_WORD, R_EDX);",
"s->cc_op = CC_OP_MULW;",
"break;",
"default:\ncase OT_LONG:\n#ifdef TARGET_X86_64\ngen_op_mov_TN_reg(OT_LONG, 1, R_EAX);",
"tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);",
"tcg_gen_ext32s_tl(cpu_T[1], cpu_T[1]);",
"tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);",
"gen_op_mov_reg_T0(OT_LONG, R_EAX);",
"tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);",
"tcg_gen_ext32s_tl(cpu_tmp0, cpu_T[0]);",
"tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);",
"tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 32);",
"gen_op_mov_reg_T0(OT_LONG, R_EDX);",
"#else\n{",
"TCGv_i64 t0, t1;",
"t0 = tcg_temp_new_i64();",
"t1 = tcg_temp_new_i64();",
"gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);",
"tcg_gen_ext_i32_i64(t0, cpu_T[0]);",
"tcg_gen_ext_i32_i64(t1, cpu_T[1]);",
"tcg_gen_mul_i64(t0, t0, t1);",
"tcg_gen_trunc_i64_i32(cpu_T[0], t0);",
"gen_op_mov_reg_T0(OT_LONG, R_EAX);",
"tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);",
"tcg_gen_sari_tl(cpu_tmp0, cpu_T[0], 31);",
"tcg_gen_shri_i64(t0, t0, 32);",
"tcg_gen_trunc_i64_i32(cpu_T[0], t0);",
"gen_op_mov_reg_T0(OT_LONG, R_EDX);",
"tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);",
"}",
"#endif\ns->cc_op = CC_OP_MULL;",
"break;",
"#ifdef TARGET_X86_64\ncase OT_QUAD:\ngen_helper_imulq_EAX_T0(cpu_env, cpu_T[0]);",
"s->cc_op = CC_OP_MULQ;",
"break;",
"#endif\n}",
"break;",
"case 6:\nswitch(VAR_5) {",
"case OT_BYTE:\ngen_jmp_im(pc_start - s->cs_base);",
"gen_helper_divb_AL(cpu_env, cpu_T[0]);",
"break;",
"case OT_WORD:\ngen_jmp_im(pc_start - s->cs_base);",
"gen_helper_divw_AX(cpu_env, cpu_T[0]);",
"break;",
"default:\ncase OT_LONG:\ngen_jmp_im(pc_start - s->cs_base);",
"gen_helper_divl_EAX(cpu_env, cpu_T[0]);",
"break;",
"#ifdef TARGET_X86_64\ncase OT_QUAD:\ngen_jmp_im(pc_start - s->cs_base);",
"gen_helper_divq_EAX(cpu_env, cpu_T[0]);",
"break;",
"#endif\n}",
"break;",
"case 7:\nswitch(VAR_5) {",
"case OT_BYTE:\ngen_jmp_im(pc_start - s->cs_base);",
"gen_helper_idivb_AL(cpu_env, cpu_T[0]);",
"break;",
"case OT_WORD:\ngen_jmp_im(pc_start - s->cs_base);",
"gen_helper_idivw_AX(cpu_env, cpu_T[0]);",
"break;",
"default:\ncase OT_LONG:\ngen_jmp_im(pc_start - s->cs_base);",
"gen_helper_idivl_EAX(cpu_env, cpu_T[0]);",
"break;",
"#ifdef TARGET_X86_64\ncase OT_QUAD:\ngen_jmp_im(pc_start - s->cs_base);",
"gen_helper_idivq_EAX(cpu_env, cpu_T[0]);",
"break;",
"#endif\n}",
"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_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_8 = (VAR_6 & 7) | REX_B(s);",
"VAR_17 = (VAR_6 >> 3) & 7;",
"if (VAR_17 >= 2 && VAR_0 == 0xfe) {",
"goto illegal_op;",
"}",
"if (CODE64(s)) {",
"if (VAR_17 == 2 || VAR_17 == 4) {",
"VAR_5 = OT_QUAD;",
"} else if (VAR_17 == 3 || VAR_17 == 5) {",
"VAR_5 = VAR_3 ? OT_LONG + (VAR_15 == 1) : OT_WORD;",
"} else if (VAR_17 == 6) {",
"VAR_5 = VAR_3 ? OT_QUAD : OT_WORD;",
"}",
"}",
"if (VAR_9 != 3) {",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"if (VAR_17 >= 2 && VAR_17 != 3 && VAR_17 != 5)\ngen_op_ld_T0_A0(VAR_5 + s->mem_index);",
"} else {",
"gen_op_mov_TN_reg(VAR_5, 0, VAR_8);",
"}",
"switch(VAR_17) {",
"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();",
"next_eip = s->pc - s->cs_base;",
"gen_movtl_T1_im(next_eip);",
"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_add_A0_im(s, 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_jmp_im(pc_start - s->cs_base);",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"gen_helper_lcall_protected(cpu_env, cpu_tmp2_i32, cpu_T[1],\ntcg_const_i32(VAR_3),\ntcg_const_i32(s->pc - pc_start));",
"} else {",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"gen_helper_lcall_real(cpu_env, cpu_tmp2_i32, cpu_T[1],\ntcg_const_i32(VAR_3),\ntcg_const_i32(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_add_A0_im(s, 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_jmp_im(pc_start - s->cs_base);",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"gen_helper_ljmp_protected(cpu_env, cpu_tmp2_i32, cpu_T[1],\ntcg_const_i32(s->pc - pc_start));",
"} else {",
"gen_op_movl_seg_T0_vm(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_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 0);",
"gen_op_mov_TN_reg(VAR_5, 1, VAR_7);",
"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_WORD;",
"VAR_18 = insn_get(s, VAR_5);",
"gen_op_mov_TN_reg(VAR_5, 0, OR_EAX);",
"gen_op_movl_T1_im(VAR_18);",
"gen_op_testl_T0_T1_cc();",
"s->cc_op = CC_OP_LOGICB + VAR_5;",
"break;",
"case 0x98:\n#ifdef TARGET_X86_64\nif (VAR_3 == 2) {",
"gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);",
"tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);",
"gen_op_mov_reg_T0(OT_QUAD, R_EAX);",
"} else",
"#endif\nif (VAR_3 == 1) {",
"gen_op_mov_TN_reg(OT_WORD, 0, R_EAX);",
"tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);",
"gen_op_mov_reg_T0(OT_LONG, R_EAX);",
"} else {",
"gen_op_mov_TN_reg(OT_BYTE, 0, R_EAX);",
"tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);",
"gen_op_mov_reg_T0(OT_WORD, R_EAX);",
"}",
"break;",
"case 0x99:\n#ifdef TARGET_X86_64\nif (VAR_3 == 2) {",
"gen_op_mov_TN_reg(OT_QUAD, 0, R_EAX);",
"tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 63);",
"gen_op_mov_reg_T0(OT_QUAD, R_EDX);",
"} else",
"#endif\nif (VAR_3 == 1) {",
"gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);",
"tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);",
"tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 31);",
"gen_op_mov_reg_T0(OT_LONG, R_EDX);",
"} else {",
"gen_op_mov_TN_reg(OT_WORD, 0, R_EAX);",
"tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);",
"tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 15);",
"gen_op_mov_reg_T0(OT_WORD, R_EDX);",
"}",
"break;",
"case 0x1af:\ncase 0x69:\ncase 0x6b:\nVAR_5 = VAR_3 + OT_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"if (VAR_0 == 0x69)\ns->rip_offset = insn_const_size(VAR_5);",
"else if (VAR_0 == 0x6b)\ns->rip_offset = 1;",
"gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 0);",
"if (VAR_0 == 0x69) {",
"VAR_18 = insn_get(s, VAR_5);",
"gen_op_movl_T1_im(VAR_18);",
"} else if (VAR_0 == 0x6b) {",
"VAR_18 = (int8_t)insn_get(s, OT_BYTE);",
"gen_op_movl_T1_im(VAR_18);",
"} else {",
"gen_op_mov_TN_reg(VAR_5, 1, VAR_7);",
"}",
"#ifdef TARGET_X86_64\nif (VAR_5 == OT_QUAD) {",
"gen_helper_imulq_T0_T1(cpu_T[0], cpu_env, cpu_T[0], cpu_T[1]);",
"} else",
"#endif\nif (VAR_5 == OT_LONG) {",
"#ifdef TARGET_X86_64\ntcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);",
"tcg_gen_ext32s_tl(cpu_T[1], cpu_T[1]);",
"tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);",
"tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);",
"tcg_gen_ext32s_tl(cpu_tmp0, cpu_T[0]);",
"tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);",
"#else\n{",
"TCGv_i64 t0, t1;",
"t0 = tcg_temp_new_i64();",
"t1 = tcg_temp_new_i64();",
"tcg_gen_ext_i32_i64(t0, cpu_T[0]);",
"tcg_gen_ext_i32_i64(t1, cpu_T[1]);",
"tcg_gen_mul_i64(t0, t0, t1);",
"tcg_gen_trunc_i64_i32(cpu_T[0], t0);",
"tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);",
"tcg_gen_sari_tl(cpu_tmp0, cpu_T[0], 31);",
"tcg_gen_shri_i64(t0, t0, 32);",
"tcg_gen_trunc_i64_i32(cpu_T[1], t0);",
"tcg_gen_sub_tl(cpu_cc_src, cpu_T[1], cpu_tmp0);",
"}",
"#endif\n} else {",
"tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);",
"tcg_gen_ext16s_tl(cpu_T[1], cpu_T[1]);",
"tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);",
"tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);",
"tcg_gen_ext16s_tl(cpu_tmp0, cpu_T[0]);",
"tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);",
"}",
"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_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"VAR_9 = (VAR_6 >> 6) & 3;",
"if (VAR_9 == 3) {",
"VAR_8 = (VAR_6 & 7) | REX_B(s);",
"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:\n{",
"int VAR_29, VAR_19;",
"TCGv t0, t1, t2, a0;",
"if ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_5 = VAR_3 + OT_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"VAR_9 = (VAR_6 >> 6) & 3;",
"t0 = tcg_temp_local_new();",
"t1 = tcg_temp_local_new();",
"t2 = tcg_temp_local_new();",
"a0 = tcg_temp_local_new();",
"gen_op_mov_v_reg(VAR_5, t1, VAR_7);",
"if (VAR_9 == 3) {",
"VAR_8 = (VAR_6 & 7) | REX_B(s);",
"gen_op_mov_v_reg(VAR_5, t0, VAR_8);",
"} else {",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"tcg_gen_mov_tl(a0, cpu_A0);",
"gen_op_ld_v(VAR_5 + s->mem_index, t0, a0);",
"VAR_8 = 0;",
"}",
"VAR_29 = gen_new_label();",
"tcg_gen_sub_tl(t2, cpu_regs[R_EAX], t0);",
"gen_extu(VAR_5, t2);",
"tcg_gen_brcondi_tl(TCG_COND_EQ, t2, 0, VAR_29);",
"VAR_19 = gen_new_label();",
"if (VAR_9 == 3) {",
"gen_op_mov_reg_v(VAR_5, R_EAX, t0);",
"tcg_gen_br(VAR_19);",
"gen_set_label(VAR_29);",
"gen_op_mov_reg_v(VAR_5, VAR_8, t1);",
"} else {",
"gen_op_st_v(VAR_5 + s->mem_index, t0, a0);",
"gen_op_mov_reg_v(VAR_5, R_EAX, t0);",
"tcg_gen_br(VAR_19);",
"gen_set_label(VAR_29);",
"gen_op_st_v(VAR_5 + s->mem_index, t1, a0);",
"}",
"gen_set_label(VAR_19);",
"tcg_gen_mov_tl(cpu_cc_src, t0);",
"tcg_gen_mov_tl(cpu_cc_dst, t2);",
"s->cc_op = CC_OP_SUBB + VAR_5;",
"tcg_temp_free(t0);",
"tcg_temp_free(t1);",
"tcg_temp_free(t2);",
"tcg_temp_free(a0);",
"}",
"break;",
"case 0x1c7:\nVAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"if ((VAR_9 == 3) || ((VAR_6 & 0x38) != 0x8))\ngoto illegal_op;",
"#ifdef TARGET_X86_64\nif (VAR_3 == 2) {",
"if (!(s->cpuid_ext_features & CPUID_EXT_CX16))\ngoto illegal_op;",
"gen_jmp_im(pc_start - s->cs_base);",
"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_helper_cmpxchg16b(cpu_env, cpu_A0);",
"} else",
"#endif\n{",
"if (!(s->cpuid_features & CPUID_CX8))\ngoto illegal_op;",
"gen_jmp_im(pc_start - s->cs_base);",
"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_helper_cmpxchg8b(cpu_env, cpu_A0);",
"}",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x50 ... 0x57:\ngen_op_mov_TN_reg(OT_LONG, 0, (VAR_0 & 7) | REX_B(s));",
"gen_push_T0(s);",
"break;",
"case 0x58 ... 0x5f:\nif (CODE64(s)) {",
"VAR_5 = VAR_3 ? OT_QUAD : OT_WORD;",
"} else {",
"VAR_5 = VAR_3 + OT_WORD;",
"}",
"gen_pop_T0(s);",
"gen_pop_update(s);",
"gen_op_mov_reg_T0(VAR_5, (VAR_0 & 7) | REX_B(s));",
"break;",
"case 0x60:\nif (CODE64(s))\ngoto illegal_op;",
"gen_pusha(s);",
"break;",
"case 0x61:\nif (CODE64(s))\ngoto illegal_op;",
"gen_popa(s);",
"break;",
"case 0x68:\ncase 0x6a:\nif (CODE64(s)) {",
"VAR_5 = VAR_3 ? OT_QUAD : OT_WORD;",
"} else {",
"VAR_5 = VAR_3 + OT_WORD;",
"}",
"if (VAR_0 == 0x68)\nVAR_18 = insn_get(s, VAR_5);",
"else\nVAR_18 = (int8_t)insn_get(s, OT_BYTE);",
"gen_op_movl_T0_im(VAR_18);",
"gen_push_T0(s);",
"break;",
"case 0x8f:\nif (CODE64(s)) {",
"VAR_5 = VAR_3 ? OT_QUAD : OT_WORD;",
"} else {",
"VAR_5 = VAR_3 + OT_WORD;",
"}",
"VAR_6 = cpu_ldub_code(cpu_single_env, 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) | REX_B(s);",
"gen_op_mov_reg_T0(VAR_5, VAR_8);",
"} else {",
"s->popl_esp_hack = 1 << VAR_5;",
"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_20;",
"VAR_18 = cpu_lduw_code(cpu_single_env, s->pc);",
"s->pc += 2;",
"VAR_20 = cpu_ldub_code(cpu_single_env, s->pc++);",
"gen_enter(s, VAR_18, VAR_20);",
"}",
"break;",
"case 0xc9:\nif (CODE64(s)) {",
"gen_op_mov_TN_reg(OT_QUAD, 0, R_EBP);",
"gen_op_mov_reg_T0(OT_QUAD, R_ESP);",
"} else 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);",
"if (CODE64(s)) {",
"VAR_5 = VAR_3 ? OT_QUAD : OT_WORD;",
"} else {",
"VAR_5 = VAR_3 + OT_WORD;",
"}",
"gen_op_mov_reg_T0(VAR_5, R_EBP);",
"gen_pop_update(s);",
"break;",
"case 0x06:\ncase 0x0e:\ncase 0x16:\ncase 0x1e:\nif (CODE64(s))\ngoto illegal_op;",
"gen_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:\nif (CODE64(s))\ngoto illegal_op;",
"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))\ngen_helper_set_inhibit_irq(cpu_env);",
"s->tf = 0;",
"}",
"if (s->is_jmp) {",
"gen_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_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_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"gen_ldst_modrm(s, VAR_6, VAR_5, VAR_7, 1);",
"break;",
"case 0xc6:\ncase 0xc7:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_5 = VAR_3 + OT_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"if (VAR_9 != 3) {",
"s->rip_offset = insn_const_size(VAR_5);",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"}",
"VAR_18 = insn_get(s, VAR_5);",
"gen_op_movl_T0_im(VAR_18);",
"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) | REX_B(s));",
"break;",
"case 0x8a:\ncase 0x8b:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_5 = OT_WORD + VAR_3;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"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 = cpu_ldub_code(cpu_single_env, 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_helper_set_inhibit_irq(cpu_env);",
"s->tf = 0;",
"}",
"if (s->is_jmp) {",
"gen_jmp_im(s->pc - s->cs_base);",
"gen_eob(s);",
"}",
"break;",
"case 0x8c:\nVAR_6 = cpu_ldub_code(cpu_single_env, 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);",
"if (VAR_9 == 3)\nVAR_5 = OT_WORD + VAR_3;",
"else\nVAR_5 = OT_WORD;",
"gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 1);",
"break;",
"case 0x1b6:\ncase 0x1b7:\ncase 0x1be:\ncase 0x1bf:\n{",
"int VAR_21;",
"VAR_21 = VAR_3 + OT_WORD;",
"VAR_5 = (VAR_0 & 1) + OT_BYTE;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_8 = (VAR_6 & 7) | REX_B(s);",
"if (VAR_9 == 3) {",
"gen_op_mov_TN_reg(VAR_5, 0, VAR_8);",
"switch(VAR_5 | (VAR_0 & 8)) {",
"case OT_BYTE:\ntcg_gen_ext8u_tl(cpu_T[0], cpu_T[0]);",
"break;",
"case OT_BYTE | 8:\ntcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);",
"break;",
"case OT_WORD:\ntcg_gen_ext16u_tl(cpu_T[0], cpu_T[0]);",
"break;",
"default:\ncase OT_WORD | 8:\ntcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);",
"break;",
"}",
"gen_op_mov_reg_T0(VAR_21, 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_21, VAR_7);",
"}",
"}",
"break;",
"case 0x8d:\nVAR_5 = VAR_3 + OT_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"if (VAR_9 == 3)\ngoto illegal_op;",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"s->override = -1;",
"VAR_18 = s->addseg;",
"s->addseg = 0;",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"s->addseg = VAR_18;",
"gen_op_mov_reg_A0(VAR_5 - OT_WORD, VAR_7);",
"break;",
"case 0xa0:\ncase 0xa1:\ncase 0xa2:\ncase 0xa3:\n{",
"target_ulong VAR_13;",
"if ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_5 = VAR_3 + OT_WORD;",
"#ifdef TARGET_X86_64\nif (s->VAR_2 == 2) {",
"VAR_13 = cpu_ldq_code(cpu_single_env, s->pc);",
"s->pc += 8;",
"gen_op_movq_A0_im(VAR_13);",
"} else",
"#endif\n{",
"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);",
"}",
"gen_add_A0_ds_seg(s);",
"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:\n#ifdef TARGET_X86_64\nif (s->VAR_2 == 2) {",
"gen_op_movq_A0_reg(R_EBX);",
"gen_op_mov_TN_reg(OT_QUAD, 0, R_EAX);",
"tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xff);",
"tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_T[0]);",
"} else",
"#endif\n{",
"gen_op_movl_A0_reg(R_EBX);",
"gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);",
"tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xff);",
"tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_T[0]);",
"if (s->VAR_2 == 0)\ngen_op_andl_A0_ffff();",
"else\ntcg_gen_andi_tl(cpu_A0, cpu_A0, 0xffffffff);",
"}",
"gen_add_A0_ds_seg(s);",
"gen_op_ldu_T0_A0(OT_BYTE + s->mem_index);",
"gen_op_mov_reg_T0(OT_BYTE, R_EAX);",
"break;",
"case 0xb0 ... 0xb7:\nVAR_18 = insn_get(s, OT_BYTE);",
"gen_op_movl_T0_im(VAR_18);",
"gen_op_mov_reg_T0(OT_BYTE, (VAR_0 & 7) | REX_B(s));",
"break;",
"case 0xb8 ... 0xbf:\n#ifdef TARGET_X86_64\nif (VAR_3 == 2) {",
"uint64_t tmp;",
"tmp = cpu_ldq_code(cpu_single_env, s->pc);",
"s->pc += 8;",
"VAR_7 = (VAR_0 & 7) | REX_B(s);",
"gen_movtl_T0_im(tmp);",
"gen_op_mov_reg_T0(OT_QUAD, VAR_7);",
"} else",
"#endif\n{",
"VAR_5 = VAR_3 ? OT_LONG : OT_WORD;",
"VAR_18 = insn_get(s, VAR_5);",
"VAR_7 = (VAR_0 & 7) | REX_B(s);",
"gen_op_movl_T0_im(VAR_18);",
"gen_op_mov_reg_T0(VAR_5, VAR_7);",
"}",
"break;",
"case 0x91 ... 0x97:\ndo_xchg_reg_eax:\nVAR_5 = VAR_3 + OT_WORD;",
"VAR_7 = (VAR_0 & 7) | REX_B(s);",
"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_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"VAR_9 = (VAR_6 >> 6) & 3;",
"if (VAR_9 == 3) {",
"VAR_8 = (VAR_6 & 7) | REX_B(s);",
"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_helper_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_helper_unlock();",
"gen_op_mov_reg_T1(VAR_5, VAR_7);",
"}",
"break;",
"case 0xc4:\nif (CODE64(s))\ngoto illegal_op;",
"VAR_17 = R_ES;",
"goto do_lxx;",
"case 0xc5:\nif (CODE64(s))\ngoto illegal_op;",
"VAR_17 = R_DS;",
"goto do_lxx;",
"case 0x1b2:\nVAR_17 = R_SS;",
"goto do_lxx;",
"case 0x1b4:\nVAR_17 = R_FS;",
"goto do_lxx;",
"case 0x1b5:\nVAR_17 = R_GS;",
"do_lxx:\nVAR_5 = VAR_3 ? OT_LONG : OT_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"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_add_A0_im(s, 1 << (VAR_5 - OT_WORD + 1));",
"gen_op_ldu_T0_A0(OT_WORD + s->mem_index);",
"gen_movl_seg_T0(s, VAR_17, pc_start - s->cs_base);",
"gen_op_mov_reg_T1(VAR_5, VAR_7);",
"if (s->is_jmp) {",
"gen_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_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_17 = (VAR_6 >> 3) & 7;",
"if (VAR_9 != 3) {",
"if (VAR_4 == 2) {",
"s->rip_offset = 1;",
"}",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"VAR_12 = OR_TMP0;",
"} else {",
"VAR_12 = (VAR_6 & 7) | REX_B(s);",
"}",
"if (VAR_4 == 0) {",
"gen_shift(s, VAR_17, VAR_5, VAR_12, OR_ECX);",
"} else {",
"if (VAR_4 == 2) {",
"VAR_4 = cpu_ldub_code(cpu_single_env, s->pc++);",
"}",
"gen_shifti(s, VAR_17, 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_17 = 0;",
"VAR_4 = 1;",
"goto do_shiftd;",
"case 0x1a5:\nVAR_17 = 0;",
"VAR_4 = 0;",
"goto do_shiftd;",
"case 0x1ac:\nVAR_17 = 1;",
"VAR_4 = 1;",
"goto do_shiftd;",
"case 0x1ad:\nVAR_17 = 1;",
"VAR_4 = 0;",
"do_shiftd:\nVAR_5 = VAR_3 + OT_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_8 = (VAR_6 & 7) | REX_B(s);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"if (VAR_9 != 3) {",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"VAR_12 = OR_TMP0;",
"} else {",
"VAR_12 = VAR_8;",
"}",
"gen_op_mov_TN_reg(VAR_5, 1, VAR_7);",
"if (VAR_4) {",
"VAR_18 = cpu_ldub_code(cpu_single_env, s->pc++);",
"tcg_gen_movi_tl(cpu_T3, VAR_18);",
"} else {",
"tcg_gen_mov_tl(cpu_T3, cpu_regs[R_ECX]);",
"}",
"gen_shiftd_rm_T1_T3(s, VAR_5, VAR_12, VAR_17);",
"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 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_8 = VAR_6 & 7;",
"VAR_17 = ((VAR_0 & 7) << 3) | ((VAR_6 >> 3) & 7);",
"if (VAR_9 != 3) {",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"switch(VAR_17) {",
"case 0x00 ... 0x07:\ncase 0x10 ... 0x17:\ncase 0x20 ... 0x27:\ncase 0x30 ... 0x37:\n{",
"int VAR_23;",
"VAR_23 = VAR_17 & 7;",
"switch(VAR_17 >> 4) {",
"case 0:\ngen_op_ld_T0_A0(OT_LONG + s->mem_index);",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"gen_helper_flds_FT0(cpu_env, cpu_tmp2_i32);",
"break;",
"case 1:\ngen_op_ld_T0_A0(OT_LONG + s->mem_index);",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"gen_helper_fildl_FT0(cpu_env, cpu_tmp2_i32);",
"break;",
"case 2:\ntcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,\n(s->mem_index >> 2) - 1);",
"gen_helper_fldl_FT0(cpu_env, cpu_tmp1_i64);",
"break;",
"case 3:\ndefault:\ngen_op_lds_T0_A0(OT_WORD + s->mem_index);",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"gen_helper_fildl_FT0(cpu_env, cpu_tmp2_i32);",
"break;",
"}",
"gen_helper_fp_arith_ST0_FT0(VAR_23);",
"if (VAR_23 == 3) {",
"gen_helper_fpop(cpu_env);",
"}",
"}",
"break;",
"case 0x08:\ncase 0x0a:\ncase 0x0b:\ncase 0x18 ... 0x1b:\ncase 0x28 ... 0x2b:\ncase 0x38 ... 0x3b:\nswitch(VAR_17 & 7) {",
"case 0:\nswitch(VAR_17 >> 4) {",
"case 0:\ngen_op_ld_T0_A0(OT_LONG + s->mem_index);",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"gen_helper_flds_ST0(cpu_env, cpu_tmp2_i32);",
"break;",
"case 1:\ngen_op_ld_T0_A0(OT_LONG + s->mem_index);",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"gen_helper_fildl_ST0(cpu_env, cpu_tmp2_i32);",
"break;",
"case 2:\ntcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,\n(s->mem_index >> 2) - 1);",
"gen_helper_fldl_ST0(cpu_env, cpu_tmp1_i64);",
"break;",
"case 3:\ndefault:\ngen_op_lds_T0_A0(OT_WORD + s->mem_index);",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"gen_helper_fildl_ST0(cpu_env, cpu_tmp2_i32);",
"break;",
"}",
"break;",
"case 1:\nswitch(VAR_17 >> 4) {",
"case 1:\ngen_helper_fisttl_ST0(cpu_tmp2_i32, cpu_env);",
"tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);",
"gen_op_st_T0_A0(OT_LONG + s->mem_index);",
"break;",
"case 2:\ngen_helper_fisttll_ST0(cpu_tmp1_i64, cpu_env);",
"tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,\n(s->mem_index >> 2) - 1);",
"break;",
"case 3:\ndefault:\ngen_helper_fistt_ST0(cpu_tmp2_i32, cpu_env);",
"tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);",
"gen_op_st_T0_A0(OT_WORD + s->mem_index);",
"break;",
"}",
"gen_helper_fpop(cpu_env);",
"break;",
"default:\nswitch(VAR_17 >> 4) {",
"case 0:\ngen_helper_fsts_ST0(cpu_tmp2_i32, cpu_env);",
"tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);",
"gen_op_st_T0_A0(OT_LONG + s->mem_index);",
"break;",
"case 1:\ngen_helper_fistl_ST0(cpu_tmp2_i32, cpu_env);",
"tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);",
"gen_op_st_T0_A0(OT_LONG + s->mem_index);",
"break;",
"case 2:\ngen_helper_fstl_ST0(cpu_tmp1_i64, cpu_env);",
"tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,\n(s->mem_index >> 2) - 1);",
"break;",
"case 3:\ndefault:\ngen_helper_fist_ST0(cpu_tmp2_i32, cpu_env);",
"tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);",
"gen_op_st_T0_A0(OT_WORD + s->mem_index);",
"break;",
"}",
"if ((VAR_17 & 7) == 3)\ngen_helper_fpop(cpu_env);",
"break;",
"}",
"break;",
"case 0x0c:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_fldenv(cpu_env, cpu_A0, tcg_const_i32(s->VAR_3));",
"break;",
"case 0x0d:\ngen_op_ld_T0_A0(OT_WORD + s->mem_index);",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"gen_helper_fldcw(cpu_env, cpu_tmp2_i32);",
"break;",
"case 0x0e:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_fstenv(cpu_env, cpu_A0, tcg_const_i32(s->VAR_3));",
"break;",
"case 0x0f:\ngen_helper_fnstcw(cpu_tmp2_i32, cpu_env);",
"tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);",
"gen_op_st_T0_A0(OT_WORD + s->mem_index);",
"break;",
"case 0x1d:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_fldt_ST0(cpu_env, cpu_A0);",
"break;",
"case 0x1f:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_fstt_ST0(cpu_env, cpu_A0);",
"gen_helper_fpop(cpu_env);",
"break;",
"case 0x2c:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_frstor(cpu_env, cpu_A0, tcg_const_i32(s->VAR_3));",
"break;",
"case 0x2e:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_fsave(cpu_env, cpu_A0, tcg_const_i32(s->VAR_3));",
"break;",
"case 0x2f:\ngen_helper_fnstsw(cpu_tmp2_i32, cpu_env);",
"tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);",
"gen_op_st_T0_A0(OT_WORD + s->mem_index);",
"break;",
"case 0x3c:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_fbld_ST0(cpu_env, cpu_A0);",
"break;",
"case 0x3e:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_fbst_ST0(cpu_env, cpu_A0);",
"gen_helper_fpop(cpu_env);",
"break;",
"case 0x3d:\ntcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,\n(s->mem_index >> 2) - 1);",
"gen_helper_fildll_ST0(cpu_env, cpu_tmp1_i64);",
"break;",
"case 0x3f:\ngen_helper_fistll_ST0(cpu_tmp1_i64, cpu_env);",
"tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,\n(s->mem_index >> 2) - 1);",
"gen_helper_fpop(cpu_env);",
"break;",
"default:\ngoto illegal_op;",
"}",
"} else {",
"VAR_12 = VAR_8;",
"switch(VAR_17) {",
"case 0x08:\ngen_helper_fpush(cpu_env);",
"gen_helper_fmov_ST0_STN(cpu_env,\ntcg_const_i32((VAR_12 + 1) & 7));",
"break;",
"case 0x09:\ncase 0x29:\ncase 0x39:\ngen_helper_fxchg_ST0_STN(cpu_env, tcg_const_i32(VAR_12));",
"break;",
"case 0x0a:\nswitch(VAR_8) {",
"case 0:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_fwait(cpu_env);",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x0c:\nswitch(VAR_8) {",
"case 0:\ngen_helper_fchs_ST0(cpu_env);",
"break;",
"case 1:\ngen_helper_fabs_ST0(cpu_env);",
"break;",
"case 4:\ngen_helper_fldz_FT0(cpu_env);",
"gen_helper_fcom_ST0_FT0(cpu_env);",
"break;",
"case 5:\ngen_helper_fxam_ST0(cpu_env);",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x0d:\n{",
"switch(VAR_8) {",
"case 0:\ngen_helper_fpush(cpu_env);",
"gen_helper_fld1_ST0(cpu_env);",
"break;",
"case 1:\ngen_helper_fpush(cpu_env);",
"gen_helper_fldl2t_ST0(cpu_env);",
"break;",
"case 2:\ngen_helper_fpush(cpu_env);",
"gen_helper_fldl2e_ST0(cpu_env);",
"break;",
"case 3:\ngen_helper_fpush(cpu_env);",
"gen_helper_fldpi_ST0(cpu_env);",
"break;",
"case 4:\ngen_helper_fpush(cpu_env);",
"gen_helper_fldlg2_ST0(cpu_env);",
"break;",
"case 5:\ngen_helper_fpush(cpu_env);",
"gen_helper_fldln2_ST0(cpu_env);",
"break;",
"case 6:\ngen_helper_fpush(cpu_env);",
"gen_helper_fldz_ST0(cpu_env);",
"break;",
"default:\ngoto illegal_op;",
"}",
"}",
"break;",
"case 0x0e:\nswitch(VAR_8) {",
"case 0:\ngen_helper_f2xm1(cpu_env);",
"break;",
"case 1:\ngen_helper_fyl2x(cpu_env);",
"break;",
"case 2:\ngen_helper_fptan(cpu_env);",
"break;",
"case 3:\ngen_helper_fpatan(cpu_env);",
"break;",
"case 4:\ngen_helper_fxtract(cpu_env);",
"break;",
"case 5:\ngen_helper_fprem1(cpu_env);",
"break;",
"case 6:\ngen_helper_fdecstp(cpu_env);",
"break;",
"default:\ncase 7:\ngen_helper_fincstp(cpu_env);",
"break;",
"}",
"break;",
"case 0x0f:\nswitch(VAR_8) {",
"case 0:\ngen_helper_fprem(cpu_env);",
"break;",
"case 1:\ngen_helper_fyl2xp1(cpu_env);",
"break;",
"case 2:\ngen_helper_fsqrt(cpu_env);",
"break;",
"case 3:\ngen_helper_fsincos(cpu_env);",
"break;",
"case 5:\ngen_helper_fscale(cpu_env);",
"break;",
"case 4:\ngen_helper_frndint(cpu_env);",
"break;",
"case 6:\ngen_helper_fsin(cpu_env);",
"break;",
"default:\ncase 7:\ngen_helper_fcos(cpu_env);",
"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_23;",
"VAR_23 = VAR_17 & 7;",
"if (VAR_17 >= 0x20) {",
"gen_helper_fp_arith_STN_ST0(VAR_23, VAR_12);",
"if (VAR_17 >= 0x30)\ngen_helper_fpop(cpu_env);",
"} else {",
"gen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));",
"gen_helper_fp_arith_ST0_FT0(VAR_23);",
"}",
"}",
"break;",
"case 0x02:\ncase 0x22:\ngen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));",
"gen_helper_fcom_ST0_FT0(cpu_env);",
"break;",
"case 0x03:\ncase 0x23:\ncase 0x32:\ngen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));",
"gen_helper_fcom_ST0_FT0(cpu_env);",
"gen_helper_fpop(cpu_env);",
"break;",
"case 0x15:\nswitch(VAR_8) {",
"case 1:\ngen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(1));",
"gen_helper_fucom_ST0_FT0(cpu_env);",
"gen_helper_fpop(cpu_env);",
"gen_helper_fpop(cpu_env);",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x1c:\nswitch(VAR_8) {",
"case 0:\nbreak;",
"case 1:\nbreak;",
"case 2:\ngen_helper_fclex(cpu_env);",
"break;",
"case 3:\ngen_helper_fninit(cpu_env);",
"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_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));",
"gen_helper_fucomi_ST0_FT0(cpu_env);",
"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_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));",
"gen_helper_fcomi_ST0_FT0(cpu_env);",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x28:\ngen_helper_ffree_STN(cpu_env, tcg_const_i32(VAR_12));",
"break;",
"case 0x2a:\ngen_helper_fmov_STN_ST0(cpu_env, tcg_const_i32(VAR_12));",
"break;",
"case 0x2b:\ncase 0x0b:\ncase 0x3a:\ncase 0x3b:\ngen_helper_fmov_STN_ST0(cpu_env, tcg_const_i32(VAR_12));",
"gen_helper_fpop(cpu_env);",
"break;",
"case 0x2c:\ngen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));",
"gen_helper_fucom_ST0_FT0(cpu_env);",
"break;",
"case 0x2d:\ngen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));",
"gen_helper_fucom_ST0_FT0(cpu_env);",
"gen_helper_fpop(cpu_env);",
"break;",
"case 0x33:\nswitch(VAR_8) {",
"case 1:\ngen_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(1));",
"gen_helper_fcom_ST0_FT0(cpu_env);",
"gen_helper_fpop(cpu_env);",
"gen_helper_fpop(cpu_env);",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x38:\ngen_helper_ffree_STN(cpu_env, tcg_const_i32(VAR_12));",
"gen_helper_fpop(cpu_env);",
"break;",
"case 0x3c:\nswitch(VAR_8) {",
"case 0:\ngen_helper_fnstsw(cpu_tmp2_i32, cpu_env);",
"tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);",
"gen_op_mov_reg_T0(OT_WORD, R_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_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));",
"gen_helper_fucomi_ST0_FT0(cpu_env);",
"gen_helper_fpop(cpu_env);",
"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_helper_fmov_FT0_STN(cpu_env, tcg_const_i32(VAR_12));",
"gen_helper_fcomi_ST0_FT0(cpu_env);",
"gen_helper_fpop(cpu_env);",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x10 ... 0x13:\ncase 0x18 ... 0x1b:\n{",
"int VAR_23, VAR_27;",
"static const uint8_t VAR_24[8] = {",
"(JCC_B << 1),\n(JCC_Z << 1),\n(JCC_BE << 1),\n(JCC_P << 1),\n};",
"VAR_23 = VAR_24[VAR_17 & 3] | (((VAR_17 >> 3) & 1) ^ 1);",
"VAR_27 = gen_new_label();",
"gen_jcc1(s, s->cc_op, VAR_23, VAR_27);",
"gen_helper_fmov_ST0_STN(cpu_env, tcg_const_i32(VAR_12));",
"gen_set_label(VAR_27);",
"}",
"break;",
"default:\ngoto illegal_op;",
"}",
"}",
"break;",
"case 0xa4:\ncase 0xa5:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_5 = VAR_3 + 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_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_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_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_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_op_mov_TN_reg(OT_WORD, 0, R_EDX);",
"gen_op_andl_T0_ffff();",
"gen_check_io(s, VAR_5, pc_start - s->cs_base,\nSVM_IOIO_TYPE_MASK | svm_is_rep(VAR_1) | 4);",
"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);",
"if (use_icount) {",
"gen_jmp(s, s->pc - s->cs_base);",
"}",
"}",
"break;",
"case 0x6e:\ncase 0x6f:\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, pc_start - s->cs_base,\nsvm_is_rep(VAR_1) | 4);",
"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);",
"if (use_icount) {",
"gen_jmp(s, s->pc - s->cs_base);",
"}",
"}",
"break;",
"case 0xe4:\ncase 0xe5:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_5 = VAR_3 ? OT_LONG : OT_WORD;",
"VAR_18 = cpu_ldub_code(cpu_single_env, s->pc++);",
"gen_op_movl_T0_im(VAR_18);",
"gen_check_io(s, VAR_5, pc_start - s->cs_base,\nSVM_IOIO_TYPE_MASK | svm_is_rep(VAR_1));",
"if (use_icount)\ngen_io_start();",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"gen_helper_in_func(VAR_5, cpu_T[1], cpu_tmp2_i32);",
"gen_op_mov_reg_T1(VAR_5, R_EAX);",
"if (use_icount) {",
"gen_io_end();",
"gen_jmp(s, s->pc - s->cs_base);",
"}",
"break;",
"case 0xe6:\ncase 0xe7:\nif ((VAR_0 & 1) == 0)\nVAR_5 = OT_BYTE;",
"else\nVAR_5 = VAR_3 ? OT_LONG : OT_WORD;",
"VAR_18 = cpu_ldub_code(cpu_single_env, s->pc++);",
"gen_op_movl_T0_im(VAR_18);",
"gen_check_io(s, VAR_5, pc_start - s->cs_base,\nsvm_is_rep(VAR_1));",
"gen_op_mov_TN_reg(VAR_5, 1, R_EAX);",
"if (use_icount)\ngen_io_start();",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[1]);",
"gen_helper_out_func(VAR_5, cpu_tmp2_i32, cpu_tmp3_i32);",
"if (use_icount) {",
"gen_io_end();",
"gen_jmp(s, s->pc - s->cs_base);",
"}",
"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, pc_start - s->cs_base,\nSVM_IOIO_TYPE_MASK | svm_is_rep(VAR_1));",
"if (use_icount)\ngen_io_start();",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"gen_helper_in_func(VAR_5, cpu_T[1], cpu_tmp2_i32);",
"gen_op_mov_reg_T1(VAR_5, R_EAX);",
"if (use_icount) {",
"gen_io_end();",
"gen_jmp(s, s->pc - s->cs_base);",
"}",
"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, pc_start - s->cs_base,\nsvm_is_rep(VAR_1));",
"gen_op_mov_TN_reg(VAR_5, 1, R_EAX);",
"if (use_icount)\ngen_io_start();",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[1]);",
"gen_helper_out_func(VAR_5, cpu_tmp2_i32, cpu_tmp3_i32);",
"if (use_icount) {",
"gen_io_end();",
"gen_jmp(s, s->pc - s->cs_base);",
"}",
"break;",
"case 0xc2:\nVAR_18 = cpu_ldsw_code(cpu_single_env, s->pc);",
"s->pc += 2;",
"gen_pop_T0(s);",
"if (CODE64(s) && s->VAR_3)\ns->VAR_3 = 2;",
"gen_stack_update(s, VAR_18 + (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_18 = cpu_ldsw_code(cpu_single_env, 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_jmp_im(pc_start - s->cs_base);",
"gen_helper_lret_protected(cpu_env, tcg_const_i32(s->VAR_3),\ntcg_const_i32(VAR_18));",
"} 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(R_CS);",
"gen_stack_update(s, VAR_18 + (4 << s->VAR_3));",
"}",
"gen_eob(s);",
"break;",
"case 0xcb:\nVAR_18 = 0;",
"goto do_lret;",
"case 0xcf:\ngen_svm_check_intercept(s, pc_start, SVM_EXIT_IRET);",
"if (!s->pe) {",
"gen_helper_iret_real(cpu_env, tcg_const_i32(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_helper_iret_real(cpu_env, tcg_const_i32(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_jmp_im(pc_start - s->cs_base);",
"gen_helper_iret_protected(cpu_env, tcg_const_i32(s->VAR_3),\ntcg_const_i32(s->pc - s->cs_base));",
"s->cc_op = CC_OP_EFLAGS;",
"}",
"gen_eob(s);",
"break;",
"case 0xe8:\n{",
"if (VAR_3)\ntval = (int32_t)insn_get(s, OT_LONG);",
"else\ntval = (int16_t)insn_get(s, OT_WORD);",
"next_eip = s->pc - s->cs_base;",
"tval += next_eip;",
"if (s->VAR_3 == 0)\ntval &= 0xffff;",
"else if(!CODE64(s))\ntval &= 0xffffffff;",
"gen_movtl_T0_im(next_eip);",
"gen_push_T0(s);",
"gen_jmp(s, tval);",
"}",
"break;",
"case 0x9a:\n{",
"unsigned int VAR_27, VAR_27;",
"if (CODE64(s))\ngoto illegal_op;",
"VAR_5 = VAR_3 ? OT_LONG : OT_WORD;",
"VAR_27 = insn_get(s, VAR_5);",
"VAR_27 = insn_get(s, OT_WORD);",
"gen_op_movl_T0_im(VAR_27);",
"gen_op_movl_T1_imu(VAR_27);",
"}",
"goto do_lcall;",
"case 0xe9:\nif (VAR_3)\ntval = (int32_t)insn_get(s, OT_LONG);",
"else\ntval = (int16_t)insn_get(s, OT_WORD);",
"tval += s->pc - s->cs_base;",
"if (s->VAR_3 == 0)\ntval &= 0xffff;",
"else if(!CODE64(s))\ntval &= 0xffffffff;",
"gen_jmp(s, tval);",
"break;",
"case 0xea:\n{",
"unsigned int VAR_27, VAR_27;",
"if (CODE64(s))\ngoto illegal_op;",
"VAR_5 = VAR_3 ? OT_LONG : OT_WORD;",
"VAR_27 = insn_get(s, VAR_5);",
"VAR_27 = insn_get(s, OT_WORD);",
"gen_op_movl_T0_im(VAR_27);",
"gen_op_movl_T1_imu(VAR_27);",
"}",
"goto do_ljmp;",
"case 0xeb:\ntval = (int8_t)insn_get(s, OT_BYTE);",
"tval += s->pc - s->cs_base;",
"if (s->VAR_3 == 0)\ntval &= 0xffff;",
"gen_jmp(s, tval);",
"break;",
"case 0x70 ... 0x7f:\ntval = (int8_t)insn_get(s, OT_BYTE);",
"goto do_jcc;",
"case 0x180 ... 0x18f:\nif (VAR_3) {",
"tval = (int32_t)insn_get(s, OT_LONG);",
"} else {",
"tval = (int16_t)insn_get(s, OT_WORD);",
"}",
"do_jcc:\nnext_eip = s->pc - s->cs_base;",
"tval += next_eip;",
"if (s->VAR_3 == 0)\ntval &= 0xffff;",
"gen_jcc(s, VAR_0, tval, next_eip);",
"break;",
"case 0x190 ... 0x19f:\nVAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"gen_setcc(s, VAR_0);",
"gen_ldst_modrm(s, VAR_6, OT_BYTE, OR_TMP0, 1);",
"break;",
"case 0x140 ... 0x14f:\n{",
"int VAR_27;",
"TCGv t0;",
"VAR_5 = VAR_3 + OT_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"VAR_9 = (VAR_6 >> 6) & 3;",
"t0 = tcg_temp_local_new();",
"if (VAR_9 != 3) {",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"gen_op_ld_v(VAR_5 + s->mem_index, t0, cpu_A0);",
"} else {",
"VAR_8 = (VAR_6 & 7) | REX_B(s);",
"gen_op_mov_v_reg(VAR_5, t0, VAR_8);",
"}",
"#ifdef TARGET_X86_64\nif (VAR_5 == OT_LONG) {",
"VAR_27 = gen_new_label();",
"gen_jcc1(s, s->cc_op, VAR_0 ^ 1, VAR_27);",
"tcg_gen_mov_tl(cpu_regs[VAR_7], t0);",
"gen_set_label(VAR_27);",
"tcg_gen_ext32u_tl(cpu_regs[VAR_7], cpu_regs[VAR_7]);",
"} else",
"#endif\n{",
"VAR_27 = gen_new_label();",
"gen_jcc1(s, s->cc_op, VAR_0 ^ 1, VAR_27);",
"gen_op_mov_reg_v(VAR_5, VAR_7, t0);",
"gen_set_label(VAR_27);",
"}",
"tcg_temp_free(t0);",
"}",
"break;",
"case 0x9c:\ngen_svm_check_intercept(s, pc_start, SVM_EXIT_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)\ngen_op_set_cc_op(s->cc_op);",
"gen_helper_read_eflags(cpu_T[0], cpu_env);",
"gen_push_T0(s);",
"}",
"break;",
"case 0x9d:\ngen_svm_check_intercept(s, pc_start, SVM_EXIT_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->VAR_3) {",
"gen_helper_write_eflags(cpu_env, cpu_T[0],\ntcg_const_i32((TF_MASK | AC_MASK |\nID_MASK | NT_MASK |\nIF_MASK |\nIOPL_MASK)));",
"} else {",
"gen_helper_write_eflags(cpu_env, cpu_T[0],\ntcg_const_i32((TF_MASK | AC_MASK |\nID_MASK | NT_MASK |\nIF_MASK | IOPL_MASK)\n& 0xffff));",
"}",
"} else {",
"if (s->cpl <= s->iopl) {",
"if (s->VAR_3) {",
"gen_helper_write_eflags(cpu_env, cpu_T[0],\ntcg_const_i32((TF_MASK |\nAC_MASK |\nID_MASK |\nNT_MASK |\nIF_MASK)));",
"} else {",
"gen_helper_write_eflags(cpu_env, cpu_T[0],\ntcg_const_i32((TF_MASK |\nAC_MASK |\nID_MASK |\nNT_MASK |\nIF_MASK)\n& 0xffff));",
"}",
"} else {",
"if (s->VAR_3) {",
"gen_helper_write_eflags(cpu_env, cpu_T[0],\ntcg_const_i32((TF_MASK | AC_MASK |\nID_MASK | NT_MASK)));",
"} else {",
"gen_helper_write_eflags(cpu_env, cpu_T[0],\ntcg_const_i32((TF_MASK | AC_MASK |\nID_MASK | NT_MASK)\n& 0xffff));",
"}",
"}",
"}",
"gen_pop_update(s);",
"s->cc_op = CC_OP_EFLAGS;",
"gen_jmp_im(s->pc - s->cs_base);",
"gen_eob(s);",
"}",
"break;",
"case 0x9e:\nif (CODE64(s) && !(s->cpuid_ext3_features & CPUID_EXT3_LAHF_LM))\ngoto illegal_op;",
"gen_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_compute_eflags(cpu_cc_src);",
"tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, CC_O);",
"tcg_gen_andi_tl(cpu_T[0], cpu_T[0], CC_S | CC_Z | CC_A | CC_P | CC_C);",
"tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, cpu_T[0]);",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x9f:\nif (CODE64(s) && !(s->cpuid_ext3_features & CPUID_EXT3_LAHF_LM))\ngoto illegal_op;",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_compute_eflags(cpu_T[0]);",
"tcg_gen_ori_tl(cpu_T[0], cpu_T[0], 0x02);",
"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_compute_eflags(cpu_cc_src);",
"tcg_gen_xori_tl(cpu_cc_src, cpu_cc_src, CC_C);",
"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_compute_eflags(cpu_cc_src);",
"tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, ~CC_C);",
"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_compute_eflags(cpu_cc_src);",
"tcg_gen_ori_tl(cpu_cc_src, cpu_cc_src, CC_C);",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0xfc:\ntcg_gen_movi_i32(cpu_tmp2_i32, 1);",
"tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, offsetof(CPUX86State, df));",
"break;",
"case 0xfd:\ntcg_gen_movi_i32(cpu_tmp2_i32, -1);",
"tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, offsetof(CPUX86State, df));",
"break;",
"case 0x1ba:\nVAR_5 = VAR_3 + OT_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_17 = (VAR_6 >> 3) & 7;",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_8 = (VAR_6 & 7) | REX_B(s);",
"if (VAR_9 != 3) {",
"s->rip_offset = 1;",
"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_18 = cpu_ldub_code(cpu_single_env, s->pc++);",
"gen_op_movl_T1_im(VAR_18);",
"if (VAR_17 < 4)\ngoto illegal_op;",
"VAR_17 -= 4;",
"goto bt_op;",
"case 0x1a3:\nVAR_17 = 0;",
"goto do_btx;",
"case 0x1ab:\nVAR_17 = 1;",
"goto do_btx;",
"case 0x1b3:\nVAR_17 = 2;",
"goto do_btx;",
"case 0x1bb:\nVAR_17 = 3;",
"do_btx:\nVAR_5 = VAR_3 + OT_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_8 = (VAR_6 & 7) | REX_B(s);",
"gen_op_mov_TN_reg(OT_LONG, 1, VAR_7);",
"if (VAR_9 != 3) {",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"gen_exts(VAR_5, cpu_T[1]);",
"tcg_gen_sari_tl(cpu_tmp0, cpu_T[1], 3 + VAR_5);",
"tcg_gen_shli_tl(cpu_tmp0, cpu_tmp0, VAR_5);",
"tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);",
"gen_op_ld_T0_A0(VAR_5 + s->mem_index);",
"} else {",
"gen_op_mov_TN_reg(VAR_5, 0, VAR_8);",
"}",
"bt_op:\ntcg_gen_andi_tl(cpu_T[1], cpu_T[1], (1 << (3 + VAR_5)) - 1);",
"switch(VAR_17) {",
"case 0:\ntcg_gen_shr_tl(cpu_cc_src, cpu_T[0], cpu_T[1]);",
"tcg_gen_movi_tl(cpu_cc_dst, 0);",
"break;",
"case 1:\ntcg_gen_shr_tl(cpu_tmp4, cpu_T[0], cpu_T[1]);",
"tcg_gen_movi_tl(cpu_tmp0, 1);",
"tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);",
"tcg_gen_or_tl(cpu_T[0], cpu_T[0], cpu_tmp0);",
"break;",
"case 2:\ntcg_gen_shr_tl(cpu_tmp4, cpu_T[0], cpu_T[1]);",
"tcg_gen_movi_tl(cpu_tmp0, 1);",
"tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);",
"tcg_gen_not_tl(cpu_tmp0, cpu_tmp0);",
"tcg_gen_and_tl(cpu_T[0], cpu_T[0], cpu_tmp0);",
"break;",
"default:\ncase 3:\ntcg_gen_shr_tl(cpu_tmp4, cpu_T[0], cpu_T[1]);",
"tcg_gen_movi_tl(cpu_tmp0, 1);",
"tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);",
"tcg_gen_xor_tl(cpu_T[0], cpu_T[0], cpu_tmp0);",
"break;",
"}",
"s->cc_op = CC_OP_SARB + VAR_5;",
"if (VAR_17 != 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);",
"tcg_gen_mov_tl(cpu_cc_src, cpu_tmp4);",
"tcg_gen_movi_tl(cpu_cc_dst, 0);",
"}",
"break;",
"case 0x1bc:\ncase 0x1bd:\n{",
"int VAR_29;",
"TCGv t0;",
"VAR_5 = VAR_3 + OT_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"gen_ldst_modrm(s,VAR_6, VAR_5, OR_TMP0, 0);",
"gen_extu(VAR_5, cpu_T[0]);",
"t0 = tcg_temp_local_new();",
"tcg_gen_mov_tl(t0, cpu_T[0]);",
"if ((VAR_0 & 1) && (VAR_1 & PREFIX_REPZ) &&\n(s->cpuid_ext3_features & CPUID_EXT3_ABM)) {",
"switch(VAR_5) {",
"case OT_WORD: gen_helper_lzcnt(cpu_T[0], t0,\ntcg_const_i32(16)); break;",
"case OT_LONG: gen_helper_lzcnt(cpu_T[0], t0,\ntcg_const_i32(32)); break;",
"case OT_QUAD: gen_helper_lzcnt(cpu_T[0], t0,\ntcg_const_i32(64)); break;",
"}",
"gen_op_mov_reg_T0(VAR_5, VAR_7);",
"} else {",
"VAR_29 = gen_new_label();",
"tcg_gen_movi_tl(cpu_cc_dst, 0);",
"tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, VAR_29);",
"if (VAR_0 & 1) {",
"gen_helper_bsr(cpu_T[0], t0);",
"} else {",
"gen_helper_bsf(cpu_T[0], t0);",
"}",
"gen_op_mov_reg_T0(VAR_5, VAR_7);",
"tcg_gen_movi_tl(cpu_cc_dst, 1);",
"gen_set_label(VAR_29);",
"tcg_gen_discard_tl(cpu_cc_src);",
"s->cc_op = CC_OP_LOGICB + VAR_5;",
"}",
"tcg_temp_free(t0);",
"}",
"break;",
"case 0x27:\nif (CODE64(s))\ngoto illegal_op;",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_helper_daa(cpu_env);",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x2f:\nif (CODE64(s))\ngoto illegal_op;",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_helper_das(cpu_env);",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x37:\nif (CODE64(s))\ngoto illegal_op;",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_helper_aaa(cpu_env);",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x3f:\nif (CODE64(s))\ngoto illegal_op;",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_helper_aas(cpu_env);",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0xd4:\nif (CODE64(s))\ngoto illegal_op;",
"VAR_18 = cpu_ldub_code(cpu_single_env, s->pc++);",
"if (VAR_18 == 0) {",
"gen_exception(s, EXCP00_DIVZ, pc_start - s->cs_base);",
"} else {",
"gen_helper_aam(cpu_env, tcg_const_i32(VAR_18));",
"s->cc_op = CC_OP_LOGICB;",
"}",
"break;",
"case 0xd5:\nif (CODE64(s))\ngoto illegal_op;",
"VAR_18 = cpu_ldub_code(cpu_single_env, s->pc++);",
"gen_helper_aad(cpu_env, tcg_const_i32(VAR_18));",
"s->cc_op = CC_OP_LOGICB;",
"break;",
"case 0x90:\nif (VAR_1 & PREFIX_LOCK) {",
"goto illegal_op;",
"}",
"if (REX_B(s)) {",
"goto do_xchg_reg_eax;",
"}",
"if (VAR_1 & PREFIX_REPZ) {",
"gen_svm_check_intercept(s, pc_start, SVM_EXIT_PAUSE);",
"}",
"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_jmp_im(pc_start - s->cs_base);",
"gen_helper_fwait(cpu_env);",
"}",
"break;",
"case 0xcc:\ngen_interrupt(s, EXCP03_INT3, pc_start - s->cs_base, s->pc - s->cs_base);",
"break;",
"case 0xcd:\nVAR_18 = cpu_ldub_code(cpu_single_env, s->pc++);",
"if (s->vm86 && s->iopl != 3) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"} else {",
"gen_interrupt(s, VAR_18, pc_start - s->cs_base, s->pc - s->cs_base);",
"}",
"break;",
"case 0xce:\nif (CODE64(s))\ngoto illegal_op;",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_into(cpu_env, tcg_const_i32(s->pc - pc_start));",
"break;",
"#ifdef WANT_ICEBP\ncase 0xf1:\ngen_svm_check_intercept(s, pc_start, SVM_EXIT_ICEBP);",
"#if 1\ngen_debug(s, pc_start - s->cs_base);",
"#else\ntb_flush(cpu_single_env);",
"cpu_set_log(CPU_LOG_INT | CPU_LOG_TB_IN_ASM);",
"#endif\nbreak;",
"#endif\ncase 0xfa:\nif (!s->vm86) {",
"if (s->cpl <= s->iopl) {",
"gen_helper_cli(cpu_env);",
"} else {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"}",
"} else {",
"if (s->iopl == 3) {",
"gen_helper_cli(cpu_env);",
"} 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_helper_sti(cpu_env);",
"if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))\ngen_helper_set_inhibit_irq(cpu_env);",
"gen_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:\nif (CODE64(s))\ngoto illegal_op;",
"VAR_5 = VAR_3 ? OT_LONG : OT_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = (VAR_6 >> 3) & 7;",
"VAR_9 = (VAR_6 >> 6) & 3;",
"if (VAR_9 == 3)\ngoto illegal_op;",
"gen_op_mov_TN_reg(VAR_5, 0, VAR_7);",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"gen_jmp_im(pc_start - s->cs_base);",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"if (VAR_5 == OT_WORD) {",
"gen_helper_boundw(cpu_env, cpu_A0, cpu_tmp2_i32);",
"} else {",
"gen_helper_boundl(cpu_env, cpu_A0, cpu_tmp2_i32);",
"}",
"break;",
"case 0x1c8 ... 0x1cf:\nVAR_7 = (VAR_0 & 7) | REX_B(s);",
"#ifdef TARGET_X86_64\nif (VAR_3 == 2) {",
"gen_op_mov_TN_reg(OT_QUAD, 0, VAR_7);",
"tcg_gen_bswap64_i64(cpu_T[0], cpu_T[0]);",
"gen_op_mov_reg_T0(OT_QUAD, VAR_7);",
"} else",
"#endif\n{",
"gen_op_mov_TN_reg(OT_LONG, 0, VAR_7);",
"tcg_gen_ext32u_tl(cpu_T[0], cpu_T[0]);",
"tcg_gen_bswap32_tl(cpu_T[0], cpu_T[0]);",
"gen_op_mov_reg_T0(OT_LONG, VAR_7);",
"}",
"break;",
"case 0xd6:\nif (CODE64(s))\ngoto illegal_op;",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_compute_eflags_c(cpu_T[0]);",
"tcg_gen_neg_tl(cpu_T[0], cpu_T[0]);",
"gen_op_mov_reg_T0(OT_BYTE, R_EAX);",
"break;",
"case 0xe0:\ncase 0xe1:\ncase 0xe2:\ncase 0xe3:\n{",
"int VAR_27, VAR_27, VAR_28;",
"tval = (int8_t)insn_get(s, OT_BYTE);",
"next_eip = s->pc - s->cs_base;",
"tval += next_eip;",
"if (s->VAR_3 == 0)\ntval &= 0xffff;",
"VAR_27 = gen_new_label();",
"VAR_27 = gen_new_label();",
"VAR_28 = gen_new_label();",
"VAR_0 &= 3;",
"switch(VAR_0) {",
"case 0:\ncase 1:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_op_add_reg_im(s->VAR_2, R_ECX, -1);",
"gen_op_jz_ecx(s->VAR_2, VAR_28);",
"gen_compute_eflags(cpu_tmp0);",
"tcg_gen_andi_tl(cpu_tmp0, cpu_tmp0, CC_Z);",
"if (VAR_0 == 0) {",
"tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, VAR_27);",
"} else {",
"tcg_gen_brcondi_tl(TCG_COND_NE, cpu_tmp0, 0, VAR_27);",
"}",
"break;",
"case 2:\ngen_op_add_reg_im(s->VAR_2, R_ECX, -1);",
"gen_op_jnz_ecx(s->VAR_2, VAR_27);",
"break;",
"default:\ncase 3:\ngen_op_jz_ecx(s->VAR_2, VAR_27);",
"break;",
"}",
"gen_set_label(VAR_28);",
"gen_jmp_im(next_eip);",
"tcg_gen_br(VAR_27);",
"gen_set_label(VAR_27);",
"gen_jmp_im(tval);",
"gen_set_label(VAR_27);",
"gen_eob(s);",
"}",
"break;",
"case 0x130:\ncase 0x132:\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_jmp_im(pc_start - s->cs_base);",
"if (VAR_0 & 2) {",
"gen_helper_rdmsr(cpu_env);",
"} else {",
"gen_helper_wrmsr(cpu_env);",
"}",
"}",
"break;",
"case 0x131:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"if (use_icount)\ngen_io_start();",
"gen_helper_rdtsc(cpu_env);",
"if (use_icount) {",
"gen_io_end();",
"gen_jmp(s, s->pc - s->cs_base);",
"}",
"break;",
"case 0x133:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_rdpmc(cpu_env);",
"break;",
"case 0x134:\nif (CODE64(s) && cpu_single_env->cpuid_vendor1 != CPUID_VENDOR_INTEL_1)\ngoto illegal_op;",
"if (!s->pe) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"} else {",
"gen_update_cc_op(s);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_sysenter(cpu_env);",
"gen_eob(s);",
"}",
"break;",
"case 0x135:\nif (CODE64(s) && cpu_single_env->cpuid_vendor1 != CPUID_VENDOR_INTEL_1)\ngoto illegal_op;",
"if (!s->pe) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"} else {",
"gen_update_cc_op(s);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_sysexit(cpu_env, tcg_const_i32(VAR_3));",
"gen_eob(s);",
"}",
"break;",
"#ifdef TARGET_X86_64\ncase 0x105:\ngen_update_cc_op(s);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_syscall(cpu_env, tcg_const_i32(s->pc - pc_start));",
"gen_eob(s);",
"break;",
"case 0x107:\nif (!s->pe) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"} else {",
"gen_update_cc_op(s);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_sysret(cpu_env, tcg_const_i32(s->VAR_3));",
"if (s->lma)\ns->cc_op = CC_OP_EFLAGS;",
"gen_eob(s);",
"}",
"break;",
"#endif\ncase 0x1a2:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_cpuid(cpu_env);",
"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_jmp_im(pc_start - s->cs_base);",
"gen_helper_hlt(cpu_env, tcg_const_i32(s->pc - pc_start));",
"s->is_jmp = DISAS_TB_JUMP;",
"}",
"break;",
"case 0x100:\nVAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_17 = (VAR_6 >> 3) & 7;",
"switch(VAR_17) {",
"case 0:\nif (!s->pe || s->vm86)\ngoto illegal_op;",
"gen_svm_check_intercept(s, pc_start, SVM_EXIT_LDTR_READ);",
"tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,ldt.VAR_27));",
"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_svm_check_intercept(s, pc_start, SVM_EXIT_LDTR_WRITE);",
"gen_ldst_modrm(s, VAR_6, OT_WORD, OR_TMP0, 0);",
"gen_jmp_im(pc_start - s->cs_base);",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"gen_helper_lldt(cpu_env, cpu_tmp2_i32);",
"}",
"break;",
"case 1:\nif (!s->pe || s->vm86)\ngoto illegal_op;",
"gen_svm_check_intercept(s, pc_start, SVM_EXIT_TR_READ);",
"tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,tr.VAR_27));",
"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_svm_check_intercept(s, pc_start, SVM_EXIT_TR_WRITE);",
"gen_ldst_modrm(s, VAR_6, OT_WORD, OR_TMP0, 0);",
"gen_jmp_im(pc_start - s->cs_base);",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"gen_helper_ltr(cpu_env, cpu_tmp2_i32);",
"}",
"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_17 == 4) {",
"gen_helper_verr(cpu_env, cpu_T[0]);",
"} else {",
"gen_helper_verw(cpu_env, cpu_T[0]);",
"}",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x101:\nVAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_17 = (VAR_6 >> 3) & 7;",
"VAR_8 = VAR_6 & 7;",
"switch(VAR_17) {",
"case 0:\nif (VAR_9 == 3)\ngoto illegal_op;",
"gen_svm_check_intercept(s, pc_start, SVM_EXIT_GDTR_READ);",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, gdt.limit));",
"gen_op_st_T0_A0(OT_WORD + s->mem_index);",
"gen_add_A0_im(s, 2);",
"tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, gdt.base));",
"if (!s->VAR_3)\ngen_op_andl_T0_im(0xffffff);",
"gen_op_st_T0_A0(CODE64(s) + OT_LONG + s->mem_index);",
"break;",
"case 1:\nif (VAR_9 == 3) {",
"switch (VAR_8) {",
"case 0:\nif (!(s->cpuid_ext_features & CPUID_EXT_MONITOR) ||\ns->cpl != 0)\ngoto illegal_op;",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"#ifdef TARGET_X86_64\nif (s->VAR_2 == 2) {",
"gen_op_movq_A0_reg(R_EAX);",
"} else",
"#endif\n{",
"gen_op_movl_A0_reg(R_EAX);",
"if (s->VAR_2 == 0)\ngen_op_andl_A0_ffff();",
"}",
"gen_add_A0_ds_seg(s);",
"gen_helper_monitor(cpu_env, cpu_A0);",
"break;",
"case 1:\nif (!(s->cpuid_ext_features & CPUID_EXT_MONITOR) ||\ns->cpl != 0)\ngoto illegal_op;",
"gen_update_cc_op(s);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_mwait(cpu_env, tcg_const_i32(s->pc - pc_start));",
"gen_eob(s);",
"break;",
"default:\ngoto illegal_op;",
"}",
"} else {",
"gen_svm_check_intercept(s, pc_start, SVM_EXIT_IDTR_READ);",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, idt.limit));",
"gen_op_st_T0_A0(OT_WORD + s->mem_index);",
"gen_add_A0_im(s, 2);",
"tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, idt.base));",
"if (!s->VAR_3)\ngen_op_andl_T0_im(0xffffff);",
"gen_op_st_T0_A0(CODE64(s) + OT_LONG + s->mem_index);",
"}",
"break;",
"case 2:\ncase 3:\nif (VAR_9 == 3) {",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"switch(VAR_8) {",
"case 0:\nif (!(s->flags & HF_SVME_MASK) || !s->pe)\ngoto illegal_op;",
"if (s->cpl != 0) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"break;",
"} else {",
"gen_helper_vmrun(cpu_env, tcg_const_i32(s->VAR_2),\ntcg_const_i32(s->pc - pc_start));",
"tcg_gen_exit_tb(0);",
"s->is_jmp = DISAS_TB_JUMP;",
"}",
"break;",
"case 1:\nif (!(s->flags & HF_SVME_MASK))\ngoto illegal_op;",
"gen_helper_vmmcall(cpu_env);",
"break;",
"case 2:\nif (!(s->flags & HF_SVME_MASK) || !s->pe)\ngoto illegal_op;",
"if (s->cpl != 0) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"break;",
"} else {",
"gen_helper_vmload(cpu_env, tcg_const_i32(s->VAR_2));",
"}",
"break;",
"case 3:\nif (!(s->flags & HF_SVME_MASK) || !s->pe)\ngoto illegal_op;",
"if (s->cpl != 0) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"break;",
"} else {",
"gen_helper_vmsave(cpu_env, tcg_const_i32(s->VAR_2));",
"}",
"break;",
"case 4:\nif ((!(s->flags & HF_SVME_MASK) &&\n!(s->cpuid_ext3_features & CPUID_EXT3_SKINIT)) ||\n!s->pe)\ngoto illegal_op;",
"if (s->cpl != 0) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"break;",
"} else {",
"gen_helper_stgi(cpu_env);",
"}",
"break;",
"case 5:\nif (!(s->flags & HF_SVME_MASK) || !s->pe)\ngoto illegal_op;",
"if (s->cpl != 0) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"break;",
"} else {",
"gen_helper_clgi(cpu_env);",
"}",
"break;",
"case 6:\nif ((!(s->flags & HF_SVME_MASK) &&\n!(s->cpuid_ext3_features & CPUID_EXT3_SKINIT)) ||\n!s->pe)\ngoto illegal_op;",
"gen_helper_skinit(cpu_env);",
"break;",
"case 7:\nif (!(s->flags & HF_SVME_MASK) || !s->pe)\ngoto illegal_op;",
"if (s->cpl != 0) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"break;",
"} else {",
"gen_helper_invlpga(cpu_env, tcg_const_i32(s->VAR_2));",
"}",
"break;",
"default:\ngoto illegal_op;",
"}",
"} else if (s->cpl != 0) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"} else {",
"gen_svm_check_intercept(s, pc_start,\nVAR_17==2 ? SVM_EXIT_GDTR_WRITE : SVM_EXIT_IDTR_WRITE);",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"gen_op_ld_T1_A0(OT_WORD + s->mem_index);",
"gen_add_A0_im(s, 2);",
"gen_op_ld_T0_A0(CODE64(s) + OT_LONG + s->mem_index);",
"if (!s->VAR_3)\ngen_op_andl_T0_im(0xffffff);",
"if (VAR_17 == 2) {",
"tcg_gen_st_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,gdt.base));",
"tcg_gen_st32_tl(cpu_T[1], cpu_env, offsetof(CPUX86State,gdt.limit));",
"} else {",
"tcg_gen_st_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,idt.base));",
"tcg_gen_st32_tl(cpu_T[1], cpu_env, offsetof(CPUX86State,idt.limit));",
"}",
"}",
"break;",
"case 4:\ngen_svm_check_intercept(s, pc_start, SVM_EXIT_READ_CR0);",
"#if defined TARGET_X86_64 && defined HOST_WORDS_BIGENDIAN\ntcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,cr[0]) + 4);",
"#else\ntcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,cr[0]));",
"#endif\ngen_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_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_CR0);",
"gen_ldst_modrm(s, VAR_6, OT_WORD, OR_TMP0, 0);",
"gen_helper_lmsw(cpu_env, cpu_T[0]);",
"gen_jmp_im(s->pc - s->cs_base);",
"gen_eob(s);",
"}",
"break;",
"case 7:\nif (VAR_9 != 3) {",
"if (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_jmp_im(pc_start - s->cs_base);",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"gen_helper_invlpg(cpu_env, cpu_A0);",
"gen_jmp_im(s->pc - s->cs_base);",
"gen_eob(s);",
"}",
"} else {",
"switch (VAR_8) {",
"case 0:\n#ifdef TARGET_X86_64\nif (CODE64(s)) {",
"if (s->cpl != 0) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"} else {",
"tcg_gen_ld_tl(cpu_T[0], cpu_env,\noffsetof(CPUX86State,segs[R_GS].base));",
"tcg_gen_ld_tl(cpu_T[1], cpu_env,\noffsetof(CPUX86State,kernelgsbase));",
"tcg_gen_st_tl(cpu_T[1], cpu_env,\noffsetof(CPUX86State,segs[R_GS].base));",
"tcg_gen_st_tl(cpu_T[0], cpu_env,\noffsetof(CPUX86State,kernelgsbase));",
"}",
"} else",
"#endif\n{",
"goto illegal_op;",
"}",
"break;",
"case 1:\nif (!(s->cpuid_ext2_features & CPUID_EXT2_RDTSCP))\ngoto illegal_op;",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"if (use_icount)\ngen_io_start();",
"gen_helper_rdtscp(cpu_env);",
"if (use_icount) {",
"gen_io_end();",
"gen_jmp(s, s->pc - s->cs_base);",
"}",
"break;",
"default:\ngoto illegal_op;",
"}",
"}",
"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 {",
"gen_svm_check_intercept(s, pc_start, (VAR_0 & 2) ? SVM_EXIT_INVD : SVM_EXIT_WBINVD);",
"}",
"break;",
"case 0x63:\n#ifdef TARGET_X86_64\nif (CODE64(s)) {",
"int VAR_21;",
"VAR_21 = VAR_3 + OT_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_8 = (VAR_6 & 7) | REX_B(s);",
"if (VAR_9 == 3) {",
"gen_op_mov_TN_reg(OT_LONG, 0, VAR_8);",
"if (VAR_21 == OT_QUAD)\ntcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);",
"gen_op_mov_reg_T0(VAR_21, VAR_7);",
"} else {",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"if (VAR_21 == OT_QUAD) {",
"gen_op_lds_T0_A0(OT_LONG + s->mem_index);",
"} else {",
"gen_op_ld_T0_A0(OT_LONG + s->mem_index);",
"}",
"gen_op_mov_reg_T0(VAR_21, VAR_7);",
"}",
"} else",
"#endif\n{",
"int VAR_29;",
"TCGv t0, t1, t2, a0;",
"if (!s->pe || s->vm86)\ngoto illegal_op;",
"t0 = tcg_temp_local_new();",
"t1 = tcg_temp_local_new();",
"t2 = tcg_temp_local_new();",
"VAR_5 = OT_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, 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_v(VAR_5 + s->mem_index, t0, cpu_A0);",
"a0 = tcg_temp_local_new();",
"tcg_gen_mov_tl(a0, cpu_A0);",
"} else {",
"gen_op_mov_v_reg(VAR_5, t0, VAR_8);",
"TCGV_UNUSED(a0);",
"}",
"gen_op_mov_v_reg(VAR_5, t1, VAR_7);",
"tcg_gen_andi_tl(cpu_tmp0, t0, 3);",
"tcg_gen_andi_tl(t1, t1, 3);",
"tcg_gen_movi_tl(t2, 0);",
"VAR_29 = gen_new_label();",
"tcg_gen_brcond_tl(TCG_COND_GE, cpu_tmp0, t1, VAR_29);",
"tcg_gen_andi_tl(t0, t0, ~3);",
"tcg_gen_or_tl(t0, t0, t1);",
"tcg_gen_movi_tl(t2, CC_Z);",
"gen_set_label(VAR_29);",
"if (VAR_9 != 3) {",
"gen_op_st_v(VAR_5 + s->mem_index, t0, a0);",
"tcg_temp_free(a0);",
"} else {",
"gen_op_mov_reg_v(VAR_5, VAR_8, t0);",
"}",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_compute_eflags(cpu_cc_src);",
"tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, ~CC_Z);",
"tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, t2);",
"s->cc_op = CC_OP_EFLAGS;",
"tcg_temp_free(t0);",
"tcg_temp_free(t1);",
"tcg_temp_free(t2);",
"}",
"break;",
"case 0x102:\ncase 0x103:\n{",
"int VAR_29;",
"TCGv t0;",
"if (!s->pe || s->vm86)\ngoto illegal_op;",
"VAR_5 = VAR_3 ? OT_LONG : OT_WORD;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"gen_ldst_modrm(s, VAR_6, OT_WORD, OR_TMP0, 0);",
"t0 = tcg_temp_local_new();",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"if (VAR_0 == 0x102) {",
"gen_helper_lar(t0, cpu_env, cpu_T[0]);",
"} else {",
"gen_helper_lsl(t0, cpu_env, cpu_T[0]);",
"}",
"tcg_gen_andi_tl(cpu_tmp0, cpu_cc_src, CC_Z);",
"VAR_29 = gen_new_label();",
"tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, VAR_29);",
"gen_op_mov_reg_v(VAR_5, VAR_7, t0);",
"gen_set_label(VAR_29);",
"s->cc_op = CC_OP_EFLAGS;",
"tcg_temp_free(t0);",
"}",
"break;",
"case 0x118:\nVAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_17 = (VAR_6 >> 3) & 7;",
"switch(VAR_17) {",
"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:\ngen_nop_modrm(s, VAR_6);",
"break;",
"}",
"break;",
"case 0x119 ... 0x11f:\nVAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"gen_nop_modrm(s, VAR_6);",
"break;",
"case 0x120:\ncase 0x122:\nif (s->cpl != 0) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"} else {",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_8 = (VAR_6 & 7) | REX_B(s);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"if (CODE64(s))\nVAR_5 = OT_QUAD;",
"else\nVAR_5 = OT_LONG;",
"if ((VAR_1 & PREFIX_LOCK) && (VAR_7 == 0) &&\n(s->cpuid_ext3_features & CPUID_EXT3_CR8LEG)) {",
"VAR_7 = 8;",
"}",
"switch(VAR_7) {",
"case 0:\ncase 2:\ncase 3:\ncase 4:\ncase 8:\nif (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"if (VAR_0 & 2) {",
"gen_op_mov_TN_reg(VAR_5, 0, VAR_8);",
"gen_helper_write_crN(cpu_env, tcg_const_i32(VAR_7),\ncpu_T[0]);",
"gen_jmp_im(s->pc - s->cs_base);",
"gen_eob(s);",
"} else {",
"gen_helper_read_crN(cpu_T[0], cpu_env, tcg_const_i32(VAR_7));",
"gen_op_mov_reg_T0(VAR_5, 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 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_8 = (VAR_6 & 7) | REX_B(s);",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"if (CODE64(s))\nVAR_5 = OT_QUAD;",
"else\nVAR_5 = OT_LONG;",
"if (VAR_7 == 4 || VAR_7 == 5 || VAR_7 >= 8)\ngoto illegal_op;",
"if (VAR_0 & 2) {",
"gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_DR0 + VAR_7);",
"gen_op_mov_TN_reg(VAR_5, 0, VAR_8);",
"gen_helper_movl_drN_T0(cpu_env, tcg_const_i32(VAR_7), cpu_T[0]);",
"gen_jmp_im(s->pc - s->cs_base);",
"gen_eob(s);",
"} else {",
"gen_svm_check_intercept(s, pc_start, SVM_EXIT_READ_DR0 + VAR_7);",
"tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,dr[VAR_7]));",
"gen_op_mov_reg_T0(VAR_5, VAR_8);",
"}",
"}",
"break;",
"case 0x106:\nif (s->cpl != 0) {",
"gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);",
"} else {",
"gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_CR0);",
"gen_helper_clts(cpu_env);",
"gen_jmp_im(s->pc - s->cs_base);",
"gen_eob(s);",
"}",
"break;",
"case 0x1c3:\nif (!(s->cpuid_features & CPUID_SSE2))\ngoto illegal_op;",
"VAR_5 = s->VAR_3 == 2 ? OT_QUAD : OT_LONG;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"if (VAR_9 == 3)\ngoto illegal_op;",
"VAR_7 = ((VAR_6 >> 3) & 7) | VAR_16;",
"gen_ldst_modrm(s, VAR_6, VAR_5, VAR_7, 1);",
"break;",
"case 0x1ae:\nVAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"VAR_17 = (VAR_6 >> 3) & 7;",
"switch(VAR_17) {",
"case 0:\nif (VAR_9 == 3 || !(s->cpuid_features & CPUID_FXSR) ||\n(s->prefix & PREFIX_LOCK))\ngoto illegal_op;",
"if ((s->flags & HF_EM_MASK) || (s->flags & HF_TS_MASK)) {",
"gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);",
"break;",
"}",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_fxsave(cpu_env, cpu_A0, tcg_const_i32((s->VAR_3 == 2)));",
"break;",
"case 1:\nif (VAR_9 == 3 || !(s->cpuid_features & CPUID_FXSR) ||\n(s->prefix & PREFIX_LOCK))\ngoto illegal_op;",
"if ((s->flags & HF_EM_MASK) || (s->flags & HF_TS_MASK)) {",
"gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);",
"break;",
"}",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"if (s->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(s->cc_op);",
"gen_jmp_im(pc_start - s->cs_base);",
"gen_helper_fxrstor(cpu_env, cpu_A0,\ntcg_const_i32((s->VAR_3 == 2)));",
"break;",
"case 2:\ncase 3:\nif (s->flags & HF_TS_MASK) {",
"gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);",
"break;",
"}",
"if ((s->flags & HF_EM_MASK) || !(s->flags & HF_OSFXSR_MASK) ||\nVAR_9 == 3)\ngoto illegal_op;",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"if (VAR_17 == 2) {",
"gen_op_ld_T0_A0(OT_LONG + s->mem_index);",
"tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);",
"gen_helper_ldmxcsr(cpu_env, cpu_tmp2_i32);",
"} else {",
"tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, mxcsr));",
"gen_op_st_T0_A0(OT_LONG + s->mem_index);",
"}",
"break;",
"case 5:\ncase 6:\nif ((VAR_6 & 0xc7) != 0xc0 || !(s->cpuid_features & CPUID_SSE2))\ngoto illegal_op;",
"break;",
"case 7:\nif ((VAR_6 & 0xc7) == 0xc0) {",
"if (!(s->cpuid_features & CPUID_SSE))\ngoto illegal_op;",
"} else {",
"if (!(s->cpuid_features & CPUID_CLFLUSH))\ngoto illegal_op;",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"}",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x10d:\nVAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_9 = (VAR_6 >> 6) & 3;",
"if (VAR_9 == 3)\ngoto illegal_op;",
"gen_lea_modrm(s, VAR_6, &VAR_10, &VAR_13);",
"break;",
"case 0x1aa:\ngen_svm_check_intercept(s, pc_start, SVM_EXIT_RSM);",
"if (!(s->flags & HF_SMM_MASK))\ngoto illegal_op;",
"gen_update_cc_op(s);",
"gen_jmp_im(s->pc - s->cs_base);",
"gen_helper_rsm(cpu_env);",
"gen_eob(s);",
"break;",
"case 0x1b8:\nif ((VAR_1 & (PREFIX_REPZ | PREFIX_LOCK | PREFIX_REPNZ)) !=\nPREFIX_REPZ)\ngoto illegal_op;",
"if (!(s->cpuid_ext_features & CPUID_EXT_POPCNT))\ngoto illegal_op;",
"VAR_6 = cpu_ldub_code(cpu_single_env, s->pc++);",
"VAR_7 = ((VAR_6 >> 3) & 7);",
"if (s->prefix & PREFIX_DATA)\nVAR_5 = OT_WORD;",
"else if (s->VAR_3 != 2)\nVAR_5 = OT_LONG;",
"else\nVAR_5 = OT_QUAD;",
"gen_ldst_modrm(s, VAR_6, VAR_5, OR_TMP0, 0);",
"gen_helper_popcnt(cpu_T[0], cpu_env, cpu_T[0], tcg_const_i32(VAR_5));",
"gen_op_mov_reg_T0(VAR_5, VAR_7);",
"s->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x10e ... 0x10f:\ns->prefix &= ~(PREFIX_REPZ | PREFIX_REPNZ | PREFIX_DATA);",
"case 0x110 ... 0x117:\ncase 0x128 ... 0x12f:\ncase 0x138 ... 0x13a:\ncase 0x150 ... 0x179:\ncase 0x17c ... 0x17f:\ncase 0x1c2:\ncase 0x1c4 ... 0x1c6:\ncase 0x1d0 ... 0x1fe:\ngen_sse(s, VAR_0, pc_start, VAR_16);",
"break;",
"default:\ngoto illegal_op;",
"}",
"if (s->prefix & PREFIX_LOCK)\ngen_helper_unlock();",
"return s->pc;",
"illegal_op:\nif (s->prefix & PREFIX_LOCK)\ngen_helper_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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37,
39
],
[
41
],
[
43
],
[
45,
47
],
[
49,
51
],
[
53
],
[
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
],
[
127
],
[
129,
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
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
],
[
253
],
[
255
],
[
257
],
[
263,
265
],
[
271,
273
],
[
275,
281
],
[
283
],
[
291,
293,
295,
297,
299,
301,
303,
305,
307
],
[
309
],
[
311
],
[
313
],
[
317,
319
],
[
321,
323
],
[
327
],
[
329,
331
],
[
333
],
[
335
],
[
337
],
[
339
],
[
341
],
[
343
],
[
345
],
[
347,
351
],
[
353
],
[
355
],
[
357
],
[
359
],
[
361
],
[
363
],
[
365
],
[
367
],
[
369
],
[
371
],
[
373,
375
],
[
377
],
[
379
],
[
381
],
[
383
],
[
385
],
[
387
],
[
389
],
[
391
],
[
393
],
[
395
],
[
397
],
[
399
],
[
401
],
[
403,
405
],
[
407
],
[
409
],
[
411
],
[
413
],
[
415
],
[
417
],
[
421,
423,
425
],
[
427,
429,
431,
433
],
[
435
],
[
439,
441
],
[
443,
445
],
[
449
],
[
451
],
[
453
],
[
455
],
[
459
],
[
461,
463
],
[
465,
467
],
[
469
],
[
471
],
[
473
],
[
475
],
[
477
],
[
481
],
[
483,
485,
487,
489,
491
],
[
493
],
[
495,
497
],
[
499
],
[
501
],
[
503
],
[
505
],
[
507
],
[
509
],
[
517,
519
],
[
521
],
[
523
],
[
525,
527
],
[
529
],
[
531
],
[
533,
535,
537,
539
],
[
541,
543
],
[
547
],
[
549
],
[
551
],
[
553
],
[
555
],
[
557,
559
],
[
561
],
[
563
],
[
565
],
[
567
],
[
569
],
[
573
],
[
575,
577
],
[
579
],
[
581
],
[
583
],
[
585
],
[
587,
589
],
[
591
],
[
593
],
[
595
],
[
597
],
[
599
],
[
601
],
[
603,
605
],
[
607
],
[
609
],
[
611
],
[
613
],
[
615
],
[
617
],
[
619
],
[
621
],
[
623,
625
],
[
627,
629
],
[
631
],
[
633
],
[
637
],
[
639
],
[
641
],
[
643
],
[
645
],
[
647
],
[
649,
651
],
[
653
],
[
655
],
[
659
],
[
661
],
[
663
],
[
665
],
[
667
],
[
669
],
[
671
],
[
673
],
[
675,
677,
679,
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
],
[
769
],
[
771
],
[
773
],
[
775
],
[
777
],
[
779
],
[
781
],
[
783,
785
],
[
787
],
[
789
],
[
793
],
[
795
],
[
797
],
[
799
],
[
801
],
[
803
],
[
805
],
[
807
],
[
809
],
[
811,
813,
815,
817
],
[
819
],
[
821
],
[
823
],
[
825
],
[
827
],
[
829
],
[
831
],
[
833
],
[
835
],
[
837,
839
],
[
841
],
[
843
],
[
845
],
[
847
],
[
849
],
[
851
],
[
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,
909
],
[
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
],
[
997,
999,
1001,
1003
],
[
1005,
1007
],
[
1011
],
[
1013
],
[
1015
],
[
1017
],
[
1019
],
[
1021
],
[
1023
],
[
1025
],
[
1027
],
[
1031
],
[
1033
],
[
1035
],
[
1037
],
[
1041
],
[
1043
],
[
1045
],
[
1047
],
[
1049
],
[
1051,
1053
],
[
1055
],
[
1057
],
[
1059
],
[
1063
],
[
1065,
1067,
1069
],
[
1071,
1073
],
[
1075
],
[
1077
],
[
1079,
1081,
1083
],
[
1085,
1087
],
[
1089
],
[
1091
],
[
1093,
1097,
1099
],
[
1101
],
[
1103
],
[
1105
],
[
1107
],
[
1109
],
[
1111
],
[
1113,
1115
],
[
1117
],
[
1119
],
[
1121,
1123
],
[
1125,
1127
],
[
1129
],
[
1131
],
[
1133,
1135,
1137
],
[
1139
],
[
1141
],
[
1143,
1145,
1147
],
[
1149
],
[
1151
],
[
1153
],
[
1155,
1157,
1159
],
[
1161
],
[
1163
],
[
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
],
[
1221,
1223,
1225,
1227
],
[
1229,
1231
],
[
1235
],
[
1237
],
[
1241
],
[
1243
],
[
1245
],
[
1247
],
[
1249
],
[
1253,
1255,
1257,
1259
],
[
1261,
1263
],
[
1265
],
[
1269
],
[
1271
],
[
1273
],
[
1275
],
[
1277
],
[
1281,
1283,
1285
],
[
1287
],
[
1289
],
[
1291
],
[
1293
],
[
1295,
1297
],
[
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
],
[
1353
],
[
1355
],
[
1357,
1359,
1361,
1363
],
[
1365
],
[
1367
],
[
1369,
1371
],
[
1373,
1375
],
[
1377
],
[
1379
],
[
1381
],
[
1383
],
[
1385
],
[
1387
],
[
1389
],
[
1391
],
[
1393
],
[
1395
],
[
1399,
1401
],
[
1403
],
[
1405
],
[
1407,
1409
],
[
1411,
1413
],
[
1415
],
[
1417
],
[
1419
],
[
1421
],
[
1423
],
[
1425,
1427
],
[
1429
],
[
1431
],
[
1433
],
[
1435
],
[
1437
],
[
1439
],
[
1441
],
[
1443
],
[
1445
],
[
1447
],
[
1449
],
[
1451
],
[
1453
],
[
1455,
1457
],
[
1459
],
[
1461
],
[
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
],
[
1515
],
[
1517
],
[
1519
],
[
1521
],
[
1523
],
[
1525
],
[
1527
],
[
1529
],
[
1531
],
[
1533
],
[
1535,
1537,
1539
],
[
1541
],
[
1543
],
[
1547,
1549
],
[
1551,
1553
],
[
1555
],
[
1557
],
[
1559
],
[
1561
],
[
1563
],
[
1565
],
[
1567
],
[
1569
],
[
1571
],
[
1573
],
[
1575
],
[
1577
],
[
1579
],
[
1581
],
[
1583
],
[
1585
],
[
1587
],
[
1589
],
[
1591
],
[
1593
],
[
1595
],
[
1597
],
[
1599
],
[
1601
],
[
1603
],
[
1605
],
[
1607
],
[
1609
],
[
1617
],
[
1619
],
[
1621
],
[
1623
],
[
1625
],
[
1627
],
[
1629
],
[
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
],
[
1689,
1691
],
[
1693
],
[
1695
],
[
1697
],
[
1699
],
[
1701
],
[
1709,
1711
],
[
1713
],
[
1715
],
[
1717,
1719
],
[
1721
],
[
1723
],
[
1725
],
[
1727
],
[
1729
],
[
1733
],
[
1735
],
[
1737
],
[
1739,
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
],
[
1813
],
[
1815
],
[
1819
],
[
1821
],
[
1823
],
[
1825
],
[
1827
],
[
1829
],
[
1831,
1833
],
[
1835
],
[
1837
],
[
1839
],
[
1841
],
[
1843
],
[
1845
],
[
1847
],
[
1849,
1853
],
[
1855
],
[
1857
],
[
1859
],
[
1861
],
[
1863
],
[
1865
],
[
1867
],
[
1869
],
[
1871
],
[
1873
],
[
1875
],
[
1877
],
[
1879
],
[
1881
],
[
1883
],
[
1885
],
[
1887
],
[
1889
],
[
1891,
1893,
1895,
1897,
1899,
1901
],
[
1903
],
[
1905
],
[
1907
],
[
1909,
1911,
1913
],
[
1915
],
[
1917
],
[
1919,
1921,
1923,
1925,
1927
],
[
1929
],
[
1931
],
[
1933
],
[
1935
],
[
1937
],
[
1945,
1947
],
[
1949
],
[
1951
],
[
1953
],
[
1955
],
[
1957
],
[
1959
],
[
1961
],
[
1963,
1965,
1967
],
[
1969
],
[
1971
],
[
1973
],
[
1975
],
[
1977
],
[
1979
],
[
1981
],
[
1989,
1991,
1993,
1995
],
[
1997,
1999
],
[
2001
],
[
2003
],
[
2009
],
[
2011
],
[
2013,
2015,
2017,
2019
],
[
2021,
2023
],
[
2025
],
[
2027
],
[
2029
],
[
2031
],
[
2033
],
[
2035
],
[
2037
],
[
2039
],
[
2041,
2043
],
[
2045,
2047
],
[
2049
],
[
2051,
2053,
2055,
2057
],
[
2059,
2061
],
[
2063
],
[
2065
],
[
2069
],
[
2071
],
[
2073
],
[
2075,
2077
],
[
2079
],
[
2081,
2083
],
[
2085
],
[
2087
],
[
2089
],
[
2097,
2099
],
[
2101
],
[
2103
],
[
2105
],
[
2107
],
[
2109
],
[
2111
],
[
2113
],
[
2115,
2117
],
[
2119
],
[
2121
],
[
2123,
2125
],
[
2127
],
[
2129,
2131
],
[
2133,
2135
],
[
2137
],
[
2139
],
[
2143,
2145,
2147,
2149,
2151
],
[
2153
],
[
2157
],
[
2161
],
[
2163
],
[
2165
],
[
2167
],
[
2169
],
[
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
],
[
2233,
2235
],
[
2237
],
[
2239
],
[
2241,
2243
],
[
2245
],
[
2249
],
[
2251
],
[
2253
],
[
2255
],
[
2257
],
[
2259
],
[
2261
],
[
2265,
2267,
2269,
2271,
2273
],
[
2275
],
[
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
],
[
2329
],
[
2331
],
[
2333
],
[
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
],
[
2403
],
[
2405
],
[
2407
],
[
2409
],
[
2411
],
[
2413
],
[
2415,
2417
],
[
2419
],
[
2421
],
[
2423
],
[
2425
],
[
2427
],
[
2429
],
[
2431
],
[
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
],
[
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
],
[
2563
],
[
2565
],
[
2569
],
[
2571
],
[
2573
],
[
2575
],
[
2577
],
[
2579
],
[
2587,
2589,
2593
],
[
2595,
2597
],
[
2599,
2601
],
[
2603,
2605
],
[
2609
],
[
2611
],
[
2613
],
[
2617
],
[
2619
],
[
2621
],
[
2623
],
[
2625
],
[
2627
],
[
2629
],
[
2631
],
[
2633
],
[
2639
],
[
2641
],
[
2643
],
[
2645
],
[
2647
],
[
2649
],
[
2651
],
[
2653
],
[
2655
],
[
2657
],
[
2659,
2661,
2665
],
[
2667
],
[
2669,
2671,
2675
],
[
2677
],
[
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
],
[
2739
],
[
2741
],
[
2743
],
[
2745
],
[
2747
],
[
2749
],
[
2751
],
[
2753
],
[
2761,
2763
],
[
2769
],
[
2771
],
[
2773
],
[
2775
],
[
2777
],
[
2779
],
[
2781
],
[
2783
],
[
2787
],
[
2789
],
[
2791,
2793,
2795,
2797,
2799
],
[
2801
],
[
2803
],
[
2807
],
[
2809,
2811
],
[
2813
],
[
2815
],
[
2817
],
[
2819,
2821
],
[
2823
],
[
2825
],
[
2827
],
[
2829,
2831,
2833
],
[
2835
],
[
2837
],
[
2839,
2841,
2843
],
[
2845
],
[
2847
],
[
2849
],
[
2851
],
[
2855
],
[
2857
],
[
2861
],
[
2863
],
[
2865
],
[
2867
],
[
2869,
2871,
2873,
2875,
2877,
2879,
2881
],
[
2883,
2885
],
[
2887,
2889
],
[
2891
],
[
2893
],
[
2895
],
[
2897,
2899
],
[
2901
],
[
2903
],
[
2905
],
[
2907,
2909,
2911
],
[
2913
],
[
2915
],
[
2917,
2919,
2921
],
[
2923
],
[
2925
],
[
2927
],
[
2929
],
[
2931
],
[
2933,
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
],
[
2999
],
[
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,
3083
],
[
3085
],
[
3087
],
[
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
],
[
3185
],
[
3187,
3189
],
[
3191
],
[
3193
],
[
3197
],
[
3201
],
[
3203,
3205
],
[
3207,
3209
],
[
3211
],
[
3213,
3215,
3217,
3219
],
[
3221
],
[
3223,
3225
],
[
3227,
3231,
3233
],
[
3235
],
[
3237
],
[
3239
],
[
3241,
3243
],
[
3245
],
[
3247
],
[
3249,
3251
],
[
3253,
3255
],
[
3257
],
[
3259,
3261
],
[
3263
],
[
3265,
3267
],
[
3269
],
[
3271
],
[
3273,
3275
],
[
3277
],
[
3279,
3281
],
[
3283
],
[
3285
],
[
3287,
3289
],
[
3291
],
[
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
],
[
3363,
3365
],
[
3367
],
[
3369,
3371
],
[
3373
],
[
3375,
3377
],
[
3379
],
[
3381,
3383
],
[
3385
],
[
3387,
3389
],
[
3391
],
[
3393,
3395
],
[
3397
],
[
3399,
3401
],
[
3403
],
[
3405,
3407,
3409
],
[
3411
],
[
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,
3467
],
[
3469
],
[
3471
],
[
3473
],
[
3475,
3477,
3479,
3481
],
[
3483
],
[
3487
],
[
3489
],
[
3491
],
[
3493,
3495
],
[
3497
],
[
3499
],
[
3501
],
[
3503
],
[
3505
],
[
3507
],
[
3509,
3511,
3513
],
[
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
],
[
3591
],
[
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
],
[
3675
],
[
3677
],
[
3679
],
[
3681,
3683
],
[
3685
],
[
3687
],
[
3689,
3691
],
[
3693
],
[
3695
],
[
3697,
3699
],
[
3701,
3703
],
[
3705
],
[
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
],
[
3777
],
[
3779
],
[
3781
],
[
3783
],
[
3785,
3787
],
[
3789
],
[
3791
],
[
3793
],
[
3801,
3803,
3805,
3807
],
[
3809,
3811
],
[
3815
],
[
3817
],
[
3819
],
[
3821
],
[
3823
],
[
3825
],
[
3829,
3831,
3833,
3835
],
[
3837,
3839
],
[
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
],
[
3911,
3913,
3915,
3917
],
[
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
],
[
4025,
4027,
4029,
4031
],
[
4033,
4035
],
[
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
],
[
4089,
4091
],
[
4093
],
[
4095
],
[
4097
],
[
4099
],
[
4101
],
[
4103
],
[
4105
],
[
4107
],
[
4109,
4111,
4113,
4115
],
[
4117,
4119
],
[
4121
],
[
4123
],
[
4125,
4127
],
[
4129,
4131
],
[
4133
],
[
4135
],
[
4137
],
[
4139
],
[
4141
],
[
4143
],
[
4145
],
[
4147
],
[
4149,
4151,
4153,
4155
],
[
4157,
4159
],
[
4161
],
[
4163
],
[
4165,
4167
],
[
4169
],
[
4173,
4175
],
[
4177
],
[
4179
],
[
4181
],
[
4183
],
[
4185
],
[
4187
],
[
4189
],
[
4191
],
[
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
],
[
4265
],
[
4267,
4269
],
[
4275
],
[
4279
],
[
4281
],
[
4283
],
[
4287
],
[
4289
],
[
4291
],
[
4293
],
[
4295,
4297
],
[
4299
],
[
4301,
4303
],
[
4305
],
[
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
],
[
4389,
4391
],
[
4393
],
[
4395
],
[
4397
],
[
4401
],
[
4403
],
[
4405
],
[
4407
],
[
4409,
4411,
4413
],
[
4415,
4417
],
[
4419
],
[
4421,
4423
],
[
4425,
4427
],
[
4429
],
[
4431
],
[
4433,
4435
],
[
4437
],
[
4441,
4443
],
[
4445
],
[
4447
],
[
4449
],
[
4453
],
[
4455
],
[
4457
],
[
4459
],
[
4461,
4463
],
[
4465
],
[
4467,
4469
],
[
4471
],
[
4473
],
[
4475,
4477
],
[
4479
],
[
4481,
4483
],
[
4485
],
[
4487
],
[
4489
],
[
4491
],
[
4493,
4495
],
[
4497
],
[
4499,
4501
],
[
4503
],
[
4505
],
[
4509,
4511
],
[
4513
],
[
4515
],
[
4517
],
[
4519,
4521
],
[
4523
],
[
4525
],
[
4529
],
[
4531
],
[
4533
],
[
4535
],
[
4537
],
[
4539
],
[
4541
],
[
4543
],
[
4545
],
[
4547
],
[
4549
],
[
4551
],
[
4553,
4555
],
[
4559
],
[
4561
],
[
4563
],
[
4565
],
[
4567
],
[
4569
],
[
4571,
4573
],
[
4575
],
[
4577
],
[
4579
],
[
4581
],
[
4583
],
[
4585
],
[
4587
],
[
4589
],
[
4597,
4599
],
[
4601
],
[
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
],
[
4693
],
[
4695
],
[
4697
],
[
4699,
4701,
4703
],
[
4705
],
[
4707,
4709,
4711,
4713
],
[
4715
],
[
4717
],
[
4719
],
[
4721
],
[
4723
],
[
4727
],
[
4729
],
[
4731
],
[
4733
],
[
4735,
4737,
4739
],
[
4741
],
[
4743,
4745
],
[
4747
],
[
4749
],
[
4751
],
[
4753
],
[
4755
],
[
4757
],
[
4759,
4761,
4763
],
[
4765,
4767
],
[
4769
],
[
4773
],
[
4775
],
[
4777
],
[
4779,
4781,
4783
],
[
4785
],
[
4787
],
[
4789
],
[
4791
],
[
4793,
4795,
4797
],
[
4799
],
[
4801
],
[
4803
],
[
4805
],
[
4807,
4809,
4811
],
[
4813
],
[
4815
],
[
4817
],
[
4819
],
[
4821,
4823
],
[
4825
],
[
4827
],
[
4829,
4831
],
[
4833
],
[
4835
],
[
4843,
4845
],
[
4847
],
[
4849
],
[
4851
],
[
4853
],
[
4855
],
[
4857
],
[
4859
],
[
4861
],
[
4863
],
[
4865
],
[
4867
],
[
4871
],
[
4873
],
[
4875,
4877
],
[
4879
],
[
4881
],
[
4883,
4885
],
[
4887
],
[
4889,
4891
],
[
4893
],
[
4895,
4897
],
[
4899
],
[
4901,
4903
],
[
4905,
4907
],
[
4909
],
[
4911
],
[
4913
],
[
4915
],
[
4917
],
[
4919
],
[
4921
],
[
4925
],
[
4927
],
[
4929
],
[
4931
],
[
4933
],
[
4935
],
[
4937
],
[
4939
],
[
4941,
4943
],
[
4945
],
[
4947,
4949
],
[
4951
],
[
4953
],
[
4955,
4957
],
[
4959
],
[
4961
],
[
4963
],
[
4965
],
[
4967,
4969
],
[
4971
],
[
4973
],
[
4975
],
[
4977
],
[
4979
],
[
4981,
4983,
4985
],
[
4987
],
[
4989
],
[
4991
],
[
4993
],
[
4995
],
[
4997
],
[
4999
],
[
5001,
5003
],
[
5005,
5007
],
[
5009
],
[
5011
],
[
5013
],
[
5015
],
[
5017,
5019,
5021
],
[
5023
],
[
5025
],
[
5029
],
[
5031
],
[
5033
],
[
5035
],
[
5037
],
[
5039
],
[
5041
],
[
5043,
5045
],
[
5047
],
[
5049,
5051
],
[
5053,
5055
],
[
5057,
5059
],
[
5061
],
[
5063
],
[
5065
],
[
5067
],
[
5069
],
[
5071
],
[
5073
],
[
5075
],
[
5077
],
[
5079
],
[
5081
],
[
5083
],
[
5085
],
[
5087
],
[
5089
],
[
5091
],
[
5093
],
[
5095
],
[
5097
],
[
5099
],
[
5105,
5107,
5109
],
[
5111,
5113
],
[
5115
],
[
5117
],
[
5119
],
[
5121,
5123,
5125
],
[
5127,
5129
],
[
5131
],
[
5133
],
[
5135
],
[
5137,
5139,
5141
],
[
5143,
5145
],
[
5147
],
[
5149
],
[
5151
],
[
5153,
5155,
5157
],
[
5159,
5161
],
[
5163
],
[
5165
],
[
5167
],
[
5169,
5171,
5173
],
[
5175
],
[
5177
],
[
5179
],
[
5181
],
[
5183
],
[
5185
],
[
5187
],
[
5189
],
[
5191,
5193,
5195
],
[
5197
],
[
5199
],
[
5201
],
[
5203
],
[
5209,
5213
],
[
5215
],
[
5217
],
[
5221
],
[
5223
],
[
5225
],
[
5227
],
[
5229
],
[
5231
],
[
5233
],
[
5235,
5237,
5239
],
[
5241
],
[
5243
],
[
5245,
5247
],
[
5249
],
[
5251
],
[
5253
],
[
5255
],
[
5257,
5259
],
[
5261
],
[
5263,
5265
],
[
5267
],
[
5269
],
[
5271
],
[
5273
],
[
5275
],
[
5277
],
[
5279,
5281,
5283
],
[
5285,
5287
],
[
5289
],
[
5291
],
[
5293
],
[
5295,
5297,
5299
],
[
5301,
5303
],
[
5305,
5309
],
[
5311
],
[
5313,
5315
],
[
5317,
5319,
5321
],
[
5323
],
[
5325
],
[
5327
],
[
5329
],
[
5331
],
[
5333
],
[
5335
],
[
5337
],
[
5339
],
[
5341
],
[
5343
],
[
5345
],
[
5347
],
[
5349,
5351
],
[
5353
],
[
5355,
5357
],
[
5365,
5367
],
[
5371
],
[
5373
],
[
5375
],
[
5377
],
[
5379
],
[
5381
],
[
5383
],
[
5385
],
[
5387
],
[
5389
],
[
5391
],
[
5393
],
[
5395
],
[
5397,
5399,
5401
],
[
5403
],
[
5405
],
[
5407
],
[
5409
],
[
5411,
5413
],
[
5415
],
[
5417
],
[
5419
],
[
5421
],
[
5423
],
[
5425
],
[
5427
],
[
5429
],
[
5431
],
[
5433
],
[
5435,
5437
],
[
5439,
5441
],
[
5443
],
[
5445
],
[
5447
],
[
5449
],
[
5451,
5453
],
[
5455
],
[
5457
],
[
5459
],
[
5461
],
[
5463
],
[
5465
],
[
5467,
5469,
5471
],
[
5473,
5475
],
[
5477
],
[
5479
],
[
5481
],
[
5483
],
[
5485,
5487,
5489,
5491,
5493
],
[
5495
],
[
5499
],
[
5501
],
[
5503
],
[
5505,
5507
],
[
5511
],
[
5513
],
[
5515
],
[
5517
],
[
5519
],
[
5521,
5523,
5525,
5527
],
[
5529
],
[
5531
],
[
5533
],
[
5535
],
[
5537
],
[
5539
],
[
5541
],
[
5543
],
[
5545
],
[
5547
],
[
5549,
5551
],
[
5553
],
[
5555
],
[
5557,
5559,
5561
],
[
5563
],
[
5565
],
[
5569
],
[
5571
],
[
5573
],
[
5577
],
[
5579
],
[
5581
],
[
5583
],
[
5585
],
[
5587
],
[
5589,
5591,
5593
],
[
5595
],
[
5597
],
[
5599,
5601
],
[
5603
],
[
5605
],
[
5607
],
[
5609
],
[
5611
],
[
5613
],
[
5615
],
[
5617
],
[
5619,
5621,
5623
],
[
5625
],
[
5627,
5629
],
[
5631
],
[
5633
],
[
5635
],
[
5637
],
[
5639
],
[
5641
],
[
5643,
5645,
5647
],
[
5649
],
[
5651
],
[
5653
],
[
5655,
5659,
5661
],
[
5663
],
[
5665
],
[
5667
],
[
5669
],
[
5671
],
[
5673
],
[
5675
],
[
5677
],
[
5679
],
[
5681,
5685,
5687
],
[
5689
],
[
5691
],
[
5693
],
[
5695
],
[
5697
],
[
5699
],
[
5701
],
[
5703
],
[
5705
],
[
5707,
5709,
5713
],
[
5715
],
[
5717
],
[
5719
],
[
5721
],
[
5723,
5725
],
[
5727
],
[
5729
],
[
5731
],
[
5733
],
[
5735
],
[
5739,
5741
],
[
5743
],
[
5745
],
[
5747
],
[
5749,
5751,
5753,
5755
],
[
5757
],
[
5759
],
[
5761
],
[
5763,
5765
],
[
5767
],
[
5769
],
[
5771,
5773
],
[
5775
],
[
5777
],
[
5779
],
[
5781
],
[
5783
],
[
5785,
5787
],
[
5789
],
[
5791
],
[
5793
],
[
5795,
5797,
5799
],
[
5801
],
[
5803
],
[
5805
],
[
5807,
5809
],
[
5811
],
[
5813
],
[
5815,
5817,
5819
],
[
5821
],
[
5823
],
[
5825
],
[
5827
],
[
5829
],
[
5831
],
[
5833
],
[
5835
],
[
5837
],
[
5839
],
[
5841,
5843,
5845
],
[
5847
],
[
5849
],
[
5851
],
[
5853,
5855
],
[
5857
],
[
5859
],
[
5861,
5863,
5865
],
[
5867
],
[
5869
],
[
5871
],
[
5873
],
[
5875
],
[
5877
],
[
5879
],
[
5881
],
[
5883
],
[
5885
],
[
5887,
5889,
5891,
5893
],
[
5895
],
[
5897,
5899
],
[
5901
],
[
5903
],
[
5905
],
[
5907
],
[
5909
],
[
5911
],
[
5913
],
[
5915,
5917
],
[
5919
],
[
5921
],
[
5923,
5925
],
[
5927
],
[
5929
],
[
5931
],
[
5933
],
[
5935,
5937,
5939
],
[
5941
],
[
5943
],
[
5945
],
[
5947
],
[
5949
],
[
5951
],
[
5953,
5955
],
[
5957
],
[
5959
],
[
5961,
5963
],
[
5965
],
[
5967,
5969,
5971,
5973
],
[
5975,
5977
],
[
5979
],
[
5981,
5983
],
[
5985
],
[
5987
],
[
5989,
5991
],
[
5993
],
[
5995,
5997
],
[
5999
],
[
6001
],
[
6003
],
[
6005
],
[
6007,
6009,
6011,
6013
],
[
6015
],
[
6017
],
[
6019
],
[
6021
],
[
6023
],
[
6025,
6027
],
[
6029
],
[
6031
],
[
6033
],
[
6035
],
[
6037
],
[
6039
],
[
6041
],
[
6043
],
[
6045,
6047
],
[
6049
],
[
6051
],
[
6053
],
[
6055,
6057,
6059
],
[
6061,
6063
],
[
6065
],
[
6067
],
[
6069,
6071,
6073
],
[
6075
],
[
6077
],
[
6079
],
[
6081
],
[
6083,
6085
],
[
6087
],
[
6089
],
[
6091
],
[
6093
],
[
6095,
6097,
6099
],
[
6101
],
[
6103
],
[
6105,
6107,
6109
],
[
6111
],
[
6113
],
[
6115
],
[
6117
],
[
6119
],
[
6121
],
[
6123
],
[
6125,
6127,
6129
],
[
6131
],
[
6133
],
[
6135
],
[
6137
],
[
6139
],
[
6141
],
[
6143
],
[
6145,
6147,
6149,
6151,
6153
],
[
6155
],
[
6157
],
[
6159
],
[
6161
],
[
6163
],
[
6165
],
[
6167
],
[
6169,
6171,
6173
],
[
6175
],
[
6177
],
[
6179
],
[
6181
],
[
6183
],
[
6185
],
[
6187
],
[
6189,
6191,
6193,
6195,
6197
],
[
6199
],
[
6201
],
[
6203,
6205,
6207
],
[
6209
],
[
6211
],
[
6213
],
[
6215
],
[
6217
],
[
6219
],
[
6221
],
[
6223,
6225
],
[
6227
],
[
6229
],
[
6231
],
[
6233
],
[
6235,
6237
],
[
6239
],
[
6241
],
[
6243
],
[
6245
],
[
6247,
6249
],
[
6251
],
[
6253
],
[
6255
],
[
6257
],
[
6259
],
[
6261
],
[
6263
],
[
6265
],
[
6267
],
[
6269,
6271
],
[
6273,
6275
],
[
6277,
6279
],
[
6281,
6283
],
[
6285
],
[
6287,
6289
],
[
6291
],
[
6293
],
[
6295
],
[
6297
],
[
6299
],
[
6301
],
[
6303
],
[
6305
],
[
6307
],
[
6309,
6311
],
[
6313
],
[
6315
],
[
6317
],
[
6319,
6321
],
[
6323
],
[
6325
],
[
6327
],
[
6329
],
[
6331
],
[
6333
],
[
6335
],
[
6337
],
[
6339,
6341,
6343
],
[
6345
],
[
6347
],
[
6349
],
[
6351,
6353
],
[
6355,
6357
],
[
6359,
6361
],
[
6363,
6365
],
[
6367
],
[
6369
],
[
6371,
6373
],
[
6375
],
[
6377
],
[
6379
],
[
6381,
6383,
6385
],
[
6387,
6389
],
[
6391
],
[
6393,
6395
],
[
6397
],
[
6399
],
[
6401
],
[
6403
],
[
6405
],
[
6407
],
[
6409,
6411
],
[
6413
],
[
6415
],
[
6417
],
[
6419,
6421
],
[
6423
],
[
6425
],
[
6427,
6429,
6431
],
[
6433
],
[
6435
],
[
6437
],
[
6441
],
[
6443
],
[
6445,
6447,
6449
],
[
6451
],
[
6455
],
[
6459
],
[
6461
],
[
6463
],
[
6465
],
[
6469
],
[
6471
],
[
6475,
6477
],
[
6479
],
[
6481
],
[
6483
],
[
6485
],
[
6487
],
[
6489
],
[
6491
],
[
6493
],
[
6495
],
[
6497
],
[
6499
],
[
6501,
6503
],
[
6505
],
[
6507
],
[
6511,
6513
],
[
6515
],
[
6517
],
[
6519
],
[
6521
],
[
6523
],
[
6525
],
[
6527
],
[
6529
],
[
6531
],
[
6533
],
[
6535
],
[
6537
],
[
6539
],
[
6541
],
[
6543
],
[
6545
],
[
6547
],
[
6549
],
[
6551
],
[
6553
],
[
6555
],
[
6557
],
[
6559
],
[
6561
],
[
6563
],
[
6565
],
[
6567
],
[
6569
],
[
6571
],
[
6573
],
[
6575
],
[
6577
],
[
6579
],
[
6581,
6583
],
[
6585
],
[
6587
],
[
6589
],
[
6591
],
[
6593
],
[
6595
],
[
6597
],
[
6599
],
[
6601
],
[
6603,
6605,
6607
],
[
6609
],
[
6611
],
[
6613,
6615
],
[
6617
],
[
6619
],
[
6621
],
[
6623
],
[
6625
],
[
6627,
6629
],
[
6631
],
[
6633
],
[
6635
],
[
6637
],
[
6639
],
[
6641
],
[
6643
],
[
6645
],
[
6647
],
[
6649
],
[
6651
],
[
6653
],
[
6655
],
[
6657
],
[
6659,
6661
],
[
6663
],
[
6665
],
[
6667
],
[
6669,
6671,
6673,
6675,
6677,
6679
],
[
6681
],
[
6685
],
[
6687,
6689
],
[
6691
],
[
6693
],
[
6695
],
[
6697,
6699
],
[
6701
],
[
6703
],
[
6705,
6707,
6709
],
[
6711
],
[
6713
],
[
6715
],
[
6727
],
[
6729
],
[
6731,
6733
],
[
6735,
6737
],
[
6739,
6741
],
[
6743
],
[
6745
],
[
6747
],
[
6749,
6751,
6753,
6755,
6757,
6759,
6761
],
[
6763
],
[
6765
],
[
6767
],
[
6769,
6771
],
[
6773
],
[
6775
],
[
6777
],
[
6779
],
[
6781
],
[
6783
],
[
6785
],
[
6787,
6789
],
[
6791
],
[
6793
],
[
6795
],
[
6797,
6799,
6801
],
[
6803
],
[
6805
],
[
6807
],
[
6819
],
[
6821
],
[
6823,
6825
],
[
6827,
6829
],
[
6833,
6835
],
[
6837
],
[
6839
],
[
6841
],
[
6843
],
[
6845
],
[
6847
],
[
6849
],
[
6851
],
[
6853
],
[
6855
],
[
6857
],
[
6859
],
[
6861
],
[
6863,
6865
],
[
6867
],
[
6869
],
[
6871
],
[
6873
],
[
6877
],
[
6879
],
[
6881
],
[
6883
],
[
6887,
6889,
6891
],
[
6893
],
[
6895
],
[
6897
],
[
6899,
6901
],
[
6903
],
[
6907
],
[
6909
],
[
6911,
6913
],
[
6915
],
[
6917
],
[
6919
],
[
6921,
6923,
6925,
6927
],
[
6929
],
[
6931
],
[
6933
],
[
6935
],
[
6937
],
[
6939,
6941
],
[
6943
],
[
6945
],
[
6947
],
[
6949,
6951,
6953,
6955
],
[
6957
],
[
6959
],
[
6961
],
[
6963
],
[
6965
],
[
6967,
6969
],
[
6971
],
[
6973,
6975
],
[
6977
],
[
6979,
6981,
6983
],
[
6985
],
[
6987
],
[
6989
],
[
6991,
6993,
6995
],
[
6997
],
[
6999
],
[
7001
],
[
7003
],
[
7005
],
[
7007
],
[
7009
],
[
7011
],
[
7013
],
[
7015
],
[
7017,
7019,
7021,
7023
],
[
7025
],
[
7027,
7029
],
[
7035,
7037
],
[
7039
],
[
7043,
7045
],
[
7047
],
[
7049
],
[
7051
],
[
7053,
7055
],
[
7057
],
[
7059
],
[
7061,
7063
],
[
7065
],
[
7067,
7069
],
[
7071
],
[
7075
],
[
7077,
7079
],
[
7081,
7083
],
[
7085
],
[
7087
],
[
7089
],
[
7091
],
[
7093
],
[
7095,
7097,
7099,
7101
],
[
7103,
7105
],
[
7109
],
[
7111
],
[
7115,
7117
],
[
7119,
7121
],
[
7123,
7125
],
[
7129
],
[
7131
],
[
7133
],
[
7137
],
[
7139
],
[
7141,
7145
],
[
7147,
7149,
7151,
7153,
7155,
7157,
7159,
7161,
7163
],
[
7165
],
[
7167,
7169
],
[
7171
],
[
7175,
7177
],
[
7179
],
[
7181,
7183,
7185
],
[
7189
],
[
7191
],
[
7193
]
] |
24,049 | static void rpza_decode_stream(RpzaContext *s)
{
int width = s->avctx->width;
int stride = s->frame.linesize[0] / 2;
int row_inc = stride - 4;
int stream_ptr = 0;
int chunk_size;
unsigned char opcode;
int n_blocks;
unsigned short colorA = 0, colorB;
unsigned short color4[4];
unsigned char index, idx;
unsigned short ta, tb;
unsigned short *pixels = (unsigned short *)s->frame.data[0];
int row_ptr = 0;
int pixel_ptr = 0;
int block_ptr;
int pixel_x, pixel_y;
int total_blocks;
/* First byte is always 0xe1. Warn if it's different */
if (s->buf[stream_ptr] != 0xe1)
av_log(s->avctx, AV_LOG_ERROR, "First chunk byte is 0x%02x instead of 0xe1\n",
s->buf[stream_ptr]);
/* Get chunk size, ingnoring first byte */
chunk_size = AV_RB32(&s->buf[stream_ptr]) & 0x00FFFFFF;
stream_ptr += 4;
/* If length mismatch use size from MOV file and try to decode anyway */
if (chunk_size != s->size)
av_log(s->avctx, AV_LOG_ERROR, "MOV chunk size != encoded chunk size; using MOV chunk size\n");
chunk_size = s->size;
/* Number of 4x4 blocks in frame. */
total_blocks = ((s->avctx->width + 3) / 4) * ((s->avctx->height + 3) / 4);
/* Process chunk data */
while (stream_ptr < chunk_size) {
opcode = s->buf[stream_ptr++]; /* Get opcode */
n_blocks = (opcode & 0x1f) + 1; /* Extract block counter from opcode */
/* If opcode MSbit is 0, we need more data to decide what to do */
if ((opcode & 0x80) == 0) {
colorA = (opcode << 8) | (s->buf[stream_ptr++]);
opcode = 0;
if ((s->buf[stream_ptr] & 0x80) != 0) {
/* Must behave as opcode 110xxxxx, using colorA computed
* above. Use fake opcode 0x20 to enter switch block at
* the right place */
opcode = 0x20;
n_blocks = 1;
}
}
switch (opcode & 0xe0) {
/* Skip blocks */
case 0x80:
while (n_blocks--) {
ADVANCE_BLOCK();
}
break;
/* Fill blocks with one color */
case 0xa0:
colorA = AV_RB16 (&s->buf[stream_ptr]);
stream_ptr += 2;
while (n_blocks--) {
block_ptr = row_ptr + pixel_ptr;
for (pixel_y = 0; pixel_y < 4; pixel_y++) {
for (pixel_x = 0; pixel_x < 4; pixel_x++){
pixels[block_ptr] = colorA;
block_ptr++;
}
block_ptr += row_inc;
}
ADVANCE_BLOCK();
}
break;
/* Fill blocks with 4 colors */
case 0xc0:
colorA = AV_RB16 (&s->buf[stream_ptr]);
stream_ptr += 2;
case 0x20:
colorB = AV_RB16 (&s->buf[stream_ptr]);
stream_ptr += 2;
/* sort out the colors */
color4[0] = colorB;
color4[1] = 0;
color4[2] = 0;
color4[3] = colorA;
/* red components */
ta = (colorA >> 10) & 0x1F;
tb = (colorB >> 10) & 0x1F;
color4[1] |= ((11 * ta + 21 * tb) >> 5) << 10;
color4[2] |= ((21 * ta + 11 * tb) >> 5) << 10;
/* green components */
ta = (colorA >> 5) & 0x1F;
tb = (colorB >> 5) & 0x1F;
color4[1] |= ((11 * ta + 21 * tb) >> 5) << 5;
color4[2] |= ((21 * ta + 11 * tb) >> 5) << 5;
/* blue components */
ta = colorA & 0x1F;
tb = colorB & 0x1F;
color4[1] |= ((11 * ta + 21 * tb) >> 5);
color4[2] |= ((21 * ta + 11 * tb) >> 5);
if (s->size - stream_ptr < n_blocks * 4)
return;
while (n_blocks--) {
block_ptr = row_ptr + pixel_ptr;
for (pixel_y = 0; pixel_y < 4; pixel_y++) {
index = s->buf[stream_ptr++];
for (pixel_x = 0; pixel_x < 4; pixel_x++){
idx = (index >> (2 * (3 - pixel_x))) & 0x03;
pixels[block_ptr] = color4[idx];
block_ptr++;
}
block_ptr += row_inc;
}
ADVANCE_BLOCK();
}
break;
/* Fill block with 16 colors */
case 0x00:
if (s->size - stream_ptr < 16)
return;
block_ptr = row_ptr + pixel_ptr;
for (pixel_y = 0; pixel_y < 4; pixel_y++) {
for (pixel_x = 0; pixel_x < 4; pixel_x++){
/* We already have color of upper left pixel */
if ((pixel_y != 0) || (pixel_x !=0)) {
colorA = AV_RB16 (&s->buf[stream_ptr]);
stream_ptr += 2;
}
pixels[block_ptr] = colorA;
block_ptr++;
}
block_ptr += row_inc;
}
ADVANCE_BLOCK();
break;
/* Unknown opcode */
default:
av_log(s->avctx, AV_LOG_ERROR, "Unknown opcode %d in rpza chunk."
" Skip remaining %d bytes of chunk data.\n", opcode,
chunk_size - stream_ptr);
return;
} /* Opcode switch */
}
}
| false | FFmpeg | 3819db745da2ac7fb3faacb116788c32f4753f34 | static void rpza_decode_stream(RpzaContext *s)
{
int width = s->avctx->width;
int stride = s->frame.linesize[0] / 2;
int row_inc = stride - 4;
int stream_ptr = 0;
int chunk_size;
unsigned char opcode;
int n_blocks;
unsigned short colorA = 0, colorB;
unsigned short color4[4];
unsigned char index, idx;
unsigned short ta, tb;
unsigned short *pixels = (unsigned short *)s->frame.data[0];
int row_ptr = 0;
int pixel_ptr = 0;
int block_ptr;
int pixel_x, pixel_y;
int total_blocks;
if (s->buf[stream_ptr] != 0xe1)
av_log(s->avctx, AV_LOG_ERROR, "First chunk byte is 0x%02x instead of 0xe1\n",
s->buf[stream_ptr]);
chunk_size = AV_RB32(&s->buf[stream_ptr]) & 0x00FFFFFF;
stream_ptr += 4;
if (chunk_size != s->size)
av_log(s->avctx, AV_LOG_ERROR, "MOV chunk size != encoded chunk size; using MOV chunk size\n");
chunk_size = s->size;
total_blocks = ((s->avctx->width + 3) / 4) * ((s->avctx->height + 3) / 4);
while (stream_ptr < chunk_size) {
opcode = s->buf[stream_ptr++];
n_blocks = (opcode & 0x1f) + 1;
if ((opcode & 0x80) == 0) {
colorA = (opcode << 8) | (s->buf[stream_ptr++]);
opcode = 0;
if ((s->buf[stream_ptr] & 0x80) != 0) {
opcode = 0x20;
n_blocks = 1;
}
}
switch (opcode & 0xe0) {
case 0x80:
while (n_blocks--) {
ADVANCE_BLOCK();
}
break;
case 0xa0:
colorA = AV_RB16 (&s->buf[stream_ptr]);
stream_ptr += 2;
while (n_blocks--) {
block_ptr = row_ptr + pixel_ptr;
for (pixel_y = 0; pixel_y < 4; pixel_y++) {
for (pixel_x = 0; pixel_x < 4; pixel_x++){
pixels[block_ptr] = colorA;
block_ptr++;
}
block_ptr += row_inc;
}
ADVANCE_BLOCK();
}
break;
case 0xc0:
colorA = AV_RB16 (&s->buf[stream_ptr]);
stream_ptr += 2;
case 0x20:
colorB = AV_RB16 (&s->buf[stream_ptr]);
stream_ptr += 2;
color4[0] = colorB;
color4[1] = 0;
color4[2] = 0;
color4[3] = colorA;
ta = (colorA >> 10) & 0x1F;
tb = (colorB >> 10) & 0x1F;
color4[1] |= ((11 * ta + 21 * tb) >> 5) << 10;
color4[2] |= ((21 * ta + 11 * tb) >> 5) << 10;
ta = (colorA >> 5) & 0x1F;
tb = (colorB >> 5) & 0x1F;
color4[1] |= ((11 * ta + 21 * tb) >> 5) << 5;
color4[2] |= ((21 * ta + 11 * tb) >> 5) << 5;
ta = colorA & 0x1F;
tb = colorB & 0x1F;
color4[1] |= ((11 * ta + 21 * tb) >> 5);
color4[2] |= ((21 * ta + 11 * tb) >> 5);
if (s->size - stream_ptr < n_blocks * 4)
return;
while (n_blocks--) {
block_ptr = row_ptr + pixel_ptr;
for (pixel_y = 0; pixel_y < 4; pixel_y++) {
index = s->buf[stream_ptr++];
for (pixel_x = 0; pixel_x < 4; pixel_x++){
idx = (index >> (2 * (3 - pixel_x))) & 0x03;
pixels[block_ptr] = color4[idx];
block_ptr++;
}
block_ptr += row_inc;
}
ADVANCE_BLOCK();
}
break;
case 0x00:
if (s->size - stream_ptr < 16)
return;
block_ptr = row_ptr + pixel_ptr;
for (pixel_y = 0; pixel_y < 4; pixel_y++) {
for (pixel_x = 0; pixel_x < 4; pixel_x++){
if ((pixel_y != 0) || (pixel_x !=0)) {
colorA = AV_RB16 (&s->buf[stream_ptr]);
stream_ptr += 2;
}
pixels[block_ptr] = colorA;
block_ptr++;
}
block_ptr += row_inc;
}
ADVANCE_BLOCK();
break;
default:
av_log(s->avctx, AV_LOG_ERROR, "Unknown opcode %d in rpza chunk."
" Skip remaining %d bytes of chunk data.\n", opcode,
chunk_size - stream_ptr);
return;
}
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(RpzaContext *VAR_0)
{
int VAR_1 = VAR_0->avctx->VAR_1;
int VAR_2 = VAR_0->frame.linesize[0] / 2;
int VAR_3 = VAR_2 - 4;
int VAR_4 = 0;
int VAR_5;
unsigned char VAR_6;
int VAR_7;
unsigned short VAR_8 = 0, VAR_9;
unsigned short VAR_10[4];
unsigned char VAR_11, VAR_12;
unsigned short VAR_13, VAR_14;
unsigned short *VAR_15 = (unsigned short *)VAR_0->frame.data[0];
int VAR_16 = 0;
int VAR_17 = 0;
int VAR_18;
int VAR_19, VAR_20;
int VAR_21;
if (VAR_0->buf[VAR_4] != 0xe1)
av_log(VAR_0->avctx, AV_LOG_ERROR, "First chunk byte is 0x%02x instead of 0xe1\n",
VAR_0->buf[VAR_4]);
VAR_5 = AV_RB32(&VAR_0->buf[VAR_4]) & 0x00FFFFFF;
VAR_4 += 4;
if (VAR_5 != VAR_0->size)
av_log(VAR_0->avctx, AV_LOG_ERROR, "MOV chunk size != encoded chunk size; using MOV chunk size\n");
VAR_5 = VAR_0->size;
VAR_21 = ((VAR_0->avctx->VAR_1 + 3) / 4) * ((VAR_0->avctx->height + 3) / 4);
while (VAR_4 < VAR_5) {
VAR_6 = VAR_0->buf[VAR_4++];
VAR_7 = (VAR_6 & 0x1f) + 1;
if ((VAR_6 & 0x80) == 0) {
VAR_8 = (VAR_6 << 8) | (VAR_0->buf[VAR_4++]);
VAR_6 = 0;
if ((VAR_0->buf[VAR_4] & 0x80) != 0) {
VAR_6 = 0x20;
VAR_7 = 1;
}
}
switch (VAR_6 & 0xe0) {
case 0x80:
while (VAR_7--) {
ADVANCE_BLOCK();
}
break;
case 0xa0:
VAR_8 = AV_RB16 (&VAR_0->buf[VAR_4]);
VAR_4 += 2;
while (VAR_7--) {
VAR_18 = VAR_16 + VAR_17;
for (VAR_20 = 0; VAR_20 < 4; VAR_20++) {
for (VAR_19 = 0; VAR_19 < 4; VAR_19++){
VAR_15[VAR_18] = VAR_8;
VAR_18++;
}
VAR_18 += VAR_3;
}
ADVANCE_BLOCK();
}
break;
case 0xc0:
VAR_8 = AV_RB16 (&VAR_0->buf[VAR_4]);
VAR_4 += 2;
case 0x20:
VAR_9 = AV_RB16 (&VAR_0->buf[VAR_4]);
VAR_4 += 2;
VAR_10[0] = VAR_9;
VAR_10[1] = 0;
VAR_10[2] = 0;
VAR_10[3] = VAR_8;
VAR_13 = (VAR_8 >> 10) & 0x1F;
VAR_14 = (VAR_9 >> 10) & 0x1F;
VAR_10[1] |= ((11 * VAR_13 + 21 * VAR_14) >> 5) << 10;
VAR_10[2] |= ((21 * VAR_13 + 11 * VAR_14) >> 5) << 10;
VAR_13 = (VAR_8 >> 5) & 0x1F;
VAR_14 = (VAR_9 >> 5) & 0x1F;
VAR_10[1] |= ((11 * VAR_13 + 21 * VAR_14) >> 5) << 5;
VAR_10[2] |= ((21 * VAR_13 + 11 * VAR_14) >> 5) << 5;
VAR_13 = VAR_8 & 0x1F;
VAR_14 = VAR_9 & 0x1F;
VAR_10[1] |= ((11 * VAR_13 + 21 * VAR_14) >> 5);
VAR_10[2] |= ((21 * VAR_13 + 11 * VAR_14) >> 5);
if (VAR_0->size - VAR_4 < VAR_7 * 4)
return;
while (VAR_7--) {
VAR_18 = VAR_16 + VAR_17;
for (VAR_20 = 0; VAR_20 < 4; VAR_20++) {
VAR_11 = VAR_0->buf[VAR_4++];
for (VAR_19 = 0; VAR_19 < 4; VAR_19++){
VAR_12 = (VAR_11 >> (2 * (3 - VAR_19))) & 0x03;
VAR_15[VAR_18] = VAR_10[VAR_12];
VAR_18++;
}
VAR_18 += VAR_3;
}
ADVANCE_BLOCK();
}
break;
case 0x00:
if (VAR_0->size - VAR_4 < 16)
return;
VAR_18 = VAR_16 + VAR_17;
for (VAR_20 = 0; VAR_20 < 4; VAR_20++) {
for (VAR_19 = 0; VAR_19 < 4; VAR_19++){
if ((VAR_20 != 0) || (VAR_19 !=0)) {
VAR_8 = AV_RB16 (&VAR_0->buf[VAR_4]);
VAR_4 += 2;
}
VAR_15[VAR_18] = VAR_8;
VAR_18++;
}
VAR_18 += VAR_3;
}
ADVANCE_BLOCK();
break;
default:
av_log(VAR_0->avctx, AV_LOG_ERROR, "Unknown VAR_6 %d in rpza chunk."
" Skip remaining %d bytes of chunk data.\n", VAR_6,
VAR_5 - VAR_4);
return;
}
}
}
| [
"static void FUNC_0(RpzaContext *VAR_0)\n{",
"int VAR_1 = VAR_0->avctx->VAR_1;",
"int VAR_2 = VAR_0->frame.linesize[0] / 2;",
"int VAR_3 = VAR_2 - 4;",
"int VAR_4 = 0;",
"int VAR_5;",
"unsigned char VAR_6;",
"int VAR_7;",
"unsigned short VAR_8 = 0, VAR_9;",
"unsigned short VAR_10[4];",
"unsigned char VAR_11, VAR_12;",
"unsigned short VAR_13, VAR_14;",
"unsigned short *VAR_15 = (unsigned short *)VAR_0->frame.data[0];",
"int VAR_16 = 0;",
"int VAR_17 = 0;",
"int VAR_18;",
"int VAR_19, VAR_20;",
"int VAR_21;",
"if (VAR_0->buf[VAR_4] != 0xe1)\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"First chunk byte is 0x%02x instead of 0xe1\\n\",\nVAR_0->buf[VAR_4]);",
"VAR_5 = AV_RB32(&VAR_0->buf[VAR_4]) & 0x00FFFFFF;",
"VAR_4 += 4;",
"if (VAR_5 != VAR_0->size)\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"MOV chunk size != encoded chunk size; using MOV chunk size\\n\");",
"VAR_5 = VAR_0->size;",
"VAR_21 = ((VAR_0->avctx->VAR_1 + 3) / 4) * ((VAR_0->avctx->height + 3) / 4);",
"while (VAR_4 < VAR_5) {",
"VAR_6 = VAR_0->buf[VAR_4++];",
"VAR_7 = (VAR_6 & 0x1f) + 1;",
"if ((VAR_6 & 0x80) == 0) {",
"VAR_8 = (VAR_6 << 8) | (VAR_0->buf[VAR_4++]);",
"VAR_6 = 0;",
"if ((VAR_0->buf[VAR_4] & 0x80) != 0) {",
"VAR_6 = 0x20;",
"VAR_7 = 1;",
"}",
"}",
"switch (VAR_6 & 0xe0) {",
"case 0x80:\nwhile (VAR_7--) {",
"ADVANCE_BLOCK();",
"}",
"break;",
"case 0xa0:\nVAR_8 = AV_RB16 (&VAR_0->buf[VAR_4]);",
"VAR_4 += 2;",
"while (VAR_7--) {",
"VAR_18 = VAR_16 + VAR_17;",
"for (VAR_20 = 0; VAR_20 < 4; VAR_20++) {",
"for (VAR_19 = 0; VAR_19 < 4; VAR_19++){",
"VAR_15[VAR_18] = VAR_8;",
"VAR_18++;",
"}",
"VAR_18 += VAR_3;",
"}",
"ADVANCE_BLOCK();",
"}",
"break;",
"case 0xc0:\nVAR_8 = AV_RB16 (&VAR_0->buf[VAR_4]);",
"VAR_4 += 2;",
"case 0x20:\nVAR_9 = AV_RB16 (&VAR_0->buf[VAR_4]);",
"VAR_4 += 2;",
"VAR_10[0] = VAR_9;",
"VAR_10[1] = 0;",
"VAR_10[2] = 0;",
"VAR_10[3] = VAR_8;",
"VAR_13 = (VAR_8 >> 10) & 0x1F;",
"VAR_14 = (VAR_9 >> 10) & 0x1F;",
"VAR_10[1] |= ((11 * VAR_13 + 21 * VAR_14) >> 5) << 10;",
"VAR_10[2] |= ((21 * VAR_13 + 11 * VAR_14) >> 5) << 10;",
"VAR_13 = (VAR_8 >> 5) & 0x1F;",
"VAR_14 = (VAR_9 >> 5) & 0x1F;",
"VAR_10[1] |= ((11 * VAR_13 + 21 * VAR_14) >> 5) << 5;",
"VAR_10[2] |= ((21 * VAR_13 + 11 * VAR_14) >> 5) << 5;",
"VAR_13 = VAR_8 & 0x1F;",
"VAR_14 = VAR_9 & 0x1F;",
"VAR_10[1] |= ((11 * VAR_13 + 21 * VAR_14) >> 5);",
"VAR_10[2] |= ((21 * VAR_13 + 11 * VAR_14) >> 5);",
"if (VAR_0->size - VAR_4 < VAR_7 * 4)\nreturn;",
"while (VAR_7--) {",
"VAR_18 = VAR_16 + VAR_17;",
"for (VAR_20 = 0; VAR_20 < 4; VAR_20++) {",
"VAR_11 = VAR_0->buf[VAR_4++];",
"for (VAR_19 = 0; VAR_19 < 4; VAR_19++){",
"VAR_12 = (VAR_11 >> (2 * (3 - VAR_19))) & 0x03;",
"VAR_15[VAR_18] = VAR_10[VAR_12];",
"VAR_18++;",
"}",
"VAR_18 += VAR_3;",
"}",
"ADVANCE_BLOCK();",
"}",
"break;",
"case 0x00:\nif (VAR_0->size - VAR_4 < 16)\nreturn;",
"VAR_18 = VAR_16 + VAR_17;",
"for (VAR_20 = 0; VAR_20 < 4; VAR_20++) {",
"for (VAR_19 = 0; VAR_19 < 4; VAR_19++){",
"if ((VAR_20 != 0) || (VAR_19 !=0)) {",
"VAR_8 = AV_RB16 (&VAR_0->buf[VAR_4]);",
"VAR_4 += 2;",
"}",
"VAR_15[VAR_18] = VAR_8;",
"VAR_18++;",
"}",
"VAR_18 += VAR_3;",
"}",
"ADVANCE_BLOCK();",
"break;",
"default:\nav_log(VAR_0->avctx, AV_LOG_ERROR, \"Unknown VAR_6 %d in rpza chunk.\"\n\" Skip remaining %d bytes of chunk data.\\n\", VAR_6,\nVAR_5 - VAR_4);",
"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,
0,
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
],
[
33
],
[
35
],
[
37
],
[
39
],
[
45,
47,
49
],
[
55
],
[
57
],
[
63,
65
],
[
69
],
[
75
],
[
81
],
[
83
],
[
87
],
[
93
],
[
95
],
[
97
],
[
99
],
[
107
],
[
109
],
[
111
],
[
113
],
[
117
],
[
123,
125
],
[
127
],
[
129
],
[
131
],
[
137,
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
171,
173
],
[
175
],
[
177,
179
],
[
181
],
[
187
],
[
189
],
[
191
],
[
193
],
[
199
],
[
201
],
[
203
],
[
205
],
[
211
],
[
213
],
[
215
],
[
217
],
[
223
],
[
225
],
[
227
],
[
229
],
[
233,
235
],
[
237
],
[
239
],
[
241
],
[
243
],
[
245
],
[
247
],
[
249
],
[
251
],
[
253
],
[
255
],
[
257
],
[
259
],
[
261
],
[
263
],
[
269,
271,
273
],
[
275
],
[
277
],
[
279
],
[
283
],
[
285
],
[
287
],
[
289
],
[
291
],
[
293
],
[
295
],
[
297
],
[
299
],
[
301
],
[
303
],
[
309,
311,
313,
315
],
[
317
],
[
319
],
[
321
],
[
323
]
] |
24,051 | int usb_device_attach(USBDevice *dev)
{
USBBus *bus = usb_bus_from_device(dev);
if (bus->nfree == 1 && dev->port_path == NULL) {
/* Create a new hub and chain it on
(unless a physical port location is specified). */
usb_create_simple(bus, "usb-hub");
}
return do_attach(dev);
}
| false | qemu | 891fb2cd4592b6fe76106a69e0ca40efbf82726a | int usb_device_attach(USBDevice *dev)
{
USBBus *bus = usb_bus_from_device(dev);
if (bus->nfree == 1 && dev->port_path == NULL) {
usb_create_simple(bus, "usb-hub");
}
return do_attach(dev);
}
| {
"code": [],
"line_no": []
} | int FUNC_0(USBDevice *VAR_0)
{
USBBus *bus = usb_bus_from_device(VAR_0);
if (bus->nfree == 1 && VAR_0->port_path == NULL) {
usb_create_simple(bus, "usb-hub");
}
return do_attach(VAR_0);
}
| [
"int FUNC_0(USBDevice *VAR_0)\n{",
"USBBus *bus = usb_bus_from_device(VAR_0);",
"if (bus->nfree == 1 && VAR_0->port_path == NULL) {",
"usb_create_simple(bus, \"usb-hub\");",
"}",
"return do_attach(VAR_0);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
9
],
[
15
],
[
17
],
[
19
],
[
21
]
] |
24,052 | static void cpu_debug_handler(CPUState *env)
{
gdb_set_stop_cpu(env);
qemu_system_debug_request();
}
| false | qemu | 83f338f73ecb88cc6f85d6e7b81ebef112ce07be | static void cpu_debug_handler(CPUState *env)
{
gdb_set_stop_cpu(env);
qemu_system_debug_request();
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(CPUState *VAR_0)
{
gdb_set_stop_cpu(VAR_0);
qemu_system_debug_request();
}
| [
"static void FUNC_0(CPUState *VAR_0)\n{",
"gdb_set_stop_cpu(VAR_0);",
"qemu_system_debug_request();",
"}"
] | [
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
]
] |
24,054 | static uint16_t qpci_spapr_io_readw(QPCIBus *bus, void *addr)
{
QPCIBusSPAPR *s = container_of(bus, QPCIBusSPAPR, bus);
uint64_t port = (uintptr_t)addr;
uint16_t v;
if (port < s->pio.size) {
v = readw(s->pio_cpu_base + port);
} else {
v = readw(s->mmio_cpu_base + port);
}
return bswap16(v);
}
| false | qemu | 8360544a6d3a54df1fce80f55ba4ad075a8ded54 | static uint16_t qpci_spapr_io_readw(QPCIBus *bus, void *addr)
{
QPCIBusSPAPR *s = container_of(bus, QPCIBusSPAPR, bus);
uint64_t port = (uintptr_t)addr;
uint16_t v;
if (port < s->pio.size) {
v = readw(s->pio_cpu_base + port);
} else {
v = readw(s->mmio_cpu_base + port);
}
return bswap16(v);
}
| {
"code": [],
"line_no": []
} | static uint16_t FUNC_0(QPCIBus *bus, void *addr)
{
QPCIBusSPAPR *s = container_of(bus, QPCIBusSPAPR, bus);
uint64_t port = (uintptr_t)addr;
uint16_t v;
if (port < s->pio.size) {
v = readw(s->pio_cpu_base + port);
} else {
v = readw(s->mmio_cpu_base + port);
}
return bswap16(v);
}
| [
"static uint16_t FUNC_0(QPCIBus *bus, void *addr)\n{",
"QPCIBusSPAPR *s = container_of(bus, QPCIBusSPAPR, bus);",
"uint64_t port = (uintptr_t)addr;",
"uint16_t v;",
"if (port < s->pio.size) {",
"v = readw(s->pio_cpu_base + port);",
"} else {",
"v = readw(s->mmio_cpu_base + port);",
"}",
"return bswap16(v);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
]
] |
24,055 | static int ast_read_header(AVFormatContext *s)
{
int codec;
AVStream *st;
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
avio_skip(s->pb, 8);
codec = avio_rb16(s->pb);
switch (codec) {
case 1:
st->codec->codec_id = AV_CODEC_ID_PCM_S16BE_PLANAR;
break;
default:
av_log(s, AV_LOG_ERROR, "unsupported codec %d\n", codec);
}
avio_skip(s->pb, 2);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->channels = avio_rb16(s->pb);
if (!st->codec->channels)
return AVERROR_INVALIDDATA;
if (st->codec->channels == 2)
st->codec->channel_layout = AV_CH_LAYOUT_STEREO;
else if (st->codec->channels == 4)
st->codec->channel_layout = AV_CH_LAYOUT_4POINT0;
avio_skip(s->pb, 2);
st->codec->sample_rate = avio_rb32(s->pb);
if (st->codec->sample_rate <= 0)
return AVERROR_INVALIDDATA;
st->start_time = 0;
st->duration = avio_rb32(s->pb);
avio_skip(s->pb, 40);
avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
return 0;
}
| false | FFmpeg | d0a503c97cc59b17e77585a726448dfa46245f4d | static int ast_read_header(AVFormatContext *s)
{
int codec;
AVStream *st;
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
avio_skip(s->pb, 8);
codec = avio_rb16(s->pb);
switch (codec) {
case 1:
st->codec->codec_id = AV_CODEC_ID_PCM_S16BE_PLANAR;
break;
default:
av_log(s, AV_LOG_ERROR, "unsupported codec %d\n", codec);
}
avio_skip(s->pb, 2);
st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
st->codec->channels = avio_rb16(s->pb);
if (!st->codec->channels)
return AVERROR_INVALIDDATA;
if (st->codec->channels == 2)
st->codec->channel_layout = AV_CH_LAYOUT_STEREO;
else if (st->codec->channels == 4)
st->codec->channel_layout = AV_CH_LAYOUT_4POINT0;
avio_skip(s->pb, 2);
st->codec->sample_rate = avio_rb32(s->pb);
if (st->codec->sample_rate <= 0)
return AVERROR_INVALIDDATA;
st->start_time = 0;
st->duration = avio_rb32(s->pb);
avio_skip(s->pb, 40);
avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0)
{
int VAR_1;
AVStream *st;
st = avformat_new_stream(VAR_0, NULL);
if (!st)
return AVERROR(ENOMEM);
avio_skip(VAR_0->pb, 8);
VAR_1 = avio_rb16(VAR_0->pb);
switch (VAR_1) {
case 1:
st->VAR_1->codec_id = AV_CODEC_ID_PCM_S16BE_PLANAR;
break;
default:
av_log(VAR_0, AV_LOG_ERROR, "unsupported VAR_1 %d\n", VAR_1);
}
avio_skip(VAR_0->pb, 2);
st->VAR_1->codec_type = AVMEDIA_TYPE_AUDIO;
st->VAR_1->channels = avio_rb16(VAR_0->pb);
if (!st->VAR_1->channels)
return AVERROR_INVALIDDATA;
if (st->VAR_1->channels == 2)
st->VAR_1->channel_layout = AV_CH_LAYOUT_STEREO;
else if (st->VAR_1->channels == 4)
st->VAR_1->channel_layout = AV_CH_LAYOUT_4POINT0;
avio_skip(VAR_0->pb, 2);
st->VAR_1->sample_rate = avio_rb32(VAR_0->pb);
if (st->VAR_1->sample_rate <= 0)
return AVERROR_INVALIDDATA;
st->start_time = 0;
st->duration = avio_rb32(VAR_0->pb);
avio_skip(VAR_0->pb, 40);
avpriv_set_pts_info(st, 64, 1, st->VAR_1->sample_rate);
return 0;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0)\n{",
"int VAR_1;",
"AVStream *st;",
"st = avformat_new_stream(VAR_0, NULL);",
"if (!st)\nreturn AVERROR(ENOMEM);",
"avio_skip(VAR_0->pb, 8);",
"VAR_1 = avio_rb16(VAR_0->pb);",
"switch (VAR_1) {",
"case 1:\nst->VAR_1->codec_id = AV_CODEC_ID_PCM_S16BE_PLANAR;",
"break;",
"default:\nav_log(VAR_0, AV_LOG_ERROR, \"unsupported VAR_1 %d\\n\", VAR_1);",
"}",
"avio_skip(VAR_0->pb, 2);",
"st->VAR_1->codec_type = AVMEDIA_TYPE_AUDIO;",
"st->VAR_1->channels = avio_rb16(VAR_0->pb);",
"if (!st->VAR_1->channels)\nreturn AVERROR_INVALIDDATA;",
"if (st->VAR_1->channels == 2)\nst->VAR_1->channel_layout = AV_CH_LAYOUT_STEREO;",
"else if (st->VAR_1->channels == 4)\nst->VAR_1->channel_layout = AV_CH_LAYOUT_4POINT0;",
"avio_skip(VAR_0->pb, 2);",
"st->VAR_1->sample_rate = avio_rb32(VAR_0->pb);",
"if (st->VAR_1->sample_rate <= 0)\nreturn AVERROR_INVALIDDATA;",
"st->start_time = 0;",
"st->duration = avio_rb32(VAR_0->pb);",
"avio_skip(VAR_0->pb, 40);",
"avpriv_set_pts_info(st, 64, 1, st->VAR_1->sample_rate);",
"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
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13,
15
],
[
19
],
[
21
],
[
23
],
[
25,
27
],
[
29
],
[
31,
33
],
[
35
],
[
39
],
[
43
],
[
45
],
[
47,
49
],
[
53,
55
],
[
57,
59
],
[
63
],
[
65
],
[
67,
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
81
],
[
83
]
] |
24,056 | static av_cold int vsink_init(AVFilterContext *ctx, void *opaque)
{
BufferSinkContext *buf = ctx->priv;
AVBufferSinkParams *params = opaque;
if (params && params->pixel_fmts) {
const int *pixel_fmts = params->pixel_fmts;
buf->pixel_fmts = ff_copy_int_list(pixel_fmts);
if (!buf->pixel_fmts)
return AVERROR(ENOMEM);
}
return common_init(ctx);
}
| false | FFmpeg | e48ded8551172b58a78f30303a81dfce125344e0 | static av_cold int vsink_init(AVFilterContext *ctx, void *opaque)
{
BufferSinkContext *buf = ctx->priv;
AVBufferSinkParams *params = opaque;
if (params && params->pixel_fmts) {
const int *pixel_fmts = params->pixel_fmts;
buf->pixel_fmts = ff_copy_int_list(pixel_fmts);
if (!buf->pixel_fmts)
return AVERROR(ENOMEM);
}
return common_init(ctx);
}
| {
"code": [],
"line_no": []
} | static av_cold int FUNC_0(AVFilterContext *ctx, void *opaque)
{
BufferSinkContext *buf = ctx->priv;
AVBufferSinkParams *params = opaque;
if (params && params->VAR_0) {
const int *VAR_0 = params->VAR_0;
buf->VAR_0 = ff_copy_int_list(VAR_0);
if (!buf->VAR_0)
return AVERROR(ENOMEM);
}
return common_init(ctx);
}
| [
"static av_cold int FUNC_0(AVFilterContext *ctx, void *opaque)\n{",
"BufferSinkContext *buf = ctx->priv;",
"AVBufferSinkParams *params = opaque;",
"if (params && params->VAR_0) {",
"const int *VAR_0 = params->VAR_0;",
"buf->VAR_0 = ff_copy_int_list(VAR_0);",
"if (!buf->VAR_0)\nreturn AVERROR(ENOMEM);",
"}",
"return common_init(ctx);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
17
],
[
19,
21
],
[
23
],
[
27
],
[
29
]
] |
24,057 | static int aac_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
AACContext *ac = avctx->priv_data;
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
GetBitContext gb;
int buf_consumed;
int buf_offset;
int err;
int new_extradata_size;
const uint8_t *new_extradata = av_packet_get_side_data(avpkt,
AV_PKT_DATA_NEW_EXTRADATA,
&new_extradata_size);
int jp_dualmono_size;
const uint8_t *jp_dualmono = av_packet_get_side_data(avpkt,
AV_PKT_DATA_JP_DUALMONO,
&jp_dualmono_size);
if (new_extradata && 0) {
av_free(avctx->extradata);
avctx->extradata = av_mallocz(new_extradata_size +
AV_INPUT_BUFFER_PADDING_SIZE);
if (!avctx->extradata)
return AVERROR(ENOMEM);
avctx->extradata_size = new_extradata_size;
memcpy(avctx->extradata, new_extradata, new_extradata_size);
push_output_configuration(ac);
if (decode_audio_specific_config(ac, ac->avctx, &ac->oc[1].m4ac,
avctx->extradata,
avctx->extradata_size*8, 1) < 0) {
pop_output_configuration(ac);
return AVERROR_INVALIDDATA;
}
}
ac->dmono_mode = 0;
if (jp_dualmono && jp_dualmono_size > 0)
ac->dmono_mode = 1 + *jp_dualmono;
if (ac->force_dmono_mode >= 0)
ac->dmono_mode = ac->force_dmono_mode;
if (INT_MAX / 8 <= buf_size)
return AVERROR_INVALIDDATA;
if ((err = init_get_bits8(&gb, buf, buf_size)) < 0)
return err;
switch (ac->oc[1].m4ac.object_type) {
case AOT_ER_AAC_LC:
case AOT_ER_AAC_LTP:
case AOT_ER_AAC_LD:
case AOT_ER_AAC_ELD:
err = aac_decode_er_frame(avctx, data, got_frame_ptr, &gb);
break;
default:
err = aac_decode_frame_int(avctx, data, got_frame_ptr, &gb, avpkt);
}
if (err < 0)
return err;
buf_consumed = (get_bits_count(&gb) + 7) >> 3;
for (buf_offset = buf_consumed; buf_offset < buf_size; buf_offset++)
if (buf[buf_offset])
break;
return buf_size > buf_offset ? buf_consumed : buf_size;
}
| true | FFmpeg | 7f46a641bf2540b8cf1293d5e50c0c0e34264254 | static int aac_decode_frame(AVCodecContext *avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
AACContext *ac = avctx->priv_data;
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
GetBitContext gb;
int buf_consumed;
int buf_offset;
int err;
int new_extradata_size;
const uint8_t *new_extradata = av_packet_get_side_data(avpkt,
AV_PKT_DATA_NEW_EXTRADATA,
&new_extradata_size);
int jp_dualmono_size;
const uint8_t *jp_dualmono = av_packet_get_side_data(avpkt,
AV_PKT_DATA_JP_DUALMONO,
&jp_dualmono_size);
if (new_extradata && 0) {
av_free(avctx->extradata);
avctx->extradata = av_mallocz(new_extradata_size +
AV_INPUT_BUFFER_PADDING_SIZE);
if (!avctx->extradata)
return AVERROR(ENOMEM);
avctx->extradata_size = new_extradata_size;
memcpy(avctx->extradata, new_extradata, new_extradata_size);
push_output_configuration(ac);
if (decode_audio_specific_config(ac, ac->avctx, &ac->oc[1].m4ac,
avctx->extradata,
avctx->extradata_size*8, 1) < 0) {
pop_output_configuration(ac);
return AVERROR_INVALIDDATA;
}
}
ac->dmono_mode = 0;
if (jp_dualmono && jp_dualmono_size > 0)
ac->dmono_mode = 1 + *jp_dualmono;
if (ac->force_dmono_mode >= 0)
ac->dmono_mode = ac->force_dmono_mode;
if (INT_MAX / 8 <= buf_size)
return AVERROR_INVALIDDATA;
if ((err = init_get_bits8(&gb, buf, buf_size)) < 0)
return err;
switch (ac->oc[1].m4ac.object_type) {
case AOT_ER_AAC_LC:
case AOT_ER_AAC_LTP:
case AOT_ER_AAC_LD:
case AOT_ER_AAC_ELD:
err = aac_decode_er_frame(avctx, data, got_frame_ptr, &gb);
break;
default:
err = aac_decode_frame_int(avctx, data, got_frame_ptr, &gb, avpkt);
}
if (err < 0)
return err;
buf_consumed = (get_bits_count(&gb) + 7) >> 3;
for (buf_offset = buf_consumed; buf_offset < buf_size; buf_offset++)
if (buf[buf_offset])
break;
return buf_size > buf_offset ? buf_consumed : buf_size;
}
| {
"code": [
" avctx->extradata_size*8, 1) < 0) {"
],
"line_no": [
61
]
} | static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,
int *VAR_2, AVPacket *VAR_3)
{
AACContext *ac = VAR_0->priv_data;
const uint8_t *VAR_4 = VAR_3->VAR_1;
int VAR_5 = VAR_3->size;
GetBitContext gb;
int VAR_6;
int VAR_7;
int VAR_8;
int VAR_9;
const uint8_t *VAR_10 = av_packet_get_side_data(VAR_3,
AV_PKT_DATA_NEW_EXTRADATA,
&VAR_9);
int VAR_11;
const uint8_t *VAR_12 = av_packet_get_side_data(VAR_3,
AV_PKT_DATA_JP_DUALMONO,
&VAR_11);
if (VAR_10 && 0) {
av_free(VAR_0->extradata);
VAR_0->extradata = av_mallocz(VAR_9 +
AV_INPUT_BUFFER_PADDING_SIZE);
if (!VAR_0->extradata)
return AVERROR(ENOMEM);
VAR_0->extradata_size = VAR_9;
memcpy(VAR_0->extradata, VAR_10, VAR_9);
push_output_configuration(ac);
if (decode_audio_specific_config(ac, ac->VAR_0, &ac->oc[1].m4ac,
VAR_0->extradata,
VAR_0->extradata_size*8, 1) < 0) {
pop_output_configuration(ac);
return AVERROR_INVALIDDATA;
}
}
ac->dmono_mode = 0;
if (VAR_12 && VAR_11 > 0)
ac->dmono_mode = 1 + *VAR_12;
if (ac->force_dmono_mode >= 0)
ac->dmono_mode = ac->force_dmono_mode;
if (INT_MAX / 8 <= VAR_5)
return AVERROR_INVALIDDATA;
if ((VAR_8 = init_get_bits8(&gb, VAR_4, VAR_5)) < 0)
return VAR_8;
switch (ac->oc[1].m4ac.object_type) {
case AOT_ER_AAC_LC:
case AOT_ER_AAC_LTP:
case AOT_ER_AAC_LD:
case AOT_ER_AAC_ELD:
VAR_8 = aac_decode_er_frame(VAR_0, VAR_1, VAR_2, &gb);
break;
default:
VAR_8 = aac_decode_frame_int(VAR_0, VAR_1, VAR_2, &gb, VAR_3);
}
if (VAR_8 < 0)
return VAR_8;
VAR_6 = (get_bits_count(&gb) + 7) >> 3;
for (VAR_7 = VAR_6; VAR_7 < VAR_5; VAR_7++)
if (VAR_4[VAR_7])
break;
return VAR_5 > VAR_7 ? VAR_6 : VAR_5;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0, void *VAR_1,\nint *VAR_2, AVPacket *VAR_3)\n{",
"AACContext *ac = VAR_0->priv_data;",
"const uint8_t *VAR_4 = VAR_3->VAR_1;",
"int VAR_5 = VAR_3->size;",
"GetBitContext gb;",
"int VAR_6;",
"int VAR_7;",
"int VAR_8;",
"int VAR_9;",
"const uint8_t *VAR_10 = av_packet_get_side_data(VAR_3,\nAV_PKT_DATA_NEW_EXTRADATA,\n&VAR_9);",
"int VAR_11;",
"const uint8_t *VAR_12 = av_packet_get_side_data(VAR_3,\nAV_PKT_DATA_JP_DUALMONO,\n&VAR_11);",
"if (VAR_10 && 0) {",
"av_free(VAR_0->extradata);",
"VAR_0->extradata = av_mallocz(VAR_9 +\nAV_INPUT_BUFFER_PADDING_SIZE);",
"if (!VAR_0->extradata)\nreturn AVERROR(ENOMEM);",
"VAR_0->extradata_size = VAR_9;",
"memcpy(VAR_0->extradata, VAR_10, VAR_9);",
"push_output_configuration(ac);",
"if (decode_audio_specific_config(ac, ac->VAR_0, &ac->oc[1].m4ac,\nVAR_0->extradata,\nVAR_0->extradata_size*8, 1) < 0) {",
"pop_output_configuration(ac);",
"return AVERROR_INVALIDDATA;",
"}",
"}",
"ac->dmono_mode = 0;",
"if (VAR_12 && VAR_11 > 0)\nac->dmono_mode = 1 + *VAR_12;",
"if (ac->force_dmono_mode >= 0)\nac->dmono_mode = ac->force_dmono_mode;",
"if (INT_MAX / 8 <= VAR_5)\nreturn AVERROR_INVALIDDATA;",
"if ((VAR_8 = init_get_bits8(&gb, VAR_4, VAR_5)) < 0)\nreturn VAR_8;",
"switch (ac->oc[1].m4ac.object_type) {",
"case AOT_ER_AAC_LC:\ncase AOT_ER_AAC_LTP:\ncase AOT_ER_AAC_LD:\ncase AOT_ER_AAC_ELD:\nVAR_8 = aac_decode_er_frame(VAR_0, VAR_1, VAR_2, &gb);",
"break;",
"default:\nVAR_8 = aac_decode_frame_int(VAR_0, VAR_1, VAR_2, &gb, VAR_3);",
"}",
"if (VAR_8 < 0)\nreturn VAR_8;",
"VAR_6 = (get_bits_count(&gb) + 7) >> 3;",
"for (VAR_7 = VAR_6; VAR_7 < VAR_5; VAR_7++)",
"if (VAR_4[VAR_7])\nbreak;",
"return VAR_5 > VAR_7 ? VAR_6 : VAR_5;",
"}"
] | [
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
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
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
],
[
73
],
[
75,
77
],
[
79,
81
],
[
85,
87
],
[
91,
93
],
[
97
],
[
99,
101,
103,
105,
107
],
[
109
],
[
111,
113
],
[
115
],
[
117,
119
],
[
123
],
[
125
],
[
127,
129
],
[
133
],
[
135
]
] |
24,058 | static void init_proc_book3s_64(CPUPPCState *env, int version)
{
gen_spr_ne_601(env);
gen_tbl(env);
gen_spr_book3s_altivec(env);
gen_spr_book3s_pmu_sup(env);
gen_spr_book3s_pmu_user(env);
gen_spr_book3s_common(env);
switch (version) {
case BOOK3S_CPU_970:
case BOOK3S_CPU_POWER5PLUS:
gen_spr_970_hid(env);
gen_spr_970_hior(env);
gen_low_BATs(env);
gen_spr_970_pmu_sup(env);
gen_spr_970_pmu_user(env);
break;
case BOOK3S_CPU_POWER7:
case BOOK3S_CPU_POWER8:
gen_spr_book3s_ids(env);
gen_spr_amr(env, version >= BOOK3S_CPU_POWER8);
gen_spr_book3s_purr(env);
env->ci_large_pages = true;
break;
default:
g_assert_not_reached();
}
if (version >= BOOK3S_CPU_POWER5PLUS) {
gen_spr_power5p_common(env);
gen_spr_power5p_lpar(env);
gen_spr_power5p_ear(env);
} else {
gen_spr_970_lpar(env);
}
if (version == BOOK3S_CPU_970) {
gen_spr_970_dbg(env);
}
if (version >= BOOK3S_CPU_POWER6) {
gen_spr_power6_common(env);
gen_spr_power6_dbg(env);
}
if (version == BOOK3S_CPU_POWER7) {
gen_spr_power7_book4(env);
}
if (version >= BOOK3S_CPU_POWER8) {
gen_spr_power8_tce_address_control(env);
gen_spr_power8_ids(env);
gen_spr_power8_ebb(env);
gen_spr_power8_fscr(env);
gen_spr_power8_pmu_sup(env);
gen_spr_power8_pmu_user(env);
gen_spr_power8_tm(env);
gen_spr_power8_pspb(env);
gen_spr_vtb(env);
gen_spr_power8_ic(env);
gen_spr_power8_book4(env);
}
if (version < BOOK3S_CPU_POWER8) {
gen_spr_book3s_dbg(env);
} else {
gen_spr_book3s_207_dbg(env);
}
#if !defined(CONFIG_USER_ONLY)
switch (version) {
case BOOK3S_CPU_970:
case BOOK3S_CPU_POWER5PLUS:
env->slb_nr = 64;
break;
case BOOK3S_CPU_POWER7:
case BOOK3S_CPU_POWER8:
default:
env->slb_nr = 32;
break;
}
#endif
/* Allocate hardware IRQ controller */
switch (version) {
case BOOK3S_CPU_970:
case BOOK3S_CPU_POWER5PLUS:
init_excp_970(env);
ppc970_irq_init(ppc_env_get_cpu(env));
break;
case BOOK3S_CPU_POWER7:
case BOOK3S_CPU_POWER8:
init_excp_POWER7(env);
ppcPOWER7_irq_init(ppc_env_get_cpu(env));
break;
default:
g_assert_not_reached();
}
env->dcache_line_size = 128;
env->icache_line_size = 128;
}
| true | qemu | f03a1af581b926118d619ad1acc3304ad84d5e5b | static void init_proc_book3s_64(CPUPPCState *env, int version)
{
gen_spr_ne_601(env);
gen_tbl(env);
gen_spr_book3s_altivec(env);
gen_spr_book3s_pmu_sup(env);
gen_spr_book3s_pmu_user(env);
gen_spr_book3s_common(env);
switch (version) {
case BOOK3S_CPU_970:
case BOOK3S_CPU_POWER5PLUS:
gen_spr_970_hid(env);
gen_spr_970_hior(env);
gen_low_BATs(env);
gen_spr_970_pmu_sup(env);
gen_spr_970_pmu_user(env);
break;
case BOOK3S_CPU_POWER7:
case BOOK3S_CPU_POWER8:
gen_spr_book3s_ids(env);
gen_spr_amr(env, version >= BOOK3S_CPU_POWER8);
gen_spr_book3s_purr(env);
env->ci_large_pages = true;
break;
default:
g_assert_not_reached();
}
if (version >= BOOK3S_CPU_POWER5PLUS) {
gen_spr_power5p_common(env);
gen_spr_power5p_lpar(env);
gen_spr_power5p_ear(env);
} else {
gen_spr_970_lpar(env);
}
if (version == BOOK3S_CPU_970) {
gen_spr_970_dbg(env);
}
if (version >= BOOK3S_CPU_POWER6) {
gen_spr_power6_common(env);
gen_spr_power6_dbg(env);
}
if (version == BOOK3S_CPU_POWER7) {
gen_spr_power7_book4(env);
}
if (version >= BOOK3S_CPU_POWER8) {
gen_spr_power8_tce_address_control(env);
gen_spr_power8_ids(env);
gen_spr_power8_ebb(env);
gen_spr_power8_fscr(env);
gen_spr_power8_pmu_sup(env);
gen_spr_power8_pmu_user(env);
gen_spr_power8_tm(env);
gen_spr_power8_pspb(env);
gen_spr_vtb(env);
gen_spr_power8_ic(env);
gen_spr_power8_book4(env);
}
if (version < BOOK3S_CPU_POWER8) {
gen_spr_book3s_dbg(env);
} else {
gen_spr_book3s_207_dbg(env);
}
#if !defined(CONFIG_USER_ONLY)
switch (version) {
case BOOK3S_CPU_970:
case BOOK3S_CPU_POWER5PLUS:
env->slb_nr = 64;
break;
case BOOK3S_CPU_POWER7:
case BOOK3S_CPU_POWER8:
default:
env->slb_nr = 32;
break;
}
#endif
switch (version) {
case BOOK3S_CPU_970:
case BOOK3S_CPU_POWER5PLUS:
init_excp_970(env);
ppc970_irq_init(ppc_env_get_cpu(env));
break;
case BOOK3S_CPU_POWER7:
case BOOK3S_CPU_POWER8:
init_excp_POWER7(env);
ppcPOWER7_irq_init(ppc_env_get_cpu(env));
break;
default:
g_assert_not_reached();
}
env->dcache_line_size = 128;
env->icache_line_size = 128;
}
| {
"code": [
" case BOOK3S_CPU_POWER8:"
],
"line_no": [
39
]
} | static void FUNC_0(CPUPPCState *VAR_0, int VAR_1)
{
gen_spr_ne_601(VAR_0);
gen_tbl(VAR_0);
gen_spr_book3s_altivec(VAR_0);
gen_spr_book3s_pmu_sup(VAR_0);
gen_spr_book3s_pmu_user(VAR_0);
gen_spr_book3s_common(VAR_0);
switch (VAR_1) {
case BOOK3S_CPU_970:
case BOOK3S_CPU_POWER5PLUS:
gen_spr_970_hid(VAR_0);
gen_spr_970_hior(VAR_0);
gen_low_BATs(VAR_0);
gen_spr_970_pmu_sup(VAR_0);
gen_spr_970_pmu_user(VAR_0);
break;
case BOOK3S_CPU_POWER7:
case BOOK3S_CPU_POWER8:
gen_spr_book3s_ids(VAR_0);
gen_spr_amr(VAR_0, VAR_1 >= BOOK3S_CPU_POWER8);
gen_spr_book3s_purr(VAR_0);
VAR_0->ci_large_pages = true;
break;
default:
g_assert_not_reached();
}
if (VAR_1 >= BOOK3S_CPU_POWER5PLUS) {
gen_spr_power5p_common(VAR_0);
gen_spr_power5p_lpar(VAR_0);
gen_spr_power5p_ear(VAR_0);
} else {
gen_spr_970_lpar(VAR_0);
}
if (VAR_1 == BOOK3S_CPU_970) {
gen_spr_970_dbg(VAR_0);
}
if (VAR_1 >= BOOK3S_CPU_POWER6) {
gen_spr_power6_common(VAR_0);
gen_spr_power6_dbg(VAR_0);
}
if (VAR_1 == BOOK3S_CPU_POWER7) {
gen_spr_power7_book4(VAR_0);
}
if (VAR_1 >= BOOK3S_CPU_POWER8) {
gen_spr_power8_tce_address_control(VAR_0);
gen_spr_power8_ids(VAR_0);
gen_spr_power8_ebb(VAR_0);
gen_spr_power8_fscr(VAR_0);
gen_spr_power8_pmu_sup(VAR_0);
gen_spr_power8_pmu_user(VAR_0);
gen_spr_power8_tm(VAR_0);
gen_spr_power8_pspb(VAR_0);
gen_spr_vtb(VAR_0);
gen_spr_power8_ic(VAR_0);
gen_spr_power8_book4(VAR_0);
}
if (VAR_1 < BOOK3S_CPU_POWER8) {
gen_spr_book3s_dbg(VAR_0);
} else {
gen_spr_book3s_207_dbg(VAR_0);
}
#if !defined(CONFIG_USER_ONLY)
switch (VAR_1) {
case BOOK3S_CPU_970:
case BOOK3S_CPU_POWER5PLUS:
VAR_0->slb_nr = 64;
break;
case BOOK3S_CPU_POWER7:
case BOOK3S_CPU_POWER8:
default:
VAR_0->slb_nr = 32;
break;
}
#endif
switch (VAR_1) {
case BOOK3S_CPU_970:
case BOOK3S_CPU_POWER5PLUS:
init_excp_970(VAR_0);
ppc970_irq_init(ppc_env_get_cpu(VAR_0));
break;
case BOOK3S_CPU_POWER7:
case BOOK3S_CPU_POWER8:
init_excp_POWER7(VAR_0);
ppcPOWER7_irq_init(ppc_env_get_cpu(VAR_0));
break;
default:
g_assert_not_reached();
}
VAR_0->dcache_line_size = 128;
VAR_0->icache_line_size = 128;
}
| [
"static void FUNC_0(CPUPPCState *VAR_0, int VAR_1)\n{",
"gen_spr_ne_601(VAR_0);",
"gen_tbl(VAR_0);",
"gen_spr_book3s_altivec(VAR_0);",
"gen_spr_book3s_pmu_sup(VAR_0);",
"gen_spr_book3s_pmu_user(VAR_0);",
"gen_spr_book3s_common(VAR_0);",
"switch (VAR_1) {",
"case BOOK3S_CPU_970:\ncase BOOK3S_CPU_POWER5PLUS:\ngen_spr_970_hid(VAR_0);",
"gen_spr_970_hior(VAR_0);",
"gen_low_BATs(VAR_0);",
"gen_spr_970_pmu_sup(VAR_0);",
"gen_spr_970_pmu_user(VAR_0);",
"break;",
"case BOOK3S_CPU_POWER7:\ncase BOOK3S_CPU_POWER8:\ngen_spr_book3s_ids(VAR_0);",
"gen_spr_amr(VAR_0, VAR_1 >= BOOK3S_CPU_POWER8);",
"gen_spr_book3s_purr(VAR_0);",
"VAR_0->ci_large_pages = true;",
"break;",
"default:\ng_assert_not_reached();",
"}",
"if (VAR_1 >= BOOK3S_CPU_POWER5PLUS) {",
"gen_spr_power5p_common(VAR_0);",
"gen_spr_power5p_lpar(VAR_0);",
"gen_spr_power5p_ear(VAR_0);",
"} else {",
"gen_spr_970_lpar(VAR_0);",
"}",
"if (VAR_1 == BOOK3S_CPU_970) {",
"gen_spr_970_dbg(VAR_0);",
"}",
"if (VAR_1 >= BOOK3S_CPU_POWER6) {",
"gen_spr_power6_common(VAR_0);",
"gen_spr_power6_dbg(VAR_0);",
"}",
"if (VAR_1 == BOOK3S_CPU_POWER7) {",
"gen_spr_power7_book4(VAR_0);",
"}",
"if (VAR_1 >= BOOK3S_CPU_POWER8) {",
"gen_spr_power8_tce_address_control(VAR_0);",
"gen_spr_power8_ids(VAR_0);",
"gen_spr_power8_ebb(VAR_0);",
"gen_spr_power8_fscr(VAR_0);",
"gen_spr_power8_pmu_sup(VAR_0);",
"gen_spr_power8_pmu_user(VAR_0);",
"gen_spr_power8_tm(VAR_0);",
"gen_spr_power8_pspb(VAR_0);",
"gen_spr_vtb(VAR_0);",
"gen_spr_power8_ic(VAR_0);",
"gen_spr_power8_book4(VAR_0);",
"}",
"if (VAR_1 < BOOK3S_CPU_POWER8) {",
"gen_spr_book3s_dbg(VAR_0);",
"} else {",
"gen_spr_book3s_207_dbg(VAR_0);",
"}",
"#if !defined(CONFIG_USER_ONLY)\nswitch (VAR_1) {",
"case BOOK3S_CPU_970:\ncase BOOK3S_CPU_POWER5PLUS:\nVAR_0->slb_nr = 64;",
"break;",
"case BOOK3S_CPU_POWER7:\ncase BOOK3S_CPU_POWER8:\ndefault:\nVAR_0->slb_nr = 32;",
"break;",
"}",
"#endif\nswitch (VAR_1) {",
"case BOOK3S_CPU_970:\ncase BOOK3S_CPU_POWER5PLUS:\ninit_excp_970(VAR_0);",
"ppc970_irq_init(ppc_env_get_cpu(VAR_0));",
"break;",
"case BOOK3S_CPU_POWER7:\ncase BOOK3S_CPU_POWER8:\ninit_excp_POWER7(VAR_0);",
"ppcPOWER7_irq_init(ppc_env_get_cpu(VAR_0));",
"break;",
"default:\ng_assert_not_reached();",
"}",
"VAR_0->dcache_line_size = 128;",
"VAR_0->icache_line_size = 128;",
"}"
] | [
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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
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
],
[
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,
155
],
[
157,
159,
161
],
[
163
],
[
165
],
[
167,
169,
171
],
[
173
],
[
175
],
[
177,
179
],
[
181
],
[
185
],
[
187
],
[
189
]
] |
24,059 | static void virtio_host_initfn(Object *obj)
{
VirtIOInputHostPCI *dev = VIRTIO_INPUT_HOST_PCI(obj);
virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
TYPE_VIRTIO_INPUT_HOST);
}
| true | qemu | c6047e9621f77a65993bcda8f58b676996e24bb5 | static void virtio_host_initfn(Object *obj)
{
VirtIOInputHostPCI *dev = VIRTIO_INPUT_HOST_PCI(obj);
virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
TYPE_VIRTIO_INPUT_HOST);
}
| {
"code": [
"static void virtio_host_initfn(Object *obj)",
" VirtIOInputHostPCI *dev = VIRTIO_INPUT_HOST_PCI(obj);",
" virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),",
" TYPE_VIRTIO_INPUT_HOST);"
],
"line_no": [
1,
5,
9,
11
]
} | static void FUNC_0(Object *VAR_0)
{
VirtIOInputHostPCI *dev = VIRTIO_INPUT_HOST_PCI(VAR_0);
virtio_instance_init_common(VAR_0, &dev->vdev, sizeof(dev->vdev),
TYPE_VIRTIO_INPUT_HOST);
}
| [
"static void FUNC_0(Object *VAR_0)\n{",
"VirtIOInputHostPCI *dev = VIRTIO_INPUT_HOST_PCI(VAR_0);",
"virtio_instance_init_common(VAR_0, &dev->vdev, sizeof(dev->vdev),\nTYPE_VIRTIO_INPUT_HOST);",
"}"
] | [
1,
1,
1,
0
] | [
[
1,
3
],
[
5
],
[
9,
11
],
[
13
]
] |
24,060 | int qcow2_update_snapshot_refcount(BlockDriverState *bs,
int64_t l1_table_offset, int l1_size, int addend)
{
BDRVQcowState *s = bs->opaque;
uint64_t *l1_table, *l2_table, l2_offset, offset, l1_size2, l1_allocated;
int64_t old_offset, old_l2_offset;
int i, j, l1_modified = 0, nb_csectors, refcount;
int ret;
l2_table = NULL;
l1_table = NULL;
l1_size2 = l1_size * sizeof(uint64_t);
/* WARNING: qcow2_snapshot_goto relies on this function not using the
* l1_table_offset when it is the current s->l1_table_offset! Be careful
* when changing this! */
if (l1_table_offset != s->l1_table_offset) {
l1_table = g_malloc0(align_offset(l1_size2, 512));
l1_allocated = 1;
ret = bdrv_pread(bs->file, l1_table_offset, l1_table, l1_size2);
if (ret < 0) {
goto fail;
}
for(i = 0;i < l1_size; i++)
be64_to_cpus(&l1_table[i]);
} else {
assert(l1_size == s->l1_size);
l1_table = s->l1_table;
l1_allocated = 0;
}
for(i = 0; i < l1_size; i++) {
l2_offset = l1_table[i];
if (l2_offset) {
old_l2_offset = l2_offset;
l2_offset &= L1E_OFFSET_MASK;
ret = qcow2_cache_get(bs, s->l2_table_cache, l2_offset,
(void**) &l2_table);
if (ret < 0) {
goto fail;
}
for(j = 0; j < s->l2_size; j++) {
offset = be64_to_cpu(l2_table[j]);
if (offset != 0) {
old_offset = offset;
offset &= ~QCOW_OFLAG_COPIED;
if (offset & QCOW_OFLAG_COMPRESSED) {
nb_csectors = ((offset >> s->csize_shift) &
s->csize_mask) + 1;
if (addend != 0) {
int ret;
ret = update_refcount(bs,
(offset & s->cluster_offset_mask) & ~511,
nb_csectors * 512, addend);
if (ret < 0) {
goto fail;
}
}
/* compressed clusters are never modified */
refcount = 2;
} else {
uint64_t cluster_index = (offset & L2E_OFFSET_MASK) >> s->cluster_bits;
if (addend != 0) {
refcount = update_cluster_refcount(bs, cluster_index, addend);
} else {
refcount = get_refcount(bs, cluster_index);
}
if (refcount < 0) {
ret = refcount;
goto fail;
}
}
if (refcount == 1) {
offset |= QCOW_OFLAG_COPIED;
}
if (offset != old_offset) {
if (addend > 0) {
qcow2_cache_set_dependency(bs, s->l2_table_cache,
s->refcount_block_cache);
}
l2_table[j] = cpu_to_be64(offset);
qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_table);
}
}
}
ret = qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table);
if (ret < 0) {
goto fail;
}
if (addend != 0) {
refcount = update_cluster_refcount(bs, l2_offset >> s->cluster_bits, addend);
} else {
refcount = get_refcount(bs, l2_offset >> s->cluster_bits);
}
if (refcount < 0) {
ret = refcount;
goto fail;
} else if (refcount == 1) {
l2_offset |= QCOW_OFLAG_COPIED;
}
if (l2_offset != old_l2_offset) {
l1_table[i] = l2_offset;
l1_modified = 1;
}
}
}
ret = bdrv_flush(bs);
fail:
if (l2_table) {
qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table);
}
/* Update L1 only if it isn't deleted anyway (addend = -1) */
if (addend >= 0 && l1_modified) {
for(i = 0; i < l1_size; i++)
cpu_to_be64s(&l1_table[i]);
if (bdrv_pwrite_sync(bs->file, l1_table_offset, l1_table,
l1_size2) < 0)
goto fail;
for(i = 0; i < l1_size; i++)
be64_to_cpus(&l1_table[i]);
}
if (l1_allocated)
g_free(l1_table);
return ret;
}
| true | qemu | c2b6ff51e4a3ad1f7ec5dbc94970e9778b31d718 | int qcow2_update_snapshot_refcount(BlockDriverState *bs,
int64_t l1_table_offset, int l1_size, int addend)
{
BDRVQcowState *s = bs->opaque;
uint64_t *l1_table, *l2_table, l2_offset, offset, l1_size2, l1_allocated;
int64_t old_offset, old_l2_offset;
int i, j, l1_modified = 0, nb_csectors, refcount;
int ret;
l2_table = NULL;
l1_table = NULL;
l1_size2 = l1_size * sizeof(uint64_t);
if (l1_table_offset != s->l1_table_offset) {
l1_table = g_malloc0(align_offset(l1_size2, 512));
l1_allocated = 1;
ret = bdrv_pread(bs->file, l1_table_offset, l1_table, l1_size2);
if (ret < 0) {
goto fail;
}
for(i = 0;i < l1_size; i++)
be64_to_cpus(&l1_table[i]);
} else {
assert(l1_size == s->l1_size);
l1_table = s->l1_table;
l1_allocated = 0;
}
for(i = 0; i < l1_size; i++) {
l2_offset = l1_table[i];
if (l2_offset) {
old_l2_offset = l2_offset;
l2_offset &= L1E_OFFSET_MASK;
ret = qcow2_cache_get(bs, s->l2_table_cache, l2_offset,
(void**) &l2_table);
if (ret < 0) {
goto fail;
}
for(j = 0; j < s->l2_size; j++) {
offset = be64_to_cpu(l2_table[j]);
if (offset != 0) {
old_offset = offset;
offset &= ~QCOW_OFLAG_COPIED;
if (offset & QCOW_OFLAG_COMPRESSED) {
nb_csectors = ((offset >> s->csize_shift) &
s->csize_mask) + 1;
if (addend != 0) {
int ret;
ret = update_refcount(bs,
(offset & s->cluster_offset_mask) & ~511,
nb_csectors * 512, addend);
if (ret < 0) {
goto fail;
}
}
refcount = 2;
} else {
uint64_t cluster_index = (offset & L2E_OFFSET_MASK) >> s->cluster_bits;
if (addend != 0) {
refcount = update_cluster_refcount(bs, cluster_index, addend);
} else {
refcount = get_refcount(bs, cluster_index);
}
if (refcount < 0) {
ret = refcount;
goto fail;
}
}
if (refcount == 1) {
offset |= QCOW_OFLAG_COPIED;
}
if (offset != old_offset) {
if (addend > 0) {
qcow2_cache_set_dependency(bs, s->l2_table_cache,
s->refcount_block_cache);
}
l2_table[j] = cpu_to_be64(offset);
qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_table);
}
}
}
ret = qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table);
if (ret < 0) {
goto fail;
}
if (addend != 0) {
refcount = update_cluster_refcount(bs, l2_offset >> s->cluster_bits, addend);
} else {
refcount = get_refcount(bs, l2_offset >> s->cluster_bits);
}
if (refcount < 0) {
ret = refcount;
goto fail;
} else if (refcount == 1) {
l2_offset |= QCOW_OFLAG_COPIED;
}
if (l2_offset != old_l2_offset) {
l1_table[i] = l2_offset;
l1_modified = 1;
}
}
}
ret = bdrv_flush(bs);
fail:
if (l2_table) {
qcow2_cache_put(bs, s->l2_table_cache, (void**) &l2_table);
}
if (addend >= 0 && l1_modified) {
for(i = 0; i < l1_size; i++)
cpu_to_be64s(&l1_table[i]);
if (bdrv_pwrite_sync(bs->file, l1_table_offset, l1_table,
l1_size2) < 0)
goto fail;
for(i = 0; i < l1_size; i++)
be64_to_cpus(&l1_table[i]);
}
if (l1_allocated)
g_free(l1_table);
return ret;
}
| {
"code": [
" if (addend >= 0 && l1_modified) {",
" for(i = 0; i < l1_size; i++)",
" if (bdrv_pwrite_sync(bs->file, l1_table_offset, l1_table,",
" l1_size2) < 0)",
" goto fail;",
" for(i = 0; i < l1_size; i++)"
],
"line_no": [
247,
249,
253,
255,
45,
249
]
} | int FUNC_0(BlockDriverState *VAR_0,
int64_t VAR_1, int VAR_2, int VAR_3)
{
BDRVQcowState *s = VAR_0->opaque;
uint64_t *l1_table, *l2_table, l2_offset, offset, l1_size2, l1_allocated;
int64_t old_offset, old_l2_offset;
int VAR_4, VAR_5, VAR_6 = 0, VAR_7, VAR_8;
int VAR_9;
l2_table = NULL;
l1_table = NULL;
l1_size2 = VAR_2 * sizeof(uint64_t);
if (VAR_1 != s->VAR_1) {
l1_table = g_malloc0(align_offset(l1_size2, 512));
l1_allocated = 1;
VAR_9 = bdrv_pread(VAR_0->file, VAR_1, l1_table, l1_size2);
if (VAR_9 < 0) {
goto fail;
}
for(VAR_4 = 0;VAR_4 < VAR_2; VAR_4++)
be64_to_cpus(&l1_table[VAR_4]);
} else {
assert(VAR_2 == s->VAR_2);
l1_table = s->l1_table;
l1_allocated = 0;
}
for(VAR_4 = 0; VAR_4 < VAR_2; VAR_4++) {
l2_offset = l1_table[VAR_4];
if (l2_offset) {
old_l2_offset = l2_offset;
l2_offset &= L1E_OFFSET_MASK;
VAR_9 = qcow2_cache_get(VAR_0, s->l2_table_cache, l2_offset,
(void**) &l2_table);
if (VAR_9 < 0) {
goto fail;
}
for(VAR_5 = 0; VAR_5 < s->l2_size; VAR_5++) {
offset = be64_to_cpu(l2_table[VAR_5]);
if (offset != 0) {
old_offset = offset;
offset &= ~QCOW_OFLAG_COPIED;
if (offset & QCOW_OFLAG_COMPRESSED) {
VAR_7 = ((offset >> s->csize_shift) &
s->csize_mask) + 1;
if (VAR_3 != 0) {
int VAR_9;
VAR_9 = update_refcount(VAR_0,
(offset & s->cluster_offset_mask) & ~511,
VAR_7 * 512, VAR_3);
if (VAR_9 < 0) {
goto fail;
}
}
VAR_8 = 2;
} else {
uint64_t cluster_index = (offset & L2E_OFFSET_MASK) >> s->cluster_bits;
if (VAR_3 != 0) {
VAR_8 = update_cluster_refcount(VAR_0, cluster_index, VAR_3);
} else {
VAR_8 = get_refcount(VAR_0, cluster_index);
}
if (VAR_8 < 0) {
VAR_9 = VAR_8;
goto fail;
}
}
if (VAR_8 == 1) {
offset |= QCOW_OFLAG_COPIED;
}
if (offset != old_offset) {
if (VAR_3 > 0) {
qcow2_cache_set_dependency(VAR_0, s->l2_table_cache,
s->refcount_block_cache);
}
l2_table[VAR_5] = cpu_to_be64(offset);
qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_table);
}
}
}
VAR_9 = qcow2_cache_put(VAR_0, s->l2_table_cache, (void**) &l2_table);
if (VAR_9 < 0) {
goto fail;
}
if (VAR_3 != 0) {
VAR_8 = update_cluster_refcount(VAR_0, l2_offset >> s->cluster_bits, VAR_3);
} else {
VAR_8 = get_refcount(VAR_0, l2_offset >> s->cluster_bits);
}
if (VAR_8 < 0) {
VAR_9 = VAR_8;
goto fail;
} else if (VAR_8 == 1) {
l2_offset |= QCOW_OFLAG_COPIED;
}
if (l2_offset != old_l2_offset) {
l1_table[VAR_4] = l2_offset;
VAR_6 = 1;
}
}
}
VAR_9 = bdrv_flush(VAR_0);
fail:
if (l2_table) {
qcow2_cache_put(VAR_0, s->l2_table_cache, (void**) &l2_table);
}
if (VAR_3 >= 0 && VAR_6) {
for(VAR_4 = 0; VAR_4 < VAR_2; VAR_4++)
cpu_to_be64s(&l1_table[VAR_4]);
if (bdrv_pwrite_sync(VAR_0->file, VAR_1, l1_table,
l1_size2) < 0)
goto fail;
for(VAR_4 = 0; VAR_4 < VAR_2; VAR_4++)
be64_to_cpus(&l1_table[VAR_4]);
}
if (l1_allocated)
g_free(l1_table);
return VAR_9;
}
| [
"int FUNC_0(BlockDriverState *VAR_0,\nint64_t VAR_1, int VAR_2, int VAR_3)\n{",
"BDRVQcowState *s = VAR_0->opaque;",
"uint64_t *l1_table, *l2_table, l2_offset, offset, l1_size2, l1_allocated;",
"int64_t old_offset, old_l2_offset;",
"int VAR_4, VAR_5, VAR_6 = 0, VAR_7, VAR_8;",
"int VAR_9;",
"l2_table = NULL;",
"l1_table = NULL;",
"l1_size2 = VAR_2 * sizeof(uint64_t);",
"if (VAR_1 != s->VAR_1) {",
"l1_table = g_malloc0(align_offset(l1_size2, 512));",
"l1_allocated = 1;",
"VAR_9 = bdrv_pread(VAR_0->file, VAR_1, l1_table, l1_size2);",
"if (VAR_9 < 0) {",
"goto fail;",
"}",
"for(VAR_4 = 0;VAR_4 < VAR_2; VAR_4++)",
"be64_to_cpus(&l1_table[VAR_4]);",
"} else {",
"assert(VAR_2 == s->VAR_2);",
"l1_table = s->l1_table;",
"l1_allocated = 0;",
"}",
"for(VAR_4 = 0; VAR_4 < VAR_2; VAR_4++) {",
"l2_offset = l1_table[VAR_4];",
"if (l2_offset) {",
"old_l2_offset = l2_offset;",
"l2_offset &= L1E_OFFSET_MASK;",
"VAR_9 = qcow2_cache_get(VAR_0, s->l2_table_cache, l2_offset,\n(void**) &l2_table);",
"if (VAR_9 < 0) {",
"goto fail;",
"}",
"for(VAR_5 = 0; VAR_5 < s->l2_size; VAR_5++) {",
"offset = be64_to_cpu(l2_table[VAR_5]);",
"if (offset != 0) {",
"old_offset = offset;",
"offset &= ~QCOW_OFLAG_COPIED;",
"if (offset & QCOW_OFLAG_COMPRESSED) {",
"VAR_7 = ((offset >> s->csize_shift) &\ns->csize_mask) + 1;",
"if (VAR_3 != 0) {",
"int VAR_9;",
"VAR_9 = update_refcount(VAR_0,\n(offset & s->cluster_offset_mask) & ~511,\nVAR_7 * 512, VAR_3);",
"if (VAR_9 < 0) {",
"goto fail;",
"}",
"}",
"VAR_8 = 2;",
"} else {",
"uint64_t cluster_index = (offset & L2E_OFFSET_MASK) >> s->cluster_bits;",
"if (VAR_3 != 0) {",
"VAR_8 = update_cluster_refcount(VAR_0, cluster_index, VAR_3);",
"} else {",
"VAR_8 = get_refcount(VAR_0, cluster_index);",
"}",
"if (VAR_8 < 0) {",
"VAR_9 = VAR_8;",
"goto fail;",
"}",
"}",
"if (VAR_8 == 1) {",
"offset |= QCOW_OFLAG_COPIED;",
"}",
"if (offset != old_offset) {",
"if (VAR_3 > 0) {",
"qcow2_cache_set_dependency(VAR_0, s->l2_table_cache,\ns->refcount_block_cache);",
"}",
"l2_table[VAR_5] = cpu_to_be64(offset);",
"qcow2_cache_entry_mark_dirty(s->l2_table_cache, l2_table);",
"}",
"}",
"}",
"VAR_9 = qcow2_cache_put(VAR_0, s->l2_table_cache, (void**) &l2_table);",
"if (VAR_9 < 0) {",
"goto fail;",
"}",
"if (VAR_3 != 0) {",
"VAR_8 = update_cluster_refcount(VAR_0, l2_offset >> s->cluster_bits, VAR_3);",
"} else {",
"VAR_8 = get_refcount(VAR_0, l2_offset >> s->cluster_bits);",
"}",
"if (VAR_8 < 0) {",
"VAR_9 = VAR_8;",
"goto fail;",
"} else if (VAR_8 == 1) {",
"l2_offset |= QCOW_OFLAG_COPIED;",
"}",
"if (l2_offset != old_l2_offset) {",
"l1_table[VAR_4] = l2_offset;",
"VAR_6 = 1;",
"}",
"}",
"}",
"VAR_9 = bdrv_flush(VAR_0);",
"fail:\nif (l2_table) {",
"qcow2_cache_put(VAR_0, s->l2_table_cache, (void**) &l2_table);",
"}",
"if (VAR_3 >= 0 && VAR_6) {",
"for(VAR_4 = 0; VAR_4 < VAR_2; VAR_4++)",
"cpu_to_be64s(&l1_table[VAR_4]);",
"if (bdrv_pwrite_sync(VAR_0->file, VAR_1, l1_table,\nl1_size2) < 0)\ngoto fail;",
"for(VAR_4 = 0; VAR_4 < VAR_2; VAR_4++)",
"be64_to_cpus(&l1_table[VAR_4]);",
"}",
"if (l1_allocated)\ng_free(l1_table);",
"return VAR_9;",
"}"
] | [
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,
1,
1,
0,
1,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
79,
81
],
[
83
],
[
85
],
[
87
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103,
105
],
[
107
],
[
109
],
[
111,
113,
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
157
],
[
159
],
[
161
],
[
163
],
[
165
],
[
167,
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
185
],
[
187
],
[
189
],
[
191
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225
],
[
227
],
[
229
],
[
233
],
[
235,
237
],
[
239
],
[
241
],
[
247
],
[
249
],
[
251
],
[
253,
255,
257
],
[
259
],
[
261
],
[
263
],
[
265,
267
],
[
269
],
[
271
]
] |
24,061 | int ff_dirac_golomb_read_32bit(DiracGolombLUT *lut_ctx, const uint8_t *buf,
int bytes, uint8_t *_dst, int coeffs)
{
int i, b, c_idx = 0;
int32_t *dst = (int32_t *)_dst;
DiracGolombLUT *future[4], *l = &lut_ctx[2*LUT_SIZE + buf[0]];
INIT_RESIDUE(res);
for (b = 1; b <= bytes; b++) {
future[0] = &lut_ctx[buf[b]];
future[1] = future[0] + 1*LUT_SIZE;
future[2] = future[0] + 2*LUT_SIZE;
future[3] = future[0] + 3*LUT_SIZE;
if ((c_idx + 1) > coeffs)
return c_idx;
/* res_bits is a hint for better branch prediction */
if (res_bits && l->sign) {
int32_t coeff = 1;
APPEND_RESIDUE(res, l->preamble);
for (i = 0; i < (res_bits >> 1) - 1; i++) {
coeff <<= 1;
coeff |= (res >> (RSIZE_BITS - 2*i - 2)) & 1;
}
dst[c_idx++] = l->sign * (coeff - 1);
}
memcpy(&dst[c_idx], l->ready, LUT_BITS*sizeof(int32_t));
c_idx += l->ready_num;
APPEND_RESIDUE(res, l->leftover);
l = future[l->need_s ? 3 : !res_bits ? 2 : res_bits & 1];
}
return c_idx;
} | true | FFmpeg | c595139f1fdb5ce5ee128c317ed9e4e836282436 | int ff_dirac_golomb_read_32bit(DiracGolombLUT *lut_ctx, const uint8_t *buf,
int bytes, uint8_t *_dst, int coeffs)
{
int i, b, c_idx = 0;
int32_t *dst = (int32_t *)_dst;
DiracGolombLUT *future[4], *l = &lut_ctx[2*LUT_SIZE + buf[0]];
INIT_RESIDUE(res);
for (b = 1; b <= bytes; b++) {
future[0] = &lut_ctx[buf[b]];
future[1] = future[0] + 1*LUT_SIZE;
future[2] = future[0] + 2*LUT_SIZE;
future[3] = future[0] + 3*LUT_SIZE;
if ((c_idx + 1) > coeffs)
return c_idx;
if (res_bits && l->sign) {
int32_t coeff = 1;
APPEND_RESIDUE(res, l->preamble);
for (i = 0; i < (res_bits >> 1) - 1; i++) {
coeff <<= 1;
coeff |= (res >> (RSIZE_BITS - 2*i - 2)) & 1;
}
dst[c_idx++] = l->sign * (coeff - 1);
}
memcpy(&dst[c_idx], l->ready, LUT_BITS*sizeof(int32_t));
c_idx += l->ready_num;
APPEND_RESIDUE(res, l->leftover);
l = future[l->need_s ? 3 : !res_bits ? 2 : res_bits & 1];
}
return c_idx;
} | {
"code": [],
"line_no": []
} | int FUNC_0(DiracGolombLUT *VAR_0, const uint8_t *VAR_1,
int VAR_2, uint8_t *VAR_3, int VAR_4)
{
int VAR_5, VAR_6, VAR_7 = 0;
int32_t *dst = (int32_t *)VAR_3;
DiracGolombLUT *future[4], *l = &VAR_0[2*LUT_SIZE + VAR_1[0]];
INIT_RESIDUE(res);
for (VAR_6 = 1; VAR_6 <= VAR_2; VAR_6++) {
future[0] = &VAR_0[VAR_1[VAR_6]];
future[1] = future[0] + 1*LUT_SIZE;
future[2] = future[0] + 2*LUT_SIZE;
future[3] = future[0] + 3*LUT_SIZE;
if ((VAR_7 + 1) > VAR_4)
return VAR_7;
if (res_bits && l->sign) {
int32_t coeff = 1;
APPEND_RESIDUE(res, l->preamble);
for (VAR_5 = 0; VAR_5 < (res_bits >> 1) - 1; VAR_5++) {
coeff <<= 1;
coeff |= (res >> (RSIZE_BITS - 2*VAR_5 - 2)) & 1;
}
dst[VAR_7++] = l->sign * (coeff - 1);
}
memcpy(&dst[VAR_7], l->ready, LUT_BITS*sizeof(int32_t));
VAR_7 += l->ready_num;
APPEND_RESIDUE(res, l->leftover);
l = future[l->need_s ? 3 : !res_bits ? 2 : res_bits & 1];
}
return VAR_7;
} | [
"int FUNC_0(DiracGolombLUT *VAR_0, const uint8_t *VAR_1,\nint VAR_2, uint8_t *VAR_3, int VAR_4)\n{",
"int VAR_5, VAR_6, VAR_7 = 0;",
"int32_t *dst = (int32_t *)VAR_3;",
"DiracGolombLUT *future[4], *l = &VAR_0[2*LUT_SIZE + VAR_1[0]];",
"INIT_RESIDUE(res);",
"for (VAR_6 = 1; VAR_6 <= VAR_2; VAR_6++) {",
"future[0] = &VAR_0[VAR_1[VAR_6]];",
"future[1] = future[0] + 1*LUT_SIZE;",
"future[2] = future[0] + 2*LUT_SIZE;",
"future[3] = future[0] + 3*LUT_SIZE;",
"if ((VAR_7 + 1) > VAR_4)\nreturn VAR_7;",
"if (res_bits && l->sign) {",
"int32_t coeff = 1;",
"APPEND_RESIDUE(res, l->preamble);",
"for (VAR_5 = 0; VAR_5 < (res_bits >> 1) - 1; VAR_5++) {",
"coeff <<= 1;",
"coeff |= (res >> (RSIZE_BITS - 2*VAR_5 - 2)) & 1;",
"}",
"dst[VAR_7++] = l->sign * (coeff - 1);",
"}",
"memcpy(&dst[VAR_7], l->ready, LUT_BITS*sizeof(int32_t));",
"VAR_7 += l->ready_num;",
"APPEND_RESIDUE(res, l->leftover);",
"l = future[l->need_s ? 3 : !res_bits ? 2 : res_bits & 1];",
"}",
"return VAR_7;",
"}"
] | [
0,
0,
0,
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
],
[
16
],
[
17
],
[
18
],
[
19
],
[
20
],
[
21
],
[
22
],
[
23
],
[
24
],
[
25
],
[
26
],
[
27
],
[
28
],
[
29
],
[
30
],
[
31
]
] |
24,062 | static uint32_t syborg_virtio_readl(void *opaque, target_phys_addr_t offset)
{
SyborgVirtIOProxy *s = opaque;
VirtIODevice *vdev = s->vdev;
uint32_t ret;
DPRINTF("readl 0x%x\n", (int)offset);
if (offset >= SYBORG_VIRTIO_CONFIG) {
return virtio_config_readl(vdev, offset - SYBORG_VIRTIO_CONFIG);
}
switch(offset >> 2) {
case SYBORG_VIRTIO_ID:
ret = SYBORG_ID_VIRTIO;
break;
case SYBORG_VIRTIO_DEVTYPE:
ret = s->id;
break;
case SYBORG_VIRTIO_HOST_FEATURES:
ret = vdev->get_features(vdev);
ret |= (1 << VIRTIO_F_NOTIFY_ON_EMPTY);
break;
case SYBORG_VIRTIO_GUEST_FEATURES:
ret = vdev->features;
break;
case SYBORG_VIRTIO_QUEUE_BASE:
ret = virtio_queue_get_addr(vdev, vdev->queue_sel);
break;
case SYBORG_VIRTIO_QUEUE_NUM:
ret = virtio_queue_get_num(vdev, vdev->queue_sel);
break;
case SYBORG_VIRTIO_QUEUE_SEL:
ret = vdev->queue_sel;
break;
case SYBORG_VIRTIO_STATUS:
ret = vdev->status;
break;
case SYBORG_VIRTIO_INT_ENABLE:
ret = s->int_enable;
break;
case SYBORG_VIRTIO_INT_STATUS:
ret = vdev->isr;
break;
default:
BADF("Bad read offset 0x%x\n", (int)offset);
return 0;
}
return ret;
}
| true | qemu | 6d74ca5aa83b83fb52332f7735c61ecb7a5328c1 | static uint32_t syborg_virtio_readl(void *opaque, target_phys_addr_t offset)
{
SyborgVirtIOProxy *s = opaque;
VirtIODevice *vdev = s->vdev;
uint32_t ret;
DPRINTF("readl 0x%x\n", (int)offset);
if (offset >= SYBORG_VIRTIO_CONFIG) {
return virtio_config_readl(vdev, offset - SYBORG_VIRTIO_CONFIG);
}
switch(offset >> 2) {
case SYBORG_VIRTIO_ID:
ret = SYBORG_ID_VIRTIO;
break;
case SYBORG_VIRTIO_DEVTYPE:
ret = s->id;
break;
case SYBORG_VIRTIO_HOST_FEATURES:
ret = vdev->get_features(vdev);
ret |= (1 << VIRTIO_F_NOTIFY_ON_EMPTY);
break;
case SYBORG_VIRTIO_GUEST_FEATURES:
ret = vdev->features;
break;
case SYBORG_VIRTIO_QUEUE_BASE:
ret = virtio_queue_get_addr(vdev, vdev->queue_sel);
break;
case SYBORG_VIRTIO_QUEUE_NUM:
ret = virtio_queue_get_num(vdev, vdev->queue_sel);
break;
case SYBORG_VIRTIO_QUEUE_SEL:
ret = vdev->queue_sel;
break;
case SYBORG_VIRTIO_STATUS:
ret = vdev->status;
break;
case SYBORG_VIRTIO_INT_ENABLE:
ret = s->int_enable;
break;
case SYBORG_VIRTIO_INT_STATUS:
ret = vdev->isr;
break;
default:
BADF("Bad read offset 0x%x\n", (int)offset);
return 0;
}
return ret;
}
| {
"code": [
" ret |= (1 << VIRTIO_F_NOTIFY_ON_EMPTY);",
" ret |= (1 << VIRTIO_F_NOTIFY_ON_EMPTY);"
],
"line_no": [
39,
39
]
} | static uint32_t FUNC_0(void *opaque, target_phys_addr_t offset)
{
SyborgVirtIOProxy *s = opaque;
VirtIODevice *vdev = s->vdev;
uint32_t ret;
DPRINTF("readl 0x%x\n", (int)offset);
if (offset >= SYBORG_VIRTIO_CONFIG) {
return virtio_config_readl(vdev, offset - SYBORG_VIRTIO_CONFIG);
}
switch(offset >> 2) {
case SYBORG_VIRTIO_ID:
ret = SYBORG_ID_VIRTIO;
break;
case SYBORG_VIRTIO_DEVTYPE:
ret = s->id;
break;
case SYBORG_VIRTIO_HOST_FEATURES:
ret = vdev->get_features(vdev);
ret |= (1 << VIRTIO_F_NOTIFY_ON_EMPTY);
break;
case SYBORG_VIRTIO_GUEST_FEATURES:
ret = vdev->features;
break;
case SYBORG_VIRTIO_QUEUE_BASE:
ret = virtio_queue_get_addr(vdev, vdev->queue_sel);
break;
case SYBORG_VIRTIO_QUEUE_NUM:
ret = virtio_queue_get_num(vdev, vdev->queue_sel);
break;
case SYBORG_VIRTIO_QUEUE_SEL:
ret = vdev->queue_sel;
break;
case SYBORG_VIRTIO_STATUS:
ret = vdev->status;
break;
case SYBORG_VIRTIO_INT_ENABLE:
ret = s->int_enable;
break;
case SYBORG_VIRTIO_INT_STATUS:
ret = vdev->isr;
break;
default:
BADF("Bad read offset 0x%x\n", (int)offset);
return 0;
}
return ret;
}
| [
"static uint32_t FUNC_0(void *opaque, target_phys_addr_t offset)\n{",
"SyborgVirtIOProxy *s = opaque;",
"VirtIODevice *vdev = s->vdev;",
"uint32_t ret;",
"DPRINTF(\"readl 0x%x\\n\", (int)offset);",
"if (offset >= SYBORG_VIRTIO_CONFIG) {",
"return virtio_config_readl(vdev, offset - SYBORG_VIRTIO_CONFIG);",
"}",
"switch(offset >> 2) {",
"case SYBORG_VIRTIO_ID:\nret = SYBORG_ID_VIRTIO;",
"break;",
"case SYBORG_VIRTIO_DEVTYPE:\nret = s->id;",
"break;",
"case SYBORG_VIRTIO_HOST_FEATURES:\nret = vdev->get_features(vdev);",
"ret |= (1 << VIRTIO_F_NOTIFY_ON_EMPTY);",
"break;",
"case SYBORG_VIRTIO_GUEST_FEATURES:\nret = vdev->features;",
"break;",
"case SYBORG_VIRTIO_QUEUE_BASE:\nret = virtio_queue_get_addr(vdev, vdev->queue_sel);",
"break;",
"case SYBORG_VIRTIO_QUEUE_NUM:\nret = virtio_queue_get_num(vdev, vdev->queue_sel);",
"break;",
"case SYBORG_VIRTIO_QUEUE_SEL:\nret = vdev->queue_sel;",
"break;",
"case SYBORG_VIRTIO_STATUS:\nret = vdev->status;",
"break;",
"case SYBORG_VIRTIO_INT_ENABLE:\nret = s->int_enable;",
"break;",
"case SYBORG_VIRTIO_INT_STATUS:\nret = vdev->isr;",
"break;",
"default:\nBADF(\"Bad read offset 0x%x\\n\", (int)offset);",
"return 0;",
"}",
"return ret;",
"}"
] | [
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
] | [
[
1,
3
],
[
5
],
[
7
],
[
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,
75
],
[
77
],
[
79,
81
],
[
83
],
[
85,
87
],
[
89
],
[
91
],
[
93
],
[
95
]
] |
24,064 | static int nfs_file_create(const char *url, QemuOpts *opts, Error **errp)
{
int ret = 0;
int64_t total_size = 0;
NFSClient *client = g_new0(NFSClient, 1);
QDict *options = NULL;
client->aio_context = qemu_get_aio_context();
/* Read out options */
total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
BDRV_SECTOR_SIZE);
options = qdict_new();
ret = nfs_parse_uri(url, options, errp);
if (ret < 0) {
goto out;
}
ret = nfs_client_open(client, options, O_CREAT, errp, 0);
if (ret < 0) {
goto out;
}
ret = nfs_ftruncate(client->context, client->fh, total_size);
nfs_client_close(client);
out:
g_free(client);
return ret;
} | true | qemu | 07555ba6f303d4be8af538c3a66cc46ccb2e5751 | static int nfs_file_create(const char *url, QemuOpts *opts, Error **errp)
{
int ret = 0;
int64_t total_size = 0;
NFSClient *client = g_new0(NFSClient, 1);
QDict *options = NULL;
client->aio_context = qemu_get_aio_context();
total_size = ROUND_UP(qemu_opt_get_size_del(opts, BLOCK_OPT_SIZE, 0),
BDRV_SECTOR_SIZE);
options = qdict_new();
ret = nfs_parse_uri(url, options, errp);
if (ret < 0) {
goto out;
}
ret = nfs_client_open(client, options, O_CREAT, errp, 0);
if (ret < 0) {
goto out;
}
ret = nfs_ftruncate(client->context, client->fh, total_size);
nfs_client_close(client);
out:
g_free(client);
return ret;
} | {
"code": [],
"line_no": []
} | static int FUNC_0(const char *VAR_0, QemuOpts *VAR_1, Error **VAR_2)
{
int VAR_3 = 0;
int64_t total_size = 0;
NFSClient *client = g_new0(NFSClient, 1);
QDict *options = NULL;
client->aio_context = qemu_get_aio_context();
total_size = ROUND_UP(qemu_opt_get_size_del(VAR_1, BLOCK_OPT_SIZE, 0),
BDRV_SECTOR_SIZE);
options = qdict_new();
VAR_3 = nfs_parse_uri(VAR_0, options, VAR_2);
if (VAR_3 < 0) {
goto out;
}
VAR_3 = nfs_client_open(client, options, O_CREAT, VAR_2, 0);
if (VAR_3 < 0) {
goto out;
}
VAR_3 = nfs_ftruncate(client->context, client->fh, total_size);
nfs_client_close(client);
out:
g_free(client);
return VAR_3;
} | [
"static int FUNC_0(const char *VAR_0, QemuOpts *VAR_1, Error **VAR_2)\n{",
"int VAR_3 = 0;",
"int64_t total_size = 0;",
"NFSClient *client = g_new0(NFSClient, 1);",
"QDict *options = NULL;",
"client->aio_context = qemu_get_aio_context();",
"total_size = ROUND_UP(qemu_opt_get_size_del(VAR_1, BLOCK_OPT_SIZE, 0),\nBDRV_SECTOR_SIZE);",
"options = qdict_new();",
"VAR_3 = nfs_parse_uri(VAR_0, options, VAR_2);",
"if (VAR_3 < 0) {",
"goto out;",
"}",
"VAR_3 = nfs_client_open(client, options, O_CREAT, VAR_2, 0);",
"if (VAR_3 < 0) {",
"goto out;",
"}",
"VAR_3 = nfs_ftruncate(client->context, client->fh, total_size);",
"nfs_client_close(client);",
"out:\ng_free(client);",
"return VAR_3;",
"}"
] | [
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
],
[
21,
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51,
54
],
[
56
],
[
58
]
] |
24,065 | int setenv(const char *name, const char *value, int overwrite)
{
int result = 0;
if (overwrite || !getenv(name)) {
size_t length = strlen(name) + strlen(value) + 2;
char *string = g_malloc(length);
snprintf(string, length, "%s=%s", name, value);
result = putenv(string);
}
return result;
} | true | qemu | 91a9ecefb6d7f066c6eecc09f7231ce7969d1817 | int setenv(const char *name, const char *value, int overwrite)
{
int result = 0;
if (overwrite || !getenv(name)) {
size_t length = strlen(name) + strlen(value) + 2;
char *string = g_malloc(length);
snprintf(string, length, "%s=%s", name, value);
result = putenv(string);
}
return result;
} | {
"code": [],
"line_no": []
} | int FUNC_0(const char *VAR_0, const char *VAR_1, int VAR_2)
{
int VAR_3 = 0;
if (VAR_2 || !getenv(VAR_0)) {
size_t length = strlen(VAR_0) + strlen(VAR_1) + 2;
char *VAR_4 = g_malloc(length);
snprintf(VAR_4, length, "%s=%s", VAR_0, VAR_1);
VAR_3 = putenv(VAR_4);
}
return VAR_3;
} | [
"int FUNC_0(const char *VAR_0, const char *VAR_1, int VAR_2)\n{",
"int VAR_3 = 0;",
"if (VAR_2 || !getenv(VAR_0)) {",
"size_t length = strlen(VAR_0) + strlen(VAR_1) + 2;",
"char *VAR_4 = g_malloc(length);",
"snprintf(VAR_4, length, \"%s=%s\", VAR_0, VAR_1);",
"VAR_3 = putenv(VAR_4);",
"}",
"return VAR_3;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
2
],
[
3
],
[
4
],
[
5
],
[
6
],
[
7
],
[
8
],
[
9
],
[
10
],
[
11
]
] |
24,067 | static void clone_tables(H264Context *dst, H264Context *src){
dst->intra4x4_pred_mode = src->intra4x4_pred_mode;
dst->non_zero_count = src->non_zero_count;
dst->slice_table = src->slice_table;
dst->cbp_table = src->cbp_table;
dst->mb2b_xy = src->mb2b_xy;
dst->mb2b8_xy = src->mb2b8_xy;
dst->chroma_pred_mode_table = src->chroma_pred_mode_table;
dst->mvd_table[0] = src->mvd_table[0];
dst->mvd_table[1] = src->mvd_table[1];
dst->direct_table = src->direct_table;
if(!dst->dequant4_coeff[0])
init_dequant_tables(dst);
dst->s.obmc_scratchpad = NULL;
ff_h264_pred_init(&dst->hpc, src->s.codec_id);
dst->dequant_coeff_pps= -1;
}
| true | FFmpeg | 50c21814b9de5635cf01e2d1ea091a9a272a4d67 | static void clone_tables(H264Context *dst, H264Context *src){
dst->intra4x4_pred_mode = src->intra4x4_pred_mode;
dst->non_zero_count = src->non_zero_count;
dst->slice_table = src->slice_table;
dst->cbp_table = src->cbp_table;
dst->mb2b_xy = src->mb2b_xy;
dst->mb2b8_xy = src->mb2b8_xy;
dst->chroma_pred_mode_table = src->chroma_pred_mode_table;
dst->mvd_table[0] = src->mvd_table[0];
dst->mvd_table[1] = src->mvd_table[1];
dst->direct_table = src->direct_table;
if(!dst->dequant4_coeff[0])
init_dequant_tables(dst);
dst->s.obmc_scratchpad = NULL;
ff_h264_pred_init(&dst->hpc, src->s.codec_id);
dst->dequant_coeff_pps= -1;
}
| {
"code": [
" if(!dst->dequant4_coeff[0])",
" init_dequant_tables(dst);",
" dst->dequant_coeff_pps= -1;"
],
"line_no": [
25,
27,
33
]
} | static void FUNC_0(H264Context *VAR_0, H264Context *VAR_1){
VAR_0->intra4x4_pred_mode = VAR_1->intra4x4_pred_mode;
VAR_0->non_zero_count = VAR_1->non_zero_count;
VAR_0->slice_table = VAR_1->slice_table;
VAR_0->cbp_table = VAR_1->cbp_table;
VAR_0->mb2b_xy = VAR_1->mb2b_xy;
VAR_0->mb2b8_xy = VAR_1->mb2b8_xy;
VAR_0->chroma_pred_mode_table = VAR_1->chroma_pred_mode_table;
VAR_0->mvd_table[0] = VAR_1->mvd_table[0];
VAR_0->mvd_table[1] = VAR_1->mvd_table[1];
VAR_0->direct_table = VAR_1->direct_table;
if(!VAR_0->dequant4_coeff[0])
init_dequant_tables(VAR_0);
VAR_0->s.obmc_scratchpad = NULL;
ff_h264_pred_init(&VAR_0->hpc, VAR_1->s.codec_id);
VAR_0->dequant_coeff_pps= -1;
}
| [
"static void FUNC_0(H264Context *VAR_0, H264Context *VAR_1){",
"VAR_0->intra4x4_pred_mode = VAR_1->intra4x4_pred_mode;",
"VAR_0->non_zero_count = VAR_1->non_zero_count;",
"VAR_0->slice_table = VAR_1->slice_table;",
"VAR_0->cbp_table = VAR_1->cbp_table;",
"VAR_0->mb2b_xy = VAR_1->mb2b_xy;",
"VAR_0->mb2b8_xy = VAR_1->mb2b8_xy;",
"VAR_0->chroma_pred_mode_table = VAR_1->chroma_pred_mode_table;",
"VAR_0->mvd_table[0] = VAR_1->mvd_table[0];",
"VAR_0->mvd_table[1] = VAR_1->mvd_table[1];",
"VAR_0->direct_table = VAR_1->direct_table;",
"if(!VAR_0->dequant4_coeff[0])\ninit_dequant_tables(VAR_0);",
"VAR_0->s.obmc_scratchpad = NULL;",
"ff_h264_pred_init(&VAR_0->hpc, VAR_1->s.codec_id);",
"VAR_0->dequant_coeff_pps= -1;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
1,
0
] | [
[
1
],
[
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25,
27
],
[
29
],
[
31
],
[
33
],
[
35
]
] |
24,068 | static void adb_kbd_reset(DeviceState *dev)
{
ADBDevice *d = ADB_DEVICE(dev);
KBDState *s = ADB_KEYBOARD(dev);
d->handler = 1;
d->devaddr = ADB_DEVID_KEYBOARD;
memset(s->data, 0, sizeof(s->data));
s->rptr = 0;
s->wptr = 0;
s->count = 0;
}
| true | qemu | 77cb0f5aafc8e6d0c6d3c339f381c9b7921648e0 | static void adb_kbd_reset(DeviceState *dev)
{
ADBDevice *d = ADB_DEVICE(dev);
KBDState *s = ADB_KEYBOARD(dev);
d->handler = 1;
d->devaddr = ADB_DEVID_KEYBOARD;
memset(s->data, 0, sizeof(s->data));
s->rptr = 0;
s->wptr = 0;
s->count = 0;
}
| {
"code": [
"static void adb_kbd_reset(DeviceState *dev)",
" ADBDevice *d = ADB_DEVICE(dev);",
" KBDState *s = ADB_KEYBOARD(dev);",
" d->handler = 1;",
" d->devaddr = ADB_DEVID_KEYBOARD;",
" memset(s->data, 0, sizeof(s->data));",
" s->rptr = 0;",
" s->wptr = 0;",
" s->count = 0;",
" d->devaddr = ADB_DEVID_KEYBOARD;",
" ADBDevice *d = ADB_DEVICE(dev);"
],
"line_no": [
1,
5,
7,
11,
13,
15,
17,
19,
21,
13,
5
]
} | static void FUNC_0(DeviceState *VAR_0)
{
ADBDevice *d = ADB_DEVICE(VAR_0);
KBDState *s = ADB_KEYBOARD(VAR_0);
d->handler = 1;
d->devaddr = ADB_DEVID_KEYBOARD;
memset(s->data, 0, sizeof(s->data));
s->rptr = 0;
s->wptr = 0;
s->count = 0;
}
| [
"static void FUNC_0(DeviceState *VAR_0)\n{",
"ADBDevice *d = ADB_DEVICE(VAR_0);",
"KBDState *s = ADB_KEYBOARD(VAR_0);",
"d->handler = 1;",
"d->devaddr = ADB_DEVID_KEYBOARD;",
"memset(s->data, 0, sizeof(s->data));",
"s->rptr = 0;",
"s->wptr = 0;",
"s->count = 0;",
"}"
] | [
1,
1,
1,
1,
1,
1,
1,
1,
1,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
]
] |
24,071 | static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al,
const uint8_t *mb_bitmask, const AVFrame *reference){
int i, mb_x, mb_y;
uint8_t* data[MAX_COMPONENTS];
const uint8_t *reference_data[MAX_COMPONENTS];
int linesize[MAX_COMPONENTS];
GetBitContext mb_bitmask_gb;
if (mb_bitmask) {
init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width*s->mb_height);
if(s->flipped && s->avctx->flags & CODEC_FLAG_EMU_EDGE) {
av_log(s->avctx, AV_LOG_ERROR, "Can not flip image with CODEC_FLAG_EMU_EDGE set!\n");
s->flipped = 0;
for(i=0; i < nb_components; i++) {
int c = s->comp_index[i];
data[c] = s->picture_ptr->data[c];
reference_data[c] = reference ? reference->data[c] : NULL;
linesize[c]=s->linesize[c];
s->coefs_finished[c] |= 1;
if(s->flipped) {
//picture should be flipped upside-down for this codec
int offset = (linesize[c] * (s->v_scount[i] * (8 * s->mb_height -((s->height/s->v_max)&7)) - 1 ));
data[c] += offset;
reference_data[c] += offset;
linesize[c] *= -1;
for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
if (s->restart_interval && !s->restart_count)
s->restart_count = s->restart_interval;
for(i=0;i<nb_components;i++) {
uint8_t *ptr;
int n, h, v, x, y, c, j;
int block_offset;
n = s->nb_blocks[i];
c = s->comp_index[i];
h = s->h_scount[i];
v = s->v_scount[i];
x = 0;
y = 0;
for(j=0;j<n;j++) {
block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
(h * mb_x + x) * 8) >> s->avctx->lowres);
if(s->interlaced && s->bottom_field)
block_offset += linesize[c] >> 1;
ptr = data[c] + block_offset;
if(!s->progressive) {
if (copy_mb) {
mjpeg_copy_block(ptr, reference_data[c] + block_offset, linesize[c], s->avctx->lowres);
} else {
s->dsp.clear_block(s->block);
if(decode_block(s, s->block, i,
s->dc_index[i], s->ac_index[i],
s->quant_matrixes[ s->quant_index[c] ]) < 0) {
av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
s->dsp.idct_put(ptr, linesize[c], s->block);
} else {
int block_idx = s->block_stride[c] * (v * mb_y + y) + (h * mb_x + x);
DCTELEM *block = s->blocks[c][block_idx];
if(Ah)
block[0] += get_bits1(&s->gb) * s->quant_matrixes[ s->quant_index[c] ][0] << Al;
else if(decode_dc_progressive(s, block, i, s->dc_index[i], s->quant_matrixes[ s->quant_index[c] ], Al) < 0) {
av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
// av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x);
//av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s->bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8);
if (++x == h) {
x = 0;
y++;
if (s->restart_interval && !--s->restart_count) {
align_get_bits(&s->gb);
skip_bits(&s->gb, 16); /* skip RSTn */
for (i=0; i<nb_components; i++) /* reset dc */
s->last_dc[i] = 1024;
return 0;
| true | FFmpeg | 76cd98b445c5a1608e9a5974bef0b0be6b35f1ce | static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al,
const uint8_t *mb_bitmask, const AVFrame *reference){
int i, mb_x, mb_y;
uint8_t* data[MAX_COMPONENTS];
const uint8_t *reference_data[MAX_COMPONENTS];
int linesize[MAX_COMPONENTS];
GetBitContext mb_bitmask_gb;
if (mb_bitmask) {
init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width*s->mb_height);
if(s->flipped && s->avctx->flags & CODEC_FLAG_EMU_EDGE) {
av_log(s->avctx, AV_LOG_ERROR, "Can not flip image with CODEC_FLAG_EMU_EDGE set!\n");
s->flipped = 0;
for(i=0; i < nb_components; i++) {
int c = s->comp_index[i];
data[c] = s->picture_ptr->data[c];
reference_data[c] = reference ? reference->data[c] : NULL;
linesize[c]=s->linesize[c];
s->coefs_finished[c] |= 1;
if(s->flipped) {
int offset = (linesize[c] * (s->v_scount[i] * (8 * s->mb_height -((s->height/s->v_max)&7)) - 1 ));
data[c] += offset;
reference_data[c] += offset;
linesize[c] *= -1;
for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
if (s->restart_interval && !s->restart_count)
s->restart_count = s->restart_interval;
for(i=0;i<nb_components;i++) {
uint8_t *ptr;
int n, h, v, x, y, c, j;
int block_offset;
n = s->nb_blocks[i];
c = s->comp_index[i];
h = s->h_scount[i];
v = s->v_scount[i];
x = 0;
y = 0;
for(j=0;j<n;j++) {
block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
(h * mb_x + x) * 8) >> s->avctx->lowres);
if(s->interlaced && s->bottom_field)
block_offset += linesize[c] >> 1;
ptr = data[c] + block_offset;
if(!s->progressive) {
if (copy_mb) {
mjpeg_copy_block(ptr, reference_data[c] + block_offset, linesize[c], s->avctx->lowres);
} else {
s->dsp.clear_block(s->block);
if(decode_block(s, s->block, i,
s->dc_index[i], s->ac_index[i],
s->quant_matrixes[ s->quant_index[c] ]) < 0) {
av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
s->dsp.idct_put(ptr, linesize[c], s->block);
} else {
int block_idx = s->block_stride[c] * (v * mb_y + y) + (h * mb_x + x);
DCTELEM *block = s->blocks[c][block_idx];
if(Ah)
block[0] += get_bits1(&s->gb) * s->quant_matrixes[ s->quant_index[c] ][0] << Al;
else if(decode_dc_progressive(s, block, i, s->dc_index[i], s->quant_matrixes[ s->quant_index[c] ], Al) < 0) {
av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
if (++x == h) {
x = 0;
y++;
if (s->restart_interval && !--s->restart_count) {
align_get_bits(&s->gb);
skip_bits(&s->gb, 16);
for (i=0; i<nb_components; i++)
s->last_dc[i] = 1024;
return 0;
| {
"code": [],
"line_no": []
} | static int FUNC_0(MJpegDecodeContext *VAR_0, int VAR_1, int VAR_2, int VAR_3,
const uint8_t *VAR_4, const AVFrame *VAR_5){
int VAR_6, VAR_7, VAR_8;
uint8_t* data[MAX_COMPONENTS];
const uint8_t *VAR_9[MAX_COMPONENTS];
int VAR_10[MAX_COMPONENTS];
GetBitContext mb_bitmask_gb;
if (VAR_4) {
init_get_bits(&mb_bitmask_gb, VAR_4, VAR_0->mb_width*VAR_0->mb_height);
if(VAR_0->flipped && VAR_0->avctx->flags & CODEC_FLAG_EMU_EDGE) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "Can not flip image with CODEC_FLAG_EMU_EDGE set!\n");
VAR_0->flipped = 0;
for(VAR_6=0; VAR_6 < VAR_1; VAR_6++) {
int VAR_11 = VAR_0->comp_index[VAR_6];
data[VAR_11] = VAR_0->picture_ptr->data[VAR_11];
VAR_9[VAR_11] = VAR_5 ? VAR_5->data[VAR_11] : NULL;
VAR_10[VAR_11]=VAR_0->VAR_10[VAR_11];
VAR_0->coefs_finished[VAR_11] |= 1;
if(VAR_0->flipped) {
int VAR_12 = (VAR_10[VAR_11] * (VAR_0->v_scount[VAR_6] * (8 * VAR_0->mb_height -((VAR_0->height/VAR_0->v_max)&7)) - 1 ));
data[VAR_11] += VAR_12;
VAR_9[VAR_11] += VAR_12;
VAR_10[VAR_11] *= -1;
for(VAR_8 = 0; VAR_8 < VAR_0->mb_height; VAR_8++) {
for(VAR_7 = 0; VAR_7 < VAR_0->mb_width; VAR_7++) {
const int copy_mb = VAR_4 && !get_bits1(&mb_bitmask_gb);
if (VAR_0->restart_interval && !VAR_0->restart_count)
VAR_0->restart_count = VAR_0->restart_interval;
for(VAR_6=0;VAR_6<VAR_1;VAR_6++) {
uint8_t *ptr;
int n, h, v, x, y, VAR_11, j;
int block_offset;
n = VAR_0->nb_blocks[VAR_6];
VAR_11 = VAR_0->comp_index[VAR_6];
h = VAR_0->h_scount[VAR_6];
v = VAR_0->v_scount[VAR_6];
x = 0;
y = 0;
for(j=0;j<n;j++) {
block_offset = (((VAR_10[VAR_11] * (v * VAR_8 + y) * 8) +
(h * VAR_7 + x) * 8) >> VAR_0->avctx->lowres);
if(VAR_0->interlaced && VAR_0->bottom_field)
block_offset += VAR_10[VAR_11] >> 1;
ptr = data[VAR_11] + block_offset;
if(!VAR_0->progressive) {
if (copy_mb) {
mjpeg_copy_block(ptr, VAR_9[VAR_11] + block_offset, VAR_10[VAR_11], VAR_0->avctx->lowres);
} else {
VAR_0->dsp.clear_block(VAR_0->block);
if(decode_block(VAR_0, VAR_0->block, VAR_6,
VAR_0->dc_index[VAR_6], VAR_0->ac_index[VAR_6],
VAR_0->quant_matrixes[ VAR_0->quant_index[VAR_11] ]) < 0) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", VAR_8, VAR_7);
VAR_0->dsp.idct_put(ptr, VAR_10[VAR_11], VAR_0->block);
} else {
int block_idx = VAR_0->block_stride[VAR_11] * (v * VAR_8 + y) + (h * VAR_7 + x);
DCTELEM *block = VAR_0->blocks[VAR_11][block_idx];
if(VAR_2)
block[0] += get_bits1(&VAR_0->gb) * VAR_0->quant_matrixes[ VAR_0->quant_index[VAR_11] ][0] << VAR_3;
else if(decode_dc_progressive(VAR_0, block, VAR_6, VAR_0->dc_index[VAR_6], VAR_0->quant_matrixes[ VAR_0->quant_index[VAR_11] ], VAR_3) < 0) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", VAR_8, VAR_7);
if (++x == h) {
x = 0;
y++;
if (VAR_0->restart_interval && !--VAR_0->restart_count) {
align_get_bits(&VAR_0->gb);
skip_bits(&VAR_0->gb, 16);
for (VAR_6=0; VAR_6<VAR_1; VAR_6++)
VAR_0->last_dc[VAR_6] = 1024;
return 0;
| [
"static int FUNC_0(MJpegDecodeContext *VAR_0, int VAR_1, int VAR_2, int VAR_3,\nconst uint8_t *VAR_4, const AVFrame *VAR_5){",
"int VAR_6, VAR_7, VAR_8;",
"uint8_t* data[MAX_COMPONENTS];",
"const uint8_t *VAR_9[MAX_COMPONENTS];",
"int VAR_10[MAX_COMPONENTS];",
"GetBitContext mb_bitmask_gb;",
"if (VAR_4) {",
"init_get_bits(&mb_bitmask_gb, VAR_4, VAR_0->mb_width*VAR_0->mb_height);",
"if(VAR_0->flipped && VAR_0->avctx->flags & CODEC_FLAG_EMU_EDGE) {",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"Can not flip image with CODEC_FLAG_EMU_EDGE set!\\n\");",
"VAR_0->flipped = 0;",
"for(VAR_6=0; VAR_6 < VAR_1; VAR_6++) {",
"int VAR_11 = VAR_0->comp_index[VAR_6];",
"data[VAR_11] = VAR_0->picture_ptr->data[VAR_11];",
"VAR_9[VAR_11] = VAR_5 ? VAR_5->data[VAR_11] : NULL;",
"VAR_10[VAR_11]=VAR_0->VAR_10[VAR_11];",
"VAR_0->coefs_finished[VAR_11] |= 1;",
"if(VAR_0->flipped) {",
"int VAR_12 = (VAR_10[VAR_11] * (VAR_0->v_scount[VAR_6] * (8 * VAR_0->mb_height -((VAR_0->height/VAR_0->v_max)&7)) - 1 ));",
"data[VAR_11] += VAR_12;",
"VAR_9[VAR_11] += VAR_12;",
"VAR_10[VAR_11] *= -1;",
"for(VAR_8 = 0; VAR_8 < VAR_0->mb_height; VAR_8++) {",
"for(VAR_7 = 0; VAR_7 < VAR_0->mb_width; VAR_7++) {",
"const int copy_mb = VAR_4 && !get_bits1(&mb_bitmask_gb);",
"if (VAR_0->restart_interval && !VAR_0->restart_count)\nVAR_0->restart_count = VAR_0->restart_interval;",
"for(VAR_6=0;VAR_6<VAR_1;VAR_6++) {",
"uint8_t *ptr;",
"int n, h, v, x, y, VAR_11, j;",
"int block_offset;",
"n = VAR_0->nb_blocks[VAR_6];",
"VAR_11 = VAR_0->comp_index[VAR_6];",
"h = VAR_0->h_scount[VAR_6];",
"v = VAR_0->v_scount[VAR_6];",
"x = 0;",
"y = 0;",
"for(j=0;j<n;j++) {",
"block_offset = (((VAR_10[VAR_11] * (v * VAR_8 + y) * 8) +\n(h * VAR_7 + x) * 8) >> VAR_0->avctx->lowres);",
"if(VAR_0->interlaced && VAR_0->bottom_field)\nblock_offset += VAR_10[VAR_11] >> 1;",
"ptr = data[VAR_11] + block_offset;",
"if(!VAR_0->progressive) {",
"if (copy_mb) {",
"mjpeg_copy_block(ptr, VAR_9[VAR_11] + block_offset, VAR_10[VAR_11], VAR_0->avctx->lowres);",
"} else {",
"VAR_0->dsp.clear_block(VAR_0->block);",
"if(decode_block(VAR_0, VAR_0->block, VAR_6,\nVAR_0->dc_index[VAR_6], VAR_0->ac_index[VAR_6],\nVAR_0->quant_matrixes[ VAR_0->quant_index[VAR_11] ]) < 0) {",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"error y=%d x=%d\\n\", VAR_8, VAR_7);",
"VAR_0->dsp.idct_put(ptr, VAR_10[VAR_11], VAR_0->block);",
"} else {",
"int block_idx = VAR_0->block_stride[VAR_11] * (v * VAR_8 + y) + (h * VAR_7 + x);",
"DCTELEM *block = VAR_0->blocks[VAR_11][block_idx];",
"if(VAR_2)\nblock[0] += get_bits1(&VAR_0->gb) * VAR_0->quant_matrixes[ VAR_0->quant_index[VAR_11] ][0] << VAR_3;",
"else if(decode_dc_progressive(VAR_0, block, VAR_6, VAR_0->dc_index[VAR_6], VAR_0->quant_matrixes[ VAR_0->quant_index[VAR_11] ], VAR_3) < 0) {",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"error y=%d x=%d\\n\", VAR_8, VAR_7);",
"if (++x == h) {",
"x = 0;",
"y++;",
"if (VAR_0->restart_interval && !--VAR_0->restart_count) {",
"align_get_bits(&VAR_0->gb);",
"skip_bits(&VAR_0->gb, 16);",
"for (VAR_6=0; VAR_6<VAR_1; VAR_6++)",
"VAR_0->last_dc[VAR_6] = 1024;",
"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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
24
],
[
26
],
[
28
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
47
],
[
49
],
[
51
],
[
53
],
[
59
],
[
61
],
[
63
],
[
67,
69
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99,
101
],
[
105,
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121,
123,
125
],
[
127
],
[
131
],
[
134
],
[
136
],
[
138
],
[
140,
142
],
[
144
],
[
146
],
[
155
],
[
157
],
[
159
],
[
166
],
[
168
],
[
170
],
[
172
],
[
174
],
[
179
]
] |
24,073 | static int flv_data_packet(AVFormatContext *s, AVPacket *pkt,
int64_t dts, int64_t next)
{
AVIOContext *pb = s->pb;
AVStream *st = NULL;
char buf[20];
int ret = AVERROR_INVALIDDATA;
int i, length = -1;
switch (avio_r8(pb)) {
case AMF_DATA_TYPE_MIXEDARRAY:
avio_seek(pb, 4, SEEK_CUR);
case AMF_DATA_TYPE_OBJECT:
break;
default:
goto skip;
}
while ((ret = amf_get_string(pb, buf, sizeof(buf))) > 0) {
AMFDataType type = avio_r8(pb);
if (type == AMF_DATA_TYPE_STRING && !strcmp(buf, "text")) {
length = avio_rb16(pb);
ret = av_get_packet(pb, pkt, length);
if (ret < 0)
goto skip;
else
break;
} else {
if ((ret = amf_skip_tag(pb, type)) < 0)
goto skip;
}
}
if (length < 0) {
ret = AVERROR_INVALIDDATA;
goto skip;
}
for (i = 0; i < s->nb_streams; i++) {
st = s->streams[i];
if (st->codec->codec_type == AVMEDIA_TYPE_DATA)
break;
}
if (i == s->nb_streams) {
st = create_stream(s, AVMEDIA_TYPE_DATA);
if (!st)
return AVERROR_INVALIDDATA;
st->codec->codec_id = AV_CODEC_ID_TEXT;
}
pkt->dts = dts;
pkt->pts = dts;
pkt->size = ret;
pkt->stream_index = st->index;
pkt->flags |= AV_PKT_FLAG_KEY;
skip:
avio_seek(s->pb, next + 4, SEEK_SET);
return ret;
}
| false | FFmpeg | 629b2ed0ac77d7c4bf1aeac5e70cafee5fa0fcae | static int flv_data_packet(AVFormatContext *s, AVPacket *pkt,
int64_t dts, int64_t next)
{
AVIOContext *pb = s->pb;
AVStream *st = NULL;
char buf[20];
int ret = AVERROR_INVALIDDATA;
int i, length = -1;
switch (avio_r8(pb)) {
case AMF_DATA_TYPE_MIXEDARRAY:
avio_seek(pb, 4, SEEK_CUR);
case AMF_DATA_TYPE_OBJECT:
break;
default:
goto skip;
}
while ((ret = amf_get_string(pb, buf, sizeof(buf))) > 0) {
AMFDataType type = avio_r8(pb);
if (type == AMF_DATA_TYPE_STRING && !strcmp(buf, "text")) {
length = avio_rb16(pb);
ret = av_get_packet(pb, pkt, length);
if (ret < 0)
goto skip;
else
break;
} else {
if ((ret = amf_skip_tag(pb, type)) < 0)
goto skip;
}
}
if (length < 0) {
ret = AVERROR_INVALIDDATA;
goto skip;
}
for (i = 0; i < s->nb_streams; i++) {
st = s->streams[i];
if (st->codec->codec_type == AVMEDIA_TYPE_DATA)
break;
}
if (i == s->nb_streams) {
st = create_stream(s, AVMEDIA_TYPE_DATA);
if (!st)
return AVERROR_INVALIDDATA;
st->codec->codec_id = AV_CODEC_ID_TEXT;
}
pkt->dts = dts;
pkt->pts = dts;
pkt->size = ret;
pkt->stream_index = st->index;
pkt->flags |= AV_PKT_FLAG_KEY;
skip:
avio_seek(s->pb, next + 4, SEEK_SET);
return ret;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1,
int64_t VAR_2, int64_t VAR_3)
{
AVIOContext *pb = VAR_0->pb;
AVStream *st = NULL;
char VAR_4[20];
int VAR_5 = AVERROR_INVALIDDATA;
int VAR_6, VAR_7 = -1;
switch (avio_r8(pb)) {
case AMF_DATA_TYPE_MIXEDARRAY:
avio_seek(pb, 4, SEEK_CUR);
case AMF_DATA_TYPE_OBJECT:
break;
default:
goto skip;
}
while ((VAR_5 = amf_get_string(pb, VAR_4, sizeof(VAR_4))) > 0) {
AMFDataType type = avio_r8(pb);
if (type == AMF_DATA_TYPE_STRING && !strcmp(VAR_4, "text")) {
VAR_7 = avio_rb16(pb);
VAR_5 = av_get_packet(pb, VAR_1, VAR_7);
if (VAR_5 < 0)
goto skip;
else
break;
} else {
if ((VAR_5 = amf_skip_tag(pb, type)) < 0)
goto skip;
}
}
if (VAR_7 < 0) {
VAR_5 = AVERROR_INVALIDDATA;
goto skip;
}
for (VAR_6 = 0; VAR_6 < VAR_0->nb_streams; VAR_6++) {
st = VAR_0->streams[VAR_6];
if (st->codec->codec_type == AVMEDIA_TYPE_DATA)
break;
}
if (VAR_6 == VAR_0->nb_streams) {
st = create_stream(VAR_0, AVMEDIA_TYPE_DATA);
if (!st)
return AVERROR_INVALIDDATA;
st->codec->codec_id = AV_CODEC_ID_TEXT;
}
VAR_1->VAR_2 = VAR_2;
VAR_1->pts = VAR_2;
VAR_1->size = VAR_5;
VAR_1->stream_index = st->index;
VAR_1->flags |= AV_PKT_FLAG_KEY;
skip:
avio_seek(VAR_0->pb, VAR_3 + 4, SEEK_SET);
return VAR_5;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1,\nint64_t VAR_2, int64_t VAR_3)\n{",
"AVIOContext *pb = VAR_0->pb;",
"AVStream *st = NULL;",
"char VAR_4[20];",
"int VAR_5 = AVERROR_INVALIDDATA;",
"int VAR_6, VAR_7 = -1;",
"switch (avio_r8(pb)) {",
"case AMF_DATA_TYPE_MIXEDARRAY:\navio_seek(pb, 4, SEEK_CUR);",
"case AMF_DATA_TYPE_OBJECT:\nbreak;",
"default:\ngoto skip;",
"}",
"while ((VAR_5 = amf_get_string(pb, VAR_4, sizeof(VAR_4))) > 0) {",
"AMFDataType type = avio_r8(pb);",
"if (type == AMF_DATA_TYPE_STRING && !strcmp(VAR_4, \"text\")) {",
"VAR_7 = avio_rb16(pb);",
"VAR_5 = av_get_packet(pb, VAR_1, VAR_7);",
"if (VAR_5 < 0)\ngoto skip;",
"else\nbreak;",
"} else {",
"if ((VAR_5 = amf_skip_tag(pb, type)) < 0)\ngoto skip;",
"}",
"}",
"if (VAR_7 < 0) {",
"VAR_5 = AVERROR_INVALIDDATA;",
"goto skip;",
"}",
"for (VAR_6 = 0; VAR_6 < VAR_0->nb_streams; VAR_6++) {",
"st = VAR_0->streams[VAR_6];",
"if (st->codec->codec_type == AVMEDIA_TYPE_DATA)\nbreak;",
"}",
"if (VAR_6 == VAR_0->nb_streams) {",
"st = create_stream(VAR_0, AVMEDIA_TYPE_DATA);",
"if (!st)\nreturn AVERROR_INVALIDDATA;",
"st->codec->codec_id = AV_CODEC_ID_TEXT;",
"}",
"VAR_1->VAR_2 = VAR_2;",
"VAR_1->pts = VAR_2;",
"VAR_1->size = VAR_5;",
"VAR_1->stream_index = st->index;",
"VAR_1->flags |= AV_PKT_FLAG_KEY;",
"skip:\navio_seek(VAR_0->pb, VAR_3 + 4, SEEK_SET);",
"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
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21,
23
],
[
25,
27
],
[
29,
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47,
49
],
[
51,
53
],
[
55
],
[
57,
59
],
[
61
],
[
63
],
[
67
],
[
69
],
[
71
],
[
73
],
[
77
],
[
79
],
[
81,
83
],
[
85
],
[
89
],
[
91
],
[
93,
95
],
[
97
],
[
99
],
[
103
],
[
105
],
[
107
],
[
111
],
[
113
],
[
117,
119
],
[
123
],
[
125
]
] |
24,074 | void ff_h264_write_back_intra_pred_mode(H264Context *h){
int8_t *mode= h->intra4x4_pred_mode + h->mb2br_xy[h->mb_xy];
AV_COPY32(mode, h->intra4x4_pred_mode_cache + 4 + 8*4);
mode[4]= h->intra4x4_pred_mode_cache[7+8*3];
mode[5]= h->intra4x4_pred_mode_cache[7+8*2];
mode[6]= h->intra4x4_pred_mode_cache[7+8*1];
}
| false | FFmpeg | 3b7ebeb4d52a25c7e1038ae90c6c19b0d6f11877 | void ff_h264_write_back_intra_pred_mode(H264Context *h){
int8_t *mode= h->intra4x4_pred_mode + h->mb2br_xy[h->mb_xy];
AV_COPY32(mode, h->intra4x4_pred_mode_cache + 4 + 8*4);
mode[4]= h->intra4x4_pred_mode_cache[7+8*3];
mode[5]= h->intra4x4_pred_mode_cache[7+8*2];
mode[6]= h->intra4x4_pred_mode_cache[7+8*1];
}
| {
"code": [],
"line_no": []
} | void FUNC_0(H264Context *VAR_0){
int8_t *mode= VAR_0->intra4x4_pred_mode + VAR_0->mb2br_xy[VAR_0->mb_xy];
AV_COPY32(mode, VAR_0->intra4x4_pred_mode_cache + 4 + 8*4);
mode[4]= VAR_0->intra4x4_pred_mode_cache[7+8*3];
mode[5]= VAR_0->intra4x4_pred_mode_cache[7+8*2];
mode[6]= VAR_0->intra4x4_pred_mode_cache[7+8*1];
}
| [
"void FUNC_0(H264Context *VAR_0){",
"int8_t *mode= VAR_0->intra4x4_pred_mode + VAR_0->mb2br_xy[VAR_0->mb_xy];",
"AV_COPY32(mode, VAR_0->intra4x4_pred_mode_cache + 4 + 8*4);",
"mode[4]= VAR_0->intra4x4_pred_mode_cache[7+8*3];",
"mode[5]= VAR_0->intra4x4_pred_mode_cache[7+8*2];",
"mode[6]= VAR_0->intra4x4_pred_mode_cache[7+8*1];",
"}"
] | [
0,
0,
0,
0,
0,
0,
0
] | [
[
1
],
[
3
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
]
] |
24,076 | static int noise(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size, int keyframe){
unsigned int *state= bsfc->priv_data;
int amount= args ? atoi(args) : (*state % 10001+1);
int i;
*poutbuf= av_malloc(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
memcpy(*poutbuf, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
for(i=0; i<buf_size; i++){
(*state) += (*poutbuf)[i] + 1;
if(*state % amount == 0)
(*poutbuf)[i] = *state;
}
return 1;
} | true | FFmpeg | 93ef29b6f47eda7d73eb9e71628f1f1abb64266d | static int noise(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args,
uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size, int keyframe){
unsigned int *state= bsfc->priv_data;
int amount= args ? atoi(args) : (*state % 10001+1);
int i;
*poutbuf= av_malloc(buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
memcpy(*poutbuf, buf, buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
for(i=0; i<buf_size; i++){
(*state) += (*poutbuf)[i] + 1;
if(*state % amount == 0)
(*poutbuf)[i] = *state;
}
return 1;
} | {
"code": [],
"line_no": []
} | static int FUNC_0(AVBitStreamFilterContext *VAR_0, AVCodecContext *VAR_1, const char *VAR_2,
uint8_t **VAR_3, int *VAR_4,
const uint8_t *VAR_5, int VAR_6, int VAR_7){
unsigned int *VAR_8= VAR_0->priv_data;
int VAR_9= VAR_2 ? atoi(VAR_2) : (*VAR_8 % 10001+1);
int VAR_10;
*VAR_3= av_malloc(VAR_6 + FF_INPUT_BUFFER_PADDING_SIZE);
memcpy(*VAR_3, VAR_5, VAR_6 + FF_INPUT_BUFFER_PADDING_SIZE);
for(VAR_10=0; VAR_10<VAR_6; VAR_10++){
(*VAR_8) += (*VAR_3)[VAR_10] + 1;
if(*VAR_8 % VAR_9 == 0)
(*VAR_3)[VAR_10] = *VAR_8;
}
return 1;
} | [
"static int FUNC_0(AVBitStreamFilterContext *VAR_0, AVCodecContext *VAR_1, const char *VAR_2,\nuint8_t **VAR_3, int *VAR_4,\nconst uint8_t *VAR_5, int VAR_6, int VAR_7){",
"unsigned int *VAR_8= VAR_0->priv_data;",
"int VAR_9= VAR_2 ? atoi(VAR_2) : (*VAR_8 % 10001+1);",
"int VAR_10;",
"*VAR_3= av_malloc(VAR_6 + FF_INPUT_BUFFER_PADDING_SIZE);",
"memcpy(*VAR_3, VAR_5, VAR_6 + FF_INPUT_BUFFER_PADDING_SIZE);",
"for(VAR_10=0; VAR_10<VAR_6; VAR_10++){",
"(*VAR_8) += (*VAR_3)[VAR_10] + 1;",
"if(*VAR_8 % VAR_9 == 0)\n(*VAR_3)[VAR_10] = *VAR_8;",
"}",
"return 1;",
"}"
] | [
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
]
] |
24,077 | static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al,
const uint8_t *mb_bitmask, const AVFrame *reference){
int i, mb_x, mb_y;
uint8_t* data[MAX_COMPONENTS];
const uint8_t *reference_data[MAX_COMPONENTS];
int linesize[MAX_COMPONENTS];
GetBitContext mb_bitmask_gb;
if (mb_bitmask) {
init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width*s->mb_height);
}
if(s->flipped && s->avctx->flags & CODEC_FLAG_EMU_EDGE) {
av_log(s->avctx, AV_LOG_ERROR, "Can not flip image with CODEC_FLAG_EMU_EDGE set!\n");
s->flipped = 0;
}
for(i=0; i < nb_components; i++) {
int c = s->comp_index[i];
data[c] = s->picture_ptr->data[c];
reference_data[c] = reference ? reference->data[c] : NULL;
linesize[c]=s->linesize[c];
s->coefs_finished[c] |= 1;
if(s->flipped) {
//picture should be flipped upside-down for this codec
int offset = (linesize[c] * (s->v_scount[i] * (8 * s->mb_height -((s->height/s->v_max)&7)) - 1 ));
data[c] += offset;
reference_data[c] += offset;
linesize[c] *= -1;
}
}
for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
if (s->restart_interval && !s->restart_count)
s->restart_count = s->restart_interval;
if(get_bits_count(&s->gb)>s->gb.size_in_bits){
av_log(s->avctx, AV_LOG_ERROR, "overread %d\n", get_bits_count(&s->gb) - s->gb.size_in_bits);
return -1;
}
for(i=0;i<nb_components;i++) {
uint8_t *ptr;
int n, h, v, x, y, c, j;
int block_offset;
n = s->nb_blocks[i];
c = s->comp_index[i];
h = s->h_scount[i];
v = s->v_scount[i];
x = 0;
y = 0;
for(j=0;j<n;j++) {
block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
(h * mb_x + x) * 8) >> s->avctx->lowres);
if(s->interlaced && s->bottom_field)
block_offset += linesize[c] >> 1;
ptr = data[c] + block_offset;
if(!s->progressive) {
if (copy_mb) {
mjpeg_copy_block(ptr, reference_data[c] + block_offset, linesize[c], s->avctx->lowres);
} else {
s->dsp.clear_block(s->block);
if(decode_block(s, s->block, i,
s->dc_index[i], s->ac_index[i],
s->quant_matrixes[ s->quant_index[c] ]) < 0) {
av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
return -1;
}
s->dsp.idct_put(ptr, linesize[c], s->block);
}
} else {
int block_idx = s->block_stride[c] * (v * mb_y + y) + (h * mb_x + x);
DCTELEM *block = s->blocks[c][block_idx];
if(Ah)
block[0] += get_bits1(&s->gb) * s->quant_matrixes[ s->quant_index[c] ][0] << Al;
else if(decode_dc_progressive(s, block, i, s->dc_index[i], s->quant_matrixes[ s->quant_index[c] ], Al) < 0) {
av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
return -1;
}
}
// av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x);
//av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s->bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8);
if (++x == h) {
x = 0;
y++;
}
}
}
if (s->restart_interval && show_bits(&s->gb, 8) == 0xFF){ /* skip RSTn */
--s->restart_count;
align_get_bits(&s->gb);
while(show_bits(&s->gb, 8) == 0xFF)
skip_bits(&s->gb, 8);
skip_bits(&s->gb, 8);
for (i=0; i<nb_components; i++) /* reset dc */
s->last_dc[i] = 1024;
}
}
}
return 0;
}
| false | FFmpeg | e268a352af893e47bd3ea2aed90761cb0b4feca7 | static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al,
const uint8_t *mb_bitmask, const AVFrame *reference){
int i, mb_x, mb_y;
uint8_t* data[MAX_COMPONENTS];
const uint8_t *reference_data[MAX_COMPONENTS];
int linesize[MAX_COMPONENTS];
GetBitContext mb_bitmask_gb;
if (mb_bitmask) {
init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width*s->mb_height);
}
if(s->flipped && s->avctx->flags & CODEC_FLAG_EMU_EDGE) {
av_log(s->avctx, AV_LOG_ERROR, "Can not flip image with CODEC_FLAG_EMU_EDGE set!\n");
s->flipped = 0;
}
for(i=0; i < nb_components; i++) {
int c = s->comp_index[i];
data[c] = s->picture_ptr->data[c];
reference_data[c] = reference ? reference->data[c] : NULL;
linesize[c]=s->linesize[c];
s->coefs_finished[c] |= 1;
if(s->flipped) {
int offset = (linesize[c] * (s->v_scount[i] * (8 * s->mb_height -((s->height/s->v_max)&7)) - 1 ));
data[c] += offset;
reference_data[c] += offset;
linesize[c] *= -1;
}
}
for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
if (s->restart_interval && !s->restart_count)
s->restart_count = s->restart_interval;
if(get_bits_count(&s->gb)>s->gb.size_in_bits){
av_log(s->avctx, AV_LOG_ERROR, "overread %d\n", get_bits_count(&s->gb) - s->gb.size_in_bits);
return -1;
}
for(i=0;i<nb_components;i++) {
uint8_t *ptr;
int n, h, v, x, y, c, j;
int block_offset;
n = s->nb_blocks[i];
c = s->comp_index[i];
h = s->h_scount[i];
v = s->v_scount[i];
x = 0;
y = 0;
for(j=0;j<n;j++) {
block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
(h * mb_x + x) * 8) >> s->avctx->lowres);
if(s->interlaced && s->bottom_field)
block_offset += linesize[c] >> 1;
ptr = data[c] + block_offset;
if(!s->progressive) {
if (copy_mb) {
mjpeg_copy_block(ptr, reference_data[c] + block_offset, linesize[c], s->avctx->lowres);
} else {
s->dsp.clear_block(s->block);
if(decode_block(s, s->block, i,
s->dc_index[i], s->ac_index[i],
s->quant_matrixes[ s->quant_index[c] ]) < 0) {
av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
return -1;
}
s->dsp.idct_put(ptr, linesize[c], s->block);
}
} else {
int block_idx = s->block_stride[c] * (v * mb_y + y) + (h * mb_x + x);
DCTELEM *block = s->blocks[c][block_idx];
if(Ah)
block[0] += get_bits1(&s->gb) * s->quant_matrixes[ s->quant_index[c] ][0] << Al;
else if(decode_dc_progressive(s, block, i, s->dc_index[i], s->quant_matrixes[ s->quant_index[c] ], Al) < 0) {
av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
return -1;
}
}
if (++x == h) {
x = 0;
y++;
}
}
}
if (s->restart_interval && show_bits(&s->gb, 8) == 0xFF){
--s->restart_count;
align_get_bits(&s->gb);
while(show_bits(&s->gb, 8) == 0xFF)
skip_bits(&s->gb, 8);
skip_bits(&s->gb, 8);
for (i=0; i<nb_components; i++)
s->last_dc[i] = 1024;
}
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(MJpegDecodeContext *VAR_0, int VAR_1, int VAR_2, int VAR_3,
const uint8_t *VAR_4, const AVFrame *VAR_5){
int VAR_6, VAR_7, VAR_8;
uint8_t* data[MAX_COMPONENTS];
const uint8_t *VAR_9[MAX_COMPONENTS];
int VAR_10[MAX_COMPONENTS];
GetBitContext mb_bitmask_gb;
if (VAR_4) {
init_get_bits(&mb_bitmask_gb, VAR_4, VAR_0->mb_width*VAR_0->mb_height);
}
if(VAR_0->flipped && VAR_0->avctx->flags & CODEC_FLAG_EMU_EDGE) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "Can not flip image with CODEC_FLAG_EMU_EDGE set!\n");
VAR_0->flipped = 0;
}
for(VAR_6=0; VAR_6 < VAR_1; VAR_6++) {
int VAR_11 = VAR_0->comp_index[VAR_6];
data[VAR_11] = VAR_0->picture_ptr->data[VAR_11];
VAR_9[VAR_11] = VAR_5 ? VAR_5->data[VAR_11] : NULL;
VAR_10[VAR_11]=VAR_0->VAR_10[VAR_11];
VAR_0->coefs_finished[VAR_11] |= 1;
if(VAR_0->flipped) {
int VAR_12 = (VAR_10[VAR_11] * (VAR_0->v_scount[VAR_6] * (8 * VAR_0->mb_height -((VAR_0->height/VAR_0->v_max)&7)) - 1 ));
data[VAR_11] += VAR_12;
VAR_9[VAR_11] += VAR_12;
VAR_10[VAR_11] *= -1;
}
}
for(VAR_8 = 0; VAR_8 < VAR_0->mb_height; VAR_8++) {
for(VAR_7 = 0; VAR_7 < VAR_0->mb_width; VAR_7++) {
const int copy_mb = VAR_4 && !get_bits1(&mb_bitmask_gb);
if (VAR_0->restart_interval && !VAR_0->restart_count)
VAR_0->restart_count = VAR_0->restart_interval;
if(get_bits_count(&VAR_0->gb)>VAR_0->gb.size_in_bits){
av_log(VAR_0->avctx, AV_LOG_ERROR, "overread %d\n", get_bits_count(&VAR_0->gb) - VAR_0->gb.size_in_bits);
return -1;
}
for(VAR_6=0;VAR_6<VAR_1;VAR_6++) {
uint8_t *ptr;
int n, h, v, x, y, VAR_11, j;
int block_offset;
n = VAR_0->nb_blocks[VAR_6];
VAR_11 = VAR_0->comp_index[VAR_6];
h = VAR_0->h_scount[VAR_6];
v = VAR_0->v_scount[VAR_6];
x = 0;
y = 0;
for(j=0;j<n;j++) {
block_offset = (((VAR_10[VAR_11] * (v * VAR_8 + y) * 8) +
(h * VAR_7 + x) * 8) >> VAR_0->avctx->lowres);
if(VAR_0->interlaced && VAR_0->bottom_field)
block_offset += VAR_10[VAR_11] >> 1;
ptr = data[VAR_11] + block_offset;
if(!VAR_0->progressive) {
if (copy_mb) {
mjpeg_copy_block(ptr, VAR_9[VAR_11] + block_offset, VAR_10[VAR_11], VAR_0->avctx->lowres);
} else {
VAR_0->dsp.clear_block(VAR_0->block);
if(decode_block(VAR_0, VAR_0->block, VAR_6,
VAR_0->dc_index[VAR_6], VAR_0->ac_index[VAR_6],
VAR_0->quant_matrixes[ VAR_0->quant_index[VAR_11] ]) < 0) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", VAR_8, VAR_7);
return -1;
}
VAR_0->dsp.idct_put(ptr, VAR_10[VAR_11], VAR_0->block);
}
} else {
int block_idx = VAR_0->block_stride[VAR_11] * (v * VAR_8 + y) + (h * VAR_7 + x);
DCTELEM *block = VAR_0->blocks[VAR_11][block_idx];
if(VAR_2)
block[0] += get_bits1(&VAR_0->gb) * VAR_0->quant_matrixes[ VAR_0->quant_index[VAR_11] ][0] << VAR_3;
else if(decode_dc_progressive(VAR_0, block, VAR_6, VAR_0->dc_index[VAR_6], VAR_0->quant_matrixes[ VAR_0->quant_index[VAR_11] ], VAR_3) < 0) {
av_log(VAR_0->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", VAR_8, VAR_7);
return -1;
}
}
if (++x == h) {
x = 0;
y++;
}
}
}
if (VAR_0->restart_interval && show_bits(&VAR_0->gb, 8) == 0xFF){
--VAR_0->restart_count;
align_get_bits(&VAR_0->gb);
while(show_bits(&VAR_0->gb, 8) == 0xFF)
skip_bits(&VAR_0->gb, 8);
skip_bits(&VAR_0->gb, 8);
for (VAR_6=0; VAR_6<VAR_1; VAR_6++)
VAR_0->last_dc[VAR_6] = 1024;
}
}
}
return 0;
}
| [
"static int FUNC_0(MJpegDecodeContext *VAR_0, int VAR_1, int VAR_2, int VAR_3,\nconst uint8_t *VAR_4, const AVFrame *VAR_5){",
"int VAR_6, VAR_7, VAR_8;",
"uint8_t* data[MAX_COMPONENTS];",
"const uint8_t *VAR_9[MAX_COMPONENTS];",
"int VAR_10[MAX_COMPONENTS];",
"GetBitContext mb_bitmask_gb;",
"if (VAR_4) {",
"init_get_bits(&mb_bitmask_gb, VAR_4, VAR_0->mb_width*VAR_0->mb_height);",
"}",
"if(VAR_0->flipped && VAR_0->avctx->flags & CODEC_FLAG_EMU_EDGE) {",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"Can not flip image with CODEC_FLAG_EMU_EDGE set!\\n\");",
"VAR_0->flipped = 0;",
"}",
"for(VAR_6=0; VAR_6 < VAR_1; VAR_6++) {",
"int VAR_11 = VAR_0->comp_index[VAR_6];",
"data[VAR_11] = VAR_0->picture_ptr->data[VAR_11];",
"VAR_9[VAR_11] = VAR_5 ? VAR_5->data[VAR_11] : NULL;",
"VAR_10[VAR_11]=VAR_0->VAR_10[VAR_11];",
"VAR_0->coefs_finished[VAR_11] |= 1;",
"if(VAR_0->flipped) {",
"int VAR_12 = (VAR_10[VAR_11] * (VAR_0->v_scount[VAR_6] * (8 * VAR_0->mb_height -((VAR_0->height/VAR_0->v_max)&7)) - 1 ));",
"data[VAR_11] += VAR_12;",
"VAR_9[VAR_11] += VAR_12;",
"VAR_10[VAR_11] *= -1;",
"}",
"}",
"for(VAR_8 = 0; VAR_8 < VAR_0->mb_height; VAR_8++) {",
"for(VAR_7 = 0; VAR_7 < VAR_0->mb_width; VAR_7++) {",
"const int copy_mb = VAR_4 && !get_bits1(&mb_bitmask_gb);",
"if (VAR_0->restart_interval && !VAR_0->restart_count)\nVAR_0->restart_count = VAR_0->restart_interval;",
"if(get_bits_count(&VAR_0->gb)>VAR_0->gb.size_in_bits){",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"overread %d\\n\", get_bits_count(&VAR_0->gb) - VAR_0->gb.size_in_bits);",
"return -1;",
"}",
"for(VAR_6=0;VAR_6<VAR_1;VAR_6++) {",
"uint8_t *ptr;",
"int n, h, v, x, y, VAR_11, j;",
"int block_offset;",
"n = VAR_0->nb_blocks[VAR_6];",
"VAR_11 = VAR_0->comp_index[VAR_6];",
"h = VAR_0->h_scount[VAR_6];",
"v = VAR_0->v_scount[VAR_6];",
"x = 0;",
"y = 0;",
"for(j=0;j<n;j++) {",
"block_offset = (((VAR_10[VAR_11] * (v * VAR_8 + y) * 8) +\n(h * VAR_7 + x) * 8) >> VAR_0->avctx->lowres);",
"if(VAR_0->interlaced && VAR_0->bottom_field)\nblock_offset += VAR_10[VAR_11] >> 1;",
"ptr = data[VAR_11] + block_offset;",
"if(!VAR_0->progressive) {",
"if (copy_mb) {",
"mjpeg_copy_block(ptr, VAR_9[VAR_11] + block_offset, VAR_10[VAR_11], VAR_0->avctx->lowres);",
"} else {",
"VAR_0->dsp.clear_block(VAR_0->block);",
"if(decode_block(VAR_0, VAR_0->block, VAR_6,\nVAR_0->dc_index[VAR_6], VAR_0->ac_index[VAR_6],\nVAR_0->quant_matrixes[ VAR_0->quant_index[VAR_11] ]) < 0) {",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"error y=%d x=%d\\n\", VAR_8, VAR_7);",
"return -1;",
"}",
"VAR_0->dsp.idct_put(ptr, VAR_10[VAR_11], VAR_0->block);",
"}",
"} else {",
"int block_idx = VAR_0->block_stride[VAR_11] * (v * VAR_8 + y) + (h * VAR_7 + x);",
"DCTELEM *block = VAR_0->blocks[VAR_11][block_idx];",
"if(VAR_2)\nblock[0] += get_bits1(&VAR_0->gb) * VAR_0->quant_matrixes[ VAR_0->quant_index[VAR_11] ][0] << VAR_3;",
"else if(decode_dc_progressive(VAR_0, block, VAR_6, VAR_0->dc_index[VAR_6], VAR_0->quant_matrixes[ VAR_0->quant_index[VAR_11] ], VAR_3) < 0) {",
"av_log(VAR_0->avctx, AV_LOG_ERROR, \"error y=%d x=%d\\n\", VAR_8, VAR_7);",
"return -1;",
"}",
"}",
"if (++x == h) {",
"x = 0;",
"y++;",
"}",
"}",
"}",
"if (VAR_0->restart_interval && show_bits(&VAR_0->gb, 8) == 0xFF){",
"--VAR_0->restart_count;",
"align_get_bits(&VAR_0->gb);",
"while(show_bits(&VAR_0->gb, 8) == 0xFF)\nskip_bits(&VAR_0->gb, 8);",
"skip_bits(&VAR_0->gb, 8);",
"for (VAR_6=0; VAR_6<VAR_1; VAR_6++)",
"VAR_0->last_dc[VAR_6] = 1024;",
"}",
"}",
"}",
"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,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63
],
[
65
],
[
67
],
[
71,
73
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107,
109
],
[
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
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
183
],
[
185
],
[
187
],
[
189,
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
]
] |
24,078 | static void qcow2_invalidate_cache(BlockDriverState *bs)
{
BDRVQcowState *s = bs->opaque;
int flags = s->flags;
AES_KEY aes_encrypt_key;
AES_KEY aes_decrypt_key;
uint32_t crypt_method = 0;
QDict *options;
/*
* Backing files are read-only which makes all of their metadata immutable,
* that means we don't have to worry about reopening them here.
*/
if (s->crypt_method) {
crypt_method = s->crypt_method;
memcpy(&aes_encrypt_key, &s->aes_encrypt_key, sizeof(aes_encrypt_key));
memcpy(&aes_decrypt_key, &s->aes_decrypt_key, sizeof(aes_decrypt_key));
}
qcow2_close(bs);
options = qdict_new();
qdict_put(options, QCOW2_OPT_LAZY_REFCOUNTS,
qbool_from_int(s->use_lazy_refcounts));
memset(s, 0, sizeof(BDRVQcowState));
qcow2_open(bs, options, flags, NULL);
QDECREF(options);
if (crypt_method) {
s->crypt_method = crypt_method;
memcpy(&s->aes_encrypt_key, &aes_encrypt_key, sizeof(aes_encrypt_key));
memcpy(&s->aes_decrypt_key, &aes_decrypt_key, sizeof(aes_decrypt_key));
}
} | true | qemu | 3456a8d1852e970688b73d03fdc44dde851759e1 | static void qcow2_invalidate_cache(BlockDriverState *bs)
{
BDRVQcowState *s = bs->opaque;
int flags = s->flags;
AES_KEY aes_encrypt_key;
AES_KEY aes_decrypt_key;
uint32_t crypt_method = 0;
QDict *options;
if (s->crypt_method) {
crypt_method = s->crypt_method;
memcpy(&aes_encrypt_key, &s->aes_encrypt_key, sizeof(aes_encrypt_key));
memcpy(&aes_decrypt_key, &s->aes_decrypt_key, sizeof(aes_decrypt_key));
}
qcow2_close(bs);
options = qdict_new();
qdict_put(options, QCOW2_OPT_LAZY_REFCOUNTS,
qbool_from_int(s->use_lazy_refcounts));
memset(s, 0, sizeof(BDRVQcowState));
qcow2_open(bs, options, flags, NULL);
QDECREF(options);
if (crypt_method) {
s->crypt_method = crypt_method;
memcpy(&s->aes_encrypt_key, &aes_encrypt_key, sizeof(aes_encrypt_key));
memcpy(&s->aes_decrypt_key, &aes_decrypt_key, sizeof(aes_decrypt_key));
}
} | {
"code": [],
"line_no": []
} | static void FUNC_0(BlockDriverState *VAR_0)
{
BDRVQcowState *s = VAR_0->opaque;
int VAR_1 = s->VAR_1;
AES_KEY aes_encrypt_key;
AES_KEY aes_decrypt_key;
uint32_t crypt_method = 0;
QDict *options;
if (s->crypt_method) {
crypt_method = s->crypt_method;
memcpy(&aes_encrypt_key, &s->aes_encrypt_key, sizeof(aes_encrypt_key));
memcpy(&aes_decrypt_key, &s->aes_decrypt_key, sizeof(aes_decrypt_key));
}
qcow2_close(VAR_0);
options = qdict_new();
qdict_put(options, QCOW2_OPT_LAZY_REFCOUNTS,
qbool_from_int(s->use_lazy_refcounts));
memset(s, 0, sizeof(BDRVQcowState));
qcow2_open(VAR_0, options, VAR_1, NULL);
QDECREF(options);
if (crypt_method) {
s->crypt_method = crypt_method;
memcpy(&s->aes_encrypt_key, &aes_encrypt_key, sizeof(aes_encrypt_key));
memcpy(&s->aes_decrypt_key, &aes_decrypt_key, sizeof(aes_decrypt_key));
}
} | [
"static void FUNC_0(BlockDriverState *VAR_0)\n{",
"BDRVQcowState *s = VAR_0->opaque;",
"int VAR_1 = s->VAR_1;",
"AES_KEY aes_encrypt_key;",
"AES_KEY aes_decrypt_key;",
"uint32_t crypt_method = 0;",
"QDict *options;",
"if (s->crypt_method) {",
"crypt_method = s->crypt_method;",
"memcpy(&aes_encrypt_key, &s->aes_encrypt_key, sizeof(aes_encrypt_key));",
"memcpy(&aes_decrypt_key, &s->aes_decrypt_key, sizeof(aes_decrypt_key));",
"}",
"qcow2_close(VAR_0);",
"options = qdict_new();",
"qdict_put(options, QCOW2_OPT_LAZY_REFCOUNTS,\nqbool_from_int(s->use_lazy_refcounts));",
"memset(s, 0, sizeof(BDRVQcowState));",
"qcow2_open(VAR_0, options, VAR_1, NULL);",
"QDECREF(options);",
"if (crypt_method) {",
"s->crypt_method = crypt_method;",
"memcpy(&s->aes_encrypt_key, &aes_encrypt_key, sizeof(aes_encrypt_key));",
"memcpy(&s->aes_decrypt_key, &aes_decrypt_key, sizeof(aes_decrypt_key));",
"}",
"}"
] | [
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
],
[
13
],
[
14
],
[
15
],
[
16
],
[
17
],
[
18
],
[
19
],
[
20,
21
],
[
22
],
[
23
],
[
24
],
[
25
],
[
26
],
[
27
],
[
28
],
[
29
],
[
30
]
] |
24,079 | static av_cold int avui_encode_init(AVCodecContext *avctx)
{
avctx->coded_frame = av_frame_alloc();
if (avctx->width != 720 || avctx->height != 486 && avctx->height != 576) {
av_log(avctx, AV_LOG_ERROR, "Only 720x486 and 720x576 are supported.\n");
return AVERROR(EINVAL);
}
if (!avctx->coded_frame) {
av_log(avctx, AV_LOG_ERROR, "Could not allocate frame.\n");
return AVERROR(ENOMEM);
}
if (!(avctx->extradata = av_mallocz(24 + FF_INPUT_BUFFER_PADDING_SIZE)))
return AVERROR(ENOMEM);
avctx->extradata_size = 24;
memcpy(avctx->extradata, "\0\0\0\x18""APRGAPRG0001", 16);
if (avctx->field_order > AV_FIELD_PROGRESSIVE) {
avctx->extradata[19] = 2;
} else {
avctx->extradata[19] = 1;
}
return 0;
}
| true | FFmpeg | e29153f414f5b2d10e0386abf7921aed4a4fa454 | static av_cold int avui_encode_init(AVCodecContext *avctx)
{
avctx->coded_frame = av_frame_alloc();
if (avctx->width != 720 || avctx->height != 486 && avctx->height != 576) {
av_log(avctx, AV_LOG_ERROR, "Only 720x486 and 720x576 are supported.\n");
return AVERROR(EINVAL);
}
if (!avctx->coded_frame) {
av_log(avctx, AV_LOG_ERROR, "Could not allocate frame.\n");
return AVERROR(ENOMEM);
}
if (!(avctx->extradata = av_mallocz(24 + FF_INPUT_BUFFER_PADDING_SIZE)))
return AVERROR(ENOMEM);
avctx->extradata_size = 24;
memcpy(avctx->extradata, "\0\0\0\x18""APRGAPRG0001", 16);
if (avctx->field_order > AV_FIELD_PROGRESSIVE) {
avctx->extradata[19] = 2;
} else {
avctx->extradata[19] = 1;
}
return 0;
}
| {
"code": [
" avctx->coded_frame = av_frame_alloc();",
" if (!avctx->coded_frame) {",
" av_log(avctx, AV_LOG_ERROR, \"Could not allocate frame.\\n\");",
" return AVERROR(ENOMEM);"
],
"line_no": [
5,
17,
19,
21
]
} | static av_cold int FUNC_0(AVCodecContext *avctx)
{
avctx->coded_frame = av_frame_alloc();
if (avctx->width != 720 || avctx->height != 486 && avctx->height != 576) {
av_log(avctx, AV_LOG_ERROR, "Only 720x486 and 720x576 are supported.\n");
return AVERROR(EINVAL);
}
if (!avctx->coded_frame) {
av_log(avctx, AV_LOG_ERROR, "Could not allocate frame.\n");
return AVERROR(ENOMEM);
}
if (!(avctx->extradata = av_mallocz(24 + FF_INPUT_BUFFER_PADDING_SIZE)))
return AVERROR(ENOMEM);
avctx->extradata_size = 24;
memcpy(avctx->extradata, "\0\0\0\x18""APRGAPRG0001", 16);
if (avctx->field_order > AV_FIELD_PROGRESSIVE) {
avctx->extradata[19] = 2;
} else {
avctx->extradata[19] = 1;
}
return 0;
}
| [
"static av_cold int FUNC_0(AVCodecContext *avctx)\n{",
"avctx->coded_frame = av_frame_alloc();",
"if (avctx->width != 720 || avctx->height != 486 && avctx->height != 576) {",
"av_log(avctx, AV_LOG_ERROR, \"Only 720x486 and 720x576 are supported.\\n\");",
"return AVERROR(EINVAL);",
"}",
"if (!avctx->coded_frame) {",
"av_log(avctx, AV_LOG_ERROR, \"Could not allocate frame.\\n\");",
"return AVERROR(ENOMEM);",
"}",
"if (!(avctx->extradata = av_mallocz(24 + FF_INPUT_BUFFER_PADDING_SIZE)))\nreturn AVERROR(ENOMEM);",
"avctx->extradata_size = 24;",
"memcpy(avctx->extradata, \"\\0\\0\\0\\x18\"\"APRGAPRG0001\", 16);",
"if (avctx->field_order > AV_FIELD_PROGRESSIVE) {",
"avctx->extradata[19] = 2;",
"} else {",
"avctx->extradata[19] = 1;",
"}",
"return 0;",
"}"
] | [
0,
1,
0,
0,
0,
0,
1,
1,
1,
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
],
[
47
],
[
49
]
] |
24,080 | void acpi_pm1_evt_write_sts(ACPIREGS *ar, uint16_t val)
{
uint16_t pm1_sts = acpi_pm1_evt_get_sts(ar, ar->tmr.overflow_time);
if (pm1_sts & val & ACPI_BITMASK_TIMER_STATUS) {
/* if TMRSTS is reset, then compute the new overflow time */
acpi_pm_tmr_calc_overflow_time(ar);
}
ar->pm1.evt.sts &= ~val;
}
| true | qemu | 2886be1b01c274570fa139748a402207482405bd | void acpi_pm1_evt_write_sts(ACPIREGS *ar, uint16_t val)
{
uint16_t pm1_sts = acpi_pm1_evt_get_sts(ar, ar->tmr.overflow_time);
if (pm1_sts & val & ACPI_BITMASK_TIMER_STATUS) {
acpi_pm_tmr_calc_overflow_time(ar);
}
ar->pm1.evt.sts &= ~val;
}
| {
"code": [
" uint16_t pm1_sts = acpi_pm1_evt_get_sts(ar, ar->tmr.overflow_time);"
],
"line_no": [
5
]
} | void FUNC_0(ACPIREGS *VAR_0, uint16_t VAR_1)
{
uint16_t pm1_sts = acpi_pm1_evt_get_sts(VAR_0, VAR_0->tmr.overflow_time);
if (pm1_sts & VAR_1 & ACPI_BITMASK_TIMER_STATUS) {
acpi_pm_tmr_calc_overflow_time(VAR_0);
}
VAR_0->pm1.evt.sts &= ~VAR_1;
}
| [
"void FUNC_0(ACPIREGS *VAR_0, uint16_t VAR_1)\n{",
"uint16_t pm1_sts = acpi_pm1_evt_get_sts(VAR_0, VAR_0->tmr.overflow_time);",
"if (pm1_sts & VAR_1 & ACPI_BITMASK_TIMER_STATUS) {",
"acpi_pm_tmr_calc_overflow_time(VAR_0);",
"}",
"VAR_0->pm1.evt.sts &= ~VAR_1;",
"}"
] | [
0,
1,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
]
] |
24,081 | static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
MPADecodeContext *s = avctx->priv_data;
uint32_t header;
int ret;
if (buf_size < HEADER_SIZE)
return AVERROR_INVALIDDATA;
header = AV_RB32(buf);
if (ff_mpa_check_header(header) < 0) {
av_log(avctx, AV_LOG_ERROR, "Header missing\n");
return AVERROR_INVALIDDATA;
}
if (avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {
/* free format: prepare to compute frame size */
s->frame_size = -1;
return AVERROR_INVALIDDATA;
}
/* update codec info */
avctx->channels = s->nb_channels;
avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
if (!avctx->bit_rate)
avctx->bit_rate = s->bit_rate;
s->frame = data;
ret = mp_decode_frame(s, NULL, buf, buf_size);
if (ret >= 0) {
s->frame->nb_samples = avctx->frame_size;
*got_frame_ptr = 1;
avctx->sample_rate = s->sample_rate;
//FIXME maybe move the other codec info stuff from above here too
} else {
av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
/* Only return an error if the bad frame makes up the whole packet or
* the error is related to buffer management.
* If there is more data in the packet, just consume the bad frame
* instead of returning an error, which would discard the whole
* packet. */
*got_frame_ptr = 0;
if (buf_size == avpkt->size || ret != AVERROR_INVALIDDATA)
return ret;
}
s->frame_size = 0;
return buf_size;
}
| false | FFmpeg | 955aec3c7c7be39b659197e1ec379a09f2b7c41c | static int decode_frame(AVCodecContext * avctx, void *data, int *got_frame_ptr,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
MPADecodeContext *s = avctx->priv_data;
uint32_t header;
int ret;
if (buf_size < HEADER_SIZE)
return AVERROR_INVALIDDATA;
header = AV_RB32(buf);
if (ff_mpa_check_header(header) < 0) {
av_log(avctx, AV_LOG_ERROR, "Header missing\n");
return AVERROR_INVALIDDATA;
}
if (avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {
s->frame_size = -1;
return AVERROR_INVALIDDATA;
}
avctx->channels = s->nb_channels;
avctx->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
if (!avctx->bit_rate)
avctx->bit_rate = s->bit_rate;
s->frame = data;
ret = mp_decode_frame(s, NULL, buf, buf_size);
if (ret >= 0) {
s->frame->nb_samples = avctx->frame_size;
*got_frame_ptr = 1;
avctx->sample_rate = s->sample_rate;
} else {
av_log(avctx, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
*got_frame_ptr = 0;
if (buf_size == avpkt->size || ret != AVERROR_INVALIDDATA)
return ret;
}
s->frame_size = 0;
return buf_size;
}
| {
"code": [],
"line_no": []
} | 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;
MPADecodeContext *s = VAR_0->priv_data;
uint32_t header;
int VAR_6;
if (VAR_5 < HEADER_SIZE)
return AVERROR_INVALIDDATA;
header = AV_RB32(VAR_4);
if (ff_mpa_check_header(header) < 0) {
av_log(VAR_0, AV_LOG_ERROR, "Header missing\n");
return AVERROR_INVALIDDATA;
}
if (avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {
s->frame_size = -1;
return AVERROR_INVALIDDATA;
}
VAR_0->channels = s->nb_channels;
VAR_0->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;
if (!VAR_0->bit_rate)
VAR_0->bit_rate = s->bit_rate;
s->frame = VAR_1;
VAR_6 = mp_decode_frame(s, NULL, VAR_4, VAR_5);
if (VAR_6 >= 0) {
s->frame->nb_samples = VAR_0->frame_size;
*VAR_2 = 1;
VAR_0->sample_rate = s->sample_rate;
} else {
av_log(VAR_0, AV_LOG_ERROR, "Error while decoding MPEG audio frame.\n");
*VAR_2 = 0;
if (VAR_5 == VAR_3->size || VAR_6 != AVERROR_INVALIDDATA)
return VAR_6;
}
s->frame_size = 0;
return VAR_5;
}
| [
"static int FUNC_0(AVCodecContext * VAR_0, void *VAR_1, int *VAR_2,\nAVPacket *VAR_3)\n{",
"const uint8_t *VAR_4 = VAR_3->VAR_1;",
"int VAR_5 = VAR_3->size;",
"MPADecodeContext *s = VAR_0->priv_data;",
"uint32_t header;",
"int VAR_6;",
"if (VAR_5 < HEADER_SIZE)\nreturn AVERROR_INVALIDDATA;",
"header = AV_RB32(VAR_4);",
"if (ff_mpa_check_header(header) < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Header missing\\n\");",
"return AVERROR_INVALIDDATA;",
"}",
"if (avpriv_mpegaudio_decode_header((MPADecodeHeader *)s, header) == 1) {",
"s->frame_size = -1;",
"return AVERROR_INVALIDDATA;",
"}",
"VAR_0->channels = s->nb_channels;",
"VAR_0->channel_layout = s->nb_channels == 1 ? AV_CH_LAYOUT_MONO : AV_CH_LAYOUT_STEREO;",
"if (!VAR_0->bit_rate)\nVAR_0->bit_rate = s->bit_rate;",
"s->frame = VAR_1;",
"VAR_6 = mp_decode_frame(s, NULL, VAR_4, VAR_5);",
"if (VAR_6 >= 0) {",
"s->frame->nb_samples = VAR_0->frame_size;",
"*VAR_2 = 1;",
"VAR_0->sample_rate = s->sample_rate;",
"} else {",
"av_log(VAR_0, AV_LOG_ERROR, \"Error while decoding MPEG audio frame.\\n\");",
"*VAR_2 = 0;",
"if (VAR_5 == VAR_3->size || VAR_6 != AVERROR_INVALIDDATA)\nreturn VAR_6;",
"}",
"s->frame_size = 0;",
"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
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19,
21
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37
],
[
41
],
[
43
],
[
45
],
[
49
],
[
51
],
[
53,
55
],
[
59
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
75
],
[
77
],
[
89
],
[
91,
93
],
[
95
],
[
97
],
[
99
],
[
101
]
] |
24,082 | int attribute_align_arg avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options)
{
int ret = 0;
AVDictionary *tmp = NULL;
if (avcodec_is_open(avctx))
return 0;
if ((!codec && !avctx->codec)) {
av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2().\n");
return AVERROR(EINVAL);
}
if ((codec && avctx->codec && codec != avctx->codec)) {
av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
"but %s passed to avcodec_open2().\n", avctx->codec->name, codec->name);
return AVERROR(EINVAL);
}
if (!codec)
codec = avctx->codec;
if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
return AVERROR(EINVAL);
if (options)
av_dict_copy(&tmp, *options, 0);
/* If there is a user-supplied mutex locking routine, call it. */
if (ff_lockmgr_cb) {
if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
return -1;
}
entangled_thread_counter++;
if(entangled_thread_counter != 1){
av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
ret = -1;
goto end;
}
avctx->internal = av_mallocz(sizeof(AVCodecInternal));
if (!avctx->internal) {
ret = AVERROR(ENOMEM);
goto end;
}
if (codec->priv_data_size > 0) {
if(!avctx->priv_data){
avctx->priv_data = av_mallocz(codec->priv_data_size);
if (!avctx->priv_data) {
ret = AVERROR(ENOMEM);
goto end;
}
if (codec->priv_class) {
*(const AVClass**)avctx->priv_data= codec->priv_class;
av_opt_set_defaults(avctx->priv_data);
}
}
if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
goto free_and_end;
} else {
avctx->priv_data = NULL;
}
if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
goto free_and_end;
if (codec->capabilities & CODEC_CAP_EXPERIMENTAL)
if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
av_log(avctx, AV_LOG_ERROR, "Codec is experimental but experimental codecs are not enabled, try -strict -2\n");
ret = -1;
goto free_and_end;
}
//We only call avcodec_set_dimensions() for non h264 codecs so as not to overwrite previously setup dimensions
if(!( avctx->coded_width && avctx->coded_height && avctx->width && avctx->height && avctx->codec_id == CODEC_ID_H264)){
if(avctx->coded_width && avctx->coded_height)
avcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
else if(avctx->width && avctx->height)
avcodec_set_dimensions(avctx, avctx->width, avctx->height);
}
if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
&& ( av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx) < 0
|| av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0)) {
av_log(avctx, AV_LOG_WARNING, "ignoring invalid width/height values\n");
avcodec_set_dimensions(avctx, 0, 0);
}
/* if the decoder init function was already called previously,
free the already allocated subtitle_header before overwriting it */
if (av_codec_is_decoder(codec))
av_freep(&avctx->subtitle_header);
#define SANE_NB_CHANNELS 128U
if (avctx->channels > SANE_NB_CHANNELS) {
ret = AVERROR(EINVAL);
goto free_and_end;
}
avctx->codec = codec;
if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
avctx->codec_id == CODEC_ID_NONE) {
avctx->codec_type = codec->type;
avctx->codec_id = codec->id;
}
if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
&& avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
av_log(avctx, AV_LOG_ERROR, "codec type or id mismatches\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
avctx->frame_number = 0;
if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
(!avctx->time_base.num || !avctx->time_base.den)) {
avctx->time_base.num = 1;
avctx->time_base.den = avctx->sample_rate;
}
if (!HAVE_THREADS)
av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
if (HAVE_THREADS && !avctx->thread_opaque) {
ret = ff_thread_init(avctx);
if (ret < 0) {
goto free_and_end;
}
}
if (!HAVE_THREADS && !(codec->capabilities & CODEC_CAP_AUTO_THREADS))
avctx->thread_count = 1;
if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
av_log(avctx, AV_LOG_ERROR, "The maximum value for lowres supported by the decoder is %d\n",
avctx->codec->max_lowres);
ret = AVERROR(EINVAL);
goto free_and_end;
}
if (av_codec_is_encoder(avctx->codec)) {
int i;
if (avctx->codec->sample_fmts) {
for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++)
if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
break;
if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
av_log(avctx, AV_LOG_ERROR, "Specified sample_fmt is not supported.\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
}
if (avctx->codec->pix_fmts) {
for (i = 0; avctx->codec->pix_fmts[i] != PIX_FMT_NONE; i++)
if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
break;
if (avctx->codec->pix_fmts[i] == PIX_FMT_NONE
&& !((avctx->codec_id == CODEC_ID_MJPEG || avctx->codec_id == CODEC_ID_LJPEG)
&& avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL)) {
av_log(avctx, AV_LOG_ERROR, "Specified pix_fmt is not supported\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
}
if (avctx->codec->supported_samplerates) {
for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
break;
if (avctx->codec->supported_samplerates[i] == 0) {
av_log(avctx, AV_LOG_ERROR, "Specified sample_rate is not supported\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
}
if (avctx->codec->channel_layouts) {
if (!avctx->channel_layout) {
av_log(avctx, AV_LOG_WARNING, "channel_layout not specified\n");
} else {
for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
if (avctx->channel_layout == avctx->codec->channel_layouts[i])
break;
if (avctx->codec->channel_layouts[i] == 0) {
av_log(avctx, AV_LOG_ERROR, "Specified channel_layout is not supported\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
}
}
if (avctx->channel_layout && avctx->channels) {
if (av_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels) {
av_log(avctx, AV_LOG_ERROR, "channel layout does not match number of channels\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
} else if (avctx->channel_layout) {
avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
}
}
avctx->pts_correction_num_faulty_pts =
avctx->pts_correction_num_faulty_dts = 0;
avctx->pts_correction_last_pts =
avctx->pts_correction_last_dts = INT64_MIN;
if(avctx->codec->init && !(avctx->active_thread_type&FF_THREAD_FRAME)){
ret = avctx->codec->init(avctx);
if (ret < 0) {
goto free_and_end;
}
}
ret=0;
if (av_codec_is_decoder(avctx->codec)) {
if (!avctx->bit_rate)
avctx->bit_rate = get_bit_rate(avctx);
/* validate channel layout from the decoder */
if (avctx->channel_layout &&
av_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels) {
av_log(avctx, AV_LOG_WARNING, "channel layout does not match number of channels\n");
avctx->channel_layout = 0;
}
}
end:
entangled_thread_counter--;
/* Release any user-supplied mutex. */
if (ff_lockmgr_cb) {
(*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
}
if (options) {
av_dict_free(options);
*options = tmp;
}
return ret;
free_and_end:
av_dict_free(&tmp);
av_freep(&avctx->priv_data);
av_freep(&avctx->internal);
avctx->codec= NULL;
goto end;
}
| false | FFmpeg | fde1bc64adbec49301c665efab2b49b94bb39c23 | int attribute_align_arg avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options)
{
int ret = 0;
AVDictionary *tmp = NULL;
if (avcodec_is_open(avctx))
return 0;
if ((!codec && !avctx->codec)) {
av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2().\n");
return AVERROR(EINVAL);
}
if ((codec && avctx->codec && codec != avctx->codec)) {
av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
"but %s passed to avcodec_open2().\n", avctx->codec->name, codec->name);
return AVERROR(EINVAL);
}
if (!codec)
codec = avctx->codec;
if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
return AVERROR(EINVAL);
if (options)
av_dict_copy(&tmp, *options, 0);
if (ff_lockmgr_cb) {
if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
return -1;
}
entangled_thread_counter++;
if(entangled_thread_counter != 1){
av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
ret = -1;
goto end;
}
avctx->internal = av_mallocz(sizeof(AVCodecInternal));
if (!avctx->internal) {
ret = AVERROR(ENOMEM);
goto end;
}
if (codec->priv_data_size > 0) {
if(!avctx->priv_data){
avctx->priv_data = av_mallocz(codec->priv_data_size);
if (!avctx->priv_data) {
ret = AVERROR(ENOMEM);
goto end;
}
if (codec->priv_class) {
*(const AVClass**)avctx->priv_data= codec->priv_class;
av_opt_set_defaults(avctx->priv_data);
}
}
if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
goto free_and_end;
} else {
avctx->priv_data = NULL;
}
if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
goto free_and_end;
if (codec->capabilities & CODEC_CAP_EXPERIMENTAL)
if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
av_log(avctx, AV_LOG_ERROR, "Codec is experimental but experimental codecs are not enabled, try -strict -2\n");
ret = -1;
goto free_and_end;
}
if(!( avctx->coded_width && avctx->coded_height && avctx->width && avctx->height && avctx->codec_id == CODEC_ID_H264)){
if(avctx->coded_width && avctx->coded_height)
avcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
else if(avctx->width && avctx->height)
avcodec_set_dimensions(avctx, avctx->width, avctx->height);
}
if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
&& ( av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx) < 0
|| av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0)) {
av_log(avctx, AV_LOG_WARNING, "ignoring invalid width/height values\n");
avcodec_set_dimensions(avctx, 0, 0);
}
if (av_codec_is_decoder(codec))
av_freep(&avctx->subtitle_header);
#define SANE_NB_CHANNELS 128U
if (avctx->channels > SANE_NB_CHANNELS) {
ret = AVERROR(EINVAL);
goto free_and_end;
}
avctx->codec = codec;
if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
avctx->codec_id == CODEC_ID_NONE) {
avctx->codec_type = codec->type;
avctx->codec_id = codec->id;
}
if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
&& avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
av_log(avctx, AV_LOG_ERROR, "codec type or id mismatches\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
avctx->frame_number = 0;
if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
(!avctx->time_base.num || !avctx->time_base.den)) {
avctx->time_base.num = 1;
avctx->time_base.den = avctx->sample_rate;
}
if (!HAVE_THREADS)
av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
if (HAVE_THREADS && !avctx->thread_opaque) {
ret = ff_thread_init(avctx);
if (ret < 0) {
goto free_and_end;
}
}
if (!HAVE_THREADS && !(codec->capabilities & CODEC_CAP_AUTO_THREADS))
avctx->thread_count = 1;
if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
av_log(avctx, AV_LOG_ERROR, "The maximum value for lowres supported by the decoder is %d\n",
avctx->codec->max_lowres);
ret = AVERROR(EINVAL);
goto free_and_end;
}
if (av_codec_is_encoder(avctx->codec)) {
int i;
if (avctx->codec->sample_fmts) {
for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++)
if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
break;
if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
av_log(avctx, AV_LOG_ERROR, "Specified sample_fmt is not supported.\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
}
if (avctx->codec->pix_fmts) {
for (i = 0; avctx->codec->pix_fmts[i] != PIX_FMT_NONE; i++)
if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
break;
if (avctx->codec->pix_fmts[i] == PIX_FMT_NONE
&& !((avctx->codec_id == CODEC_ID_MJPEG || avctx->codec_id == CODEC_ID_LJPEG)
&& avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL)) {
av_log(avctx, AV_LOG_ERROR, "Specified pix_fmt is not supported\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
}
if (avctx->codec->supported_samplerates) {
for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
break;
if (avctx->codec->supported_samplerates[i] == 0) {
av_log(avctx, AV_LOG_ERROR, "Specified sample_rate is not supported\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
}
if (avctx->codec->channel_layouts) {
if (!avctx->channel_layout) {
av_log(avctx, AV_LOG_WARNING, "channel_layout not specified\n");
} else {
for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
if (avctx->channel_layout == avctx->codec->channel_layouts[i])
break;
if (avctx->codec->channel_layouts[i] == 0) {
av_log(avctx, AV_LOG_ERROR, "Specified channel_layout is not supported\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
}
}
if (avctx->channel_layout && avctx->channels) {
if (av_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels) {
av_log(avctx, AV_LOG_ERROR, "channel layout does not match number of channels\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
} else if (avctx->channel_layout) {
avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
}
}
avctx->pts_correction_num_faulty_pts =
avctx->pts_correction_num_faulty_dts = 0;
avctx->pts_correction_last_pts =
avctx->pts_correction_last_dts = INT64_MIN;
if(avctx->codec->init && !(avctx->active_thread_type&FF_THREAD_FRAME)){
ret = avctx->codec->init(avctx);
if (ret < 0) {
goto free_and_end;
}
}
ret=0;
if (av_codec_is_decoder(avctx->codec)) {
if (!avctx->bit_rate)
avctx->bit_rate = get_bit_rate(avctx);
if (avctx->channel_layout &&
av_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels) {
av_log(avctx, AV_LOG_WARNING, "channel layout does not match number of channels\n");
avctx->channel_layout = 0;
}
}
end:
entangled_thread_counter--;
if (ff_lockmgr_cb) {
(*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
}
if (options) {
av_dict_free(options);
*options = tmp;
}
return ret;
free_and_end:
av_dict_free(&tmp);
av_freep(&avctx->priv_data);
av_freep(&avctx->internal);
avctx->codec= NULL;
goto end;
}
| {
"code": [],
"line_no": []
} | int VAR_0 avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options)
{
int ret = 0;
AVDictionary *tmp = NULL;
if (avcodec_is_open(avctx))
return 0;
if ((!codec && !avctx->codec)) {
av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2().\n");
return AVERROR(EINVAL);
}
if ((codec && avctx->codec && codec != avctx->codec)) {
av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
"but %s passed to avcodec_open2().\n", avctx->codec->name, codec->name);
return AVERROR(EINVAL);
}
if (!codec)
codec = avctx->codec;
if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
return AVERROR(EINVAL);
if (options)
av_dict_copy(&tmp, *options, 0);
if (ff_lockmgr_cb) {
if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))
return -1;
}
entangled_thread_counter++;
if(entangled_thread_counter != 1){
av_log(avctx, AV_LOG_ERROR, "insufficient thread locking around avcodec_open/close()\n");
ret = -1;
goto end;
}
avctx->internal = av_mallocz(sizeof(AVCodecInternal));
if (!avctx->internal) {
ret = AVERROR(ENOMEM);
goto end;
}
if (codec->priv_data_size > 0) {
if(!avctx->priv_data){
avctx->priv_data = av_mallocz(codec->priv_data_size);
if (!avctx->priv_data) {
ret = AVERROR(ENOMEM);
goto end;
}
if (codec->priv_class) {
*(const AVClass**)avctx->priv_data= codec->priv_class;
av_opt_set_defaults(avctx->priv_data);
}
}
if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
goto free_and_end;
} else {
avctx->priv_data = NULL;
}
if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
goto free_and_end;
if (codec->capabilities & CODEC_CAP_EXPERIMENTAL)
if (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
av_log(avctx, AV_LOG_ERROR, "Codec is experimental but experimental codecs are not enabled, try -strict -2\n");
ret = -1;
goto free_and_end;
}
if(!( avctx->coded_width && avctx->coded_height && avctx->width && avctx->height && avctx->codec_id == CODEC_ID_H264)){
if(avctx->coded_width && avctx->coded_height)
avcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
else if(avctx->width && avctx->height)
avcodec_set_dimensions(avctx, avctx->width, avctx->height);
}
if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
&& ( av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx) < 0
|| av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0)) {
av_log(avctx, AV_LOG_WARNING, "ignoring invalid width/height values\n");
avcodec_set_dimensions(avctx, 0, 0);
}
if (av_codec_is_decoder(codec))
av_freep(&avctx->subtitle_header);
#define SANE_NB_CHANNELS 128U
if (avctx->channels > SANE_NB_CHANNELS) {
ret = AVERROR(EINVAL);
goto free_and_end;
}
avctx->codec = codec;
if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
avctx->codec_id == CODEC_ID_NONE) {
avctx->codec_type = codec->type;
avctx->codec_id = codec->id;
}
if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type
&& avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
av_log(avctx, AV_LOG_ERROR, "codec type or id mismatches\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
avctx->frame_number = 0;
if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
(!avctx->time_base.num || !avctx->time_base.den)) {
avctx->time_base.num = 1;
avctx->time_base.den = avctx->sample_rate;
}
if (!HAVE_THREADS)
av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");
if (HAVE_THREADS && !avctx->thread_opaque) {
ret = ff_thread_init(avctx);
if (ret < 0) {
goto free_and_end;
}
}
if (!HAVE_THREADS && !(codec->capabilities & CODEC_CAP_AUTO_THREADS))
avctx->thread_count = 1;
if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
av_log(avctx, AV_LOG_ERROR, "The maximum value for lowres supported by the decoder is %d\n",
avctx->codec->max_lowres);
ret = AVERROR(EINVAL);
goto free_and_end;
}
if (av_codec_is_encoder(avctx->codec)) {
int i;
if (avctx->codec->sample_fmts) {
for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++)
if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
break;
if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
av_log(avctx, AV_LOG_ERROR, "Specified sample_fmt is not supported.\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
}
if (avctx->codec->pix_fmts) {
for (i = 0; avctx->codec->pix_fmts[i] != PIX_FMT_NONE; i++)
if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
break;
if (avctx->codec->pix_fmts[i] == PIX_FMT_NONE
&& !((avctx->codec_id == CODEC_ID_MJPEG || avctx->codec_id == CODEC_ID_LJPEG)
&& avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL)) {
av_log(avctx, AV_LOG_ERROR, "Specified pix_fmt is not supported\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
}
if (avctx->codec->supported_samplerates) {
for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
break;
if (avctx->codec->supported_samplerates[i] == 0) {
av_log(avctx, AV_LOG_ERROR, "Specified sample_rate is not supported\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
}
if (avctx->codec->channel_layouts) {
if (!avctx->channel_layout) {
av_log(avctx, AV_LOG_WARNING, "channel_layout not specified\n");
} else {
for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
if (avctx->channel_layout == avctx->codec->channel_layouts[i])
break;
if (avctx->codec->channel_layouts[i] == 0) {
av_log(avctx, AV_LOG_ERROR, "Specified channel_layout is not supported\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
}
}
if (avctx->channel_layout && avctx->channels) {
if (av_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels) {
av_log(avctx, AV_LOG_ERROR, "channel layout does not match number of channels\n");
ret = AVERROR(EINVAL);
goto free_and_end;
}
} else if (avctx->channel_layout) {
avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
}
}
avctx->pts_correction_num_faulty_pts =
avctx->pts_correction_num_faulty_dts = 0;
avctx->pts_correction_last_pts =
avctx->pts_correction_last_dts = INT64_MIN;
if(avctx->codec->init && !(avctx->active_thread_type&FF_THREAD_FRAME)){
ret = avctx->codec->init(avctx);
if (ret < 0) {
goto free_and_end;
}
}
ret=0;
if (av_codec_is_decoder(avctx->codec)) {
if (!avctx->bit_rate)
avctx->bit_rate = get_bit_rate(avctx);
if (avctx->channel_layout &&
av_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels) {
av_log(avctx, AV_LOG_WARNING, "channel layout does not match number of channels\n");
avctx->channel_layout = 0;
}
}
end:
entangled_thread_counter--;
if (ff_lockmgr_cb) {
(*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);
}
if (options) {
av_dict_free(options);
*options = tmp;
}
return ret;
free_and_end:
av_dict_free(&tmp);
av_freep(&avctx->priv_data);
av_freep(&avctx->internal);
avctx->codec= NULL;
goto end;
}
| [
"int VAR_0 avcodec_open2(AVCodecContext *avctx, AVCodec *codec, AVDictionary **options)\n{",
"int ret = 0;",
"AVDictionary *tmp = NULL;",
"if (avcodec_is_open(avctx))\nreturn 0;",
"if ((!codec && !avctx->codec)) {",
"av_log(avctx, AV_LOG_ERROR, \"No codec provided to avcodec_open2().\\n\");",
"return AVERROR(EINVAL);",
"}",
"if ((codec && avctx->codec && codec != avctx->codec)) {",
"av_log(avctx, AV_LOG_ERROR, \"This AVCodecContext was allocated for %s, \"\n\"but %s passed to avcodec_open2().\\n\", avctx->codec->name, codec->name);",
"return AVERROR(EINVAL);",
"}",
"if (!codec)\ncodec = avctx->codec;",
"if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)\nreturn AVERROR(EINVAL);",
"if (options)\nav_dict_copy(&tmp, *options, 0);",
"if (ff_lockmgr_cb) {",
"if ((*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_OBTAIN))\nreturn -1;",
"}",
"entangled_thread_counter++;",
"if(entangled_thread_counter != 1){",
"av_log(avctx, AV_LOG_ERROR, \"insufficient thread locking around avcodec_open/close()\\n\");",
"ret = -1;",
"goto end;",
"}",
"avctx->internal = av_mallocz(sizeof(AVCodecInternal));",
"if (!avctx->internal) {",
"ret = AVERROR(ENOMEM);",
"goto end;",
"}",
"if (codec->priv_data_size > 0) {",
"if(!avctx->priv_data){",
"avctx->priv_data = av_mallocz(codec->priv_data_size);",
"if (!avctx->priv_data) {",
"ret = AVERROR(ENOMEM);",
"goto end;",
"}",
"if (codec->priv_class) {",
"*(const AVClass**)avctx->priv_data= codec->priv_class;",
"av_opt_set_defaults(avctx->priv_data);",
"}",
"}",
"if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)\ngoto free_and_end;",
"} else {",
"avctx->priv_data = NULL;",
"}",
"if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)\ngoto free_and_end;",
"if (codec->capabilities & CODEC_CAP_EXPERIMENTAL)\nif (avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {",
"av_log(avctx, AV_LOG_ERROR, \"Codec is experimental but experimental codecs are not enabled, try -strict -2\\n\");",
"ret = -1;",
"goto free_and_end;",
"}",
"if(!( avctx->coded_width && avctx->coded_height && avctx->width && avctx->height && avctx->codec_id == CODEC_ID_H264)){",
"if(avctx->coded_width && avctx->coded_height)\navcodec_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);",
"else if(avctx->width && avctx->height)\navcodec_set_dimensions(avctx, avctx->width, avctx->height);",
"}",
"if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)\n&& ( av_image_check_size(avctx->coded_width, avctx->coded_height, 0, avctx) < 0\n|| av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0)) {",
"av_log(avctx, AV_LOG_WARNING, \"ignoring invalid width/height values\\n\");",
"avcodec_set_dimensions(avctx, 0, 0);",
"}",
"if (av_codec_is_decoder(codec))\nav_freep(&avctx->subtitle_header);",
"#define SANE_NB_CHANNELS 128U\nif (avctx->channels > SANE_NB_CHANNELS) {",
"ret = AVERROR(EINVAL);",
"goto free_and_end;",
"}",
"avctx->codec = codec;",
"if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&\navctx->codec_id == CODEC_ID_NONE) {",
"avctx->codec_type = codec->type;",
"avctx->codec_id = codec->id;",
"}",
"if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type\n&& avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {",
"av_log(avctx, AV_LOG_ERROR, \"codec type or id mismatches\\n\");",
"ret = AVERROR(EINVAL);",
"goto free_and_end;",
"}",
"avctx->frame_number = 0;",
"if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&\n(!avctx->time_base.num || !avctx->time_base.den)) {",
"avctx->time_base.num = 1;",
"avctx->time_base.den = avctx->sample_rate;",
"}",
"if (!HAVE_THREADS)\nav_log(avctx, AV_LOG_WARNING, \"Warning: not compiled with thread support, using thread emulation\\n\");",
"if (HAVE_THREADS && !avctx->thread_opaque) {",
"ret = ff_thread_init(avctx);",
"if (ret < 0) {",
"goto free_and_end;",
"}",
"}",
"if (!HAVE_THREADS && !(codec->capabilities & CODEC_CAP_AUTO_THREADS))\navctx->thread_count = 1;",
"if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {",
"av_log(avctx, AV_LOG_ERROR, \"The maximum value for lowres supported by the decoder is %d\\n\",\navctx->codec->max_lowres);",
"ret = AVERROR(EINVAL);",
"goto free_and_end;",
"}",
"if (av_codec_is_encoder(avctx->codec)) {",
"int i;",
"if (avctx->codec->sample_fmts) {",
"for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++)",
"if (avctx->sample_fmt == avctx->codec->sample_fmts[i])\nbreak;",
"if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {",
"av_log(avctx, AV_LOG_ERROR, \"Specified sample_fmt is not supported.\\n\");",
"ret = AVERROR(EINVAL);",
"goto free_and_end;",
"}",
"}",
"if (avctx->codec->pix_fmts) {",
"for (i = 0; avctx->codec->pix_fmts[i] != PIX_FMT_NONE; i++)",
"if (avctx->pix_fmt == avctx->codec->pix_fmts[i])\nbreak;",
"if (avctx->codec->pix_fmts[i] == PIX_FMT_NONE\n&& !((avctx->codec_id == CODEC_ID_MJPEG || avctx->codec_id == CODEC_ID_LJPEG)\n&& avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL)) {",
"av_log(avctx, AV_LOG_ERROR, \"Specified pix_fmt is not supported\\n\");",
"ret = AVERROR(EINVAL);",
"goto free_and_end;",
"}",
"}",
"if (avctx->codec->supported_samplerates) {",
"for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)",
"if (avctx->sample_rate == avctx->codec->supported_samplerates[i])\nbreak;",
"if (avctx->codec->supported_samplerates[i] == 0) {",
"av_log(avctx, AV_LOG_ERROR, \"Specified sample_rate is not supported\\n\");",
"ret = AVERROR(EINVAL);",
"goto free_and_end;",
"}",
"}",
"if (avctx->codec->channel_layouts) {",
"if (!avctx->channel_layout) {",
"av_log(avctx, AV_LOG_WARNING, \"channel_layout not specified\\n\");",
"} else {",
"for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)",
"if (avctx->channel_layout == avctx->codec->channel_layouts[i])\nbreak;",
"if (avctx->codec->channel_layouts[i] == 0) {",
"av_log(avctx, AV_LOG_ERROR, \"Specified channel_layout is not supported\\n\");",
"ret = AVERROR(EINVAL);",
"goto free_and_end;",
"}",
"}",
"}",
"if (avctx->channel_layout && avctx->channels) {",
"if (av_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels) {",
"av_log(avctx, AV_LOG_ERROR, \"channel layout does not match number of channels\\n\");",
"ret = AVERROR(EINVAL);",
"goto free_and_end;",
"}",
"} else if (avctx->channel_layout) {",
"avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);",
"}",
"}",
"avctx->pts_correction_num_faulty_pts =\navctx->pts_correction_num_faulty_dts = 0;",
"avctx->pts_correction_last_pts =\navctx->pts_correction_last_dts = INT64_MIN;",
"if(avctx->codec->init && !(avctx->active_thread_type&FF_THREAD_FRAME)){",
"ret = avctx->codec->init(avctx);",
"if (ret < 0) {",
"goto free_and_end;",
"}",
"}",
"ret=0;",
"if (av_codec_is_decoder(avctx->codec)) {",
"if (!avctx->bit_rate)\navctx->bit_rate = get_bit_rate(avctx);",
"if (avctx->channel_layout &&\nav_get_channel_layout_nb_channels(avctx->channel_layout) != avctx->channels) {",
"av_log(avctx, AV_LOG_WARNING, \"channel layout does not match number of channels\\n\");",
"avctx->channel_layout = 0;",
"}",
"}",
"end:\nentangled_thread_counter--;",
"if (ff_lockmgr_cb) {",
"(*ff_lockmgr_cb)(&codec_mutex, AV_LOCK_RELEASE);",
"}",
"if (options) {",
"av_dict_free(options);",
"*options = tmp;",
"}",
"return ret;",
"free_and_end:\nav_dict_free(&tmp);",
"av_freep(&avctx->priv_data);",
"av_freep(&avctx->internal);",
"avctx->codec= NULL;",
"goto end;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35,
37
],
[
41,
43
],
[
47,
49
],
[
55
],
[
57,
59
],
[
61
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115,
117
],
[
119
],
[
121
],
[
123
],
[
125,
127
],
[
131,
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
147
],
[
149,
151
],
[
153,
155
],
[
157
],
[
161,
163,
165
],
[
167
],
[
169
],
[
171
],
[
179,
181
],
[
185,
187
],
[
189
],
[
191
],
[
193
],
[
197
],
[
199,
201
],
[
203
],
[
205
],
[
207
],
[
209,
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
225,
227
],
[
229
],
[
231
],
[
233
],
[
237,
239
],
[
243
],
[
245
],
[
247
],
[
249
],
[
251
],
[
253
],
[
255,
257
],
[
261
],
[
263,
265
],
[
267
],
[
269
],
[
271
],
[
275
],
[
277
],
[
279
],
[
281
],
[
283,
285
],
[
287
],
[
289
],
[
291
],
[
293
],
[
295
],
[
297
],
[
299
],
[
301
],
[
303,
305
],
[
307,
309,
311
],
[
313
],
[
315
],
[
317
],
[
319
],
[
321
],
[
323
],
[
325
],
[
327,
329
],
[
331
],
[
333
],
[
335
],
[
337
],
[
339
],
[
341
],
[
343
],
[
345
],
[
347
],
[
349
],
[
351
],
[
353,
355
],
[
357
],
[
359
],
[
361
],
[
363
],
[
365
],
[
367
],
[
369
],
[
371
],
[
373
],
[
375
],
[
377
],
[
379
],
[
381
],
[
383
],
[
385
],
[
387
],
[
389
],
[
393,
395
],
[
397,
399
],
[
403
],
[
405
],
[
407
],
[
409
],
[
411
],
[
413
],
[
417
],
[
421
],
[
423,
425
],
[
429,
431
],
[
433
],
[
435
],
[
437
],
[
439
],
[
441,
443
],
[
449
],
[
451
],
[
453
],
[
455
],
[
457
],
[
459
],
[
461
],
[
465
],
[
467,
469
],
[
471
],
[
473
],
[
475
],
[
477
],
[
479
]
] |
24,083 | static int get_transform_coeffs1(uint8_t *exps, uint8_t *bap, float chcoeff,
float *coeffs, int start, int end, int dith_flag, GetBitContext *gb,
dither_state *state)
{
int16_t mantissa;
int i;
int gcode;
mant_group l3_grp, l5_grp, l11_grp;
for (i = 0; i < 3; i++)
l3_grp.gcodes[i] = l5_grp.gcodes[i] = l11_grp.gcodes[i] = -1;
l3_grp.gcptr = l5_grp.gcptr = 3;
l11_grp.gcptr = 2;
i = 0;
while (i < start)
coeffs[i++] = 0;
for (i = start; i < end; i++) {
switch (bap[i]) {
case 0:
if (!dith_flag) {
coeffs[i] = 0;
continue;
}
else {
mantissa = dither_int16(state);
coeffs[i] = to_float(exps[i], mantissa) * chcoeff;
continue;
}
case 1:
if (l3_grp.gcptr > 2) {
gcode = get_bits(gb, 5);
if (gcode > 26)
return -1;
l3_grp.gcodes[0] = gcode / 9;
l3_grp.gcodes[1] = (gcode % 9) / 3;
l3_grp.gcodes[2] = (gcode % 9) % 3;
l3_grp.gcptr = 0;
}
mantissa = l3_q_tab[l3_grp.gcodes[l3_grp.gcptr++]];
coeffs[i] = to_float(exps[i], mantissa) * chcoeff;
continue;
case 2:
if (l5_grp.gcptr > 2) {
gcode = get_bits(gb, 7);
if (gcode > 124)
return -1;
l5_grp.gcodes[0] = gcode / 25;
l5_grp.gcodes[1] = (gcode % 25) / 5;
l5_grp.gcodes[2] = (gcode % 25) % 5;
l5_grp.gcptr = 0;
}
mantissa = l5_q_tab[l5_grp.gcodes[l5_grp.gcptr++]];
coeffs[i] = to_float(exps[i], mantissa) * chcoeff;
continue;
case 3:
mantissa = get_bits(gb, 3);
if (mantissa > 6)
return -1;
mantissa = l7_q_tab[mantissa];
coeffs[i] = to_float(exps[i], mantissa);
continue;
case 4:
if (l11_grp.gcptr > 1) {
gcode = get_bits(gb, 7);
if (gcode > 120)
return -1;
l11_grp.gcodes[0] = gcode / 11;
l11_grp.gcodes[1] = gcode % 11;
}
mantissa = l11_q_tab[l11_grp.gcodes[l11_grp.gcptr++]];
coeffs[i] = to_float(exps[i], mantissa) * chcoeff;
continue;
case 5:
mantissa = get_bits(gb, 4);
if (mantissa > 14)
return -1;
mantissa = l15_q_tab[mantissa];
coeffs[i] = to_float(exps[i], mantissa) * chcoeff;
continue;
default:
mantissa = get_bits(gb, qntztab[bap[i]]) << (16 - qntztab[bap[i]]);
coeffs[i] = to_float(exps[i], mantissa) * chcoeff;
continue;
}
}
i = end;
while (i < 256)
coeffs[i++] = 0;
return 0;
}
| false | FFmpeg | 486637af8ef29ec215e0e0b7ecd3b5470f0e04e5 | static int get_transform_coeffs1(uint8_t *exps, uint8_t *bap, float chcoeff,
float *coeffs, int start, int end, int dith_flag, GetBitContext *gb,
dither_state *state)
{
int16_t mantissa;
int i;
int gcode;
mant_group l3_grp, l5_grp, l11_grp;
for (i = 0; i < 3; i++)
l3_grp.gcodes[i] = l5_grp.gcodes[i] = l11_grp.gcodes[i] = -1;
l3_grp.gcptr = l5_grp.gcptr = 3;
l11_grp.gcptr = 2;
i = 0;
while (i < start)
coeffs[i++] = 0;
for (i = start; i < end; i++) {
switch (bap[i]) {
case 0:
if (!dith_flag) {
coeffs[i] = 0;
continue;
}
else {
mantissa = dither_int16(state);
coeffs[i] = to_float(exps[i], mantissa) * chcoeff;
continue;
}
case 1:
if (l3_grp.gcptr > 2) {
gcode = get_bits(gb, 5);
if (gcode > 26)
return -1;
l3_grp.gcodes[0] = gcode / 9;
l3_grp.gcodes[1] = (gcode % 9) / 3;
l3_grp.gcodes[2] = (gcode % 9) % 3;
l3_grp.gcptr = 0;
}
mantissa = l3_q_tab[l3_grp.gcodes[l3_grp.gcptr++]];
coeffs[i] = to_float(exps[i], mantissa) * chcoeff;
continue;
case 2:
if (l5_grp.gcptr > 2) {
gcode = get_bits(gb, 7);
if (gcode > 124)
return -1;
l5_grp.gcodes[0] = gcode / 25;
l5_grp.gcodes[1] = (gcode % 25) / 5;
l5_grp.gcodes[2] = (gcode % 25) % 5;
l5_grp.gcptr = 0;
}
mantissa = l5_q_tab[l5_grp.gcodes[l5_grp.gcptr++]];
coeffs[i] = to_float(exps[i], mantissa) * chcoeff;
continue;
case 3:
mantissa = get_bits(gb, 3);
if (mantissa > 6)
return -1;
mantissa = l7_q_tab[mantissa];
coeffs[i] = to_float(exps[i], mantissa);
continue;
case 4:
if (l11_grp.gcptr > 1) {
gcode = get_bits(gb, 7);
if (gcode > 120)
return -1;
l11_grp.gcodes[0] = gcode / 11;
l11_grp.gcodes[1] = gcode % 11;
}
mantissa = l11_q_tab[l11_grp.gcodes[l11_grp.gcptr++]];
coeffs[i] = to_float(exps[i], mantissa) * chcoeff;
continue;
case 5:
mantissa = get_bits(gb, 4);
if (mantissa > 14)
return -1;
mantissa = l15_q_tab[mantissa];
coeffs[i] = to_float(exps[i], mantissa) * chcoeff;
continue;
default:
mantissa = get_bits(gb, qntztab[bap[i]]) << (16 - qntztab[bap[i]]);
coeffs[i] = to_float(exps[i], mantissa) * chcoeff;
continue;
}
}
i = end;
while (i < 256)
coeffs[i++] = 0;
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(uint8_t *VAR_0, uint8_t *VAR_1, float VAR_2,
float *VAR_3, int VAR_4, int VAR_5, int VAR_6, GetBitContext *VAR_7,
dither_state *VAR_8)
{
int16_t mantissa;
int VAR_9;
int VAR_10;
mant_group l3_grp, l5_grp, l11_grp;
for (VAR_9 = 0; VAR_9 < 3; VAR_9++)
l3_grp.gcodes[VAR_9] = l5_grp.gcodes[VAR_9] = l11_grp.gcodes[VAR_9] = -1;
l3_grp.gcptr = l5_grp.gcptr = 3;
l11_grp.gcptr = 2;
VAR_9 = 0;
while (VAR_9 < VAR_4)
VAR_3[VAR_9++] = 0;
for (VAR_9 = VAR_4; VAR_9 < VAR_5; VAR_9++) {
switch (VAR_1[VAR_9]) {
case 0:
if (!VAR_6) {
VAR_3[VAR_9] = 0;
continue;
}
else {
mantissa = dither_int16(VAR_8);
VAR_3[VAR_9] = to_float(VAR_0[VAR_9], mantissa) * VAR_2;
continue;
}
case 1:
if (l3_grp.gcptr > 2) {
VAR_10 = get_bits(VAR_7, 5);
if (VAR_10 > 26)
return -1;
l3_grp.gcodes[0] = VAR_10 / 9;
l3_grp.gcodes[1] = (VAR_10 % 9) / 3;
l3_grp.gcodes[2] = (VAR_10 % 9) % 3;
l3_grp.gcptr = 0;
}
mantissa = l3_q_tab[l3_grp.gcodes[l3_grp.gcptr++]];
VAR_3[VAR_9] = to_float(VAR_0[VAR_9], mantissa) * VAR_2;
continue;
case 2:
if (l5_grp.gcptr > 2) {
VAR_10 = get_bits(VAR_7, 7);
if (VAR_10 > 124)
return -1;
l5_grp.gcodes[0] = VAR_10 / 25;
l5_grp.gcodes[1] = (VAR_10 % 25) / 5;
l5_grp.gcodes[2] = (VAR_10 % 25) % 5;
l5_grp.gcptr = 0;
}
mantissa = l5_q_tab[l5_grp.gcodes[l5_grp.gcptr++]];
VAR_3[VAR_9] = to_float(VAR_0[VAR_9], mantissa) * VAR_2;
continue;
case 3:
mantissa = get_bits(VAR_7, 3);
if (mantissa > 6)
return -1;
mantissa = l7_q_tab[mantissa];
VAR_3[VAR_9] = to_float(VAR_0[VAR_9], mantissa);
continue;
case 4:
if (l11_grp.gcptr > 1) {
VAR_10 = get_bits(VAR_7, 7);
if (VAR_10 > 120)
return -1;
l11_grp.gcodes[0] = VAR_10 / 11;
l11_grp.gcodes[1] = VAR_10 % 11;
}
mantissa = l11_q_tab[l11_grp.gcodes[l11_grp.gcptr++]];
VAR_3[VAR_9] = to_float(VAR_0[VAR_9], mantissa) * VAR_2;
continue;
case 5:
mantissa = get_bits(VAR_7, 4);
if (mantissa > 14)
return -1;
mantissa = l15_q_tab[mantissa];
VAR_3[VAR_9] = to_float(VAR_0[VAR_9], mantissa) * VAR_2;
continue;
default:
mantissa = get_bits(VAR_7, qntztab[VAR_1[VAR_9]]) << (16 - qntztab[VAR_1[VAR_9]]);
VAR_3[VAR_9] = to_float(VAR_0[VAR_9], mantissa) * VAR_2;
continue;
}
}
VAR_9 = VAR_5;
while (VAR_9 < 256)
VAR_3[VAR_9++] = 0;
return 0;
}
| [
"static int FUNC_0(uint8_t *VAR_0, uint8_t *VAR_1, float VAR_2,\nfloat *VAR_3, int VAR_4, int VAR_5, int VAR_6, GetBitContext *VAR_7,\ndither_state *VAR_8)\n{",
"int16_t mantissa;",
"int VAR_9;",
"int VAR_10;",
"mant_group l3_grp, l5_grp, l11_grp;",
"for (VAR_9 = 0; VAR_9 < 3; VAR_9++)",
"l3_grp.gcodes[VAR_9] = l5_grp.gcodes[VAR_9] = l11_grp.gcodes[VAR_9] = -1;",
"l3_grp.gcptr = l5_grp.gcptr = 3;",
"l11_grp.gcptr = 2;",
"VAR_9 = 0;",
"while (VAR_9 < VAR_4)\nVAR_3[VAR_9++] = 0;",
"for (VAR_9 = VAR_4; VAR_9 < VAR_5; VAR_9++) {",
"switch (VAR_1[VAR_9]) {",
"case 0:\nif (!VAR_6) {",
"VAR_3[VAR_9] = 0;",
"continue;",
"}",
"else {",
"mantissa = dither_int16(VAR_8);",
"VAR_3[VAR_9] = to_float(VAR_0[VAR_9], mantissa) * VAR_2;",
"continue;",
"}",
"case 1:\nif (l3_grp.gcptr > 2) {",
"VAR_10 = get_bits(VAR_7, 5);",
"if (VAR_10 > 26)\nreturn -1;",
"l3_grp.gcodes[0] = VAR_10 / 9;",
"l3_grp.gcodes[1] = (VAR_10 % 9) / 3;",
"l3_grp.gcodes[2] = (VAR_10 % 9) % 3;",
"l3_grp.gcptr = 0;",
"}",
"mantissa = l3_q_tab[l3_grp.gcodes[l3_grp.gcptr++]];",
"VAR_3[VAR_9] = to_float(VAR_0[VAR_9], mantissa) * VAR_2;",
"continue;",
"case 2:\nif (l5_grp.gcptr > 2) {",
"VAR_10 = get_bits(VAR_7, 7);",
"if (VAR_10 > 124)\nreturn -1;",
"l5_grp.gcodes[0] = VAR_10 / 25;",
"l5_grp.gcodes[1] = (VAR_10 % 25) / 5;",
"l5_grp.gcodes[2] = (VAR_10 % 25) % 5;",
"l5_grp.gcptr = 0;",
"}",
"mantissa = l5_q_tab[l5_grp.gcodes[l5_grp.gcptr++]];",
"VAR_3[VAR_9] = to_float(VAR_0[VAR_9], mantissa) * VAR_2;",
"continue;",
"case 3:\nmantissa = get_bits(VAR_7, 3);",
"if (mantissa > 6)\nreturn -1;",
"mantissa = l7_q_tab[mantissa];",
"VAR_3[VAR_9] = to_float(VAR_0[VAR_9], mantissa);",
"continue;",
"case 4:\nif (l11_grp.gcptr > 1) {",
"VAR_10 = get_bits(VAR_7, 7);",
"if (VAR_10 > 120)\nreturn -1;",
"l11_grp.gcodes[0] = VAR_10 / 11;",
"l11_grp.gcodes[1] = VAR_10 % 11;",
"}",
"mantissa = l11_q_tab[l11_grp.gcodes[l11_grp.gcptr++]];",
"VAR_3[VAR_9] = to_float(VAR_0[VAR_9], mantissa) * VAR_2;",
"continue;",
"case 5:\nmantissa = get_bits(VAR_7, 4);",
"if (mantissa > 14)\nreturn -1;",
"mantissa = l15_q_tab[mantissa];",
"VAR_3[VAR_9] = to_float(VAR_0[VAR_9], mantissa) * VAR_2;",
"continue;",
"default:\nmantissa = get_bits(VAR_7, qntztab[VAR_1[VAR_9]]) << (16 - qntztab[VAR_1[VAR_9]]);",
"VAR_3[VAR_9] = to_float(VAR_0[VAR_9], mantissa) * VAR_2;",
"continue;",
"}",
"}",
"VAR_9 = VAR_5;",
"while (VAR_9 < 256)\nVAR_3[VAR_9++] = 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
] | [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31,
33
],
[
37
],
[
39
],
[
41,
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63,
65
],
[
67
],
[
69,
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
91,
93
],
[
95
],
[
97,
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
119,
121
],
[
123,
125
],
[
127
],
[
129
],
[
131
],
[
135,
137
],
[
139
],
[
141,
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
159,
161
],
[
163,
165
],
[
167
],
[
169
],
[
171
],
[
175,
177
],
[
179
],
[
181
],
[
183
],
[
185
],
[
189
],
[
191,
193
],
[
197
],
[
199
]
] |
24,086 | static int usb_host_update_interfaces(USBHostDevice *dev, int configuration)
{
int dev_descr_len, config_descr_len;
int interface, nb_interfaces, nb_configurations;
int ret, i;
if (configuration == 0) /* address state - ignore */
return 1;
i = 0;
dev_descr_len = dev->descr[0];
if (dev_descr_len > dev->descr_len)
goto fail;
nb_configurations = dev->descr[17];
i += dev_descr_len;
while (i < dev->descr_len) {
#ifdef DEBUG
printf("i is %d, descr_len is %d, dl %d, dt %d\n", i, dev->descr_len,
dev->descr[i], dev->descr[i+1]);
#endif
if (dev->descr[i+1] != USB_DT_CONFIG) {
i += dev->descr[i];
continue;
}
config_descr_len = dev->descr[i];
if (configuration == dev->descr[i + 5])
break;
i += config_descr_len;
}
if (i >= dev->descr_len) {
printf("usb_host: error - device has no matching configuration\n");
goto fail;
}
nb_interfaces = dev->descr[i + 4];
#ifdef USBDEVFS_DISCONNECT
/* earlier Linux 2.4 do not support that */
{
struct usbdevfs_ioctl ctrl;
for (interface = 0; interface < nb_interfaces; interface++) {
ctrl.ioctl_code = USBDEVFS_DISCONNECT;
ctrl.ifno = interface;
ret = ioctl(dev->fd, USBDEVFS_IOCTL, &ctrl);
if (ret < 0 && errno != ENODATA) {
perror("USBDEVFS_DISCONNECT");
goto fail;
}
}
}
#endif
/* XXX: only grab if all interfaces are free */
for (interface = 0; interface < nb_interfaces; interface++) {
ret = ioctl(dev->fd, USBDEVFS_CLAIMINTERFACE, &interface);
if (ret < 0) {
if (errno == EBUSY) {
fprintf(stderr,
"usb_host: warning - device already grabbed\n");
} else {
perror("USBDEVFS_CLAIMINTERFACE");
}
fail:
return 0;
}
}
#ifdef DEBUG
printf("usb_host: %d interfaces claimed for configuration %d\n",
nb_interfaces, configuration);
#endif
return 1;
}
| false | qemu | 1f3870ab242018b724b845957f7f928a2d7c1f5b | static int usb_host_update_interfaces(USBHostDevice *dev, int configuration)
{
int dev_descr_len, config_descr_len;
int interface, nb_interfaces, nb_configurations;
int ret, i;
if (configuration == 0)
return 1;
i = 0;
dev_descr_len = dev->descr[0];
if (dev_descr_len > dev->descr_len)
goto fail;
nb_configurations = dev->descr[17];
i += dev_descr_len;
while (i < dev->descr_len) {
#ifdef DEBUG
printf("i is %d, descr_len is %d, dl %d, dt %d\n", i, dev->descr_len,
dev->descr[i], dev->descr[i+1]);
#endif
if (dev->descr[i+1] != USB_DT_CONFIG) {
i += dev->descr[i];
continue;
}
config_descr_len = dev->descr[i];
if (configuration == dev->descr[i + 5])
break;
i += config_descr_len;
}
if (i >= dev->descr_len) {
printf("usb_host: error - device has no matching configuration\n");
goto fail;
}
nb_interfaces = dev->descr[i + 4];
#ifdef USBDEVFS_DISCONNECT
{
struct usbdevfs_ioctl ctrl;
for (interface = 0; interface < nb_interfaces; interface++) {
ctrl.ioctl_code = USBDEVFS_DISCONNECT;
ctrl.ifno = interface;
ret = ioctl(dev->fd, USBDEVFS_IOCTL, &ctrl);
if (ret < 0 && errno != ENODATA) {
perror("USBDEVFS_DISCONNECT");
goto fail;
}
}
}
#endif
for (interface = 0; interface < nb_interfaces; interface++) {
ret = ioctl(dev->fd, USBDEVFS_CLAIMINTERFACE, &interface);
if (ret < 0) {
if (errno == EBUSY) {
fprintf(stderr,
"usb_host: warning - device already grabbed\n");
} else {
perror("USBDEVFS_CLAIMINTERFACE");
}
fail:
return 0;
}
}
#ifdef DEBUG
printf("usb_host: %d interfaces claimed for configuration %d\n",
nb_interfaces, configuration);
#endif
return 1;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(USBHostDevice *VAR_0, int VAR_1)
{
int VAR_2, VAR_3;
int VAR_4, VAR_5, VAR_6;
int VAR_7, VAR_8;
if (VAR_1 == 0)
return 1;
VAR_8 = 0;
VAR_2 = VAR_0->descr[0];
if (VAR_2 > VAR_0->descr_len)
goto fail;
VAR_6 = VAR_0->descr[17];
VAR_8 += VAR_2;
while (VAR_8 < VAR_0->descr_len) {
#ifdef DEBUG
printf("VAR_8 is %d, descr_len is %d, dl %d, dt %d\n", VAR_8, VAR_0->descr_len,
VAR_0->descr[VAR_8], VAR_0->descr[VAR_8+1]);
#endif
if (VAR_0->descr[VAR_8+1] != USB_DT_CONFIG) {
VAR_8 += VAR_0->descr[VAR_8];
continue;
}
VAR_3 = VAR_0->descr[VAR_8];
if (VAR_1 == VAR_0->descr[VAR_8 + 5])
break;
VAR_8 += VAR_3;
}
if (VAR_8 >= VAR_0->descr_len) {
printf("usb_host: error - device has no matching VAR_1\n");
goto fail;
}
VAR_5 = VAR_0->descr[VAR_8 + 4];
#ifdef USBDEVFS_DISCONNECT
{
struct usbdevfs_ioctl ctrl;
for (VAR_4 = 0; VAR_4 < VAR_5; VAR_4++) {
ctrl.ioctl_code = USBDEVFS_DISCONNECT;
ctrl.ifno = VAR_4;
VAR_7 = ioctl(VAR_0->fd, USBDEVFS_IOCTL, &ctrl);
if (VAR_7 < 0 && errno != ENODATA) {
perror("USBDEVFS_DISCONNECT");
goto fail;
}
}
}
#endif
for (VAR_4 = 0; VAR_4 < VAR_5; VAR_4++) {
VAR_7 = ioctl(VAR_0->fd, USBDEVFS_CLAIMINTERFACE, &VAR_4);
if (VAR_7 < 0) {
if (errno == EBUSY) {
fprintf(stderr,
"usb_host: warning - device already grabbed\n");
} else {
perror("USBDEVFS_CLAIMINTERFACE");
}
fail:
return 0;
}
}
#ifdef DEBUG
printf("usb_host: %d interfaces claimed for VAR_1 %d\n",
VAR_5, VAR_1);
#endif
return 1;
}
| [
"static int FUNC_0(USBHostDevice *VAR_0, int VAR_1)\n{",
"int VAR_2, VAR_3;",
"int VAR_4, VAR_5, VAR_6;",
"int VAR_7, VAR_8;",
"if (VAR_1 == 0)\nreturn 1;",
"VAR_8 = 0;",
"VAR_2 = VAR_0->descr[0];",
"if (VAR_2 > VAR_0->descr_len)\ngoto fail;",
"VAR_6 = VAR_0->descr[17];",
"VAR_8 += VAR_2;",
"while (VAR_8 < VAR_0->descr_len) {",
"#ifdef DEBUG\nprintf(\"VAR_8 is %d, descr_len is %d, dl %d, dt %d\\n\", VAR_8, VAR_0->descr_len,\nVAR_0->descr[VAR_8], VAR_0->descr[VAR_8+1]);",
"#endif\nif (VAR_0->descr[VAR_8+1] != USB_DT_CONFIG) {",
"VAR_8 += VAR_0->descr[VAR_8];",
"continue;",
"}",
"VAR_3 = VAR_0->descr[VAR_8];",
"if (VAR_1 == VAR_0->descr[VAR_8 + 5])\nbreak;",
"VAR_8 += VAR_3;",
"}",
"if (VAR_8 >= VAR_0->descr_len) {",
"printf(\"usb_host: error - device has no matching VAR_1\\n\");",
"goto fail;",
"}",
"VAR_5 = VAR_0->descr[VAR_8 + 4];",
"#ifdef USBDEVFS_DISCONNECT\n{",
"struct usbdevfs_ioctl ctrl;",
"for (VAR_4 = 0; VAR_4 < VAR_5; VAR_4++) {",
"ctrl.ioctl_code = USBDEVFS_DISCONNECT;",
"ctrl.ifno = VAR_4;",
"VAR_7 = ioctl(VAR_0->fd, USBDEVFS_IOCTL, &ctrl);",
"if (VAR_7 < 0 && errno != ENODATA) {",
"perror(\"USBDEVFS_DISCONNECT\");",
"goto fail;",
"}",
"}",
"}",
"#endif\nfor (VAR_4 = 0; VAR_4 < VAR_5; VAR_4++) {",
"VAR_7 = ioctl(VAR_0->fd, USBDEVFS_CLAIMINTERFACE, &VAR_4);",
"if (VAR_7 < 0) {",
"if (errno == EBUSY) {",
"fprintf(stderr,\n\"usb_host: warning - device already grabbed\\n\");",
"} else {",
"perror(\"USBDEVFS_CLAIMINTERFACE\");",
"}",
"fail:\nreturn 0;",
"}",
"}",
"#ifdef DEBUG\nprintf(\"usb_host: %d interfaces claimed for VAR_1 %d\\n\",\nVAR_5, VAR_1);",
"#endif\nreturn 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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13,
15
],
[
19
],
[
21
],
[
23,
25
],
[
27
],
[
31
],
[
33
],
[
35,
37,
39
],
[
41,
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55,
57
],
[
61
],
[
63
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
79,
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107,
113
],
[
115
],
[
117
],
[
119
],
[
121,
123
],
[
125
],
[
127
],
[
129
],
[
131,
133
],
[
135
],
[
137
],
[
141,
143,
145
],
[
147,
151
],
[
153
]
] |
24,088 | static int get_block_status(BlockDriverState *bs, int64_t offset,
int64_t bytes, MapEntry *e)
{
int64_t ret;
int depth;
BlockDriverState *file;
bool has_offset;
int nb_sectors = bytes >> BDRV_SECTOR_BITS;
assert(bytes < INT_MAX);
/* As an optimization, we could cache the current range of unallocated
* clusters in each file of the chain, and avoid querying the same
* range repeatedly.
*/
depth = 0;
for (;;) {
ret = bdrv_get_block_status(bs, offset >> BDRV_SECTOR_BITS, nb_sectors,
&nb_sectors, &file);
if (ret < 0) {
return ret;
}
assert(nb_sectors);
if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
break;
}
bs = backing_bs(bs);
if (bs == NULL) {
ret = 0;
break;
}
depth++;
}
has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID);
*e = (MapEntry) {
.start = offset,
.length = nb_sectors * BDRV_SECTOR_SIZE,
.data = !!(ret & BDRV_BLOCK_DATA),
.zero = !!(ret & BDRV_BLOCK_ZERO),
.offset = ret & BDRV_BLOCK_OFFSET_MASK,
.has_offset = has_offset,
.depth = depth,
.has_filename = file && has_offset,
.filename = file && has_offset ? file->filename : NULL,
};
return 0;
}
| false | qemu | 237d78f8fc62e62f62246883ecf62e44ed35fb80 | static int get_block_status(BlockDriverState *bs, int64_t offset,
int64_t bytes, MapEntry *e)
{
int64_t ret;
int depth;
BlockDriverState *file;
bool has_offset;
int nb_sectors = bytes >> BDRV_SECTOR_BITS;
assert(bytes < INT_MAX);
depth = 0;
for (;;) {
ret = bdrv_get_block_status(bs, offset >> BDRV_SECTOR_BITS, nb_sectors,
&nb_sectors, &file);
if (ret < 0) {
return ret;
}
assert(nb_sectors);
if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
break;
}
bs = backing_bs(bs);
if (bs == NULL) {
ret = 0;
break;
}
depth++;
}
has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID);
*e = (MapEntry) {
.start = offset,
.length = nb_sectors * BDRV_SECTOR_SIZE,
.data = !!(ret & BDRV_BLOCK_DATA),
.zero = !!(ret & BDRV_BLOCK_ZERO),
.offset = ret & BDRV_BLOCK_OFFSET_MASK,
.has_offset = has_offset,
.depth = depth,
.has_filename = file && has_offset,
.filename = file && has_offset ? file->filename : NULL,
};
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(BlockDriverState *VAR_0, int64_t VAR_1,
int64_t VAR_2, MapEntry *VAR_3)
{
int64_t ret;
int VAR_4;
BlockDriverState *file;
bool has_offset;
int VAR_5 = VAR_2 >> BDRV_SECTOR_BITS;
assert(VAR_2 < INT_MAX);
VAR_4 = 0;
for (;;) {
ret = bdrv_get_block_status(VAR_0, VAR_1 >> BDRV_SECTOR_BITS, VAR_5,
&VAR_5, &file);
if (ret < 0) {
return ret;
}
assert(VAR_5);
if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {
break;
}
VAR_0 = backing_bs(VAR_0);
if (VAR_0 == NULL) {
ret = 0;
break;
}
VAR_4++;
}
has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID);
*VAR_3 = (MapEntry) {
.start = VAR_1,
.length = VAR_5 * BDRV_SECTOR_SIZE,
.data = !!(ret & BDRV_BLOCK_DATA),
.zero = !!(ret & BDRV_BLOCK_ZERO),
.VAR_1 = ret & BDRV_BLOCK_OFFSET_MASK,
.has_offset = has_offset,
.VAR_4 = VAR_4,
.has_filename = file && has_offset,
.filename = file && has_offset ? file->filename : NULL,
};
return 0;
}
| [
"static int FUNC_0(BlockDriverState *VAR_0, int64_t VAR_1,\nint64_t VAR_2, MapEntry *VAR_3)\n{",
"int64_t ret;",
"int VAR_4;",
"BlockDriverState *file;",
"bool has_offset;",
"int VAR_5 = VAR_2 >> BDRV_SECTOR_BITS;",
"assert(VAR_2 < INT_MAX);",
"VAR_4 = 0;",
"for (;;) {",
"ret = bdrv_get_block_status(VAR_0, VAR_1 >> BDRV_SECTOR_BITS, VAR_5,\n&VAR_5, &file);",
"if (ret < 0) {",
"return ret;",
"}",
"assert(VAR_5);",
"if (ret & (BDRV_BLOCK_ZERO|BDRV_BLOCK_DATA)) {",
"break;",
"}",
"VAR_0 = backing_bs(VAR_0);",
"if (VAR_0 == NULL) {",
"ret = 0;",
"break;",
"}",
"VAR_4++;",
"}",
"has_offset = !!(ret & BDRV_BLOCK_OFFSET_VALID);",
"*VAR_3 = (MapEntry) {",
".start = VAR_1,\n.length = VAR_5 * BDRV_SECTOR_SIZE,\n.data = !!(ret & BDRV_BLOCK_DATA),\n.zero = !!(ret & BDRV_BLOCK_ZERO),\n.VAR_1 = ret & BDRV_BLOCK_OFFSET_MASK,\n.has_offset = has_offset,\n.VAR_4 = VAR_4,\n.has_filename = file && has_offset,\n.filename = file && has_offset ? file->filename : NULL,\n};",
"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
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19
],
[
31
],
[
33
],
[
35,
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65
],
[
67
],
[
71
],
[
75
],
[
77,
79,
81,
83,
85,
87,
89,
91,
93,
95
],
[
99
],
[
101
]
] |
24,091 | static void *colo_compare_thread(void *opaque)
{
CompareState *s = opaque;
GSource *timeout_source;
s->worker_context = g_main_context_new();
qemu_chr_fe_set_handlers(&s->chr_pri_in, compare_chr_can_read,
compare_pri_chr_in, NULL, NULL,
s, s->worker_context, true);
qemu_chr_fe_set_handlers(&s->chr_sec_in, compare_chr_can_read,
compare_sec_chr_in, NULL, NULL,
s, s->worker_context, true);
s->compare_loop = g_main_loop_new(s->worker_context, FALSE);
/* To kick any packets that the secondary doesn't match */
timeout_source = g_timeout_source_new(REGULAR_PACKET_CHECK_MS);
g_source_set_callback(timeout_source,
(GSourceFunc)check_old_packet_regular, s, NULL);
g_source_attach(timeout_source, s->worker_context);
g_main_loop_run(s->compare_loop);
g_source_unref(timeout_source);
g_main_loop_unref(s->compare_loop);
g_main_context_unref(s->worker_context);
return NULL;
}
| false | qemu | dd321ecfc2e82e6f9578b986060b1aa3f036bd98 | static void *colo_compare_thread(void *opaque)
{
CompareState *s = opaque;
GSource *timeout_source;
s->worker_context = g_main_context_new();
qemu_chr_fe_set_handlers(&s->chr_pri_in, compare_chr_can_read,
compare_pri_chr_in, NULL, NULL,
s, s->worker_context, true);
qemu_chr_fe_set_handlers(&s->chr_sec_in, compare_chr_can_read,
compare_sec_chr_in, NULL, NULL,
s, s->worker_context, true);
s->compare_loop = g_main_loop_new(s->worker_context, FALSE);
timeout_source = g_timeout_source_new(REGULAR_PACKET_CHECK_MS);
g_source_set_callback(timeout_source,
(GSourceFunc)check_old_packet_regular, s, NULL);
g_source_attach(timeout_source, s->worker_context);
g_main_loop_run(s->compare_loop);
g_source_unref(timeout_source);
g_main_loop_unref(s->compare_loop);
g_main_context_unref(s->worker_context);
return NULL;
}
| {
"code": [],
"line_no": []
} | static void *FUNC_0(void *VAR_0)
{
CompareState *s = VAR_0;
GSource *timeout_source;
s->worker_context = g_main_context_new();
qemu_chr_fe_set_handlers(&s->chr_pri_in, compare_chr_can_read,
compare_pri_chr_in, NULL, NULL,
s, s->worker_context, true);
qemu_chr_fe_set_handlers(&s->chr_sec_in, compare_chr_can_read,
compare_sec_chr_in, NULL, NULL,
s, s->worker_context, true);
s->compare_loop = g_main_loop_new(s->worker_context, FALSE);
timeout_source = g_timeout_source_new(REGULAR_PACKET_CHECK_MS);
g_source_set_callback(timeout_source,
(GSourceFunc)check_old_packet_regular, s, NULL);
g_source_attach(timeout_source, s->worker_context);
g_main_loop_run(s->compare_loop);
g_source_unref(timeout_source);
g_main_loop_unref(s->compare_loop);
g_main_context_unref(s->worker_context);
return NULL;
}
| [
"static void *FUNC_0(void *VAR_0)\n{",
"CompareState *s = VAR_0;",
"GSource *timeout_source;",
"s->worker_context = g_main_context_new();",
"qemu_chr_fe_set_handlers(&s->chr_pri_in, compare_chr_can_read,\ncompare_pri_chr_in, NULL, NULL,\ns, s->worker_context, true);",
"qemu_chr_fe_set_handlers(&s->chr_sec_in, compare_chr_can_read,\ncompare_sec_chr_in, NULL, NULL,\ns, s->worker_context, true);",
"s->compare_loop = g_main_loop_new(s->worker_context, FALSE);",
"timeout_source = g_timeout_source_new(REGULAR_PACKET_CHECK_MS);",
"g_source_set_callback(timeout_source,\n(GSourceFunc)check_old_packet_regular, s, NULL);",
"g_source_attach(timeout_source, s->worker_context);",
"g_main_loop_run(s->compare_loop);",
"g_source_unref(timeout_source);",
"g_main_loop_unref(s->compare_loop);",
"g_main_context_unref(s->worker_context);",
"return NULL;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
15,
17,
19
],
[
21,
23,
25
],
[
29
],
[
35
],
[
37,
39
],
[
41
],
[
45
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
]
] |
24,092 | static int find_image_format(BlockDriverState *bs, const char *filename,
BlockDriver **pdrv, Error **errp)
{
BlockDriver *drv;
uint8_t buf[BLOCK_PROBE_BUF_SIZE];
int ret = 0;
/* Return the raw BlockDriver * to scsi-generic devices or empty drives */
if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
*pdrv = &bdrv_raw;
return ret;
}
ret = bdrv_pread(bs, 0, buf, sizeof(buf));
if (ret < 0) {
error_setg_errno(errp, -ret, "Could not read image for determining its "
"format");
*pdrv = NULL;
return ret;
}
drv = bdrv_probe_all(buf, ret, filename);
if (!drv) {
error_setg(errp, "Could not determine image format: No compatible "
"driver found");
ret = -ENOENT;
}
*pdrv = drv;
return ret;
}
| false | qemu | b192af8acc597a6e8068873434e56e0c7de1b7d3 | static int find_image_format(BlockDriverState *bs, const char *filename,
BlockDriver **pdrv, Error **errp)
{
BlockDriver *drv;
uint8_t buf[BLOCK_PROBE_BUF_SIZE];
int ret = 0;
if (bs->sg || !bdrv_is_inserted(bs) || bdrv_getlength(bs) == 0) {
*pdrv = &bdrv_raw;
return ret;
}
ret = bdrv_pread(bs, 0, buf, sizeof(buf));
if (ret < 0) {
error_setg_errno(errp, -ret, "Could not read image for determining its "
"format");
*pdrv = NULL;
return ret;
}
drv = bdrv_probe_all(buf, ret, filename);
if (!drv) {
error_setg(errp, "Could not determine image format: No compatible "
"driver found");
ret = -ENOENT;
}
*pdrv = drv;
return ret;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(BlockDriverState *VAR_0, const char *VAR_1,
BlockDriver **VAR_2, Error **VAR_3)
{
BlockDriver *drv;
uint8_t buf[BLOCK_PROBE_BUF_SIZE];
int VAR_4 = 0;
if (VAR_0->sg || !bdrv_is_inserted(VAR_0) || bdrv_getlength(VAR_0) == 0) {
*VAR_2 = &bdrv_raw;
return VAR_4;
}
VAR_4 = bdrv_pread(VAR_0, 0, buf, sizeof(buf));
if (VAR_4 < 0) {
error_setg_errno(VAR_3, -VAR_4, "Could not read image for determining its "
"format");
*VAR_2 = NULL;
return VAR_4;
}
drv = bdrv_probe_all(buf, VAR_4, VAR_1);
if (!drv) {
error_setg(VAR_3, "Could not determine image format: No compatible "
"driver found");
VAR_4 = -ENOENT;
}
*VAR_2 = drv;
return VAR_4;
}
| [
"static int FUNC_0(BlockDriverState *VAR_0, const char *VAR_1,\nBlockDriver **VAR_2, Error **VAR_3)\n{",
"BlockDriver *drv;",
"uint8_t buf[BLOCK_PROBE_BUF_SIZE];",
"int VAR_4 = 0;",
"if (VAR_0->sg || !bdrv_is_inserted(VAR_0) || bdrv_getlength(VAR_0) == 0) {",
"*VAR_2 = &bdrv_raw;",
"return VAR_4;",
"}",
"VAR_4 = bdrv_pread(VAR_0, 0, buf, sizeof(buf));",
"if (VAR_4 < 0) {",
"error_setg_errno(VAR_3, -VAR_4, \"Could not read image for determining its \"\n\"format\");",
"*VAR_2 = NULL;",
"return VAR_4;",
"}",
"drv = bdrv_probe_all(buf, VAR_4, VAR_1);",
"if (!drv) {",
"error_setg(VAR_3, \"Could not determine image format: No compatible \"\n\"driver found\");",
"VAR_4 = -ENOENT;",
"}",
"*VAR_2 = drv;",
"return VAR_4;",
"}"
] | [
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
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29
],
[
31,
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47,
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
]
] |
24,093 | static int fits_write_packet(AVFormatContext *s, AVPacket *pkt)
{
write_image_header(s);
avio_write(s->pb, pkt->data, pkt->size);
return 0;
}
| false | FFmpeg | 284b432662b6e137148ff9d13ef2b554cb14b4ae | static int fits_write_packet(AVFormatContext *s, AVPacket *pkt)
{
write_image_header(s);
avio_write(s->pb, pkt->data, pkt->size);
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)
{
write_image_header(VAR_0);
avio_write(VAR_0->pb, VAR_1->data, VAR_1->size);
return 0;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0, AVPacket *VAR_1)\n{",
"write_image_header(VAR_0);",
"avio_write(VAR_0->pb, VAR_1->data, VAR_1->size);",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
]
] |
24,094 | static void uart_parameters_setup(UartState *s)
{
QEMUSerialSetParams ssp;
unsigned int baud_rate, packet_size;
baud_rate = (s->r[R_MR] & UART_MR_CLKS) ?
UART_INPUT_CLK / 8 : UART_INPUT_CLK;
ssp.speed = baud_rate / (s->r[R_BRGR] * (s->r[R_BDIV] + 1));
packet_size = 1;
switch (s->r[R_MR] & UART_MR_PAR) {
case UART_PARITY_EVEN:
ssp.parity = 'E';
packet_size++;
break;
case UART_PARITY_ODD:
ssp.parity = 'O';
packet_size++;
break;
default:
ssp.parity = 'N';
break;
}
switch (s->r[R_MR] & UART_MR_CHRL) {
case UART_DATA_BITS_6:
ssp.data_bits = 6;
break;
case UART_DATA_BITS_7:
ssp.data_bits = 7;
break;
default:
ssp.data_bits = 8;
break;
}
switch (s->r[R_MR] & UART_MR_NBSTOP) {
case UART_STOP_BITS_1:
ssp.stop_bits = 1;
break;
default:
ssp.stop_bits = 2;
break;
}
packet_size += ssp.data_bits + ssp.stop_bits;
s->char_tx_time = (get_ticks_per_sec() / ssp.speed) * packet_size;
qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_SERIAL_SET_PARAMS, &ssp);
}
| false | qemu | af52fe862fba686713044efdf9158195f84535ab | static void uart_parameters_setup(UartState *s)
{
QEMUSerialSetParams ssp;
unsigned int baud_rate, packet_size;
baud_rate = (s->r[R_MR] & UART_MR_CLKS) ?
UART_INPUT_CLK / 8 : UART_INPUT_CLK;
ssp.speed = baud_rate / (s->r[R_BRGR] * (s->r[R_BDIV] + 1));
packet_size = 1;
switch (s->r[R_MR] & UART_MR_PAR) {
case UART_PARITY_EVEN:
ssp.parity = 'E';
packet_size++;
break;
case UART_PARITY_ODD:
ssp.parity = 'O';
packet_size++;
break;
default:
ssp.parity = 'N';
break;
}
switch (s->r[R_MR] & UART_MR_CHRL) {
case UART_DATA_BITS_6:
ssp.data_bits = 6;
break;
case UART_DATA_BITS_7:
ssp.data_bits = 7;
break;
default:
ssp.data_bits = 8;
break;
}
switch (s->r[R_MR] & UART_MR_NBSTOP) {
case UART_STOP_BITS_1:
ssp.stop_bits = 1;
break;
default:
ssp.stop_bits = 2;
break;
}
packet_size += ssp.data_bits + ssp.stop_bits;
s->char_tx_time = (get_ticks_per_sec() / ssp.speed) * packet_size;
qemu_chr_fe_ioctl(s->chr, CHR_IOCTL_SERIAL_SET_PARAMS, &ssp);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(UartState *VAR_0)
{
QEMUSerialSetParams ssp;
unsigned int VAR_1, VAR_2;
VAR_1 = (VAR_0->r[R_MR] & UART_MR_CLKS) ?
UART_INPUT_CLK / 8 : UART_INPUT_CLK;
ssp.speed = VAR_1 / (VAR_0->r[R_BRGR] * (VAR_0->r[R_BDIV] + 1));
VAR_2 = 1;
switch (VAR_0->r[R_MR] & UART_MR_PAR) {
case UART_PARITY_EVEN:
ssp.parity = 'E';
VAR_2++;
break;
case UART_PARITY_ODD:
ssp.parity = 'O';
VAR_2++;
break;
default:
ssp.parity = 'N';
break;
}
switch (VAR_0->r[R_MR] & UART_MR_CHRL) {
case UART_DATA_BITS_6:
ssp.data_bits = 6;
break;
case UART_DATA_BITS_7:
ssp.data_bits = 7;
break;
default:
ssp.data_bits = 8;
break;
}
switch (VAR_0->r[R_MR] & UART_MR_NBSTOP) {
case UART_STOP_BITS_1:
ssp.stop_bits = 1;
break;
default:
ssp.stop_bits = 2;
break;
}
VAR_2 += ssp.data_bits + ssp.stop_bits;
VAR_0->char_tx_time = (get_ticks_per_sec() / ssp.speed) * VAR_2;
qemu_chr_fe_ioctl(VAR_0->chr, CHR_IOCTL_SERIAL_SET_PARAMS, &ssp);
}
| [
"static void FUNC_0(UartState *VAR_0)\n{",
"QEMUSerialSetParams ssp;",
"unsigned int VAR_1, VAR_2;",
"VAR_1 = (VAR_0->r[R_MR] & UART_MR_CLKS) ?\nUART_INPUT_CLK / 8 : UART_INPUT_CLK;",
"ssp.speed = VAR_1 / (VAR_0->r[R_BRGR] * (VAR_0->r[R_BDIV] + 1));",
"VAR_2 = 1;",
"switch (VAR_0->r[R_MR] & UART_MR_PAR) {",
"case UART_PARITY_EVEN:\nssp.parity = 'E';",
"VAR_2++;",
"break;",
"case UART_PARITY_ODD:\nssp.parity = 'O';",
"VAR_2++;",
"break;",
"default:\nssp.parity = 'N';",
"break;",
"}",
"switch (VAR_0->r[R_MR] & UART_MR_CHRL) {",
"case UART_DATA_BITS_6:\nssp.data_bits = 6;",
"break;",
"case UART_DATA_BITS_7:\nssp.data_bits = 7;",
"break;",
"default:\nssp.data_bits = 8;",
"break;",
"}",
"switch (VAR_0->r[R_MR] & UART_MR_NBSTOP) {",
"case UART_STOP_BITS_1:\nssp.stop_bits = 1;",
"break;",
"default:\nssp.stop_bits = 2;",
"break;",
"}",
"VAR_2 += ssp.data_bits + ssp.stop_bits;",
"VAR_0->char_tx_time = (get_ticks_per_sec() / ssp.speed) * VAR_2;",
"qemu_chr_fe_ioctl(VAR_0->chr, CHR_IOCTL_SERIAL_SET_PARAMS, &ssp);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
13
],
[
17
],
[
19
],
[
23
],
[
25,
27
],
[
29
],
[
31
],
[
33,
35
],
[
37
],
[
39
],
[
41,
43
],
[
45
],
[
47
],
[
51
],
[
53,
55
],
[
57
],
[
59,
61
],
[
63
],
[
65,
67
],
[
69
],
[
71
],
[
75
],
[
77,
79
],
[
81
],
[
83,
85
],
[
87
],
[
89
],
[
93
],
[
95
],
[
97
],
[
99
]
] |
24,096 | eth_read(void *opaque, target_phys_addr_t addr, unsigned int size)
{
struct fs_eth *eth = opaque;
uint32_t r = 0;
addr >>= 2;
switch (addr) {
case R_STAT:
r = eth->mdio_bus.mdio & 1;
break;
default:
r = eth->regs[addr];
D(printf ("%s %x\n", __func__, addr * 4));
break;
}
return r;
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | eth_read(void *opaque, target_phys_addr_t addr, unsigned int size)
{
struct fs_eth *eth = opaque;
uint32_t r = 0;
addr >>= 2;
switch (addr) {
case R_STAT:
r = eth->mdio_bus.mdio & 1;
break;
default:
r = eth->regs[addr];
D(printf ("%s %x\n", __func__, addr * 4));
break;
}
return r;
}
| {
"code": [],
"line_no": []
} | FUNC_0(void *VAR_0, target_phys_addr_t VAR_1, unsigned int VAR_2)
{
struct fs_eth *VAR_3 = VAR_0;
uint32_t r = 0;
VAR_1 >>= 2;
switch (VAR_1) {
case R_STAT:
r = VAR_3->mdio_bus.mdio & 1;
break;
default:
r = VAR_3->regs[VAR_1];
D(printf ("%s %x\n", __func__, VAR_1 * 4));
break;
}
return r;
}
| [
"FUNC_0(void *VAR_0, target_phys_addr_t VAR_1, unsigned int VAR_2)\n{",
"struct fs_eth *VAR_3 = VAR_0;",
"uint32_t r = 0;",
"VAR_1 >>= 2;",
"switch (VAR_1) {",
"case R_STAT:\nr = VAR_3->mdio_bus.mdio & 1;",
"break;",
"default:\nr = VAR_3->regs[VAR_1];",
"D(printf (\"%s %x\\n\", __func__, VAR_1 * 4));",
"break;",
"}",
"return r;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
15
],
[
17,
19
],
[
21
],
[
23,
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
]
] |
24,097 | int vnc_display_open(DisplayState *ds, const char *display)
{
VncState *vs = ds ? (VncState *)ds->opaque : vnc_state;
const char *options;
int password = 0;
int reverse = 0;
int to_port = 0;
#ifdef CONFIG_VNC_TLS
int tls = 0, x509 = 0;
#endif
vnc_display_close(ds);
if (strcmp(display, "none") == 0)
return 0;
if (!(vs->display = strdup(display)))
return -1;
options = display;
while ((options = strchr(options, ','))) {
options++;
if (strncmp(options, "password", 8) == 0) {
password = 1; /* Require password auth */
} else if (strncmp(options, "reverse", 7) == 0) {
reverse = 1;
} else if (strncmp(options, "to=", 3) == 0) {
to_port = atoi(options+3) + 5900;
#ifdef CONFIG_VNC_TLS
} else if (strncmp(options, "tls", 3) == 0) {
tls = 1; /* Require TLS */
} else if (strncmp(options, "x509", 4) == 0) {
char *start, *end;
x509 = 1; /* Require x509 certificates */
if (strncmp(options, "x509verify", 10) == 0)
vs->x509verify = 1; /* ...and verify client certs */
/* Now check for 'x509=/some/path' postfix
* and use that to setup x509 certificate/key paths */
start = strchr(options, '=');
end = strchr(options, ',');
if (start && (!end || (start < end))) {
int len = end ? end-(start+1) : strlen(start+1);
char *path = qemu_malloc(len+1);
pstrcpy(path, len, start + 1);
path[len] = '\0';
VNC_DEBUG("Trying certificate path '%s'\n", path);
if (vnc_set_x509_credential_dir(vs, path) < 0) {
fprintf(stderr, "Failed to find x509 certificates/keys in %s\n", path);
qemu_free(path);
qemu_free(vs->display);
vs->display = NULL;
return -1;
}
qemu_free(path);
} else {
fprintf(stderr, "No certificate path provided\n");
qemu_free(vs->display);
vs->display = NULL;
return -1;
}
#endif
}
}
if (password) {
#ifdef CONFIG_VNC_TLS
if (tls) {
vs->auth = VNC_AUTH_VENCRYPT;
if (x509) {
VNC_DEBUG("Initializing VNC server with x509 password auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_X509VNC;
} else {
VNC_DEBUG("Initializing VNC server with TLS password auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_TLSVNC;
}
} else {
#endif
VNC_DEBUG("Initializing VNC server with password auth\n");
vs->auth = VNC_AUTH_VNC;
#ifdef CONFIG_VNC_TLS
vs->subauth = VNC_AUTH_INVALID;
}
#endif
} else {
#ifdef CONFIG_VNC_TLS
if (tls) {
vs->auth = VNC_AUTH_VENCRYPT;
if (x509) {
VNC_DEBUG("Initializing VNC server with x509 no auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_X509NONE;
} else {
VNC_DEBUG("Initializing VNC server with TLS no auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_TLSNONE;
}
} else {
#endif
VNC_DEBUG("Initializing VNC server with no auth\n");
vs->auth = VNC_AUTH_NONE;
#ifdef CONFIG_VNC_TLS
vs->subauth = VNC_AUTH_INVALID;
}
#endif
}
if (reverse) {
/* connect to viewer */
if (strncmp(display, "unix:", 5) == 0)
vs->lsock = unix_connect(display+5);
else
vs->lsock = inet_connect(display, SOCK_STREAM);
if (-1 == vs->lsock) {
free(vs->display);
vs->display = NULL;
return -1;
} else {
vs->csock = vs->lsock;
vs->lsock = -1;
vnc_connect(vs);
}
return 0;
} else {
/* listen for connects */
char *dpy;
dpy = qemu_malloc(256);
if (strncmp(display, "unix:", 5) == 0) {
strcpy(dpy, "unix:");
vs->lsock = unix_listen(display, dpy+5, 256-5);
} else {
vs->lsock = inet_listen(display, dpy, 256, SOCK_STREAM, 5900);
}
if (-1 == vs->lsock) {
free(dpy);
} else {
free(vs->display);
vs->display = dpy;
}
}
return qemu_set_fd_handler2(vs->lsock, vnc_listen_poll, vnc_listen_read, NULL, vs);
}
| false | qemu | be3512610bdeebfaa40c63ae15d19d9fae991e1b | int vnc_display_open(DisplayState *ds, const char *display)
{
VncState *vs = ds ? (VncState *)ds->opaque : vnc_state;
const char *options;
int password = 0;
int reverse = 0;
int to_port = 0;
#ifdef CONFIG_VNC_TLS
int tls = 0, x509 = 0;
#endif
vnc_display_close(ds);
if (strcmp(display, "none") == 0)
return 0;
if (!(vs->display = strdup(display)))
return -1;
options = display;
while ((options = strchr(options, ','))) {
options++;
if (strncmp(options, "password", 8) == 0) {
password = 1;
} else if (strncmp(options, "reverse", 7) == 0) {
reverse = 1;
} else if (strncmp(options, "to=", 3) == 0) {
to_port = atoi(options+3) + 5900;
#ifdef CONFIG_VNC_TLS
} else if (strncmp(options, "tls", 3) == 0) {
tls = 1;
} else if (strncmp(options, "x509", 4) == 0) {
char *start, *end;
x509 = 1;
if (strncmp(options, "x509verify", 10) == 0)
vs->x509verify = 1;
start = strchr(options, '=');
end = strchr(options, ',');
if (start && (!end || (start < end))) {
int len = end ? end-(start+1) : strlen(start+1);
char *path = qemu_malloc(len+1);
pstrcpy(path, len, start + 1);
path[len] = '\0';
VNC_DEBUG("Trying certificate path '%s'\n", path);
if (vnc_set_x509_credential_dir(vs, path) < 0) {
fprintf(stderr, "Failed to find x509 certificates/keys in %s\n", path);
qemu_free(path);
qemu_free(vs->display);
vs->display = NULL;
return -1;
}
qemu_free(path);
} else {
fprintf(stderr, "No certificate path provided\n");
qemu_free(vs->display);
vs->display = NULL;
return -1;
}
#endif
}
}
if (password) {
#ifdef CONFIG_VNC_TLS
if (tls) {
vs->auth = VNC_AUTH_VENCRYPT;
if (x509) {
VNC_DEBUG("Initializing VNC server with x509 password auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_X509VNC;
} else {
VNC_DEBUG("Initializing VNC server with TLS password auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_TLSVNC;
}
} else {
#endif
VNC_DEBUG("Initializing VNC server with password auth\n");
vs->auth = VNC_AUTH_VNC;
#ifdef CONFIG_VNC_TLS
vs->subauth = VNC_AUTH_INVALID;
}
#endif
} else {
#ifdef CONFIG_VNC_TLS
if (tls) {
vs->auth = VNC_AUTH_VENCRYPT;
if (x509) {
VNC_DEBUG("Initializing VNC server with x509 no auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_X509NONE;
} else {
VNC_DEBUG("Initializing VNC server with TLS no auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_TLSNONE;
}
} else {
#endif
VNC_DEBUG("Initializing VNC server with no auth\n");
vs->auth = VNC_AUTH_NONE;
#ifdef CONFIG_VNC_TLS
vs->subauth = VNC_AUTH_INVALID;
}
#endif
}
if (reverse) {
if (strncmp(display, "unix:", 5) == 0)
vs->lsock = unix_connect(display+5);
else
vs->lsock = inet_connect(display, SOCK_STREAM);
if (-1 == vs->lsock) {
free(vs->display);
vs->display = NULL;
return -1;
} else {
vs->csock = vs->lsock;
vs->lsock = -1;
vnc_connect(vs);
}
return 0;
} else {
char *dpy;
dpy = qemu_malloc(256);
if (strncmp(display, "unix:", 5) == 0) {
strcpy(dpy, "unix:");
vs->lsock = unix_listen(display, dpy+5, 256-5);
} else {
vs->lsock = inet_listen(display, dpy, 256, SOCK_STREAM, 5900);
}
if (-1 == vs->lsock) {
free(dpy);
} else {
free(vs->display);
vs->display = dpy;
}
}
return qemu_set_fd_handler2(vs->lsock, vnc_listen_poll, vnc_listen_read, NULL, vs);
}
| {
"code": [],
"line_no": []
} | int FUNC_0(DisplayState *VAR_0, const char *VAR_1)
{
VncState *vs = VAR_0 ? (VncState *)VAR_0->opaque : vnc_state;
const char *VAR_2;
int VAR_3 = 0;
int VAR_4 = 0;
int VAR_5 = 0;
#ifdef CONFIG_VNC_TLS
int tls = 0, x509 = 0;
#endif
vnc_display_close(VAR_0);
if (strcmp(VAR_1, "none") == 0)
return 0;
if (!(vs->VAR_1 = strdup(VAR_1)))
return -1;
VAR_2 = VAR_1;
while ((VAR_2 = strchr(VAR_2, ','))) {
VAR_2++;
if (strncmp(VAR_2, "VAR_3", 8) == 0) {
VAR_3 = 1;
} else if (strncmp(VAR_2, "VAR_4", 7) == 0) {
VAR_4 = 1;
} else if (strncmp(VAR_2, "to=", 3) == 0) {
VAR_5 = atoi(VAR_2+3) + 5900;
#ifdef CONFIG_VNC_TLS
} else if (strncmp(VAR_2, "tls", 3) == 0) {
tls = 1;
} else if (strncmp(VAR_2, "x509", 4) == 0) {
char *start, *end;
x509 = 1;
if (strncmp(VAR_2, "x509verify", 10) == 0)
vs->x509verify = 1;
start = strchr(VAR_2, '=');
end = strchr(VAR_2, ',');
if (start && (!end || (start < end))) {
int len = end ? end-(start+1) : strlen(start+1);
char *path = qemu_malloc(len+1);
pstrcpy(path, len, start + 1);
path[len] = '\0';
VNC_DEBUG("Trying certificate path '%s'\n", path);
if (vnc_set_x509_credential_dir(vs, path) < 0) {
fprintf(stderr, "Failed to find x509 certificates/keys in %s\n", path);
qemu_free(path);
qemu_free(vs->VAR_1);
vs->VAR_1 = NULL;
return -1;
}
qemu_free(path);
} else {
fprintf(stderr, "No certificate path provided\n");
qemu_free(vs->VAR_1);
vs->VAR_1 = NULL;
return -1;
}
#endif
}
}
if (VAR_3) {
#ifdef CONFIG_VNC_TLS
if (tls) {
vs->auth = VNC_AUTH_VENCRYPT;
if (x509) {
VNC_DEBUG("Initializing VNC server with x509 VAR_3 auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_X509VNC;
} else {
VNC_DEBUG("Initializing VNC server with TLS VAR_3 auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_TLSVNC;
}
} else {
#endif
VNC_DEBUG("Initializing VNC server with VAR_3 auth\n");
vs->auth = VNC_AUTH_VNC;
#ifdef CONFIG_VNC_TLS
vs->subauth = VNC_AUTH_INVALID;
}
#endif
} else {
#ifdef CONFIG_VNC_TLS
if (tls) {
vs->auth = VNC_AUTH_VENCRYPT;
if (x509) {
VNC_DEBUG("Initializing VNC server with x509 no auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_X509NONE;
} else {
VNC_DEBUG("Initializing VNC server with TLS no auth\n");
vs->subauth = VNC_AUTH_VENCRYPT_TLSNONE;
}
} else {
#endif
VNC_DEBUG("Initializing VNC server with no auth\n");
vs->auth = VNC_AUTH_NONE;
#ifdef CONFIG_VNC_TLS
vs->subauth = VNC_AUTH_INVALID;
}
#endif
}
if (VAR_4) {
if (strncmp(VAR_1, "unix:", 5) == 0)
vs->lsock = unix_connect(VAR_1+5);
else
vs->lsock = inet_connect(VAR_1, SOCK_STREAM);
if (-1 == vs->lsock) {
free(vs->VAR_1);
vs->VAR_1 = NULL;
return -1;
} else {
vs->csock = vs->lsock;
vs->lsock = -1;
vnc_connect(vs);
}
return 0;
} else {
char *VAR_6;
VAR_6 = qemu_malloc(256);
if (strncmp(VAR_1, "unix:", 5) == 0) {
strcpy(VAR_6, "unix:");
vs->lsock = unix_listen(VAR_1, VAR_6+5, 256-5);
} else {
vs->lsock = inet_listen(VAR_1, VAR_6, 256, SOCK_STREAM, 5900);
}
if (-1 == vs->lsock) {
free(VAR_6);
} else {
free(vs->VAR_1);
vs->VAR_1 = VAR_6;
}
}
return qemu_set_fd_handler2(vs->lsock, vnc_listen_poll, vnc_listen_read, NULL, vs);
}
| [
"int FUNC_0(DisplayState *VAR_0, const char *VAR_1)\n{",
"VncState *vs = VAR_0 ? (VncState *)VAR_0->opaque : vnc_state;",
"const char *VAR_2;",
"int VAR_3 = 0;",
"int VAR_4 = 0;",
"int VAR_5 = 0;",
"#ifdef CONFIG_VNC_TLS\nint tls = 0, x509 = 0;",
"#endif\nvnc_display_close(VAR_0);",
"if (strcmp(VAR_1, \"none\") == 0)\nreturn 0;",
"if (!(vs->VAR_1 = strdup(VAR_1)))\nreturn -1;",
"VAR_2 = VAR_1;",
"while ((VAR_2 = strchr(VAR_2, ','))) {",
"VAR_2++;",
"if (strncmp(VAR_2, \"VAR_3\", 8) == 0) {",
"VAR_3 = 1;",
"} else if (strncmp(VAR_2, \"VAR_4\", 7) == 0) {",
"VAR_4 = 1;",
"} else if (strncmp(VAR_2, \"to=\", 3) == 0) {",
"VAR_5 = atoi(VAR_2+3) + 5900;",
"#ifdef CONFIG_VNC_TLS\n} else if (strncmp(VAR_2, \"tls\", 3) == 0) {",
"tls = 1;",
"} else if (strncmp(VAR_2, \"x509\", 4) == 0) {",
"char *start, *end;",
"x509 = 1;",
"if (strncmp(VAR_2, \"x509verify\", 10) == 0)\nvs->x509verify = 1;",
"start = strchr(VAR_2, '=');",
"end = strchr(VAR_2, ',');",
"if (start && (!end || (start < end))) {",
"int len = end ? end-(start+1) : strlen(start+1);",
"char *path = qemu_malloc(len+1);",
"pstrcpy(path, len, start + 1);",
"path[len] = '\\0';",
"VNC_DEBUG(\"Trying certificate path '%s'\\n\", path);",
"if (vnc_set_x509_credential_dir(vs, path) < 0) {",
"fprintf(stderr, \"Failed to find x509 certificates/keys in %s\\n\", path);",
"qemu_free(path);",
"qemu_free(vs->VAR_1);",
"vs->VAR_1 = NULL;",
"return -1;",
"}",
"qemu_free(path);",
"} else {",
"fprintf(stderr, \"No certificate path provided\\n\");",
"qemu_free(vs->VAR_1);",
"vs->VAR_1 = NULL;",
"return -1;",
"}",
"#endif\n}",
"}",
"if (VAR_3) {",
"#ifdef CONFIG_VNC_TLS\nif (tls) {",
"vs->auth = VNC_AUTH_VENCRYPT;",
"if (x509) {",
"VNC_DEBUG(\"Initializing VNC server with x509 VAR_3 auth\\n\");",
"vs->subauth = VNC_AUTH_VENCRYPT_X509VNC;",
"} else {",
"VNC_DEBUG(\"Initializing VNC server with TLS VAR_3 auth\\n\");",
"vs->subauth = VNC_AUTH_VENCRYPT_TLSVNC;",
"}",
"} else {",
"#endif\nVNC_DEBUG(\"Initializing VNC server with VAR_3 auth\\n\");",
"vs->auth = VNC_AUTH_VNC;",
"#ifdef CONFIG_VNC_TLS\nvs->subauth = VNC_AUTH_INVALID;",
"}",
"#endif\n} else {",
"#ifdef CONFIG_VNC_TLS\nif (tls) {",
"vs->auth = VNC_AUTH_VENCRYPT;",
"if (x509) {",
"VNC_DEBUG(\"Initializing VNC server with x509 no auth\\n\");",
"vs->subauth = VNC_AUTH_VENCRYPT_X509NONE;",
"} else {",
"VNC_DEBUG(\"Initializing VNC server with TLS no auth\\n\");",
"vs->subauth = VNC_AUTH_VENCRYPT_TLSNONE;",
"}",
"} else {",
"#endif\nVNC_DEBUG(\"Initializing VNC server with no auth\\n\");",
"vs->auth = VNC_AUTH_NONE;",
"#ifdef CONFIG_VNC_TLS\nvs->subauth = VNC_AUTH_INVALID;",
"}",
"#endif\n}",
"if (VAR_4) {",
"if (strncmp(VAR_1, \"unix:\", 5) == 0)\nvs->lsock = unix_connect(VAR_1+5);",
"else\nvs->lsock = inet_connect(VAR_1, SOCK_STREAM);",
"if (-1 == vs->lsock) {",
"free(vs->VAR_1);",
"vs->VAR_1 = NULL;",
"return -1;",
"} else {",
"vs->csock = vs->lsock;",
"vs->lsock = -1;",
"vnc_connect(vs);",
"}",
"return 0;",
"} else {",
"char *VAR_6;",
"VAR_6 = qemu_malloc(256);",
"if (strncmp(VAR_1, \"unix:\", 5) == 0) {",
"strcpy(VAR_6, \"unix:\");",
"vs->lsock = unix_listen(VAR_1, VAR_6+5, 256-5);",
"} else {",
"vs->lsock = inet_listen(VAR_1, VAR_6, 256, SOCK_STREAM, 5900);",
"}",
"if (-1 == vs->lsock) {",
"free(VAR_6);",
"} else {",
"free(vs->VAR_1);",
"vs->VAR_1 = VAR_6;",
"}",
"}",
"return qemu_set_fd_handler2(vs->lsock, vnc_listen_poll, vnc_listen_read, NULL, vs);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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,
23
],
[
25,
27
],
[
31,
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55,
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67,
69
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123,
125
],
[
127
],
[
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
],
[
211
],
[
215,
217
],
[
219,
221
],
[
223
],
[
225
],
[
227
],
[
229
],
[
231
],
[
233
],
[
235
],
[
237
],
[
239
],
[
241
],
[
245
],
[
249
],
[
251
],
[
253
],
[
255
],
[
257
],
[
259
],
[
261
],
[
263
],
[
265
],
[
267
],
[
269
],
[
271
],
[
273
],
[
275
],
[
277
],
[
281
],
[
283
]
] |
24,098 | static void nabm_writeb (void *opaque, uint32_t addr, uint32_t val)
{
PCIAC97LinkState *d = opaque;
AC97LinkState *s = &d->ac97;
AC97BusMasterRegs *r = NULL;
uint32_t index = addr - s->base[1];
switch (index) {
case PI_LVI:
case PO_LVI:
case MC_LVI:
r = &s->bm_regs[GET_BM (index)];
if ((r->cr & CR_RPBM) && (r->sr & SR_DCH)) {
r->sr &= ~(SR_DCH | SR_CELV);
r->civ = r->piv;
r->piv = (r->piv + 1) % 32;
fetch_bd (s, r);
}
r->lvi = val % 32;
dolog ("LVI[%d] <- %#x\n", GET_BM (index), val);
break;
case PI_CR:
case PO_CR:
case MC_CR:
r = &s->bm_regs[GET_BM (index)];
if (val & CR_RR) {
reset_bm_regs (s, r);
}
else {
r->cr = val & CR_VALID_MASK;
if (!(r->cr & CR_RPBM)) {
voice_set_active (s, r - s->bm_regs, 0);
r->sr |= SR_DCH;
}
else {
r->civ = r->piv;
r->piv = (r->piv + 1) % 32;
fetch_bd (s, r);
r->sr &= ~SR_DCH;
voice_set_active (s, r - s->bm_regs, 1);
}
}
dolog ("CR[%d] <- %#x (cr %#x)\n", GET_BM (index), val, r->cr);
break;
case PI_SR:
case PO_SR:
case MC_SR:
r = &s->bm_regs[GET_BM (index)];
r->sr |= val & ~(SR_RO_MASK | SR_WCLEAR_MASK);
update_sr (s, r, r->sr & ~(val & SR_WCLEAR_MASK));
dolog ("SR[%d] <- %#x (sr %#x)\n", GET_BM (index), val, r->sr);
break;
default:
dolog ("U nabm writeb %#x <- %#x\n", addr, val);
break;
}
}
| false | qemu | 10ee2aaa417d8d8978cdb2bbed55ebb152df5f6b | static void nabm_writeb (void *opaque, uint32_t addr, uint32_t val)
{
PCIAC97LinkState *d = opaque;
AC97LinkState *s = &d->ac97;
AC97BusMasterRegs *r = NULL;
uint32_t index = addr - s->base[1];
switch (index) {
case PI_LVI:
case PO_LVI:
case MC_LVI:
r = &s->bm_regs[GET_BM (index)];
if ((r->cr & CR_RPBM) && (r->sr & SR_DCH)) {
r->sr &= ~(SR_DCH | SR_CELV);
r->civ = r->piv;
r->piv = (r->piv + 1) % 32;
fetch_bd (s, r);
}
r->lvi = val % 32;
dolog ("LVI[%d] <- %#x\n", GET_BM (index), val);
break;
case PI_CR:
case PO_CR:
case MC_CR:
r = &s->bm_regs[GET_BM (index)];
if (val & CR_RR) {
reset_bm_regs (s, r);
}
else {
r->cr = val & CR_VALID_MASK;
if (!(r->cr & CR_RPBM)) {
voice_set_active (s, r - s->bm_regs, 0);
r->sr |= SR_DCH;
}
else {
r->civ = r->piv;
r->piv = (r->piv + 1) % 32;
fetch_bd (s, r);
r->sr &= ~SR_DCH;
voice_set_active (s, r - s->bm_regs, 1);
}
}
dolog ("CR[%d] <- %#x (cr %#x)\n", GET_BM (index), val, r->cr);
break;
case PI_SR:
case PO_SR:
case MC_SR:
r = &s->bm_regs[GET_BM (index)];
r->sr |= val & ~(SR_RO_MASK | SR_WCLEAR_MASK);
update_sr (s, r, r->sr & ~(val & SR_WCLEAR_MASK));
dolog ("SR[%d] <- %#x (sr %#x)\n", GET_BM (index), val, r->sr);
break;
default:
dolog ("U nabm writeb %#x <- %#x\n", addr, val);
break;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0 (void *VAR_0, uint32_t VAR_1, uint32_t VAR_2)
{
PCIAC97LinkState *d = VAR_0;
AC97LinkState *s = &d->ac97;
AC97BusMasterRegs *r = NULL;
uint32_t index = VAR_1 - s->base[1];
switch (index) {
case PI_LVI:
case PO_LVI:
case MC_LVI:
r = &s->bm_regs[GET_BM (index)];
if ((r->cr & CR_RPBM) && (r->sr & SR_DCH)) {
r->sr &= ~(SR_DCH | SR_CELV);
r->civ = r->piv;
r->piv = (r->piv + 1) % 32;
fetch_bd (s, r);
}
r->lvi = VAR_2 % 32;
dolog ("LVI[%d] <- %#x\n", GET_BM (index), VAR_2);
break;
case PI_CR:
case PO_CR:
case MC_CR:
r = &s->bm_regs[GET_BM (index)];
if (VAR_2 & CR_RR) {
reset_bm_regs (s, r);
}
else {
r->cr = VAR_2 & CR_VALID_MASK;
if (!(r->cr & CR_RPBM)) {
voice_set_active (s, r - s->bm_regs, 0);
r->sr |= SR_DCH;
}
else {
r->civ = r->piv;
r->piv = (r->piv + 1) % 32;
fetch_bd (s, r);
r->sr &= ~SR_DCH;
voice_set_active (s, r - s->bm_regs, 1);
}
}
dolog ("CR[%d] <- %#x (cr %#x)\n", GET_BM (index), VAR_2, r->cr);
break;
case PI_SR:
case PO_SR:
case MC_SR:
r = &s->bm_regs[GET_BM (index)];
r->sr |= VAR_2 & ~(SR_RO_MASK | SR_WCLEAR_MASK);
update_sr (s, r, r->sr & ~(VAR_2 & SR_WCLEAR_MASK));
dolog ("SR[%d] <- %#x (sr %#x)\n", GET_BM (index), VAR_2, r->sr);
break;
default:
dolog ("U nabm writeb %#x <- %#x\n", VAR_1, VAR_2);
break;
}
}
| [
"static void FUNC_0 (void *VAR_0, uint32_t VAR_1, uint32_t VAR_2)\n{",
"PCIAC97LinkState *d = VAR_0;",
"AC97LinkState *s = &d->ac97;",
"AC97BusMasterRegs *r = NULL;",
"uint32_t index = VAR_1 - s->base[1];",
"switch (index) {",
"case PI_LVI:\ncase PO_LVI:\ncase MC_LVI:\nr = &s->bm_regs[GET_BM (index)];",
"if ((r->cr & CR_RPBM) && (r->sr & SR_DCH)) {",
"r->sr &= ~(SR_DCH | SR_CELV);",
"r->civ = r->piv;",
"r->piv = (r->piv + 1) % 32;",
"fetch_bd (s, r);",
"}",
"r->lvi = VAR_2 % 32;",
"dolog (\"LVI[%d] <- %#x\\n\", GET_BM (index), VAR_2);",
"break;",
"case PI_CR:\ncase PO_CR:\ncase MC_CR:\nr = &s->bm_regs[GET_BM (index)];",
"if (VAR_2 & CR_RR) {",
"reset_bm_regs (s, r);",
"}",
"else {",
"r->cr = VAR_2 & CR_VALID_MASK;",
"if (!(r->cr & CR_RPBM)) {",
"voice_set_active (s, r - s->bm_regs, 0);",
"r->sr |= SR_DCH;",
"}",
"else {",
"r->civ = r->piv;",
"r->piv = (r->piv + 1) % 32;",
"fetch_bd (s, r);",
"r->sr &= ~SR_DCH;",
"voice_set_active (s, r - s->bm_regs, 1);",
"}",
"}",
"dolog (\"CR[%d] <- %#x (cr %#x)\\n\", GET_BM (index), VAR_2, r->cr);",
"break;",
"case PI_SR:\ncase PO_SR:\ncase MC_SR:\nr = &s->bm_regs[GET_BM (index)];",
"r->sr |= VAR_2 & ~(SR_RO_MASK | SR_WCLEAR_MASK);",
"update_sr (s, r, r->sr & ~(VAR_2 & SR_WCLEAR_MASK));",
"dolog (\"SR[%d] <- %#x (sr %#x)\\n\", GET_BM (index), VAR_2, r->sr);",
"break;",
"default:\ndolog (\"U nabm writeb %#x <- %#x\\n\", VAR_1, VAR_2);",
"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
] | [
[
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
],
[
99
],
[
101
],
[
103,
105
],
[
107
],
[
109
],
[
111
]
] |
24,099 | void helper_xssubqp(CPUPPCState *env, uint32_t opcode)
{
ppc_vsr_t xt, xa, xb;
float_status tstat;
getVSR(rA(opcode) + 32, &xa, env);
getVSR(rB(opcode) + 32, &xb, env);
getVSR(rD(opcode) + 32, &xt, env);
helper_reset_fpstatus(env);
if (unlikely(Rc(opcode) != 0)) {
/* TODO: Support xssubqp after round-to-odd is implemented */
abort();
}
tstat = env->fp_status;
set_float_exception_flags(0, &tstat);
xt.f128 = float128_sub(xa.f128, xb.f128, &tstat);
env->fp_status.float_exception_flags |= tstat.float_exception_flags;
if (unlikely(tstat.float_exception_flags & float_flag_invalid)) {
if (float128_is_infinity(xa.f128) && float128_is_infinity(xb.f128)) {
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, 1);
} else if (float128_is_signaling_nan(xa.f128, &tstat) ||
float128_is_signaling_nan(xb.f128, &tstat)) {
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
}
}
helper_compute_fprf_float128(env, xt.f128);
putVSR(rD(opcode) + 32, &xt, env);
float_check_status(env);
}
| false | qemu | a8d411abac9347aadeac87687b8a3c9895ea0fd7 | void helper_xssubqp(CPUPPCState *env, uint32_t opcode)
{
ppc_vsr_t xt, xa, xb;
float_status tstat;
getVSR(rA(opcode) + 32, &xa, env);
getVSR(rB(opcode) + 32, &xb, env);
getVSR(rD(opcode) + 32, &xt, env);
helper_reset_fpstatus(env);
if (unlikely(Rc(opcode) != 0)) {
abort();
}
tstat = env->fp_status;
set_float_exception_flags(0, &tstat);
xt.f128 = float128_sub(xa.f128, xb.f128, &tstat);
env->fp_status.float_exception_flags |= tstat.float_exception_flags;
if (unlikely(tstat.float_exception_flags & float_flag_invalid)) {
if (float128_is_infinity(xa.f128) && float128_is_infinity(xb.f128)) {
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, 1);
} else if (float128_is_signaling_nan(xa.f128, &tstat) ||
float128_is_signaling_nan(xb.f128, &tstat)) {
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
}
}
helper_compute_fprf_float128(env, xt.f128);
putVSR(rD(opcode) + 32, &xt, env);
float_check_status(env);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(CPUPPCState *VAR_0, uint32_t VAR_1)
{
ppc_vsr_t xt, xa, xb;
float_status tstat;
getVSR(rA(VAR_1) + 32, &xa, VAR_0);
getVSR(rB(VAR_1) + 32, &xb, VAR_0);
getVSR(rD(VAR_1) + 32, &xt, VAR_0);
helper_reset_fpstatus(VAR_0);
if (unlikely(Rc(VAR_1) != 0)) {
abort();
}
tstat = VAR_0->fp_status;
set_float_exception_flags(0, &tstat);
xt.f128 = float128_sub(xa.f128, xb.f128, &tstat);
VAR_0->fp_status.float_exception_flags |= tstat.float_exception_flags;
if (unlikely(tstat.float_exception_flags & float_flag_invalid)) {
if (float128_is_infinity(xa.f128) && float128_is_infinity(xb.f128)) {
float_invalid_op_excp(VAR_0, POWERPC_EXCP_FP_VXISI, 1);
} else if (float128_is_signaling_nan(xa.f128, &tstat) ||
float128_is_signaling_nan(xb.f128, &tstat)) {
float_invalid_op_excp(VAR_0, POWERPC_EXCP_FP_VXSNAN, 1);
}
}
helper_compute_fprf_float128(VAR_0, xt.f128);
putVSR(rD(VAR_1) + 32, &xt, VAR_0);
float_check_status(VAR_0);
}
| [
"void FUNC_0(CPUPPCState *VAR_0, uint32_t VAR_1)\n{",
"ppc_vsr_t xt, xa, xb;",
"float_status tstat;",
"getVSR(rA(VAR_1) + 32, &xa, VAR_0);",
"getVSR(rB(VAR_1) + 32, &xb, VAR_0);",
"getVSR(rD(VAR_1) + 32, &xt, VAR_0);",
"helper_reset_fpstatus(VAR_0);",
"if (unlikely(Rc(VAR_1) != 0)) {",
"abort();",
"}",
"tstat = VAR_0->fp_status;",
"set_float_exception_flags(0, &tstat);",
"xt.f128 = float128_sub(xa.f128, xb.f128, &tstat);",
"VAR_0->fp_status.float_exception_flags |= tstat.float_exception_flags;",
"if (unlikely(tstat.float_exception_flags & float_flag_invalid)) {",
"if (float128_is_infinity(xa.f128) && float128_is_infinity(xb.f128)) {",
"float_invalid_op_excp(VAR_0, POWERPC_EXCP_FP_VXISI, 1);",
"} else if (float128_is_signaling_nan(xa.f128, &tstat) ||",
"float128_is_signaling_nan(xb.f128, &tstat)) {",
"float_invalid_op_excp(VAR_0, POWERPC_EXCP_FP_VXSNAN, 1);",
"}",
"}",
"helper_compute_fprf_float128(VAR_0, xt.f128);",
"putVSR(rD(VAR_1) + 32, &xt, VAR_0);",
"float_check_status(VAR_0);",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
59
],
[
61
],
[
63
],
[
65
]
] |
24,101 | void acpi_pm1_cnt_init(ACPIREGS *ar, MemoryRegion *parent)
{
ar->wakeup.notify = acpi_notify_wakeup;
qemu_register_wakeup_notifier(&ar->wakeup);
memory_region_init_io(&ar->pm1.cnt.io, &acpi_pm_cnt_ops, ar, "acpi-cnt", 2);
memory_region_add_subregion(parent, 4, &ar->pm1.cnt.io);
}
| false | qemu | 560e63965232e37d1916a447125cf91c18a96930 | void acpi_pm1_cnt_init(ACPIREGS *ar, MemoryRegion *parent)
{
ar->wakeup.notify = acpi_notify_wakeup;
qemu_register_wakeup_notifier(&ar->wakeup);
memory_region_init_io(&ar->pm1.cnt.io, &acpi_pm_cnt_ops, ar, "acpi-cnt", 2);
memory_region_add_subregion(parent, 4, &ar->pm1.cnt.io);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(ACPIREGS *VAR_0, MemoryRegion *VAR_1)
{
VAR_0->wakeup.notify = acpi_notify_wakeup;
qemu_register_wakeup_notifier(&VAR_0->wakeup);
memory_region_init_io(&VAR_0->pm1.cnt.io, &acpi_pm_cnt_ops, VAR_0, "acpi-cnt", 2);
memory_region_add_subregion(VAR_1, 4, &VAR_0->pm1.cnt.io);
}
| [
"void FUNC_0(ACPIREGS *VAR_0, MemoryRegion *VAR_1)\n{",
"VAR_0->wakeup.notify = acpi_notify_wakeup;",
"qemu_register_wakeup_notifier(&VAR_0->wakeup);",
"memory_region_init_io(&VAR_0->pm1.cnt.io, &acpi_pm_cnt_ops, VAR_0, \"acpi-cnt\", 2);",
"memory_region_add_subregion(VAR_1, 4, &VAR_0->pm1.cnt.io);",
"}"
] | [
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
]
] |
24,102 | static void vfio_probe_nvidia_bar0_quirk(VFIOPCIDevice *vdev, int nr)
{
VFIOQuirk *quirk;
VFIOConfigMirrorQuirk *mirror;
if (!vfio_pci_is(vdev, PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID) ||
!vfio_is_vga(vdev) || nr != 0) {
return;
}
quirk = g_malloc0(sizeof(*quirk));
mirror = quirk->data = g_malloc0(sizeof(*mirror));
mirror->mem = quirk->mem = g_new0(MemoryRegion, 1);
quirk->nr_mem = 1;
mirror->vdev = vdev;
mirror->offset = 0x88000;
mirror->bar = nr;
memory_region_init_io(mirror->mem, OBJECT(vdev),
&vfio_nvidia_mirror_quirk, mirror,
"vfio-nvidia-bar0-88000-mirror-quirk",
PCIE_CONFIG_SPACE_SIZE);
memory_region_add_subregion_overlap(&vdev->bars[nr].region.mem,
mirror->offset, mirror->mem, 1);
QLIST_INSERT_HEAD(&vdev->bars[nr].quirks, quirk, next);
/* The 0x1800 offset mirror only seems to get used by legacy VGA */
if (vdev->has_vga) {
quirk = g_malloc0(sizeof(*quirk));
mirror = quirk->data = g_malloc0(sizeof(*mirror));
mirror->mem = quirk->mem = g_new0(MemoryRegion, 1);
quirk->nr_mem = 1;
mirror->vdev = vdev;
mirror->offset = 0x1800;
mirror->bar = nr;
memory_region_init_io(mirror->mem, OBJECT(vdev),
&vfio_nvidia_mirror_quirk, mirror,
"vfio-nvidia-bar0-1800-mirror-quirk",
PCI_CONFIG_SPACE_SIZE);
memory_region_add_subregion_overlap(&vdev->bars[nr].region.mem,
mirror->offset, mirror->mem, 1);
QLIST_INSERT_HEAD(&vdev->bars[nr].quirks, quirk, next);
}
trace_vfio_quirk_nvidia_bar0_probe(vdev->vbasedev.name);
}
| false | qemu | f5793fd9e1fd89808f4adbfe690235b094176a37 | static void vfio_probe_nvidia_bar0_quirk(VFIOPCIDevice *vdev, int nr)
{
VFIOQuirk *quirk;
VFIOConfigMirrorQuirk *mirror;
if (!vfio_pci_is(vdev, PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID) ||
!vfio_is_vga(vdev) || nr != 0) {
return;
}
quirk = g_malloc0(sizeof(*quirk));
mirror = quirk->data = g_malloc0(sizeof(*mirror));
mirror->mem = quirk->mem = g_new0(MemoryRegion, 1);
quirk->nr_mem = 1;
mirror->vdev = vdev;
mirror->offset = 0x88000;
mirror->bar = nr;
memory_region_init_io(mirror->mem, OBJECT(vdev),
&vfio_nvidia_mirror_quirk, mirror,
"vfio-nvidia-bar0-88000-mirror-quirk",
PCIE_CONFIG_SPACE_SIZE);
memory_region_add_subregion_overlap(&vdev->bars[nr].region.mem,
mirror->offset, mirror->mem, 1);
QLIST_INSERT_HEAD(&vdev->bars[nr].quirks, quirk, next);
if (vdev->has_vga) {
quirk = g_malloc0(sizeof(*quirk));
mirror = quirk->data = g_malloc0(sizeof(*mirror));
mirror->mem = quirk->mem = g_new0(MemoryRegion, 1);
quirk->nr_mem = 1;
mirror->vdev = vdev;
mirror->offset = 0x1800;
mirror->bar = nr;
memory_region_init_io(mirror->mem, OBJECT(vdev),
&vfio_nvidia_mirror_quirk, mirror,
"vfio-nvidia-bar0-1800-mirror-quirk",
PCI_CONFIG_SPACE_SIZE);
memory_region_add_subregion_overlap(&vdev->bars[nr].region.mem,
mirror->offset, mirror->mem, 1);
QLIST_INSERT_HEAD(&vdev->bars[nr].quirks, quirk, next);
}
trace_vfio_quirk_nvidia_bar0_probe(vdev->vbasedev.name);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(VFIOPCIDevice *VAR_0, int VAR_1)
{
VFIOQuirk *quirk;
VFIOConfigMirrorQuirk *mirror;
if (!vfio_pci_is(VAR_0, PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID) ||
!vfio_is_vga(VAR_0) || VAR_1 != 0) {
return;
}
quirk = g_malloc0(sizeof(*quirk));
mirror = quirk->data = g_malloc0(sizeof(*mirror));
mirror->mem = quirk->mem = g_new0(MemoryRegion, 1);
quirk->nr_mem = 1;
mirror->VAR_0 = VAR_0;
mirror->offset = 0x88000;
mirror->bar = VAR_1;
memory_region_init_io(mirror->mem, OBJECT(VAR_0),
&vfio_nvidia_mirror_quirk, mirror,
"vfio-nvidia-bar0-88000-mirror-quirk",
PCIE_CONFIG_SPACE_SIZE);
memory_region_add_subregion_overlap(&VAR_0->bars[VAR_1].region.mem,
mirror->offset, mirror->mem, 1);
QLIST_INSERT_HEAD(&VAR_0->bars[VAR_1].quirks, quirk, next);
if (VAR_0->has_vga) {
quirk = g_malloc0(sizeof(*quirk));
mirror = quirk->data = g_malloc0(sizeof(*mirror));
mirror->mem = quirk->mem = g_new0(MemoryRegion, 1);
quirk->nr_mem = 1;
mirror->VAR_0 = VAR_0;
mirror->offset = 0x1800;
mirror->bar = VAR_1;
memory_region_init_io(mirror->mem, OBJECT(VAR_0),
&vfio_nvidia_mirror_quirk, mirror,
"vfio-nvidia-bar0-1800-mirror-quirk",
PCI_CONFIG_SPACE_SIZE);
memory_region_add_subregion_overlap(&VAR_0->bars[VAR_1].region.mem,
mirror->offset, mirror->mem, 1);
QLIST_INSERT_HEAD(&VAR_0->bars[VAR_1].quirks, quirk, next);
}
trace_vfio_quirk_nvidia_bar0_probe(VAR_0->vbasedev.name);
}
| [
"static void FUNC_0(VFIOPCIDevice *VAR_0, int VAR_1)\n{",
"VFIOQuirk *quirk;",
"VFIOConfigMirrorQuirk *mirror;",
"if (!vfio_pci_is(VAR_0, PCI_VENDOR_ID_NVIDIA, PCI_ANY_ID) ||\n!vfio_is_vga(VAR_0) || VAR_1 != 0) {",
"return;",
"}",
"quirk = g_malloc0(sizeof(*quirk));",
"mirror = quirk->data = g_malloc0(sizeof(*mirror));",
"mirror->mem = quirk->mem = g_new0(MemoryRegion, 1);",
"quirk->nr_mem = 1;",
"mirror->VAR_0 = VAR_0;",
"mirror->offset = 0x88000;",
"mirror->bar = VAR_1;",
"memory_region_init_io(mirror->mem, OBJECT(VAR_0),\n&vfio_nvidia_mirror_quirk, mirror,\n\"vfio-nvidia-bar0-88000-mirror-quirk\",\nPCIE_CONFIG_SPACE_SIZE);",
"memory_region_add_subregion_overlap(&VAR_0->bars[VAR_1].region.mem,\nmirror->offset, mirror->mem, 1);",
"QLIST_INSERT_HEAD(&VAR_0->bars[VAR_1].quirks, quirk, next);",
"if (VAR_0->has_vga) {",
"quirk = g_malloc0(sizeof(*quirk));",
"mirror = quirk->data = g_malloc0(sizeof(*mirror));",
"mirror->mem = quirk->mem = g_new0(MemoryRegion, 1);",
"quirk->nr_mem = 1;",
"mirror->VAR_0 = VAR_0;",
"mirror->offset = 0x1800;",
"mirror->bar = VAR_1;",
"memory_region_init_io(mirror->mem, OBJECT(VAR_0),\n&vfio_nvidia_mirror_quirk, mirror,\n\"vfio-nvidia-bar0-1800-mirror-quirk\",\nPCI_CONFIG_SPACE_SIZE);",
"memory_region_add_subregion_overlap(&VAR_0->bars[VAR_1].region.mem,\nmirror->offset, mirror->mem, 1);",
"QLIST_INSERT_HEAD(&VAR_0->bars[VAR_1].quirks, quirk, next);",
"}",
"trace_vfio_quirk_nvidia_bar0_probe(VAR_0->vbasedev.name);",
"}"
] | [
0,
0,
0,
0,
0,
0,
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,
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
37,
39,
41,
43
],
[
45,
47
],
[
51
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
75,
77,
79,
81
],
[
83,
85
],
[
89
],
[
91
],
[
95
],
[
97
]
] |
24,104 | static int mkv_write_tag_targets(AVFormatContext *s,
unsigned int elementid, unsigned int uid,
ebml_master *tags, ebml_master* tag)
{
AVIOContext *pb;
MatroskaMuxContext *mkv = s->priv_data;
ebml_master targets;
int ret;
if (!tags->pos) {
ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TAGS, avio_tell(s->pb));
if (ret < 0) return ret;
start_ebml_master_crc32(s->pb, &mkv->tags_bc, tags, MATROSKA_ID_TAGS, 0);
}
pb = mkv->tags_bc;
*tag = start_ebml_master(pb, MATROSKA_ID_TAG, 0);
targets = start_ebml_master(pb, MATROSKA_ID_TAGTARGETS, 0);
if (elementid)
put_ebml_uint(pb, elementid, uid);
end_ebml_master(pb, targets);
return 0;
}
| false | FFmpeg | eabbc64728c2fdb74f565aededec2ab023d20699 | static int mkv_write_tag_targets(AVFormatContext *s,
unsigned int elementid, unsigned int uid,
ebml_master *tags, ebml_master* tag)
{
AVIOContext *pb;
MatroskaMuxContext *mkv = s->priv_data;
ebml_master targets;
int ret;
if (!tags->pos) {
ret = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TAGS, avio_tell(s->pb));
if (ret < 0) return ret;
start_ebml_master_crc32(s->pb, &mkv->tags_bc, tags, MATROSKA_ID_TAGS, 0);
}
pb = mkv->tags_bc;
*tag = start_ebml_master(pb, MATROSKA_ID_TAG, 0);
targets = start_ebml_master(pb, MATROSKA_ID_TAGTARGETS, 0);
if (elementid)
put_ebml_uint(pb, elementid, uid);
end_ebml_master(pb, targets);
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVFormatContext *VAR_0,
unsigned int VAR_1, unsigned int VAR_2,
ebml_master *VAR_3, ebml_master* VAR_4)
{
AVIOContext *pb;
MatroskaMuxContext *mkv = VAR_0->priv_data;
ebml_master targets;
int VAR_5;
if (!VAR_3->pos) {
VAR_5 = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TAGS, avio_tell(VAR_0->pb));
if (VAR_5 < 0) return VAR_5;
start_ebml_master_crc32(VAR_0->pb, &mkv->tags_bc, VAR_3, MATROSKA_ID_TAGS, 0);
}
pb = mkv->tags_bc;
*VAR_4 = start_ebml_master(pb, MATROSKA_ID_TAG, 0);
targets = start_ebml_master(pb, MATROSKA_ID_TAGTARGETS, 0);
if (VAR_1)
put_ebml_uint(pb, VAR_1, VAR_2);
end_ebml_master(pb, targets);
return 0;
}
| [
"static int FUNC_0(AVFormatContext *VAR_0,\nunsigned int VAR_1, unsigned int VAR_2,\nebml_master *VAR_3, ebml_master* VAR_4)\n{",
"AVIOContext *pb;",
"MatroskaMuxContext *mkv = VAR_0->priv_data;",
"ebml_master targets;",
"int VAR_5;",
"if (!VAR_3->pos) {",
"VAR_5 = mkv_add_seekhead_entry(mkv->main_seekhead, MATROSKA_ID_TAGS, avio_tell(VAR_0->pb));",
"if (VAR_5 < 0) return VAR_5;",
"start_ebml_master_crc32(VAR_0->pb, &mkv->tags_bc, VAR_3, MATROSKA_ID_TAGS, 0);",
"}",
"pb = mkv->tags_bc;",
"*VAR_4 = start_ebml_master(pb, MATROSKA_ID_TAG, 0);",
"targets = start_ebml_master(pb, MATROSKA_ID_TAGTARGETS, 0);",
"if (VAR_1)\nput_ebml_uint(pb, VAR_1, VAR_2);",
"end_ebml_master(pb, targets);",
"return 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
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39,
41
],
[
43
],
[
45
],
[
47
]
] |
24,105 | static int v9fs_synth_symlink(FsContext *fs_ctx, const char *oldpath,
V9fsPath *newpath, const char *buf, FsCred *credp)
{
errno = EPERM;
return -1;
}
| false | qemu | 364031f17932814484657e5551ba12957d993d7e | static int v9fs_synth_symlink(FsContext *fs_ctx, const char *oldpath,
V9fsPath *newpath, const char *buf, FsCred *credp)
{
errno = EPERM;
return -1;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(FsContext *VAR_0, const char *VAR_1,
V9fsPath *VAR_2, const char *VAR_3, FsCred *VAR_4)
{
errno = EPERM;
return -1;
}
| [
"static int FUNC_0(FsContext *VAR_0, const char *VAR_1,\nV9fsPath *VAR_2, const char *VAR_3, FsCred *VAR_4)\n{",
"errno = EPERM;",
"return -1;",
"}"
] | [
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
]
] |
24,106 | static uint32_t virtio_ioport_read(void *opaque, uint32_t addr)
{
VirtIODevice *vdev = to_virtio_device(opaque);
uint32_t ret = 0xFFFFFFFF;
addr -= vdev->addr;
switch (addr) {
case VIRTIO_PCI_HOST_FEATURES:
ret = vdev->get_features(vdev);
ret |= (1 << VIRTIO_F_NOTIFY_ON_EMPTY);
break;
case VIRTIO_PCI_GUEST_FEATURES:
ret = vdev->features;
break;
case VIRTIO_PCI_QUEUE_PFN:
ret = vdev->vq[vdev->queue_sel].pfn;
break;
case VIRTIO_PCI_QUEUE_NUM:
ret = vdev->vq[vdev->queue_sel].vring.num;
break;
case VIRTIO_PCI_QUEUE_SEL:
ret = vdev->queue_sel;
break;
case VIRTIO_PCI_STATUS:
ret = vdev->status;
break;
case VIRTIO_PCI_ISR:
/* reading from the ISR also clears it. */
ret = vdev->isr;
vdev->isr = 0;
virtio_update_irq(vdev);
break;
default:
break;
}
return ret;
}
| false | qemu | 8eca6b1bc770982595db2f7207c65051572436cb | static uint32_t virtio_ioport_read(void *opaque, uint32_t addr)
{
VirtIODevice *vdev = to_virtio_device(opaque);
uint32_t ret = 0xFFFFFFFF;
addr -= vdev->addr;
switch (addr) {
case VIRTIO_PCI_HOST_FEATURES:
ret = vdev->get_features(vdev);
ret |= (1 << VIRTIO_F_NOTIFY_ON_EMPTY);
break;
case VIRTIO_PCI_GUEST_FEATURES:
ret = vdev->features;
break;
case VIRTIO_PCI_QUEUE_PFN:
ret = vdev->vq[vdev->queue_sel].pfn;
break;
case VIRTIO_PCI_QUEUE_NUM:
ret = vdev->vq[vdev->queue_sel].vring.num;
break;
case VIRTIO_PCI_QUEUE_SEL:
ret = vdev->queue_sel;
break;
case VIRTIO_PCI_STATUS:
ret = vdev->status;
break;
case VIRTIO_PCI_ISR:
ret = vdev->isr;
vdev->isr = 0;
virtio_update_irq(vdev);
break;
default:
break;
}
return ret;
}
| {
"code": [],
"line_no": []
} | static uint32_t FUNC_0(void *opaque, uint32_t addr)
{
VirtIODevice *vdev = to_virtio_device(opaque);
uint32_t ret = 0xFFFFFFFF;
addr -= vdev->addr;
switch (addr) {
case VIRTIO_PCI_HOST_FEATURES:
ret = vdev->get_features(vdev);
ret |= (1 << VIRTIO_F_NOTIFY_ON_EMPTY);
break;
case VIRTIO_PCI_GUEST_FEATURES:
ret = vdev->features;
break;
case VIRTIO_PCI_QUEUE_PFN:
ret = vdev->vq[vdev->queue_sel].pfn;
break;
case VIRTIO_PCI_QUEUE_NUM:
ret = vdev->vq[vdev->queue_sel].vring.num;
break;
case VIRTIO_PCI_QUEUE_SEL:
ret = vdev->queue_sel;
break;
case VIRTIO_PCI_STATUS:
ret = vdev->status;
break;
case VIRTIO_PCI_ISR:
ret = vdev->isr;
vdev->isr = 0;
virtio_update_irq(vdev);
break;
default:
break;
}
return ret;
}
| [
"static uint32_t FUNC_0(void *opaque, uint32_t addr)\n{",
"VirtIODevice *vdev = to_virtio_device(opaque);",
"uint32_t ret = 0xFFFFFFFF;",
"addr -= vdev->addr;",
"switch (addr) {",
"case VIRTIO_PCI_HOST_FEATURES:\nret = vdev->get_features(vdev);",
"ret |= (1 << VIRTIO_F_NOTIFY_ON_EMPTY);",
"break;",
"case VIRTIO_PCI_GUEST_FEATURES:\nret = vdev->features;",
"break;",
"case VIRTIO_PCI_QUEUE_PFN:\nret = vdev->vq[vdev->queue_sel].pfn;",
"break;",
"case VIRTIO_PCI_QUEUE_NUM:\nret = vdev->vq[vdev->queue_sel].vring.num;",
"break;",
"case VIRTIO_PCI_QUEUE_SEL:\nret = vdev->queue_sel;",
"break;",
"case VIRTIO_PCI_STATUS:\nret = vdev->status;",
"break;",
"case VIRTIO_PCI_ISR:\nret = vdev->isr;",
"vdev->isr = 0;",
"virtio_update_irq(vdev);",
"break;",
"default:\nbreak;",
"}",
"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
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
15
],
[
17,
19
],
[
21
],
[
23
],
[
25,
27
],
[
29
],
[
31,
33
],
[
35
],
[
37,
39
],
[
41
],
[
43,
45
],
[
47
],
[
49,
51
],
[
53
],
[
55,
59
],
[
61
],
[
63
],
[
65
],
[
67,
69
],
[
71
],
[
75
],
[
77
]
] |
24,107 | static void sb16_realizefn (DeviceState *dev, Error **errp)
{
ISADevice *isadev = ISA_DEVICE (dev);
SB16State *s = SB16 (dev);
IsaDmaClass *k;
isa_init_irq (isadev, &s->pic, s->irq);
s->mixer_regs[0x80] = magic_of_irq (s->irq);
s->mixer_regs[0x81] = (1 << s->dma) | (1 << s->hdma);
s->mixer_regs[0x82] = 2 << 5;
s->csp_regs[5] = 1;
s->csp_regs[9] = 0xf8;
reset_mixer (s);
s->aux_ts = timer_new_ns(QEMU_CLOCK_VIRTUAL, aux_timer, s);
if (!s->aux_ts) {
dolog ("warning: Could not create auxiliary timer\n");
}
isa_register_portio_list (isadev, s->port, sb16_ioport_list, s, "sb16");
s->isa_hdma = isa_get_dma(isa_bus_from_device(isadev), s->hdma);
k = ISADMA_GET_CLASS(s->isa_hdma);
k->register_channel(s->isa_hdma, s->hdma, SB_read_DMA, s);
s->isa_dma = isa_get_dma(isa_bus_from_device(isadev), s->dma);
k = ISADMA_GET_CLASS(s->isa_dma);
k->register_channel(s->isa_dma, s->dma, SB_read_DMA, s);
s->can_write = 1;
AUD_register_card ("sb16", &s->card);
}
| true | qemu | e305a16510afa74eec20390479e349402e55ef4c | static void sb16_realizefn (DeviceState *dev, Error **errp)
{
ISADevice *isadev = ISA_DEVICE (dev);
SB16State *s = SB16 (dev);
IsaDmaClass *k;
isa_init_irq (isadev, &s->pic, s->irq);
s->mixer_regs[0x80] = magic_of_irq (s->irq);
s->mixer_regs[0x81] = (1 << s->dma) | (1 << s->hdma);
s->mixer_regs[0x82] = 2 << 5;
s->csp_regs[5] = 1;
s->csp_regs[9] = 0xf8;
reset_mixer (s);
s->aux_ts = timer_new_ns(QEMU_CLOCK_VIRTUAL, aux_timer, s);
if (!s->aux_ts) {
dolog ("warning: Could not create auxiliary timer\n");
}
isa_register_portio_list (isadev, s->port, sb16_ioport_list, s, "sb16");
s->isa_hdma = isa_get_dma(isa_bus_from_device(isadev), s->hdma);
k = ISADMA_GET_CLASS(s->isa_hdma);
k->register_channel(s->isa_hdma, s->hdma, SB_read_DMA, s);
s->isa_dma = isa_get_dma(isa_bus_from_device(isadev), s->dma);
k = ISADMA_GET_CLASS(s->isa_dma);
k->register_channel(s->isa_dma, s->dma, SB_read_DMA, s);
s->can_write = 1;
AUD_register_card ("sb16", &s->card);
}
| {
"code": [
" isa_register_portio_list (isadev, s->port, sb16_ioport_list, s, \"sb16\");"
],
"line_no": [
43
]
} | static void FUNC_0 (DeviceState *VAR_0, Error **VAR_1)
{
ISADevice *isadev = ISA_DEVICE (VAR_0);
SB16State *s = SB16 (VAR_0);
IsaDmaClass *k;
isa_init_irq (isadev, &s->pic, s->irq);
s->mixer_regs[0x80] = magic_of_irq (s->irq);
s->mixer_regs[0x81] = (1 << s->dma) | (1 << s->hdma);
s->mixer_regs[0x82] = 2 << 5;
s->csp_regs[5] = 1;
s->csp_regs[9] = 0xf8;
reset_mixer (s);
s->aux_ts = timer_new_ns(QEMU_CLOCK_VIRTUAL, aux_timer, s);
if (!s->aux_ts) {
dolog ("warning: Could not create auxiliary timer\n");
}
isa_register_portio_list (isadev, s->port, sb16_ioport_list, s, "sb16");
s->isa_hdma = isa_get_dma(isa_bus_from_device(isadev), s->hdma);
k = ISADMA_GET_CLASS(s->isa_hdma);
k->register_channel(s->isa_hdma, s->hdma, SB_read_DMA, s);
s->isa_dma = isa_get_dma(isa_bus_from_device(isadev), s->dma);
k = ISADMA_GET_CLASS(s->isa_dma);
k->register_channel(s->isa_dma, s->dma, SB_read_DMA, s);
s->can_write = 1;
AUD_register_card ("sb16", &s->card);
}
| [
"static void FUNC_0 (DeviceState *VAR_0, Error **VAR_1)\n{",
"ISADevice *isadev = ISA_DEVICE (VAR_0);",
"SB16State *s = SB16 (VAR_0);",
"IsaDmaClass *k;",
"isa_init_irq (isadev, &s->pic, s->irq);",
"s->mixer_regs[0x80] = magic_of_irq (s->irq);",
"s->mixer_regs[0x81] = (1 << s->dma) | (1 << s->hdma);",
"s->mixer_regs[0x82] = 2 << 5;",
"s->csp_regs[5] = 1;",
"s->csp_regs[9] = 0xf8;",
"reset_mixer (s);",
"s->aux_ts = timer_new_ns(QEMU_CLOCK_VIRTUAL, aux_timer, s);",
"if (!s->aux_ts) {",
"dolog (\"warning: Could not create auxiliary timer\\n\");",
"}",
"isa_register_portio_list (isadev, s->port, sb16_ioport_list, s, \"sb16\");",
"s->isa_hdma = isa_get_dma(isa_bus_from_device(isadev), s->hdma);",
"k = ISADMA_GET_CLASS(s->isa_hdma);",
"k->register_channel(s->isa_hdma, s->hdma, SB_read_DMA, s);",
"s->isa_dma = isa_get_dma(isa_bus_from_device(isadev), s->dma);",
"k = ISADMA_GET_CLASS(s->isa_dma);",
"k->register_channel(s->isa_dma, s->dma, SB_read_DMA, s);",
"s->can_write = 1;",
"AUD_register_card (\"sb16\", &s->card);",
"}"
] | [
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
] | [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
47
],
[
49
],
[
51
],
[
55
],
[
57
],
[
59
],
[
63
],
[
67
],
[
69
]
] |
24,108 | static int slavio_misc_init1(SysBusDevice *sbd)
{
DeviceState *dev = DEVICE(sbd);
MiscState *s = SLAVIO_MISC(dev);
sysbus_init_irq(sbd, &s->irq);
sysbus_init_irq(sbd, &s->fdc_tc);
/* 8 bit registers */
/* Slavio control */
memory_region_init_io(&s->cfg_iomem, OBJECT(s), &slavio_cfg_mem_ops, s,
"configuration", MISC_SIZE);
sysbus_init_mmio(sbd, &s->cfg_iomem);
/* Diagnostics */
memory_region_init_io(&s->diag_iomem, OBJECT(s), &slavio_diag_mem_ops, s,
"diagnostic", MISC_SIZE);
sysbus_init_mmio(sbd, &s->diag_iomem);
/* Modem control */
memory_region_init_io(&s->mdm_iomem, OBJECT(s), &slavio_mdm_mem_ops, s,
"modem", MISC_SIZE);
sysbus_init_mmio(sbd, &s->mdm_iomem);
/* 16 bit registers */
/* ss600mp diag LEDs */
memory_region_init_io(&s->led_iomem, OBJECT(s), &slavio_led_mem_ops, s,
"leds", MISC_SIZE);
sysbus_init_mmio(sbd, &s->led_iomem);
/* 32 bit registers */
/* System control */
memory_region_init_io(&s->sysctrl_iomem, OBJECT(s), &slavio_sysctrl_mem_ops, s,
"system-control", MISC_SIZE);
sysbus_init_mmio(sbd, &s->sysctrl_iomem);
/* AUX 1 (Misc System Functions) */
memory_region_init_io(&s->aux1_iomem, OBJECT(s), &slavio_aux1_mem_ops, s,
"misc-system-functions", MISC_SIZE);
sysbus_init_mmio(sbd, &s->aux1_iomem);
/* AUX 2 (Software Powerdown Control) */
memory_region_init_io(&s->aux2_iomem, OBJECT(s), &slavio_aux2_mem_ops, s,
"software-powerdown-control", MISC_SIZE);
sysbus_init_mmio(sbd, &s->aux2_iomem);
qdev_init_gpio_in(dev, slavio_set_power_fail, 1);
return 0;
}
| true | qemu | 0e1cd6576c55269b6e5251dc739a7fc819f9b4a6 | static int slavio_misc_init1(SysBusDevice *sbd)
{
DeviceState *dev = DEVICE(sbd);
MiscState *s = SLAVIO_MISC(dev);
sysbus_init_irq(sbd, &s->irq);
sysbus_init_irq(sbd, &s->fdc_tc);
memory_region_init_io(&s->cfg_iomem, OBJECT(s), &slavio_cfg_mem_ops, s,
"configuration", MISC_SIZE);
sysbus_init_mmio(sbd, &s->cfg_iomem);
memory_region_init_io(&s->diag_iomem, OBJECT(s), &slavio_diag_mem_ops, s,
"diagnostic", MISC_SIZE);
sysbus_init_mmio(sbd, &s->diag_iomem);
memory_region_init_io(&s->mdm_iomem, OBJECT(s), &slavio_mdm_mem_ops, s,
"modem", MISC_SIZE);
sysbus_init_mmio(sbd, &s->mdm_iomem);
memory_region_init_io(&s->led_iomem, OBJECT(s), &slavio_led_mem_ops, s,
"leds", MISC_SIZE);
sysbus_init_mmio(sbd, &s->led_iomem);
memory_region_init_io(&s->sysctrl_iomem, OBJECT(s), &slavio_sysctrl_mem_ops, s,
"system-control", MISC_SIZE);
sysbus_init_mmio(sbd, &s->sysctrl_iomem);
memory_region_init_io(&s->aux1_iomem, OBJECT(s), &slavio_aux1_mem_ops, s,
"misc-system-functions", MISC_SIZE);
sysbus_init_mmio(sbd, &s->aux1_iomem);
memory_region_init_io(&s->aux2_iomem, OBJECT(s), &slavio_aux2_mem_ops, s,
"software-powerdown-control", MISC_SIZE);
sysbus_init_mmio(sbd, &s->aux2_iomem);
qdev_init_gpio_in(dev, slavio_set_power_fail, 1);
return 0;
}
| {
"code": [
" \"leds\", MISC_SIZE);",
" \"system-control\", MISC_SIZE);"
],
"line_no": [
55,
67
]
} | static int FUNC_0(SysBusDevice *VAR_0)
{
DeviceState *dev = DEVICE(VAR_0);
MiscState *s = SLAVIO_MISC(dev);
sysbus_init_irq(VAR_0, &s->irq);
sysbus_init_irq(VAR_0, &s->fdc_tc);
memory_region_init_io(&s->cfg_iomem, OBJECT(s), &slavio_cfg_mem_ops, s,
"configuration", MISC_SIZE);
sysbus_init_mmio(VAR_0, &s->cfg_iomem);
memory_region_init_io(&s->diag_iomem, OBJECT(s), &slavio_diag_mem_ops, s,
"diagnostic", MISC_SIZE);
sysbus_init_mmio(VAR_0, &s->diag_iomem);
memory_region_init_io(&s->mdm_iomem, OBJECT(s), &slavio_mdm_mem_ops, s,
"modem", MISC_SIZE);
sysbus_init_mmio(VAR_0, &s->mdm_iomem);
memory_region_init_io(&s->led_iomem, OBJECT(s), &slavio_led_mem_ops, s,
"leds", MISC_SIZE);
sysbus_init_mmio(VAR_0, &s->led_iomem);
memory_region_init_io(&s->sysctrl_iomem, OBJECT(s), &slavio_sysctrl_mem_ops, s,
"system-control", MISC_SIZE);
sysbus_init_mmio(VAR_0, &s->sysctrl_iomem);
memory_region_init_io(&s->aux1_iomem, OBJECT(s), &slavio_aux1_mem_ops, s,
"misc-system-functions", MISC_SIZE);
sysbus_init_mmio(VAR_0, &s->aux1_iomem);
memory_region_init_io(&s->aux2_iomem, OBJECT(s), &slavio_aux2_mem_ops, s,
"software-powerdown-control", MISC_SIZE);
sysbus_init_mmio(VAR_0, &s->aux2_iomem);
qdev_init_gpio_in(dev, slavio_set_power_fail, 1);
return 0;
}
| [
"static int FUNC_0(SysBusDevice *VAR_0)\n{",
"DeviceState *dev = DEVICE(VAR_0);",
"MiscState *s = SLAVIO_MISC(dev);",
"sysbus_init_irq(VAR_0, &s->irq);",
"sysbus_init_irq(VAR_0, &s->fdc_tc);",
"memory_region_init_io(&s->cfg_iomem, OBJECT(s), &slavio_cfg_mem_ops, s,\n\"configuration\", MISC_SIZE);",
"sysbus_init_mmio(VAR_0, &s->cfg_iomem);",
"memory_region_init_io(&s->diag_iomem, OBJECT(s), &slavio_diag_mem_ops, s,\n\"diagnostic\", MISC_SIZE);",
"sysbus_init_mmio(VAR_0, &s->diag_iomem);",
"memory_region_init_io(&s->mdm_iomem, OBJECT(s), &slavio_mdm_mem_ops, s,\n\"modem\", MISC_SIZE);",
"sysbus_init_mmio(VAR_0, &s->mdm_iomem);",
"memory_region_init_io(&s->led_iomem, OBJECT(s), &slavio_led_mem_ops, s,\n\"leds\", MISC_SIZE);",
"sysbus_init_mmio(VAR_0, &s->led_iomem);",
"memory_region_init_io(&s->sysctrl_iomem, OBJECT(s), &slavio_sysctrl_mem_ops, s,\n\"system-control\", MISC_SIZE);",
"sysbus_init_mmio(VAR_0, &s->sysctrl_iomem);",
"memory_region_init_io(&s->aux1_iomem, OBJECT(s), &slavio_aux1_mem_ops, s,\n\"misc-system-functions\", MISC_SIZE);",
"sysbus_init_mmio(VAR_0, &s->aux1_iomem);",
"memory_region_init_io(&s->aux2_iomem, OBJECT(s), &slavio_aux2_mem_ops, s,\n\"software-powerdown-control\", MISC_SIZE);",
"sysbus_init_mmio(VAR_0, &s->aux2_iomem);",
"qdev_init_gpio_in(dev, slavio_set_power_fail, 1);",
"return 0;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
21,
23
],
[
25
],
[
31,
33
],
[
35
],
[
41,
43
],
[
45
],
[
53,
55
],
[
57
],
[
65,
67
],
[
69
],
[
75,
77
],
[
79
],
[
85,
87
],
[
89
],
[
93
],
[
97
],
[
99
]
] |
24,109 | static QIOChannelSocket *nbd_establish_connection(SocketAddress *saddr,
Error **errp)
{
QIOChannelSocket *sioc;
Error *local_err = NULL;
sioc = qio_channel_socket_new();
qio_channel_set_name(QIO_CHANNEL(sioc), "nbd-client");
qio_channel_socket_connect_sync(sioc,
saddr,
&local_err);
if (local_err) {
error_propagate(errp, local_err);
return NULL;
}
qio_channel_set_delay(QIO_CHANNEL(sioc), false);
return sioc;
} | true | qemu | cc1e13913916f755fd2dc5041b8d4bf25d3ea88e | static QIOChannelSocket *nbd_establish_connection(SocketAddress *saddr,
Error **errp)
{
QIOChannelSocket *sioc;
Error *local_err = NULL;
sioc = qio_channel_socket_new();
qio_channel_set_name(QIO_CHANNEL(sioc), "nbd-client");
qio_channel_socket_connect_sync(sioc,
saddr,
&local_err);
if (local_err) {
error_propagate(errp, local_err);
return NULL;
}
qio_channel_set_delay(QIO_CHANNEL(sioc), false);
return sioc;
} | {
"code": [],
"line_no": []
} | static QIOChannelSocket *FUNC_0(SocketAddress *saddr,
Error **errp)
{
QIOChannelSocket *sioc;
Error *local_err = NULL;
sioc = qio_channel_socket_new();
qio_channel_set_name(QIO_CHANNEL(sioc), "nbd-client");
qio_channel_socket_connect_sync(sioc,
saddr,
&local_err);
if (local_err) {
error_propagate(errp, local_err);
return NULL;
}
qio_channel_set_delay(QIO_CHANNEL(sioc), false);
return sioc;
} | [
"static QIOChannelSocket *FUNC_0(SocketAddress *saddr,\nError **errp)\n{",
"QIOChannelSocket *sioc;",
"Error *local_err = NULL;",
"sioc = qio_channel_socket_new();",
"qio_channel_set_name(QIO_CHANNEL(sioc), \"nbd-client\");",
"qio_channel_socket_connect_sync(sioc,\nsaddr,\n&local_err);",
"if (local_err) {",
"error_propagate(errp, local_err);",
"return NULL;",
"}",
"qio_channel_set_delay(QIO_CHANNEL(sioc), false);",
"return sioc;",
"}"
] | [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
] | [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
19,
21,
23
],
[
25
],
[
28
],
[
30
],
[
32
],
[
36
],
[
40
],
[
42
]
] |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.