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 1979 #define op_ldst(name) (*gen_op_##name[ctx->mem_idx])()
1980 1980 #if defined(CONFIG_USER_ONLY)
1981 1981 #if defined(TARGET_PPC64)
  1982 +/* User mode only - 64 bits */
1982 1983 #define OP_LD_TABLE(width) \
1983 1984 static GenOpFunc *gen_op_l##width[] = { \
1984 1985 &gen_op_l##width##_raw, \
... ... @@ -1997,6 +1998,7 @@ static GenOpFunc *gen_op_st##width[] = { \
1997 1998 #define gen_op_stb_le_64_raw gen_op_stb_64_raw
1998 1999 #define gen_op_lbz_le_64_raw gen_op_lbz_64_raw
1999 2000 #else
  2001 +/* User mode only - 32 bits */
2000 2002 #define OP_LD_TABLE(width) \
2001 2003 static GenOpFunc *gen_op_l##width[] = { \
2002 2004 &gen_op_l##width##_raw, \
... ... @@ -2013,34 +2015,75 @@ static GenOpFunc *gen_op_st##width[] = { \
2013 2015 #define gen_op_lbz_le_raw gen_op_lbz_raw
2014 2016 #else
2015 2017 #if defined(TARGET_PPC64)
  2018 +#if defined(TARGET_PPC64H)
  2019 +/* Full system - 64 bits with hypervisor mode */
2016 2020 #define OP_LD_TABLE(width) \
2017 2021 static GenOpFunc *gen_op_l##width[] = { \
2018 2022 &gen_op_l##width##_user, \
2019 2023 &gen_op_l##width##_le_user, \
2020   - &gen_op_l##width##_kernel, \
2021   - &gen_op_l##width##_le_kernel, \
2022 2024 &gen_op_l##width##_64_user, \
2023 2025 &gen_op_l##width##_le_64_user, \
  2026 + &gen_op_l##width##_kernel, \
  2027 + &gen_op_l##width##_le_kernel, \
2024 2028 &gen_op_l##width##_64_kernel, \
2025 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 2035 #define OP_ST_TABLE(width) \
2028 2036 static GenOpFunc *gen_op_st##width[] = { \
2029 2037 &gen_op_st##width##_user, \
2030 2038 &gen_op_st##width##_le_user, \
  2039 + &gen_op_st##width##_64_user, \
  2040 + &gen_op_st##width##_le_64_user, \
2031 2041 &gen_op_st##width##_kernel, \
2032 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 2072 &gen_op_st##width##_64_user, \
2034 2073 &gen_op_st##width##_le_64_user, \
  2074 + &gen_op_st##width##_kernel, \
  2075 + &gen_op_st##width##_le_kernel, \
2035 2076 &gen_op_st##width##_64_kernel, \
2036 2077 &gen_op_st##width##_le_64_kernel, \
2037 2078 };
  2079 +#endif
2038 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 2083 #define gen_op_stb_le_64_kernel gen_op_stb_64_kernel
2042 2084 #define gen_op_lbz_le_64_kernel gen_op_lbz_64_kernel
2043 2085 #else
  2086 +/* Full system - 32 bits */
2044 2087 #define OP_LD_TABLE(width) \
2045 2088 static GenOpFunc *gen_op_l##width[] = { \
2046 2089 &gen_op_l##width##_user, \
... ... @@ -2057,8 +2100,8 @@ static GenOpFunc *gen_op_st##width[] = { \
2057 2100 };
2058 2101 #endif
2059 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 2105 #define gen_op_stb_le_kernel gen_op_stb_kernel
2063 2106 #define gen_op_lbz_le_kernel gen_op_lbz_kernel
2064 2107 #endif
... ... @@ -2316,51 +2359,61 @@ GEN_STX(wbr, 0x16, 0x14, PPC_INTEGER);
2316 2359  
2317 2360 /*** Integer load and store multiple ***/
2318 2361 #define op_ldstm(name, reg) (*gen_op_##name[ctx->mem_idx])(reg)
2319   -#if defined(TARGET_PPC64)
2320 2362 #if defined(CONFIG_USER_ONLY)
  2363 +/* User-mode only */
2321 2364 static GenOpFunc1 *gen_op_lmw[] = {
2322 2365 &gen_op_lmw_raw,
2323 2366 &gen_op_lmw_le_raw,
  2367 +#if defined(TARGET_PPC64)
2324 2368 &gen_op_lmw_64_raw,
2325 2369 &gen_op_lmw_le_64_raw,
  2370 +#endif
2326 2371 };
2327 2372 static GenOpFunc1 *gen_op_stmw[] = {
  2373 + &gen_op_stmw_raw,
  2374 + &gen_op_stmw_le_raw,
  2375 +#if defined(TARGET_PPC64)
2328 2376 &gen_op_stmw_64_raw,
2329 2377 &gen_op_stmw_le_64_raw,
  2378 +#endif
2330 2379 };
2331 2380 #else
  2381 +#if defined(TARGET_PPC64)
  2382 +/* Full system - 64 bits mode */
2332 2383 static GenOpFunc1 *gen_op_lmw[] = {
2333 2384 &gen_op_lmw_user,
2334 2385 &gen_op_lmw_le_user,
2335   - &gen_op_lmw_kernel,
2336   - &gen_op_lmw_le_kernel,
2337 2386 &gen_op_lmw_64_user,
2338 2387 &gen_op_lmw_le_64_user,
  2388 + &gen_op_lmw_kernel,
  2389 + &gen_op_lmw_le_kernel,
2339 2390 &gen_op_lmw_64_kernel,
2340 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 2399 static GenOpFunc1 *gen_op_stmw[] = {
2343 2400 &gen_op_stmw_user,
2344 2401 &gen_op_stmw_le_user,
2345   - &gen_op_stmw_kernel,
2346   - &gen_op_stmw_le_kernel,
2347 2402 &gen_op_stmw_64_user,
2348 2403 &gen_op_stmw_le_64_user,
  2404 + &gen_op_stmw_kernel,
  2405 + &gen_op_stmw_le_kernel,
2349 2406 &gen_op_stmw_64_kernel,
2350 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 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 2415 #else
  2416 +/* Full system - 32 bits mode */
2364 2417 static GenOpFunc1 *gen_op_lmw[] = {
2365 2418 &gen_op_lmw_user,
2366 2419 &gen_op_lmw_le_user,
... ... @@ -2397,73 +2450,85 @@ GEN_HANDLER(stmw, 0x2F, 0xFF, 0xFF, 0x00000000, PPC_INTEGER)
2397 2450 /*** Integer load and store strings ***/
2398 2451 #define op_ldsts(name, start) (*gen_op_##name[ctx->mem_idx])(start)
2399 2452 #define op_ldstsx(name, rd, ra, rb) (*gen_op_##name[ctx->mem_idx])(rd, ra, rb)
2400   -#if defined(TARGET_PPC64)
2401 2453 #if defined(CONFIG_USER_ONLY)
  2454 +/* User-mode only */
2402 2455 static GenOpFunc1 *gen_op_lswi[] = {
2403 2456 &gen_op_lswi_raw,
2404 2457 &gen_op_lswi_le_raw,
  2458 +#if defined(TARGET_PPC64)
2405 2459 &gen_op_lswi_64_raw,
2406 2460 &gen_op_lswi_le_64_raw,
  2461 +#endif
2407 2462 };
2408 2463 static GenOpFunc3 *gen_op_lswx[] = {
2409 2464 &gen_op_lswx_raw,
2410 2465 &gen_op_lswx_le_raw,
  2466 +#if defined(TARGET_PPC64)
2411 2467 &gen_op_lswx_64_raw,
2412 2468 &gen_op_lswx_le_64_raw,
  2469 +#endif
2413 2470 };
2414 2471 static GenOpFunc1 *gen_op_stsw[] = {
2415 2472 &gen_op_stsw_raw,
2416 2473 &gen_op_stsw_le_raw,
  2474 +#if defined(TARGET_PPC64)
2417 2475 &gen_op_stsw_64_raw,
2418 2476 &gen_op_stsw_le_64_raw,
  2477 +#endif
2419 2478 };
2420 2479 #else
  2480 +#if defined(TARGET_PPC64)
  2481 +/* Full system - 64 bits mode */
2421 2482 static GenOpFunc1 *gen_op_lswi[] = {
2422 2483 &gen_op_lswi_user,
2423 2484 &gen_op_lswi_le_user,
2424   - &gen_op_lswi_kernel,
2425   - &gen_op_lswi_le_kernel,
2426 2485 &gen_op_lswi_64_user,
2427 2486 &gen_op_lswi_le_64_user,
  2487 + &gen_op_lswi_kernel,
  2488 + &gen_op_lswi_le_kernel,
2428 2489 &gen_op_lswi_64_kernel,
2429 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 2498 static GenOpFunc3 *gen_op_lswx[] = {
2432 2499 &gen_op_lswx_user,
2433 2500 &gen_op_lswx_le_user,
2434   - &gen_op_lswx_kernel,
2435   - &gen_op_lswx_le_kernel,
2436 2501 &gen_op_lswx_64_user,
2437 2502 &gen_op_lswx_le_64_user,
  2503 + &gen_op_lswx_kernel,
  2504 + &gen_op_lswx_le_kernel,
2438 2505 &gen_op_lswx_64_kernel,
2439 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 2514 static GenOpFunc1 *gen_op_stsw[] = {
2442 2515 &gen_op_stsw_user,
2443 2516 &gen_op_stsw_le_user,
2444   - &gen_op_stsw_kernel,
2445   - &gen_op_stsw_le_kernel,
2446 2517 &gen_op_stsw_64_user,
2447 2518 &gen_op_stsw_le_64_user,
  2519 + &gen_op_stsw_kernel,
  2520 + &gen_op_stsw_le_kernel,
2448 2521 &gen_op_stsw_64_kernel,
2449 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 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 2530 #else
  2531 +/* Full system - 32 bits mode */
2467 2532 static GenOpFunc1 *gen_op_lswi[] = {
2468 2533 &gen_op_lswi_user,
2469 2534 &gen_op_lswi_le_user,
... ... @@ -2569,53 +2634,61 @@ GEN_HANDLER(isync, 0x13, 0x16, 0x04, 0x03FFF801, PPC_MEM)
2569 2634  
2570 2635 #define op_lwarx() (*gen_op_lwarx[ctx->mem_idx])()
2571 2636 #define op_stwcx() (*gen_op_stwcx[ctx->mem_idx])()
2572   -#if defined(TARGET_PPC64)
2573 2637 #if defined(CONFIG_USER_ONLY)
  2638 +/* User-mode only */
2574 2639 static GenOpFunc *gen_op_lwarx[] = {
2575 2640 &gen_op_lwarx_raw,
2576 2641 &gen_op_lwarx_le_raw,
  2642 +#if defined(TARGET_PPC64)
2577 2643 &gen_op_lwarx_64_raw,
2578 2644 &gen_op_lwarx_le_64_raw,
  2645 +#endif
2579 2646 };
2580 2647 static GenOpFunc *gen_op_stwcx[] = {
2581 2648 &gen_op_stwcx_raw,
2582 2649 &gen_op_stwcx_le_raw,
  2650 +#if defined(TARGET_PPC64)
2583 2651 &gen_op_stwcx_64_raw,
2584 2652 &gen_op_stwcx_le_64_raw,
  2653 +#endif
2585 2654 };
2586 2655 #else
  2656 +#if defined(TARGET_PPC64)
  2657 +/* Full system - 64 bits mode */
2587 2658 static GenOpFunc *gen_op_lwarx[] = {
2588 2659 &gen_op_lwarx_user,
2589 2660 &gen_op_lwarx_le_user,
2590   - &gen_op_lwarx_kernel,
2591   - &gen_op_lwarx_le_kernel,
2592 2661 &gen_op_lwarx_64_user,
2593 2662 &gen_op_lwarx_le_64_user,
  2663 + &gen_op_lwarx_kernel,
  2664 + &gen_op_lwarx_le_kernel,
2594 2665 &gen_op_lwarx_64_kernel,
2595 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 2674 static GenOpFunc *gen_op_stwcx[] = {
2598 2675 &gen_op_stwcx_user,
2599 2676 &gen_op_stwcx_le_user,
2600   - &gen_op_stwcx_kernel,
2601   - &gen_op_stwcx_le_kernel,
2602 2677 &gen_op_stwcx_64_user,
2603 2678 &gen_op_stwcx_le_64_user,
  2679 + &gen_op_stwcx_kernel,
  2680 + &gen_op_stwcx_le_kernel,
2604 2681 &gen_op_stwcx_64_kernel,
2605 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 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 2690 #else
  2691 +/* Full system - 32 bits mode */
2619 2692 static GenOpFunc *gen_op_lwarx[] = {
2620 2693 &gen_op_lwarx_user,
2621 2694 &gen_op_lwarx_le_user,
... ... @@ -2655,6 +2728,7 @@ GEN_HANDLER(stwcx_, 0x1F, 0x16, 0x04, 0x00000000, PPC_RES)
2655 2728 #define op_ldarx() (*gen_op_ldarx[ctx->mem_idx])()
2656 2729 #define op_stdcx() (*gen_op_stdcx[ctx->mem_idx])()
2657 2730 #if defined(CONFIG_USER_ONLY)
  2731 +/* User-mode only */
2658 2732 static GenOpFunc *gen_op_ldarx[] = {
2659 2733 &gen_op_ldarx_raw,
2660 2734 &gen_op_ldarx_le_raw,
... ... @@ -2668,25 +2742,38 @@ static GenOpFunc *gen_op_stdcx[] = {
2668 2742 &gen_op_stdcx_le_64_raw,
2669 2743 };
2670 2744 #else
  2745 +/* Full system */
2671 2746 static GenOpFunc *gen_op_ldarx[] = {
2672 2747 &gen_op_ldarx_user,
2673 2748 &gen_op_ldarx_le_user,
2674   - &gen_op_ldarx_kernel,
2675   - &gen_op_ldarx_le_kernel,
2676 2749 &gen_op_ldarx_64_user,
2677 2750 &gen_op_ldarx_le_64_user,
  2751 + &gen_op_ldarx_kernel,
  2752 + &gen_op_ldarx_le_kernel,
2678 2753 &gen_op_ldarx_64_kernel,
2679 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 2762 static GenOpFunc *gen_op_stdcx[] = {
2682 2763 &gen_op_stdcx_user,
2683 2764 &gen_op_stdcx_le_user,
2684   - &gen_op_stdcx_kernel,
2685   - &gen_op_stdcx_le_kernel,
2686 2765 &gen_op_stdcx_64_user,
2687 2766 &gen_op_stdcx_le_64_user,
  2767 + &gen_op_stdcx_kernel,
  2768 + &gen_op_stdcx_le_kernel,
2688 2769 &gen_op_stdcx_64_kernel,
2689 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 2778 #endif
2692 2779  
... ... @@ -3537,33 +3624,37 @@ GEN_HANDLER(dcbtst, 0x1F, 0x16, 0x07, 0x02000001, PPC_CACHE)
3537 3624  
3538 3625 /* dcbz */
3539 3626 #define op_dcbz() (*gen_op_dcbz[ctx->mem_idx])()
3540   -#if defined(TARGET_PPC64)
3541 3627 #if defined(CONFIG_USER_ONLY)
  3628 +/* User-mode only */
3542 3629 static GenOpFunc *gen_op_dcbz[] = {
3543 3630 &gen_op_dcbz_raw,
3544 3631 &gen_op_dcbz_raw,
  3632 +#if defined(TARGET_PPC64)
3545 3633 &gen_op_dcbz_64_raw,
3546 3634 &gen_op_dcbz_64_raw,
  3635 +#endif
3547 3636 };
3548 3637 #else
  3638 +#if defined(TARGET_PPC64)
  3639 +/* Full system - 64 bits mode */
3549 3640 static GenOpFunc *gen_op_dcbz[] = {
3550 3641 &gen_op_dcbz_user,
3551 3642 &gen_op_dcbz_user,
3552   - &gen_op_dcbz_kernel,
3553   - &gen_op_dcbz_kernel,
3554 3643 &gen_op_dcbz_64_user,
3555 3644 &gen_op_dcbz_64_user,
  3645 + &gen_op_dcbz_kernel,
  3646 + &gen_op_dcbz_kernel,
3556 3647 &gen_op_dcbz_64_kernel,
3557 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 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 3656 #else
  3657 +/* Full system - 32 bits mode */
3567 3658 static GenOpFunc *gen_op_dcbz[] = {
3568 3659 &gen_op_dcbz_user,
3569 3660 &gen_op_dcbz_user,
... ... @@ -3582,33 +3673,37 @@ GEN_HANDLER(dcbz, 0x1F, 0x16, 0x1F, 0x03E00001, PPC_CACHE)
3582 3673  
3583 3674 /* icbi */
3584 3675 #define op_icbi() (*gen_op_icbi[ctx->mem_idx])()
3585   -#if defined(TARGET_PPC64)
3586 3676 #if defined(CONFIG_USER_ONLY)
  3677 +/* User-mode only */
3587 3678 static GenOpFunc *gen_op_icbi[] = {
3588 3679 &gen_op_icbi_raw,
3589 3680 &gen_op_icbi_raw,
  3681 +#if defined(TARGET_PPC64)
3590 3682 &gen_op_icbi_64_raw,
3591 3683 &gen_op_icbi_64_raw,
  3684 +#endif
3592 3685 };
3593 3686 #else
  3687 +/* Full system - 64 bits mode */
  3688 +#if defined(TARGET_PPC64)
3594 3689 static GenOpFunc *gen_op_icbi[] = {
3595 3690 &gen_op_icbi_user,
3596 3691 &gen_op_icbi_user,
3597   - &gen_op_icbi_kernel,
3598   - &gen_op_icbi_kernel,
3599 3692 &gen_op_icbi_64_user,
3600 3693 &gen_op_icbi_64_user,
  3694 + &gen_op_icbi_kernel,
  3695 + &gen_op_icbi_kernel,
3601 3696 &gen_op_icbi_64_kernel,
3602 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 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 3705 #else
  3706 +/* Full system - 32 bits mode */
3612 3707 static GenOpFunc *gen_op_icbi[] = {
3613 3708 &gen_op_icbi_user,
3614 3709 &gen_op_icbi_user,
... ... @@ -3796,53 +3891,61 @@ GEN_HANDLER(slbie, 0x1F, 0x12, 0x0D, 0x03FF0001, PPC_SLBI)
3796 3891 /* Optional: */
3797 3892 #define op_eciwx() (*gen_op_eciwx[ctx->mem_idx])()
3798 3893 #define op_ecowx() (*gen_op_ecowx[ctx->mem_idx])()
3799   -#if defined(TARGET_PPC64)
3800 3894 #if defined(CONFIG_USER_ONLY)
  3895 +/* User-mode only */
3801 3896 static GenOpFunc *gen_op_eciwx[] = {
3802 3897 &gen_op_eciwx_raw,
3803 3898 &gen_op_eciwx_le_raw,
  3899 +#if defined(TARGET_PPC64)
3804 3900 &gen_op_eciwx_64_raw,
3805 3901 &gen_op_eciwx_le_64_raw,
  3902 +#endif
3806 3903 };
3807 3904 static GenOpFunc *gen_op_ecowx[] = {
3808 3905 &gen_op_ecowx_raw,
3809 3906 &gen_op_ecowx_le_raw,
  3907 +#if defined(TARGET_PPC64)
3810 3908 &gen_op_ecowx_64_raw,
3811 3909 &gen_op_ecowx_le_64_raw,
  3910 +#endif
3812 3911 };
3813 3912 #else
  3913 +#if defined(TARGET_PPC64)
  3914 +/* Full system - 64 bits mode */
3814 3915 static GenOpFunc *gen_op_eciwx[] = {
3815 3916 &gen_op_eciwx_user,
3816 3917 &gen_op_eciwx_le_user,
3817   - &gen_op_eciwx_kernel,
3818   - &gen_op_eciwx_le_kernel,
3819 3918 &gen_op_eciwx_64_user,
3820 3919 &gen_op_eciwx_le_64_user,
  3920 + &gen_op_eciwx_kernel,
  3921 + &gen_op_eciwx_le_kernel,
3821 3922 &gen_op_eciwx_64_kernel,
3822 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 3931 static GenOpFunc *gen_op_ecowx[] = {
3825 3932 &gen_op_ecowx_user,
3826 3933 &gen_op_ecowx_le_user,
3827   - &gen_op_ecowx_kernel,
3828   - &gen_op_ecowx_le_kernel,
3829 3934 &gen_op_ecowx_64_user,
3830 3935 &gen_op_ecowx_le_64_user,
  3936 + &gen_op_ecowx_kernel,
  3937 + &gen_op_ecowx_le_kernel,
3831 3938 &gen_op_ecowx_64_kernel,
3832 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 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 3947 #else
  3948 +/* Full system - 32 bits mode */
3846 3949 static GenOpFunc *gen_op_eciwx[] = {
3847 3950 &gen_op_eciwx_user,
3848 3951 &gen_op_eciwx_le_user,
... ... @@ -3981,7 +4084,7 @@ GEN_HANDLER(dozi, 0x09, 0xFF, 0xFF, 0x00000000, PPC_POWER_BR)
3981 4084 }
3982 4085  
3983 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 4088 (*gen_op_POWER_lscbx[ctx->mem_idx])(start, ra, rb)
3986 4089 #if defined(CONFIG_USER_ONLY)
3987 4090 static GenOpFunc3 *gen_op_POWER_lscbx[] = {
... ... @@ -5269,6 +5372,7 @@ static inline void gen_addr_spe_imm_index (DisasContext *ctx, int sh)
5269 5372 #define op_spe_ldst(name) (*gen_op_##name[ctx->mem_idx])()
5270 5373 #if defined(CONFIG_USER_ONLY)
5271 5374 #if defined(TARGET_PPC64)
  5375 +/* User-mode only - 64 bits mode */
5272 5376 #define OP_SPE_LD_TABLE(name) \
5273 5377 static GenOpFunc *gen_op_spe_l##name[] = { \
5274 5378 &gen_op_spe_l##name##_raw, \
... ... @@ -5284,6 +5388,7 @@ static GenOpFunc *gen_op_spe_st##name[] = { \
5284 5388 &gen_op_spe_st##name##_le_64_raw, \
5285 5389 };
5286 5390 #else /* defined(TARGET_PPC64) */
  5391 +/* User-mode only - 32 bits mode */
5287 5392 #define OP_SPE_LD_TABLE(name) \
5288 5393 static GenOpFunc *gen_op_spe_l##name[] = { \
5289 5394 &gen_op_spe_l##name##_raw, \
... ... @@ -5296,30 +5401,64 @@ static GenOpFunc *gen_op_spe_st##name[] = { \
5296 5401 };
5297 5402 #endif /* defined(TARGET_PPC64) */
5298 5403 #else /* defined(CONFIG_USER_ONLY) */
5299   -#if defined(TARGET_PPC64)
  5404 +#if defined(TARGET_PPC64H)
  5405 +/* Full system with hypervisor mode */
5300 5406 #define OP_SPE_LD_TABLE(name) \
5301 5407 static GenOpFunc *gen_op_spe_l##name[] = { \
5302 5408 &gen_op_spe_l##name##_user, \
5303 5409 &gen_op_spe_l##name##_le_user, \
5304   - &gen_op_spe_l##name##_kernel, \
5305   - &gen_op_spe_l##name##_le_kernel, \
5306 5410 &gen_op_spe_l##name##_64_user, \
5307 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 5414 &gen_op_spe_l##name##_64_kernel, \
5309 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 5421 #define OP_SPE_ST_TABLE(name) \
5312 5422 static GenOpFunc *gen_op_spe_st##name[] = { \
5313 5423 &gen_op_spe_st##name##_user, \
5314 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 5427 &gen_op_spe_st##name##_kernel, \
5316 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 5453 &gen_op_spe_st##name##_64_user, \
5318 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 5457 &gen_op_spe_st##name##_64_kernel, \
5320 5458 &gen_op_spe_st##name##_le_64_kernel, \
5321 5459 };
5322 5460 #else /* defined(TARGET_PPC64) */
  5461 +/* Full system - 32 bits mode */
5323 5462 #define OP_SPE_LD_TABLE(name) \
5324 5463 static GenOpFunc *gen_op_spe_l##name[] = { \
5325 5464 &gen_op_spe_l##name##_user, \
... ... @@ -6173,6 +6312,7 @@ static inline int gen_intermediate_code_internal (CPUState *env,
6173 6312 opc_handler_t **table, *handler;
6174 6313 target_ulong pc_start;
6175 6314 uint16_t *gen_opc_end;
  6315 + int supervisor;
6176 6316 int j, lj = -1;
6177 6317  
6178 6318 pc_start = tb->pc;
... ... @@ -6185,24 +6325,21 @@ static inline int gen_intermediate_code_internal (CPUState *env,
6185 6325 ctx.exception = POWERPC_EXCP_NONE;
6186 6326 ctx.spr_cb = env->spr_cb;
6187 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 6329 #else
6193 6330 #if defined(TARGET_PPC64H)
6194 6331 if (msr_pr == 0 && msr_hv == 1)
6195   - ctx.supervisor = 2;
  6332 + supervisor = 2;
6196 6333 else
6197 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 6337 #endif
6204 6338 #if defined(TARGET_PPC64)
6205 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 6343 #endif
6207 6344 ctx.fpu_enabled = msr_fp;
6208 6345 #if defined(TARGET_PPCEMB)
... ...