![[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-sh4|
Return to op.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / target-sh4 |
1.1 root 1: /*
2: * SH4 emulation
3: *
4: * Copyright (c) 2005 Samuel Tardieu
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: #include "exec.h"
21:
22: static inline void set_flag(uint32_t flag)
23: {
24: env->flags |= flag;
25: }
26:
27: static inline void clr_flag(uint32_t flag)
28: {
29: env->flags &= ~flag;
30: }
31:
32: static inline void set_t(void)
33: {
34: env->sr |= SR_T;
35: }
36:
37: static inline void clr_t(void)
38: {
39: env->sr &= ~SR_T;
40: }
41:
42: static inline void cond_t(int cond)
43: {
44: if (cond)
45: set_t();
46: else
47: clr_t();
48: }
49:
50: void OPPROTO op_movl_imm_T0(void)
51: {
52: T0 = (uint32_t) PARAM1;
53: RETURN();
54: }
55:
56: void OPPROTO op_movl_imm_T1(void)
57: {
58: T0 = (uint32_t) PARAM1;
59: RETURN();
60: }
61:
62: void OPPROTO op_movl_imm_T2(void)
63: {
64: T0 = (uint32_t) PARAM1;
65: RETURN();
66: }
67:
68: void OPPROTO op_cmp_eq_imm_T0(void)
69: {
70: cond_t((int32_t) T0 == (int32_t) PARAM1);
71: RETURN();
72: }
73:
74: void OPPROTO op_cmd_eq_T0_T1(void)
75: {
76: cond_t(T0 == T1);
77: RETURN();
78: }
79:
80: void OPPROTO op_cmd_hs_T0_T1(void)
81: {
82: cond_t((uint32_t) T0 <= (uint32_t) T1);
83: RETURN();
84: }
85:
86: void OPPROTO op_cmd_ge_T0_T1(void)
87: {
88: cond_t((int32_t) T0 <= (int32_t) T1);
89: RETURN();
90: }
91:
92: void OPPROTO op_cmd_hi_T0_T1(void)
93: {
94: cond_t((uint32_t) T0 < (uint32_t) T1);
95: RETURN();
96: }
97:
98: void OPPROTO op_cmd_gt_T0_T1(void)
99: {
100: cond_t((int32_t) T0 < (int32_t) T1);
101: RETURN();
102: }
103:
104: void OPPROTO op_not_T0(void)
105: {
106: T0 = ~T0;
107: RETURN();
108: }
109:
110: void OPPROTO op_bf_s(void)
111: {
112: env->delayed_pc = PARAM1;
1.1.1.2 ! root 113: set_flag(DELAY_SLOT_CONDITIONAL | ((~env->sr) & SR_T));
1.1 root 114: RETURN();
115: }
116:
117: void OPPROTO op_bt_s(void)
118: {
119: env->delayed_pc = PARAM1;
1.1.1.2 ! root 120: set_flag(DELAY_SLOT_CONDITIONAL | (env->sr & SR_T));
1.1 root 121: RETURN();
122: }
123:
124: void OPPROTO op_bra(void)
125: {
126: env->delayed_pc = PARAM1;
127: set_flag(DELAY_SLOT);
128: RETURN();
129: }
130:
131: void OPPROTO op_braf_T0(void)
132: {
133: env->delayed_pc = PARAM1 + T0;
134: set_flag(DELAY_SLOT);
135: RETURN();
136: }
137:
138: void OPPROTO op_bsr(void)
139: {
140: env->pr = PARAM1;
141: env->delayed_pc = PARAM2;
142: set_flag(DELAY_SLOT);
143: RETURN();
144: }
145:
146: void OPPROTO op_bsrf_T0(void)
147: {
148: env->pr = PARAM1;
149: env->delayed_pc = PARAM1 + T0;
150: set_flag(DELAY_SLOT);
151: RETURN();
152: }
153:
154: void OPPROTO op_jsr_T0(void)
155: {
156: env->pr = PARAM1;
157: env->delayed_pc = T0;
158: set_flag(DELAY_SLOT);
159: RETURN();
160: }
161:
162: void OPPROTO op_rts(void)
163: {
164: env->delayed_pc = env->pr;
165: set_flag(DELAY_SLOT);
166: RETURN();
167: }
168:
169: void OPPROTO op_clr_delay_slot(void)
170: {
171: clr_flag(DELAY_SLOT);
172: RETURN();
173: }
174:
175: void OPPROTO op_clr_delay_slot_conditional(void)
176: {
177: clr_flag(DELAY_SLOT_CONDITIONAL);
178: RETURN();
179: }
180:
181: void OPPROTO op_exit_tb(void)
182: {
183: EXIT_TB();
184: RETURN();
185: }
186:
187: void OPPROTO op_addl_imm_T0(void)
188: {
189: T0 += PARAM1;
190: RETURN();
191: }
192:
193: void OPPROTO op_addl_imm_T1(void)
194: {
195: T1 += PARAM1;
196: RETURN();
197: }
198:
199: void OPPROTO op_clrmac(void)
200: {
201: env->mach = env->macl = 0;
202: RETURN();
203: }
204:
205: void OPPROTO op_clrs(void)
206: {
207: env->sr &= ~SR_S;
208: RETURN();
209: }
210:
211: void OPPROTO op_clrt(void)
212: {
213: env->sr &= ~SR_T;
214: RETURN();
215: }
216:
217: void OPPROTO op_sets(void)
218: {
219: env->sr |= SR_S;
220: RETURN();
221: }
222:
223: void OPPROTO op_sett(void)
224: {
225: env->sr |= SR_T;
226: RETURN();
227: }
228:
1.1.1.2 ! root 229: void OPPROTO op_frchg(void)
! 230: {
! 231: env->fpscr ^= FPSCR_FR;
! 232: RETURN();
! 233: }
! 234:
! 235: void OPPROTO op_fschg(void)
! 236: {
! 237: env->fpscr ^= FPSCR_SZ;
! 238: RETURN();
! 239: }
! 240:
1.1 root 241: void OPPROTO op_rte(void)
242: {
243: env->sr = env->ssr;
244: env->delayed_pc = env->spc;
245: set_flag(DELAY_SLOT);
246: RETURN();
247: }
248:
249: void OPPROTO op_swapb_T0(void)
250: {
251: T0 = (T0 & 0xffff0000) | ((T0 & 0xff) << 8) | ((T0 >> 8) & 0xff);
252: RETURN();
253: }
254:
255: void OPPROTO op_swapw_T0(void)
256: {
257: T0 = ((T0 & 0xffff) << 16) | ((T0 >> 16) & 0xffff);
258: RETURN();
259: }
260:
261: void OPPROTO op_xtrct_T0_T1(void)
262: {
263: T1 = ((T0 & 0xffff) << 16) | ((T1 >> 16) & 0xffff);
264: RETURN();
265: }
266:
267: void OPPROTO op_addc_T0_T1(void)
268: {
269: helper_addc_T0_T1();
270: RETURN();
271: }
272:
273: void OPPROTO op_addv_T0_T1(void)
274: {
275: helper_addv_T0_T1();
276: RETURN();
277: }
278:
279: void OPPROTO op_cmp_eq_T0_T1(void)
280: {
281: cond_t(T1 == T0);
282: RETURN();
283: }
284:
285: void OPPROTO op_cmp_ge_T0_T1(void)
286: {
287: cond_t((int32_t) T1 >= (int32_t) T0);
288: RETURN();
289: }
290:
291: void OPPROTO op_cmp_gt_T0_T1(void)
292: {
293: cond_t((int32_t) T1 > (int32_t) T0);
294: RETURN();
295: }
296:
297: void OPPROTO op_cmp_hi_T0_T1(void)
298: {
299: cond_t((uint32_t) T1 > (uint32_t) T0);
300: RETURN();
301: }
302:
303: void OPPROTO op_cmp_hs_T0_T1(void)
304: {
305: cond_t((uint32_t) T1 >= (uint32_t) T0);
306: RETURN();
307: }
308:
309: void OPPROTO op_cmp_str_T0_T1(void)
310: {
311: cond_t((T0 & 0x000000ff) == (T1 & 0x000000ff) ||
312: (T0 & 0x0000ff00) == (T1 & 0x0000ff00) ||
313: (T0 & 0x00ff0000) == (T1 & 0x00ff0000) ||
314: (T0 & 0xff000000) == (T1 & 0xff000000));
315: RETURN();
316: }
317:
318: void OPPROTO op_tst_T0_T1(void)
319: {
320: cond_t((T1 & T0) == 0);
321: RETURN();
322: }
323:
324: void OPPROTO op_div0s_T0_T1(void)
325: {
326: if (T1 & 0x80000000)
327: env->sr |= SR_Q;
328: else
329: env->sr &= ~SR_Q;
330: if (T0 & 0x80000000)
331: env->sr |= SR_M;
332: else
333: env->sr &= ~SR_M;
334: cond_t((T1 ^ T0) & 0x80000000);
335: RETURN();
336: }
337:
338: void OPPROTO op_div0u(void)
339: {
340: env->sr &= ~(SR_M | SR_Q | SR_T);
341: RETURN();
342: }
343:
344: void OPPROTO op_div1_T0_T1(void)
345: {
346: helper_div1_T0_T1();
347: RETURN();
348: }
349:
350: void OPPROTO op_dmulsl_T0_T1(void)
351: {
352: helper_dmulsl_T0_T1();
353: RETURN();
354: }
355:
356: void OPPROTO op_dmulul_T0_T1(void)
357: {
358: helper_dmulul_T0_T1();
359: RETURN();
360: }
361:
362: void OPPROTO op_macl_T0_T1(void)
363: {
364: helper_macl_T0_T1();
365: RETURN();
366: }
367:
368: void OPPROTO op_macw_T0_T1(void)
369: {
370: helper_macw_T0_T1();
371: RETURN();
372: }
373:
374: void OPPROTO op_mull_T0_T1(void)
375: {
376: env->macl = (T0 * T1) & 0xffffffff;
377: RETURN();
378: }
379:
380: void OPPROTO op_mulsw_T0_T1(void)
381: {
382: env->macl = (int32_t) T0 *(int32_t) T1;
383: RETURN();
384: }
385:
386: void OPPROTO op_muluw_T0_T1(void)
387: {
388: env->macl = (uint32_t) T0 *(uint32_t) T1;
389: RETURN();
390: }
391:
392: void OPPROTO op_neg_T0(void)
393: {
394: T0 = -T0;
395: RETURN();
396: }
397:
398: void OPPROTO op_negc_T0(void)
399: {
400: helper_negc_T0();
401: RETURN();
402: }
403:
404: void OPPROTO op_shad_T0_T1(void)
405: {
406: if ((T0 & 0x80000000) == 0)
407: T1 <<= (T0 & 0x1f);
408: else if ((T0 & 0x1f) == 0)
409: T1 = 0;
410: else
411: T1 = ((int32_t) T1) >> ((~T0 & 0x1f) + 1);
412: RETURN();
413: }
414:
415: void OPPROTO op_shld_T0_T1(void)
416: {
417: if ((T0 & 0x80000000) == 0)
418: T1 <<= (T0 & 0x1f);
419: else if ((T0 & 0x1f) == 0)
420: T1 = 0;
421: else
422: T1 = ((uint32_t) T1) >> ((~T0 & 0x1f) + 1);
423: RETURN();
424: }
425:
426: void OPPROTO op_subc_T0_T1(void)
427: {
428: helper_subc_T0_T1();
429: RETURN();
430: }
431:
432: void OPPROTO op_subv_T0_T1(void)
433: {
434: helper_subv_T0_T1();
435: RETURN();
436: }
437:
438: void OPPROTO op_trapa(void)
439: {
440: env->tra = PARAM1 * 2;
441: env->exception_index = 0x160;
442: do_raise_exception();
443: RETURN();
444: }
445:
446: void OPPROTO op_cmp_pl_T0(void)
447: {
448: cond_t((int32_t) T0 > 0);
449: RETURN();
450: }
451:
452: void OPPROTO op_cmp_pz_T0(void)
453: {
454: cond_t((int32_t) T0 >= 0);
455: RETURN();
456: }
457:
458: void OPPROTO op_jmp_T0(void)
459: {
460: env->delayed_pc = T0;
461: set_flag(DELAY_SLOT);
462: RETURN();
463: }
464:
465: void OPPROTO op_movl_rN_rN(void)
466: {
467: env->gregs[PARAM2] = env->gregs[PARAM1];
468: RETURN();
469: }
470:
471: void OPPROTO op_ldcl_rMplus_rN_bank(void)
472: {
473: env->gregs[PARAM2] = env->gregs[PARAM1];
474: env->gregs[PARAM1] += 4;
475: RETURN();
476: }
477:
1.1.1.2 ! root 478: void OPPROTO op_ldc_T0_sr(void)
! 479: {
! 480: env->sr = T0 & 0x700083f3;
! 481: RETURN();
! 482: }
! 483:
! 484: void OPPROTO op_stc_sr_T0(void)
! 485: {
! 486: T0 = env->sr;
! 487: RETURN();
! 488: }
! 489:
1.1 root 490: #define LDSTOPS(target,load,store) \
491: void OPPROTO op_##load##_T0_##target (void) \
492: { env ->target = T0; RETURN(); \
493: } \
494: void OPPROTO op_##store##_##target##_T0 (void) \
495: { T0 = env->target; RETURN(); \
496: } \
497:
498: LDSTOPS(gbr, ldc, stc)
499: LDSTOPS(vbr, ldc, stc)
500: LDSTOPS(ssr, ldc, stc)
501: LDSTOPS(spc, ldc, stc)
502: LDSTOPS(sgr, ldc, stc)
503: LDSTOPS(dbr, ldc, stc)
504: LDSTOPS(mach, lds, sts)
505: LDSTOPS(macl, lds, sts)
506: LDSTOPS(pr, lds, sts)
1.1.1.2 ! root 507: LDSTOPS(fpul, lds, sts)
! 508:
! 509: void OPPROTO op_lds_T0_fpscr(void)
! 510: {
! 511: env->fpscr = T0 & 0x003fffff;
! 512: RETURN();
! 513: }
! 514:
! 515: void OPPROTO op_sts_fpscr_T0(void)
! 516: {
! 517: T0 = env->fpscr & 0x003fffff;
! 518: RETURN();
! 519: }
1.1 root 520:
521: void OPPROTO op_movt_rN(void)
522: {
523: env->gregs[PARAM1] = env->sr & SR_T;
524: RETURN();
525: }
526:
527: void OPPROTO op_rotcl_Rn(void)
528: {
529: helper_rotcl(&env->gregs[PARAM1]);
530: RETURN();
531: }
532:
533: void OPPROTO op_rotcr_Rn(void)
534: {
535: helper_rotcr(&env->gregs[PARAM1]);
536: RETURN();
537: }
538:
539: void OPPROTO op_rotl_Rn(void)
540: {
541: cond_t(env->gregs[PARAM1] & 0x80000000);
542: env->gregs[PARAM1] = (env->gregs[PARAM1] << 1) | (env->sr & SR_T);
543: RETURN();
544: }
545:
546: void OPPROTO op_rotr_Rn(void)
547: {
548: cond_t(env->gregs[PARAM1] & 1);
549: env->gregs[PARAM1] = (env->gregs[PARAM1] >> 1) |
550: ((env->sr & SR_T) ? 0x80000000 : 0);
551: RETURN();
552: }
553:
554: void OPPROTO op_shal_Rn(void)
555: {
556: cond_t(env->gregs[PARAM1] & 0x80000000);
557: env->gregs[PARAM1] <<= 1;
558: RETURN();
559: }
560:
561: void OPPROTO op_shar_Rn(void)
562: {
563: cond_t(env->gregs[PARAM1] & 1);
564: *(int32_t *) & env->gregs[PARAM1] >>= 1;
565: RETURN();
566: }
567:
568: void OPPROTO op_shlr_Rn(void)
569: {
570: cond_t(env->gregs[PARAM1] & 1);
571: *(uint32_t *) & env->gregs[PARAM1] >>= 1;
572: RETURN();
573: }
574:
575: void OPPROTO op_shll2_Rn(void)
576: {
577: env->gregs[PARAM1] <<= 2;
578: RETURN();
579: }
580:
581: void OPPROTO op_shll8_Rn(void)
582: {
583: env->gregs[PARAM1] <<= 8;
584: RETURN();
585: }
586:
587: void OPPROTO op_shll16_Rn(void)
588: {
589: env->gregs[PARAM1] <<= 16;
590: RETURN();
591: }
592:
593: void OPPROTO op_shlr2_Rn(void)
594: {
595: *(uint32_t *) & env->gregs[PARAM1] >>= 2;
596: RETURN();
597: }
598:
599: void OPPROTO op_shlr8_Rn(void)
600: {
601: *(uint32_t *) & env->gregs[PARAM1] >>= 8;
602: RETURN();
603: }
604:
605: void OPPROTO op_shlr16_Rn(void)
606: {
607: *(uint32_t *) & env->gregs[PARAM1] >>= 16;
608: RETURN();
609: }
610:
611: void OPPROTO op_tasb_rN(void)
612: {
613: cond_t(*(int8_t *) env->gregs[PARAM1] == 0);
614: *(int8_t *) env->gregs[PARAM1] |= 0x80;
615: RETURN();
616: }
617:
618: void OPPROTO op_movl_T0_rN(void)
619: {
620: env->gregs[PARAM1] = T0;
621: RETURN();
622: }
623:
624: void OPPROTO op_movl_T1_rN(void)
625: {
626: env->gregs[PARAM1] = T1;
627: RETURN();
628: }
629:
630: void OPPROTO op_movb_rN_T0(void)
631: {
632: T0 = (int32_t) (int8_t) (env->gregs[PARAM1] & 0xff);
633: RETURN();
634: }
635:
636: void OPPROTO op_movub_rN_T0(void)
637: {
638: T0 = env->gregs[PARAM1] & 0xff;
639: RETURN();
640: }
641:
642: void OPPROTO op_movw_rN_T0(void)
643: {
644: T0 = (int32_t) (int16_t) (env->gregs[PARAM1] & 0xffff);
645: RETURN();
646: }
647:
648: void OPPROTO op_movuw_rN_T0(void)
649: {
650: T0 = env->gregs[PARAM1] & 0xffff;
651: RETURN();
652: }
653:
654: void OPPROTO op_movl_rN_T0(void)
655: {
656: T0 = env->gregs[PARAM1];
657: RETURN();
658: }
659:
660: void OPPROTO op_movb_rN_T1(void)
661: {
662: T1 = (int32_t) (int8_t) (env->gregs[PARAM1] & 0xff);
663: RETURN();
664: }
665:
666: void OPPROTO op_movub_rN_T1(void)
667: {
668: T1 = env->gregs[PARAM1] & 0xff;
669: RETURN();
670: }
671:
672: void OPPROTO op_movw_rN_T1(void)
673: {
674: T1 = (int32_t) (int16_t) (env->gregs[PARAM1] & 0xffff);
675: RETURN();
676: }
677:
678: void OPPROTO op_movuw_rN_T1(void)
679: {
680: T1 = env->gregs[PARAM1] & 0xffff;
681: RETURN();
682: }
683:
684: void OPPROTO op_movl_rN_T1(void)
685: {
686: T1 = env->gregs[PARAM1];
687: RETURN();
688: }
689:
690: void OPPROTO op_movl_imm_rN(void)
691: {
692: env->gregs[PARAM2] = PARAM1;
693: RETURN();
694: }
695:
1.1.1.2 ! root 696: void OPPROTO op_fmov_frN_FT0(void)
! 697: {
! 698: FT0 = *(float32 *)&env->fregs[PARAM1];
! 699: RETURN();
! 700: }
! 701:
! 702: void OPPROTO op_fmov_drN_DT0(void)
! 703: {
! 704: DT0 = *(float64 *)&env->fregs[PARAM1];
! 705: RETURN();
! 706: }
! 707:
! 708: void OPPROTO op_fmov_FT0_frN(void)
! 709: {
! 710: *(float32 *)&env->fregs[PARAM1] = FT0;
! 711: RETURN();
! 712: }
! 713:
! 714: void OPPROTO op_fmov_DT0_drN(void)
! 715: {
! 716: *(float64 *)&env->fregs[PARAM1] = DT0;
! 717: RETURN();
! 718: }
! 719:
1.1 root 720: void OPPROTO op_dec1_rN(void)
721: {
722: env->gregs[PARAM1] -= 1;
723: RETURN();
724: }
725:
726: void OPPROTO op_dec2_rN(void)
727: {
728: env->gregs[PARAM1] -= 2;
729: RETURN();
730: }
731:
732: void OPPROTO op_dec4_rN(void)
733: {
734: env->gregs[PARAM1] -= 4;
735: RETURN();
736: }
737:
1.1.1.2 ! root 738: void OPPROTO op_dec8_rN(void)
! 739: {
! 740: env->gregs[PARAM1] -= 4;
! 741: RETURN();
! 742: }
! 743:
1.1 root 744: void OPPROTO op_inc1_rN(void)
745: {
746: env->gregs[PARAM1] += 1;
747: RETURN();
748: }
749:
750: void OPPROTO op_inc2_rN(void)
751: {
752: env->gregs[PARAM1] += 2;
753: RETURN();
754: }
755:
756: void OPPROTO op_inc4_rN(void)
757: {
758: env->gregs[PARAM1] += 4;
759: RETURN();
760: }
761:
1.1.1.2 ! root 762: void OPPROTO op_inc8_rN(void)
! 763: {
! 764: env->gregs[PARAM1] += 4;
! 765: RETURN();
! 766: }
! 767:
1.1 root 768: void OPPROTO op_add_T0_rN(void)
769: {
770: env->gregs[PARAM1] += T0;
771: RETURN();
772: }
773:
774: void OPPROTO op_sub_T0_rN(void)
775: {
776: env->gregs[PARAM1] -= T0;
777: RETURN();
778: }
779:
780: void OPPROTO op_and_T0_rN(void)
781: {
782: env->gregs[PARAM1] &= T0;
783: RETURN();
784: }
785:
786: void OPPROTO op_or_T0_rN(void)
787: {
788: env->gregs[PARAM1] |= T0;
789: RETURN();
790: }
791:
792: void OPPROTO op_xor_T0_rN(void)
793: {
794: env->gregs[PARAM1] ^= T0;
795: RETURN();
796: }
797:
798: void OPPROTO op_add_rN_T0(void)
799: {
800: T0 += env->gregs[PARAM1];
801: RETURN();
802: }
803:
804: void OPPROTO op_add_rN_T1(void)
805: {
806: T1 += env->gregs[PARAM1];
807: RETURN();
808: }
809:
810: void OPPROTO op_add_imm_rN(void)
811: {
812: env->gregs[PARAM2] += PARAM1;
813: RETURN();
814: }
815:
816: void OPPROTO op_and_imm_rN(void)
817: {
818: env->gregs[PARAM2] &= PARAM1;
819: RETURN();
820: }
821:
822: void OPPROTO op_or_imm_rN(void)
823: {
824: env->gregs[PARAM2] |= PARAM1;
825: RETURN();
826: }
827:
828: void OPPROTO op_xor_imm_rN(void)
829: {
830: env->gregs[PARAM2] ^= PARAM1;
831: RETURN();
832: }
833:
834: void OPPROTO op_dt_rN(void)
835: {
836: cond_t((--env->gregs[PARAM1]) == 0);
837: RETURN();
838: }
839:
840: void OPPROTO op_tst_imm_rN(void)
841: {
842: cond_t((env->gregs[PARAM2] & PARAM1) == 0);
843: RETURN();
844: }
845:
846: void OPPROTO op_movl_T0_T1(void)
847: {
848: T1 = T0;
849: RETURN();
850: }
851:
1.1.1.2 ! root 852: void OPPROTO op_movl_fpul_FT0(void)
! 853: {
! 854: FT0 = *(float32 *)&env->fpul;
! 855: RETURN();
! 856: }
! 857:
! 858: void OPPROTO op_movl_FT0_fpul(void)
! 859: {
! 860: *(float32 *)&env->fpul = FT0;
! 861: RETURN();
! 862: }
! 863:
1.1 root 864: void OPPROTO op_goto_tb0(void)
865: {
866: GOTO_TB(op_goto_tb0, PARAM1, 0);
867: RETURN();
868: }
869:
870: void OPPROTO op_goto_tb1(void)
871: {
872: GOTO_TB(op_goto_tb1, PARAM1, 1);
873: RETURN();
874: }
875:
876: void OPPROTO op_movl_imm_PC(void)
877: {
878: env->pc = PARAM1;
879: RETURN();
880: }
881:
882: void OPPROTO op_jT(void)
883: {
884: if (env->sr & SR_T)
885: GOTO_LABEL_PARAM(1);
886: RETURN();
887: }
888:
1.1.1.2 ! root 889: void OPPROTO op_jdelayed(void)
1.1 root 890: {
1.1.1.2 ! root 891: uint32_t flags;
! 892: flags = env->flags;
! 893: env->flags &= ~(DELAY_SLOT | DELAY_SLOT_CONDITIONAL);
! 894: if (flags & DELAY_SLOT)
1.1 root 895: GOTO_LABEL_PARAM(1);
896: RETURN();
897: }
898:
899: void OPPROTO op_movl_delayed_pc_PC(void)
900: {
901: env->pc = env->delayed_pc;
902: RETURN();
903: }
904:
905: void OPPROTO op_addl_GBR_T0(void)
906: {
907: T0 += env->gbr;
908: RETURN();
909: }
910:
911: void OPPROTO op_and_imm_T0(void)
912: {
913: T0 &= PARAM1;
914: RETURN();
915: }
916:
917: void OPPROTO op_or_imm_T0(void)
918: {
919: T0 |= PARAM1;
920: RETURN();
921: }
922:
923: void OPPROTO op_xor_imm_T0(void)
924: {
925: T0 ^= PARAM1;
926: RETURN();
927: }
928:
929: void OPPROTO op_tst_imm_T0(void)
930: {
931: cond_t((T0 & PARAM1) == 0);
932: RETURN();
933: }
934:
935: void OPPROTO op_raise_illegal_instruction(void)
936: {
937: env->exception_index = 0x180;
938: do_raise_exception();
939: RETURN();
940: }
941:
942: void OPPROTO op_raise_slot_illegal_instruction(void)
943: {
944: env->exception_index = 0x1a0;
945: do_raise_exception();
946: RETURN();
947: }
948:
949: void OPPROTO op_debug(void)
950: {
951: env->exception_index = EXCP_DEBUG;
952: cpu_loop_exit();
953: }
954:
955: /* Load and store */
956: #define MEMSUFFIX _raw
957: #include "op_mem.c"
958: #undef MEMSUFFIX
959: #if !defined(CONFIG_USER_ONLY)
960: #define MEMSUFFIX _user
961: #include "op_mem.c"
962: #undef MEMSUFFIX
963:
964: #define MEMSUFFIX _kernel
965: #include "op_mem.c"
966: #undef MEMSUFFIX
967: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.