Commit 74f30f15 authored by Peter Maydell's avatar Peter Maydell
Browse files

Merge remote-tracking branch 'remotes/rth/tags/pull-tcg-20160209' into staging 



Queued TCG patches

# gpg: Signature made Mon 08 Feb 2016 23:57:30 GMT using RSA key ID 4DD0279B
# gpg: Good signature from "Richard Henderson <rth7680@gmail.com>"
# gpg:                 aka "Richard Henderson <rth@redhat.com>"
# gpg:                 aka "Richard Henderson <rth@twiddle.net>"

* remotes/rth/tags/pull-tcg-20160209:
  tcg: Introduce temp_load
  tcg: Change temp_save argument to TCGTemp
  tcg: Change temp_sync argument to TCGTemp
  tcg: Change temp_dead argument to TCGTemp
  tcg: Change reg_to_temp to TCGTemp pointer
  tcg: Remove tcg_get_arg_str_i32/64
  tcg: More use of TCGReg where appropriate
  tcg: Work around clang bug wrt enum ranges
  tcg: Tidy temporary allocation
  tcg: Change ts->mem_reg to ts->mem_base
  tcg: Change tcg_global_mem_new_* to take a TCGv_ptr
  tcg: Remove lingering references to gen_opc_buf
  tcg: Respect highwater in tcg_out_tb_finalize

Signed-off-by: default avatarPeter Maydell <peter.maydell@linaro.org>
parents e4a096b1 40ae5c62

target-alpha/translate.c

+4 −4
Original line number Diff line number Diff line
@@ -152,13 +152,13 @@ void alpha_translate_init(void) 
    cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");



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

        cpu_std_ir[i] = tcg_global_mem_new_i64(TCG_AREG0,

        cpu_std_ir[i] = tcg_global_mem_new_i64(cpu_env,

                                               offsetof(CPUAlphaState, ir[i]),

                                               greg_names[i]);

    }



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

        cpu_fir[i] = tcg_global_mem_new_i64(TCG_AREG0,

        cpu_fir[i] = tcg_global_mem_new_i64(cpu_env,

                                            offsetof(CPUAlphaState, fir[i]),

                                            freg_names[i]);

    }
@@ -167,7 +167,7 @@ void alpha_translate_init(void) 
    memcpy(cpu_pal_ir, cpu_std_ir, sizeof(cpu_pal_ir));

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

        int r = (i == 7 ? 25 : i + 8);

        cpu_pal_ir[r] = tcg_global_mem_new_i64(TCG_AREG0,

        cpu_pal_ir[r] = tcg_global_mem_new_i64(cpu_env,

                                               offsetof(CPUAlphaState,

                                                        shadow[i]),

                                               shadow_names[i]);
@@ -176,7 +176,7 @@ void alpha_translate_init(void) 


    for (i = 0; i < ARRAY_SIZE(vars); ++i) {

        const GlobalVar *v = &vars[i];

        *v->var = tcg_global_mem_new_i64(TCG_AREG0, v->ofs, v->name);

        *v->var = tcg_global_mem_new_i64(cpu_env, v->ofs, v->name);

    }

}

target-arm/translate-a64.c

+3 −3
Original line number Diff line number Diff line
@@ -86,16 +86,16 @@ void a64_translate_init(void) 
{

    int i;



    cpu_pc = tcg_global_mem_new_i64(TCG_AREG0,

    cpu_pc = tcg_global_mem_new_i64(cpu_env,

                                    offsetof(CPUARMState, pc),

                                    "pc");

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

        cpu_X[i] = tcg_global_mem_new_i64(TCG_AREG0,

        cpu_X[i] = tcg_global_mem_new_i64(cpu_env,

                                          offsetof(CPUARMState, xregs[i]),

                                          regnames[i]);

    }



    cpu_exclusive_high = tcg_global_mem_new_i64(TCG_AREG0,

    cpu_exclusive_high = tcg_global_mem_new_i64(cpu_env,

        offsetof(CPUARMState, exclusive_high), "exclusive_high");

}

target-arm/translate.c

+10 −11
Original line number Diff line number Diff line
@@ -86,23 +86,23 @@ void arm_translate_init(void) 
    cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");



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

        cpu_R[i] = tcg_global_mem_new_i32(TCG_AREG0,

        cpu_R[i] = tcg_global_mem_new_i32(cpu_env,

                                          offsetof(CPUARMState, regs[i]),

                                          regnames[i]);

    }

    cpu_CF = tcg_global_mem_new_i32(TCG_AREG0, offsetof(CPUARMState, CF), "CF");

    cpu_NF = tcg_global_mem_new_i32(TCG_AREG0, offsetof(CPUARMState, NF), "NF");

    cpu_VF = tcg_global_mem_new_i32(TCG_AREG0, offsetof(CPUARMState, VF), "VF");

    cpu_ZF = tcg_global_mem_new_i32(TCG_AREG0, offsetof(CPUARMState, ZF), "ZF");

    cpu_CF = tcg_global_mem_new_i32(cpu_env, offsetof(CPUARMState, CF), "CF");

    cpu_NF = tcg_global_mem_new_i32(cpu_env, offsetof(CPUARMState, NF), "NF");

    cpu_VF = tcg_global_mem_new_i32(cpu_env, offsetof(CPUARMState, VF), "VF");

    cpu_ZF = tcg_global_mem_new_i32(cpu_env, offsetof(CPUARMState, ZF), "ZF");



    cpu_exclusive_addr = tcg_global_mem_new_i64(TCG_AREG0,

    cpu_exclusive_addr = tcg_global_mem_new_i64(cpu_env,

        offsetof(CPUARMState, exclusive_addr), "exclusive_addr");

    cpu_exclusive_val = tcg_global_mem_new_i64(TCG_AREG0,

    cpu_exclusive_val = tcg_global_mem_new_i64(cpu_env,

        offsetof(CPUARMState, exclusive_val), "exclusive_val");

#ifdef CONFIG_USER_ONLY

    cpu_exclusive_test = tcg_global_mem_new_i64(TCG_AREG0,

    cpu_exclusive_test = tcg_global_mem_new_i64(cpu_env,

        offsetof(CPUARMState, exclusive_test), "exclusive_test");

    cpu_exclusive_info = tcg_global_mem_new_i32(TCG_AREG0,

    cpu_exclusive_info = tcg_global_mem_new_i32(cpu_env,

        offsetof(CPUARMState, exclusive_info), "exclusive_info");

#endif
@@ -11209,8 +11209,7 @@ static bool insn_crosses_page(CPUARMState *env, DisasContext *s) 
    return false;

}



/* generate intermediate code in gen_opc_buf and gen_opparam_buf for

   basic block 'tb'.  */

/* generate intermediate code for basic block 'tb'.  */

void gen_intermediate_code(CPUARMState *env, TranslationBlock *tb)

{

    ARMCPU *cpu = arm_env_get_cpu(env);

target-cris/translate.c

+12 −12
Original line number Diff line number Diff line
@@ -3364,41 +3364,41 @@ void cris_initialize_tcg(void) 
    int i;



    cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");

    cc_x = tcg_global_mem_new(TCG_AREG0,

    cc_x = tcg_global_mem_new(cpu_env,

                              offsetof(CPUCRISState, cc_x), "cc_x");

    cc_src = tcg_global_mem_new(TCG_AREG0,

    cc_src = tcg_global_mem_new(cpu_env,

                                offsetof(CPUCRISState, cc_src), "cc_src");

    cc_dest = tcg_global_mem_new(TCG_AREG0,

    cc_dest = tcg_global_mem_new(cpu_env,

                                 offsetof(CPUCRISState, cc_dest),

                                 "cc_dest");

    cc_result = tcg_global_mem_new(TCG_AREG0,

    cc_result = tcg_global_mem_new(cpu_env,

                                   offsetof(CPUCRISState, cc_result),

                                   "cc_result");

    cc_op = tcg_global_mem_new(TCG_AREG0,

    cc_op = tcg_global_mem_new(cpu_env,

                               offsetof(CPUCRISState, cc_op), "cc_op");

    cc_size = tcg_global_mem_new(TCG_AREG0,

    cc_size = tcg_global_mem_new(cpu_env,

                                 offsetof(CPUCRISState, cc_size),

                                 "cc_size");

    cc_mask = tcg_global_mem_new(TCG_AREG0,

    cc_mask = tcg_global_mem_new(cpu_env,

                                 offsetof(CPUCRISState, cc_mask),

                                 "cc_mask");



    env_pc = tcg_global_mem_new(TCG_AREG0,

    env_pc = tcg_global_mem_new(cpu_env,

                                offsetof(CPUCRISState, pc),

                                "pc");

    env_btarget = tcg_global_mem_new(TCG_AREG0,

    env_btarget = tcg_global_mem_new(cpu_env,

                                     offsetof(CPUCRISState, btarget),

                                     "btarget");

    env_btaken = tcg_global_mem_new(TCG_AREG0,

    env_btaken = tcg_global_mem_new(cpu_env,

                                    offsetof(CPUCRISState, btaken),

                                    "btaken");

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

        cpu_R[i] = tcg_global_mem_new(TCG_AREG0,

        cpu_R[i] = tcg_global_mem_new(cpu_env,

                                      offsetof(CPUCRISState, regs[i]),

                                      regnames[i]);

    }

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

        cpu_PR[i] = tcg_global_mem_new(TCG_AREG0,

        cpu_PR[i] = tcg_global_mem_new(cpu_env,

                                       offsetof(CPUCRISState, pregs[i]),

                                       pregnames[i]);

    }

target-cris/translate_v10.c

+41 −41
Original line number Diff line number Diff line
@@ -1250,41 +1250,41 @@ void cris_initialize_crisv10_tcg(void) 
    int i;



    cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");

	cc_x = tcg_global_mem_new(TCG_AREG0,

    cc_x = tcg_global_mem_new(cpu_env,

                              offsetof(CPUCRISState, cc_x), "cc_x");

	cc_src = tcg_global_mem_new(TCG_AREG0,

    cc_src = tcg_global_mem_new(cpu_env,

                                offsetof(CPUCRISState, cc_src), "cc_src");

	cc_dest = tcg_global_mem_new(TCG_AREG0,

    cc_dest = tcg_global_mem_new(cpu_env,

                                 offsetof(CPUCRISState, cc_dest),

                                 "cc_dest");

	cc_result = tcg_global_mem_new(TCG_AREG0,

    cc_result = tcg_global_mem_new(cpu_env,

                                   offsetof(CPUCRISState, cc_result),

                                   "cc_result");

	cc_op = tcg_global_mem_new(TCG_AREG0,

    cc_op = tcg_global_mem_new(cpu_env,

                               offsetof(CPUCRISState, cc_op), "cc_op");

	cc_size = tcg_global_mem_new(TCG_AREG0,

    cc_size = tcg_global_mem_new(cpu_env,

                                 offsetof(CPUCRISState, cc_size),

                                 "cc_size");

	cc_mask = tcg_global_mem_new(TCG_AREG0,

    cc_mask = tcg_global_mem_new(cpu_env,

                                 offsetof(CPUCRISState, cc_mask),

                                 "cc_mask");



	env_pc = tcg_global_mem_new(TCG_AREG0, 

    env_pc = tcg_global_mem_new(cpu_env,

                                offsetof(CPUCRISState, pc),

                                "pc");

	env_btarget = tcg_global_mem_new(TCG_AREG0,

    env_btarget = tcg_global_mem_new(cpu_env,

                                     offsetof(CPUCRISState, btarget),

                                     "btarget");

	env_btaken = tcg_global_mem_new(TCG_AREG0,

    env_btaken = tcg_global_mem_new(cpu_env,

                                    offsetof(CPUCRISState, btaken),

                                    "btaken");

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

		cpu_R[i] = tcg_global_mem_new(TCG_AREG0,

        cpu_R[i] = tcg_global_mem_new(cpu_env,

                                      offsetof(CPUCRISState, regs[i]),

                                      regnames_v10[i]);

    }

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

		cpu_PR[i] = tcg_global_mem_new(TCG_AREG0,

        cpu_PR[i] = tcg_global_mem_new(cpu_env,

                                       offsetof(CPUCRISState, pregs[i]),

                                       pregnames_v10[i]);

    }