![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to m680x0.h 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 m680x0.h 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: #pragma once
8:
9: #include "bus.h"
10:
11: // どこ?
12: __BEGIN_DECLS
13: #include "fpu_emulate.h"
14: __END_DECLS
15:
16: // MPU 種別
17: enum class m680x0MPUType
18: {
19: NONE = 0,
20: M68030 = (1U << 1),
21: M68040 = (1U << 2),
22: };
23:
24: // FPU 種別
25: struct m680x0FPUType
26: {
27: enum m680x0FPUType_ {
28: M68030_NOFPU = 0, // 68030 without 6888x
29: M68LC040 = (1U << 0),
30: M68LC060 = (1U << 1), // (reserved)
31: M68040 = (1U << 2),
32: M68060 = (1U << 3), // (reserved)
33: M68881 = (1U << 4),
34: M68882 = (1U << 5),
35:
36: M68LC0x0 = (M68LC040 | M68LC060),
37: M680x0 = (M68040 | M68060),
38: M6888x = (M68881 | M68882),
39: } type {};
40:
41: // コンストラクタ
42: m680x0FPUType() {
43: }
44: m680x0FPUType(m680x0FPUType_ type_)
45: : type(type_)
46: {
47: }
48:
49: bool IsNoFPU() const noexcept { return (type == M68030_NOFPU); }
50: bool Is4060LC() const noexcept { return (type & M68LC0x0) != 0; }
51: bool Is40FPU() const noexcept { return (type & M68040) != 0; }
52: bool Is4060FPU() const noexcept { return (type & M680x0) != 0; }
53: bool Is6888x() const noexcept { return (type & M6888x) != 0; }
54: };
55: static inline bool operator==(const m680x0FPUType& a, const m680x0FPUType& b) {
56: return (a.type == b.type);
57: }
58: static inline bool operator!=(const m680x0FPUType& a, const m680x0FPUType& b) {
59: return !(a == b);
60: }
61:
62: // 定数
63: struct M68K
64: {
65: // SR(CCR)
66: static const uint32 SR_T = 0xc000;
67: static const uint32 SR_S = 0x2000;
68: static const uint32 SR_M = 0x1000;
69: static const uint32 SR_IMASK = 0x0700;
70: static const uint32 CCR_X = 0x0010;
71: static const uint32 CCR_N = 0x0008;
72: static const uint32 CCR_Z = 0x0004;
73: static const uint32 CCR_V = 0x0002;
74: static const uint32 CCR_C = 0x0001;
75:
76: // FC
77: static const uint32 FC_DATA = 1;
78: static const uint32 FC_PROG = 2;
79: static const uint32 FC_USER = 0;
80: static const uint32 FC_SUPER = 4;
81: static const uint32 FC_UD = (FC_USER | FC_DATA);
82: static const uint32 FC_UP = (FC_USER | FC_PROG);
83: static const uint32 FC_SD = (FC_SUPER | FC_DATA);
84: static const uint32 FC_SP = (FC_SUPER | FC_PROG);
85:
86: // FP
87: static const uint32 FPCR_MASK = 0x0000fff0;
88: static const uint32 FPSR_MASK = 0x0ffffff8;
89:
90: // 例外 (型は core.cpp の try-catch と揃えること)。
91: // FPU_NOIMPL (浮動小数点未実装命令例外) はベクタ番号が 11 ($b) で
92: // F ラインと同じだが処理が色々違うので帯域外のビットで判別する。
93: static const uint EXCEP_RESET = 0;
94: static const uint EXCEP_BUSERR = 2;
95: static const uint EXCEP_ADDRERR = 3;
96: static const uint EXCEP_ILLEGAL = 4;
97: static const uint EXCEP_ZERODIV = 5;
98: static const uint EXCEP_CHK = 6;
99: static const uint EXCEP_TRAPV = 7;
100: static const uint EXCEP_PRIV = 8;
101: static const uint EXCEP_TRACE = 9;
102: static const uint EXCEP_ALINE = 10;
103: static const uint EXCEP_FLINE = 11;
104: static const uint EXCEP_FP_UNIMPL = (11 | 0x100);
105: static const uint EXCEP_COPRO = 13;
106: static const uint EXCEP_FORMAT = 14;
107: static const uint EXCEP_UNINIT_INTR = 16;
108: static const uint EXCEP_SPURIOUS = 24;
109: static const uint EXCEP_LEVEL_BASE = 24; // オートベクタ演算用
110: static const uint EXCEP_LEVEL1 = 25;
111: static const uint EXCEP_LEVEL7 = 31;
112: static const uint EXCEP_TRAP0 = 32;
113: static const uint EXCEP_TRAP15 = 47;
114: static const uint EXCEP_FP_BSUN = 48;
115: static const uint EXCEP_FP_INEX = 49;
116: static const uint EXCEP_FP_ZERODIV = 50;
117: static const uint EXCEP_FP_UNFL = 51;
118: static const uint EXCEP_FP_OPERR = 52;
119: static const uint EXCEP_FP_OVFL = 53;
120: static const uint EXCEP_FP_SNAN = 54;
121: static const uint EXCEP_FP_UNSUPP = 55;
122: static const uint EXCEP_MMU_CONFIG = 56;
123: };
124:
125: // 定数
126: struct M68030
127: {
128: // SSW
129: static constexpr uint32 SSW_SIZE(uint32 x) { return ((x) & 0x03) << 4; }
130: static const uint32 SSW_SIZE_LONG = (0 << 4);
131: static const uint32 SSW_SIZE_BYTE = (1 << 4);
132: static const uint32 SSW_SIZE_WORD = (2 << 4);
133: static const uint32 SSW_SIZE_3BYTES = (3 << 4);
134: static const uint32 SSW_SIZE_MASK = (0x03 << 4);
135:
136: static const uint32 SSW_FC_MASK = 0x0007; // FC_*
137: static const uint32 SSW_RW = 0x0040; // SSW_BUS_{R,W}
138: static const uint32 SSW_RM = 0x0080;
139: static const uint32 SSW_DF = 0x0100; // Data Fault
140: static const uint32 SSW_RB = 0x1000;
141: static const uint32 SSW_RC = 0x2000;
142: static const uint32 SSW_FB = 0x4000;
143: static const uint32 SSW_FC = 0x8000;
144:
145: static const uint32 SSW_BUS_R = 0x0040;
146: static const uint32 SSW_BUS_W = 0x0000;
147:
148: // CACR
149: static const uint32 CACR_EI = 0x0001;
150: static const uint32 CACR_FI = 0x0002;
151: static const uint32 CACR_CEI = 0x0004;
152: static const uint32 CACR_CI = 0x0008;
153: static const uint32 CACR_IBE = 0x0010;
154: static const uint32 CACR_ED = 0x0100;
155: static const uint32 CACR_FD = 0x0200;
156: static const uint32 CACR_CED = 0x0400;
157: static const uint32 CACR_CD = 0x0800;
158: static const uint32 CACR_DBE = 0x1000;
159: static const uint32 CACR_WA = 0x2000;
160: static const uint32 CACR_MASK = 0x3f1f;
161: };
162:
163: // 定数
164: struct M68040
165: {
166: // SSW
167: static const uint32 SSW_TM_MASK = 0x0007;
168: static const uint32 SSW_TT_MASK = 0x0018;
169: static const uint32 SSW_SIZE_MASK = 0x0060; // (0x03 << 5)
170: static const uint32 SSW_RW = 0x0100;
171: static const uint32 SSW_LK = 0x0200;
172: static const uint32 SSW_ATC = 0x0400;
173: static const uint32 SSW_MA = 0x0800;
174: static const uint32 SSW_CM = 0x1000;
175: static const uint32 SSW_CT = 0x2000;
176: static const uint32 SSW_CU = 0x4000;
177: static const uint32 SSW_CP = 0x8000;
178:
179: static const uint32 SSW_SIZE_LONG = (0x00 << 5);
180: static const uint32 SSW_SIZE_BYTE = (0x01 << 5);
181: static const uint32 SSW_SIZE_WORD = (0x02 << 5);
182: static const uint32 SSW_SIZE_LINE = (0x03 << 5);
183: // バイトサイズから SSW_SIZE フィールドを作成する。1, 2, 4 バイトのみ。
184: static constexpr uint32 SSW_SIZE(uint32 x) { return ((x) & 0x03) << 5; }
185:
186: // CACR
187: static const uint32 CACR_MASK = 0x80008000;
188: static const uint32 CACR_DE = 0x80000000;
189: static const uint32 CACR_IE = 0x00008000;
190: };
191:
192: struct m680x0CCR
193: {
194: protected:
195: // X フラグは、X の X_BIT が立っていれば 1
196: // N フラグは、N の N_BIT が立っていれば 1
197: // Z フラグは、Z == 0 なら 1
198: // V フラグは、V の V_BIT が立っていれば 1
199: // C フラグは、C の C_BIT が立っていれば 1
200: static const uint32 X_BIT = 0x00000001;
201: static const uint32 N_BIT = 0x80000000;
202: static const uint32 V_BIT = 0x80000000;
203: static const uint32 C_BIT = 0x00000001;
204:
205: uint32 X;
206: uint32 V;
207: uint32 N;
208: DEF_UNION64(, CZ, C, Z);
209:
210: public:
211: // value をフラグにセットする
212: void SetX(bool value) { X = (value) ? X_BIT : 0; }
213: void SetN(bool value) { N = (value) ? N_BIT : 0; }
214: void SetZ(bool value) { Z = (value) ? 0 : 1; }
215: void SetV(bool value) { V = (value) ? V_BIT : 0; }
216: void SetC(bool value) { C = (value) ? C_BIT : 0; }
217:
218: // フラグが立っていれば真を返す
219: bool IsX() const { return ((X & X_BIT) != 0); }
220: bool IsN() const { return ((N & N_BIT) != 0); }
221: bool IsZ() const { return (Z == 0); }
222: bool IsV() const { return ((V & V_BIT) != 0); }
223: bool IsC() const { return ((C & C_BIT) != 0); }
224:
225: // CCR レジスタの内容を作って返す
226: uint8 Get() const {
227: return (IsX() ? M68K::CCR_X : 0)
228: | (IsN() ? M68K::CCR_N : 0)
229: | (IsZ() ? M68K::CCR_Z : 0)
230: | (IsV() ? M68K::CCR_V : 0)
231: | (IsC() ? M68K::CCR_C : 0);
232: }
233:
234: // CCR レジスタに val をセットする
235: void Set(uint8 val) {
236: SetX((val) & M68K::CCR_X);
237: SetN((val) & M68K::CCR_N);
238: SetZ((val) & M68K::CCR_Z);
239: SetV((val) & M68K::CCR_V);
240: SetC((val) & M68K::CCR_C);
241: }
242:
243: bool CondT() const { return true; }
244: bool CondF() const { return false; }
245: bool CondHI() const { return !IsC() && !IsZ(); }
246: bool CondLS() const { return IsC() || IsZ(); }
247: bool CondCC() const { return !IsC(); }
248: bool CondCS() const { return IsC(); }
249: bool CondNE() const { return !IsZ(); }
250: bool CondEQ() const { return IsZ(); }
251: bool CondVC() const { return !IsV(); }
252: bool CondVS() const { return IsV(); }
253: bool CondPL() const { return !IsN(); }
254: bool CondMI() const { return IsN(); }
255: bool CondGE() const { return (IsN() && IsV()) || (!IsN() && !IsV()); }
256: bool CondLT() const { return (IsN() && !IsV()) || (!IsN() && IsV()); }
257: bool CondGT() const {
258: return (IsN() && IsV() && !IsZ()) || (!IsN() && !IsV() && !IsZ());
259: }
260: bool CondLE() const {
261: return IsZ() || (IsN() && !IsV()) || (!IsN() && IsV());
262: }
263:
264: // cond で示される条件が成立すれば true を返す。
265: inline bool Cond(uint cond) const {
266: switch (cond) {
267: case 0: // T
268: return CondT();
269: case 1: // F
270: return CondF();
271: case 2:
272: return CondHI();
273: case 3:
274: return CondLS();
275: case 4:
276: return CondCC();
277: case 5:
278: return CondCS();
279: case 6:
280: return CondNE();
281: case 7:
282: return CondEQ();
283: case 8:
284: return CondVC();
285: case 9:
286: return CondVS();
287: case 10:
288: return CondPL();
289: case 11:
290: return CondMI();
291: case 12:
292: return CondGE();
293: case 13:
294: return CondLT();
295: case 14:
296: return CondGT();
297: case 15:
298: return CondLE();
299: }
300: __unreachable();
301: }
302: };
303:
304: // レジスタイメージを保持する構造体。
305: // この構造体はコピーとか比較をするのでポインタとかは置かないこと。
306: struct m68kreg
307: {
308: uint32 pc;
309: union {
310: uint32 R[16] {};
311: struct {
312: uint32 D[8];
313: uint32 A[8];
314: };
315: };
316:
317: m680x0CCR ccr;
318: bool s; // SR の S ビット
319: bool m; // SR の M ビット
320: int intr_mask; // SR の割り込みマスク (0-7)
321:
322: // 現在の SP は常に A[7]。A[7] が示しているときは対応する変数の
323: // ほうは更新されないため無効 (図中 'x')。
324: //
325: // A[7] usp isp msp
326: // ---- --- --- ---
327: // ユーザ USP x ISP MSP
328: // スーパーバイザ(I) ISP USP x MSP
329: // スーパーバイザ(M) MSP USP ISP x
330: uint32 usp;
331: uint32 isp;
332: uint32 msp;
333:
334: uint32 vbr;
335: busaddr sfc; // (R/W も含む)
336: busaddr dfc; // (R/W も含む)
337:
338: uint32 cacr;
339: uint32 caar;
340:
341: // 68030 MMU
342: union64 srp;
343: union64 crp;
344: uint32 tt[2];
345: uint32 tc;
346: uint16 mmusr;
347:
348: // 68040 MMU
349: uint32 itt[2];
350: uint32 dtt[2];
351: uint32 srp40;
352: uint32 urp40;
353: uint16 tc40;
354: uint32 mmusr40;
355:
356: struct fpframe fpframe;
357:
358: // SR レジスタ全体を返す
359: uint16 GetSR() const {
360: return (s ? M68K::SR_S : 0)
361: | (m ? M68K::SR_M : 0)
362: | (intr_mask << 8)
363: | ccr.Get();
364: }
365: // SFC, DFC レジスタの値を返す
366: uint32 GetSFC() const { return sfc.GetFC(); }
367: uint32 GetDFC() const { return dfc.GetFC(); }
368: };
369:
370: // バス状態
371: struct m68kbus
372: {
373: // 論理アドレス。(R/W, FC2-0, Addr すべて使用)
374: busaddr laddr;
375:
376: // 対応する物理アドレス (FC2, Addr のみ使用)
377: busaddr paddr;
378:
379: // アクセスサイズ (バイト数で表す)
380: uint32 size;
381:
382: // データバス。
383: // 今の所書き込みだけで使う。読み込みデータは戻り値のみ。
384: uint32 data;
385:
386: // キャッシュ禁止。/CIIN
387: bool ci;
388:
389: // ATC フォールト (68040 only)
390: bool atcfault;
391:
392: // ATC フォールトが2ページ目で起きたら true (68040 only)
393: bool atcfault2;
394:
395: // Supervisor アクセスなら true を返す
396: bool IsSuper() const { return laddr.IsSuper(); }
397:
398: // バスが Write なら true を返す
399: bool IsWrite() const { return laddr.IsWrite(); }
400: };
401:
402: // 仮
403: #define RegFP(n) (reg.fpframe.fpf_regs[(n) * 3])
404: #define RegFPCR (reg.fpframe.fpf_fpcr)
405: #define RegFPSR (reg.fpframe.fpf_fpsr)
406: #define RegFPIAR (reg.fpframe.fpf_fpiar)
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.