![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to op_mem.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / target-ppc|
Return to op_mem.h CVS log | Up to [Qemu by Fabrice Bellard] / qemu / target-ppc |
1.1 root 1: /* External helpers */
2: void glue(do_lsw, MEMSUFFIX) (int dst);
3: void glue(do_stsw, MEMSUFFIX) (int src);
4:
5: static inline uint16_t glue(ld16r, MEMSUFFIX) (target_ulong EA)
6: {
7: uint16_t tmp = glue(lduw, MEMSUFFIX)(EA);
8: return ((tmp & 0xFF00) >> 8) | ((tmp & 0x00FF) << 8);
9: }
10:
11: static inline int32_t glue(ld16rs, MEMSUFFIX) (target_ulong EA)
12: {
13: int16_t tmp = glue(lduw, MEMSUFFIX)(EA);
14: return ((tmp & 0xFF00) >> 8) | ((tmp & 0x00FF) << 8);
15: }
16:
17: static inline uint32_t glue(ld32r, MEMSUFFIX) (target_ulong EA)
18: {
19: uint32_t tmp = glue(ldl, MEMSUFFIX)(EA);
20: return ((tmp & 0xFF000000) >> 24) | ((tmp & 0x00FF0000) >> 8) |
21: ((tmp & 0x0000FF00) << 8) | ((tmp & 0x000000FF) << 24);
22: }
23:
24: static inline void glue(st16r, MEMSUFFIX) (target_ulong EA, uint16_t data)
25: {
26: uint16_t tmp = ((data & 0xFF00) >> 8) | ((data & 0x00FF) << 8);
27: glue(stw, MEMSUFFIX)(EA, tmp);
28: }
29:
30: static inline void glue(st32r, MEMSUFFIX) (target_ulong EA, uint32_t data)
31: {
32: uint32_t tmp = ((data & 0xFF000000) >> 24) | ((data & 0x00FF0000) >> 8) |
33: ((data & 0x0000FF00) << 8) | ((data & 0x000000FF) << 24);
34: glue(stl, MEMSUFFIX)(EA, tmp);
35: }
36:
37: /*** Integer load ***/
38: #define PPC_LD_OP(name, op) \
39: PPC_OP(glue(glue(l, name), MEMSUFFIX)) \
40: { \
41: T1 = glue(op, MEMSUFFIX)(T0); \
42: RETURN(); \
43: }
44:
45: #define PPC_ST_OP(name, op) \
46: PPC_OP(glue(glue(st, name), MEMSUFFIX)) \
47: { \
48: glue(op, MEMSUFFIX)(T0, T1); \
49: RETURN(); \
50: }
51:
52: PPC_LD_OP(bz, ldub);
53: PPC_LD_OP(ha, ldsw);
54: PPC_LD_OP(hz, lduw);
55: PPC_LD_OP(wz, ldl);
56:
57: PPC_LD_OP(ha_le, ld16rs);
58: PPC_LD_OP(hz_le, ld16r);
59: PPC_LD_OP(wz_le, ld32r);
60:
61: /*** Integer store ***/
62: PPC_ST_OP(b, stb);
63: PPC_ST_OP(h, stw);
64: PPC_ST_OP(w, stl);
65:
66: PPC_ST_OP(h_le, st16r);
67: PPC_ST_OP(w_le, st32r);
68:
69: /*** Integer load and store with byte reverse ***/
70: PPC_LD_OP(hbr, ld16r);
71: PPC_LD_OP(wbr, ld32r);
72: PPC_ST_OP(hbr, st16r);
73: PPC_ST_OP(wbr, st32r);
74:
75: PPC_LD_OP(hbr_le, lduw);
76: PPC_LD_OP(wbr_le, ldl);
77: PPC_ST_OP(hbr_le, stw);
78: PPC_ST_OP(wbr_le, stl);
79:
80: /*** Integer load and store multiple ***/
81: PPC_OP(glue(lmw, MEMSUFFIX))
82: {
83: int dst = PARAM(1);
84:
85: for (; dst < 32; dst++, T0 += 4) {
86: ugpr(dst) = glue(ldl, MEMSUFFIX)(T0);
87: }
88: RETURN();
89: }
90:
91: PPC_OP(glue(stmw, MEMSUFFIX))
92: {
93: int src = PARAM(1);
94:
95: for (; src < 32; src++, T0 += 4) {
96: glue(stl, MEMSUFFIX)(T0, ugpr(src));
97: }
98: RETURN();
99: }
100:
101: PPC_OP(glue(lmw_le, MEMSUFFIX))
102: {
103: int dst = PARAM(1);
104:
105: for (; dst < 32; dst++, T0 += 4) {
106: ugpr(dst) = glue(ld32r, MEMSUFFIX)(T0);
107: }
108: RETURN();
109: }
110:
111: PPC_OP(glue(stmw_le, MEMSUFFIX))
112: {
113: int src = PARAM(1);
114:
115: for (; src < 32; src++, T0 += 4) {
116: glue(st32r, MEMSUFFIX)(T0, ugpr(src));
117: }
118: RETURN();
119: }
120:
121: /*** Integer load and store strings ***/
122: PPC_OP(glue(lswi, MEMSUFFIX))
123: {
124: glue(do_lsw, MEMSUFFIX)(PARAM(1));
125: RETURN();
126: }
127:
128: void glue(do_lsw_le, MEMSUFFIX) (int dst);
129: PPC_OP(glue(lswi_le, MEMSUFFIX))
130: {
131: glue(do_lsw_le, MEMSUFFIX)(PARAM(1));
132: RETURN();
133: }
134:
135: /* PPC32 specification says we must generate an exception if
136: * rA is in the range of registers to be loaded.
137: * In an other hand, IBM says this is valid, but rA won't be loaded.
138: * For now, I'll follow the spec...
139: */
140: PPC_OP(glue(lswx, MEMSUFFIX))
141: {
142: if (T1 > 0) {
143: if ((PARAM(1) < PARAM(2) && (PARAM(1) + T1) > PARAM(2)) ||
144: (PARAM(1) < PARAM(3) && (PARAM(1) + T1) > PARAM(3))) {
145: do_raise_exception_err(EXCP_PROGRAM, EXCP_INVAL | EXCP_INVAL_LSWX);
146: } else {
147: glue(do_lsw, MEMSUFFIX)(PARAM(1));
148: }
149: }
150: RETURN();
151: }
152:
153: PPC_OP(glue(lswx_le, MEMSUFFIX))
154: {
155: if (T1 > 0) {
156: if ((PARAM(1) < PARAM(2) && (PARAM(1) + T1) > PARAM(2)) ||
157: (PARAM(1) < PARAM(3) && (PARAM(1) + T1) > PARAM(3))) {
158: do_raise_exception_err(EXCP_PROGRAM, EXCP_INVAL | EXCP_INVAL_LSWX);
159: } else {
160: glue(do_lsw_le, MEMSUFFIX)(PARAM(1));
161: }
162: }
163: RETURN();
164: }
165:
166: PPC_OP(glue(stsw, MEMSUFFIX))
167: {
168: glue(do_stsw, MEMSUFFIX)(PARAM(1));
169: RETURN();
170: }
171:
172: void glue(do_stsw_le, MEMSUFFIX) (int src);
173: PPC_OP(glue(stsw_le, MEMSUFFIX))
174: {
175: glue(do_stsw_le, MEMSUFFIX)(PARAM(1));
176: RETURN();
177: }
178:
179: /*** Floating-point store ***/
180: #define PPC_STF_OP(name, op) \
181: PPC_OP(glue(glue(st, name), MEMSUFFIX)) \
182: { \
183: glue(op, MEMSUFFIX)(T0, FT1); \
184: RETURN(); \
185: }
186:
187: PPC_STF_OP(fd, stfq);
188: PPC_STF_OP(fs, stfl);
189:
190: static inline void glue(stfqr, MEMSUFFIX) (target_ulong EA, double d)
191: {
192: union {
193: double d;
194: uint64_t u;
195: } u;
196:
197: u.d = d;
198: u.u = ((u.u & 0xFF00000000000000ULL) >> 56) |
199: ((u.u & 0x00FF000000000000ULL) >> 40) |
200: ((u.u & 0x0000FF0000000000ULL) >> 24) |
201: ((u.u & 0x000000FF00000000ULL) >> 8) |
202: ((u.u & 0x00000000FF000000ULL) << 8) |
203: ((u.u & 0x0000000000FF0000ULL) << 24) |
204: ((u.u & 0x000000000000FF00ULL) << 40) |
205: ((u.u & 0x00000000000000FFULL) << 56);
206: glue(stfq, MEMSUFFIX)(EA, u.d);
207: }
208:
209: static inline void glue(stflr, MEMSUFFIX) (target_ulong EA, float f)
210: {
211: union {
212: float f;
213: uint32_t u;
214: } u;
215:
216: u.f = f;
217: u.u = ((u.u & 0xFF000000UL) >> 24) |
218: ((u.u & 0x00FF0000ULL) >> 8) |
219: ((u.u & 0x0000FF00UL) << 8) |
220: ((u.u & 0x000000FFULL) << 24);
221: glue(stfl, MEMSUFFIX)(EA, u.f);
222: }
223:
224: PPC_STF_OP(fd_le, stfqr);
225: PPC_STF_OP(fs_le, stflr);
226:
227: /*** Floating-point load ***/
228: #define PPC_LDF_OP(name, op) \
229: PPC_OP(glue(glue(l, name), MEMSUFFIX)) \
230: { \
231: FT1 = glue(op, MEMSUFFIX)(T0); \
232: RETURN(); \
233: }
234:
235: PPC_LDF_OP(fd, ldfq);
236: PPC_LDF_OP(fs, ldfl);
237:
238: static inline double glue(ldfqr, MEMSUFFIX) (target_ulong EA)
239: {
240: union {
241: double d;
242: uint64_t u;
243: } u;
244:
245: u.d = glue(ldfq, MEMSUFFIX)(EA);
246: u.u = ((u.u & 0xFF00000000000000ULL) >> 56) |
247: ((u.u & 0x00FF000000000000ULL) >> 40) |
248: ((u.u & 0x0000FF0000000000ULL) >> 24) |
249: ((u.u & 0x000000FF00000000ULL) >> 8) |
250: ((u.u & 0x00000000FF000000ULL) << 8) |
251: ((u.u & 0x0000000000FF0000ULL) << 24) |
252: ((u.u & 0x000000000000FF00ULL) << 40) |
253: ((u.u & 0x00000000000000FFULL) << 56);
254:
255: return u.d;
256: }
257:
258: static inline float glue(ldflr, MEMSUFFIX) (target_ulong EA)
259: {
260: union {
261: float f;
262: uint32_t u;
263: } u;
264:
265: u.f = glue(ldfl, MEMSUFFIX)(EA);
266: u.u = ((u.u & 0xFF000000UL) >> 24) |
267: ((u.u & 0x00FF0000ULL) >> 8) |
268: ((u.u & 0x0000FF00UL) << 8) |
269: ((u.u & 0x000000FFULL) << 24);
270:
271: return u.f;
272: }
273:
274: PPC_LDF_OP(fd_le, ldfqr);
275: PPC_LDF_OP(fs_le, ldflr);
276:
277: /* Load and set reservation */
278: PPC_OP(glue(lwarx, MEMSUFFIX))
279: {
280: if (T0 & 0x03) {
281: do_raise_exception(EXCP_ALIGN);
282: } else {
283: T1 = glue(ldl, MEMSUFFIX)(T0);
284: regs->reserve = T0;
285: }
286: RETURN();
287: }
288:
289: PPC_OP(glue(lwarx_le, MEMSUFFIX))
290: {
291: if (T0 & 0x03) {
292: do_raise_exception(EXCP_ALIGN);
293: } else {
294: T1 = glue(ld32r, MEMSUFFIX)(T0);
295: regs->reserve = T0;
296: }
297: RETURN();
298: }
299:
300: /* Store with reservation */
301: PPC_OP(glue(stwcx, MEMSUFFIX))
302: {
303: if (T0 & 0x03) {
304: do_raise_exception(EXCP_ALIGN);
305: } else {
306: if (regs->reserve != T0) {
307: env->crf[0] = xer_ov;
308: } else {
309: glue(stl, MEMSUFFIX)(T0, T1);
310: env->crf[0] = xer_ov | 0x02;
311: }
312: }
313: regs->reserve = 0;
314: RETURN();
315: }
316:
317: PPC_OP(glue(stwcx_le, MEMSUFFIX))
318: {
319: if (T0 & 0x03) {
320: do_raise_exception(EXCP_ALIGN);
321: } else {
322: if (regs->reserve != T0) {
323: env->crf[0] = xer_ov;
324: } else {
325: glue(st32r, MEMSUFFIX)(T0, T1);
326: env->crf[0] = xer_ov | 0x02;
327: }
328: }
329: regs->reserve = 0;
330: RETURN();
331: }
332:
333: PPC_OP(glue(dcbz, MEMSUFFIX))
334: {
335: glue(stl, MEMSUFFIX)(T0 + 0x00, 0);
336: glue(stl, MEMSUFFIX)(T0 + 0x04, 0);
337: glue(stl, MEMSUFFIX)(T0 + 0x08, 0);
338: glue(stl, MEMSUFFIX)(T0 + 0x0C, 0);
339: glue(stl, MEMSUFFIX)(T0 + 0x10, 0);
340: glue(stl, MEMSUFFIX)(T0 + 0x14, 0);
341: glue(stl, MEMSUFFIX)(T0 + 0x18, 0);
342: glue(stl, MEMSUFFIX)(T0 + 0x1C, 0);
343: RETURN();
344: }
345:
346: /* External access */
347: PPC_OP(glue(eciwx, MEMSUFFIX))
348: {
349: T1 = glue(ldl, MEMSUFFIX)(T0);
350: RETURN();
351: }
352:
353: PPC_OP(glue(ecowx, MEMSUFFIX))
354: {
355: glue(stl, MEMSUFFIX)(T0, T1);
356: RETURN();
357: }
358:
359: PPC_OP(glue(eciwx_le, MEMSUFFIX))
360: {
361: T1 = glue(ld32r, MEMSUFFIX)(T0);
362: RETURN();
363: }
364:
365: PPC_OP(glue(ecowx_le, MEMSUFFIX))
366: {
367: glue(st32r, MEMSUFFIX)(T0, T1);
368: RETURN();
369: }
370:
371: #undef MEMSUFFIX
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.