Commit fe8d8f0f authored by Blue Swirl's avatar Blue Swirl
Browse files

Sparc: avoid AREG0 for memory access helpers 



Make memory access helpers take a parameter for CPUState instead
of relying on global env. Introduce wrappers for load and store ops.

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

Makefile.target

+1 −1
Original line number Diff line number Diff line
@@ -103,7 +103,7 @@ $(libobj-y): $(GENERATED_HEADERS) 


# HELPER_CFLAGS is used for all the code compiled with static register

# variables

op_helper.o ldst_helper.o user-exec.o: QEMU_CFLAGS += $(HELPER_CFLAGS)

op_helper.o user-exec.o: QEMU_CFLAGS += $(HELPER_CFLAGS)



# Note: this is a workaround. The real fix is to avoid compiling

# cpu_signal_handler() in user-exec.c.

target-sparc/cpu.h

+82 −0
Original line number Diff line number Diff line
@@ -586,8 +586,90 @@ void cpu_unassigned_access(CPUSPARCState *env1, target_phys_addr_t addr, 
#if defined(TARGET_SPARC64)

target_phys_addr_t cpu_get_phys_page_nofault(CPUSPARCState *env, target_ulong addr,

                                           int mmu_idx);

#endif



#define WRAP_LD(rettype, fn)                                    \

    rettype cpu_ ## fn (CPUSPARCState *env1, target_ulong addr)



WRAP_LD(uint32_t, ldub_kernel);

WRAP_LD(uint32_t, lduw_kernel);

WRAP_LD(uint32_t, ldl_kernel);

WRAP_LD(uint64_t, ldq_kernel);



WRAP_LD(uint32_t, ldub_user);

WRAP_LD(uint32_t, lduw_user);

WRAP_LD(uint32_t, ldl_user);

WRAP_LD(uint64_t, ldq_user);



WRAP_LD(uint64_t, ldfq_kernel);

WRAP_LD(uint64_t, ldfq_user);



#ifdef TARGET_SPARC64

WRAP_LD(uint32_t, ldub_hypv);

WRAP_LD(uint32_t, lduw_hypv);

WRAP_LD(uint32_t, ldl_hypv);

WRAP_LD(uint64_t, ldq_hypv);



WRAP_LD(uint64_t, ldfq_hypv);



WRAP_LD(uint32_t, ldub_nucleus);

WRAP_LD(uint32_t, lduw_nucleus);

WRAP_LD(uint32_t, ldl_nucleus);

WRAP_LD(uint64_t, ldq_nucleus);



WRAP_LD(uint32_t, ldub_kernel_secondary);

WRAP_LD(uint32_t, lduw_kernel_secondary);

WRAP_LD(uint32_t, ldl_kernel_secondary);

WRAP_LD(uint64_t, ldq_kernel_secondary);



WRAP_LD(uint32_t, ldub_user_secondary);

WRAP_LD(uint32_t, lduw_user_secondary);

WRAP_LD(uint32_t, ldl_user_secondary);

WRAP_LD(uint64_t, ldq_user_secondary);

#endif

#undef WRAP_LD



#define WRAP_ST(datatype, fn)                                           \

    void cpu_ ## fn (CPUSPARCState *env1, target_ulong addr, datatype val)



WRAP_ST(uint32_t, stb_kernel);

WRAP_ST(uint32_t, stw_kernel);

WRAP_ST(uint32_t, stl_kernel);

WRAP_ST(uint64_t, stq_kernel);



WRAP_ST(uint32_t, stb_user);

WRAP_ST(uint32_t, stw_user);

WRAP_ST(uint32_t, stl_user);

WRAP_ST(uint64_t, stq_user);



WRAP_ST(uint64_t, stfq_kernel);

WRAP_ST(uint64_t, stfq_user);



#ifdef TARGET_SPARC64

WRAP_ST(uint32_t, stb_hypv);

WRAP_ST(uint32_t, stw_hypv);

WRAP_ST(uint32_t, stl_hypv);

WRAP_ST(uint64_t, stq_hypv);



WRAP_ST(uint64_t, stfq_hypv);



WRAP_ST(uint32_t, stb_nucleus);

WRAP_ST(uint32_t, stw_nucleus);

WRAP_ST(uint32_t, stl_nucleus);

WRAP_ST(uint64_t, stq_nucleus);



WRAP_ST(uint32_t, stb_kernel_secondary);

WRAP_ST(uint32_t, stw_kernel_secondary);

WRAP_ST(uint32_t, stl_kernel_secondary);

WRAP_ST(uint64_t, stq_kernel_secondary);



WRAP_ST(uint32_t, stb_user_secondary);

WRAP_ST(uint32_t, stw_user_secondary);

WRAP_ST(uint32_t, stl_user_secondary);

WRAP_ST(uint64_t, stq_user_secondary);

#endif



#undef WRAP_ST

#endif

int cpu_sparc_signal_handler(int host_signum, void *pinfo, void *puc);

target-sparc/helper.h

+10 −10
Original line number Diff line number Diff line
@@ -18,11 +18,11 @@ DEF_HELPER_1(rdcwp, tl, env) 
DEF_HELPER_2(wrcwp, void, env, tl)

DEF_HELPER_FLAGS_2(array8, TCG_CALL_CONST | TCG_CALL_PURE, tl, tl, tl)

DEF_HELPER_1(popc, tl, tl)

DEF_HELPER_3(ldda_asi, void, tl, int, int)

DEF_HELPER_4(ldf_asi, void, tl, int, int, int)

DEF_HELPER_4(stf_asi, void, tl, int, int, int)

DEF_HELPER_4(cas_asi, tl, tl, tl, tl, i32)

DEF_HELPER_4(casx_asi, tl, tl, tl, tl, i32)

DEF_HELPER_4(ldda_asi, void, env, tl, int, int)

DEF_HELPER_5(ldf_asi, void, env, tl, int, int, int)

DEF_HELPER_5(stf_asi, void, env, tl, int, int, int)

DEF_HELPER_5(cas_asi, tl, env, tl, tl, tl, i32)

DEF_HELPER_5(casx_asi, tl, env, tl, tl, tl, i32)

DEF_HELPER_2(set_softint, void, env, i64)

DEF_HELPER_2(clear_softint, void, env, i64)

DEF_HELPER_2(write_softint, void, env, i64)
@@ -30,7 +30,7 @@ DEF_HELPER_2(tick_set_count, void, ptr, i64) 
DEF_HELPER_1(tick_get_count, i64, ptr)

DEF_HELPER_2(tick_set_limit, void, ptr, i64)

#endif

DEF_HELPER_2(check_align, void, tl, i32)

DEF_HELPER_3(check_align, void, env, tl, i32)

DEF_HELPER_1(debug, void, env)

DEF_HELPER_1(save, void, env)

DEF_HELPER_1(restore, void, env)
@@ -38,11 +38,11 @@ DEF_HELPER_3(udiv, tl, env, tl, tl) 
DEF_HELPER_3(udiv_cc, tl, env, tl, tl)

DEF_HELPER_3(sdiv, tl, env, tl, tl)

DEF_HELPER_3(sdiv_cc, tl, env, tl, tl)

DEF_HELPER_2(ldqf, void, tl, int)

DEF_HELPER_2(stqf, void, tl, int)

DEF_HELPER_3(ldqf, void, env, tl, int)

DEF_HELPER_3(stqf, void, env, tl, int)

#if !defined(CONFIG_USER_ONLY) || defined(TARGET_SPARC64)

DEF_HELPER_4(ld_asi, i64, tl, int, int, int)

DEF_HELPER_4(st_asi, void, tl, i64, int, int)

DEF_HELPER_5(ld_asi, i64, env, tl, int, int, int)

DEF_HELPER_5(st_asi, void, env, tl, i64, int, int)

#endif

DEF_HELPER_2(ldfsr, void, env, i32)

DEF_HELPER_FLAGS_1(fabss, TCG_CALL_CONST | TCG_CALL_PURE, f32, f32)

target-sparc/ldst_helper.c

+167 −189

File changed.

Preview size limit exceeded, changes collapsed.

target-sparc/op_helper.c

+101 −1
Original line number Diff line number Diff line
@@ -3,6 +3,7 @@ 
#include "helper.h"



#if !defined(CONFIG_USER_ONLY)

#include "softmmu_exec.h"

static void do_unaligned_access(target_ulong addr, int is_write, int is_user,

                                void *retaddr);
@@ -71,4 +72,103 @@ void tlb_fill(CPUSPARCState *env1, target_ulong addr, int is_write, int mmu_idx, 
    env = saved_env;

}



#endif /* !CONFIG_USER_ONLY */
 
#define WRAP_LD(rettype, fn)                                    \

    rettype cpu_ ## fn (CPUSPARCState *env1, target_ulong addr) \

    {                                                           \

        CPUSPARCState *saved_env;                               \

        rettype ret;                                            \

                                                                \

        saved_env = env;                                        \

        env = env1;                                             \

        ret = fn(addr);                                         \

        env = saved_env;                                        \

        return ret;                                             \

    }



WRAP_LD(uint32_t, ldub_kernel)

WRAP_LD(uint32_t, lduw_kernel)

WRAP_LD(uint32_t, ldl_kernel)

WRAP_LD(uint64_t, ldq_kernel)



WRAP_LD(uint32_t, ldub_user)

WRAP_LD(uint32_t, lduw_user)

WRAP_LD(uint32_t, ldl_user)

WRAP_LD(uint64_t, ldq_user)



WRAP_LD(uint64_t, ldfq_kernel)

WRAP_LD(uint64_t, ldfq_user)

#ifdef TARGET_SPARC64

WRAP_LD(uint32_t, ldub_hypv)

WRAP_LD(uint32_t, lduw_hypv)

WRAP_LD(uint32_t, ldl_hypv)

WRAP_LD(uint64_t, ldq_hypv)



WRAP_LD(uint64_t, ldfq_hypv)



WRAP_LD(uint32_t, ldub_nucleus)

WRAP_LD(uint32_t, lduw_nucleus)

WRAP_LD(uint32_t, ldl_nucleus)

WRAP_LD(uint64_t, ldq_nucleus)



WRAP_LD(uint32_t, ldub_kernel_secondary)

WRAP_LD(uint32_t, lduw_kernel_secondary)

WRAP_LD(uint32_t, ldl_kernel_secondary)

WRAP_LD(uint64_t, ldq_kernel_secondary)



WRAP_LD(uint32_t, ldub_user_secondary)

WRAP_LD(uint32_t, lduw_user_secondary)

WRAP_LD(uint32_t, ldl_user_secondary)

WRAP_LD(uint64_t, ldq_user_secondary)

#endif

#undef WRAP_LD



#define WRAP_ST(datatype, fn)                                           \

    void cpu_ ## fn (CPUSPARCState *env1, target_ulong addr, datatype val)   \

    {                                                                   \

        CPUSPARCState *saved_env;                                       \

                                                                        \

        saved_env = env;                                                \

        env = env1;                                                     \

        fn(addr, val);                                                  \

        env = saved_env;                                                \

    }



WRAP_ST(uint32_t, stb_kernel)

WRAP_ST(uint32_t, stw_kernel)

WRAP_ST(uint32_t, stl_kernel)

WRAP_ST(uint64_t, stq_kernel)



WRAP_ST(uint32_t, stb_user)

WRAP_ST(uint32_t, stw_user)

WRAP_ST(uint32_t, stl_user)

WRAP_ST(uint64_t, stq_user)



WRAP_ST(uint64_t, stfq_kernel)

WRAP_ST(uint64_t, stfq_user)



#ifdef TARGET_SPARC64

WRAP_ST(uint32_t, stb_hypv)

WRAP_ST(uint32_t, stw_hypv)

WRAP_ST(uint32_t, stl_hypv)

WRAP_ST(uint64_t, stq_hypv)



WRAP_ST(uint64_t, stfq_hypv)



WRAP_ST(uint32_t, stb_nucleus)

WRAP_ST(uint32_t, stw_nucleus)

WRAP_ST(uint32_t, stl_nucleus)

WRAP_ST(uint64_t, stq_nucleus)



WRAP_ST(uint32_t, stb_kernel_secondary)

WRAP_ST(uint32_t, stw_kernel_secondary)

WRAP_ST(uint32_t, stl_kernel_secondary)

WRAP_ST(uint64_t, stq_kernel_secondary)



WRAP_ST(uint32_t, stb_user_secondary)

WRAP_ST(uint32_t, stw_user_secondary)

WRAP_ST(uint32_t, stl_user_secondary)

WRAP_ST(uint64_t, stq_user_secondary)

#endif



#undef WRAP_ST

#endif