![[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;\
290: })
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))
379: env->psr |= PSR_ZERO;
380: if ((int32_t) T0 < 0)
381: env->psr |= PSR_NEG;
1.1.1.2 root 382: if ((T0 & 0xffffffff) < (src1 & 0xffffffff))
1.1 root 383: env->psr |= PSR_CARRY;
384: if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff) ^ -1) &
385: ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
386: env->psr |= PSR_OVF;
387:
388: env->xcc = 0;
389: if (!T0)
390: env->xcc |= PSR_ZERO;
391: if ((int64_t) T0 < 0)
392: env->xcc |= PSR_NEG;
393: if (T0 < src1)
394: env->xcc |= PSR_CARRY;
395: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1ULL << 63))
396: env->xcc |= PSR_OVF;
397: #else
398: if (!T0)
399: env->psr |= PSR_ZERO;
400: if ((int32_t) T0 < 0)
401: env->psr |= PSR_NEG;
402: if (T0 < src1)
403: env->psr |= PSR_CARRY;
404: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
405: env->psr |= PSR_OVF;
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))
451: env->psr |= PSR_ZERO;
452: if ((int32_t) T0 < 0)
453: env->psr |= PSR_NEG;
454: if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff) ^ -1) &
455: ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
456: env->psr |= PSR_OVF;
457:
458: if (!T0)
459: env->xcc |= PSR_ZERO;
460: if ((int64_t) T0 < 0)
461: env->xcc |= PSR_NEG;
462: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1ULL << 63))
463: env->xcc |= PSR_OVF;
464: #else
465: if (!T0)
466: env->psr |= PSR_ZERO;
467: if ((int32_t) T0 < 0)
468: env->psr |= PSR_NEG;
469: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
470: env->psr |= PSR_OVF;
471: #endif
472: FORCE_RET();
473: }
474:
475: void OPPROTO op_sub_T1_T0(void)
476: {
477: T0 -= T1;
478: }
479:
480: void OPPROTO op_sub_T1_T0_cc(void)
481: {
482: target_ulong src1;
483:
484: src1 = T0;
485: T0 -= T1;
486: env->psr = 0;
487: #ifdef TARGET_SPARC64
488: if (!(T0 & 0xffffffff))
489: env->psr |= PSR_ZERO;
490: if ((int32_t) T0 < 0)
491: env->psr |= PSR_NEG;
492: if ((src1 & 0xffffffff) < (T1 & 0xffffffff))
493: env->psr |= PSR_CARRY;
494: if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff)) &
495: ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
496: env->psr |= PSR_OVF;
497:
498: env->xcc = 0;
499: if (!T0)
500: env->xcc |= PSR_ZERO;
501: if ((int64_t) T0 < 0)
502: env->xcc |= PSR_NEG;
1.1.1.2 root 503: if (src1 < T1)
1.1 root 504: env->xcc |= PSR_CARRY;
505: if (((src1 ^ T1) & (src1 ^ T0)) & (1ULL << 63))
506: env->xcc |= PSR_OVF;
507: #else
508: if (!T0)
509: env->psr |= PSR_ZERO;
510: if ((int32_t) T0 < 0)
511: env->psr |= PSR_NEG;
512: if (src1 < T1)
513: env->psr |= PSR_CARRY;
514: if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31))
515: env->psr |= PSR_OVF;
516: #endif
517: FORCE_RET();
518: }
519:
520: void OPPROTO op_subx_T1_T0(void)
521: {
522: T0 -= T1 + FLAG_SET(PSR_CARRY);
523: }
524:
525: void OPPROTO op_subx_T1_T0_cc(void)
526: {
527: target_ulong src1;
528: src1 = T0;
1.1.1.3 root 529: if (FLAG_SET(PSR_CARRY))
530: {
531: T0 -= T1 + 1;
532: env->psr = 0;
533: #ifdef TARGET_SPARC64
534: if ((src1 & 0xffffffff) <= (T1 & 0xffffffff))
535: env->psr |= PSR_CARRY;
536: env->xcc = 0;
537: if (src1 <= T1)
538: env->xcc |= PSR_CARRY;
539: #else
540: if (src1 <= T1)
541: env->psr |= PSR_CARRY;
542: #endif
543: }
544: else
545: {
546: T0 -= T1;
547: env->psr = 0;
548: #ifdef TARGET_SPARC64
549: if ((src1 & 0xffffffff) < (T1 & 0xffffffff))
550: env->psr |= PSR_CARRY;
551: env->xcc = 0;
552: if (src1 < T1)
553: env->xcc |= PSR_CARRY;
554: #else
555: if (src1 < T1)
556: env->psr |= PSR_CARRY;
557: #endif
558: }
1.1 root 559: #ifdef TARGET_SPARC64
560: if (!(T0 & 0xffffffff))
561: env->psr |= PSR_ZERO;
562: if ((int32_t) T0 < 0)
563: env->psr |= PSR_NEG;
564: if ((((src1 & 0xffffffff) ^ (T1 & 0xffffffff)) &
565: ((src1 & 0xffffffff) ^ (T0 & 0xffffffff))) & (1 << 31))
566: env->psr |= PSR_OVF;
567:
568: if (!T0)
569: env->xcc |= PSR_ZERO;
570: if ((int64_t) T0 < 0)
571: env->xcc |= PSR_NEG;
572: if (((src1 ^ T1) & (src1 ^ T0)) & (1ULL << 63))
573: env->xcc |= PSR_OVF;
574: #else
575: if (!T0)
576: env->psr |= PSR_ZERO;
577: if ((int32_t) T0 < 0)
578: env->psr |= PSR_NEG;
579: if (((src1 ^ T1) & (src1 ^ T0)) & (1 << 31))
580: env->psr |= PSR_OVF;
581: #endif
582: FORCE_RET();
583: }
584:
585: void OPPROTO op_and_T1_T0(void)
586: {
587: T0 &= T1;
588: }
589:
590: void OPPROTO op_or_T1_T0(void)
591: {
592: T0 |= T1;
593: }
594:
595: void OPPROTO op_xor_T1_T0(void)
596: {
597: T0 ^= T1;
598: }
599:
600: void OPPROTO op_andn_T1_T0(void)
601: {
602: T0 &= ~T1;
603: }
604:
605: void OPPROTO op_orn_T1_T0(void)
606: {
607: T0 |= ~T1;
608: }
609:
610: void OPPROTO op_xnor_T1_T0(void)
611: {
612: T0 ^= ~T1;
613: }
614:
615: void OPPROTO op_umul_T1_T0(void)
616: {
617: uint64_t res;
618: res = (uint64_t) T0 * (uint64_t) T1;
619: #ifdef TARGET_SPARC64
620: T0 = res;
621: #else
622: T0 = res & 0xffffffff;
623: #endif
624: env->y = res >> 32;
625: }
626:
627: void OPPROTO op_smul_T1_T0(void)
628: {
629: uint64_t res;
630: res = (int64_t) ((int32_t) T0) * (int64_t) ((int32_t) T1);
631: #ifdef TARGET_SPARC64
632: T0 = res;
633: #else
634: T0 = res & 0xffffffff;
635: #endif
636: env->y = res >> 32;
637: }
638:
639: void OPPROTO op_mulscc_T1_T0(void)
640: {
641: unsigned int b1, N, V, b2;
642: target_ulong src1;
643:
644: N = FLAG_SET(PSR_NEG);
645: V = FLAG_SET(PSR_OVF);
646: b1 = N ^ V;
647: b2 = T0 & 1;
648: T0 = (b1 << 31) | (T0 >> 1);
649: if (!(env->y & 1))
650: T1 = 0;
651: /* do addition and update flags */
652: src1 = T0;
653: T0 += T1;
654: env->psr = 0;
655: if (!T0)
656: env->psr |= PSR_ZERO;
657: if ((int32_t) T0 < 0)
658: env->psr |= PSR_NEG;
659: if (T0 < src1)
660: env->psr |= PSR_CARRY;
661: if (((src1 ^ T1 ^ -1) & (src1 ^ T0)) & (1 << 31))
662: env->psr |= PSR_OVF;
663: env->y = (b2 << 31) | (env->y >> 1);
664: FORCE_RET();
665: }
666:
667: void OPPROTO op_udiv_T1_T0(void)
668: {
669: uint64_t x0;
670: uint32_t x1;
671:
672: x0 = T0 | ((uint64_t) (env->y) << 32);
673: x1 = T1;
674: x0 = x0 / x1;
675: if (x0 > 0xffffffff) {
676: T0 = 0xffffffff;
677: T1 = 1;
678: } else {
679: T0 = x0;
680: T1 = 0;
681: }
682: FORCE_RET();
683: }
684:
685: void OPPROTO op_sdiv_T1_T0(void)
686: {
687: int64_t x0;
688: int32_t x1;
689:
690: x0 = T0 | ((int64_t) (env->y) << 32);
691: x1 = T1;
692: x0 = x0 / x1;
693: if ((int32_t) x0 != x0) {
694: T0 = x0 < 0? 0x80000000: 0x7fffffff;
695: T1 = 1;
696: } else {
697: T0 = x0;
698: T1 = 0;
699: }
700: FORCE_RET();
701: }
702:
703: void OPPROTO op_div_cc(void)
704: {
705: env->psr = 0;
706: #ifdef TARGET_SPARC64
707: if (!T0)
708: env->psr |= PSR_ZERO;
709: if ((int32_t) T0 < 0)
710: env->psr |= PSR_NEG;
711: if (T1)
712: env->psr |= PSR_OVF;
713:
714: env->xcc = 0;
715: if (!T0)
716: env->xcc |= PSR_ZERO;
717: if ((int64_t) T0 < 0)
718: env->xcc |= PSR_NEG;
719: #else
720: if (!T0)
721: env->psr |= PSR_ZERO;
722: if ((int32_t) T0 < 0)
723: env->psr |= PSR_NEG;
724: if (T1)
725: env->psr |= PSR_OVF;
726: #endif
727: FORCE_RET();
728: }
729:
730: #ifdef TARGET_SPARC64
731: void OPPROTO op_mulx_T1_T0(void)
732: {
733: T0 *= T1;
734: FORCE_RET();
735: }
736:
737: void OPPROTO op_udivx_T1_T0(void)
738: {
739: T0 /= T1;
740: FORCE_RET();
741: }
742:
743: void OPPROTO op_sdivx_T1_T0(void)
744: {
745: if (T0 == INT64_MIN && T1 == -1)
746: T0 = INT64_MIN;
747: else
748: T0 /= (target_long) T1;
749: FORCE_RET();
750: }
751: #endif
752:
753: void OPPROTO op_logic_T0_cc(void)
754: {
755: env->psr = 0;
756: #ifdef TARGET_SPARC64
757: if (!(T0 & 0xffffffff))
758: env->psr |= PSR_ZERO;
759: if ((int32_t) T0 < 0)
760: env->psr |= PSR_NEG;
761:
762: env->xcc = 0;
763: if (!T0)
764: env->xcc |= PSR_ZERO;
765: if ((int64_t) T0 < 0)
766: env->xcc |= PSR_NEG;
767: #else
768: if (!T0)
769: env->psr |= PSR_ZERO;
770: if ((int32_t) T0 < 0)
771: env->psr |= PSR_NEG;
772: #endif
773: FORCE_RET();
774: }
775:
776: void OPPROTO op_sll(void)
777: {
778: T0 <<= T1;
779: }
780:
781: #ifdef TARGET_SPARC64
782: void OPPROTO op_srl(void)
783: {
784: T0 = (T0 & 0xffffffff) >> T1;
785: }
786:
787: void OPPROTO op_srlx(void)
788: {
789: T0 >>= T1;
790: }
791:
792: void OPPROTO op_sra(void)
793: {
794: T0 = ((int32_t) (T0 & 0xffffffff)) >> T1;
795: }
796:
797: void OPPROTO op_srax(void)
798: {
799: T0 = ((int64_t) T0) >> T1;
800: }
801: #else
802: void OPPROTO op_srl(void)
803: {
804: T0 >>= T1;
805: }
806:
807: void OPPROTO op_sra(void)
808: {
809: T0 = ((int32_t) T0) >> T1;
810: }
811: #endif
812:
813: /* Load and store */
814: #define MEMSUFFIX _raw
815: #include "op_mem.h"
816: #if !defined(CONFIG_USER_ONLY)
817: #define MEMSUFFIX _user
818: #include "op_mem.h"
819:
820: #define MEMSUFFIX _kernel
821: #include "op_mem.h"
822: #endif
823:
824: void OPPROTO op_ldfsr(void)
825: {
826: PUT_FSR32(env, *((uint32_t *) &FT0));
827: helper_ldfsr();
828: }
829:
830: void OPPROTO op_stfsr(void)
831: {
832: *((uint32_t *) &FT0) = GET_FSR32(env);
833: }
834:
835: #ifndef TARGET_SPARC64
836: void OPPROTO op_rdpsr(void)
837: {
838: do_rdpsr();
839: }
840:
841: void OPPROTO op_wrpsr(void)
842: {
843: do_wrpsr();
844: FORCE_RET();
845: }
846:
847: void OPPROTO op_rett(void)
848: {
849: helper_rett();
850: FORCE_RET();
851: }
852:
853: /* XXX: use another pointer for %iN registers to avoid slow wrapping
854: handling ? */
855: void OPPROTO op_save(void)
856: {
857: uint32_t cwp;
858: cwp = (env->cwp - 1) & (NWINDOWS - 1);
859: if (env->wim & (1 << cwp)) {
860: raise_exception(TT_WIN_OVF);
861: }
862: set_cwp(cwp);
863: FORCE_RET();
864: }
865:
866: void OPPROTO op_restore(void)
867: {
868: uint32_t cwp;
869: cwp = (env->cwp + 1) & (NWINDOWS - 1);
870: if (env->wim & (1 << cwp)) {
871: raise_exception(TT_WIN_UNF);
872: }
873: set_cwp(cwp);
874: FORCE_RET();
875: }
876: #else
877: void OPPROTO op_rdccr(void)
878: {
879: T0 = GET_CCR(env);
880: }
881:
882: void OPPROTO op_wrccr(void)
883: {
884: PUT_CCR(env, T0);
885: }
886:
887: void OPPROTO op_rdtick(void)
888: {
889: T0 = 0; // XXX read cycle counter and bit 31
890: }
891:
892: void OPPROTO op_wrtick(void)
893: {
894: // XXX write cycle counter and bit 31
895: }
896:
897: void OPPROTO op_rdtpc(void)
898: {
899: T0 = env->tpc[env->tl];
900: }
901:
902: void OPPROTO op_wrtpc(void)
903: {
904: env->tpc[env->tl] = T0;
905: }
906:
907: void OPPROTO op_rdtnpc(void)
908: {
909: T0 = env->tnpc[env->tl];
910: }
911:
912: void OPPROTO op_wrtnpc(void)
913: {
914: env->tnpc[env->tl] = T0;
915: }
916:
917: void OPPROTO op_rdtstate(void)
918: {
919: T0 = env->tstate[env->tl];
920: }
921:
922: void OPPROTO op_wrtstate(void)
923: {
924: env->tstate[env->tl] = T0;
925: }
926:
927: void OPPROTO op_rdtt(void)
928: {
929: T0 = env->tt[env->tl];
930: }
931:
932: void OPPROTO op_wrtt(void)
933: {
934: env->tt[env->tl] = T0;
935: }
936:
937: void OPPROTO op_rdpstate(void)
938: {
939: T0 = env->pstate;
940: }
941:
942: void OPPROTO op_wrpstate(void)
943: {
944: do_wrpstate();
945: }
946:
947: // CWP handling is reversed in V9, but we still use the V8 register
948: // order.
949: void OPPROTO op_rdcwp(void)
950: {
951: T0 = NWINDOWS - 1 - env->cwp;
952: }
953:
954: void OPPROTO op_wrcwp(void)
955: {
956: env->cwp = NWINDOWS - 1 - T0;
957: }
958:
959: /* XXX: use another pointer for %iN registers to avoid slow wrapping
960: handling ? */
961: void OPPROTO op_save(void)
962: {
963: uint32_t cwp;
964: cwp = (env->cwp - 1) & (NWINDOWS - 1);
965: if (env->cansave == 0) {
966: raise_exception(TT_SPILL | (env->otherwin != 0 ?
967: (TT_WOTHER | ((env->wstate & 0x38) >> 1)):
968: ((env->wstate & 0x7) << 2)));
969: } else {
970: if (env->cleanwin - env->canrestore == 0) {
971: // XXX Clean windows without trap
972: raise_exception(TT_CLRWIN);
973: } else {
974: env->cansave--;
975: env->canrestore++;
976: set_cwp(cwp);
977: }
978: }
979: FORCE_RET();
980: }
981:
982: void OPPROTO op_restore(void)
983: {
984: uint32_t cwp;
985: cwp = (env->cwp + 1) & (NWINDOWS - 1);
986: if (env->canrestore == 0) {
987: raise_exception(TT_FILL | (env->otherwin != 0 ?
988: (TT_WOTHER | ((env->wstate & 0x38) >> 1)):
989: ((env->wstate & 0x7) << 2)));
990: } else {
991: env->cansave++;
992: env->canrestore--;
993: set_cwp(cwp);
994: }
995: FORCE_RET();
996: }
997: #endif
998:
999: void OPPROTO op_exception(void)
1000: {
1001: env->exception_index = PARAM1;
1002: cpu_loop_exit();
1003: }
1004:
1005: void OPPROTO op_trap_T0(void)
1006: {
1007: env->exception_index = TT_TRAP + (T0 & 0x7f);
1008: cpu_loop_exit();
1009: }
1010:
1011: void OPPROTO op_trapcc_T0(void)
1012: {
1013: if (T2) {
1014: env->exception_index = TT_TRAP + (T0 & 0x7f);
1015: cpu_loop_exit();
1016: }
1017: FORCE_RET();
1018: }
1019:
1020: void OPPROTO op_fpexception_im(void)
1021: {
1022: env->exception_index = TT_FP_EXCP;
1023: env->fsr &= ~FSR_FTT_MASK;
1024: env->fsr |= PARAM1;
1025: cpu_loop_exit();
1026: FORCE_RET();
1027: }
1028:
1029: void OPPROTO op_debug(void)
1030: {
1031: helper_debug();
1032: }
1033:
1034: void OPPROTO op_exit_tb(void)
1035: {
1036: EXIT_TB();
1037: }
1038:
1039: void OPPROTO op_eval_ba(void)
1040: {
1041: T2 = 1;
1042: }
1043:
1044: void OPPROTO op_eval_be(void)
1045: {
1046: T2 = FLAG_SET(PSR_ZERO);
1047: }
1048:
1049: void OPPROTO op_eval_ble(void)
1050: {
1051: target_ulong Z = FLAG_SET(PSR_ZERO), N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
1052:
1053: T2 = Z | (N ^ V);
1054: }
1055:
1056: void OPPROTO op_eval_bl(void)
1057: {
1058: target_ulong N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
1059:
1060: T2 = N ^ V;
1061: }
1062:
1063: void OPPROTO op_eval_bleu(void)
1064: {
1065: target_ulong Z = FLAG_SET(PSR_ZERO), C = FLAG_SET(PSR_CARRY);
1066:
1067: T2 = C | Z;
1068: }
1069:
1070: void OPPROTO op_eval_bcs(void)
1071: {
1072: T2 = FLAG_SET(PSR_CARRY);
1073: }
1074:
1075: void OPPROTO op_eval_bvs(void)
1076: {
1077: T2 = FLAG_SET(PSR_OVF);
1078: }
1079:
1080: void OPPROTO op_eval_bn(void)
1081: {
1082: T2 = 0;
1083: }
1084:
1085: void OPPROTO op_eval_bneg(void)
1086: {
1087: T2 = FLAG_SET(PSR_NEG);
1088: }
1089:
1090: void OPPROTO op_eval_bne(void)
1091: {
1092: T2 = !FLAG_SET(PSR_ZERO);
1093: }
1094:
1095: void OPPROTO op_eval_bg(void)
1096: {
1097: target_ulong Z = FLAG_SET(PSR_ZERO), N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
1098:
1099: T2 = !(Z | (N ^ V));
1100: }
1101:
1102: void OPPROTO op_eval_bge(void)
1103: {
1104: target_ulong N = FLAG_SET(PSR_NEG), V = FLAG_SET(PSR_OVF);
1105:
1106: T2 = !(N ^ V);
1107: }
1108:
1109: void OPPROTO op_eval_bgu(void)
1110: {
1111: target_ulong Z = FLAG_SET(PSR_ZERO), C = FLAG_SET(PSR_CARRY);
1112:
1113: T2 = !(C | Z);
1114: }
1115:
1116: void OPPROTO op_eval_bcc(void)
1117: {
1118: T2 = !FLAG_SET(PSR_CARRY);
1119: }
1120:
1121: void OPPROTO op_eval_bpos(void)
1122: {
1123: T2 = !FLAG_SET(PSR_NEG);
1124: }
1125:
1126: void OPPROTO op_eval_bvc(void)
1127: {
1128: T2 = !FLAG_SET(PSR_OVF);
1129: }
1130:
1131: #ifdef TARGET_SPARC64
1132: void OPPROTO op_eval_xbe(void)
1133: {
1134: T2 = XFLAG_SET(PSR_ZERO);
1135: }
1136:
1137: void OPPROTO op_eval_xble(void)
1138: {
1139: target_ulong Z = XFLAG_SET(PSR_ZERO), N = XFLAG_SET(PSR_NEG), V = XFLAG_SET(PSR_OVF);
1140:
1141: T2 = Z | (N ^ V);
1142: }
1143:
1144: void OPPROTO op_eval_xbl(void)
1145: {
1146: target_ulong N = XFLAG_SET(PSR_NEG), V = XFLAG_SET(PSR_OVF);
1147:
1148: T2 = N ^ V;
1149: }
1150:
1151: void OPPROTO op_eval_xbleu(void)
1152: {
1153: target_ulong Z = XFLAG_SET(PSR_ZERO), C = XFLAG_SET(PSR_CARRY);
1154:
1155: T2 = C | Z;
1156: }
1157:
1158: void OPPROTO op_eval_xbcs(void)
1159: {
1160: T2 = XFLAG_SET(PSR_CARRY);
1161: }
1162:
1163: void OPPROTO op_eval_xbvs(void)
1164: {
1165: T2 = XFLAG_SET(PSR_OVF);
1166: }
1167:
1168: void OPPROTO op_eval_xbneg(void)
1169: {
1170: T2 = XFLAG_SET(PSR_NEG);
1171: }
1172:
1173: void OPPROTO op_eval_xbne(void)
1174: {
1175: T2 = !XFLAG_SET(PSR_ZERO);
1176: }
1177:
1178: void OPPROTO op_eval_xbg(void)
1179: {
1180: target_ulong Z = XFLAG_SET(PSR_ZERO), N = XFLAG_SET(PSR_NEG), V = XFLAG_SET(PSR_OVF);
1181:
1182: T2 = !(Z | (N ^ V));
1183: }
1184:
1185: void OPPROTO op_eval_xbge(void)
1186: {
1187: target_ulong N = XFLAG_SET(PSR_NEG), V = XFLAG_SET(PSR_OVF);
1188:
1189: T2 = !(N ^ V);
1190: }
1191:
1192: void OPPROTO op_eval_xbgu(void)
1193: {
1194: target_ulong Z = XFLAG_SET(PSR_ZERO), C = XFLAG_SET(PSR_CARRY);
1195:
1196: T2 = !(C | Z);
1197: }
1198:
1199: void OPPROTO op_eval_xbcc(void)
1200: {
1201: T2 = !XFLAG_SET(PSR_CARRY);
1202: }
1203:
1204: void OPPROTO op_eval_xbpos(void)
1205: {
1206: T2 = !XFLAG_SET(PSR_NEG);
1207: }
1208:
1209: void OPPROTO op_eval_xbvc(void)
1210: {
1211: T2 = !XFLAG_SET(PSR_OVF);
1212: }
1213: #endif
1214:
1215: #define FCC
1216: #define FFLAG_SET(x) (env->fsr & x? 1: 0)
1217: #include "fbranch_template.h"
1218:
1219: #ifdef TARGET_SPARC64
1220: #define FCC _fcc1
1221: #define FFLAG_SET(x) ((env->fsr & ((uint64_t)x >> 32))? 1: 0)
1222: #include "fbranch_template.h"
1223: #define FCC _fcc2
1224: #define FFLAG_SET(x) ((env->fsr & ((uint64_t)x >> 34))? 1: 0)
1225: #include "fbranch_template.h"
1226: #define FCC _fcc3
1227: #define FFLAG_SET(x) ((env->fsr & ((uint64_t)x >> 36))? 1: 0)
1228: #include "fbranch_template.h"
1229: #endif
1230:
1231: #ifdef TARGET_SPARC64
1232: void OPPROTO op_eval_brz(void)
1233: {
1234: T2 = (T0 == 0);
1235: }
1236:
1237: void OPPROTO op_eval_brnz(void)
1238: {
1239: T2 = (T0 != 0);
1240: }
1241:
1242: void OPPROTO op_eval_brlz(void)
1243: {
1244: T2 = ((int64_t)T0 < 0);
1245: }
1246:
1247: void OPPROTO op_eval_brlez(void)
1248: {
1249: T2 = ((int64_t)T0 <= 0);
1250: }
1251:
1252: void OPPROTO op_eval_brgz(void)
1253: {
1254: T2 = ((int64_t)T0 > 0);
1255: }
1256:
1257: void OPPROTO op_eval_brgez(void)
1258: {
1259: T2 = ((int64_t)T0 >= 0);
1260: }
1261:
1262: void OPPROTO op_jmp_im64(void)
1263: {
1264: env->pc = PARAMQ1;
1265: }
1266:
1267: void OPPROTO op_movq_npc_im64(void)
1268: {
1269: env->npc = PARAMQ1;
1270: }
1271: #endif
1272:
1273: void OPPROTO op_jmp_im(void)
1274: {
1275: env->pc = (uint32_t)PARAM1;
1276: }
1277:
1278: void OPPROTO op_movl_npc_im(void)
1279: {
1280: env->npc = (uint32_t)PARAM1;
1281: }
1282:
1283: void OPPROTO op_movl_npc_T0(void)
1284: {
1285: env->npc = T0;
1286: }
1287:
1288: void OPPROTO op_mov_pc_npc(void)
1289: {
1290: env->pc = env->npc;
1291: }
1292:
1293: void OPPROTO op_next_insn(void)
1294: {
1295: env->pc = env->npc;
1296: env->npc = env->npc + 4;
1297: }
1298:
1299: void OPPROTO op_goto_tb0(void)
1300: {
1301: GOTO_TB(op_goto_tb0, PARAM1, 0);
1302: }
1303:
1304: void OPPROTO op_goto_tb1(void)
1305: {
1306: GOTO_TB(op_goto_tb1, PARAM1, 1);
1307: }
1308:
1309: void OPPROTO op_jmp_label(void)
1310: {
1311: GOTO_LABEL_PARAM(1);
1312: }
1313:
1314: void OPPROTO op_jnz_T2_label(void)
1315: {
1316: if (T2)
1317: GOTO_LABEL_PARAM(1);
1318: FORCE_RET();
1319: }
1320:
1321: void OPPROTO op_jz_T2_label(void)
1322: {
1323: if (!T2)
1324: GOTO_LABEL_PARAM(1);
1325: FORCE_RET();
1326: }
1327:
1328: void OPPROTO op_flush_T0(void)
1329: {
1330: helper_flush(T0);
1331: }
1332:
1.1.1.4 ! root 1333: #define F_OP(name, p) void OPPROTO op_f##name##p(void)
1.1 root 1334:
1.1.1.4 ! root 1335: #define F_BINOP(name) \
! 1336: F_OP(name, s) \
! 1337: { \
! 1338: FT0 = float32_ ## name (FT0, FT1, &env->fp_status); \
! 1339: } \
! 1340: F_OP(name, d) \
! 1341: { \
! 1342: DT0 = float64_ ## name (DT0, DT1, &env->fp_status); \
! 1343: }
1.1 root 1344:
1.1.1.4 ! root 1345: F_BINOP(add);
! 1346: F_BINOP(sub);
! 1347: F_BINOP(mul);
! 1348: F_BINOP(div);
! 1349: #undef F_BINOP
1.1 root 1350:
1351: void OPPROTO op_fsmuld(void)
1352: {
1.1.1.4 ! root 1353: DT0 = float64_mul(float32_to_float64(FT0, &env->fp_status),
! 1354: float32_to_float64(FT1, &env->fp_status),
! 1355: &env->fp_status);
1.1 root 1356: }
1357:
1.1.1.4 ! root 1358: #define F_HELPER(name) \
! 1359: F_OP(name, s) \
! 1360: { \
! 1361: do_f##name##s(); \
! 1362: } \
! 1363: F_OP(name, d) \
! 1364: { \
! 1365: do_f##name##d(); \
! 1366: }
1.1 root 1367:
1.1.1.4 ! root 1368: F_HELPER(sqrt);
1.1 root 1369:
1.1.1.4 ! root 1370: F_OP(neg, s)
1.1 root 1371: {
1.1.1.4 ! root 1372: FT0 = float32_chs(FT1);
1.1 root 1373: }
1374:
1.1.1.4 ! root 1375: F_OP(abs, s)
1.1 root 1376: {
1.1.1.4 ! root 1377: do_fabss();
1.1 root 1378: }
1379:
1.1.1.4 ! root 1380: F_HELPER(cmp);
1.1 root 1381:
1.1.1.4 ! root 1382: #ifdef TARGET_SPARC64
! 1383: F_OP(neg, d)
1.1 root 1384: {
1.1.1.4 ! root 1385: DT0 = float64_chs(DT1);
1.1 root 1386: }
1387:
1.1.1.4 ! root 1388: F_OP(abs, d)
1.1 root 1389: {
1.1.1.4 ! root 1390: do_fabsd();
1.1 root 1391: }
1392:
1393: void OPPROTO op_fcmps_fcc1(void)
1394: {
1395: do_fcmps_fcc1();
1396: }
1397:
1398: void OPPROTO op_fcmpd_fcc1(void)
1399: {
1400: do_fcmpd_fcc1();
1401: }
1402:
1403: void OPPROTO op_fcmps_fcc2(void)
1404: {
1405: do_fcmps_fcc2();
1406: }
1407:
1408: void OPPROTO op_fcmpd_fcc2(void)
1409: {
1410: do_fcmpd_fcc2();
1411: }
1412:
1413: void OPPROTO op_fcmps_fcc3(void)
1414: {
1415: do_fcmps_fcc3();
1416: }
1417:
1418: void OPPROTO op_fcmpd_fcc3(void)
1419: {
1420: do_fcmpd_fcc3();
1421: }
1422: #endif
1423:
1.1.1.4 ! root 1424: /* Integer to float conversion. */
1.1 root 1425: #ifdef USE_INT_TO_FLOAT_HELPERS
1.1.1.4 ! root 1426: F_HELPER(ito);
1.1 root 1427: #else
1.1.1.4 ! root 1428: F_OP(ito, s)
1.1 root 1429: {
1.1.1.4 ! root 1430: FT0 = int32_to_float32(*((int32_t *)&FT1), &env->fp_status);
1.1 root 1431: }
1432:
1.1.1.4 ! root 1433: F_OP(ito, d)
1.1 root 1434: {
1.1.1.4 ! root 1435: DT0 = int32_to_float64(*((int32_t *)&FT1), &env->fp_status);
1.1 root 1436: }
1437:
1438: #ifdef TARGET_SPARC64
1.1.1.4 ! root 1439: F_OP(xto, s)
1.1 root 1440: {
1.1.1.4 ! root 1441: FT0 = int64_to_float32(*((int64_t *)&DT1), &env->fp_status);
1.1 root 1442: }
1443:
1.1.1.4 ! root 1444: F_OP(xto, d)
1.1 root 1445: {
1.1.1.4 ! root 1446: DT0 = int64_to_float64(*((int64_t *)&DT1), &env->fp_status);
1.1 root 1447: }
1448: #endif
1449: #endif
1.1.1.4 ! root 1450: #undef F_HELPER
1.1 root 1451:
1.1.1.4 ! root 1452: /* floating point conversion */
1.1 root 1453: void OPPROTO op_fdtos(void)
1454: {
1.1.1.4 ! root 1455: FT0 = float64_to_float32(DT1, &env->fp_status);
1.1 root 1456: }
1457:
1458: void OPPROTO op_fstod(void)
1459: {
1.1.1.4 ! root 1460: DT0 = float32_to_float64(FT1, &env->fp_status);
1.1 root 1461: }
1462:
1.1.1.4 ! root 1463: /* Float to integer conversion. */
1.1 root 1464: void OPPROTO op_fstoi(void)
1465: {
1.1.1.4 ! root 1466: *((int32_t *)&FT0) = float32_to_int32(FT1, &env->fp_status);
1.1 root 1467: }
1468:
1469: void OPPROTO op_fdtoi(void)
1470: {
1.1.1.4 ! root 1471: *((int32_t *)&FT0) = float64_to_int32(DT1, &env->fp_status);
1.1 root 1472: }
1473:
1474: #ifdef TARGET_SPARC64
1475: void OPPROTO op_fstox(void)
1476: {
1.1.1.4 ! root 1477: *((int64_t *)&DT0) = float32_to_int64(FT1, &env->fp_status);
1.1 root 1478: }
1479:
1480: void OPPROTO op_fdtox(void)
1481: {
1.1.1.4 ! root 1482: *((int64_t *)&DT0) = float64_to_int64(DT1, &env->fp_status);
1.1 root 1483: }
1484:
1485: void OPPROTO op_fmovs_cc(void)
1486: {
1487: if (T2)
1488: FT0 = FT1;
1489: }
1490:
1491: void OPPROTO op_fmovd_cc(void)
1492: {
1493: if (T2)
1494: DT0 = DT1;
1495: }
1496:
1497: void OPPROTO op_mov_cc(void)
1498: {
1499: if (T2)
1500: T0 = T1;
1501: }
1502:
1503: void OPPROTO op_flushw(void)
1504: {
1505: if (env->cansave != NWINDOWS - 2) {
1506: raise_exception(TT_SPILL | (env->otherwin != 0 ?
1507: (TT_WOTHER | ((env->wstate & 0x38) >> 1)):
1508: ((env->wstate & 0x7) << 2)));
1509: }
1510: }
1511:
1512: void OPPROTO op_saved(void)
1513: {
1514: env->cansave++;
1515: if (env->otherwin == 0)
1516: env->canrestore--;
1.1.1.4 ! root 1517: else
! 1518: env->otherwin--;
! 1519: FORCE_RET();
1.1 root 1520: }
1521:
1522: void OPPROTO op_restored(void)
1523: {
1524: env->canrestore++;
1525: if (env->cleanwin < NWINDOWS - 1)
1526: env->cleanwin++;
1527: if (env->otherwin == 0)
1528: env->cansave--;
1529: else
1530: env->otherwin--;
1.1.1.4 ! root 1531: FORCE_RET();
1.1 root 1532: }
1533:
1534: void OPPROTO op_popc(void)
1535: {
1536: do_popc();
1537: }
1538:
1539: void OPPROTO op_done(void)
1540: {
1541: do_done();
1542: }
1543:
1544: void OPPROTO op_retry(void)
1545: {
1546: do_retry();
1547: }
1548:
1549: void OPPROTO op_sir(void)
1550: {
1551: // XXX
1552:
1553: }
1554:
1555: void OPPROTO op_ld_asi_reg()
1556: {
1557: T0 += PARAM1;
1558: helper_ld_asi(env->asi, PARAM2, PARAM3);
1559: }
1560:
1561: void OPPROTO op_st_asi_reg()
1562: {
1563: T0 += PARAM1;
1564: helper_st_asi(env->asi, PARAM2, PARAM3);
1565: }
1566: #endif
1567:
1568: void OPPROTO op_ld_asi()
1569: {
1570: helper_ld_asi(PARAM1, PARAM2, PARAM3);
1571: }
1572:
1573: void OPPROTO op_st_asi()
1574: {
1575: helper_st_asi(PARAM1, PARAM2, PARAM3);
1576: }
1577:
1.1.1.4 ! root 1578: #ifdef TARGET_SPARC64
! 1579: void OPPROTO op_alignaddr()
! 1580: {
! 1581: uint64_t tmp;
! 1582:
! 1583: tmp = T0 + T1;
! 1584: env->gsr &= ~7ULL;
! 1585: env->gsr |= tmp & 7ULL;
! 1586: T0 = tmp & ~7ULL;
! 1587: }
! 1588:
! 1589: void OPPROTO op_faligndata()
! 1590: {
! 1591: uint64_t tmp;
! 1592:
! 1593: tmp = (*((uint64_t *)&DT0)) << ((env->gsr & 7) * 8);
! 1594: tmp |= (*((uint64_t *)&DT1)) >> (64 - (env->gsr & 7) * 8);
! 1595: (*((uint64_t *)&DT0)) = tmp;
! 1596: }
! 1597: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.