romdevtools 0.56.1 → 0.71.0

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

@@ -0,0 +1,104 @@
+// 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 -O1, NOT -O2: the sh-elf cc1.wasm build has an -O2-only pass that aborts
+  // ("memory access out of bounds" during "Assembling functions") on common control
+  // flow — e.g. an infinite loop that mutates locals through both `if`/`else` branches.
+  // -O1 dodges it entirely and is plenty for DC homebrew. A user-supplied -O<level>
+  // still wins (gcc honors the LAST -O, so only add a default when none is present).
+  const userOpts = args.cc1Options ?? [];
+  const hasOpt = userOpts.some((o) => /^-O/.test(o));
+  const cc1Options = [...(hasOpt ? [] : ["-O1"]), ...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" } : {}) };
+}