vitalif
/
mirror_qemu
mirror of https://github.com/proxmox/mirror_qemu
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

tcg: Use per-temp state data in optimize 

While we're touching many of the lines anyway, adjust the naming
of the functions to better distinguish when "TCGArg" vs "TCGTemp"
should be used.

Reviewed-by: Emilio G. Cota <cota@braap.org>
Signed-off-by: Richard Henderson <rth@twiddle.net>
master
Richard Henderson 2017-06-20 13:43:15 -07:00 committed by Richard Henderson
parent 54534d7cfd
commit 6349039d0b
2 changed files with 245 additions and 181 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

421
tcg/optimize.c
View File

@ -34,8 +34,8 @@
struct tcg_temp_info { struct tcg_temp_info {
bool is_const; bool is_const;
uint16_t prev_copy; TCGTemp *prev_copy;
uint16_t next_copy; TCGTemp *next_copy;
tcg_target_ulong val; tcg_target_ulong val;
tcg_target_ulong mask; tcg_target_ulong mask;
}; };
@ -43,25 +43,49 @@ struct tcg_temp_info {
static struct tcg_temp_info temps[TCG_MAX_TEMPS]; static struct tcg_temp_info temps[TCG_MAX_TEMPS];
static TCGTempSet temps_used; static TCGTempSet temps_used;
static inline bool temp_is_const(TCGArg arg) static inline struct tcg_temp_info *ts_info(TCGTemp *ts)
{ {
return temps[arg].is_const; return ts->state_ptr;
} }
static inline bool temp_is_copy(TCGArg arg) static inline struct tcg_temp_info *arg_info(TCGArg arg)
{ {
return temps[arg].next_copy != arg; return ts_info(arg_temp(arg));
}
static inline bool ts_is_const(TCGTemp *ts)
{
return ts_info(ts)->is_const;
}
static inline bool arg_is_const(TCGArg arg)
{
return ts_is_const(arg_temp(arg));
}
static inline bool ts_is_copy(TCGTemp *ts)
{
return ts_info(ts)->next_copy != ts;
} }
/* Reset TEMP's state, possibly removing the temp for the list of copies. */ /* Reset TEMP's state, possibly removing the temp for the list of copies. */
static void reset_temp(TCGArg temp) static void reset_ts(TCGTemp *ts)
{ {
temps[temps[temp].next_copy].prev_copy = temps[temp].prev_copy; struct tcg_temp_info *ti = ts_info(ts);
temps[temps[temp].prev_copy].next_copy = temps[temp].next_copy; struct tcg_temp_info *pi = ts_info(ti->prev_copy);
temps[temp].next_copy = temp; struct tcg_temp_info *ni = ts_info(ti->next_copy);
temps[temp].prev_copy = temp;
temps[temp].is_const = false; ni->prev_copy = ti->prev_copy;
temps[temp].mask = -1; pi->next_copy = ti->next_copy;
ti->next_copy = ts;
ti->prev_copy = ts;
ti->is_const = false;
ti->mask = -1;
}
static void reset_temp(TCGArg arg)
{
reset_ts(arg_temp(arg));
} }
/* Reset all temporaries, given that there are NB_TEMPS of them. */ /* Reset all temporaries, given that there are NB_TEMPS of them. */
@ -71,17 +95,26 @@ static void reset_all_temps(int nb_temps)
} }
/* Initialize and activate a temporary. */ /* Initialize and activate a temporary. */
static void init_temp_info(TCGArg temp) static void init_ts_info(TCGTemp *ts)
{ {
if (!test_bit(temp, temps_used.l)) { size_t idx = temp_idx(ts);
temps[temp].next_copy = temp; if (!test_bit(idx, temps_used.l)) {
temps[temp].prev_copy = temp; struct tcg_temp_info *ti = &temps[idx];
temps[temp].is_const = false;
temps[temp].mask = -1; ts->state_ptr = ti;
set_bit(temp, temps_used.l); ti->next_copy = ts;
ti->prev_copy = ts;
ti->is_const = false;
ti->mask = -1;
set_bit(idx, temps_used.l);
} }
} }
static void init_arg_info(TCGArg arg)
{
init_ts_info(arg_temp(arg));
}
static int op_bits(TCGOpcode op) static int op_bits(TCGOpcode op)
{ {
const TCGOpDef *def = &tcg_op_defs[op]; const TCGOpDef *def = &tcg_op_defs[op];
@ -116,50 +149,49 @@ static TCGOpcode op_to_movi(TCGOpcode op)
} }
} }
static TCGArg find_better_copy(TCGContext *s, TCGArg arg) static TCGTemp *find_better_copy(TCGContext *s, TCGTemp *ts)
{ {
TCGTemp *ts = arg_temp(arg); TCGTemp *i;
TCGArg i;
/* If this is already a global, we can't do better. */ /* If this is already a global, we can't do better. */
if (ts->temp_global) { if (ts->temp_global) {
return arg; return ts;
} }
/* Search for a global first. */ /* Search for a global first. */
for (i = temps[arg].next_copy ; i != arg; i = temps[i].next_copy) { for (i = ts_info(ts)->next_copy; i != ts; i = ts_info(i)->next_copy) {
if (i < s->nb_globals) { if (i->temp_global) {
return i; return i;
} }
} }
/* If it is a temp, search for a temp local. */ /* If it is a temp, search for a temp local. */
if (!ts->temp_local) { if (!ts->temp_local) {
for (i = temps[arg].next_copy ; i != arg; i = temps[i].next_copy) { for (i = ts_info(ts)->next_copy; i != ts; i = ts_info(i)->next_copy) {
if (s->temps[i].temp_local) { if (ts->temp_local) {
return i; return i;
} }
} }
} }
/* Failure to find a better representation, return the same temp. */ /* Failure to find a better representation, return the same temp. */
return arg; return ts;
} }
static bool temps_are_copies(TCGArg arg1, TCGArg arg2) static bool ts_are_copies(TCGTemp *ts1, TCGTemp *ts2)
{ {
TCGArg i; TCGTemp *i;
if (arg1 == arg2) { if (ts1 == ts2) {
return true; return true;
} }
if (!temp_is_copy(arg1) || !temp_is_copy(arg2)) { if (!ts_is_copy(ts1) || !ts_is_copy(ts2)) {
return false; return false;
} }
for (i = temps[arg1].next_copy ; i != arg1 ; i = temps[i].next_copy) { for (i = ts_info(ts1)->next_copy; i != ts1; i = ts_info(i)->next_copy) {
if (i == arg2) { if (i == ts2) {
return true; return true;
} }
} }
@ -167,22 +199,28 @@ static bool temps_are_copies(TCGArg arg1, TCGArg arg2)
return false; return false;
} }
static bool args_are_copies(TCGArg arg1, TCGArg arg2)
{
return ts_are_copies(arg_temp(arg1), arg_temp(arg2));
}
static void tcg_opt_gen_movi(TCGContext *s, TCGOp *op, TCGArg dst, TCGArg val) static void tcg_opt_gen_movi(TCGContext *s, TCGOp *op, TCGArg dst, TCGArg val)
{ {
TCGOpcode new_op = op_to_movi(op->opc); TCGOpcode new_op = op_to_movi(op->opc);
tcg_target_ulong mask; tcg_target_ulong mask;
struct tcg_temp_info *di = arg_info(dst);
op->opc = new_op; op->opc = new_op;
reset_temp(dst); reset_temp(dst);
temps[dst].is_const = true; di->is_const = true;
temps[dst].val = val; di->val = val;
mask = val; mask = val;
if (TCG_TARGET_REG_BITS > 32 && new_op == INDEX_op_movi_i32) { if (TCG_TARGET_REG_BITS > 32 && new_op == INDEX_op_movi_i32) {
/* High bits of the destination are now garbage. */ /* High bits of the destination are now garbage. */
mask |= ~0xffffffffull; mask |= ~0xffffffffull;
} }
temps[dst].mask = mask; di->mask = mask;
op->args[0] = dst; op->args[0] = dst;
op->args[1] = val; op->args[1] = val;
@ -190,35 +228,44 @@ static void tcg_opt_gen_movi(TCGContext *s, TCGOp *op, TCGArg dst, TCGArg val)
static void tcg_opt_gen_mov(TCGContext *s, TCGOp *op, TCGArg dst, TCGArg src) static void tcg_opt_gen_mov(TCGContext *s, TCGOp *op, TCGArg dst, TCGArg src)
{ {
if (temps_are_copies(dst, src)) { TCGTemp *dst_ts = arg_temp(dst);
TCGTemp *src_ts = arg_temp(src);
struct tcg_temp_info *di;
struct tcg_temp_info *si;
tcg_target_ulong mask;
TCGOpcode new_op;
if (ts_are_copies(dst_ts, src_ts)) {
tcg_op_remove(s, op); tcg_op_remove(s, op);
return; return;
} }
TCGOpcode new_op = op_to_mov(op->opc); reset_ts(dst_ts);
tcg_target_ulong mask; di = ts_info(dst_ts);
si = ts_info(src_ts);
new_op = op_to_mov(op->opc);
op->opc = new_op; op->opc = new_op;
op->args[0] = dst;
op->args[1] = src;
reset_temp(dst); mask = si->mask;
mask = temps[src].mask;
if (TCG_TARGET_REG_BITS > 32 && new_op == INDEX_op_mov_i32) { if (TCG_TARGET_REG_BITS > 32 && new_op == INDEX_op_mov_i32) {
/* High bits of the destination are now garbage. */ /* High bits of the destination are now garbage. */
mask |= ~0xffffffffull; mask |= ~0xffffffffull;
} }
temps[dst].mask = mask; di->mask = mask;
if (arg_temp(src)->type == arg_temp(dst)->type) { if (src_ts->type == dst_ts->type) {
temps[dst].next_copy = temps[src].next_copy; struct tcg_temp_info *ni = ts_info(si->next_copy);
temps[dst].prev_copy = src;
temps[temps[dst].next_copy].prev_copy = dst; di->next_copy = si->next_copy;
temps[src].next_copy = dst; di->prev_copy = src_ts;
temps[dst].is_const = temps[src].is_const; ni->prev_copy = dst_ts;
temps[dst].val = temps[src].val; si->next_copy = dst_ts;
di->is_const = si->is_const;
di->val = si->val;
} }
op->args[0] = dst;
op->args[1] = src;
} }
static TCGArg do_constant_folding_2(TCGOpcode op, TCGArg x, TCGArg y) static TCGArg do_constant_folding_2(TCGOpcode op, TCGArg x, TCGArg y)
@ -465,18 +512,20 @@ static bool do_constant_folding_cond_eq(TCGCond c)
static TCGArg do_constant_folding_cond(TCGOpcode op, TCGArg x, static TCGArg do_constant_folding_cond(TCGOpcode op, TCGArg x,
TCGArg y, TCGCond c) TCGArg y, TCGCond c)
{ {
if (temp_is_const(x) && temp_is_const(y)) { tcg_target_ulong xv = arg_info(x)->val;
tcg_target_ulong yv = arg_info(y)->val;
if (arg_is_const(x) && arg_is_const(y)) {
switch (op_bits(op)) { switch (op_bits(op)) {
case 32: case 32:
return do_constant_folding_cond_32(temps[x].val, temps[y].val, c); return do_constant_folding_cond_32(xv, yv, c);
case 64: case 64:
return do_constant_folding_cond_64(temps[x].val, temps[y].val, c); return do_constant_folding_cond_64(xv, yv, c);
default: default:
tcg_abort(); tcg_abort();
} }
} else if (temps_are_copies(x, y)) { } else if (args_are_copies(x, y)) {
return do_constant_folding_cond_eq(c); return do_constant_folding_cond_eq(c);
} else if (temp_is_const(y) && temps[y].val == 0) { } else if (arg_is_const(y) && yv == 0) {
switch (c) { switch (c) {
case TCG_COND_LTU: case TCG_COND_LTU:
return 0; return 0;
@ -496,12 +545,15 @@ static TCGArg do_constant_folding_cond2(TCGArg *p1, TCGArg *p2, TCGCond c)
TCGArg al = p1[0], ah = p1[1]; TCGArg al = p1[0], ah = p1[1];
TCGArg bl = p2[0], bh = p2[1]; TCGArg bl = p2[0], bh = p2[1];
if (temp_is_const(bl) && temp_is_const(bh)) { if (arg_is_const(bl) && arg_is_const(bh)) {
uint64_t b = ((uint64_t)temps[bh].val << 32) | (uint32_t)temps[bl].val; tcg_target_ulong blv = arg_info(bl)->val;
tcg_target_ulong bhv = arg_info(bh)->val;
uint64_t b = deposit64(blv, 32, 32, bhv);
if (temp_is_const(al) && temp_is_const(ah)) { if (arg_is_const(al) && arg_is_const(ah)) {
uint64_t a; tcg_target_ulong alv = arg_info(al)->val;
a = ((uint64_t)temps[ah].val << 32) | (uint32_t)temps[al].val; tcg_target_ulong ahv = arg_info(ah)->val;
uint64_t a = deposit64(alv, 32, 32, ahv);
return do_constant_folding_cond_64(a, b, c); return do_constant_folding_cond_64(a, b, c);
} }
if (b == 0) { if (b == 0) {
@ -515,7 +567,7 @@ static TCGArg do_constant_folding_cond2(TCGArg *p1, TCGArg *p2, TCGCond c)
} }
} }
} }
if (temps_are_copies(al, bl) && temps_are_copies(ah, bh)) { if (args_are_copies(al, bl) && args_are_copies(ah, bh)) {
return do_constant_folding_cond_eq(c); return do_constant_folding_cond_eq(c);
} }
return 2; return 2;
@ -525,8 +577,8 @@ static bool swap_commutative(TCGArg dest, TCGArg *p1, TCGArg *p2)
{ {
TCGArg a1 = *p1, a2 = *p2; TCGArg a1 = *p1, a2 = *p2;
int sum = 0; int sum = 0;
sum += temp_is_const(a1); sum += arg_is_const(a1);
sum -= temp_is_const(a2); sum -= arg_is_const(a2);
/* Prefer the constant in second argument, and then the form /* Prefer the constant in second argument, and then the form
op a, a, b, which is better handled on non-RISC hosts. */ op a, a, b, which is better handled on non-RISC hosts. */
@ -541,10 +593,10 @@ static bool swap_commutative(TCGArg dest, TCGArg *p1, TCGArg *p2)
static bool swap_commutative2(TCGArg *p1, TCGArg *p2) static bool swap_commutative2(TCGArg *p1, TCGArg *p2)
{ {
int sum = 0; int sum = 0;
sum += temp_is_const(p1[0]); sum += arg_is_const(p1[0]);
sum += temp_is_const(p1[1]); sum += arg_is_const(p1[1]);
sum -= temp_is_const(p2[0]); sum -= arg_is_const(p2[0]);
sum -= temp_is_const(p2[1]); sum -= arg_is_const(p2[1]);
if (sum > 0) { if (sum > 0) {
TCGArg t; TCGArg t;
t = p1[0], p1[0] = p2[0], p2[0] = t; t = p1[0], p1[0] = p2[0], p2[0] = t;
@ -586,23 +638,24 @@ void tcg_optimize(TCGContext *s)
nb_oargs = op->callo; nb_oargs = op->callo;
nb_iargs = op->calli; nb_iargs = op->calli;
for (i = 0; i < nb_oargs + nb_iargs; i++) { for (i = 0; i < nb_oargs + nb_iargs; i++) {
tmp = op->args[i]; TCGTemp *ts = arg_temp(op->args[i]);
if (tmp != TCG_CALL_DUMMY_ARG) { if (ts) {
init_temp_info(tmp); init_ts_info(ts);
} }
} }
} else { } else {
nb_oargs = def->nb_oargs; nb_oargs = def->nb_oargs;
nb_iargs = def->nb_iargs; nb_iargs = def->nb_iargs;
for (i = 0; i < nb_oargs + nb_iargs; i++) { for (i = 0; i < nb_oargs + nb_iargs; i++) {
init_temp_info(op->args[i]); init_arg_info(op->args[i]);
} }
} }
/* Do copy propagation */ /* Do copy propagation */
for (i = nb_oargs; i < nb_oargs + nb_iargs; i++) { for (i = nb_oargs; i < nb_oargs + nb_iargs; i++) {
if (temp_is_copy(op->args[i])) { TCGTemp *ts = arg_temp(op->args[i]);
op->args[i] = find_better_copy(s, op->args[i]); if (ts && ts_is_copy(ts)) {
op->args[i] = temp_arg(find_better_copy(s, ts));
} }
} }
@ -671,7 +724,8 @@ void tcg_optimize(TCGContext *s)
CASE_OP_32_64(sar): CASE_OP_32_64(sar):
CASE_OP_32_64(rotl): CASE_OP_32_64(rotl):
CASE_OP_32_64(rotr): CASE_OP_32_64(rotr):
if (temp_is_const(op->args[1]) && temps[op->args[1]].val == 0) { if (arg_is_const(op->args[1])
&& arg_info(op->args[1])->val == 0) {
tcg_opt_gen_movi(s, op, op->args[0], 0); tcg_opt_gen_movi(s, op, op->args[0], 0);
continue; continue;
} }
@ -681,7 +735,7 @@ void tcg_optimize(TCGContext *s)
TCGOpcode neg_op; TCGOpcode neg_op;
bool have_neg; bool have_neg;
if (temp_is_const(op->args[2])) { if (arg_is_const(op->args[2])) {
/* Proceed with possible constant folding. */ /* Proceed with possible constant folding. */
break; break;
} }
@ -695,8 +749,8 @@ void tcg_optimize(TCGContext *s)
if (!have_neg) { if (!have_neg) {
break; break;
} }
if (temp_is_const(op->args[1]) if (arg_is_const(op->args[1])
&& temps[op->args[1]].val == 0) { && arg_info(op->args[1])->val == 0) {
op->opc = neg_op; op->opc = neg_op;
reset_temp(op->args[0]); reset_temp(op->args[0]);
op->args[1] = op->args[2]; op->args[1] = op->args[2];
@ -706,34 +760,34 @@ void tcg_optimize(TCGContext *s)
break; break;
CASE_OP_32_64(xor): CASE_OP_32_64(xor):
CASE_OP_32_64(nand): CASE_OP_32_64(nand):
if (!temp_is_const(op->args[1]) if (!arg_is_const(op->args[1])
&& temp_is_const(op->args[2]) && arg_is_const(op->args[2])
&& temps[op->args[2]].val == -1) { && arg_info(op->args[2])->val == -1) {
i = 1; i = 1;
goto try_not; goto try_not;
} }
break; break;
CASE_OP_32_64(nor): CASE_OP_32_64(nor):
if (!temp_is_const(op->args[1]) if (!arg_is_const(op->args[1])
&& temp_is_const(op->args[2]) && arg_is_const(op->args[2])
&& temps[op->args[2]].val == 0) { && arg_info(op->args[2])->val == 0) {
i = 1; i = 1;
goto try_not; goto try_not;
} }
break; break;
CASE_OP_32_64(andc): CASE_OP_32_64(andc):
if (!temp_is_const(op->args[2]) if (!arg_is_const(op->args[2])
&& temp_is_const(op->args[1]) && arg_is_const(op->args[1])
&& temps[op->args[1]].val == -1) { && arg_info(op->args[1])->val == -1) {
i = 2; i = 2;
goto try_not; goto try_not;
} }
break; break;
CASE_OP_32_64(orc): CASE_OP_32_64(orc):
CASE_OP_32_64(eqv): CASE_OP_32_64(eqv):
if (!temp_is_const(op->args[2]) if (!arg_is_const(op->args[2])
&& temp_is_const(op->args[1]) && arg_is_const(op->args[1])
&& temps[op->args[1]].val == 0) { && arg_info(op->args[1])->val == 0) {
i = 2; i = 2;
goto try_not; goto try_not;
} }
@ -774,9 +828,9 @@ void tcg_optimize(TCGContext *s)
CASE_OP_32_64(or): CASE_OP_32_64(or):
CASE_OP_32_64(xor): CASE_OP_32_64(xor):
CASE_OP_32_64(andc): CASE_OP_32_64(andc):
if (!temp_is_const(op->args[1]) if (!arg_is_const(op->args[1])
&& temp_is_const(op->args[2]) && arg_is_const(op->args[2])
&& temps[op->args[2]].val == 0) { && arg_info(op->args[2])->val == 0) {
tcg_opt_gen_mov(s, op, op->args[0], op->args[1]); tcg_opt_gen_mov(s, op, op->args[0], op->args[1]);
continue; continue;
} }
@ -784,9 +838,9 @@ void tcg_optimize(TCGContext *s)
CASE_OP_32_64(and): CASE_OP_32_64(and):
CASE_OP_32_64(orc): CASE_OP_32_64(orc):
CASE_OP_32_64(eqv): CASE_OP_32_64(eqv):
if (!temp_is_const(op->args[1]) if (!arg_is_const(op->args[1])
&& temp_is_const(op->args[2]) && arg_is_const(op->args[2])
&& temps[op->args[2]].val == -1) { && arg_info(op->args[2])->val == -1) {
tcg_opt_gen_mov(s, op, op->args[0], op->args[1]); tcg_opt_gen_mov(s, op, op->args[0], op->args[1]);
continue; continue;
} }
@ -801,21 +855,21 @@ void tcg_optimize(TCGContext *s)
affected = -1; affected = -1;
switch (opc) { switch (opc) {
CASE_OP_32_64(ext8s): CASE_OP_32_64(ext8s):
if ((temps[op->args[1]].mask & 0x80) != 0) { if ((arg_info(op->args[1])->mask & 0x80) != 0) {
break; break;
} }
CASE_OP_32_64(ext8u): CASE_OP_32_64(ext8u):
mask = 0xff; mask = 0xff;
goto and_const; goto and_const;
CASE_OP_32_64(ext16s): CASE_OP_32_64(ext16s):
if ((temps[op->args[1]].mask & 0x8000) != 0) { if ((arg_info(op->args[1])->mask & 0x8000) != 0) {
break; break;
} }
CASE_OP_32_64(ext16u): CASE_OP_32_64(ext16u):
mask = 0xffff; mask = 0xffff;
goto and_const; goto and_const;
case INDEX_op_ext32s_i64: case INDEX_op_ext32s_i64:
if ((temps[op->args[1]].mask & 0x80000000) != 0) { if ((arg_info(op->args[1])->mask & 0x80000000) != 0) {
break; break;
} }
case INDEX_op_ext32u_i64: case INDEX_op_ext32u_i64:
@ -823,111 +877,114 @@ void tcg_optimize(TCGContext *s)
goto and_const; goto and_const;
CASE_OP_32_64(and): CASE_OP_32_64(and):
mask = temps[op->args[2]].mask; mask = arg_info(op->args[2])->mask;
if (temp_is_const(op->args[2])) { if (arg_is_const(op->args[2])) {
and_const: and_const:
affected = temps[op->args[1]].mask & ~mask; affected = arg_info(op->args[1])->mask & ~mask;
} }
mask = temps[op->args[1]].mask & mask; mask = arg_info(op->args[1])->mask & mask;
break; break;
case INDEX_op_ext_i32_i64: case INDEX_op_ext_i32_i64:
if ((temps[op->args[1]].mask & 0x80000000) != 0) { if ((arg_info(op->args[1])->mask & 0x80000000) != 0) {
break; break;
} }
case INDEX_op_extu_i32_i64: case INDEX_op_extu_i32_i64:
/* We do not compute affected as it is a size changing op. */ /* We do not compute affected as it is a size changing op. */
mask = (uint32_t)temps[op->args[1]].mask; mask = (uint32_t)arg_info(op->args[1])->mask;
break; break;
CASE_OP_32_64(andc): CASE_OP_32_64(andc):
/* Known-zeros does not imply known-ones. Therefore unless /* Known-zeros does not imply known-ones. Therefore unless
op->args[2] is constant, we can't infer anything from it. */ op->args[2] is constant, we can't infer anything from it. */
if (temp_is_const(op->args[2])) { if (arg_is_const(op->args[2])) {
mask = ~temps[op->args[2]].mask; mask = ~arg_info(op->args[2])->mask;
goto and_const; goto and_const;
} }
/* But we certainly know nothing outside op->args[1] may be set. */ /* But we certainly know nothing outside args[1] may be set. */
mask = temps[op->args[1]].mask; mask = arg_info(op->args[1])->mask;
break; break;
case INDEX_op_sar_i32: case INDEX_op_sar_i32:
if (temp_is_const(op->args[2])) { if (arg_is_const(op->args[2])) {
tmp = temps[op->args[2]].val & 31; tmp = arg_info(op->args[2])->val & 31;
mask = (int32_t)temps[op->args[1]].mask >> tmp; mask = (int32_t)arg_info(op->args[1])->mask >> tmp;
} }
break; break;
case INDEX_op_sar_i64: case INDEX_op_sar_i64:
if (temp_is_const(op->args[2])) { if (arg_is_const(op->args[2])) {
tmp = temps[op->args[2]].val & 63; tmp = arg_info(op->args[2])->val & 63;
mask = (int64_t)temps[op->args[1]].mask >> tmp; mask = (int64_t)arg_info(op->args[1])->mask >> tmp;
} }
break; break;
case INDEX_op_shr_i32: case INDEX_op_shr_i32:
if (temp_is_const(op->args[2])) { if (arg_is_const(op->args[2])) {
tmp = temps[op->args[2]].val & 31; tmp = arg_info(op->args[2])->val & 31;
mask = (uint32_t)temps[op->args[1]].mask >> tmp; mask = (uint32_t)arg_info(op->args[1])->mask >> tmp;
} }
break; break;
case INDEX_op_shr_i64: case INDEX_op_shr_i64:
if (temp_is_const(op->args[2])) { if (arg_is_const(op->args[2])) {
tmp = temps[op->args[2]].val & 63; tmp = arg_info(op->args[2])->val & 63;
mask = (uint64_t)temps[op->args[1]].mask >> tmp; mask = (uint64_t)arg_info(op->args[1])->mask >> tmp;
} }
break; break;
case INDEX_op_extrl_i64_i32: case INDEX_op_extrl_i64_i32:
mask = (uint32_t)temps[op->args[1]].mask; mask = (uint32_t)arg_info(op->args[1])->mask;
break; break;
case INDEX_op_extrh_i64_i32: case INDEX_op_extrh_i64_i32:
mask = (uint64_t)temps[op->args[1]].mask >> 32; mask = (uint64_t)arg_info(op->args[1])->mask >> 32;
break; break;
CASE_OP_32_64(shl): CASE_OP_32_64(shl):
if (temp_is_const(op->args[2])) { if (arg_is_const(op->args[2])) {
tmp = temps[op->args[2]].val & (TCG_TARGET_REG_BITS - 1); tmp = arg_info(op->args[2])->val & (TCG_TARGET_REG_BITS - 1);
mask = temps[op->args[1]].mask << tmp; mask = arg_info(op->args[1])->mask << tmp;
} }
break; break;
CASE_OP_32_64(neg): CASE_OP_32_64(neg):
/* Set to 1 all bits to the left of the rightmost. */ /* Set to 1 all bits to the left of the rightmost. */
mask = -(temps[op->args[1]].mask & -temps[op->args[1]].mask); mask = -(arg_info(op->args[1])->mask
& -arg_info(op->args[1])->mask);
break; break;
CASE_OP_32_64(deposit): CASE_OP_32_64(deposit):
mask = deposit64(temps[op->args[1]].mask, op->args[3], mask = deposit64(arg_info(op->args[1])->mask,
op->args[4], temps[op->args[2]].mask); op->args[3], op->args[4],
arg_info(op->args[2])->mask);
break; break;
CASE_OP_32_64(extract): CASE_OP_32_64(extract):
mask = extract64(temps[op->args[1]].mask, op->args[2], op->args[3]); mask = extract64(arg_info(op->args[1])->mask,
op->args[2], op->args[3]);
if (op->args[2] == 0) { if (op->args[2] == 0) {
affected = temps[op->args[1]].mask & ~mask; affected = arg_info(op->args[1])->mask & ~mask;
} }
break; break;
CASE_OP_32_64(sextract): CASE_OP_32_64(sextract):
mask = sextract64(temps[op->args[1]].mask, mask = sextract64(arg_info(op->args[1])->mask,
op->args[2], op->args[3]); op->args[2], op->args[3]);
if (op->args[2] == 0 && (tcg_target_long)mask >= 0) { if (op->args[2] == 0 && (tcg_target_long)mask >= 0) {
affected = temps[op->args[1]].mask & ~mask; affected = arg_info(op->args[1])->mask & ~mask;
} }
break; break;
CASE_OP_32_64(or): CASE_OP_32_64(or):
CASE_OP_32_64(xor): CASE_OP_32_64(xor):
mask = temps[op->args[1]].mask | temps[op->args[2]].mask; mask = arg_info(op->args[1])->mask | arg_info(op->args[2])->mask;
break; break;
case INDEX_op_clz_i32: case INDEX_op_clz_i32:
case INDEX_op_ctz_i32: case INDEX_op_ctz_i32:
mask = temps[op->args[2]].mask | 31; mask = arg_info(op->args[2])->mask | 31;
break; break;
case INDEX_op_clz_i64: case INDEX_op_clz_i64:
case INDEX_op_ctz_i64: case INDEX_op_ctz_i64:
mask = temps[op->args[2]].mask | 63; mask = arg_info(op->args[2])->mask | 63;
break; break;
case INDEX_op_ctpop_i32: case INDEX_op_ctpop_i32:
@ -943,7 +1000,7 @@ void tcg_optimize(TCGContext *s)
break; break;
CASE_OP_32_64(movcond): CASE_OP_32_64(movcond):
mask = temps[op->args[3]].mask | temps[op->args[4]].mask; mask = arg_info(op->args[3])->mask | arg_info(op->args[4])->mask;
break; break;
CASE_OP_32_64(ld8u): CASE_OP_32_64(ld8u):
@ -997,7 +1054,8 @@ void tcg_optimize(TCGContext *s)
CASE_OP_32_64(mul): CASE_OP_32_64(mul):
CASE_OP_32_64(muluh): CASE_OP_32_64(muluh):
CASE_OP_32_64(mulsh): CASE_OP_32_64(mulsh):
if ((temp_is_const(op->args[2]) && temps[op->args[2]].val == 0)) { if (arg_is_const(op->args[2])
&& arg_info(op->args[2])->val == 0) {
tcg_opt_gen_movi(s, op, op->args[0], 0); tcg_opt_gen_movi(s, op, op->args[0], 0);
continue; continue;
} }
@ -1010,7 +1068,7 @@ void tcg_optimize(TCGContext *s)
switch (opc) { switch (opc) {
CASE_OP_32_64(or): CASE_OP_32_64(or):
CASE_OP_32_64(and): CASE_OP_32_64(and):
if (temps_are_copies(op->args[1], op->args[2])) { if (args_are_copies(op->args[1], op->args[2])) {
tcg_opt_gen_mov(s, op, op->args[0], op->args[1]); tcg_opt_gen_mov(s, op, op->args[0], op->args[1]);
continue; continue;
} }
@ -1024,7 +1082,7 @@ void tcg_optimize(TCGContext *s)
CASE_OP_32_64(andc): CASE_OP_32_64(andc):
CASE_OP_32_64(sub): CASE_OP_32_64(sub):
CASE_OP_32_64(xor): CASE_OP_32_64(xor):
if (temps_are_copies(op->args[1], op->args[2])) { if (args_are_copies(op->args[1], op->args[2])) {
tcg_opt_gen_movi(s, op, op->args[0], 0); tcg_opt_gen_movi(s, op, op->args[0], 0);
continue; continue;
} }
@ -1057,8 +1115,8 @@ void tcg_optimize(TCGContext *s)
case INDEX_op_extu_i32_i64: case INDEX_op_extu_i32_i64:
case INDEX_op_extrl_i64_i32: case INDEX_op_extrl_i64_i32:
case INDEX_op_extrh_i64_i32: case INDEX_op_extrh_i64_i32:
if (temp_is_const(op->args[1])) { if (arg_is_const(op->args[1])) {
tmp = do_constant_folding(opc, temps[op->args[1]].val, 0); tmp = do_constant_folding(opc, arg_info(op->args[1])->val, 0);
tcg_opt_gen_movi(s, op, op->args[0], tmp); tcg_opt_gen_movi(s, op, op->args[0], tmp);
break; break;
} }
@ -1086,9 +1144,9 @@ void tcg_optimize(TCGContext *s)
CASE_OP_32_64(divu): CASE_OP_32_64(divu):
CASE_OP_32_64(rem): CASE_OP_32_64(rem):
CASE_OP_32_64(remu): CASE_OP_32_64(remu):
if (temp_is_const(op->args[1]) && temp_is_const(op->args[2])) { if (arg_is_const(op->args[1]) && arg_is_const(op->args[2])) {
tmp = do_constant_folding(opc, temps[op->args[1]].val, tmp = do_constant_folding(opc, arg_info(op->args[1])->val,
temps[op->args[2]].val); arg_info(op->args[2])->val);
tcg_opt_gen_movi(s, op, op->args[0], tmp); tcg_opt_gen_movi(s, op, op->args[0], tmp);
break; break;
} }
@ -1096,8 +1154,8 @@ void tcg_optimize(TCGContext *s)
CASE_OP_32_64(clz): CASE_OP_32_64(clz):
CASE_OP_32_64(ctz): CASE_OP_32_64(ctz):
if (temp_is_const(op->args[1])) { if (arg_is_const(op->args[1])) {
TCGArg v = temps[op->args[1]].val; TCGArg v = arg_info(op->args[1])->val;
if (v != 0) { if (v != 0) {
tmp = do_constant_folding(opc, v, 0); tmp = do_constant_folding(opc, v, 0);
tcg_opt_gen_movi(s, op, op->args[0], tmp); tcg_opt_gen_movi(s, op, op->args[0], tmp);
@ -1109,17 +1167,18 @@ void tcg_optimize(TCGContext *s)
goto do_default; goto do_default;
CASE_OP_32_64(deposit): CASE_OP_32_64(deposit):
if (temp_is_const(op->args[1]) && temp_is_const(op->args[2])) { if (arg_is_const(op->args[1]) && arg_is_const(op->args[2])) {
tmp = deposit64(temps[op->args[1]].val, op->args[3], tmp = deposit64(arg_info(op->args[1])->val,
op->args[4], temps[op->args[2]].val); op->args[3], op->args[4],
arg_info(op->args[2])->val);
tcg_opt_gen_movi(s, op, op->args[0], tmp); tcg_opt_gen_movi(s, op, op->args[0], tmp);
break; break;
} }
goto do_default; goto do_default;
CASE_OP_32_64(extract): CASE_OP_32_64(extract):
if (temp_is_const(op->args[1])) { if (arg_is_const(op->args[1])) {
tmp = extract64(temps[op->args[1]].val, tmp = extract64(arg_info(op->args[1])->val,
op->args[2], op->args[3]); op->args[2], op->args[3]);
tcg_opt_gen_movi(s, op, op->args[0], tmp); tcg_opt_gen_movi(s, op, op->args[0], tmp);
break; break;
@ -1127,8 +1186,8 @@ void tcg_optimize(TCGContext *s)
goto do_default; goto do_default;
CASE_OP_32_64(sextract): CASE_OP_32_64(sextract):
if (temp_is_const(op->args[1])) { if (arg_is_const(op->args[1])) {
tmp = sextract64(temps[op->args[1]].val, tmp = sextract64(arg_info(op->args[1])->val,
op->args[2], op->args[3]); op->args[2], op->args[3]);
tcg_opt_gen_movi(s, op, op->args[0], tmp); tcg_opt_gen_movi(s, op, op->args[0], tmp);
break; break;
@ -1166,9 +1225,9 @@ void tcg_optimize(TCGContext *s)
tcg_opt_gen_mov(s, op, op->args[0], op->args[4-tmp]); tcg_opt_gen_mov(s, op, op->args[0], op->args[4-tmp]);
break; break;
} }
if (temp_is_const(op->args[3]) && temp_is_const(op->args[4])) { if (arg_is_const(op->args[3]) && arg_is_const(op->args[4])) {
tcg_target_ulong tv = temps[op->args[3]].val; tcg_target_ulong tv = arg_info(op->args[3])->val;
tcg_target_ulong fv = temps[op->args[4]].val; tcg_target_ulong fv = arg_info(op->args[4])->val;
TCGCond cond = op->args[5]; TCGCond cond = op->args[5];
if (fv == 1 && tv == 0) { if (fv == 1 && tv == 0) {
cond = tcg_invert_cond(cond); cond = tcg_invert_cond(cond);
@ -1185,12 +1244,12 @@ void tcg_optimize(TCGContext *s)
case INDEX_op_add2_i32: case INDEX_op_add2_i32:
case INDEX_op_sub2_i32: case INDEX_op_sub2_i32:
if (temp_is_const(op->args[2]) && temp_is_const(op->args[3]) if (arg_is_const(op->args[2]) && arg_is_const(op->args[3])
&& temp_is_const(op->args[4]) && temp_is_const(op->args[5])) { && arg_is_const(op->args[4]) && arg_is_const(op->args[5])) {
uint32_t al = temps[op->args[2]].val; uint32_t al = arg_info(op->args[2])->val;
uint32_t ah = temps[op->args[3]].val; uint32_t ah = arg_info(op->args[3])->val;
uint32_t bl = temps[op->args[4]].val; uint32_t bl = arg_info(op->args[4])->val;
uint32_t bh = temps[op->args[5]].val; uint32_t bh = arg_info(op->args[5])->val;
uint64_t a = ((uint64_t)ah << 32) | al; uint64_t a = ((uint64_t)ah << 32) | al;
uint64_t b = ((uint64_t)bh << 32) | bl; uint64_t b = ((uint64_t)bh << 32) | bl;
TCGArg rl, rh; TCGArg rl, rh;
@ -1214,9 +1273,9 @@ void tcg_optimize(TCGContext *s)
goto do_default; goto do_default;
case INDEX_op_mulu2_i32: case INDEX_op_mulu2_i32:
if (temp_is_const(op->args[2]) && temp_is_const(op->args[3])) { if (arg_is_const(op->args[2]) && arg_is_const(op->args[3])) {
uint32_t a = temps[op->args[2]].val; uint32_t a = arg_info(op->args[2])->val;
uint32_t b = temps[op->args[3]].val; uint32_t b = arg_info(op->args[3])->val;
uint64_t r = (uint64_t)a * b; uint64_t r = (uint64_t)a * b;
TCGArg rl, rh; TCGArg rl, rh;
TCGOp *op2 = tcg_op_insert_before(s, op, INDEX_op_movi_i32, 2); TCGOp *op2 = tcg_op_insert_before(s, op, INDEX_op_movi_i32, 2);
@ -1247,10 +1306,10 @@ void tcg_optimize(TCGContext *s)
} }
} else if ((op->args[4] == TCG_COND_LT } else if ((op->args[4] == TCG_COND_LT
|| op->args[4] == TCG_COND_GE) || op->args[4] == TCG_COND_GE)
&& temp_is_const(op->args[2]) && arg_is_const(op->args[2])
&& temps[op->args[2]].val == 0 && arg_info(op->args[2])->val == 0
&& temp_is_const(op->args[3]) && arg_is_const(op->args[3])
&& temps[op->args[3]].val == 0) { && arg_info(op->args[3])->val == 0) {
/* Simplify LT/GE comparisons vs zero to a single compare /* Simplify LT/GE comparisons vs zero to a single compare
vs the high word of the input. */ vs the high word of the input. */
do_brcond_high: do_brcond_high:
@ -1318,15 +1377,15 @@ void tcg_optimize(TCGContext *s)
tcg_opt_gen_movi(s, op, op->args[0], tmp); tcg_opt_gen_movi(s, op, op->args[0], tmp);
} else if ((op->args[5] == TCG_COND_LT } else if ((op->args[5] == TCG_COND_LT
|| op->args[5] == TCG_COND_GE) || op->args[5] == TCG_COND_GE)
&& temp_is_const(op->args[3]) && arg_is_const(op->args[3])
&& temps[op->args[3]].val == 0 && arg_info(op->args[3])->val == 0
&& temp_is_const(op->args[4]) && arg_is_const(op->args[4])
&& temps[op->args[4]].val == 0) { && arg_info(op->args[4])->val == 0) {
/* Simplify LT/GE comparisons vs zero to a single compare /* Simplify LT/GE comparisons vs zero to a single compare
vs the high word of the input. */ vs the high word of the input. */
do_setcond_high: do_setcond_high:
reset_temp(op->args[0]); reset_temp(op->args[0]);
temps[op->args[0]].mask = 1; arg_info(op->args[0])->mask = 1;
op->opc = INDEX_op_setcond_i32; op->opc = INDEX_op_setcond_i32;
op->args[1] = op->args[2]; op->args[1] = op->args[2];
op->args[2] = op->args[4]; op->args[2] = op->args[4];
@ -1352,7 +1411,7 @@ void tcg_optimize(TCGContext *s)
} }
do_setcond_low: do_setcond_low:
reset_temp(op->args[0]); reset_temp(op->args[0]);
temps[op->args[0]].mask = 1; arg_info(op->args[0])->mask = 1;
op->opc = INDEX_op_setcond_i32; op->opc = INDEX_op_setcond_i32;
op->args[2] = op->args[3]; op->args[2] = op->args[3];
op->args[3] = op->args[5]; op->args[3] = op->args[5];
@ -1386,7 +1445,7 @@ void tcg_optimize(TCGContext *s)
& (TCG_CALL_NO_READ_GLOBALS | TCG_CALL_NO_WRITE_GLOBALS))) { & (TCG_CALL_NO_READ_GLOBALS | TCG_CALL_NO_WRITE_GLOBALS))) {
for (i = 0; i < nb_globals; i++) { for (i = 0; i < nb_globals; i++) {
if (test_bit(i, temps_used.l)) { if (test_bit(i, temps_used.l)) {
reset_temp(i); reset_ts(&s->temps[i]);
} }
} }
} }
@ -1408,7 +1467,7 @@ void tcg_optimize(TCGContext *s)
/* Save the corresponding known-zero bits mask for the /* Save the corresponding known-zero bits mask for the
first output argument (only one supported so far). */ first output argument (only one supported so far). */
if (i == 0) { if (i == 0) {
temps[op->args[i]].mask = mask; arg_info(op->args[i])->mask = mask;
} }
} }
} }

5
tcg/tcg.h
View File

@ -751,6 +751,11 @@ static inline TCGTemp *arg_temp(TCGArg a)
return a == TCG_CALL_DUMMY_ARG ? NULL : &tcg_ctx.temps[a]; return a == TCG_CALL_DUMMY_ARG ? NULL : &tcg_ctx.temps[a];
} }
static inline size_t arg_index(TCGArg a)
{
return a;
}
static inline void tcg_set_insn_param(int op_idx, int arg, TCGArg v) static inline void tcg_set_insn_param(int op_idx, int arg, TCGArg v)
{ {
tcg_ctx.gen_op_buf[op_idx].args[arg] = v; tcg_ctx.gen_op_buf[op_idx].args[arg] = v;