romdevtools 0.44.0 → 0.70.0

package/src/toolchains/mips-c/mips-c.js

@@ -0,0 +1,155 @@
+// mips-c — minimal C → MIPS binary builder for PS1 (and N64), the bare
+// gcc+newlib+libgcc path (no SDK yet). Mirrors genesis-c.js's buildMinimal.
+//
+//   buildMipsC({ source, sources, headers, platform }) →
+//     PS1: a runnable PS-EXE ('PS-X EXE' header + .text at 0x80010000)
+//     N64: a flat .bin (boot glue is libdragon's job — minimal path for now)
+//
+// Pipeline per source: cc1 → as → (link all with crt0 + libc/libm/libgcc) →
+// objcopy → wrap. Endianness from the platform (PS1 little / N64 big).
+
+import { fileURLToPath } from "node:url";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+import { runCc1mips, runMipsAs, runMipsLd, runMipsObjcopy } from "../mips-elf-gcc/gcc.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const LIB = path.join(__dirname, "lib");
+
+/** Wrap a raw .text image in a PS-EXE header (2048 bytes). The PS1 BIOS loads
+ *  `t_size` bytes from the file (after the header) to `t_addr` and jumps to pc0. */
+function wrapPsExe(text, loadAddr = 0x80010000, spBase = 0x801ffff0) {
+  const hdr = new Uint8Array(2048);
+  hdr.set(new TextEncoder().encode("PS-X EXE"), 0);
+  const put = (o, v) => { hdr[o] = v & 0xff; hdr[o + 1] = (v >> 8) & 0xff; hdr[o + 2] = (v >> 16) & 0xff; hdr[o + 3] = (v >>> 24) & 0xff; };
+  put(0x10, loadAddr);                       // pc0 (entry)
+  put(0x18, loadAddr);                       // t_addr (load address)
+  put(0x1c, (text.length + 3) & ~3);         // t_size
+  put(0x30, spBase);                         // s_addr (stack base)
+  const out = new Uint8Array(2048 + text.length);
+  out.set(hdr, 0); out.set(text, 2048);
+  return out;
+}
+
+// Minimal clean-room N64 IPL3 (assembled from lib/n64-ipl3.s): runs in SP DMEM at
+// 0xA4000040 after the (HLE or real) PIF boot copies ROM[0x40..0xFFF] there. It
+// PI-DMAs 1 MB from cart 0xB0001000 → RDRAM 0x80000400 and jumps to the game entry.
+const N64_IPL3 = [
+  0x3c08a460, 0x24090400, 0xad090000, 0x3c091000, 0x35291000, 0xad090004,
+  0x3c09000f, 0x3529ffff, 0xad09000c, 0x8d0a0010, 0x314a0003, 0x1540fffd,
+  0x00000000, 0x3c0b8000, 0x356b0400, 0x01600008, 0x00000000,
+];
+
+/** Wrap a raw .text image (linked at 0x80000400) in a bootable big-endian .z64:
+ *  64-byte header (0x80371240 magic + entry) + IPL3 at 0x40 + game at 0x1000. The
+ *  parallel_n64 HLE boot runs the IPL3, which copies the game to RDRAM and jumps. */
+function wrapN64Rom(text, entry = 0x80000400) {
+  const GAME_OFF = 0x1000;
+  const size = GAME_OFF + ((text.length + 3) & ~3);
+  const rom = new Uint8Array(size < 0x101000 ? 0x101000 : size); // ≥1MB (IPL3 copies 1MB)
+  const be32 = (o, v) => { rom[o] = (v >>> 24) & 0xff; rom[o + 1] = (v >> 16) & 0xff; rom[o + 2] = (v >> 8) & 0xff; rom[o + 3] = v & 0xff; };
+  // header: PI BSD config / magic, clock, entry, release
+  be32(0x00, 0x80371240);          // magic (Z64, native big-endian)
+  be32(0x04, 0x0000000f);          // clock rate
+  be32(0x08, entry);               // boot entry (informational; IPL3 jumps explicitly)
+  be32(0x0c, 0x00001444);          // release
+  // name (0x20..0x33)
+  const name = "ROMDEV HOMEBREW     ";
+  for (let i = 0; i < 20; i++) rom[0x20 + i] = name.charCodeAt(i);
+  be32(0x3c, 0x0000004e); // cartridge id "NE" placeholder + region
+  // IPL3 at 0x40
+  for (let i = 0; i < N64_IPL3.length; i++) be32(0x40 + i * 4, N64_IPL3[i]);
+  // game at 0x1000
+  rom.set(text, GAME_OFF);
+  return rom;
+}
+
+/**
+ * Build a minimal C program to a runnable PS1/N64 image.
+ * @param {Object} args
+ * @param {string} [args.source] single C source
+ * @param {Record<string,string>} [args.sources] multi-file (name → text)
+ * @param {Record<string,string>} [args.headers] virtual headers
+ * @param {string} args.platform "ps1" | "n64"
+ * @param {string[]} [args.cc1Options]
+ */
+export async function buildMipsC(args) {
+  const platform = args.platform;
+  const endian = platform === "ps1" ? "little" : "big";
+  const headers = args.headers ?? {};
+  const cc1Options = [...(args.cc1Options ?? []), "-O2", "-G0", "-ffreestanding", "-fno-builtin", "-Wall"];
+  const sources = args.sources ?? (args.source != null ? { "main.c": args.source } : {});
+  let log = "";
+
+  /** @type {Record<string, Uint8Array>} */
+  const userObjs = {};
+  for (const cName of Object.keys(sources).filter((n) => /\.c$/i.test(n))) {
+    const cc = await runCc1mips({ source: sources[cName], headers, options: cc1Options, endian });
+    log += `--- cc1 (${cName}) ---\n${cc.log || "(ok)"}\n`;
+    if (cc.exitCode !== 0 || !cc.asmSource) return { ok: false, binary: null, log, exitCode: cc.exitCode || 1, stage: `cc1 (${cName})`, ...(cc.crash ? { crash: cc.crash } : {}) };
+    const as = await runMipsAs({ source: cc.asmSource, endian });
+    log += `--- as (${cName}) ---\n${as.log || "(ok)"}\n`;
+    if (as.exitCode !== 0 || !as.object) return { ok: false, binary: null, log, exitCode: as.exitCode || 1, stage: `as (${cName})`, ...(as.crash ? { crash: as.crash } : {}) };
+    userObjs[cName.replace(/\.c$/i, ".o")] = as.object;
+  }
+  // raw .s sources too
+  for (const sName of Object.keys(sources).filter((n) => /\.(s|asm)$/i.test(n))) {
+    const as = await runMipsAs({ source: sources[sName], endian });
+    log += `--- as (${sName}) ---\n${as.log || "(ok)"}\n`;
+    if (as.exitCode !== 0 || !as.object) return { ok: false, binary: null, log, exitCode: as.exitCode || 1, stage: `as (${sName})`, ...(as.crash ? { crash: as.crash } : {}) };
+    userObjs[sName.replace(/\.(s|asm)$/i, ".o")] = as.object;
+  }
+
+  // crt0 (per platform)
+  const crt0Name = platform === "ps1" ? "ps1-crt0.s" : "n64-crt0.s";
+  const crt0Src = await readFile(path.join(LIB, crt0Name), "utf-8");
+  const crt0As = await runMipsAs({ source: crt0Src, endian });
+  log += `--- as (${crt0Name}) ---\n${crt0As.log || "(ok)"}\n`;
+  if (crt0As.exitCode !== 0 || !crt0As.object) return { ok: false, binary: null, log, exitCode: crt0As.exitCode || 1, stage: "as (crt0)", ...(crt0As.crash ? { crash: crt0As.crash } : {}) };
+
+  // softint.c — the few libgcc helpers (64-bit divide/mod) in plain C, so the
+  // link doesn't need an endian-specific libgcc.a (the EL libgcc isn't bundled).
+  const softSrc = await readFile(path.join(LIB, "softint.c"), "utf-8");
+  const softCc = await runCc1mips({ source: softSrc, options: cc1Options, endian });
+  const softAs = softCc.asmSource ? await runMipsAs({ source: softCc.asmSource, endian }) : { exitCode: 1 };
+  if (softCc.exitCode !== 0 || softAs.exitCode !== 0 || !softAs.object) {
+    return { ok: false, binary: null, log: log + (softCc.log || "") + (softAs.log || ""), exitCode: 1, stage: "softint" };
+  }
+
+  // link
+  const ldName = platform === "ps1" ? "ps1.ld" : "n64.ld";
+  const linkScript = await readFile(path.join(LIB, ldName), "utf-8");
+  // newlib + libgcc are endian-specific: el/ (PS1 little) vs be/ (N64 big). libgcc
+  // is only bundled for be/ — softint.c covers the EL case, so libgcc is optional.
+  const libDir = path.join(LIB, endian === "little" ? "el" : "be");
+  const [libc, libm] = await Promise.all([
+    readFile(path.join(libDir, "libc.a")), readFile(path.join(libDir, "libm.a")),
+  ]);
+  const archives = { "libc.a": new Uint8Array(libc), "libm.a": new Uint8Array(libm) };
+  const libraries = ["c", "m"];
+  try {
+    const libgcc = await readFile(path.join(libDir, "libgcc.a"));
+    archives["libgcc.a"] = new Uint8Array(libgcc);
+    libraries.unshift("gcc");
+  } catch { /* no endian libgcc — softint.c provides the needed helpers */ }
+  const ld = await runMipsLd({
+    objects: { "crt0.o": crt0As.object, "softint.o": softAs.object, ...userObjs },
+    linkScript, endian,
+    archives,
+    libraries,
+    libraryPaths: ["/work"],
+    options: ["--no-warn-rwx-segments"],
+  });
+  log += `--- ld ---\n${ld.log || "(ok)"}\n`;
+  if (ld.exitCode !== 0 || !ld.elf) return { ok: false, binary: null, log, exitCode: ld.exitCode || 1, stage: "ld", ...(ld.crash ? { crash: ld.crash } : {}) };
+
+  const oc = await runMipsObjcopy({ elf: ld.elf });
+  log += `--- objcopy ---\n${oc.log || "(ok)"}\n`;
+  if (oc.exitCode !== 0 || !oc.binary) return { ok: false, binary: null, log, exitCode: oc.exitCode || 1, stage: "objcopy", ...(oc.crash ? { crash: oc.crash } : {}) };
+
+  const binary = platform === "ps1" ? wrapPsExe(oc.binary)
+    : platform === "n64" ? wrapN64Rom(oc.binary)
+    : oc.binary;
+  return { ok: true, binary, log, exitCode: 0, stage: "done", ...(ld.map ? { symbols: ld.map } : {}) };
+}

package/src/toolchains/mips-elf-gcc/gcc.js

@@ -0,0 +1,130 @@
+// mips-elf-gcc — WASM toolchain wrappers for N64 / PS1 C builds.
+//
+// Pipeline (mirrors m68k-elf-gcc/gcc.js — gcc-the-driver can't fork/exec under
+// emscripten, so we orchestrate cc1 → as → ld → objcopy through callMain):
+//   runCc1mips({source, headers, options, endian}) → MIPS assembly (.s)
+//   runMipsAs({source, includes, endian})          → .o ELF object
+//   runMipsLd({objects, linkScript, ...})          → linked .elf (+ map)
+//   runMipsObjcopy({elf})                          → raw .bin
+//
+// Endianness: N64 (R4300) is big-endian (default), PS1 (R3000) is little-endian
+// (-EL). The same WASM toolchain emits both — pass endian:'little' for PS1.
+
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+import { runIsolated, textFile, binaryFile, getOutputBytes, getOutputText } from "../_worker/run.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// The WASM ships in romdev-toolchain-mips-gcc; fall back to the in-tree dev copy.
+function resolveMipsGlue(file) {
+  try {
+    const u = import.meta.resolve("romdev-toolchain-mips-gcc");
+    const p = path.join(path.dirname(fileURLToPath(u)), "wasm", file);
+    if (existsSync(p)) return p;
+  } catch { /* not resolvable — fall through */ }
+  const local = path.join(__dirname, "wasm", file);
+  if (existsSync(local)) return local;
+  throw new Error(`mips-elf-gcc WASM (${file}) not found — build it with scripts/build-mips-wasm-tools.sh`);
+}
+const _glue = {};
+const mipsGlue = (file) => (_glue[file] ??= resolveMipsGlue(file));
+
+/** Endian flags differ by TOOL: cc1 (the C frontend) wants `-mel`/`-meb`; the
+ *  assembler + linker want `-EL`/`-EB`. `-mabi=32` (cc1) covers both R3000 (PS1)
+ *  and R4300 (N64) 32-bit code. */
+function cc1ArchFlags(endian) {
+  return [endian === "little" ? "-mel" : "-meb", "-mabi=32"];
+}
+function asArchFlags(endian) {
+  // -G0: never use GP-relative (small-data) addressing. Without it, statics land in
+  // .sdata/.sbss and the 16-bit GPREL offsets overflow ("relocation truncated") on
+  // anything but a tiny program. -G0 forces normal .data/.bss addressing.
+  return [endian === "little" ? "-EL" : "-EB", "-mabi=32", "-G0"];
+}
+
+// ── cc1 — MIPS gcc C frontend, source → assembly ─────────────────────
+export async function runCc1mips(args) {
+  const { source, options = [], endian = "big" } = args;
+  const headers = args.headers ?? {};
+  const inputFiles = [textFile("/work/main.c", source)];
+  for (const [name, content] of Object.entries(headers)) inputFiles.push(textFile("/work/" + name, content));
+  const argv = [
+    ...cc1ArchFlags(endian),
+    "-iquote", "/work", "-I", "/work",
+    ...options,
+    "/work/main.c", "-o", "/work/main.s",
+  ];
+  const r = await runIsolated({
+    gluePath: mipsGlue("cc1.mjs"),
+    argv, inputFiles,
+    outputFiles: [{ vfsPath: "/work/main.s", encoding: "utf8" }],
+  });
+  return { log: r.log, exitCode: r.exitCode, asmSource: getOutputText(r, "/work/main.s") || null,
+    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}) };
+}
+
+// ── mips-elf-as — GNU assembler, .s → .o ─────────────────────────────
+export async function runMipsAs(args) {
+  const { source, options = [], endian = "big" } = args;
+  const includes = args.includes ?? {};
+  const binaryIncludes = args.binaryIncludes ?? {};
+  const inputFiles = [textFile("/work/main.s", source)];
+  for (const [name, content] of Object.entries(includes)) inputFiles.push(textFile("/work/" + name, content));
+  for (const [name, bytes] of Object.entries(binaryIncludes)) inputFiles.push(binaryFile("/work/" + name, bytes));
+  const argv = [...asArchFlags(endian), "-I", "/work", ...options, "/work/main.s", "-o", "/work/main.o"];
+  const r = await runIsolated({
+    gluePath: mipsGlue("mips-elf-as.mjs"),
+    argv, inputFiles,
+    outputFiles: [{ vfsPath: "/work/main.o", encoding: "base64" }],
+  });
+  return { log: r.log, exitCode: r.exitCode, object: getOutputBytes(r, "/work/main.o"),
+    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}) };
+}
+
+// ── mips-elf-ld — GNU linker, .o + linker script → .elf ──────────────
+export async function runMipsLd(args) {
+  const { objects, linkScript, libraries = [], libraryPaths = [], options = [], endian = "big" } = args;
+  const archives = args.archives ?? {};
+  const inputFiles = [textFile("/work/link.ld", linkScript)];
+  for (const [name, bytes] of Object.entries(objects)) inputFiles.push(binaryFile("/work/" + name, bytes));
+  for (const [name, bytes] of Object.entries(archives)) inputFiles.push(binaryFile("/work/" + name, bytes));
+  const argv = [
+    endian === "little" ? "-EL" : "-EB",
+    "-T", "/work/link.ld",
+    "-o", "/work/main.elf",
+    "-Map=/work/main.map",
+    ...libraryPaths.flatMap((p) => ["-L", p]),
+    ...Object.keys(objects).map((n) => "/work/" + n),
+    ...libraries.map((l) => `-l${l}`),
+    ...options,
+  ];
+  const r = await runIsolated({
+    gluePath: mipsGlue("mips-elf-ld.mjs"),
+    argv, inputFiles,
+    outputFiles: [
+      { vfsPath: "/work/main.elf", encoding: "base64" },
+      { vfsPath: "/work/main.map", encoding: "utf8" },
+    ],
+  });
+  return { log: r.log, exitCode: r.exitCode, elf: getOutputBytes(r, "/work/main.elf"),
+    map: getOutputText(r, "/work/main.map") || null,
+    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}) };
+}
+
+// ── mips-elf-objcopy — ELF → raw .bin ────────────────────────────────
+export async function runMipsObjcopy(args) {
+  const { elf, options = [] } = args;
+  const inputFiles = [binaryFile("/work/main.elf", elf)];
+  const argv = ["-O", "binary", ...options, "/work/main.elf", "/work/main.bin"];
+  const r = await runIsolated({
+    gluePath: mipsGlue("mips-elf-objcopy.mjs"),
+    argv, inputFiles,
+    outputFiles: [{ vfsPath: "/work/main.bin", encoding: "base64" }],
+  });
+  return { log: r.log, exitCode: r.exitCode, binary: getOutputBytes(r, "/work/main.bin"),
+    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}) };
+}

package/src/toolchains/sh-c/lib/dc-crt0.s

@@ -0,0 +1,23 @@
+	.section .text.start, "ax"
+	.global _start
+_start:
+	mov.l stack_top, r15      ! stack = top of 16MB DC RAM
+	mov.l bss_start, r0       ! clear .bss
+	mov.l bss_end, r1
+	mov #0, r2
+1:	cmp/hs r1, r0
+	bt 2f
+	mov.l r2, @r0
+	add #4, r0
+	bra 1b
+	nop
+2:	mov.l main_addr, r0       ! call main()
+	jsr @r0
+	nop
+hang:	bra hang
+	nop
+	.align 4
+stack_top:	.long 0x8d000000
+bss_start:	.long __bss_start
+bss_end:	.long _end
+main_addr:	.long _main

package/src/toolchains/sh-c/lib/dc.h

@@ -0,0 +1,102 @@
+/* dc.h — minimal Dreamcast helper for romdev homebrew.
+ *
+ * Brings up the PowerVR2 video output for a plain 640x480 RGB565 framebuffer and
+ * exposes pixel/fill/rect primitives. No KallistiOS dependency — just the registers
+ * the Flycast (reios HLE) core needs to scan out a direct framebuffer.
+ *
+ * Memory map:
+ *   PVR/HOLLY registers : 0xA05F8000 (uncached)
+ *   VRAM (64-bit area)  : 0xA5000000 (16 MB) — the framebuffer lives here
+ *
+ * The DC has two VRAM views; the 64-bit area (0xA5000000) is the linear one we draw to.
+ */
+#ifndef ROMDEV_DC_H
+#define ROMDEV_DC_H
+
+typedef unsigned char  u8;
+typedef unsigned short u16;
+typedef unsigned int   u32;
+
+#define DC_W 640
+#define DC_H 480
+
+/* PVR register access */
+#define PVR_BASE 0xA05F8000u
+#define PVR_REG(off) (*(volatile u32 *)(PVR_BASE + (off)))
+
+/* The framebuffer we draw to (offset 0 in the 64-bit VRAM area). */
+#define DC_FB_OFFSET 0x000000u
+#define DC_VRAM ((volatile u16 *)(0xA5000000u + DC_FB_OFFSET))
+
+/* RGB565 helper */
+static inline u16 dc_rgb(u8 r, u8 g, u8 b) {
+    return (u16)(((r & 0xF8) << 8) | ((g & 0xFC) << 3) | (b >> 3));
+}
+
+/* Bring up 640x480 RGB565 video. Call once at start. The register values are the
+ * documented PowerVR2 settings for a progressive NTSC 640x480 RGB565 framebuffer;
+ * Flycast's reios + EmulateFramebuffer scanout reads FB_R_CTRL/FB_R_SIZE/FB_R_SOF1. */
+static inline void dc_video_init(void) {
+    /* FB_R_CTRL: fb_enable=1, fb_depth=1 (RGB565), fb_concat=4 (fill low bits). */
+    PVR_REG(0x044) = 0x00000001u | (1u << 2) | (4u << 4); /* = 0x45 */
+    /* FB_W_CTRL: fb_packmode=1 (RGB565). */
+    PVR_REG(0x048) = 0x00000001u;
+    /* FB_R_SOF1 / FB_W_SOF1: framebuffer start = DC_FB_OFFSET. */
+    PVR_REG(0x050) = DC_FB_OFFSET;          /* FB_R_SOF1 */
+    PVR_REG(0x060) = DC_FB_OFFSET;          /* FB_W_SOF1 */
+    /* FB_R_SIZE: fb_x_size = (line bytes / 4) - 1, fb_y_size = lines - 1, modulus = 1.
+     * 640px * 2 bytes = 1280 bytes/line -> 1280/4 - 1 = 319. */
+    PVR_REG(0x05C) = (u32)(DC_W * 2 / 4 - 1)        /* fb_x_size = 319 */
+                   | ((u32)(DC_H - 1) << 10)        /* fb_y_size = 479 */
+                   | ((u32)1u << 20);               /* fb_modulus = 1 */
+    /* FB_W_LINESTRIDE: line stride in 64-bit (8-byte) units = 1280/8 = 160. */
+    PVR_REG(0x11C) = (u32)(DC_W * 2 / 8);
+    /* VO_CONTROL: pixel double off, normal output. */
+    PVR_REG(0x0E8) = 0x00000000u;
+    /* VO_BORDER_COL: black border. */
+    PVR_REG(0x040) = 0x00000000u;
+    /* SPG_LOAD / SPG_CONTROL: NTSC 640x480 progressive timing. */
+    PVR_REG(0x0D8) = (524u << 16) | 857u;   /* SPG_LOAD: vcount, hcount */
+    PVR_REG(0x0D0) = 0x00000000u;           /* SPG_CONTROL: NTSC, non-interlace */
+}
+
+/* Plot a pixel (no bounds clamp on the hot path; caller keeps in range). */
+static inline void dc_plot(int x, int y, u16 c) {
+    DC_VRAM[y * DC_W + x] = c;
+}
+
+/* Fill the whole framebuffer with one color. */
+static inline void dc_clear(u16 c) {
+    int i;
+    for (i = 0; i < DC_W * DC_H; i++)
+        DC_VRAM[i] = c;
+}
+
+/* Fill an axis-aligned rectangle (clipped to the screen). */
+static inline void dc_rect(int x0, int y0, int w, int h, u16 c) {
+    int x, y;
+    if (x0 < 0) { w += x0; x0 = 0; }
+    if (y0 < 0) { h += y0; y0 = 0; }
+    if (x0 + w > DC_W) w = DC_W - x0;
+    if (y0 + h > DC_H) h = DC_H - y0;
+    for (y = 0; y < h; y++)
+        for (x = 0; x < w; x++)
+            DC_VRAM[(y0 + y) * DC_W + (x0 + x)] = c;
+}
+
+/* ── Controller input (Maple bus, port 0) ─────────────────────────────────────
+ * The DC Maple controller digital-button bit layout. Full Maple DMA setup is
+ * non-trivial; the romdev host injects input (setInput) that the core maps onto
+ * Maple, so these constants document the bit layout for game logic. */
+#define DC_BTN_C      0x0001
+#define DC_BTN_B      0x0002
+#define DC_BTN_A      0x0004
+#define DC_BTN_START  0x0008
+#define DC_BTN_UP     0x0010
+#define DC_BTN_DOWN   0x0020
+#define DC_BTN_LEFT   0x0040
+#define DC_BTN_RIGHT  0x0080
+#define DC_BTN_Y      0x0200
+#define DC_BTN_X      0x0400
+
+#endif /* ROMDEV_DC_H */

package/src/toolchains/sh-c/lib/dc.ld

@@ -0,0 +1,11 @@
+ENTRY(_start)
+MEMORY { ram (rwx) : ORIGIN = 0x8c010000, LENGTH = 0x800000 }
+SECTIONS {
+  .text : { *(.text.start) *(.text*) *(.rodata*) } > ram
+  .data : { *(.data*) } > ram
+  . = ALIGN(4);
+  __bss_start = .;
+  .bss  : { *(.bss*) *(COMMON) } > ram
+  . = ALIGN(4);
+  _end = .;
+}

package/src/toolchains/sh-c/sh-c.js

@@ -0,0 +1,101 @@
+// sh-c — Dreamcast (SH-4) C build driver.
+//
+//   buildShC({ source | sources, headers }) → { ok, binary (ELF), log, symbols }
+//
+// gcc-the-driver can't fork/exec under emscripten, so we orchestrate the stages
+// directly (cc1 → as → ld → objcopy-not-needed). The output is an ELF that Flycast's
+// reios HLE BIOS boots directly (no GD-ROM/CDI image, no scrambling): reios_loadElf
+// copies the PT_LOAD segments to their vaddr (0x8c010000) and jumps to _start.
+//
+// Bare path: a small crt0 sets the stack (top of 16 MB DC RAM), zeroes .bss, and
+// calls main(). newlib libc/libm + libgcc are linked (SH-4, little-endian). The
+// romdev DC helper (rom-games/dreamcast/.../dc.h) brings up the PowerVR2 framebuffer.
+
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+
+import { runCc1sh, runShAs, runShLd } from "../sh-elf-gcc/gcc.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const LIB = path.join(__dirname, "lib");
+
+/**
+ * Compile + link Dreamcast SH-4 C to a bootable ELF.
+ * @param {object} args
+ * @param {string} [args.source] single C source (shorthand for sources["main.c"])
+ * @param {Record<string,string>} [args.sources] name → source (.c and .s)
+ * @param {Record<string,string>} [args.headers] name → header text
+ * @param {string[]} [args.cc1Options] extra cc1 flags
+ */
+export async function buildShC(args) {
+  // The bundled DC helper (dc.h) is auto-available so `#include "dc.h"` just works —
+  // it brings up the PowerVR2 framebuffer (FB_R_CTRL/SIZE/SOF1 + SPG for 640x480 RGB565)
+  // that Flycast presents. A caller-supplied "dc.h" wins (override the bundled one).
+  const bundledDcH = await readFile(path.join(LIB, "dc.h"), "utf-8").catch(() => null);
+  const headers = { ...(bundledDcH != null ? { "dc.h": bundledDcH } : {}), ...(args.headers ?? {}) };
+  // -m4-single-only is passed by the cc1 wrapper; here the language/codegen knobs.
+  // Default to -O2, but let a user-supplied -O<level> win (gcc honors the LAST -O, so a
+  // default appended AFTER the user's would clobber it — only add -O2 if absent).
+  const userOpts = args.cc1Options ?? [];
+  const hasOpt = userOpts.some((o) => /^-O/.test(o));
+  const cc1Options = [...(hasOpt ? [] : ["-O2"]), ...userOpts, "-ffreestanding", "-fno-builtin", "-Wall"];
+  const sources = args.sources ?? (args.source != null ? { "main.c": args.source } : {});
+  let log = "";
+
+  /** @type {Record<string, Uint8Array>} */
+  const userObjs = {};
+  for (const cName of Object.keys(sources).filter((n) => /\.c$/i.test(n))) {
+    const cc = await runCc1sh({ source: sources[cName], headers, options: cc1Options });
+    log += `--- cc1 (${cName}) ---\n${cc.log || "(ok)"}\n`;
+    if (cc.exitCode !== 0 || !cc.asmSource)
+      return { ok: false, binary: null, log, exitCode: cc.exitCode || 1, stage: `cc1 (${cName})`, ...(cc.crash ? { crash: cc.crash } : {}) };
+    const as = await runShAs({ source: cc.asmSource });
+    log += `--- as (${cName}) ---\n${as.log || "(ok)"}\n`;
+    if (as.exitCode !== 0 || !as.object)
+      return { ok: false, binary: null, log, exitCode: as.exitCode || 1, stage: `as (${cName})`, ...(as.crash ? { crash: as.crash } : {}) };
+    userObjs[cName.replace(/\.c$/i, ".o")] = as.object;
+  }
+  // raw .s sources too
+  for (const sName of Object.keys(sources).filter((n) => /\.(s|asm)$/i.test(n))) {
+    const as = await runShAs({ source: sources[sName] });
+    log += `--- as (${sName}) ---\n${as.log || "(ok)"}\n`;
+    if (as.exitCode !== 0 || !as.object)
+      return { ok: false, binary: null, log, exitCode: as.exitCode || 1, stage: `as (${sName})`, ...(as.crash ? { crash: as.crash } : {}) };
+    userObjs[sName.replace(/\.(s|asm)$/i, ".o")] = as.object;
+  }
+
+  // crt0 (stack + .bss clear + main()).
+  const crt0Src = await readFile(path.join(LIB, "dc-crt0.s"), "utf-8");
+  const crt0As = await runShAs({ source: crt0Src });
+  log += `--- as (dc-crt0.s) ---\n${crt0As.log || "(ok)"}\n`;
+  if (crt0As.exitCode !== 0 || !crt0As.object)
+    return { ok: false, binary: null, log, exitCode: crt0As.exitCode || 1, stage: "as (crt0)", ...(crt0As.crash ? { crash: crt0As.crash } : {}) };
+
+  // link: crt0 + user objects + newlib (libc/libm) + libgcc.
+  const linkScript = await readFile(path.join(LIB, "dc.ld"), "utf-8");
+  const [libc, libm, libgcc] = await Promise.all([
+    readFile(path.join(LIB, "libc.a")),
+    readFile(path.join(LIB, "libm.a")),
+    readFile(path.join(LIB, "libgcc.a")),
+  ]);
+  const ld = await runShLd({
+    objects: { "crt0.o": crt0As.object, ...userObjs },
+    linkScript,
+    archives: {
+      "libc.a": new Uint8Array(libc),
+      "libm.a": new Uint8Array(libm),
+      "libgcc.a": new Uint8Array(libgcc),
+    },
+    libraries: ["c", "m", "gcc"],
+    libraryPaths: ["/work"],
+    options: ["--no-warn-rwx-segments"],
+  });
+  log += `--- ld ---\n${ld.log || "(ok)"}\n`;
+  if (ld.exitCode !== 0 || !ld.elf)
+    return { ok: false, binary: null, log, exitCode: ld.exitCode || 1, stage: "ld", ...(ld.crash ? { crash: ld.crash } : {}) };
+
+  // The ELF IS the deliverable — reios boots it directly.
+  return { ok: true, binary: ld.elf, log, exitCode: 0, stage: "done", ...(ld.map ? { symbols: ld.map } : {}) };
+}

package/src/toolchains/sh-elf-gcc/gcc.js

@@ -0,0 +1,122 @@
+// sh-elf-gcc — WASM toolchain wrappers for Dreamcast (SH-4) C builds.
+//
+// Pipeline (mirrors mips-elf-gcc/gcc.js — gcc-the-driver can't fork/exec under
+// emscripten, so we orchestrate cc1 → as → ld → objcopy through callMain):
+//   runCc1sh({source, headers, options})  → SH assembly (.s)
+//   runShAs({source, includes})           → .o ELF object
+//   runShLd({objects, linkScript, ...})   → linked .elf (+ map)
+//   runShObjcopy({elf})                   → raw .bin
+//
+// The Dreamcast SH-4 is little-endian, m4-single-only FP. Single endianness — no
+// EL/EB split like MIPS. The staged tool stems keep the createMips* EXPORT_NAMEs
+// the build script reused, but the glue filenames are sh-elf-*.
+
+import { fileURLToPath } from "node:url";
+import { existsSync } from "node:fs";
+import path from "node:path";
+
+import { runIsolated, textFile, binaryFile, getOutputBytes, getOutputText } from "../_worker/run.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// The WASM ships in romdev-toolchain-sh-gcc; fall back to the in-tree dev copy.
+function resolveShGlue(file) {
+  try {
+    const u = import.meta.resolve("romdev-toolchain-sh-gcc");
+    const p = path.join(path.dirname(fileURLToPath(u)), "wasm", file);
+    if (existsSync(p)) return p;
+  } catch { /* not resolvable — fall through */ }
+  const local = path.join(__dirname, "wasm", file);
+  if (existsSync(local)) return local;
+  throw new Error(`sh-elf-gcc WASM (${file}) not found — build it with scripts/build-sh-wasm-tools.sh`);
+}
+const _glue = {};
+const shGlue = (file) => (_glue[file] ??= resolveShGlue(file));
+
+// SH-4 little-endian, m4-single-only FP. cc1 wants -ml; as wants -little --isa=sh4.
+const CC1_ARCH = ["-ml", "-m4-single-only"];
+const AS_ARCH = ["-little", "--isa=sh4"];
+
+// ── cc1 — SH gcc C frontend, source → assembly ───────────────────────
+export async function runCc1sh(args) {
+  const { source, options = [] } = args;
+  const headers = args.headers ?? {};
+  const inputFiles = [textFile("/work/main.c", source)];
+  for (const [name, content] of Object.entries(headers)) inputFiles.push(textFile("/work/" + name, content));
+  const argv = [
+    ...CC1_ARCH,
+    "-iquote", "/work", "-I", "/work",
+    ...options,
+    "/work/main.c", "-o", "/work/main.s",
+  ];
+  const r = await runIsolated({
+    gluePath: shGlue("cc1.mjs"),
+    argv, inputFiles,
+    outputFiles: [{ vfsPath: "/work/main.s", encoding: "utf8" }],
+  });
+  return { log: r.log, exitCode: r.exitCode, asmSource: getOutputText(r, "/work/main.s") || null,
+    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}) };
+}
+
+// ── sh-elf-as — GNU assembler, .s → .o ───────────────────────────────
+export async function runShAs(args) {
+  const { source, options = [] } = args;
+  const includes = args.includes ?? {};
+  const binaryIncludes = args.binaryIncludes ?? {};
+  const inputFiles = [textFile("/work/main.s", source)];
+  for (const [name, content] of Object.entries(includes)) inputFiles.push(textFile("/work/" + name, content));
+  for (const [name, bytes] of Object.entries(binaryIncludes)) inputFiles.push(binaryFile("/work/" + name, bytes));
+  const argv = [...AS_ARCH, "-I", "/work", ...options, "/work/main.s", "-o", "/work/main.o"];
+  const r = await runIsolated({
+    gluePath: shGlue("sh-elf-as.mjs"),
+    argv, inputFiles,
+    outputFiles: [{ vfsPath: "/work/main.o", encoding: "base64" }],
+  });
+  return { log: r.log, exitCode: r.exitCode, object: getOutputBytes(r, "/work/main.o"),
+    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}) };
+}
+
+// ── sh-elf-ld — GNU linker, .o + linker script → .elf ────────────────
+export async function runShLd(args) {
+  const { objects, linkScript, libraries = [], libraryPaths = [], options = [] } = args;
+  const archives = args.archives ?? {};
+  const inputFiles = [textFile("/work/link.ld", linkScript)];
+  for (const [name, bytes] of Object.entries(objects)) inputFiles.push(binaryFile("/work/" + name, bytes));
+  for (const [name, bytes] of Object.entries(archives)) inputFiles.push(binaryFile("/work/" + name, bytes));
+  const argv = [
+    "-EL",
+    "-T", "/work/link.ld",
+    "-o", "/work/main.elf",
+    "-Map=/work/main.map",
+    ...libraryPaths.flatMap((p) => ["-L", p]),
+    ...Object.keys(objects).map((n) => "/work/" + n),
+    ...libraries.map((l) => `-l${l}`),
+    ...options,
+  ];
+  const r = await runIsolated({
+    gluePath: shGlue("sh-elf-ld.mjs"),
+    argv, inputFiles,
+    outputFiles: [
+      { vfsPath: "/work/main.elf", encoding: "base64" },
+      { vfsPath: "/work/main.map", encoding: "utf8" },
+    ],
+  });
+  return { log: r.log, exitCode: r.exitCode, elf: getOutputBytes(r, "/work/main.elf"),
+    map: getOutputText(r, "/work/main.map") || null,
+    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}) };
+}
+
+// ── sh-elf-objcopy — ELF → raw .bin ──────────────────────────────────
+export async function runShObjcopy(args) {
+  const { elf, options = [] } = args;
+  const inputFiles = [binaryFile("/work/main.elf", elf)];
+  const argv = ["-O", "binary", ...options, "/work/main.elf", "/work/main.bin"];
+  const r = await runIsolated({
+    gluePath: shGlue("sh-elf-objcopy.mjs"),
+    argv, inputFiles,
+    outputFiles: [{ vfsPath: "/work/main.bin", encoding: "base64" }],
+  });
+  return { log: r.log, exitCode: r.exitCode, binary: getOutputBytes(r, "/work/main.bin"),
+    ...(r.crash ? { crash: r.crash, stage: "crash" } : {}) };
+}