gwj / at91sam9263 · Commits

Commit 7863667f35531557f10e7f920e4361f621a14e3f

Authored by j_mayer
1 parent 2f619698

Always make PowerPC hypervisor mode memory accesses and instructions 

available for full system emulation, then removing all #if TARGET_PPC64H
  from micro-ops and code translator.
Add new macros to dramatically simplify memory access tables definitions
  in target-ppc/translate.c.


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@3654 c046a42c-6fe2-441c-8c8c-71466251a162
Inline Side-by-side
Showing 6 changed files with 256 additions and 1034 deletions
target-ppc/cpu.h
  View file @7863667
@@ -305,11 +305,9 @@ struct ppc_spr_t { @@ -305,11 +305,9 @@ struct ppc_spr_t {
305 #if !defined(CONFIG_USER_ONLY) 305 #if !defined(CONFIG_USER_ONLY)
306 void (*oea_read)(void *opaque, int spr_num); 306 void (*oea_read)(void *opaque, int spr_num);
307 void (*oea_write)(void *opaque, int spr_num); 307 void (*oea_write)(void *opaque, int spr_num);
308 -#if defined(TARGET_PPC64H)  
309 void (*hea_read)(void *opaque, int spr_num); 308 void (*hea_read)(void *opaque, int spr_num);
310 void (*hea_write)(void *opaque, int spr_num); 309 void (*hea_write)(void *opaque, int spr_num);
311 #endif 310 #endif
312 -#endif  
313 const unsigned char *name; 311 const unsigned char *name;
314 }; 312 };
315 313
@@ -510,11 +508,7 @@ enum { @@ -510,11 +508,7 @@ enum {
510 508
511 /*****************************************************************************/ 509 /*****************************************************************************/
512 /* The whole PowerPC CPU context */ 510 /* The whole PowerPC CPU context */
513 -#if defined(TARGET_PPC64H)  
514 #define NB_MMU_MODES 3 511 #define NB_MMU_MODES 3
515 -#else  
516 -#define NB_MMU_MODES 2  
517 -#endif  
518 512
519 struct CPUPPCState { 513 struct CPUPPCState {
520 /* First are the most commonly used resources 514 /* 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); @@ -783,9 +777,7 @@ int ppc_dcr_write (ppc_dcr_t *dcr_env, int dcrn, target_ulong val);
783 /* MMU modes definitions */ 777 /* MMU modes definitions */
784 #define MMU_MODE0_SUFFIX _user 778 #define MMU_MODE0_SUFFIX _user
785 #define MMU_MODE1_SUFFIX _kernel 779 #define MMU_MODE1_SUFFIX _kernel
786 -#if defined(TARGET_PPC64H)  
787 #define MMU_MODE2_SUFFIX _hypv 780 #define MMU_MODE2_SUFFIX _hypv
788 -#endif  
789 #define MMU_USER_IDX 0 781 #define MMU_USER_IDX 0
790 static inline int cpu_mmu_index (CPUState *env) 782 static inline int cpu_mmu_index (CPUState *env)
791 { 783 {
target-ppc/op.c
  View file @7863667
@@ -1987,12 +1987,10 @@ void OPPROTO op_fneg (void) @@ -1987,12 +1987,10 @@ void OPPROTO op_fneg (void)
1987 #define MEMSUFFIX _kernel 1987 #define MEMSUFFIX _kernel
1988 #include "op_helper.h" 1988 #include "op_helper.h"
1989 #include "op_mem.h" 1989 #include "op_mem.h"
1990 -#if defined(TARGET_PPC64H)  
1991 #define MEMSUFFIX _hypv 1990 #define MEMSUFFIX _hypv
1992 #include "op_helper.h" 1991 #include "op_helper.h"
1993 #include "op_mem.h" 1992 #include "op_mem.h"
1994 #endif 1993 #endif
1995 -#endif  
1996 1994
1997 /* Special op to check and maybe clear reservation */ 1995 /* Special op to check and maybe clear reservation */
1998 void OPPROTO op_check_reservation (void) 1996 void OPPROTO op_check_reservation (void)
@@ -2031,9 +2029,7 @@ void OPPROTO op_rfid (void) @@ -2031,9 +2029,7 @@ void OPPROTO op_rfid (void)
2031 do_rfid(); 2029 do_rfid();
2032 RETURN(); 2030 RETURN();
2033 } 2031 }
2034 -#endif  
2035 2032
2036 -#if defined(TARGET_PPC64H)  
2037 void OPPROTO op_hrfid (void) 2033 void OPPROTO op_hrfid (void)
2038 { 2034 {
2039 do_hrfid(); 2035 do_hrfid();
target-ppc/op_helper.c
  View file @7863667
@@ -33,12 +33,10 @@ @@ -33,12 +33,10 @@
33 #define MEMSUFFIX _kernel 33 #define MEMSUFFIX _kernel
34 #include "op_helper.h" 34 #include "op_helper.h"
35 #include "op_helper_mem.h" 35 #include "op_helper_mem.h"
36 -#if defined(TARGET_PPC64H)  
37 #define MEMSUFFIX _hypv 36 #define MEMSUFFIX _hypv
38 #include "op_helper.h" 37 #include "op_helper.h"
39 #include "op_helper_mem.h" 38 #include "op_helper_mem.h"
40 #endif 39 #endif
41 -#endif  
42 40
43 //#define DEBUG_OP 41 //#define DEBUG_OP
44 //#define DEBUG_EXCEPTIONS 42 //#define DEBUG_EXCEPTIONS
@@ -1475,8 +1473,7 @@ void do_rfid (void) @@ -1475,8 +1473,7 @@ void do_rfid (void)
1475 __do_rfi(env->spr[SPR_SRR0], env->spr[SPR_SRR1], 1473 __do_rfi(env->spr[SPR_SRR0], env->spr[SPR_SRR1],
1476 ~((target_ulong)0xFFFF0000), 0); 1474 ~((target_ulong)0xFFFF0000), 0);
1477 } 1475 }
1478 -#endif  
1479 -#if defined(TARGET_PPC64H) 1476 +
1480 void do_hrfid (void) 1477 void do_hrfid (void)
1481 { 1478 {
1482 __do_rfi(env->spr[SPR_HSRR0], env->spr[SPR_HSRR1], 1479 __do_rfi(env->spr[SPR_HSRR0], env->spr[SPR_HSRR1],
target-ppc/op_helper.h
  View file @7863667
@@ -146,8 +146,6 @@ void do_store_msr (void); @@ -146,8 +146,6 @@ void do_store_msr (void);
146 void do_rfi (void); 146 void do_rfi (void);
147 #if defined(TARGET_PPC64) 147 #if defined(TARGET_PPC64)
148 void do_rfid (void); 148 void do_rfid (void);
149 -#endif  
150 -#if defined(TARGET_PPC64H)  
151 void do_hrfid (void); 149 void do_hrfid (void);
152 #endif 150 #endif
153 void do_load_6xx_tlb (int is_code); 151 void do_load_6xx_tlb (int is_code);
target-ppc/translate.c
  View file @7863667
@@ -1250,7 +1250,6 @@ GEN_HANDLER(or, 0x1F, 0x1C, 0x0D, 0x00000000, PPC_INTEGER) @@ -1250,7 +1250,6 @@ GEN_HANDLER(or, 0x1F, 0x1C, 0x0D, 0x00000000, PPC_INTEGER)
1250 gen_op_store_pri(6); 1250 gen_op_store_pri(6);
1251 } 1251 }
1252 break; 1252 break;
1253 -#if defined(TARGET_PPC64H)  
1254 case 7: 1253 case 7:
1255 if (ctx->supervisor > 1) { 1254 if (ctx->supervisor > 1) {
1256 /* Set process priority to very high */ 1255 /* Set process priority to very high */
@@ -1258,7 +1257,6 @@ GEN_HANDLER(or, 0x1F, 0x1C, 0x0D, 0x00000000, PPC_INTEGER) @@ -1258,7 +1257,6 @@ GEN_HANDLER(or, 0x1F, 0x1C, 0x0D, 0x00000000, PPC_INTEGER)
1258 } 1257 }
1259 break; 1258 break;
1260 #endif 1259 #endif
1261 -#endif  
1262 default: 1260 default:
1263 /* nop */ 1261 /* nop */
1264 break; 1262 break;
@@ -2103,136 +2101,64 @@ static always_inline void gen_addr_register (DisasContext *ctx) @@ -2103,136 +2101,64 @@ static always_inline void gen_addr_register (DisasContext *ctx)
2103 #endif 2101 #endif
2104 } 2102 }
2105 2103
2106 -/*** Integer load ***/  
2107 -#define op_ldst(name) (*gen_op_##name[ctx->mem_idx])() 2104 +#if defined(TARGET_PPC64)
  2105 +#define _GEN_MEM_FUNCS(name, mode) \
  2106 + &gen_op_##name##_##mode, \
  2107 + &gen_op_##name##_le_##mode, \
  2108 + &gen_op_##name##_64_##mode, \
  2109 + &gen_op_##name##_le_64_##mode
  2110 +#else
  2111 +#define _GEN_MEM_FUNCS(name, mode) \
  2112 + &gen_op_##name##_##mode, \
  2113 + &gen_op_##name##_le_##mode
  2114 +#endif
2108 #if defined(CONFIG_USER_ONLY) 2115 #if defined(CONFIG_USER_ONLY)
2109 #if defined(TARGET_PPC64) 2116 #if defined(TARGET_PPC64)
2110 -/* User mode only - 64 bits */  
2111 -#define OP_LD_TABLE(width) \  
2112 -static GenOpFunc *gen_op_l##width[] = { \  
2113 - &gen_op_l##width##_raw, \  
2114 - &gen_op_l##width##_le_raw, \  
2115 - &gen_op_l##width##_64_raw, \  
2116 - &gen_op_l##width##_le_64_raw, \  
2117 -};  
2118 -#define OP_ST_TABLE(width) \  
2119 -static GenOpFunc *gen_op_st##width[] = { \  
2120 - &gen_op_st##width##_raw, \  
2121 - &gen_op_st##width##_le_raw, \  
2122 - &gen_op_st##width##_64_raw, \  
2123 - &gen_op_st##width##_le_64_raw, \  
2124 -};  
2125 -/* Byte access routine are endian safe */  
2126 -#define gen_op_stb_le_64_raw gen_op_stb_64_raw  
2127 -#define gen_op_lbz_le_64_raw gen_op_lbz_64_raw 2117 +#define NB_MEM_FUNCS 4
2128 #else 2118 #else
2129 -/* User mode only - 32 bits */  
2130 -#define OP_LD_TABLE(width) \  
2131 -static GenOpFunc *gen_op_l##width[] = { \  
2132 - &gen_op_l##width##_raw, \  
2133 - &gen_op_l##width##_le_raw, \  
2134 -};  
2135 -#define OP_ST_TABLE(width) \  
2136 -static GenOpFunc *gen_op_st##width[] = { \  
2137 - &gen_op_st##width##_raw, \  
2138 - &gen_op_st##width##_le_raw, \  
2139 -}; 2119 +#define NB_MEM_FUNCS 2
2140 #endif 2120 #endif
2141 -/* Byte access routine are endian safe */  
2142 -#define gen_op_stb_le_raw gen_op_stb_raw  
2143 -#define gen_op_lbz_le_raw gen_op_lbz_raw 2121 +#define GEN_MEM_FUNCS(name) \
  2122 + _GEN_MEM_FUNCS(name, raw)
2144 #else 2123 #else
2145 #if defined(TARGET_PPC64) 2124 #if defined(TARGET_PPC64)
2146 -#if defined(TARGET_PPC64H)  
2147 -/* Full system - 64 bits with hypervisor mode */  
2148 -#define OP_LD_TABLE(width) \  
2149 -static GenOpFunc *gen_op_l##width[] = { \  
2150 - &gen_op_l##width##_user, \  
2151 - &gen_op_l##width##_le_user, \  
2152 - &gen_op_l##width##_64_user, \  
2153 - &gen_op_l##width##_le_64_user, \  
2154 - &gen_op_l##width##_kernel, \  
2155 - &gen_op_l##width##_le_kernel, \  
2156 - &gen_op_l##width##_64_kernel, \  
2157 - &gen_op_l##width##_le_64_kernel, \  
2158 - &gen_op_l##width##_hypv, \  
2159 - &gen_op_l##width##_le_hypv, \  
2160 - &gen_op_l##width##_64_hypv, \  
2161 - &gen_op_l##width##_le_64_hypv, \  
2162 -};  
2163 -#define OP_ST_TABLE(width) \  
2164 -static GenOpFunc *gen_op_st##width[] = { \  
2165 - &gen_op_st##width##_user, \  
2166 - &gen_op_st##width##_le_user, \  
2167 - &gen_op_st##width##_64_user, \  
2168 - &gen_op_st##width##_le_64_user, \  
2169 - &gen_op_st##width##_kernel, \  
2170 - &gen_op_st##width##_le_kernel, \  
2171 - &gen_op_st##width##_64_kernel, \  
2172 - &gen_op_st##width##_le_64_kernel, \  
2173 - &gen_op_st##width##_hypv, \  
2174 - &gen_op_st##width##_le_hypv, \  
2175 - &gen_op_st##width##_64_hypv, \  
2176 - &gen_op_st##width##_le_64_hypv, \  
2177 -};  
2178 -/* Byte access routine are endian safe */  
2179 -#define gen_op_stb_le_hypv gen_op_stb_64_hypv  
2180 -#define gen_op_lbz_le_hypv gen_op_lbz_64_hypv  
2181 -#define gen_op_stb_le_64_hypv gen_op_stb_64_hypv  
2182 -#define gen_op_lbz_le_64_hypv gen_op_lbz_64_hypv 2125 +#define NB_MEM_FUNCS 12
2183 #else 2126 #else
2184 -/* Full system - 64 bits */  
2185 -#define OP_LD_TABLE(width) \  
2186 -static GenOpFunc *gen_op_l##width[] = { \  
2187 - &gen_op_l##width##_user, \  
2188 - &gen_op_l##width##_le_user, \  
2189 - &gen_op_l##width##_64_user, \  
2190 - &gen_op_l##width##_le_64_user, \  
2191 - &gen_op_l##width##_kernel, \  
2192 - &gen_op_l##width##_le_kernel, \  
2193 - &gen_op_l##width##_64_kernel, \  
2194 - &gen_op_l##width##_le_64_kernel, \  
2195 -};  
2196 -#define OP_ST_TABLE(width) \  
2197 -static GenOpFunc *gen_op_st##width[] = { \  
2198 - &gen_op_st##width##_user, \  
2199 - &gen_op_st##width##_le_user, \  
2200 - &gen_op_st##width##_64_user, \  
2201 - &gen_op_st##width##_le_64_user, \  
2202 - &gen_op_st##width##_kernel, \  
2203 - &gen_op_st##width##_le_kernel, \  
2204 - &gen_op_st##width##_64_kernel, \  
2205 - &gen_op_st##width##_le_64_kernel, \  
2206 -}; 2127 +#define NB_MEM_FUNCS 6
2207 #endif 2128 #endif
  2129 +#define GEN_MEM_FUNCS(name) \
  2130 + _GEN_MEM_FUNCS(name, user), \
  2131 + _GEN_MEM_FUNCS(name, kernel), \
  2132 + _GEN_MEM_FUNCS(name, hypv)
  2133 +#endif
  2134 +
  2135 +/*** Integer load ***/
  2136 +#define op_ldst(name) (*gen_op_##name[ctx->mem_idx])()
2208 /* Byte access routine are endian safe */ 2137 /* Byte access routine are endian safe */
2209 -#define gen_op_stb_le_64_user gen_op_stb_64_user 2138 +#define gen_op_lbz_le_raw gen_op_lbz_raw
  2139 +#define gen_op_lbz_le_user gen_op_lbz_user
  2140 +#define gen_op_lbz_le_kernel gen_op_lbz_kernel
  2141 +#define gen_op_lbz_le_hypv gen_op_lbz_hypv
  2142 +#define gen_op_lbz_le_64_raw gen_op_lbz_64_raw
2210 #define gen_op_lbz_le_64_user gen_op_lbz_64_user 2143 #define gen_op_lbz_le_64_user gen_op_lbz_64_user
2211 -#define gen_op_stb_le_64_kernel gen_op_stb_64_kernel  
2212 #define gen_op_lbz_le_64_kernel gen_op_lbz_64_kernel 2144 #define gen_op_lbz_le_64_kernel gen_op_lbz_64_kernel
2213 -#else  
2214 -/* Full system - 32 bits */ 2145 +#define gen_op_lbz_le_64_hypv gen_op_lbz_64_hypv
  2146 +#define gen_op_stb_le_raw gen_op_stb_raw
  2147 +#define gen_op_stb_le_user gen_op_stb_user
  2148 +#define gen_op_stb_le_kernel gen_op_stb_kernel
  2149 +#define gen_op_stb_le_hypv gen_op_stb_hypv
  2150 +#define gen_op_stb_le_64_raw gen_op_stb_64_raw
  2151 +#define gen_op_stb_le_64_user gen_op_stb_64_user
  2152 +#define gen_op_stb_le_64_kernel gen_op_stb_64_kernel
  2153 +#define gen_op_stb_le_64_hypv gen_op_stb_64_hypv
2215 #define OP_LD_TABLE(width) \ 2154 #define OP_LD_TABLE(width) \
2216 -static GenOpFunc *gen_op_l##width[] = { \  
2217 - &gen_op_l##width##_user, \  
2218 - &gen_op_l##width##_le_user, \  
2219 - &gen_op_l##width##_kernel, \  
2220 - &gen_op_l##width##_le_kernel, \ 2155 +static GenOpFunc *gen_op_l##width[NB_MEM_FUNCS] = { \
  2156 + GEN_MEM_FUNCS(l##width), \
2221 }; 2157 };
2222 #define OP_ST_TABLE(width) \ 2158 #define OP_ST_TABLE(width) \
2223 -static GenOpFunc *gen_op_st##width[] = { \  
2224 - &gen_op_st##width##_user, \  
2225 - &gen_op_st##width##_le_user, \  
2226 - &gen_op_st##width##_kernel, \  
2227 - &gen_op_st##width##_le_kernel, \ 2159 +static GenOpFunc *gen_op_st##width[NB_MEM_FUNCS] = { \
  2160 + GEN_MEM_FUNCS(st##width), \
2228 }; 2161 };
2229 -#endif  
2230 -/* Byte access routine are endian safe */  
2231 -#define gen_op_stb_le_user gen_op_stb_user  
2232 -#define gen_op_lbz_le_user gen_op_lbz_user  
2233 -#define gen_op_stb_le_kernel gen_op_stb_kernel  
2234 -#define gen_op_lbz_le_kernel gen_op_lbz_kernel  
2235 -#endif  
2236 2162
2237 #define GEN_LD(width, opc, type) \ 2163 #define GEN_LD(width, opc, type) \
2238 GEN_HANDLER(l##width, opc, 0xFF, 0xFF, 0x00000000, type) \ 2164 GEN_HANDLER(l##width, opc, 0xFF, 0xFF, 0x00000000, type) \
@@ -2487,75 +2413,12 @@ GEN_STX(wbr, 0x16, 0x14, PPC_INTEGER); @@ -2487,75 +2413,12 @@ GEN_STX(wbr, 0x16, 0x14, PPC_INTEGER);
2487 2413
2488 /*** Integer load and store multiple ***/ 2414 /*** Integer load and store multiple ***/
2489 #define op_ldstm(name, reg) (*gen_op_##name[ctx->mem_idx])(reg) 2415 #define op_ldstm(name, reg) (*gen_op_##name[ctx->mem_idx])(reg)
2490 -#if defined(CONFIG_USER_ONLY)  
2491 -/* User-mode only */  
2492 -static GenOpFunc1 *gen_op_lmw[] = {  
2493 - &gen_op_lmw_raw,  
2494 - &gen_op_lmw_le_raw,  
2495 -#if defined(TARGET_PPC64)  
2496 - &gen_op_lmw_64_raw,  
2497 - &gen_op_lmw_le_64_raw,  
2498 -#endif 2416 +static GenOpFunc1 *gen_op_lmw[NB_MEM_FUNCS] = {
  2417 + GEN_MEM_FUNCS(lmw),
2499 }; 2418 };
2500 -static GenOpFunc1 *gen_op_stmw[] = {  
2501 - &gen_op_stmw_raw,  
2502 - &gen_op_stmw_le_raw,  
2503 -#if defined(TARGET_PPC64)  
2504 - &gen_op_stmw_64_raw,  
2505 - &gen_op_stmw_le_64_raw,  
2506 -#endif 2419 +static GenOpFunc1 *gen_op_stmw[NB_MEM_FUNCS] = {
  2420 + GEN_MEM_FUNCS(stmw),
2507 }; 2421 };
2508 -#else  
2509 -#if defined(TARGET_PPC64)  
2510 -/* Full system - 64 bits mode */  
2511 -static GenOpFunc1 *gen_op_lmw[] = {  
2512 - &gen_op_lmw_user,  
2513 - &gen_op_lmw_le_user,  
2514 - &gen_op_lmw_64_user,  
2515 - &gen_op_lmw_le_64_user,  
2516 - &gen_op_lmw_kernel,  
2517 - &gen_op_lmw_le_kernel,  
2518 - &gen_op_lmw_64_kernel,  
2519 - &gen_op_lmw_le_64_kernel,  
2520 -#if defined(TARGET_PPC64H)  
2521 - &gen_op_lmw_hypv,  
2522 - &gen_op_lmw_le_hypv,  
2523 - &gen_op_lmw_64_hypv,  
2524 - &gen_op_lmw_le_64_hypv,  
2525 -#endif  
2526 -};  
2527 -static GenOpFunc1 *gen_op_stmw[] = {  
2528 - &gen_op_stmw_user,  
2529 - &gen_op_stmw_le_user,  
2530 - &gen_op_stmw_64_user,  
2531 - &gen_op_stmw_le_64_user,  
2532 - &gen_op_stmw_kernel,  
2533 - &gen_op_stmw_le_kernel,  
2534 - &gen_op_stmw_64_kernel,  
2535 - &gen_op_stmw_le_64_kernel,  
2536 -#if defined(TARGET_PPC64H)  
2537 - &gen_op_stmw_hypv,  
2538 - &gen_op_stmw_le_hypv,  
2539 - &gen_op_stmw_64_hypv,  
2540 - &gen_op_stmw_le_64_hypv,  
2541 -#endif  
2542 -};  
2543 -#else  
2544 -/* Full system - 32 bits mode */  
2545 -static GenOpFunc1 *gen_op_lmw[] = {  
2546 - &gen_op_lmw_user,  
2547 - &gen_op_lmw_le_user,  
2548 - &gen_op_lmw_kernel,  
2549 - &gen_op_lmw_le_kernel,  
2550 -};  
2551 -static GenOpFunc1 *gen_op_stmw[] = {  
2552 - &gen_op_stmw_user,  
2553 - &gen_op_stmw_le_user,  
2554 - &gen_op_stmw_kernel,  
2555 - &gen_op_stmw_le_kernel,  
2556 -};  
2557 -#endif  
2558 -#endif  
2559 2422
2560 /* lmw */ 2423 /* lmw */
2561 GEN_HANDLER(lmw, 0x2E, 0xFF, 0xFF, 0x00000000, PPC_INTEGER) 2424 GEN_HANDLER(lmw, 0x2E, 0xFF, 0xFF, 0x00000000, PPC_INTEGER)
@@ -2578,105 +2441,15 @@ GEN_HANDLER(stmw, 0x2F, 0xFF, 0xFF, 0x00000000, PPC_INTEGER) @@ -2578,105 +2441,15 @@ GEN_HANDLER(stmw, 0x2F, 0xFF, 0xFF, 0x00000000, PPC_INTEGER)
2578 /*** Integer load and store strings ***/ 2441 /*** Integer load and store strings ***/
2579 #define op_ldsts(name, start) (*gen_op_##name[ctx->mem_idx])(start) 2442 #define op_ldsts(name, start) (*gen_op_##name[ctx->mem_idx])(start)
2580 #define op_ldstsx(name, rd, ra, rb) (*gen_op_##name[ctx->mem_idx])(rd, ra, rb) 2443 #define op_ldstsx(name, rd, ra, rb) (*gen_op_##name[ctx->mem_idx])(rd, ra, rb)
2581 -#if defined(CONFIG_USER_ONLY)  
2582 -/* User-mode only */  
2583 -static GenOpFunc1 *gen_op_lswi[] = {  
2584 - &gen_op_lswi_raw,  
2585 - &gen_op_lswi_le_raw,  
2586 -#if defined(TARGET_PPC64)  
2587 - &gen_op_lswi_64_raw,  
2588 - &gen_op_lswi_le_64_raw,  
2589 -#endif  
2590 -};  
2591 -static GenOpFunc3 *gen_op_lswx[] = {  
2592 - &gen_op_lswx_raw,  
2593 - &gen_op_lswx_le_raw,  
2594 -#if defined(TARGET_PPC64)  
2595 - &gen_op_lswx_64_raw,  
2596 - &gen_op_lswx_le_64_raw,  
2597 -#endif 2444 +static GenOpFunc1 *gen_op_lswi[NB_MEM_FUNCS] = {
  2445 + GEN_MEM_FUNCS(lswi),
2598 }; 2446 };
2599 -static GenOpFunc1 *gen_op_stsw[] = {  
2600 - &gen_op_stsw_raw,  
2601 - &gen_op_stsw_le_raw,  
2602 -#if defined(TARGET_PPC64)  
2603 - &gen_op_stsw_64_raw,  
2604 - &gen_op_stsw_le_64_raw,  
2605 -#endif  
2606 -};  
2607 -#else  
2608 -#if defined(TARGET_PPC64)  
2609 -/* Full system - 64 bits mode */  
2610 -static GenOpFunc1 *gen_op_lswi[] = {  
2611 - &gen_op_lswi_user,  
2612 - &gen_op_lswi_le_user,  
2613 - &gen_op_lswi_64_user,  
2614 - &gen_op_lswi_le_64_user,  
2615 - &gen_op_lswi_kernel,  
2616 - &gen_op_lswi_le_kernel,  
2617 - &gen_op_lswi_64_kernel,  
2618 - &gen_op_lswi_le_64_kernel,  
2619 -#if defined(TARGET_PPC64H)  
2620 - &gen_op_lswi_hypv,  
2621 - &gen_op_lswi_le_hypv,  
2622 - &gen_op_lswi_64_hypv,  
2623 - &gen_op_lswi_le_64_hypv,  
2624 -#endif 2447 +static GenOpFunc3 *gen_op_lswx[NB_MEM_FUNCS] = {
  2448 + GEN_MEM_FUNCS(lswx),
2625 }; 2449 };
2626 -static GenOpFunc3 *gen_op_lswx[] = {  
2627 - &gen_op_lswx_user,  
2628 - &gen_op_lswx_le_user,  
2629 - &gen_op_lswx_64_user,  
2630 - &gen_op_lswx_le_64_user,  
2631 - &gen_op_lswx_kernel,  
2632 - &gen_op_lswx_le_kernel,  
2633 - &gen_op_lswx_64_kernel,  
2634 - &gen_op_lswx_le_64_kernel,  
2635 -#if defined(TARGET_PPC64H)  
2636 - &gen_op_lswx_hypv,  
2637 - &gen_op_lswx_le_hypv,  
2638 - &gen_op_lswx_64_hypv,  
2639 - &gen_op_lswx_le_64_hypv,  
2640 -#endif  
2641 -};  
2642 -static GenOpFunc1 *gen_op_stsw[] = {  
2643 - &gen_op_stsw_user,  
2644 - &gen_op_stsw_le_user,  
2645 - &gen_op_stsw_64_user,  
2646 - &gen_op_stsw_le_64_user,  
2647 - &gen_op_stsw_kernel,  
2648 - &gen_op_stsw_le_kernel,  
2649 - &gen_op_stsw_64_kernel,  
2650 - &gen_op_stsw_le_64_kernel,  
2651 -#if defined(TARGET_PPC64H)  
2652 - &gen_op_stsw_hypv,  
2653 - &gen_op_stsw_le_hypv,  
2654 - &gen_op_stsw_64_hypv,  
2655 - &gen_op_stsw_le_64_hypv,  
2656 -#endif  
2657 -};  
2658 -#else  
2659 -/* Full system - 32 bits mode */  
2660 -static GenOpFunc1 *gen_op_lswi[] = {  
2661 - &gen_op_lswi_user,  
2662 - &gen_op_lswi_le_user,  
2663 - &gen_op_lswi_kernel,  
2664 - &gen_op_lswi_le_kernel, 2450 +static GenOpFunc1 *gen_op_stsw[NB_MEM_FUNCS] = {
  2451 + GEN_MEM_FUNCS(stsw),
2665 }; 2452 };
2666 -static GenOpFunc3 *gen_op_lswx[] = {  
2667 - &gen_op_lswx_user,  
2668 - &gen_op_lswx_le_user,  
2669 - &gen_op_lswx_kernel,  
2670 - &gen_op_lswx_le_kernel,  
2671 -};  
2672 -static GenOpFunc1 *gen_op_stsw[] = {  
2673 - &gen_op_stsw_user,  
2674 - &gen_op_stsw_le_user,  
2675 - &gen_op_stsw_kernel,  
2676 - &gen_op_stsw_le_kernel,  
2677 -};  
2678 -#endif  
2679 -#endif  
2680 2453
2681 /* lswi */ 2454 /* lswi */
2682 /* PowerPC32 specification says we must generate an exception if 2455 /* PowerPC32 specification says we must generate an exception if
@@ -2762,75 +2535,12 @@ GEN_HANDLER(isync, 0x13, 0x16, 0x04, 0x03FFF801, PPC_MEM) @@ -2762,75 +2535,12 @@ GEN_HANDLER(isync, 0x13, 0x16, 0x04, 0x03FFF801, PPC_MEM)
2762 2535
2763 #define op_lwarx() (*gen_op_lwarx[ctx->mem_idx])() 2536 #define op_lwarx() (*gen_op_lwarx[ctx->mem_idx])()
2764 #define op_stwcx() (*gen_op_stwcx[ctx->mem_idx])() 2537 #define op_stwcx() (*gen_op_stwcx[ctx->mem_idx])()
2765 -#if defined(CONFIG_USER_ONLY)  
2766 -/* User-mode only */  
2767 -static GenOpFunc *gen_op_lwarx[] = {  
2768 - &gen_op_lwarx_raw,  
2769 - &gen_op_lwarx_le_raw,  
2770 -#if defined(TARGET_PPC64)  
2771 - &gen_op_lwarx_64_raw,  
2772 - &gen_op_lwarx_le_64_raw,  
2773 -#endif  
2774 -};  
2775 -static GenOpFunc *gen_op_stwcx[] = {  
2776 - &gen_op_stwcx_raw,  
2777 - &gen_op_stwcx_le_raw,  
2778 -#if defined(TARGET_PPC64)  
2779 - &gen_op_stwcx_64_raw,  
2780 - &gen_op_stwcx_le_64_raw,  
2781 -#endif 2538 +static GenOpFunc *gen_op_lwarx[NB_MEM_FUNCS] = {
  2539 + GEN_MEM_FUNCS(lwarx),
2782 }; 2540 };
2783 -#else  
2784 -#if defined(TARGET_PPC64)  
2785 -/* Full system - 64 bits mode */  
2786 -static GenOpFunc *gen_op_lwarx[] = {  
2787 - &gen_op_lwarx_user,  
2788 - &gen_op_lwarx_le_user,  
2789 - &gen_op_lwarx_64_user,  
2790 - &gen_op_lwarx_le_64_user,  
2791 - &gen_op_lwarx_kernel,  
2792 - &gen_op_lwarx_le_kernel,  
2793 - &gen_op_lwarx_64_kernel,  
2794 - &gen_op_lwarx_le_64_kernel,  
2795 -#if defined(TARGET_PPC64H)  
2796 - &gen_op_lwarx_hypv,  
2797 - &gen_op_lwarx_le_hypv,  
2798 - &gen_op_lwarx_64_hypv,  
2799 - &gen_op_lwarx_le_64_hypv,  
2800 -#endif 2541 +static GenOpFunc *gen_op_stwcx[NB_MEM_FUNCS] = {
  2542 + GEN_MEM_FUNCS(stwcx),
2801 }; 2543 };
2802 -static GenOpFunc *gen_op_stwcx[] = {  
2803 - &gen_op_stwcx_user,  
2804 - &gen_op_stwcx_le_user,  
2805 - &gen_op_stwcx_64_user,  
2806 - &gen_op_stwcx_le_64_user,  
2807 - &gen_op_stwcx_kernel,  
2808 - &gen_op_stwcx_le_kernel,  
2809 - &gen_op_stwcx_64_kernel,  
2810 - &gen_op_stwcx_le_64_kernel,  
2811 -#if defined(TARGET_PPC64H)  
2812 - &gen_op_stwcx_hypv,  
2813 - &gen_op_stwcx_le_hypv,  
2814 - &gen_op_stwcx_64_hypv,  
2815 - &gen_op_stwcx_le_64_hypv,  
2816 -#endif  
2817 -};  
2818 -#else  
2819 -/* Full system - 32 bits mode */  
2820 -static GenOpFunc *gen_op_lwarx[] = {  
2821 - &gen_op_lwarx_user,  
2822 - &gen_op_lwarx_le_user,  
2823 - &gen_op_lwarx_kernel,  
2824 - &gen_op_lwarx_le_kernel,  
2825 -};  
2826 -static GenOpFunc *gen_op_stwcx[] = {  
2827 - &gen_op_stwcx_user,  
2828 - &gen_op_stwcx_le_user,  
2829 - &gen_op_stwcx_kernel,  
2830 - &gen_op_stwcx_le_kernel,  
2831 -};  
2832 -#endif  
2833 -#endif  
2834 2544
2835 /* lwarx */ 2545 /* lwarx */
2836 GEN_HANDLER(lwarx, 0x1F, 0x14, 0x00, 0x00000001, PPC_RES) 2546 GEN_HANDLER(lwarx, 0x1F, 0x14, 0x00, 0x00000001, PPC_RES)
@@ -2855,55 +2565,12 @@ GEN_HANDLER2(stwcx_, "stwcx.", 0x1F, 0x16, 0x04, 0x00000000, PPC_RES) @@ -2855,55 +2565,12 @@ GEN_HANDLER2(stwcx_, "stwcx.", 0x1F, 0x16, 0x04, 0x00000000, PPC_RES)
2855 #if defined(TARGET_PPC64) 2565 #if defined(TARGET_PPC64)
2856 #define op_ldarx() (*gen_op_ldarx[ctx->mem_idx])() 2566 #define op_ldarx() (*gen_op_ldarx[ctx->mem_idx])()
2857 #define op_stdcx() (*gen_op_stdcx[ctx->mem_idx])() 2567 #define op_stdcx() (*gen_op_stdcx[ctx->mem_idx])()
2858 -#if defined(CONFIG_USER_ONLY)  
2859 -/* User-mode only */  
2860 -static GenOpFunc *gen_op_ldarx[] = {  
2861 - &gen_op_ldarx_raw,  
2862 - &gen_op_ldarx_le_raw,  
2863 - &gen_op_ldarx_64_raw,  
2864 - &gen_op_ldarx_le_64_raw, 2568 +static GenOpFunc *gen_op_ldarx[NB_MEM_FUNCS] = {
  2569 + GEN_MEM_FUNCS(ldarx),
2865 }; 2570 };
2866 -static GenOpFunc *gen_op_stdcx[] = {  
2867 - &gen_op_stdcx_raw,  
2868 - &gen_op_stdcx_le_raw,  
2869 - &gen_op_stdcx_64_raw,  
2870 - &gen_op_stdcx_le_64_raw, 2571 +static GenOpFunc *gen_op_stdcx[NB_MEM_FUNCS] = {
  2572 + GEN_MEM_FUNCS(stdcx),
2871 }; 2573 };
2872 -#else  
2873 -/* Full system */  
2874 -static GenOpFunc *gen_op_ldarx[] = {  
2875 - &gen_op_ldarx_user,  
2876 - &gen_op_ldarx_le_user,  
2877 - &gen_op_ldarx_64_user,  
2878 - &gen_op_ldarx_le_64_user,  
2879 - &gen_op_ldarx_kernel,  
2880 - &gen_op_ldarx_le_kernel,  
2881 - &gen_op_ldarx_64_kernel,  
2882 - &gen_op_ldarx_le_64_kernel,  
2883 -#if defined(TARGET_PPC64H)  
2884 - &gen_op_ldarx_hypv,  
2885 - &gen_op_ldarx_le_hypv,  
2886 - &gen_op_ldarx_64_hypv,  
2887 - &gen_op_ldarx_le_64_hypv,  
2888 -#endif  
2889 -};  
2890 -static GenOpFunc *gen_op_stdcx[] = {  
2891 - &gen_op_stdcx_user,  
2892 - &gen_op_stdcx_le_user,  
2893 - &gen_op_stdcx_64_user,  
2894 - &gen_op_stdcx_le_64_user,  
2895 - &gen_op_stdcx_kernel,  
2896 - &gen_op_stdcx_le_kernel,  
2897 - &gen_op_stdcx_64_kernel,  
2898 - &gen_op_stdcx_le_64_kernel,  
2899 -#if defined(TARGET_PPC64H)  
2900 - &gen_op_stdcx_hypv,  
2901 - &gen_op_stdcx_le_hypv,  
2902 - &gen_op_stdcx_64_hypv,  
2903 - &gen_op_stdcx_le_64_hypv,  
2904 -#endif  
2905 -};  
2906 -#endif  
2907 2574
2908 /* ldarx */ 2575 /* ldarx */
2909 GEN_HANDLER(ldarx, 0x1F, 0x14, 0x02, 0x00000001, PPC_64B) 2576 GEN_HANDLER(ldarx, 0x1F, 0x14, 0x02, 0x00000001, PPC_64B)
@@ -3406,9 +3073,7 @@ GEN_HANDLER(rfid, 0x13, 0x12, 0x00, 0x03FF8001, PPC_64B) @@ -3406,9 +3073,7 @@ GEN_HANDLER(rfid, 0x13, 0x12, 0x00, 0x03FF8001, PPC_64B)
3406 GEN_SYNC(ctx); 3073 GEN_SYNC(ctx);
3407 #endif 3074 #endif
3408 } 3075 }
3409 -#endif  
3410 3076
3411 -#if defined(TARGET_PPC64H)  
3412 GEN_HANDLER(hrfid, 0x13, 0x12, 0x08, 0x03FF8001, PPC_64B) 3077 GEN_HANDLER(hrfid, 0x13, 0x12, 0x08, 0x03FF8001, PPC_64B)
3413 { 3078 {
3414 #if defined(CONFIG_USER_ONLY) 3079 #if defined(CONFIG_USER_ONLY)
@@ -3542,12 +3207,9 @@ static always_inline void gen_op_mfspr (DisasContext *ctx) @@ -3542,12 +3207,9 @@ static always_inline void gen_op_mfspr (DisasContext *ctx)
3542 uint32_t sprn = SPR(ctx->opcode); 3207 uint32_t sprn = SPR(ctx->opcode);
3543 3208
3544 #if !defined(CONFIG_USER_ONLY) 3209 #if !defined(CONFIG_USER_ONLY)
3545 -#if defined(TARGET_PPC64H)  
3546 if (ctx->supervisor == 2) 3210 if (ctx->supervisor == 2)
3547 read_cb = ctx->spr_cb[sprn].hea_read; 3211 read_cb = ctx->spr_cb[sprn].hea_read;
3548 - else  
3549 -#endif  
3550 - if (ctx->supervisor) 3212 + else if (ctx->supervisor)
3551 read_cb = ctx->spr_cb[sprn].oea_read; 3213 read_cb = ctx->spr_cb[sprn].oea_read;
3552 else 3214 else
3553 #endif 3215 #endif
@@ -3682,12 +3344,9 @@ GEN_HANDLER(mtspr, 0x1F, 0x13, 0x0E, 0x00000001, PPC_MISC) @@ -3682,12 +3344,9 @@ GEN_HANDLER(mtspr, 0x1F, 0x13, 0x0E, 0x00000001, PPC_MISC)
3682 uint32_t sprn = SPR(ctx->opcode); 3344 uint32_t sprn = SPR(ctx->opcode);
3683 3345
3684 #if !defined(CONFIG_USER_ONLY) 3346 #if !defined(CONFIG_USER_ONLY)
3685 -#if defined(TARGET_PPC64H)  
3686 if (ctx->supervisor == 2) 3347 if (ctx->supervisor == 2)
3687 write_cb = ctx->spr_cb[sprn].hea_write; 3348 write_cb = ctx->spr_cb[sprn].hea_write;
3688 - else  
3689 -#endif  
3690 - if (ctx->supervisor) 3349 + else if (ctx->supervisor)
3691 write_cb = ctx->spr_cb[sprn].oea_write; 3350 write_cb = ctx->spr_cb[sprn].oea_write;
3692 else 3351 else
3693 #endif 3352 #endif
@@ -3773,141 +3432,56 @@ GEN_HANDLER(dcbtst, 0x1F, 0x16, 0x07, 0x02000001, PPC_CACHE) @@ -3773,141 +3432,56 @@ GEN_HANDLER(dcbtst, 0x1F, 0x16, 0x07, 0x02000001, PPC_CACHE)
3773 3432
3774 /* dcbz */ 3433 /* dcbz */
3775 #define op_dcbz(n) (*gen_op_dcbz[n][ctx->mem_idx])() 3434 #define op_dcbz(n) (*gen_op_dcbz[n][ctx->mem_idx])()
3776 -#if defined(CONFIG_USER_ONLY)  
3777 -/* User-mode only */  
3778 -static GenOpFunc *gen_op_dcbz[4][4] = {  
3779 - {  
3780 - &gen_op_dcbz_l32_raw,  
3781 - &gen_op_dcbz_l32_raw,  
3782 -#if defined(TARGET_PPC64)  
3783 - &gen_op_dcbz_l32_64_raw,  
3784 - &gen_op_dcbz_l32_64_raw,  
3785 -#endif  
3786 - },  
3787 - {  
3788 - &gen_op_dcbz_l64_raw,  
3789 - &gen_op_dcbz_l64_raw,  
3790 -#if defined(TARGET_PPC64)  
3791 - &gen_op_dcbz_l64_64_raw,  
3792 - &gen_op_dcbz_l64_64_raw,  
3793 -#endif  
3794 - },  
3795 - {  
3796 - &gen_op_dcbz_l128_raw,  
3797 - &gen_op_dcbz_l128_raw,  
3798 -#if defined(TARGET_PPC64)  
3799 - &gen_op_dcbz_l128_64_raw,  
3800 - &gen_op_dcbz_l128_64_raw,  
3801 -#endif  
3802 - },  
3803 - {  
3804 - &gen_op_dcbz_raw,  
3805 - &gen_op_dcbz_raw,  
3806 -#if defined(TARGET_PPC64)  
3807 - &gen_op_dcbz_64_raw,  
3808 - &gen_op_dcbz_64_raw,  
3809 -#endif  
3810 - },  
3811 -};  
3812 -#else  
3813 -#if defined(TARGET_PPC64)  
3814 -/* Full system - 64 bits mode */  
3815 -static GenOpFunc *gen_op_dcbz[4][12] = { 3435 +static GenOpFunc *gen_op_dcbz[4][NB_MEM_FUNCS] = {
  3436 + /* 32 bytes cache line size */
3816 { 3437 {
3817 - &gen_op_dcbz_l32_user,  
3818 - &gen_op_dcbz_l32_user,  
3819 - &gen_op_dcbz_l32_64_user,  
3820 - &gen_op_dcbz_l32_64_user,  
3821 - &gen_op_dcbz_l32_kernel,  
3822 - &gen_op_dcbz_l32_kernel,  
3823 - &gen_op_dcbz_l32_64_kernel,  
3824 - &gen_op_dcbz_l32_64_kernel,  
3825 -#if defined(TARGET_PPC64H)  
3826 - &gen_op_dcbz_l32_hypv,  
3827 - &gen_op_dcbz_l32_hypv,  
3828 - &gen_op_dcbz_l32_64_hypv,  
3829 - &gen_op_dcbz_l32_64_hypv,  
3830 -#endif 3438 +#define gen_op_dcbz_l32_le_raw gen_op_dcbz_l32_raw
  3439 +#define gen_op_dcbz_l32_le_user gen_op_dcbz_l32_user
  3440 +#define gen_op_dcbz_l32_le_kernel gen_op_dcbz_l32_kernel
  3441 +#define gen_op_dcbz_l32_le_hypv gen_op_dcbz_l32_hypv
  3442 +#define gen_op_dcbz_l32_le_64_raw gen_op_dcbz_l32_64_raw
  3443 +#define gen_op_dcbz_l32_le_64_user gen_op_dcbz_l32_64_user
  3444 +#define gen_op_dcbz_l32_le_64_kernel gen_op_dcbz_l32_64_kernel
  3445 +#define gen_op_dcbz_l32_le_64_hypv gen_op_dcbz_l32_64_hypv
  3446 + GEN_MEM_FUNCS(dcbz_l32),
3831 }, 3447 },
  3448 + /* 64 bytes cache line size */
3832 { 3449 {
3833 - &gen_op_dcbz_l64_user,  
3834 - &gen_op_dcbz_l64_user,  
3835 - &gen_op_dcbz_l64_64_user,  
3836 - &gen_op_dcbz_l64_64_user,  
3837 - &gen_op_dcbz_l64_kernel,  
3838 - &gen_op_dcbz_l64_kernel,  
3839 - &gen_op_dcbz_l64_64_kernel,  
3840 - &gen_op_dcbz_l64_64_kernel,  
3841 -#if defined(TARGET_PPC64H)  
3842 - &gen_op_dcbz_l64_hypv,  
3843 - &gen_op_dcbz_l64_hypv,  
3844 - &gen_op_dcbz_l64_64_hypv,  
3845 - &gen_op_dcbz_l64_64_hypv,  
3846 -#endif 3450 +#define gen_op_dcbz_l64_le_raw gen_op_dcbz_l64_raw
  3451 +#define gen_op_dcbz_l64_le_user gen_op_dcbz_l64_user
  3452 +#define gen_op_dcbz_l64_le_kernel gen_op_dcbz_l64_kernel
  3453 +#define gen_op_dcbz_l64_le_hypv gen_op_dcbz_l64_hypv
  3454 +#define gen_op_dcbz_l64_le_64_raw gen_op_dcbz_l64_64_raw
  3455 +#define gen_op_dcbz_l64_le_64_user gen_op_dcbz_l64_64_user
  3456 +#define gen_op_dcbz_l64_le_64_kernel gen_op_dcbz_l64_64_kernel
  3457 +#define gen_op_dcbz_l64_le_64_hypv gen_op_dcbz_l64_64_hypv
  3458 + GEN_MEM_FUNCS(dcbz_l64),
3847 }, 3459 },
  3460 + /* 128 bytes cache line size */
3848 { 3461 {
3849 - &gen_op_dcbz_l128_user,  
3850 - &gen_op_dcbz_l128_user,  
3851 - &gen_op_dcbz_l128_64_user,  
3852 - &gen_op_dcbz_l128_64_user,  
3853 - &gen_op_dcbz_l128_kernel,  
3854 - &gen_op_dcbz_l128_kernel,  
3855 - &gen_op_dcbz_l128_64_kernel,  
3856 - &gen_op_dcbz_l128_64_kernel,  
3857 -#if defined(TARGET_PPC64H)  
3858 - &gen_op_dcbz_l128_hypv,  
3859 - &gen_op_dcbz_l128_hypv,  
3860 - &gen_op_dcbz_l128_64_hypv,  
3861 - &gen_op_dcbz_l128_64_hypv,  
3862 -#endif 3462 +#define gen_op_dcbz_l128_le_raw gen_op_dcbz_l128_raw
  3463 +#define gen_op_dcbz_l128_le_user gen_op_dcbz_l128_user
  3464 +#define gen_op_dcbz_l128_le_kernel gen_op_dcbz_l128_kernel
  3465 +#define gen_op_dcbz_l128_le_hypv gen_op_dcbz_l128_hypv
  3466 +#define gen_op_dcbz_l128_le_64_raw gen_op_dcbz_l128_64_raw
  3467 +#define gen_op_dcbz_l128_le_64_user gen_op_dcbz_l128_64_user
  3468 +#define gen_op_dcbz_l128_le_64_kernel gen_op_dcbz_l128_64_kernel
  3469 +#define gen_op_dcbz_l128_le_64_hypv gen_op_dcbz_l128_64_hypv
  3470 + GEN_MEM_FUNCS(dcbz_l128),
3863 }, 3471 },
  3472 + /* tunable cache line size */
3864 { 3473 {
3865 - &gen_op_dcbz_user,  
3866 - &gen_op_dcbz_user,  
3867 - &gen_op_dcbz_64_user,  
3868 - &gen_op_dcbz_64_user,  
3869 - &gen_op_dcbz_kernel,  
3870 - &gen_op_dcbz_kernel,  
3871 - &gen_op_dcbz_64_kernel,  
3872 - &gen_op_dcbz_64_kernel,  
3873 -#if defined(TARGET_PPC64H)  
3874 - &gen_op_dcbz_hypv,  
3875 - &gen_op_dcbz_hypv,  
3876 - &gen_op_dcbz_64_hypv,  
3877 - &gen_op_dcbz_64_hypv,  
3878 -#endif 3474 +#define gen_op_dcbz_le_raw gen_op_dcbz_raw
  3475 +#define gen_op_dcbz_le_user gen_op_dcbz_user
  3476 +#define gen_op_dcbz_le_kernel gen_op_dcbz_kernel
  3477 +#define gen_op_dcbz_le_hypv gen_op_dcbz_hypv
  3478 +#define gen_op_dcbz_le_64_raw gen_op_dcbz_64_raw
  3479 +#define gen_op_dcbz_le_64_user gen_op_dcbz_64_user
  3480 +#define gen_op_dcbz_le_64_kernel gen_op_dcbz_64_kernel
  3481 +#define gen_op_dcbz_le_64_hypv gen_op_dcbz_64_hypv
  3482 + GEN_MEM_FUNCS(dcbz),
3879 }, 3483 },
3880 }; 3484 };
3881 -#else  
3882 -/* Full system - 32 bits mode */  
3883 -static GenOpFunc *gen_op_dcbz[4][4] = {  
3884 - {  
3885 - &gen_op_dcbz_l32_user,  
3886 - &gen_op_dcbz_l32_user,  
3887 - &gen_op_dcbz_l32_kernel,  
3888 - &gen_op_dcbz_l32_kernel,  
3889 - },  
3890 - {  
3891 - &gen_op_dcbz_l64_user,  
3892 - &gen_op_dcbz_l64_user,  
3893 - &gen_op_dcbz_l64_kernel,  
3894 - &gen_op_dcbz_l64_kernel,  
3895 - },  
3896 - {  
3897 - &gen_op_dcbz_l128_user,  
3898 - &gen_op_dcbz_l128_user,  
3899 - &gen_op_dcbz_l128_kernel,  
3900 - &gen_op_dcbz_l128_kernel,  
3901 - },  
3902 - {  
3903 - &gen_op_dcbz_user,  
3904 - &gen_op_dcbz_user,  
3905 - &gen_op_dcbz_kernel,  
3906 - &gen_op_dcbz_kernel,  
3907 - },  
3908 -};  
3909 -#endif  
3910 -#endif  
3911 3485
3912 static always_inline void handler_dcbz (DisasContext *ctx, 3486 static always_inline void handler_dcbz (DisasContext *ctx,
3913 int dcache_line_size) 3487 int dcache_line_size)
@@ -3950,45 +3524,17 @@ GEN_HANDLER2(dcbz_970, "dcbz", 0x1F, 0x16, 0x1F, 0x03C00001, PPC_CACHE_DCBZT) @@ -3950,45 +3524,17 @@ GEN_HANDLER2(dcbz_970, "dcbz", 0x1F, 0x16, 0x1F, 0x03C00001, PPC_CACHE_DCBZT)
3950 3524
3951 /* icbi */ 3525 /* icbi */
3952 #define op_icbi() (*gen_op_icbi[ctx->mem_idx])() 3526 #define op_icbi() (*gen_op_icbi[ctx->mem_idx])()
3953 -#if defined(CONFIG_USER_ONLY)  
3954 -/* User-mode only */  
3955 -static GenOpFunc *gen_op_icbi[] = {  
3956 - &gen_op_icbi_raw,  
3957 - &gen_op_icbi_raw,  
3958 -#if defined(TARGET_PPC64)  
3959 - &gen_op_icbi_64_raw,  
3960 - &gen_op_icbi_64_raw,  
3961 -#endif  
3962 -};  
3963 -#else  
3964 -/* Full system - 64 bits mode */  
3965 -#if defined(TARGET_PPC64)  
3966 -static GenOpFunc *gen_op_icbi[] = {  
3967 - &gen_op_icbi_user,  
3968 - &gen_op_icbi_user,  
3969 - &gen_op_icbi_64_user,  
3970 - &gen_op_icbi_64_user,  
3971 - &gen_op_icbi_kernel,  
3972 - &gen_op_icbi_kernel,  
3973 - &gen_op_icbi_64_kernel,  
3974 - &gen_op_icbi_64_kernel,  
3975 -#if defined(TARGET_PPC64H)  
3976 - &gen_op_icbi_hypv,  
3977 - &gen_op_icbi_hypv,  
3978 - &gen_op_icbi_64_hypv,  
3979 - &gen_op_icbi_64_hypv,  
3980 -#endif  
3981 -};  
3982 -#else  
3983 -/* Full system - 32 bits mode */  
3984 -static GenOpFunc *gen_op_icbi[] = {  
3985 - &gen_op_icbi_user,  
3986 - &gen_op_icbi_user,  
3987 - &gen_op_icbi_kernel,  
3988 - &gen_op_icbi_kernel, 3527 +#define gen_op_icbi_le_raw gen_op_icbi_raw
  3528 +#define gen_op_icbi_le_user gen_op_icbi_user
  3529 +#define gen_op_icbi_le_kernel gen_op_icbi_kernel
  3530 +#define gen_op_icbi_le_hypv gen_op_icbi_hypv
  3531 +#define gen_op_icbi_le_64_raw gen_op_icbi_64_raw
  3532 +#define gen_op_icbi_le_64_user gen_op_icbi_64_user
  3533 +#define gen_op_icbi_le_64_kernel gen_op_icbi_64_kernel
  3534 +#define gen_op_icbi_le_64_hypv gen_op_icbi_64_hypv
  3535 +static GenOpFunc *gen_op_icbi[NB_MEM_FUNCS] = {
  3536 + GEN_MEM_FUNCS(icbi),
3989 }; 3537 };
3990 -#endif  
3991 -#endif  
3992 3538
3993 GEN_HANDLER(icbi, 0x1F, 0x16, 0x1E, 0x03E00001, PPC_CACHE_ICBI) 3539 GEN_HANDLER(icbi, 0x1F, 0x16, 0x1E, 0x03E00001, PPC_CACHE_ICBI)
3994 { 3540 {
@@ -4239,75 +3785,12 @@ GEN_HANDLER(slbie, 0x1F, 0x12, 0x0D, 0x03FF0001, PPC_SLBI) @@ -4239,75 +3785,12 @@ GEN_HANDLER(slbie, 0x1F, 0x12, 0x0D, 0x03FF0001, PPC_SLBI)
4239 /* Optional: */ 3785 /* Optional: */
4240 #define op_eciwx() (*gen_op_eciwx[ctx->mem_idx])() 3786 #define op_eciwx() (*gen_op_eciwx[ctx->mem_idx])()
4241 #define op_ecowx() (*gen_op_ecowx[ctx->mem_idx])() 3787 #define op_ecowx() (*gen_op_ecowx[ctx->mem_idx])()
4242 -#if defined(CONFIG_USER_ONLY)  
4243 -/* User-mode only */  
4244 -static GenOpFunc *gen_op_eciwx[] = {  
4245 - &gen_op_eciwx_raw,  
4246 - &gen_op_eciwx_le_raw,  
4247 -#if defined(TARGET_PPC64)  
4248 - &gen_op_eciwx_64_raw,  
4249 - &gen_op_eciwx_le_64_raw,  
4250 -#endif 3788 +static GenOpFunc *gen_op_eciwx[NB_MEM_FUNCS] = {
  3789 + GEN_MEM_FUNCS(eciwx),
4251 }; 3790 };
4252 -static GenOpFunc *gen_op_ecowx[] = {  
4253 - &gen_op_ecowx_raw,  
4254 - &gen_op_ecowx_le_raw,  
4255 -#if defined(TARGET_PPC64)  
4256 - &gen_op_ecowx_64_raw,  
4257 - &gen_op_ecowx_le_64_raw,  
4258 -#endif 3791 +static GenOpFunc *gen_op_ecowx[NB_MEM_FUNCS] = {
  3792 + GEN_MEM_FUNCS(ecowx),
4259 }; 3793 };
4260 -#else  
4261 -#if defined(TARGET_PPC64)  
4262 -/* Full system - 64 bits mode */  
4263 -static GenOpFunc *gen_op_eciwx[] = {  
4264 - &gen_op_eciwx_user,  
4265 - &gen_op_eciwx_le_user,  
4266 - &gen_op_eciwx_64_user,  
4267 - &gen_op_eciwx_le_64_user,  
4268 - &gen_op_eciwx_kernel,  
4269 - &gen_op_eciwx_le_kernel,  
4270 - &gen_op_eciwx_64_kernel,  
4271 - &gen_op_eciwx_le_64_kernel,  
4272 -#if defined(TARGET_PPC64H)  
4273 - &gen_op_eciwx_hypv,  
4274 - &gen_op_eciwx_le_hypv,  
4275 - &gen_op_eciwx_64_hypv,  
4276 - &gen_op_eciwx_le_64_hypv,  
4277 -#endif  
4278 -};  
4279 -static GenOpFunc *gen_op_ecowx[] = {  
4280 - &gen_op_ecowx_user,  
4281 - &gen_op_ecowx_le_user,  
4282 - &gen_op_ecowx_64_user,  
4283 - &gen_op_ecowx_le_64_user,  
4284 - &gen_op_ecowx_kernel,  
4285 - &gen_op_ecowx_le_kernel,  
4286 - &gen_op_ecowx_64_kernel,  
4287 - &gen_op_ecowx_le_64_kernel,  
4288 -#if defined(TARGET_PPC64H)  
4289 - &gen_op_ecowx_hypv,  
4290 - &gen_op_ecowx_le_hypv,  
4291 - &gen_op_ecowx_64_hypv,  
4292 - &gen_op_ecowx_le_64_hypv,  
4293 -#endif  
4294 -};  
4295 -#else  
4296 -/* Full system - 32 bits mode */  
4297 -static GenOpFunc *gen_op_eciwx[] = {  
4298 - &gen_op_eciwx_user,  
4299 - &gen_op_eciwx_le_user,  
4300 - &gen_op_eciwx_kernel,  
4301 - &gen_op_eciwx_le_kernel,  
4302 -};  
4303 -static GenOpFunc *gen_op_ecowx[] = {  
4304 - &gen_op_ecowx_user,  
4305 - &gen_op_ecowx_le_user,  
4306 - &gen_op_ecowx_kernel,  
4307 - &gen_op_ecowx_le_kernel,  
4308 -};  
4309 -#endif  
4310 -#endif  
4311 3794
4312 /* eciwx */ 3795 /* eciwx */
4313 GEN_HANDLER(eciwx, 0x1F, 0x16, 0x0D, 0x00000001, PPC_EXTERN) 3796 GEN_HANDLER(eciwx, 0x1F, 0x16, 0x0D, 0x00000001, PPC_EXTERN)
@@ -4432,22 +3915,26 @@ GEN_HANDLER(dozi, 0x09, 0xFF, 0xFF, 0x00000000, PPC_POWER_BR) @@ -4432,22 +3915,26 @@ GEN_HANDLER(dozi, 0x09, 0xFF, 0xFF, 0x00000000, PPC_POWER_BR)
4432 gen_op_store_T0_gpr(rD(ctx->opcode)); 3915 gen_op_store_T0_gpr(rD(ctx->opcode));
4433 } 3916 }
4434 3917
4435 -/* As lscbx load from memory byte after byte, it's always endian safe */ 3918 +/* As lscbx load from memory byte after byte, it's always endian safe.
  3919 + * Original POWER is 32 bits only, define 64 bits ops as 32 bits ones
  3920 + */
4436 #define op_POWER_lscbx(start, ra, rb) \ 3921 #define op_POWER_lscbx(start, ra, rb) \
4437 (*gen_op_POWER_lscbx[ctx->mem_idx])(start, ra, rb) 3922 (*gen_op_POWER_lscbx[ctx->mem_idx])(start, ra, rb)
4438 -#if defined(CONFIG_USER_ONLY)  
4439 -static GenOpFunc3 *gen_op_POWER_lscbx[] = {  
4440 - &gen_op_POWER_lscbx_raw,  
4441 - &gen_op_POWER_lscbx_raw, 3923 +#define gen_op_POWER_lscbx_64_raw gen_op_POWER_lscbx_raw
  3924 +#define gen_op_POWER_lscbx_64_user gen_op_POWER_lscbx_user
  3925 +#define gen_op_POWER_lscbx_64_kernel gen_op_POWER_lscbx_kernel
  3926 +#define gen_op_POWER_lscbx_64_hypv gen_op_POWER_lscbx_hypv
  3927 +#define gen_op_POWER_lscbx_le_raw gen_op_POWER_lscbx_raw
  3928 +#define gen_op_POWER_lscbx_le_user gen_op_POWER_lscbx_user
  3929 +#define gen_op_POWER_lscbx_le_kernel gen_op_POWER_lscbx_kernel
  3930 +#define gen_op_POWER_lscbx_le_hypv gen_op_POWER_lscbx_hypv
  3931 +#define gen_op_POWER_lscbx_le_64_raw gen_op_POWER_lscbx_raw
  3932 +#define gen_op_POWER_lscbx_le_64_user gen_op_POWER_lscbx_user
  3933 +#define gen_op_POWER_lscbx_le_64_kernel gen_op_POWER_lscbx_kernel
  3934 +#define gen_op_POWER_lscbx_le_64_hypv gen_op_POWER_lscbx_hypv
  3935 +static GenOpFunc3 *gen_op_POWER_lscbx[NB_MEM_FUNCS] = {
  3936 + GEN_MEM_FUNCS(POWER_lscbx),
4442 }; 3937 };
4443 -#else  
4444 -static GenOpFunc3 *gen_op_POWER_lscbx[] = {  
4445 - &gen_op_POWER_lscbx_user,  
4446 - &gen_op_POWER_lscbx_user,  
4447 - &gen_op_POWER_lscbx_kernel,  
4448 - &gen_op_POWER_lscbx_kernel,  
4449 -};  
4450 -#endif  
4451 3938
4452 /* lscbx - lscbx. */ 3939 /* lscbx - lscbx. */
4453 GEN_HANDLER(lscbx, 0x1F, 0x15, 0x08, 0x00000000, PPC_POWER_BR) 3940 GEN_HANDLER(lscbx, 0x1F, 0x15, 0x08, 0x00000000, PPC_POWER_BR)
@@ -4901,31 +4388,31 @@ GEN_HANDLER(rfsvc, 0x13, 0x12, 0x02, 0x03FFF0001, PPC_POWER) @@ -4901,31 +4388,31 @@ GEN_HANDLER(rfsvc, 0x13, 0x12, 0x02, 0x03FFF0001, PPC_POWER)
4901 4388
4902 /* POWER2 specific instructions */ 4389 /* POWER2 specific instructions */
4903 /* Quad manipulation (load/store two floats at a time) */ 4390 /* Quad manipulation (load/store two floats at a time) */
  4391 +/* Original POWER2 is 32 bits only, define 64 bits ops as 32 bits ones */
4904 #define op_POWER2_lfq() (*gen_op_POWER2_lfq[ctx->mem_idx])() 4392 #define op_POWER2_lfq() (*gen_op_POWER2_lfq[ctx->mem_idx])()
4905 #define op_POWER2_stfq() (*gen_op_POWER2_stfq[ctx->mem_idx])() 4393 #define op_POWER2_stfq() (*gen_op_POWER2_stfq[ctx->mem_idx])()
4906 -#if defined(CONFIG_USER_ONLY)  
4907 -static GenOpFunc *gen_op_POWER2_lfq[] = {  
4908 - &gen_op_POWER2_lfq_le_raw,  
4909 - &gen_op_POWER2_lfq_raw,  
4910 -};  
4911 -static GenOpFunc *gen_op_POWER2_stfq[] = {  
4912 - &gen_op_POWER2_stfq_le_raw,  
4913 - &gen_op_POWER2_stfq_raw, 4394 +#define gen_op_POWER2_lfq_64_raw gen_op_POWER2_lfq_raw
  4395 +#define gen_op_POWER2_lfq_64_user gen_op_POWER2_lfq_user
  4396 +#define gen_op_POWER2_lfq_64_kernel gen_op_POWER2_lfq_kernel
  4397 +#define gen_op_POWER2_lfq_64_hypv gen_op_POWER2_lfq_hypv
  4398 +#define gen_op_POWER2_lfq_le_64_raw gen_op_POWER2_lfq_le_raw
  4399 +#define gen_op_POWER2_lfq_le_64_user gen_op_POWER2_lfq_le_user
  4400 +#define gen_op_POWER2_lfq_le_64_kernel gen_op_POWER2_lfq_le_kernel
  4401 +#define gen_op_POWER2_lfq_le_64_hypv gen_op_POWER2_lfq_le_hypv
  4402 +#define gen_op_POWER2_stfq_64_raw gen_op_POWER2_stfq_raw
  4403 +#define gen_op_POWER2_stfq_64_user gen_op_POWER2_stfq_user
  4404 +#define gen_op_POWER2_stfq_64_kernel gen_op_POWER2_stfq_kernel
  4405 +#define gen_op_POWER2_stfq_64_hypv gen_op_POWER2_stfq_hypv
  4406 +#define gen_op_POWER2_stfq_le_64_raw gen_op_POWER2_stfq_le_raw
  4407 +#define gen_op_POWER2_stfq_le_64_user gen_op_POWER2_stfq_le_user
  4408 +#define gen_op_POWER2_stfq_le_64_kernel gen_op_POWER2_stfq_le_kernel
  4409 +#define gen_op_POWER2_stfq_le_64_hypv gen_op_POWER2_stfq_le_hypv
  4410 +static GenOpFunc *gen_op_POWER2_lfq[NB_MEM_FUNCS] = {
  4411 + GEN_MEM_FUNCS(POWER2_lfq),
4914 }; 4412 };
4915 -#else  
4916 -static GenOpFunc *gen_op_POWER2_lfq[] = {  
4917 - &gen_op_POWER2_lfq_le_user,  
4918 - &gen_op_POWER2_lfq_user,  
4919 - &gen_op_POWER2_lfq_le_kernel,  
4920 - &gen_op_POWER2_lfq_kernel, 4413 +static GenOpFunc *gen_op_POWER2_stfq[NB_MEM_FUNCS] = {
  4414 + GEN_MEM_FUNCS(POWER2_stfq),
4921 }; 4415 };
4922 -static GenOpFunc *gen_op_POWER2_stfq[] = {  
4923 - &gen_op_POWER2_stfq_le_user,  
4924 - &gen_op_POWER2_stfq_user,  
4925 - &gen_op_POWER2_stfq_le_kernel,  
4926 - &gen_op_POWER2_stfq_kernel,  
4927 -};  
4928 -#endif  
4929 4416
4930 /* lfq */ 4417 /* lfq */
4931 GEN_HANDLER(lfq, 0x38, 0xFF, 0xFF, 0x00000003, PPC_POWER2) 4418 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); @@ -5687,111 +5174,14 @@ GEN32(gen_op_store_A2_avr, gen_op_store_A2_avr_avr);
5687 #endif 5174 #endif
5688 5175
5689 #define op_vr_ldst(name) (*gen_op_##name[ctx->mem_idx])() 5176 #define op_vr_ldst(name) (*gen_op_##name[ctx->mem_idx])()
5690 -#if defined(CONFIG_USER_ONLY)  
5691 -#if defined(TARGET_PPC64)  
5692 -/* User-mode only - 64 bits mode */  
5693 -#define OP_VR_LD_TABLE(name) \  
5694 -static GenOpFunc *gen_op_vr_l##name[] = { \  
5695 - &gen_op_vr_l##name##_raw, \  
5696 - &gen_op_vr_l##name##_le_raw, \  
5697 - &gen_op_vr_l##name##_64_raw, \  
5698 - &gen_op_vr_l##name##_le_64_raw, \  
5699 -};  
5700 -#define OP_VR_ST_TABLE(name) \  
5701 -static GenOpFunc *gen_op_vr_st##name[] = { \  
5702 - &gen_op_vr_st##name##_raw, \  
5703 - &gen_op_vr_st##name##_le_raw, \  
5704 - &gen_op_vr_st##name##_64_raw, \  
5705 - &gen_op_vr_st##name##_le_64_raw, \  
5706 -};  
5707 -#else /* defined(TARGET_PPC64) */  
5708 -/* User-mode only - 32 bits mode */  
5709 -#define OP_VR_LD_TABLE(name) \  
5710 -static GenOpFunc *gen_op_vr_l##name[] = { \  
5711 - &gen_op_vr_l##name##_raw, \  
5712 - &gen_op_vr_l##name##_le_raw, \  
5713 -};  
5714 -#define OP_VR_ST_TABLE(name) \  
5715 -static GenOpFunc *gen_op_vr_st##name[] = { \  
5716 - &gen_op_vr_st##name##_raw, \  
5717 - &gen_op_vr_st##name##_le_raw, \  
5718 -};  
5719 -#endif /* defined(TARGET_PPC64) */  
5720 -#else /* defined(CONFIG_USER_ONLY) */  
5721 -#if defined(TARGET_PPC64H)  
5722 -/* Full system with hypervisor mode */  
5723 -#define OP_VR_LD_TABLE(name) \  
5724 -static GenOpFunc *gen_op_vr_l##name[] = { \  
5725 - &gen_op_vr_l##name##_user, \  
5726 - &gen_op_vr_l##name##_le_user, \  
5727 - &gen_op_vr_l##name##_64_user, \  
5728 - &gen_op_vr_l##name##_le_64_user, \  
5729 - &gen_op_vr_l##name##_kernel, \  
5730 - &gen_op_vr_l##name##_le_kernel, \  
5731 - &gen_op_vr_l##name##_64_kernel, \  
5732 - &gen_op_vr_l##name##_le_64_kernel, \  
5733 - &gen_op_vr_l##name##_hypv, \  
5734 - &gen_op_vr_l##name##_le_hypv, \  
5735 - &gen_op_vr_l##name##_64_hypv, \  
5736 - &gen_op_vr_l##name##_le_64_hypv, \  
5737 -};  
5738 -#define OP_VR_ST_TABLE(name) \  
5739 -static GenOpFunc *gen_op_vr_st##name[] = { \  
5740 - &gen_op_vr_st##name##_user, \  
5741 - &gen_op_vr_st##name##_le_user, \  
5742 - &gen_op_vr_st##name##_64_user, \  
5743 - &gen_op_vr_st##name##_le_64_user, \  
5744 - &gen_op_vr_st##name##_kernel, \  
5745 - &gen_op_vr_st##name##_le_kernel, \  
5746 - &gen_op_vr_st##name##_64_kernel, \  
5747 - &gen_op_vr_st##name##_le_64_kernel, \  
5748 - &gen_op_vr_st##name##_hypv, \  
5749 - &gen_op_vr_st##name##_le_hypv, \  
5750 - &gen_op_vr_st##name##_64_hypv, \  
5751 - &gen_op_vr_st##name##_le_64_hypv, \  
5752 -};  
5753 -#elif defined(TARGET_PPC64)  
5754 -/* Full system - 64 bits mode */  
5755 #define OP_VR_LD_TABLE(name) \ 5177 #define OP_VR_LD_TABLE(name) \
5756 -static GenOpFunc *gen_op_vr_l##name[] = { \  
5757 - &gen_op_vr_l##name##_user, \  
5758 - &gen_op_vr_l##name##_le_user, \  
5759 - &gen_op_vr_l##name##_64_user, \  
5760 - &gen_op_vr_l##name##_le_64_user, \  
5761 - &gen_op_vr_l##name##_kernel, \  
5762 - &gen_op_vr_l##name##_le_kernel, \  
5763 - &gen_op_vr_l##name##_64_kernel, \  
5764 - &gen_op_vr_l##name##_le_64_kernel, \ 5178 +static GenOpFunc *gen_op_vr_l##name[NB_MEM_FUNCS] = { \
  5179 + GEN_MEM_FUNCS(vr_l##name), \
5765 }; 5180 };
5766 #define OP_VR_ST_TABLE(name) \ 5181 #define OP_VR_ST_TABLE(name) \
5767 -static GenOpFunc *gen_op_vr_st##name[] = { \  
5768 - &gen_op_vr_st##name##_user, \  
5769 - &gen_op_vr_st##name##_le_user, \  
5770 - &gen_op_vr_st##name##_64_user, \  
5771 - &gen_op_vr_st##name##_le_64_user, \  
5772 - &gen_op_vr_st##name##_kernel, \  
5773 - &gen_op_vr_st##name##_le_kernel, \  
5774 - &gen_op_vr_st##name##_64_kernel, \  
5775 - &gen_op_vr_st##name##_le_64_kernel, \ 5182 +static GenOpFunc *gen_op_vr_st##name[NB_MEM_FUNCS] = { \
  5183 + GEN_MEM_FUNCS(vr_st##name), \
5776 }; 5184 };
5777 -#else /* defined(TARGET_PPC64) */  
5778 -/* Full system - 32 bits mode */  
5779 -#define OP_VR_LD_TABLE(name) \  
5780 -static GenOpFunc *gen_op_vr_l##name[] = { \  
5781 - &gen_op_vr_l##name##_user, \  
5782 - &gen_op_vr_l##name##_le_user, \  
5783 - &gen_op_vr_l##name##_kernel, \  
5784 - &gen_op_vr_l##name##_le_kernel, \  
5785 -};  
5786 -#define OP_VR_ST_TABLE(name) \  
5787 -static GenOpFunc *gen_op_vr_st##name[] = { \  
5788 - &gen_op_vr_st##name##_user, \  
5789 - &gen_op_vr_st##name##_le_user, \  
5790 - &gen_op_vr_st##name##_kernel, \  
5791 - &gen_op_vr_st##name##_le_kernel, \  
5792 -};  
5793 -#endif /* defined(TARGET_PPC64) */  
5794 -#endif /* defined(CONFIG_USER_ONLY) */  
5795 5185
5796 #define GEN_VR_LDX(name, opc2, opc3) \ 5186 #define GEN_VR_LDX(name, opc2, opc3) \
5797 GEN_HANDLER(l##name, 0x1F, opc2, opc3, 0x00000001, PPC_ALTIVEC) \ 5187 GEN_HANDLER(l##name, 0x1F, opc2, opc3, 0x00000001, PPC_ALTIVEC) \
@@ -5830,7 +5220,6 @@ GEN_VR_STX(vx, 0x07, 0x07); @@ -5830,7 +5220,6 @@ GEN_VR_STX(vx, 0x07, 0x07);
5830 GEN_VR_STX(vxl, 0x07, 0x0F); 5220 GEN_VR_STX(vxl, 0x07, 0x0F);
5831 5221
5832 /*** SPE extension ***/ 5222 /*** SPE extension ***/
5833 -  
5834 /* Register moves */ 5223 /* Register moves */
5835 #if !defined(TARGET_PPC64) 5224 #if !defined(TARGET_PPC64)
5836 5225
@@ -5893,111 +5282,14 @@ static always_inline void gen_addr_spe_imm_index (DisasContext *ctx, int sh) @@ -5893,111 +5282,14 @@ static always_inline void gen_addr_spe_imm_index (DisasContext *ctx, int sh)
5893 } 5282 }
5894 5283
5895 #define op_spe_ldst(name) (*gen_op_##name[ctx->mem_idx])() 5284 #define op_spe_ldst(name) (*gen_op_##name[ctx->mem_idx])()
5896 -#if defined(CONFIG_USER_ONLY)  
5897 -#if defined(TARGET_PPC64)  
5898 -/* User-mode only - 64 bits mode */  
5899 -#define OP_SPE_LD_TABLE(name) \  
5900 -static GenOpFunc *gen_op_spe_l##name[] = { \  
5901 - &gen_op_spe_l##name##_raw, \  
5902 - &gen_op_spe_l##name##_le_raw, \  
5903 - &gen_op_spe_l##name##_64_raw, \  
5904 - &gen_op_spe_l##name##_le_64_raw, \  
5905 -};  
5906 -#define OP_SPE_ST_TABLE(name) \  
5907 -static GenOpFunc *gen_op_spe_st##name[] = { \  
5908 - &gen_op_spe_st##name##_raw, \  
5909 - &gen_op_spe_st##name##_le_raw, \  
5910 - &gen_op_spe_st##name##_64_raw, \  
5911 - &gen_op_spe_st##name##_le_64_raw, \  
5912 -};  
5913 -#else /* defined(TARGET_PPC64) */  
5914 -/* User-mode only - 32 bits mode */  
5915 -#define OP_SPE_LD_TABLE(name) \  
5916 -static GenOpFunc *gen_op_spe_l##name[] = { \  
5917 - &gen_op_spe_l##name##_raw, \  
5918 - &gen_op_spe_l##name##_le_raw, \  
5919 -};  
5920 -#define OP_SPE_ST_TABLE(name) \  
5921 -static GenOpFunc *gen_op_spe_st##name[] = { \  
5922 - &gen_op_spe_st##name##_raw, \  
5923 - &gen_op_spe_st##name##_le_raw, \  
5924 -};  
5925 -#endif /* defined(TARGET_PPC64) */  
5926 -#else /* defined(CONFIG_USER_ONLY) */  
5927 -#if defined(TARGET_PPC64H)  
5928 -/* Full system with hypervisor mode */  
5929 #define OP_SPE_LD_TABLE(name) \ 5285 #define OP_SPE_LD_TABLE(name) \
5930 -static GenOpFunc *gen_op_spe_l##name[] = { \  
5931 - &gen_op_spe_l##name##_user, \  
5932 - &gen_op_spe_l##name##_le_user, \  
5933 - &gen_op_spe_l##name##_64_user, \  
5934 - &gen_op_spe_l##name##_le_64_user, \  
5935 - &gen_op_spe_l##name##_kernel, \  
5936 - &gen_op_spe_l##name##_le_kernel, \  
5937 - &gen_op_spe_l##name##_64_kernel, \  
5938 - &gen_op_spe_l##name##_le_64_kernel, \  
5939 - &gen_op_spe_l##name##_hypv, \  
5940 - &gen_op_spe_l##name##_le_hypv, \  
5941 - &gen_op_spe_l##name##_64_hypv, \  
5942 - &gen_op_spe_l##name##_le_64_hypv, \ 5286 +static GenOpFunc *gen_op_spe_l##name[NB_MEM_FUNCS] = { \
  5287 + GEN_MEM_FUNCS(spe_l##name), \
5943 }; 5288 };
5944 #define OP_SPE_ST_TABLE(name) \ 5289 #define OP_SPE_ST_TABLE(name) \
5945 -static GenOpFunc *gen_op_spe_st##name[] = { \  
5946 - &gen_op_spe_st##name##_user, \  
5947 - &gen_op_spe_st##name##_le_user, \  
5948 - &gen_op_spe_st##name##_64_user, \  
5949 - &gen_op_spe_st##name##_le_64_user, \  
5950 - &gen_op_spe_st##name##_kernel, \  
5951 - &gen_op_spe_st##name##_le_kernel, \  
5952 - &gen_op_spe_st##name##_64_kernel, \  
5953 - &gen_op_spe_st##name##_le_64_kernel, \  
5954 - &gen_op_spe_st##name##_hypv, \  
5955 - &gen_op_spe_st##name##_le_hypv, \  
5956 - &gen_op_spe_st##name##_64_hypv, \  
5957 - &gen_op_spe_st##name##_le_64_hypv, \  
5958 -};  
5959 -#elif defined(TARGET_PPC64)  
5960 -/* Full system - 64 bits mode */  
5961 -#define OP_SPE_LD_TABLE(name) \  
5962 -static GenOpFunc *gen_op_spe_l##name[] = { \  
5963 - &gen_op_spe_l##name##_user, \  
5964 - &gen_op_spe_l##name##_le_user, \  
5965 - &gen_op_spe_l##name##_64_user, \  
5966 - &gen_op_spe_l##name##_le_64_user, \  
5967 - &gen_op_spe_l##name##_kernel, \  
5968 - &gen_op_spe_l##name##_le_kernel, \  
5969 - &gen_op_spe_l##name##_64_kernel, \  
5970 - &gen_op_spe_l##name##_le_64_kernel, \ 5290 +static GenOpFunc *gen_op_spe_st##name[NB_MEM_FUNCS] = { \
  5291 + GEN_MEM_FUNCS(spe_st##name), \
5971 }; 5292 };
5972 -#define OP_SPE_ST_TABLE(name) \  
5973 -static GenOpFunc *gen_op_spe_st##name[] = { \  
5974 - &gen_op_spe_st##name##_user, \  
5975 - &gen_op_spe_st##name##_le_user, \  
5976 - &gen_op_spe_st##name##_64_user, \  
5977 - &gen_op_spe_st##name##_le_64_user, \  
5978 - &gen_op_spe_st##name##_kernel, \  
5979 - &gen_op_spe_st##name##_le_kernel, \  
5980 - &gen_op_spe_st##name##_64_kernel, \  
5981 - &gen_op_spe_st##name##_le_64_kernel, \  
5982 -};  
5983 -#else /* defined(TARGET_PPC64) */  
5984 -/* Full system - 32 bits mode */  
5985 -#define OP_SPE_LD_TABLE(name) \  
5986 -static GenOpFunc *gen_op_spe_l##name[] = { \  
5987 - &gen_op_spe_l##name##_user, \  
5988 - &gen_op_spe_l##name##_le_user, \  
5989 - &gen_op_spe_l##name##_kernel, \  
5990 - &gen_op_spe_l##name##_le_kernel, \  
5991 -};  
5992 -#define OP_SPE_ST_TABLE(name) \  
5993 -static GenOpFunc *gen_op_spe_st##name[] = { \  
5994 - &gen_op_spe_st##name##_user, \  
5995 - &gen_op_spe_st##name##_le_user, \  
5996 - &gen_op_spe_st##name##_kernel, \  
5997 - &gen_op_spe_st##name##_le_kernel, \  
5998 -};  
5999 -#endif /* defined(TARGET_PPC64) */  
6000 -#endif /* defined(CONFIG_USER_ONLY) */  
6001 5293
6002 #define GEN_SPE_LD(name, sh) \ 5294 #define GEN_SPE_LD(name, sh) \
6003 static always_inline void gen_evl##name (DisasContext *ctx) \ 5295 static always_inline void gen_evl##name (DisasContext *ctx) \
@@ -6258,45 +5550,38 @@ GEN_HANDLER2(evsel3, "evsel", 0x04, 0x1f, 0x09, 0x00000000, PPC_SPE) @@ -6258,45 +5550,38 @@ GEN_HANDLER2(evsel3, "evsel", 0x04, 0x1f, 0x09, 0x00000000, PPC_SPE)
6258 /* In that case, we already have 64 bits load & stores 5550 /* In that case, we already have 64 bits load & stores
6259 * so, spe_ldd is equivalent to ld and spe_std is equivalent to std 5551 * so, spe_ldd is equivalent to ld and spe_std is equivalent to std
6260 */ 5552 */
6261 -#if defined(CONFIG_USER_ONLY)  
6262 -#define gen_op_spe_ldd_raw gen_op_ld_raw  
6263 -#define gen_op_spe_ldd_64_raw gen_op_ld_64_raw  
6264 -#define gen_op_spe_ldd_le_raw gen_op_ld_le_raw  
6265 -#define gen_op_spe_ldd_le_64_raw gen_op_ld_le_64_raw  
6266 -#define gen_op_spe_stdd_raw gen_op_ld_raw  
6267 -#define gen_op_spe_stdd_64_raw gen_op_std_64_raw  
6268 -#define gen_op_spe_stdd_le_raw gen_op_std_le_raw  
6269 -#define gen_op_spe_stdd_le_64_raw gen_op_std_le_64_raw  
6270 -#else /* defined(CONFIG_USER_ONLY) */  
6271 -#if defined(TARGET_PPC64H)  
6272 -#define gen_op_spe_ldd_hypv gen_op_ld_hypv  
6273 -#define gen_op_spe_ldd_64_hypv gen_op_ld_64_hypv  
6274 -#define gen_op_spe_ldd_le_hypv gen_op_ld_hypv  
6275 -#define gen_op_spe_ldd_le_64_hypv gen_op_ld_64_hypv  
6276 -#endif  
6277 -#define gen_op_spe_ldd_kernel gen_op_ld_kernel  
6278 -#define gen_op_spe_ldd_64_kernel gen_op_ld_64_kernel  
6279 -#define gen_op_spe_ldd_le_kernel gen_op_ld_kernel  
6280 -#define gen_op_spe_ldd_le_64_kernel gen_op_ld_64_kernel  
6281 -#define gen_op_spe_ldd_user gen_op_ld_user  
6282 -#define gen_op_spe_ldd_64_user gen_op_ld_64_user  
6283 -#define gen_op_spe_ldd_le_user gen_op_ld_le_user  
6284 -#define gen_op_spe_ldd_le_64_user gen_op_ld_le_64_user  
6285 -#if defined(TARGET_PPC64H)  
6286 -#define gen_op_spe_stdd_hypv gen_op_std_hypv  
6287 -#define gen_op_spe_stdd_64_hypv gen_op_std_64_hypv  
6288 -#define gen_op_spe_stdd_le_hypv gen_op_std_hypv  
6289 -#define gen_op_spe_stdd_le_64_hypv gen_op_std_64_hypv  
6290 -#endif  
6291 -#define gen_op_spe_stdd_kernel gen_op_std_kernel  
6292 -#define gen_op_spe_stdd_64_kernel gen_op_std_64_kernel  
6293 -#define gen_op_spe_stdd_le_kernel gen_op_std_kernel  
6294 -#define gen_op_spe_stdd_le_64_kernel gen_op_std_64_kernel  
6295 -#define gen_op_spe_stdd_user gen_op_std_user  
6296 -#define gen_op_spe_stdd_64_user gen_op_std_64_user  
6297 -#define gen_op_spe_stdd_le_user gen_op_std_le_user  
6298 -#define gen_op_spe_stdd_le_64_user gen_op_std_le_64_user  
6299 -#endif /* defined(CONFIG_USER_ONLY) */ 5553 +#define gen_op_spe_ldd_raw gen_op_ld_raw
  5554 +#define gen_op_spe_ldd_user gen_op_ld_user
  5555 +#define gen_op_spe_ldd_kernel gen_op_ld_kernel
  5556 +#define gen_op_spe_ldd_hypv gen_op_ld_hypv
  5557 +#define gen_op_spe_ldd_64_raw gen_op_ld_64_raw
  5558 +#define gen_op_spe_ldd_64_user gen_op_ld_64_user
  5559 +#define gen_op_spe_ldd_64_kernel gen_op_ld_64_kernel
  5560 +#define gen_op_spe_ldd_64_hypv gen_op_ld_64_hypv
  5561 +#define gen_op_spe_ldd_le_raw gen_op_ld_le_raw
  5562 +#define gen_op_spe_ldd_le_user gen_op_ld_le_user
  5563 +#define gen_op_spe_ldd_le_kernel gen_op_ld_le_kernel
  5564 +#define gen_op_spe_ldd_le_hypv gen_op_ld_le_hypv
  5565 +#define gen_op_spe_ldd_le_64_raw gen_op_ld_le_64_raw
  5566 +#define gen_op_spe_ldd_le_64_user gen_op_ld_le_64_user
  5567 +#define gen_op_spe_ldd_le_64_kernel gen_op_ld_le_64_kernel
  5568 +#define gen_op_spe_ldd_le_64_hypv gen_op_ld_le_64_hypv
  5569 +#define gen_op_spe_stdd_raw gen_op_std_raw
  5570 +#define gen_op_spe_stdd_user gen_op_std_user
  5571 +#define gen_op_spe_stdd_kernel gen_op_std_kernel
  5572 +#define gen_op_spe_stdd_hypv gen_op_std_hypv
  5573 +#define gen_op_spe_stdd_64_raw gen_op_std_64_raw
  5574 +#define gen_op_spe_stdd_64_user gen_op_std_64_user
  5575 +#define gen_op_spe_stdd_64_kernel gen_op_std_64_kernel
  5576 +#define gen_op_spe_stdd_64_hypv gen_op_std_64_hypv
  5577 +#define gen_op_spe_stdd_le_raw gen_op_std_le_raw
  5578 +#define gen_op_spe_stdd_le_user gen_op_std_le_user
  5579 +#define gen_op_spe_stdd_le_kernel gen_op_std_le_kernel
  5580 +#define gen_op_spe_stdd_le_hypv gen_op_std_le_hypv
  5581 +#define gen_op_spe_stdd_le_64_raw gen_op_std_le_64_raw
  5582 +#define gen_op_spe_stdd_le_64_user gen_op_std_le_64_user
  5583 +#define gen_op_spe_stdd_le_64_kernel gen_op_std_le_64_kernel
  5584 +#define gen_op_spe_stdd_le_64_hypv gen_op_std_le_64_hypv
6300 #endif /* defined(TARGET_PPC64) */ 5585 #endif /* defined(TARGET_PPC64) */
6301 GEN_SPEOP_LDST(dd, 3); 5586 GEN_SPEOP_LDST(dd, 3);
6302 GEN_SPEOP_LDST(dw, 3); 5587 GEN_SPEOP_LDST(dw, 3);
@@ -6308,27 +5593,22 @@ GEN_SPEOP_ST(who, 2); @@ -6308,27 +5593,22 @@ GEN_SPEOP_ST(who, 2);
6308 5593
6309 #if defined(TARGET_PPC64) 5594 #if defined(TARGET_PPC64)
6310 /* In that case, spe_stwwo is equivalent to stw */ 5595 /* In that case, spe_stwwo is equivalent to stw */
6311 -#if defined(CONFIG_USER_ONLY)  
6312 -#define gen_op_spe_stwwo_raw gen_op_stw_raw  
6313 -#define gen_op_spe_stwwo_le_raw gen_op_stw_le_raw  
6314 -#define gen_op_spe_stwwo_64_raw gen_op_stw_64_raw  
6315 -#define gen_op_spe_stwwo_le_64_raw gen_op_stw_le_64_raw  
6316 -#else  
6317 -#define gen_op_spe_stwwo_user gen_op_stw_user  
6318 -#define gen_op_spe_stwwo_le_user gen_op_stw_le_user  
6319 -#define gen_op_spe_stwwo_64_user gen_op_stw_64_user  
6320 -#define gen_op_spe_stwwo_le_64_user gen_op_stw_le_64_user  
6321 -#define gen_op_spe_stwwo_kernel gen_op_stw_kernel  
6322 -#define gen_op_spe_stwwo_le_kernel gen_op_stw_le_kernel  
6323 -#define gen_op_spe_stwwo_64_kernel gen_op_stw_64_kernel 5596 +#define gen_op_spe_stwwo_raw gen_op_stw_raw
  5597 +#define gen_op_spe_stwwo_user gen_op_stw_user
  5598 +#define gen_op_spe_stwwo_kernel gen_op_stw_kernel
  5599 +#define gen_op_spe_stwwo_hypv gen_op_stw_hypv
  5600 +#define gen_op_spe_stwwo_le_raw gen_op_stw_le_raw
  5601 +#define gen_op_spe_stwwo_le_user gen_op_stw_le_user
  5602 +#define gen_op_spe_stwwo_le_kernel gen_op_stw_le_kernel
  5603 +#define gen_op_spe_stwwo_le_hypv gen_op_stw_le_hypv
  5604 +#define gen_op_spe_stwwo_64_raw gen_op_stw_64_raw
  5605 +#define gen_op_spe_stwwo_64_user gen_op_stw_64_user
  5606 +#define gen_op_spe_stwwo_64_kernel gen_op_stw_64_kernel
  5607 +#define gen_op_spe_stwwo_64_hypv gen_op_stw_64_hypv
  5608 +#define gen_op_spe_stwwo_le_64_raw gen_op_stw_le_64_raw
  5609 +#define gen_op_spe_stwwo_le_64_user gen_op_stw_le_64_user
6324 #define gen_op_spe_stwwo_le_64_kernel gen_op_stw_le_64_kernel 5610 #define gen_op_spe_stwwo_le_64_kernel gen_op_stw_le_64_kernel
6325 -#if defined(TARGET_PPC64H)  
6326 -#define gen_op_spe_stwwo_hypv gen_op_stw_hypv  
6327 -#define gen_op_spe_stwwo_le_hypv gen_op_stw_le_hypv  
6328 -#define gen_op_spe_stwwo_64_hypv gen_op_stw_64_hypv  
6329 -#define gen_op_spe_stwwo_le_64_hypv gen_op_stw_le_64_hypv  
6330 -#endif  
6331 -#endif 5611 +#define gen_op_spe_stwwo_le_64_hypv gen_op_stw_le_64_hypv
6332 #endif 5612 #endif
6333 #define _GEN_OP_SPE_STWWE(suffix) \ 5613 #define _GEN_OP_SPE_STWWE(suffix) \
6334 static always_inline void gen_op_spe_stwwe_##suffix (void) \ 5614 static always_inline void gen_op_spe_stwwe_##suffix (void) \
@@ -6364,11 +5644,9 @@ _GEN_OP_SPE_STWWE_LE(suffix) @@ -6364,11 +5644,9 @@ _GEN_OP_SPE_STWWE_LE(suffix)
6364 #if defined(CONFIG_USER_ONLY) 5644 #if defined(CONFIG_USER_ONLY)
6365 GEN_OP_SPE_STWWE(raw); 5645 GEN_OP_SPE_STWWE(raw);
6366 #else /* defined(CONFIG_USER_ONLY) */ 5646 #else /* defined(CONFIG_USER_ONLY) */
6367 -#if defined(TARGET_PPC64H)  
6368 -GEN_OP_SPE_STWWE(hypv);  
6369 -#endif  
6370 -GEN_OP_SPE_STWWE(kernel);  
6371 GEN_OP_SPE_STWWE(user); 5647 GEN_OP_SPE_STWWE(user);
  5648 +GEN_OP_SPE_STWWE(kernel);
  5649 +GEN_OP_SPE_STWWE(hypv);
6372 #endif /* defined(CONFIG_USER_ONLY) */ 5650 #endif /* defined(CONFIG_USER_ONLY) */
6373 GEN_SPEOP_ST(wwe, 2); 5651 GEN_SPEOP_ST(wwe, 2);
6374 GEN_SPEOP_ST(wwo, 2); 5652 GEN_SPEOP_ST(wwo, 2);
@@ -6418,107 +5696,67 @@ GEN_OP_SPE_LHX(le_64_raw); @@ -6418,107 +5696,67 @@ GEN_OP_SPE_LHX(le_64_raw);
6418 GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_64_raw); 5696 GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_64_raw);
6419 #endif 5697 #endif
6420 #else 5698 #else
6421 -#if defined(TARGET_PPC64H)  
6422 -GEN_OP_SPE_LHE(hypv);  
6423 -#endif  
6424 -GEN_OP_SPE_LHE(kernel);  
6425 GEN_OP_SPE_LHE(user); 5699 GEN_OP_SPE_LHE(user);
6426 -#if defined(TARGET_PPC64H)  
6427 -GEN_SPE_LDSPLAT(hhesplat, spe_lhe, hypv);  
6428 -#endif  
6429 -GEN_SPE_LDSPLAT(hhesplat, spe_lhe, kernel); 5700 +GEN_OP_SPE_LHE(kernel);
  5701 +GEN_OP_SPE_LHE(hypv);
6430 GEN_SPE_LDSPLAT(hhesplat, spe_lhe, user); 5702 GEN_SPE_LDSPLAT(hhesplat, spe_lhe, user);
6431 -#if defined(TARGET_PPC64H)  
6432 -GEN_OP_SPE_LHE(le_hypv);  
6433 -#endif  
6434 -GEN_OP_SPE_LHE(le_kernel); 5703 +GEN_SPE_LDSPLAT(hhesplat, spe_lhe, kernel);
  5704 +GEN_SPE_LDSPLAT(hhesplat, spe_lhe, hypv);
6435 GEN_OP_SPE_LHE(le_user); 5705 GEN_OP_SPE_LHE(le_user);
6436 -#if defined(TARGET_PPC64H)  
6437 -GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_hypv);  
6438 -#endif  
6439 -GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_kernel); 5706 +GEN_OP_SPE_LHE(le_kernel);
  5707 +GEN_OP_SPE_LHE(le_hypv);
6440 GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_user); 5708 GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_user);
6441 -#if defined(TARGET_PPC64H)  
6442 -GEN_SPE_LDSPLAT(hhousplat, spe_lh, hypv);  
6443 -#endif  
6444 -GEN_SPE_LDSPLAT(hhousplat, spe_lh, kernel); 5709 +GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_kernel);
  5710 +GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_hypv);
6445 GEN_SPE_LDSPLAT(hhousplat, spe_lh, user); 5711 GEN_SPE_LDSPLAT(hhousplat, spe_lh, user);
6446 -#if defined(TARGET_PPC64H)  
6447 -GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_hypv);  
6448 -#endif  
6449 -GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_kernel); 5712 +GEN_SPE_LDSPLAT(hhousplat, spe_lh, kernel);
  5713 +GEN_SPE_LDSPLAT(hhousplat, spe_lh, hypv);
6450 GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_user); 5714 GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_user);
6451 -#if defined(TARGET_PPC64H)  
6452 -GEN_OP_SPE_LHX(hypv);  
6453 -#endif  
6454 -GEN_OP_SPE_LHX(kernel); 5715 +GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_kernel);
  5716 +GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_hypv);
6455 GEN_OP_SPE_LHX(user); 5717 GEN_OP_SPE_LHX(user);
6456 -#if defined(TARGET_PPC64H)  
6457 -GEN_SPE_LDSPLAT(hhossplat, spe_lhx, hypv);  
6458 -#endif  
6459 -GEN_SPE_LDSPLAT(hhossplat, spe_lhx, kernel); 5718 +GEN_OP_SPE_LHX(kernel);
  5719 +GEN_OP_SPE_LHX(hypv);
6460 GEN_SPE_LDSPLAT(hhossplat, spe_lhx, user); 5720 GEN_SPE_LDSPLAT(hhossplat, spe_lhx, user);
6461 -#if defined(TARGET_PPC64H)  
6462 -GEN_OP_SPE_LHX(le_hypv);  
6463 -#endif  
6464 -GEN_OP_SPE_LHX(le_kernel); 5721 +GEN_SPE_LDSPLAT(hhossplat, spe_lhx, kernel);
  5722 +GEN_SPE_LDSPLAT(hhossplat, spe_lhx, hypv);
6465 GEN_OP_SPE_LHX(le_user); 5723 GEN_OP_SPE_LHX(le_user);
6466 -#if defined(TARGET_PPC64H)  
6467 -GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_hypv);  
6468 -#endif  
6469 -GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_kernel); 5724 +GEN_OP_SPE_LHX(le_kernel);
  5725 +GEN_OP_SPE_LHX(le_hypv);
6470 GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_user); 5726 GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_user);
  5727 +GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_kernel);
  5728 +GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_hypv);
6471 #if defined(TARGET_PPC64) 5729 #if defined(TARGET_PPC64)
6472 -#if defined(TARGET_PPC64H)  
6473 -GEN_OP_SPE_LHE(64_hypv);  
6474 -#endif  
6475 -GEN_OP_SPE_LHE(64_kernel);  
6476 GEN_OP_SPE_LHE(64_user); 5730 GEN_OP_SPE_LHE(64_user);
6477 -#if defined(TARGET_PPC64H)  
6478 -GEN_SPE_LDSPLAT(hhesplat, spe_lhe, 64_hypv);  
6479 -#endif  
6480 -GEN_SPE_LDSPLAT(hhesplat, spe_lhe, 64_kernel); 5731 +GEN_OP_SPE_LHE(64_kernel);
  5732 +GEN_OP_SPE_LHE(64_hypv);
6481 GEN_SPE_LDSPLAT(hhesplat, spe_lhe, 64_user); 5733 GEN_SPE_LDSPLAT(hhesplat, spe_lhe, 64_user);
6482 -#if defined(TARGET_PPC64H)  
6483 -GEN_OP_SPE_LHE(le_64_hypv);  
6484 -#endif  
6485 -GEN_OP_SPE_LHE(le_64_kernel); 5734 +GEN_SPE_LDSPLAT(hhesplat, spe_lhe, 64_kernel);
  5735 +GEN_SPE_LDSPLAT(hhesplat, spe_lhe, 64_hypv);
6486 GEN_OP_SPE_LHE(le_64_user); 5736 GEN_OP_SPE_LHE(le_64_user);
6487 -#if defined(TARGET_PPC64H)  
6488 -GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_64_hypv);  
6489 -#endif  
6490 -GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_64_kernel); 5737 +GEN_OP_SPE_LHE(le_64_kernel);
  5738 +GEN_OP_SPE_LHE(le_64_hypv);
6491 GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_64_user); 5739 GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_64_user);
6492 -#if defined(TARGET_PPC64H)  
6493 -GEN_SPE_LDSPLAT(hhousplat, spe_lh, 64_hypv);  
6494 -#endif  
6495 -GEN_SPE_LDSPLAT(hhousplat, spe_lh, 64_kernel); 5740 +GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_64_kernel);
  5741 +GEN_SPE_LDSPLAT(hhesplat, spe_lhe, le_64_hypv);
6496 GEN_SPE_LDSPLAT(hhousplat, spe_lh, 64_user); 5742 GEN_SPE_LDSPLAT(hhousplat, spe_lh, 64_user);
6497 -#if defined(TARGET_PPC64H)  
6498 -GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_64_hypv);  
6499 -#endif  
6500 -GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_64_kernel); 5743 +GEN_SPE_LDSPLAT(hhousplat, spe_lh, 64_kernel);
  5744 +GEN_SPE_LDSPLAT(hhousplat, spe_lh, 64_hypv);
6501 GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_64_user); 5745 GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_64_user);
6502 -#if defined(TARGET_PPC64H)  
6503 -GEN_OP_SPE_LHX(64_hypv);  
6504 -#endif  
6505 -GEN_OP_SPE_LHX(64_kernel); 5746 +GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_64_kernel);
  5747 +GEN_SPE_LDSPLAT(hhousplat, spe_lh, le_64_hypv);
6506 GEN_OP_SPE_LHX(64_user); 5748 GEN_OP_SPE_LHX(64_user);
6507 -#if defined(TARGET_PPC64H)  
6508 -GEN_SPE_LDSPLAT(hhossplat, spe_lhx, 64_hypv);  
6509 -#endif  
6510 -GEN_SPE_LDSPLAT(hhossplat, spe_lhx, 64_kernel); 5749 +GEN_OP_SPE_LHX(64_kernel);
  5750 +GEN_OP_SPE_LHX(64_hypv);
6511 GEN_SPE_LDSPLAT(hhossplat, spe_lhx, 64_user); 5751 GEN_SPE_LDSPLAT(hhossplat, spe_lhx, 64_user);
6512 -#if defined(TARGET_PPC64H)  
6513 -GEN_OP_SPE_LHX(le_64_hypv);  
6514 -#endif  
6515 -GEN_OP_SPE_LHX(le_64_kernel); 5752 +GEN_SPE_LDSPLAT(hhossplat, spe_lhx, 64_kernel);
  5753 +GEN_SPE_LDSPLAT(hhossplat, spe_lhx, 64_hypv);
6516 GEN_OP_SPE_LHX(le_64_user); 5754 GEN_OP_SPE_LHX(le_64_user);
6517 -#if defined(TARGET_PPC64H)  
6518 -GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_64_hypv);  
6519 -#endif  
6520 -GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_64_kernel); 5755 +GEN_OP_SPE_LHX(le_64_kernel);
  5756 +GEN_OP_SPE_LHX(le_64_hypv);
6521 GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_64_user); 5757 GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_64_user);
  5758 +GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_64_kernel);
  5759 +GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_64_hypv);
6522 #endif 5760 #endif
6523 #endif 5761 #endif
6524 GEN_SPEOP_LD(hhesplat, 1); 5762 GEN_SPEOP_LD(hhesplat, 1);
translate-all.c
  View file @7863667
@@ -264,7 +264,8 @@ int cpu_restore_state(TranslationBlock *tb, @@ -264,7 +264,8 @@ int cpu_restore_state(TranslationBlock *tb,
264 #else 264 #else
265 #define CASE3(op)\ 265 #define CASE3(op)\
266 case INDEX_op_ ## op ## _user:\ 266 case INDEX_op_ ## op ## _user:\
267 - case INDEX_op_ ## op ## _kernel 267 + case INDEX_op_ ## op ## _kernel:\
  268 + case INDEX_op_ ## op ## _hypv
268 #endif 269 #endif
269 270
270 CASE3(stfd): 271 CASE3(stfd):