![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to m680x0fpu.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 m680x0fpu.cpp CVS log | Up to [Isaki's NoNo m68k/m88k emulator] / nono / m680x0 |
1.1 root 1: //
2: // nono
3: // Copyright (C) 2020 nono project
4: // Licensed under nono-license.txt
5: //
6:
7: // +------ 030(without FPU)
8: // | +-- 030(+6888x)
9: // | | 040 LC040
10: // S o o 4 : FSAVE/FRESTORE (有効なEA)
11: // F F F : FSAVE/FRESTORE (無効なEA)
12: // F o o 4 : 040 でも実装してある命令 (有効なEA)
13: // F F F : 040 でも実装してある命令 (無効なEA)
14: // F o 2 4 : 6888x 命令 (有効なEA)
15: // F F F? : 6888x 命令 (無効なEA)
16: // F F F F : 無効な命令ビットパターン
17: //
18: // (厳密に言えばFPU命令ではないが)
19: // S S F? F? : cpSAVE/cpRESTORE (有効なEA)
20: // F F F? F? : cpSAVE/cpRESTORE (無効なEA)
21: // … XEiJ の flineprivilege.x によると、無効な EA のパターンは
22: // 68030 では F ライン例外になる。
23: // 040 ではコプロセッサプロトコル自体が廃止されているので
24: // ここはいずれも F ライン例外になるだろうか。
25: //
26: // o: 有効な命令処理
27: // F: F ライン例外 (Format$0)
28: // 2: 浮動小数点未実装例外(Format$2)
29: // 4: 浮動小数点未実装例外(Format$4)
30: // S: 特権違反例外
31:
32: // 68040:
33: // Int .S .D .X .P
34: // ノーマル数 o o o o x
35: // Zero o o o o x
36: // Inf - o o o x
37: // NAN - o o o x
38: // 非正規化数 - x x x x
39: // アンノーマル数 - - - x x
40: //
41: // o: ハードウェアサポート
42: // x: ソフトウェアサポート
43:
44: #include "mpu680x0.h"
45: #include "m680x0disasm.h"
46: #include "textscreen.h"
47:
48: #define SIZE_L (0)
49: #define SIZE_S (1)
50: #define SIZE_X (2)
51: #define SIZE_P (3)
52: #define SIZE_W (4)
53: #define SIZE_D (5)
54: #define SIZE_B (6)
55:
56: // val が単精度で非正規化数なら true を返す。
57: static inline bool
58: is_denormal_s(uint32 val)
59: {
60: uint32 e = (val >> 23) & 0xff;
61: uint32 m = val & 0x7f'ffff;
62: if (e == 0 && m != 0) {
63: return true;
64: }
65: return false;
66: }
67:
68: // data[0..1] が倍精度で非正規化数なら true を返す。
69: static inline bool
70: is_denormal_d(const uint32 *data)
71: {
72: uint32 e = (data[0] >> 20) & 0x7ff;
73: uint64 m = ((uint64)(data[0] & 0x000f'ffff) << 32) | data[1];
74: if (e == 0 && m != 0) {
75: return true;
76: }
77: return false;
78: }
79:
80: // data[0..2] が拡張精度で非正規化数なら true を返す。
81: static inline bool
82: is_denormal_x(const uint32 *data)
83: {
84: uint32 e = (data[0] >> 16) & 0x7fff;
85: uint32 i = (data[1] >> 31) & 1;
86: uint64 m = (((uint64)(data[1] & 0x7fff'ffff)) << 32) | data[2];
87: if (e == 0 && i == 0 && m != 0) {
88: return true;
89: }
90: return false;
91: }
92:
93: // data[0..2] が拡張精度でアンノーマル数なら true を返す。
94: static inline bool
95: is_unnormal_x(const uint32 *data)
96: {
97: uint32 e = (data[0] >> 16) & 0x7fff;
98: uint32 i = (data[1] >> 31) & 1;
99: uint64 m = (((uint64)(data[1] & 0x7fff'ffff)) << 32) | data[2];
100: if (e != 0 && e != 0x7fff && i == 0 && m != 0) {
101: return true;
102: }
103: // XXX Unnormal zero はハード処理かソフト処理か分からない。
104: if (e != 0 && e != 0x7fff && i == 0 && m == 0) {
105: return true;
106: }
107: return false;
108: }
109:
110: // リセット用のレジスタ初期値
111: /*static*/ struct fpframe
112: MPU680x0Device::initial_fpframe;
113:
114: // 初期化
115: void
116: MPU680x0Device::fpu_init()
117: {
118: int i;
119: uint32_t *p;
120:
121: // XXX cpu の初期化のところと見直してマージするとか
122: memset(&fe, 0, sizeof(fe));
123: memset(®.fpframe, 0, sizeof(reg.fpframe));
124: fe.fe_fpframe = ®.fpframe;
125:
126: // FRESTORE によるリセット用に FP レジスタの初期値を用意しておく。
127: // FPn は NAN に。FPSR, FPCR, FPIAR はゼロクリアされる。
128: memset(&initial_fpframe, 0, sizeof(initial_fpframe));
129: p = initial_fpframe.fpf_regs;
130: for (i = 0; i < 8; i++) {
131: *p++ = 0x7fff0000;
132: *p++ = 0xffffffff;
133: *p++ = 0xffffffff;
134: }
135: }
136:
137: // FPU をリセットする。
138: // MPU リセット時(true)と、NULL フレームのリストア時(false)に呼ばれる。
139: void
140: MPU680x0Device::ResetFPU(bool hard)
141: {
142: // 高速化のため、あらかじめ用意しておいたイメージをコピーする
143: memcpy(®.fpframe, &initial_fpframe, sizeof(initial_fpframe));
144:
145: fpu_state = FPU_STATE_NULL;
146:
147: if (__predict_false(hard)) {
148: // この内部情報は NULL フレームのリストア (頻繁に起きる) のたびに
149: // モニタから消えるよりは、直近の1つが見え続けていてほしい。
150: // ただしハードリセット前の状態は引き継がない。
151: memset(&fpu40, 0, sizeof(fpu40));
152: fpu40.reg1b = 0xffff;
153: fpu40.stag = FPU40::TAG_NONE;
154: fpu40.dtag = FPU40::TAG_NONE;
155: }
156: fpu40.enable = false;
157: }
158:
159: // FPU からの呼び出し用。
160: //
161: // (An)+, -(An) は、サイズが増えているのとクロックが増加している(2->6)。
162: // それ以外のアドレッシングモードでもクロック数は微妙に違うのだが、
163: // 大きくは違わないのでそっちは本体の cea と同じということにする。
164: //
165: // このルーチンは Dn、An、#imm には対応していないので(自明)、呼び出し側で
166: // 事前に弾くこと。いずれも消費クロック数は 0 なので問題ない。
167: // またそれ以外のすべてのアドレッシングモードで反応するため、命令ごとに
168: // 対応していないアドレッシングモードは事前に弾くこと。
169: inline uint32
170: MPU680x0Device::cea_fpu(int bytes)
171: {
172: int n;
173:
174: switch (eamode(ir)) {
175: case 0: // Dn
176: case 1: // An
177: break;
178: case 2: // (An)
179: return cea_anin(eanum(ir));
180: case 3: // (An)+
181: CYCLE(6);
182: n = eanum(ir);
183: save_reg_pi(n);
184: if (bytes == 1) {
185: return internal_ea_anpi_1(n);
186: } else {
187: // _anpi_{2,4} のマクロは用意されてるけど、これと同じなので
188: reg.A[n] += bytes;
189: return reg.A[n] - bytes;
190: }
191: break;
192: case 4: // -(An)
193: CYCLE(6);
194: n = eanum(ir);
195: save_reg_pd(n);
196: if (bytes == 1) {
197: return internal_ea_anpd_1(n);
198: } else {
199: // _anpd_{2,4} のマクロは用意されてるけど、これと同じなので
200: reg.A[n] -= bytes;
201: return reg.A[n];
202: }
203: break;
204: case 5: // d16(An)
205: return cea_andi(eanum(ir));
206: case 6: // (An,IX)
207: return cea_anix(eanum(ir));
208: case 7:
209: switch (eanum(ir)) {
210: case 0: // Abs.W
211: return cea_absw();
212: case 1: // Abs.L
213: return cea_absl();
214: case 2: // d16(PC)
215: return cea_pcdi();
216: case 3: // (PC,IX)
217: return cea_pcix();
218: case 4: // #imm
219: break;
220: default:
221: break;
222: }
223: break;
224: }
225: // 不当命令
226: throw M68K::EXCEP_ILLEGAL;
227: }
228:
229: // メモリから 64ビット値を読み込む
230: void
231: MPU680x0Device::read_8(uint32 addr, uint32 *data)
232: {
233: data[0] = read_4(addr);
234: data[1] = read_4(addr + 4);
235: }
236:
237: // メモリから 96ビット値を読み込む
238: void
239: MPU680x0Device::read_12(uint32 addr, uint32 *data)
240: {
241: data[0] = read_4(addr);
242: data[1] = read_4(addr + 4);
243: data[2] = read_4(addr + 8);
244: }
245:
246: // 64ビット値をメモリに書き込む
247: void
248: MPU680x0Device::write_8(uint32 addr, const uint32 *data)
249: {
250: write_4(addr, data[0]);
251: write_4(addr + 4, data[1]);
252: }
253:
254: // 96ビット値をメモリに書き込む
255: void
256: MPU680x0Device::write_12(uint32 addr, const uint32 *data)
257: {
258: write_4(addr, data[0]);
259: write_4(addr + 4, data[1]);
260: write_4(addr + 8, data[2]);
261: }
262:
263: // ソースを data[] に読み込む。
264: // 不当命令パターンなら false を返す。
265: // size_id は SIZE_*。
266: bool
267: MPU680x0Device::readSRC(int size_id, uint32 *data)
268: {
269: uint mr = ir & 0x3f;
270:
271: // 68881 本(p6-13) にはクロック数はこう書いてあるので
272: // Inst | src=FPn | memory source or dst operand format
273: // | | Int Sgl Dbl Ext Pakced
274: // ---- +---------- +------ ------- ------- ------- -------
275: // FABS | 35 | 62 54 60 58 872
276: // (差分) +27 +19 +25 +23 +837
277: // FADD | 51 | 80 72 78 76 888
278: // (差分) +29 +21 +27 +25 +837
279: //
280: // FABS.X FPn,FPm は 35 としてこれは fgen() 内で加算。
281: // FABS.L <ea>,FPm は 62 クロックなので、ここでは差分の 27 を加算。
282: // FABS.L Dn,FPm の場合 src がレジスタなので 62 から 5 引く。
283: // FABS.P <ea>,FPm は 872 クロックなので、ここでは差分の 837 を加算。
284: //
285: // XXX 多くの命令が FABS と同じだけの差分だが、
286: // FADD などいくつかは .P 以外に +2 クロックの追加があるようだ。
287: // どうしたもんか。
288:
289: if (mr < 8) { // Dn
290: switch (size_id) {
291: case SIZE_B:
292: data[0] = (int32)(int8)reg.D[mr];
293: break;
294: case SIZE_W:
295: data[0] = (int32)(int16)reg.D[mr];
296: break;
297: case SIZE_L:
298: case SIZE_S:
299: data[0] = reg.D[mr];
300: break;
301: default:
302: return false;
303: }
304: // XXX EA はどうなる?
305:
306: // ソースが Dn の場合は 5クロック減
307: CYCLE(-5);
308: } else if (mr == 0x3c) { // #imm
309: switch (size_id) {
310: case SIZE_B:
311: data[0] = fetch_2() & 0xff;
312: break;
313: case SIZE_W:
314: data[0] = fetch_2();
315: break;
316: case SIZE_L:
317: case SIZE_S:
318: data[0] = fetch_4();
319: break;
320: case SIZE_D:
321: data[0] = fetch_4();
322: data[1] = fetch_4();
323: break;
324: case SIZE_X:
325: case SIZE_P:
326: data[0] = fetch_4();
327: data[1] = fetch_4();
328: data[2] = fetch_4();
329: break;
330: default:
331: return false;
332: }
333: // XXX EA はどうなる?
334: } else {
335: // それ以外は EA を求めてからメモリから読み込む
336: uint32 ea;
337: switch (size_id) {
338: case SIZE_B:
339: ea = cea_fpu(1);
340: data[0] = (int32)(int8)read_1(ea);
341: break;
342: case SIZE_W:
343: ea = cea_fpu(2);
344: data[0] = (int32)(int16)read_2(ea);
345: break;
346: case SIZE_L:
347: case SIZE_S:
348: ea = cea_fpu(4);
349: data[0] = read_4(ea);
350: break;
351: case SIZE_D:
352: ea = cea_fpu(8);
353: read_8(ea, data);
354: break;
355: case SIZE_X:
356: case SIZE_P:
357: ea = cea_fpu(12);
358: read_12(ea, data);
359: break;
360: default:
361: return false;
362: }
363: fpu40.ea = ea;
364: }
365:
366: return true;
367: }
368:
369: // FPU 不当命令 (1ワード目で確定)
370: void
371: MPU680x0Device::fpu_op_illg()
372: {
373: putlog(1, "FPU illegal instruction %04X", ir);
374: Exception(M68K::EXCEP_FLINE);
375: }
376:
377: // FPU 不当命令 (2ワード目で確定)
378: void
379: MPU680x0Device::fpu_op_illg2()
380: {
381: putlog(1, "FPU illegal instruction %04X %04X", ir, ir2);
382: Exception(M68K::EXCEP_FLINE);
383: }
384:
385: // R/M=0 (レジスタ-レジスタ演算)、opclass=%000
386: void
387: MPU680x0Device::fpu_op_fgen_reg()
388: {
389: uint srcnum = (ir2 >> 10) & 7;
390:
391: fgen(&RegFP(srcnum), SIZE_X);
392: }
393:
394: // R/M=1 (メモリ-レジスタ演算)、opclass=%010
395: void
396: MPU680x0Device::fpu_op_fgen_mem()
397: {
398: uint size_id = (ir2 >> 10) & 7;
399: uint32 data[3];
400:
401: // source specifier はオペランドサイズ
402: if (size_id == 7) {
403: // こんなところに FMOVECR
404: fpu_op_fmovecr();
405: return;
406: }
407:
408: // 第1ワードの EA がソース EA
409: if (!readSRC(size_id, data)) {
410: fpu_op_illg2();
411: return;
412: }
413:
414: fgen(data, size_id);
415: }
416:
417: // 一般算術演算。
418: // srcdata, srcsize_id がソースの生データとサイズ識別子。
419: // デスティネーション(FPn) は ir2 から求まる。
420: void
421: MPU680x0Device::fgen(const uint32 *srcdata, uint srcsize_id)
422: {
423: uint opmode = ir2 & 0x3f;
424: uint dstnum = (ir2 >> 7) & 7;
425: bool discard_result = false;
426: struct fpn *res = NULL; // shutup gcc
427:
428: // 機種別の前処理。
429: if (GetFPUType().Is4060FPU()) {
430: // 未実装命令と未実装データ型の検出など。
431: if (fgen040pre(opmode, dstnum, srcdata, srcsize_id) == false) {
432: return;
433: }
434: } else {
435: // fe_f1, fe_f2 にロードするだけ。
436: fgen881pre(dstnum, srcdata, srcsize_id);
437: }
438:
439: switch (opmode) {
440: case 0x00: // FMOVE
441: fmove:
442: CYCLE(33);
443: res = &fe.fe_f2;
444: fpu_round_prec(&fe, res);
445: break;
446: case 0x01: // FINT
447: CYCLE(55);
448: res = fpu_int(&fe);
449: break;
450: case 0x02: // FSINH
451: CYCLE(687);
452: res = fpu_sinh(&fe);
453: fpu_round_prec(&fe, res);
454: break;
455: case 0x03: // FINTRZ
456: CYCLE(55);
457: res = fpu_intrz(&fe);
458: break;
459: case 0x04: // FSQRT
460: fsqrt:
461: CYCLE(107);
462: res = fpu_sqrt(&fe);
463: fpu_round_prec(&fe, res);
464: break;
465: case 0x06: // FLOGNP1
466: CYCLE(571);
467: res = fpu_lognp1(&fe);
468: fpu_round_prec(&fe, res);
469: break;
470: case 0x08: // FETOXM1
471: CYCLE(545);
472: res = fpu_etoxm1(&fe);
473: fpu_round_prec(&fe, res);
474: break;
475: case 0x09: // FTANH
476: CYCLE(661);
477: res = fpu_tanh(&fe);
478: fpu_round_prec(&fe, res);
479: break;
480: case 0x0a: // FATAN
481: CYCLE(403);
482: res = fpu_atan(&fe);
483: fpu_round_prec(&fe, res);
484: break;
485: case 0x0c: // FASIN
486: CYCLE(581);
487: res = fpu_asin(&fe);
488: fpu_round_prec(&fe, res);
489: break;
490: case 0x0d: // FATANH
491: CYCLE(693);
492: res = fpu_atanh(&fe);
493: fpu_round_prec(&fe, res);
494: break;
495: case 0x0e: // FSIN
496: CYCLE(391);
497: res = fpu_sin(&fe);
498: fpu_round_prec(&fe, res);
499: break;
500: case 0x0f: // FTAN
501: CYCLE(473);
502: res = fpu_tan(&fe);
503: fpu_round_prec(&fe, res);
504: break;
505: case 0x10: // FETOX
506: CYCLE(497);
507: res = fpu_etox(&fe);
508: fpu_round_prec(&fe, res);
509: break;
510: case 0x11: // FTWOTOX
511: CYCLE(567);
512: res = fpu_twotox(&fe);
513: fpu_round_prec(&fe, res);
514: break;
515: case 0x12: // FTENTOX
516: CYCLE(567);
517: res = fpu_tentox(&fe);
518: fpu_round_prec(&fe, res);
519: break;
520: case 0x14: // FLOGN
521: CYCLE(525);
522: res = fpu_logn(&fe);
523: fpu_round_prec(&fe, res);
524: break;
525: case 0x15: // FLOG10
526: CYCLE(581);
527: res = fpu_log10(&fe);
528: fpu_round_prec(&fe, res);
529: break;
530: case 0x16: // FLOG2
531: CYCLE(581);
532: res = fpu_log2(&fe);
533: fpu_round_prec(&fe, res);
534: break;
535: case 0x18: // FABS
536: fabs:
537: CYCLE(35);
538: fe.fe_f2.fp_sign = 0;
539: res = &fe.fe_f2;
540: fpu_round_prec(&fe, res);
541: break;
542: case 0x19: // FCOSH
543: CYCLE(607);
544: res = fpu_cosh(&fe);
545: fpu_round_prec(&fe, res);
546: break;
547: case 0x1a: // FNEG
548: fneg:
549: CYCLE(35);
550: res = &fe.fe_f2;
551: if (!ISNAN(res)) {
552: res->fp_sign = !res->fp_sign;
553: fpu_round_prec(&fe, res);
554: }
555: break;
556: case 0x1c: // FACOS
557: CYCLE(625);
558: res = fpu_acos(&fe);
559: fpu_round_prec(&fe, res);
560: break;
561: case 0x1d: // FCOS
562: CYCLE(391);
563: res = fpu_cos(&fe);
564: fpu_round_prec(&fe, res);
565: break;
566: case 0x1e: // FGETEXP
567: CYCLE(45);
568: res = fpu_getexp(&fe);
569: fpu_round_prec(&fe, res);
570: break;
571: case 0x1f: // FGETMAN
572: CYCLE(31);
573: res = fpu_getman(&fe);
574: fpu_round_prec(&fe, res);
575: break;
576: case 0x20: // FDIV
577: fdiv:
578: CYCLE(103);
579: res = fpu_div(&fe);
580: fpu_round_prec(&fe, res);
581: break;
582: case 0x21: // FMOD
583: CYCLE(67);
584: res = fpu_mod(&fe);
585: fpu_round_prec(&fe, res);
586: break;
587: case 0x22: // FADD
588: fadd:
589: CYCLE(51);
590: res = fpu_add(&fe);
591: fpu_round_prec(&fe, res);
592: break;
593: case 0x23: // FMUL
594: fmul:
595: CYCLE(71);
596: res = fpu_mul(&fe);
597: fpu_round_prec(&fe, res);
598: break;
599: case 0x24: // FSGLDIV
600: CYCLE(69);
601: res = fpu_sgldiv(&fe);
602: break;
603: case 0x25: // FREM
604: CYCLE(67);
605: res = fpu_rem(&fe);
606: fpu_round_prec(&fe, res);
607: break;
608: case 0x26: // FSCALE
609: // こいつだけ形式が違う。
610: // 結果は dst に直接格納済み、FPSR も演算済み。
611: CYCLE(41);
612: fpu_emul_fscale(&fe, ir2);
613: return;
614: case 0x27: // FSGLMUL
615: CYCLE(59);
616: res = fpu_sglmul(&fe);
617: break;
618: case 0x28: // FSUB
619: fsub:
620: CYCLE(51);
621: res = fpu_sub(&fe);
622: fpu_round_prec(&fe, res);
623: break;
624: case 0x30:
625: case 0x31:
626: case 0x32:
627: case 0x33:
628: case 0x34:
629: case 0x35:
630: case 0x36:
631: case 0x37: // FSINCOS
632: CYCLE(451);
633: res = fpu_sincos(&fe, opmode & 7);
634: fpu_round_prec(&fe, res);
635: break;
636: case 0x38: // FCMP
637: CYCLE(33);
638: res = fpu_cmp(&fe);
639: discard_result = 1;
640: break;
641: case 0x3a: // FTST
642: CYCLE(33);
643: res = &fe.fe_f2;
644: discard_result = 1;
645: break;
646:
647: #define ONLY_40 do { \
648: if (GetFPUType().Is40FPU() == false) { \
649: goto illegal; \
650: } \
651: } while (0)
652: // fe の精度だけ変える。
653: // fe_fpcr は RegFPCR (レジスタ) のほうには伝搬しないし、
654: // 次の命令の冒頭でまた RegFPCR から上書きされるので、
655: // 書き換えっぱなしでよい。
656: #define ROUND_FS do { \
657: fe.fe_fpcr &= ~FPCR_PREC; \
658: fe.fe_fpcr |= FPCR_SNGL; \
659: } while (0)
660: #define ROUND_FD do { \
661: fe.fe_fpcr &= ~FPCR_PREC; \
662: fe.fe_fpcr |= FPCR_DBL; \
663: } while (0)
664:
665: case 0x40: ONLY_40; ROUND_FS; goto fmove; // FSMOVE
666: case 0x44: ONLY_40; ROUND_FD; goto fmove; // FDMOVE
667: case 0x41: ONLY_40; ROUND_FS; goto fsqrt; // FSSQRT
668: case 0x45: ONLY_40; ROUND_FD; goto fsqrt; // FDSQRT
669: case 0x58: ONLY_40; ROUND_FS; goto fabs; // FSABS
670: case 0x5c: ONLY_40; ROUND_FD; goto fabs; // FDABS
671: case 0x5a: ONLY_40; ROUND_FS; goto fneg; // FSNEG
672: case 0x5e: ONLY_40; ROUND_FD; goto fneg; // FDNEG
673: case 0x60: ONLY_40; ROUND_FS; goto fdiv; // FSDIV
674: case 0x64: ONLY_40; ROUND_FD; goto fdiv; // FDDIV
675: case 0x62: ONLY_40; ROUND_FS; goto fadd; // FSADD
676: case 0x66: ONLY_40; ROUND_FD; goto fadd; // FDADD
677: case 0x63: ONLY_40; ROUND_FS; goto fmul; // FSMUL
678: case 0x67: ONLY_40; ROUND_FD; goto fmul; // FDMUL
679: case 0x68: ONLY_40; ROUND_FS; goto fsub; // FSSUB
680: case 0x6c: ONLY_40; ROUND_FD; goto fsub; // FDSUB
681:
682: illegal:
683: default:
684: // 不当命令
685: fpu_op_illg2();
686: return;
687: }
688:
689: assert(res);
690: if (!discard_result) {
691: fpu_implode(&fe, res, FTYPE_EXT, &RegFP(dstnum));
692: }
693: fpu_upd_fpsr(&fe, res);
694: fpu_upd_excp(&fe);
695: }
696:
697: // fgen() の 68881 での前処理。
698: // src, dst を fe_f2, fe_f1 にそれぞれロードするだけ。
699: void
700: MPU680x0Device::fgen881pre(uint dstnum, const uint32 *srcdata, uint srcsize_id)
701: {
702: switch (srcsize_id) {
703: case SIZE_B:
704: case SIZE_W:
705: case SIZE_L:
706: CYCLE(+27);
707: fpu_explode(&fe, &fe.fe_f2, FTYPE_LNG, srcdata);
708: break;
709: case SIZE_S:
710: CYCLE(+19);
711: fpu_explode(&fe, &fe.fe_f2, FTYPE_SNG, srcdata);
712: break;
713: case SIZE_D:
714: CYCLE(+25);
715: fpu_explode(&fe, &fe.fe_f2, FTYPE_DBL, srcdata);
716: break;
717: case SIZE_X:
718: CYCLE(+23);
719: fpu_explode(&fe, &fe.fe_f2, FTYPE_EXT, srcdata);
720: break;
721: case SIZE_P:
722: CYCLE(+837);
723: fpu_explode(&fe, &fe.fe_f2, FTYPE_BCD, srcdata);
724: break;
725: default:
726: __unreachable();
727: }
728: fpu_explode(&fe, &fe.fe_f1, FTYPE_EXT, &RegFP(dstnum));
729: }
730:
731: // fgen() の 68040 での前処理。
732: // 未実装命令のチェックと該当すればその例外処理、
733: // 未実装データ型のチェックと該当すればその例外処理を行う。
734: // 例外処理を行った場合は false を返す。
735: bool
736: MPU680x0Device::fgen040pre(uint opmode, uint dstnum,
737: const uint32 *srcdata, uint srcsize_id)
738: {
739: // 未実装命令か調べる。
740: bool unimpl = false;
741: switch (opmode) {
742: case 0x01: // FINT
743: case 0x02: // FSINH
744: case 0x03: // FINTRZ
745: case 0x06: // FLOGNP1
746: case 0x08: // FETOXM1
747: case 0x09: // FTANH
748: case 0x0a: // FATAN
749: case 0x0c: // FASIN
750: case 0x0d: // FATANH
751: case 0x0e: // FSIN
752: case 0x0f: // FTAN
753: case 0x10: // FETOX
754: case 0x11: // FTWOTOX
755: case 0x12: // FTENTOX
756: case 0x14: // FLOGN
757: case 0x15: // FLOG10
758: case 0x16: // FLOG2
759: case 0x19: // FCOSH
760: case 0x1c: // FACOS
761: case 0x1d: // FCOS
762: case 0x1e: // FGETEXP
763: case 0x1f: // FGETMAN
764: case 0x21: // FMOD
765: case 0x25: // FREM
766: case 0x26: // FSCALE
767: case 0x30: // FSINCOS
768: case 0x31: // FSINCOS
769: case 0x32: // FSINCOS
770: case 0x33: // FSINCOS
771: case 0x34: // FSINCOS
772: case 0x35: // FSINCOS
773: case 0x36: // FSINCOS
774: case 0x37: // FSINCOS
775: unimpl = true;
776: break;
777: default:
778: break;
779: }
780:
781: // ソースがサポートしている型なら拡張精度に変換して fe_f2 にセットし、
782: // stag は NONE のままか NORMAL or ZERO をセット。
783: // 未サポート型なら所定の etemp を作成して stag は DENORMAL か UNNORMAL。
784: //
785: // Int .S/.D .X .P
786: // Normal fe_f2,NORM fe_f2,NONE fe_f2,NONE etemp,UNNO
787: // Zero fe_f2,ZERO fe_f2,NONE fe_f2,NONE etemp,UNNO
788: // Inf - fe_f2,NONE fe_f2,NONE etemp,UNNO
789: // NAN - fe_f2,NONE fe_f2,NONE etemp,UNNO
790: // Denorm - etemp,DENO etemp,UNNO etemp,UNNO
791: // Unnorm - - etemp,UNNO etemp,UNNO
792:
793: int32 stag = FPU40::TAG_NONE;
794: switch (srcsize_id) {
795: case SIZE_B:
796: case SIZE_W:
797: case SIZE_L:
798: CYCLE(+27);
799: if (srcdata[0] == 0) {
800: stag = FPU40::TAG_ZERO;
801: } else {
802: stag = FPU40::TAG_NORMAL;
803: }
804: fpu_explode(&fe, &fe.fe_f2, FTYPE_LNG, srcdata);
805: break;
806: case SIZE_S:
807: CYCLE(+19);
808: if (is_denormal_s(srcdata[0])) {
809: // 68040UM.pdf, p9-24. Figure 9-9 (a)
810: uint32 s = srcdata[0] & 0x8000'0000;
811: uint32 m = srcdata[0] & 0x007f'ffff;
812: fpu40.etemp[0] = s;
813: fpu40.etemp[1] = m << 8;
814: fpu40.etemp[2] = 0;
815: stag = FPU40::TAG_DENORMAL_S;
816: break;
817: }
818: fpu_explode(&fe, &fe.fe_f2, FTYPE_SNG, srcdata);
819: break;
820: case SIZE_D:
821: CYCLE(+25);
822: if (is_denormal_d(srcdata)) {
823: // 68040UM.pdf, p9-24. Figure 9-9 (b)
824: uint32 s = srcdata[0] & 0x8000'0000;
825: uint64 m = ((uint64)(srcdata[0] & 0x000f'ffff) << 32) | srcdata[1];
826: m <<= 11;
827: fpu40.etemp[0] = s;
828: fpu40.etemp[1] = m >> 32;
829: fpu40.etemp[2] = m & 0xffffffff;
830: stag = FPU40::TAG_DENORMAL_D;
831: break;
832: }
833: fpu_explode(&fe, &fe.fe_f2, FTYPE_DBL, srcdata);
834: break;
835: case SIZE_X:
836: CYCLE(+23);
837: if (is_denormal_x(srcdata)) {
838: memcpy(fpu40.etemp, srcdata, 12);
839: stag = FPU40::TAG_DENORMAL_X;
840: break;
841: } else if (is_unnormal_x(srcdata)) {
842: memcpy(fpu40.etemp, srcdata, 12);
843: stag = FPU40::TAG_UNNORMAL_X;
844: break;
845: }
846: fpu_explode(&fe, &fe.fe_f2, FTYPE_EXT, srcdata);
847: break;
848: case SIZE_P:
849: // 上位32ビットを FPTM[31-00] に、
850: // 下位64ビットを ETM[31-00] に置く。(68040UM.pdf, pp.9-42〜43)
851: fpu40.fptemp[2] = srcdata[0];
852: fpu40.etemp[1] = srcdata[1];
853: fpu40.etemp[2] = srcdata[2];
854: // Packed の時 stag は undefined と書いてある。
855: // ここではこの後の例外判定用および表示用として使う。
856: stag = FPU40::TAG_PACKED;
857: break;
858: default:
859: __unreachable();
860: }
861:
862: // デスティネーション(レジスタ) が未サポートデータ型になるのは
863: // 非正規化数の時だけのはず。
864: int32 dtag = FPU40::TAG_NONE;
865: if (is_denormal_x(&RegFP(dstnum))) {
866: dtag = FPU40::TAG_DENORMAL_X;
867: }
868: fpu_explode(&fe, &fe.fe_f1, FTYPE_EXT, &RegFP(dstnum));
869: if (dtag == FPU40::TAG_NONE) {
870: dtag = fpu_gettag(&fe.fe_f1);
871: }
872:
873: // 例外を起こす必要があるか。
874: if (unimpl ||
875: stag >= FPU40::TAG_UNNORMAL ||
876: dtag >= FPU40::TAG_UNNORMAL)
877: {
878: // stag がまだならここで fpn から決まる。
879: if (stag == FPU40::TAG_NONE) {
880: stag = fpu_gettag(&fe.fe_f2);
881: }
882: // stag が UNNORMAL, DENORMAL なら etemp はセット済み。
883: if (stag < FPU40::TAG_UNNORMAL) {
884: fpu_implode(&fe, &fe.fe_f2, FTYPE_EXT, fpu40.etemp);
885: }
886: // Packed なら E1 を立てる、
887: // また FPTEMP にはソースを展開済みなので dst を書き込まない。
888: // XXX 68040UM.pdf p.9-44 Table 9-16 Unimplemented Instruction には
889: // E1 は always 1 とあるが、p.9-42 の E1 の説明のほうが正しそう。
890: if (srcsize_id == SIZE_P) {
891: fpu40.eflag = FPU40::E1;
892: } else {
893: fpu40.eflag = 0;
894: memcpy(&fpu40.fptemp, &RegFP(dstnum), 12);
895: }
896: fpu40.stag = stag;
897: fpu40.dtag = dtag;
898: if (unimpl) {
899: ExceptionFP(M68K::EXCEP_FP_UNIMPL);
900: } else {
901: ExceptionFP(M68K::EXCEP_FP_UNSUPP);
902: }
903: return false;
904: }
905:
906: // ハードウェア処理可能。
907:
908: // 68040 では条件命令以外 (たぶん実質クラス0命令) を実行すると
909: // NULL -> IDLE 状態になる。68040UM.pdf, p9-39
910: fpu_state = FPU_STATE_IDLE;
911:
912: return true;
913: }
914:
915: // FMOVECR
916: void
917: MPU680x0Device::fpu_op_fmovecr()
918: {
919: if (GetFPUType().Is4060FPU()) {
920: ExceptionFP(M68K::EXCEP_FP_UNIMPL);
921: return;
922: }
923:
924: CYCLE(29);
925:
926: uint offset = (ir2 & 0x7f);
927: uint dstnum = (ir2 >> 7) & 7;
928:
929: fpu_const(&fe.fe_f3, offset);
930: fpu_implode(&fe, &fe.fe_f3, FTYPE_EXT, &RegFP(dstnum));
931: fpu_upd_fpsr(&fe, &fe.fe_f3);
932: fpu_upd_excp(&fe);
933: }
934:
935: // FMOVE FPn,<ea>
936: void
937: MPU680x0Device::fpu_op_fmove_to_mem()
938: {
939: // サイズごとに分岐
940: uint size = (ir2 >> 10) & 7;
941: switch (size) {
942: case SIZE_B:
943: fpu_op_fmove_b_mem();
944: break;
945: case SIZE_W:
946: fpu_op_fmove_w_mem();
947: break;
948: case SIZE_L:
949: fpu_op_fmove_l_mem();
950: break;
951: case SIZE_S:
952: fpu_op_fmove_s_mem();
953: break;
954: case SIZE_D:
955: fpu_op_fmove_d_mem();
956: break;
957: case SIZE_X:
958: fpu_op_fmove_x_mem();
959: break;
960: case SIZE_P:
961: case 7:
962: fpu_op_fmove_p_mem();
963: break;
964: }
965: }
966:
967: // FMOVE.B FPn,<ea>
968: // cf. 68000PRM.pdf p378 (5-76)
969: void
970: MPU680x0Device::fpu_op_fmove_b_mem()
971: {
972: uint mr = ir & 0x3f;
973: uint srcnum = (ir2 >> 7) & 7;
974: uint32 ea;
975: uint32 data;
976:
977: fpu_explode(&fe, &fe.fe_f3, FTYPE_EXT, &RegFP(srcnum));
978: fpu_implode(&fe, &fe.fe_f3, FTYPE_LNG, &data);
979: // 入力値は long か、long で表現できなければ 0x80000000 が返ってくるが、
980: // ここはバイトへの変換なので表現できなければ 0x80 にする。
981: if ((int32)data < INT8_MIN || (int32)data > INT8_MAX) {
982: data = 0x80;
983: RegFPSR |= FPSR_OPERR | FPSR_AIOP;
984: }
985:
986: if (mr < 8) { // Dn
987: CYCLE(100-2);
988: reg.D[mr] &= 0xffffff00;
989: reg.D[mr] |= (uint8)data;
990: } else {
991: CYCLE(100);
992: ea = cea_fpu(1);
993: write_1(ea, (uint8)data);
994: }
995: }
996:
997: // FMOVE.W FPn,<ea>
998: // cf. 68000PRM.pdf p378 (5-76)
999: void
1000: MPU680x0Device::fpu_op_fmove_w_mem()
1001: {
1002: uint mr = ir & 0x3f;
1003: uint srcnum = (ir2 >> 7) & 7;
1004: uint32 ea;
1005: uint32 data;
1006:
1007: fpu_explode(&fe, &fe.fe_f3, FTYPE_EXT, &RegFP(srcnum));
1008: fpu_implode(&fe, &fe.fe_f3, FTYPE_LNG, &data);
1009: // 入力値は long か、long で表現できなければ 0x80000000 が返ってくるが、
1010: // ここはワードへの変換なので表現できなければ 0x8000 にする。
1011: if ((int32)data < INT16_MIN || (int32)data > INT16_MAX) {
1012: data = 0x8000;
1013: RegFPSR |= FPSR_OPERR | FPSR_AIOP;
1014: }
1015:
1016: if (mr < 8) { // Dn
1017: CYCLE(100-2);
1018: reg.D[mr] &= 0xffff0000;
1019: reg.D[mr] |= (uint16)data;
1020: } else {
1021: CYCLE(100);
1022: ea = cea_fpu(2);
1023: write_2(ea, (uint16)data);
1024: }
1025: }
1026:
1027: // FMOVE.L FPn,<ea>
1028: // cf. 68000PRM.pdf p378 (5-76)
1029: void
1030: MPU680x0Device::fpu_op_fmove_l_mem()
1031: {
1032: uint mr = ir & 0x3f;
1033: uint srcnum = (ir2 >> 7) & 7;
1034: uint32 ea;
1035: uint32 data;
1036:
1037: fpu_explode(&fe, &fe.fe_f3, FTYPE_EXT, &RegFP(srcnum));
1038: fpu_implode(&fe, &fe.fe_f3, FTYPE_LNG, &data);
1039: // XXX オーバーフローチェック
1040:
1041: if (mr < 8) { // Dn
1042: CYCLE(100-2);
1043: reg.D[mr] = data;
1044: } else {
1045: CYCLE(100);
1046: ea = cea_fpu(4);
1047: write_4(ea, data);
1048: }
1049: }
1050:
1051: // FMOVE.S FPn,<ea>
1052: // cf. 68000PRM.pdf p378 (5-76)
1053: void
1054: MPU680x0Device::fpu_op_fmove_s_mem()
1055: {
1056: uint mr = ir & 0x3f;
1057: uint srcnum = (ir2 >> 7) & 7;
1058: uint32 ea;
1059: uint32 data;
1060:
1061: fpu_explode(&fe, &fe.fe_f3, FTYPE_EXT, &RegFP(srcnum));
1062: fpu_implode(&fe, &fe.fe_f3, FTYPE_SNG, &data);
1063:
1064: // 変換時に検出した UNFL, OVFL だけ外部レジスタにコピー。
1065: fe.fe_fpframe->fpf_fpsr &= ~(FPSR_UNFL | FPSR_OVFL);
1066: fe.fe_fpframe->fpf_fpsr |= fe.fe_fpsr & (FPSR_UNFL | FPSR_OVFL);
1067: // アクルードバイトは更新。
1068: fpu_upd_excp(&fe);
1069:
1070: if (mr < 8) { // Dn
1071: CYCLE(80-2);
1072: reg.D[mr] = data;
1073: } else {
1074: CYCLE(80);
1075: ea = cea_fpu(4);
1076: write_4(ea, data);
1077: }
1078: }
1079:
1080: // FMOVE.D FPn,<ea>
1081: // cf. 68000PRM.pdf p378 (5-76)
1082: void
1083: MPU680x0Device::fpu_op_fmove_d_mem()
1084: {
1085: CYCLE(86);
1086:
1087: uint srcnum = (ir2 >> 7) & 7;
1088: uint32 ea;
1089: uint32 data[2];
1090:
1091: fpu_explode(&fe, &fe.fe_f3, FTYPE_EXT, &RegFP(srcnum));
1092: fpu_implode(&fe, &fe.fe_f3, FTYPE_DBL, data);
1093:
1094: // 変換時に検出した UNFL, OVFL だけ外部レジスタにコピー。
1095: fe.fe_fpframe->fpf_fpsr &= ~(FPSR_UNFL | FPSR_OVFL);
1096: fe.fe_fpframe->fpf_fpsr |= fe.fe_fpsr & (FPSR_UNFL | FPSR_OVFL);
1097: // アクルードバイトは更新。
1098: fpu_upd_excp(&fe);
1099:
1100: ea = cea_fpu(8);
1101: write_8(ea, data);
1102: }
1103:
1104: // FMOVE.X FPn,<ea>
1105: // cf. 68000PRM.pdf p378 (5-76)
1106: void
1107: MPU680x0Device::fpu_op_fmove_x_mem()
1108: {
1109: CYCLE(72);
1110:
1111: uint srcnum = (ir2 >> 7) & 7;
1112: uint32 ea;
1113: uint32 data[3];
1114:
1115: fpu_explode(&fe, &fe.fe_f3, FTYPE_EXT, &RegFP(srcnum));
1116: fpu_implode(&fe, &fe.fe_f3, FTYPE_EXT, data);
1117:
1118: // 変換時に検出した UNFL, OVFL だけ外部レジスタにコピー。
1119: fe.fe_fpframe->fpf_fpsr &= ~(FPSR_UNFL | FPSR_OVFL);
1120: fe.fe_fpframe->fpf_fpsr |= fe.fe_fpsr & (FPSR_UNFL | FPSR_OVFL);
1121: // アクルードバイトは更新。
1122: fpu_upd_excp(&fe);
1123:
1124: ea = cea_fpu(12);
1125: write_12(ea, data);
1126: }
1127:
1128: // FMOVE.P FPn,<ea>
1129: // cf. 68000PRM.pdf p378 (5-76)
1130: void
1131: MPU680x0Device::fpu_op_fmove_p_mem()
1132: {
1133: uint srcnum = (ir2 >> 7) & 7;
1134: uint32 ea;
1135: uint32 data[3];
1136: uint32 k;
1137:
1138: if (GetFPUType().Is4060FPU()) {
1139: ExceptionFP(M68K::EXCEP_FP_UNIMPL);
1140: return;
1141: }
1142:
1143: if ((ir2 & 0x1000)) {
1144: // dynamic k-factor
1145: CYCLE(1996+14);
1146: k = reg.D[(ir2 >> 4) & 7];
1147: } else {
1148: // static k-factor
1149: CYCLE(1996);
1150: k = ir2;
1151: }
1152: // k は7ビット符号付き数
1153: k &= 0x7f;
1154: if ((k & 0x40)) {
1155: k = (int32)(int8)(k | 0x80);
1156: }
1157:
1158: fpu_explode(&fe, &fe.fe_f3, FTYPE_EXT, &RegFP(srcnum));
1159: fpu_ftop(&fe, &fe.fe_f3, data, k);
1160:
1161: ea = cea_fpu(12);
1162: write_12(ea, data);
1163: }
1164:
1165: // FMOVEM.L <ea>,<ctllist>
1166: // 1111 ccc 000 mmmrrr | 10D RRR 0000 000000
1167: // D=0: <ea> to FPctl
1168: // RRR: register list
1169: void
1170: MPU680x0Device::fpu_op_fmovem_ea2ctl()
1171: {
1172: uint mr = ir & 0x3f;
1173: uint reglist = (ir2 >> 10) & 7;
1174: int count;
1175: uint32 ea;
1176: uint32 src[3];
1177: int i;
1178:
1179: // cache case worst case
1180: // FMOVE Rn,FPc 28 31
1181: // FMOVE <ea>,FPc 33 36
1182: // FMOVE #imm,FPc 30 31
1183: // FMOVEM <ea>,FPcs 27+6n 30+6n
1184: // FMOVEM #imm,FPcs 25+6n 29+6n
1185: //
1186: // FMOVE #imm と FMOVEM #imm (n==1) は cache case が 1クロックだけ違う
1187: // ようだけどもう無視する。
1188:
1189: // 転送するレジスタ数。
1190: // nofpc の場合は現在の 68881 の実装では FPIAR が選択される。
1191: if (reglist == 0)
1192: reglist = 1;
1193: count = __builtin_popcount(reglist);
1194:
1195: if (mr < 8) { // Dn
1196: CYCLE2(28, 31);
1197: // 対データレジスタは転送数 1 のみ有効
1198: if (count > 1) {
1199: fpu_op_illg2();
1200: return;
1201: }
1202: src[0] = reg.R[mr];
1203:
1204: } else if (mr < 16) { // An
1205: CYCLE2(28, 31);
1206: // 対アドレスレジスタは FPIAR のみ有効
1207: if (reglist != 1) {
1208: fpu_op_illg2();
1209: return;
1210: }
1211: src[0] = reg.R[mr];
1212:
1213: } else if (mr < 0x3c) { // 対メモリ
1214: CYCLE2(28, 30);
1215: CYCLE(count * 6);
1216:
1217: // EA を取得。
1218: // -(An) の時も先にレジスタ数分一気に減算して、そこからプラス方向に
1219: // 読み込んでいくので、ロジックは全部同じになる。
1220: // (68000PRM.pdf p393)
1221: ea = cea_fpu(count * 4);
1222: for (i = 0; i < count; i++) {
1223: src[i] = read_4(ea);
1224: ea += 4;
1225: }
1226:
1227: } else if (mr == 0x3c) { // #imm
1228: CYCLE2(25, 29);
1229: CYCLE(count * 6);
1230:
1231: for (i = 0; i < count; i++) {
1232: src[i] = fetch_4();
1233: }
1234:
1235: } else {
1236: fpu_op_illg2();
1237: return;
1238: }
1239:
1240: // 該当レジスタへ読み込み
1241: i = 0;
1242: if ((reglist & 4)) {
1243: RegFPCR = src[i++] & M68K::FPCR_MASK;
1244: }
1245: if ((reglist & 2)) {
1246: RegFPSR = src[i++] & M68K::FPSR_MASK;
1247: }
1248: if ((reglist & 1)) {
1249: RegFPIAR = src[i++];
1250: }
1251: }
1252:
1253: // FMOVEM.L <ctllist>,<ea>
1254: // 1111 ccc 000 mmmrrr | 10D RRR 0000 000000
1255: // D=1: FPctl to <ea>
1256: // RRR: register list
1257: void
1258: MPU680x0Device::fpu_op_fmovem_ctl2ea()
1259: {
1260: uint mr = ir & 0x3f;
1261: uint reglist = (ir2 >> 10) & 7;
1262: int count;
1263: uint32 ea;
1264:
1265: // cache case worst case
1266: // FMOVE FPc,Rn 31 34
1267: // FMOVE FPc,<ea> 33 36
1268: // FMOVEM FPcs,<ea> 27+6n 30+6n
1269:
1270: // 転送するレジスタ数。
1271: // nofpc の場合は現在の 68881 の実装では FPIAR が選択される。
1272: if (reglist == 0)
1273: reglist = 1;
1274: count = __builtin_popcount(reglist);
1275:
1276: if (mr < 8) { // Dn
1277: CYCLE2(31, 34);
1278: // 対データレジスタは転送数は 1 のみ有効
1279: if (count > 1) {
1280: fpu_op_illg2();
1281: return;
1282: }
1283:
1284: if ((reglist & 4)) {
1285: reg.R[mr] = RegFPCR;
1286: }
1287: if ((reglist & 2)) {
1288: reg.R[mr] = RegFPSR;
1289: }
1290: if ((reglist & 1)) {
1291: reg.R[mr] = RegFPIAR;
1292: }
1293: return;
1294: }
1295: if (mr < 16) { // An
1296: CYCLE2(31, 34);
1297: // 対アドレスレジスタは FPIAR のみ有効
1298: if (reglist != 1) {
1299: fpu_op_illg2();
1300: return;
1301: }
1302: reg.R[mr] = RegFPIAR;
1303: return;
1304: }
1305: if (mr >= 0x3a) { // #imm, d16(PC), (PC,IX)
1306: fpu_op_illg2();
1307: return;
1308: }
1309:
1310: // それ以外、対メモリの場合。
1311: CYCLE2(27, 30);
1312: CYCLE(count * 6);
1313:
1314: // EA を取得して...
1315: ea = cea_fpu(count * 4);
1316: // 該当レジスタをメモリへ書き出し
1317: if ((reglist & 4)) {
1318: write_4(ea, RegFPCR);
1319: ea += 4;
1320: }
1321: if ((reglist & 2)) {
1322: write_4(ea, RegFPSR);
1323: ea += 4;
1324: }
1325: if ((reglist & 1)) {
1326: write_4(ea, RegFPIAR);
1327: ea += 4;
1328: }
1329: }
1330:
1331: // FMOVEM.X <ea>,<reglist>
1332: // FMOVEM.X <ea>,Dn
1333: // 1111 ccc 000 mmmrrr | 11D MM000 RRRRRRRR
1334: // D=0: <ea> to FPn
1335: void
1336: MPU680x0Device::fpu_op_fmovem_ea2reg()
1337: {
1338: uint mr = ir & 0x3f;
1339: bool predec = !(ir2 & 0x1000);
1340: bool dynamic = (ir2 & 0x0800);
1341: uint8 reglist = ir2 & 0xff;
1342: int i;
1343: uint32 ea;
1344:
1345: // cache worst
1346: // FMOVEM.X <ea>,<list> 35+23n 38+23n
1347: // FMOVEM.X <ea>,Dn 49+23n 52+23n
1348:
1349: // 不当パターンを弾く
1350: switch (mr) {
1351: case 000 ... 007: // Dn
1352: case 010 ... 017: // An
1353: case 040 ... 047: // -(An)
1354: case 074: // #imm
1355: case 075 ... 077:
1356: fpu_op_illg2();
1357: return;
1358: }
1359:
1360: // ダイナミックモードなら reglist の %0nnn0000 にレジスタ番号が
1361: // 入っているので、この Dn の下位8ビットを取り出す。レジスタ番号以外の
1362: // ビットは無視、Dn の上位ビットも無視。
1363: // ついでにここでベースサイクル数を加算。
1364: if (dynamic) {
1365: reglist = reg.D[(reglist >> 4) & 7];
1366: CYCLE2(49, 52);
1367: } else {
1368: CYCLE2(35, 38);
1369: }
1370:
1371: // EA は最初に一度取得しておいて...
1372: int count = __builtin_popcount(reglist);
1373: ea = cea_fpu(12 * count);
1374:
1375: if (predec) {
1376: // predec ならビット7から FP7..FP0 で、bit7 側から順に転送。
1377: for (i = 7; reglist; reglist <<=1, i--) {
1378: if ((int8)reglist < 0) {
1379: read_12(ea, &RegFP(i));
1380: ea += 12;
1381: }
1382: }
1383: } else {
1384: // ctrl/postinc ならビット7から FP0..FP7 で、bit7 側から順に転送。
1385: for (i = 0; reglist; reglist <<= 1, i++) {
1386: if ((int8)reglist < 0) {
1387: read_12(ea, &RegFP(i));
1388: ea += 12;
1389: }
1390: }
1391: }
1392: CYCLE(23 * count);
1393: }
1394:
1395: // FMOVEM.X <reglist>,<ea>
1396: // FMOVEM.X Dn,<ea>
1397: // 1111 ccc 000 mmmrrr | 11D MM000 RRRRRRRR
1398: // D=1: FPn to <ea>
1399: void
1400: MPU680x0Device::fpu_op_fmovem_reg2ea()
1401: {
1402: uint mr = ir & 0x3f;
1403: bool anpd = false; // 第1ワード EA が -(An) か
1404: bool predec = !(ir2 & 0x1000); // 第2ワードの mode が predec か
1405: bool dynamic = (ir2 & 0x0800);
1406: uint8 reglist = ir2 & 0xff;
1407: int i;
1408: uint32 ea;
1409:
1410: // cache worst
1411: // FMOVEM.X <list>,<ea> 37+25n 40+25n
1412: // FMOVEM.X Dn,<ea> 51+25n 54+25n
1413:
1414: // 不当パターンを弾く
1415: // ついでに -(An) だけ覚えておく
1416: switch (mr) {
1417: case 000 ... 007: // Dn
1418: case 010 ... 017: // An
1419: case 030 ... 037: // (An)+
1420: case 072: // d16(PC)
1421: case 073: // d8(PC,IX)
1422: case 074: // #imm
1423: case 075 ... 077:
1424: fpu_op_illg2();
1425: return;
1426: case 040 ... 047: // -(An)
1427: anpd = true;
1428: break;
1429: }
1430:
1431: // ダイナミックモードなら reglist の %0nnn0000 にレジスタ番号が
1432: // 入っているので、この Dn の下位8ビットを取り出す。レジスタ番号以外の
1433: // ビットは無視、Dn の上位ビットも無視。
1434: // ついでにここでベースクロックを記録
1435: if (dynamic) {
1436: reglist = reg.D[(reglist >> 4) & 7];
1437: CYCLE2(51, 54);
1438: } else {
1439: CYCLE2(37, 40);
1440: }
1441:
1442: int count = __builtin_popcount(reglist);
1443:
1444: // -(An) の時だけ EA を別処理。
1445: // 現状の cea_fpu() は -(An) の時、巻き戻し用のレジスタを保存し
1446: // デクリメントしたアドレスを返すまでを一度に行う便利関数だが、
1447: // FMOVEM fpn,-(An) は最初に巻き戻し用レジスタを保存し (これは命令先頭
1448: // に戻るためなので最初の1回だけ)、その後レジスタ1つずつ 12バイトを
1449: // プリデクリメントしながら格納していく必要がある (この順に実行しないと
1450: // バスエラーの原因箇所が異なってしまう)。
1451: // そのため cea_fpu() がそのまま使えないので、ここだけ独自対応する。
1452: // cea_fpu() は1命令中で EA の取得が1回である前提のあくまで便利関数
1453: // なので、例外的である FMOVEM は仕方がない。
1454: if (anpd) {
1455: CYCLE(6);
1456: uint n = eanum(ir);
1457: save_reg_pd(n);
1458:
1459: if (predec) {
1460: // predec ならビット7から FP7..FP0 で、bit7 側から順に転送。
1461: for (i = 7; reglist; reglist <<= 1, i--) {
1462: if ((int8)reglist < 0) {
1463: reg.A[n] -= 12;
1464: write_12(reg.A[n], &RegFP(i));
1465: }
1466: }
1467: } else {
1468: // ctrl/postinc ならビット7から FP0..FP7 で、bit7 側から順に転送。
1469: for (i = 0; reglist; reglist <<= 1, i++) {
1470: if ((int8)reglist < 0) {
1471: reg.A[n] -= 12;
1472: write_12(reg.A[n], &RegFP(i));
1473: }
1474: }
1475: }
1476: } else {
1477: // -(An) 以外は EA を最初に一度計算しておく方法が使える
1478: ea = cea_fpu(12 * count);
1479:
1480: if (predec) {
1481: // predec ならビット7から FP7..FP0 で、bit7 側から順に転送。
1482: for (i = 7; reglist; reglist <<= 1, i--) {
1483: if ((int8)reglist < 0) {
1484: write_12(ea, &RegFP(i));
1485: ea += 12;
1486: }
1487: }
1488: } else {
1489: // ctrl/postinc ならビット7から FP0..FP7 で、bit7 側から順に転送。
1490: for (i = 0; reglist; reglist <<= 1, i++) {
1491: if ((int8)reglist < 0) {
1492: write_12(ea, &RegFP(i));
1493: ea += 12;
1494: }
1495: }
1496: }
1497: }
1498: CYCLE(25 * count);
1499: }
1500:
1501: // FScc.B <ea>
1502: // 1111 ccc 001 mmmrrr | 0000 000 000 CCCCCC
1503: void
1504: MPU680x0Device::fpu_op_fscc()
1505: {
1506: uint mr = ir & 0x3f;
1507: uint mm = eamode(ir);
1508: uint rr = eanum(ir);
1509: uint cond = ir2 & 0x3f;
1510: uint32 data;
1511: uint32 ea;
1512:
1513: // cache worst
1514: // FScc.B Dn 18 21
1515: // FScc.B (An)+/-(An) 22 25 ; condition is true
1516: // FScc.B (An)+/-(An) 21 24 ; condition is false
1517: // FScc.B <ea> 20 23
1518:
1519: if (cond > 0x1f) {
1520: fpu_op_illg2();
1521: return;
1522: }
1523:
1524: data = (test_cc(&fe, cond) == -1) ? 0xff : 0x00;
1525:
1526: switch (mm) {
1527: case 0: // Dn
1528: CYCLE2(18, 21);
1529: reg.D[rr] &= 0xffffff00;
1530: reg.D[rr] |= data;
1531: return;
1532:
1533: case 3: // (An)+
1534: case 4: // -(An)
1535: // ここだけ他のメモリ系 EA とはクロックが違うし、
1536: // 条件の成立可否でも違う。
1537: if (data == 0x00) {
1538: CYCLE2(21, 24);
1539: } else {
1540: CYCLE2(22, 25);
1541: }
1542: break;
1543: case 7:
1544: if (mr == 0x38 || mr == 0x39) { // Abs.W, Abs.L
1545: } else {
1546: fpu_op_illg2();
1547: return;
1548: }
1549: FALLTHROUGH;
1550: default:
1551: CYCLE2(20, 23);
1552: break;
1553: }
1554:
1555: ea = cea_fpu(1);
1556: write_1(ea, data);
1557: }
1558:
1559: // FDBcc Dn,<label>
1560: // 1111 ccc 001 001rrr | 0000 000 000 CCCCCC | <16bit disp>
1561: void
1562: MPU680x0Device::fpu_op_fdbcc()
1563: {
1564: uint rr = ir & 7;
1565: uint cond = ir2 & 0x3f;
1566:
1567: if (cond > 0x1f) {
1568: fpu_op_illg2();
1569: return;
1570: }
1571:
1572: if (test_cc(&fe, cond) == -1) {
1573: // 真なら何もしない。disp を読み飛ばして次へ
1574: CYCLE2(20, 24);
1575: fetch_2();
1576: } else {
1577: // 偽の場合
1578: uint16 data = reg.D[rr] - 1;
1579: reg.D[rr] = (reg.D[rr] & 0xffff0000) | data;
1580:
1581: if (data == 0xffff) {
1582: // ループ終了。disp を読み飛ばす
1583: CYCLE2(24, 32);
1584: fetch_2();
1585: } else {
1586: // 計算に使う PC はディスプレースメントのあるアドレス。
1587: CYCLE2(20, 26);
1588: uint32 origin = reg.pc;
1589: int32 disp = (int32)(int16)fetch_2();
1590: Jump(origin + disp);
1591: }
1592: }
1593: }
1594:
1595: // FTRAPcc.W #<data>
1596: void
1597: MPU680x0Device::fpu_op_ftrapcc_w()
1598: {
1599: uint cond = ir2 & 0x3f;
1600:
1601: if (cond > 0x1f) {
1602: fpu_op_illg2();
1603: return;
1604: }
1605:
1606: // 即値はいずれにしても読み捨てる必要がある。
1607: fetch_2();
1608:
1609: if (test_cc(&fe, cond) == -1) {
1610: CYCLE2(41, 45);
1611: Exception(M68K::EXCEP_TRAPV);
1612: } else {
1613: CYCLE2(20, 23);
1614: }
1615: }
1616:
1617: // FTRAPcc.L #<data>
1618: void
1619: MPU680x0Device::fpu_op_ftrapcc_l()
1620: {
1621: uint cond = ir2 & 0x3f;
1622:
1623: if (cond > 0x1f) {
1624: fpu_op_illg2();
1625: return;
1626: }
1627:
1628: // 即値はいずれにしても読み捨てる必要がある。
1629: fetch_4();
1630:
1631: if (test_cc(&fe, cond) == -1) {
1632: CYCLE2(43, 52);
1633: Exception(M68K::EXCEP_TRAPV);
1634: } else {
1635: CYCLE2(22, 27);
1636: }
1637: }
1638:
1639: // FTRAPcc
1640: void
1641: MPU680x0Device::fpu_op_ftrapcc()
1642: {
1643: uint cond = ir2 & 0x3f;
1644:
1645: if (cond > 0x1f) {
1646: fpu_op_illg2();
1647: return;
1648: }
1649:
1650: // 即値なし。
1651:
1652: if (test_cc(&fe, cond) == -1) {
1653: CYCLE2(39, 47);
1654: Exception(M68K::EXCEP_TRAPV);
1655: } else {
1656: CYCLE2(18, 22);
1657: }
1658: }
1659:
1660: // FBcc.W <label>
1661: // 1111 ccc 01S CCCCCC | <16bit disp>
1662: // S=0: 16bit disp
1663: //
1664: // FNOP
1665: // 1111 ccc 010 000000 | 0000 0000 0000 0000
1666: void
1667: MPU680x0Device::fpu_op_fbcc_w()
1668: {
1669: uint cond = ir & 0x3f;
1670:
1671: // TODO: Illegal condition の戻り値を処理すること。他の test_cc() も同様。
1672: if (test_cc(&fe, cond) == -1) {
1673: CYCLE2(20, 23);
1674: uint32 origin = reg.pc;
1675: int32 disp = (int32)(int16)fetch_2();
1676: Jump(origin + disp);
1677: } else {
1678: // disp を読み飛ばす
1679: CYCLE2(18, 19);
1680: fetch_2();
1681: }
1682: }
1683:
1684: // FBcc.L <label>
1685: // 1111 ccc 01S CCCCCC | <32bit disp>
1686: // S=1: 32bit disp
1687: void
1688: MPU680x0Device::fpu_op_fbcc_l()
1689: {
1690: uint cond = ir & 0x3f;
1691:
1692: if (test_cc(&fe, cond) == -1) {
1693: CYCLE2(20, 23);
1694: uint32 origin = reg.pc;
1695: int32 disp = (int32)fetch_4();
1696: Jump(origin + disp);
1697: } else {
1698: // disp を読み飛ばす
1699: CYCLE2(18, 21);
1700: fetch_4();
1701: }
1702: }
1703:
1704: // FSAVE の NULL フレーム (全機種共通で4バイト)
1705: /*static*/ const uint32
1706: MPU680x0Device::fsave_frame_null[] = {
1707: 0,
1708: };
1709:
1710: // FSAVE のアイドルフレーム (68881)
1711: /*static*/ const uint32
1712: MPU680x0Device::fsave_frame_idle_68881[] = {
1713: 0x1f180000,
1714: 0x0000ffff,
1715: 0,
1716: 0,
1717: 0,
1718: 0,
1719: 0x70000000,
1720: };
1721:
1722: // FSAVE のアイドルフレーム (68040)
1723: /*static*/ const uint32
1724: MPU680x0Device::fsave_frame_idle_68040[] = {
1725: 0x41000000,
1726: };
1727:
1728: // FSAVE
1729: // スーパーバイザモードは判定済み
1730: void
1731: MPU680x0Device::fpu_op_fsave()
1732: {
1733: uint32 ea;
1734: std::array<uint32, 13> frame_noimpl;
1735: const uint32 *frame;
1736: int framelen;
1737:
1738: // フレームを選択。
1739: switch (fpu_state) {
1740: case FPU_STATE_NULL:
1741: // NULL フレーム
1742: CYCLE2(16, 18);
1743: frame = fsave_frame_null;
1744: framelen = countof(fsave_frame_null);
1745: break;
1746: case FPU_STATE_IDLE:
1747: case FPU_STATE_BUSY: // 実装してないけどとりあえず。
1748: // IDLE フレーム
1749: CYCLE2(52, 54); // XXX これは最小値らしいけど
1750: if (fpu_type.Is4060FPU()) {
1751: frame = fsave_frame_idle_68040;
1752: framelen = countof(fsave_frame_idle_68040);
1753: } else {
1754: frame = fsave_frame_idle_68881;
1755: framelen = countof(fsave_frame_idle_68881);
1756: }
1757: break;
1758: case FPU_STATE_NOIMPL:
1759: // 68040 で浮動小数点未実装命令を実行した。
1760: fpu_op_fsave_frame_noimpl(frame_noimpl);
1761: frame = frame_noimpl.data();
1762: framelen = frame_noimpl.size();
1763: break;
1764: default:
1765: PANIC("fpu_state=%u corrupted", fpu_state);
1766: }
1767:
1768: switch (ir & 077) {
1769: case 020 ... 027: // (An)
1770: case 040 ... 047: // -(An)
1771: case 050 ... 057: // d16(An)
1772: case 060 ... 067: // d8(An,IX)
1773: case 070 ... 071: // Abs.[WL]
1774: ea = cea_fpu(framelen * 4);
1775: break;
1776: default:
1777: fpu_op_illg();
1778: return;
1779: }
1780:
1781: // -(An) もそれ以外もどちらも、まず先頭フレームを書き出す。
1782: // この時点で ea は先頭フレームの位置を指している。
1783: write_4(ea, frame[0]);
1784:
1785: // -(An) もそれ以外もどちらも、
1786: // 残りはプリデクリメントのように高位側から順に書き出す。
1787: ea += framelen * 4;
1788: for (int i = framelen - 1; i > 0; i--) {
1789: ea -= 4;
1790: write_4(ea, frame[i]);
1791: }
1792: }
1793:
1794: // FRESTORE
1795: // スーパーバイザモードは判定済み
1796: void
1797: MPU680x0Device::fpu_op_frestore()
1798: {
1799: uint mm = eamode(ir);
1800: uint rr = eanum(ir);
1801: uint32 ea;
1802: uint32 fmtword;
1803: uint32 ver_len;
1804: uint32 len;
1805: bool postinc;
1806:
1807: postinc = false;
1808: // EA は独自体系なのでここでべたに書く
1809: switch (mm) {
1810: case 2: // (An)
1811: ea = cea_anin(rr);
1812: break;
1813: case 3: // (An)+
1814: ea = cea_anin(rr);
1815: postinc = true;
1816: break;
1817: case 5: // d16(An)
1818: ea = cea_andi(rr);
1819: break;
1820: case 6: // (An,IX)
1821: ea = cea_anix(rr);
1822: break;
1823: case 7:
1824: switch (rr) {
1825: case 0: // Abs.W
1826: ea = cea_absw();
1827: break;
1828: case 1: // Abs.L
1829: ea = cea_absl();
1830: break;
1831: case 2: // d16(PC)
1832: ea = cea_pcdi();
1833: break;
1834: case 3: // (PC,IX)
1835: ea = cea_pcix();
1836: break;
1837: default:
1838: fpu_op_illg();
1839: return;
1840: }
1841: break;
1842: default:
1843: fpu_op_illg();
1844: return;
1845: }
1846:
1847: // 先頭の1ロングワードを読んでみる。
1848: // これがフォーマットワード $VVLL'xxxx で、VV がバージョン(8bit)、
1849: // LL が(自身を含まないこれ以降の) バイト数 (8bit) を示している。
1850: // 68881 本では下位ワードは Reserved($0000) となっているが、
1851: // 68040 本では Reserved のみで値の言及はない。
1852: //
1853: // 68881:
1854: // NULL $0000'0000
1855: // IDLE $1f18'0000 (以降 6 ロングワード)
1856: // BUSY $1fb4'0000 (以降 45 ロングワード) (*)
1857: //
1858: // 68040:
1859: // NULL $0000'xxxx
1860: // IDLE $4100'xxxx
1861: // BUSY $4160'xxxx (以降 24 ロングワード) (*)
1862: // UNIMP $4130'xxxx (以降 12 ロングワード)
1863: //
1864: // *: BUSY フレームは現状の FSAVE が出力しないので来ないはず。
1865:
1866: fmtword = read_4(ea);
1867: ea += 4;
1868:
1869: ver_len = fmtword >> 16;
1870: len = ver_len & 0xff;
1871:
1872: if (GetFPUType().Is4060FPU()) {
1873: if (ver_len == 0) {
1874: // NULL フレーム。
1875:
1876: // NULL フレームのリストアは FPU の状態をリセットする。
1877: CYCLE2(21, 22);
1878: ResetFPU(false);
1879: } else if (ver_len == 0x4100) {
1880: // IDLE フレーム。
1881:
1882: // 現状何も実装していないので、状態を戻して読み捨てるだけ。
1883: CYCLE2(57, 58);
1884: fpu_state = FPU_STATE_IDLE;
1885: } else if (ver_len == 0x4130) {
1886: // 浮動小数点未実装命令フレーム。
1887: // どうなる?
1888: putlog(0, "FRESTORE: Unsupported UNIMP frame");
1889: } else if (ver_len == 0x4160) {
1890: // BUSY フレーム。
1891: putlog(0, "FRESTORE: Unsupported BUSY frame");
1892: if (0) {
1893: putlog(0, "[+00] %08x", fmtword);
1894: for (int offset = 4; offset < len; offset += 4) {
1895: uint32 m = read_4(ea + offset);
1896: putlog(0, "[+%02x] %08x", offset, m);
1897: }
1898: }
1899: } else {
1900: Exception(M68K::EXCEP_FORMAT);
1901: goto done;
1902: }
1903: } else /* 68881 */ {
1904: if (ver_len == 0) {
1905: // NULL フレーム。
1906:
1907: // NULL フレームのリストアは FPU の状態をリセットする。
1908: CYCLE2(21, 22);
1909: ResetFPU(false);
1910: } else if (ver_len == 0x1f18) {
1911: // IDLE フレーム。
1912:
1913: // 現状何も実装していないので、状態を戻して読み捨てるだけ。
1914: CYCLE2(57, 58);
1915: fpu_state = FPU_STATE_IDLE;
1916: } else {
1917: if (ver_len == 0x1fb4) {
1918: putlog(0, "FRESTORE: Unsupported BUSY frame");
1919: }
1920: Exception(M68K::EXCEP_FORMAT);
1921: goto done;
1922: }
1923: }
1924:
1925: // とにかく残りを全部読み捨てる。
1926: len /= 4;
1927: for (int i = 0; i < len; i++) {
1928: read_4(ea);
1929: ea += 4;
1930: }
1931:
1932: done:
1933: // (An)+ なら更新。
1934: // フォーマットワードを読んだところでエラーが起きたら +4 だけ更新される?
1935: if (postinc) {
1936: reg.A[rr] = ea;
1937: }
1938: }
1939:
1940: // 現在の fpu40 の状態から
1941: // 68040 の浮動小数点未実装命令フレームを作成して frame に書き出す。
1942: void
1943: MPU680x0Device::fpu_op_fsave_frame_noimpl(std::array<uint32, 13>& frame)
1944: {
1945: uint32 cmd1;
1946: uint32 reg3b;
1947: uint32 data6;
1948:
1949: // CMDREG1B 形式の Ry+CMD1 から CMDREG3B 形式の Ry+CMD3 を作る。
1950: cmd1 = fpu40.reg1b & 0x3ff;
1951: reg3b = (cmd1 & 0x3c3) | ((cmd1 >> 1) & 0x1c) | ((cmd1 << 3) & 0x20);
1952:
1953: data6 = fpu40.eflag;
1954: if (fpu40.post) {
1955: data6 |= 0x0010'0000;
1956: }
1957:
1958: frame[0] = 0x41300000;
1959: frame[1] = reg3b << 16;
1960: frame[2] = 0;
1961: frame[3] = (uint32)fpu40.stag << 29;
1962: frame[4] = fpu40.reg1b << 16;
1963: frame[5] = (uint32)fpu40.dtag << 29;
1964: frame[6] = data6;
1965: memcpy(&frame[7], fpu40.fptemp, 12);
1966: memcpy(&frame[10], fpu40.etemp, 12);
1967:
1968: // モニタ表示用。
1969: fpu40.enable = false;
1970: }
1971:
1972: // 浮動小数点系の例外。
1973: // fpu40 の stag, dtag, etemp, fptemp, eflag を必要に応じてセットしてから
1974: // 呼ぶこと。
1975: void
1976: MPU680x0Device::ExceptionFP(uint vector)
1977: {
1978: fpu_state = FPU_STATE_NOIMPL;
1979:
1980: // CMDREG1B は実質 2ワード目のことのようだ。
1981: // FMOVECR のケースはドキュメントに見当たらないが、FPSP を読む限り
1982: // CMDREG1B はここでも FMOVECR の第2ワードそのままのようだ。
1983: // FSQRT 用のハックで cmd(offset) の $04 を $05 に書き換えるが、FPSP の
1984: // FMOVECR はどちらも 0.0 を返すので、書き換えてしまっても問題ないはず?
1985: uint32 reg1b = ir2;
1986: if ((reg1b & 0x3f) == 0x04) {
1987: // FSQRT だけマッピングが違う。
1988: reg1b++;
1989: }
1990: fpu40.reg1b = reg1b;
1991: fpu40.post = false;
1992: fpu40.enable = true;
1993:
1994: // この例外を起こした命令のアドレスは FPIAR に置く。
1995: reg.fpframe.fpf_fpiar = ppc;
1996:
1997: // EXCEP_FP_UNIMPL (未実装命令例外) はベクタが F ラインと同じで、
1998: // フレームフォーマットが違うので、定数値に細工がしてある。
1999: const uint32 inst = BranchHistory_m680x0::Exception | (vector & 0xff);
2000: ExceptionGeneric(vector, inst);
2001: }
2002:
2003: // CMDREG1B からコマンド名を返す。
2004: // FSQRT 命令の第2ワードの cmd 部分は $04 だが CMDREG1B では $05 になる。
2005: /*static*/ std::string
2006: MPU68040Device::GetReg1BName(uint32 opclass, uint32 sz, uint32 cmd)
2007: {
2008: std::string name;
2009:
2010: if (opclass != 0 && opclass != 2) {
2011: return "";
2012: }
2013:
2014: if (sz == 7) {
2015: return "fmovecr";
2016: }
2017:
2018: if (__predict_false(0x30 <= cmd && cmd < 0x38)) {
2019: name = "fsincos";
2020: name += '0' + (cmd - 0x30);
2021: return name;
2022: }
2023:
2024: if (__predict_false(cmd == 0x04)) {
2025: // 来ないはずだけど一応。
2026: return "fsqrt(4)";
2027: }
2028:
2029: if (__predict_false(cmd == 0x05)) {
2030: cmd = 0x04;
2031: }
2032: name = m680x0disasm::make_fpgen(cmd);
2033: return name;
2034: }
2035:
2036: /*static*/ std::string
2037: MPU68040Device::GetFPUTagName(int32 tag)
2038: {
2039: const char * const tagnames[] = {
2040: "(Normal)",
2041: "(Zero)",
2042: "(Inf)",
2043: "(NAN)",
2044: "(Unnormal)",
2045: "(Denormal)",
2046: };
2047:
2048: if (__predict_true(tag < countof(tagnames))) {
2049: return tagnames[tag];
2050: }
2051: if (tag == FPU40::TAG_DENORMAL_S) {
2052: return "(Denormal.S)";
2053: }
2054: if (tag == FPU40::TAG_DENORMAL_D) {
2055: return "(Denormal.D)";
2056: }
2057: if (tag == FPU40::TAG_DENORMAL_X) {
2058: return "(Denormal.X)";
2059: }
2060: if (tag == FPU40::TAG_UNNORMAL_X) {
2061: return "(Unnormal.X)";
2062: }
2063: if (tag == FPU40::TAG_NONE) {
2064: return "(NONE)";
2065: }
2066: return "";
2067: }
2068:
2069: // モニター更新 (040 内部情報)
2070: void
2071: MPU68040Device::MonitorUpdateFPU40(TextScreen& screen, int y, const FPU40& tmp)
2072: {
2073: // CMDREG1B:$xxxx OPCLASS=0 Rs=7 Rd=7 cmd=00(FTWOTOX) Flags: E3 E1 T
2074: // ETEMP :$01234567_01234567_01234567 STAG:1(Unnormal)
2075: // FPTEMP:
2076:
2077: TA attr = tmp.enable ? TA::Normal : TA::Disable;
2078:
2079: uint32 reg1b = tmp.reg1b;
2080: uint32 opclass = reg1b >> 13;
2081: uint32 rx = (reg1b >> 10) & 7;
2082: uint32 ry = (reg1b >> 7) & 7;
2083: uint32 cmd = reg1b & 0x7f;
2084:
2085: std::string cmdname = GetReg1BName(opclass, rx, cmd);
2086: if (__predict_true(cmdname.empty() == false)) {
2087: cmdname = '(' + cmdname + ')';
2088: }
2089:
2090: std::string stagname = GetFPUTagName(tmp.stag);
2091: std::string dtagname = GetFPUTagName(tmp.dtag);
2092:
2093: screen.Print(0, y, attr,
2094: "CMDREG1B:%04x OPCLASS=%u Rs=%u Rd=%u CMD=$%02x%s",
2095: reg1b, opclass, rx, ry, cmd, cmdname.c_str());
2096: screen.Puts(56, y, attr, "Flags:");
2097: screen.Puts(62, y, attr, (tmp.eflag & FPU40::E1) ? "E1" : "--");
2098: screen.Puts(65, y, attr, (tmp.eflag & FPU40::E3) ? "E3" : "--");
2099: screen.Puts(68, y, attr, (tmp.post) ? "T" : "-");
2100: y++;
2101: screen.Print(0, y, attr, "ETEMP: %08x_%08x_%08x STAG:%d%s",
2102: tmp.etemp[0], tmp.etemp[1], tmp.etemp[2],
2103: (__predict_true(tmp.stag >= 0) ? (tmp.stag & 7) : tmp.stag),
2104: stagname.c_str());
2105: screen.Print(56, y, attr, "EA:%08x", tmp.ea);
2106: y++;
2107: screen.Print(0, y++, attr, "FPTEMP:%08x_%08x_%08x DTAG:%d%s",
2108: tmp.fptemp[0], tmp.fptemp[1], tmp.fptemp[2],
2109: (__predict_true(tmp.dtag >= 0) ? (tmp.dtag & 7) : tmp.dtag),
2110: dtagname.c_str());
2111: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.