yuzu/unicorn
1
0
Fork 0
mirror of https://github.com/yuzu-emu/unicorn.git synced 2024-12-24 13:15:40 +00:00
Code Issues Packages Projects Releases Wiki Activity

tcg: Add markup for output requires new register

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

Backports commit 82790a870992bd87d5fd9e607f40859dcf4f82ac from qemu
This commit is contained in:
Richard Henderson 2018-03-01 15:24:47 -05:00 committed by Lioncash
parent 199b3859c4
commit 551ef0a9f7
No known key found for this signature in database
GPG key ID: 4E3C3CC1031BA9C7
2 changed files with 23 additions and 10 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
qemu/tcg/tcg.c
View file

@ -1307,6 +1307,10 @@ void tcg_add_target_add_op_defs(TCGContext *s, 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++;
@ -2275,6 +2279,8 @@ static void tcg_reg_alloc_op(TCGContext *s,
const TCGArg *args, TCGLifeData arg_life) const TCGArg *args, TCGLifeData arg_life)
{ {
TCGRegSet allocated_regs; 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;
@ -2291,8 +2297,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];
@ -2307,7 +2315,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);
assert(ts->val_type == TEMP_VAL_REG); assert(ts->val_type == TEMP_VAL_REG);
if (arg_ct->ct & TCG_CT_IALIAS) { if (arg_ct->ct & TCG_CT_IALIAS) {
@ -2332,13 +2340,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: ;
} }
@ -2350,20 +2358,20 @@ 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(s->tcg_target_call_clobber_regs, i)) { if (tcg_regset_test_reg(s->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 */
@ -2375,6 +2383,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;
@ -2382,10 +2394,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) {
@ -2414,7 +2426,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
qemu/tcg/tcg.h
View file

@ -725,6 +725,7 @@ void tcg_dump_info(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 */