![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to op_helper.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-alpha|
Return to op_helper.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / target-alpha |
1.1 root 1: /*
2: * Alpha emulation cpu micro-operations helpers for qemu.
3: *
4: * Copyright (c) 2007 Jocelyn Mayer
5: *
6: * This library is free software; you can redistribute it and/or
7: * modify it under the terms of the GNU Lesser General Public
8: * License as published by the Free Software Foundation; either
9: * version 2 of the License, or (at your option) any later version.
10: *
11: * This library is distributed in the hope that it will be useful,
12: * but WITHOUT ANY WARRANTY; without even the implied warranty of
13: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14: * Lesser General Public License for more details.
15: *
16: * You should have received a copy of the GNU Lesser General Public
17: * License along with this library; if not, write to the Free Software
18: * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19: */
20:
21: #include "exec.h"
22: #include "host-utils.h"
23: #include "softfloat.h"
24:
25: #include "op_helper.h"
26:
27: #define MEMSUFFIX _raw
28: #include "op_helper_mem.h"
29:
30: #if !defined(CONFIG_USER_ONLY)
31: #define MEMSUFFIX _kernel
32: #include "op_helper_mem.h"
33:
34: #define MEMSUFFIX _executive
35: #include "op_helper_mem.h"
36:
37: #define MEMSUFFIX _supervisor
38: #include "op_helper_mem.h"
39:
40: #define MEMSUFFIX _user
41: #include "op_helper_mem.h"
42:
43: /* This is used for pal modes */
44: #define MEMSUFFIX _data
45: #include "op_helper_mem.h"
46: #endif
47:
48: void helper_tb_flush (void)
49: {
50: tlb_flush(env, 1);
51: }
52:
53: void cpu_dump_EA (target_ulong EA);
54: void helper_print_mem_EA (target_ulong EA)
55: {
56: cpu_dump_EA(EA);
57: }
58:
59: /*****************************************************************************/
60: /* Exceptions processing helpers */
61: void helper_excp (uint32_t excp, uint32_t error)
62: {
63: env->exception_index = excp;
64: env->error_code = error;
65: cpu_loop_exit();
66: }
67:
68: void helper_amask (void)
69: {
70: switch (env->implver) {
71: case IMPLVER_2106x:
72: /* EV4, EV45, LCA, LCA45 & EV5 */
73: break;
74: case IMPLVER_21164:
75: case IMPLVER_21264:
76: case IMPLVER_21364:
77: T0 &= ~env->amask;
78: break;
79: }
80: }
81:
82: void helper_load_pcc (void)
83: {
84: /* XXX: TODO */
85: T0 = 0;
86: }
87:
88: void helper_load_implver (void)
89: {
90: T0 = env->implver;
91: }
92:
93: void helper_load_fpcr (void)
94: {
95: T0 = 0;
96: #ifdef CONFIG_SOFTFLOAT
97: T0 |= env->fp_status.float_exception_flags << 52;
98: if (env->fp_status.float_exception_flags)
99: T0 |= 1ULL << 63;
100: env->ipr[IPR_EXC_SUM] &= ~0x3E:
101: env->ipr[IPR_EXC_SUM] |= env->fp_status.float_exception_flags << 1;
102: #endif
103: switch (env->fp_status.float_rounding_mode) {
104: case float_round_nearest_even:
105: T0 |= 2ULL << 58;
106: break;
107: case float_round_down:
108: T0 |= 1ULL << 58;
109: break;
110: case float_round_up:
111: T0 |= 3ULL << 58;
112: break;
113: case float_round_to_zero:
114: break;
115: }
116: }
117:
118: void helper_store_fpcr (void)
119: {
120: #ifdef CONFIG_SOFTFLOAT
121: set_float_exception_flags((T0 >> 52) & 0x3F, &FP_STATUS);
122: #endif
123: switch ((T0 >> 58) & 3) {
124: case 0:
125: set_float_rounding_mode(float_round_to_zero, &FP_STATUS);
126: break;
127: case 1:
128: set_float_rounding_mode(float_round_down, &FP_STATUS);
129: break;
130: case 2:
131: set_float_rounding_mode(float_round_nearest_even, &FP_STATUS);
132: break;
133: case 3:
134: set_float_rounding_mode(float_round_up, &FP_STATUS);
135: break;
136: }
137: }
138:
139: void helper_load_irf (void)
140: {
141: /* XXX: TODO */
142: T0 = 0;
143: }
144:
145: void helper_set_irf (void)
146: {
147: /* XXX: TODO */
148: }
149:
150: void helper_clear_irf (void)
151: {
152: /* XXX: TODO */
153: }
154:
155: void helper_addqv (void)
156: {
157: T2 = T0;
158: T0 += T1;
159: if (unlikely((T2 ^ T1 ^ (-1ULL)) & (T2 ^ T0) & (1ULL << 63))) {
160: helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);
161: }
162: }
163:
164: void helper_addlv (void)
165: {
166: T2 = T0;
167: T0 = (uint32_t)(T0 + T1);
168: if (unlikely((T2 ^ T1 ^ (-1UL)) & (T2 ^ T0) & (1UL << 31))) {
169: helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);
170: }
171: }
172:
173: void helper_subqv (void)
174: {
175: T2 = T0;
176: T0 -= T1;
177: if (unlikely(((~T2) ^ T0 ^ (-1ULL)) & ((~T2) ^ T1) & (1ULL << 63))) {
178: helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);
179: }
180: }
181:
182: void helper_sublv (void)
183: {
184: T2 = T0;
185: T0 = (uint32_t)(T0 - T1);
186: if (unlikely(((~T2) ^ T0 ^ (-1UL)) & ((~T2) ^ T1) & (1UL << 31))) {
187: helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);
188: }
189: }
190:
191: void helper_mullv (void)
192: {
193: int64_t res = (int64_t)T0 * (int64_t)T1;
194:
195: if (unlikely((int32_t)res != res)) {
196: helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);
197: }
198: T0 = (int64_t)((int32_t)res);
199: }
200:
201: void helper_mulqv ()
202: {
203: uint64_t tl, th;
204:
205: muls64(&tl, &th, T0, T1);
206: /* If th != 0 && th != -1, then we had an overflow */
207: if (unlikely((th + 1) > 1)) {
208: helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);
209: }
210: T0 = tl;
211: }
212:
213: void helper_ctpop (void)
214: {
215: T0 = ctpop64(T0);
216: }
217:
218: void helper_ctlz (void)
219: {
220: T0 = clz64(T0);
221: }
222:
223: void helper_cttz (void)
224: {
225: T0 = ctz64(T0);
226: }
227:
228: static always_inline uint64_t byte_zap (uint64_t op, uint8_t mskb)
229: {
230: uint64_t mask;
231:
232: mask = 0;
233: mask |= ((mskb >> 0) & 1) * 0x00000000000000FFULL;
234: mask |= ((mskb >> 1) & 1) * 0x000000000000FF00ULL;
235: mask |= ((mskb >> 2) & 1) * 0x0000000000FF0000ULL;
236: mask |= ((mskb >> 3) & 1) * 0x00000000FF000000ULL;
237: mask |= ((mskb >> 4) & 1) * 0x000000FF00000000ULL;
238: mask |= ((mskb >> 5) & 1) * 0x0000FF0000000000ULL;
239: mask |= ((mskb >> 6) & 1) * 0x00FF000000000000ULL;
240: mask |= ((mskb >> 7) & 1) * 0xFF00000000000000ULL;
241:
242: return op & ~mask;
243: }
244:
245: void helper_mskbl (void)
246: {
247: T0 = byte_zap(T0, 0x01 << (T1 & 7));
248: }
249:
250: void helper_extbl (void)
251: {
252: T0 >>= (T1 & 7) * 8;
253: T0 = byte_zap(T0, 0xFE);
254: }
255:
256: void helper_insbl (void)
257: {
258: T0 <<= (T1 & 7) * 8;
259: T0 = byte_zap(T0, ~(0x01 << (T1 & 7)));
260: }
261:
262: void helper_mskwl (void)
263: {
264: T0 = byte_zap(T0, 0x03 << (T1 & 7));
265: }
266:
267: void helper_extwl (void)
268: {
269: T0 >>= (T1 & 7) * 8;
270: T0 = byte_zap(T0, 0xFC);
271: }
272:
273: void helper_inswl (void)
274: {
275: T0 <<= (T1 & 7) * 8;
276: T0 = byte_zap(T0, ~(0x03 << (T1 & 7)));
277: }
278:
279: void helper_mskll (void)
280: {
281: T0 = byte_zap(T0, 0x0F << (T1 & 7));
282: }
283:
284: void helper_extll (void)
285: {
286: T0 >>= (T1 & 7) * 8;
287: T0 = byte_zap(T0, 0xF0);
288: }
289:
290: void helper_insll (void)
291: {
292: T0 <<= (T1 & 7) * 8;
293: T0 = byte_zap(T0, ~(0x0F << (T1 & 7)));
294: }
295:
296: void helper_zap (void)
297: {
298: T0 = byte_zap(T0, T1);
299: }
300:
301: void helper_zapnot (void)
302: {
303: T0 = byte_zap(T0, ~T1);
304: }
305:
306: void helper_mskql (void)
307: {
308: T0 = byte_zap(T0, 0xFF << (T1 & 7));
309: }
310:
311: void helper_extql (void)
312: {
313: T0 >>= (T1 & 7) * 8;
314: T0 = byte_zap(T0, 0x00);
315: }
316:
317: void helper_insql (void)
318: {
319: T0 <<= (T1 & 7) * 8;
320: T0 = byte_zap(T0, ~(0xFF << (T1 & 7)));
321: }
322:
323: void helper_mskwh (void)
324: {
325: T0 = byte_zap(T0, (0x03 << (T1 & 7)) >> 8);
326: }
327:
328: void helper_inswh (void)
329: {
330: T0 >>= 64 - ((T1 & 7) * 8);
331: T0 = byte_zap(T0, ~((0x03 << (T1 & 7)) >> 8));
332: }
333:
334: void helper_extwh (void)
335: {
336: T0 <<= 64 - ((T1 & 7) * 8);
337: T0 = byte_zap(T0, ~0x07);
338: }
339:
340: void helper_msklh (void)
341: {
342: T0 = byte_zap(T0, (0x0F << (T1 & 7)) >> 8);
343: }
344:
345: void helper_inslh (void)
346: {
347: T0 >>= 64 - ((T1 & 7) * 8);
348: T0 = byte_zap(T0, ~((0x0F << (T1 & 7)) >> 8));
349: }
350:
351: void helper_extlh (void)
352: {
353: T0 <<= 64 - ((T1 & 7) * 8);
354: T0 = byte_zap(T0, ~0x0F);
355: }
356:
357: void helper_mskqh (void)
358: {
359: T0 = byte_zap(T0, (0xFF << (T1 & 7)) >> 8);
360: }
361:
362: void helper_insqh (void)
363: {
364: T0 >>= 64 - ((T1 & 7) * 8);
365: T0 = byte_zap(T0, ~((0xFF << (T1 & 7)) >> 8));
366: }
367:
368: void helper_extqh (void)
369: {
370: T0 <<= 64 - ((T1 & 7) * 8);
371: T0 = byte_zap(T0, 0x00);
372: }
373:
374: void helper_cmpbge (void)
375: {
376: uint8_t opa, opb, res;
377: int i;
378:
379: res = 0;
380: for (i = 0; i < 7; i++) {
381: opa = T0 >> (i * 8);
382: opb = T1 >> (i * 8);
383: if (opa >= opb)
384: res |= 1 << i;
385: }
386: T0 = res;
387: }
388:
389: void helper_cmov_fir (int freg)
390: {
391: if (FT0 != 0)
392: env->fir[freg] = FT1;
393: }
394:
395: void helper_sqrts (void)
396: {
397: FT0 = float32_sqrt(FT0, &FP_STATUS);
398: }
399:
400: void helper_cpys (void)
401: {
402: union {
403: double d;
404: uint64_t i;
405: } p, q, r;
406:
407: p.d = FT0;
408: q.d = FT1;
409: r.i = p.i & 0x8000000000000000ULL;
410: r.i |= q.i & ~0x8000000000000000ULL;
411: FT0 = r.d;
412: }
413:
414: void helper_cpysn (void)
415: {
416: union {
417: double d;
418: uint64_t i;
419: } p, q, r;
420:
421: p.d = FT0;
422: q.d = FT1;
423: r.i = (~p.i) & 0x8000000000000000ULL;
424: r.i |= q.i & ~0x8000000000000000ULL;
425: FT0 = r.d;
426: }
427:
428: void helper_cpyse (void)
429: {
430: union {
431: double d;
432: uint64_t i;
433: } p, q, r;
434:
435: p.d = FT0;
436: q.d = FT1;
437: r.i = p.i & 0xFFF0000000000000ULL;
438: r.i |= q.i & ~0xFFF0000000000000ULL;
439: FT0 = r.d;
440: }
441:
442: void helper_itofs (void)
443: {
444: union {
445: double d;
446: uint64_t i;
447: } p;
448:
449: p.d = FT0;
450: FT0 = int64_to_float32(p.i, &FP_STATUS);
451: }
452:
453: void helper_ftois (void)
454: {
455: union {
456: double d;
457: uint64_t i;
458: } p;
459:
460: p.i = float32_to_int64(FT0, &FP_STATUS);
461: FT0 = p.d;
462: }
463:
464: void helper_sqrtt (void)
465: {
466: FT0 = float64_sqrt(FT0, &FP_STATUS);
467: }
468:
469: void helper_cmptun (void)
470: {
471: union {
472: double d;
473: uint64_t i;
474: } p;
475:
476: p.i = 0;
477: if (float64_is_nan(FT0) || float64_is_nan(FT1))
478: p.i = 0x4000000000000000ULL;
479: FT0 = p.d;
480: }
481:
482: void helper_cmpteq (void)
483: {
484: union {
485: double d;
486: uint64_t i;
487: } p;
488:
489: p.i = 0;
490: if (float64_eq(FT0, FT1, &FP_STATUS))
491: p.i = 0x4000000000000000ULL;
492: FT0 = p.d;
493: }
494:
495: void helper_cmptle (void)
496: {
497: union {
498: double d;
499: uint64_t i;
500: } p;
501:
502: p.i = 0;
503: if (float64_le(FT0, FT1, &FP_STATUS))
504: p.i = 0x4000000000000000ULL;
505: FT0 = p.d;
506: }
507:
508: void helper_cmptlt (void)
509: {
510: union {
511: double d;
512: uint64_t i;
513: } p;
514:
515: p.i = 0;
516: if (float64_lt(FT0, FT1, &FP_STATUS))
517: p.i = 0x4000000000000000ULL;
518: FT0 = p.d;
519: }
520:
521: void helper_itoft (void)
522: {
523: union {
524: double d;
525: uint64_t i;
526: } p;
527:
528: p.d = FT0;
529: FT0 = int64_to_float64(p.i, &FP_STATUS);
530: }
531:
532: void helper_ftoit (void)
533: {
534: union {
535: double d;
536: uint64_t i;
537: } p;
538:
539: p.i = float64_to_int64(FT0, &FP_STATUS);
540: FT0 = p.d;
541: }
542:
543: static always_inline int vaxf_is_valid (float ff)
544: {
545: union {
546: float f;
547: uint32_t i;
548: } p;
549: uint32_t exp, mant;
550:
551: p.f = ff;
552: exp = (p.i >> 23) & 0xFF;
553: mant = p.i & 0x007FFFFF;
554: if (exp == 0 && ((p.i & 0x80000000) || mant != 0)) {
555: /* Reserved operands / Dirty zero */
556: return 0;
557: }
558:
559: return 1;
560: }
561:
562: static always_inline float vaxf_to_ieee32 (float ff)
563: {
564: union {
565: float f;
566: uint32_t i;
567: } p;
568: uint32_t exp;
569:
570: p.f = ff;
571: exp = (p.i >> 23) & 0xFF;
572: if (exp < 3) {
573: /* Underflow */
574: p.f = 0.0;
575: } else {
576: p.f *= 0.25;
577: }
578:
579: return p.f;
580: }
581:
582: static always_inline float ieee32_to_vaxf (float fi)
583: {
584: union {
585: float f;
586: uint32_t i;
587: } p;
588: uint32_t exp, mant;
589:
590: p.f = fi;
591: exp = (p.i >> 23) & 0xFF;
592: mant = p.i & 0x007FFFFF;
593: if (exp == 255) {
594: /* NaN or infinity */
595: p.i = 1;
596: } else if (exp == 0) {
597: if (mant == 0) {
598: /* Zero */
599: p.i = 0;
600: } else {
601: /* Denormalized */
602: p.f *= 2.0;
603: }
604: } else {
605: if (exp >= 253) {
606: /* Overflow */
607: p.i = 1;
608: } else {
609: p.f *= 4.0;
610: }
611: }
612:
613: return p.f;
614: }
615:
616: void helper_addf (void)
617: {
618: float ft0, ft1, ft2;
619:
620: if (!vaxf_is_valid(FT0) || !vaxf_is_valid(FT1)) {
621: /* XXX: TODO */
622: }
623: ft0 = vaxf_to_ieee32(FT0);
624: ft1 = vaxf_to_ieee32(FT1);
625: ft2 = float32_add(ft0, ft1, &FP_STATUS);
626: FT0 = ieee32_to_vaxf(ft2);
627: }
628:
629: void helper_subf (void)
630: {
631: float ft0, ft1, ft2;
632:
633: if (!vaxf_is_valid(FT0) || !vaxf_is_valid(FT1)) {
634: /* XXX: TODO */
635: }
636: ft0 = vaxf_to_ieee32(FT0);
637: ft1 = vaxf_to_ieee32(FT1);
638: ft2 = float32_sub(ft0, ft1, &FP_STATUS);
639: FT0 = ieee32_to_vaxf(ft2);
640: }
641:
642: void helper_mulf (void)
643: {
644: float ft0, ft1, ft2;
645:
646: if (!vaxf_is_valid(FT0) || !vaxf_is_valid(FT1)) {
647: /* XXX: TODO */
648: }
649: ft0 = vaxf_to_ieee32(FT0);
650: ft1 = vaxf_to_ieee32(FT1);
651: ft2 = float32_mul(ft0, ft1, &FP_STATUS);
652: FT0 = ieee32_to_vaxf(ft2);
653: }
654:
655: void helper_divf (void)
656: {
657: float ft0, ft1, ft2;
658:
659: if (!vaxf_is_valid(FT0) || !vaxf_is_valid(FT1)) {
660: /* XXX: TODO */
661: }
662: ft0 = vaxf_to_ieee32(FT0);
663: ft1 = vaxf_to_ieee32(FT1);
664: ft2 = float32_div(ft0, ft1, &FP_STATUS);
665: FT0 = ieee32_to_vaxf(ft2);
666: }
667:
668: void helper_sqrtf (void)
669: {
670: float ft0, ft1;
671:
672: if (!vaxf_is_valid(FT0) || !vaxf_is_valid(FT1)) {
673: /* XXX: TODO */
674: }
675: ft0 = vaxf_to_ieee32(FT0);
676: ft1 = float32_sqrt(ft0, &FP_STATUS);
677: FT0 = ieee32_to_vaxf(ft1);
678: }
679:
680: void helper_itoff (void)
681: {
682: /* XXX: TODO */
683: }
684:
685: static always_inline int vaxg_is_valid (double ff)
686: {
687: union {
688: double f;
689: uint64_t i;
690: } p;
691: uint64_t exp, mant;
692:
693: p.f = ff;
694: exp = (p.i >> 52) & 0x7FF;
695: mant = p.i & 0x000FFFFFFFFFFFFFULL;
696: if (exp == 0 && ((p.i & 0x8000000000000000ULL) || mant != 0)) {
697: /* Reserved operands / Dirty zero */
698: return 0;
699: }
700:
701: return 1;
702: }
703:
704: static always_inline double vaxg_to_ieee64 (double fg)
705: {
706: union {
707: double f;
708: uint64_t i;
709: } p;
710: uint32_t exp;
711:
712: p.f = fg;
713: exp = (p.i >> 52) & 0x7FF;
714: if (exp < 3) {
715: /* Underflow */
716: p.f = 0.0;
717: } else {
718: p.f *= 0.25;
719: }
720:
721: return p.f;
722: }
723:
724: static always_inline double ieee64_to_vaxg (double fi)
725: {
726: union {
727: double f;
728: uint64_t i;
729: } p;
730: uint64_t mant;
731: uint32_t exp;
732:
733: p.f = fi;
734: exp = (p.i >> 52) & 0x7FF;
735: mant = p.i & 0x000FFFFFFFFFFFFFULL;
736: if (exp == 255) {
737: /* NaN or infinity */
738: p.i = 1; /* VAX dirty zero */
739: } else if (exp == 0) {
740: if (mant == 0) {
741: /* Zero */
742: p.i = 0;
743: } else {
744: /* Denormalized */
745: p.f *= 2.0;
746: }
747: } else {
748: if (exp >= 2045) {
749: /* Overflow */
750: p.i = 1; /* VAX dirty zero */
751: } else {
752: p.f *= 4.0;
753: }
754: }
755:
756: return p.f;
757: }
758:
759: void helper_addg (void)
760: {
761: double ft0, ft1, ft2;
762:
763: if (!vaxg_is_valid(FT0) || !vaxg_is_valid(FT1)) {
764: /* XXX: TODO */
765: }
766: ft0 = vaxg_to_ieee64(FT0);
767: ft1 = vaxg_to_ieee64(FT1);
768: ft2 = float64_add(ft0, ft1, &FP_STATUS);
769: FT0 = ieee64_to_vaxg(ft2);
770: }
771:
772: void helper_subg (void)
773: {
774: double ft0, ft1, ft2;
775:
776: if (!vaxg_is_valid(FT0) || !vaxg_is_valid(FT1)) {
777: /* XXX: TODO */
778: }
779: ft0 = vaxg_to_ieee64(FT0);
780: ft1 = vaxg_to_ieee64(FT1);
781: ft2 = float64_sub(ft0, ft1, &FP_STATUS);
782: FT0 = ieee64_to_vaxg(ft2);
783: }
784:
785: void helper_mulg (void)
786: {
787: double ft0, ft1, ft2;
788:
789: if (!vaxg_is_valid(FT0) || !vaxg_is_valid(FT1)) {
790: /* XXX: TODO */
791: }
792: ft0 = vaxg_to_ieee64(FT0);
793: ft1 = vaxg_to_ieee64(FT1);
794: ft2 = float64_mul(ft0, ft1, &FP_STATUS);
795: FT0 = ieee64_to_vaxg(ft2);
796: }
797:
798: void helper_divg (void)
799: {
800: double ft0, ft1, ft2;
801:
802: if (!vaxg_is_valid(FT0) || !vaxg_is_valid(FT1)) {
803: /* XXX: TODO */
804: }
805: ft0 = vaxg_to_ieee64(FT0);
806: ft1 = vaxg_to_ieee64(FT1);
807: ft2 = float64_div(ft0, ft1, &FP_STATUS);
808: FT0 = ieee64_to_vaxg(ft2);
809: }
810:
811: void helper_sqrtg (void)
812: {
813: double ft0, ft1;
814:
815: if (!vaxg_is_valid(FT0) || !vaxg_is_valid(FT1)) {
816: /* XXX: TODO */
817: }
818: ft0 = vaxg_to_ieee64(FT0);
819: ft1 = float64_sqrt(ft0, &FP_STATUS);
820: FT0 = ieee64_to_vaxg(ft1);
821: }
822:
823: void helper_cmpgeq (void)
824: {
825: union {
826: double d;
827: uint64_t u;
828: } p;
829: double ft0, ft1;
830:
831: if (!vaxg_is_valid(FT0) || !vaxg_is_valid(FT1)) {
832: /* XXX: TODO */
833: }
834: ft0 = vaxg_to_ieee64(FT0);
835: ft1 = vaxg_to_ieee64(FT1);
836: p.u = 0;
837: if (float64_eq(ft0, ft1, &FP_STATUS))
838: p.u = 0x4000000000000000ULL;
839: FT0 = p.d;
840: }
841:
842: void helper_cmpglt (void)
843: {
844: union {
845: double d;
846: uint64_t u;
847: } p;
848: double ft0, ft1;
849:
850: if (!vaxg_is_valid(FT0) || !vaxg_is_valid(FT1)) {
851: /* XXX: TODO */
852: }
853: ft0 = vaxg_to_ieee64(FT0);
854: ft1 = vaxg_to_ieee64(FT1);
855: p.u = 0;
856: if (float64_lt(ft0, ft1, &FP_STATUS))
857: p.u = 0x4000000000000000ULL;
858: FT0 = p.d;
859: }
860:
861: void helper_cmpgle (void)
862: {
863: union {
864: double d;
865: uint64_t u;
866: } p;
867: double ft0, ft1;
868:
869: if (!vaxg_is_valid(FT0) || !vaxg_is_valid(FT1)) {
870: /* XXX: TODO */
871: }
872: ft0 = vaxg_to_ieee64(FT0);
873: ft1 = vaxg_to_ieee64(FT1);
874: p.u = 0;
875: if (float64_le(ft0, ft1, &FP_STATUS))
876: p.u = 0x4000000000000000ULL;
877: FT0 = p.d;
878: }
879:
880: void helper_cvtqs (void)
881: {
882: union {
883: double d;
884: uint64_t u;
885: } p;
886:
887: p.d = FT0;
888: FT0 = (float)p.u;
889: }
890:
891: void helper_cvttq (void)
892: {
893: union {
894: double d;
895: uint64_t u;
896: } p;
897:
898: p.u = FT0;
899: FT0 = p.d;
900: }
901:
902: void helper_cvtqt (void)
903: {
904: union {
905: double d;
906: uint64_t u;
907: } p;
908:
909: p.d = FT0;
910: FT0 = p.u;
911: }
912:
913: void helper_cvtqf (void)
914: {
915: union {
916: double d;
917: uint64_t u;
918: } p;
919:
920: p.d = FT0;
921: FT0 = ieee32_to_vaxf(p.u);
922: }
923:
924: void helper_cvtgf (void)
925: {
926: double ft0;
927:
928: ft0 = vaxg_to_ieee64(FT0);
929: FT0 = ieee32_to_vaxf(ft0);
930: }
931:
932: void helper_cvtgd (void)
933: {
934: /* XXX: TODO */
935: }
936:
937: void helper_cvtgq (void)
938: {
939: union {
940: double d;
941: uint64_t u;
942: } p;
943:
944: p.u = vaxg_to_ieee64(FT0);
945: FT0 = p.d;
946: }
947:
948: void helper_cvtqg (void)
949: {
950: union {
951: double d;
952: uint64_t u;
953: } p;
954:
955: p.d = FT0;
956: FT0 = ieee64_to_vaxg(p.u);
957: }
958:
959: void helper_cvtdg (void)
960: {
961: /* XXX: TODO */
962: }
963:
964: void helper_cvtlq (void)
965: {
966: union {
967: double d;
968: uint64_t u;
969: } p, q;
970:
971: p.d = FT0;
972: q.u = (p.u >> 29) & 0x3FFFFFFF;
973: q.u |= (p.u >> 32);
974: q.u = (int64_t)((int32_t)q.u);
975: FT0 = q.d;
976: }
977:
978: static always_inline void __helper_cvtql (int s, int v)
979: {
980: union {
981: double d;
982: uint64_t u;
983: } p, q;
984:
985: p.d = FT0;
986: q.u = ((uint64_t)(p.u & 0xC0000000)) << 32;
987: q.u |= ((uint64_t)(p.u & 0x7FFFFFFF)) << 29;
988: FT0 = q.d;
989: if (v && (int64_t)((int32_t)p.u) != (int64_t)p.u) {
990: helper_excp(EXCP_ARITH, EXCP_ARITH_OVERFLOW);
991: }
992: if (s) {
993: /* TODO */
994: }
995: }
996:
997: void helper_cvtql (void)
998: {
999: __helper_cvtql(0, 0);
1000: }
1001:
1002: void helper_cvtqlv (void)
1003: {
1004: __helper_cvtql(0, 1);
1005: }
1006:
1007: void helper_cvtqlsv (void)
1008: {
1009: __helper_cvtql(1, 1);
1010: }
1011:
1012: void helper_cmpfeq (void)
1013: {
1014: if (float64_eq(FT0, FT1, &FP_STATUS))
1015: T0 = 1;
1016: else
1017: T0 = 0;
1018: }
1019:
1020: void helper_cmpfne (void)
1021: {
1022: if (float64_eq(FT0, FT1, &FP_STATUS))
1023: T0 = 0;
1024: else
1025: T0 = 1;
1026: }
1027:
1028: void helper_cmpflt (void)
1029: {
1030: if (float64_lt(FT0, FT1, &FP_STATUS))
1031: T0 = 1;
1032: else
1033: T0 = 0;
1034: }
1035:
1036: void helper_cmpfle (void)
1037: {
1038: if (float64_lt(FT0, FT1, &FP_STATUS))
1039: T0 = 1;
1040: else
1041: T0 = 0;
1042: }
1043:
1044: void helper_cmpfgt (void)
1045: {
1046: if (float64_le(FT0, FT1, &FP_STATUS))
1047: T0 = 0;
1048: else
1049: T0 = 1;
1050: }
1051:
1052: void helper_cmpfge (void)
1053: {
1054: if (float64_lt(FT0, FT1, &FP_STATUS))
1055: T0 = 0;
1056: else
1057: T0 = 1;
1058: }
1059:
1060: #if !defined (CONFIG_USER_ONLY)
1061: void helper_mfpr (int iprn)
1062: {
1063: uint64_t val;
1064:
1065: if (cpu_alpha_mfpr(env, iprn, &val) == 0)
1066: T0 = val;
1067: }
1068:
1069: void helper_mtpr (int iprn)
1070: {
1071: cpu_alpha_mtpr(env, iprn, T0, NULL);
1072: }
1073: #endif
1074:
1075: #if defined(HOST_SPARC) || defined(HOST_SPARC64)
1076: void helper_reset_FT0 (void)
1077: {
1078: FT0 = 0;
1079: }
1080:
1081: void helper_reset_FT1 (void)
1082: {
1083: FT1 = 0;
1084: }
1085:
1086: void helper_reset_FT2 (void)
1087: {
1088: FT2 = 0;
1089: }
1090: #endif
1091:
1092: /*****************************************************************************/
1093: /* Softmmu support */
1094: #if !defined (CONFIG_USER_ONLY)
1095:
1096: #ifdef __s390__
1097: # define GETPC() ((void*)((unsigned long)__builtin_return_address(0) & 0x7fffffffUL))
1098: #else
1099: # define GETPC() (__builtin_return_address(0))
1100: #endif
1101:
1102: /* XXX: the two following helpers are pure hacks.
1103: * Hopefully, we emulate the PALcode, then we should never see
1104: * HW_LD / HW_ST instructions.
1105: */
1106: void helper_ld_phys_to_virt (void)
1107: {
1108: uint64_t tlb_addr, physaddr;
1109: int index, mmu_idx;
1110: void *retaddr;
1111:
1112: mmu_idx = cpu_mmu_index(env);
1113: index = (T0 >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
1114: redo:
1115: tlb_addr = env->tlb_table[mmu_idx][index].addr_read;
1116: if ((T0 & TARGET_PAGE_MASK) ==
1117: (tlb_addr & (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {
1118: physaddr = T0 + env->tlb_table[mmu_idx][index].addend;
1119: } else {
1120: /* the page is not in the TLB : fill it */
1121: retaddr = GETPC();
1122: tlb_fill(T0, 0, mmu_idx, retaddr);
1123: goto redo;
1124: }
1125: T0 = physaddr;
1126: }
1127:
1128: void helper_st_phys_to_virt (void)
1129: {
1130: uint64_t tlb_addr, physaddr;
1131: int index, mmu_idx;
1132: void *retaddr;
1133:
1134: mmu_idx = cpu_mmu_index(env);
1135: index = (T0 >> TARGET_PAGE_BITS) & (CPU_TLB_SIZE - 1);
1136: redo:
1137: tlb_addr = env->tlb_table[mmu_idx][index].addr_write;
1138: if ((T0 & TARGET_PAGE_MASK) ==
1139: (tlb_addr & (TARGET_PAGE_MASK | TLB_INVALID_MASK))) {
1140: physaddr = T0 + env->tlb_table[mmu_idx][index].addend;
1141: } else {
1142: /* the page is not in the TLB : fill it */
1143: retaddr = GETPC();
1144: tlb_fill(T0, 1, mmu_idx, retaddr);
1145: goto redo;
1146: }
1147: T0 = physaddr;
1148: }
1149:
1150: #define MMUSUFFIX _mmu
1151:
1152: #define SHIFT 0
1153: #include "softmmu_template.h"
1154:
1155: #define SHIFT 1
1156: #include "softmmu_template.h"
1157:
1158: #define SHIFT 2
1159: #include "softmmu_template.h"
1160:
1161: #define SHIFT 3
1162: #include "softmmu_template.h"
1163:
1164: /* try to fill the TLB and return an exception if error. If retaddr is
1165: NULL, it means that the function was called in C code (i.e. not
1166: from generated code or from helper.c) */
1167: /* XXX: fix it to restore all registers */
1168: void tlb_fill (target_ulong addr, int is_write, int mmu_idx, void *retaddr)
1169: {
1170: TranslationBlock *tb;
1171: CPUState *saved_env;
1172: unsigned long pc;
1173: int ret;
1174:
1175: /* XXX: hack to restore env in all cases, even if not called from
1176: generated code */
1177: saved_env = env;
1178: env = cpu_single_env;
1179: ret = cpu_alpha_handle_mmu_fault(env, addr, is_write, mmu_idx, 1);
1180: if (!likely(ret == 0)) {
1181: if (likely(retaddr)) {
1182: /* now we have a real cpu fault */
1183: pc = (unsigned long)retaddr;
1184: tb = tb_find_pc(pc);
1185: if (likely(tb)) {
1186: /* the PC is inside the translated code. It means that we have
1187: a virtual CPU fault */
1188: cpu_restore_state(tb, env, pc, NULL);
1189: }
1190: }
1191: /* Exception index and error code are already set */
1192: cpu_loop_exit();
1193: }
1194: env = saved_env;
1195: }
1196:
1197: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.