--- nono/m88xx0/m88100core.cpp	2026/04/29 17:04:31	1.1.1.1
+++ nono/m88xx0/m88100core.cpp	2026/04/29 17:05:05	1.1.1.10
@@ -1,6 +1,7 @@
 //
 // nono
-// Copyright (C) 2020 isaki@NetBSD.org
+// Copyright (C) 2020 nono project
+// Licensed under nono-license.txt
 //
 
 #include "m88100.h"
@@ -8,46 +9,107 @@
 #include "debugger.h"
 #include "cvprompt.h"
 #include "mpu.h"
+#include "scheduler.h"
 
 #define OP_DEF(name)	void __CONCAT(m88kcpu::op_,name)()
 #define OP_FUNC(name)	__CONCAT(op_,name)()
 #include "m88100ops.cpp"
 
+// 文字列を作る前にレベルを評価するためマクロ
+#define cpulog(lv, fmt...)	do {	\
+	if (__predict_false(gMPU->loglevel >= (lv))) {	\
+		gMPU->putlogn(fmt);	\
+	}	\
+} while (0)
+
+void
+m88kcpu::PowerOn()
+{
+	// 履歴は電源オン時だけ初期化。
+	// (LUNA88K は ROM が正常パスで CPU リセットを行ったりするので)
+	exhist.Clear();
+	brhist.Clear();
+
+	// この後起きるリセット例外で xip を初期化する前に参照することになるので
+	// これだけここでも初期化しておく。
+	xip = 0;
+}
+
 // リセット例外のようなもの?
 void
-m88kcpu::Reset(uint32 reset_vector)
+m88kcpu::Reset()
 {
-	// TODO: 未完成
+	// 例外履歴に記録 (例外発生はブランチ履歴にも記録)
+	// リセット例外も発生時の XIP を記録する。(LUNA88K の ROM 1.20)
+	exhist.AddEntry(xip | 1, 0, 0xfc000000 | 0);
+	brhist.AddEntry(xip | 1, 0, 0xfc000000 | 0);
+	// デバッガに通知 (例外ブレーク用)
+	debugger_notify_exception(0);
+
+	// 内部の割り込み状態をクリア
+	intr_pending = 0;
+	atomic_reqflag &= ~(CPU_REQ_RESET | CPU_REQ_INTR | CPU_REQ_STOP);
+
+	// Table 6-8 (p6-47)
 	psr = 0x800003ff;
-	// SFD1 = 0;
+	// XXX ただし SFU1 は未実装なので下げておく
 	psr &= ~PSR_SFD1;
 
-#if TEST_INTERRUPT
-psr &= ~PSR_IND;
-psr &= ~PSR_SFRZ;
+#if defined(TEST_INTERRUPT)
+	psr &= ~PSR_IND;
+	psr &= ~PSR_SFRZ;
 #endif
 
-	vbr = 0;
+	SetPSR();
 
-	// 実際には m88k MPU はリセット直後は 0 番地から実行を開始するので、
-	// 大抵の場合システムでリセット直後は 0 番地付近に ROM を見せるように
-	// してあるのだと思うが、ここではその代わりに ROM のアドレスを指定して、
-	// 直接そこから実行を開始することにする。
-	fip = reset_vector;
+	fip = 0;
+
+	// レジスタのうち明記されてるものをクリア。
+	// 不定と明記されてるものはリセットでは触らないでおく。
+	// scoreboard: cleared
 	nip = 0;
 	xip = 0;
+	vbr = 0;
+	fpecr = 0;
+	fpcr = 0;
+	fpsr = 0;
+	// DMTx は bit0(Valid) をクリア。他は不定
+	dmt0 &= ~DM_VALID;
+	dmt1 &= ~DM_VALID;
+	dmt2 &= ~DM_VALID;
+
+	cmmu[0].Reset();
+	cmmu[1].Reset();
 
 	fetch();
 }
 
-// request サイクル分実行する。
+// 仮想時間 delta [nsec] だけ CPU を実行する。実際には大抵行き過ぎる。
+// 戻り値は CPU 状態 (Scheduler::SCHED_CPU_*)。
 uint32
-m88kcpu::Run(uint64 request)
+m88kcpu::Run(uint32 delta)
 {
-	uint64 goal_cycle = total_cycle + request;
 	bool is_release = false;
 	bool is_intr = false;
 
+	assert(used_cycle == 0);
+
+	goal_cycle = Vtime2Cycle(delta);
+	if (__predict_false(goal_cycle == 0)) {
+		goal_cycle = 1;
+	}
+
+	if ((atomic_reqflag & CPU_REQ_STOP)) {
+		if ((atomic_reqflag & (CPU_REQ_INTR | CPU_REQ_PROMPT | CPU_REQ_RESET))) {
+			// 割り込み、デバッガ、リセットが来たら STOP 解除。
+			atomic_reqflag &= ~CPU_REQ_STOP;
+		} else {
+			// STOP 継続として戻る。
+			used_cycle = goal_cycle;
+			goto exit;
+		}
+	}
+
 	while (!is_release) {
 		// shift pipeline
 		opX = opF;
@@ -61,13 +123,24 @@ m88kcpu::Run(uint64 request)
 		if (atomic_reqflag != 0) {
 			// 何かが起きた
 
+			if ((atomic_reqflag & CPU_REQ_RESET)) {
+				// リセット例外。
+				Reset();
+				// XIP がリセットベクタを指すためにはもう一回フェッチが必要
+				// なので、ここは continue が必要。
+				continue;
+			}
+
 			// 割り込みの認識
 			// 割り込みの実行は命令実行完了後、次のプリフェッチの前
 			if ((atomic_reqflag & CPU_REQ_INTR)) {
 				atomic_reqflag &= ~CPU_REQ_INTR;
-				is_intr = true;
-#if TEST_INTERRUPT
-					atomic_reqflag |= CPU_REQ_PROMPT;
+				if (intr_pending && IsIntrEnable()) {
+					// この命令のあとに割り込み処理
+					is_intr = true;
+				}
+#if defined(TEST_INTERRUPT)
+				atomic_reqflag |= CPU_REQ_PROMPT;
 #endif
 			}
 
@@ -90,6 +163,11 @@ m88kcpu::Run(uint64 request)
 
 				// プロンプトを抜けたのでここでフラグを落とす
 				atomic_reqflag &= ~CPU_REQ_PROMPT;
+
+				// プロンプトから戻ってきたら一旦スケジューラまで戻る(?)。
+				// reset コマンドのようにデバッガからスケジューラに出した
+				// リクエストを(なるはやで?)回収するため。
+				atomic_reqflag |= CPU_REQ_RELEASE;
 			}
 
 			if ((atomic_reqflag & CPU_REQ_RELEASE)) {
@@ -111,26 +189,51 @@ m88kcpu::Run(uint64 request)
 		switch (op12) {
 #include "m88100switch.inc"
 		 default:
-			__unreachable();
+			OP_FUNC(illegal);
+			break;
 		}
 
-		if (is_intr) {
+		if (is_intr && IsIntrEnable()) {
+			// 割り込み処理要求が来ていて、
+			// 直前の命令が割り込みを禁止していなければ割り込み
+			// XXX 実際は違う気がする
 			is_intr = false;
-			if (!(psr & PSR_IND)) {
-				gMPU->putlog(4, "INTR take");
-				ExceptionCore(M88K_EXCEP_INTERRUPT, ExceptionKind::INTR);
-				continue;
-			} else {
-				gMPU->putlog(4, "INTR DISABLE");
+			cpulog(4, "INTR take");
+			ExceptionCore(M88K_EXCEP_INTERRUPT, ExceptionKind::INTR);
+			continue;
+		}
+
+		used_cycle++;
+
+		if ((atomic_reqflag & CPU_REQ_STOP)) {
+			// STOP 状態は、残りサイクルを消費したことにして戻る
+			cpulog(2, "STOP 状態検出");
+			if (used_cycle < goal_cycle) {
+				used_cycle = goal_cycle;
 			}
 		}
 
-		total_cycle++;
-		if (total_cycle >= goal_cycle)
+		// XXX 命令の実行でリリースするのに、いったんループを回って
+		// からではタイミングが遅すぎる
+		if ((atomic_reqflag & CPU_REQ_RELEASE)) {
+			// 中断リクエスト受信
+			// この命令を実行し終わったら抜ける
+			atomic_reqflag &= ~CPU_REQ_RELEASE;
+			is_release = true;
+		}
+
+		if (used_cycle >= goal_cycle)
 			break;
 	}
 
-	return atomic_reqflag;
+ exit:
+	total_vtime += Cycle2Vtime(used_cycle);
+	used_cycle = 0;
+
+	// HALT 状態がないので NORMAL か STOP かだけでいい
+	return (atomic_reqflag & CPU_REQ_STOP)
+		? Scheduler::SCHED_CPU_STOP
+		: Scheduler::SCHED_CPU_NORMAL;
 }
 
 // この命令後に実行を中断して VM に戻る
@@ -140,8 +243,15 @@ m88kcpu::Release()
 	atomic_reqflag |= CPU_REQ_RELEASE;
 }
 
+// リセット例外を発行する
+void
+m88kcpu::RequestReset()
+{
+	atomic_reqflag |= CPU_REQ_RESET;
+}
+
 // 通常の例外。
-// エラー、割り込み、TRAP からは使いません。
+// DataAccessException, エラー、割り込み、TRAP からは使わない。
 // vec はベクタ番号。
 void
 m88kcpu::Exception(int vec)
@@ -154,23 +264,52 @@ m88kcpu::Exception(int vec)
 void
 m88kcpu::ExceptionCore(int vec, ExceptionKind cause)
 {
+	uint syscall = 0;
+
+	// 例外履歴に記録 (例外発生はブランチ履歴にも記録)
+	// OpenBSD システムコールなら番号もついでに記録。
+	// システムコール番号は tb0 発行時点で r13 にセットされている。
+	// ただし 0 番は syscall(2) (間接システムコール) で、実際の番号は r2。
+	// 198番 __syscall(2) だと r2:r3 (なので実質 r3)。
+	if (vec == 450) {
+		syscall = r[13];
+		if (syscall == 0) {
+			syscall = r[2];
+		} else if (syscall == 198) {
+			syscall = r[3];
+		}
+		syscall &= 0xfff;
+	}
+	uint32 from = xip | (IsSuper() ? 1 : 0);
+	uint32 inst = 0xfc000000 | (syscall << 12) | vec;
+	exhist.AddEntry(from, 0, inst);
+	brhist.AddEntry(from, 0, inst);
+	// デバッガに通知 (例外ブレーク用)
+	debugger_notify_exception(vec);
+
+	// 命令中で起きる例外はとりあえず全部2クロック追加? (Table.7-5)
+	if (cause != ExceptionKind::INTR) {
+		AddCycle(2);
+	}
+
 	if (psr & PSR_SFRZ) {
 		if (cause != ExceptionKind::TRAP) {
-			gMPU->putlog(2, "SFRZ Error Exception");
+			cpulog(2, "SFRZ Error Exception");
 			vec = M88K_EXCEP_ERROR;
 			cause = ExceptionKind::ERROR;
 		}
 	} else {
-		gMPU->putlog(2, "Exception %x", vec);
+		cpulog(2, "Exception %x", vec);
+		if (vec != 1) {
+			cpulog(1, "Exception %x x=%x n=%x f=%x", vec, xip, nip, fip);
+		}
 		sxip = xip;
 		snip = nip;
-		sfip = fip; 
+		sfip = fip;
 
 		sxip |= SIP_V;
 		snip |= SIP_V;
-		// XXX:実機と異なり、fip は常にフェッチ前なので V=0
-		// ^^^^ コレ自体怪しい. INTERRUPT とか。
-		// でもたぶん例外ハンドラでここのビット見ないだろうなあ
+		sfip |= SIP_V;
 
 		if (OpIsBusErr(opX)) {
 			sxip |= SIP_E;	// E bit
@@ -184,11 +323,57 @@ m88kcpu::ExceptionCore(int vec, Exceptio
 		}
 	}
 
+	if (cause != ExceptionKind::DATA) {
+		// データアクセス例外以外は、
+		// データパイプラインはフラッシュ状態とする。
+		// ほんとうは違う。かも。
+		dmt0 = 0;
+	} else {
+		// xip: ld/st/xmem
+		// nip: next
+		// fip: fetch
+
+		// rom1.2 は DAE が起きると、
+
+		// ROM挙動               CPU の RTE 挙動
+		// sfip = sxip
+		// sxip -> ~V (INVALID)  CPU はそもそも sxip を評価しない
+		// snip = 0 (INVALID)    CPU はこれを nop 相当に処理する
+		// rte
+
+		// してくる。そのまま読むと命令を再実行しようとしているように
+		// 読めるが、再実行すると無限ループになってしまう。
+		// DAE の時点で xip が進んでいることを期待して利用している?
+
+		// openbsd は
+		// xmem の write バスエラーを検知すると命令を再実行するために
+		// fip = nip, nip = xip して rte する。ということは xip = xmem に
+		// なっていることを期待している。
+
+		// というわけで
+		// ld で DataAccessException のときは、実CPUはすでに次の命令を
+		// 実行している?
+		// もう少し考えると、スコアボードでレジスタの干渉がなければ、
+		// 実行している?
+
+		// 仕方がないのでハックでごまかす。
+		// rte のほうも参照のこと。
+
+		if (IsSuper() && xip >= 0x41000000 && xip < 0x42000000) {
+			// 遅延例外機構がないので、ROM 合わせのハック。
+			sxip = snip;
+		}
+	}
+
 	epsr = psr;
-	psr |= PSR_SUPER | PSR_SFD1 | PSR_IND | PSR_SFRZ;
+	SetPSR(psr | PSR_SUPER | PSR_SFD1 | PSR_IND | PSR_SFRZ);
 
 	fip = vbr + (vec << 3);
 	fetch();
+	// ここでベクタに飛ぶのだが、ベクタ内の2命令でおそらく必ずもう一度
+	// 分岐してそっちでも履歴が残るので、ここでブランチ履歴を残すのは
+	// ちょっと冗長という気もする。
+
 	if (OpIsBusErr(opF)) {
 		if (cause == ExceptionKind::ERROR) {
 			// double bus fault
@@ -200,62 +385,344 @@ m88kcpu::ExceptionCore(int vec, Exceptio
 	}
 }
 
+inline uint32
+m88kcpu::Calcdmt(uint32 flag)
+{
+	return
+		   ((psr & PSR_BO_LE) ? DM_BO : 0)
+	     | ((IsSuper() && !(flag & DM_USR)) ? DM_DAS : 0)
+	     | DM_VALID;
+}
+
 // データアクセス例外(Read)
+// ld.b, ld.h, ld.hu, ld 用
 void
-m88kcpu::ReadDataException(uint32 addr, uint32 flag)
+m88kcpu::ReadDataException32(uint32 addr, uint32 flag)
 {
 	// ミスアラインドはこの例外より前にチェックされていて、
 	// ここにはアラインドしかこない。
 	dma0 = addr & ~0x3;
-	dmt0 = ((psr & PSR_BO_LE) ? DM_BO : 0)
-	     | (((psr & PSR_SUPER) && !(flag & DM_USR)) ? DM_DAS : 0)
-	     | (flag & DM_DOUB1)	// ダブルワードの第1アクセスのときセット
-	     | (flag & DM_LOCK)		// xmem でセット
+	dmt0 = Calcdmt(flag)
 	     | (FLD_D << 7)
 	     | (flag & DM_SIGNED)
 	     | ((flag & DM_EN_MASK) >> (addr & 0x03))
-	     | 0 // DM_WRITE = 0
-	     | DM_VALID;
-	Exception(M88K_EXCEP_DATA);
+	;
+	dmt1 &= ~DM_VALID;
+	dmt2 &= ~DM_VALID;
+	cpulog(1, "ReadDAE xip=%x addr=%x", xip, addr);
+	ExceptionCore(M88K_EXCEP_DATA, ExceptionKind::DATA);
+}
+
+// データアクセス例外(Read)
+// ld.d 用
+void
+m88kcpu::ReadDataException64(uint32 addr, uint32 flag)
+{
+	// ミスアラインドはこの例外より前にチェックされていて、
+	// ここにはアラインドしかこない。
+	dma0 = addr;
+	dmt0 = Calcdmt(flag)
+	     | DM_DOUB1			// ダブルワードの第1アクセスのときセット
+	     | (FLD_D << 7)
+	     | DM_EN_MASK		// 32ビット有効
+	;
+
+	dma1 = dma0 + 4;
+	dmt1 = Calcdmt(flag)
+	     | (FLD_D2 << 7)
+	     | DM_EN_MASK			// 32ビット有効
+	;
+
+	dmt2 &= ~DM_VALID;
+
+	if ((flag & DM_DOUB1) == 0) {
+		// .d の2ワード目がバスエラー。第1ワードのアクセスは成功した。
+		dmt0 &= ~DM_VALID;
+	}
+
+	cpulog(1, "ReadDAE64 xip=%x addr=%x", xip, addr);
+	ExceptionCore(M88K_EXCEP_DATA, ExceptionKind::DATA);
+}
+
+// データアクセス例外(Write)
+// st.b, st.h, st.hu, st 用
+void
+m88kcpu::WriteDataException32(uint32 addr, uint32 flag)
+{
+	// ミスアラインドはこの例外より前にチェックされていて、
+	// ここにはアラインドしかこない。
+	dma0 = addr & ~0x3;
+	dmt0 = Calcdmt(flag)
+	     | (FLD_D << 7)
+	     | ((flag & DM_EN_MASK) >> (addr & 0x03))
+	     | DM_WRITE
+	;
+	dmd0 = rD;
+
+	dmt1 &= ~DM_VALID;
+	dmt2 &= ~DM_VALID;
+	cpulog(1, "WriteDAE xip=%x addr=%x", xip, addr);
+	ExceptionCore(M88K_EXCEP_DATA, ExceptionKind::DATA);
 }
 
 // データアクセス例外(Write)
+// st.d 用
 void
-m88kcpu::WriteDataException(uint32 addr, uint32 data, uint32 flag)
+m88kcpu::WriteDataException64(uint32 addr, uint32 flag)
 {
 	// ミスアラインドはこの例外より前にチェックされていて、
 	// ここにはアラインドしかこない。
 	dma0 = addr & ~0x3;
-	dmt0 = ((psr & PSR_BO_LE) ? DM_BO : 0)
-	     | (((psr & PSR_SUPER) && !(flag & DM_USR)) ? DM_DAS : 0)
-	     | (flag & DM_DOUB1)	// ダブルワードの第1アクセスのときセット
-	     | (flag & DM_LOCK)		// xmem でセット
+	dmt0 = Calcdmt(flag)
+	     | DM_DOUB1		// ダブルワードの第1アクセスのときセット
+	     | (FLD_D << 7)
+	     | DM_EN_MASK
+	     | DM_WRITE
+	;
+	dmd0 = rD;
+
+	dma1 = dma0 + 4;
+	dmt1 = Calcdmt(flag)
+	     | (FLD_D2 << 7)
+	     | DM_EN_MASK
+	     | DM_WRITE
+	;
+	dmd1 = rD2;
+
+	dmt2 &= ~DM_VALID;
+
+	if ((flag & DM_DOUB1) == 0) {
+		// .d の2ワード目がバスエラー。第1ワードのアクセスは成功した。
+		dmt0 &= ~DM_VALID;
+	}
+
+	cpulog(1, "WriteDAE64 xip=%x addr=%x", xip, addr);
+	ExceptionCore(M88K_EXCEP_DATA, ExceptionKind::DATA);
+}
+
+// データアクセス例外(xmem)
+// xmem には .d は無い
+void
+m88kcpu::XmemDataException(uint32 addr, uint32 flag)
+{
+	dma0 = addr & ~0x3;
+	dmt0 = Calcdmt(flag)
+	     | DM_LOCK		// xmem でセット
+	     | (FLD_D << 7)
+	     | (flag & DM_SIGNED)
+	     | ((flag & DM_EN_MASK) >> (addr & 0x03))
+	;
+
+	dma1 = dma0;
+	dmt1 = Calcdmt(flag)
+	     | DM_LOCK		// xmem でセット
 	     | (FLD_D << 7)
 	     | (flag & DM_SIGNED)
 	     | ((flag & DM_EN_MASK) >> (addr & 0x03))
 	     | DM_WRITE
-	     | DM_VALID;
+	;
+	dmd1 = rD;
+
+	dmt2 &= ~DM_VALID;
 
-	// dmd は Byte Enable 位置に配置される
-	if (flag & DM_SIZE_B) {
-		dmd0 = data << ((3 - (addr & 0x03)) * 8);
-	} else if (flag & DM_SIZE_H) {
-		dmd0 = data << ((2 - (addr & 0x03)) * 16);
+	// ミスアラインドはこの例外より前にチェックされていて、
+	// ここにはアラインドしかこない。
+	if (cmmu[1].fault_code != m88200::FAULT_CODE_BUSERR
+	 || cmmu[1].acc_read) {
+		// アドレス変換フォルトまたは read 時点
+		// nop
 	} else {
-		dmd0 = data;
+		// xmem の write 時点
+		dmt0 &= ~DM_VALID;
 	}
-	Exception(M88K_EXCEP_DATA);
+
+	cpulog(1, "xmemDAE xip=%x addr=%x", xip, addr);
+	ExceptionCore(M88K_EXCEP_DATA, ExceptionKind::DATA);
 }
 
+// FPxS レジスタをセット
 void
-m88kcpu::Interrupt()
+m88kcpu::SetFPxS(uint32& h, uint32& l, double src, uint32 ts)
 {
+	// FPHS[12]、FPLS[12] は以下の構造
+	//
+	//    3                   2                   1                   0
+	//  1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+	// +-+---------------------+---------------------------------------+
+	// |S|   Exponent(11bit)   |     High Order 20 bits of Mantissa    | FPHSn
+	// +-+---------------------+---------------------------------------+
+	//
+	// +---------------------------------------------------------------+
+	// |           Low Order bits of Mantissa, or Integer              | FPLSn
+	// +---------------------------------------------------------------+
+	//
+	// ts が 1 (double) の場合は IEEE754 double と同じ。
+	// ts が 0 (single) の場合は float を double にキャスト (拡大変換) した
+	// ものではないことに注意。
+	// S(符号ビット)はそのまま。float の Mantissa (23bit) のうち上位 20bit
+	// を FPHSn に、残り 3bit を FPLSn の上位 3bit に。ここまではいい。
+	// Exponent は float の指数部(8bit、バイアス=127) の値を *そのまま*
+	// 符号拡張(?)する。
+	// (float)1.0 は 1.0 * 2^0 なのでバイアス込みの指数部は 127、
+	// (float)2.0 は 1.0 * 2^1 なのでバイアス込みの指数部は 128。
+	// バイアス込みにした値は符号なし数のはずだが、ここではこれを 11bit に
+	// 符号拡張して FPHSn の Exponent 部に格納するようだ。取り出す際に下位
+	// 8bit しか取り出さなければ害はないし、符号拡張する方がハードウェア的に
+	// 都合がよかったとかだろうか。
+	// 仮に普通に double に変換すると double の指数部バイアスは 1023 なので
+	// バイアス込みの指数部は先程の例だとそれぞれ 1023、1024 になるが
+	// これではないということ。
+
+	union64 u;
+	u.q = d2u(src);
+	if (ts == 0) {
+		// single
+
+		uint32 exp;
+		// src は普通の double なのでこの指数部を取り出す
+		uint32 double_biased = (u.h >> 20) & 0x7ff;
+		if (double_biased == 0x7ff) {
+			// Inf, NAN
+			exp = 0x7ff00000;
+		} else {
+			// double のバイアスを外して float のバイアスを足す
+			int float_biased = (double_biased - 1023) + 127;
+			// この 8bit 値を 11bit に符号拡張して所定の位置へ
+			exp = ((int32)(float_biased << 24)) >> 4;
+			exp &= 0x7ff00000;
+		}
+
+		h = (u.h & 0x800fffff) | exp;
+		l = u.l;
+	} else {
+		// double
+		h = u.h;
+		l = u.l;
+	}
+}
+
+// FPR[HL] レジスタに double 値をセット
+// - それ以外のフィールドは保存する XXX ここでクリアしてもいいか?
+// - XXX Guard, Round, Sticky (, AddOne) はまだない
+void
+m88kcpu::SetFPRx(double src)
+{
+	union64 u;
+	uint32 exp;
+
+	u.q = d2u(src);
+
+	// Sign は FPRH
+	fprh &= ~(FPRH_SIGN | FPRH_MANT);	// Mantissa もついでにクリア
+	fprh |= u.h & 0x80000000;
+
+	// Exp  は FPIT。
+	// double は 11bit だが FPIT::RESEXP は 12bit なので 1bit 符号拡張する。
+	// 符号付き数(正確には負数)の右シフトは実装依存だが gcc, clang は
+	// 算術右シフトになる。
+	//
+	//           3                   2
+	//         1 0 9 8 7 6 5 4 3 2 1 0 9
+	//        +-+---------------------+-
+	// double |S|   Exponent(11bit)   |
+	//        +-+---------------------+-
+	//
+	//        +---------------------+-+-
+	// u.h<<1 |  Exponent(11bit)    |X|
+	//        +---------------------+-+-
+	//
+	//        +-----------------------+-
+	// exp>>1 |   Exponent(12bit)     |
+	//        +-----------------------+-
+	exp = u.h << 1;
+	exp = (int32)exp >> 1;
+	fpit &= ~FPIT_RESEXP;
+	fpit |= exp & FPIT_RESEXP;
+
+	// Mantissa は FPRH, FPRL
+	// 上位側(FPRH)には最上位(実数桁)の隠しビットを含む。
+	fprh |= (u.h & 0x000fffff);
+	fprh |= FPRH_1;
+	fprl = u.l;
+}
+
+// FP Precise 例外。浮動小数点数1つの場合。
+void
+m88kcpu::FPPreciseException(uint32 cause, double s2)
+{
+	SetFPS2(s2, m88100opf_FP_T2(opX));
+	FPPreciseException(cause);
+}
+
+// FP Precise 例外。浮動小数点数2つの場合。
+void
+m88kcpu::FPPreciseException(uint32 cause, double s1, double s2)
+{
+	SetFPS1(s1, m88100opf_FP_T1(opX));
+	SetFPS2(s2, m88100opf_FP_T2(opX));
+	FPPreciseException(cause);
+}
+
+// FP Precise 例外。
+void
+m88kcpu::FPPreciseException(uint32 cause)
+{
+	assert(cause == FPECR_FIOV   ||
+	       cause == FPECR_FUNIMP ||
+	       cause == FPECR_FPRV   ||
+	       cause == FPECR_FROP   ||
+	       cause == FPECR_FDVZ);
+
+	fpecr = cause;
+
+	// FPPT(FP Precise operation Type Register)
+	fppt = opX & 0xffe0;		// Opcode, T1, T2, TD は opX と同じ位置
+	fppt |= m88100opf_D(opX);	// DEST
+
+	Exception(M88K_EXCEP_SFU1_PRECISE);
+}
+
+// FP Imprecise 例外。
+void
+m88kcpu::FPImpreciseException(uint32 cause)
+{
+	assert(cause == FPECR_FUNF ||
+	       cause == FPECR_FOVF ||
+	       cause == FPECR_FINX);
+
+	fpecr = cause;
+
+	// FPIT(FP Imprecise operation Type Register)
+	fpit &= FPIT_RESEXP;
+	fpit |= opX & FPIT_OPCODE;
+	fpit |= (opX & 0x00000020) << 5;	// DESTSIZ
+	fpit |= (fpcr & 0x0000001f) << 5;	// EFINV,EFDVZ,EFUNF,EFOVR,EFINX
+	fpit |= m88100opf_D(opX);			// DEST
+
+	// FPRH(FP Result High Register)
+	fprh &= ~FPRH_RNDMODE;
+	fprh |= (fpcr & FPCR_RM) << 14;
+
+	Exception(M88K_EXCEP_SFU1_IMPRECISE);
+}
+
+void
+m88kcpu::Interrupt(int level)
+{
+	// level は 0 か 1。
+	intr_pending = level;
 	atomic_reqflag |= CPU_REQ_INTR;
-	gMPU->putlog(4, "INTERRUPT ACK (アドレスは不正確)");
 }
 
 void
 m88kcpu::fpu_unimpl()
 {
 	printf("%s\n", __func__);
+	FPPreciseException(FPECR_FUNIMP);
+}
+
+OP_DEF(illegal)
+{
+	// 本来は不当命令例外?
+	cpulog(0, "Illegal instruction %08x", (uint32)opX);
 }