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); |
Also available in: Unified diff