haraldwolff/qemu-patch-raspberry4
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

tcg: Move some TCG_CT_* bits to TCGArgConstraint bitfields

Browse source 
These are easier to set and test when they have their own fields.
Reduce the size of alias_index and sort_index to 4 bits, which is
sufficient for TCG_MAX_OP_ARGS.  This leaves only the bits indicating
constants within the ct field.

Move all initialization to allocation time, rather than init
individual fields in process_op_defs.

Signed-off-by: Richard Henderson <richard.henderson@linaro.org>
This commit is contained in:
Richard Henderson 2019-04-04 19:34:19 -07:00
parent 74a117906b
commit bc2b17e6ea
2 changed files with 19 additions and 23 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
include/tcg/tcg.h
View file

@ -976,15 +976,15 @@ int64_t tcg_cpu_exec_time(void);
void tcg_dump_info(void); void tcg_dump_info(void);
void tcg_dump_op_count(void); void tcg_dump_op_count(void);
#define TCG_CT_ALIAS 0x80 #define TCG_CT_CONST 1 /* any constant of register size */
#define TCG_CT_IALIAS 0x40
#define TCG_CT_NEWREG 0x20 /* output requires a new register */
#define TCG_CT_CONST 0x02 /* any constant of register size */
typedef struct TCGArgConstraint { typedef struct TCGArgConstraint {
uint16_t ct; unsigned ct : 16;
uint8_t alias_index; unsigned alias_index : 4;
uint8_t sort_index; unsigned sort_index : 4;
bool oalias : 1;
bool ialias : 1;
bool newreg : 1;
TCGRegSet regs; TCGRegSet regs;
} TCGArgConstraint; } TCGArgConstraint;

28
tcg/tcg.c
View file

@ -958,7 +958,7 @@ void tcg_context_init(TCGContext *s)
total_args += n; total_args += n;
} }
args_ct = g_malloc(sizeof(TCGArgConstraint) * total_args); args_ct = g_new0(TCGArgConstraint, total_args);
for(op = 0; op < NB_OPS; op++) { for(op = 0; op < NB_OPS; op++) {
def = &tcg_op_defs[op]; def = &tcg_op_defs[op];
@ -2197,7 +2197,7 @@ static int get_constraint_priority(const TCGOpDef *def, int k)
const TCGArgConstraint *arg_ct = &def->args_ct[k]; const TCGArgConstraint *arg_ct = &def->args_ct[k];
int n; int n;
if (arg_ct->ct & TCG_CT_ALIAS) { if (arg_ct->oalias) {
/* an alias is equivalent to a single register */ /* an alias is equivalent to a single register */
n = 1; n = 1;
} else { } else {
@ -2260,8 +2260,6 @@ static void process_op_defs(TCGContext *s)
/* Incomplete TCGTargetOpDef entry. */ /* Incomplete TCGTargetOpDef entry. */
tcg_debug_assert(ct_str != NULL); tcg_debug_assert(ct_str != NULL);
def->args_ct[i].regs = 0;
def->args_ct[i].ct = 0;
while (*ct_str != '\0') { while (*ct_str != '\0') {
switch(*ct_str) { switch(*ct_str) {
case '0' ... '9': case '0' ... '9':
@ -2270,18 +2268,18 @@ static void process_op_defs(TCGContext *s)
tcg_debug_assert(ct_str == tdefs->args_ct_str[i]); tcg_debug_assert(ct_str == tdefs->args_ct_str[i]);
tcg_debug_assert(oarg < def->nb_oargs); tcg_debug_assert(oarg < def->nb_oargs);
tcg_debug_assert(def->args_ct[oarg].regs != 0); tcg_debug_assert(def->args_ct[oarg].regs != 0);
/* TCG_CT_ALIAS is for the output arguments.
The input is tagged with TCG_CT_IALIAS. */
def->args_ct[i] = def->args_ct[oarg]; def->args_ct[i] = def->args_ct[oarg];
def->args_ct[oarg].ct |= TCG_CT_ALIAS; /* The output sets oalias. */
def->args_ct[oarg].oalias = true;
def->args_ct[oarg].alias_index = i; def->args_ct[oarg].alias_index = i;
def->args_ct[i].ct |= TCG_CT_IALIAS; /* The input sets ialias. */
def->args_ct[i].ialias = true;
def->args_ct[i].alias_index = oarg; def->args_ct[i].alias_index = oarg;
} }
ct_str++; ct_str++;
break; break;
case '&': case '&':
def->args_ct[i].ct |= TCG_CT_NEWREG; def->args_ct[i].newreg = true;
ct_str++; ct_str++;
break; break;
case 'i': case 'i':
@ -2848,7 +2846,7 @@ static void liveness_pass_1(TCGContext *s)
set = *pset; set = *pset;
set &= ct->regs; set &= ct->regs;
if (ct->ct & TCG_CT_IALIAS) { if (ct->ialias) {
set &= op->output_pref[ct->alias_index]; set &= op->output_pref[ct->alias_index];
} }
/* If the combination is not possible, restart. */ /* If the combination is not possible, restart. */
@ -3665,7 +3663,7 @@ static void tcg_reg_alloc_op(TCGContext *s, const TCGOp *op)
} }
i_preferred_regs = o_preferred_regs = 0; i_preferred_regs = o_preferred_regs = 0;
if (arg_ct->ct & TCG_CT_IALIAS) { if (arg_ct->ialias) {
o_preferred_regs = op->output_pref[arg_ct->alias_index]; o_preferred_regs = op->output_pref[arg_ct->alias_index];
if (ts->fixed_reg) { if (ts->fixed_reg) {
/* if fixed register, we must allocate a new register /* if fixed register, we must allocate a new register
@ -3688,8 +3686,7 @@ static void tcg_reg_alloc_op(TCGContext *s, const TCGOp *op)
reg = ts->reg; reg = ts->reg;
for (k2 = 0 ; k2 < k ; k2++) { for (k2 = 0 ; k2 < k ; k2++) {
i2 = def->args_ct[nb_oargs + k2].sort_index; i2 = def->args_ct[nb_oargs + k2].sort_index;
if ((def->args_ct[i2].ct & TCG_CT_IALIAS) && if (def->args_ct[i2].ialias && reg == new_args[i2]) {
reg == new_args[i2]) {
goto allocate_in_reg; goto allocate_in_reg;
} }
} }
@ -3760,10 +3757,9 @@ static void tcg_reg_alloc_op(TCGContext *s, const TCGOp *op)
/* ENV should not be modified. */ /* ENV should not be modified. */
tcg_debug_assert(!ts->fixed_reg); tcg_debug_assert(!ts->fixed_reg);
if ((arg_ct->ct & TCG_CT_ALIAS) if (arg_ct->oalias && !const_args[arg_ct->alias_index]) {
&& !const_args[arg_ct->alias_index]) {
reg = new_args[arg_ct->alias_index]; reg = new_args[arg_ct->alias_index];
} else if (arg_ct->ct & TCG_CT_NEWREG) { } else if (arg_ct->newreg) {
reg = tcg_reg_alloc(s, arg_ct->regs, reg = tcg_reg_alloc(s, arg_ct->regs,
i_allocated_regs | o_allocated_regs, i_allocated_regs | o_allocated_regs,
op->output_pref[k], ts->indirect_base); op->output_pref[k], ts->indirect_base);