ShuriZma
/
xemu
mirror of https://github.com/xemu-project/xemu.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

tcg: Add markup for output requires new register 

This is the same concept as, and same markup as, the
early clobber markup in gcc.

Reviewed-by: Alex Bennée <alex.bennee@linaro.org>
Signed-off-by: Richard Henderson <rth@twiddle.net>
This commit is contained in:
Richard Henderson 2016-11-18 08:35:03 +01:00
parent 333b21b809
commit 82790a8709
2 changed files with 23 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
tcg/tcg.c
View File

@ -1263,6 +1263,10 @@ void tcg_add_target_add_op_defs(const TCGTargetOpDef *tdefs)
if (*ct_str == '\0') if (*ct_str == '\0')
break; break;
switch(*ct_str) { switch(*ct_str) {
case '&':
def->args_ct[i].ct |= TCG_CT_NEWREG;
ct_str++;
break;
case 'i': case 'i':
def->args_ct[i].ct |= TCG_CT_CONST; def->args_ct[i].ct |= TCG_CT_CONST;
ct_str++; ct_str++;
@ -2208,7 +2212,8 @@ static void tcg_reg_alloc_op(TCGContext *s,
const TCGOpDef *def, TCGOpcode opc, const TCGOpDef *def, TCGOpcode opc,
const TCGArg *args, TCGLifeData arg_life) const TCGArg *args, TCGLifeData arg_life)
{ {
TCGRegSet allocated_regs; TCGRegSet i_allocated_regs;
TCGRegSet o_allocated_regs;
int i, k, nb_iargs, nb_oargs; int i, k, nb_iargs, nb_oargs;
TCGReg reg; TCGReg reg;
TCGArg arg; TCGArg arg;
@ -2225,8 +2230,10 @@ static void tcg_reg_alloc_op(TCGContext *s,
args + nb_oargs + nb_iargs, args + nb_oargs + nb_iargs,
sizeof(TCGArg) * def->nb_cargs); sizeof(TCGArg) * def->nb_cargs);
tcg_regset_set(i_allocated_regs, s->reserved_regs);
tcg_regset_set(o_allocated_regs, s->reserved_regs);
/* satisfy input constraints */ /* satisfy input constraints */
tcg_regset_set(allocated_regs, s->reserved_regs);
for(k = 0; k < nb_iargs; k++) { for(k = 0; k < nb_iargs; k++) {
i = def->sorted_args[nb_oargs + k]; i = def->sorted_args[nb_oargs + k];
arg = args[i]; arg = args[i];
@ -2241,7 +2248,7 @@ static void tcg_reg_alloc_op(TCGContext *s,
goto iarg_end; goto iarg_end;
} }
temp_load(s, ts, arg_ct->u.regs, allocated_regs); temp_load(s, ts, arg_ct->u.regs, i_allocated_regs);
if (arg_ct->ct & TCG_CT_IALIAS) { if (arg_ct->ct & TCG_CT_IALIAS) {
if (ts->fixed_reg) { if (ts->fixed_reg) {
@ -2275,13 +2282,13 @@ static void tcg_reg_alloc_op(TCGContext *s,
allocate_in_reg: allocate_in_reg:
/* allocate a new register matching the constraint /* allocate a new register matching the constraint
and move the temporary register into it */ and move the temporary register into it */
reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs, reg = tcg_reg_alloc(s, arg_ct->u.regs, i_allocated_regs,
ts->indirect_base); ts->indirect_base);
tcg_out_mov(s, ts->type, reg, ts->reg); tcg_out_mov(s, ts->type, reg, ts->reg);
} }
new_args[i] = reg; new_args[i] = reg;
const_args[i] = 0; const_args[i] = 0;
tcg_regset_set_reg(allocated_regs, reg); tcg_regset_set_reg(i_allocated_regs, reg);
iarg_end: ; iarg_end: ;
} }
@ -2293,24 +2300,23 @@ static void tcg_reg_alloc_op(TCGContext *s,
} }
if (def->flags & TCG_OPF_BB_END) { if (def->flags & TCG_OPF_BB_END) {
tcg_reg_alloc_bb_end(s, allocated_regs); tcg_reg_alloc_bb_end(s, i_allocated_regs);
} else { } else {
if (def->flags & TCG_OPF_CALL_CLOBBER) { if (def->flags & TCG_OPF_CALL_CLOBBER) {
/* XXX: permit generic clobber register list ? */ /* XXX: permit generic clobber register list ? */
for (i = 0; i < TCG_TARGET_NB_REGS; i++) { for (i = 0; i < TCG_TARGET_NB_REGS; i++) {
if (tcg_regset_test_reg(tcg_target_call_clobber_regs, i)) { if (tcg_regset_test_reg(tcg_target_call_clobber_regs, i)) {
tcg_reg_free(s, i, allocated_regs); tcg_reg_free(s, i, i_allocated_regs);
} }
} }
} }
if (def->flags & TCG_OPF_SIDE_EFFECTS) { if (def->flags & TCG_OPF_SIDE_EFFECTS) {
/* sync globals if the op has side effects and might trigger /* sync globals if the op has side effects and might trigger
an exception. */ an exception. */
sync_globals(s, allocated_regs); sync_globals(s, i_allocated_regs);
} }
/* satisfy the output constraints */ /* satisfy the output constraints */
tcg_regset_set(allocated_regs, s->reserved_regs);
for(k = 0; k < nb_oargs; k++) { for(k = 0; k < nb_oargs; k++) {
i = def->sorted_args[k]; i = def->sorted_args[k];
arg = args[i]; arg = args[i];
@ -2318,6 +2324,10 @@ static void tcg_reg_alloc_op(TCGContext *s,
ts = &s->temps[arg]; ts = &s->temps[arg];
if (arg_ct->ct & TCG_CT_ALIAS) { if (arg_ct->ct & TCG_CT_ALIAS) {
reg = new_args[arg_ct->alias_index]; reg = new_args[arg_ct->alias_index];
} else if (arg_ct->ct & TCG_CT_NEWREG) {
reg = tcg_reg_alloc(s, arg_ct->u.regs,
i_allocated_regs | o_allocated_regs,
ts->indirect_base);
} else { } else {
/* if fixed register, we try to use it */ /* if fixed register, we try to use it */
reg = ts->reg; reg = ts->reg;
@ -2325,10 +2335,10 @@ static void tcg_reg_alloc_op(TCGContext *s,
tcg_regset_test_reg(arg_ct->u.regs, reg)) { tcg_regset_test_reg(arg_ct->u.regs, reg)) {
goto oarg_end; goto oarg_end;
} }
reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs, reg = tcg_reg_alloc(s, arg_ct->u.regs, o_allocated_regs,
ts->indirect_base); ts->indirect_base);
} }
tcg_regset_set_reg(allocated_regs, reg); tcg_regset_set_reg(o_allocated_regs, reg);
/* if a fixed register is used, then a move will be done afterwards */ /* if a fixed register is used, then a move will be done afterwards */
if (!ts->fixed_reg) { if (!ts->fixed_reg) {
if (ts->val_type == TEMP_VAL_REG) { if (ts->val_type == TEMP_VAL_REG) {
@ -2357,7 +2367,7 @@ static void tcg_reg_alloc_op(TCGContext *s,
tcg_out_mov(s, ts->type, ts->reg, reg); tcg_out_mov(s, ts->type, ts->reg, reg);
} }
if (NEED_SYNC_ARG(i)) { if (NEED_SYNC_ARG(i)) {
temp_sync(s, ts, allocated_regs, IS_DEAD_ARG(i)); temp_sync(s, ts, o_allocated_regs, IS_DEAD_ARG(i));
} else if (IS_DEAD_ARG(i)) { } else if (IS_DEAD_ARG(i)) {
temp_dead(s, ts); temp_dead(s, ts);
} }

1
tcg/tcg.h
View File

@ -851,6 +851,7 @@ void tcg_dump_op_count(FILE *f, fprintf_function cpu_fprintf);
#define TCG_CT_ALIAS 0x80 #define TCG_CT_ALIAS 0x80
#define TCG_CT_IALIAS 0x40 #define TCG_CT_IALIAS 0x40
#define TCG_CT_NEWREG 0x20 /* output requires a new register */
#define TCG_CT_REG 0x01 #define TCG_CT_REG 0x01
#define TCG_CT_CONST 0x02 /* any constant of register size */ #define TCG_CT_CONST 0x02 /* any constant of register size */