diff options
Diffstat (limited to 'target-ppc')
| -rw-r--r-- | target-ppc/cpu.h | 8 | ||||
| -rw-r--r-- | target-ppc/op.c | 4 | ||||
| -rw-r--r-- | target-ppc/op_helper.c | 5 | ||||
| -rw-r--r-- | target-ppc/op_helper.h | 2 | ||||
| -rw-r--r-- | target-ppc/translate.c | 1268 |
5 files changed, 254 insertions, 1033 deletions
diff --git a/target-ppc/cpu.h b/target-ppc/cpu.h index bb50c1df66..d40bb40703 100644 --- a/target-ppc/cpu.h +++ b/target-ppc/cpu.h @@ -305,11 +305,9 @@ struct ppc_spr_t { #if !defined(CONFIG_USER_ONLY) void (*oea_read)(void *opaque, int spr_num); void (*oea_write)(void *opaque, int spr_num); -#if defined(TARGET_PPC64H) void (*hea_read)(void *opaque, int spr_num); void (*hea_write)(void *opaque, int spr_num); #endif -#endif const unsigned char *name; }; @@ -510,11 +508,7 @@ enum { /*****************************************************************************/ /* The whole PowerPC CPU context */ -#if defined(TARGET_PPC64H) #define NB_MMU_MODES 3 -#else -#define NB_MMU_MODES 2 -#endif struct CPUPPCState { /* First are the most commonly used resources @@ -783,9 +777,7 @@ int ppc_dcr_write (ppc_dcr_t *dcr_env, int dcrn, target_ulong val); /* MMU modes definitions */ #define MMU_MODE0_SUFFIX _user #define MMU_MODE1_SUFFIX _kernel -#if defined(TARGET_PPC64H) #define MMU_MODE2_SUFFIX _hypv -#endif #define MMU_USER_IDX 0 static inline int cpu_mmu_index (CPUState *env) { diff --git a/target-ppc/op.c b/target-ppc/op.c index 9bf16f5b31..c950579a1b 100644 --- a/target-ppc/op.c +++ b/target-ppc/op.c @@ -1987,12 +1987,10 @@ void OPPROTO op_fneg (void) #define MEMSUFFIX _kernel #include "op_helper.h" #include "op_mem.h" -#if defined(TARGET_PPC64H) #define MEMSUFFIX _hypv #include "op_helper.h" #include "op_mem.h" #endif -#endif /* Special op to check and maybe clear reservation */ void OPPROTO op_check_reservation (void) @@ -2031,9 +2029,7 @@ void OPPROTO op_rfid (void) do_rfid(); RETURN(); } -#endif -#if defined(TARGET_PPC64H) void OPPROTO op_hrfid (void) { do_hrfid(); diff --git a/target-ppc/op_helper.c b/target-ppc/op_helper.c index 1dde1a18c9..50c3d72d0f 100644 --- a/target-ppc/op_helper.c +++ b/target-ppc/op_helper.c @@ -33,12 +33,10 @@ #define MEMSUFFIX _kernel #include "op_helper.h" #include "op_helper_mem.h" -#if defined(TARGET_PPC64H) #define MEMSUFFIX _hypv #include "op_helper.h" #include "op_helper_mem.h" #endif -#endif //#define DEBUG_OP //#define DEBUG_EXCEPTIONS @@ -1475,8 +1473,7 @@ void do_rfid (void) __do_rfi(env->spr[SPR_SRR0], env->spr[SPR_SRR1], ~((target_ulong)0xFFFF0000), 0); } -#endif -#if defined(TARGET_PPC64H) + void do_hrfid (void) { __do_rfi(env->spr[SPR_HSRR0], env->spr[SPR_HSRR1], diff --git a/target-ppc/op_helper.h b/target-ppc/op_helper.h index 657825fa28..94cf4673f2 100644 --- a/target-ppc/op_helper.h +++ b/target-ppc/op_helper.h @@ -146,8 +146,6 @@ void do_store_msr (void); void do_rfi (void); #if defined(TARGET_PPC64) void do_rfid (void); -#endif -#if defined(TARGET_PPC64H) void do_hrfid (void); #endif void do_load_6xx_tlb (int is_code); diff --git a/target-ppc/translate.c b/target-ppc/translate.c index 67b7613abe..072eb914b3 100644 --- a/target-ppc/translate.c +++ b/target-ppc/translate.c @@ -1250,7 +1250,6 @@ GEN_HANDLER(or, 0x1F, 0x1C, 0x0D, 0x00000000, PPC_INTEGER) gen_op_store_pri(6); } break; -#if defined(TARGET_PPC64H) case 7: if (ctx->supervisor > 1) { /* Set process priority to very high */ @@ -1258,7 +1257,6 @@ GEN_HANDLER(or, 0x1F, 0x1C, 0x0D, 0x00000000, PPC_INTEGER) } break; #endif -#endif default: /* nop */ break; @@ -2103,136 +2101,64 @@ static always_inline void gen_addr_register (DisasContext *ctx) #endif } -/*** Integer load ***/ -#define op_ldst(name) (*gen_op_##name[ctx->mem_idx])() +#if defined(TARGET_PPC64) +#define _GEN_MEM_FUNCS(name, mode) \ + &gen_op_##name##_##mode, \ + &gen_op_##name##_le_##mode, \ + &gen_op_##name##_64_##mode, \ + &gen_op_##name##_le_64_##mode +#else +#define _GEN_MEM_FUNCS(name, mode) \ + &gen_op_##name##_##mode, \ + &gen_op_##name##_le_##mode +#endif #if defined(CONFIG_USER_ONLY) #if defined(TARGET_PPC64) -/* User mode only - 64 bits */ -#define OP_LD_TABLE(width) \ -static GenOpFunc *gen_op_l##width[] = { \ - &gen_op_l##width##_raw, \ - &gen_op_l##width##_le_raw, \ - &gen_op_l##width##_64_raw, \ - &gen_op_l##width##_le_64_raw, \ -}; -#define OP_ST_TABLE(width) \ -static GenOpFunc *gen_op_st##width[] = { \ - &gen_op_st##width##_raw, \ - &gen_op_st##width##_le_raw, \ - &gen_op_st##width##_64_raw, \ - &gen_op_st##width##_le_64_raw, \ -}; -/* Byte access routine are endian safe */ -#define gen_op_stb_le_64_raw gen_op_stb_64_raw -#define gen_op_lbz_le_64_raw gen_op_lbz_64_raw +#define NB_MEM_FUNCS 4 #else -/* User mode only - 32 bits */ -#define OP_LD_TABLE(width) \ -static GenOpFunc *gen_op_l##width[] = { \ - &gen_op_l##width##_raw, \ - &gen_op_l##width##_le_raw, \ -}; -#define OP_ST_TABLE(width) \ -static GenOpFunc *gen_op_st##width[] = { \ - &gen_op_st##width##_raw, \ - &gen_op_st##width##_le_raw, \ -}; +#define NB_MEM_FUNCS 2 #endif -/* Byte access routine are endian safe */ -#define gen_op_stb_le_raw gen_op_stb_raw -#define gen_op_lbz_le_raw gen_op_lbz_raw +#define GEN_MEM_FUNCS(name) \ + _GEN_MEM_FUNCS(name, raw) #else #if defined(TARGET_PPC64) -#if defined(TARGET_PPC64H) -/* Full system - 64 bits with hypervisor mode */ -#define OP_LD_TABLE(width) \ -static GenOpFunc *gen_op_l##width[] = { \ - &gen_op_l##width##_user, \ - &gen_op_l##width##_le_user, \ - &gen_op_l##width##_64_user, \ - &gen_op_l##width##_le_64_user, \ - &gen_op_l##width##_kernel, \ - &gen_op_l##width##_le_kernel, \ - &gen_op_l##width##_64_kernel, \ - &gen_op_l##width##_le_64_kernel, \ - &gen_op_l##width##_hypv, \ - &gen_op_l##width##_le_hypv, \ - &gen_op_l##width##_64_hypv, \ - &gen_op_l##width##_le_64_hypv, \ -}; -#define OP_ST_TABLE(width) \ -static GenOpFunc *gen_op_st##width[] = { \ - &gen_op_st##width##_user, \ - &gen_op_st##width##_le_user, \ - &gen_op_st##width##_64_user, \ - &gen_op_st##width##_le_64_user, \ - &gen_op_st##width##_kernel, \ - &gen_op_st##width##_le_kernel, \ - &gen_op_st##width##_64_kernel, \ - &gen_op_st##width##_le_64_kernel, \ - &gen_op_st##width##_hypv, \ - &gen_op_st##width##_le_hypv, \ - &gen_op_st##width##_64_hypv, \ - &gen_op_st##width##_le_64_hypv, \ -}; -/* Byte access routine are endian safe */ -#define gen_op_stb_le_hypv gen_op_stb_64_hypv -#define gen_op_lbz_le_hypv gen_op_lbz_64_hypv -#define gen_op_stb_le_64_hypv gen_op_stb_64_hypv -#define gen_op_lbz_le_64_hypv gen_op_lbz_64_hypv +#define NB_MEM_FUNCS 12 #else -/* Full system - 64 bits */ -#define OP_LD_TABLE(width) \ -static GenOpFunc *gen_op_l##width[] = { \ - &gen_op_l##width##_user, \ - &gen_op_l##width##_le_user, \ - &gen_op_l##width##_64_user, \ - &gen_op_l##width##_le_64_user, \ - &gen_op_l##width##_kernel, \ - &gen_op_l##width##_le_kernel, \ - &gen_op_l##width##_64_kernel, \ - &gen_op_l##width##_le_64_kernel, \ -}; -#define OP_ST_TABLE(width) \ -static GenOpFunc *gen_op_st##width[] = { \ - &gen_op_st##width##_user, \ - &gen_op_st##width##_le_user, \ - &gen_op_st##width##_64_user, \ - &gen_op_st##width##_le_64_user, \ - &gen_op_st##width##_kernel, \ - &gen_op_st##width##_le_kernel, \ - &gen_op_st##width##_64_kernel, \ - &gen_op_st##width##_le_64_kernel, \ -}; +#define NB_MEM_FUNCS 6 #endif +#define GEN_MEM_FUNCS(name) \ + _GEN_MEM_FUNCS(name, user), \ + _GEN_MEM_FUNCS(name, kernel), \ + _GEN_MEM_FUNCS(name, hypv) +#endif + +/*** Integer load ***/ +#define op_ldst(name) (*gen_op_##name[ctx->mem_idx])() /* Byte access routine are endian safe */ -#define gen_op_stb_le_64_user gen_op_stb_64_user +#define gen_op_lbz_le_raw gen_op_lbz_raw +#define gen_op_lbz_le_user gen_op_lbz_user +#define gen_op_lbz_le_kernel gen_op_lbz_kernel +#define gen_op_lbz_le_hypv gen_op_lbz_hypv +#define gen_op_lbz_le_64_raw gen_op_lbz_64_raw #define gen_op_lbz_le_64_user gen_op_lbz_64_user -#define gen_op_stb_le_64_kernel gen_op_stb_64_kernel #define gen_op_lbz_le_64_kernel gen_op_lbz_64_kernel -#else -/* Full system - 32 bits */ +#define gen_op_lbz_le_64_hypv gen_op_lbz_64_hypv +#define gen_op_stb_le_raw gen_op_stb_raw +#define gen_op_stb_le_user gen_op_stb_user +#define gen_op_stb_le_kernel gen_op_stb_kernel +#define gen_op_stb_le_hypv gen_op_stb_hypv +#define gen_op_stb_le_64_raw gen_op_stb_64_raw +#define gen_op_stb_le_64_user gen_op_stb_64_user +#define gen_op_stb_le_64_kernel gen_op_stb_64_kernel +#define gen_op_stb_le_64_hypv gen_op_stb_64_hypv #define OP_LD_TABLE(width) \ -static GenOpFunc *gen_op_l##width[] = { \ - &gen_op_l##width##_user, \ - &gen_op_l##width##_le_user, \ - &gen_op_l##width##_kernel, \ - &gen_op_l##width##_le_kernel, \ +static GenOpFunc *gen_op_l##width[NB_MEM_FUNCS] = { \ + GEN_MEM_FUNCS(l##width), \ }; #define OP_ST_TABLE(width) \ -static GenOpFunc *gen_op_st##width[] = { \ - &gen_op_st##width##_user, \ - &gen_op_st##width##_le_user, \ - &gen_op_st##width##_kernel, \ - &gen_op_st##width##_le_kernel, \ +static GenOpFunc *gen_op_st##width[NB_MEM_FUNCS] = { \ + GEN_MEM_FUNCS(st##width), \ }; -#endif -/* Byte access routine are endian safe */ -#define gen_op_stb_le_user gen_op_stb_user -#define gen_op_lbz_le_user gen_op_lbz_user -#define gen_op_stb_le_kernel gen_op_stb_kernel -#define gen_op_lbz_le_kernel gen_op_lbz_kernel -#endif #define GEN_LD(width, opc, type) \ GEN_HANDLER(l##width, opc, 0xFF, 0xFF, 0x00000000, type) \ @@ -2487,75 +2413,12 @@ GEN_STX(wbr, 0x16, 0x14, PPC_INTEGER); /*** Integer load and store multiple ***/ #define op_ldstm(name, reg) (*gen_op_##name[ctx->mem_idx])(reg) -#if defined(CONFIG_USER_ONLY) -/* User-mode only */ -static GenOpFunc1 *gen_op_lmw[] = { - &gen_op_lmw_raw, - &gen_op_lmw_le_raw, -#if defined(TARGET_PPC64) - &gen_op_lmw_64_raw, - &gen_op_lmw_le_64_raw, -#endif +static GenOpFunc1 *gen_op_lmw[NB_MEM_FUNCS] = { + GEN_MEM_FUNCS(lmw), }; -static GenOpFunc1 *gen_op_stmw[] = { - &gen_op_stmw_raw, - &gen_op_stmw_le_raw, -#if defined(TARGET_PPC64) - &gen_op_stmw_64_raw, - &gen_op_stmw_le_64_raw, -#endif +static GenOpFunc1 *gen_op_stmw[NB_MEM_FUNCS] = { + GEN_MEM_FUNCS(stmw), }; -#else -#if defined(TARGET_PPC64) -/* Full system - 64 bits mode */ -static GenOpFunc1 *gen_op_lmw[] = { - &gen_op_lmw_user, - &gen_op_lmw_le_user, - &gen_op_lmw_64_user, - &gen_op_lmw_le_64_user, - &gen_op_lmw_kernel, - &gen_op_lmw_le_kernel, - &gen_op_lmw_64_kernel, - &gen_op_lmw_le_64_kernel, -#if defined(TARGET_PPC64H) - &gen_op_lmw_hypv, - &gen_op_lmw_le_hypv, - &gen_op_lmw_64_hypv, - &gen_op_lmw_le_64_hypv, -#endif -}; -static GenOpFunc1 *gen_op_stmw[] = { - &gen_op_stmw_user, - &gen_op_stmw_le_user, - &gen_op_stmw_64_user, - &gen_op_stmw_le_64_user, - &gen_op_stmw_kernel, - &gen_op_stmw_le_kernel, - &gen_op_stmw_64_kernel, - &gen_op_stmw_le_64_kernel, -#if defined(TARGET_PPC64H) - &gen_op_stmw_hypv, - &gen_op_stmw_le_hypv, - &gen_op_stmw_64_hypv, - &gen_op_stmw_le_64_hypv, -#endif -}; -#else -/* Full system - 32 bits mode */ -static GenOpFunc1 *gen_op_lmw[] = { - &gen_op_lmw_user, - &gen_op_lmw_le_user, - &gen_op_lmw_kernel, - &gen_op_lmw_le_kernel, -}; -static GenOpFunc1 *gen_op_stmw[] = { - &gen_op_stmw_user, - &gen_op_stmw_le_user, - &gen_op_stmw_kernel, - &gen_op_stmw_le_kernel, -}; -#endif -#endif /* lmw */ GEN_HANDLER(lmw, 0x2E, 0xFF, 0xFF, 0x00000000, PPC_INTEGER) @@ -2578,105 +2441,15 @@ GEN_HANDLER(stmw, 0x2F, 0xFF, 0xFF, 0x00000000, PPC_INTEGER) /*** Integer load and store strings ***/ #define op_ldsts(name, start) (*gen_op_##name[ctx->mem_idx])(start) #define op_ldstsx(name, rd, ra, rb) (*gen_op_##name[ctx->mem_idx])(rd, ra, rb) -#if defined(CONFIG_USER_ONLY) -/* User-mode only */ -static GenOpFunc1 *gen_op_lswi[] = { - &gen_op_lswi_raw, - &gen_op_lswi_le_raw, -#if defined(TARGET_PPC64) - &gen_op_lswi_64_raw, - &gen_op_lswi_le_64_raw, -#endif -}; -static GenOpFunc3 *gen_op_lswx[] = { - &gen_op_lswx_raw, - &gen_op_lswx_le_raw, -#if defined(TARGET_PPC64) - &gen_op_lswx_64_raw, - &gen_op_lswx_le_64_raw, -#endif +static GenOpFunc1 *gen_op_lswi[NB_MEM_FUNCS] = { + GEN_MEM_FUNCS(lswi), }; -static GenOpFunc1 *gen_op_stsw[] = { - &gen_op_stsw_raw, - &gen_op_stsw_le_raw, -#if defined(TARGET_PPC64) - &gen_op_stsw_64_raw, - &gen_op_stsw_le_64_raw, -#endif -}; -#else -#if defined(TARGET_PPC64) -/* Full system - 64 bits mode */ -static GenOpFunc1 *gen_op_lswi[] = { - &gen_op_lswi_user, - &gen_op_lswi_le_user, - &gen_op_lswi_64_user, - &gen_op_lswi_le_64_user, - &gen_op_lswi_kernel, - &gen_op_lswi_le_kernel, - &gen_op_lswi_64_kernel, - &gen_op_lswi_le_64_kernel, -#if defined(TARGET_PPC64H) - &gen_op_lswi_hypv, - &gen_op_lswi_le_hypv, - &gen_op_lswi_64_hypv, - &gen_op_lswi_le_64_hypv, -#endif +static GenOpFunc3 *gen_op_lswx[NB_MEM_FUNCS] = { + GEN_MEM_FUNCS(lswx), }; -static GenOpFunc3 *gen_op_lswx[] = { - &gen_op_lswx_user, - &gen_op_lswx_le_user, - &gen_op_lswx_64_user, - &gen_op_lswx_le_64_user, - &gen_op_lswx_kernel, - &gen_op_lswx_le_kernel, - &gen_op_lswx_64_kernel, - &gen_op_lswx_le_64_kernel, -#if defined(TARGET_PPC64H) - &gen_op_lswx_hypv, - &gen_op_lswx_le_hypv, - &gen_op_lswx_64_hypv, - &gen_op_lswx_le_64_hypv, -#endif -}; -static GenOpFunc1 *gen_op_stsw[] = { - &gen_op_stsw_user, - &gen_op_stsw_le_user, - &gen_op_stsw_64_user, - &gen_op_stsw_le_64_user, - &gen_op_stsw_kernel, - &gen_op_stsw_le_kernel, - &gen_op_stsw_64_kernel, - &gen_op_stsw_le_64_kernel, -#if defined(TARGET_PPC64H) - &gen_op_stsw_hypv, - &gen_op_stsw_le_hypv, - &gen_op_stsw_64_hypv, - &gen_op_stsw_le_64_hypv, -#endif -}; -#else -/* Full system - 32 bits mode */ -static GenOpFunc1 *gen_op_lswi[] = { - &gen_op_lswi_user, - &gen_op_lswi_le_user, - &gen_op_lswi_kernel, - &gen_op_lswi_le_kernel, +static GenOpFunc1 *gen_op_stsw[NB_MEM_FUNCS] = { + GEN_MEM_FUNCS(stsw), }; -static GenOpFunc3 *gen_op_lswx[] = { - &gen_op_lswx_user, - &gen_op_lswx_le_user, - &gen_op_lswx_kernel, - &gen_op_lswx_le_kernel, -}; -static GenOpFunc1 *gen_op_stsw[] = { - &gen_op_stsw_user, - &gen_op_stsw_le_user, - &gen_op_stsw_kernel, - &gen_op_stsw_le_kernel, -}; -#endif -#endif /* lswi */ /* PowerPC32 specification says we must generate an exception if @@ -2762,75 +2535,12 @@ GEN_HANDLER(isync, 0x13, 0x16, 0x04, 0x03FFF801, PPC_MEM) #define op_lwarx() (*gen_op_lwarx[ctx->mem_idx])() #define op_stwcx() (*gen_op_stwcx[ctx->mem_idx])() -#if defined(CONFIG_USER_ONLY) -/* User-mode only */ -static GenOpFunc *gen_op_lwarx[] = { - &gen_op_lwarx_raw, - &gen_op_lwarx_le_raw, -#if defined(TARGET_PPC64) - &gen_op_lwarx_64_raw, - &gen_op_lwarx_le_64_raw, -#endif -}; -static GenOpFunc *gen_op_stwcx[] = { - &gen_op_stwcx_raw, - &gen_op_stwcx_le_raw, -#if defined(TARGET_PPC64) - &gen_op_stwcx_64_raw, - &gen_op_stwcx_le_64_raw, -#endif +static GenOpFunc *gen_op_lwarx[NB_MEM_FUNCS] = { + GEN_MEM_FUNCS(lwarx), }; -#else -#if defined(TARGET_PPC64) -/* Full system - 64 bits mode */ -static GenOpFunc *gen_op_lwarx[] = { - &gen_op_lwarx_user, - &gen_op_lwarx_le_user, - &gen_op_lwarx_64_user, - &gen_op_lwarx_le_64_user, - &gen_op_lwarx_kernel, - &gen_op_lwarx_le_kernel, - &gen_op_lwarx_64_kernel, - &gen_op_lwarx_le_64_kernel, -#if defined(TARGET_PPC64H) - &gen_op_lwarx_hypv, - &gen_op_lwarx_le_hypv, - &gen_op_lwarx_64_hypv, - &gen_op_lwarx_le_64_hypv, -#endif +static GenOpFunc *gen_op_stwcx[NB_MEM_FUNCS] = { + GEN_MEM_FUNCS(stwcx), }; -static GenOpFunc *gen_op_stwcx[] = { - &gen_op_stwcx_user, - &gen_op_stwcx_le_user, - &gen_op_stwcx_64_user, - &gen_op_stwcx_le_64_user, - &gen_op_stwcx_kernel, - &gen_op_stwcx_le_kernel, - &gen_op_stwcx_64_kernel, - &gen_op_stwcx_le_64_kernel, -#if defined(TARGET_PPC64H) - &gen_op_stwcx_hypv, - &gen_op_stwcx_le_hypv, - &gen_op_stwcx_64_hypv, - &gen_op_stwcx_le_64_hypv, -#endif -}; -#else -/* Full system - 32 bits mode */ -static GenOpFunc *gen_op_lwarx[] = { - &gen_op_lwarx_user, - &gen_op_lwarx_le_user, - &gen_op_lwarx_kernel, - &gen_op_lwarx_le_kernel, -}; -static GenOpFunc *gen_op_stwcx[] = { - &gen_op_stwcx_user, - &gen_op_stwcx_le_user, - &gen_op_stwcx_kernel, - &gen_op_stwcx_le_kernel, -}; -#endif -#endif /* lwarx */ GEN_HANDLER(lwarx, 0x1F, 0x14, 0x00, 0x00000001, PPC_RES) @@ -2855,55 +2565,12 @@ GEN_HANDLER2(stwcx_, "stwcx.", 0x1F, 0x16, 0x04, 0x00000000, PPC_RES) #if defined(TARGET_PPC64) #define op_ldarx() (*gen_op_ldarx[ctx->mem_idx])() #define op_stdcx() (*gen_op_stdcx[ctx->mem_idx])() -#if defined(CONFIG_USER_ONLY) -/* User-mode only */ -static GenOpFunc *gen_op_ldarx[] = { - &gen_op_ldarx_raw, - &gen_op_ldarx_le_raw, - &gen_op_ldarx_64_raw, - &gen_op_ldarx_le_64_raw, +static GenOpFunc *gen_op_ldarx[NB_MEM_FUNCS] = { + GEN_MEM_FUNCS(ldarx), }; -static GenOpFunc *gen_op_stdcx[] = { - &gen_op_stdcx_raw, - &gen_op_stdcx_le_raw, - &gen_op_stdcx_64_raw, - &gen_op_stdcx_le_64_raw, +static GenOpFunc *gen_op_stdcx[NB_MEM_FUNCS] = { + GEN_MEM_FUNCS(stdcx), }; -#else -/* Full system */ -static GenOpFunc *gen_op_ldarx[] = { - &gen_op_ldarx_user, - &gen_op_ldarx_le_user, - &gen_op_ldarx_64_user, - &gen_op_ldarx_le_64_user, - &gen_op_ldarx_kernel, - &gen_op_ldarx_le_kernel, - &gen_op_ldarx_64_kernel, - &gen_op_ldarx_le_64_kernel, -#if defined(TARGET_PPC64H) - &gen_op_ldarx_hypv, - &gen_op_ldarx_le_hypv, - &gen_op_ldarx_64_hypv, - &gen_op_ldarx_le_64_hypv, -#endif -}; -static GenOpFunc *gen_op_stdcx[] = { - &gen_op_stdcx_user, - &gen_op_stdcx_le_user, - &gen_op_stdcx_64_user, - &gen_op_stdcx_le_64_user, - &gen_op_stdcx_kernel, - &gen_op_stdcx_le_kernel, - &gen_op_stdcx_64_kernel, - &gen_op_stdcx_le_64_kernel, -#if defined(TARGET_PPC64H) - &gen_op_stdcx_hypv, - &gen_op_stdcx_le_hypv, - &gen_op_stdcx_64_hypv, - &gen_op_stdcx_le_64_hypv, -#endif -}; -#endif /* ldarx */ GEN_HANDLER(ldarx, 0x1F, 0x14, 0x02, 0x00000001, PPC_64B) @@ -3406,9 +3073,7 @@ GEN_HANDLER(rfid, 0x13, 0x12, 0x00, 0x03FF8001, PPC_64B) GEN_SYNC(ctx); #endif } -#endif -#if defined(TARGET_PPC64H) GEN_HANDLER(hrfid, 0x13, 0x12, 0x08, 0x03FF8001, PPC_64B) { #if defined(CONFIG_USER_ONLY) @@ -3542,12 +3207,9 @@ static always_inline void gen_op_mfspr (DisasContext *ctx) uint32_t sprn = SPR(ctx->opcode); #if !defined(CONFIG_USER_ONLY) -#if defined(TARGET_PPC64H) if (ctx->supervisor == 2) read_cb = ctx->spr_cb[sprn].hea_read; - else -#endif - if (ctx->supervisor) + else if (ctx->supervisor) read_cb = ctx->spr_cb[sprn].oea_read; else #endif @@ -3682,12 +3344,9 @@ GEN_HANDLER(mtspr, 0x1F, 0x13, 0x0E, 0x00000001, PPC_MISC) uint32_t sprn = SPR(ctx->opcode); #if !defined(CONFIG_USER_ONLY) -#if defined(TARGET_PPC64H) if (ctx->supervisor == 2) write_cb = ctx->spr_cb[sprn].hea_write; - else -#endif - if (ctx->supervisor) + else if (ctx->supervisor) write_cb = ctx->spr_cb[sprn].oea_write; else #endif @@ -3773,141 +3432,56 @@ GEN_HANDLER(dcbtst, 0x1F, 0x16, 0x07, 0x02000001, PPC_CACHE) /* dcbz */ #define op_dcbz(n) (*gen_op_dcbz[n][ctx->mem_idx])() -#if defined(CONFIG_USER_ONLY) -/* User-mode only */ -static GenOpFunc *gen_op_dcbz[4][4] = { - { - &gen_op_dcbz_l32_raw, - &gen_op_dcbz_l32_raw, -#if defined(TARGET_PPC64) - &gen_op_dcbz_l32_64_raw, - &gen_op_dcbz_l32_64_raw, -#endif - }, - { - &gen_op_dcbz_l64_raw, - &gen_op_dcbz_l64_raw, -#if defined(TARGET_PPC64) - &gen_op_dcbz_l64_64_raw, - &gen_op_dcbz_l64_64_raw, -#endif - }, - { - &gen_op_dcbz_l128_raw, - &gen_op_dcbz_l128_raw, -#if defined(TARGET_PPC64) - &gen_op_dcbz_l128_64_raw, - &gen_op_dcbz_l128_64_raw, -#endif - }, - { - &gen_op_dcbz_raw, - &gen_op_dcbz_raw, -#if defined(TARGET_PPC64) - &gen_op_dcbz_64_raw, - &gen_op_dcbz_64_raw, -#endif - }, -}; -#else -#if defined(TARGET_PPC64) -/* Full system - 64 bits mode */ -static GenOpFunc *gen_op_dcbz[4][12] = { +static GenOpFunc *gen_op_dcbz[4][NB_MEM_FUNCS] = { + /* 32 bytes cache line size */ { - &gen_op_dcbz_l32_user, - &gen_op_dcbz_l32_user, - &gen_op_dcbz_l32_64_user, - &gen_op_dcbz_l32_64_user, - &gen_op_dcbz_l32_kernel, - &gen_op_dcbz_l32_kernel, - &gen_op_dcbz_l32_64_kernel, - &gen_op_dcbz_l32_64_kernel, -#if defined(TARGET_PPC64H) - &gen_op_dcbz_l32_hypv, - &gen_op_dcbz_l32_hypv, - &gen_op_dcbz_l32_64_hypv, - &gen_op_dcbz_l32_64_hypv, -#endif +#define gen_op_dcbz_l32_le_raw gen_op_dcbz_l32_raw +#define gen_op_dcbz_l32_le_user gen_op_dcbz_l32_user +#define gen_op_dcbz_l32_le_kernel gen_op_dcbz_l32_kernel +#define gen_op_dcbz_l32_le_hypv gen_op_dcbz_l32_hypv +#define gen_op_dcbz_l32_le_64_raw gen_op_dcbz_l32_64_raw +#define gen_op_dcbz_l32_le_64_user gen_op_dcbz_l32_64_user +#define gen_op_dcbz_l32_le_64_kernel gen_op_dcbz_l32_64_kernel +#define gen_op_dcbz_l32_le_64_hypv gen_op_dcbz_l32_64_hypv + GEN_MEM_FUNCS(dcbz_l32), }, + /* 64 bytes cache line size */ { - &gen_op_dcbz_l64_user, - &gen_op_dcbz_l64_user, - &gen_op_dcbz_l64_64_user, - &gen_op_dcbz_l64_64_user, - &gen_op_dcbz_l64_kernel, - &gen_op_dcbz_l64_kernel, - &gen_op_dcbz_l64_64_kernel, - &gen_op_dcbz_l64_64_kernel, -#if defined(TARGET_PPC64H) - &gen_op_dcbz_l64_hypv, - &gen_op_dcbz_l64_hypv, - &gen_op_dcbz_l64_64_hypv, - &gen_op_dcbz_l64_64_hypv, -#endif +#define gen_op_dcbz_l64_le_raw gen_op_dcbz_l64_raw +#define gen_op_dcbz_l64_le_user gen_op_dcbz_l64_user +#define gen_op_dcbz_l64_le_kernel gen_op_dcbz_l64_kernel +#define gen_op_dcbz_l64_le_hypv gen_op_dcbz_l64_hypv +#define gen_op_dcbz_l64_le_64_raw gen_op_dcbz_l64_64_raw +#define gen_op_dcbz_l64_le_64_user gen_op_dcbz_l64_64_user +#define gen_op_dcbz_l64_le_64_kernel gen_op_dcbz_l64_64_kernel +#define gen_op_dcbz_l64_le_64_hypv gen_op_dcbz_l64_64_hypv + GEN_MEM_FUNCS(dcbz_l64), }, + /* 128 bytes cache line size */ { - &gen_op_dcbz_l128_user, - &gen_op_dcbz_l128_user, - &gen_op_dcbz_l128_64_user, - &gen_op_dcbz_l128_64_user, - &gen_op_dcbz_l128_kernel, - &gen_op_dcbz_l128_kernel, - &gen_op_dcbz_l128_64_kernel, - &gen_op_dcbz_l128_64_kernel, -#if defined(TARGET_PPC64H) - &gen_op_dcbz_l128_hypv, - &gen_op_dcbz_l128_hypv, - &gen_op_dcbz_l128_64_hypv, - &gen_op_dcbz_l128_64_hypv, -#endif +#define gen_op_dcbz_l128_le_raw gen_op_dcbz_l128_raw +#define gen_op_dcbz_l128_le_user gen_op_dcbz_l128_user +#define gen_op_dcbz_l128_le_kernel gen_op_dcbz_l128_kernel +#define gen_op_dcbz_l128_le_hypv gen_op_dcbz_l128_hypv +#define gen_op_dcbz_l128_le_64_raw gen_op_dcbz_l128_64_raw +#define gen_op_dcbz_l128_le_64_user gen_op_dcbz_l128_64_user +#define gen_op_dcbz_l128_le_64_kernel gen_op_dcbz_l128_64_kernel +#define gen_op_dcbz_l128_le_64_hypv gen_op_dcbz_l128_64_hypv + GEN_MEM_FUNCS(dcbz_l128), }, + /* tunable cache line size */ { - &gen_op_dcbz_user, - &gen_op_dcbz_user, - &gen_op_dcbz_64_user, - &gen_op_dcbz_64_user, - &gen_op_dcbz_kernel, - &gen_op_dcbz_kernel, - &gen_op_dcbz_64_kernel, - &gen_op_dcbz_64_kernel, -#if defined(TARGET_PPC64H) - &gen_op_dcbz_hypv, - &gen_op_dcbz_hypv, - &gen_op_dcbz_64_hypv, - &gen_op_dcbz_64_hypv, -#endif +#define gen_op_dcbz_le_raw gen_op_dcbz_raw +#define gen_op_dcbz_le_user gen_op_dcbz_user +#define gen_op_dcbz_le_kernel gen_op_dcbz_kernel +#define gen_op_dcbz_le_hypv gen_op_dcbz_hypv +#define gen_op_dcbz_le_64_raw gen_op_dcbz_64_raw +#define gen_op_dcbz_le_64_user gen_op_dcbz_64_user +#define gen_op_dcbz_le_64_kernel gen_op_dcbz_64_kernel +#define gen_op_dcbz_le_64_hypv gen_op_dcbz_64_hypv + GEN_MEM_FUNCS(dcbz), }, }; -#else -/* Full system - 32 bits mode */ -static GenOpFunc *gen_op_dcbz[4][4] = { - { - &gen_op_dcbz_l32_user, - &gen_op_dcbz_l32_user, - &gen_op_dcbz_l32_kernel, - &gen_op_dcbz_l32_kernel, - }, - { - &gen_op_dcbz_l64_user, - &gen_op_dcbz_l64_user, - &gen_op_dcbz_l64_kernel, - &gen_op_dcbz_l64_kernel, - }, - { - &gen_op_dcbz_l128_user, - &gen_op_dcbz_l128_user, - &gen_op_dcbz_l128_kernel, - &gen_op_dcbz_l128_kernel, - }, - { - &gen_op_dcbz_user, - &gen_op_dcbz_user, - &gen_op_dcbz_kernel, - &gen_op_dcbz_kernel, - }, -}; -#endif -#endif static always_inline void handler_dcbz (DisasContext *ctx, int dcache_line_size) @@ -3950,45 +3524,17 @@ GEN_HANDLER2(dcbz_970, "dcbz", 0x1F, 0x16, 0x1F, 0x03C00001, PPC_CACHE_DCBZT) /* icbi */ #define op_icbi() (*gen_op_icbi[ctx->mem_idx])() -#if defined(CONFIG_USER_ONLY) -/* User-mode only */ -static GenOpFunc *gen_op_icbi[] = { - &gen_op_icbi_raw, - &gen_op_icbi_raw, -#if defined(TARGET_PPC64) - &gen_op_icbi_64_raw, - &gen_op_icbi_64_raw, -#endif -}; -#else -/* Full system - 64 bits mode */ -#if defined(TARGET_PPC64) -static GenOpFunc *gen_op_icbi[] = { - &gen_op_icbi_user, - &gen_op_icbi_user, - &gen_op_icbi_64_user, - &gen_op_icbi_64_user, - &gen_op_icbi_kernel, - &gen_op_icbi_kernel, - &gen_op_icbi_64_kernel, - &gen_op_icbi_64_kernel, -#if defined(TARGET_PPC64H) - &gen_op_icbi_hypv, - &gen_op_icbi_hypv, - &gen_op_icbi_64_hypv, - &gen_op_icbi_64_hypv, -#endif -}; -#else -/* Full system - 32 bits mode */ -static GenOpFunc *gen_op_icbi[] = { - &gen_op_icbi_user, - &gen_op_icbi_user, - &gen_op_icbi_kernel, - &gen_op_icbi_kernel, +#define gen_op_icbi_le_raw gen_op_icbi_raw +#define gen_op_icbi_le_user gen_op_icbi_user +#define gen_op_icbi_le_kernel gen_op_icbi_kernel +#define gen_op_icbi_le_hypv gen_op_icbi_hypv +#define gen_op_icbi_le_64_raw gen_op_icbi_64_raw +#define gen_op_icbi_le_64_user gen_op_icbi_64_user +#define gen_op_icbi_le_64_kernel gen_op_icbi_64_kernel +#define gen_op_icbi_le_64_hypv gen_op_icbi_64_hypv +static GenOpFunc *gen_op_icbi[NB_MEM_FUNCS] = { + GEN_MEM_FUNCS(icbi), }; -#endif -#endif GEN_HANDLER(icbi, 0x1F, 0x16, 0x1E, 0x03E00001, PPC_CACHE_ICBI) { @@ -4239,75 +3785,12 @@ GEN_HANDLER(slbie, 0x1F, 0x12, 0x0D, 0x03FF0001, PPC_SLBI) /* Optional: */ #define op_eciwx() (*gen_op_eciwx[ctx->mem_idx])() #define op_ecowx() (*gen_op_ecowx[ctx->mem_idx])() -#if defined(CONFIG_USER_ONLY) -/* User-mode only */ -static GenOpFunc *gen_op_eciwx[] = { - &gen_op_eciwx_raw, - &gen_op_eciwx_le_raw, -#if defined(TARGET_PPC64) - &gen_op_eciwx_64_raw, - &gen_op_eciwx_le_64_raw, -#endif +static GenOpFunc *gen_op_eciwx[NB_MEM_FUNCS] = { + GEN_MEM_FUNCS(eciwx), }; -static GenOpFunc *gen_op_ecowx[] = { - &gen_op_ecowx_raw, - &gen_op_ecowx_le_raw, -#if defined(TARGET_PPC64) - &gen_op_ecowx_64_raw, - &gen_op_ecowx_le_64_raw, -#endif +static GenOpFunc *gen_op_ecowx[NB_MEM_FUNCS] = { + GEN_MEM_FUNCS(ecowx), }; -#else -#if defined(TARGET_PPC64) -/* Full system - 64 bits mode */ -static GenOpFunc *gen_op_eciwx[] = { - &gen_op_eciwx_user, - &gen_op_eciwx_le_user, - &gen_op_eciwx_64_user, - &gen_op_eciwx_le_64_user, - &gen_op_eciwx_kernel, - &gen_op_eciwx_le_kernel, - &gen_op_eciwx_64_kernel, - &gen_op_eciwx_le_64_kernel, -#if defined(TARGET_PPC64H) - &gen_op_eciwx_hypv, - &gen_op_eciwx_le_hypv, - &gen_op_eciwx_64_hypv, - &gen_op_eciwx_le_64_hypv, -#endif -}; -static GenOpFunc *gen_op_ecowx[] = { - &gen_op_ecowx_user, - &gen_op_ecowx_le_user, - &gen_op_ecowx_64_user, - &gen_op_ecowx_le_64_user, - &gen_op_ecowx_kernel, - &gen_op_ecowx_le_kernel, - &gen_op_ecowx_64_kernel, - &gen_op_ecowx_le_64_kernel, -#if defined(TARGET_PPC64H) - &gen_op_ecowx_hypv, - &gen_op_ecowx_le_hypv, - &gen_op_ecowx_64_hypv, - &gen_op_ecowx_le_64_hypv, -#endif -}; -#else -/* Full system - 32 bits mode */ -static GenOpFunc *gen_op_eciwx[] = { - &gen_op_eciwx_user, - &gen_op_eciwx_le_user, - &gen_op_eciwx_kernel, - &gen_op_eciwx_le_kernel, -}; -static GenOpFunc *gen_op_ecowx[] = { - &gen_op_ecowx_user, - &gen_op_ecowx_le_user, - &gen_op_ecowx_kernel, - &gen_op_ecowx_le_kernel, -}; -#endif -#endif /* eciwx */ GEN_HANDLER(eciwx, 0x1F, 0x16, 0x0D, 0x00000001, PPC_EXTERN) @@ -4432,22 +3915,26 @@ GEN_HANDLER(dozi, 0x09, 0xFF, 0xFF, 0x00000000, PPC_POWER_BR) gen_op_store_T0_gpr(rD(ctx->opcode)); } -/* As lscbx load from memory byte after byte, it's always endian safe */ +/* As lscbx load from memory byte after byte, it's always endian safe. + * Original POWER is 32 bits only, define 64 bits ops as 32 bits ones + */ #define op_POWER_lscbx(start, ra, rb) \ (*gen_op_POWER_lscbx[ctx->mem_idx])(start, ra, rb) -#if defined(CONFIG_USER_ONLY) -static GenOpFunc3 *gen_op_POWER_lscbx[] = { - &gen_op_POWER_lscbx_raw, - &gen_op_POWER_lscbx_raw, +#define gen_op_POWER_lscbx_64_raw gen_op_POWER_lscbx_raw +#define gen_op_POWER_lscbx_64_user gen_op_POWER_lscbx_user +#define gen_op_POWER_lscbx_64_kernel gen_op_POWER_lscbx_kernel +#define gen_op_POWER_lscbx_64_hypv gen_op_POWER_lscbx_hypv +#define gen_op_POWER_lscbx_le_raw gen_op_POWER_lscbx_raw +#define gen_op_POWER_lscbx_le_user gen_op_POWER_lscbx_user +#define gen_op_POWER_lscbx_le_kernel gen_op_POWER_lscbx_kernel +#define gen_op_POWER_lscbx_le_hypv gen_op_POWER_lscbx_hypv +#define gen_op_POWER_lscbx_le_64_raw gen_op_POWER_lscbx_raw +#define gen_op_POWER_lscbx_le_64_user gen_op_POWER_lscbx_user +#define gen_op_POWER_lscbx_le_64_kernel gen_op_POWER_lscbx_kernel +#define gen_op_POWER_lscbx_le_64_hypv gen_op_POWER_lscbx_hypv +static GenOpFunc3 *gen_op_POWER_lscbx[NB_MEM_FUNCS] = { + GEN_MEM_FUNCS(POWER_lscbx), }; -#else -static GenOpFunc3 *gen_op_POWER_lscbx[] = { - &gen_op_POWER_lscbx_user, - &gen_op_POWER_lscbx_user, - &gen_op_POWER_lscbx_kernel, - &gen_op_POWER_lscbx_kernel, -}; -#endif /* lscbx - lscbx. */ GEN_HANDLER(lscbx, 0x1F, 0x15, 0x08, 0x00000000, PPC_POWER_BR) @@ -4901,31 +4388,31 @@ GEN_HANDLER(rfsvc, 0x13, 0x12, 0x02, 0x03FFF0001, PPC_POWER) /* POWER2 specific instructions */ /* Quad manipulation (load/store two floats at a time) */ +/* Original POWER2 is 32 bits only, define 64 bits ops as 32 bits ones */ #define op_POWER2_lfq() (*gen_op_POWER2_lfq[ctx->mem_idx])() #define op_POWER2_stfq() (*gen_op_POWER2_stfq[ctx->mem_idx])() -#if defined(CONFIG_USER_ONLY) -static GenOpFunc *gen_op_POWER2_lfq[] = { - &gen_op_POWER2_lfq_le_raw, - &gen_op_POWER2_lfq_raw, -}; -static GenOpFunc *gen_op_POWER2_stfq[] = { - &gen_op_POWER2_stfq_le_raw, - &gen_op_POWER2_stfq_raw, +#define gen_op_POWER2_lfq_64_raw gen_op_POWER2_lfq_raw +#define gen_op_POWER2_lfq_64_user gen_op_POWER2_lfq_user +#define gen_op_POWER2_lfq_64_kernel gen_op_POWER2_lfq_kernel +#define gen_op_POWER2_lfq_64_hypv gen_op_POWER2_lfq_hypv +#define gen_op_POWER2_lfq_le_64_raw gen_op_POWER2_lfq_le_raw +#define gen_op_POWER2_lfq_le_64_user gen_op_POWER2_lfq_le_user +#define gen_op_POWER2_lfq_le_64_kernel gen_op_POWER2_lfq_le_kernel +#define gen_op_POWER2_lfq_le_64_hypv gen_op_POWER2_lfq_le_hypv +#define gen_op_POWER2_stfq_64_raw gen_op_POWER2_stfq_raw +#define gen_op_POWER2_stfq_64_user gen_op_POWER2_stfq_user +#define gen_op_POWER2_stfq_64_kernel gen_op_POWER2_stfq_kernel +#define gen_op_POWER2_stfq_64_hypv gen_op_POWER2_stfq_hypv +#define gen_op_POWER2_stfq_le_64_raw gen_op_POWER2_stfq_le_raw +#define gen_op_POWER2_stfq_le_64_user gen_op_POWER2_stfq_le_user +#define gen_op_POWER2_stfq_le_64_kernel gen_op_POWER2_stfq_le_kernel +#define gen_op_POWER2_stfq_le_64_hypv gen_op_POWER2_stfq_le_hypv +static GenOpFunc *gen_op_POWER2_lfq[NB_MEM_FUNCS] = { + GEN_MEM_FUNCS(POWER2_lfq), }; -#else -static GenOpFunc *gen_op_POWER2_lfq[] = { - &gen_op_POWER2_lfq_le_user, - &gen_op_POWER2_lfq_user, - &gen_op_POWER2_lfq_le_kernel, - &gen_op_POWER2_lfq_kernel, +static GenOpFunc *gen_op_POWER2_stfq[NB_MEM_FUNCS] = { + GEN_MEM_FUNCS(POWER2_stfq), }; -static GenOpFunc *gen_op_POWER2_stfq[] = { - &gen_op_POWER2_stfq_le_user, - &gen_op_POWER2_stfq_user, - &gen_op_POWER2_stfq_le_kernel, - &gen_op_POWER2_stfq_kernel, -}; -#endif /* lfq */ GEN_HANDLER(lfq, 0x38, 0xFF, 0xFF, 0x00000003, PPC_POWER2) @@ -5687,111 +5174,14 @@ GEN32(gen_op_store_A2_avr, gen_op_store_A2_avr_avr); #endif #define op_vr_ldst(name) (*gen_op_##name[ctx->mem_idx])() -#if defined(CONFIG_USER_ONLY) -#if defined(TARGET_PPC64) -/* User-mode only - 64 bits mode */ -#define OP_VR_LD_TABLE(name) \ -static GenOpFunc *gen_op_vr_l##name[] = { \ - &gen_op_vr_l##name##_raw, \ - &gen_op_vr_l##name##_le_raw, \ - &gen_op_vr_l##name##_64_raw, \ - &gen_op_vr_l##name##_le_64_raw, \ -}; -#define OP_VR_ST_TABLE(name) \ -static GenOpFunc *gen_op_vr_st##name[] = { \ - &gen_op_vr_st##name##_raw, \ - &gen_op_vr_st##name##_le_raw, \ - &gen_op_vr_st##name##_64_raw, \ - &gen_op_vr_st##name##_le_64_raw, \ -}; -#else /* defined(TARGET_PPC64) */ -/* User-mode only - 32 bits mode */ -#define OP_VR_LD_TABLE(name) \ -static GenOpFunc *gen_op_vr_l##name[] = { \ - &gen_op_vr_l##name##_raw, \ - &gen_op_vr_l##name##_le_raw, \ -}; -#define OP_VR_ST_TABLE(name) \ -static GenOpFunc *gen_op_vr_st##name[] = { \ - &gen_op_vr_st##name##_raw, \ - &gen_op_vr_st##name##_le_raw, \ -}; -#endif /* defined(TARGET_PPC64) */ -#else /* defined(CONFIG_USER_ONLY) */ -#if defined(TARGET_PPC64H) -/* Full system with hypervisor mode */ -#define OP_VR_LD_TABLE(name) \ -static GenOpFunc *gen_op_vr_l##name[] = { \ - &gen_op_vr_l##name##_user, \ - &gen_op_vr_l##name##_le_user, \ - &gen_op_vr_l##name##_64_user, \ - &gen_op_vr_l##name##_le_64_user, \ - &gen_op_vr_l##name##_kernel, \ - &gen_op_vr_l##name##_le_kernel, \ - &gen_op_vr_l##name##_64_kernel, \ - &gen_op_vr_l##name##_le_64_kernel, \ - &gen_op_vr_l##name##_hypv, \ - &gen_op_vr_l##name##_le_hypv, \ - &gen_op_vr_l##name##_64_hypv, \ - &gen_op_vr_l##name##_le_64_hypv, \ -}; -#define OP_VR_ST_TABLE(name) \ -static GenOpFunc *gen_op_vr_st##name[] = { \ - &gen_op_vr_st##name##_user, \ - &gen_op_vr_st##name##_le_user, \ - &gen_op_vr_st##name##_64_user, \ - &gen_op_vr_st##name##_le_64_user, \ - &gen_op_vr_st##name##_kernel, \ - &gen_op_vr_st##name##_le_kernel, \ - &gen_op_vr_st##name##_64_kernel, \ - &gen_op_vr_st##name##_le_64_kernel, \ - &gen_op_vr_st##name##_hypv, \ - &gen_op_vr_st##name##_le_hypv, \ - &gen_op_vr_st##name##_64_hypv, \ - &gen_op_vr_st##name##_le_64_hypv, \ -}; -#elif defined(TARGET_PPC64) -/* Full system - 64 bits mode */ #define OP_VR_LD_TABLE(name) \ -static GenOpFunc *gen_op_vr_l##name[] = { \ - &gen_op_vr_l##name##_user, \ - &gen_op_vr_l##name##_le_user, \ - &gen_op_vr_l##name##_64_user, \ - &gen_op_vr_l##name##_le_64_user, \ - &gen_op_vr_l##name##_kernel, \ - &gen_op_vr_l##name##_le_kernel, \ - &gen_op_vr_l##name##_64_kernel, \ - &gen_op_vr_l##name##_le_64_kernel, \ +static GenOpFunc *gen_op_vr_l##name[NB_MEM_FUNCS] = { \ + GEN_MEM_FUNCS(vr_l##name), \ }; #define OP_VR_ST_TABLE(name) \ -static GenOpFunc *gen_op_vr_st##name[] = { \ - &gen_op_vr_st##name##_user, \ - &gen_op_vr_st##name##_le_user, \ - &gen_op_vr_st##name##_64_user, \ - &gen_op_vr_st##name##_le_64_user, \ - &gen_op_vr_st##name##_kernel, \ - &gen_op_vr_st##name##_le_kernel, \ - &gen_op_vr_st##name##_64_kernel, \ - &gen_op_vr_st##name##_le_64_kernel, \ +static GenOpFunc *gen_op_vr_st##name[NB_MEM_FUNCS] = { \ + GEN_MEM_FUNCS(vr_st##name), \ }; -#else /* defined(TARGET_PPC64) */ -/* Full system - 32 bits mode */ -#define OP_VR_LD_TABLE(name) \ -static GenOpFunc *gen_op_vr_l##name[] = { \ - &gen_op_vr_l##name##_user, \ - &gen_op_vr_l##name##_le_user, \ - &gen_op_vr_l##name##_kernel, \ - &gen_op_vr_l##name##_le_kernel, \ -}; -#define OP_VR_ST_TABLE(name) \ -static GenOpFunc *gen_op_vr_st##name[] = { \ - &gen_op_vr_st##name##_user, \ - &gen_op_vr_st##name##_le_user, \ - &gen_op_vr_st##name##_kernel, \ - &gen_op_vr_st##name##_le_kernel, \ -}; -#endif /* defined(TARGET_PPC64) */ -#endif /* defined(CONFIG_USER_ONLY) */ #define GEN_VR_LDX(name, opc2, opc3) \ GEN_HANDLER(l##name, 0x1F, opc2, opc3, 0x00000001, PPC_ALTIVEC) \ @@ -5830,7 +5220,6 @@ GEN_VR_STX(vx, 0x07, 0x07); GEN_VR_STX(vxl, 0x07, 0x0F); /*** SPE extension ***/ - /* Register moves */ #if !defined(TARGET_PPC64) @@ -5893,111 +5282,14 @@ static always_inline void gen_addr_spe_imm_index (DisasContext *ctx, int sh) } #define op_spe_ldst(name) (*gen_op_##name[ctx->mem_idx])() -#if defined(CONFIG_USER_ONLY) -#if defined(TARGET_PPC64) -/* User-mode only - 64 bits mode */ -#define OP_SPE_LD_TABLE(name) \ -static GenOpFunc *gen_op_spe_l##name[] = { \ - &gen_op_spe_l##name##_raw, \ - &gen_op_spe_l##name##_le_raw, \ - &gen_op_spe_l##name##_64_raw, \ - &gen_op_spe_l##name##_le_64_raw, \ -}; -#define OP_SPE_ST_TABLE(name) \ -static GenOpFunc *gen_op_spe_st##name[] = { \ - &gen_op_spe_st##name##_raw, \ - &gen_op_spe_st##name##_le_raw, \ - &gen_op_spe_st##name##_64_raw, \ - &gen_op_spe_st##name##_le_64_raw, \ -}; -#else /* defined(TARGET_PPC64) */ -/* User-mode only - 32 bits mode */ -#define OP_SPE_LD_TABLE(name) \ -static GenOpFunc *gen_op_spe_l##name[] = { \ - &gen_op_spe_l##name##_raw, \ - &gen_op_spe_l##name##_le_raw, \ -}; -#define OP_SPE_ST_TABLE(name) \ -static GenOpFunc *gen_op_spe_st##name[] = { \ - &gen_op_spe_st##name##_raw, \ - &gen_op_spe_st##name##_le_raw, \ -}; -#endif /* defined(TARGET_PPC64) */ -#else /* defined(CONFIG_USER_ONLY) */ -#if defined(TARGET_PPC64H) -/* Full system with hypervisor mode */ #define OP_SPE_LD_TABLE(name) \ -static GenOpFunc *gen_op_spe_l##name[] = { \ - &gen_op_spe_l##name##_user, \ - &gen_op_spe_l##name##_le_user, \ - &gen_op_spe_l##name##_64_user, \ - &gen_op_spe_l##name##_le_64_user, \ - &gen_op_spe_l##name##_kernel, \ - &gen_op_spe_l##name##_le_kernel, \ - &gen_op_spe_l##name##_64_kernel, \ - &gen_op_spe_l##name##_le_64_kernel, \ - &gen_op_spe_l##name##_hypv, \ - &gen_op_spe_l##name##_le_hypv, \ - &gen_op_spe_l##name##_64_hypv, \ - &gen_op_spe_l##name##_le_64_hypv, \ +static GenOpFunc *gen_op_spe_l##name[NB_MEM_FUNCS] = { \ + GEN_MEM_FUNCS(spe_l##name), \ }; #define OP_SPE_ST_TABLE(name) \ -static GenOpFunc *gen_op_spe_st##name[] = { \ - &gen_op_spe_st##name##_user, \ - &gen_op_spe_st##name##_le_user, \ - &gen_op_spe_st##name##_64_user, \ - &gen_op_spe_st##name##_le_64_user, \ - &gen_op_spe_st##name##_kernel, \ - &gen_op_spe_st##name##_le_kernel, \ - &gen_op_spe_st##name##_64_kernel, \ - &gen_op_spe_st##name##_le_64_kernel, \ - &gen_op_spe_st##name##_hypv, \ - &gen_op_spe_st##name##_le_hypv, \ - &gen_op_spe_st##name##_64_hypv, \ - &gen_op_spe_st##name##_le_64_hypv, \ -}; -#elif defined(TARGET_PPC64) -/* Full system - 64 bits mode */ -#define OP_SPE_LD_TABLE(name) \ -static GenOpFunc *gen_op_spe_l##name[] = { \ - &gen_op_spe_l##name##_user, \ - &gen_op_spe_l##name##_le_user, \ - &gen_op_spe_l##name##_64_user, \ - &gen_op_spe_l##name##_le_64_user, \ - &gen_op_spe_l##name##_kernel, \ - &gen_op_spe_l##name##_le_kernel, \ - &gen_op_spe_l##name##_64_kernel, \ - &gen_op_spe_l##name##_le_64_kernel, \ +static GenOpFunc *gen_op_spe_st##name[NB_MEM_FUNCS] = { \ + GEN_MEM_FUNCS(spe_st##name), \ }; -#define OP_SPE_ST_TABLE(name) \ -static GenOpFunc *gen_op_spe_st##name[] = { \ - &gen_op_spe_st##name##_user, \ - &gen_op_spe_st##name##_le_user, \ - &gen_op_spe_st##name##_64_user, \ - &gen_op_spe_st##name##_le_64_user, \ - &gen_op_spe_st##name##_kernel, \ - &gen_op_spe_st##name##_le_kernel, \ - &gen_op_spe_st##name##_64_kernel, \ - &gen_op_spe_st##name##_le_64_kernel, \ -}; -#else /* defined(TARGET_PPC64) */ -/* Full system - 32 bits mode */ -#define OP_SPE_LD_TABLE(name) \ -static GenOpFunc *gen_op_spe_l##name[] = { \ - &gen_op_spe_l##name##_user, \ - &gen_op_spe_l##name##_le_user, \ - &gen_op_spe_l##name##_kernel, \ - &gen_op_spe_l##name##_le_kernel, \ -}; -#define OP_SPE_ST_TABLE(name) \ -static GenOpFunc *gen_op_spe_st##name[] = { \ - &gen_op_spe_st##name##_user, \ - &gen_op_spe_st##name##_le_user, \ - &gen_op_spe_st##name##_kernel, \ - &gen_op_spe_st##name##_le_kernel, \ -}; -#endif /* defined(TARGET_PPC64) */ -#endif /* defined(CONFIG_USER_ONLY) */ #define GEN_SPE_LD(name, sh) \ static always_inline void gen_evl##name (DisasContext *ctx) \ @@ -6258,45 +5550,38 @@ GEN_HANDLER2(evsel3, "evsel", 0x04, 0x1f, 0x09, 0x00000000, PPC_SPE) /* In that case, we already have 64 bits load & stores * so, spe_ldd is equivalent to ld and spe_std is equivalent to std */ -#if defined(CONFIG_USER_ONLY) -#define gen_op_spe_ldd_raw gen_op_ld_raw -#define gen_op_spe_ldd_64_raw gen_op_ld_64_raw -#define gen_op_spe_ldd_le_raw gen_op_ld_le_raw -#define gen_op_spe_ldd_le_64_raw gen_op_ld_le_64_raw -#define gen_op_spe_stdd_raw gen_op_ld_raw -#define gen_op_spe_stdd_64_raw gen_op_std_64_raw -#define gen_op_spe_stdd_le_raw gen_op_std_le_raw -#define gen_op_spe_stdd_le_64_raw gen_op_std_le_64_raw -#else /* defined(CONFIG_USER_ONLY) */ -#if defined(TARGET_PPC64H) -#define gen_op_spe_ldd_hypv gen_op_ld_hypv -#define gen_op_spe_ldd_64_hypv gen_op_ld_64_hypv -#define gen_op_spe_ldd_le_hypv gen_op_ld_hypv -#define gen_op_spe_ldd_le_64_hypv gen_op_ld_64_hypv -#endif -#define gen_op_spe_ldd_kernel gen_op_ld_kernel -#define gen_op_spe_ldd_64_kernel gen_op_ld_64_kernel -#define gen_op_spe_ldd_le_kernel gen_op_ld_kernel -#define gen_op_spe_ldd_le_64_kernel gen_op_ld_64_kernel -#define gen_op_spe_ldd_user gen_op_ld_user -#define gen_op_spe_ldd_64_user gen_op_ld_64_user -#define gen_op_spe_ldd_le_user gen_op_ld_le_user -#define gen_op_spe_ldd_le_64_user gen_op_ld_le_64_user -#if defined(TARGET_PPC64H) -#define gen_op_spe_stdd_hypv gen_op_std_hypv -#define gen_op_spe_stdd_64_hypv gen_op_std_64_hypv -#define gen_op_spe_stdd_le_hypv gen_op_std_hypv -#define gen_op_spe_stdd_le_64_hypv gen_op_std_64_hypv -#endif -#define gen_op_spe_stdd_kernel gen_op_std_kernel -#define gen_op_spe_stdd_64_kernel gen_op_std_64_kernel -#define gen_op_spe_stdd_le_kernel gen_op_std_kernel -#define gen_op_spe_stdd_le_64_kernel gen_op_std_64_kernel -#define gen_op_spe_stdd_user gen_op_std_user -#define gen_op_spe_stdd_64_user gen_op_std_64_user -#define gen_op_spe_stdd_le_user gen_op_std_le_user -#define gen_op_spe_stdd_le_64_user gen_op_std_le_64_user -#endif /* defined(CONFIG_USER_ONLY) */ +#define gen_op_spe_ldd_raw gen_op_ld_raw +#define gen_op_spe_ldd_user gen_op_ld_user +#define gen_op_spe_ldd_kernel gen_op_ld_kernel +#define gen_op_spe_ldd_hypv gen_op_ld_hypv +#define gen_op_spe_ldd_64_raw gen_op_ld_64_raw +#define gen_op_spe_ldd_64_user gen_op_ld_64_user +#define gen_op_spe_ldd_64_kernel gen_op_ld_64_kernel +#define gen_op_spe_ldd_64_hypv gen_op_ld_64_hypv +#define gen_op_spe_ldd_le_raw gen_op_ld_le_raw +#define gen_op_spe_ldd_le_user gen_op_ld_le_user +#define gen_op_spe_ldd_le_kernel gen_op_ld_le_kernel +#define gen_op_spe_ldd_le_hypv gen_op_ld_le_hypv +#define gen_op_spe_ldd_le_64_raw gen_op_ld_le_64_raw +#define gen_op_spe_ldd_le_64_user gen_op_ld_le_64_user +#define gen_op_spe_ldd_le_64_kernel gen_op_ld_le_64_kernel +#define gen_op_spe_ldd_le_64_hypv gen_op_ld_le_64_hypv +#define gen_op_spe_stdd_raw gen_op_std_raw +#define gen_op_spe_stdd_user gen_op_std_user +#define gen_op_spe_stdd_kernel gen_op_std_kernel +#define gen_op_spe_stdd_hypv gen_op_std_hypv +#define gen_op_spe_stdd_64_raw gen_op_std_64_raw +#define gen_op_spe_stdd_64_user gen_op_std_64_user +#define gen_op_spe_stdd_64_kernel gen_op_std_64_kernel +#define gen_op_spe_stdd_64_hypv gen_op_std_64_hypv +#define gen_op_spe_stdd_le_raw gen_op_std_le_raw +#define gen_op_spe_stdd_le_user gen_op_std_le_user +#define gen_op_spe_stdd_le_kernel gen_op_std_le_kernel +#define gen_op_spe_stdd_le_hypv gen_op_std_le_hypv +#define gen_op_spe_stdd_le_64_raw gen_op_std_le_64_raw +#define gen_op_spe_stdd_le_64_user gen_op_std_le_64_user +#define gen_op_spe_stdd_le_64_kernel gen_op_std_le_64_kernel +#define gen_op_spe_stdd_le_64_hypv gen_op_std_le_64_hypv #endif /* defined(TARGET_PPC64) */ GEN_SPEOP_LDST(dd, 3); GEN_SPEOP_LDST(dw, 3); @@ -6308,27 +5593,22 @@ GEN_SPEOP_ST(who, 2); #if defined(TARGET_PPC64) /* In that case, spe_stwwo is equivalent to stw */ -#if defined(CONFIG_USER_ONLY) -#define gen_op_spe_stwwo_raw gen_op_stw_raw -#define gen_op_spe_stwwo_le_raw gen_op_stw_le_raw -#define gen_op_spe_stwwo_64_raw gen_op_stw_64_raw -#define gen_op_spe_stwwo_le_64_raw gen_op_stw_le_64_raw -#else -#define gen_op_spe_stwwo_user gen_op_stw_user -#define gen_op_spe_stwwo_le_user gen_op_stw_le_user -#define gen_op_spe_stwwo_64_user gen_op_stw_64_user -#define gen_op_spe_stwwo_le_64_user gen_op_stw_le_64_user -#define gen_op_spe_stwwo_kernel gen_op_stw_kernel -#define gen_op_spe_stwwo_le_kernel gen_op_stw_le_kernel -#define gen_op_spe_stwwo_64_kernel gen_op_stw_64_kernel +#define gen_op_spe_stwwo_raw gen_op_stw_raw +#define gen_op_spe_stwwo_user gen_op_stw_user +#define gen_op_spe_stwwo_kernel gen_op_stw_kernel +#define gen_op_spe_stwwo_hypv gen_op_stw_hypv +#define gen_op_spe_stwwo_le_raw gen_op_stw_le_raw +#define gen_op_spe_stwwo_le_user gen_op_stw_le_user +#define gen_op_spe_stwwo_le_kernel gen_op_stw_le_kernel +#define gen_op_spe_stwwo_le_hypv gen_op_stw_le_hypv +#define gen_op_spe_stwwo_64_raw gen_op_stw_64_raw +#define gen_op_spe_stwwo_64_user gen_op_stw_64_user +#define gen_op_spe_stwwo_64_kernel gen_op_stw_64_kernel +#define gen_op_spe_stwwo_64_hypv gen_op_stw_64_hypv +#define gen_op_spe_stwwo_le_64_raw gen_op_stw_le_64_raw +#define gen_op_spe_stwwo_le_64_user gen_op_stw_le_64_user #define gen_op_spe_stwwo_le_64_kernel gen_op_stw_le_64_kernel -#if defined(TARGET_PPC64H) -#define gen_op_spe_stwwo_hypv gen_op_stw_hypv -#define gen_op_spe_stwwo_le_hypv gen_op_stw_le_hypv -#define gen_op_spe_stwwo_64_hypv gen_op_stw_64_hypv -#define gen_op_spe_stwwo_le_64_hypv gen_op_stw_le_64_hypv -#endif -#endif +#define gen_op_spe_stwwo_le_64_hypv gen_op_stw_le_64_hypv #endif #define _GEN_OP_SPE_STWWE(suffix) \ static always_inline void gen_op_spe_stwwe_##suffix (void) \ @@ -6364,11 +5644,9 @@ _GEN_OP_SPE_STWWE_LE(suffix) #if defined(CONFIG_USER_ONLY) GEN_OP_SPE_STWWE(raw); #else /* defined(CONFIG_USER_ONLY) */ -#if defined(TARGET_PPC64H) -GEN_OP_SPE_STWWE(hypv); -#endif -GEN_OP_SPE_STWWE(kernel); GEN_OP_SPE_STWWE(user); +GEN_OP_SPE_STWWE(kernel); +GEN_OP_SPE_STWWE(hypv); #endif /* defined(CONFIG_USER_ONLY) */ GEN_SPEOP_ST(wwe, 2); GEN_SPEOP_ST(wwo, 2); @@ -6418,107 +5696,67 @@ GEN_OP_SPE_LHX(le_64_raw); GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_64_raw); #endif #else -#if defined(TARGET_PPC64H) -GEN_OP_SPE_LHE(hypv); -#endif -GEN_OP_SPE_LHE(kernel); GEN_OP_SPE_LHE(user); -#if defined(TARGET_PPC64H) -GEN_SPE_LDSPLAT(hhesplat, spe_lhe, hypv); -#endif -GEN_SPE_LDSPLAT(hhesplat, spe_lhe, kernel); +GEN_OP_SPE_LHE(kernel); +GEN_OP_SPE_LHE(hypv); GEN_SPE_LDSPLAT(hhesplat, spe_lhe, user); -#if defined(TARGET_PPC64H) -GEN_OP_SPE_LHE(le_hypv); -#endif -GEN_OP_SPE_LHE(le_kernel); +GEN_SPE_LDSPLAT(hhesplat, spe_lhe, kernel); +GEN_SPE_LDSPLAT(hhesplat, spe_lhe, hypv); GEN_OP_SPE_LHE(le_user); -#if defined(TARGET_PPC64H) -GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_hypv); -#endif -GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_kernel); +GEN_OP_SPE_LHE(le_kernel); +GEN_OP_SPE_LHE(le_hypv); GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_user); -#if defined(TARGET_PPC64H) -GEN_SPE_LDSPLAT(hhousplat, spe_lh, hypv); -#endif -GEN_SPE_LDSPLAT(hhousplat, spe_lh, kernel); +GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_kernel); +GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_hypv); GEN_SPE_LDSPLAT(hhousplat, spe_lh, user); -#if defined(TARGET_PPC64H) -GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_hypv); -#endif -GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_kernel); +GEN_SPE_LDSPLAT(hhousplat, spe_lh, kernel); +GEN_SPE_LDSPLAT(hhousplat, spe_lh, hypv); GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_user); -#if defined(TARGET_PPC64H) -GEN_OP_SPE_LHX(hypv); -#endif -GEN_OP_SPE_LHX(kernel); +GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_kernel); +GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_hypv); GEN_OP_SPE_LHX(user); -#if defined(TARGET_PPC64H) -GEN_SPE_LDSPLAT(hhossplat, spe_lhx, hypv); -#endif -GEN_SPE_LDSPLAT(hhossplat, spe_lhx, kernel); +GEN_OP_SPE_LHX(kernel); +GEN_OP_SPE_LHX(hypv); GEN_SPE_LDSPLAT(hhossplat, spe_lhx, user); -#if defined(TARGET_PPC64H) -GEN_OP_SPE_LHX(le_hypv); -#endif -GEN_OP_SPE_LHX(le_kernel); +GEN_SPE_LDSPLAT(hhossplat, spe_lhx, kernel); +GEN_SPE_LDSPLAT(hhossplat, spe_lhx, hypv); GEN_OP_SPE_LHX(le_user); -#if defined(TARGET_PPC64H) -GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_hypv); -#endif -GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_kernel); +GEN_OP_SPE_LHX(le_kernel); +GEN_OP_SPE_LHX(le_hypv); GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_user); +GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_kernel); +GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_hypv); #if defined(TARGET_PPC64) -#if defined(TARGET_PPC64H) -GEN_OP_SPE_LHE(64_hypv); -#endif -GEN_OP_SPE_LHE(64_kernel); GEN_OP_SPE_LHE(64_user); -#if defined(TARGET_PPC64H) -GEN_SPE_LDSPLAT(hhesplat, spe_lhe, 64_hypv); -#endif -GEN_SPE_LDSPLAT(hhesplat, spe_lhe, 64_kernel); +GEN_OP_SPE_LHE(64_kernel); +GEN_OP_SPE_LHE(64_hypv); GEN_SPE_LDSPLAT(hhesplat, spe_lhe, 64_user); -#if defined(TARGET_PPC64H) -GEN_OP_SPE_LHE(le_64_hypv); -#endif -GEN_OP_SPE_LHE(le_64_kernel); +GEN_SPE_LDSPLAT(hhesplat, spe_lhe, 64_kernel); +GEN_SPE_LDSPLAT(hhesplat, spe_lhe, 64_hypv); GEN_OP_SPE_LHE(le_64_user); -#if defined(TARGET_PPC64H) -GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_64_hypv); -#endif -GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_64_kernel); +GEN_OP_SPE_LHE(le_64_kernel); +GEN_OP_SPE_LHE(le_64_hypv); GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_64_user); -#if defined(TARGET_PPC64H) -GEN_SPE_LDSPLAT(hhousplat, spe_lh, 64_hypv); -#endif -GEN_SPE_LDSPLAT(hhousplat, spe_lh, 64_kernel); +GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_64_kernel); +GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_64_hypv); GEN_SPE_LDSPLAT(hhousplat, spe_lh, 64_user); -#if defined(TARGET_PPC64H) -GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_64_hypv); -#endif -GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_64_kernel); +GEN_SPE_LDSPLAT(hhousplat, spe_lh, 64_kernel); +GEN_SPE_LDSPLAT(hhousplat, spe_lh, 64_hypv); GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_64_user); -#if defined(TARGET_PPC64H) -GEN_OP_SPE_LHX(64_hypv); -#endif -GEN_OP_SPE_LHX(64_kernel); +GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_64_kernel); +GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_64_hypv); GEN_OP_SPE_LHX(64_user); -#if defined(TARGET_PPC64H) -GEN_SPE_LDSPLAT(hhossplat, spe_lhx, 64_hypv); -#endif -GEN_SPE_LDSPLAT(hhossplat, spe_lhx, 64_kernel); +GEN_OP_SPE_LHX(64_kernel); +GEN_OP_SPE_LHX(64_hypv); GEN_SPE_LDSPLAT(hhossplat, spe_lhx, 64_user); -#if defined(TARGET_PPC64H) -GEN_OP_SPE_LHX(le_64_hypv); -#endif -GEN_OP_SPE_LHX(le_64_kernel); +GEN_SPE_LDSPLAT(hhossplat, spe_lhx, 64_kernel); +GEN_SPE_LDSPLAT(hhossplat, spe_lhx, 64_hypv); GEN_OP_SPE_LHX(le_64_user); -#if defined(TARGET_PPC64H) -GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_64_hypv); -#endif -GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_64_kernel); +GEN_OP_SPE_LHX(le_64_kernel); +GEN_OP_SPE_LHX(le_64_hypv); GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_64_user); +GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_64_kernel); +GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_64_hypv); #endif #endif GEN_SPEOP_LD(hhesplat, 1); |