gwj / at91sam9263 · Commits

Commit 2857068eb1f7098d1af15d715c92fcd4e29d274f

Authored by j_mayer
1 parent 2f401176

Code provision for hypervisor mode memory accesses. 

Add comments in load & store tables to ease code reading.


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@3313 c046a42c-6fe2-441c-8c8c-71466251a162
Inline Side-by-side
Showing 1 changed file with 245 additions and 108 deletions
target-ppc/translate.c
  View file @2857068
@@ -1979,6 +1979,7 @@ static inline void gen_addr_register (DisasContext *ctx) @@ -1979,6 +1979,7 @@ static inline void gen_addr_register (DisasContext *ctx)
1979 #define op_ldst(name) (*gen_op_##name[ctx->mem_idx])() 1979 #define op_ldst(name) (*gen_op_##name[ctx->mem_idx])()
1980 #if defined(CONFIG_USER_ONLY) 1980 #if defined(CONFIG_USER_ONLY)
1981 #if defined(TARGET_PPC64) 1981 #if defined(TARGET_PPC64)
  1982 +/* User mode only - 64 bits */
1982 #define OP_LD_TABLE(width) \ 1983 #define OP_LD_TABLE(width) \
1983 static GenOpFunc *gen_op_l##width[] = { \ 1984 static GenOpFunc *gen_op_l##width[] = { \
1984 &gen_op_l##width##_raw, \ 1985 &gen_op_l##width##_raw, \
@@ -1997,6 +1998,7 @@ static GenOpFunc *gen_op_st##width[] = { \ @@ -1997,6 +1998,7 @@ static GenOpFunc *gen_op_st##width[] = { \
1997 #define gen_op_stb_le_64_raw gen_op_stb_64_raw 1998 #define gen_op_stb_le_64_raw gen_op_stb_64_raw
1998 #define gen_op_lbz_le_64_raw gen_op_lbz_64_raw 1999 #define gen_op_lbz_le_64_raw gen_op_lbz_64_raw
1999 #else 2000 #else
  2001 +/* User mode only - 32 bits */
2000 #define OP_LD_TABLE(width) \ 2002 #define OP_LD_TABLE(width) \
2001 static GenOpFunc *gen_op_l##width[] = { \ 2003 static GenOpFunc *gen_op_l##width[] = { \
2002 &gen_op_l##width##_raw, \ 2004 &gen_op_l##width##_raw, \
@@ -2013,34 +2015,75 @@ static GenOpFunc *gen_op_st##width[] = { \ @@ -2013,34 +2015,75 @@ static GenOpFunc *gen_op_st##width[] = { \
2013 #define gen_op_lbz_le_raw gen_op_lbz_raw 2015 #define gen_op_lbz_le_raw gen_op_lbz_raw
2014 #else 2016 #else
2015 #if defined(TARGET_PPC64) 2017 #if defined(TARGET_PPC64)
  2018 +#if defined(TARGET_PPC64H)
  2019 +/* Full system - 64 bits with hypervisor mode */
2016 #define OP_LD_TABLE(width) \ 2020 #define OP_LD_TABLE(width) \
2017 static GenOpFunc *gen_op_l##width[] = { \ 2021 static GenOpFunc *gen_op_l##width[] = { \
2018 &gen_op_l##width##_user, \ 2022 &gen_op_l##width##_user, \
2019 &gen_op_l##width##_le_user, \ 2023 &gen_op_l##width##_le_user, \
2020 - &gen_op_l##width##_kernel, \  
2021 - &gen_op_l##width##_le_kernel, \  
2022 &gen_op_l##width##_64_user, \ 2024 &gen_op_l##width##_64_user, \
2023 &gen_op_l##width##_le_64_user, \ 2025 &gen_op_l##width##_le_64_user, \
  2026 + &gen_op_l##width##_kernel, \
  2027 + &gen_op_l##width##_le_kernel, \
2024 &gen_op_l##width##_64_kernel, \ 2028 &gen_op_l##width##_64_kernel, \
2025 &gen_op_l##width##_le_64_kernel, \ 2029 &gen_op_l##width##_le_64_kernel, \
  2030 + &gen_op_l##width##_hypv, \
  2031 + &gen_op_l##width##_le_hypv, \
  2032 + &gen_op_l##width##_64_hypv, \
  2033 + &gen_op_l##width##_le_64_hypv, \
2026 }; 2034 };
2027 #define OP_ST_TABLE(width) \ 2035 #define OP_ST_TABLE(width) \
2028 static GenOpFunc *gen_op_st##width[] = { \ 2036 static GenOpFunc *gen_op_st##width[] = { \
2029 &gen_op_st##width##_user, \ 2037 &gen_op_st##width##_user, \
2030 &gen_op_st##width##_le_user, \ 2038 &gen_op_st##width##_le_user, \
  2039 + &gen_op_st##width##_64_user, \
  2040 + &gen_op_st##width##_le_64_user, \
2031 &gen_op_st##width##_kernel, \ 2041 &gen_op_st##width##_kernel, \
2032 &gen_op_st##width##_le_kernel, \ 2042 &gen_op_st##width##_le_kernel, \
  2043 + &gen_op_st##width##_64_kernel, \
  2044 + &gen_op_st##width##_le_64_kernel, \
  2045 + &gen_op_st##width##_hypv, \
  2046 + &gen_op_st##width##_le_hypv, \
  2047 + &gen_op_st##width##_64_hypv, \
  2048 + &gen_op_st##width##_le_64_hypv, \
  2049 +};
  2050 +/* Byte access routine are endian safe */
  2051 +#define gen_op_stb_le_hypv gen_op_stb_64_hypv
  2052 +#define gen_op_lbz_le_hypv gen_op_lbz_64_hypv
  2053 +#define gen_op_stb_le_64_hypv gen_op_stb_64_hypv
  2054 +#define gen_op_lbz_le_64_hypv gen_op_lbz_64_hypv
  2055 +#else
  2056 +/* Full system - 64 bits */
  2057 +#define OP_LD_TABLE(width) \
  2058 +static GenOpFunc *gen_op_l##width[] = { \
  2059 + &gen_op_l##width##_user, \
  2060 + &gen_op_l##width##_le_user, \
  2061 + &gen_op_l##width##_64_user, \
  2062 + &gen_op_l##width##_le_64_user, \
  2063 + &gen_op_l##width##_kernel, \
  2064 + &gen_op_l##width##_le_kernel, \
  2065 + &gen_op_l##width##_64_kernel, \
  2066 + &gen_op_l##width##_le_64_kernel, \
  2067 +};
  2068 +#define OP_ST_TABLE(width) \
  2069 +static GenOpFunc *gen_op_st##width[] = { \
  2070 + &gen_op_st##width##_user, \
  2071 + &gen_op_st##width##_le_user, \
2033 &gen_op_st##width##_64_user, \ 2072 &gen_op_st##width##_64_user, \
2034 &gen_op_st##width##_le_64_user, \ 2073 &gen_op_st##width##_le_64_user, \
  2074 + &gen_op_st##width##_kernel, \
  2075 + &gen_op_st##width##_le_kernel, \
2035 &gen_op_st##width##_64_kernel, \ 2076 &gen_op_st##width##_64_kernel, \
2036 &gen_op_st##width##_le_64_kernel, \ 2077 &gen_op_st##width##_le_64_kernel, \
2037 }; 2078 };
  2079 +#endif
2038 /* Byte access routine are endian safe */ 2080 /* Byte access routine are endian safe */
2039 -#define gen_op_stb_le_64_user gen_op_stb_64_user  
2040 -#define gen_op_lbz_le_64_user gen_op_lbz_64_user 2081 +#define gen_op_stb_le_64_user gen_op_stb_64_user
  2082 +#define gen_op_lbz_le_64_user gen_op_lbz_64_user
2041 #define gen_op_stb_le_64_kernel gen_op_stb_64_kernel 2083 #define gen_op_stb_le_64_kernel gen_op_stb_64_kernel
2042 #define gen_op_lbz_le_64_kernel gen_op_lbz_64_kernel 2084 #define gen_op_lbz_le_64_kernel gen_op_lbz_64_kernel
2043 #else 2085 #else
  2086 +/* Full system - 32 bits */
2044 #define OP_LD_TABLE(width) \ 2087 #define OP_LD_TABLE(width) \
2045 static GenOpFunc *gen_op_l##width[] = { \ 2088 static GenOpFunc *gen_op_l##width[] = { \
2046 &gen_op_l##width##_user, \ 2089 &gen_op_l##width##_user, \
@@ -2057,8 +2100,8 @@ static GenOpFunc *gen_op_st##width[] = { \ @@ -2057,8 +2100,8 @@ static GenOpFunc *gen_op_st##width[] = { \
2057 }; 2100 };
2058 #endif 2101 #endif
2059 /* Byte access routine are endian safe */ 2102 /* Byte access routine are endian safe */
2060 -#define gen_op_stb_le_user gen_op_stb_user  
2061 -#define gen_op_lbz_le_user gen_op_lbz_user 2103 +#define gen_op_stb_le_user gen_op_stb_user
  2104 +#define gen_op_lbz_le_user gen_op_lbz_user
2062 #define gen_op_stb_le_kernel gen_op_stb_kernel 2105 #define gen_op_stb_le_kernel gen_op_stb_kernel
2063 #define gen_op_lbz_le_kernel gen_op_lbz_kernel 2106 #define gen_op_lbz_le_kernel gen_op_lbz_kernel
2064 #endif 2107 #endif
@@ -2316,51 +2359,61 @@ GEN_STX(wbr, 0x16, 0x14, PPC_INTEGER); @@ -2316,51 +2359,61 @@ GEN_STX(wbr, 0x16, 0x14, PPC_INTEGER);
2316 2359
2317 /*** Integer load and store multiple ***/ 2360 /*** Integer load and store multiple ***/
2318 #define op_ldstm(name, reg) (*gen_op_##name[ctx->mem_idx])(reg) 2361 #define op_ldstm(name, reg) (*gen_op_##name[ctx->mem_idx])(reg)
2319 -#if defined(TARGET_PPC64)  
2320 #if defined(CONFIG_USER_ONLY) 2362 #if defined(CONFIG_USER_ONLY)
  2363 +/* User-mode only */
2321 static GenOpFunc1 *gen_op_lmw[] = { 2364 static GenOpFunc1 *gen_op_lmw[] = {
2322 &gen_op_lmw_raw, 2365 &gen_op_lmw_raw,
2323 &gen_op_lmw_le_raw, 2366 &gen_op_lmw_le_raw,
  2367 +#if defined(TARGET_PPC64)
2324 &gen_op_lmw_64_raw, 2368 &gen_op_lmw_64_raw,
2325 &gen_op_lmw_le_64_raw, 2369 &gen_op_lmw_le_64_raw,
  2370 +#endif
2326 }; 2371 };
2327 static GenOpFunc1 *gen_op_stmw[] = { 2372 static GenOpFunc1 *gen_op_stmw[] = {
  2373 + &gen_op_stmw_raw,
  2374 + &gen_op_stmw_le_raw,
  2375 +#if defined(TARGET_PPC64)
2328 &gen_op_stmw_64_raw, 2376 &gen_op_stmw_64_raw,
2329 &gen_op_stmw_le_64_raw, 2377 &gen_op_stmw_le_64_raw,
  2378 +#endif
2330 }; 2379 };
2331 #else 2380 #else
  2381 +#if defined(TARGET_PPC64)
  2382 +/* Full system - 64 bits mode */
2332 static GenOpFunc1 *gen_op_lmw[] = { 2383 static GenOpFunc1 *gen_op_lmw[] = {
2333 &gen_op_lmw_user, 2384 &gen_op_lmw_user,
2334 &gen_op_lmw_le_user, 2385 &gen_op_lmw_le_user,
2335 - &gen_op_lmw_kernel,  
2336 - &gen_op_lmw_le_kernel,  
2337 &gen_op_lmw_64_user, 2386 &gen_op_lmw_64_user,
2338 &gen_op_lmw_le_64_user, 2387 &gen_op_lmw_le_64_user,
  2388 + &gen_op_lmw_kernel,
  2389 + &gen_op_lmw_le_kernel,
2339 &gen_op_lmw_64_kernel, 2390 &gen_op_lmw_64_kernel,
2340 &gen_op_lmw_le_64_kernel, 2391 &gen_op_lmw_le_64_kernel,
  2392 +#if defined(TARGET_PPC64H)
  2393 + &gen_op_lmw_hypv,
  2394 + &gen_op_lmw_le_hypv,
  2395 + &gen_op_lmw_64_hypv,
  2396 + &gen_op_lmw_le_64_hypv,
  2397 +#endif
2341 }; 2398 };
2342 static GenOpFunc1 *gen_op_stmw[] = { 2399 static GenOpFunc1 *gen_op_stmw[] = {
2343 &gen_op_stmw_user, 2400 &gen_op_stmw_user,
2344 &gen_op_stmw_le_user, 2401 &gen_op_stmw_le_user,
2345 - &gen_op_stmw_kernel,  
2346 - &gen_op_stmw_le_kernel,  
2347 &gen_op_stmw_64_user, 2402 &gen_op_stmw_64_user,
2348 &gen_op_stmw_le_64_user, 2403 &gen_op_stmw_le_64_user,
  2404 + &gen_op_stmw_kernel,
  2405 + &gen_op_stmw_le_kernel,
2349 &gen_op_stmw_64_kernel, 2406 &gen_op_stmw_64_kernel,
2350 &gen_op_stmw_le_64_kernel, 2407 &gen_op_stmw_le_64_kernel,
2351 -}; 2408 +#if defined(TARGET_PPC64H)
  2409 + &gen_op_stmw_hypv,
  2410 + &gen_op_stmw_le_hypv,
  2411 + &gen_op_stmw_64_hypv,
  2412 + &gen_op_stmw_le_64_hypv,
2352 #endif 2413 #endif
2353 -#else  
2354 -#if defined(CONFIG_USER_ONLY)  
2355 -static GenOpFunc1 *gen_op_lmw[] = {  
2356 - &gen_op_lmw_raw,  
2357 - &gen_op_lmw_le_raw,  
2358 -};  
2359 -static GenOpFunc1 *gen_op_stmw[] = {  
2360 - &gen_op_stmw_raw,  
2361 - &gen_op_stmw_le_raw,  
2362 }; 2414 };
2363 #else 2415 #else
  2416 +/* Full system - 32 bits mode */
2364 static GenOpFunc1 *gen_op_lmw[] = { 2417 static GenOpFunc1 *gen_op_lmw[] = {
2365 &gen_op_lmw_user, 2418 &gen_op_lmw_user,
2366 &gen_op_lmw_le_user, 2419 &gen_op_lmw_le_user,
@@ -2397,73 +2450,85 @@ GEN_HANDLER(stmw, 0x2F, 0xFF, 0xFF, 0x00000000, PPC_INTEGER) @@ -2397,73 +2450,85 @@ GEN_HANDLER(stmw, 0x2F, 0xFF, 0xFF, 0x00000000, PPC_INTEGER)
2397 /*** Integer load and store strings ***/ 2450 /*** Integer load and store strings ***/
2398 #define op_ldsts(name, start) (*gen_op_##name[ctx->mem_idx])(start) 2451 #define op_ldsts(name, start) (*gen_op_##name[ctx->mem_idx])(start)
2399 #define op_ldstsx(name, rd, ra, rb) (*gen_op_##name[ctx->mem_idx])(rd, ra, rb) 2452 #define op_ldstsx(name, rd, ra, rb) (*gen_op_##name[ctx->mem_idx])(rd, ra, rb)
2400 -#if defined(TARGET_PPC64)  
2401 #if defined(CONFIG_USER_ONLY) 2453 #if defined(CONFIG_USER_ONLY)
  2454 +/* User-mode only */
2402 static GenOpFunc1 *gen_op_lswi[] = { 2455 static GenOpFunc1 *gen_op_lswi[] = {
2403 &gen_op_lswi_raw, 2456 &gen_op_lswi_raw,
2404 &gen_op_lswi_le_raw, 2457 &gen_op_lswi_le_raw,
  2458 +#if defined(TARGET_PPC64)
2405 &gen_op_lswi_64_raw, 2459 &gen_op_lswi_64_raw,
2406 &gen_op_lswi_le_64_raw, 2460 &gen_op_lswi_le_64_raw,
  2461 +#endif
2407 }; 2462 };
2408 static GenOpFunc3 *gen_op_lswx[] = { 2463 static GenOpFunc3 *gen_op_lswx[] = {
2409 &gen_op_lswx_raw, 2464 &gen_op_lswx_raw,
2410 &gen_op_lswx_le_raw, 2465 &gen_op_lswx_le_raw,
  2466 +#if defined(TARGET_PPC64)
2411 &gen_op_lswx_64_raw, 2467 &gen_op_lswx_64_raw,
2412 &gen_op_lswx_le_64_raw, 2468 &gen_op_lswx_le_64_raw,
  2469 +#endif
2413 }; 2470 };
2414 static GenOpFunc1 *gen_op_stsw[] = { 2471 static GenOpFunc1 *gen_op_stsw[] = {
2415 &gen_op_stsw_raw, 2472 &gen_op_stsw_raw,
2416 &gen_op_stsw_le_raw, 2473 &gen_op_stsw_le_raw,
  2474 +#if defined(TARGET_PPC64)
2417 &gen_op_stsw_64_raw, 2475 &gen_op_stsw_64_raw,
2418 &gen_op_stsw_le_64_raw, 2476 &gen_op_stsw_le_64_raw,
  2477 +#endif
2419 }; 2478 };
2420 #else 2479 #else
  2480 +#if defined(TARGET_PPC64)
  2481 +/* Full system - 64 bits mode */
2421 static GenOpFunc1 *gen_op_lswi[] = { 2482 static GenOpFunc1 *gen_op_lswi[] = {
2422 &gen_op_lswi_user, 2483 &gen_op_lswi_user,
2423 &gen_op_lswi_le_user, 2484 &gen_op_lswi_le_user,
2424 - &gen_op_lswi_kernel,  
2425 - &gen_op_lswi_le_kernel,  
2426 &gen_op_lswi_64_user, 2485 &gen_op_lswi_64_user,
2427 &gen_op_lswi_le_64_user, 2486 &gen_op_lswi_le_64_user,
  2487 + &gen_op_lswi_kernel,
  2488 + &gen_op_lswi_le_kernel,
2428 &gen_op_lswi_64_kernel, 2489 &gen_op_lswi_64_kernel,
2429 &gen_op_lswi_le_64_kernel, 2490 &gen_op_lswi_le_64_kernel,
  2491 +#if defined(TARGET_PPC64H)
  2492 + &gen_op_lswi_hypv,
  2493 + &gen_op_lswi_le_hypv,
  2494 + &gen_op_lswi_64_hypv,
  2495 + &gen_op_lswi_le_64_hypv,
  2496 +#endif
2430 }; 2497 };
2431 static GenOpFunc3 *gen_op_lswx[] = { 2498 static GenOpFunc3 *gen_op_lswx[] = {
2432 &gen_op_lswx_user, 2499 &gen_op_lswx_user,
2433 &gen_op_lswx_le_user, 2500 &gen_op_lswx_le_user,
2434 - &gen_op_lswx_kernel,  
2435 - &gen_op_lswx_le_kernel,  
2436 &gen_op_lswx_64_user, 2501 &gen_op_lswx_64_user,
2437 &gen_op_lswx_le_64_user, 2502 &gen_op_lswx_le_64_user,
  2503 + &gen_op_lswx_kernel,
  2504 + &gen_op_lswx_le_kernel,
2438 &gen_op_lswx_64_kernel, 2505 &gen_op_lswx_64_kernel,
2439 &gen_op_lswx_le_64_kernel, 2506 &gen_op_lswx_le_64_kernel,
  2507 +#if defined(TARGET_PPC64H)
  2508 + &gen_op_lswx_hypv,
  2509 + &gen_op_lswx_le_hypv,
  2510 + &gen_op_lswx_64_hypv,
  2511 + &gen_op_lswx_le_64_hypv,
  2512 +#endif
2440 }; 2513 };
2441 static GenOpFunc1 *gen_op_stsw[] = { 2514 static GenOpFunc1 *gen_op_stsw[] = {
2442 &gen_op_stsw_user, 2515 &gen_op_stsw_user,
2443 &gen_op_stsw_le_user, 2516 &gen_op_stsw_le_user,
2444 - &gen_op_stsw_kernel,  
2445 - &gen_op_stsw_le_kernel,  
2446 &gen_op_stsw_64_user, 2517 &gen_op_stsw_64_user,
2447 &gen_op_stsw_le_64_user, 2518 &gen_op_stsw_le_64_user,
  2519 + &gen_op_stsw_kernel,
  2520 + &gen_op_stsw_le_kernel,
2448 &gen_op_stsw_64_kernel, 2521 &gen_op_stsw_64_kernel,
2449 &gen_op_stsw_le_64_kernel, 2522 &gen_op_stsw_le_64_kernel,
2450 -}; 2523 +#if defined(TARGET_PPC64H)
  2524 + &gen_op_stsw_hypv,
  2525 + &gen_op_stsw_le_hypv,
  2526 + &gen_op_stsw_64_hypv,
  2527 + &gen_op_stsw_le_64_hypv,
2451 #endif 2528 #endif
2452 -#else  
2453 -#if defined(CONFIG_USER_ONLY)  
2454 -static GenOpFunc1 *gen_op_lswi[] = {  
2455 - &gen_op_lswi_raw,  
2456 - &gen_op_lswi_le_raw,  
2457 -};  
2458 -static GenOpFunc3 *gen_op_lswx[] = {  
2459 - &gen_op_lswx_raw,  
2460 - &gen_op_lswx_le_raw,  
2461 -};  
2462 -static GenOpFunc1 *gen_op_stsw[] = {  
2463 - &gen_op_stsw_raw,  
2464 - &gen_op_stsw_le_raw,  
2465 }; 2529 };
2466 #else 2530 #else
  2531 +/* Full system - 32 bits mode */
2467 static GenOpFunc1 *gen_op_lswi[] = { 2532 static GenOpFunc1 *gen_op_lswi[] = {
2468 &gen_op_lswi_user, 2533 &gen_op_lswi_user,
2469 &gen_op_lswi_le_user, 2534 &gen_op_lswi_le_user,
@@ -2569,53 +2634,61 @@ GEN_HANDLER(isync, 0x13, 0x16, 0x04, 0x03FFF801, PPC_MEM) @@ -2569,53 +2634,61 @@ GEN_HANDLER(isync, 0x13, 0x16, 0x04, 0x03FFF801, PPC_MEM)
2569 2634
2570 #define op_lwarx() (*gen_op_lwarx[ctx->mem_idx])() 2635 #define op_lwarx() (*gen_op_lwarx[ctx->mem_idx])()
2571 #define op_stwcx() (*gen_op_stwcx[ctx->mem_idx])() 2636 #define op_stwcx() (*gen_op_stwcx[ctx->mem_idx])()
2572 -#if defined(TARGET_PPC64)  
2573 #if defined(CONFIG_USER_ONLY) 2637 #if defined(CONFIG_USER_ONLY)
  2638 +/* User-mode only */
2574 static GenOpFunc *gen_op_lwarx[] = { 2639 static GenOpFunc *gen_op_lwarx[] = {
2575 &gen_op_lwarx_raw, 2640 &gen_op_lwarx_raw,
2576 &gen_op_lwarx_le_raw, 2641 &gen_op_lwarx_le_raw,
  2642 +#if defined(TARGET_PPC64)
2577 &gen_op_lwarx_64_raw, 2643 &gen_op_lwarx_64_raw,
2578 &gen_op_lwarx_le_64_raw, 2644 &gen_op_lwarx_le_64_raw,
  2645 +#endif
2579 }; 2646 };
2580 static GenOpFunc *gen_op_stwcx[] = { 2647 static GenOpFunc *gen_op_stwcx[] = {
2581 &gen_op_stwcx_raw, 2648 &gen_op_stwcx_raw,
2582 &gen_op_stwcx_le_raw, 2649 &gen_op_stwcx_le_raw,
  2650 +#if defined(TARGET_PPC64)
2583 &gen_op_stwcx_64_raw, 2651 &gen_op_stwcx_64_raw,
2584 &gen_op_stwcx_le_64_raw, 2652 &gen_op_stwcx_le_64_raw,
  2653 +#endif
2585 }; 2654 };
2586 #else 2655 #else
  2656 +#if defined(TARGET_PPC64)
  2657 +/* Full system - 64 bits mode */
2587 static GenOpFunc *gen_op_lwarx[] = { 2658 static GenOpFunc *gen_op_lwarx[] = {
2588 &gen_op_lwarx_user, 2659 &gen_op_lwarx_user,
2589 &gen_op_lwarx_le_user, 2660 &gen_op_lwarx_le_user,
2590 - &gen_op_lwarx_kernel,  
2591 - &gen_op_lwarx_le_kernel,  
2592 &gen_op_lwarx_64_user, 2661 &gen_op_lwarx_64_user,
2593 &gen_op_lwarx_le_64_user, 2662 &gen_op_lwarx_le_64_user,
  2663 + &gen_op_lwarx_kernel,
  2664 + &gen_op_lwarx_le_kernel,
2594 &gen_op_lwarx_64_kernel, 2665 &gen_op_lwarx_64_kernel,
2595 &gen_op_lwarx_le_64_kernel, 2666 &gen_op_lwarx_le_64_kernel,
  2667 +#if defined(TARGET_PPC64H)
  2668 + &gen_op_lwarx_hypv,
  2669 + &gen_op_lwarx_le_hypv,
  2670 + &gen_op_lwarx_64_hypv,
  2671 + &gen_op_lwarx_le_64_hypv,
  2672 +#endif
2596 }; 2673 };
2597 static GenOpFunc *gen_op_stwcx[] = { 2674 static GenOpFunc *gen_op_stwcx[] = {
2598 &gen_op_stwcx_user, 2675 &gen_op_stwcx_user,
2599 &gen_op_stwcx_le_user, 2676 &gen_op_stwcx_le_user,
2600 - &gen_op_stwcx_kernel,  
2601 - &gen_op_stwcx_le_kernel,  
2602 &gen_op_stwcx_64_user, 2677 &gen_op_stwcx_64_user,
2603 &gen_op_stwcx_le_64_user, 2678 &gen_op_stwcx_le_64_user,
  2679 + &gen_op_stwcx_kernel,
  2680 + &gen_op_stwcx_le_kernel,
2604 &gen_op_stwcx_64_kernel, 2681 &gen_op_stwcx_64_kernel,
2605 &gen_op_stwcx_le_64_kernel, 2682 &gen_op_stwcx_le_64_kernel,
2606 -}; 2683 +#if defined(TARGET_PPC64H)
  2684 + &gen_op_stwcx_hypv,
  2685 + &gen_op_stwcx_le_hypv,
  2686 + &gen_op_stwcx_64_hypv,
  2687 + &gen_op_stwcx_le_64_hypv,
2607 #endif 2688 #endif
2608 -#else  
2609 -#if defined(CONFIG_USER_ONLY)  
2610 -static GenOpFunc *gen_op_lwarx[] = {  
2611 - &gen_op_lwarx_raw,  
2612 - &gen_op_lwarx_le_raw,  
2613 -};  
2614 -static GenOpFunc *gen_op_stwcx[] = {  
2615 - &gen_op_stwcx_raw,  
2616 - &gen_op_stwcx_le_raw,  
2617 }; 2689 };
2618 #else 2690 #else
  2691 +/* Full system - 32 bits mode */
2619 static GenOpFunc *gen_op_lwarx[] = { 2692 static GenOpFunc *gen_op_lwarx[] = {
2620 &gen_op_lwarx_user, 2693 &gen_op_lwarx_user,
2621 &gen_op_lwarx_le_user, 2694 &gen_op_lwarx_le_user,
@@ -2655,6 +2728,7 @@ GEN_HANDLER(stwcx_, 0x1F, 0x16, 0x04, 0x00000000, PPC_RES) @@ -2655,6 +2728,7 @@ GEN_HANDLER(stwcx_, 0x1F, 0x16, 0x04, 0x00000000, PPC_RES)
2655 #define op_ldarx() (*gen_op_ldarx[ctx->mem_idx])() 2728 #define op_ldarx() (*gen_op_ldarx[ctx->mem_idx])()
2656 #define op_stdcx() (*gen_op_stdcx[ctx->mem_idx])() 2729 #define op_stdcx() (*gen_op_stdcx[ctx->mem_idx])()
2657 #if defined(CONFIG_USER_ONLY) 2730 #if defined(CONFIG_USER_ONLY)
  2731 +/* User-mode only */
2658 static GenOpFunc *gen_op_ldarx[] = { 2732 static GenOpFunc *gen_op_ldarx[] = {
2659 &gen_op_ldarx_raw, 2733 &gen_op_ldarx_raw,
2660 &gen_op_ldarx_le_raw, 2734 &gen_op_ldarx_le_raw,
@@ -2668,25 +2742,38 @@ static GenOpFunc *gen_op_stdcx[] = { @@ -2668,25 +2742,38 @@ static GenOpFunc *gen_op_stdcx[] = {
2668 &gen_op_stdcx_le_64_raw, 2742 &gen_op_stdcx_le_64_raw,
2669 }; 2743 };
2670 #else 2744 #else
  2745 +/* Full system */
2671 static GenOpFunc *gen_op_ldarx[] = { 2746 static GenOpFunc *gen_op_ldarx[] = {
2672 &gen_op_ldarx_user, 2747 &gen_op_ldarx_user,
2673 &gen_op_ldarx_le_user, 2748 &gen_op_ldarx_le_user,
2674 - &gen_op_ldarx_kernel,  
2675 - &gen_op_ldarx_le_kernel,  
2676 &gen_op_ldarx_64_user, 2749 &gen_op_ldarx_64_user,
2677 &gen_op_ldarx_le_64_user, 2750 &gen_op_ldarx_le_64_user,
  2751 + &gen_op_ldarx_kernel,
  2752 + &gen_op_ldarx_le_kernel,
2678 &gen_op_ldarx_64_kernel, 2753 &gen_op_ldarx_64_kernel,
2679 &gen_op_ldarx_le_64_kernel, 2754 &gen_op_ldarx_le_64_kernel,
  2755 +#if defined(TARGET_PPC64H)
  2756 + &gen_op_ldarx_hypv,
  2757 + &gen_op_ldarx_le_hypv,
  2758 + &gen_op_ldarx_64_hypv,
  2759 + &gen_op_ldarx_le_64_hypv,
  2760 +#endif
2680 }; 2761 };
2681 static GenOpFunc *gen_op_stdcx[] = { 2762 static GenOpFunc *gen_op_stdcx[] = {
2682 &gen_op_stdcx_user, 2763 &gen_op_stdcx_user,
2683 &gen_op_stdcx_le_user, 2764 &gen_op_stdcx_le_user,
2684 - &gen_op_stdcx_kernel,  
2685 - &gen_op_stdcx_le_kernel,  
2686 &gen_op_stdcx_64_user, 2765 &gen_op_stdcx_64_user,
2687 &gen_op_stdcx_le_64_user, 2766 &gen_op_stdcx_le_64_user,
  2767 + &gen_op_stdcx_kernel,
  2768 + &gen_op_stdcx_le_kernel,
2688 &gen_op_stdcx_64_kernel, 2769 &gen_op_stdcx_64_kernel,
2689 &gen_op_stdcx_le_64_kernel, 2770 &gen_op_stdcx_le_64_kernel,
  2771 +#if defined(TARGET_PPC64H)
  2772 + &gen_op_stdcx_hypv,
  2773 + &gen_op_stdcx_le_hypv,
  2774 + &gen_op_stdcx_64_hypv,
  2775 + &gen_op_stdcx_le_64_hypv,
  2776 +#endif
2690 }; 2777 };
2691 #endif 2778 #endif
2692 2779
@@ -3537,33 +3624,37 @@ GEN_HANDLER(dcbtst, 0x1F, 0x16, 0x07, 0x02000001, PPC_CACHE) @@ -3537,33 +3624,37 @@ GEN_HANDLER(dcbtst, 0x1F, 0x16, 0x07, 0x02000001, PPC_CACHE)
3537 3624
3538 /* dcbz */ 3625 /* dcbz */
3539 #define op_dcbz() (*gen_op_dcbz[ctx->mem_idx])() 3626 #define op_dcbz() (*gen_op_dcbz[ctx->mem_idx])()
3540 -#if defined(TARGET_PPC64)  
3541 #if defined(CONFIG_USER_ONLY) 3627 #if defined(CONFIG_USER_ONLY)
  3628 +/* User-mode only */
3542 static GenOpFunc *gen_op_dcbz[] = { 3629 static GenOpFunc *gen_op_dcbz[] = {
3543 &gen_op_dcbz_raw, 3630 &gen_op_dcbz_raw,
3544 &gen_op_dcbz_raw, 3631 &gen_op_dcbz_raw,
  3632 +#if defined(TARGET_PPC64)
3545 &gen_op_dcbz_64_raw, 3633 &gen_op_dcbz_64_raw,
3546 &gen_op_dcbz_64_raw, 3634 &gen_op_dcbz_64_raw,
  3635 +#endif
3547 }; 3636 };
3548 #else 3637 #else
  3638 +#if defined(TARGET_PPC64)
  3639 +/* Full system - 64 bits mode */
3549 static GenOpFunc *gen_op_dcbz[] = { 3640 static GenOpFunc *gen_op_dcbz[] = {
3550 &gen_op_dcbz_user, 3641 &gen_op_dcbz_user,
3551 &gen_op_dcbz_user, 3642 &gen_op_dcbz_user,
3552 - &gen_op_dcbz_kernel,  
3553 - &gen_op_dcbz_kernel,  
3554 &gen_op_dcbz_64_user, 3643 &gen_op_dcbz_64_user,
3555 &gen_op_dcbz_64_user, 3644 &gen_op_dcbz_64_user,
  3645 + &gen_op_dcbz_kernel,
  3646 + &gen_op_dcbz_kernel,
3556 &gen_op_dcbz_64_kernel, 3647 &gen_op_dcbz_64_kernel,
3557 &gen_op_dcbz_64_kernel, 3648 &gen_op_dcbz_64_kernel,
3558 -}; 3649 +#if defined(TARGET_PPC64H)
  3650 + &gen_op_dcbz_hypv,
  3651 + &gen_op_dcbz_hypv,
  3652 + &gen_op_dcbz_64_hypv,
  3653 + &gen_op_dcbz_64_hypv,
3559 #endif 3654 #endif
3560 -#else  
3561 -#if defined(CONFIG_USER_ONLY)  
3562 -static GenOpFunc *gen_op_dcbz[] = {  
3563 - &gen_op_dcbz_raw,  
3564 - &gen_op_dcbz_raw,  
3565 }; 3655 };
3566 #else 3656 #else
  3657 +/* Full system - 32 bits mode */
3567 static GenOpFunc *gen_op_dcbz[] = { 3658 static GenOpFunc *gen_op_dcbz[] = {
3568 &gen_op_dcbz_user, 3659 &gen_op_dcbz_user,
3569 &gen_op_dcbz_user, 3660 &gen_op_dcbz_user,
@@ -3582,33 +3673,37 @@ GEN_HANDLER(dcbz, 0x1F, 0x16, 0x1F, 0x03E00001, PPC_CACHE) @@ -3582,33 +3673,37 @@ GEN_HANDLER(dcbz, 0x1F, 0x16, 0x1F, 0x03E00001, PPC_CACHE)
3582 3673
3583 /* icbi */ 3674 /* icbi */
3584 #define op_icbi() (*gen_op_icbi[ctx->mem_idx])() 3675 #define op_icbi() (*gen_op_icbi[ctx->mem_idx])()
3585 -#if defined(TARGET_PPC64)  
3586 #if defined(CONFIG_USER_ONLY) 3676 #if defined(CONFIG_USER_ONLY)
  3677 +/* User-mode only */
3587 static GenOpFunc *gen_op_icbi[] = { 3678 static GenOpFunc *gen_op_icbi[] = {
3588 &gen_op_icbi_raw, 3679 &gen_op_icbi_raw,
3589 &gen_op_icbi_raw, 3680 &gen_op_icbi_raw,
  3681 +#if defined(TARGET_PPC64)
3590 &gen_op_icbi_64_raw, 3682 &gen_op_icbi_64_raw,
3591 &gen_op_icbi_64_raw, 3683 &gen_op_icbi_64_raw,
  3684 +#endif
3592 }; 3685 };
3593 #else 3686 #else
  3687 +/* Full system - 64 bits mode */
  3688 +#if defined(TARGET_PPC64)
3594 static GenOpFunc *gen_op_icbi[] = { 3689 static GenOpFunc *gen_op_icbi[] = {
3595 &gen_op_icbi_user, 3690 &gen_op_icbi_user,
3596 &gen_op_icbi_user, 3691 &gen_op_icbi_user,
3597 - &gen_op_icbi_kernel,  
3598 - &gen_op_icbi_kernel,  
3599 &gen_op_icbi_64_user, 3692 &gen_op_icbi_64_user,
3600 &gen_op_icbi_64_user, 3693 &gen_op_icbi_64_user,
  3694 + &gen_op_icbi_kernel,
  3695 + &gen_op_icbi_kernel,
3601 &gen_op_icbi_64_kernel, 3696 &gen_op_icbi_64_kernel,
3602 &gen_op_icbi_64_kernel, 3697 &gen_op_icbi_64_kernel,
3603 -}; 3698 +#if defined(TARGET_PPC64H)
  3699 + &gen_op_icbi_hypv,
  3700 + &gen_op_icbi_hypv,
  3701 + &gen_op_icbi_64_hypv,
  3702 + &gen_op_icbi_64_hypv,
3604 #endif 3703 #endif
3605 -#else  
3606 -#if defined(CONFIG_USER_ONLY)  
3607 -static GenOpFunc *gen_op_icbi[] = {  
3608 - &gen_op_icbi_raw,  
3609 - &gen_op_icbi_raw,  
3610 }; 3704 };
3611 #else 3705 #else
  3706 +/* Full system - 32 bits mode */
3612 static GenOpFunc *gen_op_icbi[] = { 3707 static GenOpFunc *gen_op_icbi[] = {
3613 &gen_op_icbi_user, 3708 &gen_op_icbi_user,
3614 &gen_op_icbi_user, 3709 &gen_op_icbi_user,
@@ -3796,53 +3891,61 @@ GEN_HANDLER(slbie, 0x1F, 0x12, 0x0D, 0x03FF0001, PPC_SLBI) @@ -3796,53 +3891,61 @@ GEN_HANDLER(slbie, 0x1F, 0x12, 0x0D, 0x03FF0001, PPC_SLBI)
3796 /* Optional: */ 3891 /* Optional: */
3797 #define op_eciwx() (*gen_op_eciwx[ctx->mem_idx])() 3892 #define op_eciwx() (*gen_op_eciwx[ctx->mem_idx])()
3798 #define op_ecowx() (*gen_op_ecowx[ctx->mem_idx])() 3893 #define op_ecowx() (*gen_op_ecowx[ctx->mem_idx])()
3799 -#if defined(TARGET_PPC64)  
3800 #if defined(CONFIG_USER_ONLY) 3894 #if defined(CONFIG_USER_ONLY)
  3895 +/* User-mode only */
3801 static GenOpFunc *gen_op_eciwx[] = { 3896 static GenOpFunc *gen_op_eciwx[] = {
3802 &gen_op_eciwx_raw, 3897 &gen_op_eciwx_raw,
3803 &gen_op_eciwx_le_raw, 3898 &gen_op_eciwx_le_raw,
  3899 +#if defined(TARGET_PPC64)
3804 &gen_op_eciwx_64_raw, 3900 &gen_op_eciwx_64_raw,
3805 &gen_op_eciwx_le_64_raw, 3901 &gen_op_eciwx_le_64_raw,
  3902 +#endif
3806 }; 3903 };
3807 static GenOpFunc *gen_op_ecowx[] = { 3904 static GenOpFunc *gen_op_ecowx[] = {
3808 &gen_op_ecowx_raw, 3905 &gen_op_ecowx_raw,
3809 &gen_op_ecowx_le_raw, 3906 &gen_op_ecowx_le_raw,
  3907 +#if defined(TARGET_PPC64)
3810 &gen_op_ecowx_64_raw, 3908 &gen_op_ecowx_64_raw,
3811 &gen_op_ecowx_le_64_raw, 3909 &gen_op_ecowx_le_64_raw,
  3910 +#endif
3812 }; 3911 };
3813 #else 3912 #else
  3913 +#if defined(TARGET_PPC64)
  3914 +/* Full system - 64 bits mode */
3814 static GenOpFunc *gen_op_eciwx[] = { 3915 static GenOpFunc *gen_op_eciwx[] = {
3815 &gen_op_eciwx_user, 3916 &gen_op_eciwx_user,
3816 &gen_op_eciwx_le_user, 3917 &gen_op_eciwx_le_user,
3817 - &gen_op_eciwx_kernel,  
3818 - &gen_op_eciwx_le_kernel,  
3819 &gen_op_eciwx_64_user, 3918 &gen_op_eciwx_64_user,
3820 &gen_op_eciwx_le_64_user, 3919 &gen_op_eciwx_le_64_user,
  3920 + &gen_op_eciwx_kernel,
  3921 + &gen_op_eciwx_le_kernel,
3821 &gen_op_eciwx_64_kernel, 3922 &gen_op_eciwx_64_kernel,
3822 &gen_op_eciwx_le_64_kernel, 3923 &gen_op_eciwx_le_64_kernel,
  3924 +#if defined(TARGET_PPC64H)
  3925 + &gen_op_eciwx_hypv,
  3926 + &gen_op_eciwx_le_hypv,
  3927 + &gen_op_eciwx_64_hypv,
  3928 + &gen_op_eciwx_le_64_hypv,
  3929 +#endif
3823 }; 3930 };
3824 static GenOpFunc *gen_op_ecowx[] = { 3931 static GenOpFunc *gen_op_ecowx[] = {
3825 &gen_op_ecowx_user, 3932 &gen_op_ecowx_user,
3826 &gen_op_ecowx_le_user, 3933 &gen_op_ecowx_le_user,
3827 - &gen_op_ecowx_kernel,  
3828 - &gen_op_ecowx_le_kernel,  
3829 &gen_op_ecowx_64_user, 3934 &gen_op_ecowx_64_user,
3830 &gen_op_ecowx_le_64_user, 3935 &gen_op_ecowx_le_64_user,
  3936 + &gen_op_ecowx_kernel,
  3937 + &gen_op_ecowx_le_kernel,
3831 &gen_op_ecowx_64_kernel, 3938 &gen_op_ecowx_64_kernel,
3832 &gen_op_ecowx_le_64_kernel, 3939 &gen_op_ecowx_le_64_kernel,
3833 -}; 3940 +#if defined(TARGET_PPC64H)
  3941 + &gen_op_ecowx_hypv,
  3942 + &gen_op_ecowx_le_hypv,
  3943 + &gen_op_ecowx_64_hypv,
  3944 + &gen_op_ecowx_le_64_hypv,
3834 #endif 3945 #endif
3835 -#else  
3836 -#if defined(CONFIG_USER_ONLY)  
3837 -static GenOpFunc *gen_op_eciwx[] = {  
3838 - &gen_op_eciwx_raw,  
3839 - &gen_op_eciwx_le_raw,  
3840 -};  
3841 -static GenOpFunc *gen_op_ecowx[] = {  
3842 - &gen_op_ecowx_raw,  
3843 - &gen_op_ecowx_le_raw,  
3844 }; 3946 };
3845 #else 3947 #else
  3948 +/* Full system - 32 bits mode */
3846 static GenOpFunc *gen_op_eciwx[] = { 3949 static GenOpFunc *gen_op_eciwx[] = {
3847 &gen_op_eciwx_user, 3950 &gen_op_eciwx_user,
3848 &gen_op_eciwx_le_user, 3951 &gen_op_eciwx_le_user,
@@ -3981,7 +4084,7 @@ GEN_HANDLER(dozi, 0x09, 0xFF, 0xFF, 0x00000000, PPC_POWER_BR) @@ -3981,7 +4084,7 @@ GEN_HANDLER(dozi, 0x09, 0xFF, 0xFF, 0x00000000, PPC_POWER_BR)
3981 } 4084 }
3982 4085
3983 /* As lscbx load from memory byte after byte, it's always endian safe */ 4086 /* As lscbx load from memory byte after byte, it's always endian safe */
3984 -#define op_POWER_lscbx(start, ra, rb) \ 4087 +#define op_POWER_lscbx(start, ra, rb) \
3985 (*gen_op_POWER_lscbx[ctx->mem_idx])(start, ra, rb) 4088 (*gen_op_POWER_lscbx[ctx->mem_idx])(start, ra, rb)
3986 #if defined(CONFIG_USER_ONLY) 4089 #if defined(CONFIG_USER_ONLY)
3987 static GenOpFunc3 *gen_op_POWER_lscbx[] = { 4090 static GenOpFunc3 *gen_op_POWER_lscbx[] = {
@@ -5269,6 +5372,7 @@ static inline void gen_addr_spe_imm_index (DisasContext *ctx, int sh) @@ -5269,6 +5372,7 @@ static inline void gen_addr_spe_imm_index (DisasContext *ctx, int sh)
5269 #define op_spe_ldst(name) (*gen_op_##name[ctx->mem_idx])() 5372 #define op_spe_ldst(name) (*gen_op_##name[ctx->mem_idx])()
5270 #if defined(CONFIG_USER_ONLY) 5373 #if defined(CONFIG_USER_ONLY)
5271 #if defined(TARGET_PPC64) 5374 #if defined(TARGET_PPC64)
  5375 +/* User-mode only - 64 bits mode */
5272 #define OP_SPE_LD_TABLE(name) \ 5376 #define OP_SPE_LD_TABLE(name) \
5273 static GenOpFunc *gen_op_spe_l##name[] = { \ 5377 static GenOpFunc *gen_op_spe_l##name[] = { \
5274 &gen_op_spe_l##name##_raw, \ 5378 &gen_op_spe_l##name##_raw, \
@@ -5284,6 +5388,7 @@ static GenOpFunc *gen_op_spe_st##name[] = { \ @@ -5284,6 +5388,7 @@ static GenOpFunc *gen_op_spe_st##name[] = { \
5284 &gen_op_spe_st##name##_le_64_raw, \ 5388 &gen_op_spe_st##name##_le_64_raw, \
5285 }; 5389 };
5286 #else /* defined(TARGET_PPC64) */ 5390 #else /* defined(TARGET_PPC64) */
  5391 +/* User-mode only - 32 bits mode */
5287 #define OP_SPE_LD_TABLE(name) \ 5392 #define OP_SPE_LD_TABLE(name) \
5288 static GenOpFunc *gen_op_spe_l##name[] = { \ 5393 static GenOpFunc *gen_op_spe_l##name[] = { \
5289 &gen_op_spe_l##name##_raw, \ 5394 &gen_op_spe_l##name##_raw, \
@@ -5296,30 +5401,64 @@ static GenOpFunc *gen_op_spe_st##name[] = { \ @@ -5296,30 +5401,64 @@ static GenOpFunc *gen_op_spe_st##name[] = { \
5296 }; 5401 };
5297 #endif /* defined(TARGET_PPC64) */ 5402 #endif /* defined(TARGET_PPC64) */
5298 #else /* defined(CONFIG_USER_ONLY) */ 5403 #else /* defined(CONFIG_USER_ONLY) */
5299 -#if defined(TARGET_PPC64) 5404 +#if defined(TARGET_PPC64H)
  5405 +/* Full system with hypervisor mode */
5300 #define OP_SPE_LD_TABLE(name) \ 5406 #define OP_SPE_LD_TABLE(name) \
5301 static GenOpFunc *gen_op_spe_l##name[] = { \ 5407 static GenOpFunc *gen_op_spe_l##name[] = { \
5302 &gen_op_spe_l##name##_user, \ 5408 &gen_op_spe_l##name##_user, \
5303 &gen_op_spe_l##name##_le_user, \ 5409 &gen_op_spe_l##name##_le_user, \
5304 - &gen_op_spe_l##name##_kernel, \  
5305 - &gen_op_spe_l##name##_le_kernel, \  
5306 &gen_op_spe_l##name##_64_user, \ 5410 &gen_op_spe_l##name##_64_user, \
5307 &gen_op_spe_l##name##_le_64_user, \ 5411 &gen_op_spe_l##name##_le_64_user, \
  5412 + &gen_op_spe_l##name##_kernel, \
  5413 + &gen_op_spe_l##name##_le_kernel, \
5308 &gen_op_spe_l##name##_64_kernel, \ 5414 &gen_op_spe_l##name##_64_kernel, \
5309 &gen_op_spe_l##name##_le_64_kernel, \ 5415 &gen_op_spe_l##name##_le_64_kernel, \
  5416 + &gen_op_spe_l##name##_hypv, \
  5417 + &gen_op_spe_l##name##_le_hypv, \
  5418 + &gen_op_spe_l##name##_64_hypv, \
  5419 + &gen_op_spe_l##name##_le_64_hypv, \
5310 }; 5420 };
5311 #define OP_SPE_ST_TABLE(name) \ 5421 #define OP_SPE_ST_TABLE(name) \
5312 static GenOpFunc *gen_op_spe_st##name[] = { \ 5422 static GenOpFunc *gen_op_spe_st##name[] = { \
5313 &gen_op_spe_st##name##_user, \ 5423 &gen_op_spe_st##name##_user, \
5314 &gen_op_spe_st##name##_le_user, \ 5424 &gen_op_spe_st##name##_le_user, \
  5425 + &gen_op_spe_st##name##_64_user, \
  5426 + &gen_op_spe_st##name##_le_64_user, \
5315 &gen_op_spe_st##name##_kernel, \ 5427 &gen_op_spe_st##name##_kernel, \
5316 &gen_op_spe_st##name##_le_kernel, \ 5428 &gen_op_spe_st##name##_le_kernel, \
  5429 + &gen_op_spe_st##name##_64_kernel, \
  5430 + &gen_op_spe_st##name##_le_64_kernel, \
  5431 + &gen_op_spe_st##name##_hypv, \
  5432 + &gen_op_spe_st##name##_le_hypv, \
  5433 + &gen_op_spe_st##name##_64_hypv, \
  5434 + &gen_op_spe_st##name##_le_64_hypv, \
  5435 +};
  5436 +#elif defined(TARGET_PPC64)
  5437 +/* Full system - 64 bits mode */
  5438 +#define OP_SPE_LD_TABLE(name) \
  5439 +static GenOpFunc *gen_op_spe_l##name[] = { \
  5440 + &gen_op_spe_l##name##_user, \
  5441 + &gen_op_spe_l##name##_le_user, \
  5442 + &gen_op_spe_l##name##_64_user, \
  5443 + &gen_op_spe_l##name##_le_64_user, \
  5444 + &gen_op_spe_l##name##_kernel, \
  5445 + &gen_op_spe_l##name##_le_kernel, \
  5446 + &gen_op_spe_l##name##_64_kernel, \
  5447 + &gen_op_spe_l##name##_le_64_kernel, \
  5448 +};
  5449 +#define OP_SPE_ST_TABLE(name) \
  5450 +static GenOpFunc *gen_op_spe_st##name[] = { \
  5451 + &gen_op_spe_st##name##_user, \
  5452 + &gen_op_spe_st##name##_le_user, \
5317 &gen_op_spe_st##name##_64_user, \ 5453 &gen_op_spe_st##name##_64_user, \
5318 &gen_op_spe_st##name##_le_64_user, \ 5454 &gen_op_spe_st##name##_le_64_user, \
  5455 + &gen_op_spe_st##name##_kernel, \
  5456 + &gen_op_spe_st##name##_le_kernel, \
5319 &gen_op_spe_st##name##_64_kernel, \ 5457 &gen_op_spe_st##name##_64_kernel, \
5320 &gen_op_spe_st##name##_le_64_kernel, \ 5458 &gen_op_spe_st##name##_le_64_kernel, \
5321 }; 5459 };
5322 #else /* defined(TARGET_PPC64) */ 5460 #else /* defined(TARGET_PPC64) */
  5461 +/* Full system - 32 bits mode */
5323 #define OP_SPE_LD_TABLE(name) \ 5462 #define OP_SPE_LD_TABLE(name) \
5324 static GenOpFunc *gen_op_spe_l##name[] = { \ 5463 static GenOpFunc *gen_op_spe_l##name[] = { \
5325 &gen_op_spe_l##name##_user, \ 5464 &gen_op_spe_l##name##_user, \
@@ -6173,6 +6312,7 @@ static inline int gen_intermediate_code_internal (CPUState *env, @@ -6173,6 +6312,7 @@ static inline int gen_intermediate_code_internal (CPUState *env,
6173 opc_handler_t **table, *handler; 6312 opc_handler_t **table, *handler;
6174 target_ulong pc_start; 6313 target_ulong pc_start;
6175 uint16_t *gen_opc_end; 6314 uint16_t *gen_opc_end;
  6315 + int supervisor;
6176 int j, lj = -1; 6316 int j, lj = -1;
6177 6317
6178 pc_start = tb->pc; 6318 pc_start = tb->pc;
@@ -6185,24 +6325,21 @@ static inline int gen_intermediate_code_internal (CPUState *env, @@ -6185,24 +6325,21 @@ static inline int gen_intermediate_code_internal (CPUState *env,
6185 ctx.exception = POWERPC_EXCP_NONE; 6325 ctx.exception = POWERPC_EXCP_NONE;
6186 ctx.spr_cb = env->spr_cb; 6326 ctx.spr_cb = env->spr_cb;
6187 #if defined(CONFIG_USER_ONLY) 6327 #if defined(CONFIG_USER_ONLY)
6188 - ctx.mem_idx = msr_le;  
6189 -#if defined(TARGET_PPC64)  
6190 - ctx.mem_idx |= msr_sf << 1;  
6191 -#endif 6328 + supervisor = 0;
6192 #else 6329 #else
6193 #if defined(TARGET_PPC64H) 6330 #if defined(TARGET_PPC64H)
6194 if (msr_pr == 0 && msr_hv == 1) 6331 if (msr_pr == 0 && msr_hv == 1)
6195 - ctx.supervisor = 2; 6332 + supervisor = 2;
6196 else 6333 else
6197 #endif 6334 #endif
6198 - ctx.supervisor = 1 - msr_pr;  
6199 - ctx.mem_idx = ((1 - msr_pr) << 1) | msr_le;  
6200 -#if defined(TARGET_PPC64)  
6201 - ctx.mem_idx |= msr_sf << 2;  
6202 -#endif 6335 + supervisor = 1 - msr_pr;
  6336 + ctx.supervisor = supervisor;
6203 #endif 6337 #endif
6204 #if defined(TARGET_PPC64) 6338 #if defined(TARGET_PPC64)
6205 ctx.sf_mode = msr_sf; 6339 ctx.sf_mode = msr_sf;
  6340 + ctx.mem_idx = (supervisor << 2) | (msr_sf << 1) | msr_le;
  6341 +#else
  6342 + ctx.mem_idx = (supervisor << 1) | msr_le;
6206 #endif 6343 #endif
6207 ctx.fpu_enabled = msr_fp; 6344 ctx.fpu_enabled = msr_fp;
6208 #if defined(TARGET_PPCEMB) 6345 #if defined(TARGET_PPCEMB)