mirror of https://gitlab.com/qemu-project/qemu
tcg: Centralize updates to reg_to_temp
Create two new functions, set_temp_val_{reg,nonreg}.
Assert that the reg_to_temp mapping is correct before
any changes are made.
Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
This commit is contained in:
Richard Henderson
parent
36f5539cfd
commit
098859f108
159
tcg/tcg.c
159
tcg/tcg.c
|
|
@ -3019,6 +3019,35 @@ static void temp_allocate_frame(TCGContext *s, TCGTemp *ts)
|
|||
ts->mem_allocated = 1;
|
||||
}
|
||||
|
||||
/* Assign @reg to @ts, and update reg_to_temp[]. */
|
||||
static void set_temp_val_reg(TCGContext *s, TCGTemp *ts, TCGReg reg)
|
||||
{
|
||||
if (ts->val_type == TEMP_VAL_REG) {
|
||||
TCGReg old = ts->reg;
|
||||
tcg_debug_assert(s->reg_to_temp[old] == ts);
|
||||
if (old == reg) {
|
||||
return;
|
||||
}
|
||||
s->reg_to_temp[old] = NULL;
|
||||
}
|
||||
tcg_debug_assert(s->reg_to_temp[reg] == NULL);
|
||||
s->reg_to_temp[reg] = ts;
|
||||
ts->val_type = TEMP_VAL_REG;
|
||||
ts->reg = reg;
|
||||
}
|
||||
|
||||
/* Assign a non-register value type to @ts, and update reg_to_temp[]. */
|
||||
static void set_temp_val_nonreg(TCGContext *s, TCGTemp *ts, TCGTempVal type)
|
||||
{
|
||||
tcg_debug_assert(type != TEMP_VAL_REG);
|
||||
if (ts->val_type == TEMP_VAL_REG) {
|
||||
TCGReg reg = ts->reg;
|
||||
tcg_debug_assert(s->reg_to_temp[reg] == ts);
|
||||
s->reg_to_temp[reg] = NULL;
|
||||
}
|
||||
ts->val_type = type;
|
||||
}
|
||||
|
||||
static void temp_load(TCGContext *, TCGTemp *, TCGRegSet, TCGRegSet, TCGRegSet);
|
||||
|
||||
/* Mark a temporary as free or dead. If 'free_or_dead' is negative,
|
||||
|
|
@ -3044,10 +3073,7 @@ static void temp_free_or_dead(TCGContext *s, TCGTemp *ts, int free_or_dead)
|
|||
default:
|
||||
g_assert_not_reached();
|
||||
}
|
||||
if (ts->val_type == TEMP_VAL_REG) {
|
||||
s->reg_to_temp[ts->reg] = NULL;
|
||||
}
|
||||
ts->val_type = new_type;
|
||||
set_temp_val_nonreg(s, ts, new_type);
|
||||
}
|
||||
|
||||
/* Mark a temporary as dead. */
|
||||
|
|
@ -3227,9 +3253,7 @@ static void temp_load(TCGContext *s, TCGTemp *ts, TCGRegSet desired_regs,
|
|||
default:
|
||||
tcg_abort();
|
||||
}
|
||||
ts->reg = reg;
|
||||
ts->val_type = TEMP_VAL_REG;
|
||||
s->reg_to_temp[reg] = ts;
|
||||
set_temp_val_reg(s, ts, reg);
|
||||
}
|
||||
|
||||
/* Save a temporary to memory. 'allocated_regs' is used in case a
|
||||
|
|
@ -3341,10 +3365,7 @@ static void tcg_reg_alloc_do_movi(TCGContext *s, TCGTemp *ots,
|
|||
tcg_debug_assert(!temp_readonly(ots));
|
||||
|
||||
/* The movi is not explicitly generated here. */
|
||||
if (ots->val_type == TEMP_VAL_REG) {
|
||||
s->reg_to_temp[ots->reg] = NULL;
|
||||
}
|
||||
ots->val_type = TEMP_VAL_CONST;
|
||||
set_temp_val_nonreg(s, ots, TEMP_VAL_CONST);
|
||||
ots->val = val;
|
||||
ots->mem_coherent = 0;
|
||||
if (NEED_SYNC_ARG(0)) {
|
||||
|
|
@ -3363,6 +3384,7 @@ static void tcg_reg_alloc_mov(TCGContext *s, const TCGOp *op)
|
|||
TCGRegSet allocated_regs, preferred_regs;
|
||||
TCGTemp *ts, *ots;
|
||||
TCGType otype, itype;
|
||||
TCGReg oreg, ireg;
|
||||
|
||||
allocated_regs = s->reserved_regs;
|
||||
preferred_regs = op->output_pref[0];
|
||||
|
|
@ -3394,8 +3416,9 @@ static void tcg_reg_alloc_mov(TCGContext *s, const TCGOp *op)
|
|||
temp_load(s, ts, tcg_target_available_regs[itype],
|
||||
allocated_regs, preferred_regs);
|
||||
}
|
||||
|
||||
tcg_debug_assert(ts->val_type == TEMP_VAL_REG);
|
||||
ireg = ts->reg;
|
||||
|
||||
if (IS_DEAD_ARG(0)) {
|
||||
/* mov to a non-saved dead register makes no sense (even with
|
||||
liveness analysis disabled). */
|
||||
|
|
@ -3403,52 +3426,53 @@ static void tcg_reg_alloc_mov(TCGContext *s, const TCGOp *op)
|
|||
if (!ots->mem_allocated) {
|
||||
temp_allocate_frame(s, ots);
|
||||
}
|
||||
tcg_out_st(s, otype, ts->reg, ots->mem_base->reg, ots->mem_offset);
|
||||
tcg_out_st(s, otype, ireg, ots->mem_base->reg, ots->mem_offset);
|
||||
if (IS_DEAD_ARG(1)) {
|
||||
temp_dead(s, ts);
|
||||
}
|
||||
temp_dead(s, ots);
|
||||
return;
|
||||
}
|
||||
|
||||
if (IS_DEAD_ARG(1) && ts->kind != TEMP_FIXED) {
|
||||
/*
|
||||
* The mov can be suppressed. Kill input first, so that it
|
||||
* is unlinked from reg_to_temp, then set the output to the
|
||||
* reg that we saved from the input.
|
||||
*/
|
||||
temp_dead(s, ts);
|
||||
oreg = ireg;
|
||||
} else {
|
||||
if (IS_DEAD_ARG(1) && ts->kind != TEMP_FIXED) {
|
||||
/* the mov can be suppressed */
|
||||
if (ots->val_type == TEMP_VAL_REG) {
|
||||
s->reg_to_temp[ots->reg] = NULL;
|
||||
}
|
||||
ots->reg = ts->reg;
|
||||
temp_dead(s, ts);
|
||||
if (ots->val_type == TEMP_VAL_REG) {
|
||||
oreg = ots->reg;
|
||||
} else {
|
||||
if (ots->val_type != TEMP_VAL_REG) {
|
||||
/* When allocating a new register, make sure to not spill the
|
||||
input one. */
|
||||
tcg_regset_set_reg(allocated_regs, ts->reg);
|
||||
ots->reg = tcg_reg_alloc(s, tcg_target_available_regs[otype],
|
||||
allocated_regs, preferred_regs,
|
||||
ots->indirect_base);
|
||||
}
|
||||
if (!tcg_out_mov(s, otype, ots->reg, ts->reg)) {
|
||||
/*
|
||||
* Cross register class move not supported.
|
||||
* Store the source register into the destination slot
|
||||
* and leave the destination temp as TEMP_VAL_MEM.
|
||||
*/
|
||||
assert(!temp_readonly(ots));
|
||||
if (!ts->mem_allocated) {
|
||||
temp_allocate_frame(s, ots);
|
||||
}
|
||||
tcg_out_st(s, ts->type, ts->reg,
|
||||
ots->mem_base->reg, ots->mem_offset);
|
||||
ots->mem_coherent = 1;
|
||||
temp_free_or_dead(s, ots, -1);
|
||||
return;
|
||||
}
|
||||
/* Make sure to not spill the input register during allocation. */
|
||||
oreg = tcg_reg_alloc(s, tcg_target_available_regs[otype],
|
||||
allocated_regs | ((TCGRegSet)1 << ireg),
|
||||
preferred_regs, ots->indirect_base);
|
||||
}
|
||||
ots->val_type = TEMP_VAL_REG;
|
||||
ots->mem_coherent = 0;
|
||||
s->reg_to_temp[ots->reg] = ots;
|
||||
if (NEED_SYNC_ARG(0)) {
|
||||
temp_sync(s, ots, allocated_regs, 0, 0);
|
||||
if (!tcg_out_mov(s, otype, oreg, ireg)) {
|
||||
/*
|
||||
* Cross register class move not supported.
|
||||
* Store the source register into the destination slot
|
||||
* and leave the destination temp as TEMP_VAL_MEM.
|
||||
*/
|
||||
assert(!temp_readonly(ots));
|
||||
if (!ts->mem_allocated) {
|
||||
temp_allocate_frame(s, ots);
|
||||
}
|
||||
tcg_out_st(s, ts->type, ireg, ots->mem_base->reg, ots->mem_offset);
|
||||
set_temp_val_nonreg(s, ts, TEMP_VAL_MEM);
|
||||
ots->mem_coherent = 1;
|
||||
return;
|
||||
}
|
||||
}
|
||||
set_temp_val_reg(s, ots, oreg);
|
||||
ots->mem_coherent = 0;
|
||||
|
||||
if (NEED_SYNC_ARG(0)) {
|
||||
temp_sync(s, ots, allocated_regs, 0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
|
|
@ -3490,15 +3514,15 @@ static void tcg_reg_alloc_dup(TCGContext *s, const TCGOp *op)
|
|||
/* Allocate the output register now. */
|
||||
if (ots->val_type != TEMP_VAL_REG) {
|
||||
TCGRegSet allocated_regs = s->reserved_regs;
|
||||
TCGReg oreg;
|
||||
|
||||
if (!IS_DEAD_ARG(1) && its->val_type == TEMP_VAL_REG) {
|
||||
/* Make sure to not spill the input register. */
|
||||
tcg_regset_set_reg(allocated_regs, its->reg);
|
||||
}
|
||||
ots->reg = tcg_reg_alloc(s, dup_out_regs, allocated_regs,
|
||||
op->output_pref[0], ots->indirect_base);
|
||||
ots->val_type = TEMP_VAL_REG;
|
||||
s->reg_to_temp[ots->reg] = ots;
|
||||
oreg = tcg_reg_alloc(s, dup_out_regs, allocated_regs,
|
||||
op->output_pref[0], ots->indirect_base);
|
||||
set_temp_val_reg(s, ots, oreg);
|
||||
}
|
||||
|
||||
switch (its->val_type) {
|
||||
|
|
@ -3535,10 +3559,12 @@ static void tcg_reg_alloc_dup(TCGContext *s, const TCGOp *op)
|
|||
#else
|
||||
endian_fixup = 0;
|
||||
#endif
|
||||
/* Attempt to dup directly from the input memory slot. */
|
||||
if (tcg_out_dupm_vec(s, vtype, vece, ots->reg, its->mem_base->reg,
|
||||
its->mem_offset + endian_fixup)) {
|
||||
goto done;
|
||||
}
|
||||
/* Load the input into the destination vector register. */
|
||||
tcg_out_ld(s, itype, ots->reg, its->mem_base->reg, its->mem_offset);
|
||||
break;
|
||||
|
||||
|
|
@ -3707,17 +3733,8 @@ static void tcg_reg_alloc_op(TCGContext *s, const TCGOp *op)
|
|||
op->output_pref[k], ts->indirect_base);
|
||||
}
|
||||
tcg_regset_set_reg(o_allocated_regs, reg);
|
||||
if (ts->val_type == TEMP_VAL_REG) {
|
||||
s->reg_to_temp[ts->reg] = NULL;
|
||||
}
|
||||
ts->val_type = TEMP_VAL_REG;
|
||||
ts->reg = reg;
|
||||
/*
|
||||
* Temp value is modified, so the value kept in memory is
|
||||
* potentially not the same.
|
||||
*/
|
||||
set_temp_val_reg(s, ts, reg);
|
||||
ts->mem_coherent = 0;
|
||||
s->reg_to_temp[reg] = ts;
|
||||
new_args[i] = reg;
|
||||
}
|
||||
}
|
||||
|
|
@ -3767,6 +3784,7 @@ static bool tcg_reg_alloc_dup2(TCGContext *s, const TCGOp *op)
|
|||
TCGRegSet allocated_regs = s->reserved_regs;
|
||||
TCGRegSet dup_out_regs =
|
||||
tcg_op_defs[INDEX_op_dup_vec].args_ct[0].regs;
|
||||
TCGReg oreg;
|
||||
|
||||
/* Make sure to not spill the input registers. */
|
||||
if (!IS_DEAD_ARG(1) && itsl->val_type == TEMP_VAL_REG) {
|
||||
|
|
@ -3776,10 +3794,9 @@ static bool tcg_reg_alloc_dup2(TCGContext *s, const TCGOp *op)
|
|||
tcg_regset_set_reg(allocated_regs, itsh->reg);
|
||||
}
|
||||
|
||||
ots->reg = tcg_reg_alloc(s, dup_out_regs, allocated_regs,
|
||||
op->output_pref[0], ots->indirect_base);
|
||||
ots->val_type = TEMP_VAL_REG;
|
||||
s->reg_to_temp[ots->reg] = ots;
|
||||
oreg = tcg_reg_alloc(s, dup_out_regs, allocated_regs,
|
||||
op->output_pref[0], ots->indirect_base);
|
||||
set_temp_val_reg(s, ots, oreg);
|
||||
}
|
||||
|
||||
/* Promote dup2 of immediates to dupi_vec. */
|
||||
|
|
@ -3962,14 +3979,8 @@ static void tcg_reg_alloc_call(TCGContext *s, TCGOp *op)
|
|||
tcg_debug_assert(!temp_readonly(ts));
|
||||
|
||||
reg = tcg_target_call_oarg_regs[i];
|
||||
tcg_debug_assert(s->reg_to_temp[reg] == NULL);
|
||||
if (ts->val_type == TEMP_VAL_REG) {
|
||||
s->reg_to_temp[ts->reg] = NULL;
|
||||
}
|
||||
ts->val_type = TEMP_VAL_REG;
|
||||
ts->reg = reg;
|
||||
set_temp_val_reg(s, ts, reg);
|
||||
ts->mem_coherent = 0;
|
||||
s->reg_to_temp[reg] = ts;
|
||||
if (NEED_SYNC_ARG(i)) {
|
||||
temp_sync(s, ts, allocated_regs, 0, IS_DEAD_ARG(i));
|
||||
} else if (IS_DEAD_ARG(i)) {
|
||||
|
|
|
|||
Loading…
Reference in New Issue