Revision 7863667f target-ppc/translate.c

b/target-ppc/translate.c
1250 1250
                gen_op_store_pri(6);
1251 1251
            }
1252 1252
            break;
1253
#if defined(TARGET_PPC64H)
1254 1253
        case 7:
1255 1254
            if (ctx->supervisor > 1) {
1256 1255
                /* Set process priority to very high */
......
1258 1257
            }
1259 1258
            break;
1260 1259
#endif
1261
#endif
1262 1260
        default:
1263 1261
            /* nop */
1264 1262
            break;
......
2103 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 2115
#if defined(CONFIG_USER_ONLY)
2109 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 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 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 2123
#else
2145 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 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 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 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 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 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 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 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 2163
#define GEN_LD(width, opc, type)                                              \
2238 2164
GEN_HANDLER(l##width, opc, 0xFF, 0xFF, 0x00000000, type)                      \
......
2487 2413

  
2488 2414
/***                    Integer load and store multiple                    ***/
2489 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 2423
/* lmw */
2561 2424
GEN_HANDLER(lmw, 0x2E, 0xFF, 0xFF, 0x00000000, PPC_INTEGER)
......
2578 2441
/***                    Integer load and store strings                     ***/
2579 2442
#define op_ldsts(name, start) (*gen_op_##name[ctx->mem_idx])(start)
2580 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 2454
/* lswi */
2682 2455
/* PowerPC32 specification says we must generate an exception if
......
2762 2535

  
2763 2536
#define op_lwarx() (*gen_op_lwarx[ctx->mem_idx])()
2764 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 2545
/* lwarx */
2836 2546
GEN_HANDLER(lwarx, 0x1F, 0x14, 0x00, 0x00000001, PPC_RES)
......
2855 2565
#if defined(TARGET_PPC64)
2856 2566
#define op_ldarx() (*gen_op_ldarx[ctx->mem_idx])()
2857 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 2575
/* ldarx */
2909 2576
GEN_HANDLER(ldarx, 0x1F, 0x14, 0x02, 0x00000001, PPC_64B)
......
3406 3073
    GEN_SYNC(ctx);
3407 3074
#endif
3408 3075
}
3409
#endif
3410 3076

  
3411
#if defined(TARGET_PPC64H)
3412 3077
GEN_HANDLER(hrfid, 0x13, 0x12, 0x08, 0x03FF8001, PPC_64B)
3413 3078
{
3414 3079
#if defined(CONFIG_USER_ONLY)
......
3542 3207
    uint32_t sprn = SPR(ctx->opcode);
3543 3208

  
3544 3209
#if !defined(CONFIG_USER_ONLY)
3545
#if defined(TARGET_PPC64H)
3546 3210
    if (ctx->supervisor == 2)
3547 3211
        read_cb = ctx->spr_cb[sprn].hea_read;
3548
    else
3549
#endif
3550
    if (ctx->supervisor)
3212
    else if (ctx->supervisor)
3551 3213
        read_cb = ctx->spr_cb[sprn].oea_read;
3552 3214
    else
3553 3215
#endif
......
3682 3344
    uint32_t sprn = SPR(ctx->opcode);
3683 3345

  
3684 3346
#if !defined(CONFIG_USER_ONLY)
3685
#if defined(TARGET_PPC64H)
3686 3347
    if (ctx->supervisor == 2)
3687 3348
        write_cb = ctx->spr_cb[sprn].hea_write;
3688
    else
3689
#endif
3690
    if (ctx->supervisor)
3349
    else if (ctx->supervisor)
3691 3350
        write_cb = ctx->spr_cb[sprn].oea_write;
3692 3351
    else
3693 3352
#endif
......
3773 3432

  
3774 3433
/* dcbz */
3775 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 3486
static always_inline void handler_dcbz (DisasContext *ctx,
3913 3487
                                        int dcache_line_size)
......
3950 3524

  
3951 3525
/* icbi */
3952 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 3539
GEN_HANDLER(icbi, 0x1F, 0x16, 0x1E, 0x03E00001, PPC_CACHE_ICBI)
3994 3540
{
......
4239 3785
/* Optional: */
4240 3786
#define op_eciwx() (*gen_op_eciwx[ctx->mem_idx])()
4241 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 3795
/* eciwx */
4313 3796
GEN_HANDLER(eciwx, 0x1F, 0x16, 0x0D, 0x00000001, PPC_EXTERN)
......
4432 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 3921
#define op_POWER_lscbx(start, ra, rb)                                         \
4437 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 3939
/* lscbx - lscbx. */
4453 3940
GEN_HANDLER(lscbx, 0x1F, 0x15, 0x08, 0x00000000, PPC_POWER_BR)
......
4901 4388

  
4902 4389
/* POWER2 specific instructions */
4903 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 4392
#define op_POWER2_lfq() (*gen_op_POWER2_lfq[ctx->mem_idx])()
4905 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 4417
/* lfq */
4931 4418
GEN_HANDLER(lfq, 0x38, 0xFF, 0xFF, 0x00000003, PPC_POWER2)
......
5687 5174
#endif
5688 5175

  
5689 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 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 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 5186
#define GEN_VR_LDX(name, opc2, opc3)                                          \
5797 5187
GEN_HANDLER(l##name, 0x1F, opc2, opc3, 0x00000001, PPC_ALTIVEC)               \
......
5830 5220
GEN_VR_STX(vxl, 0x07, 0x0F);
5831 5221

  
5832 5222
/***                           SPE extension                               ***/
5833

  
5834 5223
/* Register moves */
5835 5224
#if !defined(TARGET_PPC64)
5836 5225

  
......
5893 5282
}
5894 5283

  
5895 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 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 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 5294
#define GEN_SPE_LD(name, sh)                                                  \
6003 5295
static always_inline void gen_evl##name (DisasContext *ctx)                   \
......
6258 5550
/* In that case, we already have 64 bits load & stores
6259 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 5585
#endif /* defined(TARGET_PPC64) */
6301 5586
GEN_SPEOP_LDST(dd, 3);
6302 5587
GEN_SPEOP_LDST(dw, 3);
......
6308 5593

  
6309 5594
#if defined(TARGET_PPC64)
6310 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 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 5612
#endif
6333 5613
#define _GEN_OP_SPE_STWWE(suffix)                                             \
6334 5614
static always_inline void gen_op_spe_stwwe_##suffix (void)                    \
......
6364 5644
#if defined(CONFIG_USER_ONLY)
6365 5645
GEN_OP_SPE_STWWE(raw);
6366 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 5647
GEN_OP_SPE_STWWE(user);
5648
GEN_OP_SPE_STWWE(kernel);
5649
GEN_OP_SPE_STWWE(hypv);
6372 5650
#endif /* defined(CONFIG_USER_ONLY) */
6373 5651
GEN_SPEOP_ST(wwe, 2);
6374 5652
GEN_SPEOP_ST(wwo, 2);
......
6418 5696
GEN_SPE_LDSPLAT(hhossplat, spe_lhx, le_64_raw);
6419 5697
#endif
6420 5698
#else
6421
#if defined(TARGET_PPC64H)
6422
GEN_OP_SPE_LHE(hypv);
6423
#endif
6424
GEN_OP_SPE_LHE(kernel);
6425 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 5751
GEN_SPE_LDSPLAT(hhossplat, spe_lhx, 64_user);
6512
#if defined(TARGET_PPC64H)
6513
GEN_OP_SPE_LHX(le_64_hypv);
... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff