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
|