Commit d63e3b6e authored by Richard Henderson's avatar Richard Henderson
Browse files

tcg: Assert fixed_reg is read-only 



The only fixed_reg is cpu_env, and it should not be modified
during any TB.  Therefore code that tries to special-case moves
into a fixed_reg is dead.  Remove it.

Reviewed-by: default avatarAlex Bennée <alex.bennee@linaro.org>
Reviewed-by: default avatarDavid Hildenbrand <david@redhat.com>
Signed-off-by: default avatarRichard Henderson <richard.henderson@linaro.org>
parent 53229a77

tcg/tcg.c

+40 −47
Original line number Diff line number Diff line
@@ -3274,11 +3274,8 @@ static void tcg_reg_alloc_do_movi(TCGContext *s, TCGTemp *ots, 
                                  tcg_target_ulong val, TCGLifeData arg_life,

                                  TCGRegSet preferred_regs)

{

    if (ots->fixed_reg) {

        /* For fixed registers, we do not do any constant propagation.  */

        tcg_out_movi(s, ots->type, ots->reg, val);

        return;

    }

    /* ENV should not be modified.  */

    tcg_debug_assert(!ots->fixed_reg);



    /* The movi is not explicitly generated here.  */

    if (ots->val_type == TEMP_VAL_REG) {
@@ -3314,6 +3311,9 @@ static void tcg_reg_alloc_mov(TCGContext *s, const TCGOp *op) 
    ots = arg_temp(op->args[0]);

    ts = arg_temp(op->args[1]);



    /* ENV should not be modified.  */

    tcg_debug_assert(!ots->fixed_reg);



    /* Note that otype != itype for no-op truncation.  */

    otype = ots->type;

    itype = ts->type;
@@ -3338,7 +3338,7 @@ static void tcg_reg_alloc_mov(TCGContext *s, const TCGOp *op) 
    }



    tcg_debug_assert(ts->val_type == TEMP_VAL_REG);

    if (IS_DEAD_ARG(0) && !ots->fixed_reg) {

    if (IS_DEAD_ARG(0)) {

        /* mov to a non-saved dead register makes no sense (even with

           liveness analysis disabled). */

        tcg_debug_assert(NEED_SYNC_ARG(0));
@@ -3351,7 +3351,7 @@ static void tcg_reg_alloc_mov(TCGContext *s, const TCGOp *op) 
        }

        temp_dead(s, ots);

    } else {

        if (IS_DEAD_ARG(1) && !ts->fixed_reg && !ots->fixed_reg) {

        if (IS_DEAD_ARG(1) && !ts->fixed_reg) {

            /* the mov can be suppressed */

            if (ots->val_type == TEMP_VAL_REG) {

                s->reg_to_temp[ots->reg] = NULL;
@@ -3504,6 +3504,10 @@ static void tcg_reg_alloc_op(TCGContext *s, const TCGOp *op) 
            arg = op->args[i];

            arg_ct = &def->args_ct[i];

            ts = arg_temp(arg);



            /* ENV should not be modified.  */

            tcg_debug_assert(!ts->fixed_reg);



            if ((arg_ct->ct & TCG_CT_ALIAS)

                && !const_args[arg_ct->alias_index]) {

                reg = new_args[arg_ct->alias_index];
@@ -3512,29 +3516,21 @@ static void tcg_reg_alloc_op(TCGContext *s, const TCGOp *op) 
                                    i_allocated_regs | o_allocated_regs,

                                    op->output_pref[k], ts->indirect_base);

            } else {

                /* if fixed register, we try to use it */

                reg = ts->reg;

                if (ts->fixed_reg &&

                    tcg_regset_test_reg(arg_ct->u.regs, reg)) {

                    goto oarg_end;

                }

                reg = tcg_reg_alloc(s, arg_ct->u.regs, o_allocated_regs,

                                    op->output_pref[k], ts->indirect_base);

            }

            tcg_regset_set_reg(o_allocated_regs, reg);

            /* if a fixed register is used, then a move will be done afterwards */

            if (!ts->fixed_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 */

            /*

             * Temp value is modified, so the value kept in memory is

             * potentially not the same.

             */

            ts->mem_coherent = 0;

            s->reg_to_temp[reg] = ts;

            }

        oarg_end:

            new_args[i] = reg;

        }

    }
@@ -3550,10 +3546,10 @@ static void tcg_reg_alloc_op(TCGContext *s, const TCGOp *op) 
    /* move the outputs in the correct register if needed */

    for(i = 0; i < nb_oargs; i++) {

        ts = arg_temp(op->args[i]);

        reg = new_args[i];

        if (ts->fixed_reg && ts->reg != reg) {

            tcg_out_mov(s, ts->type, ts->reg, reg);

        }



        /* ENV should not be modified.  */

        tcg_debug_assert(!ts->fixed_reg);



        if (NEED_SYNC_ARG(i)) {

            temp_sync(s, ts, o_allocated_regs, 0, IS_DEAD_ARG(i));

        } else if (IS_DEAD_ARG(i)) {
@@ -3674,14 +3670,12 @@ static void tcg_reg_alloc_call(TCGContext *s, TCGOp *op) 
    for(i = 0; i < nb_oargs; i++) {

        arg = op->args[i];

        ts = arg_temp(arg);



        /* ENV should not be modified.  */

        tcg_debug_assert(!ts->fixed_reg);



        reg = tcg_target_call_oarg_regs[i];

        tcg_debug_assert(s->reg_to_temp[reg] == NULL);



        if (ts->fixed_reg) {

            if (ts->reg != reg) {

                tcg_out_mov(s, ts->type, ts->reg, reg);

            }

        } else {

        if (ts->val_type == TEMP_VAL_REG) {

            s->reg_to_temp[ts->reg] = NULL;

        }
@@ -3696,7 +3690,6 @@ static void tcg_reg_alloc_call(TCGContext *s, TCGOp *op) 
        }

    }

}

}



#ifdef CONFIG_PROFILER