Commit 6a18ae2d authored by Blue Swirl's avatar Blue Swirl
Browse files

i386: Remove REGPARM 



Use stack based calling convention (GCC default) for interfacing with
generated code instead of register based convention (regparm(3)).

Signed-off-by: default avatarBlue Swirl <blauwirbel@gmail.com>
parent 361dea40

osdep.h

+0 −6
Original line number Diff line number Diff line
@@ -70,12 +70,6 @@ 
#define inline always_inline

#endif



#ifdef __i386__

#define REGPARM __attribute((regparm(3)))

#else

#define REGPARM

#endif



#define qemu_printf printf



int qemu_daemon(int nochdir, int noclose);

softmmu_defs.h

+16 −16
Original line number Diff line number Diff line
@@ -9,22 +9,22 @@ 
#ifndef SOFTMMU_DEFS_H

#define SOFTMMU_DEFS_H



uint8_t REGPARM __ldb_mmu(target_ulong addr, int mmu_idx);

void REGPARM __stb_mmu(target_ulong addr, uint8_t val, int mmu_idx);

uint16_t REGPARM __ldw_mmu(target_ulong addr, int mmu_idx);

void REGPARM __stw_mmu(target_ulong addr, uint16_t val, int mmu_idx);

uint32_t REGPARM __ldl_mmu(target_ulong addr, int mmu_idx);

void REGPARM __stl_mmu(target_ulong addr, uint32_t val, int mmu_idx);

uint64_t REGPARM __ldq_mmu(target_ulong addr, int mmu_idx);

void REGPARM __stq_mmu(target_ulong addr, uint64_t val, int mmu_idx);

uint8_t __ldb_mmu(target_ulong addr, int mmu_idx);

void __stb_mmu(target_ulong addr, uint8_t val, int mmu_idx);

uint16_t __ldw_mmu(target_ulong addr, int mmu_idx);

void __stw_mmu(target_ulong addr, uint16_t val, int mmu_idx);

uint32_t __ldl_mmu(target_ulong addr, int mmu_idx);

void __stl_mmu(target_ulong addr, uint32_t val, int mmu_idx);

uint64_t __ldq_mmu(target_ulong addr, int mmu_idx);

void __stq_mmu(target_ulong addr, uint64_t val, int mmu_idx);



uint8_t REGPARM __ldb_cmmu(target_ulong addr, int mmu_idx);

void REGPARM __stb_cmmu(target_ulong addr, uint8_t val, int mmu_idx);

uint16_t REGPARM __ldw_cmmu(target_ulong addr, int mmu_idx);

void REGPARM __stw_cmmu(target_ulong addr, uint16_t val, int mmu_idx);

uint32_t REGPARM __ldl_cmmu(target_ulong addr, int mmu_idx);

void REGPARM __stl_cmmu(target_ulong addr, uint32_t val, int mmu_idx);

uint64_t REGPARM __ldq_cmmu(target_ulong addr, int mmu_idx);

void REGPARM __stq_cmmu(target_ulong addr, uint64_t val, int mmu_idx);

uint8_t __ldb_cmmu(target_ulong addr, int mmu_idx);

void __stb_cmmu(target_ulong addr, uint8_t val, int mmu_idx);

uint16_t __ldw_cmmu(target_ulong addr, int mmu_idx);

void __stw_cmmu(target_ulong addr, uint16_t val, int mmu_idx);

uint32_t __ldl_cmmu(target_ulong addr, int mmu_idx);

void __stl_cmmu(target_ulong addr, uint32_t val, int mmu_idx);

uint64_t __ldq_cmmu(target_ulong addr, int mmu_idx);

void __stq_cmmu(target_ulong addr, uint64_t val, int mmu_idx);



#endif

softmmu_template.h

+3 −5
Original line number Diff line number Diff line
@@ -89,8 +89,7 @@ static inline DATA_TYPE glue(io_read, SUFFIX)(target_phys_addr_t physaddr, 
}



/* handle all cases except unaligned access which span two pages */

DATA_TYPE REGPARM glue(glue(__ld, SUFFIX), MMUSUFFIX)(target_ulong addr,

                                                      int mmu_idx)

DATA_TYPE glue(glue(__ld, SUFFIX), MMUSUFFIX)(target_ulong addr, int mmu_idx)

{

    DATA_TYPE res;

    int index;
@@ -232,8 +231,7 @@ static inline void glue(io_write, SUFFIX)(target_phys_addr_t physaddr, 
#endif /* SHIFT > 2 */

}



void REGPARM glue(glue(__st, SUFFIX), MMUSUFFIX)(target_ulong addr,

                                                 DATA_TYPE val,

void glue(glue(__st, SUFFIX), MMUSUFFIX)(target_ulong addr, DATA_TYPE val,

                                         int mmu_idx)

{

    target_phys_addr_t ioaddr;

tcg/i386/tcg-target.c

+56 −56
Original line number Diff line number Diff line
@@ -116,17 +116,7 @@ static inline int tcg_target_get_call_iarg_regs_count(int flags) 
        return 6;

    }



    flags &= TCG_CALL_TYPE_MASK;

    switch(flags) {

    case TCG_CALL_TYPE_STD:

    return 0;

    case TCG_CALL_TYPE_REGPARM_1:

    case TCG_CALL_TYPE_REGPARM_2:

    case TCG_CALL_TYPE_REGPARM:

        return flags - TCG_CALL_TYPE_REGPARM_1 + 1;

    default:

        tcg_abort();

    }

}



/* parse target specific constraints */
@@ -1148,7 +1138,12 @@ static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args, 
    int data_reg, data_reg2 = 0;

    int addrlo_idx;

#if defined(CONFIG_SOFTMMU)

    int mem_index, s_bits, arg_idx;

    int mem_index, s_bits;

#if TCG_TARGET_REG_BITS == 64

    int arg_idx;

#else

    int stack_adjust;

#endif

    uint8_t *label_ptr[3];

#endif
@@ -1184,16 +1179,33 @@ static void tcg_out_qemu_ld(TCGContext *s, const TCGArg *args, 
    }



    /* XXX: move that code at the end of the TB */

#if TCG_TARGET_REG_BITS == 32

    tcg_out_pushi(s, mem_index);

    stack_adjust = 4;

    if (TARGET_LONG_BITS == 64) {

        tcg_out_push(s, args[addrlo_idx + 1]);

        stack_adjust += 4;

    }

    tcg_out_push(s, args[addrlo_idx]);

    stack_adjust += 4;

#else

    /* The first argument is already loaded with addrlo.  */

    arg_idx = 1;

    if (TCG_TARGET_REG_BITS == 32 && TARGET_LONG_BITS == 64) {

        tcg_out_mov(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[arg_idx++],

                    args[addrlo_idx + 1]);

    }

    tcg_out_movi(s, TCG_TYPE_I32, tcg_target_call_iarg_regs[arg_idx],

                 mem_index);

#endif



    tcg_out_calli(s, (tcg_target_long)qemu_ld_helpers[s_bits]);



#if TCG_TARGET_REG_BITS == 32

    if (stack_adjust == (TCG_TARGET_REG_BITS / 8)) {

        /* Pop and discard.  This is 2 bytes smaller than the add.  */

        tcg_out_pop(s, TCG_REG_ECX);

    } else if (stack_adjust != 0) {

        tcg_out_addi(s, TCG_REG_CALL_STACK, stack_adjust);

    }

#endif



    switch(opc) {

    case 0 | 4:

        tcg_out_ext8s(s, data_reg, TCG_REG_EAX, P_REXW);
@@ -1359,45 +1371,27 @@ static void tcg_out_qemu_st(TCGContext *s, const TCGArg *args, 
    }



    /* XXX: move that code at the end of the TB */

    if (TCG_TARGET_REG_BITS == 64) {

        tcg_out_mov(s, (opc == 3 ? TCG_TYPE_I64 : TCG_TYPE_I32),

                    TCG_REG_RSI, data_reg);

        tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_RDX, mem_index);

        stack_adjust = 0;

    } else if (TARGET_LONG_BITS == 32) {

        tcg_out_mov(s, TCG_TYPE_I32, TCG_REG_EDX, data_reg);

        if (opc == 3) {

            tcg_out_mov(s, TCG_TYPE_I32, TCG_REG_ECX, data_reg2);

#if TCG_TARGET_REG_BITS == 32

    tcg_out_pushi(s, mem_index);

    stack_adjust = 4;

        } else {

            tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_ECX, mem_index);

            stack_adjust = 0;

        }

    } else {

    if (opc == 3) {

            tcg_out_mov(s, TCG_TYPE_I32, TCG_REG_EDX, args[addrlo_idx + 1]);

            tcg_out_pushi(s, mem_index);

        tcg_out_push(s, data_reg2);

            tcg_out_push(s, data_reg);

            stack_adjust = 12;

        } else {

            tcg_out_mov(s, TCG_TYPE_I32, TCG_REG_EDX, args[addrlo_idx + 1]);

            switch(opc) {

            case 0:

                tcg_out_ext8u(s, TCG_REG_ECX, data_reg);

                break;

            case 1:

                tcg_out_ext16u(s, TCG_REG_ECX, data_reg);

                break;

            case 2:

                tcg_out_mov(s, TCG_TYPE_I32, TCG_REG_ECX, data_reg);

                break;

            }

            tcg_out_pushi(s, mem_index);

            stack_adjust = 4;

        stack_adjust += 4;

    }

    tcg_out_push(s, data_reg);

    stack_adjust += 4;

    if (TARGET_LONG_BITS == 64) {

        tcg_out_push(s, args[addrlo_idx + 1]);

        stack_adjust += 4;

    }

    tcg_out_push(s, args[addrlo_idx]);

    stack_adjust += 4;

#else

    tcg_out_mov(s, (opc == 3 ? TCG_TYPE_I64 : TCG_TYPE_I32),

                TCG_REG_RSI, data_reg);

    tcg_out_movi(s, TCG_TYPE_I32, TCG_REG_RDX, mem_index);

    stack_adjust = 0;

#endif



    tcg_out_calli(s, (tcg_target_long)qemu_st_helpers[s_bits]);
@@ -1962,9 +1956,15 @@ static void tcg_target_qemu_prologue(TCGContext *s) 
        tcg_out_push(s, tcg_target_callee_save_regs[i]);

    }



    tcg_out_addi(s, TCG_REG_ESP, -stack_addend);



#if TCG_TARGET_REG_BITS == 32

    tcg_out_ld(s, TCG_TYPE_PTR, TCG_AREG0, TCG_REG_ESP,

               (ARRAY_SIZE(tcg_target_callee_save_regs) + 1) * 4);

    tcg_out_ld(s, TCG_TYPE_PTR, tcg_target_call_iarg_regs[1], TCG_REG_ESP,

               (ARRAY_SIZE(tcg_target_callee_save_regs) + 2) * 4);

#else

    tcg_out_mov(s, TCG_TYPE_PTR, TCG_AREG0, tcg_target_call_iarg_regs[0]);

#endif

    tcg_out_addi(s, TCG_REG_ESP, -stack_addend);



    /* jmp *tb.  */

    tcg_out_modrm(s, OPC_GRP5, EXT5_JMPN_Ev, tcg_target_call_iarg_regs[1]);

tcg/ppc/tcg-target.h

+1 −1
Original line number Diff line number Diff line
@@ -98,5 +98,5 @@ typedef enum { 
#define TCG_TARGET_HAS_GUEST_BASE



#define tcg_qemu_tb_exec(env, tb_ptr) \

    ((long REGPARM __attribute__ ((longcall)) \

    ((long __attribute__ ((longcall)) \

      (*)(void *, void *))code_gen_prologue)(env, tb_ptr)