--- nono/vm/ram.cpp	2026/04/29 17:04:53	1.1.1.8
+++ nono/vm/ram.cpp	2026/04/29 17:05:14	1.1.1.12
@@ -4,9 +4,14 @@
 // Licensed under nono-license.txt
 //
 
+//
+// メインメモリ
+//
+
 #include "ram.h"
 #include "aout.h"
 #include "autofd.h"
+#include "config.h"
 #include "elf.h"
 #include "iodevstream.h"
 #include "mainapp.h"
@@ -16,25 +21,22 @@
 #include <sys/mman.h>
 #include <zlib.h>
 
-//
-// メインメモリ
-//
-
-std::unique_ptr<RAMDevice> gRAM;
+// グローバル参照用
+RAMDevice *gRAM;
 
 // RAM はロングワード単位でホストバイトオーダ配置なので、
 // バイトアクセス、ワードアクセス時は HLB(), HLW() マクロを使用のこと。
 std::unique_ptr<uint8[]> mainram;
 
+// コンストラクタ
 RAMDevice::RAMDevice()
+	: inherited("RAM")
 {
-	logname = "ram";
-	devname = "MainRAM";
 	devaddr = 0;
 
 	// アクセスウェイト
 	switch (gMainApp.GetVMType()) {
-	 case VMTYPE_LUNA88K:
+	 case VMType::LUNA88K:
 		// 取扱説明書p.21 に、CMMU からのアクセスタイムが
 		// リード(4byte)で 200ns、バーストリード(16byte)で 320ns
 		// ライト(4byte)で 160ns、バーストライト(16byte)で 280ns とある。
@@ -43,21 +45,23 @@ RAMDevice::RAMDevice()
 		read_wait  = 3;
 		write_wait = 2;
 		break;
-	 case VMTYPE_LUNA1:
+	 case VMType::LUNA1:
 		// LUNA-I は1ウェイト。
 		read_wait  = 1;
 		write_wait = 1;
 		break;
 
-	 case VMTYPE_X68030:
+	 case VMType::X68030:
 	 default:
 		// X68030 ではシステムポートが設定するのでここでは不要。
 		break;
 	}
 }
 
+// デストラクタ
 RAMDevice::~RAMDevice()
 {
+	gRAM = NULL;
 }
 
 bool
@@ -73,16 +77,16 @@ RAMDevice::Init()
 	}
 	// 下限以外の制約は機種による
 	switch (gMainApp.GetVMType()) {
-	 case VMTYPE_X68030:
+	 case VMType::X68030:
 		// メインメモリは 12MB まで。
 		// 内部は 8KB 単位で処理できるが設定が 1MB 単位。
 		if (ram_size_MB > 12) {
-			item.Err();
+			item.Err("configurable maximum main memory size is 12 [MB]");
 			return false;
 		}
 		break;
 
-	 case VMTYPE_LUNA1:
+	 case VMType::LUNA1:
 		// 16MB までは、実機に合わせて 4MB 単位とする。
 		// see http://wiki.netbsd.org/ports/luna68k/luna68k_info/#hardware
 		//
@@ -93,26 +97,26 @@ RAMDevice::Init()
 		// 上限だが、設定ファイルからの指定が 1MB 単位なので 255MB。
 		if (ram_size_MB <= 16) {
 			if (ram_size_MB % 4 != 0) {
-				item.Err();
+				item.Err("for 16MB or less, must be specified in 4 [MB] unit");
 				return false;
 			}
 		} else if (ram_size_MB > 255) {
-			item.Err();
+			item.Err("configurable maximum RAM size is 255 [MB]");
 			return false;
 		}
 		break;
 
-	 case VMTYPE_LUNA88K:
+	 case VMType::LUNA88K:
 		// 64MB までは、実機に合わせて 16MB 単位とする。
 		//
 		// 64MB を超える増設 (or 魔改造) 部分は未確認。
 		if (ram_size_MB <= 64) {
 			if (ram_size_MB % 16 != 0) {
-				item.Err();
+				item.Err("for 64MB or less, must be specified in 16 [MB] unit");
 				return false;
 			}
 		} else if (ram_size_MB > 255) {
-			item.Err();
+			item.Err("configurable maximum RAM size is 255 [MB]");
 			return false;
 		}
 		break;
@@ -129,19 +133,16 @@ RAMDevice::Init()
 	return true;
 }
 
-bool
-RAMDevice::PowerOn()
-{
-	// XXX ノイズを用意する
-
-	return true;
-}
-
+// 電源オン/リセット
 void
-RAMDevice::ResetHard()
+RAMDevice::ResetHard(bool poweron)
 {
+	if (poweron) {
+		// XXX ノイズを用意する
+	}
+
 	// X68030 ではリセットで戻るはず。(LUNA は固定なので関係ない)
-	if (gMainApp.GetVMType() == VMTYPE_X68030) {
+	if (gMainApp.GetVMType() == VMType::X68030) {
 		read_wait  = 0;
 		write_wait = 0;
 	}
@@ -232,30 +233,30 @@ RAMDevice::LoadFile(const char *filepath
 
 	fd = open(filepath, O_RDONLY);
 	if (fd == -1) {
-		warn("LoadFile \"%s\" open failed", filepath);
+		warn("%s \"%s\" open failed", __func__, filepath);
 		return 0;
 	}
 
 	if (fstat(fd, &st) == -1) {
-		warn("LoadFile \"%s\" fstat failed", filepath);
+		warn("%s \"%s\" fstat failed", __func__, filepath);
 		return 0;
 	}
 
 	if (!S_ISREG(st.st_mode)) {
-		warnx("LoadFile \"%s\" not a regular file", filepath);
+		warnx("%s \"%s\" not a regular file", __func__, filepath);
 		return 0;
 	}
 
 	// 今の所マジック判定は最初の4バイトで出来るので
 	if (st.st_size < 4) {
-		warnx("LoadFile \"%s\" file too short", filepath);
+		warnx("%s \"%s\" file too short", __func__, filepath);
 		return 0;
 	}
 	filesize = st.st_size;
 
 	file = (uint8 *)mmap(NULL, filesize, PROT_READ, MAP_PRIVATE, fd, 0);
 	if (file == MAP_FAILED) {
-		warn("LoadFile \"%s\" mmap failed", filepath);
+		warn("%s \"%s\" mmap failed", __func__, filepath);
 		return 0;
 	}
 
@@ -292,7 +293,7 @@ RAMDevice::LoadGzFile(const char *filepa
 	z.opaque = Z_NULL;
 	rv = inflateInit2(&z, 47);
 	if (rv != Z_OK) {
-		warnx("LoadGzFile \"%s\" inflateInit2 failed %d", filepath, rv);
+		warnx("%s \"%s\" inflateInit2 failed %d", __func__, filepath, rv);
 		return 0;
 	}
 
@@ -302,7 +303,7 @@ RAMDevice::LoadGzFile(const char *filepa
 	z.avail_out = decompsize;
 	rv = inflate(&z, Z_NO_FLUSH);
 	if (rv != Z_OK) {
-		warnx("LoadGzFile \"%s\" inflate failed %d", filepath, rv);
+		warnx("%s \"%s\" inflate failed %d", __func__, filepath, rv);
 		return 0;
 	}
 
@@ -326,10 +327,10 @@ RAMDevice::LoadFile(const char *name, co
 	const aout_header *aout = (const aout_header *)file;
 	if (memcmp(ehdr->e_ident, "\177ELF", 4) == 0) {
 		entry = Load_elf32(name, file, filesize);
-	} else if ((be32toh(aout->magic) & 0xffff) == AOUT_OMAGIC) {
+	} else if (AOUT_MAGIC(be32toh(aout->magic)) == AOUT_OMAGIC) {
 		entry = Load_aout(name, file, filesize);
 	} else {
-		warnx("LoadFile \"%s\" unknown executable file format", name);
+		warnx("%s \"%s\" unknown executable file format", __func__, name);
 	}
 
 	return entry;
@@ -344,7 +345,7 @@ RAMDevice::Load_aout(const char *name, c
 	int copylen;
 
 	if (filesize < sizeof(aout)) {
-		warnx("Load_aout \"%s\" file too short", name);
+		warnx("%s \"%s\" file too short", __func__, name);
 		return 0;
 	}
 
@@ -359,33 +360,35 @@ RAMDevice::Load_aout(const char *name, c
 	aout.textrelsize = be32toh(((const aout_header *)file)->textrelsize);
 	aout.datarelsize = be32toh(((const aout_header *)file)->datarelsize);
 
-	// マジックをチェック
-	uint32 target_mid;
-	if (gMainApp.HasVMFeature(VMF_M68K)) {
-		target_mid = AOUT_MID_M68K;
-	} else if (gMainApp.HasVMFeature(VMF_M88K)) {
-		target_mid = AOUT_MID_M88K;
-	} else {
-		PANIC("Unknown CPU?");
-	}
-	uint32 mid = AOUT_MID(aout.magic);
-	if (mid != target_mid) {
-		warnx("Load_aout \"%s\" machine id mismatch (%03x expected but %03x)",
-			name, target_mid, mid);
-		return 0;
+	if (loglevel >= 1) {
+		const char *mstr;
+		switch (AOUT_MAGIC(aout.magic)) {
+		 case AOUT_OMAGIC:	mstr = "OMAGIC";	break;
+		 case AOUT_NMAGIC:	mstr = "NMAGIC";	break;
+		 case AOUT_ZMAGIC:	mstr = "ZMAGIC";	break;
+		 default:
+			mstr = "unsupported magic";
+			break;
+		}
+		putmsgn("%s magic       = %08x (MID=0x%03x, %s)", __func__,
+			aout.magic, AOUT_MID(aout.magic), mstr);
+		putmsgn("%s textsize    = %08x", __func__, aout.textsize);
+		putmsgn("%s datasize    = %08x", __func__, aout.datasize);
+		putmsgn("%s bsssize     = %08x", __func__, aout.bsssize);
+		putmsgn("%s symsize     = %08x", __func__, aout.symsize);
+		putmsgn("%s entry       = %08x", __func__, aout.entry);
+		putmsgn("%s textrelsize = %08x", __func__, aout.textrelsize);
+		putmsgn("%s datarelsize = %08x", __func__, aout.datarelsize);
 	}
 
-	putmsg(1, "%s textsize    = %08x", __func__, aout.textsize);
-	putmsg(1, "%s datasize    = %08x", __func__, aout.datasize);
-	putmsg(1, "%s bsssize     = %08x", __func__, aout.bsssize);
-	putmsg(1, "%s symsize     = %08x", __func__, aout.symsize);
-	putmsg(1, "%s entry       = %08x", __func__, aout.entry);
-	putmsg(1, "%s textrelsize = %08x", __func__, aout.textrelsize);
-	putmsg(1, "%s datarelsize = %08x", __func__, aout.datarelsize);
+	// MID はチェックしない。
+	// CPU アーキテクチャが一致するかくらいはチェックしたいところだが、
+	// MID は CPU ごとではなく OS(?) ごとに異なっているのと、MID の
+	// 一元管理された一次情報が存在しないので、正解リストを作るのが困難。
 
 	// とりあえず再配置は無視
 	if (aout.textrelsize != 0 || aout.datarelsize != 0) {
-		warnx("Load_aout \"%s\" relocation not supported", name);
+		warnx("%s \"%s\" relocation not supported", __func__, name);
 		return 0;
 	}
 
@@ -395,14 +398,15 @@ RAMDevice::Load_aout(const char *name, c
 	copylen = aout.textsize + aout.datasize;
 	if (copylen >= filesize) {
 		copylen = filesize;
-		warnx("warning: Load_aout \"%s\" corrupted? "
+		warnx("warning: %s \"%s\" corrupted? "
 		      "(text=%u + data=%u, filesize=%d); loading %d bytes",
+			__func__,
 			name, aout.textsize, aout.datasize, (int)filesize, copylen);
 		/* FALLTHROUGH */
 	}
 
 	if (aout.entry + copylen > GetSize()) {
-		warnx("Load_aout \"%s\" out of memory in VM", name);
+		warnx("%s \"%s\" out of memory in VM", __func__, name);
 		return 0;
 	}
 
@@ -481,16 +485,25 @@ static std::pair<uint, const char *> pty
 };
 #define GetElfPTypeStr(x)	GetElfStr1(ptype_str, (x))
 
-// ホストの a.out をゲストの RAM に読み込む。
+static std::pair<uint, const char *> shtype_str[] = {
+	{ SHT_NULL,		"SHT_NULL" },
+	{ SHT_PROGBITS,	"SHT_PROGBITS" },
+	{ SHT_RELA,		"SHT_RELA" },
+	{ SHT_NOBITS,	"SHT_NOBITS" },
+	{ SHT_REL,		"SHT_REL" },
+};
+#define GetElfShTypeStr(x)	GetElfStr1(shtype_str, (x))
+
+// ホストの ELF をゲストの RAM に読み込む。
 // 戻り値はエントリポイントアドレス。エラーなら 0 を返す。
 uint32
 RAMDevice::Load_elf32(const char *name, const uint8 *file, size_t filesize)
 {
 	uint16 target_elf_mid;
 
-	if (gMainApp.HasVMFeature(VMF_M68K)) {
+	if (gMainApp.Has(VMCap::M68K)) {
 		target_elf_mid = EM_68K;
-	} else if (gMainApp.HasVMFeature(VMF_M88K)) {
+	} else if (gMainApp.Has(VMCap::M88K)) {
 		target_elf_mid = EM_88K;
 	} else {
 		PANIC("Unknown CPU?");
@@ -499,7 +512,7 @@ RAMDevice::Load_elf32(const char *name,
 	// ヘッダをチェック
 	const Elf32_Ehdr *ehdr = (const Elf32_Ehdr *)file;
 	if (filesize < sizeof(*ehdr)) {
-		warnx("Load_elf32 \"%s\" file too short", name);
+		warnx("%s \"%s\" file too short", __func__, name);
 		return 0;
 	}
 	uint16 e_type    = elf16toh(ehdr->e_type);
@@ -519,20 +532,39 @@ RAMDevice::Load_elf32(const char *name,
 	}
 
 	if (ehdr->e_ident[EI_CLASS] != ELFCLASS32) {
-		warnx("Load_elf32 \"%s\" not ELF32 format", name);
-		return 0;
-	}
-	if (e_type != ET_EXEC) {
-		warnx("Load_elf32 \"%s\" not executable file", name);
+		warnx("%s \"%s\" not ELF32 format", __func__, name);
 		return 0;
 	}
 	if (e_machine != target_elf_mid) {
-		warnx("Load_elf32 \"%s\" machine type mismatch "
-			"($%02x expected but $%02x)",
+		warnx("%s \"%s\" machine type mismatch "
+			"($%02x expected but $%02x)", __func__,
 			name, target_elf_mid, e_machine);
 		return 0;
 	}
 
+	switch (e_type) {
+	 case ET_EXEC:
+		if (Load_elf32_exec(name, file, filesize)) {
+			return e_entry;
+		}
+		break;
+	 case ET_REL:
+		return Load_elf32_rel(name, file, filesize);
+	 default:
+		warnx("%s \"%s\" unsupported file type", __func__, name);
+		break;
+	}
+	return 0;
+}
+
+// ホストの ELF 実行形式ファイルをゲストの RAM に読み込む。
+// 読み込めたら true、エラーなら false を返す。
+// エントリポイントは呼び出し元が知っているのでこっちでは関与しない。
+bool
+RAMDevice::Load_elf32_exec(const char *name, const uint8 *file, size_t filesize)
+{
+	const Elf32_Ehdr *ehdr = (const Elf32_Ehdr *)file;
+
 	// プログラムヘッダに読み込むべき領域が示されている
 	// phoff がプログラムヘッダのファイル先頭からのオフセット
 	// phentsize がプログラムヘッダ1つの大きさ
@@ -546,9 +578,9 @@ RAMDevice::Load_elf32(const char *name,
 		putlogn("e_phnum     = %d",    e_phnum);
 	}
 	if (e_phentsize != sizeof(Elf32_Phdr)) {
-		warnx("Load_elf32 \"%s\" unknown program header size 0x%x",
+		warnx("%s \"%s\" unknown program header size 0x%x", __func__,
 			name, e_phentsize);
-		return 0;
+		return false;
 	}
 
 	IODeviceStream ds(this);
@@ -573,8 +605,8 @@ RAMDevice::Load_elf32(const char *name,
 
 		if (p_type == PT_LOAD) {
 			if (p_vaddr + p_memsz > GetSize()) {
-				warn("Load_elf32 \"%s\" out of memory in VM", name);
-				return 0;
+				warnx("%s \"%s\" out of memory in VM", __func__, name);
+				return false;
 			}
 
 			ds.SetAddr(p_vaddr);
@@ -594,11 +626,71 @@ RAMDevice::Load_elf32(const char *name,
 			continue;
 
 		} else {
-			warnx("Load_elf32 \"%s\" p_type 0x%x(%s) not supported",
+			warnx("%s \"%s\" p_type 0x%x(%s) not supported", __func__,
 				name, p_type, GetElfPTypeStr(p_type));
+			return false;
+		}
+	}
+
+	return true;
+}
+
+// ホストの ELF オブジェクトの text セクションをゲストの RAM に読み込む。
+// .o(オブジェクトファイル) 用。
+// 読み込めたら true、エラーなら false を返す。
+// 戻り値はエントリポイントアドレス。エラーなら 0 を返す。
+uint32
+RAMDevice::Load_elf32_rel(const char *name, const uint8 *file, size_t filesize)
+{
+	const Elf32_Ehdr *ehdr = (const Elf32_Ehdr *)file;
+	uint32 entry = 0x20000;
+
+	uint32 e_shoff     = elf32toh(ehdr->e_shoff);
+	uint16 e_shentsize = elf16toh(ehdr->e_shentsize);
+	uint16 e_shnum     = elf16toh(ehdr->e_shnum);
+	if (loglevel >= 1) {
+		putlogn("e_shoff     = $%08x", e_shoff);
+		putlogn("e_shentsize = $%04x", e_shentsize);
+		putlogn("e_shnum     = %d",    e_shnum);
+	}
+	if (e_shentsize != sizeof(Elf32_Shdr)) {
+		warnx("%s \"%s\" unknown section header size 0x%x", __func__,
+			name, e_shentsize);
+		return 0;
+	}
+
+	IODeviceStream ds(this);
+	ds.SetAddr(entry);
+
+	for (int j = 0; j < e_shnum; j++) {
+		const Elf32_Shdr *shdr = &((const Elf32_Shdr*)(file + e_shoff))[j];
+		// sh_type
+		uint32 sh_type   = elf32toh(shdr->sh_type);		// タイプ
+		uint32 sh_addr   = elf32toh(shdr->sh_addr);		// アドレス
+		uint32 sh_offset = elf32toh(shdr->sh_offset);	// ファイル先頭から
+		uint32 sh_size   = elf32toh(shdr->sh_size);		// サイズ
+		if (loglevel >= 1) {
+			putlogn("[%d] sh_type   = $%08x (%s)", j,
+				sh_type, GetElfShTypeStr(sh_type));
+			putlogn("    sh_addr   = $%08x", sh_addr);
+			putlogn("    sh_offset = $%08x", sh_offset);
+			putlogn("    sh_size   = $%08x", sh_size);
+		}
+
+		if (sh_type == SHT_PROGBITS) {
+			const uint8 *src = file + sh_offset;
+			int i = 0;
+			for (; i < sh_size; i++) {
+				ds.Write8(*src++);
+			}
+		} else if (sh_type == SHT_RELA || sh_type == SHT_REL) {
+			// 再配置情報があるのは .R 形式ではない
+			warnx("%s \"%s\" has relocation section", __func__, name);
 			return 0;
+		} else {
+			// ?
 		}
 	}
 
-	return e_entry;
+	return entry;
 }