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

tcg: Change ts->mem_reg to ts->mem_base 



Chain the temporaries together via pointers intstead of indices.
The mem_reg value is now mem_base->reg.  This will be important later.

This does require that the frame pointer have a global temporary
allocated for it.  This is simple bar the existing reserved_regs check.

Reviewed-by: default avatarAurelien Jarno <aurelien@aurel32.net>
Signed-off-by: default avatarRichard Henderson <rth@twiddle.net>
parent e1ccc054

tcg/tcg.c

+36 −29
Original line number Diff line number Diff line
@@ -403,13 +403,6 @@ void tcg_prologue_init(TCGContext *s) 
#endif

}



void tcg_set_frame(TCGContext *s, int reg, intptr_t start, intptr_t size)

{

    s->frame_start = start;

    s->frame_end = start + size;

    s->frame_reg = reg;

}



void tcg_func_start(TCGContext *s)

{

    tcg_pool_reset(s);
@@ -439,19 +432,15 @@ static inline void tcg_temp_alloc(TCGContext *s, int n) 
        tcg_abort();

}



static inline int tcg_global_reg_new_internal(TCGType type, int reg,

                                              const char *name)

static int tcg_global_reg_new_internal(TCGContext *s, TCGType type,

                                       int reg, const char *name)

{

    TCGContext *s = &tcg_ctx;

    TCGTemp *ts;

    int idx;



#if TCG_TARGET_REG_BITS == 32

    if (type != TCG_TYPE_I32)

        tcg_abort();

#endif

    if (tcg_regset_test_reg(s->reserved_regs, reg))

    if (TCG_TARGET_REG_BITS == 32 && type != TCG_TYPE_I32) {

        tcg_abort();

    }

    idx = s->nb_globals;

    tcg_temp_alloc(s, s->nb_globals + 1);

    ts = &s->temps[s->nb_globals];
@@ -465,19 +454,36 @@ static inline int tcg_global_reg_new_internal(TCGType type, int reg, 
    return idx;

}



void tcg_set_frame(TCGContext *s, int reg, intptr_t start, intptr_t size)

{

    int idx;

    s->frame_start = start;

    s->frame_end = start + size;

    idx = tcg_global_reg_new_internal(s, TCG_TYPE_PTR, reg, "_frame");

    s->frame_temp = &s->temps[idx];

}



TCGv_i32 tcg_global_reg_new_i32(int reg, const char *name)

{

    TCGContext *s = &tcg_ctx;

    int idx;



    idx = tcg_global_reg_new_internal(TCG_TYPE_I32, reg, name);

    if (tcg_regset_test_reg(s->reserved_regs, reg)) {

        tcg_abort();

    }

    idx = tcg_global_reg_new_internal(s, TCG_TYPE_I32, reg, name);

    return MAKE_TCGV_I32(idx);

}



TCGv_i64 tcg_global_reg_new_i64(int reg, const char *name)

{

    TCGContext *s = &tcg_ctx;

    int idx;



    idx = tcg_global_reg_new_internal(TCG_TYPE_I64, reg, name);

    if (tcg_regset_test_reg(s->reserved_regs, reg)) {

        tcg_abort();

    }

    idx = tcg_global_reg_new_internal(s, TCG_TYPE_I64, reg, name);

    return MAKE_TCGV_I64(idx);

}
@@ -486,7 +492,7 @@ int tcg_global_mem_new_internal(TCGType type, TCGv_ptr base, 
{

    TCGContext *s = &tcg_ctx;

    TCGTemp *ts, *base_ts = &s->temps[GET_TCGV_PTR(base)];

    int idx, reg = base_ts->reg;

    int idx;



    idx = s->nb_globals;

#if TCG_TARGET_REG_BITS == 32
@@ -498,7 +504,7 @@ int tcg_global_mem_new_internal(TCGType type, TCGv_ptr base, 
        ts->type = TCG_TYPE_I32;

        ts->fixed_reg = 0;

        ts->mem_allocated = 1;

        ts->mem_reg = reg;

        ts->mem_base = base_ts;

#ifdef HOST_WORDS_BIGENDIAN

        ts->mem_offset = offset + 4;

#else
@@ -513,7 +519,7 @@ int tcg_global_mem_new_internal(TCGType type, TCGv_ptr base, 
        ts->type = TCG_TYPE_I32;

        ts->fixed_reg = 0;

        ts->mem_allocated = 1;

        ts->mem_reg = reg;

        ts->mem_base = base_ts;

#ifdef HOST_WORDS_BIGENDIAN

        ts->mem_offset = offset;

#else
@@ -533,7 +539,7 @@ int tcg_global_mem_new_internal(TCGType type, TCGv_ptr base, 
        ts->type = type;

        ts->fixed_reg = 0;

        ts->mem_allocated = 1;

        ts->mem_reg = reg;

        ts->mem_base = base_ts;

        ts->mem_offset = offset;

        ts->name = name;

        s->nb_globals++;
@@ -1587,7 +1593,8 @@ static void dump_regs(TCGContext *s) 
            printf("%s", tcg_target_reg_names[ts->reg]);

            break;

        case TEMP_VAL_MEM:

            printf("%d(%s)", (int)ts->mem_offset, tcg_target_reg_names[ts->mem_reg]);

            printf("%d(%s)", (int)ts->mem_offset,

                   tcg_target_reg_names[ts->mem_base->reg]);

            break;

        case TEMP_VAL_CONST:

            printf("$0x%" TCG_PRIlx, ts->val);
@@ -1660,7 +1667,7 @@ static void temp_allocate_frame(TCGContext *s, int temp) 
        tcg_abort();

    }

    ts->mem_offset = s->current_frame_offset;

    ts->mem_reg = s->frame_reg;

    ts->mem_base = s->frame_temp;

    ts->mem_allocated = 1;

    s->current_frame_offset += sizeof(tcg_target_long);

}
@@ -1678,7 +1685,7 @@ static inline void tcg_reg_sync(TCGContext *s, int reg) 
        if (!ts->mem_allocated) {

            temp_allocate_frame(s, temp);

        }

        tcg_out_st(s, ts->type, reg, ts->mem_reg, ts->mem_offset);

        tcg_out_st(s, ts->type, reg, ts->mem_base->reg, ts->mem_offset);

    }

    ts->mem_coherent = 1;

}
@@ -1894,7 +1901,7 @@ static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def, 
        ts->reg = tcg_reg_alloc(s, tcg_target_available_regs[itype],

                                allocated_regs);

        if (ts->val_type == TEMP_VAL_MEM) {

            tcg_out_ld(s, itype, ts->reg, ts->mem_reg, ts->mem_offset);

            tcg_out_ld(s, itype, ts->reg, ts->mem_base->reg, ts->mem_offset);

            ts->mem_coherent = 1;

        } else if (ts->val_type == TEMP_VAL_CONST) {

            tcg_out_movi(s, itype, ts->reg, ts->val);
@@ -1913,7 +1920,7 @@ static void tcg_reg_alloc_mov(TCGContext *s, const TCGOpDef *def, 
        if (!ots->mem_allocated) {

            temp_allocate_frame(s, args[0]);

        }

        tcg_out_st(s, otype, ts->reg, ots->mem_reg, ots->mem_offset);

        tcg_out_st(s, otype, ts->reg, ots->mem_base->reg, ots->mem_offset);

        if (IS_DEAD_ARG(1)) {

            temp_dead(s, args[1]);

        }
@@ -1988,7 +1995,7 @@ static void tcg_reg_alloc_op(TCGContext *s, 
        ts = &s->temps[arg];

        if (ts->val_type == TEMP_VAL_MEM) {

            reg = tcg_reg_alloc(s, arg_ct->u.regs, allocated_regs);

            tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);

            tcg_out_ld(s, ts->type, reg, ts->mem_base->reg, ts->mem_offset);

            ts->val_type = TEMP_VAL_REG;

            ts->reg = reg;

            ts->mem_coherent = 1;
@@ -2182,7 +2189,7 @@ static void tcg_reg_alloc_call(TCGContext *s, int nb_oargs, int nb_iargs, 
                reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type], 

                                    s->reserved_regs);

                /* XXX: not correct if reading values from the stack */

                tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);

                tcg_out_ld(s, ts->type, reg, ts->mem_base->reg, ts->mem_offset);

                tcg_out_st(s, ts->type, reg, TCG_REG_CALL_STACK, stack_offset);

            } else if (ts->val_type == TEMP_VAL_CONST) {

                reg = tcg_reg_alloc(s, tcg_target_available_regs[ts->type],
@@ -2212,7 +2219,7 @@ static void tcg_reg_alloc_call(TCGContext *s, int nb_oargs, int nb_iargs, 
                    tcg_out_mov(s, ts->type, reg, ts->reg);

                }

            } else if (ts->val_type == TEMP_VAL_MEM) {

                tcg_out_ld(s, ts->type, reg, ts->mem_reg, ts->mem_offset);

                tcg_out_ld(s, ts->type, reg, ts->mem_base->reg, ts->mem_offset);

            } else if (ts->val_type == TEMP_VAL_CONST) {

                /* XXX: sign extend ? */

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

tcg/tcg.h

+2 −2
Original line number Diff line number Diff line
@@ -449,7 +449,6 @@ typedef enum TCGTempVal { 


typedef struct TCGTemp {

    unsigned int reg:8;

    unsigned int mem_reg:8;

    TCGTempVal val_type:8;

    TCGType base_type:8;

    TCGType type:8;
@@ -462,6 +461,7 @@ typedef struct TCGTemp { 
    unsigned int temp_allocated:1; /* never used for code gen */



    tcg_target_long val;

    struct TCGTemp *mem_base;

    intptr_t mem_offset;

    const char *name;

} TCGTemp;
@@ -515,7 +515,7 @@ struct TCGContext { 
    intptr_t current_frame_offset;

    intptr_t frame_start;

    intptr_t frame_end;

    int frame_reg;

    TCGTemp *frame_temp;



    tcg_insn_unit *code_ptr;