![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to m68030fpu.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Isaki's NoNo m68k/m88k emulator] / nono / m680x0|
Return to m68030fpu.cpp CVS log | Up to [Isaki's NoNo m68k/m88k emulator] / nono / m680x0 |
1.1 root 1: //
2: // nono
3: // Copyright (C) 2018 [email protected]
4: //
5:
6: #include "header.h"
7: #include "m68030core.h"
8: #include "m68030bus.h"
9: #include "m68030excep.h"
10: #include "m68030ea.h"
11: #include "m68030fpu.h"
12:
13: static void fgen(m68kcpu *);
14: static void fpu_op_fmovecr(m68kcpu *);
15:
16: // リセット用のレジスタ初期値
17: struct fpframe initial_fpframe;
18:
19: // 初期化
20: void
21: fpu_init(m68kcpu *cpu)
22: {
23: int i;
24: uint32_t *p;
25:
26: // XXX cpu の初期化のところと見直してマージするとか
27: memset(&cpu->fe, 0, sizeof(cpu->fe));
28: memset(&cpu->reg.fpframe, 0, sizeof(cpu->reg.fpframe));
29: cpu->fe.fe_fpframe = &cpu->reg.fpframe;
30:
31: // FRESTORE によるリセット用に FP レジスタの初期値を用意しておく
32: memset(&initial_fpframe, 0, sizeof(initial_fpframe));
33: p = initial_fpframe.fpf_regs;
34: for (i = 0; i < 8; i++) {
35: *p++ = 0x7fff0000;
36: *p++ = 0xffffffff;
37: *p++ = 0xffffffff;
38: }
39: }
40:
41: // FPU をリセットする。
42: // MPU リセット時と、NULL フレームのリストア時に呼ばれる。
43: void
44: fpu_reset(m68kcpu *cpu)
45: {
46: // 高速化のため、あらかじめ用意しておいたイメージをコピーする
47: memcpy(&cpu->reg.fpframe, &initial_fpframe, sizeof(initial_fpframe));
48:
49: cpu->fpu_dirty = false;
50: }
51:
52: // FPU からの呼び出し用。
53: //
54: // (An)+, -(An) は、サイズが増えているのとクロックが増加している(2->6)。
55: // それ以外のアドレッシングモードでもクロック数は微妙に違うのだが、
56: // 大きくは違わないのでそっちは本体の cea と同じということにする。
57: //
58: // このルーチンは Dn、An、#imm には対応していないので(自明)、呼び出し側で
59: // 事前に弾くこと。いずれも消費クロック数は 0 なので問題ない。
60: // またそれ以外のすべてのアドレッシングモードで反応するため、命令ごとに
61: // 対応していないアドレッシングモードは事前に弾くこと。
62: static inline uint32
63: cea_fpu(m68kcpu *cpu, int bytes)
64: {
65: int n;
66:
67: switch (eamode(RegIR)) {
68: case 0: // Dn
69: case 1: // An
70: break;
71: case 2: // (An)
72: return cea_anin(cpu, eanum(RegIR));
73: case 3: // (An)+
74: CYCLE(6);
75: n = eanum(RegIR);
76: m68030_save_reg_pi(cpu, n);
77: if (bytes == 1) {
78: return internal_ea_anpi_8(cpu, n);
79: } else {
80: // _anpi_{16,32} のマクロは用意されてるけど、これと同じなので
81: RegA(n) += bytes;
82: return RegA(n) - bytes;
83: }
84: break;
85: case 4: // -(An)
86: CYCLE(6);
87: n = eanum(RegIR);
88: m68030_save_reg_pd(cpu, n);
89: if (bytes == 1) {
90: return internal_ea_anpd_8(cpu, n);
91: } else {
92: // _anpd_{16,32} のマクロは用意されてるけど、これと同じなので
93: RegA(n) -= bytes;
94: return RegA(n);
95: }
96: break;
97: case 5: // d16(An)
98: return cea_andi(cpu, eanum(RegIR));
99: case 6: // (An,IX)
100: return cea_anix(cpu, eanum(RegIR));
101: case 7:
102: switch (eanum(RegIR)) {
103: case 0: // Abs.W
104: return cea_absw(cpu);
105: case 1: // Abs.L
106: return cea_absl(cpu);
107: case 2: // d16(PC)
108: return cea_pcdi(cpu);
109: case 3: // (PC,IX)
110: return cea_pcix(cpu);
111: case 4: // #imm
112: break;
113: default:
114: break;
115: }
116: break;
117: }
118: // 不当命令
119: throw M68K_EXCEP_ILLEGAL;
120: }
121:
122: // メモリから 64ビット値を読み込む
123: void
124: m68030_read_64(m68kcpu *cpu, uint32 addr, uint32 *data)
125: {
126: data[0] = m68030_read_32(cpu, addr);
127: data[1] = m68030_read_32(cpu, addr + 4);
128: }
129:
130: // メモリから 96ビット値を読み込む
131: void
132: m68030_read_96(m68kcpu *cpu, uint32 addr, uint32 *data)
133: {
134: data[0] = m68030_read_32(cpu, addr);
135: data[1] = m68030_read_32(cpu, addr + 4);
136: data[2] = m68030_read_32(cpu, addr + 8);
137: }
138:
139: // 64ビット値(.D)をメモリに書き込む
140: void
141: m68030_write_64(m68kcpu *cpu, int32 addr, const uint32 *data)
142: {
143: m68030_write_32(cpu, addr, data[0]);
144: m68030_write_32(cpu, addr + 4, data[1]);
145: }
146:
147: // 96ビット値(.D)をメモリに書き込む
148: void
149: m68030_write_96(m68kcpu *cpu, int32 addr, const uint32 *data)
150: {
151: m68030_write_32(cpu, addr, data[0]);
152: m68030_write_32(cpu, addr + 4, data[1]);
153: m68030_write_32(cpu, addr + 8, data[2]);
154: }
155:
156: // ソースを読み込みます。
157: // 不当命令パターンなら false を返します。
158: // size_id は SIZE_* です。
159: static bool
160: readSRC(m68kcpu *cpu, int size_id, struct fpn *fpn)
161: {
162: struct fpemu *fe = &cpu->fe;
163: uint mr = RegIR & 0x3f;
164: uint32 ea;
165: uint32 data[3];
166:
167: // 68881 本(p6-13) にはクロック数はこう書いてあるので
168: // Inst | src=FPn | memory source or dst operand format
169: // | | Int Sgl Dbl Ext Pakced
170: // ---- +---------- +------ ------- ------- ------- -------
171: // FABS | 35 | 62 54 60 58 872
172: // (差分) +27 +19 +25 +23 +837
173: // FADD | 51 | 80 72 78 76 888
174: // (差分) +29 +21 +27 +25 +837
175: //
176: // FABS.X FPn,FPm は 35 としてこれは fgen() 内で加算。
177: // FABS.L <ea>,FPm は 62 クロックなので、ここでは差分の 27 を加算。
178: // FABS.L Dn,FPm の場合 src がレジスタなので 62 から 5 引く。
179: // FABS.P <ea>,FPm は 872 クロックなので、ここでは差分の 837 を加算。
180: //
181: // XXX 多くの命令が FABS と同じだけの差分だが、
182: // FADD などいくつかは .P 以外に +2 クロックの追加があるようだ。
183: // どうしたもんか。
184:
185: if (mr < 8) { // Dn
186: switch (size_id) {
187: case SIZE_B:
188: data[0] = (int32)(int8)RegD(mr);
189: break;
190: case SIZE_W:
191: data[0] = (int32)(int16)RegD(mr);
192: break;
193: case SIZE_L:
194: case SIZE_S:
195: data[0] = RegD(mr);
196: break;
197: default:
198: return false;
199: }
200: // ソースが Dn の場合は 5クロック減
201: CYCLE(-5);
202: } else if (mr == 0x3c) { // #imm
203: switch (size_id) {
204: case SIZE_B:
205: data[0] = m68030_fetch_16(cpu) & 0xff;
206: break;
207: case SIZE_W:
208: data[0] = m68030_fetch_16(cpu);
209: break;
210: case SIZE_L:
211: case SIZE_S:
212: data[0] = m68030_fetch_32(cpu);
213: break;
214: case SIZE_D:
215: data[0] = m68030_fetch_32(cpu);
216: data[1] = m68030_fetch_32(cpu);
217: break;
218: case SIZE_X:
219: case SIZE_P:
220: data[0] = m68030_fetch_32(cpu);
221: data[1] = m68030_fetch_32(cpu);
222: data[2] = m68030_fetch_32(cpu);
223: break;
224: default:
225: return false;
226: }
227: } else {
228: // それ以外は EA を求めてからメモリから読み込む
229: switch (size_id) {
230: case SIZE_B:
231: ea = cea_fpu(cpu, 1);
232: data[0] = (int32)(int8)m68030_read_8(cpu, ea);
233: break;
234: case SIZE_W:
235: ea = cea_fpu(cpu, 2);
236: data[0] = (int32)(int16)m68030_read_16(cpu, ea);
237: break;
238: case SIZE_L:
239: case SIZE_S:
240: ea = cea_fpu(cpu, 4);
241: data[0] = m68030_read_32(cpu, ea);
242: break;
243: case SIZE_D:
244: ea = cea_fpu(cpu, 8);
245: m68030_read_64(cpu, ea, data);
246: break;
247: case SIZE_X:
248: case SIZE_P:
249: ea = cea_fpu(cpu, 12);
250: m68030_read_96(cpu, ea, data);
251: break;
252: default:
253: return false;
254: }
255: }
256:
257: // 型別に fpn に変換
258: switch (size_id) {
259: case SIZE_B:
260: case SIZE_W:
261: case SIZE_L:
262: CYCLE(+27);
263: fpu_explode(fe, fpn, FTYPE_LNG, data);
264: break;
265: case SIZE_S:
266: CYCLE(+19);
267: fpu_explode(fe, fpn, FTYPE_SNG, data);
268: break;
269: case SIZE_D:
270: CYCLE(+25);
271: fpu_explode(fe, fpn, FTYPE_DBL, data);
272: break;
273: case SIZE_X:
274: CYCLE(+23);
275: fpu_explode(fe, fpn, FTYPE_EXT, data);
276: break;
277: case SIZE_P:
278: CYCLE(+837);
279: fpu_explode(fe, fpn, FTYPE_BCD, data);
280: break;
281: }
282:
283: return true;
284: }
285:
286: // FPU 不当命令 (1ワード目で確定)
287: void
288: fpu_op_illg(m68kcpu *cpu)
289: {
290: cpulog(1, "FPU 不当命令 %04X", RegIR);
291: m68030_exception(cpu, M68K_EXCEP_FLINE);
292: }
293:
294: // FPU 不当命令 (2ワード目で確定)
295: void
296: fpu_op_illg2(m68kcpu *cpu)
297: {
298: cpulog(1, "FPU 不当命令 %04X %04X", RegIR, RegIR2);
299: m68030_exception(cpu, M68K_EXCEP_FLINE);
300: }
301:
302: // R/M=0 (レジスタ-レジスタ演算)
303: void
304: fpu_op_fgen_reg(m68kcpu *cpu)
305: {
306: struct fpemu *fe = &cpu->fe;
307: uint srcnum = (RegIR2 >> 10) & 7;
308: uint dstnum = (RegIR2 >> 7) & 7;
309:
310: fpu_explode(fe, &fe->fe_f2, FTYPE_EXT, &RegFP(srcnum * 3));
311: fpu_explode(fe, &fe->fe_f1, FTYPE_EXT, &RegFP(dstnum * 3));
312: fgen(cpu);
313: }
314:
315: // R/M=1 (メモリ-レジスタ演算)
316: void
317: fpu_op_fgen_mem(m68kcpu *cpu)
318: {
319: struct fpemu *fe = &cpu->fe;
320: uint size_id = (RegIR2 >> 10) & 7;
321: uint dstnum = (RegIR2 >> 7) & 7;
322:
323: // source specifier はオペランドサイズ
324: if (size_id == 7) {
325: // こんなところに FMOVECR
326: fpu_op_fmovecr(cpu);
327: return;
328: }
329:
330: // 第1ワードの EA がソース EA
331: if (!readSRC(cpu, size_id, &fe->fe_f2)) {
332: fpu_op_illg2(cpu);
333: return;
334: }
335: fpu_explode(fe, &fe->fe_f1, FTYPE_EXT, &RegFP(dstnum * 3));
336: fgen(cpu);
337: }
338:
339: // 一般算術演算
340: static void
341: fgen(m68kcpu *cpu)
342: {
343: struct fpemu *fe = &cpu->fe;
344: uint opmode = RegIR2 & 0x3f;
345: uint dstnum = (RegIR2 >> 7) & 7;
346: bool discard_result = false;
347: struct fpn *res = NULL; // shutup gcc
348:
349: switch (opmode) {
350: case 0x00: // FMOVE
351: CYCLE(33);
352: res = &fe->fe_f2;
353: fpu_round_prec(fe, res);
354: break;
355: case 0x01: // FINT
356: CYCLE(55);
357: res = fpu_int(fe);
358: break;
359: case 0x02: // FSINH
360: CYCLE(687);
361: res = fpu_sinh(fe);
362: fpu_round_prec(fe, res);
363: break;
364: case 0x03: // FINTRZ
365: CYCLE(55);
366: res = fpu_intrz(fe);
367: break;
368: case 0x04: // FSQRT
369: CYCLE(107);
370: res = fpu_sqrt(fe);
371: fpu_round_prec(fe, res);
372: break;
373: case 0x06: // FLOGNP1
374: CYCLE(571);
375: res = fpu_lognp1(fe);
376: fpu_round_prec(fe, res);
377: break;
378: case 0x08: // FETOXM1
379: CYCLE(545);
380: res = fpu_etoxm1(fe);
381: fpu_round_prec(fe, res);
382: break;
383: case 0x09: // FTANH
384: CYCLE(661);
385: res = fpu_tanh(fe);
386: fpu_round_prec(fe, res);
387: break;
388: case 0x0a: // FATAN
389: CYCLE(403);
390: res = fpu_atan(fe);
391: fpu_round_prec(fe, res);
392: break;
393: case 0x0c: // FASIN
394: CYCLE(581);
395: res = fpu_asin(fe);
396: fpu_round_prec(fe, res);
397: break;
398: case 0x0d: // FATANH
399: CYCLE(693);
400: res = fpu_atanh(fe);
401: fpu_round_prec(fe, res);
402: break;
403: case 0x0e: // FSIN
404: CYCLE(391);
405: res = fpu_sin(fe);
406: fpu_round_prec(fe, res);
407: break;
408: case 0x0f: // FTAN
409: CYCLE(473);
410: res = fpu_tan(fe);
411: fpu_round_prec(fe, res);
412: break;
413: case 0x10: // FETOX
414: CYCLE(497);
415: res = fpu_etox(fe);
416: fpu_round_prec(fe, res);
417: break;
418: case 0x11: // FTWOTOX
419: CYCLE(567);
420: res = fpu_twotox(fe);
421: fpu_round_prec(fe, res);
422: break;
423: case 0x12: // FTENTOX
424: CYCLE(567);
425: res = fpu_tentox(fe);
426: fpu_round_prec(fe, res);
427: break;
428: case 0x14: // FLOGN
429: CYCLE(525);
430: res = fpu_logn(fe);
431: fpu_round_prec(fe, res);
432: break;
433: case 0x15: // FLOG10
434: CYCLE(581);
435: res = fpu_log10(fe);
436: fpu_round_prec(fe, res);
437: break;
438: case 0x16: // FLOG2
439: CYCLE(581);
440: res = fpu_log2(fe);
441: fpu_round_prec(fe, res);
442: break;
443: case 0x18: // FABS
444: CYCLE(35);
445: fe->fe_f2.fp_sign = 0;
446: res = &fe->fe_f2;
447: fpu_round_prec(fe, res);
448: break;
449: case 0x19: // FCOSH
450: CYCLE(607);
451: res = fpu_cosh(fe);
452: fpu_round_prec(fe, res);
453: break;
454: case 0x1a: // FNEG
455: CYCLE(35);
456: res = &fe->fe_f2;
457: if (!ISNAN(res)) {
458: res->fp_sign = !res->fp_sign;
459: fpu_round_prec(fe, res);
460: }
461: break;
462: case 0x1c: // FACOS
463: CYCLE(625);
464: res = fpu_acos(fe);
465: fpu_round_prec(fe, res);
466: break;
467: case 0x1d: // FCOS
468: CYCLE(391);
469: res = fpu_cos(fe);
470: fpu_round_prec(fe, res);
471: break;
472: case 0x1e: // FGETEXP
473: CYCLE(45);
474: res = fpu_getexp(fe);
475: fpu_round_prec(fe, res);
476: break;
477: case 0x1f: // FGETMAN
478: CYCLE(31);
479: res = fpu_getman(fe);
480: fpu_round_prec(fe, res);
481: break;
482: case 0x20: // FDIV
483: CYCLE(103);
484: res = fpu_div(fe);
485: fpu_round_prec(fe, res);
486: break;
487: case 0x21: // FMOD
488: CYCLE(67);
489: res = fpu_mod(fe);
490: fpu_round_prec(fe, res);
491: break;
492: case 0x22: // FADD
493: CYCLE(51);
494: res = fpu_add(fe);
495: fpu_round_prec(fe, res);
496: break;
497: case 0x23: // FMUL
498: CYCLE(71);
499: res = fpu_mul(fe);
500: fpu_round_prec(fe, res);
501: break;
502: case 0x24: // FSGLDIV
503: CYCLE(69);
504: res = fpu_sgldiv(fe);
505: break;
506: case 0x25: // FREM
507: CYCLE(67);
508: res = fpu_rem(fe);
509: fpu_round_prec(fe, res);
510: break;
511: case 0x26: // FSCALE
512: // こいつだけ形式が違う。
513: // 結果は dst に直接格納済み、FPSR も演算済み。
514: CYCLE(41);
515: fpu_emul_fscale(fe, RegIR2);
516: return;
517: case 0x27: // FSGLMUL
518: CYCLE(59);
519: res = fpu_sglmul(fe);
520: break;
521: case 0x28: // FSUB
522: CYCLE(51);
523: res = fpu_sub(fe);
524: fpu_round_prec(fe, res);
525: break;
526: case 0x30:
527: case 0x31:
528: case 0x32:
529: case 0x33:
530: case 0x34:
531: case 0x35:
532: case 0x36:
533: case 0x37: // FSINCOS
534: CYCLE(451);
535: res = fpu_sincos(fe, opmode & 7);
536: fpu_round_prec(fe, res);
537: break;
538: case 0x38: // FCMP
539: CYCLE(33);
540: res = fpu_cmp(fe);
541: discard_result = 1;
542: break;
543: case 0x3a: // FTST
544: CYCLE(33);
545: res = &fe->fe_f2;
546: discard_result = 1;
547: break;
548:
549: default:
550: // 不当命令
551: fpu_op_illg2(cpu);
552: return;
553: }
554:
555: assert(res);
556: if (!discard_result) {
557: fpu_implode(fe, res, FTYPE_EXT, &RegFP(dstnum * 3));
558: }
559: fpu_upd_fpsr(fe, res);
560: fpu_upd_excp(fe);
561: }
562:
563: // FMOVECR
564: void
565: fpu_op_fmovecr(m68kcpu *cpu)
566: {
567: CYCLE(29);
568:
569: struct fpemu *fe = &cpu->fe;
570: uint offset = (RegIR2 & 0x7f);
571: uint dstnum = (RegIR2 >> 7) & 7;
572:
573: fpu_const(&fe->fe_f3, offset);
574: fpu_implode(fe, &fe->fe_f3, FTYPE_EXT, &RegFP(dstnum * 3));
575: fpu_upd_fpsr(fe, &fe->fe_f3);
576: fpu_upd_excp(fe);
577: }
578:
579: // FMOVE.B FPn,<ea>
580: // cf. 68000PRM.pdf p378 (5-76)
581: void
582: fpu_op_fmove_b_mem(m68kcpu *cpu)
583: {
584: struct fpemu *fe = &cpu->fe;
585: uint mr = RegIR & 0x3f;
586: uint srcnum = (RegIR2 >> 7) & 7;
587: uint32 ea;
588: uint32 data;
589:
590: fpu_explode(fe, &fe->fe_f3, FTYPE_EXT, &RegFP(srcnum * 3));
591: fpu_implode(fe, &fe->fe_f3, FTYPE_LNG, &data);
592: if ((int32)data < INT8_MIN || (int32)data > INT8_MAX) {
593: RegFPSR |= FPSR_OPERR | FPSR_AIOP;
594: }
595:
596: if (mr < 8) { // Dn
597: CYCLE(100-2);
598: RegD(mr) &= 0xffffff00;
599: RegD(mr) |= (uint8)data;
600: } else {
601: CYCLE(100);
602: ea = cea_fpu(cpu, 1);
603: m68030_write_8(cpu, ea, (uint8)data);
604: }
605: }
606:
607: // FMOVE.W FPn,<ea>
608: // cf. 68000PRM.pdf p378 (5-76)
609: void
610: fpu_op_fmove_w_mem(m68kcpu *cpu)
611: {
612: struct fpemu *fe = &cpu->fe;
613: uint mr = RegIR & 0x3f;
614: uint srcnum = (RegIR2 >> 7) & 7;
615: uint32 ea;
616: uint32 data;
617:
618: fpu_explode(fe, &fe->fe_f3, FTYPE_EXT, &RegFP(srcnum * 3));
619: fpu_implode(fe, &fe->fe_f3, FTYPE_LNG, &data);
620: if ((int32)data < INT16_MIN || (int32)data > INT16_MAX) {
621: RegFPSR |= FPSR_OPERR | FPSR_AIOP;
622: }
623:
624: if (mr < 8) { // Dn
625: CYCLE(100-2);
626: RegD(mr) &= 0xffff0000;
627: RegD(mr) |= (uint16)data;
628: } else {
629: CYCLE(100);
630: ea = cea_fpu(cpu, 2);
631: m68030_write_16(cpu, ea, (uint16)data);
632: }
633: }
634:
635: // FMOVE.L FPn,<ea>
636: // cf. 68000PRM.pdf p378 (5-76)
637: void
638: fpu_op_fmove_l_mem(m68kcpu *cpu)
639: {
640: struct fpemu *fe = &cpu->fe;
641: uint mr = RegIR & 0x3f;
642: uint srcnum = (RegIR2 >> 7) & 7;
643: uint32 ea;
644: uint32 data;
645:
646: fpu_explode(fe, &fe->fe_f3, FTYPE_EXT, &RegFP(srcnum * 3));
647: fpu_implode(fe, &fe->fe_f3, FTYPE_LNG, &data);
648: // XXX オーバーフローチェック
649:
650: if (mr < 8) { // Dn
651: CYCLE(100-2);
652: RegD(mr) = data;
653: } else {
654: CYCLE(100);
655: ea = cea_fpu(cpu, 4);
656: m68030_write_32(cpu, ea, data);
657: }
658: }
659:
660: // FMOVE.S FPn,<ea>
661: // cf. 68000PRM.pdf p378 (5-76)
662: void
663: fpu_op_fmove_s_mem(m68kcpu *cpu)
664: {
665: struct fpemu *fe = &cpu->fe;
666: uint mr = RegIR & 0x3f;
667: uint srcnum = (RegIR2 >> 7) & 7;
668: uint32 ea;
669: uint32 data;
670:
671: fpu_explode(fe, &fe->fe_f3, FTYPE_EXT, &RegFP(srcnum * 3));
672: fpu_implode(fe, &fe->fe_f3, FTYPE_SNG, &data);
673:
674: if (mr < 8) { // Dn
675: CYCLE(80-2);
676: RegD(mr) = data;
677: } else {
678: CYCLE(80);
679: ea = cea_fpu(cpu, 4);
680: m68030_write_32(cpu, ea, data);
681: }
682: }
683:
684: // FMOVE.D FPn,<ea>
685: // cf. 68000PRM.pdf p378 (5-76)
686: void
687: fpu_op_fmove_d_mem(m68kcpu *cpu)
688: {
689: CYCLE(86);
690:
691: struct fpemu *fe = &cpu->fe;
692: uint srcnum = (RegIR2 >> 7) & 7;
693: uint32 ea;
694: uint32 data[2];
695:
696: fpu_explode(fe, &fe->fe_f3, FTYPE_EXT, &RegFP(srcnum * 3));
697: fpu_implode(fe, &fe->fe_f3, FTYPE_DBL, data);
698:
699: ea = cea_fpu(cpu, 8);
700: m68030_write_64(cpu, ea, data);
701: }
702:
703: // FMOVE.X FPn,<ea>
704: // cf. 68000PRM.pdf p378 (5-76)
705: void
706: fpu_op_fmove_x_mem(m68kcpu *cpu)
707: {
708: CYCLE(72);
709:
710: uint srcnum = (RegIR2 >> 7) & 7;
711: uint32 ea;
712:
713: ea = cea_fpu(cpu, 12);
714: m68030_write_96(cpu, ea, &RegFP(srcnum * 3));
715: }
716:
717: // FMOVE.P FPn,<ea>
718: // cf. 68000PRM.pdf p378 (5-76)
719: void
720: fpu_op_fmove_p_mem(m68kcpu *cpu)
721: {
722: struct fpemu *fe = &cpu->fe;
723: uint srcnum = (RegIR2 >> 7) & 7;
724: uint32 ea;
725: uint32 data[3];
726: uint32 k;
727:
728: if ((RegIR2 & 0x1000)) {
729: // dynamic k-factor
730: CYCLE(1996+14);
731: k = RegD((RegIR2 >> 4) & 7);
732: } else {
733: // static k-factor
734: CYCLE(1996);
735: k = RegIR2;
736: }
737: // k は7ビット符号付き数
738: k &= 0x7f;
739: if ((k & 0x40)) {
740: k = (int32)(int8)(k | 0x80);
741: }
742:
743: fpu_explode(fe, &fe->fe_f3, FTYPE_EXT, &RegFP(srcnum * 3));
744: fpu_ftop(fe, &fe->fe_f3, data, k);
745:
746: ea = cea_fpu(cpu, 12);
747: m68030_write_96(cpu, ea, data);
748: }
749:
750: // FMOVEM.L <ea>,<ctllist>
751: // 1111 ccc 000 mmmrrr | 10D RRR 0000 000000
752: // D=0: <ea> to FPctl
753: // RRR: register list
754: void
755: fpu_op_fmovem_ea2ctl(m68kcpu *cpu)
756: {
757: uint mr = RegIR & 0x3f;
758: uint reglist = (RegIR2 >> 10) & 7;
759: int count;
760: uint32 ea;
761: uint32 src[3];
762: int i;
763:
764: // cache case worst case
765: // FMOVE Rn,FPc 28 31
766: // FMOVE <ea>,FPc 33 36
767: // FMOVE #imm,FPc 30 31
768: // FMOVEM <ea>,FPcs 27+6n 30+6n
769: // FMOVEM #imm,FPcs 25+6n 29+6n
770: //
771: // FMOVE #imm と FMOVEM #imm (n==1) は cache case が 1クロックだけ違う
772: // ようだけどもう無視する。
773:
774: // 転送するレジスタ数
775: // ただし nofpc は FPIAR とみなされるようだ。see exp/fmovem.php
776: if (reglist == 0)
777: reglist = 1;
778: count = __builtin_popcount(reglist);
779:
780: if (mr < 8) { // Dn
781: CYCLE2(28, 31);
782: // 対データレジスタは転送数 1 のみ有効
783: if (count > 1) {
784: fpu_op_illg2(cpu);
785: return;
786: }
787: src[0] = RegR(mr);
788:
789: } else if (mr < 16) { // An
790: CYCLE2(28, 31);
791: // 対アドレスレジスタは FPIAR のみ有効
792: if (reglist != 1) {
793: fpu_op_illg2(cpu);
794: return;
795: }
796: src[0] = RegR(mr);
797:
798: } else if (mr < 0x3c) { // 対メモリ
799: CYCLE2(28, 30);
800: CYCLE(count * 6);
801:
802: // EA を取得。
803: // -(An) の時も先にレジスタ数分一気に減算して、そこからプラス方向に
804: // 読み込んでいくので、ロジックは全部同じになる。
805: // (68000PRM.pdf p393)
806: ea = cea_fpu(cpu, count * 4);
807: for (i = 0; i < count; i++) {
808: src[i] = m68030_read_32(cpu, ea);
809: ea += 4;
810: }
811:
812: } else if (mr == 0x3c) { // #imm
813: CYCLE2(25, 29);
814: CYCLE(count * 6);
815:
816: for (i = 0; i < count; i++) {
817: src[i] = m68030_fetch_32(cpu);
818: }
819:
820: } else {
821: fpu_op_illg2(cpu);
822: return;
823: }
824:
825: // 該当レジスタへ読み込み
826: i = 0;
827: if ((reglist & 4)) {
828: RegFPCR = src[i++] & M68K_FPCR_MASK;
829: }
830: if ((reglist & 2)) {
831: RegFPSR = src[i++] & M68K_FPSR_MASK;
832: }
833: if ((reglist & 1)) {
834: RegFPIAR = src[i++];
835: }
836: }
837:
838: // FMOVEM.L <ctllist>,<ea>
839: // 1111 ccc 000 mmmrrr | 10D RRR 0000 000000
840: // D=1: FPctl to <ea>
841: // RRR: register list
842: void
843: fpu_op_fmovem_ctl2ea(m68kcpu *cpu)
844: {
845: uint mr = RegIR & 0x3f;
846: uint reglist = (RegIR2 >> 10) & 7;
847: int count;
848: uint32 ea;
849:
850: // cache case worst case
851: // FMOVE FPc,Rn 31 34
852: // FMOVE FPc,<ea> 33 36
853: // FMOVEM FPcs,<ea> 27+6n 30+6n
854:
855: // 転送するレジスタ数
856: // ただし nofpc は FPIAR とみなされるようだ。see exp/fmovem.php
857: if (reglist == 0)
858: reglist = 1;
859: count = __builtin_popcount(reglist);
860:
861: if (mr < 8) { // Dn
862: CYCLE2(31, 34);
863: // 対データレジスタは転送数は 1 のみ有効
864: if (count > 1) {
865: fpu_op_illg2(cpu);
866: return;
867: }
868:
869: if ((reglist & 4)) {
870: RegR(mr) = RegFPCR;
871: }
872: if ((reglist & 2)) {
873: RegR(mr) = RegFPSR;
874: }
875: if ((reglist & 1)) {
876: RegR(mr) = RegFPIAR;
877: }
878: return;
879: }
880: if (mr < 16) { // An
881: CYCLE2(31, 34);
882: // 対アドレスレジスタは FPIAR のみ有効
883: if (reglist != 1) {
884: fpu_op_illg2(cpu);
885: return;
886: }
887: RegR(mr) = RegFPIAR;
888: return;
889: }
890: if (mr >= 0x3a) { // #imm, d16(PC), (PC,IX)
891: fpu_op_illg2(cpu);
892: return;
893: }
894:
895: // それ以外、対メモリの場合。
896: CYCLE2(27, 30);
897: CYCLE(count * 6);
898:
899: // EA を取得して...
900: ea = cea_fpu(cpu, count * 4);
901: // 該当レジスタをメモリへ書き出し
902: if ((reglist & 4)) {
903: m68030_write_32(cpu, ea, RegFPCR);
904: ea += 4;
905: }
906: if ((reglist & 2)) {
907: m68030_write_32(cpu, ea, RegFPSR);
908: ea += 4;
909: }
910: if ((reglist & 1)) {
911: m68030_write_32(cpu, ea, RegFPIAR);
912: ea += 4;
913: }
914: }
915:
916: // FMOVEM.X <ea>,<reglist>
917: // FMOVEM.X <ea>,Dn
918: // 1111 ccc 000 mmmrrr | 11D MM000 RRRRRRRR
919: // D=0: <ea> to FPn
920: void
921: fpu_op_fmovem_ea2reg(m68kcpu *cpu)
922: {
923: uint mr = RegIR & 0x3f;
924: bool predec = !(RegIR2 & 0x1000);
925: bool dynamic = (RegIR2 & 0x0800);
926: uint8 reglist = RegIR2 & 0xff;
927: int i;
928: uint32 ea;
929:
930: // cache worst
931: // FMOVEM.X <ea>,<list> 35+23n 38+23n
932: // FMOVEM.X <ea>,Dn 49+23n 52+23n
933:
934: // 不当パターンを弾く
935: switch (mr) {
936: case 0x00 ... 0x07: // Dn
937: case 0x08 ... 0x0f: // An
938: case 0x20 ... 0x27: // -(An)
939: case 0x3c: // #imm
940: case 0x3d ... 0x3f:
941: fpu_op_illg2(cpu);
942: return;
943: }
944:
945: // ダイナミックモードなら reglist の %0nnn0000 にレジスタ番号が
946: // 入っているので、この Dn の下位8ビットを取り出す。レジスタ番号以外の
947: // ビットは無視、Dn の上位ビットも無視。
948: // ついでにここでベースクロックを記録
949: if (dynamic) {
950: reglist = RegD((reglist >> 4) & 7);
951: CYCLE2(49, 52);
952: } else {
953: CYCLE2(35, 38);
954: }
955:
956: // EA は最初に一度取得しておいて...
957: int count = __builtin_popcount(reglist);
958: ea = cea_fpu(cpu, 12 * count);
959:
960: if (predec) {
961: // predec ならビット7から FP7..FP0 で、bit7 側から順に転送。
962: for (i = 7; reglist; reglist <<=1, i--) {
963: if ((int8)reglist < 0) {
964: m68030_read_96(cpu, ea, &RegFP(i * 3));
965: ea += 12;
966: }
967: }
968: } else {
969: // ctrl/postinc ならビット7から FP0..FP7 で、bit7 側から順に転送。
970: for (i = 0; reglist; reglist <<= 1, i++) {
971: if ((int8)reglist < 0) {
972: m68030_read_96(cpu, ea, &RegFP(i * 3));
973: ea += 12;
974: }
975: }
976: }
977: CYCLE(23 * count);
978: }
979:
980: // FMOVEM.X <reglist>,<ea>
981: // FMOVEM.X Dn,<ea>
982: // 1111 ccc 000 mmmrrr | 11D MM000 RRRRRRRR
983: // D=1: FPn to <ea>
984: void
985: fpu_op_fmovem_reg2ea(m68kcpu *cpu)
986: {
987: uint mr = RegIR & 0x3f;
988: bool anpd = false; // 第1ワード EA が -(An) か
989: bool predec = !(RegIR2 & 0x1000); // 第2ワードの mode が predec か
990: bool dynamic = (RegIR2 & 0x0800);
991: uint8 reglist = RegIR2 & 0xff;
992: int i;
993: uint32 ea;
994:
995: // cache worst
996: // FMOVEM.X <list>,<ea> 37+25n 40+25n
997: // FMOVEM.X Dn,<ea> 51+25n 54+25n
998:
999: // 不当パターンを弾く
1000: // ついでに -(An) だけ覚えておく
1001: switch (mr) {
1002: case 0x00 ... 0x07: // Dn
1003: case 0x08 ... 0x0f: // An
1004: case 0x18 ... 0x1f: // (An)+
1005: case 0x3a: // d16(PC)
1006: case 0x3b: // (PC,IX)
1007: case 0x3c: // #imm
1008: case 0x3d ... 0x3f:
1009: fpu_op_illg2(cpu);
1010: return;
1011: case 0x20 ... 0x27: // -(An)
1012: anpd = true;
1013: break;
1014: }
1015:
1016: // ダイナミックモードなら reglist の %0nnn0000 にレジスタ番号が
1017: // 入っているので、この Dn の下位8ビットを取り出す。レジスタ番号以外の
1018: // ビットは無視、Dn の上位ビットも無視。
1019: // ついでにここでベースクロックを記録
1020: if (dynamic) {
1021: reglist = RegD((reglist >> 4) & 7);
1022: CYCLE2(51, 54);
1023: } else {
1024: CYCLE2(37, 40);
1025: }
1026:
1027: int count = __builtin_popcount(reglist);
1028:
1029: // -(An) の時だけ EA を別処理。
1030: // 現状の cea_fpu() は -(An) の時、巻き戻し用のレジスタを保存し
1031: // デクリメントしたアドレスを返すまでを一度に行う便利関数だが、
1032: // FMOVEM fpn,-(An) は最初に巻き戻し用レジスタを保存し (これは命令先頭
1033: // に戻るためなので最初の1回だけ)、その後レジスタ1つずつ 12バイトを
1034: // プリデクリメントしながら格納していく必要がある (この順に実行しないと
1035: // バスエラーの原因箇所が異なってしまう)。
1036: // そのため cea_fpu() がそのまま使えないので、ここだけ独自対応する。
1037: // cea_fpu() は1命令中で EA の取得が1回である前提のあくまで便利関数
1038: // なので、例外的である FMOVEM は仕方がない。
1039: if (anpd) {
1040: CYCLE(6);
1041: uint n = eanum(RegIR);
1042: m68030_save_reg_pd(cpu, n);
1043:
1044: if (predec) {
1045: // predec ならビット7から FP7..FP0 で、bit7 側から順に転送。
1046: for (i = 7; reglist; reglist <<= 1, i--) {
1047: if ((int8)reglist < 0) {
1048: RegA(n) -= 12;
1049: m68030_write_96(cpu, RegA(n), &RegFP(i * 3));
1050: }
1051: }
1052: } else {
1053: // ctrl/postinc ならビット7から FP0..FP7 で、bit7 側から順に転送。
1054: for (i = 0; reglist; reglist <<= 1, i++) {
1055: if ((int8)reglist < 0) {
1056: RegA(n) -= 12;
1057: m68030_write_96(cpu, RegA(n), &RegFP(i * 3));
1058: }
1059: }
1060: }
1061: } else {
1062: // -(An) 以外は EA を最初に一度計算しておく方法が使える
1063: ea = cea_fpu(cpu, 12 * count);
1064:
1065: if (predec) {
1066: // predec ならビット7から FP7..FP0 で、bit7 側から順に転送。
1067: for (i = 7; reglist; reglist <<= 1, i--) {
1068: if ((int8)reglist < 0) {
1069: m68030_write_96(cpu, ea, &RegFP(i * 3));
1070: ea += 12;
1071: }
1072: }
1073: } else {
1074: // ctrl/postinc ならビット7から FP0..FP7 で、bit7 側から順に転送。
1075: for (i = 0; reglist; reglist <<= 1, i++) {
1076: if ((int8)reglist < 0) {
1077: m68030_write_96(cpu, ea, &RegFP(i * 3));
1078: ea += 12;
1079: }
1080: }
1081: }
1082: }
1083: CYCLE(25 * count);
1084: }
1085:
1086: // FScc.B <ea>
1087: // 1111 ccc 001 mmmrrr | 0000 000 000 CCCCCC
1088: void
1089: fpu_op_fscc(m68kcpu *cpu)
1090: {
1091: struct fpemu *fe = &cpu->fe;
1092: uint mr = RegIR & 0x3f;
1093: uint mm = eamode(RegIR);
1094: uint rr = eanum(RegIR);
1095: uint cond = RegIR2 & 0x3f;
1096: int data;
1097: uint32 ea;
1098:
1099: // cache worst
1100: // FScc.B Dn 18 21
1101: // FScc.B (An)+/-(An) 22 25 ; condition is true
1102: // FScc.B (An)+/-(An) 21 24 ; condition is false
1103: // FScc.B <ea> 20 23
1104:
1105: if (cond > 0x1f) {
1106: fpu_op_illg2(cpu);
1107: return;
1108: }
1109:
1110: data = (test_cc(fe, cond) == -1) ? 0xff : 0x00;
1111:
1112: switch (mm) {
1113: case 0: // Dn
1114: CYCLE2(18, 21);
1115: RegD(rr) &= 0xffffff00;
1116: RegD(rr) |= data;
1117: return;
1118:
1119: case 3: // (An)+
1120: case 4: // -(An)
1121: // ここだけ他のメモリ系 EA とはクロックが違うし、
1122: // 条件の成立可否でも違う。
1123: if (data == 0x00) {
1124: CYCLE2(21, 24);
1125: } else {
1126: CYCLE2(22, 25);
1127: }
1128: break;
1129: case 7:
1130: if (mr == 0x38 || mr == 0x39) { // Abs.W, Abs.L
1131: } else {
1132: fpu_op_illg2(cpu);
1133: return;
1134: }
1135: FALLTHROUGH;
1136: default:
1137: CYCLE2(20, 23);
1138: break;
1139: }
1140:
1141: ea = cea_fpu(cpu, 1);
1142: m68030_write_8(cpu, ea, data);
1143: }
1144:
1145: // FDBcc Dn,<label>
1146: // 1111 ccc 001 001rrr | 0000 000 000 CCCCCC | <16bit disp>
1147: void
1148: fpu_op_fdbcc(m68kcpu *cpu)
1149: {
1150: struct fpemu *fe = &cpu->fe;
1151: uint rr = RegIR & 7;
1152: uint cond = RegIR2 & 0x3f;
1153:
1154: if (cond > 0x1f) {
1155: fpu_op_illg2(cpu);
1156: return;
1157: }
1158:
1159: if (test_cc(fe, cond) == -1) {
1160: // 真なら何もしない。disp を読み飛ばして次へ
1161: CYCLE2(20, 24);
1162: m68030_fetch_16(cpu);
1163: } else {
1164: // 偽の場合
1165: uint16 data = RegD(rr) - 1;
1166: RegD(rr) = (RegD(rr) & 0xffff0000) | data;
1167:
1168: if (data == 0xffff) {
1169: // ループ終了。disp を読み飛ばす
1170: CYCLE2(24, 32);
1171: m68030_fetch_16(cpu);
1172: } else {
1173: // 計算に使う PC は FDBcc 命令+2 のところらしい
1174: CYCLE2(20, 26);
1175: uint32 pc = RegPPC + 2;
1176: int32 disp = (int32)(int16)m68030_fetch_16(cpu);
1177: m68030_jump(cpu, pc + disp);
1178: }
1179: }
1180: }
1181:
1182: // FTRAPcc.W #<data>
1183: void
1184: fpu_op_ftrapcc_w(m68kcpu *cpu)
1185: {
1186: struct fpemu *fe = &cpu->fe;
1187: uint cond = RegIR2 & 0x3f;
1188:
1189: if (cond > 0x1f) {
1190: fpu_op_illg2(cpu);
1191: return;
1192: }
1193:
1194: if (test_cc(fe, cond) == -1) {
1195: // TODO: 例外発生
1196: CYCLE2(41, 45);
1197: PANIC("unimpl ftrapcc_w at %08X", RegPPC);
1198: } else {
1199: // 即値は読み捨て
1200: CYCLE2(20, 23);
1201: m68030_fetch_16(cpu);
1202: }
1203: }
1204:
1205: // FTRAPcc.L #<data>
1206: void
1207: fpu_op_ftrapcc_l(m68kcpu *cpu)
1208: {
1209: struct fpemu *fe = &cpu->fe;
1210: uint cond = RegIR2 & 0x3f;
1211:
1212: if (cond > 0x1f) {
1213: fpu_op_illg2(cpu);
1214: return;
1215: }
1216:
1217: if (test_cc(fe, cond) == -1) {
1218: // TODO: 例外発生
1219: CYCLE2(43, 52);
1220: PANIC("unimpl ftrapcc_l at %08X", RegPPC);
1221: } else {
1222: // 即値は読み捨て
1223: CYCLE2(22, 27);
1224: m68030_fetch_32(cpu);
1225: }
1226: }
1227:
1228: // FTRAPcc
1229: void
1230: fpu_op_ftrapcc(m68kcpu *cpu)
1231: {
1232: struct fpemu *fe = &cpu->fe;
1233: uint cond = RegIR2 & 0x3f;
1234:
1235: if (cond > 0x1f) {
1236: fpu_op_illg2(cpu);
1237: return;
1238: }
1239:
1240: if (test_cc(fe, cond) == -1) {
1241: // TODO: 例外発生
1242: CYCLE2(39, 47);
1243: PANIC("unimpl ftrapcc_l at %08X", RegPPC);
1244: } else {
1245: // 即値はないので、何もしない
1246: CYCLE2(18, 22);
1247: }
1248: }
1249:
1250: // FBcc.W <label>
1251: // 1111 ccc 01S CCCCCC | <16bit disp>
1252: // S=0: 16bit disp
1253: //
1254: // FNOP
1255: // 1111 ccc 010 000000 | 0000 0000 0000 0000
1256: void
1257: fpu_op_fbcc_w(m68kcpu *cpu)
1258: {
1259: struct fpemu *fe = &cpu->fe;
1260: uint cond = RegIR & 0x3f;
1261:
1262: if (test_cc(fe, cond) == -1) {
1263: CYCLE2(20, 23);
1264: uint32 pc = RegPC;
1265: int32 disp = (int32)(int16)m68030_fetch_16(cpu);
1266: m68030_jump(cpu, pc + disp);
1267: } else {
1268: // disp を読み飛ばす
1269: CYCLE2(18, 19);
1270: m68030_fetch_16(cpu);
1271: }
1272: }
1273:
1274: // FBcc.L <label>
1275: // 1111 ccc 01S CCCCCC | <32bit disp>
1276: // S=1: 32bit disp
1277: void
1278: fpu_op_fbcc_l(m68kcpu *cpu)
1279: {
1280: struct fpemu *fe = &cpu->fe;
1281: uint cond = RegIR & 0x3f;
1282:
1283: if (test_cc(fe, cond) == -1) {
1284: CYCLE2(20, 23);
1285: uint32 pc = RegPC;
1286: int32 disp = (int32)m68030_fetch_32(cpu);
1287: m68030_jump(cpu, pc + disp);
1288: } else {
1289: // disp を読み飛ばす
1290: CYCLE2(18, 21);
1291: m68030_fetch_32(cpu);
1292: }
1293: }
1294:
1295: // FSAVE の NULL フレーム (全機種共通で4バイト)
1296: static const uint32 fsave_frame_null[] = {
1297: 0,
1298: };
1299:
1300: // FSAVE のアイドルフレーム (68881 は 0x1c = 28 バイト、 7ロングワード)
1301: static const uint32 fsave_frame_idle[] = {
1302: 0x1f180000,
1303: 0,
1304: 0,
1305: 0,
1306: 0,
1307: 0,
1308: 0x70000000,
1309: };
1310:
1311: // FSAVE
1312: // スーパーバイザモードは判定済み
1313: void
1314: fpu_op_fsave(m68kcpu *cpu)
1315: {
1316: uint mm = eamode(RegIR);
1317: uint rr = eanum(RegIR);
1318: uint32 ea;
1319: const uint32 *frame;
1320: int framelen;
1321:
1322: // XXX EA が -(An) の時 An が逐次減算て書いてあるソースきぼんぬ
1323:
1324: // フレームを選択
1325: if (cpu->fpu_dirty == false) {
1326: // NULL フレーム
1327: CYCLE2(16, 18);
1328: frame = fsave_frame_null;
1329: framelen = countof(fsave_frame_null);
1330: } else {
1331: // IDLE フレーム
1332: CYCLE2(52, 54); // XXX これは最小値らしいけど
1333: frame = fsave_frame_idle;
1334: framelen = countof(fsave_frame_idle);
1335: }
1336:
1337: // EA は独自体系なのでここでべたに書く
1338: switch (mm) {
1339: case 2: // (An)
1340: ea = cea_anin(cpu, rr);
1341: break;
1342: case 4: // -(An)
1343: // これだけ処理が違うので、ここでやる
1344: m68030_save_reg_pd(cpu, rr);
1345: for (int i = framelen; i >= 0; i--) {
1346: RegA(rr) -= 4;
1347: m68030_write_32(cpu, RegA(rr), frame[i]);
1348: }
1349: return;
1350:
1351: case 5: // d16(An)
1352: ea = cea_andi(cpu, rr);
1353: break;
1354: case 6: // (An,IX)
1355: ea = cea_anix(cpu, rr);
1356: break;
1357: case 7:
1358: switch (rr) {
1359: case 0: // Abs.W
1360: ea = cea_absw(cpu);
1361: break;
1362: case 1: // Abs.L
1363: ea = cea_absl(cpu);
1364: break;
1365: default:
1366: fpu_op_illg(cpu);
1367: return;
1368: }
1369: break;
1370: default:
1371: fpu_op_illg(cpu);
1372: return;
1373: }
1374:
1375: // -(An) 以外の EA の場合
1376: for (int i = 0; i < framelen; i++) {
1377: m68030_write_32(cpu, ea, frame[i]);
1378: ea += 4;
1379: }
1380: }
1381:
1382: // FRESTORE
1383: // スーパーバイザモードは判定済み
1384: void
1385: fpu_op_frestore(m68kcpu *cpu)
1386: {
1387: uint mm = eamode(RegIR);
1388: uint rr = eanum(RegIR);
1389: uint32 ea;
1390: uint32 data;
1391: bool postinc;
1392:
1393: postinc = false;
1394: // EA は独自体系なのでここでべたに書く
1395: switch (mm) {
1396: case 2: // (An)
1397: ea = cea_anin(cpu, rr);
1398: break;
1399: case 3: // (An)+
1400: ea = cea_anin(cpu, rr);
1401: postinc = true;
1402: break;
1403: case 5: // d16(An)
1404: ea = cea_andi(cpu, rr);
1405: break;
1406: case 6: // (An,IX)
1407: ea = cea_anix(cpu, rr);
1408: break;
1409: case 7:
1410: switch (rr) {
1411: case 0: // Abs.W
1412: ea = cea_absw(cpu);
1413: break;
1414: case 1: // Abs.L
1415: ea = cea_absl(cpu);
1416: break;
1417: case 2: // d16(PC)
1418: ea = cea_pcdi(cpu);
1419: break;
1420: case 3: // (PC,IX)
1421: ea = cea_pcix(cpu);
1422: break;
1423: default:
1424: fpu_op_illg(cpu);
1425: return;
1426: }
1427: break;
1428: default:
1429: fpu_op_illg(cpu);
1430: return;
1431: }
1432:
1433: // 1ロングワード読んでみる
1434: data = m68030_read_32(cpu, ea);
1435: ea += 4;
1436:
1437: if (data == 0) {
1438: // NULL フレームなら、これ以上フレームはない。
1439: CYCLE2(21, 22);
1440:
1441: // NULL フレームのリストアは FPU の状態をリセットする
1442: fpu_reset(cpu);
1443: } else {
1444: // それ以外のフレームは先頭ロングワードから長さを取得。
1445: // 先頭1ロングワードは $VVLL0000 で VV がバージョン(8bit)、
1446: // LL が(自身を含まないこれ以降の)バイト数 (8bit) を示している。
1447: // 現在の実装ではセーブ/リストアは何も実装していないので、
1448: // 全部読み捨てる。
1449:
1450: // 実際にはフレーム種別によってサイクル数は変わるけど、ここでは
1451: // FSAVE は NULL フレーム以外には IDLE フレームしか吐かないので
1452: // IDLE フレームのサイクルだけでいい。
1453: CYCLE2(57, 58);
1454:
1455: int len = (data >> 16) & 0xff;
1456: len /= 4;
1457: for (int i = 0; i < len; i++) {
1458: m68030_read_32(cpu, ea);
1459: ea += 4;
1460: }
1461:
1462: cpu->fpu_dirty = true;
1463: }
1464:
1465: // (An)+ なら書き戻し
1466: if (postinc) {
1467: RegA(rr) = ea;
1468: }
1469: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.