gwj / at91sam9263 · Commits

Commit e7c240035fe1ffbb6efba10e8db002f92459ad00

Authored by j_mayer
1 parent 67d6abff

Add new sane low-level memory accessors for PowerPC that do proper 

size or zero extension, with homogenous names.
Fix load & store strings: those are now endian-sensitive, by definition.
Fix dcbz: must always align the target address to a cache line boundary.


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@3719 c046a42c-6fe2-441c-8c8c-71466251a162
Inline Side-by-side
Showing 5 changed files with 443 additions and 524 deletions
target-ppc/op_helper.h
  View file @e7c2400
@@ -22,9 +22,7 @@ @@ -22,9 +22,7 @@
22 22
23 /* Memory load/store helpers */ 23 /* Memory load/store helpers */
24 void glue(do_lsw, MEMSUFFIX) (int dst); 24 void glue(do_lsw, MEMSUFFIX) (int dst);
25 -void glue(do_lsw_le, MEMSUFFIX) (int dst);  
26 void glue(do_stsw, MEMSUFFIX) (int src); 25 void glue(do_stsw, MEMSUFFIX) (int src);
27 -void glue(do_stsw_le, MEMSUFFIX) (int src);  
28 void glue(do_lmw, MEMSUFFIX) (int dst); 26 void glue(do_lmw, MEMSUFFIX) (int dst);
29 void glue(do_lmw_le, MEMSUFFIX) (int dst); 27 void glue(do_lmw_le, MEMSUFFIX) (int dst);
30 void glue(do_stmw, MEMSUFFIX) (int src); 28 void glue(do_stmw, MEMSUFFIX) (int src);
@@ -39,9 +37,7 @@ void glue(do_POWER2_stfq_le, MEMSUFFIX) (void); @@ -39,9 +37,7 @@ void glue(do_POWER2_stfq_le, MEMSUFFIX) (void);
39 37
40 #if defined(TARGET_PPC64) 38 #if defined(TARGET_PPC64)
41 void glue(do_lsw_64, MEMSUFFIX) (int dst); 39 void glue(do_lsw_64, MEMSUFFIX) (int dst);
42 -void glue(do_lsw_le_64, MEMSUFFIX) (int dst);  
43 void glue(do_stsw_64, MEMSUFFIX) (int src); 40 void glue(do_stsw_64, MEMSUFFIX) (int src);
44 -void glue(do_stsw_le_64, MEMSUFFIX) (int src);  
45 void glue(do_lmw_64, MEMSUFFIX) (int dst); 41 void glue(do_lmw_64, MEMSUFFIX) (int dst);
46 void glue(do_lmw_le_64, MEMSUFFIX) (int dst); 42 void glue(do_lmw_le_64, MEMSUFFIX) (int dst);
47 void glue(do_stmw_64, MEMSUFFIX) (int src); 43 void glue(do_stmw_64, MEMSUFFIX) (int src);
target-ppc/op_helper_mem.h
  View file @e7c2400
@@ -18,27 +18,13 @@ @@ -18,27 +18,13 @@
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */ 19 */
20 20
21 -/* Multiple word / string load and store */  
22 -static always_inline target_ulong glue(ld32r, MEMSUFFIX) (target_ulong EA)  
23 -{  
24 - uint32_t tmp = glue(ldl, MEMSUFFIX)(EA);  
25 - return ((tmp & 0xFF000000UL) >> 24) | ((tmp & 0x00FF0000UL) >> 8) |  
26 - ((tmp & 0x0000FF00UL) << 8) | ((tmp & 0x000000FFUL) << 24);  
27 -}  
28 -  
29 -static always_inline void glue(st32r, MEMSUFFIX) (target_ulong EA,  
30 - target_ulong data)  
31 -{  
32 - uint32_t tmp =  
33 - ((data & 0xFF000000UL) >> 24) | ((data & 0x00FF0000UL) >> 8) |  
34 - ((data & 0x0000FF00UL) << 8) | ((data & 0x000000FFUL) << 24);  
35 - glue(stl, MEMSUFFIX)(EA, tmp);  
36 -} 21 +#include "op_mem_access.h"
37 22
  23 +/* Multiple word / string load and store */
38 void glue(do_lmw, MEMSUFFIX) (int dst) 24 void glue(do_lmw, MEMSUFFIX) (int dst)
39 { 25 {
40 for (; dst < 32; dst++, T0 += 4) { 26 for (; dst < 32; dst++, T0 += 4) {
41 - env->gpr[dst] = glue(ldl, MEMSUFFIX)((uint32_t)T0); 27 + env->gpr[dst] = glue(ldu32, MEMSUFFIX)((uint32_t)T0);
42 } 28 }
43 } 29 }
44 30
@@ -46,7 +32,7 @@ void glue(do_lmw, MEMSUFFIX) (int dst) @@ -46,7 +32,7 @@ void glue(do_lmw, MEMSUFFIX) (int dst)
46 void glue(do_lmw_64, MEMSUFFIX) (int dst) 32 void glue(do_lmw_64, MEMSUFFIX) (int dst)
47 { 33 {
48 for (; dst < 32; dst++, T0 += 4) { 34 for (; dst < 32; dst++, T0 += 4) {
49 - env->gpr[dst] = glue(ldl, MEMSUFFIX)((uint64_t)T0); 35 + env->gpr[dst] = glue(ldu32, MEMSUFFIX)((uint64_t)T0);
50 } 36 }
51 } 37 }
52 #endif 38 #endif
@@ -54,7 +40,7 @@ void glue(do_lmw_64, MEMSUFFIX) (int dst) @@ -54,7 +40,7 @@ void glue(do_lmw_64, MEMSUFFIX) (int dst)
54 void glue(do_stmw, MEMSUFFIX) (int src) 40 void glue(do_stmw, MEMSUFFIX) (int src)
55 { 41 {
56 for (; src < 32; src++, T0 += 4) { 42 for (; src < 32; src++, T0 += 4) {
57 - glue(stl, MEMSUFFIX)((uint32_t)T0, env->gpr[src]); 43 + glue(st32, MEMSUFFIX)((uint32_t)T0, env->gpr[src]);
58 } 44 }
59 } 45 }
60 46
@@ -62,7 +48,7 @@ void glue(do_stmw, MEMSUFFIX) (int src) @@ -62,7 +48,7 @@ void glue(do_stmw, MEMSUFFIX) (int src)
62 void glue(do_stmw_64, MEMSUFFIX) (int src) 48 void glue(do_stmw_64, MEMSUFFIX) (int src)
63 { 49 {
64 for (; src < 32; src++, T0 += 4) { 50 for (; src < 32; src++, T0 += 4) {
65 - glue(stl, MEMSUFFIX)((uint64_t)T0, env->gpr[src]); 51 + glue(st32, MEMSUFFIX)((uint64_t)T0, env->gpr[src]);
66 } 52 }
67 } 53 }
68 #endif 54 #endif
@@ -70,7 +56,7 @@ void glue(do_stmw_64, MEMSUFFIX) (int src) @@ -70,7 +56,7 @@ void glue(do_stmw_64, MEMSUFFIX) (int src)
70 void glue(do_lmw_le, MEMSUFFIX) (int dst) 56 void glue(do_lmw_le, MEMSUFFIX) (int dst)
71 { 57 {
72 for (; dst < 32; dst++, T0 += 4) { 58 for (; dst < 32; dst++, T0 += 4) {
73 - env->gpr[dst] = glue(ld32r, MEMSUFFIX)((uint32_t)T0); 59 + env->gpr[dst] = glue(ldu32r, MEMSUFFIX)((uint32_t)T0);
74 } 60 }
75 } 61 }
76 62
@@ -78,7 +64,7 @@ void glue(do_lmw_le, MEMSUFFIX) (int dst) @@ -78,7 +64,7 @@ void glue(do_lmw_le, MEMSUFFIX) (int dst)
78 void glue(do_lmw_le_64, MEMSUFFIX) (int dst) 64 void glue(do_lmw_le_64, MEMSUFFIX) (int dst)
79 { 65 {
80 for (; dst < 32; dst++, T0 += 4) { 66 for (; dst < 32; dst++, T0 += 4) {
81 - env->gpr[dst] = glue(ld32r, MEMSUFFIX)((uint64_t)T0); 67 + env->gpr[dst] = glue(ldu32r, MEMSUFFIX)((uint64_t)T0);
82 } 68 }
83 } 69 }
84 #endif 70 #endif
@@ -105,14 +91,14 @@ void glue(do_lsw, MEMSUFFIX) (int dst) @@ -105,14 +91,14 @@ void glue(do_lsw, MEMSUFFIX) (int dst)
105 int sh; 91 int sh;
106 92
107 for (; T1 > 3; T1 -= 4, T0 += 4) { 93 for (; T1 > 3; T1 -= 4, T0 += 4) {
108 - env->gpr[dst++] = glue(ldl, MEMSUFFIX)((uint32_t)T0); 94 + env->gpr[dst++] = glue(ldu32, MEMSUFFIX)((uint32_t)T0);
109 if (unlikely(dst == 32)) 95 if (unlikely(dst == 32))
110 dst = 0; 96 dst = 0;
111 } 97 }
112 if (unlikely(T1 != 0)) { 98 if (unlikely(T1 != 0)) {
113 tmp = 0; 99 tmp = 0;
114 for (sh = 24; T1 > 0; T1--, T0++, sh -= 8) { 100 for (sh = 24; T1 > 0; T1--, T0++, sh -= 8) {
115 - tmp |= glue(ldub, MEMSUFFIX)((uint32_t)T0) << sh; 101 + tmp |= glue(ldu8, MEMSUFFIX)((uint32_t)T0) << sh;
116 } 102 }
117 env->gpr[dst] = tmp; 103 env->gpr[dst] = tmp;
118 } 104 }
@@ -125,14 +111,14 @@ void glue(do_lsw_64, MEMSUFFIX) (int dst) @@ -125,14 +111,14 @@ void glue(do_lsw_64, MEMSUFFIX) (int dst)
125 int sh; 111 int sh;
126 112
127 for (; T1 > 3; T1 -= 4, T0 += 4) { 113 for (; T1 > 3; T1 -= 4, T0 += 4) {
128 - env->gpr[dst++] = glue(ldl, MEMSUFFIX)((uint64_t)T0); 114 + env->gpr[dst++] = glue(ldu32, MEMSUFFIX)((uint64_t)T0);
129 if (unlikely(dst == 32)) 115 if (unlikely(dst == 32))
130 dst = 0; 116 dst = 0;
131 } 117 }
132 if (unlikely(T1 != 0)) { 118 if (unlikely(T1 != 0)) {
133 tmp = 0; 119 tmp = 0;
134 for (sh = 24; T1 > 0; T1--, T0++, sh -= 8) { 120 for (sh = 24; T1 > 0; T1--, T0++, sh -= 8) {
135 - tmp |= glue(ldub, MEMSUFFIX)((uint64_t)T0) << sh; 121 + tmp |= glue(ldu8, MEMSUFFIX)((uint64_t)T0) << sh;
136 } 122 }
137 env->gpr[dst] = tmp; 123 env->gpr[dst] = tmp;
138 } 124 }
@@ -144,13 +130,13 @@ void glue(do_stsw, MEMSUFFIX) (int src) @@ -144,13 +130,13 @@ void glue(do_stsw, MEMSUFFIX) (int src)
144 int sh; 130 int sh;
145 131
146 for (; T1 > 3; T1 -= 4, T0 += 4) { 132 for (; T1 > 3; T1 -= 4, T0 += 4) {
147 - glue(stl, MEMSUFFIX)((uint32_t)T0, env->gpr[src++]); 133 + glue(st32, MEMSUFFIX)((uint32_t)T0, env->gpr[src++]);
148 if (unlikely(src == 32)) 134 if (unlikely(src == 32))
149 src = 0; 135 src = 0;
150 } 136 }
151 if (unlikely(T1 != 0)) { 137 if (unlikely(T1 != 0)) {
152 for (sh = 24; T1 > 0; T1--, T0++, sh -= 8) 138 for (sh = 24; T1 > 0; T1--, T0++, sh -= 8)
153 - glue(stb, MEMSUFFIX)((uint32_t)T0, (env->gpr[src] >> sh) & 0xFF); 139 + glue(st8, MEMSUFFIX)((uint32_t)T0, (env->gpr[src] >> sh) & 0xFF);
154 } 140 }
155 } 141 }
156 142
@@ -160,85 +146,13 @@ void glue(do_stsw_64, MEMSUFFIX) (int src) @@ -160,85 +146,13 @@ void glue(do_stsw_64, MEMSUFFIX) (int src)
160 int sh; 146 int sh;
161 147
162 for (; T1 > 3; T1 -= 4, T0 += 4) { 148 for (; T1 > 3; T1 -= 4, T0 += 4) {
163 - glue(stl, MEMSUFFIX)((uint64_t)T0, env->gpr[src++]); 149 + glue(st32, MEMSUFFIX)((uint64_t)T0, env->gpr[src++]);
164 if (unlikely(src == 32)) 150 if (unlikely(src == 32))
165 src = 0; 151 src = 0;
166 } 152 }
167 if (unlikely(T1 != 0)) { 153 if (unlikely(T1 != 0)) {
168 for (sh = 24; T1 > 0; T1--, T0++, sh -= 8) 154 for (sh = 24; T1 > 0; T1--, T0++, sh -= 8)
169 - glue(stb, MEMSUFFIX)((uint64_t)T0, (env->gpr[src] >> sh) & 0xFF);  
170 - }  
171 -}  
172 -#endif  
173 -  
174 -void glue(do_lsw_le, MEMSUFFIX) (int dst)  
175 -{  
176 - uint32_t tmp;  
177 - int sh;  
178 -  
179 - for (; T1 > 3; T1 -= 4, T0 += 4) {  
180 - env->gpr[dst++] = glue(ld32r, MEMSUFFIX)((uint32_t)T0);  
181 - if (unlikely(dst == 32))  
182 - dst = 0;  
183 - }  
184 - if (unlikely(T1 != 0)) {  
185 - tmp = 0;  
186 - for (sh = 0; T1 > 0; T1--, T0++, sh += 8) {  
187 - tmp |= glue(ldub, MEMSUFFIX)((uint32_t)T0) << sh;  
188 - }  
189 - env->gpr[dst] = tmp;  
190 - }  
191 -}  
192 -  
193 -#if defined(TARGET_PPC64)  
194 -void glue(do_lsw_le_64, MEMSUFFIX) (int dst)  
195 -{  
196 - uint32_t tmp;  
197 - int sh;  
198 -  
199 - for (; T1 > 3; T1 -= 4, T0 += 4) {  
200 - env->gpr[dst++] = glue(ld32r, MEMSUFFIX)((uint64_t)T0);  
201 - if (unlikely(dst == 32))  
202 - dst = 0;  
203 - }  
204 - if (unlikely(T1 != 0)) {  
205 - tmp = 0;  
206 - for (sh = 0; T1 > 0; T1--, T0++, sh += 8) {  
207 - tmp |= glue(ldub, MEMSUFFIX)((uint64_t)T0) << sh;  
208 - }  
209 - env->gpr[dst] = tmp;  
210 - }  
211 -}  
212 -#endif  
213 -  
214 -void glue(do_stsw_le, MEMSUFFIX) (int src)  
215 -{  
216 - int sh;  
217 -  
218 - for (; T1 > 3; T1 -= 4, T0 += 4) {  
219 - glue(st32r, MEMSUFFIX)((uint32_t)T0, env->gpr[src++]);  
220 - if (unlikely(src == 32))  
221 - src = 0;  
222 - }  
223 - if (unlikely(T1 != 0)) {  
224 - for (sh = 0; T1 > 0; T1--, T0++, sh += 8)  
225 - glue(stb, MEMSUFFIX)((uint32_t)T0, (env->gpr[src] >> sh) & 0xFF);  
226 - }  
227 -}  
228 -  
229 -#if defined(TARGET_PPC64)  
230 -void glue(do_stsw_le_64, MEMSUFFIX) (int src)  
231 -{  
232 - int sh;  
233 -  
234 - for (; T1 > 3; T1 -= 4, T0 += 4) {  
235 - glue(st32r, MEMSUFFIX)((uint64_t)T0, env->gpr[src++]);  
236 - if (unlikely(src == 32))  
237 - src = 0;  
238 - }  
239 - if (unlikely(T1 != 0)) {  
240 - for (sh = 0; T1 > 0; T1--, T0++, sh += 8)  
241 - glue(stb, MEMSUFFIX)((uint64_t)T0, (env->gpr[src] >> sh) & 0xFF); 155 + glue(st8, MEMSUFFIX)((uint64_t)T0, (env->gpr[src] >> sh) & 0xFF);
242 } 156 }
243 } 157 }
244 #endif 158 #endif
@@ -281,6 +195,7 @@ void glue(do_dcbz, MEMSUFFIX) (void) @@ -281,6 +195,7 @@ void glue(do_dcbz, MEMSUFFIX) (void)
281 /* XXX: should be 970 specific (?) */ 195 /* XXX: should be 970 specific (?) */
282 if (((env->spr[SPR_970_HID5] >> 7) & 0x3) == 1) 196 if (((env->spr[SPR_970_HID5] >> 7) & 0x3) == 1)
283 dcache_line_size = 32; 197 dcache_line_size = 32;
  198 + T0 &= ~(uint32_t)(dcache_line_size - 1);
284 glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x00), 0); 199 glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x00), 0);
285 glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x04), 0); 200 glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x04), 0);
286 glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x08), 0); 201 glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x08), 0);
@@ -327,6 +242,7 @@ void glue(do_dcbz_64, MEMSUFFIX) (void) @@ -327,6 +242,7 @@ void glue(do_dcbz_64, MEMSUFFIX) (void)
327 /* XXX: should be 970 specific (?) */ 242 /* XXX: should be 970 specific (?) */
328 if (((env->spr[SPR_970_HID5] >> 6) & 0x3) == 0x2) 243 if (((env->spr[SPR_970_HID5] >> 6) & 0x3) == 0x2)
329 dcache_line_size = 32; 244 dcache_line_size = 32;
  245 + T0 &= ~(uint64_t)(dcache_line_size - 1);
330 glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x00), 0); 246 glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x00), 0);
331 glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x04), 0); 247 glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x04), 0);
332 glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x08), 0); 248 glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x08), 0);
@@ -375,7 +291,7 @@ void glue(do_POWER_lscbx, MEMSUFFIX) (int dest, int ra, int rb) @@ -375,7 +291,7 @@ void glue(do_POWER_lscbx, MEMSUFFIX) (int dest, int ra, int rb)
375 d = 24; 291 d = 24;
376 reg = dest; 292 reg = dest;
377 for (i = 0; i < T1; i++) { 293 for (i = 0; i < T1; i++) {
378 - c = glue(ldub, MEMSUFFIX)((uint32_t)T0++); 294 + c = glue(ldu8, MEMSUFFIX)((uint32_t)T0++);
379 /* ra (if not 0) and rb are never modified */ 295 /* ra (if not 0) and rb are never modified */
380 if (likely(reg != rb && (ra == 0 || reg != ra))) { 296 if (likely(reg != rb && (ra == 0 || reg != ra))) {
381 env->gpr[reg] = (env->gpr[reg] & ~(0xFF << d)) | (c << d); 297 env->gpr[reg] = (env->gpr[reg] & ~(0xFF << d)) | (c << d);
@@ -408,14 +324,7 @@ static always_inline double glue(ldfqr, MEMSUFFIX) (target_ulong EA) @@ -408,14 +324,7 @@ static always_inline double glue(ldfqr, MEMSUFFIX) (target_ulong EA)
408 } u; 324 } u;
409 325
410 u.d = glue(ldfq, MEMSUFFIX)(EA); 326 u.d = glue(ldfq, MEMSUFFIX)(EA);
411 - u.u = ((u.u & 0xFF00000000000000ULL) >> 56) |  
412 - ((u.u & 0x00FF000000000000ULL) >> 40) |  
413 - ((u.u & 0x0000FF0000000000ULL) >> 24) |  
414 - ((u.u & 0x000000FF00000000ULL) >> 8) |  
415 - ((u.u & 0x00000000FF000000ULL) << 8) |  
416 - ((u.u & 0x0000000000FF0000ULL) << 24) |  
417 - ((u.u & 0x000000000000FF00ULL) << 40) |  
418 - ((u.u & 0x00000000000000FFULL) << 56); 327 + u.u = bswap64(u.u);
419 328
420 return u.d; 329 return u.d;
421 } 330 }
@@ -440,14 +349,7 @@ static always_inline void glue(stfqr, MEMSUFFIX) (target_ulong EA, double d) @@ -440,14 +349,7 @@ static always_inline void glue(stfqr, MEMSUFFIX) (target_ulong EA, double d)
440 } u; 349 } u;
441 350
442 u.d = d; 351 u.d = d;
443 - u.u = ((u.u & 0xFF00000000000000ULL) >> 56) |  
444 - ((u.u & 0x00FF000000000000ULL) >> 40) |  
445 - ((u.u & 0x0000FF0000000000ULL) >> 24) |  
446 - ((u.u & 0x000000FF00000000ULL) >> 8) |  
447 - ((u.u & 0x00000000FF000000ULL) << 8) |  
448 - ((u.u & 0x0000000000FF0000ULL) << 24) |  
449 - ((u.u & 0x000000000000FF00ULL) << 40) |  
450 - ((u.u & 0x00000000000000FFULL) << 56); 352 + u.u = bswap64(u.u);
451 glue(stfq, MEMSUFFIX)(EA, u.d); 353 glue(stfq, MEMSUFFIX)(EA, u.d);
452 } 354 }
453 355
target-ppc/op_mem.h
  View file @e7c2400
@@ -18,80 +18,7 @@ @@ -18,80 +18,7 @@
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */ 19 */
20 20
21 -static always_inline uint16_t glue(ld16r, MEMSUFFIX) (target_ulong EA)  
22 -{  
23 - uint16_t tmp = glue(lduw, MEMSUFFIX)(EA);  
24 - return ((tmp & 0xFF00) >> 8) | ((tmp & 0x00FF) << 8);  
25 -}  
26 -  
27 -static always_inline int32_t glue(ld16rs, MEMSUFFIX) (target_ulong EA)  
28 -{  
29 - int16_t tmp = glue(lduw, MEMSUFFIX)(EA);  
30 - return (int16_t)((tmp & 0xFF00) >> 8) | ((tmp & 0x00FF) << 8);  
31 -}  
32 -  
33 -static always_inline uint32_t glue(ld32r, MEMSUFFIX) (target_ulong EA)  
34 -{  
35 - uint32_t tmp = glue(ldl, MEMSUFFIX)(EA);  
36 - return ((tmp & 0xFF000000) >> 24) | ((tmp & 0x00FF0000) >> 8) |  
37 - ((tmp & 0x0000FF00) << 8) | ((tmp & 0x000000FF) << 24);  
38 -}  
39 -  
40 -static always_inline uint64_t glue(ld64r, MEMSUFFIX) (target_ulong EA)  
41 -{  
42 - uint64_t tmp = glue(ldq, MEMSUFFIX)(EA);  
43 - return ((tmp & 0xFF00000000000000ULL) >> 56) |  
44 - ((tmp & 0x00FF000000000000ULL) >> 40) |  
45 - ((tmp & 0x0000FF0000000000ULL) >> 24) |  
46 - ((tmp & 0x000000FF00000000ULL) >> 8) |  
47 - ((tmp & 0x00000000FF000000ULL) << 8) |  
48 - ((tmp & 0x0000000000FF0000ULL) << 24) |  
49 - ((tmp & 0x000000000000FF00ULL) << 40) |  
50 - ((tmp & 0x00000000000000FFULL) << 54);  
51 -}  
52 -  
53 -#if defined(TARGET_PPC64)  
54 -static always_inline int64_t glue(ldsl, MEMSUFFIX) (target_ulong EA)  
55 -{  
56 - return (int32_t)glue(ldl, MEMSUFFIX)(EA);  
57 -}  
58 -  
59 -static always_inline int64_t glue(ld32rs, MEMSUFFIX) (target_ulong EA)  
60 -{  
61 - uint32_t tmp = glue(ldl, MEMSUFFIX)(EA);  
62 - return (int32_t)((tmp & 0xFF000000) >> 24) | ((tmp & 0x00FF0000) >> 8) |  
63 - ((tmp & 0x0000FF00) << 8) | ((tmp & 0x000000FF) << 24);  
64 -}  
65 -#endif  
66 -  
67 -static always_inline void glue(st16r, MEMSUFFIX) (target_ulong EA,  
68 - uint16_t data)  
69 -{  
70 - uint16_t tmp = ((data & 0xFF00) >> 8) | ((data & 0x00FF) << 8);  
71 - glue(stw, MEMSUFFIX)(EA, tmp);  
72 -}  
73 -  
74 -static always_inline void glue(st32r, MEMSUFFIX) (target_ulong EA,  
75 - uint32_t data)  
76 -{  
77 - uint32_t tmp = ((data & 0xFF000000) >> 24) | ((data & 0x00FF0000) >> 8) |  
78 - ((data & 0x0000FF00) << 8) | ((data & 0x000000FF) << 24);  
79 - glue(stl, MEMSUFFIX)(EA, tmp);  
80 -}  
81 -  
82 -static always_inline void glue(st64r, MEMSUFFIX) (target_ulong EA,  
83 - uint64_t data)  
84 -{  
85 - uint64_t tmp = ((data & 0xFF00000000000000ULL) >> 56) |  
86 - ((data & 0x00FF000000000000ULL) >> 40) |  
87 - ((data & 0x0000FF0000000000ULL) >> 24) |  
88 - ((data & 0x000000FF00000000ULL) >> 8) |  
89 - ((data & 0x00000000FF000000ULL) << 8) |  
90 - ((data & 0x0000000000FF0000ULL) << 24) |  
91 - ((data & 0x000000000000FF00ULL) << 40) |  
92 - ((data & 0x00000000000000FFULL) << 56);  
93 - glue(stq, MEMSUFFIX)(EA, tmp);  
94 -} 21 +#include "op_mem_access.h"
95 22
96 /*** Integer load ***/ 23 /*** Integer load ***/
97 #define PPC_LD_OP(name, op) \ 24 #define PPC_LD_OP(name, op) \
@@ -126,76 +53,76 @@ void OPPROTO glue(glue(glue(op_st, name), _64), MEMSUFFIX) (void) \ @@ -126,76 +53,76 @@ void OPPROTO glue(glue(glue(op_st, name), _64), MEMSUFFIX) (void) \
126 } 53 }
127 #endif 54 #endif
128 55
129 -PPC_LD_OP(bz, ldub);  
130 -PPC_LD_OP(ha, ldsw);  
131 -PPC_LD_OP(hz, lduw);  
132 -PPC_LD_OP(wz, ldl); 56 +PPC_LD_OP(bz, ldu8);
  57 +PPC_LD_OP(ha, lds16);
  58 +PPC_LD_OP(hz, ldu16);
  59 +PPC_LD_OP(wz, ldu32);
133 #if defined(TARGET_PPC64) 60 #if defined(TARGET_PPC64)
134 -PPC_LD_OP(d, ldq);  
135 -PPC_LD_OP(wa, ldsl);  
136 -PPC_LD_OP_64(d, ldq);  
137 -PPC_LD_OP_64(wa, ldsl);  
138 -PPC_LD_OP_64(bz, ldub);  
139 -PPC_LD_OP_64(ha, ldsw);  
140 -PPC_LD_OP_64(hz, lduw);  
141 -PPC_LD_OP_64(wz, ldl); 61 +PPC_LD_OP(wa, lds32);
  62 +PPC_LD_OP(d, ldu64);
  63 +PPC_LD_OP_64(bz, ldu8);
  64 +PPC_LD_OP_64(ha, lds16);
  65 +PPC_LD_OP_64(hz, ldu16);
  66 +PPC_LD_OP_64(wz, ldu32);
  67 +PPC_LD_OP_64(wa, lds32);
  68 +PPC_LD_OP_64(d, ldu64);
142 #endif 69 #endif
143 70
144 -PPC_LD_OP(ha_le, ld16rs);  
145 -PPC_LD_OP(hz_le, ld16r);  
146 -PPC_LD_OP(wz_le, ld32r); 71 +PPC_LD_OP(ha_le, lds16r);
  72 +PPC_LD_OP(hz_le, ldu16r);
  73 +PPC_LD_OP(wz_le, ldu32r);
147 #if defined(TARGET_PPC64) 74 #if defined(TARGET_PPC64)
148 -PPC_LD_OP(d_le, ld64r);  
149 -PPC_LD_OP(wa_le, ld32rs);  
150 -PPC_LD_OP_64(d_le, ld64r);  
151 -PPC_LD_OP_64(wa_le, ld32rs);  
152 -PPC_LD_OP_64(ha_le, ld16rs);  
153 -PPC_LD_OP_64(hz_le, ld16r);  
154 -PPC_LD_OP_64(wz_le, ld32r); 75 +PPC_LD_OP(wa_le, lds32r);
  76 +PPC_LD_OP(d_le, ldu64r);
  77 +PPC_LD_OP_64(ha_le, lds16r);
  78 +PPC_LD_OP_64(hz_le, ldu16r);
  79 +PPC_LD_OP_64(wz_le, ldu32r);
  80 +PPC_LD_OP_64(wa_le, lds32r);
  81 +PPC_LD_OP_64(d_le, ldu64r);
155 #endif 82 #endif
156 83
157 /*** Integer store ***/ 84 /*** Integer store ***/
158 -PPC_ST_OP(b, stb);  
159 -PPC_ST_OP(h, stw);  
160 -PPC_ST_OP(w, stl); 85 +PPC_ST_OP(b, st8);
  86 +PPC_ST_OP(h, st16);
  87 +PPC_ST_OP(w, st32);
161 #if defined(TARGET_PPC64) 88 #if defined(TARGET_PPC64)
162 -PPC_ST_OP(d, stq);  
163 -PPC_ST_OP_64(d, stq);  
164 -PPC_ST_OP_64(b, stb);  
165 -PPC_ST_OP_64(h, stw);  
166 -PPC_ST_OP_64(w, stl); 89 +PPC_ST_OP(d, st64);
  90 +PPC_ST_OP_64(b, st8);
  91 +PPC_ST_OP_64(h, st16);
  92 +PPC_ST_OP_64(w, st32);
  93 +PPC_ST_OP_64(d, st64);
167 #endif 94 #endif
168 95
169 PPC_ST_OP(h_le, st16r); 96 PPC_ST_OP(h_le, st16r);
170 PPC_ST_OP(w_le, st32r); 97 PPC_ST_OP(w_le, st32r);
171 #if defined(TARGET_PPC64) 98 #if defined(TARGET_PPC64)
172 PPC_ST_OP(d_le, st64r); 99 PPC_ST_OP(d_le, st64r);
173 -PPC_ST_OP_64(d_le, st64r);  
174 PPC_ST_OP_64(h_le, st16r); 100 PPC_ST_OP_64(h_le, st16r);
175 PPC_ST_OP_64(w_le, st32r); 101 PPC_ST_OP_64(w_le, st32r);
  102 +PPC_ST_OP_64(d_le, st64r);
176 #endif 103 #endif
177 104
178 /*** Integer load and store with byte reverse ***/ 105 /*** Integer load and store with byte reverse ***/
179 -PPC_LD_OP(hbr, ld16r);  
180 -PPC_LD_OP(wbr, ld32r); 106 +PPC_LD_OP(hbr, ldu16r);
  107 +PPC_LD_OP(wbr, ldu32r);
181 PPC_ST_OP(hbr, st16r); 108 PPC_ST_OP(hbr, st16r);
182 PPC_ST_OP(wbr, st32r); 109 PPC_ST_OP(wbr, st32r);
183 #if defined(TARGET_PPC64) 110 #if defined(TARGET_PPC64)
184 -PPC_LD_OP_64(hbr, ld16r);  
185 -PPC_LD_OP_64(wbr, ld32r); 111 +PPC_LD_OP_64(hbr, ldu16r);
  112 +PPC_LD_OP_64(wbr, ldu32r);
186 PPC_ST_OP_64(hbr, st16r); 113 PPC_ST_OP_64(hbr, st16r);
187 PPC_ST_OP_64(wbr, st32r); 114 PPC_ST_OP_64(wbr, st32r);
188 #endif 115 #endif
189 116
190 -PPC_LD_OP(hbr_le, lduw);  
191 -PPC_LD_OP(wbr_le, ldl);  
192 -PPC_ST_OP(hbr_le, stw);  
193 -PPC_ST_OP(wbr_le, stl); 117 +PPC_LD_OP(hbr_le, ldu16);
  118 +PPC_LD_OP(wbr_le, ldu32);
  119 +PPC_ST_OP(hbr_le, st16);
  120 +PPC_ST_OP(wbr_le, st32);
194 #if defined(TARGET_PPC64) 121 #if defined(TARGET_PPC64)
195 -PPC_LD_OP_64(hbr_le, lduw);  
196 -PPC_LD_OP_64(wbr_le, ldl);  
197 -PPC_ST_OP_64(hbr_le, stw);  
198 -PPC_ST_OP_64(wbr_le, stl); 122 +PPC_LD_OP_64(hbr_le, ldu16);
  123 +PPC_LD_OP_64(wbr_le, ldu32);
  124 +PPC_ST_OP_64(hbr_le, st16);
  125 +PPC_ST_OP_64(wbr_le, st32);
199 #endif 126 #endif
200 127
201 /*** Integer load and store multiple ***/ 128 /*** Integer load and store multiple ***/
@@ -270,20 +197,6 @@ void OPPROTO glue(op_lswi_64, MEMSUFFIX) (void) @@ -270,20 +197,6 @@ void OPPROTO glue(op_lswi_64, MEMSUFFIX) (void)
270 } 197 }
271 #endif 198 #endif
272 199
273 -void OPPROTO glue(op_lswi_le, MEMSUFFIX) (void)  
274 -{  
275 - glue(do_lsw_le, MEMSUFFIX)(PARAM1);  
276 - RETURN();  
277 -}  
278 -  
279 -#if defined(TARGET_PPC64)  
280 -void OPPROTO glue(op_lswi_le_64, MEMSUFFIX) (void)  
281 -{  
282 - glue(do_lsw_le_64, MEMSUFFIX)(PARAM1);  
283 - RETURN();  
284 -}  
285 -#endif  
286 -  
287 /* PPC32 specification says we must generate an exception if 200 /* PPC32 specification says we must generate an exception if
288 * rA is in the range of registers to be loaded. 201 * rA is in the range of registers to be loaded.
289 * In an other hand, IBM says this is valid, but rA won't be loaded. 202 * In an other hand, IBM says this is valid, but rA won't be loaded.
@@ -323,40 +236,6 @@ void OPPROTO glue(op_lswx_64, MEMSUFFIX) (void) @@ -323,40 +236,6 @@ void OPPROTO glue(op_lswx_64, MEMSUFFIX) (void)
323 } 236 }
324 #endif 237 #endif
325 238
326 -void OPPROTO glue(op_lswx_le, MEMSUFFIX) (void)  
327 -{  
328 - /* Note: T1 comes from xer_bc then no cast is needed */  
329 - if (likely(T1 != 0)) {  
330 - if (unlikely((PARAM1 < PARAM2 && (PARAM1 + T1) > PARAM2) ||  
331 - (PARAM1 < PARAM3 && (PARAM1 + T1) > PARAM3))) {  
332 - do_raise_exception_err(POWERPC_EXCP_PROGRAM,  
333 - POWERPC_EXCP_INVAL |  
334 - POWERPC_EXCP_INVAL_LSWX);  
335 - } else {  
336 - glue(do_lsw_le, MEMSUFFIX)(PARAM1);  
337 - }  
338 - }  
339 - RETURN();  
340 -}  
341 -  
342 -#if defined(TARGET_PPC64)  
343 -void OPPROTO glue(op_lswx_le_64, MEMSUFFIX) (void)  
344 -{  
345 - /* Note: T1 comes from xer_bc then no cast is needed */  
346 - if (likely(T1 != 0)) {  
347 - if (unlikely((PARAM1 < PARAM2 && (PARAM1 + T1) > PARAM2) ||  
348 - (PARAM1 < PARAM3 && (PARAM1 + T1) > PARAM3))) {  
349 - do_raise_exception_err(POWERPC_EXCP_PROGRAM,  
350 - POWERPC_EXCP_INVAL |  
351 - POWERPC_EXCP_INVAL_LSWX);  
352 - } else {  
353 - glue(do_lsw_le_64, MEMSUFFIX)(PARAM1);  
354 - }  
355 - }  
356 - RETURN();  
357 -}  
358 -#endif  
359 -  
360 void OPPROTO glue(op_stsw, MEMSUFFIX) (void) 239 void OPPROTO glue(op_stsw, MEMSUFFIX) (void)
361 { 240 {
362 glue(do_stsw, MEMSUFFIX)(PARAM1); 241 glue(do_stsw, MEMSUFFIX)(PARAM1);
@@ -371,20 +250,6 @@ void OPPROTO glue(op_stsw_64, MEMSUFFIX) (void) @@ -371,20 +250,6 @@ void OPPROTO glue(op_stsw_64, MEMSUFFIX) (void)
371 } 250 }
372 #endif 251 #endif
373 252
374 -void OPPROTO glue(op_stsw_le, MEMSUFFIX) (void)  
375 -{  
376 - glue(do_stsw_le, MEMSUFFIX)(PARAM1);  
377 - RETURN();  
378 -}  
379 -  
380 -#if defined(TARGET_PPC64)  
381 -void OPPROTO glue(op_stsw_le_64, MEMSUFFIX) (void)  
382 -{  
383 - glue(do_stsw_le_64, MEMSUFFIX)(PARAM1);  
384 - RETURN();  
385 -}  
386 -#endif  
387 -  
388 /*** Floating-point store ***/ 253 /*** Floating-point store ***/
389 #define PPC_STF_OP(name, op) \ 254 #define PPC_STF_OP(name, op) \
390 void OPPROTO glue(glue(op_st, name), MEMSUFFIX) (void) \ 255 void OPPROTO glue(glue(op_st, name), MEMSUFFIX) (void) \
@@ -423,7 +288,7 @@ static always_inline void glue(stfiw, MEMSUFFIX) (target_ulong EA, double d) @@ -423,7 +288,7 @@ static always_inline void glue(stfiw, MEMSUFFIX) (target_ulong EA, double d)
423 288
424 /* Store the low order 32 bits without any conversion */ 289 /* Store the low order 32 bits without any conversion */
425 u.d = d; 290 u.d = d;
426 - glue(stl, MEMSUFFIX)(EA, u.u[WORD0]); 291 + glue(st32, MEMSUFFIX)(EA, u.u[WORD0]);
427 } 292 }
428 #undef WORD0 293 #undef WORD0
429 #undef WORD1 294 #undef WORD1
@@ -445,14 +310,7 @@ static always_inline void glue(stfqr, MEMSUFFIX) (target_ulong EA, double d) @@ -445,14 +310,7 @@ static always_inline void glue(stfqr, MEMSUFFIX) (target_ulong EA, double d)
445 } u; 310 } u;
446 311
447 u.d = d; 312 u.d = d;
448 - u.u = ((u.u & 0xFF00000000000000ULL) >> 56) |  
449 - ((u.u & 0x00FF000000000000ULL) >> 40) |  
450 - ((u.u & 0x0000FF0000000000ULL) >> 24) |  
451 - ((u.u & 0x000000FF00000000ULL) >> 8) |  
452 - ((u.u & 0x00000000FF000000ULL) << 8) |  
453 - ((u.u & 0x0000000000FF0000ULL) << 24) |  
454 - ((u.u & 0x000000000000FF00ULL) << 40) |  
455 - ((u.u & 0x00000000000000FFULL) << 56); 313 + u.u = bswap64(u.u);
456 glue(stfq, MEMSUFFIX)(EA, u.d); 314 glue(stfq, MEMSUFFIX)(EA, u.d);
457 } 315 }
458 316
@@ -464,10 +322,7 @@ static always_inline void glue(stfsr, MEMSUFFIX) (target_ulong EA, double d) @@ -464,10 +322,7 @@ static always_inline void glue(stfsr, MEMSUFFIX) (target_ulong EA, double d)
464 } u; 322 } u;
465 323
466 u.f = float64_to_float32(d, &env->fp_status); 324 u.f = float64_to_float32(d, &env->fp_status);
467 - u.u = ((u.u & 0xFF000000UL) >> 24) |  
468 - ((u.u & 0x00FF0000ULL) >> 8) |  
469 - ((u.u & 0x0000FF00UL) << 8) |  
470 - ((u.u & 0x000000FFULL) << 24); 325 + u.u = bswap32(u.u);
471 glue(stfl, MEMSUFFIX)(EA, u.f); 326 glue(stfl, MEMSUFFIX)(EA, u.f);
472 } 327 }
473 328
@@ -480,11 +335,8 @@ static always_inline void glue(stfiwr, MEMSUFFIX) (target_ulong EA, double d) @@ -480,11 +335,8 @@ static always_inline void glue(stfiwr, MEMSUFFIX) (target_ulong EA, double d)
480 335
481 /* Store the low order 32 bits without any conversion */ 336 /* Store the low order 32 bits without any conversion */
482 u.d = d; 337 u.d = d;
483 - u.u = ((u.u & 0xFF000000UL) >> 24) |  
484 - ((u.u & 0x00FF0000ULL) >> 8) |  
485 - ((u.u & 0x0000FF00UL) << 8) |  
486 - ((u.u & 0x000000FFULL) << 24);  
487 - glue(stl, MEMSUFFIX)(EA, u.u); 338 + u.u = bswap32(u.u);
  339 + glue(st32, MEMSUFFIX)(EA, u.u);
488 } 340 }
489 341
490 PPC_STF_OP(fd_le, stfqr); 342 PPC_STF_OP(fd_le, stfqr);
@@ -533,14 +385,7 @@ static always_inline double glue(ldfqr, MEMSUFFIX) (target_ulong EA) @@ -533,14 +385,7 @@ static always_inline double glue(ldfqr, MEMSUFFIX) (target_ulong EA)
533 } u; 385 } u;
534 386
535 u.d = glue(ldfq, MEMSUFFIX)(EA); 387 u.d = glue(ldfq, MEMSUFFIX)(EA);
536 - u.u = ((u.u & 0xFF00000000000000ULL) >> 56) |  
537 - ((u.u & 0x00FF000000000000ULL) >> 40) |  
538 - ((u.u & 0x0000FF0000000000ULL) >> 24) |  
539 - ((u.u & 0x000000FF00000000ULL) >> 8) |  
540 - ((u.u & 0x00000000FF000000ULL) << 8) |  
541 - ((u.u & 0x0000000000FF0000ULL) << 24) |  
542 - ((u.u & 0x000000000000FF00ULL) << 40) |  
543 - ((u.u & 0x00000000000000FFULL) << 56); 388 + u.u = bswap64(u.u);
544 389
545 return u.d; 390 return u.d;
546 } 391 }
@@ -553,10 +398,7 @@ static always_inline double glue(ldfsr, MEMSUFFIX) (target_ulong EA) @@ -553,10 +398,7 @@ static always_inline double glue(ldfsr, MEMSUFFIX) (target_ulong EA)
553 } u; 398 } u;
554 399
555 u.f = glue(ldfl, MEMSUFFIX)(EA); 400 u.f = glue(ldfl, MEMSUFFIX)(EA);
556 - u.u = ((u.u & 0xFF000000UL) >> 24) |  
557 - ((u.u & 0x00FF0000ULL) >> 8) |  
558 - ((u.u & 0x0000FF00UL) << 8) |  
559 - ((u.u & 0x000000FFULL) << 24); 401 + u.u = bswap32(u.u);
560 402
561 return float32_to_float64(u.f, &env->fp_status); 403 return float32_to_float64(u.f, &env->fp_status);
562 } 404 }
@@ -574,7 +416,7 @@ void OPPROTO glue(op_lwarx, MEMSUFFIX) (void) @@ -574,7 +416,7 @@ void OPPROTO glue(op_lwarx, MEMSUFFIX) (void)
574 if (unlikely(T0 & 0x03)) { 416 if (unlikely(T0 & 0x03)) {
575 do_raise_exception(POWERPC_EXCP_ALIGN); 417 do_raise_exception(POWERPC_EXCP_ALIGN);
576 } else { 418 } else {
577 - T1 = glue(ldl, MEMSUFFIX)((uint32_t)T0); 419 + T1 = glue(ldu32, MEMSUFFIX)((uint32_t)T0);
578 env->reserve = (uint32_t)T0; 420 env->reserve = (uint32_t)T0;
579 } 421 }
580 RETURN(); 422 RETURN();
@@ -586,7 +428,7 @@ void OPPROTO glue(op_lwarx_64, MEMSUFFIX) (void) @@ -586,7 +428,7 @@ void OPPROTO glue(op_lwarx_64, MEMSUFFIX) (void)
586 if (unlikely(T0 & 0x03)) { 428 if (unlikely(T0 & 0x03)) {
587 do_raise_exception(POWERPC_EXCP_ALIGN); 429 do_raise_exception(POWERPC_EXCP_ALIGN);
588 } else { 430 } else {
589 - T1 = glue(ldl, MEMSUFFIX)((uint64_t)T0); 431 + T1 = glue(ldu32, MEMSUFFIX)((uint64_t)T0);
590 env->reserve = (uint64_t)T0; 432 env->reserve = (uint64_t)T0;
591 } 433 }
592 RETURN(); 434 RETURN();
@@ -597,7 +439,7 @@ void OPPROTO glue(op_ldarx, MEMSUFFIX) (void) @@ -597,7 +439,7 @@ void OPPROTO glue(op_ldarx, MEMSUFFIX) (void)
597 if (unlikely(T0 & 0x03)) { 439 if (unlikely(T0 & 0x03)) {
598 do_raise_exception(POWERPC_EXCP_ALIGN); 440 do_raise_exception(POWERPC_EXCP_ALIGN);
599 } else { 441 } else {
600 - T1 = glue(ldq, MEMSUFFIX)((uint32_t)T0); 442 + T1 = glue(ldu64, MEMSUFFIX)((uint32_t)T0);
601 env->reserve = (uint32_t)T0; 443 env->reserve = (uint32_t)T0;
602 } 444 }
603 RETURN(); 445 RETURN();
@@ -608,7 +450,7 @@ void OPPROTO glue(op_ldarx_64, MEMSUFFIX) (void) @@ -608,7 +450,7 @@ void OPPROTO glue(op_ldarx_64, MEMSUFFIX) (void)
608 if (unlikely(T0 & 0x03)) { 450 if (unlikely(T0 & 0x03)) {
609 do_raise_exception(POWERPC_EXCP_ALIGN); 451 do_raise_exception(POWERPC_EXCP_ALIGN);
610 } else { 452 } else {
611 - T1 = glue(ldq, MEMSUFFIX)((uint64_t)T0); 453 + T1 = glue(ldu64, MEMSUFFIX)((uint64_t)T0);
612 env->reserve = (uint64_t)T0; 454 env->reserve = (uint64_t)T0;
613 } 455 }
614 RETURN(); 456 RETURN();
@@ -620,7 +462,7 @@ void OPPROTO glue(op_lwarx_le, MEMSUFFIX) (void) @@ -620,7 +462,7 @@ void OPPROTO glue(op_lwarx_le, MEMSUFFIX) (void)
620 if (unlikely(T0 & 0x03)) { 462 if (unlikely(T0 & 0x03)) {
621 do_raise_exception(POWERPC_EXCP_ALIGN); 463 do_raise_exception(POWERPC_EXCP_ALIGN);
622 } else { 464 } else {
623 - T1 = glue(ld32r, MEMSUFFIX)((uint32_t)T0); 465 + T1 = glue(ldu32r, MEMSUFFIX)((uint32_t)T0);
624 env->reserve = (uint32_t)T0; 466 env->reserve = (uint32_t)T0;
625 } 467 }
626 RETURN(); 468 RETURN();
@@ -632,7 +474,7 @@ void OPPROTO glue(op_lwarx_le_64, MEMSUFFIX) (void) @@ -632,7 +474,7 @@ void OPPROTO glue(op_lwarx_le_64, MEMSUFFIX) (void)
632 if (unlikely(T0 & 0x03)) { 474 if (unlikely(T0 & 0x03)) {
633 do_raise_exception(POWERPC_EXCP_ALIGN); 475 do_raise_exception(POWERPC_EXCP_ALIGN);
634 } else { 476 } else {
635 - T1 = glue(ld32r, MEMSUFFIX)((uint64_t)T0); 477 + T1 = glue(ldu32r, MEMSUFFIX)((uint64_t)T0);
636 env->reserve = (uint64_t)T0; 478 env->reserve = (uint64_t)T0;
637 } 479 }
638 RETURN(); 480 RETURN();
@@ -643,7 +485,7 @@ void OPPROTO glue(op_ldarx_le, MEMSUFFIX) (void) @@ -643,7 +485,7 @@ void OPPROTO glue(op_ldarx_le, MEMSUFFIX) (void)
643 if (unlikely(T0 & 0x03)) { 485 if (unlikely(T0 & 0x03)) {
644 do_raise_exception(POWERPC_EXCP_ALIGN); 486 do_raise_exception(POWERPC_EXCP_ALIGN);
645 } else { 487 } else {
646 - T1 = glue(ld64r, MEMSUFFIX)((uint32_t)T0); 488 + T1 = glue(ldu64r, MEMSUFFIX)((uint32_t)T0);
647 env->reserve = (uint32_t)T0; 489 env->reserve = (uint32_t)T0;
648 } 490 }
649 RETURN(); 491 RETURN();
@@ -654,7 +496,7 @@ void OPPROTO glue(op_ldarx_le_64, MEMSUFFIX) (void) @@ -654,7 +496,7 @@ void OPPROTO glue(op_ldarx_le_64, MEMSUFFIX) (void)
654 if (unlikely(T0 & 0x03)) { 496 if (unlikely(T0 & 0x03)) {
655 do_raise_exception(POWERPC_EXCP_ALIGN); 497 do_raise_exception(POWERPC_EXCP_ALIGN);
656 } else { 498 } else {
657 - T1 = glue(ld64r, MEMSUFFIX)((uint64_t)T0); 499 + T1 = glue(ldu64r, MEMSUFFIX)((uint64_t)T0);
658 env->reserve = (uint64_t)T0; 500 env->reserve = (uint64_t)T0;
659 } 501 }
660 RETURN(); 502 RETURN();
@@ -670,7 +512,7 @@ void OPPROTO glue(op_stwcx, MEMSUFFIX) (void) @@ -670,7 +512,7 @@ void OPPROTO glue(op_stwcx, MEMSUFFIX) (void)
670 if (unlikely(env->reserve != (uint32_t)T0)) { 512 if (unlikely(env->reserve != (uint32_t)T0)) {
671 env->crf[0] = xer_so; 513 env->crf[0] = xer_so;
672 } else { 514 } else {
673 - glue(stl, MEMSUFFIX)((uint32_t)T0, T1); 515 + glue(st32, MEMSUFFIX)((uint32_t)T0, T1);
674 env->crf[0] = xer_so | 0x02; 516 env->crf[0] = xer_so | 0x02;
675 } 517 }
676 } 518 }
@@ -687,7 +529,7 @@ void OPPROTO glue(op_stwcx_64, MEMSUFFIX) (void) @@ -687,7 +529,7 @@ void OPPROTO glue(op_stwcx_64, MEMSUFFIX) (void)
687 if (unlikely(env->reserve != (uint64_t)T0)) { 529 if (unlikely(env->reserve != (uint64_t)T0)) {
688 env->crf[0] = xer_so; 530 env->crf[0] = xer_so;
689 } else { 531 } else {
690 - glue(stl, MEMSUFFIX)((uint64_t)T0, T1); 532 + glue(st32, MEMSUFFIX)((uint64_t)T0, T1);
691 env->crf[0] = xer_so | 0x02; 533 env->crf[0] = xer_so | 0x02;
692 } 534 }
693 } 535 }
@@ -703,7 +545,7 @@ void OPPROTO glue(op_stdcx, MEMSUFFIX) (void) @@ -703,7 +545,7 @@ void OPPROTO glue(op_stdcx, MEMSUFFIX) (void)
703 if (unlikely(env->reserve != (uint32_t)T0)) { 545 if (unlikely(env->reserve != (uint32_t)T0)) {
704 env->crf[0] = xer_so; 546 env->crf[0] = xer_so;
705 } else { 547 } else {
706 - glue(stq, MEMSUFFIX)((uint32_t)T0, T1); 548 + glue(st64, MEMSUFFIX)((uint32_t)T0, T1);
707 env->crf[0] = xer_so | 0x02; 549 env->crf[0] = xer_so | 0x02;
708 } 550 }
709 } 551 }
@@ -719,7 +561,7 @@ void OPPROTO glue(op_stdcx_64, MEMSUFFIX) (void) @@ -719,7 +561,7 @@ void OPPROTO glue(op_stdcx_64, MEMSUFFIX) (void)
719 if (unlikely(env->reserve != (uint64_t)T0)) { 561 if (unlikely(env->reserve != (uint64_t)T0)) {
720 env->crf[0] = xer_so; 562 env->crf[0] = xer_so;
721 } else { 563 } else {
722 - glue(stq, MEMSUFFIX)((uint64_t)T0, T1); 564 + glue(st64, MEMSUFFIX)((uint64_t)T0, T1);
723 env->crf[0] = xer_so | 0x02; 565 env->crf[0] = xer_so | 0x02;
724 } 566 }
725 } 567 }
@@ -796,72 +638,75 @@ void OPPROTO glue(op_stdcx_le_64, MEMSUFFIX) (void) @@ -796,72 +638,75 @@ void OPPROTO glue(op_stdcx_le_64, MEMSUFFIX) (void)
796 638
797 void OPPROTO glue(op_dcbz_l32, MEMSUFFIX) (void) 639 void OPPROTO glue(op_dcbz_l32, MEMSUFFIX) (void)
798 { 640 {
799 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x00), 0);  
800 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x04), 0);  
801 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x08), 0);  
802 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x0C), 0);  
803 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x10), 0);  
804 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x14), 0);  
805 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x18), 0);  
806 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x1C), 0); 641 + T0 &= ~((uint32_t)31);
  642 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x00), 0);
  643 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x04), 0);
  644 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x08), 0);
  645 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x0C), 0);
  646 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x10), 0);
  647 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x14), 0);
  648 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x18), 0);
  649 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x1C), 0);
807 RETURN(); 650 RETURN();
808 } 651 }
809 652
810 void OPPROTO glue(op_dcbz_l64, MEMSUFFIX) (void) 653 void OPPROTO glue(op_dcbz_l64, MEMSUFFIX) (void)
811 { 654 {
812 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x00), 0);  
813 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x04), 0);  
814 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x08), 0);  
815 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x0C), 0);  
816 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x10), 0);  
817 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x14), 0);  
818 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x18), 0);  
819 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x1C), 0);  
820 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x20UL), 0);  
821 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x24UL), 0);  
822 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x28UL), 0);  
823 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x2CUL), 0);  
824 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x30UL), 0);  
825 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x34UL), 0);  
826 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x38UL), 0);  
827 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x3CUL), 0); 655 + T0 &= ~((uint32_t)63);
  656 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x00), 0);
  657 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x04), 0);
  658 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x08), 0);
  659 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x0C), 0);
  660 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x10), 0);
  661 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x14), 0);
  662 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x18), 0);
  663 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x1C), 0);
  664 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x20UL), 0);
  665 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x24UL), 0);
  666 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x28UL), 0);
  667 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x2CUL), 0);
  668 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x30UL), 0);
  669 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x34UL), 0);
  670 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x38UL), 0);
  671 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x3CUL), 0);
828 RETURN(); 672 RETURN();
829 } 673 }
830 674
831 void OPPROTO glue(op_dcbz_l128, MEMSUFFIX) (void) 675 void OPPROTO glue(op_dcbz_l128, MEMSUFFIX) (void)
832 { 676 {
833 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x00), 0);  
834 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x04), 0);  
835 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x08), 0);  
836 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x0C), 0);  
837 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x10), 0);  
838 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x14), 0);  
839 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x18), 0);  
840 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x1C), 0);  
841 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x20UL), 0);  
842 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x24UL), 0);  
843 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x28UL), 0);  
844 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x2CUL), 0);  
845 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x30UL), 0);  
846 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x34UL), 0);  
847 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x38UL), 0);  
848 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x3CUL), 0);  
849 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x40UL), 0);  
850 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x44UL), 0);  
851 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x48UL), 0);  
852 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x4CUL), 0);  
853 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x50UL), 0);  
854 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x54UL), 0);  
855 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x58UL), 0);  
856 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x5CUL), 0);  
857 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x60UL), 0);  
858 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x64UL), 0);  
859 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x68UL), 0);  
860 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x6CUL), 0);  
861 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x70UL), 0);  
862 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x74UL), 0);  
863 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x78UL), 0);  
864 - glue(stl, MEMSUFFIX)((uint32_t)(T0 + 0x7CUL), 0); 677 + T0 &= ~((uint32_t)127);
  678 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x00), 0);
  679 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x04), 0);
  680 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x08), 0);
  681 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x0C), 0);
  682 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x10), 0);
  683 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x14), 0);
  684 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x18), 0);
  685 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x1C), 0);
  686 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x20UL), 0);
  687 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x24UL), 0);
  688 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x28UL), 0);
  689 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x2CUL), 0);
  690 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x30UL), 0);
  691 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x34UL), 0);
  692 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x38UL), 0);
  693 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x3CUL), 0);
  694 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x40UL), 0);
  695 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x44UL), 0);
  696 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x48UL), 0);
  697 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x4CUL), 0);
  698 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x50UL), 0);
  699 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x54UL), 0);
  700 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x58UL), 0);
  701 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x5CUL), 0);
  702 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x60UL), 0);
  703 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x64UL), 0);
  704 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x68UL), 0);
  705 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x6CUL), 0);
  706 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x70UL), 0);
  707 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x74UL), 0);
  708 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x78UL), 0);
  709 + glue(st32, MEMSUFFIX)((uint32_t)(T0 + 0x7CUL), 0);
865 RETURN(); 710 RETURN();
866 } 711 }
867 712
@@ -874,72 +719,75 @@ void OPPROTO glue(op_dcbz, MEMSUFFIX) (void) @@ -874,72 +719,75 @@ void OPPROTO glue(op_dcbz, MEMSUFFIX) (void)
874 #if defined(TARGET_PPC64) 719 #if defined(TARGET_PPC64)
875 void OPPROTO glue(op_dcbz_l32_64, MEMSUFFIX) (void) 720 void OPPROTO glue(op_dcbz_l32_64, MEMSUFFIX) (void)
876 { 721 {
877 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x00), 0);  
878 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x04), 0);  
879 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x08), 0);  
880 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x0C), 0);  
881 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x10), 0);  
882 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x14), 0);  
883 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x18), 0);  
884 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x1C), 0); 722 + T0 &= ~((uint64_t)31);
  723 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x00), 0);
  724 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x04), 0);
  725 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x08), 0);
  726 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x0C), 0);
  727 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x10), 0);
  728 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x14), 0);
  729 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x18), 0);
  730 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x1C), 0);
885 RETURN(); 731 RETURN();
886 } 732 }
887 733
888 void OPPROTO glue(op_dcbz_l64_64, MEMSUFFIX) (void) 734 void OPPROTO glue(op_dcbz_l64_64, MEMSUFFIX) (void)
889 { 735 {
890 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x00), 0);  
891 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x04), 0);  
892 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x08), 0);  
893 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x0C), 0);  
894 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x10), 0);  
895 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x14), 0);  
896 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x18), 0);  
897 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x1C), 0);  
898 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x20UL), 0);  
899 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x24UL), 0);  
900 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x28UL), 0);  
901 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x2CUL), 0);  
902 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x30UL), 0);  
903 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x34UL), 0);  
904 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x38UL), 0);  
905 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x3CUL), 0); 736 + T0 &= ~((uint64_t)63);
  737 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x00), 0);
  738 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x04), 0);
  739 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x08), 0);
  740 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x0C), 0);
  741 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x10), 0);
  742 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x14), 0);
  743 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x18), 0);
  744 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x1C), 0);
  745 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x20UL), 0);
  746 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x24UL), 0);
  747 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x28UL), 0);
  748 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x2CUL), 0);
  749 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x30UL), 0);
  750 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x34UL), 0);
  751 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x38UL), 0);
  752 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x3CUL), 0);
906 RETURN(); 753 RETURN();
907 } 754 }
908 755
909 void OPPROTO glue(op_dcbz_l128_64, MEMSUFFIX) (void) 756 void OPPROTO glue(op_dcbz_l128_64, MEMSUFFIX) (void)
910 { 757 {
911 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x00), 0);  
912 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x04), 0);  
913 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x08), 0);  
914 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x0C), 0);  
915 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x10), 0);  
916 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x14), 0);  
917 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x18), 0);  
918 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x1C), 0);  
919 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x20UL), 0);  
920 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x24UL), 0);  
921 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x28UL), 0);  
922 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x2CUL), 0);  
923 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x30UL), 0);  
924 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x34UL), 0);  
925 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x38UL), 0);  
926 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x3CUL), 0);  
927 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x40UL), 0);  
928 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x44UL), 0);  
929 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x48UL), 0);  
930 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x4CUL), 0);  
931 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x50UL), 0);  
932 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x54UL), 0);  
933 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x58UL), 0);  
934 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x5CUL), 0);  
935 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x60UL), 0);  
936 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x64UL), 0);  
937 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x68UL), 0);  
938 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x6CUL), 0);  
939 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x70UL), 0);  
940 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x74UL), 0);  
941 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x78UL), 0);  
942 - glue(stl, MEMSUFFIX)((uint64_t)(T0 + 0x7CUL), 0); 758 + T0 &= ~((uint64_t)127);
  759 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x00), 0);
  760 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x04), 0);
  761 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x08), 0);
  762 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x0C), 0);
  763 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x10), 0);
  764 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x14), 0);
  765 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x18), 0);
  766 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x1C), 0);
  767 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x20UL), 0);
  768 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x24UL), 0);
  769 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x28UL), 0);
  770 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x2CUL), 0);
  771 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x30UL), 0);
  772 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x34UL), 0);
  773 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x38UL), 0);
  774 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x3CUL), 0);
  775 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x40UL), 0);
  776 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x44UL), 0);
  777 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x48UL), 0);
  778 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x4CUL), 0);
  779 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x50UL), 0);
  780 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x54UL), 0);
  781 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x58UL), 0);
  782 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x5CUL), 0);
  783 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x60UL), 0);
  784 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x64UL), 0);
  785 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x68UL), 0);
  786 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x6CUL), 0);
  787 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x70UL), 0);
  788 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x74UL), 0);
  789 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x78UL), 0);
  790 + glue(st32, MEMSUFFIX)((uint64_t)(T0 + 0x7CUL), 0);
943 RETURN(); 791 RETURN();
944 } 792 }
945 793
@@ -968,42 +816,42 @@ void OPPROTO glue(op_icbi_64, MEMSUFFIX) (void) @@ -968,42 +816,42 @@ void OPPROTO glue(op_icbi_64, MEMSUFFIX) (void)
968 /* External access */ 816 /* External access */
969 void OPPROTO glue(op_eciwx, MEMSUFFIX) (void) 817 void OPPROTO glue(op_eciwx, MEMSUFFIX) (void)
970 { 818 {
971 - T1 = glue(ldl, MEMSUFFIX)((uint32_t)T0); 819 + T1 = glue(ldu32, MEMSUFFIX)((uint32_t)T0);
972 RETURN(); 820 RETURN();
973 } 821 }
974 822
975 #if defined(TARGET_PPC64) 823 #if defined(TARGET_PPC64)
976 void OPPROTO glue(op_eciwx_64, MEMSUFFIX) (void) 824 void OPPROTO glue(op_eciwx_64, MEMSUFFIX) (void)
977 { 825 {
978 - T1 = glue(ldl, MEMSUFFIX)((uint64_t)T0); 826 + T1 = glue(ldu32, MEMSUFFIX)((uint64_t)T0);
979 RETURN(); 827 RETURN();
980 } 828 }
981 #endif 829 #endif
982 830
983 void OPPROTO glue(op_ecowx, MEMSUFFIX) (void) 831 void OPPROTO glue(op_ecowx, MEMSUFFIX) (void)
984 { 832 {
985 - glue(stl, MEMSUFFIX)((uint32_t)T0, T1); 833 + glue(st32, MEMSUFFIX)((uint32_t)T0, T1);
986 RETURN(); 834 RETURN();
987 } 835 }
988 836
989 #if defined(TARGET_PPC64) 837 #if defined(TARGET_PPC64)
990 void OPPROTO glue(op_ecowx_64, MEMSUFFIX) (void) 838 void OPPROTO glue(op_ecowx_64, MEMSUFFIX) (void)
991 { 839 {
992 - glue(stl, MEMSUFFIX)((uint64_t)T0, T1); 840 + glue(st32, MEMSUFFIX)((uint64_t)T0, T1);
993 RETURN(); 841 RETURN();
994 } 842 }
995 #endif 843 #endif
996 844
997 void OPPROTO glue(op_eciwx_le, MEMSUFFIX) (void) 845 void OPPROTO glue(op_eciwx_le, MEMSUFFIX) (void)
998 { 846 {
999 - T1 = glue(ld32r, MEMSUFFIX)((uint32_t)T0); 847 + T1 = glue(ldu32r, MEMSUFFIX)((uint32_t)T0);
1000 RETURN(); 848 RETURN();
1001 } 849 }
1002 850
1003 #if defined(TARGET_PPC64) 851 #if defined(TARGET_PPC64)
1004 void OPPROTO glue(op_eciwx_le_64, MEMSUFFIX) (void) 852 void OPPROTO glue(op_eciwx_le_64, MEMSUFFIX) (void)
1005 { 853 {
1006 - T1 = glue(ld32r, MEMSUFFIX)((uint64_t)T0); 854 + T1 = glue(ldu32r, MEMSUFFIX)((uint64_t)T0);
1007 RETURN(); 855 RETURN();
1008 } 856 }
1009 #endif 857 #endif
@@ -1069,51 +917,51 @@ void OPPROTO glue(op_POWER2_stfq_le, MEMSUFFIX) (void) @@ -1069,51 +917,51 @@ void OPPROTO glue(op_POWER2_stfq_le, MEMSUFFIX) (void)
1069 #endif 917 #endif
1070 void OPPROTO glue(op_vr_lvx, MEMSUFFIX) (void) 918 void OPPROTO glue(op_vr_lvx, MEMSUFFIX) (void)
1071 { 919 {
1072 - AVR0.u64[VR_DWORD0] = glue(ldq, MEMSUFFIX)((uint32_t)T0);  
1073 - AVR0.u64[VR_DWORD1] = glue(ldq, MEMSUFFIX)((uint32_t)T0 + 8); 920 + AVR0.u64[VR_DWORD0] = glue(ldu64, MEMSUFFIX)((uint32_t)T0);
  921 + AVR0.u64[VR_DWORD1] = glue(ldu64, MEMSUFFIX)((uint32_t)T0 + 8);
1074 } 922 }
1075 923
1076 void OPPROTO glue(op_vr_lvx_le, MEMSUFFIX) (void) 924 void OPPROTO glue(op_vr_lvx_le, MEMSUFFIX) (void)
1077 { 925 {
1078 - AVR0.u64[VR_DWORD1] = glue(ldq, MEMSUFFIX)((uint32_t)T0);  
1079 - AVR0.u64[VR_DWORD0] = glue(ldq, MEMSUFFIX)((uint32_t)T0 + 8); 926 + AVR0.u64[VR_DWORD1] = glue(ldu64r, MEMSUFFIX)((uint32_t)T0);
  927 + AVR0.u64[VR_DWORD0] = glue(ldu64r, MEMSUFFIX)((uint32_t)T0 + 8);
1080 } 928 }
1081 929
1082 void OPPROTO glue(op_vr_stvx, MEMSUFFIX) (void) 930 void OPPROTO glue(op_vr_stvx, MEMSUFFIX) (void)
1083 { 931 {
1084 - glue(stq, MEMSUFFIX)((uint32_t)T0, AVR0.u64[VR_DWORD0]);  
1085 - glue(stq, MEMSUFFIX)((uint32_t)T0 + 8, AVR0.u64[VR_DWORD1]); 932 + glue(st64, MEMSUFFIX)((uint32_t)T0, AVR0.u64[VR_DWORD0]);
  933 + glue(st64, MEMSUFFIX)((uint32_t)T0 + 8, AVR0.u64[VR_DWORD1]);
1086 } 934 }
1087 935
1088 void OPPROTO glue(op_vr_stvx_le, MEMSUFFIX) (void) 936 void OPPROTO glue(op_vr_stvx_le, MEMSUFFIX) (void)
1089 { 937 {
1090 - glue(stq, MEMSUFFIX)((uint32_t)T0, AVR0.u64[VR_DWORD1]);  
1091 - glue(stq, MEMSUFFIX)((uint32_t)T0 + 8, AVR0.u64[VR_DWORD0]); 938 + glue(st64r, MEMSUFFIX)((uint32_t)T0, AVR0.u64[VR_DWORD1]);
  939 + glue(st64r, MEMSUFFIX)((uint32_t)T0 + 8, AVR0.u64[VR_DWORD0]);
1092 } 940 }
1093 941
1094 #if defined(TARGET_PPC64) 942 #if defined(TARGET_PPC64)
1095 void OPPROTO glue(op_vr_lvx_64, MEMSUFFIX) (void) 943 void OPPROTO glue(op_vr_lvx_64, MEMSUFFIX) (void)
1096 { 944 {
1097 - AVR0.u64[VR_DWORD0] = glue(ldq, MEMSUFFIX)((uint64_t)T0);  
1098 - AVR0.u64[VR_DWORD1] = glue(ldq, MEMSUFFIX)((uint64_t)T0 + 8); 945 + AVR0.u64[VR_DWORD0] = glue(ldu64, MEMSUFFIX)((uint64_t)T0);
  946 + AVR0.u64[VR_DWORD1] = glue(ldu64, MEMSUFFIX)((uint64_t)T0 + 8);
1099 } 947 }
1100 948
1101 void OPPROTO glue(op_vr_lvx_le_64, MEMSUFFIX) (void) 949 void OPPROTO glue(op_vr_lvx_le_64, MEMSUFFIX) (void)
1102 { 950 {
1103 - AVR0.u64[VR_DWORD1] = glue(ldq, MEMSUFFIX)((uint64_t)T0);  
1104 - AVR0.u64[VR_DWORD0] = glue(ldq, MEMSUFFIX)((uint64_t)T0 + 8); 951 + AVR0.u64[VR_DWORD1] = glue(ldu64r, MEMSUFFIX)((uint64_t)T0);
  952 + AVR0.u64[VR_DWORD0] = glue(ldu64r, MEMSUFFIX)((uint64_t)T0 + 8);
1105 } 953 }
1106 954
1107 void OPPROTO glue(op_vr_stvx_64, MEMSUFFIX) (void) 955 void OPPROTO glue(op_vr_stvx_64, MEMSUFFIX) (void)
1108 { 956 {
1109 - glue(stq, MEMSUFFIX)((uint64_t)T0, AVR0.u64[VR_DWORD0]);  
1110 - glue(stq, MEMSUFFIX)((uint64_t)T0 + 8, AVR0.u64[VR_DWORD1]); 957 + glue(st64, MEMSUFFIX)((uint64_t)T0, AVR0.u64[VR_DWORD0]);
  958 + glue(st64, MEMSUFFIX)((uint64_t)T0 + 8, AVR0.u64[VR_DWORD1]);
1111 } 959 }
1112 960
1113 void OPPROTO glue(op_vr_stvx_le_64, MEMSUFFIX) (void) 961 void OPPROTO glue(op_vr_stvx_le_64, MEMSUFFIX) (void)
1114 { 962 {
1115 - glue(stq, MEMSUFFIX)((uint64_t)T0, AVR0.u64[VR_DWORD1]);  
1116 - glue(stq, MEMSUFFIX)((uint64_t)T0 + 8, AVR0.u64[VR_DWORD0]); 963 + glue(st64r, MEMSUFFIX)((uint64_t)T0, AVR0.u64[VR_DWORD1]);
  964 + glue(st64r, MEMSUFFIX)((uint64_t)T0 + 8, AVR0.u64[VR_DWORD0]);
1117 } 965 }
1118 #endif 966 #endif
1119 #undef VR_DWORD0 967 #undef VR_DWORD0
@@ -1165,31 +1013,31 @@ _PPC_SPE_ST_OP(name, op) @@ -1165,31 +1013,31 @@ _PPC_SPE_ST_OP(name, op)
1165 #endif 1013 #endif
1166 1014
1167 #if !defined(TARGET_PPC64) 1015 #if !defined(TARGET_PPC64)
1168 -PPC_SPE_LD_OP(dd, ldq);  
1169 -PPC_SPE_ST_OP(dd, stq);  
1170 -PPC_SPE_LD_OP(dd_le, ld64r); 1016 +PPC_SPE_LD_OP(dd, ldu64);
  1017 +PPC_SPE_ST_OP(dd, st64);
  1018 +PPC_SPE_LD_OP(dd_le, ldu64r);
1171 PPC_SPE_ST_OP(dd_le, st64r); 1019 PPC_SPE_ST_OP(dd_le, st64r);
1172 #endif 1020 #endif
1173 static always_inline uint64_t glue(spe_ldw, MEMSUFFIX) (target_ulong EA) 1021 static always_inline uint64_t glue(spe_ldw, MEMSUFFIX) (target_ulong EA)
1174 { 1022 {
1175 uint64_t ret; 1023 uint64_t ret;
1176 - ret = (uint64_t)glue(ldl, MEMSUFFIX)(EA) << 32;  
1177 - ret |= (uint64_t)glue(ldl, MEMSUFFIX)(EA + 4); 1024 + ret = (uint64_t)glue(ldu32, MEMSUFFIX)(EA) << 32;
  1025 + ret |= (uint64_t)glue(ldu32, MEMSUFFIX)(EA + 4);
1178 return ret; 1026 return ret;
1179 } 1027 }
1180 PPC_SPE_LD_OP(dw, spe_ldw); 1028 PPC_SPE_LD_OP(dw, spe_ldw);
1181 static always_inline void glue(spe_stdw, MEMSUFFIX) (target_ulong EA, 1029 static always_inline void glue(spe_stdw, MEMSUFFIX) (target_ulong EA,
1182 uint64_t data) 1030 uint64_t data)
1183 { 1031 {
1184 - glue(stl, MEMSUFFIX)(EA, data >> 32);  
1185 - glue(stl, MEMSUFFIX)(EA + 4, data); 1032 + glue(st32, MEMSUFFIX)(EA, data >> 32);
  1033 + glue(st32, MEMSUFFIX)(EA + 4, data);
1186 } 1034 }
1187 PPC_SPE_ST_OP(dw, spe_stdw); 1035 PPC_SPE_ST_OP(dw, spe_stdw);
1188 static always_inline uint64_t glue(spe_ldw_le, MEMSUFFIX) (target_ulong EA) 1036 static always_inline uint64_t glue(spe_ldw_le, MEMSUFFIX) (target_ulong EA)
1189 { 1037 {
1190 uint64_t ret; 1038 uint64_t ret;
1191 - ret = (uint64_t)glue(ld32r, MEMSUFFIX)(EA) << 32;  
1192 - ret |= (uint64_t)glue(ld32r, MEMSUFFIX)(EA + 4); 1039 + ret = (uint64_t)glue(ldu32r, MEMSUFFIX)(EA) << 32;
  1040 + ret |= (uint64_t)glue(ldu32r, MEMSUFFIX)(EA + 4);
1193 return ret; 1041 return ret;
1194 } 1042 }
1195 PPC_SPE_LD_OP(dw_le, spe_ldw_le); 1043 PPC_SPE_LD_OP(dw_le, spe_ldw_le);
@@ -1203,29 +1051,29 @@ PPC_SPE_ST_OP(dw_le, spe_stdw_le); @@ -1203,29 +1051,29 @@ PPC_SPE_ST_OP(dw_le, spe_stdw_le);
1203 static always_inline uint64_t glue(spe_ldh, MEMSUFFIX) (target_ulong EA) 1051 static always_inline uint64_t glue(spe_ldh, MEMSUFFIX) (target_ulong EA)
1204 { 1052 {
1205 uint64_t ret; 1053 uint64_t ret;
1206 - ret = (uint64_t)glue(lduw, MEMSUFFIX)(EA) << 48;  
1207 - ret |= (uint64_t)glue(lduw, MEMSUFFIX)(EA + 2) << 32;  
1208 - ret |= (uint64_t)glue(lduw, MEMSUFFIX)(EA + 4) << 16;  
1209 - ret |= (uint64_t)glue(lduw, MEMSUFFIX)(EA + 6); 1054 + ret = (uint64_t)glue(ldu16, MEMSUFFIX)(EA) << 48;
  1055 + ret |= (uint64_t)glue(ldu16, MEMSUFFIX)(EA + 2) << 32;
  1056 + ret |= (uint64_t)glue(ldu16, MEMSUFFIX)(EA + 4) << 16;
  1057 + ret |= (uint64_t)glue(ldu16, MEMSUFFIX)(EA + 6);
1210 return ret; 1058 return ret;
1211 } 1059 }
1212 PPC_SPE_LD_OP(dh, spe_ldh); 1060 PPC_SPE_LD_OP(dh, spe_ldh);
1213 static always_inline void glue(spe_stdh, MEMSUFFIX) (target_ulong EA, 1061 static always_inline void glue(spe_stdh, MEMSUFFIX) (target_ulong EA,
1214 uint64_t data) 1062 uint64_t data)
1215 { 1063 {
1216 - glue(stw, MEMSUFFIX)(EA, data >> 48);  
1217 - glue(stw, MEMSUFFIX)(EA + 2, data >> 32);  
1218 - glue(stw, MEMSUFFIX)(EA + 4, data >> 16);  
1219 - glue(stw, MEMSUFFIX)(EA + 6, data); 1064 + glue(st16, MEMSUFFIX)(EA, data >> 48);
  1065 + glue(st16, MEMSUFFIX)(EA + 2, data >> 32);
  1066 + glue(st16, MEMSUFFIX)(EA + 4, data >> 16);
  1067 + glue(st16, MEMSUFFIX)(EA + 6, data);
1220 } 1068 }
1221 PPC_SPE_ST_OP(dh, spe_stdh); 1069 PPC_SPE_ST_OP(dh, spe_stdh);
1222 static always_inline uint64_t glue(spe_ldh_le, MEMSUFFIX) (target_ulong EA) 1070 static always_inline uint64_t glue(spe_ldh_le, MEMSUFFIX) (target_ulong EA)
1223 { 1071 {
1224 uint64_t ret; 1072 uint64_t ret;
1225 - ret = (uint64_t)glue(ld16r, MEMSUFFIX)(EA) << 48;  
1226 - ret |= (uint64_t)glue(ld16r, MEMSUFFIX)(EA + 2) << 32;  
1227 - ret |= (uint64_t)glue(ld16r, MEMSUFFIX)(EA + 4) << 16;  
1228 - ret |= (uint64_t)glue(ld16r, MEMSUFFIX)(EA + 6); 1073 + ret = (uint64_t)glue(ldu16r, MEMSUFFIX)(EA) << 48;
  1074 + ret |= (uint64_t)glue(ldu16r, MEMSUFFIX)(EA + 2) << 32;
  1075 + ret |= (uint64_t)glue(ldu16r, MEMSUFFIX)(EA + 4) << 16;
  1076 + ret |= (uint64_t)glue(ldu16r, MEMSUFFIX)(EA + 6);
1229 return ret; 1077 return ret;
1230 } 1078 }
1231 PPC_SPE_LD_OP(dh_le, spe_ldh_le); 1079 PPC_SPE_LD_OP(dh_le, spe_ldh_le);
@@ -1241,23 +1089,23 @@ PPC_SPE_ST_OP(dh_le, spe_stdh_le); @@ -1241,23 +1089,23 @@ PPC_SPE_ST_OP(dh_le, spe_stdh_le);
1241 static always_inline uint64_t glue(spe_lwhe, MEMSUFFIX) (target_ulong EA) 1089 static always_inline uint64_t glue(spe_lwhe, MEMSUFFIX) (target_ulong EA)
1242 { 1090 {
1243 uint64_t ret; 1091 uint64_t ret;
1244 - ret = (uint64_t)glue(lduw, MEMSUFFIX)(EA) << 48;  
1245 - ret |= (uint64_t)glue(lduw, MEMSUFFIX)(EA + 2) << 16; 1092 + ret = (uint64_t)glue(ldu16, MEMSUFFIX)(EA) << 48;
  1093 + ret |= (uint64_t)glue(ldu16, MEMSUFFIX)(EA + 2) << 16;
1246 return ret; 1094 return ret;
1247 } 1095 }
1248 PPC_SPE_LD_OP(whe, spe_lwhe); 1096 PPC_SPE_LD_OP(whe, spe_lwhe);
1249 static always_inline void glue(spe_stwhe, MEMSUFFIX) (target_ulong EA, 1097 static always_inline void glue(spe_stwhe, MEMSUFFIX) (target_ulong EA,
1250 uint64_t data) 1098 uint64_t data)
1251 { 1099 {
1252 - glue(stw, MEMSUFFIX)(EA, data >> 48);  
1253 - glue(stw, MEMSUFFIX)(EA + 2, data >> 16); 1100 + glue(st16, MEMSUFFIX)(EA, data >> 48);
  1101 + glue(st16, MEMSUFFIX)(EA + 2, data >> 16);
1254 } 1102 }
1255 PPC_SPE_ST_OP(whe, spe_stwhe); 1103 PPC_SPE_ST_OP(whe, spe_stwhe);
1256 static always_inline uint64_t glue(spe_lwhe_le, MEMSUFFIX) (target_ulong EA) 1104 static always_inline uint64_t glue(spe_lwhe_le, MEMSUFFIX) (target_ulong EA)
1257 { 1105 {
1258 uint64_t ret; 1106 uint64_t ret;
1259 - ret = (uint64_t)glue(ld16r, MEMSUFFIX)(EA) << 48;  
1260 - ret |= (uint64_t)glue(ld16r, MEMSUFFIX)(EA + 2) << 16; 1107 + ret = (uint64_t)glue(ldu16r, MEMSUFFIX)(EA) << 48;
  1108 + ret |= (uint64_t)glue(ldu16r, MEMSUFFIX)(EA + 2) << 16;
1261 return ret; 1109 return ret;
1262 } 1110 }
1263 PPC_SPE_LD_OP(whe_le, spe_lwhe_le); 1111 PPC_SPE_LD_OP(whe_le, spe_lwhe_le);
@@ -1271,39 +1119,39 @@ PPC_SPE_ST_OP(whe_le, spe_stwhe_le); @@ -1271,39 +1119,39 @@ PPC_SPE_ST_OP(whe_le, spe_stwhe_le);
1271 static always_inline uint64_t glue(spe_lwhou, MEMSUFFIX) (target_ulong EA) 1119 static always_inline uint64_t glue(spe_lwhou, MEMSUFFIX) (target_ulong EA)
1272 { 1120 {
1273 uint64_t ret; 1121 uint64_t ret;
1274 - ret = (uint64_t)glue(lduw, MEMSUFFIX)(EA) << 32;  
1275 - ret |= (uint64_t)glue(lduw, MEMSUFFIX)(EA + 2); 1122 + ret = (uint64_t)glue(ldu16, MEMSUFFIX)(EA) << 32;
  1123 + ret |= (uint64_t)glue(ldu16, MEMSUFFIX)(EA + 2);
1276 return ret; 1124 return ret;
1277 } 1125 }
1278 PPC_SPE_LD_OP(whou, spe_lwhou); 1126 PPC_SPE_LD_OP(whou, spe_lwhou);
1279 static always_inline uint64_t glue(spe_lwhos, MEMSUFFIX) (target_ulong EA) 1127 static always_inline uint64_t glue(spe_lwhos, MEMSUFFIX) (target_ulong EA)
1280 { 1128 {
1281 uint64_t ret; 1129 uint64_t ret;
1282 - ret = ((uint64_t)((int32_t)glue(ldsw, MEMSUFFIX)(EA))) << 32;  
1283 - ret |= (uint64_t)((int32_t)glue(ldsw, MEMSUFFIX)(EA + 2)); 1130 + ret = ((uint64_t)((int32_t)glue(lds16, MEMSUFFIX)(EA))) << 32;
  1131 + ret |= (uint64_t)((int32_t)glue(lds16, MEMSUFFIX)(EA + 2));
1284 return ret; 1132 return ret;
1285 } 1133 }
1286 PPC_SPE_LD_OP(whos, spe_lwhos); 1134 PPC_SPE_LD_OP(whos, spe_lwhos);
1287 static always_inline void glue(spe_stwho, MEMSUFFIX) (target_ulong EA, 1135 static always_inline void glue(spe_stwho, MEMSUFFIX) (target_ulong EA,
1288 uint64_t data) 1136 uint64_t data)
1289 { 1137 {
1290 - glue(stw, MEMSUFFIX)(EA, data >> 32);  
1291 - glue(stw, MEMSUFFIX)(EA + 2, data); 1138 + glue(st16, MEMSUFFIX)(EA, data >> 32);
  1139 + glue(st16, MEMSUFFIX)(EA + 2, data);
1292 } 1140 }
1293 PPC_SPE_ST_OP(who, spe_stwho); 1141 PPC_SPE_ST_OP(who, spe_stwho);
1294 static always_inline uint64_t glue(spe_lwhou_le, MEMSUFFIX) (target_ulong EA) 1142 static always_inline uint64_t glue(spe_lwhou_le, MEMSUFFIX) (target_ulong EA)
1295 { 1143 {
1296 uint64_t ret; 1144 uint64_t ret;
1297 - ret = (uint64_t)glue(ld16r, MEMSUFFIX)(EA) << 32;  
1298 - ret |= (uint64_t)glue(ld16r, MEMSUFFIX)(EA + 2); 1145 + ret = (uint64_t)glue(ldu16r, MEMSUFFIX)(EA) << 32;
  1146 + ret |= (uint64_t)glue(ldu16r, MEMSUFFIX)(EA + 2);
1299 return ret; 1147 return ret;
1300 } 1148 }
1301 PPC_SPE_LD_OP(whou_le, spe_lwhou_le); 1149 PPC_SPE_LD_OP(whou_le, spe_lwhou_le);
1302 static always_inline uint64_t glue(spe_lwhos_le, MEMSUFFIX) (target_ulong EA) 1150 static always_inline uint64_t glue(spe_lwhos_le, MEMSUFFIX) (target_ulong EA)
1303 { 1151 {
1304 uint64_t ret; 1152 uint64_t ret;
1305 - ret = ((uint64_t)((int32_t)glue(ld16rs, MEMSUFFIX)(EA))) << 32;  
1306 - ret |= (uint64_t)((int32_t)glue(ld16rs, MEMSUFFIX)(EA + 2)); 1153 + ret = ((uint64_t)((int32_t)glue(lds16r, MEMSUFFIX)(EA))) << 32;
  1154 + ret |= (uint64_t)((int32_t)glue(lds16r, MEMSUFFIX)(EA + 2));
1307 return ret; 1155 return ret;
1308 } 1156 }
1309 PPC_SPE_LD_OP(whos_le, spe_lwhos_le); 1157 PPC_SPE_LD_OP(whos_le, spe_lwhos_le);
@@ -1318,7 +1166,7 @@ PPC_SPE_ST_OP(who_le, spe_stwho_le); @@ -1318,7 +1166,7 @@ PPC_SPE_ST_OP(who_le, spe_stwho_le);
1318 static always_inline void glue(spe_stwwo, MEMSUFFIX) (target_ulong EA, 1166 static always_inline void glue(spe_stwwo, MEMSUFFIX) (target_ulong EA,
1319 uint64_t data) 1167 uint64_t data)
1320 { 1168 {
1321 - glue(stl, MEMSUFFIX)(EA, data); 1169 + glue(st32, MEMSUFFIX)(EA, data);
1322 } 1170 }
1323 PPC_SPE_ST_OP(wwo, spe_stwwo); 1171 PPC_SPE_ST_OP(wwo, spe_stwwo);
1324 static always_inline void glue(spe_stwwo_le, MEMSUFFIX) (target_ulong EA, 1172 static always_inline void glue(spe_stwwo_le, MEMSUFFIX) (target_ulong EA,
@@ -1331,21 +1179,21 @@ PPC_SPE_ST_OP(wwo_le, spe_stwwo_le); @@ -1331,21 +1179,21 @@ PPC_SPE_ST_OP(wwo_le, spe_stwwo_le);
1331 static always_inline uint64_t glue(spe_lh, MEMSUFFIX) (target_ulong EA) 1179 static always_inline uint64_t glue(spe_lh, MEMSUFFIX) (target_ulong EA)
1332 { 1180 {
1333 uint16_t tmp; 1181 uint16_t tmp;
1334 - tmp = glue(lduw, MEMSUFFIX)(EA); 1182 + tmp = glue(ldu16, MEMSUFFIX)(EA);
1335 return ((uint64_t)tmp << 48) | ((uint64_t)tmp << 16); 1183 return ((uint64_t)tmp << 48) | ((uint64_t)tmp << 16);
1336 } 1184 }
1337 PPC_SPE_LD_OP(h, spe_lh); 1185 PPC_SPE_LD_OP(h, spe_lh);
1338 static always_inline uint64_t glue(spe_lh_le, MEMSUFFIX) (target_ulong EA) 1186 static always_inline uint64_t glue(spe_lh_le, MEMSUFFIX) (target_ulong EA)
1339 { 1187 {
1340 uint16_t tmp; 1188 uint16_t tmp;
1341 - tmp = glue(ld16r, MEMSUFFIX)(EA); 1189 + tmp = glue(ldu16r, MEMSUFFIX)(EA);
1342 return ((uint64_t)tmp << 48) | ((uint64_t)tmp << 16); 1190 return ((uint64_t)tmp << 48) | ((uint64_t)tmp << 16);
1343 } 1191 }
1344 PPC_SPE_LD_OP(h_le, spe_lh_le); 1192 PPC_SPE_LD_OP(h_le, spe_lh_le);
1345 static always_inline uint64_t glue(spe_lwwsplat, MEMSUFFIX) (target_ulong EA) 1193 static always_inline uint64_t glue(spe_lwwsplat, MEMSUFFIX) (target_ulong EA)
1346 { 1194 {
1347 uint32_t tmp; 1195 uint32_t tmp;
1348 - tmp = glue(ldl, MEMSUFFIX)(EA); 1196 + tmp = glue(ldu32, MEMSUFFIX)(EA);
1349 return ((uint64_t)tmp << 32) | (uint64_t)tmp; 1197 return ((uint64_t)tmp << 32) | (uint64_t)tmp;
1350 } 1198 }
1351 PPC_SPE_LD_OP(wwsplat, spe_lwwsplat); 1199 PPC_SPE_LD_OP(wwsplat, spe_lwwsplat);
@@ -1353,7 +1201,7 @@ static always_inline @@ -1353,7 +1201,7 @@ static always_inline
1353 uint64_t glue(spe_lwwsplat_le, MEMSUFFIX) (target_ulong EA) 1201 uint64_t glue(spe_lwwsplat_le, MEMSUFFIX) (target_ulong EA)
1354 { 1202 {
1355 uint32_t tmp; 1203 uint32_t tmp;
1356 - tmp = glue(ld32r, MEMSUFFIX)(EA); 1204 + tmp = glue(ldu32r, MEMSUFFIX)(EA);
1357 return ((uint64_t)tmp << 32) | (uint64_t)tmp; 1205 return ((uint64_t)tmp << 32) | (uint64_t)tmp;
1358 } 1206 }
1359 PPC_SPE_LD_OP(wwsplat_le, spe_lwwsplat_le); 1207 PPC_SPE_LD_OP(wwsplat_le, spe_lwwsplat_le);
@@ -1361,9 +1209,9 @@ static always_inline uint64_t glue(spe_lwhsplat, MEMSUFFIX) (target_ulong EA) @@ -1361,9 +1209,9 @@ static always_inline uint64_t glue(spe_lwhsplat, MEMSUFFIX) (target_ulong EA)
1361 { 1209 {
1362 uint64_t ret; 1210 uint64_t ret;
1363 uint16_t tmp; 1211 uint16_t tmp;
1364 - tmp = glue(lduw, MEMSUFFIX)(EA); 1212 + tmp = glue(ldu16, MEMSUFFIX)(EA);
1365 ret = ((uint64_t)tmp << 48) | ((uint64_t)tmp << 32); 1213 ret = ((uint64_t)tmp << 48) | ((uint64_t)tmp << 32);
1366 - tmp = glue(lduw, MEMSUFFIX)(EA + 2); 1214 + tmp = glue(ldu16, MEMSUFFIX)(EA + 2);
1367 ret |= ((uint64_t)tmp << 16) | (uint64_t)tmp; 1215 ret |= ((uint64_t)tmp << 16) | (uint64_t)tmp;
1368 return ret; 1216 return ret;
1369 } 1217 }
@@ -1373,9 +1221,9 @@ uint64_t glue(spe_lwhsplat_le, MEMSUFFIX) (target_ulong EA) @@ -1373,9 +1221,9 @@ uint64_t glue(spe_lwhsplat_le, MEMSUFFIX) (target_ulong EA)
1373 { 1221 {
1374 uint64_t ret; 1222 uint64_t ret;
1375 uint16_t tmp; 1223 uint16_t tmp;
1376 - tmp = glue(ld16r, MEMSUFFIX)(EA); 1224 + tmp = glue(ldu16r, MEMSUFFIX)(EA);
1377 ret = ((uint64_t)tmp << 48) | ((uint64_t)tmp << 32); 1225 ret = ((uint64_t)tmp << 48) | ((uint64_t)tmp << 32);
1378 - tmp = glue(ld16r, MEMSUFFIX)(EA + 2); 1226 + tmp = glue(ldu16r, MEMSUFFIX)(EA + 2);
1379 ret |= ((uint64_t)tmp << 16) | (uint64_t)tmp; 1227 ret |= ((uint64_t)tmp << 16) | (uint64_t)tmp;
1380 return ret; 1228 return ret;
1381 } 1229 }
target-ppc/op_mem_access.h 0 → 100644
  View file @e7c2400
  1 +/*
  2 + * PowerPC emulation memory access helpers for qemu.
  3 + *
  4 + * Copyright (c) 2003-2007 Jocelyn Mayer
  5 + *
  6 + * This library is free software; you can redistribute it and/or
  7 + * modify it under the terms of the GNU Lesser General Public
  8 + * License as published by the Free Software Foundation; either
  9 + * version 2 of the License, or (at your option) any later version.
  10 + *
  11 + * This library is distributed in the hope that it will be useful,
  12 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14 + * Lesser General Public License for more details.
  15 + *
  16 + * You should have received a copy of the GNU Lesser General Public
  17 + * License along with this library; if not, write to the Free Software
  18 + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19 + */
  20 +
  21 +/* 8 bits accesses */
  22 +static always_inline target_ulong glue(ldu8, MEMSUFFIX) (target_ulong EA)
  23 +{
  24 + return (uint8_t)glue(ldub, MEMSUFFIX)(EA);
  25 +}
  26 +
  27 +static always_inline target_long glue(lds8, MEMSUFFIX) (target_ulong EA)
  28 +{
  29 + return (int8_t)glue(ldsb, MEMSUFFIX)(EA);
  30 +}
  31 +
  32 +static always_inline void glue(st8, MEMSUFFIX) (target_ulong EA, uint8_t val)
  33 +{
  34 + glue(stb, MEMSUFFIX)(EA, val);
  35 +}
  36 +
  37 +/* 16 bits accesses */
  38 +static always_inline target_ulong glue(ldu16, MEMSUFFIX) (target_ulong EA)
  39 +{
  40 + return (uint16_t)glue(lduw, MEMSUFFIX)(EA);
  41 +}
  42 +
  43 +static always_inline target_long glue(lds16, MEMSUFFIX) (target_ulong EA)
  44 +{
  45 + return (int16_t)glue(ldsw, MEMSUFFIX)(EA);
  46 +}
  47 +
  48 +static always_inline void glue(st16, MEMSUFFIX) (target_ulong EA, uint16_t val)
  49 +{
  50 + glue(stw, MEMSUFFIX)(EA, val);
  51 +}
  52 +
  53 +static always_inline target_ulong glue(ldu16r, MEMSUFFIX) (target_ulong EA)
  54 +{
  55 + return (uint16_t)bswap16(glue(lduw, MEMSUFFIX)(EA));
  56 +}
  57 +
  58 +static always_inline target_long glue(lds16r, MEMSUFFIX) (target_ulong EA)
  59 +{
  60 + return (int16_t)bswap16(glue(lduw, MEMSUFFIX)(EA));
  61 +}
  62 +
  63 +static always_inline void glue(st16r, MEMSUFFIX) (target_ulong EA, uint16_t val)
  64 +{
  65 + glue(stw, MEMSUFFIX)(EA, bswap16(val));
  66 +}
  67 +
  68 +/* 32 bits accesses */
  69 +static always_inline uint32_t glue(__ldul, MEMSUFFIX) (target_ulong EA)
  70 +{
  71 + return (uint32_t)glue(ldl, MEMSUFFIX)(EA);
  72 +}
  73 +
  74 +static always_inline int32_t glue(__ldsl, MEMSUFFIX) (target_ulong EA)
  75 +{
  76 + return (int32_t)glue(ldl, MEMSUFFIX)(EA);
  77 +}
  78 +
  79 +static always_inline target_ulong glue(ldu32, MEMSUFFIX) (target_ulong EA)
  80 +{
  81 + return glue(__ldul, MEMSUFFIX)(EA);
  82 +}
  83 +
  84 +static always_inline target_long glue(lds32, MEMSUFFIX) (target_ulong EA)
  85 +{
  86 + return glue(__ldsl, MEMSUFFIX)(EA);
  87 +}
  88 +
  89 +static always_inline void glue(st32, MEMSUFFIX) (target_ulong EA, uint32_t val)
  90 +{
  91 + glue(stl, MEMSUFFIX)(EA, val);
  92 +}
  93 +
  94 +static always_inline target_ulong glue(ldu32r, MEMSUFFIX) (target_ulong EA)
  95 +{
  96 + return bswap32(glue(__ldul, MEMSUFFIX)(EA));
  97 +}
  98 +
  99 +static always_inline target_long glue(lds32r, MEMSUFFIX) (target_ulong EA)
  100 +{
  101 + return (int32_t)bswap32(glue(__ldul, MEMSUFFIX)(EA));
  102 +}
  103 +
  104 +static always_inline void glue(st32r, MEMSUFFIX) (target_ulong EA, uint32_t val)
  105 +{
  106 + glue(stl, MEMSUFFIX)(EA, bswap32(val));
  107 +}
  108 +
  109 +/* 64 bits accesses */
  110 +static always_inline uint64_t glue(__lduq, MEMSUFFIX) (target_ulong EA)
  111 +{
  112 + return (uint64_t)glue(ldq, MEMSUFFIX)(EA);
  113 +}
  114 +
  115 +static always_inline int64_t glue(__ldsq, MEMSUFFIX) (target_ulong EA)
  116 +{
  117 + return (int64_t)glue(ldq, MEMSUFFIX)(EA);
  118 +}
  119 +
  120 +static always_inline uint64_t glue(ldu64, MEMSUFFIX) (target_ulong EA)
  121 +{
  122 + return glue(__lduq, MEMSUFFIX)(EA);
  123 +}
  124 +
  125 +static always_inline int64_t glue(lds64, MEMSUFFIX) (target_ulong EA)
  126 +{
  127 + return glue(__ldsq, MEMSUFFIX)(EA);
  128 +}
  129 +
  130 +static always_inline void glue(st64, MEMSUFFIX) (target_ulong EA, uint64_t val)
  131 +{
  132 + glue(stq, MEMSUFFIX)(EA, val);
  133 +}
  134 +
  135 +static always_inline uint64_t glue(ldu64r, MEMSUFFIX) (target_ulong EA)
  136 +{
  137 + return bswap64(glue(__lduq, MEMSUFFIX)(EA));
  138 +}
  139 +
  140 +static always_inline int64_t glue(lds64r, MEMSUFFIX) (target_ulong EA)
  141 +{
  142 + return (int64_t)bswap64(glue(__lduq, MEMSUFFIX)(EA));
  143 +}
  144 +
  145 +static always_inline void glue(st64r, MEMSUFFIX) (target_ulong EA, uint64_t val)
  146 +{
  147 + glue(stq, MEMSUFFIX)(EA, bswap64(val));
  148 +}
target-ppc/translate.c
  View file @e7c2400
@@ -2455,12 +2455,37 @@ GEN_HANDLER(stmw, 0x2F, 0xFF, 0xFF, 0x00000000, PPC_INTEGER) @@ -2455,12 +2455,37 @@ GEN_HANDLER(stmw, 0x2F, 0xFF, 0xFF, 0x00000000, PPC_INTEGER)
2455 /*** Integer load and store strings ***/ 2455 /*** Integer load and store strings ***/
2456 #define op_ldsts(name, start) (*gen_op_##name[ctx->mem_idx])(start) 2456 #define op_ldsts(name, start) (*gen_op_##name[ctx->mem_idx])(start)
2457 #define op_ldstsx(name, rd, ra, rb) (*gen_op_##name[ctx->mem_idx])(rd, ra, rb) 2457 #define op_ldstsx(name, rd, ra, rb) (*gen_op_##name[ctx->mem_idx])(rd, ra, rb)
  2458 +/* string load & stores are by definition endian-safe */
  2459 +#define gen_op_lswi_le_raw gen_op_lswi_raw
  2460 +#define gen_op_lswi_le_user gen_op_lswi_user
  2461 +#define gen_op_lswi_le_kernel gen_op_lswi_kernel
  2462 +#define gen_op_lswi_le_hypv gen_op_lswi_hypv
  2463 +#define gen_op_lswi_le_64_raw gen_op_lswi_raw
  2464 +#define gen_op_lswi_le_64_user gen_op_lswi_user
  2465 +#define gen_op_lswi_le_64_kernel gen_op_lswi_kernel
  2466 +#define gen_op_lswi_le_64_hypv gen_op_lswi_hypv
2458 static GenOpFunc1 *gen_op_lswi[NB_MEM_FUNCS] = { 2467 static GenOpFunc1 *gen_op_lswi[NB_MEM_FUNCS] = {
2459 GEN_MEM_FUNCS(lswi), 2468 GEN_MEM_FUNCS(lswi),
2460 }; 2469 };
  2470 +#define gen_op_lswx_le_raw gen_op_lswx_raw
  2471 +#define gen_op_lswx_le_user gen_op_lswx_user
  2472 +#define gen_op_lswx_le_kernel gen_op_lswx_kernel
  2473 +#define gen_op_lswx_le_hypv gen_op_lswx_hypv
  2474 +#define gen_op_lswx_le_64_raw gen_op_lswx_raw
  2475 +#define gen_op_lswx_le_64_user gen_op_lswx_user
  2476 +#define gen_op_lswx_le_64_kernel gen_op_lswx_kernel
  2477 +#define gen_op_lswx_le_64_hypv gen_op_lswx_hypv
2461 static GenOpFunc3 *gen_op_lswx[NB_MEM_FUNCS] = { 2478 static GenOpFunc3 *gen_op_lswx[NB_MEM_FUNCS] = {
2462 GEN_MEM_FUNCS(lswx), 2479 GEN_MEM_FUNCS(lswx),
2463 }; 2480 };
  2481 +#define gen_op_stsw_le_raw gen_op_stsw_raw
  2482 +#define gen_op_stsw_le_user gen_op_stsw_user
  2483 +#define gen_op_stsw_le_kernel gen_op_stsw_kernel
  2484 +#define gen_op_stsw_le_hypv gen_op_stsw_hypv
  2485 +#define gen_op_stsw_le_64_raw gen_op_stsw_raw
  2486 +#define gen_op_stsw_le_64_user gen_op_stsw_user
  2487 +#define gen_op_stsw_le_64_kernel gen_op_stsw_kernel
  2488 +#define gen_op_stsw_le_64_hypv gen_op_stsw_hypv
2464 static GenOpFunc1 *gen_op_stsw[NB_MEM_FUNCS] = { 2489 static GenOpFunc1 *gen_op_stsw[NB_MEM_FUNCS] = {
2465 GEN_MEM_FUNCS(stsw), 2490 GEN_MEM_FUNCS(stsw),
2466 }; 2491 };