romdevtools 0.70.0 → 0.71.0

package/src/toolchains/asar/asar.js

@@ -74,6 +74,17 @@ export async function runAsar(args) {
   });
   let { binary, log, exitCode } = first;
 
+  // asar exits a NORMAL error build via its C++ exception path (quit throws a
+  // numeric heap pointer, not a clean status), so the worker appends a generic
+  // `[worker] Abort in WASM: <ptr>` line even though asar DID write proper
+  // diagnostics (e.g. `…: error: (Elabel_not_found): …`). That line reads as a
+  // silent crash + the heap-pointer "<number>" looks like an OOM/trap — it cost
+  // real diagnosis time (v0.70.0 feedback #5). When the log already has a real
+  // asar diagnostic, this was an ordinary error exit: drop the misleading line.
+  if (exitCode !== 0 && /:\s*(error|warning)\s*:/i.test(log)) {
+    log = log.replace(/\n?\s*\[worker\] Abort in WASM:[^\n]*\n?/g, "\n").replace(/\n{3,}/g, "\n\n").trimEnd() + "\n";
+  }
+
   // Silent-fail recovery. When asar throws a numeric value through Emscripten's
   // C++-exception path, that "number" is a heap pointer to the thrown object,
   // not an exit code — and we've lost the actual error message. Under
@@ -101,9 +112,19 @@ export async function runAsar(args) {
 
     const hex = "0x" + (exitCode >>> 0).toString(16).toUpperCase();
     const looksLikeHeapPointer = exitCode > 1024;
-    const hint = looksLikeHeapPointer
+    // Count DISTINCT files touched via the readfile/filesize/canreadfile API.
+    // asar-WASM has a known resource issue where reading enough distinct files
+    // that way (the canonical commercial-disassembly asset-conversion idiom, e.g.
+    // an incpal macro converting many .pal palettes) can abort with no diagnostic
+    // (v0.70.0 feedback #1). Surfacing the count turns a silent dead-end into a
+    // lead. (incbin of the same files does NOT trip it — only readfile1/filesize.)
+    const distinctReadfileFiles = countReadfileFiles(source);
+    const readfileHint = distinctReadfileFiles >= READFILE_DISTINCT_WARN
+      ? ` This source reads ${distinctReadfileFiles} DISTINCT files via readfile1/filesize/canreadfile — asar-WASM can abort with no diagnostic above a threshold of distinct files read that way (a known limitation). If you're converting assets at assemble time (e.g. .pal -> 15-bit), pre-convert them to .bin blobs offline and incbin those instead (incbin does NOT leak) — the output is byte-identical.`
+      : "";
+    const hint = (looksLikeHeapPointer
       ? "Exit code looks like a heap pointer, not a real exit code — likely a C++ exception that escaped without writing to stderr. Common causes: bank-border-crossed, section overlap, ROM size exceeded, or out-of-memory while assembling."
-      : "asar exited non-zero with no output.";
+      : "asar exited non-zero with no output.") + readfileHint;
 
     const layoutText = formatLayout(summarizeWrittenRegions(verboseBinary, baseRom, { flatBinary }));
 
@@ -155,6 +176,20 @@ export async function runAsar(args) {
     includesInfo[name] = { size };
   }
 
+  // Proactive advisory: even when THIS build squeaked by, a source reading many
+  // distinct files via readfile1/filesize is at risk of the asar-WASM abort —
+  // surface it (non-fatal) so a growing disassembly doesn't dead-end later.
+  {
+    const distinct = countReadfileFiles(source);
+    if (distinct >= READFILE_DISTINCT_WARN && !/readfile.*distinct files/i.test(log)) {
+      log =
+        `[asar advisory] this source reads ${distinct} distinct files via readfile1/filesize — ` +
+        `asar-WASM can abort (no diagnostic) above a threshold of distinct files read that way. ` +
+        `If you're converting assets at assemble time, prefer pre-converting them to .bin and ` +
+        `'incbin' (byte-identical, no leak).\n` + log;
+    }
+  }
+
   // Try to read the symbol file that asar emitted, if any.
   let symbolsText = null;
   if (wantSymbols) {
@@ -346,20 +381,30 @@ function asarPreflight(source, { binaryIncludes = {}, includes = {} } = {}) {
   }
 
   // -----------------------------------------------------------------------
-  // Header-overlap detection: if an `incbin "foo.bin"` lands in a 32 KB
-  // bank window starting at $XX8000 and the file size would extend past
-  // $XXFFC0 (16 KB of usable area before the LoROM header), warn the user
-  // BEFORE asar happily clobbers the header during pass 2.
+  // Header-overlap detection: an `incbin "foo.bin"` whose span would reach
+  // $00FFC0 clobbers the LoROM header during pass 2. **The LoROM header lives
+  // ONLY in bank $00** ($00FFC0..$00FFFF) — for banks $01+, $XXFFC0 is ordinary
+  // ROM, and games (e.g. SMW's GFX banks 08-0B) legitimately fill across those
+  // boundaries under `check bankcross off`. So only flag BANK $00 (v0.70.0 #6:
+  // the old check false-positived on every bank as "$08FFC0 header"). Also honor
+  // `check bankcross off` (the user is explicitly opting into bank-crossing fills).
   //
-  // We only check incbin's pointing at files in binaryIncludes (where we
-  // know the size). We assume each incbin is preceded by an `org $XX8000`
-  // and that the file fits or doesn't from that base.
+  // We only check incbin's pointing at files in binaryIncludes (size known) and
+  // assume each is preceded by an `org $008000`. Note: this scans only the entry
+  // source — `incbin`s inside `incsrc`'d files aren't seen (so the check is a
+  // best-effort early warning, not full coverage).
   // -----------------------------------------------------------------------
   const incbinDirective = /^\s*incbin\s+"([^"]+)"/;
-  // Walk top-to-bottom, tracking the most recent org as the "cursor".
+  const bankcrossOffRe = /^\s*check\s+bankcross\s+off\b/i;
+  const bankcrossOnRe = /^\s*check\s+bankcross\s+(on|half)\b/i;
+  // Walk top-to-bottom, tracking the most recent org as the "cursor" and the
+  // current `check bankcross` state (off = the user opted into crossing fills).
   let cursor = null;
+  let bankcrossOff = false;
   for (let i = 0; i < lines.length; i++) {
     const line = stripComment(lines[i]);
+    if (bankcrossOffRe.test(line)) { bankcrossOff = true; continue; }
+    if (bankcrossOnRe.test(line)) { bankcrossOff = false; continue; }
     const orgMatch = line.match(orgDirective);
     if (orgMatch) {
       cursor = parseInt(orgMatch[1], 16);
@@ -373,15 +418,16 @@ function asarPreflight(source, { binaryIncludes = {}, includes = {} } = {}) {
     const size = blob instanceof Uint8Array ? blob.length : Buffer.from(blob, "base64").length;
     const bank = (cursor >>> 16) & 0xFF;
     const off = cursor & 0xFFFF;
-    const headerStart = 0xFFC0; // LoROM header lives at $XXFFC0..$XXFFFF
-    if (off >= 0x8000 && off + size > headerStart) {
+    const headerStart = 0xFFC0; // LoROM header lives at $00FFC0..$00FFFF (bank $00 ONLY)
+    if (!bankcrossOff && bank === 0x00 && off >= 0x8000 && off + size > headerStart) {
       const fmtAddr = (a) => "$" + a.toString(16).padStart(6, "0").toUpperCase();
       const endAddr = (bank << 16) | (off + size - 1);
       issues.push(
         `[asar preflight] line ${i + 1}: 'incbin "${name}"' (${size} bytes) starting at ` +
         `${fmtAddr(cursor)} would extend to ${fmtAddr(endAddr)}, overlapping the LoROM ` +
-        `header at $${bank.toString(16).padStart(2, "0").toUpperCase()}FFC0. Move this data ` +
-        `to a higher bank (e.g. 'org $018000') or shrink it below ${headerStart - off} bytes.`,
+        `header at $00FFC0. Move this data to a higher bank (e.g. 'org $018000') or ` +
+        `shrink it below ${headerStart - off} bytes. (Add 'check bankcross off' if this ` +
+        `crossing is intentional.)`,
       );
     }
     // Advance cursor so consecutive incbins in the same bank stack.
@@ -531,3 +577,27 @@ function asarPreflight(source, { binaryIncludes = {}, includes = {} } = {}) {
   }
   return null;
 }
+
+// asar-WASM aborts (no diagnostic) once readfile1/filesize/canreadfile touch
+// enough DISTINCT files — the canonical commercial-disassembly asset-conversion
+// idiom (an incpal-style macro converting many .pal palettes at assemble time).
+// We can't always predict the exact ceiling, so warn above this many distinct
+// files so the build doesn't silently dead-end (v0.70.0 feedback #1).
+const READFILE_DISTINCT_WARN = 40;
+
+/**
+ * Count DISTINCT file names passed to the readfile / filesize / canreadfile
+ * functions. Only literal string filenames are counted (computed names can't be
+ * resolved statically). Used for the readfile-leak advisory.
+ * @param {string} source
+ * @returns {number}
+ */
+function countReadfileFiles(source) {
+  const names = new Set();
+  // readfile1("x",..) / readfile2(...) / readfile3 / readfile4 / filesize("x")
+  // / canreadfile("x",..) / canreadfile1..4 — first string arg is the filename.
+  const re = /\b(?:readfile[1-4]|canreadfile[1-4]?|filesize)\s*\(\s*"([^"]+)"/gi;
+  let m;
+  while ((m = re.exec(source)) !== null) names.add(m[1]);
+  return names.size;
+}

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

@@ -77,9 +77,30 @@ function wrapN64Rom(text, entry = 0x80000400) {
 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 } : {});
+
+  // Auto-bundle the platform helper lib so `#include "n64.h"` / `#include "psx.h"`
+  // just works (parity with the Dreamcast sh-c path that auto-bundles dc.h). The
+  // header is added to the virtual headers; the matching .c is compiled + linked as
+  // an extra source — UNLESS the caller already provides their own (caller wins, and
+  // we skip auto-linking the .c if a same-named source is already present so there's
+  // no duplicate-symbol clash). The helper lives in platforms/<platform>/lib/c/.
+  const helperName = platform === "ps1" ? "psx" : platform === "n64" ? "n64" : null;
+  const headers = { ...(args.headers ?? {}) };
+  /** @type {Record<string,string>} */
+  let autoHelperSrc = null;
+  if (helperName) {
+    const helperDir = path.join(__dirname, "..", "..", "platforms", platform, "lib", "c");
+    const hPath = path.join(helperDir, `${helperName}.h`);
+    const cPath = path.join(helperDir, `${helperName}.c`);
+    if (headers[`${helperName}.h`] == null) {
+      const hSrc = await readFile(hPath, "utf-8").catch(() => null);
+      if (hSrc != null) headers[`${helperName}.h`] = hSrc;
+    }
+    const callerHasC = (args.sources && (args.sources[`${helperName}.c`] != null));
+    if (!callerHasC) autoHelperSrc = await readFile(cPath, "utf-8").catch(() => null);
+  }
   let log = "";
 
   /** @type {Record<string, Uint8Array>} */
@@ -93,6 +114,19 @@ export async function buildMipsC(args) {
     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;
   }
+  // Auto-bundled helper .c (n64.c / psx.c) — compiled with the SAME headers so it can
+  // see its own header, linked alongside the user objects. Skipped when the caller
+  // supplied their own helper .c (callerHasC) above.
+  if (autoHelperSrc != null) {
+    const cc = await runCc1mips({ source: autoHelperSrc, headers, options: cc1Options, endian });
+    log += `--- cc1 (${helperName}.c, bundled) ---\n${cc.log || "(ok)"}\n`;
+    if (cc.exitCode !== 0 || !cc.asmSource) return { ok: false, binary: null, log, exitCode: cc.exitCode || 1, stage: `cc1 (${helperName}.c bundled)`, ...(cc.crash ? { crash: cc.crash } : {}) };
+    const as = await runMipsAs({ source: cc.asmSource, endian });
+    log += `--- as (${helperName}.c, bundled) ---\n${as.log || "(ok)"}\n`;
+    if (as.exitCode !== 0 || !as.object) return { ok: false, binary: null, log, exitCode: as.exitCode || 1, stage: `as (${helperName}.c bundled)` };
+    userObjs[`${helperName}.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 });

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

@@ -55,9 +55,11 @@ static inline void dc_video_init(void) {
     PVR_REG(0x0E8) = 0x00000000u;
     /* VO_BORDER_COL: black border. */
     PVR_REG(0x040) = 0x00000000u;
-    /* SPG_LOAD / SPG_CONTROL: NTSC 640x480 progressive timing. */
+    /* SPG_LOAD / SPG_CONTROL: NTSC 640x480 INTERLACED (480i). Non-interlace (240p)
+     * only displays 240 lines, so the top half of a 480-line framebuffer never shows.
+     * interlace=1 outputs the full 480-line image. */
     PVR_REG(0x0D8) = (524u << 16) | 857u;   /* SPG_LOAD: vcount, hcount */
-    PVR_REG(0x0D0) = 0x00000000u;           /* SPG_CONTROL: NTSC, non-interlace */
+    PVR_REG(0x0D0) = 0x00000050u;           /* SPG_CONTROL: NTSC, interlace=1 (bit4), PAL=0 */
 }
 
 /* Plot a pixel (no bounds clamp on the hot path; caller keeps in range). */
@@ -85,18 +87,66 @@ static inline void dc_rect(int x0, int y0, int w, int h, u16 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
+ * Digital-button bits, matching Flycast's DC kcode (active-LOW on the wire — a bit
+ * is 0 when pressed). dc_pad() does a real Maple "Get Condition" DMA, inverts the
+ * kcode to active-HIGH, and masks to the real button bits. The romdev host's
+ * setInput drives the emulated pad. */
+#define DC_BTN_C      (1u << 0)
+#define DC_BTN_B      (1u << 1)
+#define DC_BTN_A      (1u << 2)
+#define DC_BTN_START  (1u << 3)
+#define DC_BTN_UP     (1u << 4)
+#define DC_BTN_DOWN   (1u << 5)
+#define DC_BTN_LEFT   (1u << 6)
+#define DC_BTN_RIGHT  (1u << 7)
+#define DC_BTN_Y      (1u << 9)
+#define DC_BTN_X      (1u << 10)
+/* only the bits above are real digital buttons; mask out reserved bits on read. */
+#define DC_BTN_MASK   0x06FFu
+
+/* Maple DMA registers (Holly system bus). */
+#define DC_SB(o)   (*(volatile u32 *)(0xA05F6C00u + (o)))
+#define DC_MDSTAR  0x04   /* command-table address */
+#define DC_MDEN    0x14   /* DMA enable */
+#define DC_MDST    0x18   /* DMA start */
+
+/* Read controller port 0 via a Maple "Get Condition" DMA. Builds a one-shot command
+ * frame (recipient = port-0 controller AP 0x20, cmd 0x09 GetCondition, function =
+ * controller 0x01000000), points the recv buffer at a scratch, kicks the DMA, then
+ * scans the response for the controller's function-id marker (0x01000000) and reads
+ * the 16-bit kcode that immediately follows. kcode is active-LOW on the wire, so we
+ * invert + mask to the real button bits → DC_BTN_* set == pressed.
+ *
+ * NOTE: the exact word offset of the kcode in the recv frame can vary; we locate it
+ * by the MFID marker rather than a fixed index, which is robust across the response
+ * framing. Returns 0 if no controller response is found. */
+static inline u32 dc_pad(void) {
+    static volatile u32 cmd[8] __attribute__((aligned(32)));
+    static volatile u32 rsp[16] __attribute__((aligned(32)));
+    u32 phys_cmd = ((u32)(unsigned long)cmd) & 0x1FFFFFFF;
+    u32 phys_rsp = ((u32)(unsigned long)rsp) & 0x1FFFFFFF;
+    int i;
+    for (i = 0; i < 16; i++) rsp[i] = 0;
+    cmd[0] = 0x80000000u;             /* last xfer (bit31), op=START(0), frame len-1=0 */
+    cmd[1] = phys_rsp;                /* receive address */
+    cmd[2] = (1u << 24)               /* data length in words (1) */
+           | (0x20u << 16)            /* sender address */
+           | (0x20u << 8)             /* recipient: port 0 controller (AP 0x20) */
+           | 0x09u;                   /* command: Get Condition */
+    cmd[3] = 0x01000000u;             /* function: controller */
+    DC_SB(DC_MDEN) = 1;
+    DC_SB(DC_MDSTAR) = phys_cmd;
+    DC_SB(DC_MDST) = 1;               /* synchronous under the romdev/HLE core */
+    /* find the controller function-id (0x01000000) in the response; the kcode is the
+     * next word's low half. The response data starts after the frame header word. */
+    for (i = 0; i < 15; i++) {
+        if (rsp[i] == 0x01000000u) {
+            u32 kcode = rsp[i + 1] & 0xFFFF;
+            return ((~kcode) & DC_BTN_MASK);
+        }
+    }
+    return 0;
+}
+static inline int dc_pressed(u32 mask) { return (dc_pad() & mask) ? 1 : 0; }
 
 #endif /* ROMDEV_DC_H */

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

@@ -36,11 +36,14 @@ export async function buildShC(args) {
   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).
+  // 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 ? [] : ["-O2"]), ...userOpts, "-ffreestanding", "-fno-builtin", "-Wall"];
+  const cc1Options = [...(hasOpt ? [] : ["-O1"]), ...userOpts, "-ffreestanding", "-fno-builtin", "-Wall"];
   const sources = args.sources ?? (args.source != null ? { "main.c": args.source } : {});
   let log = "";