![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to op.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / target-sparc|
Return to op.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / target-sparc |
1.1 root 1: /*
2: SPARC micro operations
3:
4: Copyright (C) 2003 Thomas M. Ogrisegg <[email protected]>
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: #include "exec.h"
22:
23: /*XXX*/
24: #define REGNAME g0
25: #define REG (env->gregs[0])
26: #include "op_template.h"
27: #define REGNAME g1
28: #define REG (env->gregs[1])
29: #include "op_template.h"
30: #define REGNAME g2
31: #define REG (env->gregs[2])
32: #include "op_template.h"
33: #define REGNAME g3
34: #define REG (env->gregs[3])
35: #include "op_template.h"
36: #define REGNAME g4
37: #define REG (env->gregs[4])
38: #include "op_template.h"
39: #define REGNAME g5
40: #define REG (env->gregs[5])
41: #include "op_template.h"
42: #define REGNAME g6
43: #define REG (env->gregs[6])
44: #include "op_template.h"
45: #define REGNAME g7
46: #define REG (env->gregs[7])
47: #include "op_template.h"
48: #define REGNAME i0
49: #define REG (REGWPTR[16])
50: #include "op_template.h"
51: #define REGNAME i1
52: #define REG (REGWPTR[17])
53: #include "op_template.h"
54: #define REGNAME i2
55: #define REG (REGWPTR[18])
56: #include "op_template.h"
57: #define REGNAME i3
58: #define REG (REGWPTR[19])
59: #include "op_template.h"
60: #define REGNAME i4
61: #define REG (REGWPTR[20])
62: #include "op_template.h"
63: #define REGNAME i5
64: #define REG (REGWPTR[21])
65: #include "op_template.h"
66: #define REGNAME i6
67: #define REG (REGWPTR[22])
68: #include "op_template.h"
69: #define REGNAME i7
70: #define REG (REGWPTR[23])
71: #include "op_template.h"
72: #define REGNAME l0
73: #define REG (REGWPTR[8])
74: #include "op_template.h"
75: #define REGNAME l1
76: #define REG (REGWPTR[9])
77: #include "op_template.h"
78: #define REGNAME l2
79: #define REG (REGWPTR[10])
80: #include "op_template.h"
81: #define REGNAME l3
82: #define REG (REGWPTR[11])
83: #include "op_template.h"
84: #define REGNAME l4
85: #define REG (REGWPTR[12])
86: #include "op_template.h"
87: #define REGNAME l5
88: #define REG (REGWPTR[13])
89: #include "op_template.h"
90: #define REGNAME l6
91: #define REG (REGWPTR[14])
92: #include "op_template.h"
93: #define REGNAME l7
94: #define REG (REGWPTR[15])
95: #include "op_template.h"
96: #define REGNAME o0
97: #define REG (REGWPTR[0])
98: #include "op_template.h"
99: #define REGNAME o1
100: #define REG (REGWPTR[1])
101: #include "op_template.h"
102: #define REGNAME o2
103: #define REG (REGWPTR[2])
104: #include "op_template.h"
105: #define REGNAME o3
106: #define REG (REGWPTR[3])
107: #include "op_template.h"
108: #define REGNAME o4
109: #define REG (REGWPTR[4])
110: #include "op_template.h"
111: #define REGNAME o5
112: #define REG (REGWPTR[5])
113: #include "op_template.h"
114: #define REGNAME o6
115: #define REG (REGWPTR[6])
116: #include "op_template.h"
117: #define REGNAME o7
118: #define REG (REGWPTR[7])
119: #include "op_template.h"
120:
121: #define REGNAME f0
122: #define REG (env->fpr[0])
123: #include "fop_template.h"
124: #define REGNAME f1
125: #define REG (env->fpr[1])
126: #include "fop_template.h"
127: #define REGNAME f2
128: #define REG (env->fpr[2])
129: #include "fop_template.h"
130: #define REGNAME f3
131: #define REG (env->fpr[3])
132: #include "fop_template.h"
133: #define REGNAME f4
134: #define REG (env->fpr[4])
135: #include "fop_template.h"
136: #define REGNAME f5
137: #define REG (env->fpr[5])
138: #include "fop_template.h"
139: #define REGNAME f6
140: #define REG (env->fpr[6])
141: #include "fop_template.h"
142: #define REGNAME f7
143: #define REG (env->fpr[7])
144: #include "fop_template.h"
145: #define REGNAME f8
146: #define REG (env->fpr[8])
147: #include "fop_template.h"
148: #define REGNAME f9
149: #define REG (env->fpr[9])
150: #include "fop_template.h"
151: #define REGNAME f10
152: #define REG (env->fpr[10])
153: #include "fop_template.h"
154: #define REGNAME f11
155: #define REG (env->fpr[11])
156: #include "fop_template.h"
157: #define REGNAME f12
158: #define REG (env->fpr[12])
159: #include "fop_template.h"
160: #define REGNAME f13
161: #define REG (env->fpr[13])
162: #include "fop_template.h"
163: #define REGNAME f14
164: #define REG (env->fpr[14])
165: #include "fop_template.h"
166: #define REGNAME f15
167: #define REG (env->fpr[15])
168: #include "fop_template.h"
169: #define REGNAME f16
170: #define REG (env->fpr[16])
171: #include "fop_template.h"
172: #define REGNAME f17
173: #define REG (env->fpr[17])
174: #include "fop_template.h"
175: #define REGNAME f18
176: #define REG (env->fpr[18])
177: #include "fop_template.h"
178: #define REGNAME f19
179: #define REG (env->fpr[19])
180: #include "fop_template.h"
181: #define REGNAME f20
182: #define REG (env->fpr[20])
183: #include "fop_template.h"
184: #define REGNAME f21
185: #define REG (env->fpr[21])
186: #include "fop_template.h"
187: #define REGNAME f22
188: #define REG (env->fpr[22])
189: #include "fop_template.h"
190: #define REGNAME f23
191: #define REG (env->fpr[23])
192: #include "fop_template.h"
193: #define REGNAME f24
194: #define REG (env->fpr[24])
195: #include "fop_template.h"
196: #define REGNAME f25
197: #define REG (env->fpr[25])
198: #include "fop_template.h"
199: #define REGNAME f26
200: #define REG (env->fpr[26])
201: #include "fop_template.h"
202: #define REGNAME f27
203: #define REG (env->fpr[27])
204: #include "fop_template.h"
205: #define REGNAME f28
206: #define REG (env->fpr[28])
207: #include "fop_template.h"
208: #define REGNAME f29
209: #define REG (env->fpr[29])
210: #include "fop_template.h"
211: #define REGNAME f30
212: #define REG (env->fpr[30])
213: #include "fop_template.h"
214: #define REGNAME f31
215: #define REG (env->fpr[31])
216: #include "fop_template.h"
217:
218: #ifdef TARGET_SPARC64
219: #define REGNAME f32
220: #define REG (env->fpr[32])
221: #include "fop_template.h"
222: #define REGNAME f34
223: #define REG (env->fpr[34])
224: #include "fop_template.h"
225: #define REGNAME f36
226: #define REG (env->fpr[36])
227: #include "fop_template.h"
228: #define REGNAME f38
229: #define REG (env->fpr[38])
230: #include "fop_template.h"
231: #define REGNAME f40
232: #define REG (env->fpr[40])
233: #include "fop_template.h"
234: #define REGNAME f42
235: #define REG (env->fpr[42])
236: #include "fop_template.h"
237: #define REGNAME f44
238: #define REG (env->fpr[44])
239: #include "fop_template.h"
240: #define REGNAME f46
241: #define REG (env->fpr[46])
242: #include "fop_template.h"
243: #define REGNAME f48
244: #define REG (env->fpr[47])
245: #include "fop_template.h"
246: #define REGNAME f50
247: #define REG (env->fpr[50])
248: #include "fop_template.h"
249: #define REGNAME f52
250: #define REG (env->fpr[52])
251: #include "fop_template.h"
252: #define REGNAME f54
253: #define REG (env->fpr[54])
254: #include "fop_template.h"
255: #define REGNAME f56
256: #define REG (env->fpr[56])
257: #include "fop_template.h"
258: #define REGNAME f58
259: #define REG (env->fpr[58])
260: #include "fop_template.h"
261: #define REGNAME f60
262: #define REG (env->fpr[60])
263: #include "fop_template.h"
264: #define REGNAME f62
265: #define REG (env->fpr[62])
266: #include "fop_template.h"
267: #endif
268:
269: #ifdef TARGET_SPARC64
270: #ifdef WORDS_BIGENDIAN
271: typedef union UREG64 {
272: struct { uint16_t v3, v2, v1, v0; } w;
273: struct { uint32_t v1, v0; } l;
274: uint64_t q;
275: } UREG64;
276: #else
277: typedef union UREG64 {
278: struct { uint16_t v0, v1, v2, v3; } w;
279: struct { uint32_t v0, v1; } l;
280: uint64_t q;
281: } UREG64;
282: #endif
283:
284: #define PARAMQ1 \
285: ({\
286: UREG64 __p;\
287: __p.l.v1 = PARAM1;\
288: __p.l.v0 = PARAM2;\
289: __p.q;\
1.1.1.6 ! root 290: })
1.1 root 291:
292: void OPPROTO op_movq_T0_im64(void)
293: {
294: T0 = PARAMQ1;
295: }
296:
297: void OPPROTO op_movq_T1_im64(void)
298: {
299: T1 = PARAMQ1;
300: }
301:
302: #define XFLAG_SET(x) ((env->xcc&x)?1:0)
303:
304: #else
305: #define EIP (env->pc)
306: #endif
307:
308: #define FLAG_SET(x) ((env->psr&x)?1:0)
309:
310: void OPPROTO op_movl_T0_0(void)
311: {
312: T0 = 0;
313: }
314:
315: void OPPROTO op_movl_T0_im(void)
316: {
317: T0 = (uint32_t)PARAM1;
318: }
319:
320: void OPPROTO op_movl_T1_im(void)
321: {
322: T1 = (uint32_t)PARAM1;
323: }
324:
325: void OPPROTO op_movl_T2_im(void)
326: {
327: T2 = (uint32_t)PARAM1;
328: }
329:
330: void OPPROTO op_movl_T0_sim(void)
331: {
332: T0 = (int32_t)PARAM1;
333: }
334:
335: void OPPROTO op_movl_T1_sim(void)
336: {
337: T1 = (int32_t)PARAM1;
338: }
339:
340: void OPPROTO op_movl_T2_sim(void)
341: {
342: T2 = (int32_t)PARAM1;
343: }
344:
345: void OPPROTO op_movl_T0_env(void)
346: {
347: T0 = *(uint32_t *)((char *)env + PARAM1);
348: }
349:
350: void OPPROTO op_movl_env_T0(void)
351: {
352: *(uint32_t *)((char *)env + PARAM1) = T0;
353: }
354:
355: void OPPROTO op_movtl_T0_env(void)
356: {
357: T0 = *(target_ulong *)((char *)env + PARAM1);
358: }
359:
360: void OPPROTO op_movtl_env_T0(void)
361: {
362: *(target_ulong *)((char *)env + PARAM1) = T0;
363: }
364:
365: void OPPROTO op_add_T1_T0(void)
366: {
367: T0 += T1;
368: }
369:
370: void OPPROTO op_add_T1_T0_cc(void)
371: {
372: target_ulong src1;
373:
374: src1 = T0;
375: T0 += T1;
376: env->psr = 0;
377: #ifdef TARGET_SPARC64
378: if (!(T0 & 0xffffffff))
1.1.1.6 ! root 379: env->psr |= PSR_ZERO;
1.1 root 380: if ((int32_t) T0 < 0)
1.1.1.6 ! root 381: env->psr |= PSR_NEG;
1.1.1.2 root 382: if ((T0 & 0xffffffff) < (src1 & 0xffffffff))
1.1.1.6 ! root 383: env->psr |= PSR_CARRY;
1.1 root 384: if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff) ^ -1) &
1.1.1.6 ! root 385: ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
! 386: env->psr |= PSR_OVF;
1.1 root 387:
388: env->xcc = 0;
389: if (!T0)
1.1.1.6 ! root 390: env->xcc |= PSR_ZERO;
1.1 root 391: if ((int64_t) T0 < 0)
1.1.1.6 ! root 392: env->xcc |= PSR_NEG;
1.1 root 393: if (T0 < src1)
1.1.1.6 ! root 394: env->xcc |= PSR_CARRY;
1.1 root 395: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1ULL << 63))
1.1.1.6 ! root 396: env->xcc |= PSR_OVF;
1.1 root 397: #else
398: if (!T0)
1.1.1.6 ! root 399: env->psr |= PSR_ZERO;
1.1 root 400: if ((int32_t) T0 < 0)
1.1.1.6 ! root 401: env->psr |= PSR_NEG;
1.1 root 402: if (T0 < src1)
1.1.1.6 ! root 403: env->psr |= PSR_CARRY;
1.1 root 404: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
1.1.1.6 ! root 405: env->psr |= PSR_OVF;
1.1 root 406: #endif
407: FORCE_RET();
408: }
409:
410: void OPPROTO op_addx_T1_T0(void)
411: {
412: T0 += T1 + FLAG_SET(PSR_CARRY);
413: }
414:
415: void OPPROTO op_addx_T1_T0_cc(void)
416: {
417: target_ulong src1;
418: src1 = T0;
1.1.1.3 root 419: if (FLAG_SET(PSR_CARRY))
420: {
421: T0 += T1 + 1;
422: env->psr = 0;
423: #ifdef TARGET_SPARC64
424: if ((T0 & 0xffffffff) <= (src1 & 0xffffffff))
425: env->psr |= PSR_CARRY;
426: env->xcc = 0;
427: if (T0 <= src1)
428: env->xcc |= PSR_CARRY;
429: #else
430: if (T0 <= src1)
431: env->psr |= PSR_CARRY;
432: #endif
433: }
434: else
435: {
436: T0 += T1;
437: env->psr = 0;
438: #ifdef TARGET_SPARC64
439: if ((T0 & 0xffffffff) < (src1 & 0xffffffff))
440: env->psr |= PSR_CARRY;
441: env->xcc = 0;
442: if (T0 < src1)
443: env->xcc |= PSR_CARRY;
444: #else
445: if (T0 < src1)
446: env->psr |= PSR_CARRY;
447: #endif
448: }
1.1 root 449: #ifdef TARGET_SPARC64
450: if (!(T0 & 0xffffffff))
1.1.1.6 ! root 451: env->psr |= PSR_ZERO;
1.1 root 452: if ((int32_t) T0 < 0)
1.1.1.6 ! root 453: env->psr |= PSR_NEG;
1.1 root 454: if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff) ^ -1) &
1.1.1.6 ! root 455: ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
! 456: env->psr |= PSR_OVF;
1.1 root 457:
458: if (!T0)
1.1.1.6 ! root 459: env->xcc |= PSR_ZERO;
1.1 root 460: if ((int64_t) T0 < 0)
1.1.1.6 ! root 461: env->xcc |= PSR_NEG;
1.1 root 462: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1ULL << 63))
1.1.1.6 ! root 463: env->xcc |= PSR_OVF;
1.1 root 464: #else
465: if (!T0)
1.1.1.6 ! root 466: env->psr |= PSR_ZERO;
1.1 root 467: if ((int32_t) T0 < 0)
1.1.1.6 ! root 468: env->psr |= PSR_NEG;
1.1 root 469: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
1.1.1.6 ! root 470: env->psr |= PSR_OVF;
! 471: #endif
! 472: FORCE_RET();
! 473: }
! 474:
! 475: void OPPROTO op_tadd_T1_T0_cc(void)
! 476: {
! 477: target_ulong src1;
! 478:
! 479: src1 = T0;
! 480: T0 += T1;
! 481: env->psr = 0;
! 482: #ifdef TARGET_SPARC64
! 483: if (!(T0 & 0xffffffff))
! 484: env->psr |= PSR_ZERO;
! 485: if ((int32_t) T0 < 0)
! 486: env->psr |= PSR_NEG;
! 487: if ((T0 & 0xffffffff) < (src1 & 0xffffffff))
! 488: env->psr |= PSR_CARRY;
! 489: if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff) ^ -1) &
! 490: ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
! 491: env->psr |= PSR_OVF;
! 492: if ((src1 & 0x03) || (T1 & 0x03))
! 493: env->psr |= PSR_OVF;
! 494:
! 495: env->xcc = 0;
! 496: if (!T0)
! 497: env->xcc |= PSR_ZERO;
! 498: if ((int64_t) T0 < 0)
! 499: env->xcc |= PSR_NEG;
! 500: if (T0 < src1)
! 501: env->xcc |= PSR_CARRY;
! 502: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1ULL << 63))
! 503: env->xcc |= PSR_OVF;
! 504: #else
! 505: if (!T0)
! 506: env->psr |= PSR_ZERO;
! 507: if ((int32_t) T0 < 0)
! 508: env->psr |= PSR_NEG;
! 509: if (T0 < src1)
! 510: env->psr |= PSR_CARRY;
! 511: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
! 512: env->psr |= PSR_OVF;
! 513: if ((src1 & 0x03) || (T1 & 0x03))
! 514: env->psr |= PSR_OVF;
! 515: #endif
! 516: FORCE_RET();
! 517: }
! 518:
! 519: void OPPROTO op_tadd_T1_T0_ccTV(void)
! 520: {
! 521: target_ulong src1;
! 522:
! 523: if ((T0 & 0x03) || (T1 & 0x03)) {
! 524: raise_exception(TT_TOVF);
! 525: FORCE_RET();
! 526: return;
! 527: }
! 528:
! 529: src1 = T0;
! 530: T0 += T1;
! 531:
! 532: #ifdef TARGET_SPARC64
! 533: if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff) ^ -1) &
! 534: ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
! 535: raise_exception(TT_TOVF);
! 536: #else
! 537: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
! 538: raise_exception(TT_TOVF);
! 539: #endif
! 540:
! 541: env->psr = 0;
! 542: #ifdef TARGET_SPARC64
! 543: if (!(T0 & 0xffffffff))
! 544: env->psr |= PSR_ZERO;
! 545: if ((int32_t) T0 < 0)
! 546: env->psr |= PSR_NEG;
! 547: if ((T0 & 0xffffffff) < (src1 & 0xffffffff))
! 548: env->psr |= PSR_CARRY;
! 549:
! 550: env->xcc = 0;
! 551: if (!T0)
! 552: env->xcc |= PSR_ZERO;
! 553: if ((int64_t) T0 < 0)
! 554: env->xcc |= PSR_NEG;
! 555: if (T0 < src1)
! 556: env->xcc |= PSR_CARRY;
! 557: #else
! 558: if (!T0)
! 559: env->psr |= PSR_ZERO;
! 560: if ((int32_t) T0 < 0)
! 561: env->psr |= PSR_NEG;
! 562: if (T0 < src1)
! 563: env->psr |= PSR_CARRY;
1.1 root 564: #endif
565: FORCE_RET();
566: }
567:
568: void OPPROTO op_sub_T1_T0(void)
569: {
570: T0 -= T1;
571: }
572:
573: void OPPROTO op_sub_T1_T0_cc(void)
574: {
575: target_ulong src1;
576:
577: src1 = T0;
578: T0 -= T1;
579: env->psr = 0;
580: #ifdef TARGET_SPARC64
581: if (!(T0 & 0xffffffff))
1.1.1.6 ! root 582: env->psr |= PSR_ZERO;
1.1 root 583: if ((int32_t) T0 < 0)
1.1.1.6 ! root 584: env->psr |= PSR_NEG;
1.1 root 585: if ((src1 & 0xffffffff) < (T1 & 0xffffffff))
1.1.1.6 ! root 586: env->psr |= PSR_CARRY;
1.1 root 587: if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff)) &
1.1.1.6 ! root 588: ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
! 589: env->psr |= PSR_OVF;
1.1 root 590:
591: env->xcc = 0;
592: if (!T0)
1.1.1.6 ! root 593: env->xcc |= PSR_ZERO;
1.1 root 594: if ((int64_t) T0 < 0)
1.1.1.6 ! root 595: env->xcc |= PSR_NEG;
1.1.1.2 root 596: if (src1 < T1)
1.1.1.6 ! root 597: env->xcc |= PSR_CARRY;
1.1 root 598: if (((src1 ^ T1) & (src1 ^ T0)) & (1ULL << 63))
1.1.1.6 ! root 599: env->xcc |= PSR_OVF;
1.1 root 600: #else
601: if (!T0)
1.1.1.6 ! root 602: env->psr |= PSR_ZERO;
1.1 root 603: if ((int32_t) T0 < 0)
1.1.1.6 ! root 604: env->psr |= PSR_NEG;
1.1 root 605: if (src1 < T1)
1.1.1.6 ! root 606: env->psr |= PSR_CARRY;
1.1 root 607: if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31))
1.1.1.6 ! root 608: env->psr |= PSR_OVF;
1.1 root 609: #endif
610: FORCE_RET();
611: }
612:
613: void OPPROTO op_subx_T1_T0(void)
614: {
615: T0 -= T1 + FLAG_SET(PSR_CARRY);
616: }
617:
618: void OPPROTO op_subx_T1_T0_cc(void)
619: {
620: target_ulong src1;
621: src1 = T0;
1.1.1.3 root 622: if (FLAG_SET(PSR_CARRY))
623: {
624: T0 -= T1 + 1;
625: env->psr = 0;
626: #ifdef TARGET_SPARC64
627: if ((src1 & 0xffffffff) <= (T1 & 0xffffffff))
628: env->psr |= PSR_CARRY;
629: env->xcc = 0;
630: if (src1 <= T1)
631: env->xcc |= PSR_CARRY;
632: #else
633: if (src1 <= T1)
634: env->psr |= PSR_CARRY;
635: #endif
636: }
637: else
638: {
639: T0 -= T1;
640: env->psr = 0;
641: #ifdef TARGET_SPARC64
642: if ((src1 & 0xffffffff) < (T1 & 0xffffffff))
643: env->psr |= PSR_CARRY;
644: env->xcc = 0;
645: if (src1 < T1)
646: env->xcc |= PSR_CARRY;
647: #else
648: if (src1 < T1)
649: env->psr |= PSR_CARRY;
650: #endif
651: }
1.1 root 652: #ifdef TARGET_SPARC64
653: if (!(T0 & 0xffffffff))
1.1.1.6 ! root 654: env->psr |= PSR_ZERO;
1.1 root 655: if ((int32_t) T0 < 0)
1.1.1.6 ! root 656: env->psr |= PSR_NEG;
1.1 root 657: if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff)) &
1.1.1.6 ! root 658: ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
! 659: env->psr |= PSR_OVF;
1.1 root 660:
661: if (!T0)
1.1.1.6 ! root 662: env->xcc |= PSR_ZERO;
1.1 root 663: if ((int64_t) T0 < 0)
1.1.1.6 ! root 664: env->xcc |= PSR_NEG;
1.1 root 665: if (((src1 ^ T1) & (src1 ^ T0)) & (1ULL << 63))
1.1.1.6 ! root 666: env->xcc |= PSR_OVF;
1.1 root 667: #else
668: if (!T0)
1.1.1.6 ! root 669: env->psr |= PSR_ZERO;
1.1 root 670: if ((int32_t) T0 < 0)
1.1.1.6 ! root 671: env->psr |= PSR_NEG;
1.1 root 672: if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31))
1.1.1.6 ! root 673: env->psr |= PSR_OVF;
! 674: #endif
! 675: FORCE_RET();
! 676: }
! 677:
! 678: void OPPROTO op_tsub_T1_T0_cc(void)
! 679: {
! 680: target_ulong src1;
! 681:
! 682: src1 = T0;
! 683: T0 -= T1;
! 684: env->psr = 0;
! 685: #ifdef TARGET_SPARC64
! 686: if (!(T0 & 0xffffffff))
! 687: env->psr |= PSR_ZERO;
! 688: if ((int32_t) T0 < 0)
! 689: env->psr |= PSR_NEG;
! 690: if ((src1 & 0xffffffff) < (T1 & 0xffffffff))
! 691: env->psr |= PSR_CARRY;
! 692: if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff)) &
! 693: ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
! 694: env->psr |= PSR_OVF;
! 695: if ((src1 & 0x03) || (T1 & 0x03))
! 696: env->psr |= PSR_OVF;
! 697:
! 698: env->xcc = 0;
! 699: if (!T0)
! 700: env->xcc |= PSR_ZERO;
! 701: if ((int64_t) T0 < 0)
! 702: env->xcc |= PSR_NEG;
! 703: if (src1 < T1)
! 704: env->xcc |= PSR_CARRY;
! 705: if (((src1 ^ T1) & (src1 ^ T0)) & (1ULL << 63))
! 706: env->xcc |= PSR_OVF;
! 707: #else
! 708: if (!T0)
! 709: env->psr |= PSR_ZERO;
! 710: if ((int32_t) T0 < 0)
! 711: env->psr |= PSR_NEG;
! 712: if (src1 < T1)
! 713: env->psr |= PSR_CARRY;
! 714: if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31))
! 715: env->psr |= PSR_OVF;
! 716: if ((src1 & 0x03) || (T1 & 0x03))
! 717: env->psr |= PSR_OVF;
! 718: #endif
! 719: FORCE_RET();
! 720: }
! 721:
! 722: void OPPROTO op_tsub_T1_T0_ccTV(void)
! 723: {
! 724: target_ulong src1;
! 725:
! 726: if ((T0 & 0x03) || (T1 & 0x03))
! 727: raise_exception(TT_TOVF);
! 728:
! 729: src1 = T0;
! 730: T0 -= T1;
! 731:
! 732: #ifdef TARGET_SPARC64
! 733: if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff)) &
! 734: ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
! 735: raise_exception(TT_TOVF);
! 736: #else
! 737: if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31))
! 738: raise_exception(TT_TOVF);
! 739: #endif
! 740:
! 741: env->psr = 0;
! 742: #ifdef TARGET_SPARC64
! 743: if (!(T0 & 0xffffffff))
! 744: env->psr |= PSR_ZERO;
! 745: if ((int32_t) T0 < 0)
! 746: env->psr |= PSR_NEG;
! 747: if ((src1 & 0xffffffff) < (T1 & 0xffffffff))
! 748: env->psr |= PSR_CARRY;
! 749:
! 750: env->xcc = 0;
! 751: if (!T0)
! 752: env->xcc |= PSR_ZERO;
! 753: if ((int64_t) T0 < 0)
! 754: env->xcc |= PSR_NEG;
! 755: if (src1 < T1)
! 756: env->xcc |= PSR_CARRY;
! 757: #else
! 758: if (!T0)
! 759: env->psr |= PSR_ZERO;
! 760: if ((int32_t) T0 < 0)
! 761: env->psr |= PSR_NEG;
! 762: if (src1 < T1)
! 763: env->psr |= PSR_CARRY;
1.1 root 764: #endif
765: FORCE_RET();
766: }
767:
768: void OPPROTO op_and_T1_T0(void)
769: {
770: T0 &= T1;
771: }
772:
773: void OPPROTO op_or_T1_T0(void)
774: {
775: T0 |= T1;
776: }
777:
778: void OPPROTO op_xor_T1_T0(void)
779: {
780: T0 ^= T1;
781: }
782:
783: void OPPROTO op_andn_T1_T0(void)
784: {
785: T0 &= ~T1;
786: }
787:
788: void OPPROTO op_orn_T1_T0(void)
789: {
790: T0 |= ~T1;
791: }
792:
793: void OPPROTO op_xnor_T1_T0(void)
794: {
795: T0 ^= ~T1;
796: }
797:
798: void OPPROTO op_umul_T1_T0(void)
799: {
800: uint64_t res;
801: res = (uint64_t) T0 * (uint64_t) T1;
802: #ifdef TARGET_SPARC64
803: T0 = res;
804: #else
805: T0 = res & 0xffffffff;
806: #endif
807: env->y = res >> 32;
808: }
809:
810: void OPPROTO op_smul_T1_T0(void)
811: {
812: uint64_t res;
813: res = (int64_t) ((int32_t) T0) * (int64_t) ((int32_t) T1);
814: #ifdef TARGET_SPARC64
815: T0 = res;
816: #else
817: T0 = res & 0xffffffff;
818: #endif
819: env->y = res >> 32;
820: }
821:
822: void OPPROTO op_mulscc_T1_T0(void)
823: {
824: unsigned int b1, N, V, b2;
825: target_ulong src1;
826:
827: N = FLAG_SET(PSR_NEG);
828: V = FLAG_SET(PSR_OVF);
829: b1 = N ^ V;
830: b2 = T0 & 1;
831: T0 = (b1 << 31) | (T0 >> 1);
832: if (!(env->y & 1))
833: T1 = 0;
834: /* do addition and update flags */
835: src1 = T0;
836: T0 += T1;
837: env->psr = 0;
838: if (!T0)
1.1.1.6 ! root 839: env->psr |= PSR_ZERO;
1.1 root 840: if ((int32_t) T0 < 0)
1.1.1.6 ! root 841: env->psr |= PSR_NEG;
1.1 root 842: if (T0 < src1)
1.1.1.6 ! root 843: env->psr |= PSR_CARRY;
1.1 root 844: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
1.1.1.6 ! root 845: env->psr |= PSR_OVF;
1.1 root 846: env->y = (b2 << 31) | (env->y >> 1);
847: FORCE_RET();
848: }
849:
850: void OPPROTO op_udiv_T1_T0(void)
851: {
852: uint64_t x0;
853: uint32_t x1;
854:
855: x0 = T0 | ((uint64_t) (env->y) << 32);
856: x1 = T1;
1.1.1.6 ! root 857:
! 858: if (x1 == 0) {
! 859: raise_exception(TT_DIV_ZERO);
! 860: }
! 861:
1.1 root 862: x0 = x0 / x1;
863: if (x0 > 0xffffffff) {
1.1.1.6 ! root 864: T0 = 0xffffffff;
! 865: T1 = 1;
1.1 root 866: } else {
1.1.1.6 ! root 867: T0 = x0;
! 868: T1 = 0;
1.1 root 869: }
870: FORCE_RET();
871: }
872:
873: void OPPROTO op_sdiv_T1_T0(void)
874: {
875: int64_t x0;
876: int32_t x1;
877:
878: x0 = T0 | ((int64_t) (env->y) << 32);
879: x1 = T1;
1.1.1.6 ! root 880:
! 881: if (x1 == 0) {
! 882: raise_exception(TT_DIV_ZERO);
! 883: }
! 884:
1.1 root 885: x0 = x0 / x1;
886: if ((int32_t) x0 != x0) {
1.1.1.6 ! root 887: T0 = x0 < 0? 0x80000000: 0x7fffffff;
! 888: T1 = 1;
1.1 root 889: } else {
1.1.1.6 ! root 890: T0 = x0;
! 891: T1 = 0;
1.1 root 892: }
893: FORCE_RET();
894: }
895:
896: void OPPROTO op_div_cc(void)
897: {
898: env->psr = 0;
899: #ifdef TARGET_SPARC64
900: if (!T0)
1.1.1.6 ! root 901: env->psr |= PSR_ZERO;
1.1 root 902: if ((int32_t) T0 < 0)
1.1.1.6 ! root 903: env->psr |= PSR_NEG;
1.1 root 904: if (T1)
1.1.1.6 ! root 905: env->psr |= PSR_OVF;
1.1 root 906:
907: env->xcc = 0;
908: if (!T0)
1.1.1.6 ! root 909: env->xcc |= PSR_ZERO;
1.1 root 910: if ((int64_t) T0 < 0)
1.1.1.6 ! root 911: env->xcc |= PSR_NEG;
1.1 root 912: #else
913: if (!T0)
1.1.1.6 ! root 914: env->psr |= PSR_ZERO;
1.1 root 915: if ((int32_t) T0 < 0)
1.1.1.6 ! root 916: env->psr |= PSR_NEG;
1.1 root 917: if (T1)
1.1.1.6 ! root 918: env->psr |= PSR_OVF;
1.1 root 919: #endif
920: FORCE_RET();
921: }
922:
923: #ifdef TARGET_SPARC64
924: void OPPROTO op_mulx_T1_T0(void)
925: {
926: T0 *= T1;
927: FORCE_RET();
928: }
929:
930: void OPPROTO op_udivx_T1_T0(void)
931: {
1.1.1.6 ! root 932: if (T1 == 0) {
! 933: raise_exception(TT_DIV_ZERO);
! 934: }
1.1 root 935: T0 /= T1;
936: FORCE_RET();
937: }
938:
939: void OPPROTO op_sdivx_T1_T0(void)
940: {
1.1.1.6 ! root 941: if (T1 == 0) {
! 942: raise_exception(TT_DIV_ZERO);
! 943: }
1.1 root 944: if (T0 == INT64_MIN && T1 == -1)
1.1.1.6 ! root 945: T0 = INT64_MIN;
1.1 root 946: else
1.1.1.6 ! root 947: T0 /= (target_long) T1;
1.1 root 948: FORCE_RET();
949: }
950: #endif
951:
952: void OPPROTO op_logic_T0_cc(void)
953: {
954: env->psr = 0;
955: #ifdef TARGET_SPARC64
956: if (!(T0 & 0xffffffff))
1.1.1.6 ! root 957: env->psr |= PSR_ZERO;
1.1 root 958: if ((int32_t) T0 < 0)
1.1.1.6 ! root 959: env->psr |= PSR_NEG;
1.1 root 960:
961: env->xcc = 0;
962: if (!T0)
1.1.1.6 ! root 963: env->xcc |= PSR_ZERO;
1.1 root 964: if ((int64_t) T0 < 0)
1.1.1.6 ! root 965: env->xcc |= PSR_NEG;
1.1 root 966: #else
967: if (!T0)
1.1.1.6 ! root 968: env->psr |= PSR_ZERO;
1.1 root 969: if ((int32_t) T0 < 0)
1.1.1.6 ! root 970: env->psr |= PSR_NEG;
1.1 root 971: #endif
972: FORCE_RET();
973: }
974:
975: void OPPROTO op_sll(void)
976: {
1.1.1.6 ! root 977: T0 <<= (T1 & 0x1f);
1.1 root 978: }
979:
980: #ifdef TARGET_SPARC64
1.1.1.6 ! root 981: void OPPROTO op_sllx(void)
! 982: {
! 983: T0 <<= (T1 & 0x3f);
! 984: }
! 985:
1.1 root 986: void OPPROTO op_srl(void)
987: {
1.1.1.6 ! root 988: T0 = (T0 & 0xffffffff) >> (T1 & 0x1f);
1.1 root 989: }
990:
991: void OPPROTO op_srlx(void)
992: {
1.1.1.6 ! root 993: T0 >>= (T1 & 0x3f);
1.1 root 994: }
995:
996: void OPPROTO op_sra(void)
997: {
1.1.1.6 ! root 998: T0 = ((int32_t) (T0 & 0xffffffff)) >> (T1 & 0x1f);
1.1 root 999: }
1000:
1001: void OPPROTO op_srax(void)
1002: {
1.1.1.6 ! root 1003: T0 = ((int64_t) T0) >> (T1 & 0x3f);
1.1 root 1004: }
1005: #else
1006: void OPPROTO op_srl(void)
1007: {
1.1.1.6 ! root 1008: T0 >>= (T1 & 0x1f);
1.1 root 1009: }
1010:
1011: void OPPROTO op_sra(void)
1012: {
1.1.1.6 ! root 1013: T0 = ((int32_t) T0) >> (T1 & 0x1f);
1.1 root 1014: }
1015: #endif
1016:
1017: /* Load and store */
1018: #define MEMSUFFIX _raw
1019: #include "op_mem.h"
1020: #if !defined(CONFIG_USER_ONLY)
1021: #define MEMSUFFIX _user
1022: #include "op_mem.h"
1023:
1024: #define MEMSUFFIX _kernel
1025: #include "op_mem.h"
1.1.1.6 ! root 1026:
! 1027: #ifdef TARGET_SPARC64
! 1028: #define MEMSUFFIX _hypv
! 1029: #include "op_mem.h"
! 1030: #endif
1.1 root 1031: #endif
1032:
1033: void OPPROTO op_ldfsr(void)
1034: {
1035: PUT_FSR32(env, *((uint32_t *) &FT0));
1036: helper_ldfsr();
1037: }
1038:
1039: void OPPROTO op_stfsr(void)
1040: {
1041: *((uint32_t *) &FT0) = GET_FSR32(env);
1042: }
1043:
1044: #ifndef TARGET_SPARC64
1045: void OPPROTO op_rdpsr(void)
1046: {
1047: do_rdpsr();
1048: }
1049:
1050: void OPPROTO op_wrpsr(void)
1051: {
1052: do_wrpsr();
1053: FORCE_RET();
1054: }
1055:
1.1.1.5 root 1056: void OPPROTO op_wrwim(void)
1057: {
1058: #if NWINDOWS == 32
1059: env->wim = T0;
1060: #else
1061: env->wim = T0 & ((1 << NWINDOWS) - 1);
1062: #endif
1063: }
1064:
1.1 root 1065: void OPPROTO op_rett(void)
1066: {
1067: helper_rett();
1068: FORCE_RET();
1069: }
1070:
1071: /* XXX: use another pointer for %iN registers to avoid slow wrapping
1072: handling ? */
1073: void OPPROTO op_save(void)
1074: {
1075: uint32_t cwp;
1.1.1.6 ! root 1076: cwp = (env->cwp - 1) & (NWINDOWS - 1);
1.1 root 1077: if (env->wim & (1 << cwp)) {
1078: raise_exception(TT_WIN_OVF);
1079: }
1080: set_cwp(cwp);
1081: FORCE_RET();
1082: }
1083:
1084: void OPPROTO op_restore(void)
1085: {
1086: uint32_t cwp;
1.1.1.6 ! root 1087: cwp = (env->cwp + 1) & (NWINDOWS - 1);
1.1 root 1088: if (env->wim & (1 << cwp)) {
1089: raise_exception(TT_WIN_UNF);
1090: }
1091: set_cwp(cwp);
1092: FORCE_RET();
1093: }
1094: #else
1095: void OPPROTO op_rdccr(void)
1096: {
1097: T0 = GET_CCR(env);
1098: }
1099:
1100: void OPPROTO op_wrccr(void)
1101: {
1102: PUT_CCR(env, T0);
1103: }
1104:
1105: void OPPROTO op_rdtick(void)
1106: {
1.1.1.6 ! root 1107: T0 = do_tick_get_count(env->tick);
1.1 root 1108: }
1109:
1110: void OPPROTO op_wrtick(void)
1111: {
1.1.1.6 ! root 1112: do_tick_set_count(env->tick, T0);
! 1113: }
! 1114:
! 1115: void OPPROTO op_wrtick_cmpr(void)
! 1116: {
! 1117: do_tick_set_limit(env->tick, T0);
! 1118: }
! 1119:
! 1120: void OPPROTO op_rdstick(void)
! 1121: {
! 1122: T0 = do_tick_get_count(env->stick);
! 1123: }
! 1124:
! 1125: void OPPROTO op_wrstick(void)
! 1126: {
! 1127: do_tick_set_count(env->stick, T0);
! 1128: do_tick_set_count(env->hstick, T0);
! 1129: }
! 1130:
! 1131: void OPPROTO op_wrstick_cmpr(void)
! 1132: {
! 1133: do_tick_set_limit(env->stick, T0);
! 1134: }
! 1135:
! 1136: void OPPROTO op_wrhstick_cmpr(void)
! 1137: {
! 1138: do_tick_set_limit(env->hstick, T0);
1.1 root 1139: }
1140:
1141: void OPPROTO op_rdtpc(void)
1142: {
1143: T0 = env->tpc[env->tl];
1144: }
1145:
1146: void OPPROTO op_wrtpc(void)
1147: {
1148: env->tpc[env->tl] = T0;
1149: }
1150:
1151: void OPPROTO op_rdtnpc(void)
1152: {
1153: T0 = env->tnpc[env->tl];
1154: }
1155:
1156: void OPPROTO op_wrtnpc(void)
1157: {
1158: env->tnpc[env->tl] = T0;
1159: }
1160:
1161: void OPPROTO op_rdtstate(void)
1162: {
1163: T0 = env->tstate[env->tl];
1164: }
1165:
1166: void OPPROTO op_wrtstate(void)
1167: {
1168: env->tstate[env->tl] = T0;
1169: }
1170:
1171: void OPPROTO op_rdtt(void)
1172: {
1173: T0 = env->tt[env->tl];
1174: }
1175:
1176: void OPPROTO op_wrtt(void)
1177: {
1178: env->tt[env->tl] = T0;
1179: }
1180:
1181: void OPPROTO op_rdpstate(void)
1182: {
1183: T0 = env->pstate;
1184: }
1185:
1186: void OPPROTO op_wrpstate(void)
1187: {
1188: do_wrpstate();
1189: }
1190:
1191: // CWP handling is reversed in V9, but we still use the V8 register
1192: // order.
1193: void OPPROTO op_rdcwp(void)
1194: {
1.1.1.6 ! root 1195: T0 = GET_CWP64(env);
1.1 root 1196: }
1197:
1198: void OPPROTO op_wrcwp(void)
1199: {
1.1.1.6 ! root 1200: PUT_CWP64(env, T0);
1.1 root 1201: }
1202:
1203: /* XXX: use another pointer for %iN registers to avoid slow wrapping
1204: handling ? */
1205: void OPPROTO op_save(void)
1206: {
1207: uint32_t cwp;
1.1.1.6 ! root 1208: cwp = (env->cwp - 1) & (NWINDOWS - 1);
1.1 root 1209: if (env->cansave == 0) {
1.1.1.6 ! root 1210: raise_exception(TT_SPILL | (env->otherwin != 0 ?
! 1211: (TT_WOTHER | ((env->wstate & 0x38) >> 1)):
! 1212: ((env->wstate & 0x7) << 2)));
1.1 root 1213: } else {
1.1.1.6 ! root 1214: if (env->cleanwin - env->canrestore == 0) {
! 1215: // XXX Clean windows without trap
! 1216: raise_exception(TT_CLRWIN);
! 1217: } else {
! 1218: env->cansave--;
! 1219: env->canrestore++;
! 1220: set_cwp(cwp);
! 1221: }
1.1 root 1222: }
1223: FORCE_RET();
1224: }
1225:
1226: void OPPROTO op_restore(void)
1227: {
1228: uint32_t cwp;
1.1.1.6 ! root 1229: cwp = (env->cwp + 1) & (NWINDOWS - 1);
1.1 root 1230: if (env->canrestore == 0) {
1.1.1.6 ! root 1231: raise_exception(TT_FILL | (env->otherwin != 0 ?
! 1232: (TT_WOTHER | ((env->wstate & 0x38) >> 1)):
! 1233: ((env->wstate & 0x7) << 2)));
1.1 root 1234: } else {
1.1.1.6 ! root 1235: env->cansave++;
! 1236: env->canrestore--;
! 1237: set_cwp(cwp);
1.1 root 1238: }
1239: FORCE_RET();
1240: }
1241: #endif
1242:
1243: void OPPROTO op_exception(void)
1244: {
1245: env->exception_index = PARAM1;
1246: cpu_loop_exit();
1.1.1.6 ! root 1247: FORCE_RET();
1.1 root 1248: }
1249:
1250: void OPPROTO op_trap_T0(void)
1251: {
1252: env->exception_index = TT_TRAP + (T0 & 0x7f);
1253: cpu_loop_exit();
1.1.1.6 ! root 1254: FORCE_RET();
1.1 root 1255: }
1256:
1257: void OPPROTO op_trapcc_T0(void)
1258: {
1259: if (T2) {
1260: env->exception_index = TT_TRAP + (T0 & 0x7f);
1261: cpu_loop_exit();
1262: }
1263: FORCE_RET();
1264: }
1265:
1266: void OPPROTO op_fpexception_im(void)
1267: {
1268: env->exception_index = TT_FP_EXCP;
1269: env->fsr &= ~FSR_FTT_MASK;
1270: env->fsr |= PARAM1;
1271: cpu_loop_exit();
1272: FORCE_RET();
1273: }
1274:
1275: void OPPROTO op_debug(void)
1276: {
1277: helper_debug();
1278: }
1279:
1280: void OPPROTO op_exit_tb(void)
1281: {
1282: EXIT_TB();
1283: }
1284:
1285: void OPPROTO op_eval_ba(void)
1286: {
1287: T2 = 1;
1288: }
1289:
1290: void OPPROTO op_eval_be(void)
1291: {
1292: T2 = FLAG_SET(PSR_ZERO);
1293: }
1294:
1295: void OPPROTO op_eval_ble(void)
1296: {
1297: target_ulong Z = FLAG_SET(PSR_ZERO), N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
1.1.1.6 ! root 1298:
1.1 root 1299: T2 = Z | (N ^ V);
1300: }
1301:
1302: void OPPROTO op_eval_bl(void)
1303: {
1304: target_ulong N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
1305:
1306: T2 = N ^ V;
1307: }
1308:
1309: void OPPROTO op_eval_bleu(void)
1310: {
1311: target_ulong Z = FLAG_SET(PSR_ZERO), C = FLAG_SET(PSR_CARRY);
1312:
1313: T2 = C | Z;
1314: }
1315:
1316: void OPPROTO op_eval_bcs(void)
1317: {
1318: T2 = FLAG_SET(PSR_CARRY);
1319: }
1320:
1321: void OPPROTO op_eval_bvs(void)
1322: {
1323: T2 = FLAG_SET(PSR_OVF);
1324: }
1325:
1326: void OPPROTO op_eval_bn(void)
1327: {
1328: T2 = 0;
1329: }
1330:
1331: void OPPROTO op_eval_bneg(void)
1332: {
1333: T2 = FLAG_SET(PSR_NEG);
1334: }
1335:
1336: void OPPROTO op_eval_bne(void)
1337: {
1338: T2 = !FLAG_SET(PSR_ZERO);
1339: }
1340:
1341: void OPPROTO op_eval_bg(void)
1342: {
1343: target_ulong Z = FLAG_SET(PSR_ZERO), N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
1344:
1345: T2 = !(Z | (N ^ V));
1346: }
1347:
1348: void OPPROTO op_eval_bge(void)
1349: {
1350: target_ulong N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
1351:
1352: T2 = !(N ^ V);
1353: }
1354:
1355: void OPPROTO op_eval_bgu(void)
1356: {
1357: target_ulong Z = FLAG_SET(PSR_ZERO), C = FLAG_SET(PSR_CARRY);
1358:
1359: T2 = !(C | Z);
1360: }
1361:
1362: void OPPROTO op_eval_bcc(void)
1363: {
1364: T2 = !FLAG_SET(PSR_CARRY);
1365: }
1366:
1367: void OPPROTO op_eval_bpos(void)
1368: {
1369: T2 = !FLAG_SET(PSR_NEG);
1370: }
1371:
1372: void OPPROTO op_eval_bvc(void)
1373: {
1374: T2 = !FLAG_SET(PSR_OVF);
1375: }
1376:
1377: #ifdef TARGET_SPARC64
1378: void OPPROTO op_eval_xbe(void)
1379: {
1380: T2 = XFLAG_SET(PSR_ZERO);
1381: }
1382:
1383: void OPPROTO op_eval_xble(void)
1384: {
1385: target_ulong Z = XFLAG_SET(PSR_ZERO), N = XFLAG_SET(PSR_NEG), V = XFLAG_SET(PSR_OVF);
1.1.1.6 ! root 1386:
1.1 root 1387: T2 = Z | (N ^ V);
1388: }
1389:
1390: void OPPROTO op_eval_xbl(void)
1391: {
1392: target_ulong N = XFLAG_SET(PSR_NEG), V = XFLAG_SET(PSR_OVF);
1393:
1394: T2 = N ^ V;
1395: }
1396:
1397: void OPPROTO op_eval_xbleu(void)
1398: {
1399: target_ulong Z = XFLAG_SET(PSR_ZERO), C = XFLAG_SET(PSR_CARRY);
1400:
1401: T2 = C | Z;
1402: }
1403:
1404: void OPPROTO op_eval_xbcs(void)
1405: {
1406: T2 = XFLAG_SET(PSR_CARRY);
1407: }
1408:
1409: void OPPROTO op_eval_xbvs(void)
1410: {
1411: T2 = XFLAG_SET(PSR_OVF);
1412: }
1413:
1414: void OPPROTO op_eval_xbneg(void)
1415: {
1416: T2 = XFLAG_SET(PSR_NEG);
1417: }
1418:
1419: void OPPROTO op_eval_xbne(void)
1420: {
1421: T2 = !XFLAG_SET(PSR_ZERO);
1422: }
1423:
1424: void OPPROTO op_eval_xbg(void)
1425: {
1426: target_ulong Z = XFLAG_SET(PSR_ZERO), N = XFLAG_SET(PSR_NEG), V = XFLAG_SET(PSR_OVF);
1427:
1428: T2 = !(Z | (N ^ V));
1429: }
1430:
1431: void OPPROTO op_eval_xbge(void)
1432: {
1433: target_ulong N = XFLAG_SET(PSR_NEG), V = XFLAG_SET(PSR_OVF);
1434:
1435: T2 = !(N ^ V);
1436: }
1437:
1438: void OPPROTO op_eval_xbgu(void)
1439: {
1440: target_ulong Z = XFLAG_SET(PSR_ZERO), C = XFLAG_SET(PSR_CARRY);
1441:
1442: T2 = !(C | Z);
1443: }
1444:
1445: void OPPROTO op_eval_xbcc(void)
1446: {
1447: T2 = !XFLAG_SET(PSR_CARRY);
1448: }
1449:
1450: void OPPROTO op_eval_xbpos(void)
1451: {
1452: T2 = !XFLAG_SET(PSR_NEG);
1453: }
1454:
1455: void OPPROTO op_eval_xbvc(void)
1456: {
1457: T2 = !XFLAG_SET(PSR_OVF);
1458: }
1459: #endif
1460:
1461: #define FCC
1462: #define FFLAG_SET(x) (env->fsr & x? 1: 0)
1463: #include "fbranch_template.h"
1464:
1465: #ifdef TARGET_SPARC64
1466: #define FCC _fcc1
1467: #define FFLAG_SET(x) ((env->fsr & ((uint64_t)x >> 32))? 1: 0)
1468: #include "fbranch_template.h"
1469: #define FCC _fcc2
1470: #define FFLAG_SET(x) ((env->fsr & ((uint64_t)x >> 34))? 1: 0)
1471: #include "fbranch_template.h"
1472: #define FCC _fcc3
1473: #define FFLAG_SET(x) ((env->fsr & ((uint64_t)x >> 36))? 1: 0)
1474: #include "fbranch_template.h"
1475: #endif
1476:
1477: #ifdef TARGET_SPARC64
1478: void OPPROTO op_eval_brz(void)
1479: {
1480: T2 = (T0 == 0);
1481: }
1482:
1483: void OPPROTO op_eval_brnz(void)
1484: {
1485: T2 = (T0 != 0);
1486: }
1487:
1488: void OPPROTO op_eval_brlz(void)
1489: {
1490: T2 = ((int64_t)T0 < 0);
1491: }
1492:
1493: void OPPROTO op_eval_brlez(void)
1494: {
1495: T2 = ((int64_t)T0 <= 0);
1496: }
1497:
1498: void OPPROTO op_eval_brgz(void)
1499: {
1500: T2 = ((int64_t)T0 > 0);
1501: }
1502:
1503: void OPPROTO op_eval_brgez(void)
1504: {
1505: T2 = ((int64_t)T0 >= 0);
1506: }
1507:
1508: void OPPROTO op_jmp_im64(void)
1509: {
1510: env->pc = PARAMQ1;
1511: }
1512:
1513: void OPPROTO op_movq_npc_im64(void)
1514: {
1515: env->npc = PARAMQ1;
1516: }
1517: #endif
1518:
1519: void OPPROTO op_jmp_im(void)
1520: {
1521: env->pc = (uint32_t)PARAM1;
1522: }
1523:
1524: void OPPROTO op_movl_npc_im(void)
1525: {
1526: env->npc = (uint32_t)PARAM1;
1527: }
1528:
1529: void OPPROTO op_movl_npc_T0(void)
1530: {
1531: env->npc = T0;
1532: }
1533:
1534: void OPPROTO op_mov_pc_npc(void)
1535: {
1536: env->pc = env->npc;
1537: }
1538:
1539: void OPPROTO op_next_insn(void)
1540: {
1541: env->pc = env->npc;
1542: env->npc = env->npc + 4;
1543: }
1544:
1545: void OPPROTO op_goto_tb0(void)
1546: {
1547: GOTO_TB(op_goto_tb0, PARAM1, 0);
1548: }
1549:
1550: void OPPROTO op_goto_tb1(void)
1551: {
1552: GOTO_TB(op_goto_tb1, PARAM1, 1);
1553: }
1554:
1555: void OPPROTO op_jmp_label(void)
1556: {
1557: GOTO_LABEL_PARAM(1);
1558: }
1559:
1560: void OPPROTO op_jnz_T2_label(void)
1561: {
1562: if (T2)
1563: GOTO_LABEL_PARAM(1);
1564: FORCE_RET();
1565: }
1566:
1567: void OPPROTO op_jz_T2_label(void)
1568: {
1569: if (!T2)
1570: GOTO_LABEL_PARAM(1);
1571: FORCE_RET();
1572: }
1573:
1574: void OPPROTO op_flush_T0(void)
1575: {
1576: helper_flush(T0);
1577: }
1578:
1.1.1.6 ! root 1579: void OPPROTO op_clear_ieee_excp_and_FTT(void)
! 1580: {
! 1581: env->fsr &= ~(FSR_FTT_MASK | FSR_CEXC_MASK);;
! 1582: }
! 1583:
1.1.1.4 root 1584: #define F_OP(name, p) void OPPROTO op_f##name##p(void)
1.1 root 1585:
1.1.1.6 ! root 1586: #if defined(CONFIG_USER_ONLY)
1.1.1.4 root 1587: #define F_BINOP(name) \
1588: F_OP(name, s) \
1589: { \
1.1.1.6 ! root 1590: set_float_exception_flags(0, &env->fp_status); \
1.1.1.4 root 1591: FT0 = float32_ ## name (FT0, FT1, &env->fp_status); \
1.1.1.6 ! root 1592: check_ieee_exceptions(); \
1.1.1.4 root 1593: } \
1594: F_OP(name, d) \
1595: { \
1.1.1.6 ! root 1596: set_float_exception_flags(0, &env->fp_status); \
1.1.1.4 root 1597: DT0 = float64_ ## name (DT0, DT1, &env->fp_status); \
1.1.1.6 ! root 1598: check_ieee_exceptions(); \
! 1599: } \
! 1600: F_OP(name, q) \
! 1601: { \
! 1602: set_float_exception_flags(0, &env->fp_status); \
! 1603: QT0 = float128_ ## name (QT0, QT1, &env->fp_status); \
! 1604: check_ieee_exceptions(); \
1.1.1.4 root 1605: }
1.1.1.6 ! root 1606: #else
! 1607: #define F_BINOP(name) \
! 1608: F_OP(name, s) \
! 1609: { \
! 1610: set_float_exception_flags(0, &env->fp_status); \
! 1611: FT0 = float32_ ## name (FT0, FT1, &env->fp_status); \
! 1612: check_ieee_exceptions(); \
! 1613: } \
! 1614: F_OP(name, d) \
! 1615: { \
! 1616: set_float_exception_flags(0, &env->fp_status); \
! 1617: DT0 = float64_ ## name (DT0, DT1, &env->fp_status); \
! 1618: check_ieee_exceptions(); \
! 1619: }
! 1620: #endif
1.1 root 1621:
1.1.1.4 root 1622: F_BINOP(add);
1623: F_BINOP(sub);
1624: F_BINOP(mul);
1625: F_BINOP(div);
1626: #undef F_BINOP
1.1 root 1627:
1628: void OPPROTO op_fsmuld(void)
1629: {
1.1.1.6 ! root 1630: set_float_exception_flags(0, &env->fp_status);
1.1.1.4 root 1631: DT0 = float64_mul(float32_to_float64(FT0, &env->fp_status),
1632: float32_to_float64(FT1, &env->fp_status),
1633: &env->fp_status);
1.1.1.6 ! root 1634: check_ieee_exceptions();
1.1 root 1635: }
1636:
1.1.1.6 ! root 1637: #if defined(CONFIG_USER_ONLY)
! 1638: void OPPROTO op_fdmulq(void)
! 1639: {
! 1640: set_float_exception_flags(0, &env->fp_status);
! 1641: QT0 = float128_mul(float64_to_float128(DT0, &env->fp_status),
! 1642: float64_to_float128(DT1, &env->fp_status),
! 1643: &env->fp_status);
! 1644: check_ieee_exceptions();
! 1645: }
! 1646: #endif
! 1647:
! 1648: #if defined(CONFIG_USER_ONLY)
! 1649: #define F_HELPER(name) \
! 1650: F_OP(name, s) \
! 1651: { \
! 1652: do_f##name##s(); \
! 1653: } \
! 1654: F_OP(name, d) \
! 1655: { \
! 1656: do_f##name##d(); \
! 1657: } \
! 1658: F_OP(name, q) \
! 1659: { \
! 1660: do_f##name##q(); \
! 1661: }
! 1662: #else
1.1.1.4 root 1663: #define F_HELPER(name) \
1664: F_OP(name, s) \
1665: { \
1666: do_f##name##s(); \
1667: } \
1668: F_OP(name, d) \
1669: { \
1670: do_f##name##d(); \
1671: }
1.1.1.6 ! root 1672: #endif
1.1 root 1673:
1.1.1.4 root 1674: F_HELPER(sqrt);
1.1 root 1675:
1.1.1.4 root 1676: F_OP(neg, s)
1.1 root 1677: {
1.1.1.4 root 1678: FT0 = float32_chs(FT1);
1.1 root 1679: }
1680:
1.1.1.4 root 1681: F_OP(abs, s)
1.1 root 1682: {
1.1.1.4 root 1683: do_fabss();
1.1 root 1684: }
1685:
1.1.1.4 root 1686: F_HELPER(cmp);
1.1.1.6 ! root 1687: F_HELPER(cmpe);
1.1 root 1688:
1.1.1.4 root 1689: #ifdef TARGET_SPARC64
1690: F_OP(neg, d)
1.1 root 1691: {
1.1.1.4 root 1692: DT0 = float64_chs(DT1);
1.1 root 1693: }
1694:
1.1.1.4 root 1695: F_OP(abs, d)
1.1 root 1696: {
1.1.1.4 root 1697: do_fabsd();
1.1 root 1698: }
1699:
1.1.1.6 ! root 1700: #if defined(CONFIG_USER_ONLY)
! 1701: F_OP(neg, q)
! 1702: {
! 1703: QT0 = float128_chs(QT1);
! 1704: }
! 1705:
! 1706: F_OP(abs, q)
! 1707: {
! 1708: do_fabsd();
! 1709: }
! 1710: #endif
! 1711:
1.1 root 1712: void OPPROTO op_fcmps_fcc1(void)
1713: {
1714: do_fcmps_fcc1();
1715: }
1716:
1717: void OPPROTO op_fcmpd_fcc1(void)
1718: {
1719: do_fcmpd_fcc1();
1720: }
1721:
1722: void OPPROTO op_fcmps_fcc2(void)
1723: {
1724: do_fcmps_fcc2();
1725: }
1726:
1727: void OPPROTO op_fcmpd_fcc2(void)
1728: {
1729: do_fcmpd_fcc2();
1730: }
1731:
1732: void OPPROTO op_fcmps_fcc3(void)
1733: {
1734: do_fcmps_fcc3();
1735: }
1736:
1737: void OPPROTO op_fcmpd_fcc3(void)
1738: {
1739: do_fcmpd_fcc3();
1740: }
1.1.1.6 ! root 1741:
! 1742: void OPPROTO op_fcmpes_fcc1(void)
! 1743: {
! 1744: do_fcmpes_fcc1();
! 1745: }
! 1746:
! 1747: void OPPROTO op_fcmped_fcc1(void)
! 1748: {
! 1749: do_fcmped_fcc1();
! 1750: }
! 1751:
! 1752: void OPPROTO op_fcmpes_fcc2(void)
! 1753: {
! 1754: do_fcmpes_fcc2();
! 1755: }
! 1756:
! 1757: void OPPROTO op_fcmped_fcc2(void)
! 1758: {
! 1759: do_fcmped_fcc2();
! 1760: }
! 1761:
! 1762: void OPPROTO op_fcmpes_fcc3(void)
! 1763: {
! 1764: do_fcmpes_fcc3();
! 1765: }
! 1766:
! 1767: void OPPROTO op_fcmped_fcc3(void)
! 1768: {
! 1769: do_fcmped_fcc3();
! 1770: }
! 1771:
! 1772: #if defined(CONFIG_USER_ONLY)
! 1773: void OPPROTO op_fcmpq_fcc1(void)
! 1774: {
! 1775: do_fcmpq_fcc1();
! 1776: }
! 1777:
! 1778: void OPPROTO op_fcmpq_fcc2(void)
! 1779: {
! 1780: do_fcmpq_fcc2();
! 1781: }
! 1782:
! 1783: void OPPROTO op_fcmpq_fcc3(void)
! 1784: {
! 1785: do_fcmpq_fcc3();
! 1786: }
! 1787:
! 1788: void OPPROTO op_fcmpeq_fcc1(void)
! 1789: {
! 1790: do_fcmpeq_fcc1();
! 1791: }
! 1792:
! 1793: void OPPROTO op_fcmpeq_fcc2(void)
! 1794: {
! 1795: do_fcmpeq_fcc2();
! 1796: }
! 1797:
! 1798: void OPPROTO op_fcmpeq_fcc3(void)
! 1799: {
! 1800: do_fcmpeq_fcc3();
! 1801: }
! 1802: #endif
! 1803:
1.1 root 1804: #endif
1805:
1.1.1.4 root 1806: /* Integer to float conversion. */
1.1 root 1807: #ifdef USE_INT_TO_FLOAT_HELPERS
1.1.1.4 root 1808: F_HELPER(ito);
1.1.1.6 ! root 1809: #ifdef TARGET_SPARC64
! 1810: F_HELPER(xto);
! 1811: #endif
1.1 root 1812: #else
1.1.1.4 root 1813: F_OP(ito, s)
1.1 root 1814: {
1.1.1.6 ! root 1815: set_float_exception_flags(0, &env->fp_status);
1.1.1.4 root 1816: FT0 = int32_to_float32(*((int32_t *)&FT1), &env->fp_status);
1.1.1.6 ! root 1817: check_ieee_exceptions();
1.1 root 1818: }
1819:
1.1.1.4 root 1820: F_OP(ito, d)
1.1 root 1821: {
1.1.1.6 ! root 1822: set_float_exception_flags(0, &env->fp_status);
1.1.1.4 root 1823: DT0 = int32_to_float64(*((int32_t *)&FT1), &env->fp_status);
1.1.1.6 ! root 1824: check_ieee_exceptions();
! 1825: }
! 1826:
! 1827: #if defined(CONFIG_USER_ONLY)
! 1828: F_OP(ito, q)
! 1829: {
! 1830: set_float_exception_flags(0, &env->fp_status);
! 1831: QT0 = int32_to_float128(*((int32_t *)&FT1), &env->fp_status);
! 1832: check_ieee_exceptions();
1.1 root 1833: }
1.1.1.6 ! root 1834: #endif
1.1 root 1835:
1836: #ifdef TARGET_SPARC64
1.1.1.4 root 1837: F_OP(xto, s)
1.1 root 1838: {
1.1.1.6 ! root 1839: set_float_exception_flags(0, &env->fp_status);
1.1.1.4 root 1840: FT0 = int64_to_float32(*((int64_t *)&DT1), &env->fp_status);
1.1.1.6 ! root 1841: check_ieee_exceptions();
1.1 root 1842: }
1843:
1.1.1.4 root 1844: F_OP(xto, d)
1.1 root 1845: {
1.1.1.6 ! root 1846: set_float_exception_flags(0, &env->fp_status);
1.1.1.4 root 1847: DT0 = int64_to_float64(*((int64_t *)&DT1), &env->fp_status);
1.1.1.6 ! root 1848: check_ieee_exceptions();
! 1849: }
! 1850: #if defined(CONFIG_USER_ONLY)
! 1851: F_OP(xto, q)
! 1852: {
! 1853: set_float_exception_flags(0, &env->fp_status);
! 1854: QT0 = int64_to_float128(*((int64_t *)&DT1), &env->fp_status);
! 1855: check_ieee_exceptions();
1.1 root 1856: }
1857: #endif
1858: #endif
1.1.1.6 ! root 1859: #endif
1.1.1.4 root 1860: #undef F_HELPER
1.1 root 1861:
1.1.1.4 root 1862: /* floating point conversion */
1.1 root 1863: void OPPROTO op_fdtos(void)
1864: {
1.1.1.6 ! root 1865: set_float_exception_flags(0, &env->fp_status);
1.1.1.4 root 1866: FT0 = float64_to_float32(DT1, &env->fp_status);
1.1.1.6 ! root 1867: check_ieee_exceptions();
1.1 root 1868: }
1869:
1870: void OPPROTO op_fstod(void)
1871: {
1.1.1.6 ! root 1872: set_float_exception_flags(0, &env->fp_status);
1.1.1.4 root 1873: DT0 = float32_to_float64(FT1, &env->fp_status);
1.1.1.6 ! root 1874: check_ieee_exceptions();
! 1875: }
! 1876:
! 1877: #if defined(CONFIG_USER_ONLY)
! 1878: void OPPROTO op_fqtos(void)
! 1879: {
! 1880: set_float_exception_flags(0, &env->fp_status);
! 1881: FT0 = float128_to_float32(QT1, &env->fp_status);
! 1882: check_ieee_exceptions();
1.1 root 1883: }
1884:
1.1.1.6 ! root 1885: void OPPROTO op_fstoq(void)
! 1886: {
! 1887: set_float_exception_flags(0, &env->fp_status);
! 1888: QT0 = float32_to_float128(FT1, &env->fp_status);
! 1889: check_ieee_exceptions();
! 1890: }
! 1891:
! 1892: void OPPROTO op_fqtod(void)
! 1893: {
! 1894: set_float_exception_flags(0, &env->fp_status);
! 1895: DT0 = float128_to_float64(QT1, &env->fp_status);
! 1896: check_ieee_exceptions();
! 1897: }
! 1898:
! 1899: void OPPROTO op_fdtoq(void)
! 1900: {
! 1901: set_float_exception_flags(0, &env->fp_status);
! 1902: QT0 = float64_to_float128(DT1, &env->fp_status);
! 1903: check_ieee_exceptions();
! 1904: }
! 1905: #endif
! 1906:
1.1.1.4 root 1907: /* Float to integer conversion. */
1.1 root 1908: void OPPROTO op_fstoi(void)
1909: {
1.1.1.6 ! root 1910: set_float_exception_flags(0, &env->fp_status);
! 1911: *((int32_t *)&FT0) = float32_to_int32_round_to_zero(FT1, &env->fp_status);
! 1912: check_ieee_exceptions();
1.1 root 1913: }
1914:
1915: void OPPROTO op_fdtoi(void)
1916: {
1.1.1.6 ! root 1917: set_float_exception_flags(0, &env->fp_status);
! 1918: *((int32_t *)&FT0) = float64_to_int32_round_to_zero(DT1, &env->fp_status);
! 1919: check_ieee_exceptions();
1.1 root 1920: }
1921:
1.1.1.6 ! root 1922: #if defined(CONFIG_USER_ONLY)
! 1923: void OPPROTO op_fqtoi(void)
! 1924: {
! 1925: set_float_exception_flags(0, &env->fp_status);
! 1926: *((int32_t *)&FT0) = float128_to_int32_round_to_zero(QT1, &env->fp_status);
! 1927: check_ieee_exceptions();
! 1928: }
! 1929: #endif
! 1930:
1.1 root 1931: #ifdef TARGET_SPARC64
1932: void OPPROTO op_fstox(void)
1933: {
1.1.1.6 ! root 1934: set_float_exception_flags(0, &env->fp_status);
! 1935: *((int64_t *)&DT0) = float32_to_int64_round_to_zero(FT1, &env->fp_status);
! 1936: check_ieee_exceptions();
1.1 root 1937: }
1938:
1939: void OPPROTO op_fdtox(void)
1940: {
1.1.1.6 ! root 1941: set_float_exception_flags(0, &env->fp_status);
! 1942: *((int64_t *)&DT0) = float64_to_int64_round_to_zero(DT1, &env->fp_status);
! 1943: check_ieee_exceptions();
1.1 root 1944: }
1945:
1.1.1.6 ! root 1946: #if defined(CONFIG_USER_ONLY)
! 1947: void OPPROTO op_fqtox(void)
! 1948: {
! 1949: set_float_exception_flags(0, &env->fp_status);
! 1950: *((int64_t *)&DT0) = float128_to_int64_round_to_zero(QT1, &env->fp_status);
! 1951: check_ieee_exceptions();
! 1952: }
! 1953: #endif
! 1954:
1.1 root 1955: void OPPROTO op_fmovs_cc(void)
1956: {
1957: if (T2)
1.1.1.6 ! root 1958: FT0 = FT1;
1.1 root 1959: }
1960:
1961: void OPPROTO op_fmovd_cc(void)
1962: {
1963: if (T2)
1.1.1.6 ! root 1964: DT0 = DT1;
! 1965: }
! 1966:
! 1967: #if defined(CONFIG_USER_ONLY)
! 1968: void OPPROTO op_fmovq_cc(void)
! 1969: {
! 1970: if (T2)
! 1971: QT0 = QT1;
1.1 root 1972: }
1.1.1.6 ! root 1973: #endif
1.1 root 1974:
1975: void OPPROTO op_mov_cc(void)
1976: {
1977: if (T2)
1.1.1.6 ! root 1978: T0 = T1;
1.1 root 1979: }
1980:
1981: void OPPROTO op_flushw(void)
1982: {
1983: if (env->cansave != NWINDOWS - 2) {
1.1.1.6 ! root 1984: raise_exception(TT_SPILL | (env->otherwin != 0 ?
! 1985: (TT_WOTHER | ((env->wstate & 0x38) >> 1)):
! 1986: ((env->wstate & 0x7) << 2)));
1.1 root 1987: }
1988: }
1989:
1990: void OPPROTO op_saved(void)
1991: {
1992: env->cansave++;
1993: if (env->otherwin == 0)
1.1.1.6 ! root 1994: env->canrestore--;
1.1.1.4 root 1995: else
1.1.1.6 ! root 1996: env->otherwin--;
1.1.1.4 root 1997: FORCE_RET();
1.1 root 1998: }
1999:
2000: void OPPROTO op_restored(void)
2001: {
2002: env->canrestore++;
2003: if (env->cleanwin < NWINDOWS - 1)
1.1.1.6 ! root 2004: env->cleanwin++;
1.1 root 2005: if (env->otherwin == 0)
1.1.1.6 ! root 2006: env->cansave--;
1.1 root 2007: else
1.1.1.6 ! root 2008: env->otherwin--;
1.1.1.4 root 2009: FORCE_RET();
1.1 root 2010: }
2011:
2012: void OPPROTO op_popc(void)
2013: {
2014: do_popc();
2015: }
2016:
2017: void OPPROTO op_done(void)
2018: {
2019: do_done();
2020: }
2021:
2022: void OPPROTO op_retry(void)
2023: {
2024: do_retry();
2025: }
2026:
2027: void OPPROTO op_sir(void)
2028: {
1.1.1.6 ! root 2029: T0 = 0; // XXX
1.1 root 2030: }
2031:
2032: void OPPROTO op_ld_asi_reg()
2033: {
2034: T0 += PARAM1;
2035: helper_ld_asi(env->asi, PARAM2, PARAM3);
2036: }
2037:
2038: void OPPROTO op_st_asi_reg()
2039: {
2040: T0 += PARAM1;
1.1.1.6 ! root 2041: helper_st_asi(env->asi, PARAM2);
! 2042: }
! 2043:
! 2044: void OPPROTO op_ldf_asi_reg()
! 2045: {
! 2046: T0 += PARAM1;
! 2047: helper_ldf_asi(env->asi, PARAM2, PARAM3);
! 2048: }
! 2049:
! 2050: void OPPROTO op_stf_asi_reg()
! 2051: {
! 2052: T0 += PARAM1;
! 2053: helper_stf_asi(env->asi, PARAM2, PARAM3);
! 2054: }
! 2055:
! 2056: void OPPROTO op_ldf_asi()
! 2057: {
! 2058: helper_ldf_asi(PARAM1, PARAM2, PARAM3);
! 2059: }
! 2060:
! 2061: void OPPROTO op_stf_asi()
! 2062: {
! 2063: helper_stf_asi(PARAM1, PARAM2, PARAM3);
! 2064: }
! 2065:
! 2066: void OPPROTO op_ldstub_asi_reg() /* XXX: should be atomically */
! 2067: {
! 2068: target_ulong tmp;
! 2069:
! 2070: T0 += PARAM1;
! 2071: helper_ld_asi(env->asi, 1, 0);
! 2072: tmp = T1;
! 2073: T1 = 0xff;
! 2074: helper_st_asi(env->asi, 1);
! 2075: T1 = tmp;
! 2076: }
! 2077:
! 2078: void OPPROTO op_swap_asi_reg() /* XXX: should be atomically */
! 2079: {
! 2080: target_ulong tmp1, tmp2;
! 2081:
! 2082: T0 += PARAM1;
! 2083: tmp1 = T1;
! 2084: helper_ld_asi(env->asi, 4, 0);
! 2085: tmp2 = T1;
! 2086: T1 = tmp1;
! 2087: helper_st_asi(env->asi, 4);
! 2088: T1 = tmp2;
! 2089: }
! 2090:
! 2091: void OPPROTO op_ldda_asi()
! 2092: {
! 2093: helper_ld_asi(PARAM1, 8, 0);
! 2094: T0 = T1 & 0xffffffffUL;
! 2095: T1 >>= 32;
! 2096: }
! 2097:
! 2098: void OPPROTO op_ldda_asi_reg()
! 2099: {
! 2100: T0 += PARAM1;
! 2101: helper_ld_asi(env->asi, 8, 0);
! 2102: T0 = T1 & 0xffffffffUL;
! 2103: T1 >>= 32;
! 2104: }
! 2105:
! 2106: void OPPROTO op_stda_asi()
! 2107: {
! 2108: T1 <<= 32;
! 2109: T1 += T2 & 0xffffffffUL;
! 2110: helper_st_asi(PARAM1, 8);
! 2111: }
! 2112:
! 2113: void OPPROTO op_stda_asi_reg()
! 2114: {
! 2115: T0 += PARAM1;
! 2116: T1 <<= 32;
! 2117: T1 += T2 & 0xffffffffUL;
! 2118: helper_st_asi(env->asi, 8);
! 2119: }
! 2120:
! 2121: void OPPROTO op_cas_asi() /* XXX: should be atomically */
! 2122: {
! 2123: target_ulong tmp;
! 2124:
! 2125: tmp = T1 & 0xffffffffUL;
! 2126: helper_ld_asi(PARAM1, 4, 0);
! 2127: if (tmp == T1) {
! 2128: tmp = T1;
! 2129: T1 = T2 & 0xffffffffUL;
! 2130: helper_st_asi(PARAM1, 4);
! 2131: T1 = tmp;
! 2132: }
! 2133: T1 &= 0xffffffffUL;
! 2134: }
! 2135:
! 2136: void OPPROTO op_cas_asi_reg() /* XXX: should be atomically */
! 2137: {
! 2138: target_ulong tmp;
! 2139:
! 2140: T0 += PARAM1;
! 2141: tmp = T1 & 0xffffffffUL;
! 2142: helper_ld_asi(env->asi, 4, 0);
! 2143: if (tmp == T1) {
! 2144: tmp = T1;
! 2145: T1 = T2 & 0xffffffffUL;
! 2146: helper_st_asi(env->asi, 4);
! 2147: T1 = tmp;
! 2148: }
! 2149: T1 &= 0xffffffffUL;
! 2150: }
! 2151:
! 2152: void OPPROTO op_casx_asi() /* XXX: should be atomically */
! 2153: {
! 2154: target_ulong tmp;
! 2155:
! 2156: tmp = T1;
! 2157: helper_ld_asi(PARAM1, 8, 0);
! 2158: if (tmp == T1) {
! 2159: tmp = T1;
! 2160: T1 = T2;
! 2161: helper_st_asi(PARAM1, 8);
! 2162: T1 = tmp;
! 2163: }
! 2164: }
! 2165:
! 2166: void OPPROTO op_casx_asi_reg() /* XXX: should be atomically */
! 2167: {
! 2168: target_ulong tmp;
! 2169:
! 2170: T0 += PARAM1;
! 2171: tmp = T1;
! 2172: helper_ld_asi(env->asi, 8, 0);
! 2173: if (tmp == T1) {
! 2174: tmp = T1;
! 2175: T1 = T2;
! 2176: helper_st_asi(env->asi, 8);
! 2177: T1 = tmp;
! 2178: }
1.1 root 2179: }
2180: #endif
2181:
1.1.1.6 ! root 2182: #if !defined(CONFIG_USER_ONLY) || defined(TARGET_SPARC64)
1.1 root 2183: void OPPROTO op_ld_asi()
2184: {
2185: helper_ld_asi(PARAM1, PARAM2, PARAM3);
2186: }
2187:
2188: void OPPROTO op_st_asi()
2189: {
1.1.1.6 ! root 2190: helper_st_asi(PARAM1, PARAM2);
! 2191: }
! 2192:
! 2193: void OPPROTO op_ldstub_asi() /* XXX: should be atomically */
! 2194: {
! 2195: target_ulong tmp;
! 2196:
! 2197: helper_ld_asi(PARAM1, 1, 0);
! 2198: tmp = T1;
! 2199: T1 = 0xff;
! 2200: helper_st_asi(PARAM1, 1);
! 2201: T1 = tmp;
! 2202: }
! 2203:
! 2204: void OPPROTO op_swap_asi() /* XXX: should be atomically */
! 2205: {
! 2206: target_ulong tmp1, tmp2;
! 2207:
! 2208: tmp1 = T1;
! 2209: helper_ld_asi(PARAM1, 4, 0);
! 2210: tmp2 = T1;
! 2211: T1 = tmp1;
! 2212: helper_st_asi(PARAM1, 4);
! 2213: T1 = tmp2;
1.1 root 2214: }
1.1.1.6 ! root 2215: #endif
1.1 root 2216:
1.1.1.4 root 2217: #ifdef TARGET_SPARC64
1.1.1.6 ! root 2218: // This function uses non-native bit order
! 2219: #define GET_FIELD(X, FROM, TO) \
! 2220: ((X) >> (63 - (TO)) & ((1ULL << ((TO) - (FROM) + 1)) - 1))
! 2221:
! 2222: // This function uses the order in the manuals, i.e. bit 0 is 2^0
! 2223: #define GET_FIELD_SP(X, FROM, TO) \
! 2224: GET_FIELD(X, 63 - (TO), 63 - (FROM))
! 2225:
! 2226: void OPPROTO op_array8()
! 2227: {
! 2228: T0 = (GET_FIELD_SP(T0, 60, 63) << (17 + 2 * T1)) |
! 2229: (GET_FIELD_SP(T0, 39, 39 + T1 - 1) << (17 + T1)) |
! 2230: (GET_FIELD_SP(T0, 17 + T1 - 1, 17) << 17) |
! 2231: (GET_FIELD_SP(T0, 56, 59) << 13) | (GET_FIELD_SP(T0, 35, 38) << 9) |
! 2232: (GET_FIELD_SP(T0, 13, 16) << 5) | (((T0 >> 55) & 1) << 4) |
! 2233: (GET_FIELD_SP(T0, 33, 34) << 2) | GET_FIELD_SP(T0, 11, 12);
! 2234: }
! 2235:
! 2236: void OPPROTO op_array16()
! 2237: {
! 2238: T0 = ((GET_FIELD_SP(T0, 60, 63) << (17 + 2 * T1)) |
! 2239: (GET_FIELD_SP(T0, 39, 39 + T1 - 1) << (17 + T1)) |
! 2240: (GET_FIELD_SP(T0, 17 + T1 - 1, 17) << 17) |
! 2241: (GET_FIELD_SP(T0, 56, 59) << 13) | (GET_FIELD_SP(T0, 35, 38) << 9) |
! 2242: (GET_FIELD_SP(T0, 13, 16) << 5) | (((T0 >> 55) & 1) << 4) |
! 2243: (GET_FIELD_SP(T0, 33, 34) << 2) | GET_FIELD_SP(T0, 11, 12)) << 1;
! 2244: }
! 2245:
! 2246: void OPPROTO op_array32()
! 2247: {
! 2248: T0 = ((GET_FIELD_SP(T0, 60, 63) << (17 + 2 * T1)) |
! 2249: (GET_FIELD_SP(T0, 39, 39 + T1 - 1) << (17 + T1)) |
! 2250: (GET_FIELD_SP(T0, 17 + T1 - 1, 17) << 17) |
! 2251: (GET_FIELD_SP(T0, 56, 59) << 13) | (GET_FIELD_SP(T0, 35, 38) << 9) |
! 2252: (GET_FIELD_SP(T0, 13, 16) << 5) | (((T0 >> 55) & 1) << 4) |
! 2253: (GET_FIELD_SP(T0, 33, 34) << 2) | GET_FIELD_SP(T0, 11, 12)) << 2;
! 2254: }
! 2255:
1.1.1.4 root 2256: void OPPROTO op_alignaddr()
2257: {
2258: uint64_t tmp;
2259:
2260: tmp = T0 + T1;
2261: env->gsr &= ~7ULL;
2262: env->gsr |= tmp & 7ULL;
2263: T0 = tmp & ~7ULL;
2264: }
2265:
2266: void OPPROTO op_faligndata()
2267: {
2268: uint64_t tmp;
2269:
2270: tmp = (*((uint64_t *)&DT0)) << ((env->gsr & 7) * 8);
2271: tmp |= (*((uint64_t *)&DT1)) >> (64 - (env->gsr & 7) * 8);
1.1.1.6 ! root 2272: *((uint64_t *)&DT0) = tmp;
! 2273: }
! 2274:
! 2275: void OPPROTO op_movl_FT0_0(void)
! 2276: {
! 2277: *((uint32_t *)&FT0) = 0;
! 2278: }
! 2279:
! 2280: void OPPROTO op_movl_DT0_0(void)
! 2281: {
! 2282: *((uint64_t *)&DT0) = 0;
! 2283: }
! 2284:
! 2285: void OPPROTO op_movl_FT0_1(void)
! 2286: {
! 2287: *((uint32_t *)&FT0) = 0xffffffff;
1.1.1.4 root 2288: }
1.1.1.6 ! root 2289:
! 2290: void OPPROTO op_movl_DT0_1(void)
! 2291: {
! 2292: *((uint64_t *)&DT0) = 0xffffffffffffffffULL;
! 2293: }
! 2294:
! 2295: void OPPROTO op_fnot(void)
! 2296: {
! 2297: *(uint64_t *)&DT0 = ~*(uint64_t *)&DT1;
! 2298: }
! 2299:
! 2300: void OPPROTO op_fnots(void)
! 2301: {
! 2302: *(uint32_t *)&FT0 = ~*(uint32_t *)&FT1;
! 2303: }
! 2304:
! 2305: void OPPROTO op_fnor(void)
! 2306: {
! 2307: *(uint64_t *)&DT0 = ~(*(uint64_t *)&DT0 | *(uint64_t *)&DT1);
! 2308: }
! 2309:
! 2310: void OPPROTO op_fnors(void)
! 2311: {
! 2312: *(uint32_t *)&FT0 = ~(*(uint32_t *)&FT0 | *(uint32_t *)&FT1);
! 2313: }
! 2314:
! 2315: void OPPROTO op_for(void)
! 2316: {
! 2317: *(uint64_t *)&DT0 |= *(uint64_t *)&DT1;
! 2318: }
! 2319:
! 2320: void OPPROTO op_fors(void)
! 2321: {
! 2322: *(uint32_t *)&FT0 |= *(uint32_t *)&FT1;
! 2323: }
! 2324:
! 2325: void OPPROTO op_fxor(void)
! 2326: {
! 2327: *(uint64_t *)&DT0 ^= *(uint64_t *)&DT1;
! 2328: }
! 2329:
! 2330: void OPPROTO op_fxors(void)
! 2331: {
! 2332: *(uint32_t *)&FT0 ^= *(uint32_t *)&FT1;
! 2333: }
! 2334:
! 2335: void OPPROTO op_fand(void)
! 2336: {
! 2337: *(uint64_t *)&DT0 &= *(uint64_t *)&DT1;
! 2338: }
! 2339:
! 2340: void OPPROTO op_fands(void)
! 2341: {
! 2342: *(uint32_t *)&FT0 &= *(uint32_t *)&FT1;
! 2343: }
! 2344:
! 2345: void OPPROTO op_fornot(void)
! 2346: {
! 2347: *(uint64_t *)&DT0 = *(uint64_t *)&DT0 | ~*(uint64_t *)&DT1;
! 2348: }
! 2349:
! 2350: void OPPROTO op_fornots(void)
! 2351: {
! 2352: *(uint32_t *)&FT0 = *(uint32_t *)&FT0 | ~*(uint32_t *)&FT1;
! 2353: }
! 2354:
! 2355: void OPPROTO op_fandnot(void)
! 2356: {
! 2357: *(uint64_t *)&DT0 = *(uint64_t *)&DT0 & ~*(uint64_t *)&DT1;
! 2358: }
! 2359:
! 2360: void OPPROTO op_fandnots(void)
! 2361: {
! 2362: *(uint32_t *)&FT0 = *(uint32_t *)&FT0 & ~*(uint32_t *)&FT1;
! 2363: }
! 2364:
! 2365: void OPPROTO op_fnand(void)
! 2366: {
! 2367: *(uint64_t *)&DT0 = ~(*(uint64_t *)&DT0 & *(uint64_t *)&DT1);
! 2368: }
! 2369:
! 2370: void OPPROTO op_fnands(void)
! 2371: {
! 2372: *(uint32_t *)&FT0 = ~(*(uint32_t *)&FT0 & *(uint32_t *)&FT1);
! 2373: }
! 2374:
! 2375: void OPPROTO op_fxnor(void)
! 2376: {
! 2377: *(uint64_t *)&DT0 ^= ~*(uint64_t *)&DT1;
! 2378: }
! 2379:
! 2380: void OPPROTO op_fxnors(void)
! 2381: {
! 2382: *(uint32_t *)&FT0 ^= ~*(uint32_t *)&FT1;
! 2383: }
! 2384:
! 2385: #ifdef WORDS_BIGENDIAN
! 2386: #define VIS_B64(n) b[7 - (n)]
! 2387: #define VIS_W64(n) w[3 - (n)]
! 2388: #define VIS_SW64(n) sw[3 - (n)]
! 2389: #define VIS_L64(n) l[1 - (n)]
! 2390: #define VIS_B32(n) b[3 - (n)]
! 2391: #define VIS_W32(n) w[1 - (n)]
! 2392: #else
! 2393: #define VIS_B64(n) b[n]
! 2394: #define VIS_W64(n) w[n]
! 2395: #define VIS_SW64(n) sw[n]
! 2396: #define VIS_L64(n) l[n]
! 2397: #define VIS_B32(n) b[n]
! 2398: #define VIS_W32(n) w[n]
! 2399: #endif
! 2400:
! 2401: typedef union {
! 2402: uint8_t b[8];
! 2403: uint16_t w[4];
! 2404: int16_t sw[4];
! 2405: uint32_t l[2];
! 2406: float64 d;
! 2407: } vis64;
! 2408:
! 2409: typedef union {
! 2410: uint8_t b[4];
! 2411: uint16_t w[2];
! 2412: uint32_t l;
! 2413: float32 f;
! 2414: } vis32;
! 2415:
! 2416: void OPPROTO op_fpmerge(void)
! 2417: {
! 2418: vis64 s, d;
! 2419:
! 2420: s.d = DT0;
! 2421: d.d = DT1;
! 2422:
! 2423: // Reverse calculation order to handle overlap
! 2424: d.VIS_B64(7) = s.VIS_B64(3);
! 2425: d.VIS_B64(6) = d.VIS_B64(3);
! 2426: d.VIS_B64(5) = s.VIS_B64(2);
! 2427: d.VIS_B64(4) = d.VIS_B64(2);
! 2428: d.VIS_B64(3) = s.VIS_B64(1);
! 2429: d.VIS_B64(2) = d.VIS_B64(1);
! 2430: d.VIS_B64(1) = s.VIS_B64(0);
! 2431: //d.VIS_B64(0) = d.VIS_B64(0);
! 2432:
! 2433: DT0 = d.d;
! 2434: }
! 2435:
! 2436: void OPPROTO op_fmul8x16(void)
! 2437: {
! 2438: vis64 s, d;
! 2439: uint32_t tmp;
! 2440:
! 2441: s.d = DT0;
! 2442: d.d = DT1;
! 2443:
! 2444: #define PMUL(r) \
! 2445: tmp = (int32_t)d.VIS_SW64(r) * (int32_t)s.VIS_B64(r); \
! 2446: if ((tmp & 0xff) > 0x7f) \
! 2447: tmp += 0x100; \
! 2448: d.VIS_W64(r) = tmp >> 8;
! 2449:
! 2450: PMUL(0);
! 2451: PMUL(1);
! 2452: PMUL(2);
! 2453: PMUL(3);
! 2454: #undef PMUL
! 2455:
! 2456: DT0 = d.d;
! 2457: }
! 2458:
! 2459: void OPPROTO op_fmul8x16al(void)
! 2460: {
! 2461: vis64 s, d;
! 2462: uint32_t tmp;
! 2463:
! 2464: s.d = DT0;
! 2465: d.d = DT1;
! 2466:
! 2467: #define PMUL(r) \
! 2468: tmp = (int32_t)d.VIS_SW64(1) * (int32_t)s.VIS_B64(r); \
! 2469: if ((tmp & 0xff) > 0x7f) \
! 2470: tmp += 0x100; \
! 2471: d.VIS_W64(r) = tmp >> 8;
! 2472:
! 2473: PMUL(0);
! 2474: PMUL(1);
! 2475: PMUL(2);
! 2476: PMUL(3);
! 2477: #undef PMUL
! 2478:
! 2479: DT0 = d.d;
! 2480: }
! 2481:
! 2482: void OPPROTO op_fmul8x16au(void)
! 2483: {
! 2484: vis64 s, d;
! 2485: uint32_t tmp;
! 2486:
! 2487: s.d = DT0;
! 2488: d.d = DT1;
! 2489:
! 2490: #define PMUL(r) \
! 2491: tmp = (int32_t)d.VIS_SW64(0) * (int32_t)s.VIS_B64(r); \
! 2492: if ((tmp & 0xff) > 0x7f) \
! 2493: tmp += 0x100; \
! 2494: d.VIS_W64(r) = tmp >> 8;
! 2495:
! 2496: PMUL(0);
! 2497: PMUL(1);
! 2498: PMUL(2);
! 2499: PMUL(3);
! 2500: #undef PMUL
! 2501:
! 2502: DT0 = d.d;
! 2503: }
! 2504:
! 2505: void OPPROTO op_fmul8sux16(void)
! 2506: {
! 2507: vis64 s, d;
! 2508: uint32_t tmp;
! 2509:
! 2510: s.d = DT0;
! 2511: d.d = DT1;
! 2512:
! 2513: #define PMUL(r) \
! 2514: tmp = (int32_t)d.VIS_SW64(r) * ((int32_t)s.VIS_SW64(r) >> 8); \
! 2515: if ((tmp & 0xff) > 0x7f) \
! 2516: tmp += 0x100; \
! 2517: d.VIS_W64(r) = tmp >> 8;
! 2518:
! 2519: PMUL(0);
! 2520: PMUL(1);
! 2521: PMUL(2);
! 2522: PMUL(3);
! 2523: #undef PMUL
! 2524:
! 2525: DT0 = d.d;
! 2526: }
! 2527:
! 2528: void OPPROTO op_fmul8ulx16(void)
! 2529: {
! 2530: vis64 s, d;
! 2531: uint32_t tmp;
! 2532:
! 2533: s.d = DT0;
! 2534: d.d = DT1;
! 2535:
! 2536: #define PMUL(r) \
! 2537: tmp = (int32_t)d.VIS_SW64(r) * ((uint32_t)s.VIS_B64(r * 2)); \
! 2538: if ((tmp & 0xff) > 0x7f) \
! 2539: tmp += 0x100; \
! 2540: d.VIS_W64(r) = tmp >> 8;
! 2541:
! 2542: PMUL(0);
! 2543: PMUL(1);
! 2544: PMUL(2);
! 2545: PMUL(3);
! 2546: #undef PMUL
! 2547:
! 2548: DT0 = d.d;
! 2549: }
! 2550:
! 2551: void OPPROTO op_fmuld8sux16(void)
! 2552: {
! 2553: vis64 s, d;
! 2554: uint32_t tmp;
! 2555:
! 2556: s.d = DT0;
! 2557: d.d = DT1;
! 2558:
! 2559: #define PMUL(r) \
! 2560: tmp = (int32_t)d.VIS_SW64(r) * ((int32_t)s.VIS_SW64(r) >> 8); \
! 2561: if ((tmp & 0xff) > 0x7f) \
! 2562: tmp += 0x100; \
! 2563: d.VIS_L64(r) = tmp;
! 2564:
! 2565: // Reverse calculation order to handle overlap
! 2566: PMUL(1);
! 2567: PMUL(0);
! 2568: #undef PMUL
! 2569:
! 2570: DT0 = d.d;
! 2571: }
! 2572:
! 2573: void OPPROTO op_fmuld8ulx16(void)
! 2574: {
! 2575: vis64 s, d;
! 2576: uint32_t tmp;
! 2577:
! 2578: s.d = DT0;
! 2579: d.d = DT1;
! 2580:
! 2581: #define PMUL(r) \
! 2582: tmp = (int32_t)d.VIS_SW64(r) * ((uint32_t)s.VIS_B64(r * 2)); \
! 2583: if ((tmp & 0xff) > 0x7f) \
! 2584: tmp += 0x100; \
! 2585: d.VIS_L64(r) = tmp;
! 2586:
! 2587: // Reverse calculation order to handle overlap
! 2588: PMUL(1);
! 2589: PMUL(0);
! 2590: #undef PMUL
! 2591:
! 2592: DT0 = d.d;
! 2593: }
! 2594:
! 2595: void OPPROTO op_fexpand(void)
! 2596: {
! 2597: vis32 s;
! 2598: vis64 d;
! 2599:
! 2600: s.l = (uint32_t)(*(uint64_t *)&DT0 & 0xffffffff);
! 2601: d.d = DT1;
! 2602: d.VIS_L64(0) = s.VIS_W32(0) << 4;
! 2603: d.VIS_L64(1) = s.VIS_W32(1) << 4;
! 2604: d.VIS_L64(2) = s.VIS_W32(2) << 4;
! 2605: d.VIS_L64(3) = s.VIS_W32(3) << 4;
! 2606:
! 2607: DT0 = d.d;
! 2608: }
! 2609:
! 2610: #define VIS_OP(name, F) \
! 2611: void OPPROTO name##16(void) \
! 2612: { \
! 2613: vis64 s, d; \
! 2614: \
! 2615: s.d = DT0; \
! 2616: d.d = DT1; \
! 2617: \
! 2618: d.VIS_W64(0) = F(d.VIS_W64(0), s.VIS_W64(0)); \
! 2619: d.VIS_W64(1) = F(d.VIS_W64(1), s.VIS_W64(1)); \
! 2620: d.VIS_W64(2) = F(d.VIS_W64(2), s.VIS_W64(2)); \
! 2621: d.VIS_W64(3) = F(d.VIS_W64(3), s.VIS_W64(3)); \
! 2622: \
! 2623: DT0 = d.d; \
! 2624: } \
! 2625: \
! 2626: void OPPROTO name##16s(void) \
! 2627: { \
! 2628: vis32 s, d; \
! 2629: \
! 2630: s.f = FT0; \
! 2631: d.f = FT1; \
! 2632: \
! 2633: d.VIS_W32(0) = F(d.VIS_W32(0), s.VIS_W32(0)); \
! 2634: d.VIS_W32(1) = F(d.VIS_W32(1), s.VIS_W32(1)); \
! 2635: \
! 2636: FT0 = d.f; \
! 2637: } \
! 2638: \
! 2639: void OPPROTO name##32(void) \
! 2640: { \
! 2641: vis64 s, d; \
! 2642: \
! 2643: s.d = DT0; \
! 2644: d.d = DT1; \
! 2645: \
! 2646: d.VIS_L64(0) = F(d.VIS_L64(0), s.VIS_L64(0)); \
! 2647: d.VIS_L64(1) = F(d.VIS_L64(1), s.VIS_L64(1)); \
! 2648: \
! 2649: DT0 = d.d; \
! 2650: } \
! 2651: \
! 2652: void OPPROTO name##32s(void) \
! 2653: { \
! 2654: vis32 s, d; \
! 2655: \
! 2656: s.f = FT0; \
! 2657: d.f = FT1; \
! 2658: \
! 2659: d.l = F(d.l, s.l); \
! 2660: \
! 2661: FT0 = d.f; \
! 2662: }
! 2663:
! 2664: #define FADD(a, b) ((a) + (b))
! 2665: #define FSUB(a, b) ((a) - (b))
! 2666: VIS_OP(op_fpadd, FADD)
! 2667: VIS_OP(op_fpsub, FSUB)
! 2668:
! 2669: #define VIS_CMPOP(name, F) \
! 2670: void OPPROTO name##16(void) \
! 2671: { \
! 2672: vis64 s, d; \
! 2673: \
! 2674: s.d = DT0; \
! 2675: d.d = DT1; \
! 2676: \
! 2677: d.VIS_W64(0) = F(d.VIS_W64(0), s.VIS_W64(0))? 1: 0; \
! 2678: d.VIS_W64(0) |= F(d.VIS_W64(1), s.VIS_W64(1))? 2: 0; \
! 2679: d.VIS_W64(0) |= F(d.VIS_W64(2), s.VIS_W64(2))? 4: 0; \
! 2680: d.VIS_W64(0) |= F(d.VIS_W64(3), s.VIS_W64(3))? 8: 0; \
! 2681: \
! 2682: DT0 = d.d; \
! 2683: } \
! 2684: \
! 2685: void OPPROTO name##32(void) \
! 2686: { \
! 2687: vis64 s, d; \
! 2688: \
! 2689: s.d = DT0; \
! 2690: d.d = DT1; \
! 2691: \
! 2692: d.VIS_L64(0) = F(d.VIS_L64(0), s.VIS_L64(0))? 1: 0; \
! 2693: d.VIS_L64(0) |= F(d.VIS_L64(1), s.VIS_L64(1))? 2: 0; \
! 2694: \
! 2695: DT0 = d.d; \
! 2696: }
! 2697:
! 2698: #define FCMPGT(a, b) ((a) > (b))
! 2699: #define FCMPEQ(a, b) ((a) == (b))
! 2700: #define FCMPLE(a, b) ((a) <= (b))
! 2701: #define FCMPNE(a, b) ((a) != (b))
! 2702:
! 2703: VIS_CMPOP(op_fcmpgt, FCMPGT)
! 2704: VIS_CMPOP(op_fcmpeq, FCMPEQ)
! 2705: VIS_CMPOP(op_fcmple, FCMPLE)
! 2706: VIS_CMPOP(op_fcmpne, FCMPNE)
! 2707:
1.1.1.4 root 2708: #endif
1.1.1.6 ! root 2709:
! 2710: #define CHECK_ALIGN_OP(align) \
! 2711: void OPPROTO op_check_align_T0_ ## align (void) \
! 2712: { \
! 2713: if (T0 & align) \
! 2714: raise_exception(TT_UNALIGNED); \
! 2715: FORCE_RET(); \
! 2716: }
! 2717:
! 2718: CHECK_ALIGN_OP(1)
! 2719: CHECK_ALIGN_OP(3)
! 2720: CHECK_ALIGN_OP(7)
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.