id
int32 0
27.3k
| func
stringlengths 26
142k
| target
bool 2
classes | project
stringclasses 2
values | commit_id
stringlengths 40
40
| func_clean
stringlengths 26
131k
| vul_lines
dict | normalized_func
stringlengths 24
132k
| lines
listlengths 1
2.8k
| label
listlengths 1
2.8k
| line_no
listlengths 1
2.8k
|
|---|---|---|---|---|---|---|---|---|---|---|
16,957 | void net_tx_pkt_build_vheader(struct NetTxPkt *pkt, bool tso_enable,
bool csum_enable, uint32_t gso_size)
{
struct tcp_hdr l4hdr;
assert(pkt);
/* csum has to be enabled if tso is. */
assert(csum_enable || !tso_enable);
pkt->virt_hdr.gso_type = net_tx_pkt_get_gso_type(pkt, tso_enable);
switch (pkt->virt_hdr.gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
case VIRTIO_NET_HDR_GSO_NONE:
pkt->virt_hdr.hdr_len = 0;
pkt->virt_hdr.gso_size = 0;
break;
case VIRTIO_NET_HDR_GSO_UDP:
pkt->virt_hdr.gso_size = IP_FRAG_ALIGN_SIZE(gso_size);
pkt->virt_hdr.hdr_len = pkt->hdr_len + sizeof(struct udp_header);
break;
case VIRTIO_NET_HDR_GSO_TCPV4:
case VIRTIO_NET_HDR_GSO_TCPV6:
iov_to_buf(&pkt->vec[NET_TX_PKT_PL_START_FRAG], pkt->payload_frags,
0, &l4hdr, sizeof(l4hdr));
pkt->virt_hdr.hdr_len = pkt->hdr_len + l4hdr.th_off * sizeof(uint32_t);
pkt->virt_hdr.gso_size = IP_FRAG_ALIGN_SIZE(gso_size);
break;
default:
g_assert_not_reached();
}
if (csum_enable) {
switch (pkt->l4proto) {
case IP_PROTO_TCP:
pkt->virt_hdr.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
pkt->virt_hdr.csum_start = pkt->hdr_len;
pkt->virt_hdr.csum_offset = offsetof(struct tcp_hdr, th_sum);
break;
case IP_PROTO_UDP:
pkt->virt_hdr.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
pkt->virt_hdr.csum_start = pkt->hdr_len;
pkt->virt_hdr.csum_offset = offsetof(struct udp_hdr, uh_sum);
break;
default:
break;
}
}
}
| false | qemu | eb700029c7836798046191d62d595363d92c84d4 | void net_tx_pkt_build_vheader(struct NetTxPkt *pkt, bool tso_enable,
bool csum_enable, uint32_t gso_size)
{
struct tcp_hdr l4hdr;
assert(pkt);
assert(csum_enable || !tso_enable);
pkt->virt_hdr.gso_type = net_tx_pkt_get_gso_type(pkt, tso_enable);
switch (pkt->virt_hdr.gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
case VIRTIO_NET_HDR_GSO_NONE:
pkt->virt_hdr.hdr_len = 0;
pkt->virt_hdr.gso_size = 0;
break;
case VIRTIO_NET_HDR_GSO_UDP:
pkt->virt_hdr.gso_size = IP_FRAG_ALIGN_SIZE(gso_size);
pkt->virt_hdr.hdr_len = pkt->hdr_len + sizeof(struct udp_header);
break;
case VIRTIO_NET_HDR_GSO_TCPV4:
case VIRTIO_NET_HDR_GSO_TCPV6:
iov_to_buf(&pkt->vec[NET_TX_PKT_PL_START_FRAG], pkt->payload_frags,
0, &l4hdr, sizeof(l4hdr));
pkt->virt_hdr.hdr_len = pkt->hdr_len + l4hdr.th_off * sizeof(uint32_t);
pkt->virt_hdr.gso_size = IP_FRAG_ALIGN_SIZE(gso_size);
break;
default:
g_assert_not_reached();
}
if (csum_enable) {
switch (pkt->l4proto) {
case IP_PROTO_TCP:
pkt->virt_hdr.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
pkt->virt_hdr.csum_start = pkt->hdr_len;
pkt->virt_hdr.csum_offset = offsetof(struct tcp_hdr, th_sum);
break;
case IP_PROTO_UDP:
pkt->virt_hdr.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
pkt->virt_hdr.csum_start = pkt->hdr_len;
pkt->virt_hdr.csum_offset = offsetof(struct udp_hdr, uh_sum);
break;
default:
break;
}
}
}
| {
"code": [],
"line_no": []
} | void FUNC_0(struct NetTxPkt *VAR_0, bool VAR_1,
bool VAR_2, uint32_t VAR_3)
{
struct tcp_hdr VAR_4;
assert(VAR_0);
assert(VAR_2 || !VAR_1);
VAR_0->virt_hdr.gso_type = net_tx_pkt_get_gso_type(VAR_0, VAR_1);
switch (VAR_0->virt_hdr.gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
case VIRTIO_NET_HDR_GSO_NONE:
VAR_0->virt_hdr.hdr_len = 0;
VAR_0->virt_hdr.VAR_3 = 0;
break;
case VIRTIO_NET_HDR_GSO_UDP:
VAR_0->virt_hdr.VAR_3 = IP_FRAG_ALIGN_SIZE(VAR_3);
VAR_0->virt_hdr.hdr_len = VAR_0->hdr_len + sizeof(struct udp_header);
break;
case VIRTIO_NET_HDR_GSO_TCPV4:
case VIRTIO_NET_HDR_GSO_TCPV6:
iov_to_buf(&VAR_0->vec[NET_TX_PKT_PL_START_FRAG], VAR_0->payload_frags,
0, &VAR_4, sizeof(VAR_4));
VAR_0->virt_hdr.hdr_len = VAR_0->hdr_len + VAR_4.th_off * sizeof(uint32_t);
VAR_0->virt_hdr.VAR_3 = IP_FRAG_ALIGN_SIZE(VAR_3);
break;
default:
g_assert_not_reached();
}
if (VAR_2) {
switch (VAR_0->l4proto) {
case IP_PROTO_TCP:
VAR_0->virt_hdr.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
VAR_0->virt_hdr.csum_start = VAR_0->hdr_len;
VAR_0->virt_hdr.csum_offset = offsetof(struct tcp_hdr, th_sum);
break;
case IP_PROTO_UDP:
VAR_0->virt_hdr.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
VAR_0->virt_hdr.csum_start = VAR_0->hdr_len;
VAR_0->virt_hdr.csum_offset = offsetof(struct udp_hdr, uh_sum);
break;
default:
break;
}
}
}
| [
"void FUNC_0(struct NetTxPkt *VAR_0, bool VAR_1,\nbool VAR_2, uint32_t VAR_3)\n{",
"struct tcp_hdr VAR_4;",
"assert(VAR_0);",
"assert(VAR_2 || !VAR_1);",
"VAR_0->virt_hdr.gso_type = net_tx_pkt_get_gso_type(VAR_0, VAR_1);",
"switch (VAR_0->virt_hdr.gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {",
"case VIRTIO_NET_HDR_GSO_NONE:\nVAR_0->virt_hdr.hdr_len = 0;",
"VAR_0->virt_hdr.VAR_3 = 0;",
"break;",
"case VIRTIO_NET_HDR_GSO_UDP:\nVAR_0->virt_hdr.VAR_3 = IP_FRAG_ALIGN_SIZE(VAR_3);",
"VAR_0->virt_hdr.hdr_len = VAR_0->hdr_len + sizeof(struct udp_header);",
"break;",
"case VIRTIO_NET_HDR_GSO_TCPV4:\ncase VIRTIO_NET_HDR_GSO_TCPV6:\niov_to_buf(&VAR_0->vec[NET_TX_PKT_PL_START_FRAG], VAR_0->payload_frags,\n0, &VAR_4, sizeof(VAR_4));",
"VAR_0->virt_hdr.hdr_len = VAR_0->hdr_len + VAR_4.th_off * sizeof(uint32_t);",
"VAR_0->virt_hdr.VAR_3 = IP_FRAG_ALIGN_SIZE(VAR_3);",
"break;",
"default:\ng_assert_not_reached();",
"}",
"if (VAR_2) {",
"switch (VAR_0->l4proto) {",
"case IP_PROTO_TCP:\nVAR_0->virt_hdr.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;",
"VAR_0->virt_hdr.csum_start = VAR_0->hdr_len;",
"VAR_0->virt_hdr.csum_offset = offsetof(struct tcp_hdr, th_sum);",
"break;",
"case IP_PROTO_UDP:\nVAR_0->virt_hdr.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;",
"VAR_0->virt_hdr.csum_start = VAR_0->hdr_len;",
"VAR_0->virt_hdr.csum_offset = offsetof(struct udp_hdr, uh_sum);",
"break;",
"default:\nbreak;",
"}",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
15
],
[
19
],
[
23
],
[
25,
27
],
[
29
],
[
31
],
[
35,
37
],
[
39
],
[
41
],
[
45,
47,
49,
51
],
[
53
],
[
55
],
[
57
],
[
61,
63
],
[
65
],
[
69
],
[
71
],
[
73,
75
],
[
77
],
[
79
],
[
81
],
[
83,
85
],
[
87
],
[
89
],
[
91
],
[
93,
95
],
[
97
],
[
99
],
[
101
]
]
|
16,958 | static void gen_mipsdsp_add_cmp_pick(DisasContext *ctx,
uint32_t op1, uint32_t op2,
int ret, int v1, int v2, int check_ret)
{
const char *opn = "mipsdsp add compare pick";
TCGv_i32 t0;
TCGv t1;
TCGv v1_t;
TCGv v2_t;
if ((ret == 0) && (check_ret == 1)) {
/* Treat as NOP. */
MIPS_DEBUG("NOP");
return;
}
t0 = tcg_temp_new_i32();
t1 = tcg_temp_new();
v1_t = tcg_temp_new();
v2_t = tcg_temp_new();
gen_load_gpr(v1_t, v1);
gen_load_gpr(v2_t, v2);
switch (op1) {
case OPC_APPEND_DSP:
switch (op2) {
case OPC_APPEND:
tcg_gen_movi_i32(t0, v2);
gen_helper_append(cpu_gpr[ret], cpu_gpr[ret], v1_t, t0);
break;
case OPC_PREPEND:
tcg_gen_movi_i32(t0, v2);
gen_helper_prepend(cpu_gpr[ret], v1_t, cpu_gpr[ret], t0);
break;
case OPC_BALIGN:
tcg_gen_movi_i32(t0, v2);
gen_helper_balign(cpu_gpr[ret], v1_t, cpu_gpr[ret], t0);
break;
default: /* Invid */
MIPS_INVAL("MASK APPEND");
generate_exception(ctx, EXCP_RI);
break;
}
break;
case OPC_CMPU_EQ_QB_DSP:
switch (op2) {
case OPC_CMPU_EQ_QB:
check_dsp(ctx);
gen_helper_cmpu_eq_qb(v1_t, v2_t, cpu_env);
break;
case OPC_CMPU_LT_QB:
check_dsp(ctx);
gen_helper_cmpu_lt_qb(v1_t, v2_t, cpu_env);
break;
case OPC_CMPU_LE_QB:
check_dsp(ctx);
gen_helper_cmpu_le_qb(v1_t, v2_t, cpu_env);
break;
case OPC_CMPGU_EQ_QB:
check_dsp(ctx);
gen_helper_cmpgu_eq_qb(cpu_gpr[ret], v1_t, v2_t);
break;
case OPC_CMPGU_LT_QB:
check_dsp(ctx);
gen_helper_cmpgu_lt_qb(cpu_gpr[ret], v1_t, v2_t);
break;
case OPC_CMPGU_LE_QB:
check_dsp(ctx);
gen_helper_cmpgu_le_qb(cpu_gpr[ret], v1_t, v2_t);
break;
case OPC_CMPGDU_EQ_QB:
check_dspr2(ctx);
gen_helper_cmpgu_eq_qb(t1, v1_t, v2_t);
tcg_gen_mov_tl(cpu_gpr[ret], t1);
tcg_gen_andi_tl(cpu_dspctrl, cpu_dspctrl, 0xF0FFFFFF);
tcg_gen_shli_tl(t1, t1, 24);
tcg_gen_or_tl(cpu_dspctrl, cpu_dspctrl, t1);
break;
case OPC_CMPGDU_LT_QB:
check_dspr2(ctx);
gen_helper_cmpgu_lt_qb(t1, v1_t, v2_t);
tcg_gen_mov_tl(cpu_gpr[ret], t1);
tcg_gen_andi_tl(cpu_dspctrl, cpu_dspctrl, 0xF0FFFFFF);
tcg_gen_shli_tl(t1, t1, 24);
tcg_gen_or_tl(cpu_dspctrl, cpu_dspctrl, t1);
break;
case OPC_CMPGDU_LE_QB:
check_dspr2(ctx);
gen_helper_cmpgu_le_qb(t1, v1_t, v2_t);
tcg_gen_mov_tl(cpu_gpr[ret], t1);
tcg_gen_andi_tl(cpu_dspctrl, cpu_dspctrl, 0xF0FFFFFF);
tcg_gen_shli_tl(t1, t1, 24);
tcg_gen_or_tl(cpu_dspctrl, cpu_dspctrl, t1);
break;
case OPC_CMP_EQ_PH:
check_dsp(ctx);
gen_helper_cmp_eq_ph(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LT_PH:
check_dsp(ctx);
gen_helper_cmp_lt_ph(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LE_PH:
check_dsp(ctx);
gen_helper_cmp_le_ph(v1_t, v2_t, cpu_env);
break;
case OPC_PICK_QB:
check_dsp(ctx);
gen_helper_pick_qb(cpu_gpr[ret], v1_t, v2_t, cpu_env);
break;
case OPC_PICK_PH:
check_dsp(ctx);
gen_helper_pick_ph(cpu_gpr[ret], v1_t, v2_t, cpu_env);
break;
case OPC_PACKRL_PH:
check_dsp(ctx);
gen_helper_packrl_ph(cpu_gpr[ret], v1_t, v2_t);
break;
}
break;
#ifdef TARGET_MIPS64
case OPC_CMPU_EQ_OB_DSP:
switch (op2) {
case OPC_CMP_EQ_PW:
check_dsp(ctx);
gen_helper_cmp_eq_pw(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LT_PW:
check_dsp(ctx);
gen_helper_cmp_lt_pw(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LE_PW:
check_dsp(ctx);
gen_helper_cmp_le_pw(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_EQ_QH:
check_dsp(ctx);
gen_helper_cmp_eq_qh(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LT_QH:
check_dsp(ctx);
gen_helper_cmp_lt_qh(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LE_QH:
check_dsp(ctx);
gen_helper_cmp_le_qh(v1_t, v2_t, cpu_env);
break;
case OPC_CMPGDU_EQ_OB:
check_dspr2(ctx);
gen_helper_cmpgdu_eq_ob(cpu_gpr[ret], v1_t, v2_t, cpu_env);
break;
case OPC_CMPGDU_LT_OB:
check_dspr2(ctx);
gen_helper_cmpgdu_lt_ob(cpu_gpr[ret], v1_t, v2_t, cpu_env);
break;
case OPC_CMPGDU_LE_OB:
check_dspr2(ctx);
gen_helper_cmpgdu_le_ob(cpu_gpr[ret], v1_t, v2_t, cpu_env);
break;
case OPC_CMPGU_EQ_OB:
check_dsp(ctx);
gen_helper_cmpgu_eq_ob(cpu_gpr[ret], v1_t, v2_t);
break;
case OPC_CMPGU_LT_OB:
check_dsp(ctx);
gen_helper_cmpgu_lt_ob(cpu_gpr[ret], v1_t, v2_t);
break;
case OPC_CMPGU_LE_OB:
check_dsp(ctx);
gen_helper_cmpgu_le_ob(cpu_gpr[ret], v1_t, v2_t);
break;
case OPC_CMPU_EQ_OB:
check_dsp(ctx);
gen_helper_cmpu_eq_ob(v1_t, v2_t, cpu_env);
break;
case OPC_CMPU_LT_OB:
check_dsp(ctx);
gen_helper_cmpu_lt_ob(v1_t, v2_t, cpu_env);
break;
case OPC_CMPU_LE_OB:
check_dsp(ctx);
gen_helper_cmpu_le_ob(v1_t, v2_t, cpu_env);
break;
case OPC_PACKRL_PW:
check_dsp(ctx);
gen_helper_packrl_pw(cpu_gpr[ret], v1_t, v2_t);
break;
case OPC_PICK_OB:
check_dsp(ctx);
gen_helper_pick_ob(cpu_gpr[ret], v1_t, v2_t, cpu_env);
break;
case OPC_PICK_PW:
check_dsp(ctx);
gen_helper_pick_pw(cpu_gpr[ret], v1_t, v2_t, cpu_env);
break;
case OPC_PICK_QH:
check_dsp(ctx);
gen_helper_pick_qh(cpu_gpr[ret], v1_t, v2_t, cpu_env);
break;
}
break;
case OPC_DAPPEND_DSP:
switch (op2) {
case OPC_DAPPEND:
tcg_gen_movi_i32(t0, v2);
gen_helper_dappend(cpu_gpr[ret], v1_t, cpu_gpr[ret], t0);
break;
case OPC_PREPENDD:
tcg_gen_movi_i32(t0, v2);
gen_helper_prependd(cpu_gpr[ret], v1_t, cpu_gpr[ret], t0);
break;
case OPC_PREPENDW:
tcg_gen_movi_i32(t0, v2);
gen_helper_prependw(cpu_gpr[ret], v1_t, cpu_gpr[ret], t0);
break;
case OPC_DBALIGN:
tcg_gen_movi_i32(t0, v2);
gen_helper_dbalign(cpu_gpr[ret], v1_t, cpu_gpr[ret], t0);
break;
default: /* Invalid */
MIPS_INVAL("MASK DAPPEND");
generate_exception(ctx, EXCP_RI);
break;
}
break;
#endif
}
tcg_temp_free_i32(t0);
tcg_temp_free(t1);
tcg_temp_free(v1_t);
tcg_temp_free(v2_t);
(void)opn; /* avoid a compiler warning */
MIPS_DEBUG("%s", opn);
}
| false | qemu | df6126a7f21a1a032e41b15899ca29777399d5a2 | static void gen_mipsdsp_add_cmp_pick(DisasContext *ctx,
uint32_t op1, uint32_t op2,
int ret, int v1, int v2, int check_ret)
{
const char *opn = "mipsdsp add compare pick";
TCGv_i32 t0;
TCGv t1;
TCGv v1_t;
TCGv v2_t;
if ((ret == 0) && (check_ret == 1)) {
MIPS_DEBUG("NOP");
return;
}
t0 = tcg_temp_new_i32();
t1 = tcg_temp_new();
v1_t = tcg_temp_new();
v2_t = tcg_temp_new();
gen_load_gpr(v1_t, v1);
gen_load_gpr(v2_t, v2);
switch (op1) {
case OPC_APPEND_DSP:
switch (op2) {
case OPC_APPEND:
tcg_gen_movi_i32(t0, v2);
gen_helper_append(cpu_gpr[ret], cpu_gpr[ret], v1_t, t0);
break;
case OPC_PREPEND:
tcg_gen_movi_i32(t0, v2);
gen_helper_prepend(cpu_gpr[ret], v1_t, cpu_gpr[ret], t0);
break;
case OPC_BALIGN:
tcg_gen_movi_i32(t0, v2);
gen_helper_balign(cpu_gpr[ret], v1_t, cpu_gpr[ret], t0);
break;
default:
MIPS_INVAL("MASK APPEND");
generate_exception(ctx, EXCP_RI);
break;
}
break;
case OPC_CMPU_EQ_QB_DSP:
switch (op2) {
case OPC_CMPU_EQ_QB:
check_dsp(ctx);
gen_helper_cmpu_eq_qb(v1_t, v2_t, cpu_env);
break;
case OPC_CMPU_LT_QB:
check_dsp(ctx);
gen_helper_cmpu_lt_qb(v1_t, v2_t, cpu_env);
break;
case OPC_CMPU_LE_QB:
check_dsp(ctx);
gen_helper_cmpu_le_qb(v1_t, v2_t, cpu_env);
break;
case OPC_CMPGU_EQ_QB:
check_dsp(ctx);
gen_helper_cmpgu_eq_qb(cpu_gpr[ret], v1_t, v2_t);
break;
case OPC_CMPGU_LT_QB:
check_dsp(ctx);
gen_helper_cmpgu_lt_qb(cpu_gpr[ret], v1_t, v2_t);
break;
case OPC_CMPGU_LE_QB:
check_dsp(ctx);
gen_helper_cmpgu_le_qb(cpu_gpr[ret], v1_t, v2_t);
break;
case OPC_CMPGDU_EQ_QB:
check_dspr2(ctx);
gen_helper_cmpgu_eq_qb(t1, v1_t, v2_t);
tcg_gen_mov_tl(cpu_gpr[ret], t1);
tcg_gen_andi_tl(cpu_dspctrl, cpu_dspctrl, 0xF0FFFFFF);
tcg_gen_shli_tl(t1, t1, 24);
tcg_gen_or_tl(cpu_dspctrl, cpu_dspctrl, t1);
break;
case OPC_CMPGDU_LT_QB:
check_dspr2(ctx);
gen_helper_cmpgu_lt_qb(t1, v1_t, v2_t);
tcg_gen_mov_tl(cpu_gpr[ret], t1);
tcg_gen_andi_tl(cpu_dspctrl, cpu_dspctrl, 0xF0FFFFFF);
tcg_gen_shli_tl(t1, t1, 24);
tcg_gen_or_tl(cpu_dspctrl, cpu_dspctrl, t1);
break;
case OPC_CMPGDU_LE_QB:
check_dspr2(ctx);
gen_helper_cmpgu_le_qb(t1, v1_t, v2_t);
tcg_gen_mov_tl(cpu_gpr[ret], t1);
tcg_gen_andi_tl(cpu_dspctrl, cpu_dspctrl, 0xF0FFFFFF);
tcg_gen_shli_tl(t1, t1, 24);
tcg_gen_or_tl(cpu_dspctrl, cpu_dspctrl, t1);
break;
case OPC_CMP_EQ_PH:
check_dsp(ctx);
gen_helper_cmp_eq_ph(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LT_PH:
check_dsp(ctx);
gen_helper_cmp_lt_ph(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LE_PH:
check_dsp(ctx);
gen_helper_cmp_le_ph(v1_t, v2_t, cpu_env);
break;
case OPC_PICK_QB:
check_dsp(ctx);
gen_helper_pick_qb(cpu_gpr[ret], v1_t, v2_t, cpu_env);
break;
case OPC_PICK_PH:
check_dsp(ctx);
gen_helper_pick_ph(cpu_gpr[ret], v1_t, v2_t, cpu_env);
break;
case OPC_PACKRL_PH:
check_dsp(ctx);
gen_helper_packrl_ph(cpu_gpr[ret], v1_t, v2_t);
break;
}
break;
#ifdef TARGET_MIPS64
case OPC_CMPU_EQ_OB_DSP:
switch (op2) {
case OPC_CMP_EQ_PW:
check_dsp(ctx);
gen_helper_cmp_eq_pw(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LT_PW:
check_dsp(ctx);
gen_helper_cmp_lt_pw(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LE_PW:
check_dsp(ctx);
gen_helper_cmp_le_pw(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_EQ_QH:
check_dsp(ctx);
gen_helper_cmp_eq_qh(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LT_QH:
check_dsp(ctx);
gen_helper_cmp_lt_qh(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LE_QH:
check_dsp(ctx);
gen_helper_cmp_le_qh(v1_t, v2_t, cpu_env);
break;
case OPC_CMPGDU_EQ_OB:
check_dspr2(ctx);
gen_helper_cmpgdu_eq_ob(cpu_gpr[ret], v1_t, v2_t, cpu_env);
break;
case OPC_CMPGDU_LT_OB:
check_dspr2(ctx);
gen_helper_cmpgdu_lt_ob(cpu_gpr[ret], v1_t, v2_t, cpu_env);
break;
case OPC_CMPGDU_LE_OB:
check_dspr2(ctx);
gen_helper_cmpgdu_le_ob(cpu_gpr[ret], v1_t, v2_t, cpu_env);
break;
case OPC_CMPGU_EQ_OB:
check_dsp(ctx);
gen_helper_cmpgu_eq_ob(cpu_gpr[ret], v1_t, v2_t);
break;
case OPC_CMPGU_LT_OB:
check_dsp(ctx);
gen_helper_cmpgu_lt_ob(cpu_gpr[ret], v1_t, v2_t);
break;
case OPC_CMPGU_LE_OB:
check_dsp(ctx);
gen_helper_cmpgu_le_ob(cpu_gpr[ret], v1_t, v2_t);
break;
case OPC_CMPU_EQ_OB:
check_dsp(ctx);
gen_helper_cmpu_eq_ob(v1_t, v2_t, cpu_env);
break;
case OPC_CMPU_LT_OB:
check_dsp(ctx);
gen_helper_cmpu_lt_ob(v1_t, v2_t, cpu_env);
break;
case OPC_CMPU_LE_OB:
check_dsp(ctx);
gen_helper_cmpu_le_ob(v1_t, v2_t, cpu_env);
break;
case OPC_PACKRL_PW:
check_dsp(ctx);
gen_helper_packrl_pw(cpu_gpr[ret], v1_t, v2_t);
break;
case OPC_PICK_OB:
check_dsp(ctx);
gen_helper_pick_ob(cpu_gpr[ret], v1_t, v2_t, cpu_env);
break;
case OPC_PICK_PW:
check_dsp(ctx);
gen_helper_pick_pw(cpu_gpr[ret], v1_t, v2_t, cpu_env);
break;
case OPC_PICK_QH:
check_dsp(ctx);
gen_helper_pick_qh(cpu_gpr[ret], v1_t, v2_t, cpu_env);
break;
}
break;
case OPC_DAPPEND_DSP:
switch (op2) {
case OPC_DAPPEND:
tcg_gen_movi_i32(t0, v2);
gen_helper_dappend(cpu_gpr[ret], v1_t, cpu_gpr[ret], t0);
break;
case OPC_PREPENDD:
tcg_gen_movi_i32(t0, v2);
gen_helper_prependd(cpu_gpr[ret], v1_t, cpu_gpr[ret], t0);
break;
case OPC_PREPENDW:
tcg_gen_movi_i32(t0, v2);
gen_helper_prependw(cpu_gpr[ret], v1_t, cpu_gpr[ret], t0);
break;
case OPC_DBALIGN:
tcg_gen_movi_i32(t0, v2);
gen_helper_dbalign(cpu_gpr[ret], v1_t, cpu_gpr[ret], t0);
break;
default:
MIPS_INVAL("MASK DAPPEND");
generate_exception(ctx, EXCP_RI);
break;
}
break;
#endif
}
tcg_temp_free_i32(t0);
tcg_temp_free(t1);
tcg_temp_free(v1_t);
tcg_temp_free(v2_t);
(void)opn;
MIPS_DEBUG("%s", opn);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DisasContext *VAR_0,
uint32_t VAR_1, uint32_t VAR_2,
int VAR_3, int VAR_4, int VAR_5, int VAR_6)
{
const char *VAR_7 = "mipsdsp add compare pick";
TCGv_i32 t0;
TCGv t1;
TCGv v1_t;
TCGv v2_t;
if ((VAR_3 == 0) && (VAR_6 == 1)) {
MIPS_DEBUG("NOP");
return;
}
t0 = tcg_temp_new_i32();
t1 = tcg_temp_new();
v1_t = tcg_temp_new();
v2_t = tcg_temp_new();
gen_load_gpr(v1_t, VAR_4);
gen_load_gpr(v2_t, VAR_5);
switch (VAR_1) {
case OPC_APPEND_DSP:
switch (VAR_2) {
case OPC_APPEND:
tcg_gen_movi_i32(t0, VAR_5);
gen_helper_append(cpu_gpr[VAR_3], cpu_gpr[VAR_3], v1_t, t0);
break;
case OPC_PREPEND:
tcg_gen_movi_i32(t0, VAR_5);
gen_helper_prepend(cpu_gpr[VAR_3], v1_t, cpu_gpr[VAR_3], t0);
break;
case OPC_BALIGN:
tcg_gen_movi_i32(t0, VAR_5);
gen_helper_balign(cpu_gpr[VAR_3], v1_t, cpu_gpr[VAR_3], t0);
break;
default:
MIPS_INVAL("MASK APPEND");
generate_exception(VAR_0, EXCP_RI);
break;
}
break;
case OPC_CMPU_EQ_QB_DSP:
switch (VAR_2) {
case OPC_CMPU_EQ_QB:
check_dsp(VAR_0);
gen_helper_cmpu_eq_qb(v1_t, v2_t, cpu_env);
break;
case OPC_CMPU_LT_QB:
check_dsp(VAR_0);
gen_helper_cmpu_lt_qb(v1_t, v2_t, cpu_env);
break;
case OPC_CMPU_LE_QB:
check_dsp(VAR_0);
gen_helper_cmpu_le_qb(v1_t, v2_t, cpu_env);
break;
case OPC_CMPGU_EQ_QB:
check_dsp(VAR_0);
gen_helper_cmpgu_eq_qb(cpu_gpr[VAR_3], v1_t, v2_t);
break;
case OPC_CMPGU_LT_QB:
check_dsp(VAR_0);
gen_helper_cmpgu_lt_qb(cpu_gpr[VAR_3], v1_t, v2_t);
break;
case OPC_CMPGU_LE_QB:
check_dsp(VAR_0);
gen_helper_cmpgu_le_qb(cpu_gpr[VAR_3], v1_t, v2_t);
break;
case OPC_CMPGDU_EQ_QB:
check_dspr2(VAR_0);
gen_helper_cmpgu_eq_qb(t1, v1_t, v2_t);
tcg_gen_mov_tl(cpu_gpr[VAR_3], t1);
tcg_gen_andi_tl(cpu_dspctrl, cpu_dspctrl, 0xF0FFFFFF);
tcg_gen_shli_tl(t1, t1, 24);
tcg_gen_or_tl(cpu_dspctrl, cpu_dspctrl, t1);
break;
case OPC_CMPGDU_LT_QB:
check_dspr2(VAR_0);
gen_helper_cmpgu_lt_qb(t1, v1_t, v2_t);
tcg_gen_mov_tl(cpu_gpr[VAR_3], t1);
tcg_gen_andi_tl(cpu_dspctrl, cpu_dspctrl, 0xF0FFFFFF);
tcg_gen_shli_tl(t1, t1, 24);
tcg_gen_or_tl(cpu_dspctrl, cpu_dspctrl, t1);
break;
case OPC_CMPGDU_LE_QB:
check_dspr2(VAR_0);
gen_helper_cmpgu_le_qb(t1, v1_t, v2_t);
tcg_gen_mov_tl(cpu_gpr[VAR_3], t1);
tcg_gen_andi_tl(cpu_dspctrl, cpu_dspctrl, 0xF0FFFFFF);
tcg_gen_shli_tl(t1, t1, 24);
tcg_gen_or_tl(cpu_dspctrl, cpu_dspctrl, t1);
break;
case OPC_CMP_EQ_PH:
check_dsp(VAR_0);
gen_helper_cmp_eq_ph(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LT_PH:
check_dsp(VAR_0);
gen_helper_cmp_lt_ph(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LE_PH:
check_dsp(VAR_0);
gen_helper_cmp_le_ph(v1_t, v2_t, cpu_env);
break;
case OPC_PICK_QB:
check_dsp(VAR_0);
gen_helper_pick_qb(cpu_gpr[VAR_3], v1_t, v2_t, cpu_env);
break;
case OPC_PICK_PH:
check_dsp(VAR_0);
gen_helper_pick_ph(cpu_gpr[VAR_3], v1_t, v2_t, cpu_env);
break;
case OPC_PACKRL_PH:
check_dsp(VAR_0);
gen_helper_packrl_ph(cpu_gpr[VAR_3], v1_t, v2_t);
break;
}
break;
#ifdef TARGET_MIPS64
case OPC_CMPU_EQ_OB_DSP:
switch (VAR_2) {
case OPC_CMP_EQ_PW:
check_dsp(VAR_0);
gen_helper_cmp_eq_pw(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LT_PW:
check_dsp(VAR_0);
gen_helper_cmp_lt_pw(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LE_PW:
check_dsp(VAR_0);
gen_helper_cmp_le_pw(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_EQ_QH:
check_dsp(VAR_0);
gen_helper_cmp_eq_qh(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LT_QH:
check_dsp(VAR_0);
gen_helper_cmp_lt_qh(v1_t, v2_t, cpu_env);
break;
case OPC_CMP_LE_QH:
check_dsp(VAR_0);
gen_helper_cmp_le_qh(v1_t, v2_t, cpu_env);
break;
case OPC_CMPGDU_EQ_OB:
check_dspr2(VAR_0);
gen_helper_cmpgdu_eq_ob(cpu_gpr[VAR_3], v1_t, v2_t, cpu_env);
break;
case OPC_CMPGDU_LT_OB:
check_dspr2(VAR_0);
gen_helper_cmpgdu_lt_ob(cpu_gpr[VAR_3], v1_t, v2_t, cpu_env);
break;
case OPC_CMPGDU_LE_OB:
check_dspr2(VAR_0);
gen_helper_cmpgdu_le_ob(cpu_gpr[VAR_3], v1_t, v2_t, cpu_env);
break;
case OPC_CMPGU_EQ_OB:
check_dsp(VAR_0);
gen_helper_cmpgu_eq_ob(cpu_gpr[VAR_3], v1_t, v2_t);
break;
case OPC_CMPGU_LT_OB:
check_dsp(VAR_0);
gen_helper_cmpgu_lt_ob(cpu_gpr[VAR_3], v1_t, v2_t);
break;
case OPC_CMPGU_LE_OB:
check_dsp(VAR_0);
gen_helper_cmpgu_le_ob(cpu_gpr[VAR_3], v1_t, v2_t);
break;
case OPC_CMPU_EQ_OB:
check_dsp(VAR_0);
gen_helper_cmpu_eq_ob(v1_t, v2_t, cpu_env);
break;
case OPC_CMPU_LT_OB:
check_dsp(VAR_0);
gen_helper_cmpu_lt_ob(v1_t, v2_t, cpu_env);
break;
case OPC_CMPU_LE_OB:
check_dsp(VAR_0);
gen_helper_cmpu_le_ob(v1_t, v2_t, cpu_env);
break;
case OPC_PACKRL_PW:
check_dsp(VAR_0);
gen_helper_packrl_pw(cpu_gpr[VAR_3], v1_t, v2_t);
break;
case OPC_PICK_OB:
check_dsp(VAR_0);
gen_helper_pick_ob(cpu_gpr[VAR_3], v1_t, v2_t, cpu_env);
break;
case OPC_PICK_PW:
check_dsp(VAR_0);
gen_helper_pick_pw(cpu_gpr[VAR_3], v1_t, v2_t, cpu_env);
break;
case OPC_PICK_QH:
check_dsp(VAR_0);
gen_helper_pick_qh(cpu_gpr[VAR_3], v1_t, v2_t, cpu_env);
break;
}
break;
case OPC_DAPPEND_DSP:
switch (VAR_2) {
case OPC_DAPPEND:
tcg_gen_movi_i32(t0, VAR_5);
gen_helper_dappend(cpu_gpr[VAR_3], v1_t, cpu_gpr[VAR_3], t0);
break;
case OPC_PREPENDD:
tcg_gen_movi_i32(t0, VAR_5);
gen_helper_prependd(cpu_gpr[VAR_3], v1_t, cpu_gpr[VAR_3], t0);
break;
case OPC_PREPENDW:
tcg_gen_movi_i32(t0, VAR_5);
gen_helper_prependw(cpu_gpr[VAR_3], v1_t, cpu_gpr[VAR_3], t0);
break;
case OPC_DBALIGN:
tcg_gen_movi_i32(t0, VAR_5);
gen_helper_dbalign(cpu_gpr[VAR_3], v1_t, cpu_gpr[VAR_3], t0);
break;
default:
MIPS_INVAL("MASK DAPPEND");
generate_exception(VAR_0, EXCP_RI);
break;
}
break;
#endif
}
tcg_temp_free_i32(t0);
tcg_temp_free(t1);
tcg_temp_free(v1_t);
tcg_temp_free(v2_t);
(void)VAR_7;
MIPS_DEBUG("%s", VAR_7);
}
| [
"static void FUNC_0(DisasContext *VAR_0,\nuint32_t VAR_1, uint32_t VAR_2,\nint VAR_3, int VAR_4, int VAR_5, int VAR_6)\n{",
"const char *VAR_7 = \"mipsdsp add compare pick\";",
"TCGv_i32 t0;",
"TCGv t1;",
"TCGv v1_t;",
"TCGv v2_t;",
"if ((VAR_3 == 0) && (VAR_6 == 1)) {",
"MIPS_DEBUG(\"NOP\");",
"return;",
"}",
"t0 = tcg_temp_new_i32();",
"t1 = tcg_temp_new();",
"v1_t = tcg_temp_new();",
"v2_t = tcg_temp_new();",
"gen_load_gpr(v1_t, VAR_4);",
"gen_load_gpr(v2_t, VAR_5);",
"switch (VAR_1) {",
"case OPC_APPEND_DSP:\nswitch (VAR_2) {",
"case OPC_APPEND:\ntcg_gen_movi_i32(t0, VAR_5);",
"gen_helper_append(cpu_gpr[VAR_3], cpu_gpr[VAR_3], v1_t, t0);",
"break;",
"case OPC_PREPEND:\ntcg_gen_movi_i32(t0, VAR_5);",
"gen_helper_prepend(cpu_gpr[VAR_3], v1_t, cpu_gpr[VAR_3], t0);",
"break;",
"case OPC_BALIGN:\ntcg_gen_movi_i32(t0, VAR_5);",
"gen_helper_balign(cpu_gpr[VAR_3], v1_t, cpu_gpr[VAR_3], t0);",
"break;",
"default:\nMIPS_INVAL(\"MASK APPEND\");",
"generate_exception(VAR_0, EXCP_RI);",
"break;",
"}",
"break;",
"case OPC_CMPU_EQ_QB_DSP:\nswitch (VAR_2) {",
"case OPC_CMPU_EQ_QB:\ncheck_dsp(VAR_0);",
"gen_helper_cmpu_eq_qb(v1_t, v2_t, cpu_env);",
"break;",
"case OPC_CMPU_LT_QB:\ncheck_dsp(VAR_0);",
"gen_helper_cmpu_lt_qb(v1_t, v2_t, cpu_env);",
"break;",
"case OPC_CMPU_LE_QB:\ncheck_dsp(VAR_0);",
"gen_helper_cmpu_le_qb(v1_t, v2_t, cpu_env);",
"break;",
"case OPC_CMPGU_EQ_QB:\ncheck_dsp(VAR_0);",
"gen_helper_cmpgu_eq_qb(cpu_gpr[VAR_3], v1_t, v2_t);",
"break;",
"case OPC_CMPGU_LT_QB:\ncheck_dsp(VAR_0);",
"gen_helper_cmpgu_lt_qb(cpu_gpr[VAR_3], v1_t, v2_t);",
"break;",
"case OPC_CMPGU_LE_QB:\ncheck_dsp(VAR_0);",
"gen_helper_cmpgu_le_qb(cpu_gpr[VAR_3], v1_t, v2_t);",
"break;",
"case OPC_CMPGDU_EQ_QB:\ncheck_dspr2(VAR_0);",
"gen_helper_cmpgu_eq_qb(t1, v1_t, v2_t);",
"tcg_gen_mov_tl(cpu_gpr[VAR_3], t1);",
"tcg_gen_andi_tl(cpu_dspctrl, cpu_dspctrl, 0xF0FFFFFF);",
"tcg_gen_shli_tl(t1, t1, 24);",
"tcg_gen_or_tl(cpu_dspctrl, cpu_dspctrl, t1);",
"break;",
"case OPC_CMPGDU_LT_QB:\ncheck_dspr2(VAR_0);",
"gen_helper_cmpgu_lt_qb(t1, v1_t, v2_t);",
"tcg_gen_mov_tl(cpu_gpr[VAR_3], t1);",
"tcg_gen_andi_tl(cpu_dspctrl, cpu_dspctrl, 0xF0FFFFFF);",
"tcg_gen_shli_tl(t1, t1, 24);",
"tcg_gen_or_tl(cpu_dspctrl, cpu_dspctrl, t1);",
"break;",
"case OPC_CMPGDU_LE_QB:\ncheck_dspr2(VAR_0);",
"gen_helper_cmpgu_le_qb(t1, v1_t, v2_t);",
"tcg_gen_mov_tl(cpu_gpr[VAR_3], t1);",
"tcg_gen_andi_tl(cpu_dspctrl, cpu_dspctrl, 0xF0FFFFFF);",
"tcg_gen_shli_tl(t1, t1, 24);",
"tcg_gen_or_tl(cpu_dspctrl, cpu_dspctrl, t1);",
"break;",
"case OPC_CMP_EQ_PH:\ncheck_dsp(VAR_0);",
"gen_helper_cmp_eq_ph(v1_t, v2_t, cpu_env);",
"break;",
"case OPC_CMP_LT_PH:\ncheck_dsp(VAR_0);",
"gen_helper_cmp_lt_ph(v1_t, v2_t, cpu_env);",
"break;",
"case OPC_CMP_LE_PH:\ncheck_dsp(VAR_0);",
"gen_helper_cmp_le_ph(v1_t, v2_t, cpu_env);",
"break;",
"case OPC_PICK_QB:\ncheck_dsp(VAR_0);",
"gen_helper_pick_qb(cpu_gpr[VAR_3], v1_t, v2_t, cpu_env);",
"break;",
"case OPC_PICK_PH:\ncheck_dsp(VAR_0);",
"gen_helper_pick_ph(cpu_gpr[VAR_3], v1_t, v2_t, cpu_env);",
"break;",
"case OPC_PACKRL_PH:\ncheck_dsp(VAR_0);",
"gen_helper_packrl_ph(cpu_gpr[VAR_3], v1_t, v2_t);",
"break;",
"}",
"break;",
"#ifdef TARGET_MIPS64\ncase OPC_CMPU_EQ_OB_DSP:\nswitch (VAR_2) {",
"case OPC_CMP_EQ_PW:\ncheck_dsp(VAR_0);",
"gen_helper_cmp_eq_pw(v1_t, v2_t, cpu_env);",
"break;",
"case OPC_CMP_LT_PW:\ncheck_dsp(VAR_0);",
"gen_helper_cmp_lt_pw(v1_t, v2_t, cpu_env);",
"break;",
"case OPC_CMP_LE_PW:\ncheck_dsp(VAR_0);",
"gen_helper_cmp_le_pw(v1_t, v2_t, cpu_env);",
"break;",
"case OPC_CMP_EQ_QH:\ncheck_dsp(VAR_0);",
"gen_helper_cmp_eq_qh(v1_t, v2_t, cpu_env);",
"break;",
"case OPC_CMP_LT_QH:\ncheck_dsp(VAR_0);",
"gen_helper_cmp_lt_qh(v1_t, v2_t, cpu_env);",
"break;",
"case OPC_CMP_LE_QH:\ncheck_dsp(VAR_0);",
"gen_helper_cmp_le_qh(v1_t, v2_t, cpu_env);",
"break;",
"case OPC_CMPGDU_EQ_OB:\ncheck_dspr2(VAR_0);",
"gen_helper_cmpgdu_eq_ob(cpu_gpr[VAR_3], v1_t, v2_t, cpu_env);",
"break;",
"case OPC_CMPGDU_LT_OB:\ncheck_dspr2(VAR_0);",
"gen_helper_cmpgdu_lt_ob(cpu_gpr[VAR_3], v1_t, v2_t, cpu_env);",
"break;",
"case OPC_CMPGDU_LE_OB:\ncheck_dspr2(VAR_0);",
"gen_helper_cmpgdu_le_ob(cpu_gpr[VAR_3], v1_t, v2_t, cpu_env);",
"break;",
"case OPC_CMPGU_EQ_OB:\ncheck_dsp(VAR_0);",
"gen_helper_cmpgu_eq_ob(cpu_gpr[VAR_3], v1_t, v2_t);",
"break;",
"case OPC_CMPGU_LT_OB:\ncheck_dsp(VAR_0);",
"gen_helper_cmpgu_lt_ob(cpu_gpr[VAR_3], v1_t, v2_t);",
"break;",
"case OPC_CMPGU_LE_OB:\ncheck_dsp(VAR_0);",
"gen_helper_cmpgu_le_ob(cpu_gpr[VAR_3], v1_t, v2_t);",
"break;",
"case OPC_CMPU_EQ_OB:\ncheck_dsp(VAR_0);",
"gen_helper_cmpu_eq_ob(v1_t, v2_t, cpu_env);",
"break;",
"case OPC_CMPU_LT_OB:\ncheck_dsp(VAR_0);",
"gen_helper_cmpu_lt_ob(v1_t, v2_t, cpu_env);",
"break;",
"case OPC_CMPU_LE_OB:\ncheck_dsp(VAR_0);",
"gen_helper_cmpu_le_ob(v1_t, v2_t, cpu_env);",
"break;",
"case OPC_PACKRL_PW:\ncheck_dsp(VAR_0);",
"gen_helper_packrl_pw(cpu_gpr[VAR_3], v1_t, v2_t);",
"break;",
"case OPC_PICK_OB:\ncheck_dsp(VAR_0);",
"gen_helper_pick_ob(cpu_gpr[VAR_3], v1_t, v2_t, cpu_env);",
"break;",
"case OPC_PICK_PW:\ncheck_dsp(VAR_0);",
"gen_helper_pick_pw(cpu_gpr[VAR_3], v1_t, v2_t, cpu_env);",
"break;",
"case OPC_PICK_QH:\ncheck_dsp(VAR_0);",
"gen_helper_pick_qh(cpu_gpr[VAR_3], v1_t, v2_t, cpu_env);",
"break;",
"}",
"break;",
"case OPC_DAPPEND_DSP:\nswitch (VAR_2) {",
"case OPC_DAPPEND:\ntcg_gen_movi_i32(t0, VAR_5);",
"gen_helper_dappend(cpu_gpr[VAR_3], v1_t, cpu_gpr[VAR_3], t0);",
"break;",
"case OPC_PREPENDD:\ntcg_gen_movi_i32(t0, VAR_5);",
"gen_helper_prependd(cpu_gpr[VAR_3], v1_t, cpu_gpr[VAR_3], t0);",
"break;",
"case OPC_PREPENDW:\ntcg_gen_movi_i32(t0, VAR_5);",
"gen_helper_prependw(cpu_gpr[VAR_3], v1_t, cpu_gpr[VAR_3], t0);",
"break;",
"case OPC_DBALIGN:\ntcg_gen_movi_i32(t0, VAR_5);",
"gen_helper_dbalign(cpu_gpr[VAR_3], v1_t, cpu_gpr[VAR_3], t0);",
"break;",
"default:\nMIPS_INVAL(\"MASK DAPPEND\");",
"generate_exception(VAR_0, EXCP_RI);",
"break;",
"}",
"break;",
"#endif\n}",
"tcg_temp_free_i32(t0);",
"tcg_temp_free(t1);",
"tcg_temp_free(v1_t);",
"tcg_temp_free(v2_t);",
"(void)VAR_7;",
"MIPS_DEBUG(\"%s\", 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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
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
],
[
153
],
[
155
],
[
157
],
[
159,
161
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175,
177
],
[
179
],
[
181
],
[
183
],
[
185
],
[
187
],
[
189
],
[
191,
193
],
[
195
],
[
197
],
[
199,
201
],
[
203
],
[
205
],
[
207,
209
],
[
211
],
[
213
],
[
215,
217
],
[
219
],
[
221
],
[
223,
225
],
[
227
],
[
229
],
[
231,
233
],
[
235
],
[
237
],
[
239
],
[
241
],
[
243,
245,
247
],
[
249,
251
],
[
253
],
[
255
],
[
257,
259
],
[
261
],
[
263
],
[
265,
267
],
[
269
],
[
271
],
[
273,
275
],
[
277
],
[
279
],
[
281,
283
],
[
285
],
[
287
],
[
289,
291
],
[
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
],
[
391
],
[
393,
395
],
[
397
],
[
399
],
[
401
],
[
403
],
[
405,
407
],
[
409,
411
],
[
413
],
[
415
],
[
417,
419
],
[
421
],
[
423
],
[
425,
427
],
[
429
],
[
431
],
[
433,
435
],
[
437
],
[
439
],
[
441,
443
],
[
445
],
[
447
],
[
449
],
[
451
],
[
453,
455
],
[
459
],
[
461
],
[
463
],
[
465
],
[
469
],
[
471
],
[
473
]
]
|
16,959 | static inline int IRQ_testbit(IRQQueue *q, int n_IRQ)
{
return test_bit(q->queue, n_IRQ);
}
| false | qemu | e69a17f65e9f12f33c48b04a789e49d40a8993f5 | static inline int IRQ_testbit(IRQQueue *q, int n_IRQ)
{
return test_bit(q->queue, n_IRQ);
}
| {
"code": [],
"line_no": []
} | static inline int FUNC_0(IRQQueue *VAR_0, int VAR_1)
{
return test_bit(VAR_0->queue, VAR_1);
}
| [
"static inline int FUNC_0(IRQQueue *VAR_0, int VAR_1)\n{",
"return test_bit(VAR_0->queue, VAR_1);",
"}"
]
| [
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
]
]
|
16,960 | static int pic_arrays_init(HEVCContext *s)
{
int log2_min_cb_size = s->sps->log2_min_cb_size;
int width = s->sps->width;
int height = s->sps->height;
int pic_size = width * height;
int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
((height >> log2_min_cb_size) + 1);
int ctb_count = s->sps->ctb_width * s->sps->ctb_height;
int min_pu_width = width >> s->sps->log2_min_pu_size;
int pic_height_in_min_pu = height >> s->sps->log2_min_pu_size;
int pic_size_in_min_pu = min_pu_width * pic_height_in_min_pu;
int pic_width_in_min_tu = width >> s->sps->log2_min_tb_size;
int pic_height_in_min_tu = height >> s->sps->log2_min_tb_size;
s->bs_width = width >> 3;
s->bs_height = height >> 3;
s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
s->split_cu_flag = av_malloc(pic_size);
if (!s->sao || !s->deblock || !s->split_cu_flag)
goto fail;
s->skip_flag = av_malloc(pic_size_in_ctb);
s->tab_ct_depth = av_malloc(s->sps->min_cb_height * s->sps->min_cb_width);
if (!s->skip_flag || !s->tab_ct_depth)
goto fail;
s->tab_ipm = av_malloc(pic_size_in_min_pu);
s->cbf_luma = av_malloc(pic_width_in_min_tu * pic_height_in_min_tu);
s->is_pcm = av_malloc(pic_size_in_min_pu);
if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
goto fail;
s->filter_slice_edges = av_malloc(ctb_count);
s->tab_slice_address = av_malloc(pic_size_in_ctb * sizeof(*s->tab_slice_address));
s->qp_y_tab = av_malloc(pic_size_in_ctb * sizeof(*s->qp_y_tab));
if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
goto fail;
s->horizontal_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
s->vertical_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
if (!s->horizontal_bs || !s->vertical_bs)
goto fail;
s->tab_mvf_pool = av_buffer_pool_init(pic_size_in_min_pu * sizeof(MvField),
av_buffer_alloc);
s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
av_buffer_allocz);
if (!s->tab_mvf_pool || !s->rpl_tab_pool)
goto fail;
return 0;
fail:
pic_arrays_free(s);
return AVERROR(ENOMEM);
}
| false | FFmpeg | 4db81f081743aeed366e8af7a748667818a27e0f | static int pic_arrays_init(HEVCContext *s)
{
int log2_min_cb_size = s->sps->log2_min_cb_size;
int width = s->sps->width;
int height = s->sps->height;
int pic_size = width * height;
int pic_size_in_ctb = ((width >> log2_min_cb_size) + 1) *
((height >> log2_min_cb_size) + 1);
int ctb_count = s->sps->ctb_width * s->sps->ctb_height;
int min_pu_width = width >> s->sps->log2_min_pu_size;
int pic_height_in_min_pu = height >> s->sps->log2_min_pu_size;
int pic_size_in_min_pu = min_pu_width * pic_height_in_min_pu;
int pic_width_in_min_tu = width >> s->sps->log2_min_tb_size;
int pic_height_in_min_tu = height >> s->sps->log2_min_tb_size;
s->bs_width = width >> 3;
s->bs_height = height >> 3;
s->sao = av_mallocz_array(ctb_count, sizeof(*s->sao));
s->deblock = av_mallocz_array(ctb_count, sizeof(*s->deblock));
s->split_cu_flag = av_malloc(pic_size);
if (!s->sao || !s->deblock || !s->split_cu_flag)
goto fail;
s->skip_flag = av_malloc(pic_size_in_ctb);
s->tab_ct_depth = av_malloc(s->sps->min_cb_height * s->sps->min_cb_width);
if (!s->skip_flag || !s->tab_ct_depth)
goto fail;
s->tab_ipm = av_malloc(pic_size_in_min_pu);
s->cbf_luma = av_malloc(pic_width_in_min_tu * pic_height_in_min_tu);
s->is_pcm = av_malloc(pic_size_in_min_pu);
if (!s->tab_ipm || !s->cbf_luma || !s->is_pcm)
goto fail;
s->filter_slice_edges = av_malloc(ctb_count);
s->tab_slice_address = av_malloc(pic_size_in_ctb * sizeof(*s->tab_slice_address));
s->qp_y_tab = av_malloc(pic_size_in_ctb * sizeof(*s->qp_y_tab));
if (!s->qp_y_tab || !s->filter_slice_edges || !s->tab_slice_address)
goto fail;
s->horizontal_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
s->vertical_bs = av_mallocz(2 * s->bs_width * (s->bs_height + 1));
if (!s->horizontal_bs || !s->vertical_bs)
goto fail;
s->tab_mvf_pool = av_buffer_pool_init(pic_size_in_min_pu * sizeof(MvField),
av_buffer_alloc);
s->rpl_tab_pool = av_buffer_pool_init(ctb_count * sizeof(RefPicListTab),
av_buffer_allocz);
if (!s->tab_mvf_pool || !s->rpl_tab_pool)
goto fail;
return 0;
fail:
pic_arrays_free(s);
return AVERROR(ENOMEM);
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(HEVCContext *VAR_0)
{
int VAR_1 = VAR_0->sps->VAR_1;
int VAR_2 = VAR_0->sps->VAR_2;
int VAR_3 = VAR_0->sps->VAR_3;
int VAR_4 = VAR_2 * VAR_3;
int VAR_5 = ((VAR_2 >> VAR_1) + 1) *
((VAR_3 >> VAR_1) + 1);
int VAR_6 = VAR_0->sps->ctb_width * VAR_0->sps->ctb_height;
int VAR_7 = VAR_2 >> VAR_0->sps->log2_min_pu_size;
int VAR_8 = VAR_3 >> VAR_0->sps->log2_min_pu_size;
int VAR_9 = VAR_7 * VAR_8;
int VAR_10 = VAR_2 >> VAR_0->sps->log2_min_tb_size;
int VAR_11 = VAR_3 >> VAR_0->sps->log2_min_tb_size;
VAR_0->bs_width = VAR_2 >> 3;
VAR_0->bs_height = VAR_3 >> 3;
VAR_0->sao = av_mallocz_array(VAR_6, sizeof(*VAR_0->sao));
VAR_0->deblock = av_mallocz_array(VAR_6, sizeof(*VAR_0->deblock));
VAR_0->split_cu_flag = av_malloc(VAR_4);
if (!VAR_0->sao || !VAR_0->deblock || !VAR_0->split_cu_flag)
goto fail;
VAR_0->skip_flag = av_malloc(VAR_5);
VAR_0->tab_ct_depth = av_malloc(VAR_0->sps->min_cb_height * VAR_0->sps->min_cb_width);
if (!VAR_0->skip_flag || !VAR_0->tab_ct_depth)
goto fail;
VAR_0->tab_ipm = av_malloc(VAR_9);
VAR_0->cbf_luma = av_malloc(VAR_10 * VAR_11);
VAR_0->is_pcm = av_malloc(VAR_9);
if (!VAR_0->tab_ipm || !VAR_0->cbf_luma || !VAR_0->is_pcm)
goto fail;
VAR_0->filter_slice_edges = av_malloc(VAR_6);
VAR_0->tab_slice_address = av_malloc(VAR_5 * sizeof(*VAR_0->tab_slice_address));
VAR_0->qp_y_tab = av_malloc(VAR_5 * sizeof(*VAR_0->qp_y_tab));
if (!VAR_0->qp_y_tab || !VAR_0->filter_slice_edges || !VAR_0->tab_slice_address)
goto fail;
VAR_0->horizontal_bs = av_mallocz(2 * VAR_0->bs_width * (VAR_0->bs_height + 1));
VAR_0->vertical_bs = av_mallocz(2 * VAR_0->bs_width * (VAR_0->bs_height + 1));
if (!VAR_0->horizontal_bs || !VAR_0->vertical_bs)
goto fail;
VAR_0->tab_mvf_pool = av_buffer_pool_init(VAR_9 * sizeof(MvField),
av_buffer_alloc);
VAR_0->rpl_tab_pool = av_buffer_pool_init(VAR_6 * sizeof(RefPicListTab),
av_buffer_allocz);
if (!VAR_0->tab_mvf_pool || !VAR_0->rpl_tab_pool)
goto fail;
return 0;
fail:
pic_arrays_free(VAR_0);
return AVERROR(ENOMEM);
}
| [
"static int FUNC_0(HEVCContext *VAR_0)\n{",
"int VAR_1 = VAR_0->sps->VAR_1;",
"int VAR_2 = VAR_0->sps->VAR_2;",
"int VAR_3 = VAR_0->sps->VAR_3;",
"int VAR_4 = VAR_2 * VAR_3;",
"int VAR_5 = ((VAR_2 >> VAR_1) + 1) *\n((VAR_3 >> VAR_1) + 1);",
"int VAR_6 = VAR_0->sps->ctb_width * VAR_0->sps->ctb_height;",
"int VAR_7 = VAR_2 >> VAR_0->sps->log2_min_pu_size;",
"int VAR_8 = VAR_3 >> VAR_0->sps->log2_min_pu_size;",
"int VAR_9 = VAR_7 * VAR_8;",
"int VAR_10 = VAR_2 >> VAR_0->sps->log2_min_tb_size;",
"int VAR_11 = VAR_3 >> VAR_0->sps->log2_min_tb_size;",
"VAR_0->bs_width = VAR_2 >> 3;",
"VAR_0->bs_height = VAR_3 >> 3;",
"VAR_0->sao = av_mallocz_array(VAR_6, sizeof(*VAR_0->sao));",
"VAR_0->deblock = av_mallocz_array(VAR_6, sizeof(*VAR_0->deblock));",
"VAR_0->split_cu_flag = av_malloc(VAR_4);",
"if (!VAR_0->sao || !VAR_0->deblock || !VAR_0->split_cu_flag)\ngoto fail;",
"VAR_0->skip_flag = av_malloc(VAR_5);",
"VAR_0->tab_ct_depth = av_malloc(VAR_0->sps->min_cb_height * VAR_0->sps->min_cb_width);",
"if (!VAR_0->skip_flag || !VAR_0->tab_ct_depth)\ngoto fail;",
"VAR_0->tab_ipm = av_malloc(VAR_9);",
"VAR_0->cbf_luma = av_malloc(VAR_10 * VAR_11);",
"VAR_0->is_pcm = av_malloc(VAR_9);",
"if (!VAR_0->tab_ipm || !VAR_0->cbf_luma || !VAR_0->is_pcm)\ngoto fail;",
"VAR_0->filter_slice_edges = av_malloc(VAR_6);",
"VAR_0->tab_slice_address = av_malloc(VAR_5 * sizeof(*VAR_0->tab_slice_address));",
"VAR_0->qp_y_tab = av_malloc(VAR_5 * sizeof(*VAR_0->qp_y_tab));",
"if (!VAR_0->qp_y_tab || !VAR_0->filter_slice_edges || !VAR_0->tab_slice_address)\ngoto fail;",
"VAR_0->horizontal_bs = av_mallocz(2 * VAR_0->bs_width * (VAR_0->bs_height + 1));",
"VAR_0->vertical_bs = av_mallocz(2 * VAR_0->bs_width * (VAR_0->bs_height + 1));",
"if (!VAR_0->horizontal_bs || !VAR_0->vertical_bs)\ngoto fail;",
"VAR_0->tab_mvf_pool = av_buffer_pool_init(VAR_9 * sizeof(MvField),\nav_buffer_alloc);",
"VAR_0->rpl_tab_pool = av_buffer_pool_init(VAR_6 * sizeof(RefPicListTab),\nav_buffer_allocz);",
"if (!VAR_0->tab_mvf_pool || !VAR_0->rpl_tab_pool)\ngoto fail;",
"return 0;",
"fail:\npic_arrays_free(VAR_0);",
"return AVERROR(ENOMEM);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
37
],
[
39
],
[
41
],
[
43,
45
],
[
49
],
[
51
],
[
53,
55
],
[
59
],
[
61
],
[
63
],
[
65,
67
],
[
71
],
[
73
],
[
75
],
[
77,
79
],
[
83
],
[
85
],
[
87,
89
],
[
93,
95
],
[
97,
99
],
[
101,
103
],
[
107
],
[
109,
111
],
[
113
],
[
115
]
]
|
16,961 | static void ioreq_finish(struct ioreq *ioreq)
{
struct XenBlkDev *blkdev = ioreq->blkdev;
LIST_REMOVE(ioreq, list);
LIST_INSERT_HEAD(&blkdev->finished, ioreq, list);
blkdev->requests_inflight--;
blkdev->requests_finished++;
}
| false | qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | static void ioreq_finish(struct ioreq *ioreq)
{
struct XenBlkDev *blkdev = ioreq->blkdev;
LIST_REMOVE(ioreq, list);
LIST_INSERT_HEAD(&blkdev->finished, ioreq, list);
blkdev->requests_inflight--;
blkdev->requests_finished++;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(struct VAR_0 *VAR_0)
{
struct XenBlkDev *VAR_1 = VAR_0->VAR_1;
LIST_REMOVE(VAR_0, list);
LIST_INSERT_HEAD(&VAR_1->finished, VAR_0, list);
VAR_1->requests_inflight--;
VAR_1->requests_finished++;
}
| [
"static void FUNC_0(struct VAR_0 *VAR_0)\n{",
"struct XenBlkDev *VAR_1 = VAR_0->VAR_1;",
"LIST_REMOVE(VAR_0, list);",
"LIST_INSERT_HEAD(&VAR_1->finished, VAR_0, list);",
"VAR_1->requests_inflight--;",
"VAR_1->requests_finished++;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
]
]
|
16,962 | static void test_qemu_strtosz_invalid(void)
{
const char *str;
char *endptr = NULL;
int64_t res;
str = "";
res = qemu_strtosz(str, &endptr);
g_assert_cmpint(res, ==, -EINVAL);
g_assert(endptr == str);
str = " \t ";
res = qemu_strtosz(str, &endptr);
g_assert_cmpint(res, ==, -EINVAL);
g_assert(endptr == str);
str = "crap";
res = qemu_strtosz(str, &endptr);
g_assert_cmpint(res, ==, -EINVAL);
g_assert(endptr == str);
}
| false | qemu | f17fd4fdf0df3d2f3444399d04c38d22b9a3e1b7 | static void test_qemu_strtosz_invalid(void)
{
const char *str;
char *endptr = NULL;
int64_t res;
str = "";
res = qemu_strtosz(str, &endptr);
g_assert_cmpint(res, ==, -EINVAL);
g_assert(endptr == str);
str = " \t ";
res = qemu_strtosz(str, &endptr);
g_assert_cmpint(res, ==, -EINVAL);
g_assert(endptr == str);
str = "crap";
res = qemu_strtosz(str, &endptr);
g_assert_cmpint(res, ==, -EINVAL);
g_assert(endptr == str);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void)
{
const char *VAR_0;
char *VAR_1 = NULL;
int64_t res;
VAR_0 = "";
res = qemu_strtosz(VAR_0, &VAR_1);
g_assert_cmpint(res, ==, -EINVAL);
g_assert(VAR_1 == VAR_0);
VAR_0 = " \t ";
res = qemu_strtosz(VAR_0, &VAR_1);
g_assert_cmpint(res, ==, -EINVAL);
g_assert(VAR_1 == VAR_0);
VAR_0 = "crap";
res = qemu_strtosz(VAR_0, &VAR_1);
g_assert_cmpint(res, ==, -EINVAL);
g_assert(VAR_1 == VAR_0);
}
| [
"static void FUNC_0(void)\n{",
"const char *VAR_0;",
"char *VAR_1 = NULL;",
"int64_t res;",
"VAR_0 = \"\";",
"res = qemu_strtosz(VAR_0, &VAR_1);",
"g_assert_cmpint(res, ==, -EINVAL);",
"g_assert(VAR_1 == VAR_0);",
"VAR_0 = \" \\t \";",
"res = qemu_strtosz(VAR_0, &VAR_1);",
"g_assert_cmpint(res, ==, -EINVAL);",
"g_assert(VAR_1 == VAR_0);",
"VAR_0 = \"crap\";",
"res = qemu_strtosz(VAR_0, &VAR_1);",
"g_assert_cmpint(res, ==, -EINVAL);",
"g_assert(VAR_1 == VAR_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
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
]
]
|
16,963 | static void virtio_gpu_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
{
VirtIOGPU *g = VIRTIO_GPU(vdev);
struct virtio_gpu_ctrl_command *cmd;
if (!virtio_queue_ready(vq)) {
return;
}
#ifdef CONFIG_VIRGL
if (!g->renderer_inited && g->use_virgl_renderer) {
virtio_gpu_virgl_init(g);
g->renderer_inited = true;
}
#endif
cmd = g_new(struct virtio_gpu_ctrl_command, 1);
while (virtqueue_pop(vq, &cmd->elem)) {
cmd->vq = vq;
cmd->error = 0;
cmd->finished = false;
cmd->waiting = false;
QTAILQ_INSERT_TAIL(&g->cmdq, cmd, next);
cmd = g_new(struct virtio_gpu_ctrl_command, 1);
}
g_free(cmd);
virtio_gpu_process_cmdq(g);
#ifdef CONFIG_VIRGL
if (g->use_virgl_renderer) {
virtio_gpu_virgl_fence_poll(g);
}
#endif
}
| false | qemu | 51b19ebe4320f3dcd93cea71235c1219318ddfd2 | static void virtio_gpu_handle_ctrl(VirtIODevice *vdev, VirtQueue *vq)
{
VirtIOGPU *g = VIRTIO_GPU(vdev);
struct virtio_gpu_ctrl_command *cmd;
if (!virtio_queue_ready(vq)) {
return;
}
#ifdef CONFIG_VIRGL
if (!g->renderer_inited && g->use_virgl_renderer) {
virtio_gpu_virgl_init(g);
g->renderer_inited = true;
}
#endif
cmd = g_new(struct virtio_gpu_ctrl_command, 1);
while (virtqueue_pop(vq, &cmd->elem)) {
cmd->vq = vq;
cmd->error = 0;
cmd->finished = false;
cmd->waiting = false;
QTAILQ_INSERT_TAIL(&g->cmdq, cmd, next);
cmd = g_new(struct virtio_gpu_ctrl_command, 1);
}
g_free(cmd);
virtio_gpu_process_cmdq(g);
#ifdef CONFIG_VIRGL
if (g->use_virgl_renderer) {
virtio_gpu_virgl_fence_poll(g);
}
#endif
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(VirtIODevice *VAR_0, VirtQueue *VAR_1)
{
VirtIOGPU *g = VIRTIO_GPU(VAR_0);
struct virtio_gpu_ctrl_command *VAR_2;
if (!virtio_queue_ready(VAR_1)) {
return;
}
#ifdef CONFIG_VIRGL
if (!g->renderer_inited && g->use_virgl_renderer) {
virtio_gpu_virgl_init(g);
g->renderer_inited = true;
}
#endif
VAR_2 = g_new(struct virtio_gpu_ctrl_command, 1);
while (virtqueue_pop(VAR_1, &VAR_2->elem)) {
VAR_2->VAR_1 = VAR_1;
VAR_2->error = 0;
VAR_2->finished = false;
VAR_2->waiting = false;
QTAILQ_INSERT_TAIL(&g->cmdq, VAR_2, next);
VAR_2 = g_new(struct virtio_gpu_ctrl_command, 1);
}
g_free(VAR_2);
virtio_gpu_process_cmdq(g);
#ifdef CONFIG_VIRGL
if (g->use_virgl_renderer) {
virtio_gpu_virgl_fence_poll(g);
}
#endif
}
| [
"static void FUNC_0(VirtIODevice *VAR_0, VirtQueue *VAR_1)\n{",
"VirtIOGPU *g = VIRTIO_GPU(VAR_0);",
"struct virtio_gpu_ctrl_command *VAR_2;",
"if (!virtio_queue_ready(VAR_1)) {",
"return;",
"}",
"#ifdef CONFIG_VIRGL\nif (!g->renderer_inited && g->use_virgl_renderer) {",
"virtio_gpu_virgl_init(g);",
"g->renderer_inited = true;",
"}",
"#endif\nVAR_2 = g_new(struct virtio_gpu_ctrl_command, 1);",
"while (virtqueue_pop(VAR_1, &VAR_2->elem)) {",
"VAR_2->VAR_1 = VAR_1;",
"VAR_2->error = 0;",
"VAR_2->finished = false;",
"VAR_2->waiting = false;",
"QTAILQ_INSERT_TAIL(&g->cmdq, VAR_2, next);",
"VAR_2 = g_new(struct virtio_gpu_ctrl_command, 1);",
"}",
"g_free(VAR_2);",
"virtio_gpu_process_cmdq(g);",
"#ifdef CONFIG_VIRGL\nif (g->use_virgl_renderer) {",
"virtio_gpu_virgl_fence_poll(g);",
"}",
"#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
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
19,
21
],
[
23
],
[
25
],
[
27
],
[
29,
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55
],
[
59,
61
],
[
63
],
[
65
],
[
67,
69
]
]
|
16,964 | static void handle_mousemotion(DisplayState *ds, SDL_Event *ev)
{
int max_x, max_y;
if (is_graphic_console() &&
(kbd_mouse_is_absolute() || absolute_enabled)) {
max_x = real_screen->w - 1;
max_y = real_screen->h - 1;
if (gui_grab && (ev->motion.x == 0 || ev->motion.y == 0 ||
ev->motion.x == max_x || ev->motion.y == max_y)) {
sdl_grab_end();
}
if (!gui_grab && SDL_GetAppState() & SDL_APPINPUTFOCUS &&
(ev->motion.x > 0 && ev->motion.x < max_x &&
ev->motion.y > 0 && ev->motion.y < max_y)) {
sdl_grab_start();
}
}
if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) {
sdl_send_mouse_event(ev->motion.xrel, ev->motion.yrel, 0,
ev->motion.x, ev->motion.y, ev->motion.state);
}
}
| false | qemu | 85f94f868fcd868f0f605e9d3c1ad6351c557190 | static void handle_mousemotion(DisplayState *ds, SDL_Event *ev)
{
int max_x, max_y;
if (is_graphic_console() &&
(kbd_mouse_is_absolute() || absolute_enabled)) {
max_x = real_screen->w - 1;
max_y = real_screen->h - 1;
if (gui_grab && (ev->motion.x == 0 || ev->motion.y == 0 ||
ev->motion.x == max_x || ev->motion.y == max_y)) {
sdl_grab_end();
}
if (!gui_grab && SDL_GetAppState() & SDL_APPINPUTFOCUS &&
(ev->motion.x > 0 && ev->motion.x < max_x &&
ev->motion.y > 0 && ev->motion.y < max_y)) {
sdl_grab_start();
}
}
if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) {
sdl_send_mouse_event(ev->motion.xrel, ev->motion.yrel, 0,
ev->motion.x, ev->motion.y, ev->motion.state);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DisplayState *VAR_0, SDL_Event *VAR_1)
{
int VAR_2, VAR_3;
if (is_graphic_console() &&
(kbd_mouse_is_absolute() || absolute_enabled)) {
VAR_2 = real_screen->w - 1;
VAR_3 = real_screen->h - 1;
if (gui_grab && (VAR_1->motion.x == 0 || VAR_1->motion.y == 0 ||
VAR_1->motion.x == VAR_2 || VAR_1->motion.y == VAR_3)) {
sdl_grab_end();
}
if (!gui_grab && SDL_GetAppState() & SDL_APPINPUTFOCUS &&
(VAR_1->motion.x > 0 && VAR_1->motion.x < VAR_2 &&
VAR_1->motion.y > 0 && VAR_1->motion.y < VAR_3)) {
sdl_grab_start();
}
}
if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) {
sdl_send_mouse_event(VAR_1->motion.xrel, VAR_1->motion.yrel, 0,
VAR_1->motion.x, VAR_1->motion.y, VAR_1->motion.state);
}
}
| [
"static void FUNC_0(DisplayState *VAR_0, SDL_Event *VAR_1)\n{",
"int VAR_2, VAR_3;",
"if (is_graphic_console() &&\n(kbd_mouse_is_absolute() || absolute_enabled)) {",
"VAR_2 = real_screen->w - 1;",
"VAR_3 = real_screen->h - 1;",
"if (gui_grab && (VAR_1->motion.x == 0 || VAR_1->motion.y == 0 ||\nVAR_1->motion.x == VAR_2 || VAR_1->motion.y == VAR_3)) {",
"sdl_grab_end();",
"}",
"if (!gui_grab && SDL_GetAppState() & SDL_APPINPUTFOCUS &&\n(VAR_1->motion.x > 0 && VAR_1->motion.x < VAR_2 &&\nVAR_1->motion.y > 0 && VAR_1->motion.y < VAR_3)) {",
"sdl_grab_start();",
"}",
"}",
"if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) {",
"sdl_send_mouse_event(VAR_1->motion.xrel, VAR_1->motion.yrel, 0,\nVAR_1->motion.x, VAR_1->motion.y, VAR_1->motion.state);",
"}",
"}"
]
| [
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
]
]
|
16,965 | void helper_mwait(CPUX86State *env, int next_eip_addend)
{
CPUState *cs;
X86CPU *cpu;
if ((uint32_t)env->regs[R_ECX] != 0) {
raise_exception(env, EXCP0D_GPF);
}
cpu_svm_check_intercept_param(env, SVM_EXIT_MWAIT, 0);
env->eip += next_eip_addend;
cpu = x86_env_get_cpu(env);
cs = CPU(cpu);
/* XXX: not complete but not completely erroneous */
if (cs->cpu_index != 0 || CPU_NEXT(cs) != NULL) {
/* more than one CPU: do not sleep because another CPU may
wake this one */
} else {
do_hlt(cpu);
}
}
| false | qemu | 81f3053b77f7d3a4d9100c425cd8cec99ee7a3d4 | void helper_mwait(CPUX86State *env, int next_eip_addend)
{
CPUState *cs;
X86CPU *cpu;
if ((uint32_t)env->regs[R_ECX] != 0) {
raise_exception(env, EXCP0D_GPF);
}
cpu_svm_check_intercept_param(env, SVM_EXIT_MWAIT, 0);
env->eip += next_eip_addend;
cpu = x86_env_get_cpu(env);
cs = CPU(cpu);
if (cs->cpu_index != 0 || CPU_NEXT(cs) != NULL) {
} else {
do_hlt(cpu);
}
}
| {
"code": [],
"line_no": []
} | void FUNC_0(CPUX86State *VAR_0, int VAR_1)
{
CPUState *cs;
X86CPU *cpu;
if ((uint32_t)VAR_0->regs[R_ECX] != 0) {
raise_exception(VAR_0, EXCP0D_GPF);
}
cpu_svm_check_intercept_param(VAR_0, SVM_EXIT_MWAIT, 0);
VAR_0->eip += VAR_1;
cpu = x86_env_get_cpu(VAR_0);
cs = CPU(cpu);
if (cs->cpu_index != 0 || CPU_NEXT(cs) != NULL) {
} else {
do_hlt(cpu);
}
}
| [
"void FUNC_0(CPUX86State *VAR_0, int VAR_1)\n{",
"CPUState *cs;",
"X86CPU *cpu;",
"if ((uint32_t)VAR_0->regs[R_ECX] != 0) {",
"raise_exception(VAR_0, EXCP0D_GPF);",
"}",
"cpu_svm_check_intercept_param(VAR_0, SVM_EXIT_MWAIT, 0);",
"VAR_0->eip += VAR_1;",
"cpu = x86_env_get_cpu(VAR_0);",
"cs = CPU(cpu);",
"if (cs->cpu_index != 0 || CPU_NEXT(cs) != NULL) {",
"} else {",
"do_hlt(cpu);",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
29
],
[
35
],
[
37
],
[
39
],
[
41
]
]
|
16,968 | QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head,
const GraphicHwOps *hw_ops,
void *opaque)
{
Error *local_err = NULL;
int width = 640;
int height = 480;
QemuConsole *s;
DisplayState *ds;
ds = get_alloc_displaystate();
trace_console_gfx_new();
s = new_console(ds, GRAPHIC_CONSOLE);
s->hw_ops = hw_ops;
s->hw = opaque;
if (dev) {
object_property_set_link(OBJECT(s), OBJECT(dev),
"device", &local_err);
object_property_set_int(OBJECT(s), head,
"head", &local_err);
}
s->surface = qemu_create_displaysurface(width, height);
return s;
}
| true | qemu | afff2b15e89ac81c113f2ebfd729aaa02b40edb6 | QemuConsole *graphic_console_init(DeviceState *dev, uint32_t head,
const GraphicHwOps *hw_ops,
void *opaque)
{
Error *local_err = NULL;
int width = 640;
int height = 480;
QemuConsole *s;
DisplayState *ds;
ds = get_alloc_displaystate();
trace_console_gfx_new();
s = new_console(ds, GRAPHIC_CONSOLE);
s->hw_ops = hw_ops;
s->hw = opaque;
if (dev) {
object_property_set_link(OBJECT(s), OBJECT(dev),
"device", &local_err);
object_property_set_int(OBJECT(s), head,
"head", &local_err);
}
s->surface = qemu_create_displaysurface(width, height);
return s;
}
| {
"code": [
" Error *local_err = NULL;",
" Error *local_err = NULL;",
" Error *local_err = NULL;",
" s = new_console(ds, GRAPHIC_CONSOLE);",
" object_property_set_link(OBJECT(s), OBJECT(dev),",
" \"device\", &local_err);",
" object_property_set_int(OBJECT(s), head,",
" \"head\", &local_err);",
" Error *local_err = NULL;"
],
"line_no": [
9,
9,
9,
25,
33,
35,
37,
39,
9
]
} | QemuConsole *FUNC_0(DeviceState *dev, uint32_t head,
const GraphicHwOps *hw_ops,
void *opaque)
{
Error *local_err = NULL;
int VAR_0 = 640;
int VAR_1 = 480;
QemuConsole *s;
DisplayState *ds;
ds = get_alloc_displaystate();
trace_console_gfx_new();
s = new_console(ds, GRAPHIC_CONSOLE);
s->hw_ops = hw_ops;
s->hw = opaque;
if (dev) {
object_property_set_link(OBJECT(s), OBJECT(dev),
"device", &local_err);
object_property_set_int(OBJECT(s), head,
"head", &local_err);
}
s->surface = qemu_create_displaysurface(VAR_0, VAR_1);
return s;
}
| [
"QemuConsole *FUNC_0(DeviceState *dev, uint32_t head,\nconst GraphicHwOps *hw_ops,\nvoid *opaque)\n{",
"Error *local_err = NULL;",
"int VAR_0 = 640;",
"int VAR_1 = 480;",
"QemuConsole *s;",
"DisplayState *ds;",
"ds = get_alloc_displaystate();",
"trace_console_gfx_new();",
"s = new_console(ds, GRAPHIC_CONSOLE);",
"s->hw_ops = hw_ops;",
"s->hw = opaque;",
"if (dev) {",
"object_property_set_link(OBJECT(s), OBJECT(dev),\n\"device\", &local_err);",
"object_property_set_int(OBJECT(s), head,\n\"head\", &local_err);",
"}",
"s->surface = qemu_create_displaysurface(VAR_0, VAR_1);",
"return s;",
"}"
]
| [
0,
1,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
1,
1,
0,
0,
0,
0
]
| [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33,
35
],
[
37,
39
],
[
41
],
[
45
],
[
47
],
[
49
]
]
|
16,970 | static int ram_save_setup(QEMUFile *f, void *opaque)
{
RAMBlock *block;
int64_t ram_pages = last_ram_offset() >> TARGET_PAGE_BITS;
migration_bitmap = bitmap_new(ram_pages);
bitmap_set(migration_bitmap, 0, ram_pages);
migration_dirty_pages = ram_pages;
mig_throttle_on = false;
dirty_rate_high_cnt = 0;
if (migrate_use_xbzrle()) {
qemu_mutex_lock_iothread();
XBZRLE.cache = cache_init(migrate_xbzrle_cache_size() /
TARGET_PAGE_SIZE,
TARGET_PAGE_SIZE);
if (!XBZRLE.cache) {
qemu_mutex_unlock_iothread();
DPRINTF("Error creating cache\n");
return -1;
}
qemu_mutex_init(&XBZRLE.lock);
qemu_mutex_unlock_iothread();
/* We prefer not to abort if there is no memory */
XBZRLE.encoded_buf = g_try_malloc0(TARGET_PAGE_SIZE);
if (!XBZRLE.encoded_buf) {
DPRINTF("Error allocating encoded_buf\n");
return -1;
}
XBZRLE.current_buf = g_try_malloc(TARGET_PAGE_SIZE);
if (!XBZRLE.current_buf) {
DPRINTF("Error allocating current_buf\n");
g_free(XBZRLE.encoded_buf);
XBZRLE.encoded_buf = NULL;
return -1;
}
acct_clear();
}
qemu_mutex_lock_iothread();
qemu_mutex_lock_ramlist();
bytes_transferred = 0;
reset_ram_globals();
memory_global_dirty_log_start();
migration_bitmap_sync();
qemu_mutex_unlock_iothread();
qemu_put_be64(f, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE);
QTAILQ_FOREACH(block, &ram_list.blocks, next) {
qemu_put_byte(f, strlen(block->idstr));
qemu_put_buffer(f, (uint8_t *)block->idstr, strlen(block->idstr));
qemu_put_be64(f, block->length);
}
qemu_mutex_unlock_ramlist();
ram_control_before_iterate(f, RAM_CONTROL_SETUP);
ram_control_after_iterate(f, RAM_CONTROL_SETUP);
qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
return 0;
}
| true | qemu | e30d1d8c7195848abb28a8c734a82b845b8b456a | static int ram_save_setup(QEMUFile *f, void *opaque)
{
RAMBlock *block;
int64_t ram_pages = last_ram_offset() >> TARGET_PAGE_BITS;
migration_bitmap = bitmap_new(ram_pages);
bitmap_set(migration_bitmap, 0, ram_pages);
migration_dirty_pages = ram_pages;
mig_throttle_on = false;
dirty_rate_high_cnt = 0;
if (migrate_use_xbzrle()) {
qemu_mutex_lock_iothread();
XBZRLE.cache = cache_init(migrate_xbzrle_cache_size() /
TARGET_PAGE_SIZE,
TARGET_PAGE_SIZE);
if (!XBZRLE.cache) {
qemu_mutex_unlock_iothread();
DPRINTF("Error creating cache\n");
return -1;
}
qemu_mutex_init(&XBZRLE.lock);
qemu_mutex_unlock_iothread();
XBZRLE.encoded_buf = g_try_malloc0(TARGET_PAGE_SIZE);
if (!XBZRLE.encoded_buf) {
DPRINTF("Error allocating encoded_buf\n");
return -1;
}
XBZRLE.current_buf = g_try_malloc(TARGET_PAGE_SIZE);
if (!XBZRLE.current_buf) {
DPRINTF("Error allocating current_buf\n");
g_free(XBZRLE.encoded_buf);
XBZRLE.encoded_buf = NULL;
return -1;
}
acct_clear();
}
qemu_mutex_lock_iothread();
qemu_mutex_lock_ramlist();
bytes_transferred = 0;
reset_ram_globals();
memory_global_dirty_log_start();
migration_bitmap_sync();
qemu_mutex_unlock_iothread();
qemu_put_be64(f, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE);
QTAILQ_FOREACH(block, &ram_list.blocks, next) {
qemu_put_byte(f, strlen(block->idstr));
qemu_put_buffer(f, (uint8_t *)block->idstr, strlen(block->idstr));
qemu_put_be64(f, block->length);
}
qemu_mutex_unlock_ramlist();
ram_control_before_iterate(f, RAM_CONTROL_SETUP);
ram_control_after_iterate(f, RAM_CONTROL_SETUP);
qemu_put_be64(f, RAM_SAVE_FLAG_EOS);
return 0;
}
| {
"code": [
" int64_t ram_pages = last_ram_offset() >> TARGET_PAGE_BITS;",
" migration_bitmap = bitmap_new(ram_pages);",
" bitmap_set(migration_bitmap, 0, ram_pages);",
" migration_dirty_pages = ram_pages;"
],
"line_no": [
7,
11,
13,
15
]
} | static int FUNC_0(QEMUFile *VAR_0, void *VAR_1)
{
RAMBlock *block;
int64_t ram_pages = last_ram_offset() >> TARGET_PAGE_BITS;
migration_bitmap = bitmap_new(ram_pages);
bitmap_set(migration_bitmap, 0, ram_pages);
migration_dirty_pages = ram_pages;
mig_throttle_on = false;
dirty_rate_high_cnt = 0;
if (migrate_use_xbzrle()) {
qemu_mutex_lock_iothread();
XBZRLE.cache = cache_init(migrate_xbzrle_cache_size() /
TARGET_PAGE_SIZE,
TARGET_PAGE_SIZE);
if (!XBZRLE.cache) {
qemu_mutex_unlock_iothread();
DPRINTF("Error creating cache\n");
return -1;
}
qemu_mutex_init(&XBZRLE.lock);
qemu_mutex_unlock_iothread();
XBZRLE.encoded_buf = g_try_malloc0(TARGET_PAGE_SIZE);
if (!XBZRLE.encoded_buf) {
DPRINTF("Error allocating encoded_buf\n");
return -1;
}
XBZRLE.current_buf = g_try_malloc(TARGET_PAGE_SIZE);
if (!XBZRLE.current_buf) {
DPRINTF("Error allocating current_buf\n");
g_free(XBZRLE.encoded_buf);
XBZRLE.encoded_buf = NULL;
return -1;
}
acct_clear();
}
qemu_mutex_lock_iothread();
qemu_mutex_lock_ramlist();
bytes_transferred = 0;
reset_ram_globals();
memory_global_dirty_log_start();
migration_bitmap_sync();
qemu_mutex_unlock_iothread();
qemu_put_be64(VAR_0, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE);
QTAILQ_FOREACH(block, &ram_list.blocks, next) {
qemu_put_byte(VAR_0, strlen(block->idstr));
qemu_put_buffer(VAR_0, (uint8_t *)block->idstr, strlen(block->idstr));
qemu_put_be64(VAR_0, block->length);
}
qemu_mutex_unlock_ramlist();
ram_control_before_iterate(VAR_0, RAM_CONTROL_SETUP);
ram_control_after_iterate(VAR_0, RAM_CONTROL_SETUP);
qemu_put_be64(VAR_0, RAM_SAVE_FLAG_EOS);
return 0;
}
| [
"static int FUNC_0(QEMUFile *VAR_0, void *VAR_1)\n{",
"RAMBlock *block;",
"int64_t ram_pages = last_ram_offset() >> TARGET_PAGE_BITS;",
"migration_bitmap = bitmap_new(ram_pages);",
"bitmap_set(migration_bitmap, 0, ram_pages);",
"migration_dirty_pages = ram_pages;",
"mig_throttle_on = false;",
"dirty_rate_high_cnt = 0;",
"if (migrate_use_xbzrle()) {",
"qemu_mutex_lock_iothread();",
"XBZRLE.cache = cache_init(migrate_xbzrle_cache_size() /\nTARGET_PAGE_SIZE,\nTARGET_PAGE_SIZE);",
"if (!XBZRLE.cache) {",
"qemu_mutex_unlock_iothread();",
"DPRINTF(\"Error creating cache\\n\");",
"return -1;",
"}",
"qemu_mutex_init(&XBZRLE.lock);",
"qemu_mutex_unlock_iothread();",
"XBZRLE.encoded_buf = g_try_malloc0(TARGET_PAGE_SIZE);",
"if (!XBZRLE.encoded_buf) {",
"DPRINTF(\"Error allocating encoded_buf\\n\");",
"return -1;",
"}",
"XBZRLE.current_buf = g_try_malloc(TARGET_PAGE_SIZE);",
"if (!XBZRLE.current_buf) {",
"DPRINTF(\"Error allocating current_buf\\n\");",
"g_free(XBZRLE.encoded_buf);",
"XBZRLE.encoded_buf = NULL;",
"return -1;",
"}",
"acct_clear();",
"}",
"qemu_mutex_lock_iothread();",
"qemu_mutex_lock_ramlist();",
"bytes_transferred = 0;",
"reset_ram_globals();",
"memory_global_dirty_log_start();",
"migration_bitmap_sync();",
"qemu_mutex_unlock_iothread();",
"qemu_put_be64(VAR_0, ram_bytes_total() | RAM_SAVE_FLAG_MEM_SIZE);",
"QTAILQ_FOREACH(block, &ram_list.blocks, next) {",
"qemu_put_byte(VAR_0, strlen(block->idstr));",
"qemu_put_buffer(VAR_0, (uint8_t *)block->idstr, strlen(block->idstr));",
"qemu_put_be64(VAR_0, block->length);",
"}",
"qemu_mutex_unlock_ramlist();",
"ram_control_before_iterate(VAR_0, RAM_CONTROL_SETUP);",
"ram_control_after_iterate(VAR_0, RAM_CONTROL_SETUP);",
"qemu_put_be64(VAR_0, RAM_SAVE_FLAG_EOS);",
"return 0;",
"}"
]
| [
0,
0,
1,
1,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27,
29,
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
79
],
[
81
],
[
85
],
[
87
],
[
89
],
[
91
],
[
95
],
[
97
],
[
99
],
[
103
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
119
],
[
123
],
[
125
],
[
129
],
[
133
],
[
135
]
]
|
16,971 | static int xan_decode_chroma(AVCodecContext *avctx, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
XanContext *s = avctx->priv_data;
uint8_t *U, *V;
unsigned chroma_off;
int val, uval, vval;
int i, j;
const uint8_t *src, *src_end;
const uint8_t *table;
int mode, offset, dec_size;
chroma_off = AV_RL32(buf + 4);
if (!chroma_off)
return 0;
if (chroma_off + 10 >= avpkt->size) {
av_log(avctx, AV_LOG_ERROR, "Invalid chroma block position\n");
return -1;
}
src = avpkt->data + 4 + chroma_off;
table = src + 2;
mode = bytestream_get_le16(&src);
offset = bytestream_get_le16(&src) * 2;
if (src - avpkt->data >= avpkt->size - offset) {
av_log(avctx, AV_LOG_ERROR, "Invalid chroma block offset\n");
return -1;
}
memset(s->scratch_buffer, 0, s->buffer_size);
dec_size = xan_unpack(s->scratch_buffer, s->buffer_size, src + offset,
avpkt->size - offset - (src - avpkt->data));
if (dec_size < 0) {
av_log(avctx, AV_LOG_ERROR, "Chroma unpacking failed\n");
return -1;
}
U = s->pic.data[1];
V = s->pic.data[2];
src = s->scratch_buffer;
src_end = src + dec_size;
if (mode) {
for (j = 0; j < avctx->height >> 1; j++) {
for (i = 0; i < avctx->width >> 1; i++) {
val = *src++;
if (val) {
val = AV_RL16(table + (val << 1));
uval = (val >> 3) & 0xF8;
vval = (val >> 8) & 0xF8;
U[i] = uval | (uval >> 5);
V[i] = vval | (vval >> 5);
}
if (src == src_end)
return 0;
}
U += s->pic.linesize[1];
V += s->pic.linesize[2];
}
} else {
uint8_t *U2 = U + s->pic.linesize[1];
uint8_t *V2 = V + s->pic.linesize[2];
for (j = 0; j < avctx->height >> 2; j++) {
for (i = 0; i < avctx->width >> 1; i += 2) {
val = *src++;
if (val) {
val = AV_RL16(table + (val << 1));
uval = (val >> 3) & 0xF8;
vval = (val >> 8) & 0xF8;
U[i] = U[i+1] = U2[i] = U2[i+1] = uval | (uval >> 5);
V[i] = V[i+1] = V2[i] = V2[i+1] = vval | (vval >> 5);
}
}
U += s->pic.linesize[1] * 2;
V += s->pic.linesize[2] * 2;
U2 += s->pic.linesize[1] * 2;
V2 += s->pic.linesize[2] * 2;
}
}
return 0;
}
| true | FFmpeg | a68a6a4fb19caecc91d5f7fe3ef4f83f6d3c4586 | static int xan_decode_chroma(AVCodecContext *avctx, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
XanContext *s = avctx->priv_data;
uint8_t *U, *V;
unsigned chroma_off;
int val, uval, vval;
int i, j;
const uint8_t *src, *src_end;
const uint8_t *table;
int mode, offset, dec_size;
chroma_off = AV_RL32(buf + 4);
if (!chroma_off)
return 0;
if (chroma_off + 10 >= avpkt->size) {
av_log(avctx, AV_LOG_ERROR, "Invalid chroma block position\n");
return -1;
}
src = avpkt->data + 4 + chroma_off;
table = src + 2;
mode = bytestream_get_le16(&src);
offset = bytestream_get_le16(&src) * 2;
if (src - avpkt->data >= avpkt->size - offset) {
av_log(avctx, AV_LOG_ERROR, "Invalid chroma block offset\n");
return -1;
}
memset(s->scratch_buffer, 0, s->buffer_size);
dec_size = xan_unpack(s->scratch_buffer, s->buffer_size, src + offset,
avpkt->size - offset - (src - avpkt->data));
if (dec_size < 0) {
av_log(avctx, AV_LOG_ERROR, "Chroma unpacking failed\n");
return -1;
}
U = s->pic.data[1];
V = s->pic.data[2];
src = s->scratch_buffer;
src_end = src + dec_size;
if (mode) {
for (j = 0; j < avctx->height >> 1; j++) {
for (i = 0; i < avctx->width >> 1; i++) {
val = *src++;
if (val) {
val = AV_RL16(table + (val << 1));
uval = (val >> 3) & 0xF8;
vval = (val >> 8) & 0xF8;
U[i] = uval | (uval >> 5);
V[i] = vval | (vval >> 5);
}
if (src == src_end)
return 0;
}
U += s->pic.linesize[1];
V += s->pic.linesize[2];
}
} else {
uint8_t *U2 = U + s->pic.linesize[1];
uint8_t *V2 = V + s->pic.linesize[2];
for (j = 0; j < avctx->height >> 2; j++) {
for (i = 0; i < avctx->width >> 1; i += 2) {
val = *src++;
if (val) {
val = AV_RL16(table + (val << 1));
uval = (val >> 3) & 0xF8;
vval = (val >> 8) & 0xF8;
U[i] = U[i+1] = U2[i] = U2[i+1] = uval | (uval >> 5);
V[i] = V[i+1] = V2[i] = V2[i+1] = vval | (vval >> 5);
}
}
U += s->pic.linesize[1] * 2;
V += s->pic.linesize[2] * 2;
U2 += s->pic.linesize[1] * 2;
V2 += s->pic.linesize[2] * 2;
}
}
return 0;
}
| {
"code": [
" if (src == src_end)",
" return 0;"
],
"line_no": [
105,
107
]
} | static int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1)
{
const uint8_t *VAR_2 = VAR_1->data;
XanContext *s = VAR_0->priv_data;
uint8_t *U, *V;
unsigned VAR_3;
int VAR_4, VAR_5, VAR_6;
int VAR_7, VAR_8;
const uint8_t *VAR_9, *src_end;
const uint8_t *VAR_10;
int VAR_11, VAR_12, VAR_13;
VAR_3 = AV_RL32(VAR_2 + 4);
if (!VAR_3)
return 0;
if (VAR_3 + 10 >= VAR_1->size) {
av_log(VAR_0, AV_LOG_ERROR, "Invalid chroma block position\n");
return -1;
}
VAR_9 = VAR_1->data + 4 + VAR_3;
VAR_10 = VAR_9 + 2;
VAR_11 = bytestream_get_le16(&VAR_9);
VAR_12 = bytestream_get_le16(&VAR_9) * 2;
if (VAR_9 - VAR_1->data >= VAR_1->size - VAR_12) {
av_log(VAR_0, AV_LOG_ERROR, "Invalid chroma block VAR_12\n");
return -1;
}
memset(s->scratch_buffer, 0, s->buffer_size);
VAR_13 = xan_unpack(s->scratch_buffer, s->buffer_size, VAR_9 + VAR_12,
VAR_1->size - VAR_12 - (VAR_9 - VAR_1->data));
if (VAR_13 < 0) {
av_log(VAR_0, AV_LOG_ERROR, "Chroma unpacking failed\n");
return -1;
}
U = s->pic.data[1];
V = s->pic.data[2];
VAR_9 = s->scratch_buffer;
src_end = VAR_9 + VAR_13;
if (VAR_11) {
for (VAR_8 = 0; VAR_8 < VAR_0->height >> 1; VAR_8++) {
for (VAR_7 = 0; VAR_7 < VAR_0->width >> 1; VAR_7++) {
VAR_4 = *VAR_9++;
if (VAR_4) {
VAR_4 = AV_RL16(VAR_10 + (VAR_4 << 1));
VAR_5 = (VAR_4 >> 3) & 0xF8;
VAR_6 = (VAR_4 >> 8) & 0xF8;
U[VAR_7] = VAR_5 | (VAR_5 >> 5);
V[VAR_7] = VAR_6 | (VAR_6 >> 5);
}
if (VAR_9 == src_end)
return 0;
}
U += s->pic.linesize[1];
V += s->pic.linesize[2];
}
} else {
uint8_t *U2 = U + s->pic.linesize[1];
uint8_t *V2 = V + s->pic.linesize[2];
for (VAR_8 = 0; VAR_8 < VAR_0->height >> 2; VAR_8++) {
for (VAR_7 = 0; VAR_7 < VAR_0->width >> 1; VAR_7 += 2) {
VAR_4 = *VAR_9++;
if (VAR_4) {
VAR_4 = AV_RL16(VAR_10 + (VAR_4 << 1));
VAR_5 = (VAR_4 >> 3) & 0xF8;
VAR_6 = (VAR_4 >> 8) & 0xF8;
U[VAR_7] = U[VAR_7+1] = U2[VAR_7] = U2[VAR_7+1] = VAR_5 | (VAR_5 >> 5);
V[VAR_7] = V[VAR_7+1] = V2[VAR_7] = V2[VAR_7+1] = VAR_6 | (VAR_6 >> 5);
}
}
U += s->pic.linesize[1] * 2;
V += s->pic.linesize[2] * 2;
U2 += s->pic.linesize[1] * 2;
V2 += s->pic.linesize[2] * 2;
}
}
return 0;
}
| [
"static int FUNC_0(AVCodecContext *VAR_0, AVPacket *VAR_1)\n{",
"const uint8_t *VAR_2 = VAR_1->data;",
"XanContext *s = VAR_0->priv_data;",
"uint8_t *U, *V;",
"unsigned VAR_3;",
"int VAR_4, VAR_5, VAR_6;",
"int VAR_7, VAR_8;",
"const uint8_t *VAR_9, *src_end;",
"const uint8_t *VAR_10;",
"int VAR_11, VAR_12, VAR_13;",
"VAR_3 = AV_RL32(VAR_2 + 4);",
"if (!VAR_3)\nreturn 0;",
"if (VAR_3 + 10 >= VAR_1->size) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Invalid chroma block position\\n\");",
"return -1;",
"}",
"VAR_9 = VAR_1->data + 4 + VAR_3;",
"VAR_10 = VAR_9 + 2;",
"VAR_11 = bytestream_get_le16(&VAR_9);",
"VAR_12 = bytestream_get_le16(&VAR_9) * 2;",
"if (VAR_9 - VAR_1->data >= VAR_1->size - VAR_12) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Invalid chroma block VAR_12\\n\");",
"return -1;",
"}",
"memset(s->scratch_buffer, 0, s->buffer_size);",
"VAR_13 = xan_unpack(s->scratch_buffer, s->buffer_size, VAR_9 + VAR_12,\nVAR_1->size - VAR_12 - (VAR_9 - VAR_1->data));",
"if (VAR_13 < 0) {",
"av_log(VAR_0, AV_LOG_ERROR, \"Chroma unpacking failed\\n\");",
"return -1;",
"}",
"U = s->pic.data[1];",
"V = s->pic.data[2];",
"VAR_9 = s->scratch_buffer;",
"src_end = VAR_9 + VAR_13;",
"if (VAR_11) {",
"for (VAR_8 = 0; VAR_8 < VAR_0->height >> 1; VAR_8++) {",
"for (VAR_7 = 0; VAR_7 < VAR_0->width >> 1; VAR_7++) {",
"VAR_4 = *VAR_9++;",
"if (VAR_4) {",
"VAR_4 = AV_RL16(VAR_10 + (VAR_4 << 1));",
"VAR_5 = (VAR_4 >> 3) & 0xF8;",
"VAR_6 = (VAR_4 >> 8) & 0xF8;",
"U[VAR_7] = VAR_5 | (VAR_5 >> 5);",
"V[VAR_7] = VAR_6 | (VAR_6 >> 5);",
"}",
"if (VAR_9 == src_end)\nreturn 0;",
"}",
"U += s->pic.linesize[1];",
"V += s->pic.linesize[2];",
"}",
"} else {",
"uint8_t *U2 = U + s->pic.linesize[1];",
"uint8_t *V2 = V + s->pic.linesize[2];",
"for (VAR_8 = 0; VAR_8 < VAR_0->height >> 2; VAR_8++) {",
"for (VAR_7 = 0; VAR_7 < VAR_0->width >> 1; VAR_7 += 2) {",
"VAR_4 = *VAR_9++;",
"if (VAR_4) {",
"VAR_4 = AV_RL16(VAR_10 + (VAR_4 << 1));",
"VAR_5 = (VAR_4 >> 3) & 0xF8;",
"VAR_6 = (VAR_4 >> 8) & 0xF8;",
"U[VAR_7] = U[VAR_7+1] = U2[VAR_7] = U2[VAR_7+1] = VAR_5 | (VAR_5 >> 5);",
"V[VAR_7] = V[VAR_7+1] = V2[VAR_7] = V2[VAR_7+1] = VAR_6 | (VAR_6 >> 5);",
"}",
"}",
"U += s->pic.linesize[1] * 2;",
"V += s->pic.linesize[2] * 2;",
"U2 += s->pic.linesize[1] * 2;",
"V2 += s->pic.linesize[2] * 2;",
"}",
"}",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
25
],
[
27,
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
49
],
[
51
],
[
53
],
[
55
],
[
59
],
[
61,
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105,
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
161
],
[
163
]
]
|
16,972 | static int av_thread_message_queue_send_locked(AVThreadMessageQueue *mq,
void *msg,
unsigned flags)
{
while (!mq->err_send && av_fifo_space(mq->fifo) < mq->elsize) {
if ((flags & AV_THREAD_MESSAGE_NONBLOCK))
return AVERROR(EAGAIN);
pthread_cond_wait(&mq->cond, &mq->lock);
}
if (mq->err_send)
return mq->err_send;
av_fifo_generic_write(mq->fifo, msg, mq->elsize, NULL);
pthread_cond_signal(&mq->cond);
return 0;
}
| true | FFmpeg | bd5c860fdbc33d19d2ff0f6d1f06de07c17560dd | static int av_thread_message_queue_send_locked(AVThreadMessageQueue *mq,
void *msg,
unsigned flags)
{
while (!mq->err_send && av_fifo_space(mq->fifo) < mq->elsize) {
if ((flags & AV_THREAD_MESSAGE_NONBLOCK))
return AVERROR(EAGAIN);
pthread_cond_wait(&mq->cond, &mq->lock);
}
if (mq->err_send)
return mq->err_send;
av_fifo_generic_write(mq->fifo, msg, mq->elsize, NULL);
pthread_cond_signal(&mq->cond);
return 0;
}
| {
"code": [
" pthread_cond_wait(&mq->cond, &mq->lock);",
" pthread_cond_signal(&mq->cond);",
" pthread_cond_wait(&mq->cond, &mq->lock);",
" pthread_cond_signal(&mq->cond);"
],
"line_no": [
15,
25,
15,
25
]
} | static int FUNC_0(AVThreadMessageQueue *VAR_0,
void *VAR_1,
unsigned VAR_2)
{
while (!VAR_0->err_send && av_fifo_space(VAR_0->fifo) < VAR_0->elsize) {
if ((VAR_2 & AV_THREAD_MESSAGE_NONBLOCK))
return AVERROR(EAGAIN);
pthread_cond_wait(&VAR_0->cond, &VAR_0->lock);
}
if (VAR_0->err_send)
return VAR_0->err_send;
av_fifo_generic_write(VAR_0->fifo, VAR_1, VAR_0->elsize, NULL);
pthread_cond_signal(&VAR_0->cond);
return 0;
}
| [
"static int FUNC_0(AVThreadMessageQueue *VAR_0,\nvoid *VAR_1,\nunsigned VAR_2)\n{",
"while (!VAR_0->err_send && av_fifo_space(VAR_0->fifo) < VAR_0->elsize) {",
"if ((VAR_2 & AV_THREAD_MESSAGE_NONBLOCK))\nreturn AVERROR(EAGAIN);",
"pthread_cond_wait(&VAR_0->cond, &VAR_0->lock);",
"}",
"if (VAR_0->err_send)\nreturn VAR_0->err_send;",
"av_fifo_generic_write(VAR_0->fifo, VAR_1, VAR_0->elsize, NULL);",
"pthread_cond_signal(&VAR_0->cond);",
"return 0;",
"}"
]
| [
0,
0,
0,
1,
0,
0,
0,
1,
0,
0
]
| [
[
1,
3,
5,
7
],
[
9
],
[
11,
13
],
[
15
],
[
17
],
[
19,
21
],
[
23
],
[
25
],
[
27
],
[
29
]
]
|
16,973 | static int rsd_probe(AVProbeData *p)
{
if (!memcmp(p->buf, "RSD", 3) &&
p->buf[3] - '0' >= 2 && p->buf[3] - '0' <= 6)
return AVPROBE_SCORE_EXTENSION;
return 0;
}
| true | FFmpeg | 50a3c4c5d2634b5d4076a5b7c099729cbd59ac45 | static int rsd_probe(AVProbeData *p)
{
if (!memcmp(p->buf, "RSD", 3) &&
p->buf[3] - '0' >= 2 && p->buf[3] - '0' <= 6)
return AVPROBE_SCORE_EXTENSION;
return 0;
}
| {
"code": [
" if (!memcmp(p->buf, \"RSD\", 3) &&",
" p->buf[3] - '0' >= 2 && p->buf[3] - '0' <= 6)",
" return AVPROBE_SCORE_EXTENSION;",
" return 0;"
],
"line_no": [
5,
7,
9,
11
]
} | static int FUNC_0(AVProbeData *VAR_0)
{
if (!memcmp(VAR_0->buf, "RSD", 3) &&
VAR_0->buf[3] - '0' >= 2 && VAR_0->buf[3] - '0' <= 6)
return AVPROBE_SCORE_EXTENSION;
return 0;
}
| [
"static int FUNC_0(AVProbeData *VAR_0)\n{",
"if (!memcmp(VAR_0->buf, \"RSD\", 3) &&\nVAR_0->buf[3] - '0' >= 2 && VAR_0->buf[3] - '0' <= 6)\nreturn AVPROBE_SCORE_EXTENSION;",
"return 0;",
"}"
]
| [
0,
1,
1,
0
]
| [
[
1,
3
],
[
5,
7,
9
],
[
11
],
[
13
]
]
|
16,974 | static uint64_t ntohll(uint64_t v) {
union { uint32_t lv[2]; uint64_t llv; } u;
u.llv = v;
return ((uint64_t)ntohl(u.lv[0]) << 32) | (uint64_t) ntohl(u.lv[1]);
}
| true | qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | static uint64_t ntohll(uint64_t v) {
union { uint32_t lv[2]; uint64_t llv; } u;
u.llv = v;
return ((uint64_t)ntohl(u.lv[0]) << 32) | (uint64_t) ntohl(u.lv[1]);
}
| {
"code": [],
"line_no": []
} | static uint64_t FUNC_0(uint64_t v) {
union { uint32_t lv[2]; uint64_t llv; } VAR_0;
VAR_0.llv = v;
return ((uint64_t)ntohl(VAR_0.lv[0]) << 32) | (uint64_t) ntohl(VAR_0.lv[1]);
}
| [
"static uint64_t FUNC_0(uint64_t v) {",
"union { uint32_t lv[2]; uint64_t llv; } VAR_0;",
"VAR_0.llv = v;",
"return ((uint64_t)ntohl(VAR_0.lv[0]) << 32) | (uint64_t) ntohl(VAR_0.lv[1]);",
"}"
]
| [
0,
0,
0,
0,
0
]
| [
[
1
],
[
3
],
[
5
],
[
7
],
[
9
]
]
|
16,975 | static av_always_inline int simple_limit(uint8_t *p, ptrdiff_t stride, int flim)
{
LOAD_PIXELS
return 2 * FFABS(p0 - q0) + (FFABS(p1 - q1) >> 1) <= flim;
}
| true | FFmpeg | ac4b32df71bd932838043a4838b86d11e169707f | static av_always_inline int simple_limit(uint8_t *p, ptrdiff_t stride, int flim)
{
LOAD_PIXELS
return 2 * FFABS(p0 - q0) + (FFABS(p1 - q1) >> 1) <= flim;
}
| {
"code": [
"static av_always_inline int simple_limit(uint8_t *p, ptrdiff_t stride, int flim)",
" LOAD_PIXELS"
],
"line_no": [
1,
5
]
} | static av_always_inline int FUNC_0(uint8_t *p, ptrdiff_t stride, int flim)
{
LOAD_PIXELS
return 2 * FFABS(p0 - q0) + (FFABS(p1 - q1) >> 1) <= flim;
}
| [
"static av_always_inline int FUNC_0(uint8_t *p, ptrdiff_t stride, int flim)\n{",
"LOAD_PIXELS\nreturn 2 * FFABS(p0 - q0) + (FFABS(p1 - q1) >> 1) <= flim;",
"}"
]
| [
1,
1,
0
]
| [
[
1,
3
],
[
5,
7
],
[
9
]
]
|
16,976 | void sample_dump(int fnum, INT32 *tab, int n)
{
static FILE *files[16], *f;
char buf[512];
f = files[fnum];
if (!f) {
sprintf(buf, "/tmp/out%d.pcm", fnum);
f = fopen(buf, "w");
if (!f)
return;
files[fnum] = f;
}
if (fnum == 0) {
int i;
static int pos = 0;
printf("pos=%d\n", pos);
for(i=0;i<n;i++) {
printf(" %f", (double)tab[i] / 32768.0);
if ((i % 18) == 17)
printf("\n");
}
pos += n;
}
fwrite(tab, 1, n * sizeof(INT32), f);
}
| true | FFmpeg | 8155233413540c63e53a620ff5734fb4b0635611 | void sample_dump(int fnum, INT32 *tab, int n)
{
static FILE *files[16], *f;
char buf[512];
f = files[fnum];
if (!f) {
sprintf(buf, "/tmp/out%d.pcm", fnum);
f = fopen(buf, "w");
if (!f)
return;
files[fnum] = f;
}
if (fnum == 0) {
int i;
static int pos = 0;
printf("pos=%d\n", pos);
for(i=0;i<n;i++) {
printf(" %f", (double)tab[i] / 32768.0);
if ((i % 18) == 17)
printf("\n");
}
pos += n;
}
fwrite(tab, 1, n * sizeof(INT32), f);
}
| {
"code": [
" sprintf(buf, \"/tmp/out%d.pcm\", fnum);",
" int i;",
" printf(\" %f\", (double)tab[i] / 32768.0);",
" fwrite(tab, 1, n * sizeof(INT32), f);"
],
"line_no": [
15,
31,
39,
53
]
} | void FUNC_0(int VAR_0, INT32 *VAR_1, int VAR_2)
{
static FILE *VAR_3[16], *f;
char VAR_4[512];
f = VAR_3[VAR_0];
if (!f) {
sprintf(VAR_4, "/tmp/out%d.pcm", VAR_0);
f = fopen(VAR_4, "w");
if (!f)
return;
VAR_3[VAR_0] = f;
}
if (VAR_0 == 0) {
int VAR_5;
static int VAR_6 = 0;
printf("VAR_6=%d\VAR_2", VAR_6);
for(VAR_5=0;VAR_5<VAR_2;VAR_5++) {
printf(" %f", (double)VAR_1[VAR_5] / 32768.0);
if ((VAR_5 % 18) == 17)
printf("\VAR_2");
}
VAR_6 += VAR_2;
}
fwrite(VAR_1, 1, VAR_2 * sizeof(INT32), f);
}
| [
"void FUNC_0(int VAR_0, INT32 *VAR_1, int VAR_2)\n{",
"static FILE *VAR_3[16], *f;",
"char VAR_4[512];",
"f = VAR_3[VAR_0];",
"if (!f) {",
"sprintf(VAR_4, \"/tmp/out%d.pcm\", VAR_0);",
"f = fopen(VAR_4, \"w\");",
"if (!f)\nreturn;",
"VAR_3[VAR_0] = f;",
"}",
"if (VAR_0 == 0) {",
"int VAR_5;",
"static int VAR_6 = 0;",
"printf(\"VAR_6=%d\\VAR_2\", VAR_6);",
"for(VAR_5=0;VAR_5<VAR_2;VAR_5++) {",
"printf(\" %f\", (double)VAR_1[VAR_5] / 32768.0);",
"if ((VAR_5 % 18) == 17)\nprintf(\"\\VAR_2\");",
"}",
"VAR_6 += VAR_2;",
"}",
"fwrite(VAR_1, 1, VAR_2 * sizeof(INT32), f);",
"}"
]
| [
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
1,
0,
0,
0,
1,
0,
0,
0,
0,
1,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19,
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41,
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
55
]
]
|
16,978 | static void mb_cpu_realizefn(DeviceState *dev, Error **errp)
{
MicroBlazeCPU *cpu = MICROBLAZE_CPU(dev);
MicroBlazeCPUClass *mcc = MICROBLAZE_CPU_GET_CLASS(dev);
cpu_reset(CPU(cpu));
mcc->parent_realize(dev, errp);
}
| true | qemu | 14a10fc39923b3af07c8c46d22cb20843bee3a72 | static void mb_cpu_realizefn(DeviceState *dev, Error **errp)
{
MicroBlazeCPU *cpu = MICROBLAZE_CPU(dev);
MicroBlazeCPUClass *mcc = MICROBLAZE_CPU_GET_CLASS(dev);
cpu_reset(CPU(cpu));
mcc->parent_realize(dev, errp);
}
| {
"code": [
" cpu_reset(CPU(cpu));",
" cpu_reset(CPU(cpu));",
" cpu_reset(CPU(cpu));",
" cpu_reset(CPU(cpu));",
" cpu_reset(CPU(cpu));",
" MicroBlazeCPU *cpu = MICROBLAZE_CPU(dev);",
" cpu_reset(CPU(cpu));",
" cpu_reset(CPU(cpu));",
" cpu_reset(CPU(cpu));",
" cpu_reset(CPU(cpu));",
" cpu_reset(CPU(cpu));",
" cpu_reset(CPU(cpu));"
],
"line_no": [
11,
11,
11,
11,
11,
5,
11,
11,
11,
11,
11,
11
]
} | static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)
{
MicroBlazeCPU *cpu = MICROBLAZE_CPU(VAR_0);
MicroBlazeCPUClass *mcc = MICROBLAZE_CPU_GET_CLASS(VAR_0);
cpu_reset(CPU(cpu));
mcc->parent_realize(VAR_0, VAR_1);
}
| [
"static void FUNC_0(DeviceState *VAR_0, Error **VAR_1)\n{",
"MicroBlazeCPU *cpu = MICROBLAZE_CPU(VAR_0);",
"MicroBlazeCPUClass *mcc = MICROBLAZE_CPU_GET_CLASS(VAR_0);",
"cpu_reset(CPU(cpu));",
"mcc->parent_realize(VAR_0, VAR_1);",
"}"
]
| [
0,
1,
0,
1,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
15
],
[
17
]
]
|
16,979 | static int dxva2_create_decoder(AVCodecContext *s)
{
InputStream *ist = s->opaque;
int loglevel = (ist->hwaccel_id == HWACCEL_AUTO) ? AV_LOG_VERBOSE : AV_LOG_ERROR;
DXVA2Context *ctx = ist->hwaccel_ctx;
struct dxva_context *dxva_ctx = s->hwaccel_context;
GUID *guid_list = NULL;
unsigned guid_count = 0, i, j;
GUID device_guid = GUID_NULL;
const D3DFORMAT surface_format = (s->sw_pix_fmt == AV_PIX_FMT_YUV420P10) ? MKTAG('P','0','1','0') : MKTAG('N','V','1','2');
D3DFORMAT target_format = 0;
DXVA2_VideoDesc desc = { 0 };
DXVA2_ConfigPictureDecode config;
HRESULT hr;
int surface_alignment, num_surfaces;
int ret;
AVDXVA2FramesContext *frames_hwctx;
AVHWFramesContext *frames_ctx;
hr = IDirectXVideoDecoderService_GetDecoderDeviceGuids(ctx->decoder_service, &guid_count, &guid_list);
if (FAILED(hr)) {
av_log(NULL, loglevel, "Failed to retrieve decoder device GUIDs\n");
goto fail;
}
for (i = 0; dxva2_modes[i].guid; i++) {
D3DFORMAT *target_list = NULL;
unsigned target_count = 0;
const dxva2_mode *mode = &dxva2_modes[i];
if (mode->codec != s->codec_id)
continue;
for (j = 0; j < guid_count; j++) {
if (IsEqualGUID(mode->guid, &guid_list[j]))
break;
}
if (j == guid_count)
continue;
hr = IDirectXVideoDecoderService_GetDecoderRenderTargets(ctx->decoder_service, mode->guid, &target_count, &target_list);
if (FAILED(hr)) {
continue;
}
for (j = 0; j < target_count; j++) {
const D3DFORMAT format = target_list[j];
if (format == surface_format) {
target_format = format;
break;
}
}
CoTaskMemFree(target_list);
if (target_format) {
device_guid = *mode->guid;
break;
}
}
CoTaskMemFree(guid_list);
if (IsEqualGUID(&device_guid, &GUID_NULL)) {
av_log(NULL, loglevel, "No decoder device for codec found\n");
goto fail;
}
desc.SampleWidth = s->coded_width;
desc.SampleHeight = s->coded_height;
desc.Format = target_format;
ret = dxva2_get_decoder_configuration(s, &device_guid, &desc, &config);
if (ret < 0) {
goto fail;
}
/* decoding MPEG-2 requires additional alignment on some Intel GPUs,
but it causes issues for H.264 on certain AMD GPUs..... */
if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO)
surface_alignment = 32;
/* the HEVC DXVA2 spec asks for 128 pixel aligned surfaces to ensure
all coding features have enough room to work with */
else if (s->codec_id == AV_CODEC_ID_HEVC)
surface_alignment = 128;
else
surface_alignment = 16;
/* 4 base work surfaces */
num_surfaces = 4;
/* add surfaces based on number of possible refs */
if (s->codec_id == AV_CODEC_ID_H264 || s->codec_id == AV_CODEC_ID_HEVC)
num_surfaces += 16;
else if (s->codec_id == AV_CODEC_ID_VP9)
num_surfaces += 8;
else
num_surfaces += 2;
/* add extra surfaces for frame threading */
if (s->active_thread_type & FF_THREAD_FRAME)
num_surfaces += s->thread_count;
ctx->hw_frames_ctx = av_hwframe_ctx_alloc(ctx->hw_device_ctx);
if (!ctx->hw_frames_ctx)
goto fail;
frames_ctx = (AVHWFramesContext*)ctx->hw_frames_ctx->data;
frames_hwctx = frames_ctx->hwctx;
frames_ctx->format = AV_PIX_FMT_DXVA2_VLD;
frames_ctx->sw_format = (target_format == MKTAG('P','0','1','0') ? AV_PIX_FMT_P010 : AV_PIX_FMT_NV12);
frames_ctx->width = FFALIGN(s->coded_width, surface_alignment);
frames_ctx->height = FFALIGN(s->coded_height, surface_alignment);
frames_ctx->initial_pool_size = num_surfaces;
frames_hwctx->surface_type = DXVA2_VideoDecoderRenderTarget;
ret = av_hwframe_ctx_init(ctx->hw_frames_ctx);
if (ret < 0) {
av_log(NULL, loglevel, "Failed to initialize the HW frames context\n");
goto fail;
}
hr = IDirectXVideoDecoderService_CreateVideoDecoder(ctx->decoder_service, &device_guid,
&desc, &config, frames_hwctx->surfaces,
frames_hwctx->nb_surfaces, &frames_hwctx->decoder_to_release);
if (FAILED(hr)) {
av_log(NULL, loglevel, "Failed to create DXVA2 video decoder\n");
goto fail;
}
ctx->decoder_guid = device_guid;
ctx->decoder_config = config;
dxva_ctx->cfg = &ctx->decoder_config;
dxva_ctx->decoder = frames_hwctx->decoder_to_release;
dxva_ctx->surface = frames_hwctx->surfaces;
dxva_ctx->surface_count = frames_hwctx->nb_surfaces;
if (IsEqualGUID(&ctx->decoder_guid, &DXVADDI_Intel_ModeH264_E))
dxva_ctx->workaround |= FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO;
return 0;
fail:
av_buffer_unref(&ctx->hw_frames_ctx);
return AVERROR(EINVAL);
}
| false | FFmpeg | 70143a3954e1c4412efb2bf1a3a818adea2d3abf | static int dxva2_create_decoder(AVCodecContext *s)
{
InputStream *ist = s->opaque;
int loglevel = (ist->hwaccel_id == HWACCEL_AUTO) ? AV_LOG_VERBOSE : AV_LOG_ERROR;
DXVA2Context *ctx = ist->hwaccel_ctx;
struct dxva_context *dxva_ctx = s->hwaccel_context;
GUID *guid_list = NULL;
unsigned guid_count = 0, i, j;
GUID device_guid = GUID_NULL;
const D3DFORMAT surface_format = (s->sw_pix_fmt == AV_PIX_FMT_YUV420P10) ? MKTAG('P','0','1','0') : MKTAG('N','V','1','2');
D3DFORMAT target_format = 0;
DXVA2_VideoDesc desc = { 0 };
DXVA2_ConfigPictureDecode config;
HRESULT hr;
int surface_alignment, num_surfaces;
int ret;
AVDXVA2FramesContext *frames_hwctx;
AVHWFramesContext *frames_ctx;
hr = IDirectXVideoDecoderService_GetDecoderDeviceGuids(ctx->decoder_service, &guid_count, &guid_list);
if (FAILED(hr)) {
av_log(NULL, loglevel, "Failed to retrieve decoder device GUIDs\n");
goto fail;
}
for (i = 0; dxva2_modes[i].guid; i++) {
D3DFORMAT *target_list = NULL;
unsigned target_count = 0;
const dxva2_mode *mode = &dxva2_modes[i];
if (mode->codec != s->codec_id)
continue;
for (j = 0; j < guid_count; j++) {
if (IsEqualGUID(mode->guid, &guid_list[j]))
break;
}
if (j == guid_count)
continue;
hr = IDirectXVideoDecoderService_GetDecoderRenderTargets(ctx->decoder_service, mode->guid, &target_count, &target_list);
if (FAILED(hr)) {
continue;
}
for (j = 0; j < target_count; j++) {
const D3DFORMAT format = target_list[j];
if (format == surface_format) {
target_format = format;
break;
}
}
CoTaskMemFree(target_list);
if (target_format) {
device_guid = *mode->guid;
break;
}
}
CoTaskMemFree(guid_list);
if (IsEqualGUID(&device_guid, &GUID_NULL)) {
av_log(NULL, loglevel, "No decoder device for codec found\n");
goto fail;
}
desc.SampleWidth = s->coded_width;
desc.SampleHeight = s->coded_height;
desc.Format = target_format;
ret = dxva2_get_decoder_configuration(s, &device_guid, &desc, &config);
if (ret < 0) {
goto fail;
}
if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO)
surface_alignment = 32;
else if (s->codec_id == AV_CODEC_ID_HEVC)
surface_alignment = 128;
else
surface_alignment = 16;
num_surfaces = 4;
if (s->codec_id == AV_CODEC_ID_H264 || s->codec_id == AV_CODEC_ID_HEVC)
num_surfaces += 16;
else if (s->codec_id == AV_CODEC_ID_VP9)
num_surfaces += 8;
else
num_surfaces += 2;
if (s->active_thread_type & FF_THREAD_FRAME)
num_surfaces += s->thread_count;
ctx->hw_frames_ctx = av_hwframe_ctx_alloc(ctx->hw_device_ctx);
if (!ctx->hw_frames_ctx)
goto fail;
frames_ctx = (AVHWFramesContext*)ctx->hw_frames_ctx->data;
frames_hwctx = frames_ctx->hwctx;
frames_ctx->format = AV_PIX_FMT_DXVA2_VLD;
frames_ctx->sw_format = (target_format == MKTAG('P','0','1','0') ? AV_PIX_FMT_P010 : AV_PIX_FMT_NV12);
frames_ctx->width = FFALIGN(s->coded_width, surface_alignment);
frames_ctx->height = FFALIGN(s->coded_height, surface_alignment);
frames_ctx->initial_pool_size = num_surfaces;
frames_hwctx->surface_type = DXVA2_VideoDecoderRenderTarget;
ret = av_hwframe_ctx_init(ctx->hw_frames_ctx);
if (ret < 0) {
av_log(NULL, loglevel, "Failed to initialize the HW frames context\n");
goto fail;
}
hr = IDirectXVideoDecoderService_CreateVideoDecoder(ctx->decoder_service, &device_guid,
&desc, &config, frames_hwctx->surfaces,
frames_hwctx->nb_surfaces, &frames_hwctx->decoder_to_release);
if (FAILED(hr)) {
av_log(NULL, loglevel, "Failed to create DXVA2 video decoder\n");
goto fail;
}
ctx->decoder_guid = device_guid;
ctx->decoder_config = config;
dxva_ctx->cfg = &ctx->decoder_config;
dxva_ctx->decoder = frames_hwctx->decoder_to_release;
dxva_ctx->surface = frames_hwctx->surfaces;
dxva_ctx->surface_count = frames_hwctx->nb_surfaces;
if (IsEqualGUID(&ctx->decoder_guid, &DXVADDI_Intel_ModeH264_E))
dxva_ctx->workaround |= FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO;
return 0;
fail:
av_buffer_unref(&ctx->hw_frames_ctx);
return AVERROR(EINVAL);
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0)
{
InputStream *ist = VAR_0->opaque;
int VAR_1 = (ist->hwaccel_id == HWACCEL_AUTO) ? AV_LOG_VERBOSE : AV_LOG_ERROR;
DXVA2Context *ctx = ist->hwaccel_ctx;
struct dxva_context *VAR_2 = VAR_0->hwaccel_context;
GUID *guid_list = NULL;
unsigned VAR_3 = 0, VAR_4, VAR_5;
GUID device_guid = GUID_NULL;
const D3DFORMAT VAR_6 = (VAR_0->sw_pix_fmt == AV_PIX_FMT_YUV420P10) ? MKTAG('P','0','1','0') : MKTAG('N','V','1','2');
D3DFORMAT target_format = 0;
DXVA2_VideoDesc desc = { 0 };
DXVA2_ConfigPictureDecode config;
HRESULT hr;
int VAR_7, VAR_8;
int VAR_9;
AVDXVA2FramesContext *frames_hwctx;
AVHWFramesContext *frames_ctx;
hr = IDirectXVideoDecoderService_GetDecoderDeviceGuids(ctx->decoder_service, &VAR_3, &guid_list);
if (FAILED(hr)) {
av_log(NULL, VAR_1, "Failed to retrieve decoder device GUIDs\n");
goto fail;
}
for (VAR_4 = 0; dxva2_modes[VAR_4].guid; VAR_4++) {
D3DFORMAT *target_list = NULL;
unsigned target_count = 0;
const dxva2_mode *mode = &dxva2_modes[VAR_4];
if (mode->codec != VAR_0->codec_id)
continue;
for (VAR_5 = 0; VAR_5 < VAR_3; VAR_5++) {
if (IsEqualGUID(mode->guid, &guid_list[VAR_5]))
break;
}
if (VAR_5 == VAR_3)
continue;
hr = IDirectXVideoDecoderService_GetDecoderRenderTargets(ctx->decoder_service, mode->guid, &target_count, &target_list);
if (FAILED(hr)) {
continue;
}
for (VAR_5 = 0; VAR_5 < target_count; VAR_5++) {
const D3DFORMAT format = target_list[VAR_5];
if (format == VAR_6) {
target_format = format;
break;
}
}
CoTaskMemFree(target_list);
if (target_format) {
device_guid = *mode->guid;
break;
}
}
CoTaskMemFree(guid_list);
if (IsEqualGUID(&device_guid, &GUID_NULL)) {
av_log(NULL, VAR_1, "No decoder device for codec found\n");
goto fail;
}
desc.SampleWidth = VAR_0->coded_width;
desc.SampleHeight = VAR_0->coded_height;
desc.Format = target_format;
VAR_9 = dxva2_get_decoder_configuration(VAR_0, &device_guid, &desc, &config);
if (VAR_9 < 0) {
goto fail;
}
if (VAR_0->codec_id == AV_CODEC_ID_MPEG2VIDEO)
VAR_7 = 32;
else if (VAR_0->codec_id == AV_CODEC_ID_HEVC)
VAR_7 = 128;
else
VAR_7 = 16;
VAR_8 = 4;
if (VAR_0->codec_id == AV_CODEC_ID_H264 || VAR_0->codec_id == AV_CODEC_ID_HEVC)
VAR_8 += 16;
else if (VAR_0->codec_id == AV_CODEC_ID_VP9)
VAR_8 += 8;
else
VAR_8 += 2;
if (VAR_0->active_thread_type & FF_THREAD_FRAME)
VAR_8 += VAR_0->thread_count;
ctx->hw_frames_ctx = av_hwframe_ctx_alloc(ctx->hw_device_ctx);
if (!ctx->hw_frames_ctx)
goto fail;
frames_ctx = (AVHWFramesContext*)ctx->hw_frames_ctx->data;
frames_hwctx = frames_ctx->hwctx;
frames_ctx->format = AV_PIX_FMT_DXVA2_VLD;
frames_ctx->sw_format = (target_format == MKTAG('P','0','1','0') ? AV_PIX_FMT_P010 : AV_PIX_FMT_NV12);
frames_ctx->width = FFALIGN(VAR_0->coded_width, VAR_7);
frames_ctx->height = FFALIGN(VAR_0->coded_height, VAR_7);
frames_ctx->initial_pool_size = VAR_8;
frames_hwctx->surface_type = DXVA2_VideoDecoderRenderTarget;
VAR_9 = av_hwframe_ctx_init(ctx->hw_frames_ctx);
if (VAR_9 < 0) {
av_log(NULL, VAR_1, "Failed to initialize the HW frames context\n");
goto fail;
}
hr = IDirectXVideoDecoderService_CreateVideoDecoder(ctx->decoder_service, &device_guid,
&desc, &config, frames_hwctx->surfaces,
frames_hwctx->nb_surfaces, &frames_hwctx->decoder_to_release);
if (FAILED(hr)) {
av_log(NULL, VAR_1, "Failed to create DXVA2 video decoder\n");
goto fail;
}
ctx->decoder_guid = device_guid;
ctx->decoder_config = config;
VAR_2->cfg = &ctx->decoder_config;
VAR_2->decoder = frames_hwctx->decoder_to_release;
VAR_2->surface = frames_hwctx->surfaces;
VAR_2->surface_count = frames_hwctx->nb_surfaces;
if (IsEqualGUID(&ctx->decoder_guid, &DXVADDI_Intel_ModeH264_E))
VAR_2->workaround |= FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO;
return 0;
fail:
av_buffer_unref(&ctx->hw_frames_ctx);
return AVERROR(EINVAL);
}
| [
"static int FUNC_0(AVCodecContext *VAR_0)\n{",
"InputStream *ist = VAR_0->opaque;",
"int VAR_1 = (ist->hwaccel_id == HWACCEL_AUTO) ? AV_LOG_VERBOSE : AV_LOG_ERROR;",
"DXVA2Context *ctx = ist->hwaccel_ctx;",
"struct dxva_context *VAR_2 = VAR_0->hwaccel_context;",
"GUID *guid_list = NULL;",
"unsigned VAR_3 = 0, VAR_4, VAR_5;",
"GUID device_guid = GUID_NULL;",
"const D3DFORMAT VAR_6 = (VAR_0->sw_pix_fmt == AV_PIX_FMT_YUV420P10) ? MKTAG('P','0','1','0') : MKTAG('N','V','1','2');",
"D3DFORMAT target_format = 0;",
"DXVA2_VideoDesc desc = { 0 };",
"DXVA2_ConfigPictureDecode config;",
"HRESULT hr;",
"int VAR_7, VAR_8;",
"int VAR_9;",
"AVDXVA2FramesContext *frames_hwctx;",
"AVHWFramesContext *frames_ctx;",
"hr = IDirectXVideoDecoderService_GetDecoderDeviceGuids(ctx->decoder_service, &VAR_3, &guid_list);",
"if (FAILED(hr)) {",
"av_log(NULL, VAR_1, \"Failed to retrieve decoder device GUIDs\\n\");",
"goto fail;",
"}",
"for (VAR_4 = 0; dxva2_modes[VAR_4].guid; VAR_4++) {",
"D3DFORMAT *target_list = NULL;",
"unsigned target_count = 0;",
"const dxva2_mode *mode = &dxva2_modes[VAR_4];",
"if (mode->codec != VAR_0->codec_id)\ncontinue;",
"for (VAR_5 = 0; VAR_5 < VAR_3; VAR_5++) {",
"if (IsEqualGUID(mode->guid, &guid_list[VAR_5]))\nbreak;",
"}",
"if (VAR_5 == VAR_3)\ncontinue;",
"hr = IDirectXVideoDecoderService_GetDecoderRenderTargets(ctx->decoder_service, mode->guid, &target_count, &target_list);",
"if (FAILED(hr)) {",
"continue;",
"}",
"for (VAR_5 = 0; VAR_5 < target_count; VAR_5++) {",
"const D3DFORMAT format = target_list[VAR_5];",
"if (format == VAR_6) {",
"target_format = format;",
"break;",
"}",
"}",
"CoTaskMemFree(target_list);",
"if (target_format) {",
"device_guid = *mode->guid;",
"break;",
"}",
"}",
"CoTaskMemFree(guid_list);",
"if (IsEqualGUID(&device_guid, &GUID_NULL)) {",
"av_log(NULL, VAR_1, \"No decoder device for codec found\\n\");",
"goto fail;",
"}",
"desc.SampleWidth = VAR_0->coded_width;",
"desc.SampleHeight = VAR_0->coded_height;",
"desc.Format = target_format;",
"VAR_9 = dxva2_get_decoder_configuration(VAR_0, &device_guid, &desc, &config);",
"if (VAR_9 < 0) {",
"goto fail;",
"}",
"if (VAR_0->codec_id == AV_CODEC_ID_MPEG2VIDEO)\nVAR_7 = 32;",
"else if (VAR_0->codec_id == AV_CODEC_ID_HEVC)\nVAR_7 = 128;",
"else\nVAR_7 = 16;",
"VAR_8 = 4;",
"if (VAR_0->codec_id == AV_CODEC_ID_H264 || VAR_0->codec_id == AV_CODEC_ID_HEVC)\nVAR_8 += 16;",
"else if (VAR_0->codec_id == AV_CODEC_ID_VP9)\nVAR_8 += 8;",
"else\nVAR_8 += 2;",
"if (VAR_0->active_thread_type & FF_THREAD_FRAME)\nVAR_8 += VAR_0->thread_count;",
"ctx->hw_frames_ctx = av_hwframe_ctx_alloc(ctx->hw_device_ctx);",
"if (!ctx->hw_frames_ctx)\ngoto fail;",
"frames_ctx = (AVHWFramesContext*)ctx->hw_frames_ctx->data;",
"frames_hwctx = frames_ctx->hwctx;",
"frames_ctx->format = AV_PIX_FMT_DXVA2_VLD;",
"frames_ctx->sw_format = (target_format == MKTAG('P','0','1','0') ? AV_PIX_FMT_P010 : AV_PIX_FMT_NV12);",
"frames_ctx->width = FFALIGN(VAR_0->coded_width, VAR_7);",
"frames_ctx->height = FFALIGN(VAR_0->coded_height, VAR_7);",
"frames_ctx->initial_pool_size = VAR_8;",
"frames_hwctx->surface_type = DXVA2_VideoDecoderRenderTarget;",
"VAR_9 = av_hwframe_ctx_init(ctx->hw_frames_ctx);",
"if (VAR_9 < 0) {",
"av_log(NULL, VAR_1, \"Failed to initialize the HW frames context\\n\");",
"goto fail;",
"}",
"hr = IDirectXVideoDecoderService_CreateVideoDecoder(ctx->decoder_service, &device_guid,\n&desc, &config, frames_hwctx->surfaces,\nframes_hwctx->nb_surfaces, &frames_hwctx->decoder_to_release);",
"if (FAILED(hr)) {",
"av_log(NULL, VAR_1, \"Failed to create DXVA2 video decoder\\n\");",
"goto fail;",
"}",
"ctx->decoder_guid = device_guid;",
"ctx->decoder_config = config;",
"VAR_2->cfg = &ctx->decoder_config;",
"VAR_2->decoder = frames_hwctx->decoder_to_release;",
"VAR_2->surface = frames_hwctx->surfaces;",
"VAR_2->surface_count = frames_hwctx->nb_surfaces;",
"if (IsEqualGUID(&ctx->decoder_guid, &DXVADDI_Intel_ModeH264_E))\nVAR_2->workaround |= FF_DXVA2_WORKAROUND_INTEL_CLEARVIDEO;",
"return 0;",
"fail:\nav_buffer_unref(&ctx->hw_frames_ctx);",
"return AVERROR(EINVAL);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61,
63
],
[
67
],
[
69,
71
],
[
73
],
[
75,
77
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
119
],
[
121
],
[
123
],
[
125
],
[
129
],
[
131
],
[
133
],
[
137
],
[
139
],
[
141
],
[
143
],
[
151,
153
],
[
159,
161
],
[
163,
165
],
[
171
],
[
177,
179
],
[
181,
183
],
[
185,
187
],
[
193,
195
],
[
199
],
[
201,
203
],
[
205
],
[
207
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
223
],
[
227
],
[
229
],
[
231
],
[
233
],
[
235
],
[
239,
241,
243
],
[
245
],
[
247
],
[
249
],
[
251
],
[
255
],
[
257
],
[
261
],
[
263
],
[
265
],
[
267
],
[
271,
273
],
[
277
],
[
279,
281
],
[
283
],
[
285
]
]
|
16,980 | const uint8_t *ff_h263_find_resync_marker(MpegEncContext *s, const uint8_t *av_restrict p, const uint8_t *av_restrict end)
{
av_assert2(p < end);
end-=2;
p++;
if(s->resync_marker){
for(;p<end; p+=2){
if(!*p){
if (!p[-1] && p[1]) return p - 1;
else if(!p[ 1] && p[2]) return p;
}
}
}
return end+2;
}
| false | FFmpeg | 8d2e0e2c7058a3eaf7f45d740be6e93972bbfd68 | const uint8_t *ff_h263_find_resync_marker(MpegEncContext *s, const uint8_t *av_restrict p, const uint8_t *av_restrict end)
{
av_assert2(p < end);
end-=2;
p++;
if(s->resync_marker){
for(;p<end; p+=2){
if(!*p){
if (!p[-1] && p[1]) return p - 1;
else if(!p[ 1] && p[2]) return p;
}
}
}
return end+2;
}
| {
"code": [],
"line_no": []
} | const uint8_t *FUNC_0(MpegEncContext *s, const uint8_t *av_restrict p, const uint8_t *av_restrict end)
{
av_assert2(p < end);
end-=2;
p++;
if(s->resync_marker){
for(;p<end; p+=2){
if(!*p){
if (!p[-1] && p[1]) return p - 1;
else if(!p[ 1] && p[2]) return p;
}
}
}
return end+2;
}
| [
"const uint8_t *FUNC_0(MpegEncContext *s, const uint8_t *av_restrict p, const uint8_t *av_restrict end)\n{",
"av_assert2(p < end);",
"end-=2;",
"p++;",
"if(s->resync_marker){",
"for(;p<end; p+=2){",
"if(!*p){",
"if (!p[-1] && p[1]) return p - 1;",
"else if(!p[ 1] && p[2]) return p;",
"}",
"}",
"}",
"return end+2;",
"}"
]
| [
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
]
]
|
16,982 | static int start_ebml_master_crc32(AVIOContext *pb, AVIOContext **dyn_cp, ebml_master *master,
unsigned int elementid, uint64_t expectedsize)
{
int ret;
if ((ret = avio_open_dyn_buf(dyn_cp)) < 0)
return ret;
if (pb->seekable)
*master = start_ebml_master(pb, elementid, expectedsize);
else
*master = start_ebml_master(*dyn_cp, elementid, expectedsize);
return 0;
}
| false | FFmpeg | eabbc64728c2fdb74f565aededec2ab023d20699 | static int start_ebml_master_crc32(AVIOContext *pb, AVIOContext **dyn_cp, ebml_master *master,
unsigned int elementid, uint64_t expectedsize)
{
int ret;
if ((ret = avio_open_dyn_buf(dyn_cp)) < 0)
return ret;
if (pb->seekable)
*master = start_ebml_master(pb, elementid, expectedsize);
else
*master = start_ebml_master(*dyn_cp, elementid, expectedsize);
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(AVIOContext *VAR_0, AVIOContext **VAR_1, ebml_master *VAR_2,
unsigned int VAR_3, uint64_t VAR_4)
{
int VAR_5;
if ((VAR_5 = avio_open_dyn_buf(VAR_1)) < 0)
return VAR_5;
if (VAR_0->seekable)
*VAR_2 = start_ebml_master(VAR_0, VAR_3, VAR_4);
else
*VAR_2 = start_ebml_master(*VAR_1, VAR_3, VAR_4);
return 0;
}
| [
"static int FUNC_0(AVIOContext *VAR_0, AVIOContext **VAR_1, ebml_master *VAR_2,\nunsigned int VAR_3, uint64_t VAR_4)\n{",
"int VAR_5;",
"if ((VAR_5 = avio_open_dyn_buf(VAR_1)) < 0)\nreturn VAR_5;",
"if (VAR_0->seekable)\n*VAR_2 = start_ebml_master(VAR_0, VAR_3, VAR_4);",
"else\n*VAR_2 = start_ebml_master(*VAR_1, VAR_3, VAR_4);",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
11,
13
],
[
17,
19
],
[
21,
23
],
[
27
],
[
29
]
]
|
16,983 | static int decode_pic_hdr(IVI45DecContext *ctx, AVCodecContext *avctx)
{
int pic_size_indx, i, p;
IVIPicConfig pic_conf;
if (get_bits(&ctx->gb, 18) != 0x3FFF8) {
av_log(avctx, AV_LOG_ERROR, "Invalid picture start code!\n");
return AVERROR_INVALIDDATA;
}
ctx->prev_frame_type = ctx->frame_type;
ctx->frame_type = get_bits(&ctx->gb, 3);
if (ctx->frame_type == 7) {
av_log(avctx, AV_LOG_ERROR, "Invalid frame type: %d\n", ctx->frame_type);
return AVERROR_INVALIDDATA;
}
if (ctx->frame_type == IVI4_FRAMETYPE_BIDIR)
ctx->has_b_frames = 1;
ctx->transp_status = get_bits1(&ctx->gb);
if (ctx->transp_status) {
ctx->has_transp = 1;
}
/* unknown bit: Mac decoder ignores this bit, XANIM returns error */
if (get_bits1(&ctx->gb)) {
av_log(avctx, AV_LOG_ERROR, "Sync bit is set!\n");
return AVERROR_INVALIDDATA;
}
ctx->data_size = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 24) : 0;
/* null frames don't contain anything else so we just return */
if (ctx->frame_type >= IVI4_FRAMETYPE_NULL_FIRST) {
ff_dlog(avctx, "Null frame encountered!\n");
return 0;
}
/* Check key lock status. If enabled - ignore lock word. */
/* Usually we have to prompt the user for the password, but */
/* we don't do that because Indeo 4 videos can be decoded anyway */
if (get_bits1(&ctx->gb)) {
skip_bits_long(&ctx->gb, 32);
ff_dlog(avctx, "Password-protected clip!\n");
}
pic_size_indx = get_bits(&ctx->gb, 3);
if (pic_size_indx == IVI4_PIC_SIZE_ESC) {
pic_conf.pic_height = get_bits(&ctx->gb, 16);
pic_conf.pic_width = get_bits(&ctx->gb, 16);
} else {
pic_conf.pic_height = ivi4_common_pic_sizes[pic_size_indx * 2 + 1];
pic_conf.pic_width = ivi4_common_pic_sizes[pic_size_indx * 2 ];
}
/* Decode tile dimensions. */
if (get_bits1(&ctx->gb)) {
pic_conf.tile_height = scale_tile_size(pic_conf.pic_height, get_bits(&ctx->gb, 4));
pic_conf.tile_width = scale_tile_size(pic_conf.pic_width, get_bits(&ctx->gb, 4));
ctx->uses_tiling = 1;
} else {
pic_conf.tile_height = pic_conf.pic_height;
pic_conf.tile_width = pic_conf.pic_width;
}
/* Decode chroma subsampling. We support only 4:4 aka YVU9. */
if (get_bits(&ctx->gb, 2)) {
av_log(avctx, AV_LOG_ERROR, "Only YVU9 picture format is supported!\n");
return AVERROR_INVALIDDATA;
}
pic_conf.chroma_height = (pic_conf.pic_height + 3) >> 2;
pic_conf.chroma_width = (pic_conf.pic_width + 3) >> 2;
/* decode subdivision of the planes */
pic_conf.luma_bands = decode_plane_subdivision(&ctx->gb);
if (pic_conf.luma_bands)
pic_conf.chroma_bands = decode_plane_subdivision(&ctx->gb);
ctx->is_scalable = pic_conf.luma_bands != 1 || pic_conf.chroma_bands != 1;
if (ctx->is_scalable && (pic_conf.luma_bands != 4 || pic_conf.chroma_bands != 1)) {
av_log(avctx, AV_LOG_ERROR, "Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d\n",
pic_conf.luma_bands, pic_conf.chroma_bands);
return AVERROR_INVALIDDATA;
}
/* check if picture layout was changed and reallocate buffers */
if (ivi_pic_config_cmp(&pic_conf, &ctx->pic_conf)) {
if (ff_ivi_init_planes(ctx->planes, &pic_conf, 1)) {
av_log(avctx, AV_LOG_ERROR, "Couldn't reallocate color planes!\n");
ctx->pic_conf.luma_bands = 0;
return AVERROR(ENOMEM);
}
ctx->pic_conf = pic_conf;
/* set default macroblock/block dimensions */
for (p = 0; p <= 2; p++) {
for (i = 0; i < (!p ? pic_conf.luma_bands : pic_conf.chroma_bands); i++) {
ctx->planes[p].bands[i].mb_size = !p ? (!ctx->is_scalable ? 16 : 8) : 4;
ctx->planes[p].bands[i].blk_size = !p ? 8 : 4;
}
}
if (ff_ivi_init_tiles(ctx->planes, ctx->pic_conf.tile_width,
ctx->pic_conf.tile_height)) {
av_log(avctx, AV_LOG_ERROR,
"Couldn't reallocate internal structures!\n");
return AVERROR(ENOMEM);
}
}
ctx->frame_num = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 20) : 0;
/* skip decTimeEst field if present */
if (get_bits1(&ctx->gb))
skip_bits(&ctx->gb, 8);
/* decode macroblock and block huffman codebooks */
if (ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_MB_HUFF, &ctx->mb_vlc, avctx) ||
ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_BLK_HUFF, &ctx->blk_vlc, avctx))
return AVERROR_INVALIDDATA;
ctx->rvmap_sel = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 8;
ctx->in_imf = get_bits1(&ctx->gb);
ctx->in_q = get_bits1(&ctx->gb);
ctx->pic_glob_quant = get_bits(&ctx->gb, 5);
/* TODO: ignore this parameter if unused */
ctx->unknown1 = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 0;
ctx->checksum = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 16) : 0;
/* skip picture header extension if any */
while (get_bits1(&ctx->gb)) {
ff_dlog(avctx, "Pic hdr extension encountered!\n");
skip_bits(&ctx->gb, 8);
}
if (get_bits1(&ctx->gb)) {
av_log(avctx, AV_LOG_ERROR, "Bad blocks bits encountered!\n");
}
align_get_bits(&ctx->gb);
return 0;
}
| false | FFmpeg | 64250d94b74d3fd47cc8b1611f48daf6a6ed804a | static int decode_pic_hdr(IVI45DecContext *ctx, AVCodecContext *avctx)
{
int pic_size_indx, i, p;
IVIPicConfig pic_conf;
if (get_bits(&ctx->gb, 18) != 0x3FFF8) {
av_log(avctx, AV_LOG_ERROR, "Invalid picture start code!\n");
return AVERROR_INVALIDDATA;
}
ctx->prev_frame_type = ctx->frame_type;
ctx->frame_type = get_bits(&ctx->gb, 3);
if (ctx->frame_type == 7) {
av_log(avctx, AV_LOG_ERROR, "Invalid frame type: %d\n", ctx->frame_type);
return AVERROR_INVALIDDATA;
}
if (ctx->frame_type == IVI4_FRAMETYPE_BIDIR)
ctx->has_b_frames = 1;
ctx->transp_status = get_bits1(&ctx->gb);
if (ctx->transp_status) {
ctx->has_transp = 1;
}
if (get_bits1(&ctx->gb)) {
av_log(avctx, AV_LOG_ERROR, "Sync bit is set!\n");
return AVERROR_INVALIDDATA;
}
ctx->data_size = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 24) : 0;
if (ctx->frame_type >= IVI4_FRAMETYPE_NULL_FIRST) {
ff_dlog(avctx, "Null frame encountered!\n");
return 0;
}
if (get_bits1(&ctx->gb)) {
skip_bits_long(&ctx->gb, 32);
ff_dlog(avctx, "Password-protected clip!\n");
}
pic_size_indx = get_bits(&ctx->gb, 3);
if (pic_size_indx == IVI4_PIC_SIZE_ESC) {
pic_conf.pic_height = get_bits(&ctx->gb, 16);
pic_conf.pic_width = get_bits(&ctx->gb, 16);
} else {
pic_conf.pic_height = ivi4_common_pic_sizes[pic_size_indx * 2 + 1];
pic_conf.pic_width = ivi4_common_pic_sizes[pic_size_indx * 2 ];
}
if (get_bits1(&ctx->gb)) {
pic_conf.tile_height = scale_tile_size(pic_conf.pic_height, get_bits(&ctx->gb, 4));
pic_conf.tile_width = scale_tile_size(pic_conf.pic_width, get_bits(&ctx->gb, 4));
ctx->uses_tiling = 1;
} else {
pic_conf.tile_height = pic_conf.pic_height;
pic_conf.tile_width = pic_conf.pic_width;
}
if (get_bits(&ctx->gb, 2)) {
av_log(avctx, AV_LOG_ERROR, "Only YVU9 picture format is supported!\n");
return AVERROR_INVALIDDATA;
}
pic_conf.chroma_height = (pic_conf.pic_height + 3) >> 2;
pic_conf.chroma_width = (pic_conf.pic_width + 3) >> 2;
pic_conf.luma_bands = decode_plane_subdivision(&ctx->gb);
if (pic_conf.luma_bands)
pic_conf.chroma_bands = decode_plane_subdivision(&ctx->gb);
ctx->is_scalable = pic_conf.luma_bands != 1 || pic_conf.chroma_bands != 1;
if (ctx->is_scalable && (pic_conf.luma_bands != 4 || pic_conf.chroma_bands != 1)) {
av_log(avctx, AV_LOG_ERROR, "Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d\n",
pic_conf.luma_bands, pic_conf.chroma_bands);
return AVERROR_INVALIDDATA;
}
if (ivi_pic_config_cmp(&pic_conf, &ctx->pic_conf)) {
if (ff_ivi_init_planes(ctx->planes, &pic_conf, 1)) {
av_log(avctx, AV_LOG_ERROR, "Couldn't reallocate color planes!\n");
ctx->pic_conf.luma_bands = 0;
return AVERROR(ENOMEM);
}
ctx->pic_conf = pic_conf;
for (p = 0; p <= 2; p++) {
for (i = 0; i < (!p ? pic_conf.luma_bands : pic_conf.chroma_bands); i++) {
ctx->planes[p].bands[i].mb_size = !p ? (!ctx->is_scalable ? 16 : 8) : 4;
ctx->planes[p].bands[i].blk_size = !p ? 8 : 4;
}
}
if (ff_ivi_init_tiles(ctx->planes, ctx->pic_conf.tile_width,
ctx->pic_conf.tile_height)) {
av_log(avctx, AV_LOG_ERROR,
"Couldn't reallocate internal structures!\n");
return AVERROR(ENOMEM);
}
}
ctx->frame_num = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 20) : 0;
if (get_bits1(&ctx->gb))
skip_bits(&ctx->gb, 8);
if (ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_MB_HUFF, &ctx->mb_vlc, avctx) ||
ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_BLK_HUFF, &ctx->blk_vlc, avctx))
return AVERROR_INVALIDDATA;
ctx->rvmap_sel = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 8;
ctx->in_imf = get_bits1(&ctx->gb);
ctx->in_q = get_bits1(&ctx->gb);
ctx->pic_glob_quant = get_bits(&ctx->gb, 5);
ctx->unknown1 = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 0;
ctx->checksum = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 16) : 0;
while (get_bits1(&ctx->gb)) {
ff_dlog(avctx, "Pic hdr extension encountered!\n");
skip_bits(&ctx->gb, 8);
}
if (get_bits1(&ctx->gb)) {
av_log(avctx, AV_LOG_ERROR, "Bad blocks bits encountered!\n");
}
align_get_bits(&ctx->gb);
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(IVI45DecContext *VAR_0, AVCodecContext *VAR_1)
{
int VAR_2, VAR_3, VAR_4;
IVIPicConfig pic_conf;
if (get_bits(&VAR_0->gb, 18) != 0x3FFF8) {
av_log(VAR_1, AV_LOG_ERROR, "Invalid picture start code!\n");
return AVERROR_INVALIDDATA;
}
VAR_0->prev_frame_type = VAR_0->frame_type;
VAR_0->frame_type = get_bits(&VAR_0->gb, 3);
if (VAR_0->frame_type == 7) {
av_log(VAR_1, AV_LOG_ERROR, "Invalid frame type: %d\n", VAR_0->frame_type);
return AVERROR_INVALIDDATA;
}
if (VAR_0->frame_type == IVI4_FRAMETYPE_BIDIR)
VAR_0->has_b_frames = 1;
VAR_0->transp_status = get_bits1(&VAR_0->gb);
if (VAR_0->transp_status) {
VAR_0->has_transp = 1;
}
if (get_bits1(&VAR_0->gb)) {
av_log(VAR_1, AV_LOG_ERROR, "Sync bit is set!\n");
return AVERROR_INVALIDDATA;
}
VAR_0->data_size = get_bits1(&VAR_0->gb) ? get_bits(&VAR_0->gb, 24) : 0;
if (VAR_0->frame_type >= IVI4_FRAMETYPE_NULL_FIRST) {
ff_dlog(VAR_1, "Null frame encountered!\n");
return 0;
}
if (get_bits1(&VAR_0->gb)) {
skip_bits_long(&VAR_0->gb, 32);
ff_dlog(VAR_1, "Password-protected clip!\n");
}
VAR_2 = get_bits(&VAR_0->gb, 3);
if (VAR_2 == IVI4_PIC_SIZE_ESC) {
pic_conf.pic_height = get_bits(&VAR_0->gb, 16);
pic_conf.pic_width = get_bits(&VAR_0->gb, 16);
} else {
pic_conf.pic_height = ivi4_common_pic_sizes[VAR_2 * 2 + 1];
pic_conf.pic_width = ivi4_common_pic_sizes[VAR_2 * 2 ];
}
if (get_bits1(&VAR_0->gb)) {
pic_conf.tile_height = scale_tile_size(pic_conf.pic_height, get_bits(&VAR_0->gb, 4));
pic_conf.tile_width = scale_tile_size(pic_conf.pic_width, get_bits(&VAR_0->gb, 4));
VAR_0->uses_tiling = 1;
} else {
pic_conf.tile_height = pic_conf.pic_height;
pic_conf.tile_width = pic_conf.pic_width;
}
if (get_bits(&VAR_0->gb, 2)) {
av_log(VAR_1, AV_LOG_ERROR, "Only YVU9 picture format is supported!\n");
return AVERROR_INVALIDDATA;
}
pic_conf.chroma_height = (pic_conf.pic_height + 3) >> 2;
pic_conf.chroma_width = (pic_conf.pic_width + 3) >> 2;
pic_conf.luma_bands = decode_plane_subdivision(&VAR_0->gb);
if (pic_conf.luma_bands)
pic_conf.chroma_bands = decode_plane_subdivision(&VAR_0->gb);
VAR_0->is_scalable = pic_conf.luma_bands != 1 || pic_conf.chroma_bands != 1;
if (VAR_0->is_scalable && (pic_conf.luma_bands != 4 || pic_conf.chroma_bands != 1)) {
av_log(VAR_1, AV_LOG_ERROR, "Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d\n",
pic_conf.luma_bands, pic_conf.chroma_bands);
return AVERROR_INVALIDDATA;
}
if (ivi_pic_config_cmp(&pic_conf, &VAR_0->pic_conf)) {
if (ff_ivi_init_planes(VAR_0->planes, &pic_conf, 1)) {
av_log(VAR_1, AV_LOG_ERROR, "Couldn't reallocate color planes!\n");
VAR_0->pic_conf.luma_bands = 0;
return AVERROR(ENOMEM);
}
VAR_0->pic_conf = pic_conf;
for (VAR_4 = 0; VAR_4 <= 2; VAR_4++) {
for (VAR_3 = 0; VAR_3 < (!VAR_4 ? pic_conf.luma_bands : pic_conf.chroma_bands); VAR_3++) {
VAR_0->planes[VAR_4].bands[VAR_3].mb_size = !VAR_4 ? (!VAR_0->is_scalable ? 16 : 8) : 4;
VAR_0->planes[VAR_4].bands[VAR_3].blk_size = !VAR_4 ? 8 : 4;
}
}
if (ff_ivi_init_tiles(VAR_0->planes, VAR_0->pic_conf.tile_width,
VAR_0->pic_conf.tile_height)) {
av_log(VAR_1, AV_LOG_ERROR,
"Couldn't reallocate internal structures!\n");
return AVERROR(ENOMEM);
}
}
VAR_0->frame_num = get_bits1(&VAR_0->gb) ? get_bits(&VAR_0->gb, 20) : 0;
if (get_bits1(&VAR_0->gb))
skip_bits(&VAR_0->gb, 8);
if (ff_ivi_dec_huff_desc(&VAR_0->gb, get_bits1(&VAR_0->gb), IVI_MB_HUFF, &VAR_0->mb_vlc, VAR_1) ||
ff_ivi_dec_huff_desc(&VAR_0->gb, get_bits1(&VAR_0->gb), IVI_BLK_HUFF, &VAR_0->blk_vlc, VAR_1))
return AVERROR_INVALIDDATA;
VAR_0->rvmap_sel = get_bits1(&VAR_0->gb) ? get_bits(&VAR_0->gb, 3) : 8;
VAR_0->in_imf = get_bits1(&VAR_0->gb);
VAR_0->in_q = get_bits1(&VAR_0->gb);
VAR_0->pic_glob_quant = get_bits(&VAR_0->gb, 5);
VAR_0->unknown1 = get_bits1(&VAR_0->gb) ? get_bits(&VAR_0->gb, 3) : 0;
VAR_0->checksum = get_bits1(&VAR_0->gb) ? get_bits(&VAR_0->gb, 16) : 0;
while (get_bits1(&VAR_0->gb)) {
ff_dlog(VAR_1, "Pic hdr extension encountered!\n");
skip_bits(&VAR_0->gb, 8);
}
if (get_bits1(&VAR_0->gb)) {
av_log(VAR_1, AV_LOG_ERROR, "Bad blocks bits encountered!\n");
}
align_get_bits(&VAR_0->gb);
return 0;
}
| [
"static int FUNC_0(IVI45DecContext *VAR_0, AVCodecContext *VAR_1)\n{",
"int VAR_2, VAR_3, VAR_4;",
"IVIPicConfig pic_conf;",
"if (get_bits(&VAR_0->gb, 18) != 0x3FFF8) {",
"av_log(VAR_1, AV_LOG_ERROR, \"Invalid picture start code!\\n\");",
"return AVERROR_INVALIDDATA;",
"}",
"VAR_0->prev_frame_type = VAR_0->frame_type;",
"VAR_0->frame_type = get_bits(&VAR_0->gb, 3);",
"if (VAR_0->frame_type == 7) {",
"av_log(VAR_1, AV_LOG_ERROR, \"Invalid frame type: %d\\n\", VAR_0->frame_type);",
"return AVERROR_INVALIDDATA;",
"}",
"if (VAR_0->frame_type == IVI4_FRAMETYPE_BIDIR)\nVAR_0->has_b_frames = 1;",
"VAR_0->transp_status = get_bits1(&VAR_0->gb);",
"if (VAR_0->transp_status) {",
"VAR_0->has_transp = 1;",
"}",
"if (get_bits1(&VAR_0->gb)) {",
"av_log(VAR_1, AV_LOG_ERROR, \"Sync bit is set!\\n\");",
"return AVERROR_INVALIDDATA;",
"}",
"VAR_0->data_size = get_bits1(&VAR_0->gb) ? get_bits(&VAR_0->gb, 24) : 0;",
"if (VAR_0->frame_type >= IVI4_FRAMETYPE_NULL_FIRST) {",
"ff_dlog(VAR_1, \"Null frame encountered!\\n\");",
"return 0;",
"}",
"if (get_bits1(&VAR_0->gb)) {",
"skip_bits_long(&VAR_0->gb, 32);",
"ff_dlog(VAR_1, \"Password-protected clip!\\n\");",
"}",
"VAR_2 = get_bits(&VAR_0->gb, 3);",
"if (VAR_2 == IVI4_PIC_SIZE_ESC) {",
"pic_conf.pic_height = get_bits(&VAR_0->gb, 16);",
"pic_conf.pic_width = get_bits(&VAR_0->gb, 16);",
"} else {",
"pic_conf.pic_height = ivi4_common_pic_sizes[VAR_2 * 2 + 1];",
"pic_conf.pic_width = ivi4_common_pic_sizes[VAR_2 * 2 ];",
"}",
"if (get_bits1(&VAR_0->gb)) {",
"pic_conf.tile_height = scale_tile_size(pic_conf.pic_height, get_bits(&VAR_0->gb, 4));",
"pic_conf.tile_width = scale_tile_size(pic_conf.pic_width, get_bits(&VAR_0->gb, 4));",
"VAR_0->uses_tiling = 1;",
"} else {",
"pic_conf.tile_height = pic_conf.pic_height;",
"pic_conf.tile_width = pic_conf.pic_width;",
"}",
"if (get_bits(&VAR_0->gb, 2)) {",
"av_log(VAR_1, AV_LOG_ERROR, \"Only YVU9 picture format is supported!\\n\");",
"return AVERROR_INVALIDDATA;",
"}",
"pic_conf.chroma_height = (pic_conf.pic_height + 3) >> 2;",
"pic_conf.chroma_width = (pic_conf.pic_width + 3) >> 2;",
"pic_conf.luma_bands = decode_plane_subdivision(&VAR_0->gb);",
"if (pic_conf.luma_bands)\npic_conf.chroma_bands = decode_plane_subdivision(&VAR_0->gb);",
"VAR_0->is_scalable = pic_conf.luma_bands != 1 || pic_conf.chroma_bands != 1;",
"if (VAR_0->is_scalable && (pic_conf.luma_bands != 4 || pic_conf.chroma_bands != 1)) {",
"av_log(VAR_1, AV_LOG_ERROR, \"Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d\\n\",\npic_conf.luma_bands, pic_conf.chroma_bands);",
"return AVERROR_INVALIDDATA;",
"}",
"if (ivi_pic_config_cmp(&pic_conf, &VAR_0->pic_conf)) {",
"if (ff_ivi_init_planes(VAR_0->planes, &pic_conf, 1)) {",
"av_log(VAR_1, AV_LOG_ERROR, \"Couldn't reallocate color planes!\\n\");",
"VAR_0->pic_conf.luma_bands = 0;",
"return AVERROR(ENOMEM);",
"}",
"VAR_0->pic_conf = pic_conf;",
"for (VAR_4 = 0; VAR_4 <= 2; VAR_4++) {",
"for (VAR_3 = 0; VAR_3 < (!VAR_4 ? pic_conf.luma_bands : pic_conf.chroma_bands); VAR_3++) {",
"VAR_0->planes[VAR_4].bands[VAR_3].mb_size = !VAR_4 ? (!VAR_0->is_scalable ? 16 : 8) : 4;",
"VAR_0->planes[VAR_4].bands[VAR_3].blk_size = !VAR_4 ? 8 : 4;",
"}",
"}",
"if (ff_ivi_init_tiles(VAR_0->planes, VAR_0->pic_conf.tile_width,\nVAR_0->pic_conf.tile_height)) {",
"av_log(VAR_1, AV_LOG_ERROR,\n\"Couldn't reallocate internal structures!\\n\");",
"return AVERROR(ENOMEM);",
"}",
"}",
"VAR_0->frame_num = get_bits1(&VAR_0->gb) ? get_bits(&VAR_0->gb, 20) : 0;",
"if (get_bits1(&VAR_0->gb))\nskip_bits(&VAR_0->gb, 8);",
"if (ff_ivi_dec_huff_desc(&VAR_0->gb, get_bits1(&VAR_0->gb), IVI_MB_HUFF, &VAR_0->mb_vlc, VAR_1) ||\nff_ivi_dec_huff_desc(&VAR_0->gb, get_bits1(&VAR_0->gb), IVI_BLK_HUFF, &VAR_0->blk_vlc, VAR_1))\nreturn AVERROR_INVALIDDATA;",
"VAR_0->rvmap_sel = get_bits1(&VAR_0->gb) ? get_bits(&VAR_0->gb, 3) : 8;",
"VAR_0->in_imf = get_bits1(&VAR_0->gb);",
"VAR_0->in_q = get_bits1(&VAR_0->gb);",
"VAR_0->pic_glob_quant = get_bits(&VAR_0->gb, 5);",
"VAR_0->unknown1 = get_bits1(&VAR_0->gb) ? get_bits(&VAR_0->gb, 3) : 0;",
"VAR_0->checksum = get_bits1(&VAR_0->gb) ? get_bits(&VAR_0->gb, 16) : 0;",
"while (get_bits1(&VAR_0->gb)) {",
"ff_dlog(VAR_1, \"Pic hdr extension encountered!\\n\");",
"skip_bits(&VAR_0->gb, 8);",
"}",
"if (get_bits1(&VAR_0->gb)) {",
"av_log(VAR_1, AV_LOG_ERROR, \"Bad blocks bits encountered!\\n\");",
"}",
"align_get_bits(&VAR_0->gb);",
"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
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35,
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63
],
[
69
],
[
71
],
[
73
],
[
75
],
[
85
],
[
87
],
[
89
],
[
91
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
151
],
[
153,
155
],
[
157
],
[
159
],
[
161,
163
],
[
165
],
[
167
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
183
],
[
187
],
[
193
],
[
195
],
[
197
],
[
199
],
[
201
],
[
203
],
[
207,
209
],
[
211,
213
],
[
215
],
[
217
],
[
219
],
[
223
],
[
229,
231
],
[
237,
239,
241
],
[
245
],
[
249
],
[
251
],
[
255
],
[
261
],
[
265
],
[
271
],
[
273
],
[
275
],
[
277
],
[
281
],
[
283
],
[
285
],
[
289
],
[
293
],
[
295
]
]
|
16,985 | static void decode_finish_row(H264Context *h, H264SliceContext *sl)
{
int top = 16 * (h->mb_y >> FIELD_PICTURE(h));
int pic_height = 16 * h->mb_height >> FIELD_PICTURE(h);
int height = 16 << FRAME_MBAFF(h);
int deblock_border = (16 + 4) << FRAME_MBAFF(h);
if (h->deblocking_filter) {
if ((top + height) >= pic_height)
height += deblock_border;
top -= deblock_border;
}
if (top >= pic_height || (top + height) < 0)
return;
height = FFMIN(height, pic_height - top);
if (top < 0) {
height = top + height;
top = 0;
}
ff_h264_draw_horiz_band(h, sl, top, height);
if (h->droppable)
return;
ff_thread_report_progress(&h->cur_pic_ptr->tf, top + height - 1,
h->picture_structure == PICT_BOTTOM_FIELD);
}
| false | FFmpeg | e6c90ce94f1b07f50cea2babf7471af455cca0ff | static void decode_finish_row(H264Context *h, H264SliceContext *sl)
{
int top = 16 * (h->mb_y >> FIELD_PICTURE(h));
int pic_height = 16 * h->mb_height >> FIELD_PICTURE(h);
int height = 16 << FRAME_MBAFF(h);
int deblock_border = (16 + 4) << FRAME_MBAFF(h);
if (h->deblocking_filter) {
if ((top + height) >= pic_height)
height += deblock_border;
top -= deblock_border;
}
if (top >= pic_height || (top + height) < 0)
return;
height = FFMIN(height, pic_height - top);
if (top < 0) {
height = top + height;
top = 0;
}
ff_h264_draw_horiz_band(h, sl, top, height);
if (h->droppable)
return;
ff_thread_report_progress(&h->cur_pic_ptr->tf, top + height - 1,
h->picture_structure == PICT_BOTTOM_FIELD);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(H264Context *VAR_0, H264SliceContext *VAR_1)
{
int VAR_2 = 16 * (VAR_0->mb_y >> FIELD_PICTURE(VAR_0));
int VAR_3 = 16 * VAR_0->mb_height >> FIELD_PICTURE(VAR_0);
int VAR_4 = 16 << FRAME_MBAFF(VAR_0);
int VAR_5 = (16 + 4) << FRAME_MBAFF(VAR_0);
if (VAR_0->deblocking_filter) {
if ((VAR_2 + VAR_4) >= VAR_3)
VAR_4 += VAR_5;
VAR_2 -= VAR_5;
}
if (VAR_2 >= VAR_3 || (VAR_2 + VAR_4) < 0)
return;
VAR_4 = FFMIN(VAR_4, VAR_3 - VAR_2);
if (VAR_2 < 0) {
VAR_4 = VAR_2 + VAR_4;
VAR_2 = 0;
}
ff_h264_draw_horiz_band(VAR_0, VAR_1, VAR_2, VAR_4);
if (VAR_0->droppable)
return;
ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, VAR_2 + VAR_4 - 1,
VAR_0->picture_structure == PICT_BOTTOM_FIELD);
}
| [
"static void FUNC_0(H264Context *VAR_0, H264SliceContext *VAR_1)\n{",
"int VAR_2 = 16 * (VAR_0->mb_y >> FIELD_PICTURE(VAR_0));",
"int VAR_3 = 16 * VAR_0->mb_height >> FIELD_PICTURE(VAR_0);",
"int VAR_4 = 16 << FRAME_MBAFF(VAR_0);",
"int VAR_5 = (16 + 4) << FRAME_MBAFF(VAR_0);",
"if (VAR_0->deblocking_filter) {",
"if ((VAR_2 + VAR_4) >= VAR_3)\nVAR_4 += VAR_5;",
"VAR_2 -= VAR_5;",
"}",
"if (VAR_2 >= VAR_3 || (VAR_2 + VAR_4) < 0)\nreturn;",
"VAR_4 = FFMIN(VAR_4, VAR_3 - VAR_2);",
"if (VAR_2 < 0) {",
"VAR_4 = VAR_2 + VAR_4;",
"VAR_2 = 0;",
"}",
"ff_h264_draw_horiz_band(VAR_0, VAR_1, VAR_2, VAR_4);",
"if (VAR_0->droppable)\nreturn;",
"ff_thread_report_progress(&VAR_0->cur_pic_ptr->tf, VAR_2 + VAR_4 - 1,\nVAR_0->picture_structure == PICT_BOTTOM_FIELD);",
"}"
]
| [
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
],
[
27,
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
49,
51
],
[
55,
57
],
[
59
]
]
|
16,987 | static inline void show_tags(WriterContext *wctx, AVDictionary *tags, int section_id)
{
AVDictionaryEntry *tag = NULL;
if (!tags)
return;
writer_print_section_header(wctx, section_id);
while ((tag = av_dict_get(tags, "", tag, AV_DICT_IGNORE_SUFFIX)))
writer_print_string(wctx, tag->key, tag->value, 0);
writer_print_section_footer(wctx);
}
| false | FFmpeg | e87190f5d20d380608f792ceb14d0def1d80e24b | static inline void show_tags(WriterContext *wctx, AVDictionary *tags, int section_id)
{
AVDictionaryEntry *tag = NULL;
if (!tags)
return;
writer_print_section_header(wctx, section_id);
while ((tag = av_dict_get(tags, "", tag, AV_DICT_IGNORE_SUFFIX)))
writer_print_string(wctx, tag->key, tag->value, 0);
writer_print_section_footer(wctx);
}
| {
"code": [],
"line_no": []
} | static inline void FUNC_0(WriterContext *VAR_0, AVDictionary *VAR_1, int VAR_2)
{
AVDictionaryEntry *tag = NULL;
if (!VAR_1)
return;
writer_print_section_header(VAR_0, VAR_2);
while ((tag = av_dict_get(VAR_1, "", tag, AV_DICT_IGNORE_SUFFIX)))
writer_print_string(VAR_0, tag->key, tag->value, 0);
writer_print_section_footer(VAR_0);
}
| [
"static inline void FUNC_0(WriterContext *VAR_0, AVDictionary *VAR_1, int VAR_2)\n{",
"AVDictionaryEntry *tag = NULL;",
"if (!VAR_1)\nreturn;",
"writer_print_section_header(VAR_0, VAR_2);",
"while ((tag = av_dict_get(VAR_1, \"\", tag, AV_DICT_IGNORE_SUFFIX)))\nwriter_print_string(VAR_0, tag->key, tag->value, 0);",
"writer_print_section_footer(VAR_0);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9,
11
],
[
13
],
[
15,
17
],
[
19
],
[
21
]
]
|
16,989 | void qemu_spice_display_update(SimpleSpiceDisplay *ssd,
int x, int y, int w, int h)
{
QXLRect update_area;
dprint(2, "%s: x %d y %d w %d h %d\n", __FUNCTION__, x, y, w, h);
update_area.left = x,
update_area.right = x + w;
update_area.top = y;
update_area.bottom = y + h;
pthread_mutex_lock(&ssd->lock);
if (qemu_spice_rect_is_empty(&ssd->dirty)) {
ssd->notify++;
}
qemu_spice_rect_union(&ssd->dirty, &update_area);
pthread_mutex_unlock(&ssd->lock);
}
| false | qemu | 7466bc49107fbd84336ba680f860d5eadd6def13 | void qemu_spice_display_update(SimpleSpiceDisplay *ssd,
int x, int y, int w, int h)
{
QXLRect update_area;
dprint(2, "%s: x %d y %d w %d h %d\n", __FUNCTION__, x, y, w, h);
update_area.left = x,
update_area.right = x + w;
update_area.top = y;
update_area.bottom = y + h;
pthread_mutex_lock(&ssd->lock);
if (qemu_spice_rect_is_empty(&ssd->dirty)) {
ssd->notify++;
}
qemu_spice_rect_union(&ssd->dirty, &update_area);
pthread_mutex_unlock(&ssd->lock);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(SimpleSpiceDisplay *VAR_0,
int VAR_1, int VAR_2, int VAR_3, int VAR_4)
{
QXLRect update_area;
dprint(2, "%s: VAR_1 %d VAR_2 %d VAR_3 %d VAR_4 %d\n", __FUNCTION__, VAR_1, VAR_2, VAR_3, VAR_4);
update_area.left = VAR_1,
update_area.right = VAR_1 + VAR_3;
update_area.top = VAR_2;
update_area.bottom = VAR_2 + VAR_4;
pthread_mutex_lock(&VAR_0->lock);
if (qemu_spice_rect_is_empty(&VAR_0->dirty)) {
VAR_0->notify++;
}
qemu_spice_rect_union(&VAR_0->dirty, &update_area);
pthread_mutex_unlock(&VAR_0->lock);
}
| [
"void FUNC_0(SimpleSpiceDisplay *VAR_0,\nint VAR_1, int VAR_2, int VAR_3, int VAR_4)\n{",
"QXLRect update_area;",
"dprint(2, \"%s: VAR_1 %d VAR_2 %d VAR_3 %d VAR_4 %d\\n\", __FUNCTION__, VAR_1, VAR_2, VAR_3, VAR_4);",
"update_area.left = VAR_1,\nupdate_area.right = VAR_1 + VAR_3;",
"update_area.top = VAR_2;",
"update_area.bottom = VAR_2 + VAR_4;",
"pthread_mutex_lock(&VAR_0->lock);",
"if (qemu_spice_rect_is_empty(&VAR_0->dirty)) {",
"VAR_0->notify++;",
"}",
"qemu_spice_rect_union(&VAR_0->dirty, &update_area);",
"pthread_mutex_unlock(&VAR_0->lock);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
11
],
[
13,
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
]
]
|
16,990 | static void blk_alloc(struct XenDevice *xendev)
{
struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
LIST_INIT(&blkdev->inflight);
LIST_INIT(&blkdev->finished);
LIST_INIT(&blkdev->freelist);
blkdev->bh = qemu_bh_new(blk_bh, blkdev);
if (xen_mode != XEN_EMULATE)
batch_maps = 1;
}
| false | qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | static void blk_alloc(struct XenDevice *xendev)
{
struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev);
LIST_INIT(&blkdev->inflight);
LIST_INIT(&blkdev->finished);
LIST_INIT(&blkdev->freelist);
blkdev->bh = qemu_bh_new(blk_bh, blkdev);
if (xen_mode != XEN_EMULATE)
batch_maps = 1;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(struct XenDevice *VAR_0)
{
struct XenBlkDev *VAR_1 = container_of(VAR_0, struct XenBlkDev, VAR_0);
LIST_INIT(&VAR_1->inflight);
LIST_INIT(&VAR_1->finished);
LIST_INIT(&VAR_1->freelist);
VAR_1->bh = qemu_bh_new(blk_bh, VAR_1);
if (xen_mode != XEN_EMULATE)
batch_maps = 1;
}
| [
"static void FUNC_0(struct XenDevice *VAR_0)\n{",
"struct XenBlkDev *VAR_1 = container_of(VAR_0, struct XenBlkDev, VAR_0);",
"LIST_INIT(&VAR_1->inflight);",
"LIST_INIT(&VAR_1->finished);",
"LIST_INIT(&VAR_1->freelist);",
"VAR_1->bh = qemu_bh_new(blk_bh, VAR_1);",
"if (xen_mode != XEN_EMULATE)\nbatch_maps = 1;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17,
19
],
[
21
]
]
|
16,991 | static Suite *qstring_suite(void)
{
Suite *s;
TCase *qstring_public_tcase;
s = suite_create("QString test-suite");
qstring_public_tcase = tcase_create("Public Interface");
suite_add_tcase(s, qstring_public_tcase);
tcase_add_test(qstring_public_tcase, qstring_from_str_test);
tcase_add_test(qstring_public_tcase, qstring_destroy_test);
tcase_add_test(qstring_public_tcase, qstring_get_str_test);
tcase_add_test(qstring_public_tcase, qstring_append_chr_test);
tcase_add_test(qstring_public_tcase, qstring_from_substr_test);
tcase_add_test(qstring_public_tcase, qobject_to_qstring_test);
return s;
}
| false | qemu | 0ac7cc2af500b948510f2481c22e84a57b0a2447 | static Suite *qstring_suite(void)
{
Suite *s;
TCase *qstring_public_tcase;
s = suite_create("QString test-suite");
qstring_public_tcase = tcase_create("Public Interface");
suite_add_tcase(s, qstring_public_tcase);
tcase_add_test(qstring_public_tcase, qstring_from_str_test);
tcase_add_test(qstring_public_tcase, qstring_destroy_test);
tcase_add_test(qstring_public_tcase, qstring_get_str_test);
tcase_add_test(qstring_public_tcase, qstring_append_chr_test);
tcase_add_test(qstring_public_tcase, qstring_from_substr_test);
tcase_add_test(qstring_public_tcase, qobject_to_qstring_test);
return s;
}
| {
"code": [],
"line_no": []
} | static Suite *FUNC_0(void)
{
Suite *s;
TCase *qstring_public_tcase;
s = suite_create("QString test-suite");
qstring_public_tcase = tcase_create("Public Interface");
suite_add_tcase(s, qstring_public_tcase);
tcase_add_test(qstring_public_tcase, qstring_from_str_test);
tcase_add_test(qstring_public_tcase, qstring_destroy_test);
tcase_add_test(qstring_public_tcase, qstring_get_str_test);
tcase_add_test(qstring_public_tcase, qstring_append_chr_test);
tcase_add_test(qstring_public_tcase, qstring_from_substr_test);
tcase_add_test(qstring_public_tcase, qobject_to_qstring_test);
return s;
}
| [
"static Suite *FUNC_0(void)\n{",
"Suite *s;",
"TCase *qstring_public_tcase;",
"s = suite_create(\"QString test-suite\");",
"qstring_public_tcase = tcase_create(\"Public Interface\");",
"suite_add_tcase(s, qstring_public_tcase);",
"tcase_add_test(qstring_public_tcase, qstring_from_str_test);",
"tcase_add_test(qstring_public_tcase, qstring_destroy_test);",
"tcase_add_test(qstring_public_tcase, qstring_get_str_test);",
"tcase_add_test(qstring_public_tcase, qstring_append_chr_test);",
"tcase_add_test(qstring_public_tcase, qstring_from_substr_test);",
"tcase_add_test(qstring_public_tcase, qobject_to_qstring_test);",
"return s;",
"}"
]
| [
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
],
[
33
],
[
35
]
]
|
16,992 | static inline TranslationBlock *tb_find(CPUState *cpu,
TranslationBlock *last_tb,
int tb_exit)
{
TranslationBlock *tb;
target_ulong cs_base, pc;
uint32_t flags;
bool acquired_tb_lock = false;
uint32_t cf_mask = curr_cflags();
tb = tb_lookup__cpu_state(cpu, &pc, &cs_base, &flags, cf_mask);
if (tb == NULL) {
/* mmap_lock is needed by tb_gen_code, and mmap_lock must be
* taken outside tb_lock. As system emulation is currently
* single threaded the locks are NOPs.
*/
mmap_lock();
tb_lock();
acquired_tb_lock = true;
/* There's a chance that our desired tb has been translated while
* taking the locks so we check again inside the lock.
*/
tb = tb_htable_lookup(cpu, pc, cs_base, flags, cf_mask);
if (likely(tb == NULL)) {
/* if no translated code available, then translate it now */
tb = tb_gen_code(cpu, pc, cs_base, flags, cf_mask);
}
mmap_unlock();
/* We add the TB in the virtual pc hash table for the fast lookup */
atomic_set(&cpu->tb_jmp_cache[tb_jmp_cache_hash_func(pc)], tb);
}
#ifndef CONFIG_USER_ONLY
/* We don't take care of direct jumps when address mapping changes in
* system emulation. So it's not safe to make a direct jump to a TB
* spanning two pages because the mapping for the second page can change.
*/
if (tb->page_addr[1] != -1) {
last_tb = NULL;
}
#endif
/* See if we can patch the calling TB. */
if (last_tb && !qemu_loglevel_mask(CPU_LOG_TB_NOCHAIN)) {
if (!acquired_tb_lock) {
tb_lock();
acquired_tb_lock = true;
}
if (!(tb->cflags & CF_INVALID)) {
tb_add_jump(last_tb, tb_exit, tb);
}
}
if (acquired_tb_lock) {
tb_unlock();
}
return tb;
}
| false | qemu | 9b990ee5a3cc6aa38f81266fb0c6ef37a36c45b9 | static inline TranslationBlock *tb_find(CPUState *cpu,
TranslationBlock *last_tb,
int tb_exit)
{
TranslationBlock *tb;
target_ulong cs_base, pc;
uint32_t flags;
bool acquired_tb_lock = false;
uint32_t cf_mask = curr_cflags();
tb = tb_lookup__cpu_state(cpu, &pc, &cs_base, &flags, cf_mask);
if (tb == NULL) {
mmap_lock();
tb_lock();
acquired_tb_lock = true;
tb = tb_htable_lookup(cpu, pc, cs_base, flags, cf_mask);
if (likely(tb == NULL)) {
tb = tb_gen_code(cpu, pc, cs_base, flags, cf_mask);
}
mmap_unlock();
atomic_set(&cpu->tb_jmp_cache[tb_jmp_cache_hash_func(pc)], tb);
}
#ifndef CONFIG_USER_ONLY
if (tb->page_addr[1] != -1) {
last_tb = NULL;
}
#endif
if (last_tb && !qemu_loglevel_mask(CPU_LOG_TB_NOCHAIN)) {
if (!acquired_tb_lock) {
tb_lock();
acquired_tb_lock = true;
}
if (!(tb->cflags & CF_INVALID)) {
tb_add_jump(last_tb, tb_exit, tb);
}
}
if (acquired_tb_lock) {
tb_unlock();
}
return tb;
}
| {
"code": [],
"line_no": []
} | static inline TranslationBlock *FUNC_0(CPUState *cpu,
TranslationBlock *last_tb,
int tb_exit)
{
TranslationBlock *tb;
target_ulong cs_base, pc;
uint32_t flags;
bool acquired_tb_lock = false;
uint32_t cf_mask = curr_cflags();
tb = tb_lookup__cpu_state(cpu, &pc, &cs_base, &flags, cf_mask);
if (tb == NULL) {
mmap_lock();
tb_lock();
acquired_tb_lock = true;
tb = tb_htable_lookup(cpu, pc, cs_base, flags, cf_mask);
if (likely(tb == NULL)) {
tb = tb_gen_code(cpu, pc, cs_base, flags, cf_mask);
}
mmap_unlock();
atomic_set(&cpu->tb_jmp_cache[tb_jmp_cache_hash_func(pc)], tb);
}
#ifndef CONFIG_USER_ONLY
if (tb->page_addr[1] != -1) {
last_tb = NULL;
}
#endif
if (last_tb && !qemu_loglevel_mask(CPU_LOG_TB_NOCHAIN)) {
if (!acquired_tb_lock) {
tb_lock();
acquired_tb_lock = true;
}
if (!(tb->cflags & CF_INVALID)) {
tb_add_jump(last_tb, tb_exit, tb);
}
}
if (acquired_tb_lock) {
tb_unlock();
}
return tb;
}
| [
"static inline TranslationBlock *FUNC_0(CPUState *cpu,\nTranslationBlock *last_tb,\nint tb_exit)\n{",
"TranslationBlock *tb;",
"target_ulong cs_base, pc;",
"uint32_t flags;",
"bool acquired_tb_lock = false;",
"uint32_t cf_mask = curr_cflags();",
"tb = tb_lookup__cpu_state(cpu, &pc, &cs_base, &flags, cf_mask);",
"if (tb == NULL) {",
"mmap_lock();",
"tb_lock();",
"acquired_tb_lock = true;",
"tb = tb_htable_lookup(cpu, pc, cs_base, flags, cf_mask);",
"if (likely(tb == NULL)) {",
"tb = tb_gen_code(cpu, pc, cs_base, flags, cf_mask);",
"}",
"mmap_unlock();",
"atomic_set(&cpu->tb_jmp_cache[tb_jmp_cache_hash_func(pc)], tb);",
"}",
"#ifndef CONFIG_USER_ONLY\nif (tb->page_addr[1] != -1) {",
"last_tb = NULL;",
"}",
"#endif\nif (last_tb && !qemu_loglevel_mask(CPU_LOG_TB_NOCHAIN)) {",
"if (!acquired_tb_lock) {",
"tb_lock();",
"acquired_tb_lock = true;",
"}",
"if (!(tb->cflags & CF_INVALID)) {",
"tb_add_jump(last_tb, tb_exit, tb);",
"}",
"}",
"if (acquired_tb_lock) {",
"tb_unlock();",
"}",
"return tb;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
33
],
[
35
],
[
37
],
[
47
],
[
49
],
[
53
],
[
55
],
[
59
],
[
63
],
[
65
],
[
67,
77
],
[
79
],
[
81
],
[
83,
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
]
]
|
16,993 | static VncServerInfo2List *qmp_query_server_entry(QIOChannelSocket *ioc,
bool websocket,
int auth,
int subauth,
VncServerInfo2List *prev)
{
VncServerInfo2List *list;
VncServerInfo2 *info;
Error *err = NULL;
SocketAddress *addr;
addr = qio_channel_socket_get_local_address(ioc, &err);
if (!addr) {
error_free(err);
return prev;
}
info = g_new0(VncServerInfo2, 1);
vnc_init_basic_info(addr, qapi_VncServerInfo2_base(info), &err);
qapi_free_SocketAddress(addr);
if (err) {
qapi_free_VncServerInfo2(info);
error_free(err);
return prev;
}
info->websocket = websocket;
qmp_query_auth(auth, subauth, &info->auth,
&info->vencrypt, &info->has_vencrypt);
list = g_new0(VncServerInfo2List, 1);
list->value = info;
list->next = prev;
return list;
}
| false | qemu | dfd100f242370886bb6732f70f1f7cbd8eb9fedc | static VncServerInfo2List *qmp_query_server_entry(QIOChannelSocket *ioc,
bool websocket,
int auth,
int subauth,
VncServerInfo2List *prev)
{
VncServerInfo2List *list;
VncServerInfo2 *info;
Error *err = NULL;
SocketAddress *addr;
addr = qio_channel_socket_get_local_address(ioc, &err);
if (!addr) {
error_free(err);
return prev;
}
info = g_new0(VncServerInfo2, 1);
vnc_init_basic_info(addr, qapi_VncServerInfo2_base(info), &err);
qapi_free_SocketAddress(addr);
if (err) {
qapi_free_VncServerInfo2(info);
error_free(err);
return prev;
}
info->websocket = websocket;
qmp_query_auth(auth, subauth, &info->auth,
&info->vencrypt, &info->has_vencrypt);
list = g_new0(VncServerInfo2List, 1);
list->value = info;
list->next = prev;
return list;
}
| {
"code": [],
"line_no": []
} | static VncServerInfo2List *FUNC_0(QIOChannelSocket *ioc,
bool websocket,
int auth,
int subauth,
VncServerInfo2List *prev)
{
VncServerInfo2List *list;
VncServerInfo2 *info;
Error *err = NULL;
SocketAddress *addr;
addr = qio_channel_socket_get_local_address(ioc, &err);
if (!addr) {
error_free(err);
return prev;
}
info = g_new0(VncServerInfo2, 1);
vnc_init_basic_info(addr, qapi_VncServerInfo2_base(info), &err);
qapi_free_SocketAddress(addr);
if (err) {
qapi_free_VncServerInfo2(info);
error_free(err);
return prev;
}
info->websocket = websocket;
qmp_query_auth(auth, subauth, &info->auth,
&info->vencrypt, &info->has_vencrypt);
list = g_new0(VncServerInfo2List, 1);
list->value = info;
list->next = prev;
return list;
}
| [
"static VncServerInfo2List *FUNC_0(QIOChannelSocket *ioc,\nbool websocket,\nint auth,\nint subauth,\nVncServerInfo2List *prev)\n{",
"VncServerInfo2List *list;",
"VncServerInfo2 *info;",
"Error *err = NULL;",
"SocketAddress *addr;",
"addr = qio_channel_socket_get_local_address(ioc, &err);",
"if (!addr) {",
"error_free(err);",
"return prev;",
"}",
"info = g_new0(VncServerInfo2, 1);",
"vnc_init_basic_info(addr, qapi_VncServerInfo2_base(info), &err);",
"qapi_free_SocketAddress(addr);",
"if (err) {",
"qapi_free_VncServerInfo2(info);",
"error_free(err);",
"return prev;",
"}",
"info->websocket = websocket;",
"qmp_query_auth(auth, subauth, &info->auth,\n&info->vencrypt, &info->has_vencrypt);",
"list = g_new0(VncServerInfo2List, 1);",
"list->value = info;",
"list->next = prev;",
"return list;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5,
7,
9,
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
55,
57
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
]
]
|
16,994 | static void tcx_invalidate_cursor_position(TCXState *s)
{
int ymin, ymax, start, end;
/* invalidate only near the cursor */
ymin = s->cursy;
if (ymin >= s->height) {
return;
}
ymax = MIN(s->height, ymin + 32);
start = ymin * 1024;
end = ymax * 1024;
memory_region_set_dirty(&s->vram_mem, start, end-start);
}
| false | qemu | 973945804d95878375b487c0c5c9b2556c5e4543 | static void tcx_invalidate_cursor_position(TCXState *s)
{
int ymin, ymax, start, end;
ymin = s->cursy;
if (ymin >= s->height) {
return;
}
ymax = MIN(s->height, ymin + 32);
start = ymin * 1024;
end = ymax * 1024;
memory_region_set_dirty(&s->vram_mem, start, end-start);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(TCXState *VAR_0)
{
int VAR_1, VAR_2, VAR_3, VAR_4;
VAR_1 = VAR_0->cursy;
if (VAR_1 >= VAR_0->height) {
return;
}
VAR_2 = MIN(VAR_0->height, VAR_1 + 32);
VAR_3 = VAR_1 * 1024;
VAR_4 = VAR_2 * 1024;
memory_region_set_dirty(&VAR_0->vram_mem, VAR_3, VAR_4-VAR_3);
}
| [
"static void FUNC_0(TCXState *VAR_0)\n{",
"int VAR_1, VAR_2, VAR_3, VAR_4;",
"VAR_1 = VAR_0->cursy;",
"if (VAR_1 >= VAR_0->height) {",
"return;",
"}",
"VAR_2 = MIN(VAR_0->height, VAR_1 + 32);",
"VAR_3 = VAR_1 * 1024;",
"VAR_4 = VAR_2 * 1024;",
"memory_region_set_dirty(&VAR_0->vram_mem, VAR_3, VAR_4-VAR_3);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29
]
]
|
16,995 | static int pxa2xx_timer_init(SysBusDevice *dev)
{
int i;
int iomemtype;
PXA2xxTimerInfo *s;
qemu_irq irq4;
s = FROM_SYSBUS(PXA2xxTimerInfo, dev);
s->irq_enabled = 0;
s->oldclock = 0;
s->clock = 0;
s->lastload = qemu_get_clock(vm_clock);
s->reset3 = 0;
for (i = 0; i < 4; i ++) {
s->timer[i].value = 0;
sysbus_init_irq(dev, &s->timer[i].irq);
s->timer[i].info = s;
s->timer[i].num = i;
s->timer[i].level = 0;
s->timer[i].qtimer = qemu_new_timer(vm_clock,
pxa2xx_timer_tick, &s->timer[i]);
}
if (s->flags & (1 << PXA2XX_TIMER_HAVE_TM4)) {
sysbus_init_irq(dev, &irq4);
for (i = 0; i < 8; i ++) {
s->tm4[i].tm.value = 0;
s->tm4[i].tm.info = s;
s->tm4[i].tm.num = i + 4;
s->tm4[i].tm.level = 0;
s->tm4[i].freq = 0;
s->tm4[i].control = 0x0;
s->tm4[i].tm.qtimer = qemu_new_timer(vm_clock,
pxa2xx_timer_tick4, &s->tm4[i]);
s->tm4[i].tm.irq = irq4;
}
}
iomemtype = cpu_register_io_memory(pxa2xx_timer_readfn,
pxa2xx_timer_writefn, s, DEVICE_NATIVE_ENDIAN);
sysbus_init_mmio(dev, 0x00001000, iomemtype);
return 0;
}
| false | qemu | 4ff927cc62ea79092e21827f17d19a3d85973e84 | static int pxa2xx_timer_init(SysBusDevice *dev)
{
int i;
int iomemtype;
PXA2xxTimerInfo *s;
qemu_irq irq4;
s = FROM_SYSBUS(PXA2xxTimerInfo, dev);
s->irq_enabled = 0;
s->oldclock = 0;
s->clock = 0;
s->lastload = qemu_get_clock(vm_clock);
s->reset3 = 0;
for (i = 0; i < 4; i ++) {
s->timer[i].value = 0;
sysbus_init_irq(dev, &s->timer[i].irq);
s->timer[i].info = s;
s->timer[i].num = i;
s->timer[i].level = 0;
s->timer[i].qtimer = qemu_new_timer(vm_clock,
pxa2xx_timer_tick, &s->timer[i]);
}
if (s->flags & (1 << PXA2XX_TIMER_HAVE_TM4)) {
sysbus_init_irq(dev, &irq4);
for (i = 0; i < 8; i ++) {
s->tm4[i].tm.value = 0;
s->tm4[i].tm.info = s;
s->tm4[i].tm.num = i + 4;
s->tm4[i].tm.level = 0;
s->tm4[i].freq = 0;
s->tm4[i].control = 0x0;
s->tm4[i].tm.qtimer = qemu_new_timer(vm_clock,
pxa2xx_timer_tick4, &s->tm4[i]);
s->tm4[i].tm.irq = irq4;
}
}
iomemtype = cpu_register_io_memory(pxa2xx_timer_readfn,
pxa2xx_timer_writefn, s, DEVICE_NATIVE_ENDIAN);
sysbus_init_mmio(dev, 0x00001000, iomemtype);
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(SysBusDevice *VAR_0)
{
int VAR_1;
int VAR_2;
PXA2xxTimerInfo *s;
qemu_irq irq4;
s = FROM_SYSBUS(PXA2xxTimerInfo, VAR_0);
s->irq_enabled = 0;
s->oldclock = 0;
s->clock = 0;
s->lastload = qemu_get_clock(vm_clock);
s->reset3 = 0;
for (VAR_1 = 0; VAR_1 < 4; VAR_1 ++) {
s->timer[VAR_1].value = 0;
sysbus_init_irq(VAR_0, &s->timer[VAR_1].irq);
s->timer[VAR_1].info = s;
s->timer[VAR_1].num = VAR_1;
s->timer[VAR_1].level = 0;
s->timer[VAR_1].qtimer = qemu_new_timer(vm_clock,
pxa2xx_timer_tick, &s->timer[VAR_1]);
}
if (s->flags & (1 << PXA2XX_TIMER_HAVE_TM4)) {
sysbus_init_irq(VAR_0, &irq4);
for (VAR_1 = 0; VAR_1 < 8; VAR_1 ++) {
s->tm4[VAR_1].tm.value = 0;
s->tm4[VAR_1].tm.info = s;
s->tm4[VAR_1].tm.num = VAR_1 + 4;
s->tm4[VAR_1].tm.level = 0;
s->tm4[VAR_1].freq = 0;
s->tm4[VAR_1].control = 0x0;
s->tm4[VAR_1].tm.qtimer = qemu_new_timer(vm_clock,
pxa2xx_timer_tick4, &s->tm4[VAR_1]);
s->tm4[VAR_1].tm.irq = irq4;
}
}
VAR_2 = cpu_register_io_memory(pxa2xx_timer_readfn,
pxa2xx_timer_writefn, s, DEVICE_NATIVE_ENDIAN);
sysbus_init_mmio(VAR_0, 0x00001000, VAR_2);
return 0;
}
| [
"static int FUNC_0(SysBusDevice *VAR_0)\n{",
"int VAR_1;",
"int VAR_2;",
"PXA2xxTimerInfo *s;",
"qemu_irq irq4;",
"s = FROM_SYSBUS(PXA2xxTimerInfo, VAR_0);",
"s->irq_enabled = 0;",
"s->oldclock = 0;",
"s->clock = 0;",
"s->lastload = qemu_get_clock(vm_clock);",
"s->reset3 = 0;",
"for (VAR_1 = 0; VAR_1 < 4; VAR_1 ++) {",
"s->timer[VAR_1].value = 0;",
"sysbus_init_irq(VAR_0, &s->timer[VAR_1].irq);",
"s->timer[VAR_1].info = s;",
"s->timer[VAR_1].num = VAR_1;",
"s->timer[VAR_1].level = 0;",
"s->timer[VAR_1].qtimer = qemu_new_timer(vm_clock,\npxa2xx_timer_tick, &s->timer[VAR_1]);",
"}",
"if (s->flags & (1 << PXA2XX_TIMER_HAVE_TM4)) {",
"sysbus_init_irq(VAR_0, &irq4);",
"for (VAR_1 = 0; VAR_1 < 8; VAR_1 ++) {",
"s->tm4[VAR_1].tm.value = 0;",
"s->tm4[VAR_1].tm.info = s;",
"s->tm4[VAR_1].tm.num = VAR_1 + 4;",
"s->tm4[VAR_1].tm.level = 0;",
"s->tm4[VAR_1].freq = 0;",
"s->tm4[VAR_1].control = 0x0;",
"s->tm4[VAR_1].tm.qtimer = qemu_new_timer(vm_clock,\npxa2xx_timer_tick4, &s->tm4[VAR_1]);",
"s->tm4[VAR_1].tm.irq = irq4;",
"}",
"}",
"VAR_2 = cpu_register_io_memory(pxa2xx_timer_readfn,\npxa2xx_timer_writefn, s, DEVICE_NATIVE_ENDIAN);",
"sysbus_init_mmio(VAR_0, 0x00001000, VAR_2);",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41,
43
],
[
45
],
[
47
],
[
49
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67,
69
],
[
71
],
[
73
],
[
75
],
[
79,
81
],
[
83
],
[
87
],
[
89
]
]
|
16,996 | static void xenfb_mouse_event(void *opaque,
int dx, int dy, int dz, int button_state)
{
struct XenInput *xenfb = opaque;
DisplaySurface *surface = qemu_console_surface(xenfb->c.con);
int dw = surface_width(surface);
int dh = surface_height(surface);
int i;
trace_xenfb_mouse_event(opaque, dx, dy, dz, button_state,
xenfb->abs_pointer_wanted);
if (xenfb->abs_pointer_wanted)
xenfb_send_position(xenfb,
dx * (dw - 1) / 0x7fff,
dy * (dh - 1) / 0x7fff,
dz);
else
xenfb_send_motion(xenfb, dx, dy, dz);
for (i = 0 ; i < 8 ; i++) {
int lastDown = xenfb->button_state & (1 << i);
int down = button_state & (1 << i);
if (down == lastDown)
continue;
if (xenfb_send_key(xenfb, down, BTN_LEFT+i) < 0)
return;
}
xenfb->button_state = button_state;
}
| false | qemu | 9f2130f58d5dd4e1fcb435cca08bf77e7c32e6c6 | static void xenfb_mouse_event(void *opaque,
int dx, int dy, int dz, int button_state)
{
struct XenInput *xenfb = opaque;
DisplaySurface *surface = qemu_console_surface(xenfb->c.con);
int dw = surface_width(surface);
int dh = surface_height(surface);
int i;
trace_xenfb_mouse_event(opaque, dx, dy, dz, button_state,
xenfb->abs_pointer_wanted);
if (xenfb->abs_pointer_wanted)
xenfb_send_position(xenfb,
dx * (dw - 1) / 0x7fff,
dy * (dh - 1) / 0x7fff,
dz);
else
xenfb_send_motion(xenfb, dx, dy, dz);
for (i = 0 ; i < 8 ; i++) {
int lastDown = xenfb->button_state & (1 << i);
int down = button_state & (1 << i);
if (down == lastDown)
continue;
if (xenfb_send_key(xenfb, down, BTN_LEFT+i) < 0)
return;
}
xenfb->button_state = button_state;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0,
int VAR_1, int VAR_2, int VAR_3, int VAR_4)
{
struct XenInput *VAR_5 = VAR_0;
DisplaySurface *surface = qemu_console_surface(VAR_5->c.con);
int VAR_6 = surface_width(surface);
int VAR_7 = surface_height(surface);
int VAR_8;
trace_xenfb_mouse_event(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4,
VAR_5->abs_pointer_wanted);
if (VAR_5->abs_pointer_wanted)
xenfb_send_position(VAR_5,
VAR_1 * (VAR_6 - 1) / 0x7fff,
VAR_2 * (VAR_7 - 1) / 0x7fff,
VAR_3);
else
xenfb_send_motion(VAR_5, VAR_1, VAR_2, VAR_3);
for (VAR_8 = 0 ; VAR_8 < 8 ; VAR_8++) {
int VAR_9 = VAR_5->VAR_4 & (1 << VAR_8);
int VAR_10 = VAR_4 & (1 << VAR_8);
if (VAR_10 == VAR_9)
continue;
if (xenfb_send_key(VAR_5, VAR_10, BTN_LEFT+VAR_8) < 0)
return;
}
VAR_5->VAR_4 = VAR_4;
}
| [
"static void FUNC_0(void *VAR_0,\nint VAR_1, int VAR_2, int VAR_3, int VAR_4)\n{",
"struct XenInput *VAR_5 = VAR_0;",
"DisplaySurface *surface = qemu_console_surface(VAR_5->c.con);",
"int VAR_6 = surface_width(surface);",
"int VAR_7 = surface_height(surface);",
"int VAR_8;",
"trace_xenfb_mouse_event(VAR_0, VAR_1, VAR_2, VAR_3, VAR_4,\nVAR_5->abs_pointer_wanted);",
"if (VAR_5->abs_pointer_wanted)\nxenfb_send_position(VAR_5,\nVAR_1 * (VAR_6 - 1) / 0x7fff,\nVAR_2 * (VAR_7 - 1) / 0x7fff,\nVAR_3);",
"else\nxenfb_send_motion(VAR_5, VAR_1, VAR_2, VAR_3);",
"for (VAR_8 = 0 ; VAR_8 < 8 ; VAR_8++) {",
"int VAR_9 = VAR_5->VAR_4 & (1 << VAR_8);",
"int VAR_10 = VAR_4 & (1 << VAR_8);",
"if (VAR_10 == VAR_9)\ncontinue;",
"if (xenfb_send_key(VAR_5, VAR_10, BTN_LEFT+VAR_8) < 0)\nreturn;",
"}",
"VAR_5->VAR_4 = VAR_4;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
19,
21
],
[
23,
25,
27,
29,
31
],
[
33,
35
],
[
39
],
[
41
],
[
43
],
[
45,
47
],
[
51,
53
],
[
55
],
[
57
],
[
59
]
]
|
16,997 | BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
const char *child_name,
const BdrvChildRole *child_role,
void *opaque)
{
BdrvChild *child = g_new(BdrvChild, 1);
*child = (BdrvChild) {
.bs = NULL,
.name = g_strdup(child_name),
.role = child_role,
.opaque = opaque,
};
bdrv_replace_child(child, child_bs);
return child;
}
| false | qemu | d5e6f437c5508614803d11e59ee16a758dde09ef | BdrvChild *bdrv_root_attach_child(BlockDriverState *child_bs,
const char *child_name,
const BdrvChildRole *child_role,
void *opaque)
{
BdrvChild *child = g_new(BdrvChild, 1);
*child = (BdrvChild) {
.bs = NULL,
.name = g_strdup(child_name),
.role = child_role,
.opaque = opaque,
};
bdrv_replace_child(child, child_bs);
return child;
}
| {
"code": [],
"line_no": []
} | BdrvChild *FUNC_0(BlockDriverState *child_bs,
const char *child_name,
const BdrvChildRole *child_role,
void *opaque)
{
BdrvChild *child = g_new(BdrvChild, 1);
*child = (BdrvChild) {
.bs = NULL,
.name = g_strdup(child_name),
.role = child_role,
.opaque = opaque,
};
bdrv_replace_child(child, child_bs);
return child;
}
| [
"BdrvChild *FUNC_0(BlockDriverState *child_bs,\nconst char *child_name,\nconst BdrvChildRole *child_role,\nvoid *opaque)\n{",
"BdrvChild *child = g_new(BdrvChild, 1);",
"*child = (BdrvChild) {",
".bs = NULL,\n.name = g_strdup(child_name),\n.role = child_role,\n.opaque = opaque,\n};",
"bdrv_replace_child(child, child_bs);",
"return child;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
15,
17,
19,
21,
23
],
[
27
],
[
31
],
[
33
]
]
|
16,998 | static av_cold int movie_common_init(AVFilterContext *ctx)
{
MovieContext *movie = ctx->priv;
AVInputFormat *iformat = NULL;
int64_t timestamp;
int nb_streams, ret, i;
char default_streams[16], *stream_specs, *spec, *cursor;
char name[16];
AVStream *st;
if (!*movie->file_name) {
av_log(ctx, AV_LOG_ERROR, "No filename provided!\n");
return AVERROR(EINVAL);
}
movie->seek_point = movie->seek_point_d * 1000000 + 0.5;
stream_specs = movie->stream_specs;
if (!stream_specs) {
snprintf(default_streams, sizeof(default_streams), "d%c%d",
!strcmp(ctx->filter->name, "amovie") ? 'a' : 'v',
movie->stream_index);
stream_specs = default_streams;
}
for (cursor = stream_specs, nb_streams = 1; *cursor; cursor++)
if (*cursor == '+')
nb_streams++;
if (movie->loop_count != 1 && nb_streams != 1) {
av_log(ctx, AV_LOG_ERROR,
"Loop with several streams is currently unsupported\n");
return AVERROR_PATCHWELCOME;
}
av_register_all();
// Try to find the movie format (container)
iformat = movie->format_name ? av_find_input_format(movie->format_name) : NULL;
movie->format_ctx = NULL;
if ((ret = avformat_open_input(&movie->format_ctx, movie->file_name, iformat, NULL)) < 0) {
av_log(ctx, AV_LOG_ERROR,
"Failed to avformat_open_input '%s'\n", movie->file_name);
return ret;
}
if ((ret = avformat_find_stream_info(movie->format_ctx, NULL)) < 0)
av_log(ctx, AV_LOG_WARNING, "Failed to find stream info\n");
// if seeking requested, we execute it
if (movie->seek_point > 0) {
timestamp = movie->seek_point;
// add the stream start time, should it exist
if (movie->format_ctx->start_time != AV_NOPTS_VALUE) {
if (timestamp > INT64_MAX - movie->format_ctx->start_time) {
av_log(ctx, AV_LOG_ERROR,
"%s: seek value overflow with start_time:%"PRId64" seek_point:%"PRId64"\n",
movie->file_name, movie->format_ctx->start_time, movie->seek_point);
return AVERROR(EINVAL);
}
timestamp += movie->format_ctx->start_time;
}
if ((ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD)) < 0) {
av_log(ctx, AV_LOG_ERROR, "%s: could not seek to position %"PRId64"\n",
movie->file_name, timestamp);
return ret;
}
}
for (i = 0; i < movie->format_ctx->nb_streams; i++)
movie->format_ctx->streams[i]->discard = AVDISCARD_ALL;
movie->st = av_calloc(nb_streams, sizeof(*movie->st));
if (!movie->st)
return AVERROR(ENOMEM);
for (i = 0; i < nb_streams; i++) {
spec = av_strtok(stream_specs, "+", &cursor);
if (!spec)
return AVERROR_BUG;
stream_specs = NULL; /* for next strtok */
st = find_stream(ctx, movie->format_ctx, spec);
if (!st)
return AVERROR(EINVAL);
st->discard = AVDISCARD_DEFAULT;
movie->st[i].st = st;
movie->max_stream_index = FFMAX(movie->max_stream_index, st->index);
}
if (av_strtok(NULL, "+", &cursor))
return AVERROR_BUG;
movie->out_index = av_calloc(movie->max_stream_index + 1,
sizeof(*movie->out_index));
if (!movie->out_index)
return AVERROR(ENOMEM);
for (i = 0; i <= movie->max_stream_index; i++)
movie->out_index[i] = -1;
for (i = 0; i < nb_streams; i++)
movie->out_index[movie->st[i].st->index] = i;
for (i = 0; i < nb_streams; i++) {
AVFilterPad pad = { 0 };
snprintf(name, sizeof(name), "out%d", i);
pad.type = movie->st[i].st->codec->codec_type;
pad.name = av_strdup(name);
pad.config_props = movie_config_output_props;
pad.request_frame = movie_request_frame;
ff_insert_outpad(ctx, i, &pad);
ret = open_stream(ctx, &movie->st[i]);
if (ret < 0)
return ret;
if ( movie->st[i].st->codec->codec->type == AVMEDIA_TYPE_AUDIO &&
!movie->st[i].st->codec->channel_layout) {
ret = guess_channel_layout(&movie->st[i], i, ctx);
if (ret < 0)
return ret;
}
}
av_log(ctx, AV_LOG_VERBOSE, "seek_point:%"PRIi64" format_name:%s file_name:%s stream_index:%d\n",
movie->seek_point, movie->format_name, movie->file_name,
movie->stream_index);
return 0;
}
| false | FFmpeg | c679a1c358c30ec38ae3b1ac3ee2c62efc2f32e2 | static av_cold int movie_common_init(AVFilterContext *ctx)
{
MovieContext *movie = ctx->priv;
AVInputFormat *iformat = NULL;
int64_t timestamp;
int nb_streams, ret, i;
char default_streams[16], *stream_specs, *spec, *cursor;
char name[16];
AVStream *st;
if (!*movie->file_name) {
av_log(ctx, AV_LOG_ERROR, "No filename provided!\n");
return AVERROR(EINVAL);
}
movie->seek_point = movie->seek_point_d * 1000000 + 0.5;
stream_specs = movie->stream_specs;
if (!stream_specs) {
snprintf(default_streams, sizeof(default_streams), "d%c%d",
!strcmp(ctx->filter->name, "amovie") ? 'a' : 'v',
movie->stream_index);
stream_specs = default_streams;
}
for (cursor = stream_specs, nb_streams = 1; *cursor; cursor++)
if (*cursor == '+')
nb_streams++;
if (movie->loop_count != 1 && nb_streams != 1) {
av_log(ctx, AV_LOG_ERROR,
"Loop with several streams is currently unsupported\n");
return AVERROR_PATCHWELCOME;
}
av_register_all();
iformat = movie->format_name ? av_find_input_format(movie->format_name) : NULL;
movie->format_ctx = NULL;
if ((ret = avformat_open_input(&movie->format_ctx, movie->file_name, iformat, NULL)) < 0) {
av_log(ctx, AV_LOG_ERROR,
"Failed to avformat_open_input '%s'\n", movie->file_name);
return ret;
}
if ((ret = avformat_find_stream_info(movie->format_ctx, NULL)) < 0)
av_log(ctx, AV_LOG_WARNING, "Failed to find stream info\n");
if (movie->seek_point > 0) {
timestamp = movie->seek_point;
if (movie->format_ctx->start_time != AV_NOPTS_VALUE) {
if (timestamp > INT64_MAX - movie->format_ctx->start_time) {
av_log(ctx, AV_LOG_ERROR,
"%s: seek value overflow with start_time:%"PRId64" seek_point:%"PRId64"\n",
movie->file_name, movie->format_ctx->start_time, movie->seek_point);
return AVERROR(EINVAL);
}
timestamp += movie->format_ctx->start_time;
}
if ((ret = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD)) < 0) {
av_log(ctx, AV_LOG_ERROR, "%s: could not seek to position %"PRId64"\n",
movie->file_name, timestamp);
return ret;
}
}
for (i = 0; i < movie->format_ctx->nb_streams; i++)
movie->format_ctx->streams[i]->discard = AVDISCARD_ALL;
movie->st = av_calloc(nb_streams, sizeof(*movie->st));
if (!movie->st)
return AVERROR(ENOMEM);
for (i = 0; i < nb_streams; i++) {
spec = av_strtok(stream_specs, "+", &cursor);
if (!spec)
return AVERROR_BUG;
stream_specs = NULL;
st = find_stream(ctx, movie->format_ctx, spec);
if (!st)
return AVERROR(EINVAL);
st->discard = AVDISCARD_DEFAULT;
movie->st[i].st = st;
movie->max_stream_index = FFMAX(movie->max_stream_index, st->index);
}
if (av_strtok(NULL, "+", &cursor))
return AVERROR_BUG;
movie->out_index = av_calloc(movie->max_stream_index + 1,
sizeof(*movie->out_index));
if (!movie->out_index)
return AVERROR(ENOMEM);
for (i = 0; i <= movie->max_stream_index; i++)
movie->out_index[i] = -1;
for (i = 0; i < nb_streams; i++)
movie->out_index[movie->st[i].st->index] = i;
for (i = 0; i < nb_streams; i++) {
AVFilterPad pad = { 0 };
snprintf(name, sizeof(name), "out%d", i);
pad.type = movie->st[i].st->codec->codec_type;
pad.name = av_strdup(name);
pad.config_props = movie_config_output_props;
pad.request_frame = movie_request_frame;
ff_insert_outpad(ctx, i, &pad);
ret = open_stream(ctx, &movie->st[i]);
if (ret < 0)
return ret;
if ( movie->st[i].st->codec->codec->type == AVMEDIA_TYPE_AUDIO &&
!movie->st[i].st->codec->channel_layout) {
ret = guess_channel_layout(&movie->st[i], i, ctx);
if (ret < 0)
return ret;
}
}
av_log(ctx, AV_LOG_VERBOSE, "seek_point:%"PRIi64" format_name:%s file_name:%s stream_index:%d\n",
movie->seek_point, movie->format_name, movie->file_name,
movie->stream_index);
return 0;
}
| {
"code": [],
"line_no": []
} | static av_cold int FUNC_0(AVFilterContext *ctx)
{
MovieContext *movie = ctx->priv;
AVInputFormat *iformat = NULL;
int64_t timestamp;
int VAR_0, VAR_1, VAR_2;
char VAR_3[16], *VAR_4, *VAR_5, *VAR_6;
char VAR_7[16];
AVStream *st;
if (!*movie->file_name) {
av_log(ctx, AV_LOG_ERROR, "No filename provided!\n");
return AVERROR(EINVAL);
}
movie->seek_point = movie->seek_point_d * 1000000 + 0.5;
VAR_4 = movie->VAR_4;
if (!VAR_4) {
snprintf(VAR_3, sizeof(VAR_3), "d%c%d",
!strcmp(ctx->filter->VAR_7, "amovie") ? 'a' : 'v',
movie->stream_index);
VAR_4 = VAR_3;
}
for (VAR_6 = VAR_4, VAR_0 = 1; *VAR_6; VAR_6++)
if (*VAR_6 == '+')
VAR_0++;
if (movie->loop_count != 1 && VAR_0 != 1) {
av_log(ctx, AV_LOG_ERROR,
"Loop with several streams is currently unsupported\n");
return AVERROR_PATCHWELCOME;
}
av_register_all();
iformat = movie->format_name ? av_find_input_format(movie->format_name) : NULL;
movie->format_ctx = NULL;
if ((VAR_1 = avformat_open_input(&movie->format_ctx, movie->file_name, iformat, NULL)) < 0) {
av_log(ctx, AV_LOG_ERROR,
"Failed to avformat_open_input '%s'\n", movie->file_name);
return VAR_1;
}
if ((VAR_1 = avformat_find_stream_info(movie->format_ctx, NULL)) < 0)
av_log(ctx, AV_LOG_WARNING, "Failed to find stream info\n");
if (movie->seek_point > 0) {
timestamp = movie->seek_point;
if (movie->format_ctx->start_time != AV_NOPTS_VALUE) {
if (timestamp > INT64_MAX - movie->format_ctx->start_time) {
av_log(ctx, AV_LOG_ERROR,
"%s: seek value overflow with start_time:%"PRId64" seek_point:%"PRId64"\n",
movie->file_name, movie->format_ctx->start_time, movie->seek_point);
return AVERROR(EINVAL);
}
timestamp += movie->format_ctx->start_time;
}
if ((VAR_1 = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD)) < 0) {
av_log(ctx, AV_LOG_ERROR, "%s: could not seek to position %"PRId64"\n",
movie->file_name, timestamp);
return VAR_1;
}
}
for (VAR_2 = 0; VAR_2 < movie->format_ctx->VAR_0; VAR_2++)
movie->format_ctx->streams[VAR_2]->discard = AVDISCARD_ALL;
movie->st = av_calloc(VAR_0, sizeof(*movie->st));
if (!movie->st)
return AVERROR(ENOMEM);
for (VAR_2 = 0; VAR_2 < VAR_0; VAR_2++) {
VAR_5 = av_strtok(VAR_4, "+", &VAR_6);
if (!VAR_5)
return AVERROR_BUG;
VAR_4 = NULL;
st = find_stream(ctx, movie->format_ctx, VAR_5);
if (!st)
return AVERROR(EINVAL);
st->discard = AVDISCARD_DEFAULT;
movie->st[VAR_2].st = st;
movie->max_stream_index = FFMAX(movie->max_stream_index, st->index);
}
if (av_strtok(NULL, "+", &VAR_6))
return AVERROR_BUG;
movie->out_index = av_calloc(movie->max_stream_index + 1,
sizeof(*movie->out_index));
if (!movie->out_index)
return AVERROR(ENOMEM);
for (VAR_2 = 0; VAR_2 <= movie->max_stream_index; VAR_2++)
movie->out_index[VAR_2] = -1;
for (VAR_2 = 0; VAR_2 < VAR_0; VAR_2++)
movie->out_index[movie->st[VAR_2].st->index] = VAR_2;
for (VAR_2 = 0; VAR_2 < VAR_0; VAR_2++) {
AVFilterPad pad = { 0 };
snprintf(VAR_7, sizeof(VAR_7), "out%d", VAR_2);
pad.type = movie->st[VAR_2].st->codec->codec_type;
pad.VAR_7 = av_strdup(VAR_7);
pad.config_props = movie_config_output_props;
pad.request_frame = movie_request_frame;
ff_insert_outpad(ctx, VAR_2, &pad);
VAR_1 = open_stream(ctx, &movie->st[VAR_2]);
if (VAR_1 < 0)
return VAR_1;
if ( movie->st[VAR_2].st->codec->codec->type == AVMEDIA_TYPE_AUDIO &&
!movie->st[VAR_2].st->codec->channel_layout) {
VAR_1 = guess_channel_layout(&movie->st[VAR_2], VAR_2, ctx);
if (VAR_1 < 0)
return VAR_1;
}
}
av_log(ctx, AV_LOG_VERBOSE, "seek_point:%"PRIi64" format_name:%s file_name:%s stream_index:%d\n",
movie->seek_point, movie->format_name, movie->file_name,
movie->stream_index);
return 0;
}
| [
"static av_cold int FUNC_0(AVFilterContext *ctx)\n{",
"MovieContext *movie = ctx->priv;",
"AVInputFormat *iformat = NULL;",
"int64_t timestamp;",
"int VAR_0, VAR_1, VAR_2;",
"char VAR_3[16], *VAR_4, *VAR_5, *VAR_6;",
"char VAR_7[16];",
"AVStream *st;",
"if (!*movie->file_name) {",
"av_log(ctx, AV_LOG_ERROR, \"No filename provided!\\n\");",
"return AVERROR(EINVAL);",
"}",
"movie->seek_point = movie->seek_point_d * 1000000 + 0.5;",
"VAR_4 = movie->VAR_4;",
"if (!VAR_4) {",
"snprintf(VAR_3, sizeof(VAR_3), \"d%c%d\",\n!strcmp(ctx->filter->VAR_7, \"amovie\") ? 'a' : 'v',\nmovie->stream_index);",
"VAR_4 = VAR_3;",
"}",
"for (VAR_6 = VAR_4, VAR_0 = 1; *VAR_6; VAR_6++)",
"if (*VAR_6 == '+')\nVAR_0++;",
"if (movie->loop_count != 1 && VAR_0 != 1) {",
"av_log(ctx, AV_LOG_ERROR,\n\"Loop with several streams is currently unsupported\\n\");",
"return AVERROR_PATCHWELCOME;",
"}",
"av_register_all();",
"iformat = movie->format_name ? av_find_input_format(movie->format_name) : NULL;",
"movie->format_ctx = NULL;",
"if ((VAR_1 = avformat_open_input(&movie->format_ctx, movie->file_name, iformat, NULL)) < 0) {",
"av_log(ctx, AV_LOG_ERROR,\n\"Failed to avformat_open_input '%s'\\n\", movie->file_name);",
"return VAR_1;",
"}",
"if ((VAR_1 = avformat_find_stream_info(movie->format_ctx, NULL)) < 0)\nav_log(ctx, AV_LOG_WARNING, \"Failed to find stream info\\n\");",
"if (movie->seek_point > 0) {",
"timestamp = movie->seek_point;",
"if (movie->format_ctx->start_time != AV_NOPTS_VALUE) {",
"if (timestamp > INT64_MAX - movie->format_ctx->start_time) {",
"av_log(ctx, AV_LOG_ERROR,\n\"%s: seek value overflow with start_time:%\"PRId64\" seek_point:%\"PRId64\"\\n\",\nmovie->file_name, movie->format_ctx->start_time, movie->seek_point);",
"return AVERROR(EINVAL);",
"}",
"timestamp += movie->format_ctx->start_time;",
"}",
"if ((VAR_1 = av_seek_frame(movie->format_ctx, -1, timestamp, AVSEEK_FLAG_BACKWARD)) < 0) {",
"av_log(ctx, AV_LOG_ERROR, \"%s: could not seek to position %\"PRId64\"\\n\",\nmovie->file_name, timestamp);",
"return VAR_1;",
"}",
"}",
"for (VAR_2 = 0; VAR_2 < movie->format_ctx->VAR_0; VAR_2++)",
"movie->format_ctx->streams[VAR_2]->discard = AVDISCARD_ALL;",
"movie->st = av_calloc(VAR_0, sizeof(*movie->st));",
"if (!movie->st)\nreturn AVERROR(ENOMEM);",
"for (VAR_2 = 0; VAR_2 < VAR_0; VAR_2++) {",
"VAR_5 = av_strtok(VAR_4, \"+\", &VAR_6);",
"if (!VAR_5)\nreturn AVERROR_BUG;",
"VAR_4 = NULL;",
"st = find_stream(ctx, movie->format_ctx, VAR_5);",
"if (!st)\nreturn AVERROR(EINVAL);",
"st->discard = AVDISCARD_DEFAULT;",
"movie->st[VAR_2].st = st;",
"movie->max_stream_index = FFMAX(movie->max_stream_index, st->index);",
"}",
"if (av_strtok(NULL, \"+\", &VAR_6))\nreturn AVERROR_BUG;",
"movie->out_index = av_calloc(movie->max_stream_index + 1,\nsizeof(*movie->out_index));",
"if (!movie->out_index)\nreturn AVERROR(ENOMEM);",
"for (VAR_2 = 0; VAR_2 <= movie->max_stream_index; VAR_2++)",
"movie->out_index[VAR_2] = -1;",
"for (VAR_2 = 0; VAR_2 < VAR_0; VAR_2++)",
"movie->out_index[movie->st[VAR_2].st->index] = VAR_2;",
"for (VAR_2 = 0; VAR_2 < VAR_0; VAR_2++) {",
"AVFilterPad pad = { 0 };",
"snprintf(VAR_7, sizeof(VAR_7), \"out%d\", VAR_2);",
"pad.type = movie->st[VAR_2].st->codec->codec_type;",
"pad.VAR_7 = av_strdup(VAR_7);",
"pad.config_props = movie_config_output_props;",
"pad.request_frame = movie_request_frame;",
"ff_insert_outpad(ctx, VAR_2, &pad);",
"VAR_1 = open_stream(ctx, &movie->st[VAR_2]);",
"if (VAR_1 < 0)\nreturn VAR_1;",
"if ( movie->st[VAR_2].st->codec->codec->type == AVMEDIA_TYPE_AUDIO &&\n!movie->st[VAR_2].st->codec->channel_layout) {",
"VAR_1 = guess_channel_layout(&movie->st[VAR_2], VAR_2, ctx);",
"if (VAR_1 < 0)\nreturn VAR_1;",
"}",
"}",
"av_log(ctx, AV_LOG_VERBOSE, \"seek_point:%\"PRIi64\" format_name:%s file_name:%s stream_index:%d\\n\",\nmovie->seek_point, movie->format_name, movie->file_name,\nmovie->stream_index);",
"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
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
35
],
[
37
],
[
39,
41,
43
],
[
45
],
[
47
],
[
49
],
[
51,
53
],
[
57
],
[
59,
61
],
[
63
],
[
65
],
[
69
],
[
75
],
[
79
],
[
81
],
[
83,
85
],
[
87
],
[
89
],
[
91,
93
],
[
99
],
[
101
],
[
105
],
[
107
],
[
109,
111,
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125,
127
],
[
129
],
[
131
],
[
133
],
[
137
],
[
139
],
[
143
],
[
145,
147
],
[
151
],
[
153
],
[
155,
157
],
[
159
],
[
161
],
[
163,
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175,
177
],
[
181,
183
],
[
185,
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217,
219
],
[
221,
223
],
[
225
],
[
227,
229
],
[
231
],
[
233
],
[
237,
239,
241
],
[
245
],
[
247
]
]
|
17,000 | static ssize_t proxy_llistxattr(FsContext *ctx, V9fsPath *fs_path,
void *value, size_t size)
{
int retval;
retval = v9fs_request(ctx->private, T_LLISTXATTR, value, "ds", size,
fs_path);
if (retval < 0) {
errno = -retval;
}
return retval;
}
| false | qemu | 494a8ebe713055d3946183f4b395f85a18b43e9e | static ssize_t proxy_llistxattr(FsContext *ctx, V9fsPath *fs_path,
void *value, size_t size)
{
int retval;
retval = v9fs_request(ctx->private, T_LLISTXATTR, value, "ds", size,
fs_path);
if (retval < 0) {
errno = -retval;
}
return retval;
}
| {
"code": [],
"line_no": []
} | static ssize_t FUNC_0(FsContext *ctx, V9fsPath *fs_path,
void *value, size_t size)
{
int VAR_0;
VAR_0 = v9fs_request(ctx->private, T_LLISTXATTR, value, "ds", size,
fs_path);
if (VAR_0 < 0) {
errno = -VAR_0;
}
return VAR_0;
}
| [
"static ssize_t FUNC_0(FsContext *ctx, V9fsPath *fs_path,\nvoid *value, size_t size)\n{",
"int VAR_0;",
"VAR_0 = v9fs_request(ctx->private, T_LLISTXATTR, value, \"ds\", size,\nfs_path);",
"if (VAR_0 < 0) {",
"errno = -VAR_0;",
"}",
"return VAR_0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
9,
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
]
]
|
17,001 | int qemu_paio_read(struct qemu_paiocb *aiocb)
{
return qemu_paio_submit(aiocb, QEMU_PAIO_READ);
}
| false | qemu | 9ef91a677110ec200d7b2904fc4bcae5a77329ad | int qemu_paio_read(struct qemu_paiocb *aiocb)
{
return qemu_paio_submit(aiocb, QEMU_PAIO_READ);
}
| {
"code": [],
"line_no": []
} | int FUNC_0(struct qemu_paiocb *VAR_0)
{
return qemu_paio_submit(VAR_0, QEMU_PAIO_READ);
}
| [
"int FUNC_0(struct qemu_paiocb *VAR_0)\n{",
"return qemu_paio_submit(VAR_0, QEMU_PAIO_READ);",
"}"
]
| [
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
]
]
|
17,002 | static void do_io_interrupt(CPUS390XState *env)
{
LowCore *lowcore;
IOIntQueue *q;
uint8_t isc;
int disable = 1;
int found = 0;
if (!(env->psw.mask & PSW_MASK_IO)) {
cpu_abort(env, "I/O int w/o I/O mask\n");
}
for (isc = 0; isc < ARRAY_SIZE(env->io_index); isc++) {
if (env->io_index[isc] < 0) {
continue;
}
if (env->io_index[isc] > MAX_IO_QUEUE) {
cpu_abort(env, "I/O queue overrun for isc %d: %d\n",
isc, env->io_index[isc]);
}
q = &env->io_queue[env->io_index[isc]][isc];
if (!(env->cregs[6] & q->word)) {
disable = 0;
continue;
}
if (!found) {
uint64_t mask, addr;
found = 1;
lowcore = cpu_map_lowcore(env);
lowcore->subchannel_id = cpu_to_be16(q->id);
lowcore->subchannel_nr = cpu_to_be16(q->nr);
lowcore->io_int_parm = cpu_to_be32(q->parm);
lowcore->io_int_word = cpu_to_be32(q->word);
lowcore->io_old_psw.mask = cpu_to_be64(get_psw_mask(env));
lowcore->io_old_psw.addr = cpu_to_be64(env->psw.addr);
mask = be64_to_cpu(lowcore->io_new_psw.mask);
addr = be64_to_cpu(lowcore->io_new_psw.addr);
cpu_unmap_lowcore(lowcore);
env->io_index[isc]--;
DPRINTF("%s: %" PRIx64 " %" PRIx64 "\n", __func__,
env->psw.mask, env->psw.addr);
load_psw(env, mask, addr);
}
if (env->io_index[isc] >= 0) {
disable = 0;
}
continue;
}
if (disable) {
env->pending_int &= ~INTERRUPT_IO;
}
}
| false | qemu | 91b0a8f33419573c1d741e49559bfb666fd8b1f0 | static void do_io_interrupt(CPUS390XState *env)
{
LowCore *lowcore;
IOIntQueue *q;
uint8_t isc;
int disable = 1;
int found = 0;
if (!(env->psw.mask & PSW_MASK_IO)) {
cpu_abort(env, "I/O int w/o I/O mask\n");
}
for (isc = 0; isc < ARRAY_SIZE(env->io_index); isc++) {
if (env->io_index[isc] < 0) {
continue;
}
if (env->io_index[isc] > MAX_IO_QUEUE) {
cpu_abort(env, "I/O queue overrun for isc %d: %d\n",
isc, env->io_index[isc]);
}
q = &env->io_queue[env->io_index[isc]][isc];
if (!(env->cregs[6] & q->word)) {
disable = 0;
continue;
}
if (!found) {
uint64_t mask, addr;
found = 1;
lowcore = cpu_map_lowcore(env);
lowcore->subchannel_id = cpu_to_be16(q->id);
lowcore->subchannel_nr = cpu_to_be16(q->nr);
lowcore->io_int_parm = cpu_to_be32(q->parm);
lowcore->io_int_word = cpu_to_be32(q->word);
lowcore->io_old_psw.mask = cpu_to_be64(get_psw_mask(env));
lowcore->io_old_psw.addr = cpu_to_be64(env->psw.addr);
mask = be64_to_cpu(lowcore->io_new_psw.mask);
addr = be64_to_cpu(lowcore->io_new_psw.addr);
cpu_unmap_lowcore(lowcore);
env->io_index[isc]--;
DPRINTF("%s: %" PRIx64 " %" PRIx64 "\n", __func__,
env->psw.mask, env->psw.addr);
load_psw(env, mask, addr);
}
if (env->io_index[isc] >= 0) {
disable = 0;
}
continue;
}
if (disable) {
env->pending_int &= ~INTERRUPT_IO;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(CPUS390XState *VAR_0)
{
LowCore *lowcore;
IOIntQueue *q;
uint8_t isc;
int VAR_1 = 1;
int VAR_2 = 0;
if (!(VAR_0->psw.mask & PSW_MASK_IO)) {
cpu_abort(VAR_0, "I/O int w/o I/O mask\n");
}
for (isc = 0; isc < ARRAY_SIZE(VAR_0->io_index); isc++) {
if (VAR_0->io_index[isc] < 0) {
continue;
}
if (VAR_0->io_index[isc] > MAX_IO_QUEUE) {
cpu_abort(VAR_0, "I/O queue overrun for isc %d: %d\n",
isc, VAR_0->io_index[isc]);
}
q = &VAR_0->io_queue[VAR_0->io_index[isc]][isc];
if (!(VAR_0->cregs[6] & q->word)) {
VAR_1 = 0;
continue;
}
if (!VAR_2) {
uint64_t mask, addr;
VAR_2 = 1;
lowcore = cpu_map_lowcore(VAR_0);
lowcore->subchannel_id = cpu_to_be16(q->id);
lowcore->subchannel_nr = cpu_to_be16(q->nr);
lowcore->io_int_parm = cpu_to_be32(q->parm);
lowcore->io_int_word = cpu_to_be32(q->word);
lowcore->io_old_psw.mask = cpu_to_be64(get_psw_mask(VAR_0));
lowcore->io_old_psw.addr = cpu_to_be64(VAR_0->psw.addr);
mask = be64_to_cpu(lowcore->io_new_psw.mask);
addr = be64_to_cpu(lowcore->io_new_psw.addr);
cpu_unmap_lowcore(lowcore);
VAR_0->io_index[isc]--;
DPRINTF("%s: %" PRIx64 " %" PRIx64 "\n", __func__,
VAR_0->psw.mask, VAR_0->psw.addr);
load_psw(VAR_0, mask, addr);
}
if (VAR_0->io_index[isc] >= 0) {
VAR_1 = 0;
}
continue;
}
if (VAR_1) {
VAR_0->pending_int &= ~INTERRUPT_IO;
}
}
| [
"static void FUNC_0(CPUS390XState *VAR_0)\n{",
"LowCore *lowcore;",
"IOIntQueue *q;",
"uint8_t isc;",
"int VAR_1 = 1;",
"int VAR_2 = 0;",
"if (!(VAR_0->psw.mask & PSW_MASK_IO)) {",
"cpu_abort(VAR_0, \"I/O int w/o I/O mask\\n\");",
"}",
"for (isc = 0; isc < ARRAY_SIZE(VAR_0->io_index); isc++) {",
"if (VAR_0->io_index[isc] < 0) {",
"continue;",
"}",
"if (VAR_0->io_index[isc] > MAX_IO_QUEUE) {",
"cpu_abort(VAR_0, \"I/O queue overrun for isc %d: %d\\n\",\nisc, VAR_0->io_index[isc]);",
"}",
"q = &VAR_0->io_queue[VAR_0->io_index[isc]][isc];",
"if (!(VAR_0->cregs[6] & q->word)) {",
"VAR_1 = 0;",
"continue;",
"}",
"if (!VAR_2) {",
"uint64_t mask, addr;",
"VAR_2 = 1;",
"lowcore = cpu_map_lowcore(VAR_0);",
"lowcore->subchannel_id = cpu_to_be16(q->id);",
"lowcore->subchannel_nr = cpu_to_be16(q->nr);",
"lowcore->io_int_parm = cpu_to_be32(q->parm);",
"lowcore->io_int_word = cpu_to_be32(q->word);",
"lowcore->io_old_psw.mask = cpu_to_be64(get_psw_mask(VAR_0));",
"lowcore->io_old_psw.addr = cpu_to_be64(VAR_0->psw.addr);",
"mask = be64_to_cpu(lowcore->io_new_psw.mask);",
"addr = be64_to_cpu(lowcore->io_new_psw.addr);",
"cpu_unmap_lowcore(lowcore);",
"VAR_0->io_index[isc]--;",
"DPRINTF(\"%s: %\" PRIx64 \" %\" PRIx64 \"\\n\", __func__,\nVAR_0->psw.mask, VAR_0->psw.addr);",
"load_psw(VAR_0, mask, addr);",
"}",
"if (VAR_0->io_index[isc] >= 0) {",
"VAR_1 = 0;",
"}",
"continue;",
"}",
"if (VAR_1) {",
"VAR_0->pending_int &= ~INTERRUPT_IO;",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
59
],
[
61
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
83
],
[
87
],
[
91,
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
111
],
[
113
],
[
115
],
[
119
]
]
|
17,003 | static int piix3_initfn(PCIDevice *dev)
{
PIIX3State *d = DO_UPCAST(PIIX3State, dev, dev);
uint8_t *pci_conf;
isa_bus_new(&d->dev.qdev);
pci_conf = d->dev.config;
pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_INTEL);
pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_INTEL_82371SB_0); // 82371SB PIIX3 PCI-to-ISA bridge (Step A1)
pci_config_set_class(pci_conf, PCI_CLASS_BRIDGE_ISA);
pci_conf[PCI_HEADER_TYPE] =
PCI_HEADER_TYPE_NORMAL | PCI_HEADER_TYPE_MULTI_FUNCTION; // header_type = PCI_multifunction, generic
qemu_register_reset(piix3_reset, d);
return 0;
}
| false | qemu | 6eab3de16d36c48a983366b09d0a0029a5260bc3 | static int piix3_initfn(PCIDevice *dev)
{
PIIX3State *d = DO_UPCAST(PIIX3State, dev, dev);
uint8_t *pci_conf;
isa_bus_new(&d->dev.qdev);
pci_conf = d->dev.config;
pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_INTEL);
pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_INTEL_82371SB_0);
pci_config_set_class(pci_conf, PCI_CLASS_BRIDGE_ISA);
pci_conf[PCI_HEADER_TYPE] =
PCI_HEADER_TYPE_NORMAL | PCI_HEADER_TYPE_MULTI_FUNCTION;
qemu_register_reset(piix3_reset, d);
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(PCIDevice *VAR_0)
{
PIIX3State *d = DO_UPCAST(PIIX3State, VAR_0, VAR_0);
uint8_t *pci_conf;
isa_bus_new(&d->VAR_0.qdev);
pci_conf = d->VAR_0.config;
pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_INTEL);
pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_INTEL_82371SB_0);
pci_config_set_class(pci_conf, PCI_CLASS_BRIDGE_ISA);
pci_conf[PCI_HEADER_TYPE] =
PCI_HEADER_TYPE_NORMAL | PCI_HEADER_TYPE_MULTI_FUNCTION;
qemu_register_reset(piix3_reset, d);
return 0;
}
| [
"static int FUNC_0(PCIDevice *VAR_0)\n{",
"PIIX3State *d = DO_UPCAST(PIIX3State, VAR_0, VAR_0);",
"uint8_t *pci_conf;",
"isa_bus_new(&d->VAR_0.qdev);",
"pci_conf = d->VAR_0.config;",
"pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_INTEL);",
"pci_config_set_device_id(pci_conf, PCI_DEVICE_ID_INTEL_82371SB_0);",
"pci_config_set_class(pci_conf, PCI_CLASS_BRIDGE_ISA);",
"pci_conf[PCI_HEADER_TYPE] =\nPCI_HEADER_TYPE_NORMAL | PCI_HEADER_TYPE_MULTI_FUNCTION;",
"qemu_register_reset(piix3_reset, d);",
"return 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
]
]
|
17,005 | static bool event_notifier_poll(void *opaque)
{
EventNotifier *e = opaque;
AioContext *ctx = container_of(e, AioContext, notifier);
return atomic_read(&ctx->notified);
}
| false | qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | static bool event_notifier_poll(void *opaque)
{
EventNotifier *e = opaque;
AioContext *ctx = container_of(e, AioContext, notifier);
return atomic_read(&ctx->notified);
}
| {
"code": [],
"line_no": []
} | static bool FUNC_0(void *opaque)
{
EventNotifier *e = opaque;
AioContext *ctx = container_of(e, AioContext, notifier);
return atomic_read(&ctx->notified);
}
| [
"static bool FUNC_0(void *opaque)\n{",
"EventNotifier *e = opaque;",
"AioContext *ctx = container_of(e, AioContext, notifier);",
"return atomic_read(&ctx->notified);",
"}"
]
| [
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
]
]
|
17,007 | coroutine_fn iscsi_co_write_zeroes(BlockDriverState *bs, int64_t sector_num,
int nb_sectors, BdrvRequestFlags flags)
{
IscsiLun *iscsilun = bs->opaque;
struct IscsiTask iTask;
uint64_t lba;
uint32_t nb_blocks;
if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
return -EINVAL;
}
if (!(flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->has_write_same) {
/* WRITE SAME without UNMAP is not supported by the target */
return -ENOTSUP;
}
if ((flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->lbp.lbpws) {
/* WRITE SAME with UNMAP is not supported by the target */
return -ENOTSUP;
}
lba = sector_qemu2lun(sector_num, iscsilun);
nb_blocks = sector_qemu2lun(nb_sectors, iscsilun);
if (iscsilun->zeroblock == NULL) {
iscsilun->zeroblock = g_malloc0(iscsilun->block_size);
}
iscsi_co_init_iscsitask(iscsilun, &iTask);
retry:
if (iscsi_writesame16_task(iscsilun->iscsi, iscsilun->lun, lba,
iscsilun->zeroblock, iscsilun->block_size,
nb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP),
0, 0, iscsi_co_generic_cb, &iTask) == NULL) {
return -ENOMEM;
}
while (!iTask.complete) {
iscsi_set_events(iscsilun);
qemu_coroutine_yield();
}
if (iTask.status == SCSI_STATUS_CHECK_CONDITION &&
iTask.task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST &&
iTask.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
/* WRITE SAME is not supported by the target */
iscsilun->has_write_same = false;
scsi_free_scsi_task(iTask.task);
return -ENOTSUP;
}
if (iTask.task != NULL) {
scsi_free_scsi_task(iTask.task);
iTask.task = NULL;
}
if (iTask.do_retry) {
iTask.complete = 0;
goto retry;
}
if (iTask.status != SCSI_STATUS_GOOD) {
return -EIO;
}
return 0;
}
| false | qemu | 27898a5daa4c6d28adb32b401a011d7198494482 | coroutine_fn iscsi_co_write_zeroes(BlockDriverState *bs, int64_t sector_num,
int nb_sectors, BdrvRequestFlags flags)
{
IscsiLun *iscsilun = bs->opaque;
struct IscsiTask iTask;
uint64_t lba;
uint32_t nb_blocks;
if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
return -EINVAL;
}
if (!(flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->has_write_same) {
return -ENOTSUP;
}
if ((flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->lbp.lbpws) {
return -ENOTSUP;
}
lba = sector_qemu2lun(sector_num, iscsilun);
nb_blocks = sector_qemu2lun(nb_sectors, iscsilun);
if (iscsilun->zeroblock == NULL) {
iscsilun->zeroblock = g_malloc0(iscsilun->block_size);
}
iscsi_co_init_iscsitask(iscsilun, &iTask);
retry:
if (iscsi_writesame16_task(iscsilun->iscsi, iscsilun->lun, lba,
iscsilun->zeroblock, iscsilun->block_size,
nb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP),
0, 0, iscsi_co_generic_cb, &iTask) == NULL) {
return -ENOMEM;
}
while (!iTask.complete) {
iscsi_set_events(iscsilun);
qemu_coroutine_yield();
}
if (iTask.status == SCSI_STATUS_CHECK_CONDITION &&
iTask.task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST &&
iTask.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
iscsilun->has_write_same = false;
scsi_free_scsi_task(iTask.task);
return -ENOTSUP;
}
if (iTask.task != NULL) {
scsi_free_scsi_task(iTask.task);
iTask.task = NULL;
}
if (iTask.do_retry) {
iTask.complete = 0;
goto retry;
}
if (iTask.status != SCSI_STATUS_GOOD) {
return -EIO;
}
return 0;
}
| {
"code": [],
"line_no": []
} | coroutine_fn FUNC_0(BlockDriverState *bs, int64_t sector_num,
int nb_sectors, BdrvRequestFlags flags)
{
IscsiLun *iscsilun = bs->opaque;
struct IscsiTask VAR_0;
uint64_t lba;
uint32_t nb_blocks;
if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {
return -EINVAL;
}
if (!(flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->has_write_same) {
return -ENOTSUP;
}
if ((flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->lbp.lbpws) {
return -ENOTSUP;
}
lba = sector_qemu2lun(sector_num, iscsilun);
nb_blocks = sector_qemu2lun(nb_sectors, iscsilun);
if (iscsilun->zeroblock == NULL) {
iscsilun->zeroblock = g_malloc0(iscsilun->block_size);
}
iscsi_co_init_iscsitask(iscsilun, &VAR_0);
retry:
if (iscsi_writesame16_task(iscsilun->iscsi, iscsilun->lun, lba,
iscsilun->zeroblock, iscsilun->block_size,
nb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP),
0, 0, iscsi_co_generic_cb, &VAR_0) == NULL) {
return -ENOMEM;
}
while (!VAR_0.complete) {
iscsi_set_events(iscsilun);
qemu_coroutine_yield();
}
if (VAR_0.status == SCSI_STATUS_CHECK_CONDITION &&
VAR_0.task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST &&
VAR_0.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {
iscsilun->has_write_same = false;
scsi_free_scsi_task(VAR_0.task);
return -ENOTSUP;
}
if (VAR_0.task != NULL) {
scsi_free_scsi_task(VAR_0.task);
VAR_0.task = NULL;
}
if (VAR_0.do_retry) {
VAR_0.complete = 0;
goto retry;
}
if (VAR_0.status != SCSI_STATUS_GOOD) {
return -EIO;
}
return 0;
}
| [
"coroutine_fn FUNC_0(BlockDriverState *bs, int64_t sector_num,\nint nb_sectors, BdrvRequestFlags flags)\n{",
"IscsiLun *iscsilun = bs->opaque;",
"struct IscsiTask VAR_0;",
"uint64_t lba;",
"uint32_t nb_blocks;",
"if (!is_request_lun_aligned(sector_num, nb_sectors, iscsilun)) {",
"return -EINVAL;",
"}",
"if (!(flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->has_write_same) {",
"return -ENOTSUP;",
"}",
"if ((flags & BDRV_REQ_MAY_UNMAP) && !iscsilun->lbp.lbpws) {",
"return -ENOTSUP;",
"}",
"lba = sector_qemu2lun(sector_num, iscsilun);",
"nb_blocks = sector_qemu2lun(nb_sectors, iscsilun);",
"if (iscsilun->zeroblock == NULL) {",
"iscsilun->zeroblock = g_malloc0(iscsilun->block_size);",
"}",
"iscsi_co_init_iscsitask(iscsilun, &VAR_0);",
"retry:\nif (iscsi_writesame16_task(iscsilun->iscsi, iscsilun->lun, lba,\niscsilun->zeroblock, iscsilun->block_size,\nnb_blocks, 0, !!(flags & BDRV_REQ_MAY_UNMAP),\n0, 0, iscsi_co_generic_cb, &VAR_0) == NULL) {",
"return -ENOMEM;",
"}",
"while (!VAR_0.complete) {",
"iscsi_set_events(iscsilun);",
"qemu_coroutine_yield();",
"}",
"if (VAR_0.status == SCSI_STATUS_CHECK_CONDITION &&\nVAR_0.task->sense.key == SCSI_SENSE_ILLEGAL_REQUEST &&\nVAR_0.task->sense.ascq == SCSI_SENSE_ASCQ_INVALID_OPERATION_CODE) {",
"iscsilun->has_write_same = false;",
"scsi_free_scsi_task(VAR_0.task);",
"return -ENOTSUP;",
"}",
"if (VAR_0.task != NULL) {",
"scsi_free_scsi_task(VAR_0.task);",
"VAR_0.task = NULL;",
"}",
"if (VAR_0.do_retry) {",
"VAR_0.complete = 0;",
"goto retry;",
"}",
"if (VAR_0.status != SCSI_STATUS_GOOD) {",
"return -EIO;",
"}",
"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
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
25
],
[
29
],
[
31
],
[
35
],
[
39
],
[
41
],
[
45
],
[
47
],
[
51
],
[
53
],
[
55
],
[
59
],
[
61,
63,
65,
67,
69
],
[
71
],
[
73
],
[
77
],
[
79
],
[
81
],
[
83
],
[
87,
89,
91
],
[
95
],
[
97
],
[
99
],
[
101
],
[
105
],
[
107
],
[
109
],
[
111
],
[
115
],
[
117
],
[
119
],
[
121
],
[
125
],
[
127
],
[
129
],
[
133
],
[
135
]
]
|
17,008 | static size_t fd_getpagesize(int fd)
{
#ifdef CONFIG_LINUX
struct statfs fs;
int ret;
if (fd != -1) {
do {
ret = fstatfs(fd, &fs);
} while (ret != 0 && errno == EINTR);
if (ret == 0 && fs.f_type == HUGETLBFS_MAGIC) {
return fs.f_bsize;
}
}
#endif
return getpagesize();
}
| false | qemu | 7197fb4058bcb68986bae2bb2c04d6370f3e7218 | static size_t fd_getpagesize(int fd)
{
#ifdef CONFIG_LINUX
struct statfs fs;
int ret;
if (fd != -1) {
do {
ret = fstatfs(fd, &fs);
} while (ret != 0 && errno == EINTR);
if (ret == 0 && fs.f_type == HUGETLBFS_MAGIC) {
return fs.f_bsize;
}
}
#endif
return getpagesize();
}
| {
"code": [],
"line_no": []
} | static size_t FUNC_0(int fd)
{
#ifdef CONFIG_LINUX
struct statfs fs;
int ret;
if (fd != -1) {
do {
ret = fstatfs(fd, &fs);
} while (ret != 0 && errno == EINTR);
if (ret == 0 && fs.f_type == HUGETLBFS_MAGIC) {
return fs.f_bsize;
}
}
#endif
return getpagesize();
}
| [
"static size_t FUNC_0(int fd)\n{",
"#ifdef CONFIG_LINUX\nstruct statfs fs;",
"int ret;",
"if (fd != -1) {",
"do {",
"ret = fstatfs(fd, &fs);",
"} while (ret != 0 && errno == EINTR);",
"if (ret == 0 && fs.f_type == HUGETLBFS_MAGIC) {",
"return fs.f_bsize;",
"}",
"}",
"#endif\nreturn getpagesize();",
"}"
]
| [
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
],
[
29
],
[
31,
35
],
[
37
]
]
|
17,010 | static void m5206_mbar_writel(void *opaque, target_phys_addr_t offset,
uint32_t value)
{
m5206_mbar_state *s = (m5206_mbar_state *)opaque;
int width;
offset &= 0x3ff;
if (offset >= 0x200) {
hw_error("Bad MBAR write offset 0x%x", (int)offset);
}
width = m5206_mbar_width[offset >> 2];
if (width < 4) {
m5206_mbar_writew(opaque, offset, value >> 16);
m5206_mbar_writew(opaque, offset + 2, value & 0xffff);
return;
}
m5206_mbar_write(s, offset, value, 4);
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | static void m5206_mbar_writel(void *opaque, target_phys_addr_t offset,
uint32_t value)
{
m5206_mbar_state *s = (m5206_mbar_state *)opaque;
int width;
offset &= 0x3ff;
if (offset >= 0x200) {
hw_error("Bad MBAR write offset 0x%x", (int)offset);
}
width = m5206_mbar_width[offset >> 2];
if (width < 4) {
m5206_mbar_writew(opaque, offset, value >> 16);
m5206_mbar_writew(opaque, offset + 2, value & 0xffff);
return;
}
m5206_mbar_write(s, offset, value, 4);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,
uint32_t VAR_2)
{
m5206_mbar_state *s = (m5206_mbar_state *)VAR_0;
int VAR_3;
VAR_1 &= 0x3ff;
if (VAR_1 >= 0x200) {
hw_error("Bad MBAR write VAR_1 0x%x", (int)VAR_1);
}
VAR_3 = m5206_mbar_width[VAR_1 >> 2];
if (VAR_3 < 4) {
m5206_mbar_writew(VAR_0, VAR_1, VAR_2 >> 16);
m5206_mbar_writew(VAR_0, VAR_1 + 2, VAR_2 & 0xffff);
return;
}
m5206_mbar_write(s, VAR_1, VAR_2, 4);
}
| [
"static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint32_t VAR_2)\n{",
"m5206_mbar_state *s = (m5206_mbar_state *)VAR_0;",
"int VAR_3;",
"VAR_1 &= 0x3ff;",
"if (VAR_1 >= 0x200) {",
"hw_error(\"Bad MBAR write VAR_1 0x%x\", (int)VAR_1);",
"}",
"VAR_3 = m5206_mbar_width[VAR_1 >> 2];",
"if (VAR_3 < 4) {",
"m5206_mbar_writew(VAR_0, VAR_1, VAR_2 >> 16);",
"m5206_mbar_writew(VAR_0, VAR_1 + 2, VAR_2 & 0xffff);",
"return;",
"}",
"m5206_mbar_write(s, VAR_1, VAR_2, 4);",
"}"
]
| [
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
]
]
|
17,011 | static QVirtIO9P *qvirtio_9p_pci_init(void)
{
QVirtIO9P *v9p;
QVirtioPCIDevice *dev;
v9p = g_new0(QVirtIO9P, 1);
v9p->alloc = pc_alloc_init();
v9p->bus = qpci_init_pc(NULL);
dev = qvirtio_pci_device_find(v9p->bus, VIRTIO_ID_9P);
g_assert_nonnull(dev);
g_assert_cmphex(dev->vdev.device_type, ==, VIRTIO_ID_9P);
v9p->dev = (QVirtioDevice *) dev;
qvirtio_pci_device_enable(dev);
qvirtio_reset(v9p->dev);
qvirtio_set_acknowledge(v9p->dev);
qvirtio_set_driver(v9p->dev);
v9p->vq = qvirtqueue_setup(v9p->dev, v9p->alloc, 0);
return v9p;
}
| false | qemu | a980f7f2c2f4d7e9a1eba4f804cd66dbd458b6d4 | static QVirtIO9P *qvirtio_9p_pci_init(void)
{
QVirtIO9P *v9p;
QVirtioPCIDevice *dev;
v9p = g_new0(QVirtIO9P, 1);
v9p->alloc = pc_alloc_init();
v9p->bus = qpci_init_pc(NULL);
dev = qvirtio_pci_device_find(v9p->bus, VIRTIO_ID_9P);
g_assert_nonnull(dev);
g_assert_cmphex(dev->vdev.device_type, ==, VIRTIO_ID_9P);
v9p->dev = (QVirtioDevice *) dev;
qvirtio_pci_device_enable(dev);
qvirtio_reset(v9p->dev);
qvirtio_set_acknowledge(v9p->dev);
qvirtio_set_driver(v9p->dev);
v9p->vq = qvirtqueue_setup(v9p->dev, v9p->alloc, 0);
return v9p;
}
| {
"code": [],
"line_no": []
} | static QVirtIO9P *FUNC_0(void)
{
QVirtIO9P *v9p;
QVirtioPCIDevice *dev;
v9p = g_new0(QVirtIO9P, 1);
v9p->alloc = pc_alloc_init();
v9p->bus = qpci_init_pc(NULL);
dev = qvirtio_pci_device_find(v9p->bus, VIRTIO_ID_9P);
g_assert_nonnull(dev);
g_assert_cmphex(dev->vdev.device_type, ==, VIRTIO_ID_9P);
v9p->dev = (QVirtioDevice *) dev;
qvirtio_pci_device_enable(dev);
qvirtio_reset(v9p->dev);
qvirtio_set_acknowledge(v9p->dev);
qvirtio_set_driver(v9p->dev);
v9p->vq = qvirtqueue_setup(v9p->dev, v9p->alloc, 0);
return v9p;
}
| [
"static QVirtIO9P *FUNC_0(void)\n{",
"QVirtIO9P *v9p;",
"QVirtioPCIDevice *dev;",
"v9p = g_new0(QVirtIO9P, 1);",
"v9p->alloc = pc_alloc_init();",
"v9p->bus = qpci_init_pc(NULL);",
"dev = qvirtio_pci_device_find(v9p->bus, VIRTIO_ID_9P);",
"g_assert_nonnull(dev);",
"g_assert_cmphex(dev->vdev.device_type, ==, VIRTIO_ID_9P);",
"v9p->dev = (QVirtioDevice *) dev;",
"qvirtio_pci_device_enable(dev);",
"qvirtio_reset(v9p->dev);",
"qvirtio_set_acknowledge(v9p->dev);",
"qvirtio_set_driver(v9p->dev);",
"v9p->vq = qvirtqueue_setup(v9p->dev, v9p->alloc, 0);",
"return v9p;",
"}"
]
| [
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
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
]
]
|
17,013 | void drive_uninit(BlockDriverState *bdrv)
{
DriveInfo *dinfo;
TAILQ_FOREACH(dinfo, &drives, next) {
if (dinfo->bdrv != bdrv)
continue;
qemu_opts_del(dinfo->opts);
TAILQ_REMOVE(&drives, dinfo, next);
qemu_free(dinfo);
break;
}
}
| false | qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | void drive_uninit(BlockDriverState *bdrv)
{
DriveInfo *dinfo;
TAILQ_FOREACH(dinfo, &drives, next) {
if (dinfo->bdrv != bdrv)
continue;
qemu_opts_del(dinfo->opts);
TAILQ_REMOVE(&drives, dinfo, next);
qemu_free(dinfo);
break;
}
}
| {
"code": [],
"line_no": []
} | void FUNC_0(BlockDriverState *VAR_0)
{
DriveInfo *dinfo;
TAILQ_FOREACH(dinfo, &drives, next) {
if (dinfo->VAR_0 != VAR_0)
continue;
qemu_opts_del(dinfo->opts);
TAILQ_REMOVE(&drives, dinfo, next);
qemu_free(dinfo);
break;
}
}
| [
"void FUNC_0(BlockDriverState *VAR_0)\n{",
"DriveInfo *dinfo;",
"TAILQ_FOREACH(dinfo, &drives, next) {",
"if (dinfo->VAR_0 != VAR_0)\ncontinue;",
"qemu_opts_del(dinfo->opts);",
"TAILQ_REMOVE(&drives, dinfo, next);",
"qemu_free(dinfo);",
"break;",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
11,
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
],
[
25
]
]
|
17,014 | static void qio_dns_resolver_lookup_data_free(gpointer opaque)
{
struct QIODNSResolverLookupData *data = opaque;
size_t i;
qapi_free_SocketAddressLegacy(data->addr);
for (i = 0; i < data->naddrs; i++) {
qapi_free_SocketAddressLegacy(data->addrs[i]);
}
g_free(data->addrs);
g_free(data);
}
| false | qemu | bd269ebc82fbaa5fe7ce5bc7c1770ac8acecd884 | static void qio_dns_resolver_lookup_data_free(gpointer opaque)
{
struct QIODNSResolverLookupData *data = opaque;
size_t i;
qapi_free_SocketAddressLegacy(data->addr);
for (i = 0; i < data->naddrs; i++) {
qapi_free_SocketAddressLegacy(data->addrs[i]);
}
g_free(data->addrs);
g_free(data);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(gpointer VAR_0)
{
struct QIODNSResolverLookupData *VAR_1 = VAR_0;
size_t i;
qapi_free_SocketAddressLegacy(VAR_1->addr);
for (i = 0; i < VAR_1->naddrs; i++) {
qapi_free_SocketAddressLegacy(VAR_1->addrs[i]);
}
g_free(VAR_1->addrs);
g_free(VAR_1);
}
| [
"static void FUNC_0(gpointer VAR_0)\n{",
"struct QIODNSResolverLookupData *VAR_1 = VAR_0;",
"size_t i;",
"qapi_free_SocketAddressLegacy(VAR_1->addr);",
"for (i = 0; i < VAR_1->naddrs; i++) {",
"qapi_free_SocketAddressLegacy(VAR_1->addrs[i]);",
"}",
"g_free(VAR_1->addrs);",
"g_free(VAR_1);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
]
]
|
17,015 | static void vnc_write(VncState *vs, const void *data, size_t len)
{
buffer_reserve(&vs->output, len);
if (buffer_empty(&vs->output)) {
qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, vnc_client_write, vs);
}
buffer_append(&vs->output, data, len);
}
| false | qemu | 5fb6c7a8b26eab1a22207d24b4784bd2b39ab54b | static void vnc_write(VncState *vs, const void *data, size_t len)
{
buffer_reserve(&vs->output, len);
if (buffer_empty(&vs->output)) {
qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, vnc_client_write, vs);
}
buffer_append(&vs->output, data, len);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(VncState *VAR_0, const void *VAR_1, size_t VAR_2)
{
buffer_reserve(&VAR_0->output, VAR_2);
if (buffer_empty(&VAR_0->output)) {
qemu_set_fd_handler2(VAR_0->csock, NULL, vnc_client_read, vnc_client_write, VAR_0);
}
buffer_append(&VAR_0->output, VAR_1, VAR_2);
}
| [
"static void FUNC_0(VncState *VAR_0, const void *VAR_1, size_t VAR_2)\n{",
"buffer_reserve(&VAR_0->output, VAR_2);",
"if (buffer_empty(&VAR_0->output)) {",
"qemu_set_fd_handler2(VAR_0->csock, NULL, vnc_client_read, vnc_client_write, VAR_0);",
"}",
"buffer_append(&VAR_0->output, VAR_1, VAR_2);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
]
]
|
17,016 | static void tcx_stip_writel(void *opaque, hwaddr addr,
uint64_t val, unsigned size)
{
TCXState *s = opaque;
int i;
uint32_t col;
if (!(addr & 4)) {
s->tmpblit = val;
} else {
addr = (addr >> 3) & 0xfffff;
col = cpu_to_be32(s->tmpblit);
if (s->depth == 24) {
for (i = 0; i < 32; i++) {
if (val & 0x80000000) {
s->vram[addr + i] = s->tmpblit;
s->vram24[addr + i] = col;
}
val <<= 1;
}
} else {
for (i = 0; i < 32; i++) {
if (val & 0x80000000) {
s->vram[addr + i] = s->tmpblit;
}
val <<= 1;
}
}
memory_region_set_dirty(&s->vram_mem, addr, 32);
}
}
| false | qemu | 973945804d95878375b487c0c5c9b2556c5e4543 | static void tcx_stip_writel(void *opaque, hwaddr addr,
uint64_t val, unsigned size)
{
TCXState *s = opaque;
int i;
uint32_t col;
if (!(addr & 4)) {
s->tmpblit = val;
} else {
addr = (addr >> 3) & 0xfffff;
col = cpu_to_be32(s->tmpblit);
if (s->depth == 24) {
for (i = 0; i < 32; i++) {
if (val & 0x80000000) {
s->vram[addr + i] = s->tmpblit;
s->vram24[addr + i] = col;
}
val <<= 1;
}
} else {
for (i = 0; i < 32; i++) {
if (val & 0x80000000) {
s->vram[addr + i] = s->tmpblit;
}
val <<= 1;
}
}
memory_region_set_dirty(&s->vram_mem, addr, 32);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0, hwaddr VAR_1,
uint64_t VAR_2, unsigned VAR_3)
{
TCXState *s = VAR_0;
int VAR_4;
uint32_t col;
if (!(VAR_1 & 4)) {
s->tmpblit = VAR_2;
} else {
VAR_1 = (VAR_1 >> 3) & 0xfffff;
col = cpu_to_be32(s->tmpblit);
if (s->depth == 24) {
for (VAR_4 = 0; VAR_4 < 32; VAR_4++) {
if (VAR_2 & 0x80000000) {
s->vram[VAR_1 + VAR_4] = s->tmpblit;
s->vram24[VAR_1 + VAR_4] = col;
}
VAR_2 <<= 1;
}
} else {
for (VAR_4 = 0; VAR_4 < 32; VAR_4++) {
if (VAR_2 & 0x80000000) {
s->vram[VAR_1 + VAR_4] = s->tmpblit;
}
VAR_2 <<= 1;
}
}
memory_region_set_dirty(&s->vram_mem, VAR_1, 32);
}
}
| [
"static void FUNC_0(void *VAR_0, hwaddr VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{",
"TCXState *s = VAR_0;",
"int VAR_4;",
"uint32_t col;",
"if (!(VAR_1 & 4)) {",
"s->tmpblit = VAR_2;",
"} else {",
"VAR_1 = (VAR_1 >> 3) & 0xfffff;",
"col = cpu_to_be32(s->tmpblit);",
"if (s->depth == 24) {",
"for (VAR_4 = 0; VAR_4 < 32; VAR_4++) {",
"if (VAR_2 & 0x80000000) {",
"s->vram[VAR_1 + VAR_4] = s->tmpblit;",
"s->vram24[VAR_1 + VAR_4] = col;",
"}",
"VAR_2 <<= 1;",
"}",
"} else {",
"for (VAR_4 = 0; VAR_4 < 32; VAR_4++) {",
"if (VAR_2 & 0x80000000) {",
"s->vram[VAR_1 + VAR_4] = s->tmpblit;",
"}",
"VAR_2 <<= 1;",
"}",
"}",
"memory_region_set_dirty(&s->vram_mem, VAR_1, 32);",
"}",
"}"
]
| [
0,
0,
0,
0,
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
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
]
]
|
17,017 | int main(int argc, char *argv[])
{
const char *sparc_machines[] = { "SPARCbook", "Voyager", "SS-20", NULL };
const char *sparc64_machines[] = { "sun4u", "sun4v", NULL };
const char *mac_machines[] = { "mac99", "g3beige", NULL };
const char *arch = qtest_get_arch();
g_test_init(&argc, &argv, NULL);
if (!strcmp(arch, "ppc") || !strcmp(arch, "ppc64")) {
add_tests(mac_machines);
} else if (!strcmp(arch, "sparc")) {
add_tests(sparc_machines);
} else if (!strcmp(arch, "sparc64")) {
add_tests(sparc64_machines);
} else {
g_assert_not_reached();
}
return g_test_run();
}
| false | qemu | 53687348813196551874409fecb49c94d20b1ae6 | int main(int argc, char *argv[])
{
const char *sparc_machines[] = { "SPARCbook", "Voyager", "SS-20", NULL };
const char *sparc64_machines[] = { "sun4u", "sun4v", NULL };
const char *mac_machines[] = { "mac99", "g3beige", NULL };
const char *arch = qtest_get_arch();
g_test_init(&argc, &argv, NULL);
if (!strcmp(arch, "ppc") || !strcmp(arch, "ppc64")) {
add_tests(mac_machines);
} else if (!strcmp(arch, "sparc")) {
add_tests(sparc_machines);
} else if (!strcmp(arch, "sparc64")) {
add_tests(sparc64_machines);
} else {
g_assert_not_reached();
}
return g_test_run();
}
| {
"code": [],
"line_no": []
} | int FUNC_0(int VAR_0, char *VAR_1[])
{
const char *VAR_2[] = { "SPARCbook", "Voyager", "SS-20", NULL };
const char *VAR_3[] = { "sun4u", "sun4v", NULL };
const char *VAR_4[] = { "mac99", "g3beige", NULL };
const char *VAR_5 = qtest_get_arch();
g_test_init(&VAR_0, &VAR_1, NULL);
if (!strcmp(VAR_5, "ppc") || !strcmp(VAR_5, "ppc64")) {
add_tests(VAR_4);
} else if (!strcmp(VAR_5, "sparc")) {
add_tests(VAR_2);
} else if (!strcmp(VAR_5, "sparc64")) {
add_tests(VAR_3);
} else {
g_assert_not_reached();
}
return g_test_run();
}
| [
"int FUNC_0(int VAR_0, char *VAR_1[])\n{",
"const char *VAR_2[] = { \"SPARCbook\", \"Voyager\", \"SS-20\", NULL };",
"const char *VAR_3[] = { \"sun4u\", \"sun4v\", NULL };",
"const char *VAR_4[] = { \"mac99\", \"g3beige\", NULL };",
"const char *VAR_5 = qtest_get_arch();",
"g_test_init(&VAR_0, &VAR_1, NULL);",
"if (!strcmp(VAR_5, \"ppc\") || !strcmp(VAR_5, \"ppc64\")) {",
"add_tests(VAR_4);",
"} else if (!strcmp(VAR_5, \"sparc\")) {",
"add_tests(VAR_2);",
"} else if (!strcmp(VAR_5, \"sparc64\")) {",
"add_tests(VAR_3);",
"} else {",
"g_assert_not_reached();",
"}",
"return g_test_run();",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
]
]
|
17,018 | ram_addr_t qemu_ram_alloc(ram_addr_t size)
{
RAMBlock *new_block;
#ifdef CONFIG_KQEMU
if (kqemu_phys_ram_base) {
return kqemu_ram_alloc(size);
}
#endif
size = TARGET_PAGE_ALIGN(size);
new_block = qemu_malloc(sizeof(*new_block));
new_block->host = qemu_vmalloc(size);
new_block->offset = last_ram_offset;
new_block->length = size;
new_block->next = ram_blocks;
ram_blocks = new_block;
phys_ram_dirty = qemu_realloc(phys_ram_dirty,
(last_ram_offset + size) >> TARGET_PAGE_BITS);
memset(phys_ram_dirty + (last_ram_offset >> TARGET_PAGE_BITS),
0xff, size >> TARGET_PAGE_BITS);
last_ram_offset += size;
if (kvm_enabled())
kvm_setup_guest_memory(new_block->host, size);
return new_block->offset;
}
| false | qemu | 4a1418e07bdcfaa3177739e04707ecaec75d89e1 | ram_addr_t qemu_ram_alloc(ram_addr_t size)
{
RAMBlock *new_block;
#ifdef CONFIG_KQEMU
if (kqemu_phys_ram_base) {
return kqemu_ram_alloc(size);
}
#endif
size = TARGET_PAGE_ALIGN(size);
new_block = qemu_malloc(sizeof(*new_block));
new_block->host = qemu_vmalloc(size);
new_block->offset = last_ram_offset;
new_block->length = size;
new_block->next = ram_blocks;
ram_blocks = new_block;
phys_ram_dirty = qemu_realloc(phys_ram_dirty,
(last_ram_offset + size) >> TARGET_PAGE_BITS);
memset(phys_ram_dirty + (last_ram_offset >> TARGET_PAGE_BITS),
0xff, size >> TARGET_PAGE_BITS);
last_ram_offset += size;
if (kvm_enabled())
kvm_setup_guest_memory(new_block->host, size);
return new_block->offset;
}
| {
"code": [],
"line_no": []
} | ram_addr_t FUNC_0(ram_addr_t size)
{
RAMBlock *new_block;
#ifdef CONFIG_KQEMU
if (kqemu_phys_ram_base) {
return kqemu_ram_alloc(size);
}
#endif
size = TARGET_PAGE_ALIGN(size);
new_block = qemu_malloc(sizeof(*new_block));
new_block->host = qemu_vmalloc(size);
new_block->offset = last_ram_offset;
new_block->length = size;
new_block->next = ram_blocks;
ram_blocks = new_block;
phys_ram_dirty = qemu_realloc(phys_ram_dirty,
(last_ram_offset + size) >> TARGET_PAGE_BITS);
memset(phys_ram_dirty + (last_ram_offset >> TARGET_PAGE_BITS),
0xff, size >> TARGET_PAGE_BITS);
last_ram_offset += size;
if (kvm_enabled())
kvm_setup_guest_memory(new_block->host, size);
return new_block->offset;
}
| [
"ram_addr_t FUNC_0(ram_addr_t size)\n{",
"RAMBlock *new_block;",
"#ifdef CONFIG_KQEMU\nif (kqemu_phys_ram_base) {",
"return kqemu_ram_alloc(size);",
"}",
"#endif\nsize = TARGET_PAGE_ALIGN(size);",
"new_block = qemu_malloc(sizeof(*new_block));",
"new_block->host = qemu_vmalloc(size);",
"new_block->offset = last_ram_offset;",
"new_block->length = size;",
"new_block->next = ram_blocks;",
"ram_blocks = new_block;",
"phys_ram_dirty = qemu_realloc(phys_ram_dirty,\n(last_ram_offset + size) >> TARGET_PAGE_BITS);",
"memset(phys_ram_dirty + (last_ram_offset >> TARGET_PAGE_BITS),\n0xff, size >> TARGET_PAGE_BITS);",
"last_ram_offset += size;",
"if (kvm_enabled())\nkvm_setup_guest_memory(new_block->host, size);",
"return new_block->offset;",
"}"
]
| [
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,
21
],
[
23
],
[
27
],
[
29
],
[
31
],
[
35
],
[
37
],
[
41,
43
],
[
45,
47
],
[
51
],
[
55,
57
],
[
61
],
[
63
]
]
|
17,019 | static void imx_gpt_write(void *opaque, hwaddr offset, uint64_t value,
unsigned size)
{
IMXGPTState *s = IMX_GPT(opaque);
uint32_t oldreg;
uint32_t reg = offset >> 2;
DPRINTF("(%s, value = 0x%08x)\n", imx_gpt_reg_name(reg),
(uint32_t)value);
switch (reg) {
case 0:
oldreg = s->cr;
s->cr = value & ~0x7c14;
if (s->cr & GPT_CR_SWR) { /* force reset */
/* handle the reset */
imx_gpt_reset(DEVICE(s));
} else {
/* set our freq, as the source might have changed */
imx_gpt_set_freq(s);
if ((oldreg ^ s->cr) & GPT_CR_EN) {
if (s->cr & GPT_CR_EN) {
if (s->cr & GPT_CR_ENMOD) {
s->next_timeout = TIMER_MAX;
ptimer_set_count(s->timer, TIMER_MAX);
imx_gpt_compute_next_timeout(s, false);
}
ptimer_run(s->timer, 1);
} else {
/* stop timer */
ptimer_stop(s->timer);
}
}
}
break;
case 1: /* Prescaler */
s->pr = value & 0xfff;
imx_gpt_set_freq(s);
break;
case 2: /* SR */
s->sr &= ~(value & 0x3f);
imx_gpt_update_int(s);
break;
case 3: /* IR -- interrupt register */
s->ir = value & 0x3f;
imx_gpt_update_int(s);
imx_gpt_compute_next_timeout(s, false);
break;
case 4: /* OCR1 -- output compare register */
s->ocr1 = value;
/* In non-freerun mode, reset count when this register is written */
if (!(s->cr & GPT_CR_FRR)) {
s->next_timeout = TIMER_MAX;
ptimer_set_limit(s->timer, TIMER_MAX, 1);
}
/* compute the new timeout */
imx_gpt_compute_next_timeout(s, false);
break;
case 5: /* OCR2 -- output compare register */
s->ocr2 = value;
/* compute the new timeout */
imx_gpt_compute_next_timeout(s, false);
break;
case 6: /* OCR3 -- output compare register */
s->ocr3 = value;
/* compute the new timeout */
imx_gpt_compute_next_timeout(s, false);
break;
default:
IPRINTF("Bad offset %x\n", reg);
break;
}
}
| false | qemu | 203d65a4706be345c209f3408d3a011a3e48f0c9 | static void imx_gpt_write(void *opaque, hwaddr offset, uint64_t value,
unsigned size)
{
IMXGPTState *s = IMX_GPT(opaque);
uint32_t oldreg;
uint32_t reg = offset >> 2;
DPRINTF("(%s, value = 0x%08x)\n", imx_gpt_reg_name(reg),
(uint32_t)value);
switch (reg) {
case 0:
oldreg = s->cr;
s->cr = value & ~0x7c14;
if (s->cr & GPT_CR_SWR) {
imx_gpt_reset(DEVICE(s));
} else {
imx_gpt_set_freq(s);
if ((oldreg ^ s->cr) & GPT_CR_EN) {
if (s->cr & GPT_CR_EN) {
if (s->cr & GPT_CR_ENMOD) {
s->next_timeout = TIMER_MAX;
ptimer_set_count(s->timer, TIMER_MAX);
imx_gpt_compute_next_timeout(s, false);
}
ptimer_run(s->timer, 1);
} else {
ptimer_stop(s->timer);
}
}
}
break;
case 1:
s->pr = value & 0xfff;
imx_gpt_set_freq(s);
break;
case 2:
s->sr &= ~(value & 0x3f);
imx_gpt_update_int(s);
break;
case 3:
s->ir = value & 0x3f;
imx_gpt_update_int(s);
imx_gpt_compute_next_timeout(s, false);
break;
case 4:
s->ocr1 = value;
if (!(s->cr & GPT_CR_FRR)) {
s->next_timeout = TIMER_MAX;
ptimer_set_limit(s->timer, TIMER_MAX, 1);
}
imx_gpt_compute_next_timeout(s, false);
break;
case 5:
s->ocr2 = value;
imx_gpt_compute_next_timeout(s, false);
break;
case 6:
s->ocr3 = value;
imx_gpt_compute_next_timeout(s, false);
break;
default:
IPRINTF("Bad offset %x\n", reg);
break;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0, hwaddr VAR_1, uint64_t VAR_2,
unsigned VAR_3)
{
IMXGPTState *s = IMX_GPT(VAR_0);
uint32_t oldreg;
uint32_t reg = VAR_1 >> 2;
DPRINTF("(%s, VAR_2 = 0x%08x)\n", imx_gpt_reg_name(reg),
(uint32_t)VAR_2);
switch (reg) {
case 0:
oldreg = s->cr;
s->cr = VAR_2 & ~0x7c14;
if (s->cr & GPT_CR_SWR) {
imx_gpt_reset(DEVICE(s));
} else {
imx_gpt_set_freq(s);
if ((oldreg ^ s->cr) & GPT_CR_EN) {
if (s->cr & GPT_CR_EN) {
if (s->cr & GPT_CR_ENMOD) {
s->next_timeout = TIMER_MAX;
ptimer_set_count(s->timer, TIMER_MAX);
imx_gpt_compute_next_timeout(s, false);
}
ptimer_run(s->timer, 1);
} else {
ptimer_stop(s->timer);
}
}
}
break;
case 1:
s->pr = VAR_2 & 0xfff;
imx_gpt_set_freq(s);
break;
case 2:
s->sr &= ~(VAR_2 & 0x3f);
imx_gpt_update_int(s);
break;
case 3:
s->ir = VAR_2 & 0x3f;
imx_gpt_update_int(s);
imx_gpt_compute_next_timeout(s, false);
break;
case 4:
s->ocr1 = VAR_2;
if (!(s->cr & GPT_CR_FRR)) {
s->next_timeout = TIMER_MAX;
ptimer_set_limit(s->timer, TIMER_MAX, 1);
}
imx_gpt_compute_next_timeout(s, false);
break;
case 5:
s->ocr2 = VAR_2;
imx_gpt_compute_next_timeout(s, false);
break;
case 6:
s->ocr3 = VAR_2;
imx_gpt_compute_next_timeout(s, false);
break;
default:
IPRINTF("Bad VAR_1 %x\n", reg);
break;
}
}
| [
"static void FUNC_0(void *VAR_0, hwaddr VAR_1, uint64_t VAR_2,\nunsigned VAR_3)\n{",
"IMXGPTState *s = IMX_GPT(VAR_0);",
"uint32_t oldreg;",
"uint32_t reg = VAR_1 >> 2;",
"DPRINTF(\"(%s, VAR_2 = 0x%08x)\\n\", imx_gpt_reg_name(reg),\n(uint32_t)VAR_2);",
"switch (reg) {",
"case 0:\noldreg = s->cr;",
"s->cr = VAR_2 & ~0x7c14;",
"if (s->cr & GPT_CR_SWR) {",
"imx_gpt_reset(DEVICE(s));",
"} else {",
"imx_gpt_set_freq(s);",
"if ((oldreg ^ s->cr) & GPT_CR_EN) {",
"if (s->cr & GPT_CR_EN) {",
"if (s->cr & GPT_CR_ENMOD) {",
"s->next_timeout = TIMER_MAX;",
"ptimer_set_count(s->timer, TIMER_MAX);",
"imx_gpt_compute_next_timeout(s, false);",
"}",
"ptimer_run(s->timer, 1);",
"} else {",
"ptimer_stop(s->timer);",
"}",
"}",
"}",
"break;",
"case 1:\ns->pr = VAR_2 & 0xfff;",
"imx_gpt_set_freq(s);",
"break;",
"case 2:\ns->sr &= ~(VAR_2 & 0x3f);",
"imx_gpt_update_int(s);",
"break;",
"case 3:\ns->ir = VAR_2 & 0x3f;",
"imx_gpt_update_int(s);",
"imx_gpt_compute_next_timeout(s, false);",
"break;",
"case 4:\ns->ocr1 = VAR_2;",
"if (!(s->cr & GPT_CR_FRR)) {",
"s->next_timeout = TIMER_MAX;",
"ptimer_set_limit(s->timer, TIMER_MAX, 1);",
"}",
"imx_gpt_compute_next_timeout(s, false);",
"break;",
"case 5:\ns->ocr2 = VAR_2;",
"imx_gpt_compute_next_timeout(s, false);",
"break;",
"case 6:\ns->ocr3 = VAR_2;",
"imx_gpt_compute_next_timeout(s, false);",
"break;",
"default:\nIPRINTF(\"Bad VAR_1 %x\\n\", reg);",
"break;",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15,
17
],
[
21
],
[
23,
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
75,
77
],
[
79
],
[
81
],
[
85,
87
],
[
89
],
[
91
],
[
95,
97
],
[
99
],
[
103
],
[
107
],
[
111,
113
],
[
119
],
[
121
],
[
123
],
[
125
],
[
131
],
[
135
],
[
139,
141
],
[
147
],
[
151
],
[
155,
157
],
[
163
],
[
167
],
[
171,
173
],
[
175
],
[
177
],
[
179
]
]
|
17,022 | void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s)
{
if (!s) {
return;
}
virtio_blk_data_plane_stop(s);
g_free(s->batch_notify_vqs);
qemu_bh_delete(s->bh);
object_unref(OBJECT(s->iothread));
g_free(s);
}
| false | qemu | 9ffe337c08388d5c587eae1d77db1b0d1a47c7b1 | void virtio_blk_data_plane_destroy(VirtIOBlockDataPlane *s)
{
if (!s) {
return;
}
virtio_blk_data_plane_stop(s);
g_free(s->batch_notify_vqs);
qemu_bh_delete(s->bh);
object_unref(OBJECT(s->iothread));
g_free(s);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(VirtIOBlockDataPlane *VAR_0)
{
if (!VAR_0) {
return;
}
virtio_blk_data_plane_stop(VAR_0);
g_free(VAR_0->batch_notify_vqs);
qemu_bh_delete(VAR_0->bh);
object_unref(OBJECT(VAR_0->iothread));
g_free(VAR_0);
}
| [
"void FUNC_0(VirtIOBlockDataPlane *VAR_0)\n{",
"if (!VAR_0) {",
"return;",
"}",
"virtio_blk_data_plane_stop(VAR_0);",
"g_free(VAR_0->batch_notify_vqs);",
"qemu_bh_delete(VAR_0->bh);",
"object_unref(OBJECT(VAR_0->iothread));",
"g_free(VAR_0);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
],
[
23
]
]
|
17,023 | int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout)
{
#ifdef CONFIG_PPOLL
if (timeout < 0) {
return ppoll((struct pollfd *)fds, nfds, NULL, NULL);
} else {
struct timespec ts;
int64_t tvsec = timeout / 1000000000LL;
/* Avoid possibly overflowing and specifying a negative number of
* seconds, which would turn a very long timeout into a busy-wait.
*/
if (tvsec > (int64_t)INT32_MAX) {
tvsec = INT32_MAX;
}
ts.tv_sec = tvsec;
ts.tv_nsec = timeout % 1000000000LL;
return ppoll((struct pollfd *)fds, nfds, &ts, NULL);
}
#else
return g_poll(fds, nfds, qemu_timeout_ns_to_ms(timeout));
#endif
}
| false | qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | int qemu_poll_ns(GPollFD *fds, guint nfds, int64_t timeout)
{
#ifdef CONFIG_PPOLL
if (timeout < 0) {
return ppoll((struct pollfd *)fds, nfds, NULL, NULL);
} else {
struct timespec ts;
int64_t tvsec = timeout / 1000000000LL;
if (tvsec > (int64_t)INT32_MAX) {
tvsec = INT32_MAX;
}
ts.tv_sec = tvsec;
ts.tv_nsec = timeout % 1000000000LL;
return ppoll((struct pollfd *)fds, nfds, &ts, NULL);
}
#else
return g_poll(fds, nfds, qemu_timeout_ns_to_ms(timeout));
#endif
}
| {
"code": [],
"line_no": []
} | int FUNC_0(GPollFD *VAR_0, guint VAR_1, int64_t VAR_2)
{
#ifdef CONFIG_PPOLL
if (VAR_2 < 0) {
return ppoll((struct pollfd *)VAR_0, VAR_1, NULL, NULL);
} else {
struct timespec ts;
int64_t tvsec = VAR_2 / 1000000000LL;
if (tvsec > (int64_t)INT32_MAX) {
tvsec = INT32_MAX;
}
ts.tv_sec = tvsec;
ts.tv_nsec = VAR_2 % 1000000000LL;
return ppoll((struct pollfd *)VAR_0, VAR_1, &ts, NULL);
}
#else
return g_poll(VAR_0, VAR_1, qemu_timeout_ns_to_ms(VAR_2));
#endif
}
| [
"int FUNC_0(GPollFD *VAR_0, guint VAR_1, int64_t VAR_2)\n{",
"#ifdef CONFIG_PPOLL\nif (VAR_2 < 0) {",
"return ppoll((struct pollfd *)VAR_0, VAR_1, NULL, NULL);",
"} else {",
"struct timespec ts;",
"int64_t tvsec = VAR_2 / 1000000000LL;",
"if (tvsec > (int64_t)INT32_MAX) {",
"tvsec = INT32_MAX;",
"}",
"ts.tv_sec = tvsec;",
"ts.tv_nsec = VAR_2 % 1000000000LL;",
"return ppoll((struct pollfd *)VAR_0, VAR_1, &ts, NULL);",
"}",
"#else\nreturn g_poll(VAR_0, VAR_1, qemu_timeout_ns_to_ms(VAR_2));",
"#endif\n}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5,
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37,
39
],
[
41,
43
]
]
|
17,025 | vreader_get_reader_by_name(const char *name)
{
VReader *reader = NULL;
VReaderListEntry *current_entry = NULL;
vreader_list_lock();
for (current_entry = vreader_list_get_first(vreader_list); current_entry;
current_entry = vreader_list_get_next(current_entry)) {
VReader *creader = vreader_list_get_reader(current_entry);
if (strcmp(creader->name, name) == 0) {
reader = creader;
break;
}
vreader_free(creader);
}
vreader_list_unlock();
return reader;
}
| false | qemu | 1687a089f103f9b7a1b4a1555068054cb46ee9e9 | vreader_get_reader_by_name(const char *name)
{
VReader *reader = NULL;
VReaderListEntry *current_entry = NULL;
vreader_list_lock();
for (current_entry = vreader_list_get_first(vreader_list); current_entry;
current_entry = vreader_list_get_next(current_entry)) {
VReader *creader = vreader_list_get_reader(current_entry);
if (strcmp(creader->name, name) == 0) {
reader = creader;
break;
}
vreader_free(creader);
}
vreader_list_unlock();
return reader;
}
| {
"code": [],
"line_no": []
} | FUNC_0(const char *VAR_0)
{
VReader *reader = NULL;
VReaderListEntry *current_entry = NULL;
vreader_list_lock();
for (current_entry = vreader_list_get_first(vreader_list); current_entry;
current_entry = vreader_list_get_next(current_entry)) {
VReader *creader = vreader_list_get_reader(current_entry);
if (strcmp(creader->VAR_0, VAR_0) == 0) {
reader = creader;
break;
}
vreader_free(creader);
}
vreader_list_unlock();
return reader;
}
| [
"FUNC_0(const char *VAR_0)\n{",
"VReader *reader = NULL;",
"VReaderListEntry *current_entry = NULL;",
"vreader_list_lock();",
"for (current_entry = vreader_list_get_first(vreader_list); current_entry;",
"current_entry = vreader_list_get_next(current_entry)) {",
"VReader *creader = vreader_list_get_reader(current_entry);",
"if (strcmp(creader->VAR_0, VAR_0) == 0) {",
"reader = creader;",
"break;",
"}",
"vreader_free(creader);",
"}",
"vreader_list_unlock();",
"return reader;",
"}"
]
| [
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
]
]
|
17,026 | static BlockDriverState *get_bs_snapshots(void)
{
BlockDriverState *bs;
DriveInfo *dinfo;
if (bs_snapshots)
return bs_snapshots;
TAILQ_FOREACH(dinfo, &drives, next) {
bs = dinfo->bdrv;
if (bdrv_can_snapshot(bs))
goto ok;
}
return NULL;
ok:
bs_snapshots = bs;
return bs;
}
| false | qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | static BlockDriverState *get_bs_snapshots(void)
{
BlockDriverState *bs;
DriveInfo *dinfo;
if (bs_snapshots)
return bs_snapshots;
TAILQ_FOREACH(dinfo, &drives, next) {
bs = dinfo->bdrv;
if (bdrv_can_snapshot(bs))
goto ok;
}
return NULL;
ok:
bs_snapshots = bs;
return bs;
}
| {
"code": [],
"line_no": []
} | static BlockDriverState *FUNC_0(void)
{
BlockDriverState *bs;
DriveInfo *dinfo;
if (bs_snapshots)
return bs_snapshots;
TAILQ_FOREACH(dinfo, &drives, next) {
bs = dinfo->bdrv;
if (bdrv_can_snapshot(bs))
goto ok;
}
return NULL;
ok:
bs_snapshots = bs;
return bs;
}
| [
"static BlockDriverState *FUNC_0(void)\n{",
"BlockDriverState *bs;",
"DriveInfo *dinfo;",
"if (bs_snapshots)\nreturn bs_snapshots;",
"TAILQ_FOREACH(dinfo, &drives, next) {",
"bs = dinfo->bdrv;",
"if (bdrv_can_snapshot(bs))\ngoto ok;",
"}",
"return NULL;",
"ok:\nbs_snapshots = bs;",
"return bs;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11,
13
],
[
15
],
[
17
],
[
19,
21
],
[
23
],
[
25
],
[
27,
29
],
[
31
],
[
33
]
]
|
17,027 | static void print_report(const char *op, struct timeval *t, int64_t offset,
int64_t count, int64_t total, int cnt, int Cflag)
{
char s1[64], s2[64], ts[64];
timestr(t, ts, sizeof(ts), Cflag ? VERBOSE_FIXED_TIME : 0);
if (!Cflag) {
cvtstr((double)total, s1, sizeof(s1));
cvtstr(tdiv((double)total, *t), s2, sizeof(s2));
printf("%s %"PRId64"/%"PRId64" bytes at offset %" PRId64 "\n",
op, total, count, offset);
printf("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n",
s1, cnt, ts, s2, tdiv((double)cnt, *t));
} else {/* bytes,ops,time,bytes/sec,ops/sec */
printf("%"PRId64",%d,%s,%.3f,%.3f\n",
total, cnt, ts,
tdiv((double)total, *t),
tdiv((double)cnt, *t));
}
}
| false | qemu | dc38852aaa4ac187d8b44201f75fc2835241912d | static void print_report(const char *op, struct timeval *t, int64_t offset,
int64_t count, int64_t total, int cnt, int Cflag)
{
char s1[64], s2[64], ts[64];
timestr(t, ts, sizeof(ts), Cflag ? VERBOSE_FIXED_TIME : 0);
if (!Cflag) {
cvtstr((double)total, s1, sizeof(s1));
cvtstr(tdiv((double)total, *t), s2, sizeof(s2));
printf("%s %"PRId64"/%"PRId64" bytes at offset %" PRId64 "\n",
op, total, count, offset);
printf("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n",
s1, cnt, ts, s2, tdiv((double)cnt, *t));
} else {
printf("%"PRId64",%d,%s,%.3f,%.3f\n",
total, cnt, ts,
tdiv((double)total, *t),
tdiv((double)cnt, *t));
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(const char *VAR_0, struct timeval *VAR_1, int64_t VAR_2,
int64_t VAR_3, int64_t VAR_4, int VAR_5, int VAR_6)
{
char VAR_7[64], VAR_8[64], VAR_9[64];
timestr(VAR_1, VAR_9, sizeof(VAR_9), VAR_6 ? VERBOSE_FIXED_TIME : 0);
if (!VAR_6) {
cvtstr((double)VAR_4, VAR_7, sizeof(VAR_7));
cvtstr(tdiv((double)VAR_4, *VAR_1), VAR_8, sizeof(VAR_8));
printf("%s %"PRId64"/%"PRId64" bytes at VAR_2 %" PRId64 "\n",
VAR_0, VAR_4, VAR_3, VAR_2);
printf("%s, %d ops; %s (%s/sec and %.4f ops/sec)\n",
VAR_7, VAR_5, VAR_9, VAR_8, tdiv((double)VAR_5, *VAR_1));
} else {
printf("%"PRId64",%d,%s,%.3f,%.3f\n",
VAR_4, VAR_5, VAR_9,
tdiv((double)VAR_4, *VAR_1),
tdiv((double)VAR_5, *VAR_1));
}
}
| [
"static void FUNC_0(const char *VAR_0, struct timeval *VAR_1, int64_t VAR_2,\nint64_t VAR_3, int64_t VAR_4, int VAR_5, int VAR_6)\n{",
"char VAR_7[64], VAR_8[64], VAR_9[64];",
"timestr(VAR_1, VAR_9, sizeof(VAR_9), VAR_6 ? VERBOSE_FIXED_TIME : 0);",
"if (!VAR_6) {",
"cvtstr((double)VAR_4, VAR_7, sizeof(VAR_7));",
"cvtstr(tdiv((double)VAR_4, *VAR_1), VAR_8, sizeof(VAR_8));",
"printf(\"%s %\"PRId64\"/%\"PRId64\" bytes at VAR_2 %\" PRId64 \"\\n\",\nVAR_0, VAR_4, VAR_3, VAR_2);",
"printf(\"%s, %d ops; %s (%s/sec and %.4f ops/sec)\\n\",",
"VAR_7, VAR_5, VAR_9, VAR_8, tdiv((double)VAR_5, *VAR_1));",
"} else {",
"printf(\"%\"PRId64\",%d,%s,%.3f,%.3f\\n\",\nVAR_4, VAR_5, VAR_9,\ntdiv((double)VAR_4, *VAR_1),\ntdiv((double)VAR_5, *VAR_1));",
"}",
"}"
]
| [
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
]
]
|
17,029 | static int tcp_set_msgfds(CharDriverState *chr, int *fds, int num)
{
TCPCharDriver *s = chr->opaque;
/* clear old pending fd array */
if (s->write_msgfds) {
g_free(s->write_msgfds);
}
if (num) {
s->write_msgfds = g_malloc(num * sizeof(int));
memcpy(s->write_msgfds, fds, num * sizeof(int));
}
s->write_msgfds_num = num;
return 0;
}
| false | qemu | ef1e1e0782e99c9dcf2b35e5310cdd8ca9211374 | static int tcp_set_msgfds(CharDriverState *chr, int *fds, int num)
{
TCPCharDriver *s = chr->opaque;
if (s->write_msgfds) {
g_free(s->write_msgfds);
}
if (num) {
s->write_msgfds = g_malloc(num * sizeof(int));
memcpy(s->write_msgfds, fds, num * sizeof(int));
}
s->write_msgfds_num = num;
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(CharDriverState *VAR_0, int *VAR_1, int VAR_2)
{
TCPCharDriver *s = VAR_0->opaque;
if (s->write_msgfds) {
g_free(s->write_msgfds);
}
if (VAR_2) {
s->write_msgfds = g_malloc(VAR_2 * sizeof(int));
memcpy(s->write_msgfds, VAR_1, VAR_2 * sizeof(int));
}
s->write_msgfds_num = VAR_2;
return 0;
}
| [
"static int FUNC_0(CharDriverState *VAR_0, int *VAR_1, int VAR_2)\n{",
"TCPCharDriver *s = VAR_0->opaque;",
"if (s->write_msgfds) {",
"g_free(s->write_msgfds);",
"}",
"if (VAR_2) {",
"s->write_msgfds = g_malloc(VAR_2 * sizeof(int));",
"memcpy(s->write_msgfds, VAR_1, VAR_2 * sizeof(int));",
"}",
"s->write_msgfds_num = VAR_2;",
"return 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
11
],
[
13
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
29
],
[
33
],
[
35
]
]
|
17,031 | static av_always_inline int normal_limit(uint8_t *p, ptrdiff_t stride, int E, int I)
{
LOAD_PIXELS
return simple_limit(p, stride, E)
&& FFABS(p3-p2) <= I && FFABS(p2-p1) <= I && FFABS(p1-p0) <= I
&& FFABS(q3-q2) <= I && FFABS(q2-q1) <= I && FFABS(q1-q0) <= I;
}
| false | FFmpeg | b8664c929437d6d079e16979c496a2db40cf2324 | static av_always_inline int normal_limit(uint8_t *p, ptrdiff_t stride, int E, int I)
{
LOAD_PIXELS
return simple_limit(p, stride, E)
&& FFABS(p3-p2) <= I && FFABS(p2-p1) <= I && FFABS(p1-p0) <= I
&& FFABS(q3-q2) <= I && FFABS(q2-q1) <= I && FFABS(q1-q0) <= I;
}
| {
"code": [],
"line_no": []
} | static av_always_inline int FUNC_0(uint8_t *p, ptrdiff_t stride, int E, int I)
{
LOAD_PIXELS
return simple_limit(p, stride, E)
&& FFABS(p3-p2) <= I && FFABS(p2-p1) <= I && FFABS(p1-p0) <= I
&& FFABS(q3-q2) <= I && FFABS(q2-q1) <= I && FFABS(q1-q0) <= I;
}
| [
"static av_always_inline int FUNC_0(uint8_t *p, ptrdiff_t stride, int E, int I)\n{",
"LOAD_PIXELS\nreturn simple_limit(p, stride, E)\n&& FFABS(p3-p2) <= I && FFABS(p2-p1) <= I && FFABS(p1-p0) <= I\n&& FFABS(q3-q2) <= I && FFABS(q2-q1) <= I && FFABS(q1-q0) <= I;",
"}"
]
| [
0,
0,
0
]
| [
[
1,
3
],
[
5,
7,
9,
11
],
[
13
]
]
|
17,032 | static void nvdimm_build_nfit(GSList *device_list, GArray *table_offsets,
GArray *table_data, GArray *linker)
{
GArray *structures = nvdimm_build_device_structure(device_list);
unsigned int header;
acpi_add_table(table_offsets, table_data);
/* NFIT header. */
header = table_data->len;
acpi_data_push(table_data, sizeof(NvdimmNfitHeader));
/* NVDIMM device structures. */
g_array_append_vals(table_data, structures->data, structures->len);
build_header(linker, table_data,
(void *)(table_data->data + header), "NFIT",
sizeof(NvdimmNfitHeader) + structures->len, 1, NULL, NULL);
g_array_free(structures, true);
}
| false | qemu | 0e9b9edae7bebfd31fdbead4ccbbce03876a7edd | static void nvdimm_build_nfit(GSList *device_list, GArray *table_offsets,
GArray *table_data, GArray *linker)
{
GArray *structures = nvdimm_build_device_structure(device_list);
unsigned int header;
acpi_add_table(table_offsets, table_data);
header = table_data->len;
acpi_data_push(table_data, sizeof(NvdimmNfitHeader));
g_array_append_vals(table_data, structures->data, structures->len);
build_header(linker, table_data,
(void *)(table_data->data + header), "NFIT",
sizeof(NvdimmNfitHeader) + structures->len, 1, NULL, NULL);
g_array_free(structures, true);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(GSList *VAR_0, GArray *VAR_1,
GArray *VAR_2, GArray *VAR_3)
{
GArray *structures = nvdimm_build_device_structure(VAR_0);
unsigned int VAR_4;
acpi_add_table(VAR_1, VAR_2);
VAR_4 = VAR_2->len;
acpi_data_push(VAR_2, sizeof(NvdimmNfitHeader));
g_array_append_vals(VAR_2, structures->data, structures->len);
build_header(VAR_3, VAR_2,
(void *)(VAR_2->data + VAR_4), "NFIT",
sizeof(NvdimmNfitHeader) + structures->len, 1, NULL, NULL);
g_array_free(structures, true);
}
| [
"static void FUNC_0(GSList *VAR_0, GArray *VAR_1,\nGArray *VAR_2, GArray *VAR_3)\n{",
"GArray *structures = nvdimm_build_device_structure(VAR_0);",
"unsigned int VAR_4;",
"acpi_add_table(VAR_1, VAR_2);",
"VAR_4 = VAR_2->len;",
"acpi_data_push(VAR_2, sizeof(NvdimmNfitHeader));",
"g_array_append_vals(VAR_2, structures->data, structures->len);",
"build_header(VAR_3, VAR_2,\n(void *)(VAR_2->data + VAR_4), \"NFIT\",\nsizeof(NvdimmNfitHeader) + structures->len, 1, NULL, NULL);",
"g_array_free(structures, true);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
13
],
[
19
],
[
21
],
[
25
],
[
29,
31,
33
],
[
35
],
[
37
]
]
|
17,034 | long disas_insn(DisasContext *s, uint8_t *pc_start)
{
int b, prefixes, aflag, dflag;
int shift, ot;
int modrm, reg, rm, mod, reg_addr, op, opreg, offset_addr, val;
unsigned int next_eip;
s->pc = pc_start;
prefixes = 0;
aflag = s->code32;
dflag = s->code32;
// cur_pc = s->pc; /* for insn generation */
next_byte:
b = ldub(s->pc);
s->pc++;
/* check prefixes */
switch (b) {
case 0xf3:
prefixes |= PREFIX_REPZ;
goto next_byte;
case 0xf2:
prefixes |= PREFIX_REPNZ;
goto next_byte;
case 0xf0:
prefixes |= PREFIX_LOCK;
goto next_byte;
case 0x2e:
prefixes |= PREFIX_CS;
goto next_byte;
case 0x36:
prefixes |= PREFIX_SS;
goto next_byte;
case 0x3e:
prefixes |= PREFIX_DS;
goto next_byte;
case 0x26:
prefixes |= PREFIX_ES;
goto next_byte;
case 0x64:
prefixes |= PREFIX_FS;
goto next_byte;
case 0x65:
prefixes |= PREFIX_GS;
goto next_byte;
case 0x66:
prefixes |= PREFIX_DATA;
goto next_byte;
case 0x67:
prefixes |= PREFIX_ADR;
goto next_byte;
case 0x9b:
prefixes |= PREFIX_FWAIT;
goto next_byte;
}
if (prefixes & PREFIX_DATA)
dflag ^= 1;
if (prefixes & PREFIX_ADR)
aflag ^= 1;
s->prefix = prefixes;
s->aflag = aflag;
s->dflag = dflag;
/* lock generation */
if (prefixes & PREFIX_LOCK)
gen_op_lock();
/* now check op code */
reswitch:
switch(b) {
case 0x0f:
/**************************/
/* extended op code */
b = ldub(s->pc++) | 0x100;
goto reswitch;
/**************************/
/* arith & logic */
case 0x00 ... 0x05:
case 0x08 ... 0x0d:
case 0x10 ... 0x15:
case 0x18 ... 0x1d:
case 0x20 ... 0x25:
case 0x28 ... 0x2d:
case 0x30 ... 0x35:
case 0x38 ... 0x3d:
{
int op, f, val;
op = (b >> 3) & 7;
f = (b >> 1) & 3;
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
switch(f) {
case 0: /* OP Ev, Gv */
modrm = ldub(s->pc++);
reg = ((modrm >> 3) & 7) + OR_EAX;
mod = (modrm >> 6) & 3;
rm = modrm & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot]();
opreg = OR_TMP0;
} else {
opreg = OR_EAX + rm;
}
gen_op(s, op, ot, opreg, reg);
if (mod != 3 && op != 7) {
gen_op_st_T0_A0[ot]();
}
break;
case 1: /* OP Gv, Ev */
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
reg = ((modrm >> 3) & 7) + OR_EAX;
rm = modrm & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T1_A0[ot]();
opreg = OR_TMP1;
} else {
opreg = OR_EAX + rm;
}
gen_op(s, op, ot, reg, opreg);
break;
case 2: /* OP A, Iv */
val = insn_get(s, ot);
gen_opi(s, op, ot, OR_EAX, val);
break;
}
}
break;
case 0x80: /* GRP1 */
case 0x81:
case 0x83:
{
int val;
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = (modrm >> 3) & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot]();
opreg = OR_TMP0;
} else {
opreg = rm + OR_EAX;
}
switch(b) {
default:
case 0x80:
case 0x81:
val = insn_get(s, ot);
break;
case 0x83:
val = (int8_t)insn_get(s, OT_BYTE);
break;
}
gen_opi(s, op, ot, opreg, val);
if (op != 7 && mod != 3) {
gen_op_st_T0_A0[ot]();
}
}
break;
/**************************/
/* inc, dec, and other misc arith */
case 0x40 ... 0x47: /* inc Gv */
ot = dflag ? OT_LONG : OT_WORD;
gen_inc(s, ot, OR_EAX + (b & 7), 1);
break;
case 0x48 ... 0x4f: /* dec Gv */
ot = dflag ? OT_LONG : OT_WORD;
gen_inc(s, ot, OR_EAX + (b & 7), -1);
break;
case 0xf6: /* GRP3 */
case 0xf7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = (modrm >> 3) & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
switch(op) {
case 0: /* test */
val = insn_get(s, ot);
gen_op_movl_T1_im(val);
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + ot;
break;
case 2: /* not */
gen_op_notl_T0();
if (mod != 3) {
gen_op_st_T0_A0[ot]();
} else {
gen_op_mov_reg_T0[ot][rm]();
}
break;
case 3: /* neg */
gen_op_negl_T0_cc();
if (mod != 3) {
gen_op_st_T0_A0[ot]();
} else {
gen_op_mov_reg_T0[ot][rm]();
}
s->cc_op = CC_OP_SUBB + ot;
break;
case 4: /* mul */
switch(ot) {
case OT_BYTE:
gen_op_mulb_AL_T0();
break;
case OT_WORD:
gen_op_mulw_AX_T0();
break;
default:
case OT_LONG:
gen_op_mull_EAX_T0();
break;
}
s->cc_op = CC_OP_MUL;
break;
case 5: /* imul */
switch(ot) {
case OT_BYTE:
gen_op_imulb_AL_T0();
break;
case OT_WORD:
gen_op_imulw_AX_T0();
break;
default:
case OT_LONG:
gen_op_imull_EAX_T0();
break;
}
s->cc_op = CC_OP_MUL;
break;
case 6: /* div */
switch(ot) {
case OT_BYTE:
gen_op_divb_AL_T0();
break;
case OT_WORD:
gen_op_divw_AX_T0();
break;
default:
case OT_LONG:
gen_op_divl_EAX_T0();
break;
}
break;
case 7: /* idiv */
switch(ot) {
case OT_BYTE:
gen_op_idivb_AL_T0();
break;
case OT_WORD:
gen_op_idivw_AX_T0();
break;
default:
case OT_LONG:
gen_op_idivl_EAX_T0();
break;
}
break;
default:
goto illegal_op;
}
break;
case 0xfe: /* GRP4 */
case 0xff: /* GRP5 */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = (modrm >> 3) & 7;
if (op >= 2 && b == 0xfe) {
goto illegal_op;
}
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (op != 3 && op != 5)
gen_op_ld_T0_A0[ot]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
switch(op) {
case 0: /* inc Ev */
gen_inc(s, ot, OR_TMP0, 1);
if (mod != 3)
gen_op_st_T0_A0[ot]();
else
gen_op_mov_reg_T0[ot][rm]();
break;
case 1: /* dec Ev */
gen_inc(s, ot, OR_TMP0, -1);
if (mod != 3)
gen_op_st_T0_A0[ot]();
else
gen_op_mov_reg_T0[ot][rm]();
break;
case 2: /* call Ev */
/* XXX: optimize if memory (no and is necessary) */
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
next_eip = s->pc - s->cs_base;
gen_op_movl_T0_im(next_eip);
gen_push_T0(s);
s->is_jmp = 1;
break;
case 3: /* lcall Ev */
/* push return segment + offset */
gen_op_movl_T0_seg(R_CS);
gen_push_T0(s);
next_eip = s->pc - s->cs_base;
gen_op_movl_T0_im(next_eip);
gen_push_T0(s);
gen_op_ld_T1_A0[ot]();
gen_op_addl_A0_im(1 << (ot - OT_WORD + 1));
gen_op_lduw_T0_A0();
gen_movl_seg_T0(s, R_CS);
gen_op_movl_T0_T1();
gen_op_jmp_T0();
s->is_jmp = 1;
break;
case 4: /* jmp Ev */
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
s->is_jmp = 1;
break;
case 5: /* ljmp Ev */
gen_op_ld_T1_A0[ot]();
gen_op_addl_A0_im(1 << (ot - OT_WORD + 1));
gen_op_lduw_T0_A0();
gen_movl_seg_T0(s, R_CS);
gen_op_movl_T0_T1();
gen_op_jmp_T0();
s->is_jmp = 1;
break;
case 6: /* push Ev */
gen_push_T0(s);
break;
default:
goto illegal_op;
}
break;
case 0x84: /* test Ev, Gv */
case 0x85:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_mov_TN_reg[ot][1][reg + OR_EAX]();
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + ot;
break;
case 0xa8: /* test eAX, Iv */
case 0xa9:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
gen_op_mov_TN_reg[ot][0][OR_EAX]();
gen_op_movl_T1_im(val);
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + ot;
break;
case 0x98: /* CWDE/CBW */
if (dflag)
gen_op_movswl_EAX_AX();
else
gen_op_movsbw_AX_AL();
break;
case 0x99: /* CDQ/CWD */
if (dflag)
gen_op_movslq_EDX_EAX();
else
gen_op_movswl_DX_AX();
break;
case 0x1af: /* imul Gv, Ev */
case 0x69: /* imul Gv, Ev, I */
case 0x6b:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = ((modrm >> 3) & 7) + OR_EAX;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
if (b == 0x69) {
val = insn_get(s, ot);
gen_op_movl_T1_im(val);
} else if (b == 0x6b) {
val = insn_get(s, OT_BYTE);
gen_op_movl_T1_im(val);
} else {
gen_op_mov_TN_reg[ot][1][reg]();
}
if (ot == OT_LONG) {
gen_op_imull_T0_T1();
} else {
gen_op_imulw_T0_T1();
}
gen_op_mov_reg_T0[ot][reg]();
s->cc_op = CC_OP_MUL;
break;
case 0x1c0:
case 0x1c1: /* xadd Ev, Gv */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (mod == 3) {
rm = modrm & 7;
gen_op_mov_TN_reg[ot][0][reg]();
gen_op_mov_TN_reg[ot][1][rm]();
gen_op_addl_T0_T1_cc();
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]();
gen_op_ld_T1_A0[ot]();
gen_op_addl_T0_T1_cc();
gen_op_st_T0_A0[ot]();
gen_op_mov_reg_T1[ot][reg]();
}
s->cc_op = CC_OP_ADDB + ot;
break;
case 0x1b0:
case 0x1b1: /* cmpxchg Ev, Gv */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
gen_op_mov_TN_reg[ot][1][reg]();
if (mod == 3) {
rm = modrm & 7;
gen_op_mov_TN_reg[ot][0][rm]();
gen_op_cmpxchg_T0_T1_EAX_cc[ot]();
gen_op_mov_reg_T0[ot][rm]();
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot]();
gen_op_cmpxchg_T0_T1_EAX_cc[ot]();
gen_op_st_T0_A0[ot]();
}
s->cc_op = CC_OP_SUBB + ot;
break;
/**************************/
/* push/pop */
case 0x50 ... 0x57: /* push */
gen_op_mov_TN_reg[OT_LONG][0][b & 7]();
gen_push_T0(s);
break;
case 0x58 ... 0x5f: /* pop */
ot = dflag ? OT_LONG : OT_WORD;
gen_pop_T0(s);
gen_op_mov_reg_T0[ot][b & 7]();
gen_pop_update(s);
break;
case 0x60: /* pusha */
gen_pusha(s);
break;
case 0x61: /* popa */
gen_popa(s);
break;
case 0x68: /* push Iv */
case 0x6a:
ot = dflag ? OT_LONG : OT_WORD;
if (b == 0x68)
val = insn_get(s, ot);
else
val = (int8_t)insn_get(s, OT_BYTE);
gen_op_movl_T0_im(val);
gen_push_T0(s);
break;
case 0x8f: /* pop Ev */
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
gen_pop_T0(s);
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
gen_pop_update(s);
break;
case 0xc8: /* enter */
{
int level;
val = lduw(s->pc);
s->pc += 2;
level = ldub(s->pc++);
gen_enter(s, val, level);
}
break;
case 0xc9: /* leave */
/* XXX: exception not precise (ESP is update before potential exception) */
if (s->ss32) {
gen_op_mov_TN_reg[OT_LONG][0][R_EBP]();
gen_op_mov_reg_T0[OT_LONG][R_ESP]();
} else {
gen_op_mov_TN_reg[OT_WORD][0][R_EBP]();
gen_op_mov_reg_T0[OT_WORD][R_ESP]();
}
gen_pop_T0(s);
ot = dflag ? OT_LONG : OT_WORD;
gen_op_mov_reg_T0[ot][R_EBP]();
gen_pop_update(s);
break;
case 0x06: /* push es */
case 0x0e: /* push cs */
case 0x16: /* push ss */
case 0x1e: /* push ds */
gen_op_movl_T0_seg(b >> 3);
gen_push_T0(s);
break;
case 0x1a0: /* push fs */
case 0x1a8: /* push gs */
gen_op_movl_T0_seg(((b >> 3) & 7) + R_FS);
gen_push_T0(s);
break;
case 0x07: /* pop es */
case 0x17: /* pop ss */
case 0x1f: /* pop ds */
gen_pop_T0(s);
gen_movl_seg_T0(s, b >> 3);
gen_pop_update(s);
break;
case 0x1a1: /* pop fs */
case 0x1a9: /* pop gs */
gen_pop_T0(s);
gen_movl_seg_T0(s, ((b >> 3) & 7) + R_FS);
gen_pop_update(s);
break;
/**************************/
/* mov */
case 0x88:
case 0x89: /* mov Gv, Ev */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
/* generate a generic store */
gen_ldst_modrm(s, modrm, ot, OR_EAX + reg, 1);
break;
case 0xc6:
case 0xc7: /* mov Ev, Iv */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
if (mod != 3)
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
val = insn_get(s, ot);
gen_op_movl_T0_im(val);
if (mod != 3)
gen_op_st_T0_A0[ot]();
else
gen_op_mov_reg_T0[ot][modrm & 7]();
break;
case 0x8a:
case 0x8b: /* mov Ev, Gv */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_mov_reg_T0[ot][reg]();
break;
case 0x8e: /* mov seg, Gv */
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
if (reg >= 6 || reg == R_CS)
goto illegal_op;
gen_movl_seg_T0(s, reg);
break;
case 0x8c: /* mov Gv, seg */
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
if (reg >= 6)
goto illegal_op;
gen_op_movl_T0_seg(reg);
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
break;
case 0x1b6: /* movzbS Gv, Eb */
case 0x1b7: /* movzwS Gv, Eb */
case 0x1be: /* movsbS Gv, Eb */
case 0x1bf: /* movswS Gv, Eb */
{
int d_ot;
/* d_ot is the size of destination */
d_ot = dflag + OT_WORD;
/* ot is the size of source */
ot = (b & 1) + OT_BYTE;
modrm = ldub(s->pc++);
reg = ((modrm >> 3) & 7) + OR_EAX;
mod = (modrm >> 6) & 3;
rm = modrm & 7;
if (mod == 3) {
gen_op_mov_TN_reg[ot][0][rm]();
switch(ot | (b & 8)) {
case OT_BYTE:
gen_op_movzbl_T0_T0();
break;
case OT_BYTE | 8:
gen_op_movsbl_T0_T0();
break;
case OT_WORD:
gen_op_movzwl_T0_T0();
break;
default:
case OT_WORD | 8:
gen_op_movswl_T0_T0();
break;
}
gen_op_mov_reg_T0[d_ot][reg]();
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (b & 8) {
gen_op_lds_T0_A0[ot]();
} else {
gen_op_ldu_T0_A0[ot]();
}
gen_op_mov_reg_T0[d_ot][reg]();
}
}
break;
case 0x8d: /* lea */
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
/* we must ensure that no segment is added */
s->prefix &= ~(PREFIX_CS | PREFIX_SS | PREFIX_DS |
PREFIX_ES | PREFIX_FS | PREFIX_GS);
val = s->addseg;
s->addseg = 0;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
s->addseg = val;
gen_op_mov_reg_A0[ot - OT_WORD][reg]();
break;
case 0xa0: /* mov EAX, Ov */
case 0xa1:
case 0xa2: /* mov Ov, EAX */
case 0xa3:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (s->aflag)
offset_addr = insn_get(s, OT_LONG);
else
offset_addr = insn_get(s, OT_WORD);
gen_op_movl_A0_im(offset_addr);
/* handle override */
/* XXX: factorize that */
{
int override, must_add_seg;
override = R_DS;
must_add_seg = s->addseg;
if (s->prefix & (PREFIX_CS | PREFIX_SS | PREFIX_DS |
PREFIX_ES | PREFIX_FS | PREFIX_GS)) {
if (s->prefix & PREFIX_ES)
override = R_ES;
else if (s->prefix & PREFIX_CS)
override = R_CS;
else if (s->prefix & PREFIX_SS)
override = R_SS;
else if (s->prefix & PREFIX_DS)
override = R_DS;
else if (s->prefix & PREFIX_FS)
override = R_FS;
else
override = R_GS;
must_add_seg = 1;
}
if (must_add_seg) {
gen_op_addl_A0_seg(offsetof(CPUX86State,seg_cache[override].base));
}
}
if ((b & 2) == 0) {
gen_op_ld_T0_A0[ot]();
gen_op_mov_reg_T0[ot][R_EAX]();
} else {
gen_op_mov_TN_reg[ot][0][R_EAX]();
gen_op_st_T0_A0[ot]();
}
break;
case 0xd7: /* xlat */
/* handle override */
gen_op_movl_A0_reg[R_EBX]();
gen_op_addl_A0_AL();
if (s->aflag == 0)
gen_op_andl_A0_ffff();
/* XXX: factorize that */
{
int override, must_add_seg;
override = R_DS;
must_add_seg = s->addseg;
if (s->prefix & (PREFIX_CS | PREFIX_SS | PREFIX_DS |
PREFIX_ES | PREFIX_FS | PREFIX_GS)) {
if (s->prefix & PREFIX_ES)
override = R_ES;
else if (s->prefix & PREFIX_CS)
override = R_CS;
else if (s->prefix & PREFIX_SS)
override = R_SS;
else if (s->prefix & PREFIX_DS)
override = R_DS;
else if (s->prefix & PREFIX_FS)
override = R_FS;
else
override = R_GS;
must_add_seg = 1;
}
if (must_add_seg) {
gen_op_addl_A0_seg(offsetof(CPUX86State,seg_cache[override].base));
}
}
gen_op_ldub_T0_A0();
gen_op_mov_reg_T0[OT_BYTE][R_EAX]();
break;
case 0xb0 ... 0xb7: /* mov R, Ib */
val = insn_get(s, OT_BYTE);
gen_op_movl_T0_im(val);
gen_op_mov_reg_T0[OT_BYTE][b & 7]();
break;
case 0xb8 ... 0xbf: /* mov R, Iv */
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
reg = OR_EAX + (b & 7);
gen_op_movl_T0_im(val);
gen_op_mov_reg_T0[ot][reg]();
break;
case 0x91 ... 0x97: /* xchg R, EAX */
ot = dflag ? OT_LONG : OT_WORD;
reg = b & 7;
rm = R_EAX;
goto do_xchg_reg;
case 0x86:
case 0x87: /* xchg Ev, Gv */
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (mod == 3) {
rm = modrm & 7;
do_xchg_reg:
gen_op_mov_TN_reg[ot][0][reg]();
gen_op_mov_TN_reg[ot][1][rm]();
gen_op_mov_reg_T0[ot][rm]();
gen_op_mov_reg_T1[ot][reg]();
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_mov_TN_reg[ot][0][reg]();
/* for xchg, lock is implicit */
if (!(prefixes & PREFIX_LOCK))
gen_op_lock();
gen_op_ld_T1_A0[ot]();
gen_op_st_T0_A0[ot]();
if (!(prefixes & PREFIX_LOCK))
gen_op_unlock();
gen_op_mov_reg_T1[ot][reg]();
}
break;
case 0xc4: /* les Gv */
op = R_ES;
goto do_lxx;
case 0xc5: /* lds Gv */
op = R_DS;
goto do_lxx;
case 0x1b2: /* lss Gv */
op = R_SS;
goto do_lxx;
case 0x1b4: /* lfs Gv */
op = R_FS;
goto do_lxx;
case 0x1b5: /* lgs Gv */
op = R_GS;
do_lxx:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
gen_op_ld_T1_A0[ot]();
gen_op_addl_A0_im(1 << (ot - OT_WORD + 1));
/* load the segment first to handle exceptions properly */
gen_op_lduw_T0_A0();
gen_movl_seg_T0(s, op);
/* then put the data */
gen_op_mov_reg_T1[ot][reg]();
break;
/************************/
/* shifts */
case 0xc0:
case 0xc1:
/* shift Ev,Ib */
shift = 2;
grp2:
{
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = (modrm >> 3) & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot]();
opreg = OR_TMP0;
} else {
opreg = rm + OR_EAX;
}
/* simpler op */
if (shift == 0) {
gen_shift(s, op, ot, opreg, OR_ECX);
} else {
if (shift == 2) {
shift = ldub(s->pc++);
}
gen_shifti(s, op, ot, opreg, shift);
}
if (mod != 3) {
gen_op_st_T0_A0[ot]();
}
}
break;
case 0xd0:
case 0xd1:
/* shift Ev,1 */
shift = 1;
goto grp2;
case 0xd2:
case 0xd3:
/* shift Ev,cl */
shift = 0;
goto grp2;
case 0x1a4: /* shld imm */
op = 0;
shift = 1;
goto do_shiftd;
case 0x1a5: /* shld cl */
op = 0;
shift = 0;
goto do_shiftd;
case 0x1ac: /* shrd imm */
op = 1;
shift = 1;
goto do_shiftd;
case 0x1ad: /* shrd cl */
op = 1;
shift = 0;
do_shiftd:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
reg = (modrm >> 3) & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
gen_op_mov_TN_reg[ot][1][reg]();
if (shift) {
val = ldub(s->pc++);
val &= 0x1f;
if (val) {
gen_op_shiftd_T0_T1_im_cc[ot - OT_WORD][op](val);
if (op == 0 && ot != OT_WORD)
s->cc_op = CC_OP_SHLB + ot;
else
s->cc_op = CC_OP_SARB + ot;
}
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_shiftd_T0_T1_ECX_cc[ot - OT_WORD][op]();
s->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */
}
if (mod != 3) {
gen_op_st_T0_A0[ot]();
} else {
gen_op_mov_reg_T0[ot][rm]();
}
break;
/************************/
/* floats */
case 0xd8 ... 0xdf:
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = ((b & 7) << 3) | ((modrm >> 3) & 7);
if (mod != 3) {
/* memory op */
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
switch(op) {
case 0x00 ... 0x07: /* fxxxs */
case 0x10 ... 0x17: /* fixxxl */
case 0x20 ... 0x27: /* fxxxl */
case 0x30 ... 0x37: /* fixxx */
{
int op1;
op1 = op & 7;
switch(op >> 4) {
case 0:
gen_op_flds_FT0_A0();
break;
case 1:
gen_op_fildl_FT0_A0();
break;
case 2:
gen_op_fldl_FT0_A0();
break;
case 3:
default:
gen_op_fild_FT0_A0();
break;
}
gen_op_fp_arith_ST0_FT0[op1]();
if (op1 == 3) {
/* fcomp needs pop */
gen_op_fpop();
}
}
break;
case 0x08: /* flds */
case 0x0a: /* fsts */
case 0x0b: /* fstps */
case 0x18: /* fildl */
case 0x1a: /* fistl */
case 0x1b: /* fistpl */
case 0x28: /* fldl */
case 0x2a: /* fstl */
case 0x2b: /* fstpl */
case 0x38: /* filds */
case 0x3a: /* fists */
case 0x3b: /* fistps */
switch(op & 7) {
case 0:
gen_op_fpush();
switch(op >> 4) {
case 0:
gen_op_flds_ST0_A0();
break;
case 1:
gen_op_fildl_ST0_A0();
break;
case 2:
gen_op_fldl_ST0_A0();
break;
case 3:
default:
gen_op_fild_ST0_A0();
break;
}
break;
default:
switch(op >> 4) {
case 0:
gen_op_fsts_ST0_A0();
break;
case 1:
gen_op_fistl_ST0_A0();
break;
case 2:
gen_op_fstl_ST0_A0();
break;
case 3:
default:
gen_op_fist_ST0_A0();
break;
}
if ((op & 7) == 3)
gen_op_fpop();
break;
}
break;
case 0x0d: /* fldcw mem */
gen_op_fldcw_A0();
break;
case 0x0f: /* fnstcw mem */
gen_op_fnstcw_A0();
break;
case 0x1d: /* fldt mem */
gen_op_fpush();
gen_op_fldt_ST0_A0();
break;
case 0x1f: /* fstpt mem */
gen_op_fstt_ST0_A0();
gen_op_fpop();
break;
case 0x2f: /* fnstsw mem */
gen_op_fnstsw_A0();
break;
case 0x3c: /* fbld */
gen_op_fpush();
gen_op_fbld_ST0_A0();
break;
case 0x3e: /* fbstp */
gen_op_fbst_ST0_A0();
gen_op_fpop();
break;
case 0x3d: /* fildll */
gen_op_fpush();
gen_op_fildll_ST0_A0();
break;
case 0x3f: /* fistpll */
gen_op_fistll_ST0_A0();
gen_op_fpop();
break;
default:
goto illegal_op;
}
} else {
/* register float ops */
opreg = rm;
switch(op) {
case 0x08: /* fld sti */
gen_op_fpush();
gen_op_fmov_ST0_STN((opreg + 1) & 7);
break;
case 0x09: /* fxchg sti */
gen_op_fxchg_ST0_STN(opreg);
break;
case 0x0a: /* grp d9/2 */
switch(rm) {
case 0: /* fnop */
break;
default:
goto illegal_op;
}
break;
case 0x0c: /* grp d9/4 */
switch(rm) {
case 0: /* fchs */
gen_op_fchs_ST0();
break;
case 1: /* fabs */
gen_op_fabs_ST0();
break;
case 4: /* ftst */
gen_op_fldz_FT0();
gen_op_fcom_ST0_FT0();
break;
case 5: /* fxam */
gen_op_fxam_ST0();
break;
default:
goto illegal_op;
}
break;
case 0x0d: /* grp d9/5 */
{
switch(rm) {
case 0:
gen_op_fpush();
gen_op_fld1_ST0();
break;
case 1:
gen_op_fpush();
gen_op_fldl2t_ST0();
break;
case 2:
gen_op_fpush();
gen_op_fldl2e_ST0();
break;
case 3:
gen_op_fpush();
gen_op_fldpi_ST0();
break;
case 4:
gen_op_fpush();
gen_op_fldlg2_ST0();
break;
case 5:
gen_op_fpush();
gen_op_fldln2_ST0();
break;
case 6:
gen_op_fpush();
gen_op_fldz_ST0();
break;
default:
goto illegal_op;
}
}
break;
case 0x0e: /* grp d9/6 */
switch(rm) {
case 0: /* f2xm1 */
gen_op_f2xm1();
break;
case 1: /* fyl2x */
gen_op_fyl2x();
break;
case 2: /* fptan */
gen_op_fptan();
break;
case 3: /* fpatan */
gen_op_fpatan();
break;
case 4: /* fxtract */
gen_op_fxtract();
break;
case 5: /* fprem1 */
gen_op_fprem1();
break;
case 6: /* fdecstp */
gen_op_fdecstp();
break;
default:
case 7: /* fincstp */
gen_op_fincstp();
break;
}
break;
case 0x0f: /* grp d9/7 */
switch(rm) {
case 0: /* fprem */
gen_op_fprem();
break;
case 1: /* fyl2xp1 */
gen_op_fyl2xp1();
break;
case 2: /* fsqrt */
gen_op_fsqrt();
break;
case 3: /* fsincos */
gen_op_fsincos();
break;
case 5: /* fscale */
gen_op_fscale();
break;
case 4: /* frndint */
gen_op_frndint();
break;
case 6: /* fsin */
gen_op_fsin();
break;
default:
case 7: /* fcos */
gen_op_fcos();
break;
}
break;
case 0x00: case 0x01: case 0x04 ... 0x07: /* fxxx st, sti */
case 0x20: case 0x21: case 0x24 ... 0x27: /* fxxx sti, st */
case 0x30: case 0x31: case 0x34 ... 0x37: /* fxxxp sti, st */
{
int op1;
op1 = op & 7;
if (op >= 0x20) {
gen_op_fp_arith_STN_ST0[op1](opreg);
if (op >= 0x30)
gen_op_fpop();
} else {
gen_op_fmov_FT0_STN(opreg);
gen_op_fp_arith_ST0_FT0[op1]();
}
}
break;
case 0x02: /* fcom */
gen_op_fmov_FT0_STN(opreg);
gen_op_fcom_ST0_FT0();
break;
case 0x03: /* fcomp */
gen_op_fmov_FT0_STN(opreg);
gen_op_fcom_ST0_FT0();
gen_op_fpop();
break;
case 0x15: /* da/5 */
switch(rm) {
case 1: /* fucompp */
gen_op_fmov_FT0_STN(1);
gen_op_fucom_ST0_FT0();
gen_op_fpop();
gen_op_fpop();
break;
default:
goto illegal_op;
}
break;
case 0x1c:
switch(rm) {
case 2: /* fclex */
gen_op_fclex();
break;
case 3: /* fninit */
gen_op_fninit();
break;
default:
goto illegal_op;
}
break;
case 0x2a: /* fst sti */
gen_op_fmov_STN_ST0(opreg);
break;
case 0x2b: /* fstp sti */
gen_op_fmov_STN_ST0(opreg);
gen_op_fpop();
break;
case 0x2c: /* fucom st(i) */
gen_op_fmov_FT0_STN(opreg);
gen_op_fucom_ST0_FT0();
break;
case 0x2d: /* fucomp st(i) */
gen_op_fmov_FT0_STN(opreg);
gen_op_fucom_ST0_FT0();
gen_op_fpop();
break;
case 0x33: /* de/3 */
switch(rm) {
case 1: /* fcompp */
gen_op_fmov_FT0_STN(1);
gen_op_fcom_ST0_FT0();
gen_op_fpop();
gen_op_fpop();
break;
default:
goto illegal_op;
}
break;
case 0x3c: /* df/4 */
switch(rm) {
case 0:
gen_op_fnstsw_EAX();
break;
default:
goto illegal_op;
}
break;
default:
goto illegal_op;
}
}
break;
/************************/
/* string ops */
case 0xa4: /* movsS */
case 0xa5:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPZ) {
gen_op_movs[3 + ot]();
} else {
gen_op_movs[ot]();
}
break;
case 0xaa: /* stosS */
case 0xab:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPZ) {
gen_op_stos[3 + ot]();
} else {
gen_op_stos[ot]();
}
break;
case 0xac: /* lodsS */
case 0xad:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPZ) {
gen_op_lods[3 + ot]();
} else {
gen_op_lods[ot]();
}
break;
case 0xae: /* scasS */
case 0xaf:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPNZ) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_scas[6 + ot]();
s->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */
} else if (prefixes & PREFIX_REPZ) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_scas[3 + ot]();
s->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */
} else {
gen_op_scas[ot]();
s->cc_op = CC_OP_SUBB + ot;
}
break;
case 0xa6: /* cmpsS */
case 0xa7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPNZ) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_cmps[6 + ot]();
s->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */
} else if (prefixes & PREFIX_REPZ) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_cmps[3 + ot]();
s->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */
} else {
gen_op_cmps[ot]();
s->cc_op = CC_OP_SUBB + ot;
}
break;
/************************/
/* port I/O */
case 0x6c: /* insS */
case 0x6d:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPZ) {
gen_op_ins[3 + ot]();
} else {
gen_op_ins[ot]();
}
break;
case 0x6e: /* outsS */
case 0x6f:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPZ) {
gen_op_outs[3 + ot]();
} else {
gen_op_outs[ot]();
}
break;
case 0xe4:
case 0xe5:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
val = ldub(s->pc++);
gen_op_movl_T0_im(val);
gen_op_in[ot]();
gen_op_mov_reg_T1[ot][R_EAX]();
break;
case 0xe6:
case 0xe7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
val = ldub(s->pc++);
gen_op_movl_T0_im(val);
gen_op_mov_TN_reg[ot][1][R_EAX]();
gen_op_out[ot]();
break;
case 0xec:
case 0xed:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
gen_op_in[ot]();
gen_op_mov_reg_T1[ot][R_EAX]();
break;
case 0xee:
case 0xef:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
gen_op_mov_TN_reg[ot][1][R_EAX]();
gen_op_out[ot]();
break;
/************************/
/* control */
case 0xc2: /* ret im */
val = ldsw(s->pc);
s->pc += 2;
gen_pop_T0(s);
if (s->ss32)
gen_op_addl_ESP_im(val + (2 << s->dflag));
else
gen_op_addw_ESP_im(val + (2 << s->dflag));
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
s->is_jmp = 1;
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();
s->is_jmp = 1;
break;
case 0xca: /* lret im */
val = ldsw(s->pc);
s->pc += 2;
/* pop offset */
gen_pop_T0(s);
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_pop_update(s);
/* pop selector */
gen_pop_T0(s);
gen_movl_seg_T0(s, R_CS);
gen_pop_update(s);
/* add stack offset */
if (s->ss32)
gen_op_addl_ESP_im(val + (2 << s->dflag));
else
gen_op_addw_ESP_im(val + (2 << s->dflag));
s->is_jmp = 1;
break;
case 0xcb: /* lret */
/* pop offset */
gen_pop_T0(s);
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_pop_update(s);
/* pop selector */
gen_pop_T0(s);
gen_movl_seg_T0(s, R_CS);
gen_pop_update(s);
s->is_jmp = 1;
break;
case 0xe8: /* call im */
{
unsigned int next_eip;
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
next_eip = s->pc - s->cs_base;
val += next_eip;
if (s->dflag == 0)
val &= 0xffff;
gen_op_movl_T0_im(next_eip);
gen_push_T0(s);
gen_op_jmp_im(val);
s->is_jmp = 1;
}
break;
case 0x9a: /* lcall im */
{
unsigned int selector, offset;
ot = dflag ? OT_LONG : OT_WORD;
offset = insn_get(s, ot);
selector = insn_get(s, OT_WORD);
/* push return segment + offset */
gen_op_movl_T0_seg(R_CS);
gen_push_T0(s);
next_eip = s->pc - s->cs_base;
gen_op_movl_T0_im(next_eip);
gen_push_T0(s);
/* change cs and pc */
gen_op_movl_T0_im(selector);
gen_movl_seg_T0(s, R_CS);
gen_op_jmp_im((unsigned long)offset);
s->is_jmp = 1;
}
break;
case 0xe9: /* jmp */
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
val += s->pc - s->cs_base;
if (s->dflag == 0)
val = val & 0xffff;
gen_op_jmp_im(val);
s->is_jmp = 1;
break;
case 0xea: /* ljmp im */
{
unsigned int selector, offset;
ot = dflag ? OT_LONG : OT_WORD;
offset = insn_get(s, ot);
selector = insn_get(s, OT_WORD);
/* change cs and pc */
gen_op_movl_T0_im(selector);
gen_movl_seg_T0(s, R_CS);
gen_op_jmp_im((unsigned long)offset);
s->is_jmp = 1;
}
break;
case 0xeb: /* jmp Jb */
val = (int8_t)insn_get(s, OT_BYTE);
val += s->pc - s->cs_base;
if (s->dflag == 0)
val = val & 0xffff;
gen_op_jmp_im(val);
s->is_jmp = 1;
break;
case 0x70 ... 0x7f: /* jcc Jb */
val = (int8_t)insn_get(s, OT_BYTE);
goto do_jcc;
case 0x180 ... 0x18f: /* jcc Jv */
if (dflag) {
val = insn_get(s, OT_LONG);
} else {
val = (int16_t)insn_get(s, OT_WORD);
}
do_jcc:
next_eip = s->pc - s->cs_base;
val += next_eip;
if (s->dflag == 0)
val &= 0xffff;
gen_jcc(s, b, val, next_eip);
s->is_jmp = 1;
break;
case 0x190 ... 0x19f: /* setcc Gv */
modrm = ldub(s->pc++);
gen_setcc(s, b);
gen_ldst_modrm(s, modrm, OT_BYTE, OR_TMP0, 1);
break;
case 0x140 ... 0x14f: /* cmov Gv, Ev */
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
gen_setcc(s, b);
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T1_A0[ot]();
} else {
rm = modrm & 7;
gen_op_mov_TN_reg[ot][1][rm]();
}
gen_op_cmov_reg_T1_T0[ot - OT_WORD][reg]();
break;
/************************/
/* flags */
case 0x9c: /* pushf */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_movl_T0_eflags();
gen_push_T0(s);
break;
case 0x9d: /* popf */
gen_pop_T0(s);
gen_op_movl_eflags_T0();
gen_pop_update(s);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x9e: /* sahf */
gen_op_mov_TN_reg[OT_BYTE][0][R_AH]();
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_movb_eflags_T0();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x9f: /* lahf */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_movl_T0_eflags();
gen_op_mov_reg_T0[OT_BYTE][R_AH]();
break;
case 0xf5: /* cmc */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_cmc();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xf8: /* clc */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_clc();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xf9: /* stc */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_stc();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xfc: /* cld */
gen_op_cld();
break;
case 0xfd: /* std */
gen_op_std();
break;
/************************/
/* bit operations */
case 0x1ba: /* bt/bts/btr/btc Gv, im */
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
op = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
rm = modrm & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
/* load shift */
val = ldub(s->pc++);
gen_op_movl_T1_im(val);
if (op < 4)
goto illegal_op;
op -= 4;
gen_op_btx_T0_T1_cc[ot - OT_WORD][op]();
s->cc_op = CC_OP_SARB + ot;
if (op != 0) {
if (mod != 3)
gen_op_st_T0_A0[ot]();
else
gen_op_mov_reg_T0[ot][rm]();
}
break;
case 0x1a3: /* bt Gv, Ev */
op = 0;
goto do_btx;
case 0x1ab: /* bts */
op = 1;
goto do_btx;
case 0x1b3: /* btr */
op = 2;
goto do_btx;
case 0x1bb: /* btc */
op = 3;
do_btx:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
rm = modrm & 7;
gen_op_mov_TN_reg[OT_LONG][1][reg]();
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
/* specific case: we need to add a displacement */
if (ot == OT_WORD)
gen_op_add_bitw_A0_T1();
else
gen_op_add_bitl_A0_T1();
gen_op_ld_T0_A0[ot]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
gen_op_btx_T0_T1_cc[ot - OT_WORD][op]();
s->cc_op = CC_OP_SARB + ot;
if (op != 0) {
if (mod != 3)
gen_op_st_T0_A0[ot]();
else
gen_op_mov_reg_T0[ot][rm]();
}
break;
case 0x1bc: /* bsf */
case 0x1bd: /* bsr */
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_bsx_T0_cc[ot - OT_WORD][b & 1]();
/* NOTE: we always write back the result. Intel doc says it is
undefined if T0 == 0 */
gen_op_mov_reg_T0[ot][reg]();
s->cc_op = CC_OP_LOGICB + ot;
break;
/************************/
/* bcd */
case 0x27: /* daa */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_daa();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x2f: /* das */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_das();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x37: /* aaa */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_aaa();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x3f: /* aas */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_aas();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xd4: /* aam */
val = ldub(s->pc++);
gen_op_aam(val);
s->cc_op = CC_OP_LOGICB;
break;
case 0xd5: /* aad */
val = ldub(s->pc++);
gen_op_aad(val);
s->cc_op = CC_OP_LOGICB;
break;
/************************/
/* misc */
case 0x90: /* nop */
break;
case 0xcc: /* int3 */
gen_op_int3((long)pc_start);
s->is_jmp = 1;
break;
case 0xcd: /* int N */
val = ldub(s->pc++);
/* XXX: currently we ignore the interrupt number */
gen_op_int_im((long)pc_start);
s->is_jmp = 1;
break;
case 0xce: /* into */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_into((long)pc_start, (long)s->pc);
s->is_jmp = 1;
break;
case 0x1c8 ... 0x1cf: /* bswap reg */
reg = b & 7;
gen_op_mov_TN_reg[OT_LONG][0][reg]();
gen_op_bswapl_T0();
gen_op_mov_reg_T0[OT_LONG][reg]();
break;
case 0xd6: /* salc */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_salc();
break;
case 0xe0: /* loopnz */
case 0xe1: /* loopz */
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
/* FALL THRU */
case 0xe2: /* loop */
case 0xe3: /* jecxz */
val = (int8_t)insn_get(s, OT_BYTE);
next_eip = s->pc - s->cs_base;
val += next_eip;
if (s->dflag == 0)
val &= 0xffff;
gen_op_loop[s->aflag][b & 3](val, next_eip);
s->is_jmp = 1;
break;
case 0x131: /* rdtsc */
gen_op_rdtsc();
break;
#if 0
case 0x1a2: /* cpuid */
gen_insn0(OP_ASM);
break;
#endif
default:
goto illegal_op;
}
/* lock generation */
if (s->prefix & PREFIX_LOCK)
gen_op_unlock();
return (long)s->pc;
illegal_op:
/* XXX: ensure that no lock was generated */
return -1;
}
| false | qemu | 9c605cb13547a5faa5cb1092e3e44ac8b0d0b841 | long disas_insn(DisasContext *s, uint8_t *pc_start)
{
int b, prefixes, aflag, dflag;
int shift, ot;
int modrm, reg, rm, mod, reg_addr, op, opreg, offset_addr, val;
unsigned int next_eip;
s->pc = pc_start;
prefixes = 0;
aflag = s->code32;
dflag = s->code32;
next_byte:
b = ldub(s->pc);
s->pc++;
switch (b) {
case 0xf3:
prefixes |= PREFIX_REPZ;
goto next_byte;
case 0xf2:
prefixes |= PREFIX_REPNZ;
goto next_byte;
case 0xf0:
prefixes |= PREFIX_LOCK;
goto next_byte;
case 0x2e:
prefixes |= PREFIX_CS;
goto next_byte;
case 0x36:
prefixes |= PREFIX_SS;
goto next_byte;
case 0x3e:
prefixes |= PREFIX_DS;
goto next_byte;
case 0x26:
prefixes |= PREFIX_ES;
goto next_byte;
case 0x64:
prefixes |= PREFIX_FS;
goto next_byte;
case 0x65:
prefixes |= PREFIX_GS;
goto next_byte;
case 0x66:
prefixes |= PREFIX_DATA;
goto next_byte;
case 0x67:
prefixes |= PREFIX_ADR;
goto next_byte;
case 0x9b:
prefixes |= PREFIX_FWAIT;
goto next_byte;
}
if (prefixes & PREFIX_DATA)
dflag ^= 1;
if (prefixes & PREFIX_ADR)
aflag ^= 1;
s->prefix = prefixes;
s->aflag = aflag;
s->dflag = dflag;
if (prefixes & PREFIX_LOCK)
gen_op_lock();
reswitch:
switch(b) {
case 0x0f:
b = ldub(s->pc++) | 0x100;
goto reswitch;
case 0x00 ... 0x05:
case 0x08 ... 0x0d:
case 0x10 ... 0x15:
case 0x18 ... 0x1d:
case 0x20 ... 0x25:
case 0x28 ... 0x2d:
case 0x30 ... 0x35:
case 0x38 ... 0x3d:
{
int op, f, val;
op = (b >> 3) & 7;
f = (b >> 1) & 3;
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
switch(f) {
case 0:
modrm = ldub(s->pc++);
reg = ((modrm >> 3) & 7) + OR_EAX;
mod = (modrm >> 6) & 3;
rm = modrm & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot]();
opreg = OR_TMP0;
} else {
opreg = OR_EAX + rm;
}
gen_op(s, op, ot, opreg, reg);
if (mod != 3 && op != 7) {
gen_op_st_T0_A0[ot]();
}
break;
case 1:
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
reg = ((modrm >> 3) & 7) + OR_EAX;
rm = modrm & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T1_A0[ot]();
opreg = OR_TMP1;
} else {
opreg = OR_EAX + rm;
}
gen_op(s, op, ot, reg, opreg);
break;
case 2:
val = insn_get(s, ot);
gen_opi(s, op, ot, OR_EAX, val);
break;
}
}
break;
case 0x80:
case 0x81:
case 0x83:
{
int val;
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = (modrm >> 3) & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot]();
opreg = OR_TMP0;
} else {
opreg = rm + OR_EAX;
}
switch(b) {
default:
case 0x80:
case 0x81:
val = insn_get(s, ot);
break;
case 0x83:
val = (int8_t)insn_get(s, OT_BYTE);
break;
}
gen_opi(s, op, ot, opreg, val);
if (op != 7 && mod != 3) {
gen_op_st_T0_A0[ot]();
}
}
break;
case 0x40 ... 0x47:
ot = dflag ? OT_LONG : OT_WORD;
gen_inc(s, ot, OR_EAX + (b & 7), 1);
break;
case 0x48 ... 0x4f:
ot = dflag ? OT_LONG : OT_WORD;
gen_inc(s, ot, OR_EAX + (b & 7), -1);
break;
case 0xf6:
case 0xf7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = (modrm >> 3) & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
switch(op) {
case 0:
val = insn_get(s, ot);
gen_op_movl_T1_im(val);
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + ot;
break;
case 2:
gen_op_notl_T0();
if (mod != 3) {
gen_op_st_T0_A0[ot]();
} else {
gen_op_mov_reg_T0[ot][rm]();
}
break;
case 3:
gen_op_negl_T0_cc();
if (mod != 3) {
gen_op_st_T0_A0[ot]();
} else {
gen_op_mov_reg_T0[ot][rm]();
}
s->cc_op = CC_OP_SUBB + ot;
break;
case 4:
switch(ot) {
case OT_BYTE:
gen_op_mulb_AL_T0();
break;
case OT_WORD:
gen_op_mulw_AX_T0();
break;
default:
case OT_LONG:
gen_op_mull_EAX_T0();
break;
}
s->cc_op = CC_OP_MUL;
break;
case 5:
switch(ot) {
case OT_BYTE:
gen_op_imulb_AL_T0();
break;
case OT_WORD:
gen_op_imulw_AX_T0();
break;
default:
case OT_LONG:
gen_op_imull_EAX_T0();
break;
}
s->cc_op = CC_OP_MUL;
break;
case 6:
switch(ot) {
case OT_BYTE:
gen_op_divb_AL_T0();
break;
case OT_WORD:
gen_op_divw_AX_T0();
break;
default:
case OT_LONG:
gen_op_divl_EAX_T0();
break;
}
break;
case 7:
switch(ot) {
case OT_BYTE:
gen_op_idivb_AL_T0();
break;
case OT_WORD:
gen_op_idivw_AX_T0();
break;
default:
case OT_LONG:
gen_op_idivl_EAX_T0();
break;
}
break;
default:
goto illegal_op;
}
break;
case 0xfe:
case 0xff:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = (modrm >> 3) & 7;
if (op >= 2 && b == 0xfe) {
goto illegal_op;
}
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (op != 3 && op != 5)
gen_op_ld_T0_A0[ot]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
switch(op) {
case 0:
gen_inc(s, ot, OR_TMP0, 1);
if (mod != 3)
gen_op_st_T0_A0[ot]();
else
gen_op_mov_reg_T0[ot][rm]();
break;
case 1:
gen_inc(s, ot, OR_TMP0, -1);
if (mod != 3)
gen_op_st_T0_A0[ot]();
else
gen_op_mov_reg_T0[ot][rm]();
break;
case 2:
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
next_eip = s->pc - s->cs_base;
gen_op_movl_T0_im(next_eip);
gen_push_T0(s);
s->is_jmp = 1;
break;
case 3:
gen_op_movl_T0_seg(R_CS);
gen_push_T0(s);
next_eip = s->pc - s->cs_base;
gen_op_movl_T0_im(next_eip);
gen_push_T0(s);
gen_op_ld_T1_A0[ot]();
gen_op_addl_A0_im(1 << (ot - OT_WORD + 1));
gen_op_lduw_T0_A0();
gen_movl_seg_T0(s, R_CS);
gen_op_movl_T0_T1();
gen_op_jmp_T0();
s->is_jmp = 1;
break;
case 4:
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
s->is_jmp = 1;
break;
case 5:
gen_op_ld_T1_A0[ot]();
gen_op_addl_A0_im(1 << (ot - OT_WORD + 1));
gen_op_lduw_T0_A0();
gen_movl_seg_T0(s, R_CS);
gen_op_movl_T0_T1();
gen_op_jmp_T0();
s->is_jmp = 1;
break;
case 6:
gen_push_T0(s);
break;
default:
goto illegal_op;
}
break;
case 0x84:
case 0x85:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_mov_TN_reg[ot][1][reg + OR_EAX]();
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + ot;
break;
case 0xa8:
case 0xa9:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
gen_op_mov_TN_reg[ot][0][OR_EAX]();
gen_op_movl_T1_im(val);
gen_op_testl_T0_T1_cc();
s->cc_op = CC_OP_LOGICB + ot;
break;
case 0x98:
if (dflag)
gen_op_movswl_EAX_AX();
else
gen_op_movsbw_AX_AL();
break;
case 0x99:
if (dflag)
gen_op_movslq_EDX_EAX();
else
gen_op_movswl_DX_AX();
break;
case 0x1af:
case 0x69:
case 0x6b:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = ((modrm >> 3) & 7) + OR_EAX;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
if (b == 0x69) {
val = insn_get(s, ot);
gen_op_movl_T1_im(val);
} else if (b == 0x6b) {
val = insn_get(s, OT_BYTE);
gen_op_movl_T1_im(val);
} else {
gen_op_mov_TN_reg[ot][1][reg]();
}
if (ot == OT_LONG) {
gen_op_imull_T0_T1();
} else {
gen_op_imulw_T0_T1();
}
gen_op_mov_reg_T0[ot][reg]();
s->cc_op = CC_OP_MUL;
break;
case 0x1c0:
case 0x1c1:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (mod == 3) {
rm = modrm & 7;
gen_op_mov_TN_reg[ot][0][reg]();
gen_op_mov_TN_reg[ot][1][rm]();
gen_op_addl_T0_T1_cc();
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]();
gen_op_ld_T1_A0[ot]();
gen_op_addl_T0_T1_cc();
gen_op_st_T0_A0[ot]();
gen_op_mov_reg_T1[ot][reg]();
}
s->cc_op = CC_OP_ADDB + ot;
break;
case 0x1b0:
case 0x1b1:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
gen_op_mov_TN_reg[ot][1][reg]();
if (mod == 3) {
rm = modrm & 7;
gen_op_mov_TN_reg[ot][0][rm]();
gen_op_cmpxchg_T0_T1_EAX_cc[ot]();
gen_op_mov_reg_T0[ot][rm]();
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot]();
gen_op_cmpxchg_T0_T1_EAX_cc[ot]();
gen_op_st_T0_A0[ot]();
}
s->cc_op = CC_OP_SUBB + ot;
break;
case 0x50 ... 0x57:
gen_op_mov_TN_reg[OT_LONG][0][b & 7]();
gen_push_T0(s);
break;
case 0x58 ... 0x5f:
ot = dflag ? OT_LONG : OT_WORD;
gen_pop_T0(s);
gen_op_mov_reg_T0[ot][b & 7]();
gen_pop_update(s);
break;
case 0x60:
gen_pusha(s);
break;
case 0x61:
gen_popa(s);
break;
case 0x68:
case 0x6a:
ot = dflag ? OT_LONG : OT_WORD;
if (b == 0x68)
val = insn_get(s, ot);
else
val = (int8_t)insn_get(s, OT_BYTE);
gen_op_movl_T0_im(val);
gen_push_T0(s);
break;
case 0x8f:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
gen_pop_T0(s);
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
gen_pop_update(s);
break;
case 0xc8:
{
int level;
val = lduw(s->pc);
s->pc += 2;
level = ldub(s->pc++);
gen_enter(s, val, level);
}
break;
case 0xc9:
if (s->ss32) {
gen_op_mov_TN_reg[OT_LONG][0][R_EBP]();
gen_op_mov_reg_T0[OT_LONG][R_ESP]();
} else {
gen_op_mov_TN_reg[OT_WORD][0][R_EBP]();
gen_op_mov_reg_T0[OT_WORD][R_ESP]();
}
gen_pop_T0(s);
ot = dflag ? OT_LONG : OT_WORD;
gen_op_mov_reg_T0[ot][R_EBP]();
gen_pop_update(s);
break;
case 0x06:
case 0x0e:
case 0x16:
case 0x1e:
gen_op_movl_T0_seg(b >> 3);
gen_push_T0(s);
break;
case 0x1a0:
case 0x1a8:
gen_op_movl_T0_seg(((b >> 3) & 7) + R_FS);
gen_push_T0(s);
break;
case 0x07:
case 0x17:
case 0x1f:
gen_pop_T0(s);
gen_movl_seg_T0(s, b >> 3);
gen_pop_update(s);
break;
case 0x1a1:
case 0x1a9:
gen_pop_T0(s);
gen_movl_seg_T0(s, ((b >> 3) & 7) + R_FS);
gen_pop_update(s);
break;
case 0x88:
case 0x89:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_EAX + reg, 1);
break;
case 0xc6:
case 0xc7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
if (mod != 3)
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
val = insn_get(s, ot);
gen_op_movl_T0_im(val);
if (mod != 3)
gen_op_st_T0_A0[ot]();
else
gen_op_mov_reg_T0[ot][modrm & 7]();
break;
case 0x8a:
case 0x8b:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_mov_reg_T0[ot][reg]();
break;
case 0x8e:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
if (reg >= 6 || reg == R_CS)
goto illegal_op;
gen_movl_seg_T0(s, reg);
break;
case 0x8c:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
if (reg >= 6)
goto illegal_op;
gen_op_movl_T0_seg(reg);
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
break;
case 0x1b6:
case 0x1b7:
case 0x1be:
case 0x1bf:
{
int d_ot;
d_ot = dflag + OT_WORD;
ot = (b & 1) + OT_BYTE;
modrm = ldub(s->pc++);
reg = ((modrm >> 3) & 7) + OR_EAX;
mod = (modrm >> 6) & 3;
rm = modrm & 7;
if (mod == 3) {
gen_op_mov_TN_reg[ot][0][rm]();
switch(ot | (b & 8)) {
case OT_BYTE:
gen_op_movzbl_T0_T0();
break;
case OT_BYTE | 8:
gen_op_movsbl_T0_T0();
break;
case OT_WORD:
gen_op_movzwl_T0_T0();
break;
default:
case OT_WORD | 8:
gen_op_movswl_T0_T0();
break;
}
gen_op_mov_reg_T0[d_ot][reg]();
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (b & 8) {
gen_op_lds_T0_A0[ot]();
} else {
gen_op_ldu_T0_A0[ot]();
}
gen_op_mov_reg_T0[d_ot][reg]();
}
}
break;
case 0x8d:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
s->prefix &= ~(PREFIX_CS | PREFIX_SS | PREFIX_DS |
PREFIX_ES | PREFIX_FS | PREFIX_GS);
val = s->addseg;
s->addseg = 0;
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
s->addseg = val;
gen_op_mov_reg_A0[ot - OT_WORD][reg]();
break;
case 0xa0:
case 0xa1:
case 0xa2:
case 0xa3:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (s->aflag)
offset_addr = insn_get(s, OT_LONG);
else
offset_addr = insn_get(s, OT_WORD);
gen_op_movl_A0_im(offset_addr);
{
int override, must_add_seg;
override = R_DS;
must_add_seg = s->addseg;
if (s->prefix & (PREFIX_CS | PREFIX_SS | PREFIX_DS |
PREFIX_ES | PREFIX_FS | PREFIX_GS)) {
if (s->prefix & PREFIX_ES)
override = R_ES;
else if (s->prefix & PREFIX_CS)
override = R_CS;
else if (s->prefix & PREFIX_SS)
override = R_SS;
else if (s->prefix & PREFIX_DS)
override = R_DS;
else if (s->prefix & PREFIX_FS)
override = R_FS;
else
override = R_GS;
must_add_seg = 1;
}
if (must_add_seg) {
gen_op_addl_A0_seg(offsetof(CPUX86State,seg_cache[override].base));
}
}
if ((b & 2) == 0) {
gen_op_ld_T0_A0[ot]();
gen_op_mov_reg_T0[ot][R_EAX]();
} else {
gen_op_mov_TN_reg[ot][0][R_EAX]();
gen_op_st_T0_A0[ot]();
}
break;
case 0xd7:
gen_op_movl_A0_reg[R_EBX]();
gen_op_addl_A0_AL();
if (s->aflag == 0)
gen_op_andl_A0_ffff();
{
int override, must_add_seg;
override = R_DS;
must_add_seg = s->addseg;
if (s->prefix & (PREFIX_CS | PREFIX_SS | PREFIX_DS |
PREFIX_ES | PREFIX_FS | PREFIX_GS)) {
if (s->prefix & PREFIX_ES)
override = R_ES;
else if (s->prefix & PREFIX_CS)
override = R_CS;
else if (s->prefix & PREFIX_SS)
override = R_SS;
else if (s->prefix & PREFIX_DS)
override = R_DS;
else if (s->prefix & PREFIX_FS)
override = R_FS;
else
override = R_GS;
must_add_seg = 1;
}
if (must_add_seg) {
gen_op_addl_A0_seg(offsetof(CPUX86State,seg_cache[override].base));
}
}
gen_op_ldub_T0_A0();
gen_op_mov_reg_T0[OT_BYTE][R_EAX]();
break;
case 0xb0 ... 0xb7:
val = insn_get(s, OT_BYTE);
gen_op_movl_T0_im(val);
gen_op_mov_reg_T0[OT_BYTE][b & 7]();
break;
case 0xb8 ... 0xbf:
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
reg = OR_EAX + (b & 7);
gen_op_movl_T0_im(val);
gen_op_mov_reg_T0[ot][reg]();
break;
case 0x91 ... 0x97:
ot = dflag ? OT_LONG : OT_WORD;
reg = b & 7;
rm = R_EAX;
goto do_xchg_reg;
case 0x86:
case 0x87:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (mod == 3) {
rm = modrm & 7;
do_xchg_reg:
gen_op_mov_TN_reg[ot][0][reg]();
gen_op_mov_TN_reg[ot][1][rm]();
gen_op_mov_reg_T0[ot][rm]();
gen_op_mov_reg_T1[ot][reg]();
} else {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_mov_TN_reg[ot][0][reg]();
if (!(prefixes & PREFIX_LOCK))
gen_op_lock();
gen_op_ld_T1_A0[ot]();
gen_op_st_T0_A0[ot]();
if (!(prefixes & PREFIX_LOCK))
gen_op_unlock();
gen_op_mov_reg_T1[ot][reg]();
}
break;
case 0xc4:
op = R_ES;
goto do_lxx;
case 0xc5:
op = R_DS;
goto do_lxx;
case 0x1b2:
op = R_SS;
goto do_lxx;
case 0x1b4:
op = R_FS;
goto do_lxx;
case 0x1b5:
op = R_GS;
do_lxx:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
if (mod == 3)
goto illegal_op;
gen_op_ld_T1_A0[ot]();
gen_op_addl_A0_im(1 << (ot - OT_WORD + 1));
gen_op_lduw_T0_A0();
gen_movl_seg_T0(s, op);
gen_op_mov_reg_T1[ot][reg]();
break;
case 0xc0:
case 0xc1:
shift = 2;
grp2:
{
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = (modrm >> 3) & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot]();
opreg = OR_TMP0;
} else {
opreg = rm + OR_EAX;
}
if (shift == 0) {
gen_shift(s, op, ot, opreg, OR_ECX);
} else {
if (shift == 2) {
shift = ldub(s->pc++);
}
gen_shifti(s, op, ot, opreg, shift);
}
if (mod != 3) {
gen_op_st_T0_A0[ot]();
}
}
break;
case 0xd0:
case 0xd1:
shift = 1;
goto grp2;
case 0xd2:
case 0xd3:
shift = 0;
goto grp2;
case 0x1a4:
op = 0;
shift = 1;
goto do_shiftd;
case 0x1a5:
op = 0;
shift = 0;
goto do_shiftd;
case 0x1ac:
op = 1;
shift = 1;
goto do_shiftd;
case 0x1ad:
op = 1;
shift = 0;
do_shiftd:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
reg = (modrm >> 3) & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
gen_op_mov_TN_reg[ot][1][reg]();
if (shift) {
val = ldub(s->pc++);
val &= 0x1f;
if (val) {
gen_op_shiftd_T0_T1_im_cc[ot - OT_WORD][op](val);
if (op == 0 && ot != OT_WORD)
s->cc_op = CC_OP_SHLB + ot;
else
s->cc_op = CC_OP_SARB + ot;
}
} else {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_shiftd_T0_T1_ECX_cc[ot - OT_WORD][op]();
s->cc_op = CC_OP_DYNAMIC;
}
if (mod != 3) {
gen_op_st_T0_A0[ot]();
} else {
gen_op_mov_reg_T0[ot][rm]();
}
break;
case 0xd8 ... 0xdf:
modrm = ldub(s->pc++);
mod = (modrm >> 6) & 3;
rm = modrm & 7;
op = ((b & 7) << 3) | ((modrm >> 3) & 7);
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
switch(op) {
case 0x00 ... 0x07:
case 0x10 ... 0x17:
case 0x20 ... 0x27:
case 0x30 ... 0x37:
{
int op1;
op1 = op & 7;
switch(op >> 4) {
case 0:
gen_op_flds_FT0_A0();
break;
case 1:
gen_op_fildl_FT0_A0();
break;
case 2:
gen_op_fldl_FT0_A0();
break;
case 3:
default:
gen_op_fild_FT0_A0();
break;
}
gen_op_fp_arith_ST0_FT0[op1]();
if (op1 == 3) {
gen_op_fpop();
}
}
break;
case 0x08:
case 0x0a:
case 0x0b:
case 0x18:
case 0x1a:
case 0x1b:
case 0x28:
case 0x2a:
case 0x2b:
case 0x38:
case 0x3a:
case 0x3b:
switch(op & 7) {
case 0:
gen_op_fpush();
switch(op >> 4) {
case 0:
gen_op_flds_ST0_A0();
break;
case 1:
gen_op_fildl_ST0_A0();
break;
case 2:
gen_op_fldl_ST0_A0();
break;
case 3:
default:
gen_op_fild_ST0_A0();
break;
}
break;
default:
switch(op >> 4) {
case 0:
gen_op_fsts_ST0_A0();
break;
case 1:
gen_op_fistl_ST0_A0();
break;
case 2:
gen_op_fstl_ST0_A0();
break;
case 3:
default:
gen_op_fist_ST0_A0();
break;
}
if ((op & 7) == 3)
gen_op_fpop();
break;
}
break;
case 0x0d:
gen_op_fldcw_A0();
break;
case 0x0f:
gen_op_fnstcw_A0();
break;
case 0x1d:
gen_op_fpush();
gen_op_fldt_ST0_A0();
break;
case 0x1f:
gen_op_fstt_ST0_A0();
gen_op_fpop();
break;
case 0x2f:
gen_op_fnstsw_A0();
break;
case 0x3c:
gen_op_fpush();
gen_op_fbld_ST0_A0();
break;
case 0x3e:
gen_op_fbst_ST0_A0();
gen_op_fpop();
break;
case 0x3d:
gen_op_fpush();
gen_op_fildll_ST0_A0();
break;
case 0x3f:
gen_op_fistll_ST0_A0();
gen_op_fpop();
break;
default:
goto illegal_op;
}
} else {
opreg = rm;
switch(op) {
case 0x08:
gen_op_fpush();
gen_op_fmov_ST0_STN((opreg + 1) & 7);
break;
case 0x09:
gen_op_fxchg_ST0_STN(opreg);
break;
case 0x0a:
switch(rm) {
case 0:
break;
default:
goto illegal_op;
}
break;
case 0x0c:
switch(rm) {
case 0:
gen_op_fchs_ST0();
break;
case 1:
gen_op_fabs_ST0();
break;
case 4:
gen_op_fldz_FT0();
gen_op_fcom_ST0_FT0();
break;
case 5:
gen_op_fxam_ST0();
break;
default:
goto illegal_op;
}
break;
case 0x0d:
{
switch(rm) {
case 0:
gen_op_fpush();
gen_op_fld1_ST0();
break;
case 1:
gen_op_fpush();
gen_op_fldl2t_ST0();
break;
case 2:
gen_op_fpush();
gen_op_fldl2e_ST0();
break;
case 3:
gen_op_fpush();
gen_op_fldpi_ST0();
break;
case 4:
gen_op_fpush();
gen_op_fldlg2_ST0();
break;
case 5:
gen_op_fpush();
gen_op_fldln2_ST0();
break;
case 6:
gen_op_fpush();
gen_op_fldz_ST0();
break;
default:
goto illegal_op;
}
}
break;
case 0x0e:
switch(rm) {
case 0:
gen_op_f2xm1();
break;
case 1:
gen_op_fyl2x();
break;
case 2:
gen_op_fptan();
break;
case 3:
gen_op_fpatan();
break;
case 4:
gen_op_fxtract();
break;
case 5:
gen_op_fprem1();
break;
case 6:
gen_op_fdecstp();
break;
default:
case 7:
gen_op_fincstp();
break;
}
break;
case 0x0f:
switch(rm) {
case 0:
gen_op_fprem();
break;
case 1:
gen_op_fyl2xp1();
break;
case 2:
gen_op_fsqrt();
break;
case 3:
gen_op_fsincos();
break;
case 5:
gen_op_fscale();
break;
case 4:
gen_op_frndint();
break;
case 6:
gen_op_fsin();
break;
default:
case 7:
gen_op_fcos();
break;
}
break;
case 0x00: case 0x01: case 0x04 ... 0x07:
case 0x20: case 0x21: case 0x24 ... 0x27:
case 0x30: case 0x31: case 0x34 ... 0x37:
{
int op1;
op1 = op & 7;
if (op >= 0x20) {
gen_op_fp_arith_STN_ST0[op1](opreg);
if (op >= 0x30)
gen_op_fpop();
} else {
gen_op_fmov_FT0_STN(opreg);
gen_op_fp_arith_ST0_FT0[op1]();
}
}
break;
case 0x02:
gen_op_fmov_FT0_STN(opreg);
gen_op_fcom_ST0_FT0();
break;
case 0x03:
gen_op_fmov_FT0_STN(opreg);
gen_op_fcom_ST0_FT0();
gen_op_fpop();
break;
case 0x15:
switch(rm) {
case 1:
gen_op_fmov_FT0_STN(1);
gen_op_fucom_ST0_FT0();
gen_op_fpop();
gen_op_fpop();
break;
default:
goto illegal_op;
}
break;
case 0x1c:
switch(rm) {
case 2:
gen_op_fclex();
break;
case 3:
gen_op_fninit();
break;
default:
goto illegal_op;
}
break;
case 0x2a:
gen_op_fmov_STN_ST0(opreg);
break;
case 0x2b:
gen_op_fmov_STN_ST0(opreg);
gen_op_fpop();
break;
case 0x2c:
gen_op_fmov_FT0_STN(opreg);
gen_op_fucom_ST0_FT0();
break;
case 0x2d:
gen_op_fmov_FT0_STN(opreg);
gen_op_fucom_ST0_FT0();
gen_op_fpop();
break;
case 0x33:
switch(rm) {
case 1:
gen_op_fmov_FT0_STN(1);
gen_op_fcom_ST0_FT0();
gen_op_fpop();
gen_op_fpop();
break;
default:
goto illegal_op;
}
break;
case 0x3c:
switch(rm) {
case 0:
gen_op_fnstsw_EAX();
break;
default:
goto illegal_op;
}
break;
default:
goto illegal_op;
}
}
break;
case 0xa4:
case 0xa5:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPZ) {
gen_op_movs[3 + ot]();
} else {
gen_op_movs[ot]();
}
break;
case 0xaa:
case 0xab:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPZ) {
gen_op_stos[3 + ot]();
} else {
gen_op_stos[ot]();
}
break;
case 0xac:
case 0xad:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPZ) {
gen_op_lods[3 + ot]();
} else {
gen_op_lods[ot]();
}
break;
case 0xae:
case 0xaf:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPNZ) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_scas[6 + ot]();
s->cc_op = CC_OP_DYNAMIC;
} else if (prefixes & PREFIX_REPZ) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_scas[3 + ot]();
s->cc_op = CC_OP_DYNAMIC;
} else {
gen_op_scas[ot]();
s->cc_op = CC_OP_SUBB + ot;
}
break;
case 0xa6:
case 0xa7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPNZ) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_cmps[6 + ot]();
s->cc_op = CC_OP_DYNAMIC;
} else if (prefixes & PREFIX_REPZ) {
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_cmps[3 + ot]();
s->cc_op = CC_OP_DYNAMIC;
} else {
gen_op_cmps[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;
if (prefixes & PREFIX_REPZ) {
gen_op_ins[3 + ot]();
} else {
gen_op_ins[ot]();
}
break;
case 0x6e:
case 0x6f:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
if (prefixes & PREFIX_REPZ) {
gen_op_outs[3 + ot]();
} else {
gen_op_outs[ot]();
}
break;
case 0xe4:
case 0xe5:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
val = ldub(s->pc++);
gen_op_movl_T0_im(val);
gen_op_in[ot]();
gen_op_mov_reg_T1[ot][R_EAX]();
break;
case 0xe6:
case 0xe7:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
val = ldub(s->pc++);
gen_op_movl_T0_im(val);
gen_op_mov_TN_reg[ot][1][R_EAX]();
gen_op_out[ot]();
break;
case 0xec:
case 0xed:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
gen_op_in[ot]();
gen_op_mov_reg_T1[ot][R_EAX]();
break;
case 0xee:
case 0xef:
if ((b & 1) == 0)
ot = OT_BYTE;
else
ot = dflag ? OT_LONG : OT_WORD;
gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
gen_op_mov_TN_reg[ot][1][R_EAX]();
gen_op_out[ot]();
break;
case 0xc2:
val = ldsw(s->pc);
s->pc += 2;
gen_pop_T0(s);
if (s->ss32)
gen_op_addl_ESP_im(val + (2 << s->dflag));
else
gen_op_addw_ESP_im(val + (2 << s->dflag));
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
s->is_jmp = 1;
break;
case 0xc3:
gen_pop_T0(s);
gen_pop_update(s);
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
s->is_jmp = 1;
break;
case 0xca:
val = ldsw(s->pc);
s->pc += 2;
gen_pop_T0(s);
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_pop_update(s);
gen_pop_T0(s);
gen_movl_seg_T0(s, R_CS);
gen_pop_update(s);
if (s->ss32)
gen_op_addl_ESP_im(val + (2 << s->dflag));
else
gen_op_addw_ESP_im(val + (2 << s->dflag));
s->is_jmp = 1;
break;
case 0xcb:
gen_pop_T0(s);
if (s->dflag == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_pop_update(s);
gen_pop_T0(s);
gen_movl_seg_T0(s, R_CS);
gen_pop_update(s);
s->is_jmp = 1;
break;
case 0xe8:
{
unsigned int next_eip;
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
next_eip = s->pc - s->cs_base;
val += next_eip;
if (s->dflag == 0)
val &= 0xffff;
gen_op_movl_T0_im(next_eip);
gen_push_T0(s);
gen_op_jmp_im(val);
s->is_jmp = 1;
}
break;
case 0x9a:
{
unsigned int selector, offset;
ot = dflag ? OT_LONG : OT_WORD;
offset = insn_get(s, ot);
selector = insn_get(s, OT_WORD);
gen_op_movl_T0_seg(R_CS);
gen_push_T0(s);
next_eip = s->pc - s->cs_base;
gen_op_movl_T0_im(next_eip);
gen_push_T0(s);
gen_op_movl_T0_im(selector);
gen_movl_seg_T0(s, R_CS);
gen_op_jmp_im((unsigned long)offset);
s->is_jmp = 1;
}
break;
case 0xe9:
ot = dflag ? OT_LONG : OT_WORD;
val = insn_get(s, ot);
val += s->pc - s->cs_base;
if (s->dflag == 0)
val = val & 0xffff;
gen_op_jmp_im(val);
s->is_jmp = 1;
break;
case 0xea:
{
unsigned int selector, offset;
ot = dflag ? OT_LONG : OT_WORD;
offset = insn_get(s, ot);
selector = insn_get(s, OT_WORD);
gen_op_movl_T0_im(selector);
gen_movl_seg_T0(s, R_CS);
gen_op_jmp_im((unsigned long)offset);
s->is_jmp = 1;
}
break;
case 0xeb:
val = (int8_t)insn_get(s, OT_BYTE);
val += s->pc - s->cs_base;
if (s->dflag == 0)
val = val & 0xffff;
gen_op_jmp_im(val);
s->is_jmp = 1;
break;
case 0x70 ... 0x7f:
val = (int8_t)insn_get(s, OT_BYTE);
goto do_jcc;
case 0x180 ... 0x18f:
if (dflag) {
val = insn_get(s, OT_LONG);
} else {
val = (int16_t)insn_get(s, OT_WORD);
}
do_jcc:
next_eip = s->pc - s->cs_base;
val += next_eip;
if (s->dflag == 0)
val &= 0xffff;
gen_jcc(s, b, val, next_eip);
s->is_jmp = 1;
break;
case 0x190 ... 0x19f:
modrm = ldub(s->pc++);
gen_setcc(s, b);
gen_ldst_modrm(s, modrm, OT_BYTE, OR_TMP0, 1);
break;
case 0x140 ... 0x14f:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
gen_setcc(s, b);
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T1_A0[ot]();
} else {
rm = modrm & 7;
gen_op_mov_TN_reg[ot][1][rm]();
}
gen_op_cmov_reg_T1_T0[ot - OT_WORD][reg]();
break;
case 0x9c:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_movl_T0_eflags();
gen_push_T0(s);
break;
case 0x9d:
gen_pop_T0(s);
gen_op_movl_eflags_T0();
gen_pop_update(s);
s->cc_op = CC_OP_EFLAGS;
break;
case 0x9e:
gen_op_mov_TN_reg[OT_BYTE][0][R_AH]();
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_movb_eflags_T0();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x9f:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_movl_T0_eflags();
gen_op_mov_reg_T0[OT_BYTE][R_AH]();
break;
case 0xf5:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_cmc();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xf8:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_clc();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xf9:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_stc();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xfc:
gen_op_cld();
break;
case 0xfd:
gen_op_std();
break;
case 0x1ba:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
op = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
rm = modrm & 7;
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
gen_op_ld_T0_A0[ot]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
val = ldub(s->pc++);
gen_op_movl_T1_im(val);
if (op < 4)
goto illegal_op;
op -= 4;
gen_op_btx_T0_T1_cc[ot - OT_WORD][op]();
s->cc_op = CC_OP_SARB + ot;
if (op != 0) {
if (mod != 3)
gen_op_st_T0_A0[ot]();
else
gen_op_mov_reg_T0[ot][rm]();
}
break;
case 0x1a3:
op = 0;
goto do_btx;
case 0x1ab:
op = 1;
goto do_btx;
case 0x1b3:
op = 2;
goto do_btx;
case 0x1bb:
op = 3;
do_btx:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
mod = (modrm >> 6) & 3;
rm = modrm & 7;
gen_op_mov_TN_reg[OT_LONG][1][reg]();
if (mod != 3) {
gen_lea_modrm(s, modrm, ®_addr, &offset_addr);
if (ot == OT_WORD)
gen_op_add_bitw_A0_T1();
else
gen_op_add_bitl_A0_T1();
gen_op_ld_T0_A0[ot]();
} else {
gen_op_mov_TN_reg[ot][0][rm]();
}
gen_op_btx_T0_T1_cc[ot - OT_WORD][op]();
s->cc_op = CC_OP_SARB + ot;
if (op != 0) {
if (mod != 3)
gen_op_st_T0_A0[ot]();
else
gen_op_mov_reg_T0[ot][rm]();
}
break;
case 0x1bc:
case 0x1bd:
ot = dflag ? OT_LONG : OT_WORD;
modrm = ldub(s->pc++);
reg = (modrm >> 3) & 7;
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
gen_op_bsx_T0_cc[ot - OT_WORD][b & 1]();
gen_op_mov_reg_T0[ot][reg]();
s->cc_op = CC_OP_LOGICB + ot;
break;
case 0x27:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_daa();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x2f:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_das();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x37:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_aaa();
s->cc_op = CC_OP_EFLAGS;
break;
case 0x3f:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_aas();
s->cc_op = CC_OP_EFLAGS;
break;
case 0xd4:
val = ldub(s->pc++);
gen_op_aam(val);
s->cc_op = CC_OP_LOGICB;
break;
case 0xd5:
val = ldub(s->pc++);
gen_op_aad(val);
s->cc_op = CC_OP_LOGICB;
break;
case 0x90:
break;
case 0xcc:
gen_op_int3((long)pc_start);
s->is_jmp = 1;
break;
case 0xcd:
val = ldub(s->pc++);
gen_op_int_im((long)pc_start);
s->is_jmp = 1;
break;
case 0xce:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_into((long)pc_start, (long)s->pc);
s->is_jmp = 1;
break;
case 0x1c8 ... 0x1cf:
reg = b & 7;
gen_op_mov_TN_reg[OT_LONG][0][reg]();
gen_op_bswapl_T0();
gen_op_mov_reg_T0[OT_LONG][reg]();
break;
case 0xd6:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
gen_op_salc();
break;
case 0xe0:
case 0xe1:
if (s->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(s->cc_op);
case 0xe2:
case 0xe3:
val = (int8_t)insn_get(s, OT_BYTE);
next_eip = s->pc - s->cs_base;
val += next_eip;
if (s->dflag == 0)
val &= 0xffff;
gen_op_loop[s->aflag][b & 3](val, next_eip);
s->is_jmp = 1;
break;
case 0x131:
gen_op_rdtsc();
break;
#if 0
case 0x1a2:
gen_insn0(OP_ASM);
break;
#endif
default:
goto illegal_op;
}
if (s->prefix & PREFIX_LOCK)
gen_op_unlock();
return (long)s->pc;
illegal_op:
return -1;
}
| {
"code": [],
"line_no": []
} | long FUNC_0(DisasContext *VAR_0, uint8_t *VAR_1)
{
int VAR_2, VAR_3, VAR_4, VAR_5;
int VAR_6, VAR_7;
int VAR_8, VAR_9, VAR_10, VAR_11, VAR_12, VAR_18, VAR_14, VAR_15, VAR_19;
unsigned int VAR_24;
VAR_0->pc = VAR_1;
VAR_3 = 0;
VAR_4 = VAR_0->code32;
VAR_5 = VAR_0->code32;
next_byte:
VAR_2 = ldub(VAR_0->pc);
VAR_0->pc++;
switch (VAR_2) {
case 0xf3:
VAR_3 |= PREFIX_REPZ;
goto next_byte;
case 0xf2:
VAR_3 |= PREFIX_REPNZ;
goto next_byte;
case 0xf0:
VAR_3 |= PREFIX_LOCK;
goto next_byte;
case 0x2e:
VAR_3 |= PREFIX_CS;
goto next_byte;
case 0x36:
VAR_3 |= PREFIX_SS;
goto next_byte;
case 0x3e:
VAR_3 |= PREFIX_DS;
goto next_byte;
case 0x26:
VAR_3 |= PREFIX_ES;
goto next_byte;
case 0x64:
VAR_3 |= PREFIX_FS;
goto next_byte;
case 0x65:
VAR_3 |= PREFIX_GS;
goto next_byte;
case 0x66:
VAR_3 |= PREFIX_DATA;
goto next_byte;
case 0x67:
VAR_3 |= PREFIX_ADR;
goto next_byte;
case 0x9b:
VAR_3 |= PREFIX_FWAIT;
goto next_byte;
}
if (VAR_3 & PREFIX_DATA)
VAR_5 ^= 1;
if (VAR_3 & PREFIX_ADR)
VAR_4 ^= 1;
VAR_0->prefix = VAR_3;
VAR_0->VAR_4 = VAR_4;
VAR_0->VAR_5 = VAR_5;
if (VAR_3 & PREFIX_LOCK)
gen_op_lock();
reswitch:
switch(VAR_2) {
case 0x0f:
VAR_2 = ldub(VAR_0->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_18, VAR_18, VAR_19;
VAR_18 = (VAR_2 >> 3) & 7;
VAR_18 = (VAR_2 >> 1) & 3;
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
switch(VAR_18) {
case 0:
VAR_8 = ldub(VAR_0->pc++);
VAR_9 = ((VAR_8 >> 3) & 7) + OR_EAX;
VAR_11 = (VAR_8 >> 6) & 3;
VAR_10 = VAR_8 & 7;
if (VAR_11 != 3) {
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
gen_op_ld_T0_A0[VAR_7]();
VAR_14 = OR_TMP0;
} else {
VAR_14 = OR_EAX + VAR_10;
}
gen_op(VAR_0, VAR_18, VAR_7, VAR_14, VAR_9);
if (VAR_11 != 3 && VAR_18 != 7) {
gen_op_st_T0_A0[VAR_7]();
}
break;
case 1:
VAR_8 = ldub(VAR_0->pc++);
VAR_11 = (VAR_8 >> 6) & 3;
VAR_9 = ((VAR_8 >> 3) & 7) + OR_EAX;
VAR_10 = VAR_8 & 7;
if (VAR_11 != 3) {
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
gen_op_ld_T1_A0[VAR_7]();
VAR_14 = OR_TMP1;
} else {
VAR_14 = OR_EAX + VAR_10;
}
gen_op(VAR_0, VAR_18, VAR_7, VAR_9, VAR_14);
break;
case 2:
VAR_19 = insn_get(VAR_0, VAR_7);
gen_opi(VAR_0, VAR_18, VAR_7, OR_EAX, VAR_19);
break;
}
}
break;
case 0x80:
case 0x81:
case 0x83:
{
int VAR_19;
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_11 = (VAR_8 >> 6) & 3;
VAR_10 = VAR_8 & 7;
VAR_18 = (VAR_8 >> 3) & 7;
if (VAR_11 != 3) {
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
gen_op_ld_T0_A0[VAR_7]();
VAR_14 = OR_TMP0;
} else {
VAR_14 = VAR_10 + OR_EAX;
}
switch(VAR_2) {
default:
case 0x80:
case 0x81:
VAR_19 = insn_get(VAR_0, VAR_7);
break;
case 0x83:
VAR_19 = (int8_t)insn_get(VAR_0, OT_BYTE);
break;
}
gen_opi(VAR_0, VAR_18, VAR_7, VAR_14, VAR_19);
if (VAR_18 != 7 && VAR_11 != 3) {
gen_op_st_T0_A0[VAR_7]();
}
}
break;
case 0x40 ... 0x47:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
gen_inc(VAR_0, VAR_7, OR_EAX + (VAR_2 & 7), 1);
break;
case 0x48 ... 0x4f:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
gen_inc(VAR_0, VAR_7, OR_EAX + (VAR_2 & 7), -1);
break;
case 0xf6:
case 0xf7:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_11 = (VAR_8 >> 6) & 3;
VAR_10 = VAR_8 & 7;
VAR_18 = (VAR_8 >> 3) & 7;
if (VAR_11 != 3) {
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
gen_op_ld_T0_A0[VAR_7]();
} else {
gen_op_mov_TN_reg[VAR_7][0][VAR_10]();
}
switch(VAR_18) {
case 0:
VAR_19 = insn_get(VAR_0, VAR_7);
gen_op_movl_T1_im(VAR_19);
gen_op_testl_T0_T1_cc();
VAR_0->cc_op = CC_OP_LOGICB + VAR_7;
break;
case 2:
gen_op_notl_T0();
if (VAR_11 != 3) {
gen_op_st_T0_A0[VAR_7]();
} else {
gen_op_mov_reg_T0[VAR_7][VAR_10]();
}
break;
case 3:
gen_op_negl_T0_cc();
if (VAR_11 != 3) {
gen_op_st_T0_A0[VAR_7]();
} else {
gen_op_mov_reg_T0[VAR_7][VAR_10]();
}
VAR_0->cc_op = CC_OP_SUBB + VAR_7;
break;
case 4:
switch(VAR_7) {
case OT_BYTE:
gen_op_mulb_AL_T0();
break;
case OT_WORD:
gen_op_mulw_AX_T0();
break;
default:
case OT_LONG:
gen_op_mull_EAX_T0();
break;
}
VAR_0->cc_op = CC_OP_MUL;
break;
case 5:
switch(VAR_7) {
case OT_BYTE:
gen_op_imulb_AL_T0();
break;
case OT_WORD:
gen_op_imulw_AX_T0();
break;
default:
case OT_LONG:
gen_op_imull_EAX_T0();
break;
}
VAR_0->cc_op = CC_OP_MUL;
break;
case 6:
switch(VAR_7) {
case OT_BYTE:
gen_op_divb_AL_T0();
break;
case OT_WORD:
gen_op_divw_AX_T0();
break;
default:
case OT_LONG:
gen_op_divl_EAX_T0();
break;
}
break;
case 7:
switch(VAR_7) {
case OT_BYTE:
gen_op_idivb_AL_T0();
break;
case OT_WORD:
gen_op_idivw_AX_T0();
break;
default:
case OT_LONG:
gen_op_idivl_EAX_T0();
break;
}
break;
default:
goto illegal_op;
}
break;
case 0xfe:
case 0xff:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_11 = (VAR_8 >> 6) & 3;
VAR_10 = VAR_8 & 7;
VAR_18 = (VAR_8 >> 3) & 7;
if (VAR_18 >= 2 && VAR_2 == 0xfe) {
goto illegal_op;
}
if (VAR_11 != 3) {
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
if (VAR_18 != 3 && VAR_18 != 5)
gen_op_ld_T0_A0[VAR_7]();
} else {
gen_op_mov_TN_reg[VAR_7][0][VAR_10]();
}
switch(VAR_18) {
case 0:
gen_inc(VAR_0, VAR_7, OR_TMP0, 1);
if (VAR_11 != 3)
gen_op_st_T0_A0[VAR_7]();
else
gen_op_mov_reg_T0[VAR_7][VAR_10]();
break;
case 1:
gen_inc(VAR_0, VAR_7, OR_TMP0, -1);
if (VAR_11 != 3)
gen_op_st_T0_A0[VAR_7]();
else
gen_op_mov_reg_T0[VAR_7][VAR_10]();
break;
case 2:
if (VAR_0->VAR_5 == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
VAR_24 = VAR_0->pc - VAR_0->cs_base;
gen_op_movl_T0_im(VAR_24);
gen_push_T0(VAR_0);
VAR_0->is_jmp = 1;
break;
case 3:
gen_op_movl_T0_seg(R_CS);
gen_push_T0(VAR_0);
VAR_24 = VAR_0->pc - VAR_0->cs_base;
gen_op_movl_T0_im(VAR_24);
gen_push_T0(VAR_0);
gen_op_ld_T1_A0[VAR_7]();
gen_op_addl_A0_im(1 << (VAR_7 - OT_WORD + 1));
gen_op_lduw_T0_A0();
gen_movl_seg_T0(VAR_0, R_CS);
gen_op_movl_T0_T1();
gen_op_jmp_T0();
VAR_0->is_jmp = 1;
break;
case 4:
if (VAR_0->VAR_5 == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
VAR_0->is_jmp = 1;
break;
case 5:
gen_op_ld_T1_A0[VAR_7]();
gen_op_addl_A0_im(1 << (VAR_7 - OT_WORD + 1));
gen_op_lduw_T0_A0();
gen_movl_seg_T0(VAR_0, R_CS);
gen_op_movl_T0_T1();
gen_op_jmp_T0();
VAR_0->is_jmp = 1;
break;
case 6:
gen_push_T0(VAR_0);
break;
default:
goto illegal_op;
}
break;
case 0x84:
case 0x85:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_11 = (VAR_8 >> 6) & 3;
VAR_10 = VAR_8 & 7;
VAR_9 = (VAR_8 >> 3) & 7;
gen_ldst_modrm(VAR_0, VAR_8, VAR_7, OR_TMP0, 0);
gen_op_mov_TN_reg[VAR_7][1][VAR_9 + OR_EAX]();
gen_op_testl_T0_T1_cc();
VAR_0->cc_op = CC_OP_LOGICB + VAR_7;
break;
case 0xa8:
case 0xa9:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_19 = insn_get(VAR_0, VAR_7);
gen_op_mov_TN_reg[VAR_7][0][OR_EAX]();
gen_op_movl_T1_im(VAR_19);
gen_op_testl_T0_T1_cc();
VAR_0->cc_op = CC_OP_LOGICB + VAR_7;
break;
case 0x98:
if (VAR_5)
gen_op_movswl_EAX_AX();
else
gen_op_movsbw_AX_AL();
break;
case 0x99:
if (VAR_5)
gen_op_movslq_EDX_EAX();
else
gen_op_movswl_DX_AX();
break;
case 0x1af:
case 0x69:
case 0x6b:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_9 = ((VAR_8 >> 3) & 7) + OR_EAX;
gen_ldst_modrm(VAR_0, VAR_8, VAR_7, OR_TMP0, 0);
if (VAR_2 == 0x69) {
VAR_19 = insn_get(VAR_0, VAR_7);
gen_op_movl_T1_im(VAR_19);
} else if (VAR_2 == 0x6b) {
VAR_19 = insn_get(VAR_0, OT_BYTE);
gen_op_movl_T1_im(VAR_19);
} else {
gen_op_mov_TN_reg[VAR_7][1][VAR_9]();
}
if (VAR_7 == OT_LONG) {
gen_op_imull_T0_T1();
} else {
gen_op_imulw_T0_T1();
}
gen_op_mov_reg_T0[VAR_7][VAR_9]();
VAR_0->cc_op = CC_OP_MUL;
break;
case 0x1c0:
case 0x1c1:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_9 = (VAR_8 >> 3) & 7;
VAR_11 = (VAR_8 >> 6) & 3;
if (VAR_11 == 3) {
VAR_10 = VAR_8 & 7;
gen_op_mov_TN_reg[VAR_7][0][VAR_9]();
gen_op_mov_TN_reg[VAR_7][1][VAR_10]();
gen_op_addl_T0_T1_cc();
gen_op_mov_reg_T0[VAR_7][VAR_10]();
gen_op_mov_reg_T1[VAR_7][VAR_9]();
} else {
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
gen_op_mov_TN_reg[VAR_7][0][VAR_9]();
gen_op_ld_T1_A0[VAR_7]();
gen_op_addl_T0_T1_cc();
gen_op_st_T0_A0[VAR_7]();
gen_op_mov_reg_T1[VAR_7][VAR_9]();
}
VAR_0->cc_op = CC_OP_ADDB + VAR_7;
break;
case 0x1b0:
case 0x1b1:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_9 = (VAR_8 >> 3) & 7;
VAR_11 = (VAR_8 >> 6) & 3;
gen_op_mov_TN_reg[VAR_7][1][VAR_9]();
if (VAR_11 == 3) {
VAR_10 = VAR_8 & 7;
gen_op_mov_TN_reg[VAR_7][0][VAR_10]();
gen_op_cmpxchg_T0_T1_EAX_cc[VAR_7]();
gen_op_mov_reg_T0[VAR_7][VAR_10]();
} else {
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
gen_op_ld_T0_A0[VAR_7]();
gen_op_cmpxchg_T0_T1_EAX_cc[VAR_7]();
gen_op_st_T0_A0[VAR_7]();
}
VAR_0->cc_op = CC_OP_SUBB + VAR_7;
break;
case 0x50 ... 0x57:
gen_op_mov_TN_reg[OT_LONG][0][VAR_2 & 7]();
gen_push_T0(VAR_0);
break;
case 0x58 ... 0x5f:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
gen_pop_T0(VAR_0);
gen_op_mov_reg_T0[VAR_7][VAR_2 & 7]();
gen_pop_update(VAR_0);
break;
case 0x60:
gen_pusha(VAR_0);
break;
case 0x61:
gen_popa(VAR_0);
break;
case 0x68:
case 0x6a:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
if (VAR_2 == 0x68)
VAR_19 = insn_get(VAR_0, VAR_7);
else
VAR_19 = (int8_t)insn_get(VAR_0, OT_BYTE);
gen_op_movl_T0_im(VAR_19);
gen_push_T0(VAR_0);
break;
case 0x8f:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
gen_pop_T0(VAR_0);
gen_ldst_modrm(VAR_0, VAR_8, VAR_7, OR_TMP0, 1);
gen_pop_update(VAR_0);
break;
case 0xc8:
{
int VAR_19;
VAR_19 = lduw(VAR_0->pc);
VAR_0->pc += 2;
VAR_19 = ldub(VAR_0->pc++);
gen_enter(VAR_0, VAR_19, VAR_19);
}
break;
case 0xc9:
if (VAR_0->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(VAR_0);
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
gen_op_mov_reg_T0[VAR_7][R_EBP]();
gen_pop_update(VAR_0);
break;
case 0x06:
case 0x0e:
case 0x16:
case 0x1e:
gen_op_movl_T0_seg(VAR_2 >> 3);
gen_push_T0(VAR_0);
break;
case 0x1a0:
case 0x1a8:
gen_op_movl_T0_seg(((VAR_2 >> 3) & 7) + R_FS);
gen_push_T0(VAR_0);
break;
case 0x07:
case 0x17:
case 0x1f:
gen_pop_T0(VAR_0);
gen_movl_seg_T0(VAR_0, VAR_2 >> 3);
gen_pop_update(VAR_0);
break;
case 0x1a1:
case 0x1a9:
gen_pop_T0(VAR_0);
gen_movl_seg_T0(VAR_0, ((VAR_2 >> 3) & 7) + R_FS);
gen_pop_update(VAR_0);
break;
case 0x88:
case 0x89:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_9 = (VAR_8 >> 3) & 7;
gen_ldst_modrm(VAR_0, VAR_8, VAR_7, OR_EAX + VAR_9, 1);
break;
case 0xc6:
case 0xc7:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_11 = (VAR_8 >> 6) & 3;
if (VAR_11 != 3)
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
VAR_19 = insn_get(VAR_0, VAR_7);
gen_op_movl_T0_im(VAR_19);
if (VAR_11 != 3)
gen_op_st_T0_A0[VAR_7]();
else
gen_op_mov_reg_T0[VAR_7][VAR_8 & 7]();
break;
case 0x8a:
case 0x8b:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_9 = (VAR_8 >> 3) & 7;
gen_ldst_modrm(VAR_0, VAR_8, VAR_7, OR_TMP0, 0);
gen_op_mov_reg_T0[VAR_7][VAR_9]();
break;
case 0x8e:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_9 = (VAR_8 >> 3) & 7;
gen_ldst_modrm(VAR_0, VAR_8, VAR_7, OR_TMP0, 0);
if (VAR_9 >= 6 || VAR_9 == R_CS)
goto illegal_op;
gen_movl_seg_T0(VAR_0, VAR_9);
break;
case 0x8c:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_9 = (VAR_8 >> 3) & 7;
if (VAR_9 >= 6)
goto illegal_op;
gen_op_movl_T0_seg(VAR_9);
gen_ldst_modrm(VAR_0, VAR_8, VAR_7, OR_TMP0, 1);
break;
case 0x1b6:
case 0x1b7:
case 0x1be:
case 0x1bf:
{
int VAR_20;
VAR_20 = VAR_5 + OT_WORD;
VAR_7 = (VAR_2 & 1) + OT_BYTE;
VAR_8 = ldub(VAR_0->pc++);
VAR_9 = ((VAR_8 >> 3) & 7) + OR_EAX;
VAR_11 = (VAR_8 >> 6) & 3;
VAR_10 = VAR_8 & 7;
if (VAR_11 == 3) {
gen_op_mov_TN_reg[VAR_7][0][VAR_10]();
switch(VAR_7 | (VAR_2 & 8)) {
case OT_BYTE:
gen_op_movzbl_T0_T0();
break;
case OT_BYTE | 8:
gen_op_movsbl_T0_T0();
break;
case OT_WORD:
gen_op_movzwl_T0_T0();
break;
default:
case OT_WORD | 8:
gen_op_movswl_T0_T0();
break;
}
gen_op_mov_reg_T0[VAR_20][VAR_9]();
} else {
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
if (VAR_2 & 8) {
gen_op_lds_T0_A0[VAR_7]();
} else {
gen_op_ldu_T0_A0[VAR_7]();
}
gen_op_mov_reg_T0[VAR_20][VAR_9]();
}
}
break;
case 0x8d:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_9 = (VAR_8 >> 3) & 7;
VAR_0->prefix &= ~(PREFIX_CS | PREFIX_SS | PREFIX_DS |
PREFIX_ES | PREFIX_FS | PREFIX_GS);
VAR_19 = VAR_0->addseg;
VAR_0->addseg = 0;
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
VAR_0->addseg = VAR_19;
gen_op_mov_reg_A0[VAR_7 - OT_WORD][VAR_9]();
break;
case 0xa0:
case 0xa1:
case 0xa2:
case 0xa3:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
if (VAR_0->VAR_4)
VAR_15 = insn_get(VAR_0, OT_LONG);
else
VAR_15 = insn_get(VAR_0, OT_WORD);
gen_op_movl_A0_im(VAR_15);
{
int VAR_23, VAR_23;
VAR_23 = R_DS;
VAR_23 = VAR_0->addseg;
if (VAR_0->prefix & (PREFIX_CS | PREFIX_SS | PREFIX_DS |
PREFIX_ES | PREFIX_FS | PREFIX_GS)) {
if (VAR_0->prefix & PREFIX_ES)
VAR_23 = R_ES;
else if (VAR_0->prefix & PREFIX_CS)
VAR_23 = R_CS;
else if (VAR_0->prefix & PREFIX_SS)
VAR_23 = R_SS;
else if (VAR_0->prefix & PREFIX_DS)
VAR_23 = R_DS;
else if (VAR_0->prefix & PREFIX_FS)
VAR_23 = R_FS;
else
VAR_23 = R_GS;
VAR_23 = 1;
}
if (VAR_23) {
gen_op_addl_A0_seg(offsetof(CPUX86State,seg_cache[VAR_23].base));
}
}
if ((VAR_2 & 2) == 0) {
gen_op_ld_T0_A0[VAR_7]();
gen_op_mov_reg_T0[VAR_7][R_EAX]();
} else {
gen_op_mov_TN_reg[VAR_7][0][R_EAX]();
gen_op_st_T0_A0[VAR_7]();
}
break;
case 0xd7:
gen_op_movl_A0_reg[R_EBX]();
gen_op_addl_A0_AL();
if (VAR_0->VAR_4 == 0)
gen_op_andl_A0_ffff();
{
int VAR_23, VAR_23;
VAR_23 = R_DS;
VAR_23 = VAR_0->addseg;
if (VAR_0->prefix & (PREFIX_CS | PREFIX_SS | PREFIX_DS |
PREFIX_ES | PREFIX_FS | PREFIX_GS)) {
if (VAR_0->prefix & PREFIX_ES)
VAR_23 = R_ES;
else if (VAR_0->prefix & PREFIX_CS)
VAR_23 = R_CS;
else if (VAR_0->prefix & PREFIX_SS)
VAR_23 = R_SS;
else if (VAR_0->prefix & PREFIX_DS)
VAR_23 = R_DS;
else if (VAR_0->prefix & PREFIX_FS)
VAR_23 = R_FS;
else
VAR_23 = R_GS;
VAR_23 = 1;
}
if (VAR_23) {
gen_op_addl_A0_seg(offsetof(CPUX86State,seg_cache[VAR_23].base));
}
}
gen_op_ldub_T0_A0();
gen_op_mov_reg_T0[OT_BYTE][R_EAX]();
break;
case 0xb0 ... 0xb7:
VAR_19 = insn_get(VAR_0, OT_BYTE);
gen_op_movl_T0_im(VAR_19);
gen_op_mov_reg_T0[OT_BYTE][VAR_2 & 7]();
break;
case 0xb8 ... 0xbf:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_19 = insn_get(VAR_0, VAR_7);
VAR_9 = OR_EAX + (VAR_2 & 7);
gen_op_movl_T0_im(VAR_19);
gen_op_mov_reg_T0[VAR_7][VAR_9]();
break;
case 0x91 ... 0x97:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_9 = VAR_2 & 7;
VAR_10 = R_EAX;
goto do_xchg_reg;
case 0x86:
case 0x87:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_9 = (VAR_8 >> 3) & 7;
VAR_11 = (VAR_8 >> 6) & 3;
if (VAR_11 == 3) {
VAR_10 = VAR_8 & 7;
do_xchg_reg:
gen_op_mov_TN_reg[VAR_7][0][VAR_9]();
gen_op_mov_TN_reg[VAR_7][1][VAR_10]();
gen_op_mov_reg_T0[VAR_7][VAR_10]();
gen_op_mov_reg_T1[VAR_7][VAR_9]();
} else {
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
gen_op_mov_TN_reg[VAR_7][0][VAR_9]();
if (!(VAR_3 & PREFIX_LOCK))
gen_op_lock();
gen_op_ld_T1_A0[VAR_7]();
gen_op_st_T0_A0[VAR_7]();
if (!(VAR_3 & PREFIX_LOCK))
gen_op_unlock();
gen_op_mov_reg_T1[VAR_7][VAR_9]();
}
break;
case 0xc4:
VAR_18 = R_ES;
goto do_lxx;
case 0xc5:
VAR_18 = R_DS;
goto do_lxx;
case 0x1b2:
VAR_18 = R_SS;
goto do_lxx;
case 0x1b4:
VAR_18 = R_FS;
goto do_lxx;
case 0x1b5:
VAR_18 = R_GS;
do_lxx:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_9 = (VAR_8 >> 3) & 7;
VAR_11 = (VAR_8 >> 6) & 3;
if (VAR_11 == 3)
goto illegal_op;
gen_op_ld_T1_A0[VAR_7]();
gen_op_addl_A0_im(1 << (VAR_7 - OT_WORD + 1));
gen_op_lduw_T0_A0();
gen_movl_seg_T0(VAR_0, VAR_18);
gen_op_mov_reg_T1[VAR_7][VAR_9]();
break;
case 0xc0:
case 0xc1:
VAR_6 = 2;
grp2:
{
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_11 = (VAR_8 >> 6) & 3;
VAR_10 = VAR_8 & 7;
VAR_18 = (VAR_8 >> 3) & 7;
if (VAR_11 != 3) {
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
gen_op_ld_T0_A0[VAR_7]();
VAR_14 = OR_TMP0;
} else {
VAR_14 = VAR_10 + OR_EAX;
}
if (VAR_6 == 0) {
gen_shift(VAR_0, VAR_18, VAR_7, VAR_14, OR_ECX);
} else {
if (VAR_6 == 2) {
VAR_6 = ldub(VAR_0->pc++);
}
gen_shifti(VAR_0, VAR_18, VAR_7, VAR_14, VAR_6);
}
if (VAR_11 != 3) {
gen_op_st_T0_A0[VAR_7]();
}
}
break;
case 0xd0:
case 0xd1:
VAR_6 = 1;
goto grp2;
case 0xd2:
case 0xd3:
VAR_6 = 0;
goto grp2;
case 0x1a4:
VAR_18 = 0;
VAR_6 = 1;
goto do_shiftd;
case 0x1a5:
VAR_18 = 0;
VAR_6 = 0;
goto do_shiftd;
case 0x1ac:
VAR_18 = 1;
VAR_6 = 1;
goto do_shiftd;
case 0x1ad:
VAR_18 = 1;
VAR_6 = 0;
do_shiftd:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_11 = (VAR_8 >> 6) & 3;
VAR_10 = VAR_8 & 7;
VAR_9 = (VAR_8 >> 3) & 7;
if (VAR_11 != 3) {
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
gen_op_ld_T0_A0[VAR_7]();
} else {
gen_op_mov_TN_reg[VAR_7][0][VAR_10]();
}
gen_op_mov_TN_reg[VAR_7][1][VAR_9]();
if (VAR_6) {
VAR_19 = ldub(VAR_0->pc++);
VAR_19 &= 0x1f;
if (VAR_19) {
gen_op_shiftd_T0_T1_im_cc[VAR_7 - OT_WORD][VAR_18](VAR_19);
if (VAR_18 == 0 && VAR_7 != OT_WORD)
VAR_0->cc_op = CC_OP_SHLB + VAR_7;
else
VAR_0->cc_op = CC_OP_SARB + VAR_7;
}
} else {
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_shiftd_T0_T1_ECX_cc[VAR_7 - OT_WORD][VAR_18]();
VAR_0->cc_op = CC_OP_DYNAMIC;
}
if (VAR_11 != 3) {
gen_op_st_T0_A0[VAR_7]();
} else {
gen_op_mov_reg_T0[VAR_7][VAR_10]();
}
break;
case 0xd8 ... 0xdf:
VAR_8 = ldub(VAR_0->pc++);
VAR_11 = (VAR_8 >> 6) & 3;
VAR_10 = VAR_8 & 7;
VAR_18 = ((VAR_2 & 7) << 3) | ((VAR_8 >> 3) & 7);
if (VAR_11 != 3) {
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
switch(VAR_18) {
case 0x00 ... 0x07:
case 0x10 ... 0x17:
case 0x20 ... 0x27:
case 0x30 ... 0x37:
{
int VAR_24;
VAR_24 = VAR_18 & 7;
switch(VAR_18 >> 4) {
case 0:
gen_op_flds_FT0_A0();
break;
case 1:
gen_op_fildl_FT0_A0();
break;
case 2:
gen_op_fldl_FT0_A0();
break;
case 3:
default:
gen_op_fild_FT0_A0();
break;
}
gen_op_fp_arith_ST0_FT0[VAR_24]();
if (VAR_24 == 3) {
gen_op_fpop();
}
}
break;
case 0x08:
case 0x0a:
case 0x0b:
case 0x18:
case 0x1a:
case 0x1b:
case 0x28:
case 0x2a:
case 0x2b:
case 0x38:
case 0x3a:
case 0x3b:
switch(VAR_18 & 7) {
case 0:
gen_op_fpush();
switch(VAR_18 >> 4) {
case 0:
gen_op_flds_ST0_A0();
break;
case 1:
gen_op_fildl_ST0_A0();
break;
case 2:
gen_op_fldl_ST0_A0();
break;
case 3:
default:
gen_op_fild_ST0_A0();
break;
}
break;
default:
switch(VAR_18 >> 4) {
case 0:
gen_op_fsts_ST0_A0();
break;
case 1:
gen_op_fistl_ST0_A0();
break;
case 2:
gen_op_fstl_ST0_A0();
break;
case 3:
default:
gen_op_fist_ST0_A0();
break;
}
if ((VAR_18 & 7) == 3)
gen_op_fpop();
break;
}
break;
case 0x0d:
gen_op_fldcw_A0();
break;
case 0x0f:
gen_op_fnstcw_A0();
break;
case 0x1d:
gen_op_fpush();
gen_op_fldt_ST0_A0();
break;
case 0x1f:
gen_op_fstt_ST0_A0();
gen_op_fpop();
break;
case 0x2f:
gen_op_fnstsw_A0();
break;
case 0x3c:
gen_op_fpush();
gen_op_fbld_ST0_A0();
break;
case 0x3e:
gen_op_fbst_ST0_A0();
gen_op_fpop();
break;
case 0x3d:
gen_op_fpush();
gen_op_fildll_ST0_A0();
break;
case 0x3f:
gen_op_fistll_ST0_A0();
gen_op_fpop();
break;
default:
goto illegal_op;
}
} else {
VAR_14 = VAR_10;
switch(VAR_18) {
case 0x08:
gen_op_fpush();
gen_op_fmov_ST0_STN((VAR_14 + 1) & 7);
break;
case 0x09:
gen_op_fxchg_ST0_STN(VAR_14);
break;
case 0x0a:
switch(VAR_10) {
case 0:
break;
default:
goto illegal_op;
}
break;
case 0x0c:
switch(VAR_10) {
case 0:
gen_op_fchs_ST0();
break;
case 1:
gen_op_fabs_ST0();
break;
case 4:
gen_op_fldz_FT0();
gen_op_fcom_ST0_FT0();
break;
case 5:
gen_op_fxam_ST0();
break;
default:
goto illegal_op;
}
break;
case 0x0d:
{
switch(VAR_10) {
case 0:
gen_op_fpush();
gen_op_fld1_ST0();
break;
case 1:
gen_op_fpush();
gen_op_fldl2t_ST0();
break;
case 2:
gen_op_fpush();
gen_op_fldl2e_ST0();
break;
case 3:
gen_op_fpush();
gen_op_fldpi_ST0();
break;
case 4:
gen_op_fpush();
gen_op_fldlg2_ST0();
break;
case 5:
gen_op_fpush();
gen_op_fldln2_ST0();
break;
case 6:
gen_op_fpush();
gen_op_fldz_ST0();
break;
default:
goto illegal_op;
}
}
break;
case 0x0e:
switch(VAR_10) {
case 0:
gen_op_f2xm1();
break;
case 1:
gen_op_fyl2x();
break;
case 2:
gen_op_fptan();
break;
case 3:
gen_op_fpatan();
break;
case 4:
gen_op_fxtract();
break;
case 5:
gen_op_fprem1();
break;
case 6:
gen_op_fdecstp();
break;
default:
case 7:
gen_op_fincstp();
break;
}
break;
case 0x0f:
switch(VAR_10) {
case 0:
gen_op_fprem();
break;
case 1:
gen_op_fyl2xp1();
break;
case 2:
gen_op_fsqrt();
break;
case 3:
gen_op_fsincos();
break;
case 5:
gen_op_fscale();
break;
case 4:
gen_op_frndint();
break;
case 6:
gen_op_fsin();
break;
default:
case 7:
gen_op_fcos();
break;
}
break;
case 0x00: case 0x01: case 0x04 ... 0x07:
case 0x20: case 0x21: case 0x24 ... 0x27:
case 0x30: case 0x31: case 0x34 ... 0x37:
{
int VAR_24;
VAR_24 = VAR_18 & 7;
if (VAR_18 >= 0x20) {
gen_op_fp_arith_STN_ST0[VAR_24](VAR_14);
if (VAR_18 >= 0x30)
gen_op_fpop();
} else {
gen_op_fmov_FT0_STN(VAR_14);
gen_op_fp_arith_ST0_FT0[VAR_24]();
}
}
break;
case 0x02:
gen_op_fmov_FT0_STN(VAR_14);
gen_op_fcom_ST0_FT0();
break;
case 0x03:
gen_op_fmov_FT0_STN(VAR_14);
gen_op_fcom_ST0_FT0();
gen_op_fpop();
break;
case 0x15:
switch(VAR_10) {
case 1:
gen_op_fmov_FT0_STN(1);
gen_op_fucom_ST0_FT0();
gen_op_fpop();
gen_op_fpop();
break;
default:
goto illegal_op;
}
break;
case 0x1c:
switch(VAR_10) {
case 2:
gen_op_fclex();
break;
case 3:
gen_op_fninit();
break;
default:
goto illegal_op;
}
break;
case 0x2a:
gen_op_fmov_STN_ST0(VAR_14);
break;
case 0x2b:
gen_op_fmov_STN_ST0(VAR_14);
gen_op_fpop();
break;
case 0x2c:
gen_op_fmov_FT0_STN(VAR_14);
gen_op_fucom_ST0_FT0();
break;
case 0x2d:
gen_op_fmov_FT0_STN(VAR_14);
gen_op_fucom_ST0_FT0();
gen_op_fpop();
break;
case 0x33:
switch(VAR_10) {
case 1:
gen_op_fmov_FT0_STN(1);
gen_op_fcom_ST0_FT0();
gen_op_fpop();
gen_op_fpop();
break;
default:
goto illegal_op;
}
break;
case 0x3c:
switch(VAR_10) {
case 0:
gen_op_fnstsw_EAX();
break;
default:
goto illegal_op;
}
break;
default:
goto illegal_op;
}
}
break;
case 0xa4:
case 0xa5:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
if (VAR_3 & PREFIX_REPZ) {
gen_op_movs[3 + VAR_7]();
} else {
gen_op_movs[VAR_7]();
}
break;
case 0xaa:
case 0xab:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
if (VAR_3 & PREFIX_REPZ) {
gen_op_stos[3 + VAR_7]();
} else {
gen_op_stos[VAR_7]();
}
break;
case 0xac:
case 0xad:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
if (VAR_3 & PREFIX_REPZ) {
gen_op_lods[3 + VAR_7]();
} else {
gen_op_lods[VAR_7]();
}
break;
case 0xae:
case 0xaf:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
if (VAR_3 & PREFIX_REPNZ) {
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_scas[6 + VAR_7]();
VAR_0->cc_op = CC_OP_DYNAMIC;
} else if (VAR_3 & PREFIX_REPZ) {
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_scas[3 + VAR_7]();
VAR_0->cc_op = CC_OP_DYNAMIC;
} else {
gen_op_scas[VAR_7]();
VAR_0->cc_op = CC_OP_SUBB + VAR_7;
}
break;
case 0xa6:
case 0xa7:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
if (VAR_3 & PREFIX_REPNZ) {
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_cmps[6 + VAR_7]();
VAR_0->cc_op = CC_OP_DYNAMIC;
} else if (VAR_3 & PREFIX_REPZ) {
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_cmps[3 + VAR_7]();
VAR_0->cc_op = CC_OP_DYNAMIC;
} else {
gen_op_cmps[VAR_7]();
VAR_0->cc_op = CC_OP_SUBB + VAR_7;
}
break;
case 0x6c:
case 0x6d:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
if (VAR_3 & PREFIX_REPZ) {
gen_op_ins[3 + VAR_7]();
} else {
gen_op_ins[VAR_7]();
}
break;
case 0x6e:
case 0x6f:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
if (VAR_3 & PREFIX_REPZ) {
gen_op_outs[3 + VAR_7]();
} else {
gen_op_outs[VAR_7]();
}
break;
case 0xe4:
case 0xe5:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_19 = ldub(VAR_0->pc++);
gen_op_movl_T0_im(VAR_19);
gen_op_in[VAR_7]();
gen_op_mov_reg_T1[VAR_7][R_EAX]();
break;
case 0xe6:
case 0xe7:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_19 = ldub(VAR_0->pc++);
gen_op_movl_T0_im(VAR_19);
gen_op_mov_TN_reg[VAR_7][1][R_EAX]();
gen_op_out[VAR_7]();
break;
case 0xec:
case 0xed:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
gen_op_in[VAR_7]();
gen_op_mov_reg_T1[VAR_7][R_EAX]();
break;
case 0xee:
case 0xef:
if ((VAR_2 & 1) == 0)
VAR_7 = OT_BYTE;
else
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
gen_op_mov_TN_reg[VAR_7][1][R_EAX]();
gen_op_out[VAR_7]();
break;
case 0xc2:
VAR_19 = ldsw(VAR_0->pc);
VAR_0->pc += 2;
gen_pop_T0(VAR_0);
if (VAR_0->ss32)
gen_op_addl_ESP_im(VAR_19 + (2 << VAR_0->VAR_5));
else
gen_op_addw_ESP_im(VAR_19 + (2 << VAR_0->VAR_5));
if (VAR_0->VAR_5 == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
VAR_0->is_jmp = 1;
break;
case 0xc3:
gen_pop_T0(VAR_0);
gen_pop_update(VAR_0);
if (VAR_0->VAR_5 == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
VAR_0->is_jmp = 1;
break;
case 0xca:
VAR_19 = ldsw(VAR_0->pc);
VAR_0->pc += 2;
gen_pop_T0(VAR_0);
if (VAR_0->VAR_5 == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_pop_update(VAR_0);
gen_pop_T0(VAR_0);
gen_movl_seg_T0(VAR_0, R_CS);
gen_pop_update(VAR_0);
if (VAR_0->ss32)
gen_op_addl_ESP_im(VAR_19 + (2 << VAR_0->VAR_5));
else
gen_op_addw_ESP_im(VAR_19 + (2 << VAR_0->VAR_5));
VAR_0->is_jmp = 1;
break;
case 0xcb:
gen_pop_T0(VAR_0);
if (VAR_0->VAR_5 == 0)
gen_op_andl_T0_ffff();
gen_op_jmp_T0();
gen_pop_update(VAR_0);
gen_pop_T0(VAR_0);
gen_movl_seg_T0(VAR_0, R_CS);
gen_pop_update(VAR_0);
VAR_0->is_jmp = 1;
break;
case 0xe8:
{
unsigned int VAR_24;
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_19 = insn_get(VAR_0, VAR_7);
VAR_24 = VAR_0->pc - VAR_0->cs_base;
VAR_19 += VAR_24;
if (VAR_0->VAR_5 == 0)
VAR_19 &= 0xffff;
gen_op_movl_T0_im(VAR_24);
gen_push_T0(VAR_0);
gen_op_jmp_im(VAR_19);
VAR_0->is_jmp = 1;
}
break;
case 0x9a:
{
unsigned int VAR_26, VAR_26;
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_26 = insn_get(VAR_0, VAR_7);
VAR_26 = insn_get(VAR_0, OT_WORD);
gen_op_movl_T0_seg(R_CS);
gen_push_T0(VAR_0);
VAR_24 = VAR_0->pc - VAR_0->cs_base;
gen_op_movl_T0_im(VAR_24);
gen_push_T0(VAR_0);
gen_op_movl_T0_im(VAR_26);
gen_movl_seg_T0(VAR_0, R_CS);
gen_op_jmp_im((unsigned long)VAR_26);
VAR_0->is_jmp = 1;
}
break;
case 0xe9:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_19 = insn_get(VAR_0, VAR_7);
VAR_19 += VAR_0->pc - VAR_0->cs_base;
if (VAR_0->VAR_5 == 0)
VAR_19 = VAR_19 & 0xffff;
gen_op_jmp_im(VAR_19);
VAR_0->is_jmp = 1;
break;
case 0xea:
{
unsigned int VAR_26, VAR_26;
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_26 = insn_get(VAR_0, VAR_7);
VAR_26 = insn_get(VAR_0, OT_WORD);
gen_op_movl_T0_im(VAR_26);
gen_movl_seg_T0(VAR_0, R_CS);
gen_op_jmp_im((unsigned long)VAR_26);
VAR_0->is_jmp = 1;
}
break;
case 0xeb:
VAR_19 = (int8_t)insn_get(VAR_0, OT_BYTE);
VAR_19 += VAR_0->pc - VAR_0->cs_base;
if (VAR_0->VAR_5 == 0)
VAR_19 = VAR_19 & 0xffff;
gen_op_jmp_im(VAR_19);
VAR_0->is_jmp = 1;
break;
case 0x70 ... 0x7f:
VAR_19 = (int8_t)insn_get(VAR_0, OT_BYTE);
goto do_jcc;
case 0x180 ... 0x18f:
if (VAR_5) {
VAR_19 = insn_get(VAR_0, OT_LONG);
} else {
VAR_19 = (int16_t)insn_get(VAR_0, OT_WORD);
}
do_jcc:
VAR_24 = VAR_0->pc - VAR_0->cs_base;
VAR_19 += VAR_24;
if (VAR_0->VAR_5 == 0)
VAR_19 &= 0xffff;
gen_jcc(VAR_0, VAR_2, VAR_19, VAR_24);
VAR_0->is_jmp = 1;
break;
case 0x190 ... 0x19f:
VAR_8 = ldub(VAR_0->pc++);
gen_setcc(VAR_0, VAR_2);
gen_ldst_modrm(VAR_0, VAR_8, OT_BYTE, OR_TMP0, 1);
break;
case 0x140 ... 0x14f:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_9 = (VAR_8 >> 3) & 7;
VAR_11 = (VAR_8 >> 6) & 3;
gen_setcc(VAR_0, VAR_2);
if (VAR_11 != 3) {
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
gen_op_ld_T1_A0[VAR_7]();
} else {
VAR_10 = VAR_8 & 7;
gen_op_mov_TN_reg[VAR_7][1][VAR_10]();
}
gen_op_cmov_reg_T1_T0[VAR_7 - OT_WORD][VAR_9]();
break;
case 0x9c:
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_movl_T0_eflags();
gen_push_T0(VAR_0);
break;
case 0x9d:
gen_pop_T0(VAR_0);
gen_op_movl_eflags_T0();
gen_pop_update(VAR_0);
VAR_0->cc_op = CC_OP_EFLAGS;
break;
case 0x9e:
gen_op_mov_TN_reg[OT_BYTE][0][R_AH]();
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_movb_eflags_T0();
VAR_0->cc_op = CC_OP_EFLAGS;
break;
case 0x9f:
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_movl_T0_eflags();
gen_op_mov_reg_T0[OT_BYTE][R_AH]();
break;
case 0xf5:
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_cmc();
VAR_0->cc_op = CC_OP_EFLAGS;
break;
case 0xf8:
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_clc();
VAR_0->cc_op = CC_OP_EFLAGS;
break;
case 0xf9:
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_stc();
VAR_0->cc_op = CC_OP_EFLAGS;
break;
case 0xfc:
gen_op_cld();
break;
case 0xfd:
gen_op_std();
break;
case 0x1ba:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_18 = (VAR_8 >> 3) & 7;
VAR_11 = (VAR_8 >> 6) & 3;
VAR_10 = VAR_8 & 7;
if (VAR_11 != 3) {
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
gen_op_ld_T0_A0[VAR_7]();
} else {
gen_op_mov_TN_reg[VAR_7][0][VAR_10]();
}
VAR_19 = ldub(VAR_0->pc++);
gen_op_movl_T1_im(VAR_19);
if (VAR_18 < 4)
goto illegal_op;
VAR_18 -= 4;
gen_op_btx_T0_T1_cc[VAR_7 - OT_WORD][VAR_18]();
VAR_0->cc_op = CC_OP_SARB + VAR_7;
if (VAR_18 != 0) {
if (VAR_11 != 3)
gen_op_st_T0_A0[VAR_7]();
else
gen_op_mov_reg_T0[VAR_7][VAR_10]();
}
break;
case 0x1a3:
VAR_18 = 0;
goto do_btx;
case 0x1ab:
VAR_18 = 1;
goto do_btx;
case 0x1b3:
VAR_18 = 2;
goto do_btx;
case 0x1bb:
VAR_18 = 3;
do_btx:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_9 = (VAR_8 >> 3) & 7;
VAR_11 = (VAR_8 >> 6) & 3;
VAR_10 = VAR_8 & 7;
gen_op_mov_TN_reg[OT_LONG][1][VAR_9]();
if (VAR_11 != 3) {
gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);
if (VAR_7 == OT_WORD)
gen_op_add_bitw_A0_T1();
else
gen_op_add_bitl_A0_T1();
gen_op_ld_T0_A0[VAR_7]();
} else {
gen_op_mov_TN_reg[VAR_7][0][VAR_10]();
}
gen_op_btx_T0_T1_cc[VAR_7 - OT_WORD][VAR_18]();
VAR_0->cc_op = CC_OP_SARB + VAR_7;
if (VAR_18 != 0) {
if (VAR_11 != 3)
gen_op_st_T0_A0[VAR_7]();
else
gen_op_mov_reg_T0[VAR_7][VAR_10]();
}
break;
case 0x1bc:
case 0x1bd:
VAR_7 = VAR_5 ? OT_LONG : OT_WORD;
VAR_8 = ldub(VAR_0->pc++);
VAR_9 = (VAR_8 >> 3) & 7;
gen_ldst_modrm(VAR_0, VAR_8, VAR_7, OR_TMP0, 0);
gen_op_bsx_T0_cc[VAR_7 - OT_WORD][VAR_2 & 1]();
gen_op_mov_reg_T0[VAR_7][VAR_9]();
VAR_0->cc_op = CC_OP_LOGICB + VAR_7;
break;
case 0x27:
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_daa();
VAR_0->cc_op = CC_OP_EFLAGS;
break;
case 0x2f:
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_das();
VAR_0->cc_op = CC_OP_EFLAGS;
break;
case 0x37:
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_aaa();
VAR_0->cc_op = CC_OP_EFLAGS;
break;
case 0x3f:
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_aas();
VAR_0->cc_op = CC_OP_EFLAGS;
break;
case 0xd4:
VAR_19 = ldub(VAR_0->pc++);
gen_op_aam(VAR_19);
VAR_0->cc_op = CC_OP_LOGICB;
break;
case 0xd5:
VAR_19 = ldub(VAR_0->pc++);
gen_op_aad(VAR_19);
VAR_0->cc_op = CC_OP_LOGICB;
break;
case 0x90:
break;
case 0xcc:
gen_op_int3((long)VAR_1);
VAR_0->is_jmp = 1;
break;
case 0xcd:
VAR_19 = ldub(VAR_0->pc++);
gen_op_int_im((long)VAR_1);
VAR_0->is_jmp = 1;
break;
case 0xce:
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_into((long)VAR_1, (long)VAR_0->pc);
VAR_0->is_jmp = 1;
break;
case 0x1c8 ... 0x1cf:
VAR_9 = VAR_2 & 7;
gen_op_mov_TN_reg[OT_LONG][0][VAR_9]();
gen_op_bswapl_T0();
gen_op_mov_reg_T0[OT_LONG][VAR_9]();
break;
case 0xd6:
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
gen_op_salc();
break;
case 0xe0:
case 0xe1:
if (VAR_0->cc_op != CC_OP_DYNAMIC)
gen_op_set_cc_op(VAR_0->cc_op);
case 0xe2:
case 0xe3:
VAR_19 = (int8_t)insn_get(VAR_0, OT_BYTE);
VAR_24 = VAR_0->pc - VAR_0->cs_base;
VAR_19 += VAR_24;
if (VAR_0->VAR_5 == 0)
VAR_19 &= 0xffff;
gen_op_loop[VAR_0->VAR_4][VAR_2 & 3](VAR_19, VAR_24);
VAR_0->is_jmp = 1;
break;
case 0x131:
gen_op_rdtsc();
break;
#if 0
case 0x1a2:
gen_insn0(OP_ASM);
break;
#endif
default:
goto illegal_op;
}
if (VAR_0->prefix & PREFIX_LOCK)
gen_op_unlock();
return (long)VAR_0->pc;
illegal_op:
return -1;
}
| [
"long FUNC_0(DisasContext *VAR_0, uint8_t *VAR_1)\n{",
"int VAR_2, VAR_3, VAR_4, VAR_5;",
"int VAR_6, VAR_7;",
"int VAR_8, VAR_9, VAR_10, VAR_11, VAR_12, VAR_18, VAR_14, VAR_15, VAR_19;",
"unsigned int VAR_24;",
"VAR_0->pc = VAR_1;",
"VAR_3 = 0;",
"VAR_4 = VAR_0->code32;",
"VAR_5 = VAR_0->code32;",
"next_byte:\nVAR_2 = ldub(VAR_0->pc);",
"VAR_0->pc++;",
"switch (VAR_2) {",
"case 0xf3:\nVAR_3 |= PREFIX_REPZ;",
"goto next_byte;",
"case 0xf2:\nVAR_3 |= PREFIX_REPNZ;",
"goto next_byte;",
"case 0xf0:\nVAR_3 |= PREFIX_LOCK;",
"goto next_byte;",
"case 0x2e:\nVAR_3 |= PREFIX_CS;",
"goto next_byte;",
"case 0x36:\nVAR_3 |= PREFIX_SS;",
"goto next_byte;",
"case 0x3e:\nVAR_3 |= PREFIX_DS;",
"goto next_byte;",
"case 0x26:\nVAR_3 |= PREFIX_ES;",
"goto next_byte;",
"case 0x64:\nVAR_3 |= PREFIX_FS;",
"goto next_byte;",
"case 0x65:\nVAR_3 |= PREFIX_GS;",
"goto next_byte;",
"case 0x66:\nVAR_3 |= PREFIX_DATA;",
"goto next_byte;",
"case 0x67:\nVAR_3 |= PREFIX_ADR;",
"goto next_byte;",
"case 0x9b:\nVAR_3 |= PREFIX_FWAIT;",
"goto next_byte;",
"}",
"if (VAR_3 & PREFIX_DATA)\nVAR_5 ^= 1;",
"if (VAR_3 & PREFIX_ADR)\nVAR_4 ^= 1;",
"VAR_0->prefix = VAR_3;",
"VAR_0->VAR_4 = VAR_4;",
"VAR_0->VAR_5 = VAR_5;",
"if (VAR_3 & PREFIX_LOCK)\ngen_op_lock();",
"reswitch:\nswitch(VAR_2) {",
"case 0x0f:\nVAR_2 = ldub(VAR_0->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_18, VAR_18, VAR_19;",
"VAR_18 = (VAR_2 >> 3) & 7;",
"VAR_18 = (VAR_2 >> 1) & 3;",
"if ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"switch(VAR_18) {",
"case 0:\nVAR_8 = ldub(VAR_0->pc++);",
"VAR_9 = ((VAR_8 >> 3) & 7) + OR_EAX;",
"VAR_11 = (VAR_8 >> 6) & 3;",
"VAR_10 = VAR_8 & 7;",
"if (VAR_11 != 3) {",
"gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"gen_op_ld_T0_A0[VAR_7]();",
"VAR_14 = OR_TMP0;",
"} else {",
"VAR_14 = OR_EAX + VAR_10;",
"}",
"gen_op(VAR_0, VAR_18, VAR_7, VAR_14, VAR_9);",
"if (VAR_11 != 3 && VAR_18 != 7) {",
"gen_op_st_T0_A0[VAR_7]();",
"}",
"break;",
"case 1:\nVAR_8 = ldub(VAR_0->pc++);",
"VAR_11 = (VAR_8 >> 6) & 3;",
"VAR_9 = ((VAR_8 >> 3) & 7) + OR_EAX;",
"VAR_10 = VAR_8 & 7;",
"if (VAR_11 != 3) {",
"gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"gen_op_ld_T1_A0[VAR_7]();",
"VAR_14 = OR_TMP1;",
"} else {",
"VAR_14 = OR_EAX + VAR_10;",
"}",
"gen_op(VAR_0, VAR_18, VAR_7, VAR_9, VAR_14);",
"break;",
"case 2:\nVAR_19 = insn_get(VAR_0, VAR_7);",
"gen_opi(VAR_0, VAR_18, VAR_7, OR_EAX, VAR_19);",
"break;",
"}",
"}",
"break;",
"case 0x80:\ncase 0x81:\ncase 0x83:\n{",
"int VAR_19;",
"if ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_11 = (VAR_8 >> 6) & 3;",
"VAR_10 = VAR_8 & 7;",
"VAR_18 = (VAR_8 >> 3) & 7;",
"if (VAR_11 != 3) {",
"gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"gen_op_ld_T0_A0[VAR_7]();",
"VAR_14 = OR_TMP0;",
"} else {",
"VAR_14 = VAR_10 + OR_EAX;",
"}",
"switch(VAR_2) {",
"default:\ncase 0x80:\ncase 0x81:\nVAR_19 = insn_get(VAR_0, VAR_7);",
"break;",
"case 0x83:\nVAR_19 = (int8_t)insn_get(VAR_0, OT_BYTE);",
"break;",
"}",
"gen_opi(VAR_0, VAR_18, VAR_7, VAR_14, VAR_19);",
"if (VAR_18 != 7 && VAR_11 != 3) {",
"gen_op_st_T0_A0[VAR_7]();",
"}",
"}",
"break;",
"case 0x40 ... 0x47:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"gen_inc(VAR_0, VAR_7, OR_EAX + (VAR_2 & 7), 1);",
"break;",
"case 0x48 ... 0x4f:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"gen_inc(VAR_0, VAR_7, OR_EAX + (VAR_2 & 7), -1);",
"break;",
"case 0xf6:\ncase 0xf7:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_11 = (VAR_8 >> 6) & 3;",
"VAR_10 = VAR_8 & 7;",
"VAR_18 = (VAR_8 >> 3) & 7;",
"if (VAR_11 != 3) {",
"gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"gen_op_ld_T0_A0[VAR_7]();",
"} else {",
"gen_op_mov_TN_reg[VAR_7][0][VAR_10]();",
"}",
"switch(VAR_18) {",
"case 0:\nVAR_19 = insn_get(VAR_0, VAR_7);",
"gen_op_movl_T1_im(VAR_19);",
"gen_op_testl_T0_T1_cc();",
"VAR_0->cc_op = CC_OP_LOGICB + VAR_7;",
"break;",
"case 2:\ngen_op_notl_T0();",
"if (VAR_11 != 3) {",
"gen_op_st_T0_A0[VAR_7]();",
"} else {",
"gen_op_mov_reg_T0[VAR_7][VAR_10]();",
"}",
"break;",
"case 3:\ngen_op_negl_T0_cc();",
"if (VAR_11 != 3) {",
"gen_op_st_T0_A0[VAR_7]();",
"} else {",
"gen_op_mov_reg_T0[VAR_7][VAR_10]();",
"}",
"VAR_0->cc_op = CC_OP_SUBB + VAR_7;",
"break;",
"case 4:\nswitch(VAR_7) {",
"case OT_BYTE:\ngen_op_mulb_AL_T0();",
"break;",
"case OT_WORD:\ngen_op_mulw_AX_T0();",
"break;",
"default:\ncase OT_LONG:\ngen_op_mull_EAX_T0();",
"break;",
"}",
"VAR_0->cc_op = CC_OP_MUL;",
"break;",
"case 5:\nswitch(VAR_7) {",
"case OT_BYTE:\ngen_op_imulb_AL_T0();",
"break;",
"case OT_WORD:\ngen_op_imulw_AX_T0();",
"break;",
"default:\ncase OT_LONG:\ngen_op_imull_EAX_T0();",
"break;",
"}",
"VAR_0->cc_op = CC_OP_MUL;",
"break;",
"case 6:\nswitch(VAR_7) {",
"case OT_BYTE:\ngen_op_divb_AL_T0();",
"break;",
"case OT_WORD:\ngen_op_divw_AX_T0();",
"break;",
"default:\ncase OT_LONG:\ngen_op_divl_EAX_T0();",
"break;",
"}",
"break;",
"case 7:\nswitch(VAR_7) {",
"case OT_BYTE:\ngen_op_idivb_AL_T0();",
"break;",
"case OT_WORD:\ngen_op_idivw_AX_T0();",
"break;",
"default:\ncase OT_LONG:\ngen_op_idivl_EAX_T0();",
"break;",
"}",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0xfe:\ncase 0xff:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_11 = (VAR_8 >> 6) & 3;",
"VAR_10 = VAR_8 & 7;",
"VAR_18 = (VAR_8 >> 3) & 7;",
"if (VAR_18 >= 2 && VAR_2 == 0xfe) {",
"goto illegal_op;",
"}",
"if (VAR_11 != 3) {",
"gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"if (VAR_18 != 3 && VAR_18 != 5)\ngen_op_ld_T0_A0[VAR_7]();",
"} else {",
"gen_op_mov_TN_reg[VAR_7][0][VAR_10]();",
"}",
"switch(VAR_18) {",
"case 0:\ngen_inc(VAR_0, VAR_7, OR_TMP0, 1);",
"if (VAR_11 != 3)\ngen_op_st_T0_A0[VAR_7]();",
"else\ngen_op_mov_reg_T0[VAR_7][VAR_10]();",
"break;",
"case 1:\ngen_inc(VAR_0, VAR_7, OR_TMP0, -1);",
"if (VAR_11 != 3)\ngen_op_st_T0_A0[VAR_7]();",
"else\ngen_op_mov_reg_T0[VAR_7][VAR_10]();",
"break;",
"case 2:\nif (VAR_0->VAR_5 == 0)\ngen_op_andl_T0_ffff();",
"gen_op_jmp_T0();",
"VAR_24 = VAR_0->pc - VAR_0->cs_base;",
"gen_op_movl_T0_im(VAR_24);",
"gen_push_T0(VAR_0);",
"VAR_0->is_jmp = 1;",
"break;",
"case 3:\ngen_op_movl_T0_seg(R_CS);",
"gen_push_T0(VAR_0);",
"VAR_24 = VAR_0->pc - VAR_0->cs_base;",
"gen_op_movl_T0_im(VAR_24);",
"gen_push_T0(VAR_0);",
"gen_op_ld_T1_A0[VAR_7]();",
"gen_op_addl_A0_im(1 << (VAR_7 - OT_WORD + 1));",
"gen_op_lduw_T0_A0();",
"gen_movl_seg_T0(VAR_0, R_CS);",
"gen_op_movl_T0_T1();",
"gen_op_jmp_T0();",
"VAR_0->is_jmp = 1;",
"break;",
"case 4:\nif (VAR_0->VAR_5 == 0)\ngen_op_andl_T0_ffff();",
"gen_op_jmp_T0();",
"VAR_0->is_jmp = 1;",
"break;",
"case 5:\ngen_op_ld_T1_A0[VAR_7]();",
"gen_op_addl_A0_im(1 << (VAR_7 - OT_WORD + 1));",
"gen_op_lduw_T0_A0();",
"gen_movl_seg_T0(VAR_0, R_CS);",
"gen_op_movl_T0_T1();",
"gen_op_jmp_T0();",
"VAR_0->is_jmp = 1;",
"break;",
"case 6:\ngen_push_T0(VAR_0);",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x84:\ncase 0x85:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_11 = (VAR_8 >> 6) & 3;",
"VAR_10 = VAR_8 & 7;",
"VAR_9 = (VAR_8 >> 3) & 7;",
"gen_ldst_modrm(VAR_0, VAR_8, VAR_7, OR_TMP0, 0);",
"gen_op_mov_TN_reg[VAR_7][1][VAR_9 + OR_EAX]();",
"gen_op_testl_T0_T1_cc();",
"VAR_0->cc_op = CC_OP_LOGICB + VAR_7;",
"break;",
"case 0xa8:\ncase 0xa9:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_19 = insn_get(VAR_0, VAR_7);",
"gen_op_mov_TN_reg[VAR_7][0][OR_EAX]();",
"gen_op_movl_T1_im(VAR_19);",
"gen_op_testl_T0_T1_cc();",
"VAR_0->cc_op = CC_OP_LOGICB + VAR_7;",
"break;",
"case 0x98:\nif (VAR_5)\ngen_op_movswl_EAX_AX();",
"else\ngen_op_movsbw_AX_AL();",
"break;",
"case 0x99:\nif (VAR_5)\ngen_op_movslq_EDX_EAX();",
"else\ngen_op_movswl_DX_AX();",
"break;",
"case 0x1af:\ncase 0x69:\ncase 0x6b:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_9 = ((VAR_8 >> 3) & 7) + OR_EAX;",
"gen_ldst_modrm(VAR_0, VAR_8, VAR_7, OR_TMP0, 0);",
"if (VAR_2 == 0x69) {",
"VAR_19 = insn_get(VAR_0, VAR_7);",
"gen_op_movl_T1_im(VAR_19);",
"} else if (VAR_2 == 0x6b) {",
"VAR_19 = insn_get(VAR_0, OT_BYTE);",
"gen_op_movl_T1_im(VAR_19);",
"} else {",
"gen_op_mov_TN_reg[VAR_7][1][VAR_9]();",
"}",
"if (VAR_7 == OT_LONG) {",
"gen_op_imull_T0_T1();",
"} else {",
"gen_op_imulw_T0_T1();",
"}",
"gen_op_mov_reg_T0[VAR_7][VAR_9]();",
"VAR_0->cc_op = CC_OP_MUL;",
"break;",
"case 0x1c0:\ncase 0x1c1:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_9 = (VAR_8 >> 3) & 7;",
"VAR_11 = (VAR_8 >> 6) & 3;",
"if (VAR_11 == 3) {",
"VAR_10 = VAR_8 & 7;",
"gen_op_mov_TN_reg[VAR_7][0][VAR_9]();",
"gen_op_mov_TN_reg[VAR_7][1][VAR_10]();",
"gen_op_addl_T0_T1_cc();",
"gen_op_mov_reg_T0[VAR_7][VAR_10]();",
"gen_op_mov_reg_T1[VAR_7][VAR_9]();",
"} else {",
"gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"gen_op_mov_TN_reg[VAR_7][0][VAR_9]();",
"gen_op_ld_T1_A0[VAR_7]();",
"gen_op_addl_T0_T1_cc();",
"gen_op_st_T0_A0[VAR_7]();",
"gen_op_mov_reg_T1[VAR_7][VAR_9]();",
"}",
"VAR_0->cc_op = CC_OP_ADDB + VAR_7;",
"break;",
"case 0x1b0:\ncase 0x1b1:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_9 = (VAR_8 >> 3) & 7;",
"VAR_11 = (VAR_8 >> 6) & 3;",
"gen_op_mov_TN_reg[VAR_7][1][VAR_9]();",
"if (VAR_11 == 3) {",
"VAR_10 = VAR_8 & 7;",
"gen_op_mov_TN_reg[VAR_7][0][VAR_10]();",
"gen_op_cmpxchg_T0_T1_EAX_cc[VAR_7]();",
"gen_op_mov_reg_T0[VAR_7][VAR_10]();",
"} else {",
"gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"gen_op_ld_T0_A0[VAR_7]();",
"gen_op_cmpxchg_T0_T1_EAX_cc[VAR_7]();",
"gen_op_st_T0_A0[VAR_7]();",
"}",
"VAR_0->cc_op = CC_OP_SUBB + VAR_7;",
"break;",
"case 0x50 ... 0x57:\ngen_op_mov_TN_reg[OT_LONG][0][VAR_2 & 7]();",
"gen_push_T0(VAR_0);",
"break;",
"case 0x58 ... 0x5f:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"gen_pop_T0(VAR_0);",
"gen_op_mov_reg_T0[VAR_7][VAR_2 & 7]();",
"gen_pop_update(VAR_0);",
"break;",
"case 0x60:\ngen_pusha(VAR_0);",
"break;",
"case 0x61:\ngen_popa(VAR_0);",
"break;",
"case 0x68:\ncase 0x6a:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"if (VAR_2 == 0x68)\nVAR_19 = insn_get(VAR_0, VAR_7);",
"else\nVAR_19 = (int8_t)insn_get(VAR_0, OT_BYTE);",
"gen_op_movl_T0_im(VAR_19);",
"gen_push_T0(VAR_0);",
"break;",
"case 0x8f:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"gen_pop_T0(VAR_0);",
"gen_ldst_modrm(VAR_0, VAR_8, VAR_7, OR_TMP0, 1);",
"gen_pop_update(VAR_0);",
"break;",
"case 0xc8:\n{",
"int VAR_19;",
"VAR_19 = lduw(VAR_0->pc);",
"VAR_0->pc += 2;",
"VAR_19 = ldub(VAR_0->pc++);",
"gen_enter(VAR_0, VAR_19, VAR_19);",
"}",
"break;",
"case 0xc9:\nif (VAR_0->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(VAR_0);",
"VAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"gen_op_mov_reg_T0[VAR_7][R_EBP]();",
"gen_pop_update(VAR_0);",
"break;",
"case 0x06:\ncase 0x0e:\ncase 0x16:\ncase 0x1e:\ngen_op_movl_T0_seg(VAR_2 >> 3);",
"gen_push_T0(VAR_0);",
"break;",
"case 0x1a0:\ncase 0x1a8:\ngen_op_movl_T0_seg(((VAR_2 >> 3) & 7) + R_FS);",
"gen_push_T0(VAR_0);",
"break;",
"case 0x07:\ncase 0x17:\ncase 0x1f:\ngen_pop_T0(VAR_0);",
"gen_movl_seg_T0(VAR_0, VAR_2 >> 3);",
"gen_pop_update(VAR_0);",
"break;",
"case 0x1a1:\ncase 0x1a9:\ngen_pop_T0(VAR_0);",
"gen_movl_seg_T0(VAR_0, ((VAR_2 >> 3) & 7) + R_FS);",
"gen_pop_update(VAR_0);",
"break;",
"case 0x88:\ncase 0x89:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_9 = (VAR_8 >> 3) & 7;",
"gen_ldst_modrm(VAR_0, VAR_8, VAR_7, OR_EAX + VAR_9, 1);",
"break;",
"case 0xc6:\ncase 0xc7:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_11 = (VAR_8 >> 6) & 3;",
"if (VAR_11 != 3)\ngen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"VAR_19 = insn_get(VAR_0, VAR_7);",
"gen_op_movl_T0_im(VAR_19);",
"if (VAR_11 != 3)\ngen_op_st_T0_A0[VAR_7]();",
"else\ngen_op_mov_reg_T0[VAR_7][VAR_8 & 7]();",
"break;",
"case 0x8a:\ncase 0x8b:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_9 = (VAR_8 >> 3) & 7;",
"gen_ldst_modrm(VAR_0, VAR_8, VAR_7, OR_TMP0, 0);",
"gen_op_mov_reg_T0[VAR_7][VAR_9]();",
"break;",
"case 0x8e:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_9 = (VAR_8 >> 3) & 7;",
"gen_ldst_modrm(VAR_0, VAR_8, VAR_7, OR_TMP0, 0);",
"if (VAR_9 >= 6 || VAR_9 == R_CS)\ngoto illegal_op;",
"gen_movl_seg_T0(VAR_0, VAR_9);",
"break;",
"case 0x8c:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_9 = (VAR_8 >> 3) & 7;",
"if (VAR_9 >= 6)\ngoto illegal_op;",
"gen_op_movl_T0_seg(VAR_9);",
"gen_ldst_modrm(VAR_0, VAR_8, VAR_7, OR_TMP0, 1);",
"break;",
"case 0x1b6:\ncase 0x1b7:\ncase 0x1be:\ncase 0x1bf:\n{",
"int VAR_20;",
"VAR_20 = VAR_5 + OT_WORD;",
"VAR_7 = (VAR_2 & 1) + OT_BYTE;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_9 = ((VAR_8 >> 3) & 7) + OR_EAX;",
"VAR_11 = (VAR_8 >> 6) & 3;",
"VAR_10 = VAR_8 & 7;",
"if (VAR_11 == 3) {",
"gen_op_mov_TN_reg[VAR_7][0][VAR_10]();",
"switch(VAR_7 | (VAR_2 & 8)) {",
"case OT_BYTE:\ngen_op_movzbl_T0_T0();",
"break;",
"case OT_BYTE | 8:\ngen_op_movsbl_T0_T0();",
"break;",
"case OT_WORD:\ngen_op_movzwl_T0_T0();",
"break;",
"default:\ncase OT_WORD | 8:\ngen_op_movswl_T0_T0();",
"break;",
"}",
"gen_op_mov_reg_T0[VAR_20][VAR_9]();",
"} else {",
"gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"if (VAR_2 & 8) {",
"gen_op_lds_T0_A0[VAR_7]();",
"} else {",
"gen_op_ldu_T0_A0[VAR_7]();",
"}",
"gen_op_mov_reg_T0[VAR_20][VAR_9]();",
"}",
"}",
"break;",
"case 0x8d:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_9 = (VAR_8 >> 3) & 7;",
"VAR_0->prefix &= ~(PREFIX_CS | PREFIX_SS | PREFIX_DS |\nPREFIX_ES | PREFIX_FS | PREFIX_GS);",
"VAR_19 = VAR_0->addseg;",
"VAR_0->addseg = 0;",
"gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"VAR_0->addseg = VAR_19;",
"gen_op_mov_reg_A0[VAR_7 - OT_WORD][VAR_9]();",
"break;",
"case 0xa0:\ncase 0xa1:\ncase 0xa2:\ncase 0xa3:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"if (VAR_0->VAR_4)\nVAR_15 = insn_get(VAR_0, OT_LONG);",
"else\nVAR_15 = insn_get(VAR_0, OT_WORD);",
"gen_op_movl_A0_im(VAR_15);",
"{",
"int VAR_23, VAR_23;",
"VAR_23 = R_DS;",
"VAR_23 = VAR_0->addseg;",
"if (VAR_0->prefix & (PREFIX_CS | PREFIX_SS | PREFIX_DS |\nPREFIX_ES | PREFIX_FS | PREFIX_GS)) {",
"if (VAR_0->prefix & PREFIX_ES)\nVAR_23 = R_ES;",
"else if (VAR_0->prefix & PREFIX_CS)\nVAR_23 = R_CS;",
"else if (VAR_0->prefix & PREFIX_SS)\nVAR_23 = R_SS;",
"else if (VAR_0->prefix & PREFIX_DS)\nVAR_23 = R_DS;",
"else if (VAR_0->prefix & PREFIX_FS)\nVAR_23 = R_FS;",
"else\nVAR_23 = R_GS;",
"VAR_23 = 1;",
"}",
"if (VAR_23) {",
"gen_op_addl_A0_seg(offsetof(CPUX86State,seg_cache[VAR_23].base));",
"}",
"}",
"if ((VAR_2 & 2) == 0) {",
"gen_op_ld_T0_A0[VAR_7]();",
"gen_op_mov_reg_T0[VAR_7][R_EAX]();",
"} else {",
"gen_op_mov_TN_reg[VAR_7][0][R_EAX]();",
"gen_op_st_T0_A0[VAR_7]();",
"}",
"break;",
"case 0xd7:\ngen_op_movl_A0_reg[R_EBX]();",
"gen_op_addl_A0_AL();",
"if (VAR_0->VAR_4 == 0)\ngen_op_andl_A0_ffff();",
"{",
"int VAR_23, VAR_23;",
"VAR_23 = R_DS;",
"VAR_23 = VAR_0->addseg;",
"if (VAR_0->prefix & (PREFIX_CS | PREFIX_SS | PREFIX_DS |\nPREFIX_ES | PREFIX_FS | PREFIX_GS)) {",
"if (VAR_0->prefix & PREFIX_ES)\nVAR_23 = R_ES;",
"else if (VAR_0->prefix & PREFIX_CS)\nVAR_23 = R_CS;",
"else if (VAR_0->prefix & PREFIX_SS)\nVAR_23 = R_SS;",
"else if (VAR_0->prefix & PREFIX_DS)\nVAR_23 = R_DS;",
"else if (VAR_0->prefix & PREFIX_FS)\nVAR_23 = R_FS;",
"else\nVAR_23 = R_GS;",
"VAR_23 = 1;",
"}",
"if (VAR_23) {",
"gen_op_addl_A0_seg(offsetof(CPUX86State,seg_cache[VAR_23].base));",
"}",
"}",
"gen_op_ldub_T0_A0();",
"gen_op_mov_reg_T0[OT_BYTE][R_EAX]();",
"break;",
"case 0xb0 ... 0xb7:\nVAR_19 = insn_get(VAR_0, OT_BYTE);",
"gen_op_movl_T0_im(VAR_19);",
"gen_op_mov_reg_T0[OT_BYTE][VAR_2 & 7]();",
"break;",
"case 0xb8 ... 0xbf:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_19 = insn_get(VAR_0, VAR_7);",
"VAR_9 = OR_EAX + (VAR_2 & 7);",
"gen_op_movl_T0_im(VAR_19);",
"gen_op_mov_reg_T0[VAR_7][VAR_9]();",
"break;",
"case 0x91 ... 0x97:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_9 = VAR_2 & 7;",
"VAR_10 = R_EAX;",
"goto do_xchg_reg;",
"case 0x86:\ncase 0x87:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_9 = (VAR_8 >> 3) & 7;",
"VAR_11 = (VAR_8 >> 6) & 3;",
"if (VAR_11 == 3) {",
"VAR_10 = VAR_8 & 7;",
"do_xchg_reg:\ngen_op_mov_TN_reg[VAR_7][0][VAR_9]();",
"gen_op_mov_TN_reg[VAR_7][1][VAR_10]();",
"gen_op_mov_reg_T0[VAR_7][VAR_10]();",
"gen_op_mov_reg_T1[VAR_7][VAR_9]();",
"} else {",
"gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"gen_op_mov_TN_reg[VAR_7][0][VAR_9]();",
"if (!(VAR_3 & PREFIX_LOCK))\ngen_op_lock();",
"gen_op_ld_T1_A0[VAR_7]();",
"gen_op_st_T0_A0[VAR_7]();",
"if (!(VAR_3 & PREFIX_LOCK))\ngen_op_unlock();",
"gen_op_mov_reg_T1[VAR_7][VAR_9]();",
"}",
"break;",
"case 0xc4:\nVAR_18 = R_ES;",
"goto do_lxx;",
"case 0xc5:\nVAR_18 = R_DS;",
"goto do_lxx;",
"case 0x1b2:\nVAR_18 = R_SS;",
"goto do_lxx;",
"case 0x1b4:\nVAR_18 = R_FS;",
"goto do_lxx;",
"case 0x1b5:\nVAR_18 = R_GS;",
"do_lxx:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_9 = (VAR_8 >> 3) & 7;",
"VAR_11 = (VAR_8 >> 6) & 3;",
"if (VAR_11 == 3)\ngoto illegal_op;",
"gen_op_ld_T1_A0[VAR_7]();",
"gen_op_addl_A0_im(1 << (VAR_7 - OT_WORD + 1));",
"gen_op_lduw_T0_A0();",
"gen_movl_seg_T0(VAR_0, VAR_18);",
"gen_op_mov_reg_T1[VAR_7][VAR_9]();",
"break;",
"case 0xc0:\ncase 0xc1:\nVAR_6 = 2;",
"grp2:\n{",
"if ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_11 = (VAR_8 >> 6) & 3;",
"VAR_10 = VAR_8 & 7;",
"VAR_18 = (VAR_8 >> 3) & 7;",
"if (VAR_11 != 3) {",
"gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"gen_op_ld_T0_A0[VAR_7]();",
"VAR_14 = OR_TMP0;",
"} else {",
"VAR_14 = VAR_10 + OR_EAX;",
"}",
"if (VAR_6 == 0) {",
"gen_shift(VAR_0, VAR_18, VAR_7, VAR_14, OR_ECX);",
"} else {",
"if (VAR_6 == 2) {",
"VAR_6 = ldub(VAR_0->pc++);",
"}",
"gen_shifti(VAR_0, VAR_18, VAR_7, VAR_14, VAR_6);",
"}",
"if (VAR_11 != 3) {",
"gen_op_st_T0_A0[VAR_7]();",
"}",
"}",
"break;",
"case 0xd0:\ncase 0xd1:\nVAR_6 = 1;",
"goto grp2;",
"case 0xd2:\ncase 0xd3:\nVAR_6 = 0;",
"goto grp2;",
"case 0x1a4:\nVAR_18 = 0;",
"VAR_6 = 1;",
"goto do_shiftd;",
"case 0x1a5:\nVAR_18 = 0;",
"VAR_6 = 0;",
"goto do_shiftd;",
"case 0x1ac:\nVAR_18 = 1;",
"VAR_6 = 1;",
"goto do_shiftd;",
"case 0x1ad:\nVAR_18 = 1;",
"VAR_6 = 0;",
"do_shiftd:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_11 = (VAR_8 >> 6) & 3;",
"VAR_10 = VAR_8 & 7;",
"VAR_9 = (VAR_8 >> 3) & 7;",
"if (VAR_11 != 3) {",
"gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"gen_op_ld_T0_A0[VAR_7]();",
"} else {",
"gen_op_mov_TN_reg[VAR_7][0][VAR_10]();",
"}",
"gen_op_mov_TN_reg[VAR_7][1][VAR_9]();",
"if (VAR_6) {",
"VAR_19 = ldub(VAR_0->pc++);",
"VAR_19 &= 0x1f;",
"if (VAR_19) {",
"gen_op_shiftd_T0_T1_im_cc[VAR_7 - OT_WORD][VAR_18](VAR_19);",
"if (VAR_18 == 0 && VAR_7 != OT_WORD)\nVAR_0->cc_op = CC_OP_SHLB + VAR_7;",
"else\nVAR_0->cc_op = CC_OP_SARB + VAR_7;",
"}",
"} else {",
"if (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_shiftd_T0_T1_ECX_cc[VAR_7 - OT_WORD][VAR_18]();",
"VAR_0->cc_op = CC_OP_DYNAMIC;",
"}",
"if (VAR_11 != 3) {",
"gen_op_st_T0_A0[VAR_7]();",
"} else {",
"gen_op_mov_reg_T0[VAR_7][VAR_10]();",
"}",
"break;",
"case 0xd8 ... 0xdf:\nVAR_8 = ldub(VAR_0->pc++);",
"VAR_11 = (VAR_8 >> 6) & 3;",
"VAR_10 = VAR_8 & 7;",
"VAR_18 = ((VAR_2 & 7) << 3) | ((VAR_8 >> 3) & 7);",
"if (VAR_11 != 3) {",
"gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"switch(VAR_18) {",
"case 0x00 ... 0x07:\ncase 0x10 ... 0x17:\ncase 0x20 ... 0x27:\ncase 0x30 ... 0x37:\n{",
"int VAR_24;",
"VAR_24 = VAR_18 & 7;",
"switch(VAR_18 >> 4) {",
"case 0:\ngen_op_flds_FT0_A0();",
"break;",
"case 1:\ngen_op_fildl_FT0_A0();",
"break;",
"case 2:\ngen_op_fldl_FT0_A0();",
"break;",
"case 3:\ndefault:\ngen_op_fild_FT0_A0();",
"break;",
"}",
"gen_op_fp_arith_ST0_FT0[VAR_24]();",
"if (VAR_24 == 3) {",
"gen_op_fpop();",
"}",
"}",
"break;",
"case 0x08:\ncase 0x0a:\ncase 0x0b:\ncase 0x18:\ncase 0x1a:\ncase 0x1b:\ncase 0x28:\ncase 0x2a:\ncase 0x2b:\ncase 0x38:\ncase 0x3a:\ncase 0x3b:\nswitch(VAR_18 & 7) {",
"case 0:\ngen_op_fpush();",
"switch(VAR_18 >> 4) {",
"case 0:\ngen_op_flds_ST0_A0();",
"break;",
"case 1:\ngen_op_fildl_ST0_A0();",
"break;",
"case 2:\ngen_op_fldl_ST0_A0();",
"break;",
"case 3:\ndefault:\ngen_op_fild_ST0_A0();",
"break;",
"}",
"break;",
"default:\nswitch(VAR_18 >> 4) {",
"case 0:\ngen_op_fsts_ST0_A0();",
"break;",
"case 1:\ngen_op_fistl_ST0_A0();",
"break;",
"case 2:\ngen_op_fstl_ST0_A0();",
"break;",
"case 3:\ndefault:\ngen_op_fist_ST0_A0();",
"break;",
"}",
"if ((VAR_18 & 7) == 3)\ngen_op_fpop();",
"break;",
"}",
"break;",
"case 0x0d:\ngen_op_fldcw_A0();",
"break;",
"case 0x0f:\ngen_op_fnstcw_A0();",
"break;",
"case 0x1d:\ngen_op_fpush();",
"gen_op_fldt_ST0_A0();",
"break;",
"case 0x1f:\ngen_op_fstt_ST0_A0();",
"gen_op_fpop();",
"break;",
"case 0x2f:\ngen_op_fnstsw_A0();",
"break;",
"case 0x3c:\ngen_op_fpush();",
"gen_op_fbld_ST0_A0();",
"break;",
"case 0x3e:\ngen_op_fbst_ST0_A0();",
"gen_op_fpop();",
"break;",
"case 0x3d:\ngen_op_fpush();",
"gen_op_fildll_ST0_A0();",
"break;",
"case 0x3f:\ngen_op_fistll_ST0_A0();",
"gen_op_fpop();",
"break;",
"default:\ngoto illegal_op;",
"}",
"} else {",
"VAR_14 = VAR_10;",
"switch(VAR_18) {",
"case 0x08:\ngen_op_fpush();",
"gen_op_fmov_ST0_STN((VAR_14 + 1) & 7);",
"break;",
"case 0x09:\ngen_op_fxchg_ST0_STN(VAR_14);",
"break;",
"case 0x0a:\nswitch(VAR_10) {",
"case 0:\nbreak;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x0c:\nswitch(VAR_10) {",
"case 0:\ngen_op_fchs_ST0();",
"break;",
"case 1:\ngen_op_fabs_ST0();",
"break;",
"case 4:\ngen_op_fldz_FT0();",
"gen_op_fcom_ST0_FT0();",
"break;",
"case 5:\ngen_op_fxam_ST0();",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x0d:\n{",
"switch(VAR_10) {",
"case 0:\ngen_op_fpush();",
"gen_op_fld1_ST0();",
"break;",
"case 1:\ngen_op_fpush();",
"gen_op_fldl2t_ST0();",
"break;",
"case 2:\ngen_op_fpush();",
"gen_op_fldl2e_ST0();",
"break;",
"case 3:\ngen_op_fpush();",
"gen_op_fldpi_ST0();",
"break;",
"case 4:\ngen_op_fpush();",
"gen_op_fldlg2_ST0();",
"break;",
"case 5:\ngen_op_fpush();",
"gen_op_fldln2_ST0();",
"break;",
"case 6:\ngen_op_fpush();",
"gen_op_fldz_ST0();",
"break;",
"default:\ngoto illegal_op;",
"}",
"}",
"break;",
"case 0x0e:\nswitch(VAR_10) {",
"case 0:\ngen_op_f2xm1();",
"break;",
"case 1:\ngen_op_fyl2x();",
"break;",
"case 2:\ngen_op_fptan();",
"break;",
"case 3:\ngen_op_fpatan();",
"break;",
"case 4:\ngen_op_fxtract();",
"break;",
"case 5:\ngen_op_fprem1();",
"break;",
"case 6:\ngen_op_fdecstp();",
"break;",
"default:\ncase 7:\ngen_op_fincstp();",
"break;",
"}",
"break;",
"case 0x0f:\nswitch(VAR_10) {",
"case 0:\ngen_op_fprem();",
"break;",
"case 1:\ngen_op_fyl2xp1();",
"break;",
"case 2:\ngen_op_fsqrt();",
"break;",
"case 3:\ngen_op_fsincos();",
"break;",
"case 5:\ngen_op_fscale();",
"break;",
"case 4:\ngen_op_frndint();",
"break;",
"case 6:\ngen_op_fsin();",
"break;",
"default:\ncase 7:\ngen_op_fcos();",
"break;",
"}",
"break;",
"case 0x00: case 0x01: case 0x04 ... 0x07:\ncase 0x20: case 0x21: case 0x24 ... 0x27:\ncase 0x30: case 0x31: case 0x34 ... 0x37:\n{",
"int VAR_24;",
"VAR_24 = VAR_18 & 7;",
"if (VAR_18 >= 0x20) {",
"gen_op_fp_arith_STN_ST0[VAR_24](VAR_14);",
"if (VAR_18 >= 0x30)\ngen_op_fpop();",
"} else {",
"gen_op_fmov_FT0_STN(VAR_14);",
"gen_op_fp_arith_ST0_FT0[VAR_24]();",
"}",
"}",
"break;",
"case 0x02:\ngen_op_fmov_FT0_STN(VAR_14);",
"gen_op_fcom_ST0_FT0();",
"break;",
"case 0x03:\ngen_op_fmov_FT0_STN(VAR_14);",
"gen_op_fcom_ST0_FT0();",
"gen_op_fpop();",
"break;",
"case 0x15:\nswitch(VAR_10) {",
"case 1:\ngen_op_fmov_FT0_STN(1);",
"gen_op_fucom_ST0_FT0();",
"gen_op_fpop();",
"gen_op_fpop();",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x1c:\nswitch(VAR_10) {",
"case 2:\ngen_op_fclex();",
"break;",
"case 3:\ngen_op_fninit();",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x2a:\ngen_op_fmov_STN_ST0(VAR_14);",
"break;",
"case 0x2b:\ngen_op_fmov_STN_ST0(VAR_14);",
"gen_op_fpop();",
"break;",
"case 0x2c:\ngen_op_fmov_FT0_STN(VAR_14);",
"gen_op_fucom_ST0_FT0();",
"break;",
"case 0x2d:\ngen_op_fmov_FT0_STN(VAR_14);",
"gen_op_fucom_ST0_FT0();",
"gen_op_fpop();",
"break;",
"case 0x33:\nswitch(VAR_10) {",
"case 1:\ngen_op_fmov_FT0_STN(1);",
"gen_op_fcom_ST0_FT0();",
"gen_op_fpop();",
"gen_op_fpop();",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"case 0x3c:\nswitch(VAR_10) {",
"case 0:\ngen_op_fnstsw_EAX();",
"break;",
"default:\ngoto illegal_op;",
"}",
"break;",
"default:\ngoto illegal_op;",
"}",
"}",
"break;",
"case 0xa4:\ncase 0xa5:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"if (VAR_3 & PREFIX_REPZ) {",
"gen_op_movs[3 + VAR_7]();",
"} else {",
"gen_op_movs[VAR_7]();",
"}",
"break;",
"case 0xaa:\ncase 0xab:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"if (VAR_3 & PREFIX_REPZ) {",
"gen_op_stos[3 + VAR_7]();",
"} else {",
"gen_op_stos[VAR_7]();",
"}",
"break;",
"case 0xac:\ncase 0xad:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"if (VAR_3 & PREFIX_REPZ) {",
"gen_op_lods[3 + VAR_7]();",
"} else {",
"gen_op_lods[VAR_7]();",
"}",
"break;",
"case 0xae:\ncase 0xaf:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"if (VAR_3 & PREFIX_REPNZ) {",
"if (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_scas[6 + VAR_7]();",
"VAR_0->cc_op = CC_OP_DYNAMIC;",
"} else if (VAR_3 & PREFIX_REPZ) {",
"if (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_scas[3 + VAR_7]();",
"VAR_0->cc_op = CC_OP_DYNAMIC;",
"} else {",
"gen_op_scas[VAR_7]();",
"VAR_0->cc_op = CC_OP_SUBB + VAR_7;",
"}",
"break;",
"case 0xa6:\ncase 0xa7:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"if (VAR_3 & PREFIX_REPNZ) {",
"if (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_cmps[6 + VAR_7]();",
"VAR_0->cc_op = CC_OP_DYNAMIC;",
"} else if (VAR_3 & PREFIX_REPZ) {",
"if (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_cmps[3 + VAR_7]();",
"VAR_0->cc_op = CC_OP_DYNAMIC;",
"} else {",
"gen_op_cmps[VAR_7]();",
"VAR_0->cc_op = CC_OP_SUBB + VAR_7;",
"}",
"break;",
"case 0x6c:\ncase 0x6d:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"if (VAR_3 & PREFIX_REPZ) {",
"gen_op_ins[3 + VAR_7]();",
"} else {",
"gen_op_ins[VAR_7]();",
"}",
"break;",
"case 0x6e:\ncase 0x6f:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"if (VAR_3 & PREFIX_REPZ) {",
"gen_op_outs[3 + VAR_7]();",
"} else {",
"gen_op_outs[VAR_7]();",
"}",
"break;",
"case 0xe4:\ncase 0xe5:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_19 = ldub(VAR_0->pc++);",
"gen_op_movl_T0_im(VAR_19);",
"gen_op_in[VAR_7]();",
"gen_op_mov_reg_T1[VAR_7][R_EAX]();",
"break;",
"case 0xe6:\ncase 0xe7:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_19 = ldub(VAR_0->pc++);",
"gen_op_movl_T0_im(VAR_19);",
"gen_op_mov_TN_reg[VAR_7][1][R_EAX]();",
"gen_op_out[VAR_7]();",
"break;",
"case 0xec:\ncase 0xed:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();",
"gen_op_in[VAR_7]();",
"gen_op_mov_reg_T1[VAR_7][R_EAX]();",
"break;",
"case 0xee:\ncase 0xef:\nif ((VAR_2 & 1) == 0)\nVAR_7 = OT_BYTE;",
"else\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();",
"gen_op_mov_TN_reg[VAR_7][1][R_EAX]();",
"gen_op_out[VAR_7]();",
"break;",
"case 0xc2:\nVAR_19 = ldsw(VAR_0->pc);",
"VAR_0->pc += 2;",
"gen_pop_T0(VAR_0);",
"if (VAR_0->ss32)\ngen_op_addl_ESP_im(VAR_19 + (2 << VAR_0->VAR_5));",
"else\ngen_op_addw_ESP_im(VAR_19 + (2 << VAR_0->VAR_5));",
"if (VAR_0->VAR_5 == 0)\ngen_op_andl_T0_ffff();",
"gen_op_jmp_T0();",
"VAR_0->is_jmp = 1;",
"break;",
"case 0xc3:\ngen_pop_T0(VAR_0);",
"gen_pop_update(VAR_0);",
"if (VAR_0->VAR_5 == 0)\ngen_op_andl_T0_ffff();",
"gen_op_jmp_T0();",
"VAR_0->is_jmp = 1;",
"break;",
"case 0xca:\nVAR_19 = ldsw(VAR_0->pc);",
"VAR_0->pc += 2;",
"gen_pop_T0(VAR_0);",
"if (VAR_0->VAR_5 == 0)\ngen_op_andl_T0_ffff();",
"gen_op_jmp_T0();",
"gen_pop_update(VAR_0);",
"gen_pop_T0(VAR_0);",
"gen_movl_seg_T0(VAR_0, R_CS);",
"gen_pop_update(VAR_0);",
"if (VAR_0->ss32)\ngen_op_addl_ESP_im(VAR_19 + (2 << VAR_0->VAR_5));",
"else\ngen_op_addw_ESP_im(VAR_19 + (2 << VAR_0->VAR_5));",
"VAR_0->is_jmp = 1;",
"break;",
"case 0xcb:\ngen_pop_T0(VAR_0);",
"if (VAR_0->VAR_5 == 0)\ngen_op_andl_T0_ffff();",
"gen_op_jmp_T0();",
"gen_pop_update(VAR_0);",
"gen_pop_T0(VAR_0);",
"gen_movl_seg_T0(VAR_0, R_CS);",
"gen_pop_update(VAR_0);",
"VAR_0->is_jmp = 1;",
"break;",
"case 0xe8:\n{",
"unsigned int VAR_24;",
"VAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_19 = insn_get(VAR_0, VAR_7);",
"VAR_24 = VAR_0->pc - VAR_0->cs_base;",
"VAR_19 += VAR_24;",
"if (VAR_0->VAR_5 == 0)\nVAR_19 &= 0xffff;",
"gen_op_movl_T0_im(VAR_24);",
"gen_push_T0(VAR_0);",
"gen_op_jmp_im(VAR_19);",
"VAR_0->is_jmp = 1;",
"}",
"break;",
"case 0x9a:\n{",
"unsigned int VAR_26, VAR_26;",
"VAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_26 = insn_get(VAR_0, VAR_7);",
"VAR_26 = insn_get(VAR_0, OT_WORD);",
"gen_op_movl_T0_seg(R_CS);",
"gen_push_T0(VAR_0);",
"VAR_24 = VAR_0->pc - VAR_0->cs_base;",
"gen_op_movl_T0_im(VAR_24);",
"gen_push_T0(VAR_0);",
"gen_op_movl_T0_im(VAR_26);",
"gen_movl_seg_T0(VAR_0, R_CS);",
"gen_op_jmp_im((unsigned long)VAR_26);",
"VAR_0->is_jmp = 1;",
"}",
"break;",
"case 0xe9:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_19 = insn_get(VAR_0, VAR_7);",
"VAR_19 += VAR_0->pc - VAR_0->cs_base;",
"if (VAR_0->VAR_5 == 0)\nVAR_19 = VAR_19 & 0xffff;",
"gen_op_jmp_im(VAR_19);",
"VAR_0->is_jmp = 1;",
"break;",
"case 0xea:\n{",
"unsigned int VAR_26, VAR_26;",
"VAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_26 = insn_get(VAR_0, VAR_7);",
"VAR_26 = insn_get(VAR_0, OT_WORD);",
"gen_op_movl_T0_im(VAR_26);",
"gen_movl_seg_T0(VAR_0, R_CS);",
"gen_op_jmp_im((unsigned long)VAR_26);",
"VAR_0->is_jmp = 1;",
"}",
"break;",
"case 0xeb:\nVAR_19 = (int8_t)insn_get(VAR_0, OT_BYTE);",
"VAR_19 += VAR_0->pc - VAR_0->cs_base;",
"if (VAR_0->VAR_5 == 0)\nVAR_19 = VAR_19 & 0xffff;",
"gen_op_jmp_im(VAR_19);",
"VAR_0->is_jmp = 1;",
"break;",
"case 0x70 ... 0x7f:\nVAR_19 = (int8_t)insn_get(VAR_0, OT_BYTE);",
"goto do_jcc;",
"case 0x180 ... 0x18f:\nif (VAR_5) {",
"VAR_19 = insn_get(VAR_0, OT_LONG);",
"} else {",
"VAR_19 = (int16_t)insn_get(VAR_0, OT_WORD);",
"}",
"do_jcc:\nVAR_24 = VAR_0->pc - VAR_0->cs_base;",
"VAR_19 += VAR_24;",
"if (VAR_0->VAR_5 == 0)\nVAR_19 &= 0xffff;",
"gen_jcc(VAR_0, VAR_2, VAR_19, VAR_24);",
"VAR_0->is_jmp = 1;",
"break;",
"case 0x190 ... 0x19f:\nVAR_8 = ldub(VAR_0->pc++);",
"gen_setcc(VAR_0, VAR_2);",
"gen_ldst_modrm(VAR_0, VAR_8, OT_BYTE, OR_TMP0, 1);",
"break;",
"case 0x140 ... 0x14f:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_9 = (VAR_8 >> 3) & 7;",
"VAR_11 = (VAR_8 >> 6) & 3;",
"gen_setcc(VAR_0, VAR_2);",
"if (VAR_11 != 3) {",
"gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"gen_op_ld_T1_A0[VAR_7]();",
"} else {",
"VAR_10 = VAR_8 & 7;",
"gen_op_mov_TN_reg[VAR_7][1][VAR_10]();",
"}",
"gen_op_cmov_reg_T1_T0[VAR_7 - OT_WORD][VAR_9]();",
"break;",
"case 0x9c:\nif (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_movl_T0_eflags();",
"gen_push_T0(VAR_0);",
"break;",
"case 0x9d:\ngen_pop_T0(VAR_0);",
"gen_op_movl_eflags_T0();",
"gen_pop_update(VAR_0);",
"VAR_0->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x9e:\ngen_op_mov_TN_reg[OT_BYTE][0][R_AH]();",
"if (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_movb_eflags_T0();",
"VAR_0->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x9f:\nif (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_movl_T0_eflags();",
"gen_op_mov_reg_T0[OT_BYTE][R_AH]();",
"break;",
"case 0xf5:\nif (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_cmc();",
"VAR_0->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0xf8:\nif (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_clc();",
"VAR_0->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0xf9:\nif (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_stc();",
"VAR_0->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0xfc:\ngen_op_cld();",
"break;",
"case 0xfd:\ngen_op_std();",
"break;",
"case 0x1ba:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_18 = (VAR_8 >> 3) & 7;",
"VAR_11 = (VAR_8 >> 6) & 3;",
"VAR_10 = VAR_8 & 7;",
"if (VAR_11 != 3) {",
"gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"gen_op_ld_T0_A0[VAR_7]();",
"} else {",
"gen_op_mov_TN_reg[VAR_7][0][VAR_10]();",
"}",
"VAR_19 = ldub(VAR_0->pc++);",
"gen_op_movl_T1_im(VAR_19);",
"if (VAR_18 < 4)\ngoto illegal_op;",
"VAR_18 -= 4;",
"gen_op_btx_T0_T1_cc[VAR_7 - OT_WORD][VAR_18]();",
"VAR_0->cc_op = CC_OP_SARB + VAR_7;",
"if (VAR_18 != 0) {",
"if (VAR_11 != 3)\ngen_op_st_T0_A0[VAR_7]();",
"else\ngen_op_mov_reg_T0[VAR_7][VAR_10]();",
"}",
"break;",
"case 0x1a3:\nVAR_18 = 0;",
"goto do_btx;",
"case 0x1ab:\nVAR_18 = 1;",
"goto do_btx;",
"case 0x1b3:\nVAR_18 = 2;",
"goto do_btx;",
"case 0x1bb:\nVAR_18 = 3;",
"do_btx:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_9 = (VAR_8 >> 3) & 7;",
"VAR_11 = (VAR_8 >> 6) & 3;",
"VAR_10 = VAR_8 & 7;",
"gen_op_mov_TN_reg[OT_LONG][1][VAR_9]();",
"if (VAR_11 != 3) {",
"gen_lea_modrm(VAR_0, VAR_8, &VAR_12, &VAR_15);",
"if (VAR_7 == OT_WORD)\ngen_op_add_bitw_A0_T1();",
"else\ngen_op_add_bitl_A0_T1();",
"gen_op_ld_T0_A0[VAR_7]();",
"} else {",
"gen_op_mov_TN_reg[VAR_7][0][VAR_10]();",
"}",
"gen_op_btx_T0_T1_cc[VAR_7 - OT_WORD][VAR_18]();",
"VAR_0->cc_op = CC_OP_SARB + VAR_7;",
"if (VAR_18 != 0) {",
"if (VAR_11 != 3)\ngen_op_st_T0_A0[VAR_7]();",
"else\ngen_op_mov_reg_T0[VAR_7][VAR_10]();",
"}",
"break;",
"case 0x1bc:\ncase 0x1bd:\nVAR_7 = VAR_5 ? OT_LONG : OT_WORD;",
"VAR_8 = ldub(VAR_0->pc++);",
"VAR_9 = (VAR_8 >> 3) & 7;",
"gen_ldst_modrm(VAR_0, VAR_8, VAR_7, OR_TMP0, 0);",
"gen_op_bsx_T0_cc[VAR_7 - OT_WORD][VAR_2 & 1]();",
"gen_op_mov_reg_T0[VAR_7][VAR_9]();",
"VAR_0->cc_op = CC_OP_LOGICB + VAR_7;",
"break;",
"case 0x27:\nif (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_daa();",
"VAR_0->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x2f:\nif (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_das();",
"VAR_0->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x37:\nif (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_aaa();",
"VAR_0->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0x3f:\nif (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_aas();",
"VAR_0->cc_op = CC_OP_EFLAGS;",
"break;",
"case 0xd4:\nVAR_19 = ldub(VAR_0->pc++);",
"gen_op_aam(VAR_19);",
"VAR_0->cc_op = CC_OP_LOGICB;",
"break;",
"case 0xd5:\nVAR_19 = ldub(VAR_0->pc++);",
"gen_op_aad(VAR_19);",
"VAR_0->cc_op = CC_OP_LOGICB;",
"break;",
"case 0x90:\nbreak;",
"case 0xcc:\ngen_op_int3((long)VAR_1);",
"VAR_0->is_jmp = 1;",
"break;",
"case 0xcd:\nVAR_19 = ldub(VAR_0->pc++);",
"gen_op_int_im((long)VAR_1);",
"VAR_0->is_jmp = 1;",
"break;",
"case 0xce:\nif (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_into((long)VAR_1, (long)VAR_0->pc);",
"VAR_0->is_jmp = 1;",
"break;",
"case 0x1c8 ... 0x1cf:\nVAR_9 = VAR_2 & 7;",
"gen_op_mov_TN_reg[OT_LONG][0][VAR_9]();",
"gen_op_bswapl_T0();",
"gen_op_mov_reg_T0[OT_LONG][VAR_9]();",
"break;",
"case 0xd6:\nif (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"gen_op_salc();",
"break;",
"case 0xe0:\ncase 0xe1:\nif (VAR_0->cc_op != CC_OP_DYNAMIC)\ngen_op_set_cc_op(VAR_0->cc_op);",
"case 0xe2:\ncase 0xe3:\nVAR_19 = (int8_t)insn_get(VAR_0, OT_BYTE);",
"VAR_24 = VAR_0->pc - VAR_0->cs_base;",
"VAR_19 += VAR_24;",
"if (VAR_0->VAR_5 == 0)\nVAR_19 &= 0xffff;",
"gen_op_loop[VAR_0->VAR_4][VAR_2 & 3](VAR_19, VAR_24);",
"VAR_0->is_jmp = 1;",
"break;",
"case 0x131:\ngen_op_rdtsc();",
"break;",
"#if 0\ncase 0x1a2:\ngen_insn0(OP_ASM);",
"break;",
"#endif\ndefault:\ngoto illegal_op;",
"}",
"if (VAR_0->prefix & PREFIX_LOCK)\ngen_op_unlock();",
"return (long)VAR_0->pc;",
"illegal_op:\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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
25,
27
],
[
29
],
[
33
],
[
35,
37
],
[
39
],
[
41,
43
],
[
45
],
[
47,
49
],
[
51
],
[
53,
55
],
[
57
],
[
59,
61
],
[
63
],
[
65,
67
],
[
69
],
[
71,
73
],
[
75
],
[
77,
79
],
[
81
],
[
83,
85
],
[
87
],
[
89,
91
],
[
93
],
[
95,
97
],
[
99
],
[
101,
103
],
[
105
],
[
107
],
[
111,
113
],
[
115,
117
],
[
121
],
[
123
],
[
125
],
[
131,
133
],
[
139,
141
],
[
143,
149
],
[
151
],
[
159,
161,
163,
165,
167,
169,
171,
173,
175
],
[
177
],
[
179
],
[
181
],
[
185,
187
],
[
189,
191
],
[
195
],
[
197,
199
],
[
201
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
225
],
[
227
],
[
229
],
[
231,
233
],
[
235
],
[
237
],
[
239
],
[
241
],
[
243
],
[
245
],
[
247
],
[
249
],
[
251
],
[
253
],
[
255
],
[
257
],
[
259,
261
],
[
263
],
[
265
],
[
267
],
[
269
],
[
271
],
[
275,
277,
279,
281
],
[
283
],
[
287,
289
],
[
291,
293
],
[
297
],
[
299
],
[
301
],
[
303
],
[
307
],
[
309
],
[
311
],
[
313
],
[
315
],
[
317
],
[
319
],
[
323
],
[
325,
327,
329,
331
],
[
333
],
[
335,
337
],
[
339
],
[
341
],
[
345
],
[
347
],
[
349
],
[
351
],
[
353
],
[
355
],
[
363,
365
],
[
367
],
[
369
],
[
371,
373
],
[
375
],
[
377
],
[
379,
381,
383,
385
],
[
387,
389
],
[
393
],
[
395
],
[
397
],
[
399
],
[
401
],
[
403
],
[
405
],
[
407
],
[
409
],
[
411
],
[
415
],
[
417,
419
],
[
421
],
[
423
],
[
425
],
[
427
],
[
429,
431
],
[
433
],
[
435
],
[
437
],
[
439
],
[
441
],
[
443
],
[
445,
447
],
[
449
],
[
451
],
[
453
],
[
455
],
[
457
],
[
459
],
[
461
],
[
463,
465
],
[
467,
469
],
[
471
],
[
473,
475
],
[
477
],
[
479,
481,
483
],
[
485
],
[
487
],
[
489
],
[
491
],
[
493,
495
],
[
497,
499
],
[
501
],
[
503,
505
],
[
507
],
[
509,
511,
513
],
[
515
],
[
517
],
[
519
],
[
521
],
[
523,
525
],
[
527,
529
],
[
531
],
[
533,
535
],
[
537
],
[
539,
541,
543
],
[
545
],
[
547
],
[
549
],
[
551,
553
],
[
555,
557
],
[
559
],
[
561,
563
],
[
565
],
[
567,
569,
571
],
[
573
],
[
575
],
[
577
],
[
579,
581
],
[
583
],
[
585
],
[
589,
591,
593,
595
],
[
597,
599
],
[
603
],
[
605
],
[
607
],
[
609
],
[
611
],
[
613
],
[
615
],
[
617
],
[
619
],
[
621,
623
],
[
625
],
[
627
],
[
629
],
[
633
],
[
635,
637
],
[
639,
641
],
[
643,
645
],
[
647
],
[
649,
651
],
[
653,
655
],
[
657,
659
],
[
661
],
[
663,
667,
669
],
[
671
],
[
673
],
[
675
],
[
677
],
[
679
],
[
681
],
[
683,
687
],
[
689
],
[
691
],
[
693
],
[
695
],
[
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
],
[
761,
763,
765,
767
],
[
769,
771
],
[
775
],
[
777
],
[
779
],
[
781
],
[
785
],
[
787
],
[
789
],
[
791
],
[
793
],
[
797,
799,
801,
803
],
[
805,
807
],
[
809
],
[
813
],
[
815
],
[
817
],
[
819
],
[
821
],
[
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
],
[
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
],
[
995
],
[
1003,
1005
],
[
1007
],
[
1009
],
[
1011,
1013
],
[
1015
],
[
1017
],
[
1019
],
[
1021
],
[
1023,
1025
],
[
1027
],
[
1029,
1031
],
[
1033
],
[
1035,
1037,
1039
],
[
1041,
1043
],
[
1045,
1047
],
[
1049
],
[
1051
],
[
1053
],
[
1055,
1057
],
[
1059
],
[
1061
],
[
1063
],
[
1065
],
[
1067
],
[
1069,
1071
],
[
1073
],
[
1075
],
[
1077
],
[
1079
],
[
1081
],
[
1083
],
[
1085
],
[
1087,
1091
],
[
1093
],
[
1095
],
[
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
],
[
1171,
1173,
1175,
1177
],
[
1179,
1181
],
[
1183
],
[
1185
],
[
1191
],
[
1193
],
[
1195,
1197,
1199,
1201
],
[
1203,
1205
],
[
1207
],
[
1209
],
[
1211,
1213
],
[
1215
],
[
1217
],
[
1219,
1221
],
[
1223,
1225
],
[
1227
],
[
1229,
1231,
1233,
1235
],
[
1237,
1239
],
[
1241
],
[
1243
],
[
1247
],
[
1249
],
[
1251
],
[
1253,
1255
],
[
1257
],
[
1259
],
[
1261
],
[
1263,
1265
],
[
1267
],
[
1269
],
[
1271,
1273
],
[
1275
],
[
1277
],
[
1279,
1281
],
[
1283
],
[
1285
],
[
1287
],
[
1291,
1293,
1295,
1297,
1299
],
[
1301
],
[
1305
],
[
1309
],
[
1311
],
[
1313
],
[
1315
],
[
1317
],
[
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
],
[
1381,
1383
],
[
1385
],
[
1387
],
[
1391,
1393
],
[
1395
],
[
1397
],
[
1399
],
[
1401
],
[
1403
],
[
1405
],
[
1409,
1411,
1413,
1415,
1417,
1419
],
[
1421,
1423
],
[
1425,
1427
],
[
1429,
1431
],
[
1433
],
[
1439
],
[
1441
],
[
1443
],
[
1445
],
[
1447,
1449
],
[
1451,
1453
],
[
1455,
1457
],
[
1459,
1461
],
[
1463,
1465
],
[
1467,
1469
],
[
1471,
1473
],
[
1475
],
[
1477
],
[
1479
],
[
1481
],
[
1483
],
[
1485
],
[
1487
],
[
1489
],
[
1491
],
[
1493
],
[
1495
],
[
1497
],
[
1499
],
[
1501
],
[
1503,
1507
],
[
1509
],
[
1511,
1513
],
[
1517
],
[
1519
],
[
1521
],
[
1523
],
[
1525,
1527
],
[
1529,
1531
],
[
1533,
1535
],
[
1537,
1539
],
[
1541,
1543
],
[
1545,
1547
],
[
1549,
1551
],
[
1553
],
[
1555
],
[
1557
],
[
1559
],
[
1561
],
[
1563
],
[
1565
],
[
1567
],
[
1569
],
[
1571,
1573
],
[
1575
],
[
1577
],
[
1579
],
[
1581,
1583
],
[
1585
],
[
1587
],
[
1589
],
[
1591
],
[
1593
],
[
1597,
1599
],
[
1601
],
[
1603
],
[
1605
],
[
1607,
1609,
1611,
1613
],
[
1615,
1617
],
[
1619
],
[
1621
],
[
1623
],
[
1625
],
[
1627
],
[
1629,
1631
],
[
1633
],
[
1635
],
[
1637
],
[
1639
],
[
1641
],
[
1643
],
[
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
],
[
1703,
1705
],
[
1707
],
[
1709
],
[
1713
],
[
1715
],
[
1719
],
[
1721
],
[
1729,
1731,
1735
],
[
1737,
1739
],
[
1741,
1743
],
[
1745,
1747
],
[
1751
],
[
1753
],
[
1755
],
[
1757
],
[
1761
],
[
1763
],
[
1765
],
[
1767
],
[
1769
],
[
1771
],
[
1773
],
[
1779
],
[
1781
],
[
1783
],
[
1785
],
[
1787
],
[
1789
],
[
1791
],
[
1793
],
[
1797
],
[
1799
],
[
1801
],
[
1803
],
[
1805
],
[
1807,
1809,
1813
],
[
1815
],
[
1817,
1819,
1823
],
[
1825
],
[
1829,
1831
],
[
1833
],
[
1835
],
[
1837,
1839
],
[
1841
],
[
1843
],
[
1845,
1847
],
[
1849
],
[
1851
],
[
1853,
1855
],
[
1857
],
[
1859,
1861
],
[
1863
],
[
1865
],
[
1867
],
[
1869
],
[
1873
],
[
1875
],
[
1877
],
[
1879
],
[
1881
],
[
1883
],
[
1885
],
[
1889
],
[
1891
],
[
1893
],
[
1895
],
[
1897
],
[
1899,
1901
],
[
1903,
1905
],
[
1907
],
[
1909
],
[
1911,
1913
],
[
1915
],
[
1917
],
[
1919
],
[
1921
],
[
1923
],
[
1925
],
[
1927
],
[
1929
],
[
1931
],
[
1939,
1941
],
[
1943
],
[
1945
],
[
1947
],
[
1951
],
[
1955
],
[
1957
],
[
1959,
1961,
1963,
1965,
1967
],
[
1969
],
[
1971
],
[
1975
],
[
1977,
1979
],
[
1981
],
[
1983,
1985
],
[
1987
],
[
1989,
1991
],
[
1993
],
[
1995,
1997,
1999
],
[
2001
],
[
2003
],
[
2007
],
[
2009
],
[
2013
],
[
2015
],
[
2017
],
[
2019
],
[
2021,
2023,
2025,
2027,
2029,
2031,
2033,
2035,
2037,
2039,
2041,
2043,
2047
],
[
2049,
2051
],
[
2053
],
[
2055,
2057
],
[
2059
],
[
2061,
2063
],
[
2065
],
[
2067,
2069
],
[
2071
],
[
2073,
2075,
2077
],
[
2079
],
[
2081
],
[
2083
],
[
2085,
2087
],
[
2089,
2091
],
[
2093
],
[
2095,
2097
],
[
2099
],
[
2101,
2103
],
[
2105
],
[
2107,
2109,
2111
],
[
2113
],
[
2115
],
[
2117,
2119
],
[
2121
],
[
2123
],
[
2125
],
[
2127,
2129
],
[
2131
],
[
2133,
2135
],
[
2137
],
[
2139,
2141
],
[
2143
],
[
2145
],
[
2147,
2149
],
[
2151
],
[
2153
],
[
2155,
2157
],
[
2159
],
[
2161,
2163
],
[
2165
],
[
2167
],
[
2169,
2171
],
[
2173
],
[
2175
],
[
2177,
2179
],
[
2181
],
[
2183
],
[
2185,
2187
],
[
2189
],
[
2191
],
[
2193,
2195
],
[
2197
],
[
2199
],
[
2203
],
[
2207
],
[
2209,
2211
],
[
2213
],
[
2215
],
[
2217,
2219
],
[
2221
],
[
2223,
2225
],
[
2227,
2229
],
[
2231,
2233
],
[
2235
],
[
2237
],
[
2239,
2241
],
[
2243,
2245
],
[
2247
],
[
2249,
2251
],
[
2253
],
[
2255,
2257
],
[
2259
],
[
2261
],
[
2263,
2265
],
[
2267
],
[
2269,
2271
],
[
2273
],
[
2275
],
[
2277,
2279
],
[
2281
],
[
2283,
2285
],
[
2287
],
[
2289
],
[
2291,
2293
],
[
2295
],
[
2297
],
[
2299,
2301
],
[
2303
],
[
2305
],
[
2307,
2309
],
[
2311
],
[
2313
],
[
2315,
2317
],
[
2319
],
[
2321
],
[
2323,
2325
],
[
2327
],
[
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
],
[
2401
],
[
2403
],
[
2405
],
[
2407,
2409
],
[
2411,
2413
],
[
2415
],
[
2417,
2419
],
[
2421
],
[
2423,
2425
],
[
2427
],
[
2429,
2431
],
[
2433
],
[
2435,
2437
],
[
2439
],
[
2441,
2443
],
[
2445
],
[
2447,
2449
],
[
2451
],
[
2453,
2455,
2457
],
[
2459
],
[
2461
],
[
2463
],
[
2465,
2467,
2469,
2471
],
[
2473
],
[
2477
],
[
2479
],
[
2481
],
[
2483,
2485
],
[
2487
],
[
2489
],
[
2491
],
[
2493
],
[
2495
],
[
2497
],
[
2499,
2501
],
[
2503
],
[
2505
],
[
2507,
2509
],
[
2511
],
[
2513
],
[
2515
],
[
2517,
2519
],
[
2521,
2523
],
[
2525
],
[
2527
],
[
2529
],
[
2531
],
[
2533,
2535
],
[
2537
],
[
2539
],
[
2541,
2543
],
[
2545,
2547
],
[
2549
],
[
2551,
2553
],
[
2555
],
[
2557,
2559
],
[
2561
],
[
2563
],
[
2565,
2567
],
[
2569
],
[
2571,
2573
],
[
2575
],
[
2577
],
[
2579,
2581
],
[
2583
],
[
2585
],
[
2587,
2589
],
[
2591
],
[
2593
],
[
2595
],
[
2597,
2599
],
[
2601,
2603
],
[
2605
],
[
2607
],
[
2609
],
[
2611
],
[
2613,
2615
],
[
2617
],
[
2619
],
[
2621,
2623
],
[
2625,
2627
],
[
2629
],
[
2631,
2633
],
[
2635
],
[
2637
],
[
2639,
2641
],
[
2643
],
[
2645
],
[
2647
],
[
2653,
2655,
2657,
2659
],
[
2661,
2663
],
[
2665
],
[
2667
],
[
2669
],
[
2671
],
[
2673
],
[
2675
],
[
2679,
2681,
2683,
2685
],
[
2687,
2689
],
[
2691
],
[
2693
],
[
2695
],
[
2697
],
[
2699
],
[
2701
],
[
2703,
2705,
2707,
2709
],
[
2711,
2713
],
[
2715
],
[
2717
],
[
2719
],
[
2721
],
[
2723
],
[
2725
],
[
2727,
2729,
2731,
2733
],
[
2735,
2737
],
[
2739
],
[
2741,
2743
],
[
2745
],
[
2747
],
[
2749
],
[
2751,
2753
],
[
2755
],
[
2757
],
[
2759
],
[
2761
],
[
2763
],
[
2765
],
[
2767
],
[
2771,
2773,
2775,
2777
],
[
2779,
2781
],
[
2783
],
[
2785,
2787
],
[
2789
],
[
2791
],
[
2793
],
[
2795,
2797
],
[
2799
],
[
2801
],
[
2803
],
[
2805
],
[
2807
],
[
2809
],
[
2811
],
[
2819,
2821,
2823,
2825
],
[
2827,
2829
],
[
2831
],
[
2833
],
[
2835
],
[
2837
],
[
2839
],
[
2841
],
[
2843,
2845,
2847,
2849
],
[
2851,
2853
],
[
2855
],
[
2857
],
[
2859
],
[
2861
],
[
2863
],
[
2865
],
[
2867,
2869,
2871,
2873
],
[
2875,
2877
],
[
2879
],
[
2881
],
[
2883
],
[
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,
2935,
2937
],
[
2939,
2941
],
[
2943
],
[
2945
],
[
2947
],
[
2949
],
[
2957,
2959
],
[
2961
],
[
2963
],
[
2965,
2967
],
[
2969,
2971
],
[
2973,
2975
],
[
2977
],
[
2979
],
[
2981
],
[
2983,
2985
],
[
2987
],
[
2989,
2991
],
[
2993
],
[
2995
],
[
2997
],
[
2999,
3001
],
[
3003
],
[
3007
],
[
3009,
3011
],
[
3013
],
[
3015
],
[
3019
],
[
3021
],
[
3023
],
[
3027,
3029
],
[
3031,
3033
],
[
3035
],
[
3037
],
[
3039,
3043
],
[
3045,
3047
],
[
3049
],
[
3051
],
[
3055
],
[
3057
],
[
3059
],
[
3061
],
[
3063
],
[
3065,
3067
],
[
3069
],
[
3071
],
[
3073
],
[
3075
],
[
3077
],
[
3079,
3081
],
[
3083
],
[
3085
],
[
3087
],
[
3089
],
[
3091
],
[
3093
],
[
3095,
3097
],
[
3099
],
[
3103
],
[
3105
],
[
3107
],
[
3113
],
[
3115
],
[
3117
],
[
3119
],
[
3121
],
[
3127
],
[
3129
],
[
3131
],
[
3133
],
[
3135
],
[
3137
],
[
3139,
3141
],
[
3143
],
[
3145
],
[
3147,
3149
],
[
3151
],
[
3153
],
[
3155
],
[
3157,
3159
],
[
3161
],
[
3165
],
[
3167
],
[
3169
],
[
3175
],
[
3177
],
[
3179
],
[
3181
],
[
3183
],
[
3185
],
[
3187,
3189
],
[
3191
],
[
3193,
3195
],
[
3197
],
[
3199
],
[
3201
],
[
3203,
3205
],
[
3207
],
[
3209,
3211
],
[
3213
],
[
3215
],
[
3217
],
[
3219
],
[
3221,
3223
],
[
3225
],
[
3227,
3229
],
[
3231
],
[
3233
],
[
3235
],
[
3239,
3241
],
[
3243
],
[
3245
],
[
3247
],
[
3249,
3251
],
[
3253
],
[
3255
],
[
3257
],
[
3259
],
[
3261
],
[
3263
],
[
3265
],
[
3267
],
[
3269
],
[
3271
],
[
3273
],
[
3275
],
[
3277
],
[
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
],
[
3389,
3391
],
[
3393
],
[
3395
],
[
3397
],
[
3399
],
[
3401
],
[
3403
],
[
3405
],
[
3407
],
[
3409
],
[
3411
],
[
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
],
[
3485,
3487
],
[
3489,
3491
],
[
3493
],
[
3495
],
[
3497
],
[
3499
],
[
3501
],
[
3503
],
[
3505
],
[
3507,
3509
],
[
3511,
3513
],
[
3515
],
[
3517
],
[
3519,
3521,
3523
],
[
3525
],
[
3527
],
[
3529
],
[
3531
],
[
3537
],
[
3539
],
[
3541
],
[
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
],
[
3619,
3621
],
[
3623,
3625
],
[
3627
],
[
3629
],
[
3631,
3633
],
[
3637
],
[
3639
],
[
3641
],
[
3643,
3645,
3647
],
[
3649
],
[
3651
],
[
3653
],
[
3655,
3657
],
[
3659
],
[
3661
],
[
3663
],
[
3665
],
[
3667,
3669,
3671
],
[
3673
],
[
3675
],
[
3677,
3679,
3681,
3683
],
[
3687,
3689,
3691
],
[
3693
],
[
3695
],
[
3697,
3699
],
[
3701
],
[
3703
],
[
3705
],
[
3707,
3709
],
[
3711
],
[
3713,
3715,
3717
],
[
3719
],
[
3721,
3723,
3725
],
[
3727
],
[
3731,
3733
],
[
3735
],
[
3737,
3741
],
[
3743
]
]
|
17,035 | static void pci_mmio_map(PCIDevice * pci_dev, int region_num,
uint32_t addr, uint32_t size, int type)
{
PCIEEPRO100State *d = DO_UPCAST(PCIEEPRO100State, dev, pci_dev);
logout("region %d, addr=0x%08x, size=0x%08x, type=%d\n",
region_num, addr, size, type);
if (region_num == 0) {
/* Map control / status registers. */
cpu_register_physical_memory(addr, size, d->eepro100.mmio_index);
d->eepro100.region[region_num] = addr;
}
}
| false | qemu | 273a2142176098fe2c27f263d86ad66b133b43cb | static void pci_mmio_map(PCIDevice * pci_dev, int region_num,
uint32_t addr, uint32_t size, int type)
{
PCIEEPRO100State *d = DO_UPCAST(PCIEEPRO100State, dev, pci_dev);
logout("region %d, addr=0x%08x, size=0x%08x, type=%d\n",
region_num, addr, size, type);
if (region_num == 0) {
cpu_register_physical_memory(addr, size, d->eepro100.mmio_index);
d->eepro100.region[region_num] = addr;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(PCIDevice * VAR_0, int VAR_1,
uint32_t VAR_2, uint32_t VAR_3, int VAR_4)
{
PCIEEPRO100State *d = DO_UPCAST(PCIEEPRO100State, dev, VAR_0);
logout("region %d, VAR_2=0x%08x, VAR_3=0x%08x, VAR_4=%d\n",
VAR_1, VAR_2, VAR_3, VAR_4);
if (VAR_1 == 0) {
cpu_register_physical_memory(VAR_2, VAR_3, d->eepro100.mmio_index);
d->eepro100.region[VAR_1] = VAR_2;
}
}
| [
"static void FUNC_0(PCIDevice * VAR_0, int VAR_1,\nuint32_t VAR_2, uint32_t VAR_3, int VAR_4)\n{",
"PCIEEPRO100State *d = DO_UPCAST(PCIEEPRO100State, dev, VAR_0);",
"logout(\"region %d, VAR_2=0x%08x, VAR_3=0x%08x, VAR_4=%d\\n\",\nVAR_1, VAR_2, VAR_3, VAR_4);",
"if (VAR_1 == 0) {",
"cpu_register_physical_memory(VAR_2, VAR_3, d->eepro100.mmio_index);",
"d->eepro100.region[VAR_1] = VAR_2;",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
11,
13
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
]
]
|
17,037 | uint32_t ldl_le_phys(target_phys_addr_t addr)
{
return ldl_phys_internal(addr, DEVICE_LITTLE_ENDIAN);
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | uint32_t ldl_le_phys(target_phys_addr_t addr)
{
return ldl_phys_internal(addr, DEVICE_LITTLE_ENDIAN);
}
| {
"code": [],
"line_no": []
} | uint32_t FUNC_0(target_phys_addr_t addr)
{
return ldl_phys_internal(addr, DEVICE_LITTLE_ENDIAN);
}
| [
"uint32_t FUNC_0(target_phys_addr_t addr)\n{",
"return ldl_phys_internal(addr, DEVICE_LITTLE_ENDIAN);",
"}"
]
| [
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
]
]
|
17,038 | static void ivshmem_check_memdev_is_busy(const Object *obj, const char *name,
Object *val, Error **errp)
{
if (host_memory_backend_is_mapped(MEMORY_BACKEND(val))) {
char *path = object_get_canonical_path_component(val);
error_setg(errp, "can't use already busy memdev: %s", path);
g_free(path);
} else {
qdev_prop_allow_set_link_before_realize(obj, name, val, errp);
}
}
| false | qemu | e9cb190ad4cea8e6fd24afb973c5007b9a439bc9 | static void ivshmem_check_memdev_is_busy(const Object *obj, const char *name,
Object *val, Error **errp)
{
if (host_memory_backend_is_mapped(MEMORY_BACKEND(val))) {
char *path = object_get_canonical_path_component(val);
error_setg(errp, "can't use already busy memdev: %s", path);
g_free(path);
} else {
qdev_prop_allow_set_link_before_realize(obj, name, val, errp);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(const Object *VAR_0, const char *VAR_1,
Object *VAR_2, Error **VAR_3)
{
if (host_memory_backend_is_mapped(MEMORY_BACKEND(VAR_2))) {
char *VAR_4 = object_get_canonical_path_component(VAR_2);
error_setg(VAR_3, "can't use already busy memdev: %s", VAR_4);
g_free(VAR_4);
} else {
qdev_prop_allow_set_link_before_realize(VAR_0, VAR_1, VAR_2, VAR_3);
}
}
| [
"static void FUNC_0(const Object *VAR_0, const char *VAR_1,\nObject *VAR_2, Error **VAR_3)\n{",
"if (host_memory_backend_is_mapped(MEMORY_BACKEND(VAR_2))) {",
"char *VAR_4 = object_get_canonical_path_component(VAR_2);",
"error_setg(VAR_3, \"can't use already busy memdev: %s\", VAR_4);",
"g_free(VAR_4);",
"} else {",
"qdev_prop_allow_set_link_before_realize(VAR_0, VAR_1, VAR_2, VAR_3);",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
21
]
]
|
17,039 | static int connect_to_ssh(BDRVSSHState *s, QDict *options,
int ssh_flags, int creat_mode)
{
int r, ret;
Error *err = NULL;
const char *host, *user, *path, *host_key_check;
int port;
host = qdict_get_str(options, "host");
if (qdict_haskey(options, "port")) {
port = qdict_get_int(options, "port");
} else {
port = 22;
}
path = qdict_get_str(options, "path");
if (qdict_haskey(options, "user")) {
user = qdict_get_str(options, "user");
} else {
user = g_get_user_name();
if (!user) {
ret = -errno;
goto err;
}
}
if (qdict_haskey(options, "host_key_check")) {
host_key_check = qdict_get_str(options, "host_key_check");
} else {
host_key_check = "yes";
}
/* Construct the host:port name for inet_connect. */
g_free(s->hostport);
s->hostport = g_strdup_printf("%s:%d", host, port);
/* Open the socket and connect. */
s->sock = inet_connect(s->hostport, &err);
if (err != NULL) {
ret = -errno;
qerror_report_err(err);
error_free(err);
goto err;
}
/* Create SSH session. */
s->session = libssh2_session_init();
if (!s->session) {
ret = -EINVAL;
session_error_report(s, "failed to initialize libssh2 session");
goto err;
}
#if TRACE_LIBSSH2 != 0
libssh2_trace(s->session, TRACE_LIBSSH2);
#endif
r = libssh2_session_handshake(s->session, s->sock);
if (r != 0) {
ret = -EINVAL;
session_error_report(s, "failed to establish SSH session");
goto err;
}
/* Check the remote host's key against known_hosts. */
ret = check_host_key(s, host, port, host_key_check, &err);
if (ret < 0) {
qerror_report_err(err);
error_free(err);
goto err;
}
/* Authenticate. */
ret = authenticate(s, user);
if (ret < 0) {
goto err;
}
/* Start SFTP. */
s->sftp = libssh2_sftp_init(s->session);
if (!s->sftp) {
session_error_report(s, "failed to initialize sftp handle");
ret = -EINVAL;
goto err;
}
/* Open the remote file. */
DPRINTF("opening file %s flags=0x%x creat_mode=0%o",
path, ssh_flags, creat_mode);
s->sftp_handle = libssh2_sftp_open(s->sftp, path, ssh_flags, creat_mode);
if (!s->sftp_handle) {
session_error_report(s, "failed to open remote file '%s'", path);
ret = -EINVAL;
goto err;
}
r = libssh2_sftp_fstat(s->sftp_handle, &s->attrs);
if (r < 0) {
sftp_error_report(s, "failed to read file attributes");
return -EINVAL;
}
/* Delete the options we've used; any not deleted will cause the
* block layer to give an error about unused options.
*/
qdict_del(options, "host");
qdict_del(options, "port");
qdict_del(options, "user");
qdict_del(options, "path");
qdict_del(options, "host_key_check");
return 0;
err:
if (s->sftp_handle) {
libssh2_sftp_close(s->sftp_handle);
}
s->sftp_handle = NULL;
if (s->sftp) {
libssh2_sftp_shutdown(s->sftp);
}
s->sftp = NULL;
if (s->session) {
libssh2_session_disconnect(s->session,
"from qemu ssh client: "
"error opening connection");
libssh2_session_free(s->session);
}
s->session = NULL;
return ret;
}
| false | qemu | 4618e658e6dadd1ba53585157984eac71cb706c6 | static int connect_to_ssh(BDRVSSHState *s, QDict *options,
int ssh_flags, int creat_mode)
{
int r, ret;
Error *err = NULL;
const char *host, *user, *path, *host_key_check;
int port;
host = qdict_get_str(options, "host");
if (qdict_haskey(options, "port")) {
port = qdict_get_int(options, "port");
} else {
port = 22;
}
path = qdict_get_str(options, "path");
if (qdict_haskey(options, "user")) {
user = qdict_get_str(options, "user");
} else {
user = g_get_user_name();
if (!user) {
ret = -errno;
goto err;
}
}
if (qdict_haskey(options, "host_key_check")) {
host_key_check = qdict_get_str(options, "host_key_check");
} else {
host_key_check = "yes";
}
g_free(s->hostport);
s->hostport = g_strdup_printf("%s:%d", host, port);
s->sock = inet_connect(s->hostport, &err);
if (err != NULL) {
ret = -errno;
qerror_report_err(err);
error_free(err);
goto err;
}
s->session = libssh2_session_init();
if (!s->session) {
ret = -EINVAL;
session_error_report(s, "failed to initialize libssh2 session");
goto err;
}
#if TRACE_LIBSSH2 != 0
libssh2_trace(s->session, TRACE_LIBSSH2);
#endif
r = libssh2_session_handshake(s->session, s->sock);
if (r != 0) {
ret = -EINVAL;
session_error_report(s, "failed to establish SSH session");
goto err;
}
ret = check_host_key(s, host, port, host_key_check, &err);
if (ret < 0) {
qerror_report_err(err);
error_free(err);
goto err;
}
ret = authenticate(s, user);
if (ret < 0) {
goto err;
}
s->sftp = libssh2_sftp_init(s->session);
if (!s->sftp) {
session_error_report(s, "failed to initialize sftp handle");
ret = -EINVAL;
goto err;
}
DPRINTF("opening file %s flags=0x%x creat_mode=0%o",
path, ssh_flags, creat_mode);
s->sftp_handle = libssh2_sftp_open(s->sftp, path, ssh_flags, creat_mode);
if (!s->sftp_handle) {
session_error_report(s, "failed to open remote file '%s'", path);
ret = -EINVAL;
goto err;
}
r = libssh2_sftp_fstat(s->sftp_handle, &s->attrs);
if (r < 0) {
sftp_error_report(s, "failed to read file attributes");
return -EINVAL;
}
qdict_del(options, "host");
qdict_del(options, "port");
qdict_del(options, "user");
qdict_del(options, "path");
qdict_del(options, "host_key_check");
return 0;
err:
if (s->sftp_handle) {
libssh2_sftp_close(s->sftp_handle);
}
s->sftp_handle = NULL;
if (s->sftp) {
libssh2_sftp_shutdown(s->sftp);
}
s->sftp = NULL;
if (s->session) {
libssh2_session_disconnect(s->session,
"from qemu ssh client: "
"error opening connection");
libssh2_session_free(s->session);
}
s->session = NULL;
return ret;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(BDRVSSHState *VAR_0, QDict *VAR_1,
int VAR_2, int VAR_3)
{
int VAR_4, VAR_5;
Error *err = NULL;
const char *VAR_6, *VAR_7, *VAR_8, *VAR_9;
int VAR_10;
VAR_6 = qdict_get_str(VAR_1, "VAR_6");
if (qdict_haskey(VAR_1, "VAR_10")) {
VAR_10 = qdict_get_int(VAR_1, "VAR_10");
} else {
VAR_10 = 22;
}
VAR_8 = qdict_get_str(VAR_1, "VAR_8");
if (qdict_haskey(VAR_1, "VAR_7")) {
VAR_7 = qdict_get_str(VAR_1, "VAR_7");
} else {
VAR_7 = g_get_user_name();
if (!VAR_7) {
VAR_5 = -errno;
goto err;
}
}
if (qdict_haskey(VAR_1, "VAR_9")) {
VAR_9 = qdict_get_str(VAR_1, "VAR_9");
} else {
VAR_9 = "yes";
}
g_free(VAR_0->hostport);
VAR_0->hostport = g_strdup_printf("%VAR_0:%d", VAR_6, VAR_10);
VAR_0->sock = inet_connect(VAR_0->hostport, &err);
if (err != NULL) {
VAR_5 = -errno;
qerror_report_err(err);
error_free(err);
goto err;
}
VAR_0->session = libssh2_session_init();
if (!VAR_0->session) {
VAR_5 = -EINVAL;
session_error_report(VAR_0, "failed to initialize libssh2 session");
goto err;
}
#if TRACE_LIBSSH2 != 0
libssh2_trace(VAR_0->session, TRACE_LIBSSH2);
#endif
VAR_4 = libssh2_session_handshake(VAR_0->session, VAR_0->sock);
if (VAR_4 != 0) {
VAR_5 = -EINVAL;
session_error_report(VAR_0, "failed to establish SSH session");
goto err;
}
VAR_5 = check_host_key(VAR_0, VAR_6, VAR_10, VAR_9, &err);
if (VAR_5 < 0) {
qerror_report_err(err);
error_free(err);
goto err;
}
VAR_5 = authenticate(VAR_0, VAR_7);
if (VAR_5 < 0) {
goto err;
}
VAR_0->sftp = libssh2_sftp_init(VAR_0->session);
if (!VAR_0->sftp) {
session_error_report(VAR_0, "failed to initialize sftp handle");
VAR_5 = -EINVAL;
goto err;
}
DPRINTF("opening file %VAR_0 flags=0x%x VAR_3=0%o",
VAR_8, VAR_2, VAR_3);
VAR_0->sftp_handle = libssh2_sftp_open(VAR_0->sftp, VAR_8, VAR_2, VAR_3);
if (!VAR_0->sftp_handle) {
session_error_report(VAR_0, "failed to open remote file '%VAR_0'", VAR_8);
VAR_5 = -EINVAL;
goto err;
}
VAR_4 = libssh2_sftp_fstat(VAR_0->sftp_handle, &VAR_0->attrs);
if (VAR_4 < 0) {
sftp_error_report(VAR_0, "failed to read file attributes");
return -EINVAL;
}
qdict_del(VAR_1, "VAR_6");
qdict_del(VAR_1, "VAR_10");
qdict_del(VAR_1, "VAR_7");
qdict_del(VAR_1, "VAR_8");
qdict_del(VAR_1, "VAR_9");
return 0;
err:
if (VAR_0->sftp_handle) {
libssh2_sftp_close(VAR_0->sftp_handle);
}
VAR_0->sftp_handle = NULL;
if (VAR_0->sftp) {
libssh2_sftp_shutdown(VAR_0->sftp);
}
VAR_0->sftp = NULL;
if (VAR_0->session) {
libssh2_session_disconnect(VAR_0->session,
"from qemu ssh client: "
"error opening connection");
libssh2_session_free(VAR_0->session);
}
VAR_0->session = NULL;
return VAR_5;
}
| [
"static int FUNC_0(BDRVSSHState *VAR_0, QDict *VAR_1,\nint VAR_2, int VAR_3)\n{",
"int VAR_4, VAR_5;",
"Error *err = NULL;",
"const char *VAR_6, *VAR_7, *VAR_8, *VAR_9;",
"int VAR_10;",
"VAR_6 = qdict_get_str(VAR_1, \"VAR_6\");",
"if (qdict_haskey(VAR_1, \"VAR_10\")) {",
"VAR_10 = qdict_get_int(VAR_1, \"VAR_10\");",
"} else {",
"VAR_10 = 22;",
"}",
"VAR_8 = qdict_get_str(VAR_1, \"VAR_8\");",
"if (qdict_haskey(VAR_1, \"VAR_7\")) {",
"VAR_7 = qdict_get_str(VAR_1, \"VAR_7\");",
"} else {",
"VAR_7 = g_get_user_name();",
"if (!VAR_7) {",
"VAR_5 = -errno;",
"goto err;",
"}",
"}",
"if (qdict_haskey(VAR_1, \"VAR_9\")) {",
"VAR_9 = qdict_get_str(VAR_1, \"VAR_9\");",
"} else {",
"VAR_9 = \"yes\";",
"}",
"g_free(VAR_0->hostport);",
"VAR_0->hostport = g_strdup_printf(\"%VAR_0:%d\", VAR_6, VAR_10);",
"VAR_0->sock = inet_connect(VAR_0->hostport, &err);",
"if (err != NULL) {",
"VAR_5 = -errno;",
"qerror_report_err(err);",
"error_free(err);",
"goto err;",
"}",
"VAR_0->session = libssh2_session_init();",
"if (!VAR_0->session) {",
"VAR_5 = -EINVAL;",
"session_error_report(VAR_0, \"failed to initialize libssh2 session\");",
"goto err;",
"}",
"#if TRACE_LIBSSH2 != 0\nlibssh2_trace(VAR_0->session, TRACE_LIBSSH2);",
"#endif\nVAR_4 = libssh2_session_handshake(VAR_0->session, VAR_0->sock);",
"if (VAR_4 != 0) {",
"VAR_5 = -EINVAL;",
"session_error_report(VAR_0, \"failed to establish SSH session\");",
"goto err;",
"}",
"VAR_5 = check_host_key(VAR_0, VAR_6, VAR_10, VAR_9, &err);",
"if (VAR_5 < 0) {",
"qerror_report_err(err);",
"error_free(err);",
"goto err;",
"}",
"VAR_5 = authenticate(VAR_0, VAR_7);",
"if (VAR_5 < 0) {",
"goto err;",
"}",
"VAR_0->sftp = libssh2_sftp_init(VAR_0->session);",
"if (!VAR_0->sftp) {",
"session_error_report(VAR_0, \"failed to initialize sftp handle\");",
"VAR_5 = -EINVAL;",
"goto err;",
"}",
"DPRINTF(\"opening file %VAR_0 flags=0x%x VAR_3=0%o\",\nVAR_8, VAR_2, VAR_3);",
"VAR_0->sftp_handle = libssh2_sftp_open(VAR_0->sftp, VAR_8, VAR_2, VAR_3);",
"if (!VAR_0->sftp_handle) {",
"session_error_report(VAR_0, \"failed to open remote file '%VAR_0'\", VAR_8);",
"VAR_5 = -EINVAL;",
"goto err;",
"}",
"VAR_4 = libssh2_sftp_fstat(VAR_0->sftp_handle, &VAR_0->attrs);",
"if (VAR_4 < 0) {",
"sftp_error_report(VAR_0, \"failed to read file attributes\");",
"return -EINVAL;",
"}",
"qdict_del(VAR_1, \"VAR_6\");",
"qdict_del(VAR_1, \"VAR_10\");",
"qdict_del(VAR_1, \"VAR_7\");",
"qdict_del(VAR_1, \"VAR_8\");",
"qdict_del(VAR_1, \"VAR_9\");",
"return 0;",
"err:\nif (VAR_0->sftp_handle) {",
"libssh2_sftp_close(VAR_0->sftp_handle);",
"}",
"VAR_0->sftp_handle = NULL;",
"if (VAR_0->sftp) {",
"libssh2_sftp_shutdown(VAR_0->sftp);",
"}",
"VAR_0->sftp = NULL;",
"if (VAR_0->session) {",
"libssh2_session_disconnect(VAR_0->session,\n\"from qemu ssh client: \"\n\"error opening connection\");",
"libssh2_session_free(VAR_0->session);",
"}",
"VAR_0->session = NULL;",
"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,
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
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
71
],
[
73
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
111,
113
],
[
115,
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
151
],
[
153
],
[
155
],
[
157
],
[
163
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
179,
181
],
[
183
],
[
185
],
[
187
],
[
189
],
[
191
],
[
193
],
[
197
],
[
199
],
[
201
],
[
203
],
[
205
],
[
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
227
],
[
231,
233
],
[
235
],
[
237
],
[
239
],
[
241
],
[
243
],
[
245
],
[
247
],
[
249
],
[
251,
253,
255
],
[
257
],
[
259
],
[
261
],
[
265
],
[
267
]
]
|
17,040 | int kvm_irqchip_add_irq_notifier(KVMState *s, EventNotifier *n, int virq)
{
return -ENOSYS;
}
| false | qemu | b131c74a0e485b084ddaffc8214c8a19af492be7 | int kvm_irqchip_add_irq_notifier(KVMState *s, EventNotifier *n, int virq)
{
return -ENOSYS;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(KVMState *VAR_0, EventNotifier *VAR_1, int VAR_2)
{
return -ENOSYS;
}
| [
"int FUNC_0(KVMState *VAR_0, EventNotifier *VAR_1, int VAR_2)\n{",
"return -ENOSYS;",
"}"
]
| [
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
]
]
|
17,041 | static void gen_st_asi(DisasContext *dc, TCGv src, TCGv addr,
int insn, int size)
{
TCGv_i32 r_asi, r_size;
r_asi = gen_get_asi(dc, insn);
r_size = tcg_const_i32(size);
#ifdef TARGET_SPARC64
gen_helper_st_asi(cpu_env, addr, src, r_asi, r_size);
#else
{
TCGv_i64 t64 = tcg_temp_new_i64();
tcg_gen_extu_tl_i64(t64, src);
gen_helper_st_asi(cpu_env, addr, t64, r_asi, r_size);
tcg_temp_free_i64(t64);
}
#endif
tcg_temp_free_i32(r_size);
tcg_temp_free_i32(r_asi);
}
| false | qemu | 7ec1e5ea4bd0700fa48da86bffa2fcc6146c410a | static void gen_st_asi(DisasContext *dc, TCGv src, TCGv addr,
int insn, int size)
{
TCGv_i32 r_asi, r_size;
r_asi = gen_get_asi(dc, insn);
r_size = tcg_const_i32(size);
#ifdef TARGET_SPARC64
gen_helper_st_asi(cpu_env, addr, src, r_asi, r_size);
#else
{
TCGv_i64 t64 = tcg_temp_new_i64();
tcg_gen_extu_tl_i64(t64, src);
gen_helper_st_asi(cpu_env, addr, t64, r_asi, r_size);
tcg_temp_free_i64(t64);
}
#endif
tcg_temp_free_i32(r_size);
tcg_temp_free_i32(r_asi);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DisasContext *VAR_0, TCGv VAR_1, TCGv VAR_2,
int VAR_3, int VAR_4)
{
TCGv_i32 r_asi, r_size;
r_asi = gen_get_asi(VAR_0, VAR_3);
r_size = tcg_const_i32(VAR_4);
#ifdef TARGET_SPARC64
gen_helper_st_asi(cpu_env, VAR_2, VAR_1, r_asi, r_size);
#else
{
TCGv_i64 t64 = tcg_temp_new_i64();
tcg_gen_extu_tl_i64(t64, VAR_1);
gen_helper_st_asi(cpu_env, VAR_2, t64, r_asi, r_size);
tcg_temp_free_i64(t64);
}
#endif
tcg_temp_free_i32(r_size);
tcg_temp_free_i32(r_asi);
}
| [
"static void FUNC_0(DisasContext *VAR_0, TCGv VAR_1, TCGv VAR_2,\nint VAR_3, int VAR_4)\n{",
"TCGv_i32 r_asi, r_size;",
"r_asi = gen_get_asi(VAR_0, VAR_3);",
"r_size = tcg_const_i32(VAR_4);",
"#ifdef TARGET_SPARC64\ngen_helper_st_asi(cpu_env, VAR_2, VAR_1, r_asi, r_size);",
"#else\n{",
"TCGv_i64 t64 = tcg_temp_new_i64();",
"tcg_gen_extu_tl_i64(t64, VAR_1);",
"gen_helper_st_asi(cpu_env, VAR_2, t64, r_asi, r_size);",
"tcg_temp_free_i64(t64);",
"}",
"#endif\ntcg_temp_free_i32(r_size);",
"tcg_temp_free_i32(r_asi);",
"}"
]
| [
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
]
]
|
17,042 | static double tget_double(const uint8_t **p, int le)
{
av_alias64 i = { .u64 = le ? AV_RL64(*p) : AV_RB64(*p)};
*p += 8;
return i.f64;
}
| false | FFmpeg | 1ec83d9a9e472f485897ac92bad9631d551a8c5b | static double tget_double(const uint8_t **p, int le)
{
av_alias64 i = { .u64 = le ? AV_RL64(*p) : AV_RB64(*p)};
*p += 8;
return i.f64;
}
| {
"code": [],
"line_no": []
} | static double FUNC_0(const uint8_t **VAR_0, int VAR_1)
{
av_alias64 i = { .u64 = VAR_1 ? AV_RL64(*VAR_0) : AV_RB64(*VAR_0)};
*VAR_0 += 8;
return i.f64;
}
| [
"static double FUNC_0(const uint8_t **VAR_0, int VAR_1)\n{",
"av_alias64 i = { .u64 = VAR_1 ? AV_RL64(*VAR_0) : AV_RB64(*VAR_0)};",
"*VAR_0 += 8;",
"return i.f64;",
"}"
]
| [
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
]
]
|
17,044 | void empty_slot_init(target_phys_addr_t addr, uint64_t slot_size)
{
if (slot_size > 0) {
/* Only empty slots larger than 0 byte need handling. */
DeviceState *dev;
SysBusDevice *s;
EmptySlot *e;
dev = qdev_create(NULL, "empty_slot");
s = sysbus_from_qdev(dev);
e = FROM_SYSBUS(EmptySlot, s);
e->size = slot_size;
qdev_init_nofail(dev);
sysbus_mmio_map(s, 0, addr);
}
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | void empty_slot_init(target_phys_addr_t addr, uint64_t slot_size)
{
if (slot_size > 0) {
DeviceState *dev;
SysBusDevice *s;
EmptySlot *e;
dev = qdev_create(NULL, "empty_slot");
s = sysbus_from_qdev(dev);
e = FROM_SYSBUS(EmptySlot, s);
e->size = slot_size;
qdev_init_nofail(dev);
sysbus_mmio_map(s, 0, addr);
}
}
| {
"code": [],
"line_no": []
} | void FUNC_0(target_phys_addr_t VAR_0, uint64_t VAR_1)
{
if (VAR_1 > 0) {
DeviceState *dev;
SysBusDevice *s;
EmptySlot *e;
dev = qdev_create(NULL, "empty_slot");
s = sysbus_from_qdev(dev);
e = FROM_SYSBUS(EmptySlot, s);
e->size = VAR_1;
qdev_init_nofail(dev);
sysbus_mmio_map(s, 0, VAR_0);
}
}
| [
"void FUNC_0(target_phys_addr_t VAR_0, uint64_t VAR_1)\n{",
"if (VAR_1 > 0) {",
"DeviceState *dev;",
"SysBusDevice *s;",
"EmptySlot *e;",
"dev = qdev_create(NULL, \"empty_slot\");",
"s = sysbus_from_qdev(dev);",
"e = FROM_SYSBUS(EmptySlot, s);",
"e->size = VAR_1;",
"qdev_init_nofail(dev);",
"sysbus_mmio_map(s, 0, VAR_0);",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
31
],
[
33
],
[
35
]
]
|
17,045 | build_fadt(GArray *table_data, BIOSLinker *linker, unsigned dsdt)
{
AcpiFadtDescriptorRev5_1 *fadt = acpi_data_push(table_data, sizeof(*fadt));
/* Hardware Reduced = 1 and use PSCI 0.2+ and with HVC */
fadt->flags = cpu_to_le32(1 << ACPI_FADT_F_HW_REDUCED_ACPI);
fadt->arm_boot_flags = cpu_to_le16((1 << ACPI_FADT_ARM_USE_PSCI_G_0_2) |
(1 << ACPI_FADT_ARM_PSCI_USE_HVC));
/* ACPI v5.1 (fadt->revision.fadt->minor_revision) */
fadt->minor_revision = 0x1;
fadt->dsdt = cpu_to_le32(dsdt);
/* DSDT address to be filled by Guest linker */
bios_linker_loader_add_pointer(linker, ACPI_BUILD_TABLE_FILE,
ACPI_BUILD_TABLE_FILE,
&fadt->dsdt,
sizeof fadt->dsdt);
build_header(linker, table_data,
(void *)fadt, "FACP", sizeof(*fadt), 5, NULL, NULL);
}
| false | qemu | 4678124bb9bfb49e93b83f95c4d2feeb443ea38b | build_fadt(GArray *table_data, BIOSLinker *linker, unsigned dsdt)
{
AcpiFadtDescriptorRev5_1 *fadt = acpi_data_push(table_data, sizeof(*fadt));
fadt->flags = cpu_to_le32(1 << ACPI_FADT_F_HW_REDUCED_ACPI);
fadt->arm_boot_flags = cpu_to_le16((1 << ACPI_FADT_ARM_USE_PSCI_G_0_2) |
(1 << ACPI_FADT_ARM_PSCI_USE_HVC));
fadt->minor_revision = 0x1;
fadt->dsdt = cpu_to_le32(dsdt);
bios_linker_loader_add_pointer(linker, ACPI_BUILD_TABLE_FILE,
ACPI_BUILD_TABLE_FILE,
&fadt->dsdt,
sizeof fadt->dsdt);
build_header(linker, table_data,
(void *)fadt, "FACP", sizeof(*fadt), 5, NULL, NULL);
}
| {
"code": [],
"line_no": []
} | FUNC_0(GArray *VAR_0, BIOSLinker *VAR_1, unsigned VAR_2)
{
AcpiFadtDescriptorRev5_1 *fadt = acpi_data_push(VAR_0, sizeof(*fadt));
fadt->flags = cpu_to_le32(1 << ACPI_FADT_F_HW_REDUCED_ACPI);
fadt->arm_boot_flags = cpu_to_le16((1 << ACPI_FADT_ARM_USE_PSCI_G_0_2) |
(1 << ACPI_FADT_ARM_PSCI_USE_HVC));
fadt->minor_revision = 0x1;
fadt->VAR_2 = cpu_to_le32(VAR_2);
bios_linker_loader_add_pointer(VAR_1, ACPI_BUILD_TABLE_FILE,
ACPI_BUILD_TABLE_FILE,
&fadt->VAR_2,
sizeof fadt->VAR_2);
build_header(VAR_1, VAR_0,
(void *)fadt, "FACP", sizeof(*fadt), 5, NULL, NULL);
}
| [
"FUNC_0(GArray *VAR_0, BIOSLinker *VAR_1, unsigned VAR_2)\n{",
"AcpiFadtDescriptorRev5_1 *fadt = acpi_data_push(VAR_0, sizeof(*fadt));",
"fadt->flags = cpu_to_le32(1 << ACPI_FADT_F_HW_REDUCED_ACPI);",
"fadt->arm_boot_flags = cpu_to_le16((1 << ACPI_FADT_ARM_USE_PSCI_G_0_2) |\n(1 << ACPI_FADT_ARM_PSCI_USE_HVC));",
"fadt->minor_revision = 0x1;",
"fadt->VAR_2 = cpu_to_le32(VAR_2);",
"bios_linker_loader_add_pointer(VAR_1, ACPI_BUILD_TABLE_FILE,\nACPI_BUILD_TABLE_FILE,\n&fadt->VAR_2,\nsizeof fadt->VAR_2);",
"build_header(VAR_1, VAR_0,\n(void *)fadt, \"FACP\", sizeof(*fadt), 5, NULL, NULL);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
11
],
[
13,
15
],
[
21
],
[
25
],
[
29,
31,
33,
35
],
[
39,
41
],
[
43
]
]
|
17,046 | void apic_enable_vapic(DeviceState *d, target_phys_addr_t paddr)
{
APICCommonState *s = DO_UPCAST(APICCommonState, busdev.qdev, d);
APICCommonClass *info = APIC_COMMON_GET_CLASS(s);
s->vapic_paddr = paddr;
info->vapic_base_update(s);
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | void apic_enable_vapic(DeviceState *d, target_phys_addr_t paddr)
{
APICCommonState *s = DO_UPCAST(APICCommonState, busdev.qdev, d);
APICCommonClass *info = APIC_COMMON_GET_CLASS(s);
s->vapic_paddr = paddr;
info->vapic_base_update(s);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(DeviceState *VAR_0, target_phys_addr_t VAR_1)
{
APICCommonState *s = DO_UPCAST(APICCommonState, busdev.qdev, VAR_0);
APICCommonClass *info = APIC_COMMON_GET_CLASS(s);
s->vapic_paddr = VAR_1;
info->vapic_base_update(s);
}
| [
"void FUNC_0(DeviceState *VAR_0, target_phys_addr_t VAR_1)\n{",
"APICCommonState *s = DO_UPCAST(APICCommonState, busdev.qdev, VAR_0);",
"APICCommonClass *info = APIC_COMMON_GET_CLASS(s);",
"s->vapic_paddr = VAR_1;",
"info->vapic_base_update(s);",
"}"
]
| [
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
13
],
[
15
]
]
|
17,047 | void qmp_blockdev_snapshot_internal_sync(const char *device,
const char *name,
Error **errp)
{
BlockdevSnapshotInternal snapshot = {
.device = (char *) device,
.name = (char *) name
};
TransactionAction action = {
.type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC,
.u.blockdev_snapshot_internal_sync = &snapshot,
};
blockdev_do_action(&action, errp);
}
| false | qemu | 32bafa8fdd098d52fbf1102d5a5e48d29398c0aa | void qmp_blockdev_snapshot_internal_sync(const char *device,
const char *name,
Error **errp)
{
BlockdevSnapshotInternal snapshot = {
.device = (char *) device,
.name = (char *) name
};
TransactionAction action = {
.type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC,
.u.blockdev_snapshot_internal_sync = &snapshot,
};
blockdev_do_action(&action, errp);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(const char *VAR_0,
const char *VAR_1,
Error **VAR_2)
{
BlockdevSnapshotInternal snapshot = {
.VAR_0 = (char *) VAR_0,
.VAR_1 = (char *) VAR_1
};
TransactionAction action = {
.type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC,
.u.blockdev_snapshot_internal_sync = &snapshot,
};
blockdev_do_action(&action, VAR_2);
}
| [
"void FUNC_0(const char *VAR_0,\nconst char *VAR_1,\nError **VAR_2)\n{",
"BlockdevSnapshotInternal snapshot = {",
".VAR_0 = (char *) VAR_0,\n.VAR_1 = (char *) VAR_1\n};",
"TransactionAction action = {",
".type = TRANSACTION_ACTION_KIND_BLOCKDEV_SNAPSHOT_INTERNAL_SYNC,\n.u.blockdev_snapshot_internal_sync = &snapshot,\n};",
"blockdev_do_action(&action, VAR_2);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5,
7
],
[
9
],
[
11,
13,
15
],
[
17
],
[
19,
21,
23
],
[
25
],
[
27
]
]
|
17,049 | void nvdimm_acpi_hotplug(AcpiNVDIMMState *state)
{
nvdimm_build_fit_buffer(&state->fit_buf);
}
| false | qemu | 284197e41f0fe98d58ce5e8acd4966c91f28c4bd | void nvdimm_acpi_hotplug(AcpiNVDIMMState *state)
{
nvdimm_build_fit_buffer(&state->fit_buf);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(AcpiNVDIMMState *VAR_0)
{
nvdimm_build_fit_buffer(&VAR_0->fit_buf);
}
| [
"void FUNC_0(AcpiNVDIMMState *VAR_0)\n{",
"nvdimm_build_fit_buffer(&VAR_0->fit_buf);",
"}"
]
| [
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
]
]
|
17,050 | int ppc_radix64_handle_mmu_fault(PowerPCCPU *cpu, vaddr eaddr, int rwx,
int mmu_idx)
{
CPUState *cs = CPU(cpu);
CPUPPCState *env = &cpu->env;
PPCVirtualHypervisorClass *vhc =
PPC_VIRTUAL_HYPERVISOR_GET_CLASS(cpu->vhyp);
hwaddr raddr, pte_addr;
uint64_t lpid = 0, pid = 0, offset, size, patbe, prtbe0, pte;
int page_size, prot, fault_cause = 0;
assert((rwx == 0) || (rwx == 1) || (rwx == 2));
assert(!msr_hv); /* For now there is no Radix PowerNV Support */
assert(cpu->vhyp);
assert(ppc64_use_proc_tbl(cpu));
/* Real Mode Access */
if (((rwx == 2) && (msr_ir == 0)) || ((rwx != 2) && (msr_dr == 0))) {
/* In real mode top 4 effective addr bits (mostly) ignored */
raddr = eaddr & 0x0FFFFFFFFFFFFFFFULL;
tlb_set_page(cs, eaddr & TARGET_PAGE_MASK, raddr & TARGET_PAGE_MASK,
PAGE_READ | PAGE_WRITE | PAGE_EXEC, mmu_idx,
TARGET_PAGE_SIZE);
return 0;
}
/* Virtual Mode Access - get the fully qualified address */
if (!ppc_radix64_get_fully_qualified_addr(env, eaddr, &lpid, &pid)) {
ppc_radix64_raise_segi(cpu, rwx, eaddr);
return 1;
}
/* Get Process Table */
patbe = vhc->get_patbe(cpu->vhyp);
/* Index Process Table by PID to Find Corresponding Process Table Entry */
offset = pid * sizeof(struct prtb_entry);
size = 1ULL << ((patbe & PATBE1_R_PRTS) + 12);
if (offset >= size) {
/* offset exceeds size of the process table */
ppc_radix64_raise_si(cpu, rwx, eaddr, DSISR_NOPTE);
return 1;
}
prtbe0 = ldq_phys(cs->as, (patbe & PATBE1_R_PRTB) + offset);
/* Walk Radix Tree from Process Table Entry to Convert EA to RA */
page_size = PRTBE_R_GET_RTS(prtbe0);
pte = ppc_radix64_walk_tree(cpu, rwx, eaddr & R_EADDR_MASK,
prtbe0 & PRTBE_R_RPDB, prtbe0 & PRTBE_R_RPDS,
&raddr, &page_size, &fault_cause, &prot,
&pte_addr);
if (!pte) {
ppc_radix64_raise_si(cpu, rwx, eaddr, fault_cause);
return 1;
}
/* Update Reference and Change Bits */
ppc_radix64_set_rc(cpu, rwx, pte, pte_addr, &prot);
tlb_set_page(cs, eaddr & TARGET_PAGE_MASK, raddr & TARGET_PAGE_MASK,
prot, mmu_idx, 1UL << page_size);
return 0;
}
| false | qemu | 6a042827b638dc73da6a72c72596f5be80bd4581 | int ppc_radix64_handle_mmu_fault(PowerPCCPU *cpu, vaddr eaddr, int rwx,
int mmu_idx)
{
CPUState *cs = CPU(cpu);
CPUPPCState *env = &cpu->env;
PPCVirtualHypervisorClass *vhc =
PPC_VIRTUAL_HYPERVISOR_GET_CLASS(cpu->vhyp);
hwaddr raddr, pte_addr;
uint64_t lpid = 0, pid = 0, offset, size, patbe, prtbe0, pte;
int page_size, prot, fault_cause = 0;
assert((rwx == 0) || (rwx == 1) || (rwx == 2));
assert(!msr_hv);
assert(cpu->vhyp);
assert(ppc64_use_proc_tbl(cpu));
if (((rwx == 2) && (msr_ir == 0)) || ((rwx != 2) && (msr_dr == 0))) {
raddr = eaddr & 0x0FFFFFFFFFFFFFFFULL;
tlb_set_page(cs, eaddr & TARGET_PAGE_MASK, raddr & TARGET_PAGE_MASK,
PAGE_READ | PAGE_WRITE | PAGE_EXEC, mmu_idx,
TARGET_PAGE_SIZE);
return 0;
}
if (!ppc_radix64_get_fully_qualified_addr(env, eaddr, &lpid, &pid)) {
ppc_radix64_raise_segi(cpu, rwx, eaddr);
return 1;
}
patbe = vhc->get_patbe(cpu->vhyp);
offset = pid * sizeof(struct prtb_entry);
size = 1ULL << ((patbe & PATBE1_R_PRTS) + 12);
if (offset >= size) {
ppc_radix64_raise_si(cpu, rwx, eaddr, DSISR_NOPTE);
return 1;
}
prtbe0 = ldq_phys(cs->as, (patbe & PATBE1_R_PRTB) + offset);
page_size = PRTBE_R_GET_RTS(prtbe0);
pte = ppc_radix64_walk_tree(cpu, rwx, eaddr & R_EADDR_MASK,
prtbe0 & PRTBE_R_RPDB, prtbe0 & PRTBE_R_RPDS,
&raddr, &page_size, &fault_cause, &prot,
&pte_addr);
if (!pte) {
ppc_radix64_raise_si(cpu, rwx, eaddr, fault_cause);
return 1;
}
ppc_radix64_set_rc(cpu, rwx, pte, pte_addr, &prot);
tlb_set_page(cs, eaddr & TARGET_PAGE_MASK, raddr & TARGET_PAGE_MASK,
prot, mmu_idx, 1UL << page_size);
return 0;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(PowerPCCPU *VAR_0, vaddr VAR_1, int VAR_2,
int VAR_3)
{
CPUState *cs = CPU(VAR_0);
CPUPPCState *env = &VAR_0->env;
PPCVirtualHypervisorClass *vhc =
PPC_VIRTUAL_HYPERVISOR_GET_CLASS(VAR_0->vhyp);
hwaddr raddr, pte_addr;
uint64_t lpid = 0, pid = 0, offset, size, patbe, prtbe0, pte;
int VAR_4, VAR_5, VAR_6 = 0;
assert((VAR_2 == 0) || (VAR_2 == 1) || (VAR_2 == 2));
assert(!msr_hv);
assert(VAR_0->vhyp);
assert(ppc64_use_proc_tbl(VAR_0));
if (((VAR_2 == 2) && (msr_ir == 0)) || ((VAR_2 != 2) && (msr_dr == 0))) {
raddr = VAR_1 & 0x0FFFFFFFFFFFFFFFULL;
tlb_set_page(cs, VAR_1 & TARGET_PAGE_MASK, raddr & TARGET_PAGE_MASK,
PAGE_READ | PAGE_WRITE | PAGE_EXEC, VAR_3,
TARGET_PAGE_SIZE);
return 0;
}
if (!ppc_radix64_get_fully_qualified_addr(env, VAR_1, &lpid, &pid)) {
ppc_radix64_raise_segi(VAR_0, VAR_2, VAR_1);
return 1;
}
patbe = vhc->get_patbe(VAR_0->vhyp);
offset = pid * sizeof(struct prtb_entry);
size = 1ULL << ((patbe & PATBE1_R_PRTS) + 12);
if (offset >= size) {
ppc_radix64_raise_si(VAR_0, VAR_2, VAR_1, DSISR_NOPTE);
return 1;
}
prtbe0 = ldq_phys(cs->as, (patbe & PATBE1_R_PRTB) + offset);
VAR_4 = PRTBE_R_GET_RTS(prtbe0);
pte = ppc_radix64_walk_tree(VAR_0, VAR_2, VAR_1 & R_EADDR_MASK,
prtbe0 & PRTBE_R_RPDB, prtbe0 & PRTBE_R_RPDS,
&raddr, &VAR_4, &VAR_6, &VAR_5,
&pte_addr);
if (!pte) {
ppc_radix64_raise_si(VAR_0, VAR_2, VAR_1, VAR_6);
return 1;
}
ppc_radix64_set_rc(VAR_0, VAR_2, pte, pte_addr, &VAR_5);
tlb_set_page(cs, VAR_1 & TARGET_PAGE_MASK, raddr & TARGET_PAGE_MASK,
VAR_5, VAR_3, 1UL << VAR_4);
return 0;
}
| [
"int FUNC_0(PowerPCCPU *VAR_0, vaddr VAR_1, int VAR_2,\nint VAR_3)\n{",
"CPUState *cs = CPU(VAR_0);",
"CPUPPCState *env = &VAR_0->env;",
"PPCVirtualHypervisorClass *vhc =\nPPC_VIRTUAL_HYPERVISOR_GET_CLASS(VAR_0->vhyp);",
"hwaddr raddr, pte_addr;",
"uint64_t lpid = 0, pid = 0, offset, size, patbe, prtbe0, pte;",
"int VAR_4, VAR_5, VAR_6 = 0;",
"assert((VAR_2 == 0) || (VAR_2 == 1) || (VAR_2 == 2));",
"assert(!msr_hv);",
"assert(VAR_0->vhyp);",
"assert(ppc64_use_proc_tbl(VAR_0));",
"if (((VAR_2 == 2) && (msr_ir == 0)) || ((VAR_2 != 2) && (msr_dr == 0))) {",
"raddr = VAR_1 & 0x0FFFFFFFFFFFFFFFULL;",
"tlb_set_page(cs, VAR_1 & TARGET_PAGE_MASK, raddr & TARGET_PAGE_MASK,\nPAGE_READ | PAGE_WRITE | PAGE_EXEC, VAR_3,\nTARGET_PAGE_SIZE);",
"return 0;",
"}",
"if (!ppc_radix64_get_fully_qualified_addr(env, VAR_1, &lpid, &pid)) {",
"ppc_radix64_raise_segi(VAR_0, VAR_2, VAR_1);",
"return 1;",
"}",
"patbe = vhc->get_patbe(VAR_0->vhyp);",
"offset = pid * sizeof(struct prtb_entry);",
"size = 1ULL << ((patbe & PATBE1_R_PRTS) + 12);",
"if (offset >= size) {",
"ppc_radix64_raise_si(VAR_0, VAR_2, VAR_1, DSISR_NOPTE);",
"return 1;",
"}",
"prtbe0 = ldq_phys(cs->as, (patbe & PATBE1_R_PRTB) + offset);",
"VAR_4 = PRTBE_R_GET_RTS(prtbe0);",
"pte = ppc_radix64_walk_tree(VAR_0, VAR_2, VAR_1 & R_EADDR_MASK,\nprtbe0 & PRTBE_R_RPDB, prtbe0 & PRTBE_R_RPDS,\n&raddr, &VAR_4, &VAR_6, &VAR_5,\n&pte_addr);",
"if (!pte) {",
"ppc_radix64_raise_si(VAR_0, VAR_2, VAR_1, VAR_6);",
"return 1;",
"}",
"ppc_radix64_set_rc(VAR_0, VAR_2, pte, pte_addr, &VAR_5);",
"tlb_set_page(cs, VAR_1 & TARGET_PAGE_MASK, raddr & TARGET_PAGE_MASK,\nVAR_5, VAR_3, 1UL << 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
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
11,
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
29
],
[
35
],
[
39
],
[
43,
45,
47
],
[
49
],
[
51
],
[
57
],
[
59
],
[
61
],
[
63
],
[
69
],
[
75
],
[
77
],
[
79
],
[
83
],
[
85
],
[
87
],
[
89
],
[
95
],
[
97,
99,
101,
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
117
],
[
121,
123
],
[
125
],
[
127
]
]
|
17,051 | static inline void dxt1_decode_pixels(const uint8_t *s, uint32_t *d,
unsigned int qstride, unsigned int flag,
uint64_t alpha) {
unsigned int x, y, c0, c1, a = (!flag * 255u) << 24;
unsigned int rb0, rb1, rb2, rb3, g0, g1, g2, g3;
uint32_t colors[4], pixels;
c0 = AV_RL16(s);
c1 = AV_RL16(s+2);
rb0 = (c0<<3 | c0<<8) & 0xf800f8;
rb1 = (c1<<3 | c1<<8) & 0xf800f8;
rb0 += (rb0>>5) & 0x070007;
rb1 += (rb1>>5) & 0x070007;
g0 = (c0 <<5) & 0x00fc00;
g1 = (c1 <<5) & 0x00fc00;
g0 += (g0 >>6) & 0x000300;
g1 += (g1 >>6) & 0x000300;
colors[0] = rb0 + g0 + a;
colors[1] = rb1 + g1 + a;
if (c0 > c1 || flag) {
rb2 = (((2*rb0+rb1) * 21) >> 6) & 0xff00ff;
rb3 = (((2*rb1+rb0) * 21) >> 6) & 0xff00ff;
g2 = (((2*g0 +g1 ) * 21) >> 6) & 0x00ff00;
g3 = (((2*g1 +g0 ) * 21) >> 6) & 0x00ff00;
colors[3] = rb3 + g3 + a;
} else {
rb2 = ((rb0+rb1) >> 1) & 0xff00ff;
g2 = ((g0 +g1 ) >> 1) & 0x00ff00;
colors[3] = 0;
}
colors[2] = rb2 + g2 + a;
pixels = AV_RL32(s+4);
for (y=0; y<4; y++) {
for (x=0; x<4; x++) {
a = (alpha & 0x0f) << 28;
a += a >> 4;
d[x] = a + colors[pixels&3];
pixels >>= 2;
alpha >>= 4;
}
d += qstride;
}
}
| true | FFmpeg | 919f3554387e043bdfe10c6369356d1104882183 | static inline void dxt1_decode_pixels(const uint8_t *s, uint32_t *d,
unsigned int qstride, unsigned int flag,
uint64_t alpha) {
unsigned int x, y, c0, c1, a = (!flag * 255u) << 24;
unsigned int rb0, rb1, rb2, rb3, g0, g1, g2, g3;
uint32_t colors[4], pixels;
c0 = AV_RL16(s);
c1 = AV_RL16(s+2);
rb0 = (c0<<3 | c0<<8) & 0xf800f8;
rb1 = (c1<<3 | c1<<8) & 0xf800f8;
rb0 += (rb0>>5) & 0x070007;
rb1 += (rb1>>5) & 0x070007;
g0 = (c0 <<5) & 0x00fc00;
g1 = (c1 <<5) & 0x00fc00;
g0 += (g0 >>6) & 0x000300;
g1 += (g1 >>6) & 0x000300;
colors[0] = rb0 + g0 + a;
colors[1] = rb1 + g1 + a;
if (c0 > c1 || flag) {
rb2 = (((2*rb0+rb1) * 21) >> 6) & 0xff00ff;
rb3 = (((2*rb1+rb0) * 21) >> 6) & 0xff00ff;
g2 = (((2*g0 +g1 ) * 21) >> 6) & 0x00ff00;
g3 = (((2*g1 +g0 ) * 21) >> 6) & 0x00ff00;
colors[3] = rb3 + g3 + a;
} else {
rb2 = ((rb0+rb1) >> 1) & 0xff00ff;
g2 = ((g0 +g1 ) >> 1) & 0x00ff00;
colors[3] = 0;
}
colors[2] = rb2 + g2 + a;
pixels = AV_RL32(s+4);
for (y=0; y<4; y++) {
for (x=0; x<4; x++) {
a = (alpha & 0x0f) << 28;
a += a >> 4;
d[x] = a + colors[pixels&3];
pixels >>= 2;
alpha >>= 4;
}
d += qstride;
}
}
| {
"code": [
"static inline void dxt1_decode_pixels(const uint8_t *s, uint32_t *d,",
" c0 = AV_RL16(s);",
" c1 = AV_RL16(s+2);",
" pixels = AV_RL32(s+4);"
],
"line_no": [
1,
15,
17,
73
]
} | static inline void FUNC_0(const uint8_t *VAR_0, uint32_t *VAR_1,
unsigned int VAR_2, unsigned int VAR_3,
uint64_t VAR_4) {
unsigned int VAR_5, VAR_6, VAR_7, VAR_8, VAR_9 = (!VAR_3 * 255u) << 24;
unsigned int VAR_10, VAR_11, VAR_12, VAR_13, VAR_14, VAR_15, VAR_16, VAR_17;
uint32_t colors[4], pixels;
VAR_7 = AV_RL16(VAR_0);
VAR_8 = AV_RL16(VAR_0+2);
VAR_10 = (VAR_7<<3 | VAR_7<<8) & 0xf800f8;
VAR_11 = (VAR_8<<3 | VAR_8<<8) & 0xf800f8;
VAR_10 += (VAR_10>>5) & 0x070007;
VAR_11 += (VAR_11>>5) & 0x070007;
VAR_14 = (VAR_7 <<5) & 0x00fc00;
VAR_15 = (VAR_8 <<5) & 0x00fc00;
VAR_14 += (VAR_14 >>6) & 0x000300;
VAR_15 += (VAR_15 >>6) & 0x000300;
colors[0] = VAR_10 + VAR_14 + VAR_9;
colors[1] = VAR_11 + VAR_15 + VAR_9;
if (VAR_7 > VAR_8 || VAR_3) {
VAR_12 = (((2*VAR_10+VAR_11) * 21) >> 6) & 0xff00ff;
VAR_13 = (((2*VAR_11+VAR_10) * 21) >> 6) & 0xff00ff;
VAR_16 = (((2*VAR_14 +VAR_15 ) * 21) >> 6) & 0x00ff00;
VAR_17 = (((2*VAR_15 +VAR_14 ) * 21) >> 6) & 0x00ff00;
colors[3] = VAR_13 + VAR_17 + VAR_9;
} else {
VAR_12 = ((VAR_10+VAR_11) >> 1) & 0xff00ff;
VAR_16 = ((VAR_14 +VAR_15 ) >> 1) & 0x00ff00;
colors[3] = 0;
}
colors[2] = VAR_12 + VAR_16 + VAR_9;
pixels = AV_RL32(VAR_0+4);
for (VAR_6=0; VAR_6<4; VAR_6++) {
for (VAR_5=0; VAR_5<4; VAR_5++) {
VAR_9 = (VAR_4 & 0x0f) << 28;
VAR_9 += VAR_9 >> 4;
VAR_1[VAR_5] = VAR_9 + colors[pixels&3];
pixels >>= 2;
VAR_4 >>= 4;
}
VAR_1 += VAR_2;
}
}
| [
"static inline void FUNC_0(const uint8_t *VAR_0, uint32_t *VAR_1,\nunsigned int VAR_2, unsigned int VAR_3,\nuint64_t VAR_4) {",
"unsigned int VAR_5, VAR_6, VAR_7, VAR_8, VAR_9 = (!VAR_3 * 255u) << 24;",
"unsigned int VAR_10, VAR_11, VAR_12, VAR_13, VAR_14, VAR_15, VAR_16, VAR_17;",
"uint32_t colors[4], pixels;",
"VAR_7 = AV_RL16(VAR_0);",
"VAR_8 = AV_RL16(VAR_0+2);",
"VAR_10 = (VAR_7<<3 | VAR_7<<8) & 0xf800f8;",
"VAR_11 = (VAR_8<<3 | VAR_8<<8) & 0xf800f8;",
"VAR_10 += (VAR_10>>5) & 0x070007;",
"VAR_11 += (VAR_11>>5) & 0x070007;",
"VAR_14 = (VAR_7 <<5) & 0x00fc00;",
"VAR_15 = (VAR_8 <<5) & 0x00fc00;",
"VAR_14 += (VAR_14 >>6) & 0x000300;",
"VAR_15 += (VAR_15 >>6) & 0x000300;",
"colors[0] = VAR_10 + VAR_14 + VAR_9;",
"colors[1] = VAR_11 + VAR_15 + VAR_9;",
"if (VAR_7 > VAR_8 || VAR_3) {",
"VAR_12 = (((2*VAR_10+VAR_11) * 21) >> 6) & 0xff00ff;",
"VAR_13 = (((2*VAR_11+VAR_10) * 21) >> 6) & 0xff00ff;",
"VAR_16 = (((2*VAR_14 +VAR_15 ) * 21) >> 6) & 0x00ff00;",
"VAR_17 = (((2*VAR_15 +VAR_14 ) * 21) >> 6) & 0x00ff00;",
"colors[3] = VAR_13 + VAR_17 + VAR_9;",
"} else {",
"VAR_12 = ((VAR_10+VAR_11) >> 1) & 0xff00ff;",
"VAR_16 = ((VAR_14 +VAR_15 ) >> 1) & 0x00ff00;",
"colors[3] = 0;",
"}",
"colors[2] = VAR_12 + VAR_16 + VAR_9;",
"pixels = AV_RL32(VAR_0+4);",
"for (VAR_6=0; VAR_6<4; VAR_6++) {",
"for (VAR_5=0; VAR_5<4; VAR_5++) {",
"VAR_9 = (VAR_4 & 0x0f) << 28;",
"VAR_9 += VAR_9 >> 4;",
"VAR_1[VAR_5] = VAR_9 + colors[pixels&3];",
"pixels >>= 2;",
"VAR_4 >>= 4;",
"}",
"VAR_1 += VAR_2;",
"}",
"}"
]
| [
1,
0,
0,
0,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
39
],
[
41
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
69
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
]
]
|
17,052 | int cpu_restore_state(TranslationBlock *tb,
CPUState *env, unsigned long searched_pc,
void *puc)
{
TCGContext *s = &tcg_ctx;
int j;
unsigned long tc_ptr;
#ifdef CONFIG_PROFILER
int64_t ti;
#endif
#ifdef CONFIG_PROFILER
ti = profile_getclock();
#endif
tcg_func_start(s);
if (gen_intermediate_code_pc(env, tb) < 0)
return -1;
/* find opc index corresponding to search_pc */
tc_ptr = (unsigned long)tb->tc_ptr;
if (searched_pc < tc_ptr)
return -1;
s->tb_next_offset = tb->tb_next_offset;
#ifdef USE_DIRECT_JUMP
s->tb_jmp_offset = tb->tb_jmp_offset;
s->tb_next = NULL;
#else
s->tb_jmp_offset = NULL;
s->tb_next = tb->tb_next;
#endif
j = dyngen_code_search_pc(s, (uint8_t *)tc_ptr,
(void *)searched_pc);
if (j < 0)
return -1;
/* now find start of instruction before */
while (gen_opc_instr_start[j] == 0)
j--;
#if defined(TARGET_I386)
{
int cc_op;
#ifdef DEBUG_DISAS
if (loglevel & CPU_LOG_TB_OP) {
int i;
fprintf(logfile, "RESTORE:\n");
for(i=0;i<=j; i++) {
if (gen_opc_instr_start[i]) {
fprintf(logfile, "0x%04x: " TARGET_FMT_lx "\n", i, gen_opc_pc[i]);
}
}
fprintf(logfile, "spc=0x%08lx j=0x%x eip=" TARGET_FMT_lx " cs_base=%x\n",
searched_pc, j, gen_opc_pc[j] - tb->cs_base,
(uint32_t)tb->cs_base);
}
#endif
env->eip = gen_opc_pc[j] - tb->cs_base;
cc_op = gen_opc_cc_op[j];
if (cc_op != CC_OP_DYNAMIC)
env->cc_op = cc_op;
}
#elif defined(TARGET_ARM)
env->regs[15] = gen_opc_pc[j];
#elif defined(TARGET_SPARC)
{
target_ulong npc;
env->pc = gen_opc_pc[j];
npc = gen_opc_npc[j];
if (npc == 1) {
/* dynamic NPC: already stored */
} else if (npc == 2) {
target_ulong t2 = (target_ulong)(unsigned long)puc;
/* jump PC: use T2 and the jump targets of the translation */
if (t2)
env->npc = gen_opc_jump_pc[0];
else
env->npc = gen_opc_jump_pc[1];
} else {
env->npc = npc;
}
}
#elif defined(TARGET_PPC)
{
int type, c;
/* for PPC, we need to look at the micro operation to get the
access type */
env->nip = gen_opc_pc[j];
c = gen_opc_buf[j];
switch(c) {
#if defined(CONFIG_USER_ONLY)
#define CASE3(op)\
case INDEX_op_ ## op ## _raw
#else
#define CASE3(op)\
case INDEX_op_ ## op ## _user:\
case INDEX_op_ ## op ## _kernel:\
case INDEX_op_ ## op ## _hypv
#endif
CASE3(stfd):
CASE3(stfs):
CASE3(lfd):
CASE3(lfs):
type = ACCESS_FLOAT;
break;
CASE3(lwarx):
type = ACCESS_RES;
break;
CASE3(stwcx):
type = ACCESS_RES;
break;
CASE3(eciwx):
CASE3(ecowx):
type = ACCESS_EXT;
break;
default:
type = ACCESS_INT;
break;
}
env->access_type = type;
}
#elif defined(TARGET_M68K)
env->pc = gen_opc_pc[j];
#elif defined(TARGET_MIPS)
env->PC[env->current_tc] = gen_opc_pc[j];
env->hflags &= ~MIPS_HFLAG_BMASK;
env->hflags |= gen_opc_hflags[j];
#elif defined(TARGET_ALPHA)
env->pc = gen_opc_pc[j];
#elif defined(TARGET_SH4)
env->pc = gen_opc_pc[j];
env->flags = gen_opc_hflags[j];
#endif
#ifdef CONFIG_PROFILER
dyngen_restore_time += profile_getclock() - ti;
dyngen_restore_count++;
#endif
return 0;
}
| true | qemu | 2ba1eeb62c29d23238b95dc7e9ade3444b49f0a1 | int cpu_restore_state(TranslationBlock *tb,
CPUState *env, unsigned long searched_pc,
void *puc)
{
TCGContext *s = &tcg_ctx;
int j;
unsigned long tc_ptr;
#ifdef CONFIG_PROFILER
int64_t ti;
#endif
#ifdef CONFIG_PROFILER
ti = profile_getclock();
#endif
tcg_func_start(s);
if (gen_intermediate_code_pc(env, tb) < 0)
return -1;
tc_ptr = (unsigned long)tb->tc_ptr;
if (searched_pc < tc_ptr)
return -1;
s->tb_next_offset = tb->tb_next_offset;
#ifdef USE_DIRECT_JUMP
s->tb_jmp_offset = tb->tb_jmp_offset;
s->tb_next = NULL;
#else
s->tb_jmp_offset = NULL;
s->tb_next = tb->tb_next;
#endif
j = dyngen_code_search_pc(s, (uint8_t *)tc_ptr,
(void *)searched_pc);
if (j < 0)
return -1;
while (gen_opc_instr_start[j] == 0)
j--;
#if defined(TARGET_I386)
{
int cc_op;
#ifdef DEBUG_DISAS
if (loglevel & CPU_LOG_TB_OP) {
int i;
fprintf(logfile, "RESTORE:\n");
for(i=0;i<=j; i++) {
if (gen_opc_instr_start[i]) {
fprintf(logfile, "0x%04x: " TARGET_FMT_lx "\n", i, gen_opc_pc[i]);
}
}
fprintf(logfile, "spc=0x%08lx j=0x%x eip=" TARGET_FMT_lx " cs_base=%x\n",
searched_pc, j, gen_opc_pc[j] - tb->cs_base,
(uint32_t)tb->cs_base);
}
#endif
env->eip = gen_opc_pc[j] - tb->cs_base;
cc_op = gen_opc_cc_op[j];
if (cc_op != CC_OP_DYNAMIC)
env->cc_op = cc_op;
}
#elif defined(TARGET_ARM)
env->regs[15] = gen_opc_pc[j];
#elif defined(TARGET_SPARC)
{
target_ulong npc;
env->pc = gen_opc_pc[j];
npc = gen_opc_npc[j];
if (npc == 1) {
} else if (npc == 2) {
target_ulong t2 = (target_ulong)(unsigned long)puc;
if (t2)
env->npc = gen_opc_jump_pc[0];
else
env->npc = gen_opc_jump_pc[1];
} else {
env->npc = npc;
}
}
#elif defined(TARGET_PPC)
{
int type, c;
env->nip = gen_opc_pc[j];
c = gen_opc_buf[j];
switch(c) {
#if defined(CONFIG_USER_ONLY)
#define CASE3(op)\
case INDEX_op_ ## op ## _raw
#else
#define CASE3(op)\
case INDEX_op_ ## op ## _user:\
case INDEX_op_ ## op ## _kernel:\
case INDEX_op_ ## op ## _hypv
#endif
CASE3(stfd):
CASE3(stfs):
CASE3(lfd):
CASE3(lfs):
type = ACCESS_FLOAT;
break;
CASE3(lwarx):
type = ACCESS_RES;
break;
CASE3(stwcx):
type = ACCESS_RES;
break;
CASE3(eciwx):
CASE3(ecowx):
type = ACCESS_EXT;
break;
default:
type = ACCESS_INT;
break;
}
env->access_type = type;
}
#elif defined(TARGET_M68K)
env->pc = gen_opc_pc[j];
#elif defined(TARGET_MIPS)
env->PC[env->current_tc] = gen_opc_pc[j];
env->hflags &= ~MIPS_HFLAG_BMASK;
env->hflags |= gen_opc_hflags[j];
#elif defined(TARGET_ALPHA)
env->pc = gen_opc_pc[j];
#elif defined(TARGET_SH4)
env->pc = gen_opc_pc[j];
env->flags = gen_opc_hflags[j];
#endif
#ifdef CONFIG_PROFILER
dyngen_restore_time += profile_getclock() - ti;
dyngen_restore_count++;
#endif
return 0;
}
| {
"code": [
" j = dyngen_code_search_pc(s, (uint8_t *)tc_ptr, ",
" (void *)searched_pc); "
],
"line_no": [
65,
67
]
} | int FUNC_0(TranslationBlock *VAR_0,
CPUState *VAR_1, unsigned long VAR_2,
void *VAR_3)
{
TCGContext *s = &tcg_ctx;
int VAR_4;
unsigned long VAR_5;
#ifdef CONFIG_PROFILER
int64_t ti;
#endif
#ifdef CONFIG_PROFILER
ti = profile_getclock();
#endif
tcg_func_start(s);
if (gen_intermediate_code_pc(VAR_1, VAR_0) < 0)
return -1;
VAR_5 = (unsigned long)VAR_0->VAR_5;
if (VAR_2 < VAR_5)
return -1;
s->tb_next_offset = VAR_0->tb_next_offset;
#ifdef USE_DIRECT_JUMP
s->tb_jmp_offset = VAR_0->tb_jmp_offset;
s->tb_next = NULL;
#else
s->tb_jmp_offset = NULL;
s->tb_next = VAR_0->tb_next;
#endif
VAR_4 = dyngen_code_search_pc(s, (uint8_t *)VAR_5,
(void *)VAR_2);
if (VAR_4 < 0)
return -1;
while (gen_opc_instr_start[VAR_4] == 0)
VAR_4--;
#if defined(TARGET_I386)
{
int cc_op;
#ifdef DEBUG_DISAS
if (loglevel & CPU_LOG_TB_OP) {
int i;
fprintf(logfile, "RESTORE:\n");
for(i=0;i<=VAR_4; i++) {
if (gen_opc_instr_start[i]) {
fprintf(logfile, "0x%04x: " TARGET_FMT_lx "\n", i, gen_opc_pc[i]);
}
}
fprintf(logfile, "spc=0x%08lx VAR_4=0x%x eip=" TARGET_FMT_lx " cs_base=%x\n",
VAR_2, VAR_4, gen_opc_pc[VAR_4] - VAR_0->cs_base,
(uint32_t)VAR_0->cs_base);
}
#endif
VAR_1->eip = gen_opc_pc[VAR_4] - VAR_0->cs_base;
cc_op = gen_opc_cc_op[VAR_4];
if (cc_op != CC_OP_DYNAMIC)
VAR_1->cc_op = cc_op;
}
#elif defined(TARGET_ARM)
VAR_1->regs[15] = gen_opc_pc[VAR_4];
#elif defined(TARGET_SPARC)
{
target_ulong npc;
VAR_1->pc = gen_opc_pc[VAR_4];
npc = gen_opc_npc[VAR_4];
if (npc == 1) {
} else if (npc == 2) {
target_ulong t2 = (target_ulong)(unsigned long)VAR_3;
if (t2)
VAR_1->npc = gen_opc_jump_pc[0];
else
VAR_1->npc = gen_opc_jump_pc[1];
} else {
VAR_1->npc = npc;
}
}
#elif defined(TARGET_PPC)
{
int type, c;
VAR_1->nip = gen_opc_pc[VAR_4];
c = gen_opc_buf[VAR_4];
switch(c) {
#if defined(CONFIG_USER_ONLY)
#define CASE3(op)\
case INDEX_op_ ## op ## _raw
#else
#define CASE3(op)\
case INDEX_op_ ## op ## _user:\
case INDEX_op_ ## op ## _kernel:\
case INDEX_op_ ## op ## _hypv
#endif
CASE3(stfd):
CASE3(stfs):
CASE3(lfd):
CASE3(lfs):
type = ACCESS_FLOAT;
break;
CASE3(lwarx):
type = ACCESS_RES;
break;
CASE3(stwcx):
type = ACCESS_RES;
break;
CASE3(eciwx):
CASE3(ecowx):
type = ACCESS_EXT;
break;
default:
type = ACCESS_INT;
break;
}
VAR_1->access_type = type;
}
#elif defined(TARGET_M68K)
VAR_1->pc = gen_opc_pc[VAR_4];
#elif defined(TARGET_MIPS)
VAR_1->PC[VAR_1->current_tc] = gen_opc_pc[VAR_4];
VAR_1->hflags &= ~MIPS_HFLAG_BMASK;
VAR_1->hflags |= gen_opc_hflags[VAR_4];
#elif defined(TARGET_ALPHA)
VAR_1->pc = gen_opc_pc[VAR_4];
#elif defined(TARGET_SH4)
VAR_1->pc = gen_opc_pc[VAR_4];
VAR_1->flags = gen_opc_hflags[VAR_4];
#endif
#ifdef CONFIG_PROFILER
dyngen_restore_time += profile_getclock() - ti;
dyngen_restore_count++;
#endif
return 0;
}
| [
"int FUNC_0(TranslationBlock *VAR_0,\nCPUState *VAR_1, unsigned long VAR_2,\nvoid *VAR_3)\n{",
"TCGContext *s = &tcg_ctx;",
"int VAR_4;",
"unsigned long VAR_5;",
"#ifdef CONFIG_PROFILER\nint64_t ti;",
"#endif\n#ifdef CONFIG_PROFILER\nti = profile_getclock();",
"#endif\ntcg_func_start(s);",
"if (gen_intermediate_code_pc(VAR_1, VAR_0) < 0)\nreturn -1;",
"VAR_5 = (unsigned long)VAR_0->VAR_5;",
"if (VAR_2 < VAR_5)\nreturn -1;",
"s->tb_next_offset = VAR_0->tb_next_offset;",
"#ifdef USE_DIRECT_JUMP\ns->tb_jmp_offset = VAR_0->tb_jmp_offset;",
"s->tb_next = NULL;",
"#else\ns->tb_jmp_offset = NULL;",
"s->tb_next = VAR_0->tb_next;",
"#endif\nVAR_4 = dyngen_code_search_pc(s, (uint8_t *)VAR_5,\n(void *)VAR_2);",
"if (VAR_4 < 0)\nreturn -1;",
"while (gen_opc_instr_start[VAR_4] == 0)\nVAR_4--;",
"#if defined(TARGET_I386)\n{",
"int cc_op;",
"#ifdef DEBUG_DISAS\nif (loglevel & CPU_LOG_TB_OP) {",
"int i;",
"fprintf(logfile, \"RESTORE:\\n\");",
"for(i=0;i<=VAR_4; i++) {",
"if (gen_opc_instr_start[i]) {",
"fprintf(logfile, \"0x%04x: \" TARGET_FMT_lx \"\\n\", i, gen_opc_pc[i]);",
"}",
"}",
"fprintf(logfile, \"spc=0x%08lx VAR_4=0x%x eip=\" TARGET_FMT_lx \" cs_base=%x\\n\",\nVAR_2, VAR_4, gen_opc_pc[VAR_4] - VAR_0->cs_base,\n(uint32_t)VAR_0->cs_base);",
"}",
"#endif\nVAR_1->eip = gen_opc_pc[VAR_4] - VAR_0->cs_base;",
"cc_op = gen_opc_cc_op[VAR_4];",
"if (cc_op != CC_OP_DYNAMIC)\nVAR_1->cc_op = cc_op;",
"}",
"#elif defined(TARGET_ARM)\nVAR_1->regs[15] = gen_opc_pc[VAR_4];",
"#elif defined(TARGET_SPARC)\n{",
"target_ulong npc;",
"VAR_1->pc = gen_opc_pc[VAR_4];",
"npc = gen_opc_npc[VAR_4];",
"if (npc == 1) {",
"} else if (npc == 2) {",
"target_ulong t2 = (target_ulong)(unsigned long)VAR_3;",
"if (t2)\nVAR_1->npc = gen_opc_jump_pc[0];",
"else\nVAR_1->npc = gen_opc_jump_pc[1];",
"} else {",
"VAR_1->npc = npc;",
"}",
"}",
"#elif defined(TARGET_PPC)\n{",
"int type, c;",
"VAR_1->nip = gen_opc_pc[VAR_4];",
"c = gen_opc_buf[VAR_4];",
"switch(c) {",
"#if defined(CONFIG_USER_ONLY)\n#define CASE3(op)\\\ncase INDEX_op_ ## op ## _raw\n#else\n#define CASE3(op)\\\ncase INDEX_op_ ## op ## _user:\\\ncase INDEX_op_ ## op ## _kernel:\\\ncase INDEX_op_ ## op ## _hypv\n#endif\nCASE3(stfd):\nCASE3(stfs):\nCASE3(lfd):\nCASE3(lfs):\ntype = ACCESS_FLOAT;",
"break;",
"CASE3(lwarx):\ntype = ACCESS_RES;",
"break;",
"CASE3(stwcx):\ntype = ACCESS_RES;",
"break;",
"CASE3(eciwx):\nCASE3(ecowx):\ntype = ACCESS_EXT;",
"break;",
"default:\ntype = ACCESS_INT;",
"break;",
"}",
"VAR_1->access_type = type;",
"}",
"#elif defined(TARGET_M68K)\nVAR_1->pc = gen_opc_pc[VAR_4];",
"#elif defined(TARGET_MIPS)\nVAR_1->PC[VAR_1->current_tc] = gen_opc_pc[VAR_4];",
"VAR_1->hflags &= ~MIPS_HFLAG_BMASK;",
"VAR_1->hflags |= gen_opc_hflags[VAR_4];",
"#elif defined(TARGET_ALPHA)\nVAR_1->pc = gen_opc_pc[VAR_4];",
"#elif defined(TARGET_SH4)\nVAR_1->pc = gen_opc_pc[VAR_4];",
"VAR_1->flags = gen_opc_hflags[VAR_4];",
"#endif\n#ifdef CONFIG_PROFILER\ndyngen_restore_time += profile_getclock() - ti;",
"dyngen_restore_count++;",
"#endif\nreturn 0;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5,
7
],
[
9
],
[
11
],
[
13
],
[
15,
17
],
[
19,
23,
25
],
[
27,
29
],
[
33,
35
],
[
41
],
[
43,
45
],
[
49
],
[
51,
53
],
[
55
],
[
57,
59
],
[
61
],
[
63,
65,
67
],
[
69,
71
],
[
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
],
[
141
],
[
143
],
[
147,
149
],
[
151,
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
163,
165
],
[
167
],
[
173
],
[
175
],
[
177
],
[
179,
181,
183,
185,
187,
189,
191,
193,
195,
199,
201,
203,
205,
207
],
[
209
],
[
211,
213
],
[
215
],
[
217,
219
],
[
221
],
[
223,
225,
227
],
[
229
],
[
231,
233
],
[
235
],
[
237
],
[
239
],
[
241
],
[
243,
245
],
[
247,
249
],
[
251
],
[
253
],
[
255,
257
],
[
259,
261
],
[
263
],
[
265,
269,
271
],
[
273
],
[
275,
277
],
[
279
]
]
|
17,053 | void h263_encode_picture_header(MpegEncContext * s, int picture_number)
{
int format;
align_put_bits(&s->pb);
put_bits(&s->pb, 22, 0x20);
put_bits(&s->pb, 8, ((s->picture_number * 30 * FRAME_RATE_BASE) /
s->frame_rate) & 0xff);
put_bits(&s->pb, 1, 1); /* marker */
put_bits(&s->pb, 1, 0); /* h263 id */
put_bits(&s->pb, 1, 0); /* split screen off */
put_bits(&s->pb, 1, 0); /* camera off */
put_bits(&s->pb, 1, 0); /* freeze picture release off */
format = h263_get_picture_format(s->width, s->height);
if (!s->h263_plus) {
/* H.263v1 */
put_bits(&s->pb, 3, format);
put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
/* By now UMV IS DISABLED ON H.263v1, since the restrictions
of H.263v1 UMV implies to check the predicted MV after
calculation of the current MB to see if we're on the limits */
put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
put_bits(&s->pb, 1, 0); /* SAC: off */
put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
put_bits(&s->pb, 1, 0); /* not PB frame */
put_bits(&s->pb, 5, s->qscale);
put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
} else {
/* H.263v2 */
/* H.263 Plus PTYPE */
put_bits(&s->pb, 3, 7);
put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
if (format == 7)
put_bits(&s->pb,3,6); /* Custom Source Format */
else
put_bits(&s->pb, 3, format);
put_bits(&s->pb,1,0); /* Custom PCF: off */
umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
put_bits(&s->pb, 1, umvplus); /* Unrestricted Motion Vector */
put_bits(&s->pb,1,0); /* SAC: off */
put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
put_bits(&s->pb,1,0); /* Advanced Intra Coding: off */
put_bits(&s->pb,1,0); /* Deblocking Filter: off */
put_bits(&s->pb,1,0); /* Slice Structured: off */
put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
put_bits(&s->pb,1,0); /* Modified Quantization: off */
put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
put_bits(&s->pb,3,0); /* Reserved */
put_bits(&s->pb, 3, s->pict_type == P_TYPE);
put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
put_bits(&s->pb,1,0); /* Rounding Type */
put_bits(&s->pb,2,0); /* Reserved */
put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
/* This should be here if PLUSPTYPE */
put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
if (format == 7) {
/* Custom Picture Format (CPFMT) */
put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
put_bits(&s->pb,9,(s->width >> 2) - 1);
put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
put_bits(&s->pb,9,(s->height >> 2));
}
/* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
if (umvplus)
put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
put_bits(&s->pb, 5, s->qscale);
}
put_bits(&s->pb, 1, 0); /* no PEI */
}
| true | FFmpeg | 544286b3d39365b30298ae07e66a755200b0895c | void h263_encode_picture_header(MpegEncContext * s, int picture_number)
{
int format;
align_put_bits(&s->pb);
put_bits(&s->pb, 22, 0x20);
put_bits(&s->pb, 8, ((s->picture_number * 30 * FRAME_RATE_BASE) /
s->frame_rate) & 0xff);
put_bits(&s->pb, 1, 1);
put_bits(&s->pb, 1, 0);
put_bits(&s->pb, 1, 0);
put_bits(&s->pb, 1, 0);
put_bits(&s->pb, 1, 0);
format = h263_get_picture_format(s->width, s->height);
if (!s->h263_plus) {
put_bits(&s->pb, 3, format);
put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
put_bits(&s->pb, 1, 0);
put_bits(&s->pb, 1, 0);
put_bits(&s->pb, 1, 0);
put_bits(&s->pb, 1, 0);
put_bits(&s->pb, 5, s->qscale);
put_bits(&s->pb, 1, 0);
} else {
put_bits(&s->pb, 3, 7);
put_bits(&s->pb,3,1);
if (format == 7)
put_bits(&s->pb,3,6);
else
put_bits(&s->pb, 3, format);
put_bits(&s->pb,1,0);
umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
put_bits(&s->pb, 1, umvplus);
put_bits(&s->pb,1,0);
put_bits(&s->pb,1,0);
put_bits(&s->pb,1,0);
put_bits(&s->pb,1,0);
put_bits(&s->pb,1,0);
put_bits(&s->pb,1,0);
put_bits(&s->pb,1,0);
put_bits(&s->pb,1,0);
put_bits(&s->pb,1,0);
put_bits(&s->pb,1,1);
put_bits(&s->pb,3,0);
put_bits(&s->pb, 3, s->pict_type == P_TYPE);
put_bits(&s->pb,1,0);
put_bits(&s->pb,1,0);
put_bits(&s->pb,1,0);
put_bits(&s->pb,2,0);
put_bits(&s->pb,1,1);
put_bits(&s->pb, 1, 0);
if (format == 7) {
put_bits(&s->pb,4,2);
put_bits(&s->pb,9,(s->width >> 2) - 1);
put_bits(&s->pb,1,1);
put_bits(&s->pb,9,(s->height >> 2));
}
if (umvplus)
put_bits(&s->pb,1,1);
put_bits(&s->pb, 5, s->qscale);
}
put_bits(&s->pb, 1, 0);
}
| {
"code": [
" umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;",
" if (umvplus)"
],
"line_no": [
81,
151
]
} | void FUNC_0(MpegEncContext * VAR_0, int VAR_1)
{
int VAR_2;
align_put_bits(&VAR_0->pb);
put_bits(&VAR_0->pb, 22, 0x20);
put_bits(&VAR_0->pb, 8, ((VAR_0->VAR_1 * 30 * FRAME_RATE_BASE) /
VAR_0->frame_rate) & 0xff);
put_bits(&VAR_0->pb, 1, 1);
put_bits(&VAR_0->pb, 1, 0);
put_bits(&VAR_0->pb, 1, 0);
put_bits(&VAR_0->pb, 1, 0);
put_bits(&VAR_0->pb, 1, 0);
VAR_2 = h263_get_picture_format(VAR_0->width, VAR_0->height);
if (!VAR_0->h263_plus) {
put_bits(&VAR_0->pb, 3, VAR_2);
put_bits(&VAR_0->pb, 1, (VAR_0->pict_type == P_TYPE));
put_bits(&VAR_0->pb, 1, 0);
put_bits(&VAR_0->pb, 1, 0);
put_bits(&VAR_0->pb, 1, 0);
put_bits(&VAR_0->pb, 1, 0);
put_bits(&VAR_0->pb, 5, VAR_0->qscale);
put_bits(&VAR_0->pb, 1, 0);
} else {
put_bits(&VAR_0->pb, 3, 7);
put_bits(&VAR_0->pb,3,1);
if (VAR_2 == 7)
put_bits(&VAR_0->pb,3,6);
else
put_bits(&VAR_0->pb, 3, VAR_2);
put_bits(&VAR_0->pb,1,0);
umvplus = (VAR_0->pict_type == P_TYPE) && VAR_0->unrestricted_mv;
put_bits(&VAR_0->pb, 1, umvplus);
put_bits(&VAR_0->pb,1,0);
put_bits(&VAR_0->pb,1,0);
put_bits(&VAR_0->pb,1,0);
put_bits(&VAR_0->pb,1,0);
put_bits(&VAR_0->pb,1,0);
put_bits(&VAR_0->pb,1,0);
put_bits(&VAR_0->pb,1,0);
put_bits(&VAR_0->pb,1,0);
put_bits(&VAR_0->pb,1,0);
put_bits(&VAR_0->pb,1,1);
put_bits(&VAR_0->pb,3,0);
put_bits(&VAR_0->pb, 3, VAR_0->pict_type == P_TYPE);
put_bits(&VAR_0->pb,1,0);
put_bits(&VAR_0->pb,1,0);
put_bits(&VAR_0->pb,1,0);
put_bits(&VAR_0->pb,2,0);
put_bits(&VAR_0->pb,1,1);
put_bits(&VAR_0->pb, 1, 0);
if (VAR_2 == 7) {
put_bits(&VAR_0->pb,4,2);
put_bits(&VAR_0->pb,9,(VAR_0->width >> 2) - 1);
put_bits(&VAR_0->pb,1,1);
put_bits(&VAR_0->pb,9,(VAR_0->height >> 2));
}
if (umvplus)
put_bits(&VAR_0->pb,1,1);
put_bits(&VAR_0->pb, 5, VAR_0->qscale);
}
put_bits(&VAR_0->pb, 1, 0);
}
| [
"void FUNC_0(MpegEncContext * VAR_0, int VAR_1)\n{",
"int VAR_2;",
"align_put_bits(&VAR_0->pb);",
"put_bits(&VAR_0->pb, 22, 0x20);",
"put_bits(&VAR_0->pb, 8, ((VAR_0->VAR_1 * 30 * FRAME_RATE_BASE) /\nVAR_0->frame_rate) & 0xff);",
"put_bits(&VAR_0->pb, 1, 1);",
"put_bits(&VAR_0->pb, 1, 0);",
"put_bits(&VAR_0->pb, 1, 0);",
"put_bits(&VAR_0->pb, 1, 0);",
"put_bits(&VAR_0->pb, 1, 0);",
"VAR_2 = h263_get_picture_format(VAR_0->width, VAR_0->height);",
"if (!VAR_0->h263_plus) {",
"put_bits(&VAR_0->pb, 3, VAR_2);",
"put_bits(&VAR_0->pb, 1, (VAR_0->pict_type == P_TYPE));",
"put_bits(&VAR_0->pb, 1, 0);",
"put_bits(&VAR_0->pb, 1, 0);",
"put_bits(&VAR_0->pb, 1, 0);",
"put_bits(&VAR_0->pb, 1, 0);",
"put_bits(&VAR_0->pb, 5, VAR_0->qscale);",
"put_bits(&VAR_0->pb, 1, 0);",
"} else {",
"put_bits(&VAR_0->pb, 3, 7);",
"put_bits(&VAR_0->pb,3,1);",
"if (VAR_2 == 7)\nput_bits(&VAR_0->pb,3,6);",
"else\nput_bits(&VAR_0->pb, 3, VAR_2);",
"put_bits(&VAR_0->pb,1,0);",
"umvplus = (VAR_0->pict_type == P_TYPE) && VAR_0->unrestricted_mv;",
"put_bits(&VAR_0->pb, 1, umvplus);",
"put_bits(&VAR_0->pb,1,0);",
"put_bits(&VAR_0->pb,1,0);",
"put_bits(&VAR_0->pb,1,0);",
"put_bits(&VAR_0->pb,1,0);",
"put_bits(&VAR_0->pb,1,0);",
"put_bits(&VAR_0->pb,1,0);",
"put_bits(&VAR_0->pb,1,0);",
"put_bits(&VAR_0->pb,1,0);",
"put_bits(&VAR_0->pb,1,0);",
"put_bits(&VAR_0->pb,1,1);",
"put_bits(&VAR_0->pb,3,0);",
"put_bits(&VAR_0->pb, 3, VAR_0->pict_type == P_TYPE);",
"put_bits(&VAR_0->pb,1,0);",
"put_bits(&VAR_0->pb,1,0);",
"put_bits(&VAR_0->pb,1,0);",
"put_bits(&VAR_0->pb,2,0);",
"put_bits(&VAR_0->pb,1,1);",
"put_bits(&VAR_0->pb, 1, 0);",
"if (VAR_2 == 7) {",
"put_bits(&VAR_0->pb,4,2);",
"put_bits(&VAR_0->pb,9,(VAR_0->width >> 2) - 1);",
"put_bits(&VAR_0->pb,1,1);",
"put_bits(&VAR_0->pb,9,(VAR_0->height >> 2));",
"}",
"if (umvplus)\nput_bits(&VAR_0->pb,1,1);",
"put_bits(&VAR_0->pb, 5, VAR_0->qscale);",
"}",
"put_bits(&VAR_0->pb, 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,
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,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
9
],
[
11
],
[
13,
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
37
],
[
39
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
65
],
[
67
],
[
69,
71
],
[
73,
75
],
[
79
],
[
81
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
109
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
127
],
[
131
],
[
137
],
[
139
],
[
141
],
[
143
],
[
145
],
[
151,
153
],
[
155
],
[
157
],
[
161
],
[
163
]
]
|
17,054 | _net_rx_pkt_calc_l4_csum(struct NetRxPkt *pkt)
{
uint32_t cntr;
uint16_t csum;
uint16_t csl;
uint32_t cso;
trace_net_rx_pkt_l4_csum_calc_entry();
if (pkt->isip4) {
if (pkt->isudp) {
csl = be16_to_cpu(pkt->l4hdr_info.hdr.udp.uh_ulen);
trace_net_rx_pkt_l4_csum_calc_ip4_udp();
} else {
csl = be16_to_cpu(pkt->ip4hdr_info.ip4_hdr.ip_len) -
IP_HDR_GET_LEN(&pkt->ip4hdr_info.ip4_hdr);
trace_net_rx_pkt_l4_csum_calc_ip4_tcp();
}
cntr = eth_calc_ip4_pseudo_hdr_csum(&pkt->ip4hdr_info.ip4_hdr,
csl, &cso);
trace_net_rx_pkt_l4_csum_calc_ph_csum(cntr, csl);
} else {
if (pkt->isudp) {
csl = be16_to_cpu(pkt->l4hdr_info.hdr.udp.uh_ulen);
trace_net_rx_pkt_l4_csum_calc_ip6_udp();
} else {
struct ip6_header *ip6hdr = &pkt->ip6hdr_info.ip6_hdr;
size_t full_ip6hdr_len = pkt->l4hdr_off - pkt->l3hdr_off;
size_t ip6opts_len = full_ip6hdr_len - sizeof(struct ip6_header);
csl = be16_to_cpu(ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_plen) -
ip6opts_len;
trace_net_rx_pkt_l4_csum_calc_ip6_tcp();
}
cntr = eth_calc_ip6_pseudo_hdr_csum(&pkt->ip6hdr_info.ip6_hdr, csl,
pkt->ip6hdr_info.l4proto, &cso);
trace_net_rx_pkt_l4_csum_calc_ph_csum(cntr, csl);
}
cntr += net_checksum_add_iov(pkt->vec, pkt->vec_len,
pkt->l4hdr_off, csl, cso);
csum = net_checksum_finish(cntr);
trace_net_rx_pkt_l4_csum_calc_csum(pkt->l4hdr_off, csl, cntr, csum);
return csum;
}
| true | qemu | 0dacea92d26c31d453c58de2e99c178fee554166 | _net_rx_pkt_calc_l4_csum(struct NetRxPkt *pkt)
{
uint32_t cntr;
uint16_t csum;
uint16_t csl;
uint32_t cso;
trace_net_rx_pkt_l4_csum_calc_entry();
if (pkt->isip4) {
if (pkt->isudp) {
csl = be16_to_cpu(pkt->l4hdr_info.hdr.udp.uh_ulen);
trace_net_rx_pkt_l4_csum_calc_ip4_udp();
} else {
csl = be16_to_cpu(pkt->ip4hdr_info.ip4_hdr.ip_len) -
IP_HDR_GET_LEN(&pkt->ip4hdr_info.ip4_hdr);
trace_net_rx_pkt_l4_csum_calc_ip4_tcp();
}
cntr = eth_calc_ip4_pseudo_hdr_csum(&pkt->ip4hdr_info.ip4_hdr,
csl, &cso);
trace_net_rx_pkt_l4_csum_calc_ph_csum(cntr, csl);
} else {
if (pkt->isudp) {
csl = be16_to_cpu(pkt->l4hdr_info.hdr.udp.uh_ulen);
trace_net_rx_pkt_l4_csum_calc_ip6_udp();
} else {
struct ip6_header *ip6hdr = &pkt->ip6hdr_info.ip6_hdr;
size_t full_ip6hdr_len = pkt->l4hdr_off - pkt->l3hdr_off;
size_t ip6opts_len = full_ip6hdr_len - sizeof(struct ip6_header);
csl = be16_to_cpu(ip6hdr->ip6_ctlun.ip6_un1.ip6_un1_plen) -
ip6opts_len;
trace_net_rx_pkt_l4_csum_calc_ip6_tcp();
}
cntr = eth_calc_ip6_pseudo_hdr_csum(&pkt->ip6hdr_info.ip6_hdr, csl,
pkt->ip6hdr_info.l4proto, &cso);
trace_net_rx_pkt_l4_csum_calc_ph_csum(cntr, csl);
}
cntr += net_checksum_add_iov(pkt->vec, pkt->vec_len,
pkt->l4hdr_off, csl, cso);
csum = net_checksum_finish(cntr);
trace_net_rx_pkt_l4_csum_calc_csum(pkt->l4hdr_off, csl, cntr, csum);
return csum;
}
| {
"code": [
" csum = net_checksum_finish(cntr);"
],
"line_no": [
89
]
} | FUNC_0(struct NetRxPkt *VAR_0)
{
uint32_t cntr;
uint16_t csum;
uint16_t csl;
uint32_t cso;
trace_net_rx_pkt_l4_csum_calc_entry();
if (VAR_0->isip4) {
if (VAR_0->isudp) {
csl = be16_to_cpu(VAR_0->l4hdr_info.hdr.udp.uh_ulen);
trace_net_rx_pkt_l4_csum_calc_ip4_udp();
} else {
csl = be16_to_cpu(VAR_0->ip4hdr_info.ip4_hdr.ip_len) -
IP_HDR_GET_LEN(&VAR_0->ip4hdr_info.ip4_hdr);
trace_net_rx_pkt_l4_csum_calc_ip4_tcp();
}
cntr = eth_calc_ip4_pseudo_hdr_csum(&VAR_0->ip4hdr_info.ip4_hdr,
csl, &cso);
trace_net_rx_pkt_l4_csum_calc_ph_csum(cntr, csl);
} else {
if (VAR_0->isudp) {
csl = be16_to_cpu(VAR_0->l4hdr_info.hdr.udp.uh_ulen);
trace_net_rx_pkt_l4_csum_calc_ip6_udp();
} else {
struct ip6_header *VAR_1 = &VAR_0->ip6hdr_info.ip6_hdr;
size_t full_ip6hdr_len = VAR_0->l4hdr_off - VAR_0->l3hdr_off;
size_t ip6opts_len = full_ip6hdr_len - sizeof(struct ip6_header);
csl = be16_to_cpu(VAR_1->ip6_ctlun.ip6_un1.ip6_un1_plen) -
ip6opts_len;
trace_net_rx_pkt_l4_csum_calc_ip6_tcp();
}
cntr = eth_calc_ip6_pseudo_hdr_csum(&VAR_0->ip6hdr_info.ip6_hdr, csl,
VAR_0->ip6hdr_info.l4proto, &cso);
trace_net_rx_pkt_l4_csum_calc_ph_csum(cntr, csl);
}
cntr += net_checksum_add_iov(VAR_0->vec, VAR_0->vec_len,
VAR_0->l4hdr_off, csl, cso);
csum = net_checksum_finish(cntr);
trace_net_rx_pkt_l4_csum_calc_csum(VAR_0->l4hdr_off, csl, cntr, csum);
return csum;
}
| [
"FUNC_0(struct NetRxPkt *VAR_0)\n{",
"uint32_t cntr;",
"uint16_t csum;",
"uint16_t csl;",
"uint32_t cso;",
"trace_net_rx_pkt_l4_csum_calc_entry();",
"if (VAR_0->isip4) {",
"if (VAR_0->isudp) {",
"csl = be16_to_cpu(VAR_0->l4hdr_info.hdr.udp.uh_ulen);",
"trace_net_rx_pkt_l4_csum_calc_ip4_udp();",
"} else {",
"csl = be16_to_cpu(VAR_0->ip4hdr_info.ip4_hdr.ip_len) -\nIP_HDR_GET_LEN(&VAR_0->ip4hdr_info.ip4_hdr);",
"trace_net_rx_pkt_l4_csum_calc_ip4_tcp();",
"}",
"cntr = eth_calc_ip4_pseudo_hdr_csum(&VAR_0->ip4hdr_info.ip4_hdr,\ncsl, &cso);",
"trace_net_rx_pkt_l4_csum_calc_ph_csum(cntr, csl);",
"} else {",
"if (VAR_0->isudp) {",
"csl = be16_to_cpu(VAR_0->l4hdr_info.hdr.udp.uh_ulen);",
"trace_net_rx_pkt_l4_csum_calc_ip6_udp();",
"} else {",
"struct ip6_header *VAR_1 = &VAR_0->ip6hdr_info.ip6_hdr;",
"size_t full_ip6hdr_len = VAR_0->l4hdr_off - VAR_0->l3hdr_off;",
"size_t ip6opts_len = full_ip6hdr_len - sizeof(struct ip6_header);",
"csl = be16_to_cpu(VAR_1->ip6_ctlun.ip6_un1.ip6_un1_plen) -\nip6opts_len;",
"trace_net_rx_pkt_l4_csum_calc_ip6_tcp();",
"}",
"cntr = eth_calc_ip6_pseudo_hdr_csum(&VAR_0->ip6hdr_info.ip6_hdr, csl,\nVAR_0->ip6hdr_info.l4proto, &cso);",
"trace_net_rx_pkt_l4_csum_calc_ph_csum(cntr, csl);",
"}",
"cntr += net_checksum_add_iov(VAR_0->vec, VAR_0->vec_len,\nVAR_0->l4hdr_off, csl, cso);",
"csum = net_checksum_finish(cntr);",
"trace_net_rx_pkt_l4_csum_calc_csum(VAR_0->l4hdr_off, csl, cntr, csum);",
"return csum;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
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
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29,
31
],
[
33
],
[
35
],
[
39,
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63,
65
],
[
67
],
[
69
],
[
73,
75
],
[
77
],
[
79
],
[
83,
85
],
[
89
],
[
93
],
[
97
],
[
99
]
]
|
17,055 | int xen_hvm_init(ram_addr_t *below_4g_mem_size, ram_addr_t *above_4g_mem_size,
MemoryRegion **ram_memory)
{
int i, rc;
unsigned long ioreq_pfn;
unsigned long bufioreq_evtchn;
XenIOState *state;
state = g_malloc0(sizeof (XenIOState));
state->xce_handle = xen_xc_evtchn_open(NULL, 0);
if (state->xce_handle == XC_HANDLER_INITIAL_VALUE) {
perror("xen: event channel open");
return -1;
}
state->xenstore = xs_daemon_open();
if (state->xenstore == NULL) {
perror("xen: xenstore open");
return -1;
}
state->exit.notify = xen_exit_notifier;
qemu_add_exit_notifier(&state->exit);
state->suspend.notify = xen_suspend_notifier;
qemu_register_suspend_notifier(&state->suspend);
state->wakeup.notify = xen_wakeup_notifier;
qemu_register_wakeup_notifier(&state->wakeup);
xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_IOREQ_PFN, &ioreq_pfn);
DPRINTF("shared page at pfn %lx\n", ioreq_pfn);
state->shared_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,
PROT_READ|PROT_WRITE, ioreq_pfn);
if (state->shared_page == NULL) {
hw_error("map shared IO page returned error %d handle=" XC_INTERFACE_FMT,
errno, xen_xc);
}
rc = xen_get_vmport_regs_pfn(xen_xc, xen_domid, &ioreq_pfn);
if (!rc) {
DPRINTF("shared vmport page at pfn %lx\n", ioreq_pfn);
state->shared_vmport_page =
xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,
PROT_READ|PROT_WRITE, ioreq_pfn);
if (state->shared_vmport_page == NULL) {
hw_error("map shared vmport IO page returned error %d handle="
XC_INTERFACE_FMT, errno, xen_xc);
}
} else if (rc != -ENOSYS) {
hw_error("get vmport regs pfn returned error %d, rc=%d", errno, rc);
}
xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_PFN, &ioreq_pfn);
DPRINTF("buffered io page at pfn %lx\n", ioreq_pfn);
state->buffered_io_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,
PROT_READ|PROT_WRITE, ioreq_pfn);
if (state->buffered_io_page == NULL) {
hw_error("map buffered IO page returned error %d", errno);
}
/* Note: cpus is empty at this point in init */
state->cpu_by_vcpu_id = g_malloc0(max_cpus * sizeof(CPUState *));
state->ioreq_local_port = g_malloc0(max_cpus * sizeof (evtchn_port_t));
/* FIXME: how about if we overflow the page here? */
for (i = 0; i < max_cpus; i++) {
rc = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid,
xen_vcpu_eport(state->shared_page, i));
if (rc == -1) {
fprintf(stderr, "bind interdomain ioctl error %d\n", errno);
return -1;
}
state->ioreq_local_port[i] = rc;
}
rc = xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_EVTCHN,
&bufioreq_evtchn);
if (rc < 0) {
fprintf(stderr, "failed to get HVM_PARAM_BUFIOREQ_EVTCHN\n");
return -1;
}
rc = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid,
(uint32_t)bufioreq_evtchn);
if (rc == -1) {
fprintf(stderr, "bind interdomain ioctl error %d\n", errno);
return -1;
}
state->bufioreq_local_port = rc;
/* Init RAM management */
xen_map_cache_init(xen_phys_offset_to_gaddr, state);
xen_ram_init(below_4g_mem_size, above_4g_mem_size, ram_size, ram_memory);
qemu_add_vm_change_state_handler(xen_hvm_change_state_handler, state);
state->memory_listener = xen_memory_listener;
QLIST_INIT(&state->physmap);
memory_listener_register(&state->memory_listener, &address_space_memory);
state->log_for_dirtybit = NULL;
/* Initialize backend core & drivers */
if (xen_be_init() != 0) {
fprintf(stderr, "%s: xen backend core setup failed\n", __FUNCTION__);
return -1;
}
xen_be_register("console", &xen_console_ops);
xen_be_register("vkbd", &xen_kbdmouse_ops);
xen_be_register("qdisk", &xen_blkdev_ops);
xen_read_physmap(state);
return 0;
}
| true | qemu | 3996e85c1822e05c50250f8d2d1e57b6bea1229d | int xen_hvm_init(ram_addr_t *below_4g_mem_size, ram_addr_t *above_4g_mem_size,
MemoryRegion **ram_memory)
{
int i, rc;
unsigned long ioreq_pfn;
unsigned long bufioreq_evtchn;
XenIOState *state;
state = g_malloc0(sizeof (XenIOState));
state->xce_handle = xen_xc_evtchn_open(NULL, 0);
if (state->xce_handle == XC_HANDLER_INITIAL_VALUE) {
perror("xen: event channel open");
return -1;
}
state->xenstore = xs_daemon_open();
if (state->xenstore == NULL) {
perror("xen: xenstore open");
return -1;
}
state->exit.notify = xen_exit_notifier;
qemu_add_exit_notifier(&state->exit);
state->suspend.notify = xen_suspend_notifier;
qemu_register_suspend_notifier(&state->suspend);
state->wakeup.notify = xen_wakeup_notifier;
qemu_register_wakeup_notifier(&state->wakeup);
xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_IOREQ_PFN, &ioreq_pfn);
DPRINTF("shared page at pfn %lx\n", ioreq_pfn);
state->shared_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,
PROT_READ|PROT_WRITE, ioreq_pfn);
if (state->shared_page == NULL) {
hw_error("map shared IO page returned error %d handle=" XC_INTERFACE_FMT,
errno, xen_xc);
}
rc = xen_get_vmport_regs_pfn(xen_xc, xen_domid, &ioreq_pfn);
if (!rc) {
DPRINTF("shared vmport page at pfn %lx\n", ioreq_pfn);
state->shared_vmport_page =
xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,
PROT_READ|PROT_WRITE, ioreq_pfn);
if (state->shared_vmport_page == NULL) {
hw_error("map shared vmport IO page returned error %d handle="
XC_INTERFACE_FMT, errno, xen_xc);
}
} else if (rc != -ENOSYS) {
hw_error("get vmport regs pfn returned error %d, rc=%d", errno, rc);
}
xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_PFN, &ioreq_pfn);
DPRINTF("buffered io page at pfn %lx\n", ioreq_pfn);
state->buffered_io_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,
PROT_READ|PROT_WRITE, ioreq_pfn);
if (state->buffered_io_page == NULL) {
hw_error("map buffered IO page returned error %d", errno);
}
state->cpu_by_vcpu_id = g_malloc0(max_cpus * sizeof(CPUState *));
state->ioreq_local_port = g_malloc0(max_cpus * sizeof (evtchn_port_t));
for (i = 0; i < max_cpus; i++) {
rc = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid,
xen_vcpu_eport(state->shared_page, i));
if (rc == -1) {
fprintf(stderr, "bind interdomain ioctl error %d\n", errno);
return -1;
}
state->ioreq_local_port[i] = rc;
}
rc = xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_EVTCHN,
&bufioreq_evtchn);
if (rc < 0) {
fprintf(stderr, "failed to get HVM_PARAM_BUFIOREQ_EVTCHN\n");
return -1;
}
rc = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid,
(uint32_t)bufioreq_evtchn);
if (rc == -1) {
fprintf(stderr, "bind interdomain ioctl error %d\n", errno);
return -1;
}
state->bufioreq_local_port = rc;
xen_map_cache_init(xen_phys_offset_to_gaddr, state);
xen_ram_init(below_4g_mem_size, above_4g_mem_size, ram_size, ram_memory);
qemu_add_vm_change_state_handler(xen_hvm_change_state_handler, state);
state->memory_listener = xen_memory_listener;
QLIST_INIT(&state->physmap);
memory_listener_register(&state->memory_listener, &address_space_memory);
state->log_for_dirtybit = NULL;
if (xen_be_init() != 0) {
fprintf(stderr, "%s: xen backend core setup failed\n", __FUNCTION__);
return -1;
}
xen_be_register("console", &xen_console_ops);
xen_be_register("vkbd", &xen_kbdmouse_ops);
xen_be_register("qdisk", &xen_blkdev_ops);
xen_read_physmap(state);
return 0;
}
| {
"code": [
" unsigned long ioreq_pfn;",
" unsigned long bufioreq_evtchn;",
" xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_IOREQ_PFN, &ioreq_pfn);",
" xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_PFN, &ioreq_pfn);",
" DPRINTF(\"buffered io page at pfn %lx\\n\", ioreq_pfn);",
" state->buffered_io_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,",
" PROT_READ|PROT_WRITE, ioreq_pfn);",
" fprintf(stderr, \"bind interdomain ioctl error %d\\n\", errno);",
" rc = xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_EVTCHN,",
" &bufioreq_evtchn);",
" if (rc < 0) {",
" fprintf(stderr, \"failed to get HVM_PARAM_BUFIOREQ_EVTCHN\\n\");",
" return -1;",
" (uint32_t)bufioreq_evtchn);",
" fprintf(stderr, \"bind interdomain ioctl error %d\\n\", errno);"
],
"line_no": [
9,
11,
63,
109,
111,
113,
115,
145,
157,
159,
161,
163,
27,
171,
175
]
} | int FUNC_0(ram_addr_t *VAR_0, ram_addr_t *VAR_1,
MemoryRegion **VAR_2)
{
int VAR_3, VAR_4;
unsigned long VAR_5;
unsigned long VAR_6;
XenIOState *state;
state = g_malloc0(sizeof (XenIOState));
state->xce_handle = xen_xc_evtchn_open(NULL, 0);
if (state->xce_handle == XC_HANDLER_INITIAL_VALUE) {
perror("xen: event channel open");
return -1;
}
state->xenstore = xs_daemon_open();
if (state->xenstore == NULL) {
perror("xen: xenstore open");
return -1;
}
state->exit.notify = xen_exit_notifier;
qemu_add_exit_notifier(&state->exit);
state->suspend.notify = xen_suspend_notifier;
qemu_register_suspend_notifier(&state->suspend);
state->wakeup.notify = xen_wakeup_notifier;
qemu_register_wakeup_notifier(&state->wakeup);
xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_IOREQ_PFN, &VAR_5);
DPRINTF("shared page at pfn %lx\n", VAR_5);
state->shared_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,
PROT_READ|PROT_WRITE, VAR_5);
if (state->shared_page == NULL) {
hw_error("map shared IO page returned error %d handle=" XC_INTERFACE_FMT,
errno, xen_xc);
}
VAR_4 = xen_get_vmport_regs_pfn(xen_xc, xen_domid, &VAR_5);
if (!VAR_4) {
DPRINTF("shared vmport page at pfn %lx\n", VAR_5);
state->shared_vmport_page =
xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,
PROT_READ|PROT_WRITE, VAR_5);
if (state->shared_vmport_page == NULL) {
hw_error("map shared vmport IO page returned error %d handle="
XC_INTERFACE_FMT, errno, xen_xc);
}
} else if (VAR_4 != -ENOSYS) {
hw_error("get vmport regs pfn returned error %d, VAR_4=%d", errno, VAR_4);
}
xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_PFN, &VAR_5);
DPRINTF("buffered io page at pfn %lx\n", VAR_5);
state->buffered_io_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,
PROT_READ|PROT_WRITE, VAR_5);
if (state->buffered_io_page == NULL) {
hw_error("map buffered IO page returned error %d", errno);
}
state->cpu_by_vcpu_id = g_malloc0(max_cpus * sizeof(CPUState *));
state->ioreq_local_port = g_malloc0(max_cpus * sizeof (evtchn_port_t));
for (VAR_3 = 0; VAR_3 < max_cpus; VAR_3++) {
VAR_4 = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid,
xen_vcpu_eport(state->shared_page, VAR_3));
if (VAR_4 == -1) {
fprintf(stderr, "bind interdomain ioctl error %d\n", errno);
return -1;
}
state->ioreq_local_port[VAR_3] = VAR_4;
}
VAR_4 = xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_EVTCHN,
&VAR_6);
if (VAR_4 < 0) {
fprintf(stderr, "failed to get HVM_PARAM_BUFIOREQ_EVTCHN\n");
return -1;
}
VAR_4 = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid,
(uint32_t)VAR_6);
if (VAR_4 == -1) {
fprintf(stderr, "bind interdomain ioctl error %d\n", errno);
return -1;
}
state->bufioreq_local_port = VAR_4;
xen_map_cache_init(xen_phys_offset_to_gaddr, state);
xen_ram_init(VAR_0, VAR_1, ram_size, VAR_2);
qemu_add_vm_change_state_handler(xen_hvm_change_state_handler, state);
state->memory_listener = xen_memory_listener;
QLIST_INIT(&state->physmap);
memory_listener_register(&state->memory_listener, &address_space_memory);
state->log_for_dirtybit = NULL;
if (xen_be_init() != 0) {
fprintf(stderr, "%s: xen backend core setup failed\n", __FUNCTION__);
return -1;
}
xen_be_register("console", &xen_console_ops);
xen_be_register("vkbd", &xen_kbdmouse_ops);
xen_be_register("qdisk", &xen_blkdev_ops);
xen_read_physmap(state);
return 0;
}
| [
"int FUNC_0(ram_addr_t *VAR_0, ram_addr_t *VAR_1,\nMemoryRegion **VAR_2)\n{",
"int VAR_3, VAR_4;",
"unsigned long VAR_5;",
"unsigned long VAR_6;",
"XenIOState *state;",
"state = g_malloc0(sizeof (XenIOState));",
"state->xce_handle = xen_xc_evtchn_open(NULL, 0);",
"if (state->xce_handle == XC_HANDLER_INITIAL_VALUE) {",
"perror(\"xen: event channel open\");",
"return -1;",
"}",
"state->xenstore = xs_daemon_open();",
"if (state->xenstore == NULL) {",
"perror(\"xen: xenstore open\");",
"return -1;",
"}",
"state->exit.notify = xen_exit_notifier;",
"qemu_add_exit_notifier(&state->exit);",
"state->suspend.notify = xen_suspend_notifier;",
"qemu_register_suspend_notifier(&state->suspend);",
"state->wakeup.notify = xen_wakeup_notifier;",
"qemu_register_wakeup_notifier(&state->wakeup);",
"xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_IOREQ_PFN, &VAR_5);",
"DPRINTF(\"shared page at pfn %lx\\n\", VAR_5);",
"state->shared_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,\nPROT_READ|PROT_WRITE, VAR_5);",
"if (state->shared_page == NULL) {",
"hw_error(\"map shared IO page returned error %d handle=\" XC_INTERFACE_FMT,\nerrno, xen_xc);",
"}",
"VAR_4 = xen_get_vmport_regs_pfn(xen_xc, xen_domid, &VAR_5);",
"if (!VAR_4) {",
"DPRINTF(\"shared vmport page at pfn %lx\\n\", VAR_5);",
"state->shared_vmport_page =\nxc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,\nPROT_READ|PROT_WRITE, VAR_5);",
"if (state->shared_vmport_page == NULL) {",
"hw_error(\"map shared vmport IO page returned error %d handle=\"\nXC_INTERFACE_FMT, errno, xen_xc);",
"}",
"} else if (VAR_4 != -ENOSYS) {",
"hw_error(\"get vmport regs pfn returned error %d, VAR_4=%d\", errno, VAR_4);",
"}",
"xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_PFN, &VAR_5);",
"DPRINTF(\"buffered io page at pfn %lx\\n\", VAR_5);",
"state->buffered_io_page = xc_map_foreign_range(xen_xc, xen_domid, XC_PAGE_SIZE,\nPROT_READ|PROT_WRITE, VAR_5);",
"if (state->buffered_io_page == NULL) {",
"hw_error(\"map buffered IO page returned error %d\", errno);",
"}",
"state->cpu_by_vcpu_id = g_malloc0(max_cpus * sizeof(CPUState *));",
"state->ioreq_local_port = g_malloc0(max_cpus * sizeof (evtchn_port_t));",
"for (VAR_3 = 0; VAR_3 < max_cpus; VAR_3++) {",
"VAR_4 = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid,\nxen_vcpu_eport(state->shared_page, VAR_3));",
"if (VAR_4 == -1) {",
"fprintf(stderr, \"bind interdomain ioctl error %d\\n\", errno);",
"return -1;",
"}",
"state->ioreq_local_port[VAR_3] = VAR_4;",
"}",
"VAR_4 = xc_get_hvm_param(xen_xc, xen_domid, HVM_PARAM_BUFIOREQ_EVTCHN,\n&VAR_6);",
"if (VAR_4 < 0) {",
"fprintf(stderr, \"failed to get HVM_PARAM_BUFIOREQ_EVTCHN\\n\");",
"return -1;",
"}",
"VAR_4 = xc_evtchn_bind_interdomain(state->xce_handle, xen_domid,\n(uint32_t)VAR_6);",
"if (VAR_4 == -1) {",
"fprintf(stderr, \"bind interdomain ioctl error %d\\n\", errno);",
"return -1;",
"}",
"state->bufioreq_local_port = VAR_4;",
"xen_map_cache_init(xen_phys_offset_to_gaddr, state);",
"xen_ram_init(VAR_0, VAR_1, ram_size, VAR_2);",
"qemu_add_vm_change_state_handler(xen_hvm_change_state_handler, state);",
"state->memory_listener = xen_memory_listener;",
"QLIST_INIT(&state->physmap);",
"memory_listener_register(&state->memory_listener, &address_space_memory);",
"state->log_for_dirtybit = NULL;",
"if (xen_be_init() != 0) {",
"fprintf(stderr, \"%s: xen backend core setup failed\\n\", __FUNCTION__);",
"return -1;",
"}",
"xen_be_register(\"console\", &xen_console_ops);",
"xen_be_register(\"vkbd\", &xen_kbdmouse_ops);",
"xen_be_register(\"qdisk\", &xen_blkdev_ops);",
"xen_read_physmap(state);",
"return 0;",
"}"
]
| [
0,
0,
1,
1,
0,
0,
0,
0,
0,
1,
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,
1,
1,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
1,
1,
1,
0,
0,
1,
0,
1,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
21
],
[
23
],
[
25
],
[
27
],
[
29
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[
51
],
[
53
],
[
57
],
[
59
],
[
63
],
[
65
],
[
67,
69
],
[
71
],
[
73,
75
],
[
77
],
[
81
],
[
83
],
[
85
],
[
87,
89,
91
],
[
93
],
[
95,
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
109
],
[
111
],
[
113,
115
],
[
117
],
[
119
],
[
121
],
[
127
],
[
131
],
[
137
],
[
139,
141
],
[
143
],
[
145
],
[
147
],
[
149
],
[
151
],
[
153
],
[
157,
159
],
[
161
],
[
163
],
[
165
],
[
167
],
[
169,
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
181
],
[
187
],
[
189
],
[
193
],
[
197
],
[
199
],
[
201
],
[
203
],
[
209
],
[
211
],
[
213
],
[
215
],
[
217
],
[
219
],
[
221
],
[
223
],
[
227
],
[
229
]
]
|
17,057 | static void yop_paint_block(YopDecContext *s, int tag)
{
s->dstptr[0] = s->srcptr[0];
s->dstptr[1] = s->srcptr[paint_lut[tag][0]];
s->dstptr[s->frame.linesize[0]] = s->srcptr[paint_lut[tag][1]];
s->dstptr[s->frame.linesize[0] + 1] = s->srcptr[paint_lut[tag][2]];
// The number of src bytes consumed is in the last part of the lut entry.
s->srcptr += paint_lut[tag][3];
}
| true | FFmpeg | 8136f234445862c94d1c081606b2d1e3d44fccf3 | static void yop_paint_block(YopDecContext *s, int tag)
{
s->dstptr[0] = s->srcptr[0];
s->dstptr[1] = s->srcptr[paint_lut[tag][0]];
s->dstptr[s->frame.linesize[0]] = s->srcptr[paint_lut[tag][1]];
s->dstptr[s->frame.linesize[0] + 1] = s->srcptr[paint_lut[tag][2]];
s->srcptr += paint_lut[tag][3];
}
| {
"code": [
"static void yop_paint_block(YopDecContext *s, int tag)"
],
"line_no": [
1
]
} | static void FUNC_0(YopDecContext *VAR_0, int VAR_1)
{
VAR_0->dstptr[0] = VAR_0->srcptr[0];
VAR_0->dstptr[1] = VAR_0->srcptr[paint_lut[VAR_1][0]];
VAR_0->dstptr[VAR_0->frame.linesize[0]] = VAR_0->srcptr[paint_lut[VAR_1][1]];
VAR_0->dstptr[VAR_0->frame.linesize[0] + 1] = VAR_0->srcptr[paint_lut[VAR_1][2]];
VAR_0->srcptr += paint_lut[VAR_1][3];
}
| [
"static void FUNC_0(YopDecContext *VAR_0, int VAR_1)\n{",
"VAR_0->dstptr[0] = VAR_0->srcptr[0];",
"VAR_0->dstptr[1] = VAR_0->srcptr[paint_lut[VAR_1][0]];",
"VAR_0->dstptr[VAR_0->frame.linesize[0]] = VAR_0->srcptr[paint_lut[VAR_1][1]];",
"VAR_0->dstptr[VAR_0->frame.linesize[0] + 1] = VAR_0->srcptr[paint_lut[VAR_1][2]];",
"VAR_0->srcptr += paint_lut[VAR_1][3];",
"}"
]
| [
1,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
17
],
[
19
]
]
|
17,058 | av_cold int ff_rv34_decode_init(AVCodecContext *avctx)
{
RV34DecContext *r = avctx->priv_data;
MpegEncContext *s = &r->s;
int ret;
ff_MPV_decode_defaults(s);
s->avctx = avctx;
s->out_format = FMT_H263;
s->codec_id = avctx->codec_id;
s->width = avctx->width;
s->height = avctx->height;
r->s.avctx = avctx;
avctx->flags |= CODEC_FLAG_EMU_EDGE;
r->s.flags |= CODEC_FLAG_EMU_EDGE;
avctx->pix_fmt = AV_PIX_FMT_YUV420P;
avctx->has_b_frames = 1;
s->low_delay = 0;
if ((ret = ff_MPV_common_init(s)) < 0)
return ret;
ff_h264_pred_init(&r->h, AV_CODEC_ID_RV40, 8, 1);
#if CONFIG_RV30_DECODER
if (avctx->codec_id == AV_CODEC_ID_RV30)
ff_rv30dsp_init(&r->rdsp);
#endif
#if CONFIG_RV40_DECODER
if (avctx->codec_id == AV_CODEC_ID_RV40)
ff_rv40dsp_init(&r->rdsp);
#endif
if ((ret = rv34_decoder_alloc(r)) < 0)
return ret;
if(!intra_vlcs[0].cbppattern[0].bits)
rv34_init_tables();
avctx->internal->allocate_progress = 1;
return 0;
}
| true | FFmpeg | fdbd924b84e85ac5c80f01ee059ed5c81d3cc205 | av_cold int ff_rv34_decode_init(AVCodecContext *avctx)
{
RV34DecContext *r = avctx->priv_data;
MpegEncContext *s = &r->s;
int ret;
ff_MPV_decode_defaults(s);
s->avctx = avctx;
s->out_format = FMT_H263;
s->codec_id = avctx->codec_id;
s->width = avctx->width;
s->height = avctx->height;
r->s.avctx = avctx;
avctx->flags |= CODEC_FLAG_EMU_EDGE;
r->s.flags |= CODEC_FLAG_EMU_EDGE;
avctx->pix_fmt = AV_PIX_FMT_YUV420P;
avctx->has_b_frames = 1;
s->low_delay = 0;
if ((ret = ff_MPV_common_init(s)) < 0)
return ret;
ff_h264_pred_init(&r->h, AV_CODEC_ID_RV40, 8, 1);
#if CONFIG_RV30_DECODER
if (avctx->codec_id == AV_CODEC_ID_RV30)
ff_rv30dsp_init(&r->rdsp);
#endif
#if CONFIG_RV40_DECODER
if (avctx->codec_id == AV_CODEC_ID_RV40)
ff_rv40dsp_init(&r->rdsp);
#endif
if ((ret = rv34_decoder_alloc(r)) < 0)
return ret;
if(!intra_vlcs[0].cbppattern[0].bits)
rv34_init_tables();
avctx->internal->allocate_progress = 1;
return 0;
}
| {
"code": [
" if ((ret = rv34_decoder_alloc(r)) < 0)"
],
"line_no": [
71
]
} | av_cold int FUNC_0(AVCodecContext *avctx)
{
RV34DecContext *r = avctx->priv_data;
MpegEncContext *s = &r->s;
int VAR_0;
ff_MPV_decode_defaults(s);
s->avctx = avctx;
s->out_format = FMT_H263;
s->codec_id = avctx->codec_id;
s->width = avctx->width;
s->height = avctx->height;
r->s.avctx = avctx;
avctx->flags |= CODEC_FLAG_EMU_EDGE;
r->s.flags |= CODEC_FLAG_EMU_EDGE;
avctx->pix_fmt = AV_PIX_FMT_YUV420P;
avctx->has_b_frames = 1;
s->low_delay = 0;
if ((VAR_0 = ff_MPV_common_init(s)) < 0)
return VAR_0;
ff_h264_pred_init(&r->h, AV_CODEC_ID_RV40, 8, 1);
#if CONFIG_RV30_DECODER
if (avctx->codec_id == AV_CODEC_ID_RV30)
ff_rv30dsp_init(&r->rdsp);
#endif
#if CONFIG_RV40_DECODER
if (avctx->codec_id == AV_CODEC_ID_RV40)
ff_rv40dsp_init(&r->rdsp);
#endif
if ((VAR_0 = rv34_decoder_alloc(r)) < 0)
return VAR_0;
if(!intra_vlcs[0].cbppattern[0].bits)
rv34_init_tables();
avctx->internal->allocate_progress = 1;
return 0;
}
| [
"av_cold int FUNC_0(AVCodecContext *avctx)\n{",
"RV34DecContext *r = avctx->priv_data;",
"MpegEncContext *s = &r->s;",
"int VAR_0;",
"ff_MPV_decode_defaults(s);",
"s->avctx = avctx;",
"s->out_format = FMT_H263;",
"s->codec_id = avctx->codec_id;",
"s->width = avctx->width;",
"s->height = avctx->height;",
"r->s.avctx = avctx;",
"avctx->flags |= CODEC_FLAG_EMU_EDGE;",
"r->s.flags |= CODEC_FLAG_EMU_EDGE;",
"avctx->pix_fmt = AV_PIX_FMT_YUV420P;",
"avctx->has_b_frames = 1;",
"s->low_delay = 0;",
"if ((VAR_0 = ff_MPV_common_init(s)) < 0)\nreturn VAR_0;",
"ff_h264_pred_init(&r->h, AV_CODEC_ID_RV40, 8, 1);",
"#if CONFIG_RV30_DECODER\nif (avctx->codec_id == AV_CODEC_ID_RV30)\nff_rv30dsp_init(&r->rdsp);",
"#endif\n#if CONFIG_RV40_DECODER\nif (avctx->codec_id == AV_CODEC_ID_RV40)\nff_rv40dsp_init(&r->rdsp);",
"#endif\nif ((VAR_0 = rv34_decoder_alloc(r)) < 0)\nreturn VAR_0;",
"if(!intra_vlcs[0].cbppattern[0].bits)\nrv34_init_tables();",
"avctx->internal->allocate_progress = 1;",
"return 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
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43,
45
],
[
49
],
[
53,
55,
57
],
[
59,
61,
63,
65
],
[
67,
71,
73
],
[
77,
79
],
[
83
],
[
87
],
[
89
]
]
|
17,059 | static int flic_decode_frame_24BPP(AVCodecContext *avctx,
void *data, int *got_frame,
const uint8_t *buf, int buf_size)
{
FlicDecodeContext *s = avctx->priv_data;
GetByteContext g2;
int pixel_ptr;
unsigned char palette_idx1;
unsigned int frame_size;
int num_chunks;
unsigned int chunk_size;
int chunk_type;
int i, j, ret;
int lines;
int compressed_lines;
signed short line_packets;
int y_ptr;
int byte_run;
int pixel_skip;
int pixel_countdown;
unsigned char *pixels;
int pixel;
unsigned int pixel_limit;
bytestream2_init(&g2, buf, buf_size);
if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
return ret;
pixels = s->frame->data[0];
pixel_limit = s->avctx->height * s->frame->linesize[0];
frame_size = bytestream2_get_le32(&g2);
bytestream2_skip(&g2, 2); /* skip the magic number */
num_chunks = bytestream2_get_le16(&g2);
bytestream2_skip(&g2, 8); /* skip padding */
if (frame_size > buf_size)
frame_size = buf_size;
if (frame_size < 16)
frame_size -= 16;
/* iterate through the chunks */
while ((frame_size > 0) && (num_chunks > 0) &&
bytestream2_get_bytes_left(&g2) >= 4) {
int stream_ptr_after_chunk;
chunk_size = bytestream2_get_le32(&g2);
if (chunk_size > frame_size) {
av_log(avctx, AV_LOG_WARNING,
"Invalid chunk_size = %u > frame_size = %u\n", chunk_size, frame_size);
chunk_size = frame_size;
}
stream_ptr_after_chunk = bytestream2_tell(&g2) - 4 + chunk_size;
chunk_type = bytestream2_get_le16(&g2);
switch (chunk_type) {
case FLI_256_COLOR:
case FLI_COLOR:
/* For some reason, it seems that non-palettized flics do
* include one of these chunks in their first frame.
* Why I do not know, it seems rather extraneous. */
ff_dlog(avctx,
"Unexpected Palette chunk %d in non-palettized FLC\n",
chunk_type);
bytestream2_skip(&g2, chunk_size - 6);
break;
case FLI_DELTA:
case FLI_DTA_LC:
y_ptr = 0;
compressed_lines = bytestream2_get_le16(&g2);
while (compressed_lines > 0) {
if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk)
break;
line_packets = bytestream2_get_le16(&g2);
if (line_packets < 0) {
line_packets = -line_packets;
y_ptr += line_packets * s->frame->linesize[0];
} else {
compressed_lines--;
pixel_ptr = y_ptr;
CHECK_PIXEL_PTR(0);
pixel_countdown = s->avctx->width;
for (i = 0; i < line_packets; i++) {
/* account for the skip bytes */
if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk)
break;
pixel_skip = bytestream2_get_byte(&g2);
pixel_ptr += (pixel_skip*3); /* Pixel is 3 bytes wide */
pixel_countdown -= pixel_skip;
byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
if (byte_run < 0) {
byte_run = -byte_run;
pixel = bytestream2_get_le24(&g2);
CHECK_PIXEL_PTR(3 * byte_run);
for (j = 0; j < byte_run; j++, pixel_countdown -= 1) {
AV_WL24(&pixels[pixel_ptr], pixel);
pixel_ptr += 3;
}
} else {
if (bytestream2_tell(&g2) + 2*byte_run > stream_ptr_after_chunk)
break;
CHECK_PIXEL_PTR(2 * byte_run);
for (j = 0; j < byte_run; j++, pixel_countdown--) {
pixel = bytestream2_get_le24(&g2);
AV_WL24(&pixels[pixel_ptr], pixel);
pixel_ptr += 3;
}
}
}
y_ptr += s->frame->linesize[0];
}
}
break;
case FLI_LC:
av_log(avctx, AV_LOG_ERROR, "Unexpected FLI_LC chunk in non-palettized FLC\n");
bytestream2_skip(&g2, chunk_size - 6);
break;
case FLI_BLACK:
/* set the whole frame to 0x00 which is black for 24 bit mode. */
memset(pixels, 0x00,
s->frame->linesize[0] * s->avctx->height);
break;
case FLI_BRUN:
y_ptr = 0;
for (lines = 0; lines < s->avctx->height; lines++) {
pixel_ptr = y_ptr;
/* disregard the line packets; instead, iterate through all
* pixels on a row */
bytestream2_skip(&g2, 1);
pixel_countdown = (s->avctx->width * 3);
while (pixel_countdown > 0) {
if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk)
break;
byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
if (byte_run > 0) {
palette_idx1 = bytestream2_get_byte(&g2);
CHECK_PIXEL_PTR(byte_run);
for (j = 0; j < byte_run; j++) {
pixels[pixel_ptr++] = palette_idx1;
pixel_countdown--;
if (pixel_countdown < 0)
av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) (linea%d)\n",
pixel_countdown, lines);
}
} else { /* copy bytes if byte_run < 0 */
byte_run = -byte_run;
if (bytestream2_tell(&g2) + byte_run > stream_ptr_after_chunk)
break;
CHECK_PIXEL_PTR(byte_run);
for (j = 0; j < byte_run; j++) {
palette_idx1 = bytestream2_get_byte(&g2);
pixels[pixel_ptr++] = palette_idx1;
pixel_countdown--;
if (pixel_countdown < 0)
av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",
pixel_countdown, lines);
}
}
}
y_ptr += s->frame->linesize[0];
}
break;
case FLI_DTA_BRUN:
y_ptr = 0;
for (lines = 0; lines < s->avctx->height; lines++) {
pixel_ptr = y_ptr;
/* disregard the line packets; instead, iterate through all
* pixels on a row */
bytestream2_skip(&g2, 1);
pixel_countdown = s->avctx->width; /* Width is in pixels, not bytes */
while (pixel_countdown > 0) {
if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk)
break;
byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
if (byte_run > 0) {
pixel = bytestream2_get_le24(&g2);
CHECK_PIXEL_PTR(3 * byte_run);
for (j = 0; j < byte_run; j++) {
AV_WL24(pixels + pixel_ptr, pixel);
pixel_ptr += 3;
pixel_countdown--;
if (pixel_countdown < 0)
av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n",
pixel_countdown);
}
} else { /* copy pixels if byte_run < 0 */
byte_run = -byte_run;
if (bytestream2_tell(&g2) + 3 * byte_run > stream_ptr_after_chunk)
break;
CHECK_PIXEL_PTR(3 * byte_run);
for (j = 0; j < byte_run; j++) {
pixel = bytestream2_get_le24(&g2);
AV_WL24(pixels + pixel_ptr, pixel);
pixel_ptr += 3;
pixel_countdown--;
if (pixel_countdown < 0)
av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n",
pixel_countdown);
}
}
}
y_ptr += s->frame->linesize[0];
}
break;
case FLI_COPY:
case FLI_DTA_COPY:
/* copy the chunk (uncompressed frame) */
if (chunk_size - 6 > (unsigned int)(FFALIGN(s->avctx->width, 2) * s->avctx->height)*3) {
av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \
"bigger than image, skipping chunk\n", chunk_size - 6);
bytestream2_skip(&g2, chunk_size - 6);
} else {
for (y_ptr = 0; y_ptr < s->frame->linesize[0] * s->avctx->height;
y_ptr += s->frame->linesize[0]) {
pixel_countdown = s->avctx->width;
pixel_ptr = 0;
while (pixel_countdown > 0) {
pixel = bytestream2_get_le24(&g2);
AV_WL24(&pixels[y_ptr + pixel_ptr], pixel);
pixel_ptr += 3;
pixel_countdown--;
}
if (s->avctx->width & 1)
bytestream2_skip(&g2, 3);
}
}
break;
case FLI_MINI:
/* some sort of a thumbnail? disregard this chunk... */
bytestream2_skip(&g2, chunk_size - 6);
break;
default:
av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type);
break;
}
if (stream_ptr_after_chunk - bytestream2_tell(&g2) >= 0) {
bytestream2_skip(&g2, stream_ptr_after_chunk - bytestream2_tell(&g2));
} else {
av_log(avctx, AV_LOG_ERROR, "Chunk overread\n");
break;
}
frame_size -= chunk_size;
num_chunks--;
}
/* by the end of the chunk, the stream ptr should equal the frame
* size (minus 1, possibly); if it doesn't, issue a warning */
if ((bytestream2_get_bytes_left(&g2) != 0) && (bytestream2_get_bytes_left(&g2) != 1))
av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \
"and final chunk ptr = %d\n", buf_size, bytestream2_tell(&g2));
if ((ret = av_frame_ref(data, s->frame)) < 0)
return ret;
*got_frame = 1;
return buf_size;
} | true | FFmpeg | 90e8317b3b33dcb54ae01e419d85cbbfbd874963 | static int flic_decode_frame_24BPP(AVCodecContext *avctx,
void *data, int *got_frame,
const uint8_t *buf, int buf_size)
{
FlicDecodeContext *s = avctx->priv_data;
GetByteContext g2;
int pixel_ptr;
unsigned char palette_idx1;
unsigned int frame_size;
int num_chunks;
unsigned int chunk_size;
int chunk_type;
int i, j, ret;
int lines;
int compressed_lines;
signed short line_packets;
int y_ptr;
int byte_run;
int pixel_skip;
int pixel_countdown;
unsigned char *pixels;
int pixel;
unsigned int pixel_limit;
bytestream2_init(&g2, buf, buf_size);
if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
return ret;
pixels = s->frame->data[0];
pixel_limit = s->avctx->height * s->frame->linesize[0];
frame_size = bytestream2_get_le32(&g2);
bytestream2_skip(&g2, 2);
num_chunks = bytestream2_get_le16(&g2);
bytestream2_skip(&g2, 8);
if (frame_size > buf_size)
frame_size = buf_size;
if (frame_size < 16)
frame_size -= 16;
while ((frame_size > 0) && (num_chunks > 0) &&
bytestream2_get_bytes_left(&g2) >= 4) {
int stream_ptr_after_chunk;
chunk_size = bytestream2_get_le32(&g2);
if (chunk_size > frame_size) {
av_log(avctx, AV_LOG_WARNING,
"Invalid chunk_size = %u > frame_size = %u\n", chunk_size, frame_size);
chunk_size = frame_size;
}
stream_ptr_after_chunk = bytestream2_tell(&g2) - 4 + chunk_size;
chunk_type = bytestream2_get_le16(&g2);
switch (chunk_type) {
case FLI_256_COLOR:
case FLI_COLOR:
ff_dlog(avctx,
"Unexpected Palette chunk %d in non-palettized FLC\n",
chunk_type);
bytestream2_skip(&g2, chunk_size - 6);
break;
case FLI_DELTA:
case FLI_DTA_LC:
y_ptr = 0;
compressed_lines = bytestream2_get_le16(&g2);
while (compressed_lines > 0) {
if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk)
break;
line_packets = bytestream2_get_le16(&g2);
if (line_packets < 0) {
line_packets = -line_packets;
y_ptr += line_packets * s->frame->linesize[0];
} else {
compressed_lines--;
pixel_ptr = y_ptr;
CHECK_PIXEL_PTR(0);
pixel_countdown = s->avctx->width;
for (i = 0; i < line_packets; i++) {
if (bytestream2_tell(&g2) + 2 > stream_ptr_after_chunk)
break;
pixel_skip = bytestream2_get_byte(&g2);
pixel_ptr += (pixel_skip*3);
pixel_countdown -= pixel_skip;
byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
if (byte_run < 0) {
byte_run = -byte_run;
pixel = bytestream2_get_le24(&g2);
CHECK_PIXEL_PTR(3 * byte_run);
for (j = 0; j < byte_run; j++, pixel_countdown -= 1) {
AV_WL24(&pixels[pixel_ptr], pixel);
pixel_ptr += 3;
}
} else {
if (bytestream2_tell(&g2) + 2*byte_run > stream_ptr_after_chunk)
break;
CHECK_PIXEL_PTR(2 * byte_run);
for (j = 0; j < byte_run; j++, pixel_countdown--) {
pixel = bytestream2_get_le24(&g2);
AV_WL24(&pixels[pixel_ptr], pixel);
pixel_ptr += 3;
}
}
}
y_ptr += s->frame->linesize[0];
}
}
break;
case FLI_LC:
av_log(avctx, AV_LOG_ERROR, "Unexpected FLI_LC chunk in non-palettized FLC\n");
bytestream2_skip(&g2, chunk_size - 6);
break;
case FLI_BLACK:
memset(pixels, 0x00,
s->frame->linesize[0] * s->avctx->height);
break;
case FLI_BRUN:
y_ptr = 0;
for (lines = 0; lines < s->avctx->height; lines++) {
pixel_ptr = y_ptr;
bytestream2_skip(&g2, 1);
pixel_countdown = (s->avctx->width * 3);
while (pixel_countdown > 0) {
if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk)
break;
byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
if (byte_run > 0) {
palette_idx1 = bytestream2_get_byte(&g2);
CHECK_PIXEL_PTR(byte_run);
for (j = 0; j < byte_run; j++) {
pixels[pixel_ptr++] = palette_idx1;
pixel_countdown--;
if (pixel_countdown < 0)
av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) (linea%d)\n",
pixel_countdown, lines);
}
} else {
byte_run = -byte_run;
if (bytestream2_tell(&g2) + byte_run > stream_ptr_after_chunk)
break;
CHECK_PIXEL_PTR(byte_run);
for (j = 0; j < byte_run; j++) {
palette_idx1 = bytestream2_get_byte(&g2);
pixels[pixel_ptr++] = palette_idx1;
pixel_countdown--;
if (pixel_countdown < 0)
av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d) at line %d\n",
pixel_countdown, lines);
}
}
}
y_ptr += s->frame->linesize[0];
}
break;
case FLI_DTA_BRUN:
y_ptr = 0;
for (lines = 0; lines < s->avctx->height; lines++) {
pixel_ptr = y_ptr;
bytestream2_skip(&g2, 1);
pixel_countdown = s->avctx->width;
while (pixel_countdown > 0) {
if (bytestream2_tell(&g2) + 1 > stream_ptr_after_chunk)
break;
byte_run = sign_extend(bytestream2_get_byte(&g2), 8);
if (byte_run > 0) {
pixel = bytestream2_get_le24(&g2);
CHECK_PIXEL_PTR(3 * byte_run);
for (j = 0; j < byte_run; j++) {
AV_WL24(pixels + pixel_ptr, pixel);
pixel_ptr += 3;
pixel_countdown--;
if (pixel_countdown < 0)
av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n",
pixel_countdown);
}
} else {
byte_run = -byte_run;
if (bytestream2_tell(&g2) + 3 * byte_run > stream_ptr_after_chunk)
break;
CHECK_PIXEL_PTR(3 * byte_run);
for (j = 0; j < byte_run; j++) {
pixel = bytestream2_get_le24(&g2);
AV_WL24(pixels + pixel_ptr, pixel);
pixel_ptr += 3;
pixel_countdown--;
if (pixel_countdown < 0)
av_log(avctx, AV_LOG_ERROR, "pixel_countdown < 0 (%d)\n",
pixel_countdown);
}
}
}
y_ptr += s->frame->linesize[0];
}
break;
case FLI_COPY:
case FLI_DTA_COPY:
if (chunk_size - 6 > (unsigned int)(FFALIGN(s->avctx->width, 2) * s->avctx->height)*3) {
av_log(avctx, AV_LOG_ERROR, "In chunk FLI_COPY : source data (%d bytes) " \
"bigger than image, skipping chunk\n", chunk_size - 6);
bytestream2_skip(&g2, chunk_size - 6);
} else {
for (y_ptr = 0; y_ptr < s->frame->linesize[0] * s->avctx->height;
y_ptr += s->frame->linesize[0]) {
pixel_countdown = s->avctx->width;
pixel_ptr = 0;
while (pixel_countdown > 0) {
pixel = bytestream2_get_le24(&g2);
AV_WL24(&pixels[y_ptr + pixel_ptr], pixel);
pixel_ptr += 3;
pixel_countdown--;
}
if (s->avctx->width & 1)
bytestream2_skip(&g2, 3);
}
}
break;
case FLI_MINI:
bytestream2_skip(&g2, chunk_size - 6);
break;
default:
av_log(avctx, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", chunk_type);
break;
}
if (stream_ptr_after_chunk - bytestream2_tell(&g2) >= 0) {
bytestream2_skip(&g2, stream_ptr_after_chunk - bytestream2_tell(&g2));
} else {
av_log(avctx, AV_LOG_ERROR, "Chunk overread\n");
break;
}
frame_size -= chunk_size;
num_chunks--;
}
if ((bytestream2_get_bytes_left(&g2) != 0) && (bytestream2_get_bytes_left(&g2) != 1))
av_log(avctx, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \
"and final chunk ptr = %d\n", buf_size, bytestream2_tell(&g2));
if ((ret = av_frame_ref(data, s->frame)) < 0)
return ret;
*got_frame = 1;
return buf_size;
} | {
"code": [],
"line_no": []
} | static int FUNC_0(AVCodecContext *VAR_0,
void *VAR_1, int *VAR_2,
const uint8_t *VAR_3, int VAR_4)
{
FlicDecodeContext *s = VAR_0->priv_data;
GetByteContext g2;
int VAR_5;
unsigned char VAR_6;
unsigned int VAR_7;
int VAR_8;
unsigned int VAR_9;
int VAR_10;
int VAR_11, VAR_12, VAR_13;
int VAR_14;
int VAR_15;
signed short VAR_16;
int VAR_17;
int VAR_18;
int VAR_19;
int VAR_20;
unsigned char *VAR_21;
int VAR_22;
unsigned int VAR_23;
bytestream2_init(&g2, VAR_3, VAR_4);
if ((VAR_13 = ff_reget_buffer(VAR_0, s->frame)) < 0)
return VAR_13;
VAR_21 = s->frame->VAR_1[0];
VAR_23 = s->VAR_0->height * s->frame->linesize[0];
VAR_7 = bytestream2_get_le32(&g2);
bytestream2_skip(&g2, 2);
VAR_8 = bytestream2_get_le16(&g2);
bytestream2_skip(&g2, 8);
if (VAR_7 > VAR_4)
VAR_7 = VAR_4;
if (VAR_7 < 16)
VAR_7 -= 16;
while ((VAR_7 > 0) && (VAR_8 > 0) &&
bytestream2_get_bytes_left(&g2) >= 4) {
int VAR_24;
VAR_9 = bytestream2_get_le32(&g2);
if (VAR_9 > VAR_7) {
av_log(VAR_0, AV_LOG_WARNING,
"Invalid VAR_9 = %u > VAR_7 = %u\n", VAR_9, VAR_7);
VAR_9 = VAR_7;
}
VAR_24 = bytestream2_tell(&g2) - 4 + VAR_9;
VAR_10 = bytestream2_get_le16(&g2);
switch (VAR_10) {
case FLI_256_COLOR:
case FLI_COLOR:
ff_dlog(VAR_0,
"Unexpected Palette chunk %d in non-palettized FLC\n",
VAR_10);
bytestream2_skip(&g2, VAR_9 - 6);
break;
case FLI_DELTA:
case FLI_DTA_LC:
VAR_17 = 0;
VAR_15 = bytestream2_get_le16(&g2);
while (VAR_15 > 0) {
if (bytestream2_tell(&g2) + 2 > VAR_24)
break;
VAR_16 = bytestream2_get_le16(&g2);
if (VAR_16 < 0) {
VAR_16 = -VAR_16;
VAR_17 += VAR_16 * s->frame->linesize[0];
} else {
VAR_15--;
VAR_5 = VAR_17;
CHECK_PIXEL_PTR(0);
VAR_20 = s->VAR_0->width;
for (VAR_11 = 0; VAR_11 < VAR_16; VAR_11++) {
if (bytestream2_tell(&g2) + 2 > VAR_24)
break;
VAR_19 = bytestream2_get_byte(&g2);
VAR_5 += (VAR_19*3);
VAR_20 -= VAR_19;
VAR_18 = sign_extend(bytestream2_get_byte(&g2), 8);
if (VAR_18 < 0) {
VAR_18 = -VAR_18;
VAR_22 = bytestream2_get_le24(&g2);
CHECK_PIXEL_PTR(3 * VAR_18);
for (VAR_12 = 0; VAR_12 < VAR_18; VAR_12++, VAR_20 -= 1) {
AV_WL24(&VAR_21[VAR_5], VAR_22);
VAR_5 += 3;
}
} else {
if (bytestream2_tell(&g2) + 2*VAR_18 > VAR_24)
break;
CHECK_PIXEL_PTR(2 * VAR_18);
for (VAR_12 = 0; VAR_12 < VAR_18; VAR_12++, VAR_20--) {
VAR_22 = bytestream2_get_le24(&g2);
AV_WL24(&VAR_21[VAR_5], VAR_22);
VAR_5 += 3;
}
}
}
VAR_17 += s->frame->linesize[0];
}
}
break;
case FLI_LC:
av_log(VAR_0, AV_LOG_ERROR, "Unexpected FLI_LC chunk in non-palettized FLC\n");
bytestream2_skip(&g2, VAR_9 - 6);
break;
case FLI_BLACK:
memset(VAR_21, 0x00,
s->frame->linesize[0] * s->VAR_0->height);
break;
case FLI_BRUN:
VAR_17 = 0;
for (VAR_14 = 0; VAR_14 < s->VAR_0->height; VAR_14++) {
VAR_5 = VAR_17;
bytestream2_skip(&g2, 1);
VAR_20 = (s->VAR_0->width * 3);
while (VAR_20 > 0) {
if (bytestream2_tell(&g2) + 1 > VAR_24)
break;
VAR_18 = sign_extend(bytestream2_get_byte(&g2), 8);
if (VAR_18 > 0) {
VAR_6 = bytestream2_get_byte(&g2);
CHECK_PIXEL_PTR(VAR_18);
for (VAR_12 = 0; VAR_12 < VAR_18; VAR_12++) {
VAR_21[VAR_5++] = VAR_6;
VAR_20--;
if (VAR_20 < 0)
av_log(VAR_0, AV_LOG_ERROR, "VAR_20 < 0 (%d) (linea%d)\n",
VAR_20, VAR_14);
}
} else {
VAR_18 = -VAR_18;
if (bytestream2_tell(&g2) + VAR_18 > VAR_24)
break;
CHECK_PIXEL_PTR(VAR_18);
for (VAR_12 = 0; VAR_12 < VAR_18; VAR_12++) {
VAR_6 = bytestream2_get_byte(&g2);
VAR_21[VAR_5++] = VAR_6;
VAR_20--;
if (VAR_20 < 0)
av_log(VAR_0, AV_LOG_ERROR, "VAR_20 < 0 (%d) at line %d\n",
VAR_20, VAR_14);
}
}
}
VAR_17 += s->frame->linesize[0];
}
break;
case FLI_DTA_BRUN:
VAR_17 = 0;
for (VAR_14 = 0; VAR_14 < s->VAR_0->height; VAR_14++) {
VAR_5 = VAR_17;
bytestream2_skip(&g2, 1);
VAR_20 = s->VAR_0->width;
while (VAR_20 > 0) {
if (bytestream2_tell(&g2) + 1 > VAR_24)
break;
VAR_18 = sign_extend(bytestream2_get_byte(&g2), 8);
if (VAR_18 > 0) {
VAR_22 = bytestream2_get_le24(&g2);
CHECK_PIXEL_PTR(3 * VAR_18);
for (VAR_12 = 0; VAR_12 < VAR_18; VAR_12++) {
AV_WL24(VAR_21 + VAR_5, VAR_22);
VAR_5 += 3;
VAR_20--;
if (VAR_20 < 0)
av_log(VAR_0, AV_LOG_ERROR, "VAR_20 < 0 (%d)\n",
VAR_20);
}
} else {
VAR_18 = -VAR_18;
if (bytestream2_tell(&g2) + 3 * VAR_18 > VAR_24)
break;
CHECK_PIXEL_PTR(3 * VAR_18);
for (VAR_12 = 0; VAR_12 < VAR_18; VAR_12++) {
VAR_22 = bytestream2_get_le24(&g2);
AV_WL24(VAR_21 + VAR_5, VAR_22);
VAR_5 += 3;
VAR_20--;
if (VAR_20 < 0)
av_log(VAR_0, AV_LOG_ERROR, "VAR_20 < 0 (%d)\n",
VAR_20);
}
}
}
VAR_17 += s->frame->linesize[0];
}
break;
case FLI_COPY:
case FLI_DTA_COPY:
if (VAR_9 - 6 > (unsigned int)(FFALIGN(s->VAR_0->width, 2) * s->VAR_0->height)*3) {
av_log(VAR_0, AV_LOG_ERROR, "In chunk FLI_COPY : source VAR_1 (%d bytes) " \
"bigger than image, skipping chunk\n", VAR_9 - 6);
bytestream2_skip(&g2, VAR_9 - 6);
} else {
for (VAR_17 = 0; VAR_17 < s->frame->linesize[0] * s->VAR_0->height;
VAR_17 += s->frame->linesize[0]) {
VAR_20 = s->VAR_0->width;
VAR_5 = 0;
while (VAR_20 > 0) {
VAR_22 = bytestream2_get_le24(&g2);
AV_WL24(&VAR_21[VAR_17 + VAR_5], VAR_22);
VAR_5 += 3;
VAR_20--;
}
if (s->VAR_0->width & 1)
bytestream2_skip(&g2, 3);
}
}
break;
case FLI_MINI:
bytestream2_skip(&g2, VAR_9 - 6);
break;
default:
av_log(VAR_0, AV_LOG_ERROR, "Unrecognized chunk type: %d\n", VAR_10);
break;
}
if (VAR_24 - bytestream2_tell(&g2) >= 0) {
bytestream2_skip(&g2, VAR_24 - bytestream2_tell(&g2));
} else {
av_log(VAR_0, AV_LOG_ERROR, "Chunk overread\n");
break;
}
VAR_7 -= VAR_9;
VAR_8--;
}
if ((bytestream2_get_bytes_left(&g2) != 0) && (bytestream2_get_bytes_left(&g2) != 1))
av_log(VAR_0, AV_LOG_ERROR, "Processed FLI chunk where chunk size = %d " \
"and final chunk ptr = %d\n", VAR_4, bytestream2_tell(&g2));
if ((VAR_13 = av_frame_ref(VAR_1, s->frame)) < 0)
return VAR_13;
*VAR_2 = 1;
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{",
"FlicDecodeContext *s = VAR_0->priv_data;",
"GetByteContext g2;",
"int VAR_5;",
"unsigned char VAR_6;",
"unsigned int VAR_7;",
"int VAR_8;",
"unsigned int VAR_9;",
"int VAR_10;",
"int VAR_11, VAR_12, VAR_13;",
"int VAR_14;",
"int VAR_15;",
"signed short VAR_16;",
"int VAR_17;",
"int VAR_18;",
"int VAR_19;",
"int VAR_20;",
"unsigned char *VAR_21;",
"int VAR_22;",
"unsigned int VAR_23;",
"bytestream2_init(&g2, VAR_3, VAR_4);",
"if ((VAR_13 = ff_reget_buffer(VAR_0, s->frame)) < 0)\nreturn VAR_13;",
"VAR_21 = s->frame->VAR_1[0];",
"VAR_23 = s->VAR_0->height * s->frame->linesize[0];",
"VAR_7 = bytestream2_get_le32(&g2);",
"bytestream2_skip(&g2, 2);",
"VAR_8 = bytestream2_get_le16(&g2);",
"bytestream2_skip(&g2, 8);",
"if (VAR_7 > VAR_4)\nVAR_7 = VAR_4;",
"if (VAR_7 < 16)\nVAR_7 -= 16;",
"while ((VAR_7 > 0) && (VAR_8 > 0) &&\nbytestream2_get_bytes_left(&g2) >= 4) {",
"int VAR_24;",
"VAR_9 = bytestream2_get_le32(&g2);",
"if (VAR_9 > VAR_7) {",
"av_log(VAR_0, AV_LOG_WARNING,\n\"Invalid VAR_9 = %u > VAR_7 = %u\\n\", VAR_9, VAR_7);",
"VAR_9 = VAR_7;",
"}",
"VAR_24 = bytestream2_tell(&g2) - 4 + VAR_9;",
"VAR_10 = bytestream2_get_le16(&g2);",
"switch (VAR_10) {",
"case FLI_256_COLOR:\ncase FLI_COLOR:\nff_dlog(VAR_0,\n\"Unexpected Palette chunk %d in non-palettized FLC\\n\",\nVAR_10);",
"bytestream2_skip(&g2, VAR_9 - 6);",
"break;",
"case FLI_DELTA:\ncase FLI_DTA_LC:\nVAR_17 = 0;",
"VAR_15 = bytestream2_get_le16(&g2);",
"while (VAR_15 > 0) {",
"if (bytestream2_tell(&g2) + 2 > VAR_24)\nbreak;",
"VAR_16 = bytestream2_get_le16(&g2);",
"if (VAR_16 < 0) {",
"VAR_16 = -VAR_16;",
"VAR_17 += VAR_16 * s->frame->linesize[0];",
"} else {",
"VAR_15--;",
"VAR_5 = VAR_17;",
"CHECK_PIXEL_PTR(0);",
"VAR_20 = s->VAR_0->width;",
"for (VAR_11 = 0; VAR_11 < VAR_16; VAR_11++) {",
"if (bytestream2_tell(&g2) + 2 > VAR_24)\nbreak;",
"VAR_19 = bytestream2_get_byte(&g2);",
"VAR_5 += (VAR_19*3);",
"VAR_20 -= VAR_19;",
"VAR_18 = sign_extend(bytestream2_get_byte(&g2), 8);",
"if (VAR_18 < 0) {",
"VAR_18 = -VAR_18;",
"VAR_22 = bytestream2_get_le24(&g2);",
"CHECK_PIXEL_PTR(3 * VAR_18);",
"for (VAR_12 = 0; VAR_12 < VAR_18; VAR_12++, VAR_20 -= 1) {",
"AV_WL24(&VAR_21[VAR_5], VAR_22);",
"VAR_5 += 3;",
"}",
"} else {",
"if (bytestream2_tell(&g2) + 2*VAR_18 > VAR_24)\nbreak;",
"CHECK_PIXEL_PTR(2 * VAR_18);",
"for (VAR_12 = 0; VAR_12 < VAR_18; VAR_12++, VAR_20--) {",
"VAR_22 = bytestream2_get_le24(&g2);",
"AV_WL24(&VAR_21[VAR_5], VAR_22);",
"VAR_5 += 3;",
"}",
"}",
"}",
"VAR_17 += s->frame->linesize[0];",
"}",
"}",
"break;",
"case FLI_LC:\nav_log(VAR_0, AV_LOG_ERROR, \"Unexpected FLI_LC chunk in non-palettized FLC\\n\");",
"bytestream2_skip(&g2, VAR_9 - 6);",
"break;",
"case FLI_BLACK:\nmemset(VAR_21, 0x00,\ns->frame->linesize[0] * s->VAR_0->height);",
"break;",
"case FLI_BRUN:\nVAR_17 = 0;",
"for (VAR_14 = 0; VAR_14 < s->VAR_0->height; VAR_14++) {",
"VAR_5 = VAR_17;",
"bytestream2_skip(&g2, 1);",
"VAR_20 = (s->VAR_0->width * 3);",
"while (VAR_20 > 0) {",
"if (bytestream2_tell(&g2) + 1 > VAR_24)\nbreak;",
"VAR_18 = sign_extend(bytestream2_get_byte(&g2), 8);",
"if (VAR_18 > 0) {",
"VAR_6 = bytestream2_get_byte(&g2);",
"CHECK_PIXEL_PTR(VAR_18);",
"for (VAR_12 = 0; VAR_12 < VAR_18; VAR_12++) {",
"VAR_21[VAR_5++] = VAR_6;",
"VAR_20--;",
"if (VAR_20 < 0)\nav_log(VAR_0, AV_LOG_ERROR, \"VAR_20 < 0 (%d) (linea%d)\\n\",\nVAR_20, VAR_14);",
"}",
"} else {",
"VAR_18 = -VAR_18;",
"if (bytestream2_tell(&g2) + VAR_18 > VAR_24)\nbreak;",
"CHECK_PIXEL_PTR(VAR_18);",
"for (VAR_12 = 0; VAR_12 < VAR_18; VAR_12++) {",
"VAR_6 = bytestream2_get_byte(&g2);",
"VAR_21[VAR_5++] = VAR_6;",
"VAR_20--;",
"if (VAR_20 < 0)\nav_log(VAR_0, AV_LOG_ERROR, \"VAR_20 < 0 (%d) at line %d\\n\",\nVAR_20, VAR_14);",
"}",
"}",
"}",
"VAR_17 += s->frame->linesize[0];",
"}",
"break;",
"case FLI_DTA_BRUN:\nVAR_17 = 0;",
"for (VAR_14 = 0; VAR_14 < s->VAR_0->height; VAR_14++) {",
"VAR_5 = VAR_17;",
"bytestream2_skip(&g2, 1);",
"VAR_20 = s->VAR_0->width;",
"while (VAR_20 > 0) {",
"if (bytestream2_tell(&g2) + 1 > VAR_24)\nbreak;",
"VAR_18 = sign_extend(bytestream2_get_byte(&g2), 8);",
"if (VAR_18 > 0) {",
"VAR_22 = bytestream2_get_le24(&g2);",
"CHECK_PIXEL_PTR(3 * VAR_18);",
"for (VAR_12 = 0; VAR_12 < VAR_18; VAR_12++) {",
"AV_WL24(VAR_21 + VAR_5, VAR_22);",
"VAR_5 += 3;",
"VAR_20--;",
"if (VAR_20 < 0)\nav_log(VAR_0, AV_LOG_ERROR, \"VAR_20 < 0 (%d)\\n\",\nVAR_20);",
"}",
"} else {",
"VAR_18 = -VAR_18;",
"if (bytestream2_tell(&g2) + 3 * VAR_18 > VAR_24)\nbreak;",
"CHECK_PIXEL_PTR(3 * VAR_18);",
"for (VAR_12 = 0; VAR_12 < VAR_18; VAR_12++) {",
"VAR_22 = bytestream2_get_le24(&g2);",
"AV_WL24(VAR_21 + VAR_5, VAR_22);",
"VAR_5 += 3;",
"VAR_20--;",
"if (VAR_20 < 0)\nav_log(VAR_0, AV_LOG_ERROR, \"VAR_20 < 0 (%d)\\n\",\nVAR_20);",
"}",
"}",
"}",
"VAR_17 += s->frame->linesize[0];",
"}",
"break;",
"case FLI_COPY:\ncase FLI_DTA_COPY:\nif (VAR_9 - 6 > (unsigned int)(FFALIGN(s->VAR_0->width, 2) * s->VAR_0->height)*3) {",
"av_log(VAR_0, AV_LOG_ERROR, \"In chunk FLI_COPY : source VAR_1 (%d bytes) \" \\\n\"bigger than image, skipping chunk\\n\", VAR_9 - 6);",
"bytestream2_skip(&g2, VAR_9 - 6);",
"} else {",
"for (VAR_17 = 0; VAR_17 < s->frame->linesize[0] * s->VAR_0->height;",
"VAR_17 += s->frame->linesize[0]) {",
"VAR_20 = s->VAR_0->width;",
"VAR_5 = 0;",
"while (VAR_20 > 0) {",
"VAR_22 = bytestream2_get_le24(&g2);",
"AV_WL24(&VAR_21[VAR_17 + VAR_5], VAR_22);",
"VAR_5 += 3;",
"VAR_20--;",
"}",
"if (s->VAR_0->width & 1)\nbytestream2_skip(&g2, 3);",
"}",
"}",
"break;",
"case FLI_MINI:\nbytestream2_skip(&g2, VAR_9 - 6);",
"break;",
"default:\nav_log(VAR_0, AV_LOG_ERROR, \"Unrecognized chunk type: %d\\n\", VAR_10);",
"break;",
"}",
"if (VAR_24 - bytestream2_tell(&g2) >= 0) {",
"bytestream2_skip(&g2, VAR_24 - bytestream2_tell(&g2));",
"} else {",
"av_log(VAR_0, AV_LOG_ERROR, \"Chunk overread\\n\");",
"break;",
"}",
"VAR_7 -= VAR_9;",
"VAR_8--;",
"}",
"if ((bytestream2_get_bytes_left(&g2) != 0) && (bytestream2_get_bytes_left(&g2) != 1))\nav_log(VAR_0, AV_LOG_ERROR, \"Processed FLI chunk where chunk size = %d \" \\\n\"and final chunk ptr = %d\\n\", VAR_4, bytestream2_tell(&g2));",
"if ((VAR_13 = av_frame_ref(VAR_1, s->frame)) < 0)\nreturn VAR_13;",
"*VAR_2 = 1;",
"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,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5,
7
],
[
9
],
[
13
],
[
15
],
[
17
],
[
21
],
[
23
],
[
27
],
[
29
],
[
33
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
59
],
[
63,
65
],
[
69
],
[
71
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83,
85
],
[
89,
92
],
[
98,
100
],
[
102
],
[
104
],
[
106
],
[
108,
110
],
[
112
],
[
114
],
[
116
],
[
120
],
[
126
],
[
128,
130,
138,
140,
142
],
[
144
],
[
146
],
[
150,
152,
154
],
[
156
],
[
158
],
[
160,
162
],
[
166
],
[
168
],
[
170
],
[
174
],
[
176
],
[
178
],
[
180
],
[
182
],
[
184
],
[
186
],
[
190,
192
],
[
194
],
[
196
],
[
198
],
[
200
],
[
202
],
[
204
],
[
206
],
[
208
],
[
210
],
[
212
],
[
214
],
[
216
],
[
218
],
[
220,
222
],
[
224
],
[
226
],
[
228
],
[
230
],
[
232
],
[
234
],
[
236
],
[
238
],
[
242
],
[
244
],
[
246
],
[
248
],
[
252,
254
],
[
256
],
[
258
],
[
262,
266,
268
],
[
270
],
[
274,
276
],
[
278
],
[
280
],
[
286
],
[
288
],
[
292
],
[
294,
296
],
[
298
],
[
300
],
[
302
],
[
304
],
[
306
],
[
308
],
[
310
],
[
312,
314,
316
],
[
318
],
[
320
],
[
322
],
[
324,
326
],
[
328
],
[
330
],
[
332
],
[
334
],
[
336
],
[
338,
340,
342
],
[
344
],
[
346
],
[
348
],
[
352
],
[
354
],
[
356
],
[
360,
362
],
[
364
],
[
366
],
[
372
],
[
374
],
[
378
],
[
380,
382
],
[
384
],
[
386
],
[
388
],
[
390
],
[
392
],
[
394
],
[
396
],
[
398
],
[
400,
402,
404
],
[
406
],
[
408
],
[
410
],
[
412,
414
],
[
416
],
[
418
],
[
420
],
[
422
],
[
424
],
[
426
],
[
428,
430,
432
],
[
434
],
[
436
],
[
438
],
[
442
],
[
444
],
[
446
],
[
450,
452,
456
],
[
458,
460
],
[
462
],
[
464
],
[
466
],
[
468
],
[
472
],
[
474
],
[
476
],
[
478
],
[
480
],
[
482
],
[
484
],
[
486
],
[
488,
490
],
[
492
],
[
494
],
[
496
],
[
500,
504
],
[
506
],
[
510,
512
],
[
514
],
[
516
],
[
520
],
[
522
],
[
524
],
[
526
],
[
528
],
[
530
],
[
534
],
[
536
],
[
538
],
[
546,
548,
550
],
[
554,
556
],
[
560
],
[
564
],
[
566
]
]
|
17,060 | static int h264_mp4toannexb_filter(AVBitStreamFilterContext *bsfc,
AVCodecContext *avctx, const char *args,
uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size,
int keyframe) {
H264BSFContext *ctx = bsfc->priv_data;
uint8_t unit_type;
int32_t nal_size;
uint32_t cumul_size = 0;
const uint8_t *buf_end = buf + buf_size;
/* nothing to filter */
if (!avctx->extradata || avctx->extradata_size < 6) {
*poutbuf = (uint8_t*) buf;
*poutbuf_size = buf_size;
return 0;
}
/* retrieve sps and pps NAL units from extradata */
if (!ctx->extradata_parsed) {
uint16_t unit_size;
uint64_t total_size = 0;
uint8_t *out = NULL, unit_nb, sps_done = 0;
const uint8_t *extradata = avctx->extradata+4;
static const uint8_t nalu_header[4] = {0, 0, 0, 1};
/* retrieve length coded size */
ctx->length_size = (*extradata++ & 0x3) + 1;
if (ctx->length_size == 3)
return AVERROR(EINVAL);
/* retrieve sps and pps unit(s) */
unit_nb = *extradata++ & 0x1f; /* number of sps unit(s) */
if (!unit_nb) {
unit_nb = *extradata++; /* number of pps unit(s) */
sps_done++;
}
while (unit_nb--) {
void *tmp;
unit_size = AV_RB16(extradata);
total_size += unit_size+4;
if (total_size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE ||
extradata+2+unit_size > avctx->extradata+avctx->extradata_size) {
av_free(out);
return AVERROR(EINVAL);
}
tmp = av_realloc(out, total_size + FF_INPUT_BUFFER_PADDING_SIZE);
if (!tmp) {
av_free(out);
return AVERROR(ENOMEM);
}
out = tmp;
memcpy(out+total_size-unit_size-4, nalu_header, 4);
memcpy(out+total_size-unit_size, extradata+2, unit_size);
extradata += 2+unit_size;
if (!unit_nb && !sps_done++)
unit_nb = *extradata++; /* number of pps unit(s) */
}
memset(out + total_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
av_free(avctx->extradata);
avctx->extradata = out;
avctx->extradata_size = total_size;
ctx->first_idr = 1;
ctx->extradata_parsed = 1;
}
*poutbuf_size = 0;
*poutbuf = NULL;
do {
if (buf + ctx->length_size > buf_end)
goto fail;
if (ctx->length_size == 1) {
nal_size = buf[0];
} else if (ctx->length_size == 2) {
nal_size = AV_RB16(buf);
} else
nal_size = AV_RB32(buf);
buf += ctx->length_size;
unit_type = *buf & 0x1f;
if (buf + nal_size > buf_end || nal_size < 0)
goto fail;
/* prepend only to the first type 5 NAL unit of an IDR picture */
if (ctx->first_idr && unit_type == 5) {
if (alloc_and_copy(poutbuf, poutbuf_size,
avctx->extradata, avctx->extradata_size,
buf, nal_size) < 0)
goto fail;
ctx->first_idr = 0;
} else {
if (alloc_and_copy(poutbuf, poutbuf_size,
NULL, 0,
buf, nal_size) < 0)
goto fail;
if (!ctx->first_idr && unit_type == 1)
ctx->first_idr = 1;
}
buf += nal_size;
cumul_size += nal_size + ctx->length_size;
} while (cumul_size < buf_size);
return 1;
fail:
av_freep(poutbuf);
*poutbuf_size = 0;
return AVERROR(EINVAL);
}
| true | FFmpeg | 02dd3666c2944a3db44ba13916ba40dbdd41f9b1 | static int h264_mp4toannexb_filter(AVBitStreamFilterContext *bsfc,
AVCodecContext *avctx, const char *args,
uint8_t **poutbuf, int *poutbuf_size,
const uint8_t *buf, int buf_size,
int keyframe) {
H264BSFContext *ctx = bsfc->priv_data;
uint8_t unit_type;
int32_t nal_size;
uint32_t cumul_size = 0;
const uint8_t *buf_end = buf + buf_size;
if (!avctx->extradata || avctx->extradata_size < 6) {
*poutbuf = (uint8_t*) buf;
*poutbuf_size = buf_size;
return 0;
}
if (!ctx->extradata_parsed) {
uint16_t unit_size;
uint64_t total_size = 0;
uint8_t *out = NULL, unit_nb, sps_done = 0;
const uint8_t *extradata = avctx->extradata+4;
static const uint8_t nalu_header[4] = {0, 0, 0, 1};
ctx->length_size = (*extradata++ & 0x3) + 1;
if (ctx->length_size == 3)
return AVERROR(EINVAL);
unit_nb = *extradata++ & 0x1f;
if (!unit_nb) {
unit_nb = *extradata++;
sps_done++;
}
while (unit_nb--) {
void *tmp;
unit_size = AV_RB16(extradata);
total_size += unit_size+4;
if (total_size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE ||
extradata+2+unit_size > avctx->extradata+avctx->extradata_size) {
av_free(out);
return AVERROR(EINVAL);
}
tmp = av_realloc(out, total_size + FF_INPUT_BUFFER_PADDING_SIZE);
if (!tmp) {
av_free(out);
return AVERROR(ENOMEM);
}
out = tmp;
memcpy(out+total_size-unit_size-4, nalu_header, 4);
memcpy(out+total_size-unit_size, extradata+2, unit_size);
extradata += 2+unit_size;
if (!unit_nb && !sps_done++)
unit_nb = *extradata++;
}
memset(out + total_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
av_free(avctx->extradata);
avctx->extradata = out;
avctx->extradata_size = total_size;
ctx->first_idr = 1;
ctx->extradata_parsed = 1;
}
*poutbuf_size = 0;
*poutbuf = NULL;
do {
if (buf + ctx->length_size > buf_end)
goto fail;
if (ctx->length_size == 1) {
nal_size = buf[0];
} else if (ctx->length_size == 2) {
nal_size = AV_RB16(buf);
} else
nal_size = AV_RB32(buf);
buf += ctx->length_size;
unit_type = *buf & 0x1f;
if (buf + nal_size > buf_end || nal_size < 0)
goto fail;
if (ctx->first_idr && unit_type == 5) {
if (alloc_and_copy(poutbuf, poutbuf_size,
avctx->extradata, avctx->extradata_size,
buf, nal_size) < 0)
goto fail;
ctx->first_idr = 0;
} else {
if (alloc_and_copy(poutbuf, poutbuf_size,
NULL, 0,
buf, nal_size) < 0)
goto fail;
if (!ctx->first_idr && unit_type == 1)
ctx->first_idr = 1;
}
buf += nal_size;
cumul_size += nal_size + ctx->length_size;
} while (cumul_size < buf_size);
return 1;
fail:
av_freep(poutbuf);
*poutbuf_size = 0;
return AVERROR(EINVAL);
}
| {
"code": [
" uint8_t *out = NULL, unit_nb, sps_done = 0;",
" memset(out + total_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);"
],
"line_no": [
45,
123
]
} | 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) {
H264BSFContext *ctx = VAR_0->priv_data;
uint8_t unit_type;
int32_t nal_size;
uint32_t cumul_size = 0;
const uint8_t *VAR_8 = VAR_5 + VAR_6;
if (!VAR_1->VAR_9 || VAR_1->extradata_size < 6) {
*VAR_3 = (uint8_t*) VAR_5;
*VAR_4 = VAR_6;
return 0;
}
if (!ctx->extradata_parsed) {
uint16_t unit_size;
uint64_t total_size = 0;
uint8_t *out = NULL, unit_nb, sps_done = 0;
const uint8_t *VAR_9 = VAR_1->VAR_9+4;
static const uint8_t VAR_10[4] = {0, 0, 0, 1};
ctx->length_size = (*VAR_9++ & 0x3) + 1;
if (ctx->length_size == 3)
return AVERROR(EINVAL);
unit_nb = *VAR_9++ & 0x1f;
if (!unit_nb) {
unit_nb = *VAR_9++;
sps_done++;
}
while (unit_nb--) {
void *VAR_11;
unit_size = AV_RB16(VAR_9);
total_size += unit_size+4;
if (total_size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE ||
VAR_9+2+unit_size > VAR_1->VAR_9+VAR_1->extradata_size) {
av_free(out);
return AVERROR(EINVAL);
}
VAR_11 = av_realloc(out, total_size + FF_INPUT_BUFFER_PADDING_SIZE);
if (!VAR_11) {
av_free(out);
return AVERROR(ENOMEM);
}
out = VAR_11;
memcpy(out+total_size-unit_size-4, VAR_10, 4);
memcpy(out+total_size-unit_size, VAR_9+2, unit_size);
VAR_9 += 2+unit_size;
if (!unit_nb && !sps_done++)
unit_nb = *VAR_9++;
}
memset(out + total_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
av_free(VAR_1->VAR_9);
VAR_1->VAR_9 = out;
VAR_1->extradata_size = total_size;
ctx->first_idr = 1;
ctx->extradata_parsed = 1;
}
*VAR_4 = 0;
*VAR_3 = NULL;
do {
if (VAR_5 + ctx->length_size > VAR_8)
goto fail;
if (ctx->length_size == 1) {
nal_size = VAR_5[0];
} else if (ctx->length_size == 2) {
nal_size = AV_RB16(VAR_5);
} else
nal_size = AV_RB32(VAR_5);
VAR_5 += ctx->length_size;
unit_type = *VAR_5 & 0x1f;
if (VAR_5 + nal_size > VAR_8 || nal_size < 0)
goto fail;
if (ctx->first_idr && unit_type == 5) {
if (alloc_and_copy(VAR_3, VAR_4,
VAR_1->VAR_9, VAR_1->extradata_size,
VAR_5, nal_size) < 0)
goto fail;
ctx->first_idr = 0;
} else {
if (alloc_and_copy(VAR_3, VAR_4,
NULL, 0,
VAR_5, nal_size) < 0)
goto fail;
if (!ctx->first_idr && unit_type == 1)
ctx->first_idr = 1;
}
VAR_5 += nal_size;
cumul_size += nal_size + ctx->length_size;
} while (cumul_size < VAR_6);
return 1;
fail:
av_freep(VAR_3);
*VAR_4 = 0;
return AVERROR(EINVAL);
}
| [
"static int FUNC_0(AVBitStreamFilterContext *VAR_0,\nAVCodecContext *VAR_1, const char *VAR_2,\nuint8_t **VAR_3, int *VAR_4,\nconst uint8_t *VAR_5, int VAR_6,\nint VAR_7) {",
"H264BSFContext *ctx = VAR_0->priv_data;",
"uint8_t unit_type;",
"int32_t nal_size;",
"uint32_t cumul_size = 0;",
"const uint8_t *VAR_8 = VAR_5 + VAR_6;",
"if (!VAR_1->VAR_9 || VAR_1->extradata_size < 6) {",
"*VAR_3 = (uint8_t*) VAR_5;",
"*VAR_4 = VAR_6;",
"return 0;",
"}",
"if (!ctx->extradata_parsed) {",
"uint16_t unit_size;",
"uint64_t total_size = 0;",
"uint8_t *out = NULL, unit_nb, sps_done = 0;",
"const uint8_t *VAR_9 = VAR_1->VAR_9+4;",
"static const uint8_t VAR_10[4] = {0, 0, 0, 1};",
"ctx->length_size = (*VAR_9++ & 0x3) + 1;",
"if (ctx->length_size == 3)\nreturn AVERROR(EINVAL);",
"unit_nb = *VAR_9++ & 0x1f;",
"if (!unit_nb) {",
"unit_nb = *VAR_9++;",
"sps_done++;",
"}",
"while (unit_nb--) {",
"void *VAR_11;",
"unit_size = AV_RB16(VAR_9);",
"total_size += unit_size+4;",
"if (total_size > INT_MAX - FF_INPUT_BUFFER_PADDING_SIZE ||\nVAR_9+2+unit_size > VAR_1->VAR_9+VAR_1->extradata_size) {",
"av_free(out);",
"return AVERROR(EINVAL);",
"}",
"VAR_11 = av_realloc(out, total_size + FF_INPUT_BUFFER_PADDING_SIZE);",
"if (!VAR_11) {",
"av_free(out);",
"return AVERROR(ENOMEM);",
"}",
"out = VAR_11;",
"memcpy(out+total_size-unit_size-4, VAR_10, 4);",
"memcpy(out+total_size-unit_size, VAR_9+2, unit_size);",
"VAR_9 += 2+unit_size;",
"if (!unit_nb && !sps_done++)\nunit_nb = *VAR_9++;",
"}",
"memset(out + total_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);",
"av_free(VAR_1->VAR_9);",
"VAR_1->VAR_9 = out;",
"VAR_1->extradata_size = total_size;",
"ctx->first_idr = 1;",
"ctx->extradata_parsed = 1;",
"}",
"*VAR_4 = 0;",
"*VAR_3 = NULL;",
"do {",
"if (VAR_5 + ctx->length_size > VAR_8)\ngoto fail;",
"if (ctx->length_size == 1) {",
"nal_size = VAR_5[0];",
"} else if (ctx->length_size == 2) {",
"nal_size = AV_RB16(VAR_5);",
"} else",
"nal_size = AV_RB32(VAR_5);",
"VAR_5 += ctx->length_size;",
"unit_type = *VAR_5 & 0x1f;",
"if (VAR_5 + nal_size > VAR_8 || nal_size < 0)\ngoto fail;",
"if (ctx->first_idr && unit_type == 5) {",
"if (alloc_and_copy(VAR_3, VAR_4,\nVAR_1->VAR_9, VAR_1->extradata_size,\nVAR_5, nal_size) < 0)\ngoto fail;",
"ctx->first_idr = 0;",
"} else {",
"if (alloc_and_copy(VAR_3, VAR_4,\nNULL, 0,\nVAR_5, nal_size) < 0)\ngoto fail;",
"if (!ctx->first_idr && unit_type == 1)\nctx->first_idr = 1;",
"}",
"VAR_5 += nal_size;",
"cumul_size += nal_size + ctx->length_size;",
"} while (cumul_size < VAR_6);",
"return 1;",
"fail:\nav_freep(VAR_3);",
"*VAR_4 = 0;",
"return AVERROR(EINVAL);",
"}"
]
| [
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,
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
]
| [
[
1,
3,
5,
7,
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
25
],
[
27
],
[
29
],
[
31
],
[
33
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
55
],
[
57,
59
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
81
],
[
83
],
[
85,
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
97
],
[
99
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
115,
117
],
[
119
],
[
123
],
[
125
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
139
],
[
141
],
[
143
],
[
145,
147
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
165
],
[
167
],
[
171,
173
],
[
179
],
[
181,
183,
185,
187
],
[
189
],
[
191
],
[
193,
195,
197,
199
],
[
201,
203
],
[
205
],
[
209
],
[
211
],
[
213
],
[
217
],
[
221,
223
],
[
225
],
[
227
],
[
229
]
]
|
17,061 | static void dchip_write(void *opaque, target_phys_addr_t addr,
uint64_t val, unsigned size)
{
/* Skip this. It's all related to DRAM timing and setup. */
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | static void dchip_write(void *opaque, target_phys_addr_t addr,
uint64_t val, unsigned size)
{
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,
uint64_t VAR_2, unsigned VAR_3)
{
}
| [
"static void FUNC_0(void *VAR_0, target_phys_addr_t VAR_1,\nuint64_t VAR_2, unsigned VAR_3)\n{",
"}"
]
| [
0,
0
]
| [
[
1,
3,
5
],
[
9
]
]
|
17,062 | qemu_irq get_cps_irq(MIPSCPSState *s, int pin_number)
{
MIPSCPU *cpu = MIPS_CPU(first_cpu);
CPUMIPSState *env = &cpu->env;
assert(pin_number < s->num_irq);
/* TODO: return GIC pins once implemented */
return env->irq[pin_number];
}
| false | qemu | 19494f811a43c6bc226aa272d86300d9229224fe | qemu_irq get_cps_irq(MIPSCPSState *s, int pin_number)
{
MIPSCPU *cpu = MIPS_CPU(first_cpu);
CPUMIPSState *env = &cpu->env;
assert(pin_number < s->num_irq);
return env->irq[pin_number];
}
| {
"code": [],
"line_no": []
} | qemu_irq FUNC_0(MIPSCPSState *s, int pin_number)
{
MIPSCPU *cpu = MIPS_CPU(first_cpu);
CPUMIPSState *env = &cpu->env;
assert(pin_number < s->num_irq);
return env->irq[pin_number];
}
| [
"qemu_irq FUNC_0(MIPSCPSState *s, int pin_number)\n{",
"MIPSCPU *cpu = MIPS_CPU(first_cpu);",
"CPUMIPSState *env = &cpu->env;",
"assert(pin_number < s->num_irq);",
"return env->irq[pin_number];",
"}"
]
| [
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11
],
[
17
],
[
19
]
]
|
17,063 | static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
{
TCPCharDriver *s = chr->opaque;
if (s->connected) {
return send_all(s->fd, buf, len);
} else {
/* (Re-)connect for unconnected writing */
tcp_chr_connect(chr);
return 0;
}
}
| false | qemu | 455aa1e0818653c41fd794435b982426ce21ba2f | static int tcp_chr_write(CharDriverState *chr, const uint8_t *buf, int len)
{
TCPCharDriver *s = chr->opaque;
if (s->connected) {
return send_all(s->fd, buf, len);
} else {
tcp_chr_connect(chr);
return 0;
}
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(CharDriverState *VAR_0, const uint8_t *VAR_1, int VAR_2)
{
TCPCharDriver *s = VAR_0->opaque;
if (s->connected) {
return send_all(s->fd, VAR_1, VAR_2);
} else {
tcp_chr_connect(VAR_0);
return 0;
}
}
| [
"static int FUNC_0(CharDriverState *VAR_0, const uint8_t *VAR_1, int VAR_2)\n{",
"TCPCharDriver *s = VAR_0->opaque;",
"if (s->connected) {",
"return send_all(s->fd, VAR_1, VAR_2);",
"} else {",
"tcp_chr_connect(VAR_0);",
"return 0;",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
19
],
[
21
]
]
|
17,064 | static int img_create(int argc, char **argv)
{
int c, ret, flags;
const char *fmt = "raw";
const char *base_fmt = NULL;
const char *filename;
const char *base_filename = NULL;
BlockDriver *drv;
QEMUOptionParameter *param = NULL;
char *options = NULL;
flags = 0;
for(;;) {
c = getopt(argc, argv, "F:b:f:he6o:");
if (c == -1)
break;
switch(c) {
case 'h':
help();
break;
case 'F':
base_fmt = optarg;
break;
case 'b':
base_filename = optarg;
break;
case 'f':
fmt = optarg;
break;
case 'e':
flags |= BLOCK_FLAG_ENCRYPT;
break;
case '6':
flags |= BLOCK_FLAG_COMPAT6;
break;
case 'o':
options = optarg;
break;
}
}
/* Find driver and parse its options */
drv = bdrv_find_format(fmt);
if (!drv)
error("Unknown file format '%s'", fmt);
if (options && !strcmp(options, "?")) {
print_option_help(drv->create_options);
return 0;
}
if (options) {
param = parse_option_parameters(options, drv->create_options, param);
if (param == NULL) {
error("Invalid options for file format '%s'.", fmt);
}
} else {
param = parse_option_parameters("", drv->create_options, param);
}
/* Get the filename */
if (optind >= argc)
help();
filename = argv[optind++];
/* Add size to parameters */
if (optind < argc) {
set_option_parameter(param, BLOCK_OPT_SIZE, argv[optind++]);
}
/* Add old-style options to parameters */
add_old_style_options(fmt, param, flags, base_filename, base_fmt);
// The size for the image must always be specified, with one exception:
// If we are using a backing file, we can obtain the size from there
if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == 0) {
QEMUOptionParameter *backing_file =
get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
QEMUOptionParameter *backing_fmt =
get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
if (backing_file && backing_file->value.s) {
BlockDriverState *bs;
uint64_t size;
const char *fmt = NULL;
char buf[32];
if (backing_fmt && backing_fmt->value.s) {
if (bdrv_find_format(backing_fmt->value.s)) {
fmt = backing_fmt->value.s;
} else {
error("Unknown backing file format '%s'",
backing_fmt->value.s);
}
}
bs = bdrv_new_open(backing_file->value.s, fmt);
bdrv_get_geometry(bs, &size);
size *= 512;
bdrv_delete(bs);
snprintf(buf, sizeof(buf), "%" PRId64, size);
set_option_parameter(param, BLOCK_OPT_SIZE, buf);
} else {
error("Image creation needs a size parameter");
}
}
printf("Formatting '%s', fmt=%s ", filename, fmt);
print_option_parameters(param);
puts("");
ret = bdrv_create(drv, filename, param);
free_option_parameters(param);
if (ret < 0) {
if (ret == -ENOTSUP) {
error("Formatting or formatting option not supported for file format '%s'", fmt);
} else if (ret == -EFBIG) {
error("The image size is too large for file format '%s'", fmt);
} else {
error("Error while formatting");
}
}
return 0;
}
| false | qemu | 9f56640c8536a8dfb78fc05a39c1bf9921483b12 | static int img_create(int argc, char **argv)
{
int c, ret, flags;
const char *fmt = "raw";
const char *base_fmt = NULL;
const char *filename;
const char *base_filename = NULL;
BlockDriver *drv;
QEMUOptionParameter *param = NULL;
char *options = NULL;
flags = 0;
for(;;) {
c = getopt(argc, argv, "F:b:f:he6o:");
if (c == -1)
break;
switch(c) {
case 'h':
help();
break;
case 'F':
base_fmt = optarg;
break;
case 'b':
base_filename = optarg;
break;
case 'f':
fmt = optarg;
break;
case 'e':
flags |= BLOCK_FLAG_ENCRYPT;
break;
case '6':
flags |= BLOCK_FLAG_COMPAT6;
break;
case 'o':
options = optarg;
break;
}
}
drv = bdrv_find_format(fmt);
if (!drv)
error("Unknown file format '%s'", fmt);
if (options && !strcmp(options, "?")) {
print_option_help(drv->create_options);
return 0;
}
if (options) {
param = parse_option_parameters(options, drv->create_options, param);
if (param == NULL) {
error("Invalid options for file format '%s'.", fmt);
}
} else {
param = parse_option_parameters("", drv->create_options, param);
}
if (optind >= argc)
help();
filename = argv[optind++];
if (optind < argc) {
set_option_parameter(param, BLOCK_OPT_SIZE, argv[optind++]);
}
add_old_style_options(fmt, param, flags, base_filename, base_fmt);
if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == 0) {
QEMUOptionParameter *backing_file =
get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
QEMUOptionParameter *backing_fmt =
get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
if (backing_file && backing_file->value.s) {
BlockDriverState *bs;
uint64_t size;
const char *fmt = NULL;
char buf[32];
if (backing_fmt && backing_fmt->value.s) {
if (bdrv_find_format(backing_fmt->value.s)) {
fmt = backing_fmt->value.s;
} else {
error("Unknown backing file format '%s'",
backing_fmt->value.s);
}
}
bs = bdrv_new_open(backing_file->value.s, fmt);
bdrv_get_geometry(bs, &size);
size *= 512;
bdrv_delete(bs);
snprintf(buf, sizeof(buf), "%" PRId64, size);
set_option_parameter(param, BLOCK_OPT_SIZE, buf);
} else {
error("Image creation needs a size parameter");
}
}
printf("Formatting '%s', fmt=%s ", filename, fmt);
print_option_parameters(param);
puts("");
ret = bdrv_create(drv, filename, param);
free_option_parameters(param);
if (ret < 0) {
if (ret == -ENOTSUP) {
error("Formatting or formatting option not supported for file format '%s'", fmt);
} else if (ret == -EFBIG) {
error("The image size is too large for file format '%s'", fmt);
} else {
error("Error while formatting");
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(int VAR_0, char **VAR_1)
{
int VAR_2, VAR_3, VAR_4;
const char *VAR_10 = "raw";
const char *VAR_6 = NULL;
const char *VAR_7;
const char *VAR_8 = NULL;
BlockDriver *drv;
QEMUOptionParameter *param = NULL;
char *VAR_9 = NULL;
VAR_4 = 0;
for(;;) {
VAR_2 = getopt(VAR_0, VAR_1, "F:b:f:he6o:");
if (VAR_2 == -1)
break;
switch(VAR_2) {
case 'h':
help();
break;
case 'F':
VAR_6 = optarg;
break;
case 'b':
VAR_8 = optarg;
break;
case 'f':
VAR_10 = optarg;
break;
case 'e':
VAR_4 |= BLOCK_FLAG_ENCRYPT;
break;
case '6':
VAR_4 |= BLOCK_FLAG_COMPAT6;
break;
case 'o':
VAR_9 = optarg;
break;
}
}
drv = bdrv_find_format(VAR_10);
if (!drv)
error("Unknown file format '%s'", VAR_10);
if (VAR_9 && !strcmp(VAR_9, "?")) {
print_option_help(drv->create_options);
return 0;
}
if (VAR_9) {
param = parse_option_parameters(VAR_9, drv->create_options, param);
if (param == NULL) {
error("Invalid VAR_9 for file format '%s'.", VAR_10);
}
} else {
param = parse_option_parameters("", drv->create_options, param);
}
if (optind >= VAR_0)
help();
VAR_7 = VAR_1[optind++];
if (optind < VAR_0) {
set_option_parameter(param, BLOCK_OPT_SIZE, VAR_1[optind++]);
}
add_old_style_options(VAR_10, param, VAR_4, VAR_8, VAR_6);
if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == 0) {
QEMUOptionParameter *backing_file =
get_option_parameter(param, BLOCK_OPT_BACKING_FILE);
QEMUOptionParameter *backing_fmt =
get_option_parameter(param, BLOCK_OPT_BACKING_FMT);
if (backing_file && backing_file->value.s) {
BlockDriverState *bs;
uint64_t size;
const char *VAR_10 = NULL;
char VAR_10[32];
if (backing_fmt && backing_fmt->value.s) {
if (bdrv_find_format(backing_fmt->value.s)) {
VAR_10 = backing_fmt->value.s;
} else {
error("Unknown backing file format '%s'",
backing_fmt->value.s);
}
}
bs = bdrv_new_open(backing_file->value.s, VAR_10);
bdrv_get_geometry(bs, &size);
size *= 512;
bdrv_delete(bs);
snprintf(VAR_10, sizeof(VAR_10), "%" PRId64, size);
set_option_parameter(param, BLOCK_OPT_SIZE, VAR_10);
} else {
error("Image creation needs a size parameter");
}
}
printf("Formatting '%s', VAR_10=%s ", VAR_7, VAR_10);
print_option_parameters(param);
puts("");
VAR_3 = bdrv_create(drv, VAR_7, param);
free_option_parameters(param);
if (VAR_3 < 0) {
if (VAR_3 == -ENOTSUP) {
error("Formatting or formatting option not supported for file format '%s'", VAR_10);
} else if (VAR_3 == -EFBIG) {
error("The image size is too large for file format '%s'", VAR_10);
} else {
error("Error while formatting");
}
}
return 0;
}
| [
"static int FUNC_0(int VAR_0, char **VAR_1)\n{",
"int VAR_2, VAR_3, VAR_4;",
"const char *VAR_10 = \"raw\";",
"const char *VAR_6 = NULL;",
"const char *VAR_7;",
"const char *VAR_8 = NULL;",
"BlockDriver *drv;",
"QEMUOptionParameter *param = NULL;",
"char *VAR_9 = NULL;",
"VAR_4 = 0;",
"for(;;) {",
"VAR_2 = getopt(VAR_0, VAR_1, \"F:b:f:he6o:\");",
"if (VAR_2 == -1)\nbreak;",
"switch(VAR_2) {",
"case 'h':\nhelp();",
"break;",
"case 'F':\nVAR_6 = optarg;",
"break;",
"case 'b':\nVAR_8 = optarg;",
"break;",
"case 'f':\nVAR_10 = optarg;",
"break;",
"case 'e':\nVAR_4 |= BLOCK_FLAG_ENCRYPT;",
"break;",
"case '6':\nVAR_4 |= BLOCK_FLAG_COMPAT6;",
"break;",
"case 'o':\nVAR_9 = optarg;",
"break;",
"}",
"}",
"drv = bdrv_find_format(VAR_10);",
"if (!drv)\nerror(\"Unknown file format '%s'\", VAR_10);",
"if (VAR_9 && !strcmp(VAR_9, \"?\")) {",
"print_option_help(drv->create_options);",
"return 0;",
"}",
"if (VAR_9) {",
"param = parse_option_parameters(VAR_9, drv->create_options, param);",
"if (param == NULL) {",
"error(\"Invalid VAR_9 for file format '%s'.\", VAR_10);",
"}",
"} else {",
"param = parse_option_parameters(\"\", drv->create_options, param);",
"}",
"if (optind >= VAR_0)\nhelp();",
"VAR_7 = VAR_1[optind++];",
"if (optind < VAR_0) {",
"set_option_parameter(param, BLOCK_OPT_SIZE, VAR_1[optind++]);",
"}",
"add_old_style_options(VAR_10, param, VAR_4, VAR_8, VAR_6);",
"if (get_option_parameter(param, BLOCK_OPT_SIZE)->value.n == 0) {",
"QEMUOptionParameter *backing_file =\nget_option_parameter(param, BLOCK_OPT_BACKING_FILE);",
"QEMUOptionParameter *backing_fmt =\nget_option_parameter(param, BLOCK_OPT_BACKING_FMT);",
"if (backing_file && backing_file->value.s) {",
"BlockDriverState *bs;",
"uint64_t size;",
"const char *VAR_10 = NULL;",
"char VAR_10[32];",
"if (backing_fmt && backing_fmt->value.s) {",
"if (bdrv_find_format(backing_fmt->value.s)) {",
"VAR_10 = backing_fmt->value.s;",
"} else {",
"error(\"Unknown backing file format '%s'\",\nbacking_fmt->value.s);",
"}",
"}",
"bs = bdrv_new_open(backing_file->value.s, VAR_10);",
"bdrv_get_geometry(bs, &size);",
"size *= 512;",
"bdrv_delete(bs);",
"snprintf(VAR_10, sizeof(VAR_10), \"%\" PRId64, size);",
"set_option_parameter(param, BLOCK_OPT_SIZE, VAR_10);",
"} else {",
"error(\"Image creation needs a size parameter\");",
"}",
"}",
"printf(\"Formatting '%s', VAR_10=%s \", VAR_7, VAR_10);",
"print_option_parameters(param);",
"puts(\"\");",
"VAR_3 = bdrv_create(drv, VAR_7, param);",
"free_option_parameters(param);",
"if (VAR_3 < 0) {",
"if (VAR_3 == -ENOTSUP) {",
"error(\"Formatting or formatting option not supported for file format '%s'\", VAR_10);",
"} else if (VAR_3 == -EFBIG) {",
"error(\"The image size is too large for file format '%s'\", VAR_10);",
"} else {",
"error(\"Error while formatting\");",
"}",
"}",
"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
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
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
],
[
85
],
[
87,
89
],
[
93
],
[
95
],
[
97
],
[
99
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
123,
125
],
[
127
],
[
133
],
[
135
],
[
137
],
[
143
],
[
151
],
[
155,
157
],
[
159,
161
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
177
],
[
179
],
[
181
],
[
183
],
[
185,
187
],
[
189
],
[
191
],
[
195
],
[
197
],
[
199
],
[
201
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
215
],
[
219
],
[
221
],
[
223
],
[
227
],
[
229
],
[
233
],
[
235
],
[
237
],
[
239
],
[
241
],
[
243
],
[
245
],
[
247
],
[
249
],
[
251
],
[
253
]
]
|
17,065 | static int fill_filter_caches(H264Context *h, int mb_type){
MpegEncContext * const s = &h->s;
const int mb_xy= h->mb_xy;
int top_xy, left_xy[2];
int top_type, left_type[2];
top_xy = mb_xy - (s->mb_stride << MB_FIELD);
//FIXME deblocking could skip the intra and nnz parts.
/* Wow, what a mess, why didn't they simplify the interlacing & intra
* stuff, I can't imagine that these complex rules are worth it. */
left_xy[1] = left_xy[0] = mb_xy-1;
if(FRAME_MBAFF){
const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]);
const int curr_mb_field_flag = IS_INTERLACED(mb_type);
if(s->mb_y&1){
if (left_mb_field_flag != curr_mb_field_flag) {
left_xy[0] -= s->mb_stride;
}
}else{
if(curr_mb_field_flag){
top_xy += s->mb_stride & (((s->current_picture.mb_type[top_xy ]>>7)&1)-1);
}
if (left_mb_field_flag != curr_mb_field_flag) {
left_xy[1] += s->mb_stride;
}
}
}
h->top_mb_xy = top_xy;
h->left_mb_xy[0] = left_xy[0];
h->left_mb_xy[1] = left_xy[1];
{
//for sufficiently low qp, filtering wouldn't do anything
//this is a conservative estimate: could also check beta_offset and more accurate chroma_qp
int qp_thresh = h->qp_thresh; //FIXME strictly we should store qp_thresh for each mb of a slice
int qp = s->current_picture.qscale_table[mb_xy];
if(qp <= qp_thresh
&& (left_xy[0]<0 || ((qp + s->current_picture.qscale_table[left_xy[0]] + 1)>>1) <= qp_thresh)
&& (top_xy < 0 || ((qp + s->current_picture.qscale_table[top_xy ] + 1)>>1) <= qp_thresh)){
if(!FRAME_MBAFF)
return 1;
if( (left_xy[0]< 0 || ((qp + s->current_picture.qscale_table[left_xy[1] ] + 1)>>1) <= qp_thresh)
&& (top_xy < s->mb_stride || ((qp + s->current_picture.qscale_table[top_xy -s->mb_stride] + 1)>>1) <= qp_thresh))
return 1;
}
}
top_type = s->current_picture.mb_type[top_xy] ;
left_type[0] = s->current_picture.mb_type[left_xy[0]];
left_type[1] = s->current_picture.mb_type[left_xy[1]];
if(h->deblocking_filter == 2){
if(h->slice_table[top_xy ] != h->slice_num) top_type= 0;
if(h->slice_table[left_xy[0] ] != h->slice_num) left_type[0]= left_type[1]= 0;
}else{
if(h->slice_table[top_xy ] == 0xFFFF) top_type= 0;
if(h->slice_table[left_xy[0] ] == 0xFFFF) left_type[0]= left_type[1] =0;
}
h->top_type = top_type ;
h->left_type[0]= left_type[0];
h->left_type[1]= left_type[1];
if(IS_INTRA(mb_type))
return 0;
AV_COPY32(&h->non_zero_count_cache[4+8* 1], &h->non_zero_count[mb_xy][ 0]);
AV_COPY32(&h->non_zero_count_cache[4+8* 2], &h->non_zero_count[mb_xy][ 4]);
AV_COPY32(&h->non_zero_count_cache[4+8* 3], &h->non_zero_count[mb_xy][ 8]);
AV_COPY32(&h->non_zero_count_cache[4+8* 4], &h->non_zero_count[mb_xy][12]);
h->cbp= h->cbp_table[mb_xy];
{
int list;
for(list=0; list<h->list_count; list++){
int8_t *ref;
int y, b_stride;
int16_t (*mv_dst)[2];
int16_t (*mv_src)[2];
if(!USES_LIST(mb_type, list)){
fill_rectangle( h->mv_cache[list][scan8[0]], 4, 4, 8, pack16to32(0,0), 4);
AV_WN32A(&h->ref_cache[list][scan8[ 0]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
AV_WN32A(&h->ref_cache[list][scan8[ 2]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
AV_WN32A(&h->ref_cache[list][scan8[ 8]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
AV_WN32A(&h->ref_cache[list][scan8[10]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
continue;
}
ref = &s->current_picture.ref_index[list][4*mb_xy];
{
int (*ref2frm)[64] = h->ref2frm[ h->slice_num&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
AV_WN32A(&h->ref_cache[list][scan8[ 0]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
AV_WN32A(&h->ref_cache[list][scan8[ 2]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
ref += 2;
AV_WN32A(&h->ref_cache[list][scan8[ 8]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
AV_WN32A(&h->ref_cache[list][scan8[10]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
}
b_stride = h->b_stride;
mv_dst = &h->mv_cache[list][scan8[0]];
mv_src = &s->current_picture.motion_val[list][4*s->mb_x + 4*s->mb_y*b_stride];
for(y=0; y<4; y++){
AV_COPY128(mv_dst + 8*y, mv_src + y*b_stride);
}
}
}
/*
0 . T T. T T T T
1 L . .L . . . .
2 L . .L . . . .
3 . T TL . . . .
4 L . .L . . . .
5 L . .. . . . .
*/
//FIXME constraint_intra_pred & partitioning & nnz (let us hope this is just a typo in the spec)
if(top_type){
AV_COPY32(&h->non_zero_count_cache[4+8*0], &h->non_zero_count[top_xy][3*4]);
}
if(left_type[0]){
h->non_zero_count_cache[3+8*1]= h->non_zero_count[left_xy[0]][3+0*4];
h->non_zero_count_cache[3+8*2]= h->non_zero_count[left_xy[0]][3+1*4];
h->non_zero_count_cache[3+8*3]= h->non_zero_count[left_xy[0]][3+2*4];
h->non_zero_count_cache[3+8*4]= h->non_zero_count[left_xy[0]][3+3*4];
}
// CAVLC 8x8dct requires NNZ values for residual decoding that differ from what the loop filter needs
if(!CABAC && h->pps.transform_8x8_mode){
if(IS_8x8DCT(top_type)){
h->non_zero_count_cache[4+8*0]=
h->non_zero_count_cache[5+8*0]= (h->cbp_table[top_xy] & 0x4000) >> 12;
h->non_zero_count_cache[6+8*0]=
h->non_zero_count_cache[7+8*0]= (h->cbp_table[top_xy] & 0x8000) >> 12;
}
if(IS_8x8DCT(left_type[0])){
h->non_zero_count_cache[3+8*1]=
h->non_zero_count_cache[3+8*2]= (h->cbp_table[left_xy[0]]&0x2000) >> 12; //FIXME check MBAFF
}
if(IS_8x8DCT(left_type[1])){
h->non_zero_count_cache[3+8*3]=
h->non_zero_count_cache[3+8*4]= (h->cbp_table[left_xy[1]]&0x8000) >> 12; //FIXME check MBAFF
}
if(IS_8x8DCT(mb_type)){
h->non_zero_count_cache[scan8[0 ]]= h->non_zero_count_cache[scan8[1 ]]=
h->non_zero_count_cache[scan8[2 ]]= h->non_zero_count_cache[scan8[3 ]]= (h->cbp & 0x1000) >> 12;
h->non_zero_count_cache[scan8[0+ 4]]= h->non_zero_count_cache[scan8[1+ 4]]=
h->non_zero_count_cache[scan8[2+ 4]]= h->non_zero_count_cache[scan8[3+ 4]]= (h->cbp & 0x2000) >> 12;
h->non_zero_count_cache[scan8[0+ 8]]= h->non_zero_count_cache[scan8[1+ 8]]=
h->non_zero_count_cache[scan8[2+ 8]]= h->non_zero_count_cache[scan8[3+ 8]]= (h->cbp & 0x4000) >> 12;
h->non_zero_count_cache[scan8[0+12]]= h->non_zero_count_cache[scan8[1+12]]=
h->non_zero_count_cache[scan8[2+12]]= h->non_zero_count_cache[scan8[3+12]]= (h->cbp & 0x8000) >> 12;
}
}
if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){
int list;
for(list=0; list<h->list_count; list++){
if(USES_LIST(top_type, list)){
const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
const int b8_xy= 4*top_xy + 2;
int (*ref2frm)[64] = h->ref2frm[ h->slice_table[top_xy]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
AV_COPY128(h->mv_cache[list][scan8[0] + 0 - 1*8], s->current_picture.motion_val[list][b_xy + 0]);
h->ref_cache[list][scan8[0] + 0 - 1*8]=
h->ref_cache[list][scan8[0] + 1 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 0]];
h->ref_cache[list][scan8[0] + 2 - 1*8]=
h->ref_cache[list][scan8[0] + 3 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 1]];
}else{
AV_ZERO128(h->mv_cache[list][scan8[0] + 0 - 1*8]);
AV_WN32A(&h->ref_cache[list][scan8[0] + 0 - 1*8], ((LIST_NOT_USED)&0xFF)*0x01010101u);
}
if(!IS_INTERLACED(mb_type^left_type[0])){
if(USES_LIST(left_type[0], list)){
const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
const int b8_xy= 4*left_xy[0] + 1;
int (*ref2frm)[64] = h->ref2frm[ h->slice_table[left_xy[0]]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 0 ], s->current_picture.motion_val[list][b_xy + h->b_stride*0]);
AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 8 ], s->current_picture.motion_val[list][b_xy + h->b_stride*1]);
AV_COPY32(h->mv_cache[list][scan8[0] - 1 +16 ], s->current_picture.motion_val[list][b_xy + h->b_stride*2]);
AV_COPY32(h->mv_cache[list][scan8[0] - 1 +24 ], s->current_picture.motion_val[list][b_xy + h->b_stride*3]);
h->ref_cache[list][scan8[0] - 1 + 0 ]=
h->ref_cache[list][scan8[0] - 1 + 8 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*0]];
h->ref_cache[list][scan8[0] - 1 +16 ]=
h->ref_cache[list][scan8[0] - 1 +24 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*1]];
}else{
AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 0 ]);
AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 8 ]);
AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +16 ]);
AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +24 ]);
h->ref_cache[list][scan8[0] - 1 + 0 ]=
h->ref_cache[list][scan8[0] - 1 + 8 ]=
h->ref_cache[list][scan8[0] - 1 + 16 ]=
h->ref_cache[list][scan8[0] - 1 + 24 ]= LIST_NOT_USED;
}
}
}
}
return 0;
}
| false | FFmpeg | cb5469462d427ea38625e255306f07b37d75280f | static int fill_filter_caches(H264Context *h, int mb_type){
MpegEncContext * const s = &h->s;
const int mb_xy= h->mb_xy;
int top_xy, left_xy[2];
int top_type, left_type[2];
top_xy = mb_xy - (s->mb_stride << MB_FIELD);
left_xy[1] = left_xy[0] = mb_xy-1;
if(FRAME_MBAFF){
const int left_mb_field_flag = IS_INTERLACED(s->current_picture.mb_type[mb_xy-1]);
const int curr_mb_field_flag = IS_INTERLACED(mb_type);
if(s->mb_y&1){
if (left_mb_field_flag != curr_mb_field_flag) {
left_xy[0] -= s->mb_stride;
}
}else{
if(curr_mb_field_flag){
top_xy += s->mb_stride & (((s->current_picture.mb_type[top_xy ]>>7)&1)-1);
}
if (left_mb_field_flag != curr_mb_field_flag) {
left_xy[1] += s->mb_stride;
}
}
}
h->top_mb_xy = top_xy;
h->left_mb_xy[0] = left_xy[0];
h->left_mb_xy[1] = left_xy[1];
{
int qp_thresh = h->qp_thresh;
int qp = s->current_picture.qscale_table[mb_xy];
if(qp <= qp_thresh
&& (left_xy[0]<0 || ((qp + s->current_picture.qscale_table[left_xy[0]] + 1)>>1) <= qp_thresh)
&& (top_xy < 0 || ((qp + s->current_picture.qscale_table[top_xy ] + 1)>>1) <= qp_thresh)){
if(!FRAME_MBAFF)
return 1;
if( (left_xy[0]< 0 || ((qp + s->current_picture.qscale_table[left_xy[1] ] + 1)>>1) <= qp_thresh)
&& (top_xy < s->mb_stride || ((qp + s->current_picture.qscale_table[top_xy -s->mb_stride] + 1)>>1) <= qp_thresh))
return 1;
}
}
top_type = s->current_picture.mb_type[top_xy] ;
left_type[0] = s->current_picture.mb_type[left_xy[0]];
left_type[1] = s->current_picture.mb_type[left_xy[1]];
if(h->deblocking_filter == 2){
if(h->slice_table[top_xy ] != h->slice_num) top_type= 0;
if(h->slice_table[left_xy[0] ] != h->slice_num) left_type[0]= left_type[1]= 0;
}else{
if(h->slice_table[top_xy ] == 0xFFFF) top_type= 0;
if(h->slice_table[left_xy[0] ] == 0xFFFF) left_type[0]= left_type[1] =0;
}
h->top_type = top_type ;
h->left_type[0]= left_type[0];
h->left_type[1]= left_type[1];
if(IS_INTRA(mb_type))
return 0;
AV_COPY32(&h->non_zero_count_cache[4+8* 1], &h->non_zero_count[mb_xy][ 0]);
AV_COPY32(&h->non_zero_count_cache[4+8* 2], &h->non_zero_count[mb_xy][ 4]);
AV_COPY32(&h->non_zero_count_cache[4+8* 3], &h->non_zero_count[mb_xy][ 8]);
AV_COPY32(&h->non_zero_count_cache[4+8* 4], &h->non_zero_count[mb_xy][12]);
h->cbp= h->cbp_table[mb_xy];
{
int list;
for(list=0; list<h->list_count; list++){
int8_t *ref;
int y, b_stride;
int16_t (*mv_dst)[2];
int16_t (*mv_src)[2];
if(!USES_LIST(mb_type, list)){
fill_rectangle( h->mv_cache[list][scan8[0]], 4, 4, 8, pack16to32(0,0), 4);
AV_WN32A(&h->ref_cache[list][scan8[ 0]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
AV_WN32A(&h->ref_cache[list][scan8[ 2]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
AV_WN32A(&h->ref_cache[list][scan8[ 8]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
AV_WN32A(&h->ref_cache[list][scan8[10]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
continue;
}
ref = &s->current_picture.ref_index[list][4*mb_xy];
{
int (*ref2frm)[64] = h->ref2frm[ h->slice_num&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
AV_WN32A(&h->ref_cache[list][scan8[ 0]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
AV_WN32A(&h->ref_cache[list][scan8[ 2]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
ref += 2;
AV_WN32A(&h->ref_cache[list][scan8[ 8]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
AV_WN32A(&h->ref_cache[list][scan8[10]], (pack16to32(ref2frm[list][ref[0]],ref2frm[list][ref[1]])&0x00FF00FF)*0x0101);
}
b_stride = h->b_stride;
mv_dst = &h->mv_cache[list][scan8[0]];
mv_src = &s->current_picture.motion_val[list][4*s->mb_x + 4*s->mb_y*b_stride];
for(y=0; y<4; y++){
AV_COPY128(mv_dst + 8*y, mv_src + y*b_stride);
}
}
}
if(top_type){
AV_COPY32(&h->non_zero_count_cache[4+8*0], &h->non_zero_count[top_xy][3*4]);
}
if(left_type[0]){
h->non_zero_count_cache[3+8*1]= h->non_zero_count[left_xy[0]][3+0*4];
h->non_zero_count_cache[3+8*2]= h->non_zero_count[left_xy[0]][3+1*4];
h->non_zero_count_cache[3+8*3]= h->non_zero_count[left_xy[0]][3+2*4];
h->non_zero_count_cache[3+8*4]= h->non_zero_count[left_xy[0]][3+3*4];
}
if(!CABAC && h->pps.transform_8x8_mode){
if(IS_8x8DCT(top_type)){
h->non_zero_count_cache[4+8*0]=
h->non_zero_count_cache[5+8*0]= (h->cbp_table[top_xy] & 0x4000) >> 12;
h->non_zero_count_cache[6+8*0]=
h->non_zero_count_cache[7+8*0]= (h->cbp_table[top_xy] & 0x8000) >> 12;
}
if(IS_8x8DCT(left_type[0])){
h->non_zero_count_cache[3+8*1]=
h->non_zero_count_cache[3+8*2]= (h->cbp_table[left_xy[0]]&0x2000) >> 12;
}
if(IS_8x8DCT(left_type[1])){
h->non_zero_count_cache[3+8*3]=
h->non_zero_count_cache[3+8*4]= (h->cbp_table[left_xy[1]]&0x8000) >> 12;
}
if(IS_8x8DCT(mb_type)){
h->non_zero_count_cache[scan8[0 ]]= h->non_zero_count_cache[scan8[1 ]]=
h->non_zero_count_cache[scan8[2 ]]= h->non_zero_count_cache[scan8[3 ]]= (h->cbp & 0x1000) >> 12;
h->non_zero_count_cache[scan8[0+ 4]]= h->non_zero_count_cache[scan8[1+ 4]]=
h->non_zero_count_cache[scan8[2+ 4]]= h->non_zero_count_cache[scan8[3+ 4]]= (h->cbp & 0x2000) >> 12;
h->non_zero_count_cache[scan8[0+ 8]]= h->non_zero_count_cache[scan8[1+ 8]]=
h->non_zero_count_cache[scan8[2+ 8]]= h->non_zero_count_cache[scan8[3+ 8]]= (h->cbp & 0x4000) >> 12;
h->non_zero_count_cache[scan8[0+12]]= h->non_zero_count_cache[scan8[1+12]]=
h->non_zero_count_cache[scan8[2+12]]= h->non_zero_count_cache[scan8[3+12]]= (h->cbp & 0x8000) >> 12;
}
}
if(IS_INTER(mb_type) || IS_DIRECT(mb_type)){
int list;
for(list=0; list<h->list_count; list++){
if(USES_LIST(top_type, list)){
const int b_xy= h->mb2b_xy[top_xy] + 3*h->b_stride;
const int b8_xy= 4*top_xy + 2;
int (*ref2frm)[64] = h->ref2frm[ h->slice_table[top_xy]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
AV_COPY128(h->mv_cache[list][scan8[0] + 0 - 1*8], s->current_picture.motion_val[list][b_xy + 0]);
h->ref_cache[list][scan8[0] + 0 - 1*8]=
h->ref_cache[list][scan8[0] + 1 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 0]];
h->ref_cache[list][scan8[0] + 2 - 1*8]=
h->ref_cache[list][scan8[0] + 3 - 1*8]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 1]];
}else{
AV_ZERO128(h->mv_cache[list][scan8[0] + 0 - 1*8]);
AV_WN32A(&h->ref_cache[list][scan8[0] + 0 - 1*8], ((LIST_NOT_USED)&0xFF)*0x01010101u);
}
if(!IS_INTERLACED(mb_type^left_type[0])){
if(USES_LIST(left_type[0], list)){
const int b_xy= h->mb2b_xy[left_xy[0]] + 3;
const int b8_xy= 4*left_xy[0] + 1;
int (*ref2frm)[64] = h->ref2frm[ h->slice_table[left_xy[0]]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 0 ], s->current_picture.motion_val[list][b_xy + h->b_stride*0]);
AV_COPY32(h->mv_cache[list][scan8[0] - 1 + 8 ], s->current_picture.motion_val[list][b_xy + h->b_stride*1]);
AV_COPY32(h->mv_cache[list][scan8[0] - 1 +16 ], s->current_picture.motion_val[list][b_xy + h->b_stride*2]);
AV_COPY32(h->mv_cache[list][scan8[0] - 1 +24 ], s->current_picture.motion_val[list][b_xy + h->b_stride*3]);
h->ref_cache[list][scan8[0] - 1 + 0 ]=
h->ref_cache[list][scan8[0] - 1 + 8 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*0]];
h->ref_cache[list][scan8[0] - 1 +16 ]=
h->ref_cache[list][scan8[0] - 1 +24 ]= ref2frm[list][s->current_picture.ref_index[list][b8_xy + 2*1]];
}else{
AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 0 ]);
AV_ZERO32(h->mv_cache [list][scan8[0] - 1 + 8 ]);
AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +16 ]);
AV_ZERO32(h->mv_cache [list][scan8[0] - 1 +24 ]);
h->ref_cache[list][scan8[0] - 1 + 0 ]=
h->ref_cache[list][scan8[0] - 1 + 8 ]=
h->ref_cache[list][scan8[0] - 1 + 16 ]=
h->ref_cache[list][scan8[0] - 1 + 24 ]= LIST_NOT_USED;
}
}
}
}
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(H264Context *VAR_0, int VAR_1){
MpegEncContext * const s = &VAR_0->s;
const int VAR_2= VAR_0->VAR_2;
int VAR_3, VAR_4[2];
int VAR_5, VAR_6[2];
VAR_3 = VAR_2 - (s->mb_stride << MB_FIELD);
VAR_4[1] = VAR_4[0] = VAR_2-1;
if(FRAME_MBAFF){
const int VAR_7 = IS_INTERLACED(s->current_picture.VAR_1[VAR_2-1]);
const int VAR_8 = IS_INTERLACED(VAR_1);
if(s->mb_y&1){
if (VAR_7 != VAR_8) {
VAR_4[0] -= s->mb_stride;
}
}else{
if(VAR_8){
VAR_3 += s->mb_stride & (((s->current_picture.VAR_1[VAR_3 ]>>7)&1)-1);
}
if (VAR_7 != VAR_8) {
VAR_4[1] += s->mb_stride;
}
}
}
VAR_0->top_mb_xy = VAR_3;
VAR_0->left_mb_xy[0] = VAR_4[0];
VAR_0->left_mb_xy[1] = VAR_4[1];
{
int VAR_9 = VAR_0->VAR_9;
int VAR_10 = s->current_picture.qscale_table[VAR_2];
if(VAR_10 <= VAR_9
&& (VAR_4[0]<0 || ((VAR_10 + s->current_picture.qscale_table[VAR_4[0]] + 1)>>1) <= VAR_9)
&& (VAR_3 < 0 || ((VAR_10 + s->current_picture.qscale_table[VAR_3 ] + 1)>>1) <= VAR_9)){
if(!FRAME_MBAFF)
return 1;
if( (VAR_4[0]< 0 || ((VAR_10 + s->current_picture.qscale_table[VAR_4[1] ] + 1)>>1) <= VAR_9)
&& (VAR_3 < s->mb_stride || ((VAR_10 + s->current_picture.qscale_table[VAR_3 -s->mb_stride] + 1)>>1) <= VAR_9))
return 1;
}
}
VAR_5 = s->current_picture.VAR_1[VAR_3] ;
VAR_6[0] = s->current_picture.VAR_1[VAR_4[0]];
VAR_6[1] = s->current_picture.VAR_1[VAR_4[1]];
if(VAR_0->deblocking_filter == 2){
if(VAR_0->slice_table[VAR_3 ] != VAR_0->slice_num) VAR_5= 0;
if(VAR_0->slice_table[VAR_4[0] ] != VAR_0->slice_num) VAR_6[0]= VAR_6[1]= 0;
}else{
if(VAR_0->slice_table[VAR_3 ] == 0xFFFF) VAR_5= 0;
if(VAR_0->slice_table[VAR_4[0] ] == 0xFFFF) VAR_6[0]= VAR_6[1] =0;
}
VAR_0->VAR_5 = VAR_5 ;
VAR_0->VAR_6[0]= VAR_6[0];
VAR_0->VAR_6[1]= VAR_6[1];
if(IS_INTRA(VAR_1))
return 0;
AV_COPY32(&VAR_0->non_zero_count_cache[4+8* 1], &VAR_0->non_zero_count[VAR_2][ 0]);
AV_COPY32(&VAR_0->non_zero_count_cache[4+8* 2], &VAR_0->non_zero_count[VAR_2][ 4]);
AV_COPY32(&VAR_0->non_zero_count_cache[4+8* 3], &VAR_0->non_zero_count[VAR_2][ 8]);
AV_COPY32(&VAR_0->non_zero_count_cache[4+8* 4], &VAR_0->non_zero_count[VAR_2][12]);
VAR_0->cbp= VAR_0->cbp_table[VAR_2];
{
int VAR_12;
for(VAR_12=0; VAR_12<VAR_0->list_count; VAR_12++){
int8_t *ref;
int y, b_stride;
int16_t (*mv_dst)[2];
int16_t (*mv_src)[2];
if(!USES_LIST(VAR_1, VAR_12)){
fill_rectangle( VAR_0->mv_cache[VAR_12][scan8[0]], 4, 4, 8, pack16to32(0,0), 4);
AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[ 0]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[ 2]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[ 8]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[10]], ((LIST_NOT_USED)&0xFF)*0x01010101u);
continue;
}
ref = &s->current_picture.ref_index[VAR_12][4*VAR_2];
{
int (*ref2frm)[64] = VAR_0->ref2frm[ VAR_0->slice_num&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[ 0]], (pack16to32(ref2frm[VAR_12][ref[0]],ref2frm[VAR_12][ref[1]])&0x00FF00FF)*0x0101);
AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[ 2]], (pack16to32(ref2frm[VAR_12][ref[0]],ref2frm[VAR_12][ref[1]])&0x00FF00FF)*0x0101);
ref += 2;
AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[ 8]], (pack16to32(ref2frm[VAR_12][ref[0]],ref2frm[VAR_12][ref[1]])&0x00FF00FF)*0x0101);
AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[10]], (pack16to32(ref2frm[VAR_12][ref[0]],ref2frm[VAR_12][ref[1]])&0x00FF00FF)*0x0101);
}
b_stride = VAR_0->b_stride;
mv_dst = &VAR_0->mv_cache[VAR_12][scan8[0]];
mv_src = &s->current_picture.motion_val[VAR_12][4*s->mb_x + 4*s->mb_y*b_stride];
for(y=0; y<4; y++){
AV_COPY128(mv_dst + 8*y, mv_src + y*b_stride);
}
}
}
if(VAR_5){
AV_COPY32(&VAR_0->non_zero_count_cache[4+8*0], &VAR_0->non_zero_count[VAR_3][3*4]);
}
if(VAR_6[0]){
VAR_0->non_zero_count_cache[3+8*1]= VAR_0->non_zero_count[VAR_4[0]][3+0*4];
VAR_0->non_zero_count_cache[3+8*2]= VAR_0->non_zero_count[VAR_4[0]][3+1*4];
VAR_0->non_zero_count_cache[3+8*3]= VAR_0->non_zero_count[VAR_4[0]][3+2*4];
VAR_0->non_zero_count_cache[3+8*4]= VAR_0->non_zero_count[VAR_4[0]][3+3*4];
}
if(!CABAC && VAR_0->pps.transform_8x8_mode){
if(IS_8x8DCT(VAR_5)){
VAR_0->non_zero_count_cache[4+8*0]=
VAR_0->non_zero_count_cache[5+8*0]= (VAR_0->cbp_table[VAR_3] & 0x4000) >> 12;
VAR_0->non_zero_count_cache[6+8*0]=
VAR_0->non_zero_count_cache[7+8*0]= (VAR_0->cbp_table[VAR_3] & 0x8000) >> 12;
}
if(IS_8x8DCT(VAR_6[0])){
VAR_0->non_zero_count_cache[3+8*1]=
VAR_0->non_zero_count_cache[3+8*2]= (VAR_0->cbp_table[VAR_4[0]]&0x2000) >> 12;
}
if(IS_8x8DCT(VAR_6[1])){
VAR_0->non_zero_count_cache[3+8*3]=
VAR_0->non_zero_count_cache[3+8*4]= (VAR_0->cbp_table[VAR_4[1]]&0x8000) >> 12;
}
if(IS_8x8DCT(VAR_1)){
VAR_0->non_zero_count_cache[scan8[0 ]]= VAR_0->non_zero_count_cache[scan8[1 ]]=
VAR_0->non_zero_count_cache[scan8[2 ]]= VAR_0->non_zero_count_cache[scan8[3 ]]= (VAR_0->cbp & 0x1000) >> 12;
VAR_0->non_zero_count_cache[scan8[0+ 4]]= VAR_0->non_zero_count_cache[scan8[1+ 4]]=
VAR_0->non_zero_count_cache[scan8[2+ 4]]= VAR_0->non_zero_count_cache[scan8[3+ 4]]= (VAR_0->cbp & 0x2000) >> 12;
VAR_0->non_zero_count_cache[scan8[0+ 8]]= VAR_0->non_zero_count_cache[scan8[1+ 8]]=
VAR_0->non_zero_count_cache[scan8[2+ 8]]= VAR_0->non_zero_count_cache[scan8[3+ 8]]= (VAR_0->cbp & 0x4000) >> 12;
VAR_0->non_zero_count_cache[scan8[0+12]]= VAR_0->non_zero_count_cache[scan8[1+12]]=
VAR_0->non_zero_count_cache[scan8[2+12]]= VAR_0->non_zero_count_cache[scan8[3+12]]= (VAR_0->cbp & 0x8000) >> 12;
}
}
if(IS_INTER(VAR_1) || IS_DIRECT(VAR_1)){
int VAR_12;
for(VAR_12=0; VAR_12<VAR_0->list_count; VAR_12++){
if(USES_LIST(VAR_5, VAR_12)){
const int b_xy= VAR_0->mb2b_xy[VAR_3] + 3*VAR_0->b_stride;
const int b8_xy= 4*VAR_3 + 2;
int (*ref2frm)[64] = VAR_0->ref2frm[ VAR_0->slice_table[VAR_3]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
AV_COPY128(VAR_0->mv_cache[VAR_12][scan8[0] + 0 - 1*8], s->current_picture.motion_val[VAR_12][b_xy + 0]);
VAR_0->ref_cache[VAR_12][scan8[0] + 0 - 1*8]=
VAR_0->ref_cache[VAR_12][scan8[0] + 1 - 1*8]= ref2frm[VAR_12][s->current_picture.ref_index[VAR_12][b8_xy + 0]];
VAR_0->ref_cache[VAR_12][scan8[0] + 2 - 1*8]=
VAR_0->ref_cache[VAR_12][scan8[0] + 3 - 1*8]= ref2frm[VAR_12][s->current_picture.ref_index[VAR_12][b8_xy + 1]];
}else{
AV_ZERO128(VAR_0->mv_cache[VAR_12][scan8[0] + 0 - 1*8]);
AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[0] + 0 - 1*8], ((LIST_NOT_USED)&0xFF)*0x01010101u);
}
if(!IS_INTERLACED(VAR_1^VAR_6[0])){
if(USES_LIST(VAR_6[0], VAR_12)){
const int b_xy= VAR_0->mb2b_xy[VAR_4[0]] + 3;
const int b8_xy= 4*VAR_4[0] + 1;
int (*ref2frm)[64] = VAR_0->ref2frm[ VAR_0->slice_table[VAR_4[0]]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);
AV_COPY32(VAR_0->mv_cache[VAR_12][scan8[0] - 1 + 0 ], s->current_picture.motion_val[VAR_12][b_xy + VAR_0->b_stride*0]);
AV_COPY32(VAR_0->mv_cache[VAR_12][scan8[0] - 1 + 8 ], s->current_picture.motion_val[VAR_12][b_xy + VAR_0->b_stride*1]);
AV_COPY32(VAR_0->mv_cache[VAR_12][scan8[0] - 1 +16 ], s->current_picture.motion_val[VAR_12][b_xy + VAR_0->b_stride*2]);
AV_COPY32(VAR_0->mv_cache[VAR_12][scan8[0] - 1 +24 ], s->current_picture.motion_val[VAR_12][b_xy + VAR_0->b_stride*3]);
VAR_0->ref_cache[VAR_12][scan8[0] - 1 + 0 ]=
VAR_0->ref_cache[VAR_12][scan8[0] - 1 + 8 ]= ref2frm[VAR_12][s->current_picture.ref_index[VAR_12][b8_xy + 2*0]];
VAR_0->ref_cache[VAR_12][scan8[0] - 1 +16 ]=
VAR_0->ref_cache[VAR_12][scan8[0] - 1 +24 ]= ref2frm[VAR_12][s->current_picture.ref_index[VAR_12][b8_xy + 2*1]];
}else{
AV_ZERO32(VAR_0->mv_cache [VAR_12][scan8[0] - 1 + 0 ]);
AV_ZERO32(VAR_0->mv_cache [VAR_12][scan8[0] - 1 + 8 ]);
AV_ZERO32(VAR_0->mv_cache [VAR_12][scan8[0] - 1 +16 ]);
AV_ZERO32(VAR_0->mv_cache [VAR_12][scan8[0] - 1 +24 ]);
VAR_0->ref_cache[VAR_12][scan8[0] - 1 + 0 ]=
VAR_0->ref_cache[VAR_12][scan8[0] - 1 + 8 ]=
VAR_0->ref_cache[VAR_12][scan8[0] - 1 + 16 ]=
VAR_0->ref_cache[VAR_12][scan8[0] - 1 + 24 ]= LIST_NOT_USED;
}
}
}
}
return 0;
}
| [
"static int FUNC_0(H264Context *VAR_0, int VAR_1){",
"MpegEncContext * const s = &VAR_0->s;",
"const int VAR_2= VAR_0->VAR_2;",
"int VAR_3, VAR_4[2];",
"int VAR_5, VAR_6[2];",
"VAR_3 = VAR_2 - (s->mb_stride << MB_FIELD);",
"VAR_4[1] = VAR_4[0] = VAR_2-1;",
"if(FRAME_MBAFF){",
"const int VAR_7 = IS_INTERLACED(s->current_picture.VAR_1[VAR_2-1]);",
"const int VAR_8 = IS_INTERLACED(VAR_1);",
"if(s->mb_y&1){",
"if (VAR_7 != VAR_8) {",
"VAR_4[0] -= s->mb_stride;",
"}",
"}else{",
"if(VAR_8){",
"VAR_3 += s->mb_stride & (((s->current_picture.VAR_1[VAR_3 ]>>7)&1)-1);",
"}",
"if (VAR_7 != VAR_8) {",
"VAR_4[1] += s->mb_stride;",
"}",
"}",
"}",
"VAR_0->top_mb_xy = VAR_3;",
"VAR_0->left_mb_xy[0] = VAR_4[0];",
"VAR_0->left_mb_xy[1] = VAR_4[1];",
"{",
"int VAR_9 = VAR_0->VAR_9;",
"int VAR_10 = s->current_picture.qscale_table[VAR_2];",
"if(VAR_10 <= VAR_9\n&& (VAR_4[0]<0 || ((VAR_10 + s->current_picture.qscale_table[VAR_4[0]] + 1)>>1) <= VAR_9)\n&& (VAR_3 < 0 || ((VAR_10 + s->current_picture.qscale_table[VAR_3 ] + 1)>>1) <= VAR_9)){",
"if(!FRAME_MBAFF)\nreturn 1;",
"if( (VAR_4[0]< 0 || ((VAR_10 + s->current_picture.qscale_table[VAR_4[1] ] + 1)>>1) <= VAR_9)\n&& (VAR_3 < s->mb_stride || ((VAR_10 + s->current_picture.qscale_table[VAR_3 -s->mb_stride] + 1)>>1) <= VAR_9))\nreturn 1;",
"}",
"}",
"VAR_5 = s->current_picture.VAR_1[VAR_3] ;",
"VAR_6[0] = s->current_picture.VAR_1[VAR_4[0]];",
"VAR_6[1] = s->current_picture.VAR_1[VAR_4[1]];",
"if(VAR_0->deblocking_filter == 2){",
"if(VAR_0->slice_table[VAR_3 ] != VAR_0->slice_num) VAR_5= 0;",
"if(VAR_0->slice_table[VAR_4[0] ] != VAR_0->slice_num) VAR_6[0]= VAR_6[1]= 0;",
"}else{",
"if(VAR_0->slice_table[VAR_3 ] == 0xFFFF) VAR_5= 0;",
"if(VAR_0->slice_table[VAR_4[0] ] == 0xFFFF) VAR_6[0]= VAR_6[1] =0;",
"}",
"VAR_0->VAR_5 = VAR_5 ;",
"VAR_0->VAR_6[0]= VAR_6[0];",
"VAR_0->VAR_6[1]= VAR_6[1];",
"if(IS_INTRA(VAR_1))\nreturn 0;",
"AV_COPY32(&VAR_0->non_zero_count_cache[4+8* 1], &VAR_0->non_zero_count[VAR_2][ 0]);",
"AV_COPY32(&VAR_0->non_zero_count_cache[4+8* 2], &VAR_0->non_zero_count[VAR_2][ 4]);",
"AV_COPY32(&VAR_0->non_zero_count_cache[4+8* 3], &VAR_0->non_zero_count[VAR_2][ 8]);",
"AV_COPY32(&VAR_0->non_zero_count_cache[4+8* 4], &VAR_0->non_zero_count[VAR_2][12]);",
"VAR_0->cbp= VAR_0->cbp_table[VAR_2];",
"{",
"int VAR_12;",
"for(VAR_12=0; VAR_12<VAR_0->list_count; VAR_12++){",
"int8_t *ref;",
"int y, b_stride;",
"int16_t (*mv_dst)[2];",
"int16_t (*mv_src)[2];",
"if(!USES_LIST(VAR_1, VAR_12)){",
"fill_rectangle( VAR_0->mv_cache[VAR_12][scan8[0]], 4, 4, 8, pack16to32(0,0), 4);",
"AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[ 0]], ((LIST_NOT_USED)&0xFF)*0x01010101u);",
"AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[ 2]], ((LIST_NOT_USED)&0xFF)*0x01010101u);",
"AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[ 8]], ((LIST_NOT_USED)&0xFF)*0x01010101u);",
"AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[10]], ((LIST_NOT_USED)&0xFF)*0x01010101u);",
"continue;",
"}",
"ref = &s->current_picture.ref_index[VAR_12][4*VAR_2];",
"{",
"int (*ref2frm)[64] = VAR_0->ref2frm[ VAR_0->slice_num&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);",
"AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[ 0]], (pack16to32(ref2frm[VAR_12][ref[0]],ref2frm[VAR_12][ref[1]])&0x00FF00FF)*0x0101);",
"AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[ 2]], (pack16to32(ref2frm[VAR_12][ref[0]],ref2frm[VAR_12][ref[1]])&0x00FF00FF)*0x0101);",
"ref += 2;",
"AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[ 8]], (pack16to32(ref2frm[VAR_12][ref[0]],ref2frm[VAR_12][ref[1]])&0x00FF00FF)*0x0101);",
"AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[10]], (pack16to32(ref2frm[VAR_12][ref[0]],ref2frm[VAR_12][ref[1]])&0x00FF00FF)*0x0101);",
"}",
"b_stride = VAR_0->b_stride;",
"mv_dst = &VAR_0->mv_cache[VAR_12][scan8[0]];",
"mv_src = &s->current_picture.motion_val[VAR_12][4*s->mb_x + 4*s->mb_y*b_stride];",
"for(y=0; y<4; y++){",
"AV_COPY128(mv_dst + 8*y, mv_src + y*b_stride);",
"}",
"}",
"}",
"if(VAR_5){",
"AV_COPY32(&VAR_0->non_zero_count_cache[4+8*0], &VAR_0->non_zero_count[VAR_3][3*4]);",
"}",
"if(VAR_6[0]){",
"VAR_0->non_zero_count_cache[3+8*1]= VAR_0->non_zero_count[VAR_4[0]][3+0*4];",
"VAR_0->non_zero_count_cache[3+8*2]= VAR_0->non_zero_count[VAR_4[0]][3+1*4];",
"VAR_0->non_zero_count_cache[3+8*3]= VAR_0->non_zero_count[VAR_4[0]][3+2*4];",
"VAR_0->non_zero_count_cache[3+8*4]= VAR_0->non_zero_count[VAR_4[0]][3+3*4];",
"}",
"if(!CABAC && VAR_0->pps.transform_8x8_mode){",
"if(IS_8x8DCT(VAR_5)){",
"VAR_0->non_zero_count_cache[4+8*0]=\nVAR_0->non_zero_count_cache[5+8*0]= (VAR_0->cbp_table[VAR_3] & 0x4000) >> 12;",
"VAR_0->non_zero_count_cache[6+8*0]=\nVAR_0->non_zero_count_cache[7+8*0]= (VAR_0->cbp_table[VAR_3] & 0x8000) >> 12;",
"}",
"if(IS_8x8DCT(VAR_6[0])){",
"VAR_0->non_zero_count_cache[3+8*1]=\nVAR_0->non_zero_count_cache[3+8*2]= (VAR_0->cbp_table[VAR_4[0]]&0x2000) >> 12;",
"}",
"if(IS_8x8DCT(VAR_6[1])){",
"VAR_0->non_zero_count_cache[3+8*3]=\nVAR_0->non_zero_count_cache[3+8*4]= (VAR_0->cbp_table[VAR_4[1]]&0x8000) >> 12;",
"}",
"if(IS_8x8DCT(VAR_1)){",
"VAR_0->non_zero_count_cache[scan8[0 ]]= VAR_0->non_zero_count_cache[scan8[1 ]]=\nVAR_0->non_zero_count_cache[scan8[2 ]]= VAR_0->non_zero_count_cache[scan8[3 ]]= (VAR_0->cbp & 0x1000) >> 12;",
"VAR_0->non_zero_count_cache[scan8[0+ 4]]= VAR_0->non_zero_count_cache[scan8[1+ 4]]=\nVAR_0->non_zero_count_cache[scan8[2+ 4]]= VAR_0->non_zero_count_cache[scan8[3+ 4]]= (VAR_0->cbp & 0x2000) >> 12;",
"VAR_0->non_zero_count_cache[scan8[0+ 8]]= VAR_0->non_zero_count_cache[scan8[1+ 8]]=\nVAR_0->non_zero_count_cache[scan8[2+ 8]]= VAR_0->non_zero_count_cache[scan8[3+ 8]]= (VAR_0->cbp & 0x4000) >> 12;",
"VAR_0->non_zero_count_cache[scan8[0+12]]= VAR_0->non_zero_count_cache[scan8[1+12]]=\nVAR_0->non_zero_count_cache[scan8[2+12]]= VAR_0->non_zero_count_cache[scan8[3+12]]= (VAR_0->cbp & 0x8000) >> 12;",
"}",
"}",
"if(IS_INTER(VAR_1) || IS_DIRECT(VAR_1)){",
"int VAR_12;",
"for(VAR_12=0; VAR_12<VAR_0->list_count; VAR_12++){",
"if(USES_LIST(VAR_5, VAR_12)){",
"const int b_xy= VAR_0->mb2b_xy[VAR_3] + 3*VAR_0->b_stride;",
"const int b8_xy= 4*VAR_3 + 2;",
"int (*ref2frm)[64] = VAR_0->ref2frm[ VAR_0->slice_table[VAR_3]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);",
"AV_COPY128(VAR_0->mv_cache[VAR_12][scan8[0] + 0 - 1*8], s->current_picture.motion_val[VAR_12][b_xy + 0]);",
"VAR_0->ref_cache[VAR_12][scan8[0] + 0 - 1*8]=\nVAR_0->ref_cache[VAR_12][scan8[0] + 1 - 1*8]= ref2frm[VAR_12][s->current_picture.ref_index[VAR_12][b8_xy + 0]];",
"VAR_0->ref_cache[VAR_12][scan8[0] + 2 - 1*8]=\nVAR_0->ref_cache[VAR_12][scan8[0] + 3 - 1*8]= ref2frm[VAR_12][s->current_picture.ref_index[VAR_12][b8_xy + 1]];",
"}else{",
"AV_ZERO128(VAR_0->mv_cache[VAR_12][scan8[0] + 0 - 1*8]);",
"AV_WN32A(&VAR_0->ref_cache[VAR_12][scan8[0] + 0 - 1*8], ((LIST_NOT_USED)&0xFF)*0x01010101u);",
"}",
"if(!IS_INTERLACED(VAR_1^VAR_6[0])){",
"if(USES_LIST(VAR_6[0], VAR_12)){",
"const int b_xy= VAR_0->mb2b_xy[VAR_4[0]] + 3;",
"const int b8_xy= 4*VAR_4[0] + 1;",
"int (*ref2frm)[64] = VAR_0->ref2frm[ VAR_0->slice_table[VAR_4[0]]&(MAX_SLICES-1) ][0] + (MB_MBAFF ? 20 : 2);",
"AV_COPY32(VAR_0->mv_cache[VAR_12][scan8[0] - 1 + 0 ], s->current_picture.motion_val[VAR_12][b_xy + VAR_0->b_stride*0]);",
"AV_COPY32(VAR_0->mv_cache[VAR_12][scan8[0] - 1 + 8 ], s->current_picture.motion_val[VAR_12][b_xy + VAR_0->b_stride*1]);",
"AV_COPY32(VAR_0->mv_cache[VAR_12][scan8[0] - 1 +16 ], s->current_picture.motion_val[VAR_12][b_xy + VAR_0->b_stride*2]);",
"AV_COPY32(VAR_0->mv_cache[VAR_12][scan8[0] - 1 +24 ], s->current_picture.motion_val[VAR_12][b_xy + VAR_0->b_stride*3]);",
"VAR_0->ref_cache[VAR_12][scan8[0] - 1 + 0 ]=\nVAR_0->ref_cache[VAR_12][scan8[0] - 1 + 8 ]= ref2frm[VAR_12][s->current_picture.ref_index[VAR_12][b8_xy + 2*0]];",
"VAR_0->ref_cache[VAR_12][scan8[0] - 1 +16 ]=\nVAR_0->ref_cache[VAR_12][scan8[0] - 1 +24 ]= ref2frm[VAR_12][s->current_picture.ref_index[VAR_12][b8_xy + 2*1]];",
"}else{",
"AV_ZERO32(VAR_0->mv_cache [VAR_12][scan8[0] - 1 + 0 ]);",
"AV_ZERO32(VAR_0->mv_cache [VAR_12][scan8[0] - 1 + 8 ]);",
"AV_ZERO32(VAR_0->mv_cache [VAR_12][scan8[0] - 1 +16 ]);",
"AV_ZERO32(VAR_0->mv_cache [VAR_12][scan8[0] - 1 +24 ]);",
"VAR_0->ref_cache[VAR_12][scan8[0] - 1 + 0 ]=\nVAR_0->ref_cache[VAR_12][scan8[0] - 1 + 8 ]=\nVAR_0->ref_cache[VAR_12][scan8[0] - 1 + 16 ]=\nVAR_0->ref_cache[VAR_12][scan8[0] - 1 + 24 ]= LIST_NOT_USED;",
"}",
"}",
"}",
"}",
"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,
0,
0,
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
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
63
],
[
65
],
[
67
],
[
69
],
[
75
],
[
77
],
[
79,
81,
83
],
[
85,
87
],
[
89,
91,
93
],
[
95
],
[
97
],
[
101
],
[
103
],
[
105
],
[
107
],
[
109
],
[
111
],
[
113
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
129,
131
],
[
135
],
[
137
],
[
139
],
[
141
],
[
145
],
[
149
],
[
151
],
[
153
],
[
155
],
[
157
],
[
159
],
[
161
],
[
165
],
[
167
],
[
169
],
[
171
],
[
173
],
[
175
],
[
177
],
[
179
],
[
183
],
[
185
],
[
187
],
[
189
],
[
191
],
[
193
],
[
195
],
[
197
],
[
199
],
[
203
],
[
205
],
[
207
],
[
209
],
[
211
],
[
213
],
[
217
],
[
219
],
[
243
],
[
245
],
[
247
],
[
251
],
[
253
],
[
255
],
[
257
],
[
259
],
[
261
],
[
267
],
[
269
],
[
271,
273
],
[
275,
277
],
[
279
],
[
281
],
[
283,
285
],
[
287
],
[
289
],
[
291,
293
],
[
295
],
[
299
],
[
301,
303
],
[
307,
309
],
[
313,
315
],
[
319,
321
],
[
323
],
[
325
],
[
329
],
[
331
],
[
333
],
[
335
],
[
337
],
[
339
],
[
341
],
[
343
],
[
345,
347
],
[
349,
351
],
[
353
],
[
355
],
[
357
],
[
359
],
[
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
],
[
417
],
[
419
]
]
|
17,066 | static void test_visitor_in_list(TestInputVisitorData *data,
const void *unused)
{
UserDefOneList *item, *head = NULL;
Error *err = NULL;
Visitor *v;
int i;
v = visitor_input_test_init(data, "[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, { 'string': 'string2', 'integer': 44 } ]");
visit_type_UserDefOneList(v, &head, NULL, &err);
g_assert(!err);
g_assert(head != NULL);
for (i = 0, item = head; item; item = item->next, i++) {
char string[12];
snprintf(string, sizeof(string), "string%d", i);
g_assert_cmpstr(item->value->string, ==, string);
g_assert_cmpint(item->value->base->integer, ==, 42 + i);
}
qapi_free_UserDefOneList(head);
}
| false | qemu | ddf21908961073199f3d186204da4810f2ea150b | static void test_visitor_in_list(TestInputVisitorData *data,
const void *unused)
{
UserDefOneList *item, *head = NULL;
Error *err = NULL;
Visitor *v;
int i;
v = visitor_input_test_init(data, "[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, { 'string': 'string2', 'integer': 44 } ]");
visit_type_UserDefOneList(v, &head, NULL, &err);
g_assert(!err);
g_assert(head != NULL);
for (i = 0, item = head; item; item = item->next, i++) {
char string[12];
snprintf(string, sizeof(string), "string%d", i);
g_assert_cmpstr(item->value->string, ==, string);
g_assert_cmpint(item->value->base->integer, ==, 42 + i);
}
qapi_free_UserDefOneList(head);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(TestInputVisitorData *VAR_0,
const void *VAR_1)
{
UserDefOneList *item, *head = NULL;
Error *err = NULL;
Visitor *v;
int VAR_2;
v = visitor_input_test_init(VAR_0, "[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, { 'string': 'string2', 'integer': 44 } ]");
visit_type_UserDefOneList(v, &head, NULL, &err);
g_assert(!err);
g_assert(head != NULL);
for (VAR_2 = 0, item = head; item; item = item->next, VAR_2++) {
char string[12];
snprintf(string, sizeof(string), "string%d", VAR_2);
g_assert_cmpstr(item->value->string, ==, string);
g_assert_cmpint(item->value->base->integer, ==, 42 + VAR_2);
}
qapi_free_UserDefOneList(head);
}
| [
"static void FUNC_0(TestInputVisitorData *VAR_0,\nconst void *VAR_1)\n{",
"UserDefOneList *item, *head = NULL;",
"Error *err = NULL;",
"Visitor *v;",
"int VAR_2;",
"v = visitor_input_test_init(VAR_0, \"[ { 'string': 'string0', 'integer': 42 }, { 'string': 'string1', 'integer': 43 }, { 'string': 'string2', 'integer': 44 } ]\");",
"visit_type_UserDefOneList(v, &head, NULL, &err);",
"g_assert(!err);",
"g_assert(head != NULL);",
"for (VAR_2 = 0, item = head; item; item = item->next, VAR_2++) {",
"char string[12];",
"snprintf(string, sizeof(string), \"string%d\", VAR_2);",
"g_assert_cmpstr(item->value->string, ==, string);",
"g_assert_cmpint(item->value->base->integer, ==, 42 + VAR_2);",
"}",
"qapi_free_UserDefOneList(head);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
21
],
[
23
],
[
25
],
[
29
],
[
31
],
[
35
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
]
]
|
17,067 | static inline void tcg_out_ext8u(TCGContext *s, int dest, int src)
{
/* movzbl */
assert(src < 4 || TCG_TARGET_REG_BITS == 64);
tcg_out_modrm(s, OPC_MOVZBL + P_REXB_RM, dest, src);
}
| false | qemu | eabb7b91b36b202b4dac2df2d59d698e3aff197a | static inline void tcg_out_ext8u(TCGContext *s, int dest, int src)
{
assert(src < 4 || TCG_TARGET_REG_BITS == 64);
tcg_out_modrm(s, OPC_MOVZBL + P_REXB_RM, dest, src);
}
| {
"code": [],
"line_no": []
} | static inline void FUNC_0(TCGContext *VAR_0, int VAR_1, int VAR_2)
{
assert(VAR_2 < 4 || TCG_TARGET_REG_BITS == 64);
tcg_out_modrm(VAR_0, OPC_MOVZBL + P_REXB_RM, VAR_1, VAR_2);
}
| [
"static inline void FUNC_0(TCGContext *VAR_0, int VAR_1, int VAR_2)\n{",
"assert(VAR_2 < 4 || TCG_TARGET_REG_BITS == 64);",
"tcg_out_modrm(VAR_0, OPC_MOVZBL + P_REXB_RM, VAR_1, VAR_2);",
"}"
]
| [
0,
0,
0,
0
]
| [
[
1,
3
],
[
7
],
[
9
],
[
11
]
]
|
17,068 | static int cpu_post_load(void *opaque, int version_id)
{
ARMCPU *cpu = opaque;
int i, v;
/* Update the values list from the incoming migration data.
* Anything in the incoming data which we don't know about is
* a migration failure; anything we know about but the incoming
* data doesn't specify retains its current (reset) value.
* The indexes list remains untouched -- we only inspect the
* incoming migration index list so we can match the values array
* entries with the right slots in our own values array.
*/
for (i = 0, v = 0; i < cpu->cpreg_array_len
&& v < cpu->cpreg_vmstate_array_len; i++) {
if (cpu->cpreg_vmstate_indexes[v] > cpu->cpreg_indexes[i]) {
/* register in our list but not incoming : skip it */
continue;
}
if (cpu->cpreg_vmstate_indexes[v] < cpu->cpreg_indexes[i]) {
/* register in their list but not ours: fail migration */
return -1;
}
/* matching register, copy the value over */
cpu->cpreg_values[i] = cpu->cpreg_vmstate_values[v];
v++;
}
if (kvm_enabled()) {
if (!write_list_to_kvmstate(cpu)) {
return -1;
}
/* Note that it's OK for the TCG side not to know about
* every register in the list; KVM is authoritative if
* we're using it.
*/
write_list_to_cpustate(cpu);
} else {
if (!write_list_to_cpustate(cpu)) {
return -1;
}
}
hw_breakpoint_update_all(cpu);
hw_watchpoint_update_all(cpu);
return 0;
}
| false | qemu | 4b7a6bf402bd064605c287eecadc493ccf2d4897 | static int cpu_post_load(void *opaque, int version_id)
{
ARMCPU *cpu = opaque;
int i, v;
for (i = 0, v = 0; i < cpu->cpreg_array_len
&& v < cpu->cpreg_vmstate_array_len; i++) {
if (cpu->cpreg_vmstate_indexes[v] > cpu->cpreg_indexes[i]) {
continue;
}
if (cpu->cpreg_vmstate_indexes[v] < cpu->cpreg_indexes[i]) {
return -1;
}
cpu->cpreg_values[i] = cpu->cpreg_vmstate_values[v];
v++;
}
if (kvm_enabled()) {
if (!write_list_to_kvmstate(cpu)) {
return -1;
}
write_list_to_cpustate(cpu);
} else {
if (!write_list_to_cpustate(cpu)) {
return -1;
}
}
hw_breakpoint_update_all(cpu);
hw_watchpoint_update_all(cpu);
return 0;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(void *VAR_0, int VAR_1)
{
ARMCPU *cpu = VAR_0;
int VAR_2, VAR_3;
for (VAR_2 = 0, VAR_3 = 0; VAR_2 < cpu->cpreg_array_len
&& VAR_3 < cpu->cpreg_vmstate_array_len; VAR_2++) {
if (cpu->cpreg_vmstate_indexes[VAR_3] > cpu->cpreg_indexes[VAR_2]) {
continue;
}
if (cpu->cpreg_vmstate_indexes[VAR_3] < cpu->cpreg_indexes[VAR_2]) {
return -1;
}
cpu->cpreg_values[VAR_2] = cpu->cpreg_vmstate_values[VAR_3];
VAR_3++;
}
if (kvm_enabled()) {
if (!write_list_to_kvmstate(cpu)) {
return -1;
}
write_list_to_cpustate(cpu);
} else {
if (!write_list_to_cpustate(cpu)) {
return -1;
}
}
hw_breakpoint_update_all(cpu);
hw_watchpoint_update_all(cpu);
return 0;
}
| [
"static int FUNC_0(void *VAR_0, int VAR_1)\n{",
"ARMCPU *cpu = VAR_0;",
"int VAR_2, VAR_3;",
"for (VAR_2 = 0, VAR_3 = 0; VAR_2 < cpu->cpreg_array_len",
"&& VAR_3 < cpu->cpreg_vmstate_array_len; VAR_2++) {",
"if (cpu->cpreg_vmstate_indexes[VAR_3] > cpu->cpreg_indexes[VAR_2]) {",
"continue;",
"}",
"if (cpu->cpreg_vmstate_indexes[VAR_3] < cpu->cpreg_indexes[VAR_2]) {",
"return -1;",
"}",
"cpu->cpreg_values[VAR_2] = cpu->cpreg_vmstate_values[VAR_3];",
"VAR_3++;",
"}",
"if (kvm_enabled()) {",
"if (!write_list_to_kvmstate(cpu)) {",
"return -1;",
"}",
"write_list_to_cpustate(cpu);",
"} else {",
"if (!write_list_to_cpustate(cpu)) {",
"return -1;",
"}",
"}",
"hw_breakpoint_update_all(cpu);",
"hw_watchpoint_update_all(cpu);",
"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
]
| [
[
1,
3
],
[
5
],
[
7
],
[
29
],
[
31
],
[
33
],
[
37
],
[
39
],
[
41
],
[
45
],
[
47
],
[
51
],
[
53
],
[
55
],
[
59
],
[
61
],
[
63
],
[
65
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
],
[
89
],
[
91
],
[
95
],
[
97
]
]
|
17,069 | static void vhost_virtqueue_stop(struct vhost_dev *dev,
struct VirtIODevice *vdev,
struct vhost_virtqueue *vq,
unsigned idx)
{
int vhost_vq_index = dev->vhost_ops->vhost_get_vq_index(dev, idx);
struct vhost_vring_state state = {
.index = vhost_vq_index,
};
int r;
r = dev->vhost_ops->vhost_get_vring_base(dev, &state);
if (r < 0) {
fprintf(stderr, "vhost VQ %d ring restore failed: %d\n", idx, r);
fflush(stderr);
}
virtio_queue_set_last_avail_idx(vdev, idx, state.num);
virtio_queue_invalidate_signalled_used(vdev, idx);
/* In the cross-endian case, we need to reset the vring endianness to
* native as legacy devices expect so by default.
*/
if (!virtio_vdev_has_feature(vdev, VIRTIO_F_VERSION_1) &&
vhost_needs_vring_endian(vdev)) {
r = vhost_virtqueue_set_vring_endian_legacy(dev,
!virtio_is_big_endian(vdev),
vhost_vq_index);
if (r < 0) {
error_report("failed to reset vring endianness");
}
}
assert (r >= 0);
cpu_physical_memory_unmap(vq->ring, virtio_queue_get_ring_size(vdev, idx),
0, virtio_queue_get_ring_size(vdev, idx));
cpu_physical_memory_unmap(vq->used, virtio_queue_get_used_size(vdev, idx),
1, virtio_queue_get_used_size(vdev, idx));
cpu_physical_memory_unmap(vq->avail, virtio_queue_get_avail_size(vdev, idx),
0, virtio_queue_get_avail_size(vdev, idx));
cpu_physical_memory_unmap(vq->desc, virtio_queue_get_desc_size(vdev, idx),
0, virtio_queue_get_desc_size(vdev, idx));
}
| false | qemu | e58481234ef9c132554cc529d9981ebd78fb6903 | static void vhost_virtqueue_stop(struct vhost_dev *dev,
struct VirtIODevice *vdev,
struct vhost_virtqueue *vq,
unsigned idx)
{
int vhost_vq_index = dev->vhost_ops->vhost_get_vq_index(dev, idx);
struct vhost_vring_state state = {
.index = vhost_vq_index,
};
int r;
r = dev->vhost_ops->vhost_get_vring_base(dev, &state);
if (r < 0) {
fprintf(stderr, "vhost VQ %d ring restore failed: %d\n", idx, r);
fflush(stderr);
}
virtio_queue_set_last_avail_idx(vdev, idx, state.num);
virtio_queue_invalidate_signalled_used(vdev, idx);
if (!virtio_vdev_has_feature(vdev, VIRTIO_F_VERSION_1) &&
vhost_needs_vring_endian(vdev)) {
r = vhost_virtqueue_set_vring_endian_legacy(dev,
!virtio_is_big_endian(vdev),
vhost_vq_index);
if (r < 0) {
error_report("failed to reset vring endianness");
}
}
assert (r >= 0);
cpu_physical_memory_unmap(vq->ring, virtio_queue_get_ring_size(vdev, idx),
0, virtio_queue_get_ring_size(vdev, idx));
cpu_physical_memory_unmap(vq->used, virtio_queue_get_used_size(vdev, idx),
1, virtio_queue_get_used_size(vdev, idx));
cpu_physical_memory_unmap(vq->avail, virtio_queue_get_avail_size(vdev, idx),
0, virtio_queue_get_avail_size(vdev, idx));
cpu_physical_memory_unmap(vq->desc, virtio_queue_get_desc_size(vdev, idx),
0, virtio_queue_get_desc_size(vdev, idx));
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(struct vhost_dev *VAR_0,
struct VirtIODevice *VAR_1,
struct vhost_virtqueue *VAR_2,
unsigned VAR_3)
{
int VAR_4 = VAR_0->vhost_ops->vhost_get_vq_index(VAR_0, VAR_3);
struct vhost_vring_state VAR_5 = {
.index = VAR_4,
};
int VAR_6;
VAR_6 = VAR_0->vhost_ops->vhost_get_vring_base(VAR_0, &VAR_5);
if (VAR_6 < 0) {
fprintf(stderr, "vhost VQ %d ring restore failed: %d\n", VAR_3, VAR_6);
fflush(stderr);
}
virtio_queue_set_last_avail_idx(VAR_1, VAR_3, VAR_5.num);
virtio_queue_invalidate_signalled_used(VAR_1, VAR_3);
if (!virtio_vdev_has_feature(VAR_1, VIRTIO_F_VERSION_1) &&
vhost_needs_vring_endian(VAR_1)) {
VAR_6 = vhost_virtqueue_set_vring_endian_legacy(VAR_0,
!virtio_is_big_endian(VAR_1),
VAR_4);
if (VAR_6 < 0) {
error_report("failed to reset vring endianness");
}
}
assert (VAR_6 >= 0);
cpu_physical_memory_unmap(VAR_2->ring, virtio_queue_get_ring_size(VAR_1, VAR_3),
0, virtio_queue_get_ring_size(VAR_1, VAR_3));
cpu_physical_memory_unmap(VAR_2->used, virtio_queue_get_used_size(VAR_1, VAR_3),
1, virtio_queue_get_used_size(VAR_1, VAR_3));
cpu_physical_memory_unmap(VAR_2->avail, virtio_queue_get_avail_size(VAR_1, VAR_3),
0, virtio_queue_get_avail_size(VAR_1, VAR_3));
cpu_physical_memory_unmap(VAR_2->desc, virtio_queue_get_desc_size(VAR_1, VAR_3),
0, virtio_queue_get_desc_size(VAR_1, VAR_3));
}
| [
"static void FUNC_0(struct vhost_dev *VAR_0,\nstruct VirtIODevice *VAR_1,\nstruct vhost_virtqueue *VAR_2,\nunsigned VAR_3)\n{",
"int VAR_4 = VAR_0->vhost_ops->vhost_get_vq_index(VAR_0, VAR_3);",
"struct vhost_vring_state VAR_5 = {",
".index = VAR_4,\n};",
"int VAR_6;",
"VAR_6 = VAR_0->vhost_ops->vhost_get_vring_base(VAR_0, &VAR_5);",
"if (VAR_6 < 0) {",
"fprintf(stderr, \"vhost VQ %d ring restore failed: %d\\n\", VAR_3, VAR_6);",
"fflush(stderr);",
"}",
"virtio_queue_set_last_avail_idx(VAR_1, VAR_3, VAR_5.num);",
"virtio_queue_invalidate_signalled_used(VAR_1, VAR_3);",
"if (!virtio_vdev_has_feature(VAR_1, VIRTIO_F_VERSION_1) &&\nvhost_needs_vring_endian(VAR_1)) {",
"VAR_6 = vhost_virtqueue_set_vring_endian_legacy(VAR_0,\n!virtio_is_big_endian(VAR_1),\nVAR_4);",
"if (VAR_6 < 0) {",
"error_report(\"failed to reset vring endianness\");",
"}",
"}",
"assert (VAR_6 >= 0);",
"cpu_physical_memory_unmap(VAR_2->ring, virtio_queue_get_ring_size(VAR_1, VAR_3),\n0, virtio_queue_get_ring_size(VAR_1, VAR_3));",
"cpu_physical_memory_unmap(VAR_2->used, virtio_queue_get_used_size(VAR_1, VAR_3),\n1, virtio_queue_get_used_size(VAR_1, VAR_3));",
"cpu_physical_memory_unmap(VAR_2->avail, virtio_queue_get_avail_size(VAR_1, VAR_3),\n0, virtio_queue_get_avail_size(VAR_1, VAR_3));",
"cpu_physical_memory_unmap(VAR_2->desc, virtio_queue_get_desc_size(VAR_1, VAR_3),\n0, virtio_queue_get_desc_size(VAR_1, VAR_3));",
"}"
]
| [
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
],
[
45,
47
],
[
49,
51,
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
65
],
[
67,
69
],
[
71,
73
],
[
75,
77
],
[
79,
81
],
[
83
]
]
|
17,070 | static void pci_map(PCIDevice * pci_dev, int region_num,
uint32_t addr, uint32_t size, int type)
{
PCIEEPRO100State *d = DO_UPCAST(PCIEEPRO100State, dev, pci_dev);
EEPRO100State *s = &d->eepro100;
logout("region %d, addr=0x%08x, size=0x%08x, type=%d\n",
region_num, addr, size, type);
assert(region_num == 1);
register_ioport_write(addr, size, 1, ioport_write1, s);
register_ioport_read(addr, size, 1, ioport_read1, s);
register_ioport_write(addr, size, 2, ioport_write2, s);
register_ioport_read(addr, size, 2, ioport_read2, s);
register_ioport_write(addr, size, 4, ioport_write4, s);
register_ioport_read(addr, size, 4, ioport_read4, s);
s->region[region_num] = addr;
}
| false | qemu | 273a2142176098fe2c27f263d86ad66b133b43cb | static void pci_map(PCIDevice * pci_dev, int region_num,
uint32_t addr, uint32_t size, int type)
{
PCIEEPRO100State *d = DO_UPCAST(PCIEEPRO100State, dev, pci_dev);
EEPRO100State *s = &d->eepro100;
logout("region %d, addr=0x%08x, size=0x%08x, type=%d\n",
region_num, addr, size, type);
assert(region_num == 1);
register_ioport_write(addr, size, 1, ioport_write1, s);
register_ioport_read(addr, size, 1, ioport_read1, s);
register_ioport_write(addr, size, 2, ioport_write2, s);
register_ioport_read(addr, size, 2, ioport_read2, s);
register_ioport_write(addr, size, 4, ioport_write4, s);
register_ioport_read(addr, size, 4, ioport_read4, s);
s->region[region_num] = addr;
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(PCIDevice * VAR_0, int VAR_1,
uint32_t VAR_2, uint32_t VAR_3, int VAR_4)
{
PCIEEPRO100State *d = DO_UPCAST(PCIEEPRO100State, dev, VAR_0);
EEPRO100State *s = &d->eepro100;
logout("region %d, VAR_2=0x%08x, VAR_3=0x%08x, VAR_4=%d\n",
VAR_1, VAR_2, VAR_3, VAR_4);
assert(VAR_1 == 1);
register_ioport_write(VAR_2, VAR_3, 1, ioport_write1, s);
register_ioport_read(VAR_2, VAR_3, 1, ioport_read1, s);
register_ioport_write(VAR_2, VAR_3, 2, ioport_write2, s);
register_ioport_read(VAR_2, VAR_3, 2, ioport_read2, s);
register_ioport_write(VAR_2, VAR_3, 4, ioport_write4, s);
register_ioport_read(VAR_2, VAR_3, 4, ioport_read4, s);
s->region[VAR_1] = VAR_2;
}
| [
"static void FUNC_0(PCIDevice * VAR_0, int VAR_1,\nuint32_t VAR_2, uint32_t VAR_3, int VAR_4)\n{",
"PCIEEPRO100State *d = DO_UPCAST(PCIEEPRO100State, dev, VAR_0);",
"EEPRO100State *s = &d->eepro100;",
"logout(\"region %d, VAR_2=0x%08x, VAR_3=0x%08x, VAR_4=%d\\n\",\nVAR_1, VAR_2, VAR_3, VAR_4);",
"assert(VAR_1 == 1);",
"register_ioport_write(VAR_2, VAR_3, 1, ioport_write1, s);",
"register_ioport_read(VAR_2, VAR_3, 1, ioport_read1, s);",
"register_ioport_write(VAR_2, VAR_3, 2, ioport_write2, s);",
"register_ioport_read(VAR_2, VAR_3, 2, ioport_read2, s);",
"register_ioport_write(VAR_2, VAR_3, 4, ioport_write4, s);",
"register_ioport_read(VAR_2, VAR_3, 4, ioport_read4, s);",
"s->region[VAR_1] = VAR_2;",
"}"
]
| [
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
],
[
29
],
[
31
],
[
35
],
[
37
]
]
|
17,071 | static void host_signal_handler(int host_signum, siginfo_t *info,
void *puc)
{
int sig;
target_siginfo_t tinfo;
/* the CPU emulator uses some host signals to detect exceptions,
we forward to it some signals */
if ((host_signum == SIGSEGV || host_signum == SIGBUS)
&& info->si_code > 0) {
if (cpu_signal_handler(host_signum, info, puc))
return;
}
/* get target signal number */
sig = host_to_target_signal(host_signum);
if (sig < 1 || sig > TARGET_NSIG)
return;
#if defined(DEBUG_SIGNAL)
fprintf(stderr, "qemu: got signal %d\n", sig);
#endif
host_to_target_siginfo_noswap(&tinfo, info);
if (queue_signal(thread_env, sig, &tinfo) == 1) {
/* interrupt the virtual CPU as soon as possible */
cpu_interrupt(thread_env, CPU_INTERRUPT_EXIT);
}
}
| false | qemu | 3098dba01c7daab60762b6f6624ea88c0d6cb65a | static void host_signal_handler(int host_signum, siginfo_t *info,
void *puc)
{
int sig;
target_siginfo_t tinfo;
if ((host_signum == SIGSEGV || host_signum == SIGBUS)
&& info->si_code > 0) {
if (cpu_signal_handler(host_signum, info, puc))
return;
}
sig = host_to_target_signal(host_signum);
if (sig < 1 || sig > TARGET_NSIG)
return;
#if defined(DEBUG_SIGNAL)
fprintf(stderr, "qemu: got signal %d\n", sig);
#endif
host_to_target_siginfo_noswap(&tinfo, info);
if (queue_signal(thread_env, sig, &tinfo) == 1) {
cpu_interrupt(thread_env, CPU_INTERRUPT_EXIT);
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(int VAR_0, siginfo_t *VAR_1,
void *VAR_2)
{
int VAR_3;
target_siginfo_t tinfo;
if ((VAR_0 == SIGSEGV || VAR_0 == SIGBUS)
&& VAR_1->si_code > 0) {
if (cpu_signal_handler(VAR_0, VAR_1, VAR_2))
return;
}
VAR_3 = host_to_target_signal(VAR_0);
if (VAR_3 < 1 || VAR_3 > TARGET_NSIG)
return;
#if defined(DEBUG_SIGNAL)
fprintf(stderr, "qemu: got signal %d\n", VAR_3);
#endif
host_to_target_siginfo_noswap(&tinfo, VAR_1);
if (queue_signal(thread_env, VAR_3, &tinfo) == 1) {
cpu_interrupt(thread_env, CPU_INTERRUPT_EXIT);
}
}
| [
"static void FUNC_0(int VAR_0, siginfo_t *VAR_1,\nvoid *VAR_2)\n{",
"int VAR_3;",
"target_siginfo_t tinfo;",
"if ((VAR_0 == SIGSEGV || VAR_0 == SIGBUS)\n&& VAR_1->si_code > 0) {",
"if (cpu_signal_handler(VAR_0, VAR_1, VAR_2))\nreturn;",
"}",
"VAR_3 = host_to_target_signal(VAR_0);",
"if (VAR_3 < 1 || VAR_3 > TARGET_NSIG)\nreturn;",
"#if defined(DEBUG_SIGNAL)\nfprintf(stderr, \"qemu: got signal %d\\n\", VAR_3);",
"#endif\nhost_to_target_siginfo_noswap(&tinfo, VAR_1);",
"if (queue_signal(thread_env, VAR_3, &tinfo) == 1) {",
"cpu_interrupt(thread_env, CPU_INTERRUPT_EXIT);",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
17,
19
],
[
21,
23
],
[
25
],
[
31
],
[
33,
35
],
[
37,
39
],
[
41,
43
],
[
45
],
[
49
],
[
51
],
[
53
]
]
|
17,073 | static char *scsibus_get_fw_dev_path(DeviceState *dev)
{
SCSIDevice *d = SCSI_DEVICE(dev);
char path[100];
snprintf(path, sizeof(path), "channel@%x/%s@%x,%x", d->channel,
qdev_fw_name(dev), d->id, d->lun);
return strdup(path);
}
| false | qemu | a5cf8262e4eb9c4646434e2c6211ef8608db3233 | static char *scsibus_get_fw_dev_path(DeviceState *dev)
{
SCSIDevice *d = SCSI_DEVICE(dev);
char path[100];
snprintf(path, sizeof(path), "channel@%x/%s@%x,%x", d->channel,
qdev_fw_name(dev), d->id, d->lun);
return strdup(path);
}
| {
"code": [],
"line_no": []
} | static char *FUNC_0(DeviceState *VAR_0)
{
SCSIDevice *d = SCSI_DEVICE(VAR_0);
char VAR_1[100];
snprintf(VAR_1, sizeof(VAR_1), "channel@%x/%s@%x,%x", d->channel,
qdev_fw_name(VAR_0), d->id, d->lun);
return strdup(VAR_1);
}
| [
"static char *FUNC_0(DeviceState *VAR_0)\n{",
"SCSIDevice *d = SCSI_DEVICE(VAR_0);",
"char VAR_1[100];",
"snprintf(VAR_1, sizeof(VAR_1), \"channel@%x/%s@%x,%x\", d->channel,\nqdev_fw_name(VAR_0), d->id, d->lun);",
"return strdup(VAR_1);",
"}"
]
| [
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
11,
13
],
[
17
],
[
19
]
]
|
17,074 | static void lsi_do_command(LSIState *s)
{
SCSIDevice *dev;
uint8_t buf[16];
uint32_t id;
int n;
DPRINTF("Send command len=%d\n", s->dbc);
if (s->dbc > 16)
s->dbc = 16;
cpu_physical_memory_read(s->dnad, buf, s->dbc);
s->sfbr = buf[0];
s->command_complete = 0;
id = (s->select_tag >> 8) & 0xf;
dev = s->bus.devs[id];
if (!dev) {
lsi_bad_selection(s, id);
return;
}
assert(s->current == NULL);
s->current = qemu_mallocz(sizeof(lsi_request));
s->current->tag = s->select_tag;
s->current->req = scsi_req_new(dev, s->current->tag, s->current_lun,
s->current);
n = scsi_req_enqueue(s->current->req, buf);
if (n) {
if (n > 0) {
lsi_set_phase(s, PHASE_DI);
} else if (n < 0) {
lsi_set_phase(s, PHASE_DO);
}
scsi_req_continue(s->current->req);
}
if (!s->command_complete) {
if (n) {
/* Command did not complete immediately so disconnect. */
lsi_add_msg_byte(s, 2); /* SAVE DATA POINTER */
lsi_add_msg_byte(s, 4); /* DISCONNECT */
/* wait data */
lsi_set_phase(s, PHASE_MI);
s->msg_action = 1;
lsi_queue_command(s);
} else {
/* wait command complete */
lsi_set_phase(s, PHASE_DI);
}
}
}
| false | qemu | c39ce112b60ffafbaf700853e32bea74cbb2c148 | static void lsi_do_command(LSIState *s)
{
SCSIDevice *dev;
uint8_t buf[16];
uint32_t id;
int n;
DPRINTF("Send command len=%d\n", s->dbc);
if (s->dbc > 16)
s->dbc = 16;
cpu_physical_memory_read(s->dnad, buf, s->dbc);
s->sfbr = buf[0];
s->command_complete = 0;
id = (s->select_tag >> 8) & 0xf;
dev = s->bus.devs[id];
if (!dev) {
lsi_bad_selection(s, id);
return;
}
assert(s->current == NULL);
s->current = qemu_mallocz(sizeof(lsi_request));
s->current->tag = s->select_tag;
s->current->req = scsi_req_new(dev, s->current->tag, s->current_lun,
s->current);
n = scsi_req_enqueue(s->current->req, buf);
if (n) {
if (n > 0) {
lsi_set_phase(s, PHASE_DI);
} else if (n < 0) {
lsi_set_phase(s, PHASE_DO);
}
scsi_req_continue(s->current->req);
}
if (!s->command_complete) {
if (n) {
lsi_add_msg_byte(s, 2);
lsi_add_msg_byte(s, 4);
lsi_set_phase(s, PHASE_MI);
s->msg_action = 1;
lsi_queue_command(s);
} else {
lsi_set_phase(s, PHASE_DI);
}
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(LSIState *VAR_0)
{
SCSIDevice *dev;
uint8_t buf[16];
uint32_t id;
int VAR_1;
DPRINTF("Send command len=%d\VAR_1", VAR_0->dbc);
if (VAR_0->dbc > 16)
VAR_0->dbc = 16;
cpu_physical_memory_read(VAR_0->dnad, buf, VAR_0->dbc);
VAR_0->sfbr = buf[0];
VAR_0->command_complete = 0;
id = (VAR_0->select_tag >> 8) & 0xf;
dev = VAR_0->bus.devs[id];
if (!dev) {
lsi_bad_selection(VAR_0, id);
return;
}
assert(VAR_0->current == NULL);
VAR_0->current = qemu_mallocz(sizeof(lsi_request));
VAR_0->current->tag = VAR_0->select_tag;
VAR_0->current->req = scsi_req_new(dev, VAR_0->current->tag, VAR_0->current_lun,
VAR_0->current);
VAR_1 = scsi_req_enqueue(VAR_0->current->req, buf);
if (VAR_1) {
if (VAR_1 > 0) {
lsi_set_phase(VAR_0, PHASE_DI);
} else if (VAR_1 < 0) {
lsi_set_phase(VAR_0, PHASE_DO);
}
scsi_req_continue(VAR_0->current->req);
}
if (!VAR_0->command_complete) {
if (VAR_1) {
lsi_add_msg_byte(VAR_0, 2);
lsi_add_msg_byte(VAR_0, 4);
lsi_set_phase(VAR_0, PHASE_MI);
VAR_0->msg_action = 1;
lsi_queue_command(VAR_0);
} else {
lsi_set_phase(VAR_0, PHASE_DI);
}
}
}
| [
"static void FUNC_0(LSIState *VAR_0)\n{",
"SCSIDevice *dev;",
"uint8_t buf[16];",
"uint32_t id;",
"int VAR_1;",
"DPRINTF(\"Send command len=%d\\VAR_1\", VAR_0->dbc);",
"if (VAR_0->dbc > 16)\nVAR_0->dbc = 16;",
"cpu_physical_memory_read(VAR_0->dnad, buf, VAR_0->dbc);",
"VAR_0->sfbr = buf[0];",
"VAR_0->command_complete = 0;",
"id = (VAR_0->select_tag >> 8) & 0xf;",
"dev = VAR_0->bus.devs[id];",
"if (!dev) {",
"lsi_bad_selection(VAR_0, id);",
"return;",
"}",
"assert(VAR_0->current == NULL);",
"VAR_0->current = qemu_mallocz(sizeof(lsi_request));",
"VAR_0->current->tag = VAR_0->select_tag;",
"VAR_0->current->req = scsi_req_new(dev, VAR_0->current->tag, VAR_0->current_lun,\nVAR_0->current);",
"VAR_1 = scsi_req_enqueue(VAR_0->current->req, buf);",
"if (VAR_1) {",
"if (VAR_1 > 0) {",
"lsi_set_phase(VAR_0, PHASE_DI);",
"} else if (VAR_1 < 0) {",
"lsi_set_phase(VAR_0, PHASE_DO);",
"}",
"scsi_req_continue(VAR_0->current->req);",
"}",
"if (!VAR_0->command_complete) {",
"if (VAR_1) {",
"lsi_add_msg_byte(VAR_0, 2);",
"lsi_add_msg_byte(VAR_0, 4);",
"lsi_set_phase(VAR_0, PHASE_MI);",
"VAR_0->msg_action = 1;",
"lsi_queue_command(VAR_0);",
"} else {",
"lsi_set_phase(VAR_0, PHASE_DI);",
"}",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
39
],
[
43
],
[
45
],
[
47
],
[
49,
51
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
79
],
[
81
],
[
85
],
[
87
],
[
89
],
[
91
],
[
95
],
[
97
],
[
99
],
[
101
]
]
|
17,075 | void ioinst_handle_chsc(S390CPU *cpu, uint32_t ipb)
{
ChscReq *req;
ChscResp *res;
uint64_t addr;
int reg;
uint16_t len;
uint16_t command;
CPUS390XState *env = &cpu->env;
uint8_t buf[TARGET_PAGE_SIZE];
trace_ioinst("chsc");
reg = (ipb >> 20) & 0x00f;
addr = env->regs[reg];
/* Page boundary? */
if (addr & 0xfff) {
program_interrupt(env, PGM_SPECIFICATION, 2);
return;
}
/*
* Reading sizeof(ChscReq) bytes is currently enough for all of our
* present CHSC sub-handlers ... if we ever need more, we should take
* care of req->len here first.
*/
if (s390_cpu_virt_mem_read(cpu, addr, reg, buf, sizeof(ChscReq))) {
return;
}
req = (ChscReq *)buf;
len = be16_to_cpu(req->len);
/* Length field valid? */
if ((len < 16) || (len > 4088) || (len & 7)) {
program_interrupt(env, PGM_OPERAND, 2);
return;
}
memset((char *)req + len, 0, TARGET_PAGE_SIZE - len);
res = (void *)((char *)req + len);
command = be16_to_cpu(req->command);
trace_ioinst_chsc_cmd(command, len);
switch (command) {
case CHSC_SCSC:
ioinst_handle_chsc_scsc(req, res);
break;
case CHSC_SCPD:
ioinst_handle_chsc_scpd(req, res);
break;
case CHSC_SDA:
ioinst_handle_chsc_sda(req, res);
break;
case CHSC_SEI:
ioinst_handle_chsc_sei(req, res);
break;
default:
ioinst_handle_chsc_unimplemented(res);
break;
}
if (!s390_cpu_virt_mem_write(cpu, addr + len, reg, res,
be16_to_cpu(res->len))) {
setcc(cpu, 0); /* Command execution complete */
}
}
| false | qemu | 7e01376daea75e888c370aab521a7d4aeaf2ffd1 | void ioinst_handle_chsc(S390CPU *cpu, uint32_t ipb)
{
ChscReq *req;
ChscResp *res;
uint64_t addr;
int reg;
uint16_t len;
uint16_t command;
CPUS390XState *env = &cpu->env;
uint8_t buf[TARGET_PAGE_SIZE];
trace_ioinst("chsc");
reg = (ipb >> 20) & 0x00f;
addr = env->regs[reg];
if (addr & 0xfff) {
program_interrupt(env, PGM_SPECIFICATION, 2);
return;
}
if (s390_cpu_virt_mem_read(cpu, addr, reg, buf, sizeof(ChscReq))) {
return;
}
req = (ChscReq *)buf;
len = be16_to_cpu(req->len);
if ((len < 16) || (len > 4088) || (len & 7)) {
program_interrupt(env, PGM_OPERAND, 2);
return;
}
memset((char *)req + len, 0, TARGET_PAGE_SIZE - len);
res = (void *)((char *)req + len);
command = be16_to_cpu(req->command);
trace_ioinst_chsc_cmd(command, len);
switch (command) {
case CHSC_SCSC:
ioinst_handle_chsc_scsc(req, res);
break;
case CHSC_SCPD:
ioinst_handle_chsc_scpd(req, res);
break;
case CHSC_SDA:
ioinst_handle_chsc_sda(req, res);
break;
case CHSC_SEI:
ioinst_handle_chsc_sei(req, res);
break;
default:
ioinst_handle_chsc_unimplemented(res);
break;
}
if (!s390_cpu_virt_mem_write(cpu, addr + len, reg, res,
be16_to_cpu(res->len))) {
setcc(cpu, 0);
}
}
| {
"code": [],
"line_no": []
} | void FUNC_0(S390CPU *VAR_0, uint32_t VAR_1)
{
ChscReq *req;
ChscResp *res;
uint64_t addr;
int VAR_2;
uint16_t len;
uint16_t command;
CPUS390XState *env = &VAR_0->env;
uint8_t buf[TARGET_PAGE_SIZE];
trace_ioinst("chsc");
VAR_2 = (VAR_1 >> 20) & 0x00f;
addr = env->regs[VAR_2];
if (addr & 0xfff) {
program_interrupt(env, PGM_SPECIFICATION, 2);
return;
}
if (s390_cpu_virt_mem_read(VAR_0, addr, VAR_2, buf, sizeof(ChscReq))) {
return;
}
req = (ChscReq *)buf;
len = be16_to_cpu(req->len);
if ((len < 16) || (len > 4088) || (len & 7)) {
program_interrupt(env, PGM_OPERAND, 2);
return;
}
memset((char *)req + len, 0, TARGET_PAGE_SIZE - len);
res = (void *)((char *)req + len);
command = be16_to_cpu(req->command);
trace_ioinst_chsc_cmd(command, len);
switch (command) {
case CHSC_SCSC:
ioinst_handle_chsc_scsc(req, res);
break;
case CHSC_SCPD:
ioinst_handle_chsc_scpd(req, res);
break;
case CHSC_SDA:
ioinst_handle_chsc_sda(req, res);
break;
case CHSC_SEI:
ioinst_handle_chsc_sei(req, res);
break;
default:
ioinst_handle_chsc_unimplemented(res);
break;
}
if (!s390_cpu_virt_mem_write(VAR_0, addr + len, VAR_2, res,
be16_to_cpu(res->len))) {
setcc(VAR_0, 0);
}
}
| [
"void FUNC_0(S390CPU *VAR_0, uint32_t VAR_1)\n{",
"ChscReq *req;",
"ChscResp *res;",
"uint64_t addr;",
"int VAR_2;",
"uint16_t len;",
"uint16_t command;",
"CPUS390XState *env = &VAR_0->env;",
"uint8_t buf[TARGET_PAGE_SIZE];",
"trace_ioinst(\"chsc\");",
"VAR_2 = (VAR_1 >> 20) & 0x00f;",
"addr = env->regs[VAR_2];",
"if (addr & 0xfff) {",
"program_interrupt(env, PGM_SPECIFICATION, 2);",
"return;",
"}",
"if (s390_cpu_virt_mem_read(VAR_0, addr, VAR_2, buf, sizeof(ChscReq))) {",
"return;",
"}",
"req = (ChscReq *)buf;",
"len = be16_to_cpu(req->len);",
"if ((len < 16) || (len > 4088) || (len & 7)) {",
"program_interrupt(env, PGM_OPERAND, 2);",
"return;",
"}",
"memset((char *)req + len, 0, TARGET_PAGE_SIZE - len);",
"res = (void *)((char *)req + len);",
"command = be16_to_cpu(req->command);",
"trace_ioinst_chsc_cmd(command, len);",
"switch (command) {",
"case CHSC_SCSC:\nioinst_handle_chsc_scsc(req, res);",
"break;",
"case CHSC_SCPD:\nioinst_handle_chsc_scpd(req, res);",
"break;",
"case CHSC_SDA:\nioinst_handle_chsc_sda(req, res);",
"break;",
"case CHSC_SEI:\nioinst_handle_chsc_sei(req, res);",
"break;",
"default:\nioinst_handle_chsc_unimplemented(res);",
"break;",
"}",
"if (!s390_cpu_virt_mem_write(VAR_0, addr + len, VAR_2, res,\nbe16_to_cpu(res->len))) {",
"setcc(VAR_0, 0);",
"}",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
],
[
19
],
[
23
],
[
25
],
[
27
],
[
31
],
[
33
],
[
35
],
[
37
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
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
],
[
113,
115
],
[
117
],
[
119
],
[
121
]
]
|
17,076 | static int ff_estimate_motion_b(MpegEncContext * s,
int mb_x, int mb_y, int16_t (*mv_table)[2], Picture *picture, int f_code)
{
int mx, my, range, dmin;
int xmin, ymin, xmax, ymax;
int rel_xmin, rel_ymin, rel_xmax, rel_ymax;
int pred_x=0, pred_y=0;
int P[10][2];
const int shift= 1+s->quarter_sample;
const int mot_stride = s->mb_width + 2;
const int mot_xy = (mb_y + 1)*mot_stride + mb_x + 1;
uint8_t * const ref_picture= picture->data[0];
uint16_t * const mv_penalty= s->me.mv_penalty[f_code] + MAX_MV;
int mv_scale;
s->me.penalty_factor = get_penalty_factor(s, s->avctx->me_cmp);
s->me.sub_penalty_factor= get_penalty_factor(s, s->avctx->me_sub_cmp);
s->me.mb_penalty_factor = get_penalty_factor(s, s->avctx->mb_cmp);
get_limits(s, &range, &xmin, &ymin, &xmax, &ymax, f_code);
rel_xmin= xmin - mb_x*16;
rel_xmax= xmax - mb_x*16;
rel_ymin= ymin - mb_y*16;
rel_ymax= ymax - mb_y*16;
switch(s->me_method) {
case ME_ZERO:
default:
no_motion_search(s, &mx, &my);
dmin = 0;
mx-= mb_x*16;
my-= mb_y*16;
break;
case ME_FULL:
dmin = full_motion_search(s, &mx, &my, range, xmin, ymin, xmax, ymax, ref_picture);
mx-= mb_x*16;
my-= mb_y*16;
break;
case ME_LOG:
dmin = log_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
mx-= mb_x*16;
my-= mb_y*16;
break;
case ME_PHODS:
dmin = phods_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
mx-= mb_x*16;
my-= mb_y*16;
break;
case ME_X1:
case ME_EPZS:
{
P_LEFT[0] = mv_table[mot_xy - 1][0];
P_LEFT[1] = mv_table[mot_xy - 1][1];
if(P_LEFT[0] > (rel_xmax<<shift)) P_LEFT[0] = (rel_xmax<<shift);
/* special case for first line */
if (mb_y) {
P_TOP[0] = mv_table[mot_xy - mot_stride ][0];
P_TOP[1] = mv_table[mot_xy - mot_stride ][1];
P_TOPRIGHT[0] = mv_table[mot_xy - mot_stride + 1 ][0];
P_TOPRIGHT[1] = mv_table[mot_xy - mot_stride + 1 ][1];
if(P_TOP[1] > (rel_ymax<<shift)) P_TOP[1]= (rel_ymax<<shift);
if(P_TOPRIGHT[0] < (rel_xmin<<shift)) P_TOPRIGHT[0]= (rel_xmin<<shift);
if(P_TOPRIGHT[1] > (rel_ymax<<shift)) P_TOPRIGHT[1]= (rel_ymax<<shift);
P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
}
pred_x= P_LEFT[0];
pred_y= P_LEFT[1];
}
if(mv_table == s->b_forw_mv_table){
mv_scale= (s->pb_time<<16) / (s->pp_time<<shift);
}else{
mv_scale= ((s->pb_time - s->pp_time)<<16) / (s->pp_time<<shift);
}
dmin = s->me.motion_search[0](s, 0, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
picture, s->p_mv_table, mv_scale, mv_penalty);
break;
}
dmin= s->me.sub_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
pred_x, pred_y, picture, 0, 0, mv_penalty);
if(s->avctx->me_sub_cmp != s->avctx->mb_cmp && !s->me.skip)
dmin= s->me.get_mb_score(s, mx, my, pred_x, pred_y, picture, mv_penalty);
//printf("%d %d %d %d//", s->mb_x, s->mb_y, mx, my);
// s->mb_type[mb_y*s->mb_width + mb_x]= mb_type;
mv_table[mot_xy][0]= mx;
mv_table[mot_xy][1]= my;
return dmin;
}
| false | FFmpeg | ebbcdc9ac0ea190748a1605bda86ce84466c8b4e | static int ff_estimate_motion_b(MpegEncContext * s,
int mb_x, int mb_y, int16_t (*mv_table)[2], Picture *picture, int f_code)
{
int mx, my, range, dmin;
int xmin, ymin, xmax, ymax;
int rel_xmin, rel_ymin, rel_xmax, rel_ymax;
int pred_x=0, pred_y=0;
int P[10][2];
const int shift= 1+s->quarter_sample;
const int mot_stride = s->mb_width + 2;
const int mot_xy = (mb_y + 1)*mot_stride + mb_x + 1;
uint8_t * const ref_picture= picture->data[0];
uint16_t * const mv_penalty= s->me.mv_penalty[f_code] + MAX_MV;
int mv_scale;
s->me.penalty_factor = get_penalty_factor(s, s->avctx->me_cmp);
s->me.sub_penalty_factor= get_penalty_factor(s, s->avctx->me_sub_cmp);
s->me.mb_penalty_factor = get_penalty_factor(s, s->avctx->mb_cmp);
get_limits(s, &range, &xmin, &ymin, &xmax, &ymax, f_code);
rel_xmin= xmin - mb_x*16;
rel_xmax= xmax - mb_x*16;
rel_ymin= ymin - mb_y*16;
rel_ymax= ymax - mb_y*16;
switch(s->me_method) {
case ME_ZERO:
default:
no_motion_search(s, &mx, &my);
dmin = 0;
mx-= mb_x*16;
my-= mb_y*16;
break;
case ME_FULL:
dmin = full_motion_search(s, &mx, &my, range, xmin, ymin, xmax, ymax, ref_picture);
mx-= mb_x*16;
my-= mb_y*16;
break;
case ME_LOG:
dmin = log_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
mx-= mb_x*16;
my-= mb_y*16;
break;
case ME_PHODS:
dmin = phods_motion_search(s, &mx, &my, range / 2, xmin, ymin, xmax, ymax, ref_picture);
mx-= mb_x*16;
my-= mb_y*16;
break;
case ME_X1:
case ME_EPZS:
{
P_LEFT[0] = mv_table[mot_xy - 1][0];
P_LEFT[1] = mv_table[mot_xy - 1][1];
if(P_LEFT[0] > (rel_xmax<<shift)) P_LEFT[0] = (rel_xmax<<shift);
if (mb_y) {
P_TOP[0] = mv_table[mot_xy - mot_stride ][0];
P_TOP[1] = mv_table[mot_xy - mot_stride ][1];
P_TOPRIGHT[0] = mv_table[mot_xy - mot_stride + 1 ][0];
P_TOPRIGHT[1] = mv_table[mot_xy - mot_stride + 1 ][1];
if(P_TOP[1] > (rel_ymax<<shift)) P_TOP[1]= (rel_ymax<<shift);
if(P_TOPRIGHT[0] < (rel_xmin<<shift)) P_TOPRIGHT[0]= (rel_xmin<<shift);
if(P_TOPRIGHT[1] > (rel_ymax<<shift)) P_TOPRIGHT[1]= (rel_ymax<<shift);
P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
}
pred_x= P_LEFT[0];
pred_y= P_LEFT[1];
}
if(mv_table == s->b_forw_mv_table){
mv_scale= (s->pb_time<<16) / (s->pp_time<<shift);
}else{
mv_scale= ((s->pb_time - s->pp_time)<<16) / (s->pp_time<<shift);
}
dmin = s->me.motion_search[0](s, 0, &mx, &my, P, pred_x, pred_y, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
picture, s->p_mv_table, mv_scale, mv_penalty);
break;
}
dmin= s->me.sub_motion_search(s, &mx, &my, dmin, rel_xmin, rel_ymin, rel_xmax, rel_ymax,
pred_x, pred_y, picture, 0, 0, mv_penalty);
if(s->avctx->me_sub_cmp != s->avctx->mb_cmp && !s->me.skip)
dmin= s->me.get_mb_score(s, mx, my, pred_x, pred_y, picture, mv_penalty);
mv_table[mot_xy][0]= mx;
mv_table[mot_xy][1]= my;
return dmin;
}
| {
"code": [],
"line_no": []
} | static int FUNC_0(MpegEncContext * VAR_0,
int VAR_1, int VAR_2, VAR_3 (*mv_table)[2], Picture *VAR_4, int VAR_5)
{
int VAR_6, VAR_7, VAR_8, VAR_9;
int VAR_10, VAR_11, VAR_12, VAR_13;
int VAR_14, VAR_15, VAR_16, VAR_17;
int VAR_18=0, VAR_19=0;
int VAR_20[10][2];
const int VAR_21= 1+VAR_0->quarter_sample;
const int VAR_22 = VAR_0->mb_width + 2;
const int VAR_23 = (VAR_2 + 1)*VAR_22 + VAR_1 + 1;
uint8_t * const ref_picture= VAR_4->data[0];
uint16_t * const mv_penalty= VAR_0->me.mv_penalty[VAR_5] + MAX_MV;
int VAR_24;
VAR_0->me.penalty_factor = get_penalty_factor(VAR_0, VAR_0->avctx->me_cmp);
VAR_0->me.sub_penalty_factor= get_penalty_factor(VAR_0, VAR_0->avctx->me_sub_cmp);
VAR_0->me.mb_penalty_factor = get_penalty_factor(VAR_0, VAR_0->avctx->mb_cmp);
get_limits(VAR_0, &VAR_8, &VAR_10, &VAR_11, &VAR_12, &VAR_13, VAR_5);
VAR_14= VAR_10 - VAR_1*16;
VAR_16= VAR_12 - VAR_1*16;
VAR_15= VAR_11 - VAR_2*16;
VAR_17= VAR_13 - VAR_2*16;
switch(VAR_0->me_method) {
case ME_ZERO:
default:
no_motion_search(VAR_0, &VAR_6, &VAR_7);
VAR_9 = 0;
VAR_6-= VAR_1*16;
VAR_7-= VAR_2*16;
break;
case ME_FULL:
VAR_9 = full_motion_search(VAR_0, &VAR_6, &VAR_7, VAR_8, VAR_10, VAR_11, VAR_12, VAR_13, ref_picture);
VAR_6-= VAR_1*16;
VAR_7-= VAR_2*16;
break;
case ME_LOG:
VAR_9 = log_motion_search(VAR_0, &VAR_6, &VAR_7, VAR_8 / 2, VAR_10, VAR_11, VAR_12, VAR_13, ref_picture);
VAR_6-= VAR_1*16;
VAR_7-= VAR_2*16;
break;
case ME_PHODS:
VAR_9 = phods_motion_search(VAR_0, &VAR_6, &VAR_7, VAR_8 / 2, VAR_10, VAR_11, VAR_12, VAR_13, ref_picture);
VAR_6-= VAR_1*16;
VAR_7-= VAR_2*16;
break;
case ME_X1:
case ME_EPZS:
{
P_LEFT[0] = mv_table[VAR_23 - 1][0];
P_LEFT[1] = mv_table[VAR_23 - 1][1];
if(P_LEFT[0] > (VAR_16<<VAR_21)) P_LEFT[0] = (VAR_16<<VAR_21);
if (VAR_2) {
P_TOP[0] = mv_table[VAR_23 - VAR_22 ][0];
P_TOP[1] = mv_table[VAR_23 - VAR_22 ][1];
P_TOPRIGHT[0] = mv_table[VAR_23 - VAR_22 + 1 ][0];
P_TOPRIGHT[1] = mv_table[VAR_23 - VAR_22 + 1 ][1];
if(P_TOP[1] > (VAR_17<<VAR_21)) P_TOP[1]= (VAR_17<<VAR_21);
if(P_TOPRIGHT[0] < (VAR_14<<VAR_21)) P_TOPRIGHT[0]= (VAR_14<<VAR_21);
if(P_TOPRIGHT[1] > (VAR_17<<VAR_21)) P_TOPRIGHT[1]= (VAR_17<<VAR_21);
P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);
P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);
}
VAR_18= P_LEFT[0];
VAR_19= P_LEFT[1];
}
if(mv_table == VAR_0->b_forw_mv_table){
VAR_24= (VAR_0->pb_time<<16) / (VAR_0->pp_time<<VAR_21);
}else{
VAR_24= ((VAR_0->pb_time - VAR_0->pp_time)<<16) / (VAR_0->pp_time<<VAR_21);
}
VAR_9 = VAR_0->me.motion_search[0](VAR_0, 0, &VAR_6, &VAR_7, VAR_20, VAR_18, VAR_19, VAR_14, VAR_15, VAR_16, VAR_17,
VAR_4, VAR_0->p_mv_table, VAR_24, mv_penalty);
break;
}
VAR_9= VAR_0->me.sub_motion_search(VAR_0, &VAR_6, &VAR_7, VAR_9, VAR_14, VAR_15, VAR_16, VAR_17,
VAR_18, VAR_19, VAR_4, 0, 0, mv_penalty);
if(VAR_0->avctx->me_sub_cmp != VAR_0->avctx->mb_cmp && !VAR_0->me.skip)
VAR_9= VAR_0->me.get_mb_score(VAR_0, VAR_6, VAR_7, VAR_18, VAR_19, VAR_4, mv_penalty);
mv_table[VAR_23][0]= VAR_6;
mv_table[VAR_23][1]= VAR_7;
return VAR_9;
}
| [
"static int FUNC_0(MpegEncContext * VAR_0,\nint VAR_1, int VAR_2, VAR_3 (*mv_table)[2], Picture *VAR_4, int VAR_5)\n{",
"int VAR_6, VAR_7, VAR_8, VAR_9;",
"int VAR_10, VAR_11, VAR_12, VAR_13;",
"int VAR_14, VAR_15, VAR_16, VAR_17;",
"int VAR_18=0, VAR_19=0;",
"int VAR_20[10][2];",
"const int VAR_21= 1+VAR_0->quarter_sample;",
"const int VAR_22 = VAR_0->mb_width + 2;",
"const int VAR_23 = (VAR_2 + 1)*VAR_22 + VAR_1 + 1;",
"uint8_t * const ref_picture= VAR_4->data[0];",
"uint16_t * const mv_penalty= VAR_0->me.mv_penalty[VAR_5] + MAX_MV;",
"int VAR_24;",
"VAR_0->me.penalty_factor = get_penalty_factor(VAR_0, VAR_0->avctx->me_cmp);",
"VAR_0->me.sub_penalty_factor= get_penalty_factor(VAR_0, VAR_0->avctx->me_sub_cmp);",
"VAR_0->me.mb_penalty_factor = get_penalty_factor(VAR_0, VAR_0->avctx->mb_cmp);",
"get_limits(VAR_0, &VAR_8, &VAR_10, &VAR_11, &VAR_12, &VAR_13, VAR_5);",
"VAR_14= VAR_10 - VAR_1*16;",
"VAR_16= VAR_12 - VAR_1*16;",
"VAR_15= VAR_11 - VAR_2*16;",
"VAR_17= VAR_13 - VAR_2*16;",
"switch(VAR_0->me_method) {",
"case ME_ZERO:\ndefault:\nno_motion_search(VAR_0, &VAR_6, &VAR_7);",
"VAR_9 = 0;",
"VAR_6-= VAR_1*16;",
"VAR_7-= VAR_2*16;",
"break;",
"case ME_FULL:\nVAR_9 = full_motion_search(VAR_0, &VAR_6, &VAR_7, VAR_8, VAR_10, VAR_11, VAR_12, VAR_13, ref_picture);",
"VAR_6-= VAR_1*16;",
"VAR_7-= VAR_2*16;",
"break;",
"case ME_LOG:\nVAR_9 = log_motion_search(VAR_0, &VAR_6, &VAR_7, VAR_8 / 2, VAR_10, VAR_11, VAR_12, VAR_13, ref_picture);",
"VAR_6-= VAR_1*16;",
"VAR_7-= VAR_2*16;",
"break;",
"case ME_PHODS:\nVAR_9 = phods_motion_search(VAR_0, &VAR_6, &VAR_7, VAR_8 / 2, VAR_10, VAR_11, VAR_12, VAR_13, ref_picture);",
"VAR_6-= VAR_1*16;",
"VAR_7-= VAR_2*16;",
"break;",
"case ME_X1:\ncase ME_EPZS:\n{",
"P_LEFT[0] = mv_table[VAR_23 - 1][0];",
"P_LEFT[1] = mv_table[VAR_23 - 1][1];",
"if(P_LEFT[0] > (VAR_16<<VAR_21)) P_LEFT[0] = (VAR_16<<VAR_21);",
"if (VAR_2) {",
"P_TOP[0] = mv_table[VAR_23 - VAR_22 ][0];",
"P_TOP[1] = mv_table[VAR_23 - VAR_22 ][1];",
"P_TOPRIGHT[0] = mv_table[VAR_23 - VAR_22 + 1 ][0];",
"P_TOPRIGHT[1] = mv_table[VAR_23 - VAR_22 + 1 ][1];",
"if(P_TOP[1] > (VAR_17<<VAR_21)) P_TOP[1]= (VAR_17<<VAR_21);",
"if(P_TOPRIGHT[0] < (VAR_14<<VAR_21)) P_TOPRIGHT[0]= (VAR_14<<VAR_21);",
"if(P_TOPRIGHT[1] > (VAR_17<<VAR_21)) P_TOPRIGHT[1]= (VAR_17<<VAR_21);",
"P_MEDIAN[0]= mid_pred(P_LEFT[0], P_TOP[0], P_TOPRIGHT[0]);",
"P_MEDIAN[1]= mid_pred(P_LEFT[1], P_TOP[1], P_TOPRIGHT[1]);",
"}",
"VAR_18= P_LEFT[0];",
"VAR_19= P_LEFT[1];",
"}",
"if(mv_table == VAR_0->b_forw_mv_table){",
"VAR_24= (VAR_0->pb_time<<16) / (VAR_0->pp_time<<VAR_21);",
"}else{",
"VAR_24= ((VAR_0->pb_time - VAR_0->pp_time)<<16) / (VAR_0->pp_time<<VAR_21);",
"}",
"VAR_9 = VAR_0->me.motion_search[0](VAR_0, 0, &VAR_6, &VAR_7, VAR_20, VAR_18, VAR_19, VAR_14, VAR_15, VAR_16, VAR_17,\nVAR_4, VAR_0->p_mv_table, VAR_24, mv_penalty);",
"break;",
"}",
"VAR_9= VAR_0->me.sub_motion_search(VAR_0, &VAR_6, &VAR_7, VAR_9, VAR_14, VAR_15, VAR_16, VAR_17,\nVAR_18, VAR_19, VAR_4, 0, 0, mv_penalty);",
"if(VAR_0->avctx->me_sub_cmp != VAR_0->avctx->mb_cmp && !VAR_0->me.skip)\nVAR_9= VAR_0->me.get_mb_score(VAR_0, VAR_6, VAR_7, VAR_18, VAR_19, VAR_4, mv_penalty);",
"mv_table[VAR_23][0]= VAR_6;",
"mv_table[VAR_23][1]= VAR_7;",
"return VAR_9;",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
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
],
[
39
],
[
41
],
[
43
],
[
45
],
[
47
],
[
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
],
[
109
],
[
115
],
[
117
],
[
119
],
[
121
],
[
123
],
[
125
],
[
127
],
[
129
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
147
],
[
149
],
[
151
],
[
153
],
[
155
],
[
159,
161
],
[
165
],
[
167
],
[
171,
173
],
[
177,
179
],
[
187
],
[
189
],
[
193
],
[
195
]
]
|
17,077 | int inet_connect_opts(QemuOpts *opts, Error **errp,
NonBlockingConnectHandler *callback, void *opaque)
{
struct addrinfo *res, *e;
int sock = -1;
bool in_progress;
ConnectState *connect_state = NULL;
res = inet_parse_connect_opts(opts, errp);
if (!res) {
return -1;
}
if (callback != NULL) {
connect_state = g_malloc0(sizeof(*connect_state));
connect_state->addr_list = res;
connect_state->callback = callback;
connect_state->opaque = opaque;
}
for (e = res; e != NULL; e = e->ai_next) {
if (error_is_set(errp)) {
error_free(*errp);
*errp = NULL;
}
if (connect_state != NULL) {
connect_state->current_addr = e;
}
sock = inet_connect_addr(e, &in_progress, connect_state, errp);
if (in_progress) {
return sock;
} else if (sock >= 0) {
/* non blocking socket immediate success, call callback */
if (callback != NULL) {
callback(sock, opaque);
}
break;
}
}
g_free(connect_state);
freeaddrinfo(res);
return sock;
}
| false | qemu | 3f9286b7214fbc7135d4fc223f07b0b30b91e2f1 | int inet_connect_opts(QemuOpts *opts, Error **errp,
NonBlockingConnectHandler *callback, void *opaque)
{
struct addrinfo *res, *e;
int sock = -1;
bool in_progress;
ConnectState *connect_state = NULL;
res = inet_parse_connect_opts(opts, errp);
if (!res) {
return -1;
}
if (callback != NULL) {
connect_state = g_malloc0(sizeof(*connect_state));
connect_state->addr_list = res;
connect_state->callback = callback;
connect_state->opaque = opaque;
}
for (e = res; e != NULL; e = e->ai_next) {
if (error_is_set(errp)) {
error_free(*errp);
*errp = NULL;
}
if (connect_state != NULL) {
connect_state->current_addr = e;
}
sock = inet_connect_addr(e, &in_progress, connect_state, errp);
if (in_progress) {
return sock;
} else if (sock >= 0) {
if (callback != NULL) {
callback(sock, opaque);
}
break;
}
}
g_free(connect_state);
freeaddrinfo(res);
return sock;
}
| {
"code": [],
"line_no": []
} | int FUNC_0(QemuOpts *VAR_0, Error **VAR_1,
NonBlockingConnectHandler *VAR_2, void *VAR_3)
{
struct addrinfo *VAR_4, *VAR_5;
int VAR_6 = -1;
bool in_progress;
ConnectState *connect_state = NULL;
VAR_4 = inet_parse_connect_opts(VAR_0, VAR_1);
if (!VAR_4) {
return -1;
}
if (VAR_2 != NULL) {
connect_state = g_malloc0(sizeof(*connect_state));
connect_state->addr_list = VAR_4;
connect_state->VAR_2 = VAR_2;
connect_state->VAR_3 = VAR_3;
}
for (VAR_5 = VAR_4; VAR_5 != NULL; VAR_5 = VAR_5->ai_next) {
if (error_is_set(VAR_1)) {
error_free(*VAR_1);
*VAR_1 = NULL;
}
if (connect_state != NULL) {
connect_state->current_addr = VAR_5;
}
VAR_6 = inet_connect_addr(VAR_5, &in_progress, connect_state, VAR_1);
if (in_progress) {
return VAR_6;
} else if (VAR_6 >= 0) {
if (VAR_2 != NULL) {
VAR_2(VAR_6, VAR_3);
}
break;
}
}
g_free(connect_state);
freeaddrinfo(VAR_4);
return VAR_6;
}
| [
"int FUNC_0(QemuOpts *VAR_0, Error **VAR_1,\nNonBlockingConnectHandler *VAR_2, void *VAR_3)\n{",
"struct addrinfo *VAR_4, *VAR_5;",
"int VAR_6 = -1;",
"bool in_progress;",
"ConnectState *connect_state = NULL;",
"VAR_4 = inet_parse_connect_opts(VAR_0, VAR_1);",
"if (!VAR_4) {",
"return -1;",
"}",
"if (VAR_2 != NULL) {",
"connect_state = g_malloc0(sizeof(*connect_state));",
"connect_state->addr_list = VAR_4;",
"connect_state->VAR_2 = VAR_2;",
"connect_state->VAR_3 = VAR_3;",
"}",
"for (VAR_5 = VAR_4; VAR_5 != NULL; VAR_5 = VAR_5->ai_next) {",
"if (error_is_set(VAR_1)) {",
"error_free(*VAR_1);",
"*VAR_1 = NULL;",
"}",
"if (connect_state != NULL) {",
"connect_state->current_addr = VAR_5;",
"}",
"VAR_6 = inet_connect_addr(VAR_5, &in_progress, connect_state, VAR_1);",
"if (in_progress) {",
"return VAR_6;",
"} else if (VAR_6 >= 0) {",
"if (VAR_2 != NULL) {",
"VAR_2(VAR_6, VAR_3);",
"}",
"break;",
"}",
"}",
"g_free(connect_state);",
"freeaddrinfo(VAR_4);",
"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
]
| [
[
1,
3,
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
17
],
[
19
],
[
21
],
[
23
],
[
27
],
[
29
],
[
31
],
[
33
],
[
35
],
[
37
],
[
41
],
[
43
],
[
45
],
[
47
],
[
49
],
[
51
],
[
53
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
67
],
[
69
],
[
71
],
[
73
],
[
75
],
[
77
],
[
79
],
[
81
],
[
83
],
[
85
]
]
|
17,078 | static void channel_run(DBDMA_channel *ch)
{
dbdma_cmd *current = &ch->current;
uint16_t cmd, key;
uint16_t req_count;
uint32_t phy_addr;
DBDMA_DPRINTF("channel_run\n");
dump_dbdma_cmd(current);
/* clear WAKE flag at command fetch */
ch->regs[DBDMA_STATUS] &= cpu_to_be32(~WAKE);
cmd = le16_to_cpu(current->command) & COMMAND_MASK;
switch (cmd) {
case DBDMA_NOP:
nop(ch);
return;
case DBDMA_STOP:
stop(ch);
return;
}
key = le16_to_cpu(current->command) & 0x0700;
req_count = le16_to_cpu(current->req_count);
phy_addr = le32_to_cpu(current->phy_addr);
if (key == KEY_STREAM4) {
printf("command %x, invalid key 4\n", cmd);
kill_channel(ch);
return;
}
switch (cmd) {
case OUTPUT_MORE:
start_output(ch, key, phy_addr, req_count, 0);
return;
case OUTPUT_LAST:
start_output(ch, key, phy_addr, req_count, 1);
return;
case INPUT_MORE:
start_input(ch, key, phy_addr, req_count, 0);
return;
case INPUT_LAST:
start_input(ch, key, phy_addr, req_count, 1);
return;
}
if (key < KEY_REGS) {
printf("command %x, invalid key %x\n", cmd, key);
key = KEY_SYSTEM;
}
/* for LOAD_WORD and STORE_WORD, req_count is on 3 bits
* and BRANCH is invalid
*/
req_count = req_count & 0x0007;
if (req_count & 0x4) {
req_count = 4;
phy_addr &= ~3;
} else if (req_count & 0x2) {
req_count = 2;
phy_addr &= ~1;
} else
req_count = 1;
switch (cmd) {
case LOAD_WORD:
load_word(ch, key, phy_addr, req_count);
return;
case STORE_WORD:
store_word(ch, key, phy_addr, req_count);
return;
}
}
| false | qemu | ad674e53b5cce265fadafbde2c6a4f190345cd00 | static void channel_run(DBDMA_channel *ch)
{
dbdma_cmd *current = &ch->current;
uint16_t cmd, key;
uint16_t req_count;
uint32_t phy_addr;
DBDMA_DPRINTF("channel_run\n");
dump_dbdma_cmd(current);
ch->regs[DBDMA_STATUS] &= cpu_to_be32(~WAKE);
cmd = le16_to_cpu(current->command) & COMMAND_MASK;
switch (cmd) {
case DBDMA_NOP:
nop(ch);
return;
case DBDMA_STOP:
stop(ch);
return;
}
key = le16_to_cpu(current->command) & 0x0700;
req_count = le16_to_cpu(current->req_count);
phy_addr = le32_to_cpu(current->phy_addr);
if (key == KEY_STREAM4) {
printf("command %x, invalid key 4\n", cmd);
kill_channel(ch);
return;
}
switch (cmd) {
case OUTPUT_MORE:
start_output(ch, key, phy_addr, req_count, 0);
return;
case OUTPUT_LAST:
start_output(ch, key, phy_addr, req_count, 1);
return;
case INPUT_MORE:
start_input(ch, key, phy_addr, req_count, 0);
return;
case INPUT_LAST:
start_input(ch, key, phy_addr, req_count, 1);
return;
}
if (key < KEY_REGS) {
printf("command %x, invalid key %x\n", cmd, key);
key = KEY_SYSTEM;
}
req_count = req_count & 0x0007;
if (req_count & 0x4) {
req_count = 4;
phy_addr &= ~3;
} else if (req_count & 0x2) {
req_count = 2;
phy_addr &= ~1;
} else
req_count = 1;
switch (cmd) {
case LOAD_WORD:
load_word(ch, key, phy_addr, req_count);
return;
case STORE_WORD:
store_word(ch, key, phy_addr, req_count);
return;
}
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(DBDMA_channel *VAR_0)
{
dbdma_cmd *current = &VAR_0->current;
uint16_t cmd, key;
uint16_t req_count;
uint32_t phy_addr;
DBDMA_DPRINTF("FUNC_0\n");
dump_dbdma_cmd(current);
VAR_0->regs[DBDMA_STATUS] &= cpu_to_be32(~WAKE);
cmd = le16_to_cpu(current->command) & COMMAND_MASK;
switch (cmd) {
case DBDMA_NOP:
nop(VAR_0);
return;
case DBDMA_STOP:
stop(VAR_0);
return;
}
key = le16_to_cpu(current->command) & 0x0700;
req_count = le16_to_cpu(current->req_count);
phy_addr = le32_to_cpu(current->phy_addr);
if (key == KEY_STREAM4) {
printf("command %x, invalid key 4\n", cmd);
kill_channel(VAR_0);
return;
}
switch (cmd) {
case OUTPUT_MORE:
start_output(VAR_0, key, phy_addr, req_count, 0);
return;
case OUTPUT_LAST:
start_output(VAR_0, key, phy_addr, req_count, 1);
return;
case INPUT_MORE:
start_input(VAR_0, key, phy_addr, req_count, 0);
return;
case INPUT_LAST:
start_input(VAR_0, key, phy_addr, req_count, 1);
return;
}
if (key < KEY_REGS) {
printf("command %x, invalid key %x\n", cmd, key);
key = KEY_SYSTEM;
}
req_count = req_count & 0x0007;
if (req_count & 0x4) {
req_count = 4;
phy_addr &= ~3;
} else if (req_count & 0x2) {
req_count = 2;
phy_addr &= ~1;
} else
req_count = 1;
switch (cmd) {
case LOAD_WORD:
load_word(VAR_0, key, phy_addr, req_count);
return;
case STORE_WORD:
store_word(VAR_0, key, phy_addr, req_count);
return;
}
}
| [
"static void FUNC_0(DBDMA_channel *VAR_0)\n{",
"dbdma_cmd *current = &VAR_0->current;",
"uint16_t cmd, key;",
"uint16_t req_count;",
"uint32_t phy_addr;",
"DBDMA_DPRINTF(\"FUNC_0\\n\");",
"dump_dbdma_cmd(current);",
"VAR_0->regs[DBDMA_STATUS] &= cpu_to_be32(~WAKE);",
"cmd = le16_to_cpu(current->command) & COMMAND_MASK;",
"switch (cmd) {",
"case DBDMA_NOP:\nnop(VAR_0);",
"return;",
"case DBDMA_STOP:\nstop(VAR_0);",
"return;",
"}",
"key = le16_to_cpu(current->command) & 0x0700;",
"req_count = le16_to_cpu(current->req_count);",
"phy_addr = le32_to_cpu(current->phy_addr);",
"if (key == KEY_STREAM4) {",
"printf(\"command %x, invalid key 4\\n\", cmd);",
"kill_channel(VAR_0);",
"return;",
"}",
"switch (cmd) {",
"case OUTPUT_MORE:\nstart_output(VAR_0, key, phy_addr, req_count, 0);",
"return;",
"case OUTPUT_LAST:\nstart_output(VAR_0, key, phy_addr, req_count, 1);",
"return;",
"case INPUT_MORE:\nstart_input(VAR_0, key, phy_addr, req_count, 0);",
"return;",
"case INPUT_LAST:\nstart_input(VAR_0, key, phy_addr, req_count, 1);",
"return;",
"}",
"if (key < KEY_REGS) {",
"printf(\"command %x, invalid key %x\\n\", cmd, key);",
"key = KEY_SYSTEM;",
"}",
"req_count = req_count & 0x0007;",
"if (req_count & 0x4) {",
"req_count = 4;",
"phy_addr &= ~3;",
"} else if (req_count & 0x2) {",
"req_count = 2;",
"phy_addr &= ~1;",
"} else",
"req_count = 1;",
"switch (cmd) {",
"case LOAD_WORD:\nload_word(VAR_0, key, phy_addr, req_count);",
"return;",
"case STORE_WORD:\nstore_word(VAR_0, key, phy_addr, req_count);",
"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
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
15
],
[
17
],
[
25
],
[
29
],
[
33
],
[
35,
37
],
[
39
],
[
43,
45
],
[
47
],
[
49
],
[
53
],
[
55
],
[
57
],
[
61
],
[
63
],
[
65
],
[
67
],
[
69
],
[
73
],
[
75,
77
],
[
79
],
[
83,
85
],
[
87
],
[
91,
93
],
[
95
],
[
99,
101
],
[
103
],
[
105
],
[
109
],
[
111
],
[
113
],
[
115
],
[
127
],
[
129
],
[
131
],
[
133
],
[
135
],
[
137
],
[
139
],
[
141
],
[
143
],
[
147
],
[
149,
151
],
[
153
],
[
157,
159
],
[
161
],
[
163
],
[
165
]
]
|
17,079 | static void error(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
fprintf(stderr, "qemu-img: ");
vfprintf(stderr, fmt, ap);
fprintf(stderr, "\n");
va_end(ap);
}
| false | qemu | 8b7968f7c4ac8c07cad6a1a0891d38cf239a2839 | static void error(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
fprintf(stderr, "qemu-img: ");
vfprintf(stderr, fmt, ap);
fprintf(stderr, "\n");
va_end(ap);
}
| {
"code": [],
"line_no": []
} | static void FUNC_0(const char *VAR_0, ...)
{
va_list ap;
va_start(ap, VAR_0);
fprintf(stderr, "qemu-img: ");
vfprintf(stderr, VAR_0, ap);
fprintf(stderr, "\n");
va_end(ap);
}
| [
"static void FUNC_0(const char *VAR_0, ...)\n{",
"va_list ap;",
"va_start(ap, VAR_0);",
"fprintf(stderr, \"qemu-img: \");",
"vfprintf(stderr, VAR_0, ap);",
"fprintf(stderr, \"\\n\");",
"va_end(ap);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3
],
[
5
],
[
7
],
[
9
],
[
11
],
[
13
],
[
15
],
[
17
]
]
|
17,080 | void aio_set_fd_handler(AioContext *ctx,
int fd,
IOHandler *io_read,
IOHandler *io_write,
void *opaque)
{
/* fd is a SOCKET in our case */
AioHandler *node;
QLIST_FOREACH(node, &ctx->aio_handlers, node) {
if (node->pfd.fd == fd && !node->deleted) {
break;
}
}
/* Are we deleting the fd handler? */
if (!io_read && !io_write) {
if (node) {
/* If the lock is held, just mark the node as deleted */
if (ctx->walking_handlers) {
node->deleted = 1;
node->pfd.revents = 0;
} else {
/* Otherwise, delete it for real. We can't just mark it as
* deleted because deleted nodes are only cleaned up after
* releasing the walking_handlers lock.
*/
QLIST_REMOVE(node, node);
g_free(node);
}
}
} else {
HANDLE event;
if (node == NULL) {
/* Alloc and insert if it's not already there */
node = g_malloc0(sizeof(AioHandler));
node->pfd.fd = fd;
QLIST_INSERT_HEAD(&ctx->aio_handlers, node, node);
}
node->pfd.events = 0;
if (node->io_read) {
node->pfd.events |= G_IO_IN;
}
if (node->io_write) {
node->pfd.events |= G_IO_OUT;
}
node->e = &ctx->notifier;
/* Update handler with latest information */
node->opaque = opaque;
node->io_read = io_read;
node->io_write = io_write;
event = event_notifier_get_handle(&ctx->notifier);
WSAEventSelect(node->pfd.fd, event,
FD_READ | FD_ACCEPT | FD_CLOSE |
FD_CONNECT | FD_WRITE | FD_OOB);
}
aio_notify(ctx);
}
| false | qemu | 3ba235a02284c39b34a68a2a588508ffb52a7b55 | void aio_set_fd_handler(AioContext *ctx,
int fd,
IOHandler *io_read,
IOHandler *io_write,
void *opaque)
{
AioHandler *node;
QLIST_FOREACH(node, &ctx->aio_handlers, node) {
if (node->pfd.fd == fd && !node->deleted) {
break;
}
}
if (!io_read && !io_write) {
if (node) {
if (ctx->walking_handlers) {
node->deleted = 1;
node->pfd.revents = 0;
} else {
QLIST_REMOVE(node, node);
g_free(node);
}
}
} else {
HANDLE event;
if (node == NULL) {
node = g_malloc0(sizeof(AioHandler));
node->pfd.fd = fd;
QLIST_INSERT_HEAD(&ctx->aio_handlers, node, node);
}
node->pfd.events = 0;
if (node->io_read) {
node->pfd.events |= G_IO_IN;
}
if (node->io_write) {
node->pfd.events |= G_IO_OUT;
}
node->e = &ctx->notifier;
node->opaque = opaque;
node->io_read = io_read;
node->io_write = io_write;
event = event_notifier_get_handle(&ctx->notifier);
WSAEventSelect(node->pfd.fd, event,
FD_READ | FD_ACCEPT | FD_CLOSE |
FD_CONNECT | FD_WRITE | FD_OOB);
}
aio_notify(ctx);
}
| {
"code": [],
"line_no": []
} | void FUNC_0(AioContext *VAR_0,
int VAR_1,
IOHandler *VAR_2,
IOHandler *VAR_3,
void *VAR_4)
{
AioHandler *node;
QLIST_FOREACH(node, &VAR_0->aio_handlers, node) {
if (node->pfd.VAR_1 == VAR_1 && !node->deleted) {
break;
}
}
if (!VAR_2 && !VAR_3) {
if (node) {
if (VAR_0->walking_handlers) {
node->deleted = 1;
node->pfd.revents = 0;
} else {
QLIST_REMOVE(node, node);
g_free(node);
}
}
} else {
HANDLE event;
if (node == NULL) {
node = g_malloc0(sizeof(AioHandler));
node->pfd.VAR_1 = VAR_1;
QLIST_INSERT_HEAD(&VAR_0->aio_handlers, node, node);
}
node->pfd.events = 0;
if (node->VAR_2) {
node->pfd.events |= G_IO_IN;
}
if (node->VAR_3) {
node->pfd.events |= G_IO_OUT;
}
node->e = &VAR_0->notifier;
node->VAR_4 = VAR_4;
node->VAR_2 = VAR_2;
node->VAR_3 = VAR_3;
event = event_notifier_get_handle(&VAR_0->notifier);
WSAEventSelect(node->pfd.VAR_1, event,
FD_READ | FD_ACCEPT | FD_CLOSE |
FD_CONNECT | FD_WRITE | FD_OOB);
}
aio_notify(VAR_0);
}
| [
"void FUNC_0(AioContext *VAR_0,\nint VAR_1,\nIOHandler *VAR_2,\nIOHandler *VAR_3,\nvoid *VAR_4)\n{",
"AioHandler *node;",
"QLIST_FOREACH(node, &VAR_0->aio_handlers, node) {",
"if (node->pfd.VAR_1 == VAR_1 && !node->deleted) {",
"break;",
"}",
"}",
"if (!VAR_2 && !VAR_3) {",
"if (node) {",
"if (VAR_0->walking_handlers) {",
"node->deleted = 1;",
"node->pfd.revents = 0;",
"} else {",
"QLIST_REMOVE(node, node);",
"g_free(node);",
"}",
"}",
"} else {",
"HANDLE event;",
"if (node == NULL) {",
"node = g_malloc0(sizeof(AioHandler));",
"node->pfd.VAR_1 = VAR_1;",
"QLIST_INSERT_HEAD(&VAR_0->aio_handlers, node, node);",
"}",
"node->pfd.events = 0;",
"if (node->VAR_2) {",
"node->pfd.events |= G_IO_IN;",
"}",
"if (node->VAR_3) {",
"node->pfd.events |= G_IO_OUT;",
"}",
"node->e = &VAR_0->notifier;",
"node->VAR_4 = VAR_4;",
"node->VAR_2 = VAR_2;",
"node->VAR_3 = VAR_3;",
"event = event_notifier_get_handle(&VAR_0->notifier);",
"WSAEventSelect(node->pfd.VAR_1, event,\nFD_READ | FD_ACCEPT | FD_CLOSE |\nFD_CONNECT | FD_WRITE | FD_OOB);",
"}",
"aio_notify(VAR_0);",
"}"
]
| [
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0,
0
]
| [
[
1,
3,
5,
7,
9,
11
],
[
15
],
[
19
],
[
21
],
[
23
],
[
25
],
[
27
],
[
33
],
[
35
],
[
39
],
[
41
],
[
43
],
[
45
],
[
55
],
[
57
],
[
59
],
[
61
],
[
63
],
[
65
],
[
69
],
[
73
],
[
75
],
[
77
],
[
79
],
[
83
],
[
85
],
[
87
],
[
89
],
[
91
],
[
93
],
[
95
],
[
99
],
[
105
],
[
107
],
[
109
],
[
113
],
[
115,
117,
119
],
[
121
],
[
125
],
[
127
]
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.