romdevtools 0.44.0 → 0.70.0

package/src/platforms/n64/lib/c/n64.h

@@ -0,0 +1,68 @@
+/* n64.h — N64 (R4300) helper lib with a software 3D pipeline, for romdev.
+ *
+ * The N64 is a 3D machine; this is a real software 3D engine (identical fixed-point
+ * math to the PS1 lib, so games port directly) with an N64 framebuffer backend: a
+ * 320x240 16-bit (RGBA5551) framebuffer in RDRAM that the Video Interface scans out,
+ * and a software triangle rasterizer (the RDP is far more complex; direct FB writes
+ * are portable + reliable). Big-endian.
+ *
+ * Build: build({ platform:"n64", language:"c" }) → a self-booting .z64 (our clean
+ * IPL3 DMAs the game to RDRAM and jumps in). main() loops forever.
+ */
+#ifndef ROMDEV_N64_H
+#define ROMDEV_N64_H
+
+typedef int fix; /* 16.16 */
+#define FIX(n)   ((fix)((n) << 16))
+#define FIXF(f)  ((fix)((f) * 65536.0f))
+#define FMUL(a,b) ((fix)(((long long)(a) * (b)) >> 16))
+#define FDIV(a,b) ((fix)(((long long)(a) << 16) / (b)))
+#define F2I(a)   ((a) >> 16)
+
+typedef struct { fix x, y, z; } Vec3;
+
+#define SCREEN_W 320
+#define SCREEN_H 240
+
+/* RGBA5551 color (the VI framebuffer format): 5-5-5-1. */
+#define RGB(r,g,b) ((unsigned short)((((r)>>3)<<11)|(((g)>>3)<<6)|(((b)>>3)<<1)|1))
+
+/* controller digital buttons (active-high after read). */
+#define PAD_A      0x8000
+#define PAD_B      0x4000
+#define PAD_Z      0x2000
+#define PAD_START  0x1000
+#define PAD_UP     0x0800
+#define PAD_DOWN   0x0400
+#define PAD_LEFT   0x0200
+#define PAD_RIGHT  0x0100
+#define PAD_L      0x0020
+#define PAD_R      0x0010
+
+/* ── framebuffer / 2D ── */
+void n64_init(void);
+void n64_clear(unsigned short col);
+void n64_rect(int x, int y, int w, int h, unsigned short col);
+void n64_tri2d(int x0,int y0,int x1,int y1,int x2,int y2,unsigned short col);
+void n64_flip(void);          /* present the framebuffer (swap + wait vblank) */
+
+/* ── input ── */
+unsigned int n64_pad(void);
+int n64_pressed(unsigned int mask);
+
+/* ── 3D pipeline (same API as the PS1 lib) ── */
+void n64_camera(fix ex, fix ey, fix ez, fix yaw, fix pitch);
+void n64_model(fix tx, fix ty, fix tz, fix yaw);
+void n64_tri3d(Vec3 a, Vec3 b, Vec3 c, unsigned short col);
+void n64_quad3d(Vec3 a, Vec3 b, Vec3 c, Vec3 d, unsigned short col);
+void n64_tri3d_nc(Vec3 a, Vec3 b, Vec3 c, unsigned short col);
+void n64_quad3d_nc(Vec3 a, Vec3 b, Vec3 c, Vec3 d, unsigned short col);
+
+/* ── misc ── */
+fix n64_sin(fix a);
+fix n64_cos(fix a);
+unsigned int n64_rand(void);
+void n64_srand(unsigned int seed);
+void n64_number(int x, int y, unsigned int value, unsigned short col);
+
+#endif

package/src/platforms/ps1/lib/c/psx.c

@@ -0,0 +1,200 @@
+/* psx.c — PS1 helpers + software 3D pipeline (see psx.h). */
+#include "psx.h"
+
+/* ── GPU bring-up ── */
+void psx_init(void)
+{
+    GP1 = 0x00000000u;                     /* reset */
+    GP1 = 0x08000001u;                     /* display mode 320x240 NTSC 15bpp */
+    GP1 = 0x03000000u;                     /* display enable (arg 0 = on) */
+    GP1 = 0x05000000u;                     /* display start (0,0) */
+    GP1 = 0x06000000u | (0x260u | ((0x260u + 320u*8u) << 12));
+    GP1 = 0x07000000u | (16u | ((16u + 240u) << 10));
+    GP0 = 0xE3000000u;                      /* draw area TL (0,0) */
+    GP0 = 0xE4000000u | (319u) | (239u << 10); /* draw area BR */
+    GP0 = 0xE5000000u;                      /* draw offset (0,0) */
+}
+
+void psx_clear(unsigned int bgr) {
+    /* GP0 0x02 = fast fill of a VRAM rectangle (ignores draw area, no blending). */
+    GP0 = 0x02000000u | (bgr & 0x00FFFFFFu);
+    GP0 = 0; /* (x,y) = (0,0) */
+    GP0 = (240u << 16) | 320u; /* (h,w) */
+}
+
+void psx_rect(int x, int y, int w, int h, unsigned int bgr)
+{
+    /* GP0 0x60 = monochrome variable-size RECTANGLE: color, (y,x) corner, (h,w) size. */
+    GP0 = 0x60000000u | (bgr & 0x00FFFFFFu);
+    GP0 = (((unsigned)y & 0xFFFF) << 16) | ((unsigned)x & 0xFFFF);
+    GP0 = (((unsigned)h & 0xFFFF) << 16) | ((unsigned)w & 0xFFFF);
+}
+
+void psx_tri2d(int x0,int y0,int x1,int y1,int x2,int y2,unsigned int bgr)
+{
+    GP0 = 0x20000000u | (bgr & 0x00FFFFFFu); /* flat opaque triangle */
+    GP0 = ((unsigned)(y0)<<16)|((unsigned)(x0)&0xFFFF);
+    GP0 = ((unsigned)(y1)<<16)|((unsigned)(x1)&0xFFFF);
+    GP0 = ((unsigned)(y2)<<16)|((unsigned)(x2)&0xFFFF);
+}
+
+void psx_vsync(void) { volatile int i; for (i = 0; i < 60000; i++) { } }
+
+/* ── input: read controller port 0 via the SIO (the way real PS1 homebrew does;
+   the HLE core feeds host input into this SIO emulation). The digital pad reply
+   is 0x5A then two button bytes (active-LOW). We return active-HIGH. ── */
+#define SIO_DATA (*(volatile unsigned char*)0x1F801040)
+#define SIO_STAT (*(volatile unsigned short*)0x1F801044)
+#define SIO_CTRL (*(volatile unsigned short*)0x1F80104A)
+#define SIO_BAUD (*(volatile unsigned short*)0x1F80104E)
+#define SIO_MODE (*(volatile unsigned short*)0x1F801048)
+
+static unsigned char sio_xfer(unsigned char out) {
+    volatile int t;
+    while (!(SIO_STAT & 0x4)) { } /* TX ready */
+    SIO_DATA = out;
+    for (t = 0; t < 200; t++) { } /* settle */
+    while (!(SIO_STAT & 0x2)) { } /* RX ready */
+    return SIO_DATA;
+}
+
+unsigned int psx_pad(void) {
+    unsigned char b0, b1; volatile int t;
+    /* init SIO for controller (8N1, ~250kbps) */
+    SIO_MODE = 0x000D; SIO_BAUD = 0x0088; SIO_CTRL = 0x1003; /* TX/RX en + DTR + port0 */
+    sio_xfer(0x01);          /* address: controller */
+    if (sio_xfer(0x42) == 0xFF) { SIO_CTRL = 0; return 0; } /* request data; 0xFF=no pad */
+    sio_xfer(0x00);          /* discard 0x5A */
+    b0 = sio_xfer(0x00);     /* buttons lo (active-low) */
+    b1 = sio_xfer(0x00);     /* buttons hi (active-low) */
+    SIO_CTRL = 0;            /* deselect */
+    for (t = 0; t < 100; t++) { }
+    return (~((unsigned int)b0 | ((unsigned int)b1 << 8))) & 0xFFFF; /* → active-high */
+}
+int psx_pressed(unsigned int mask) { return (psx_pad() & mask) ? 1 : 0; }
+
+/* ── trig: 256-entry quarter→full sine, arg in "binary angle" 16.16 where
+   FIX(256) = one full turn. ── */
+static const short SINTAB[64] = {
+0,804,1608,2410,3212,4011,4808,5602,6393,7179,7962,8739,9512,10278,11039,11793,
+12539,13279,14010,14732,15446,16151,16846,17530,18204,18868,19519,20159,20787,21403,
+22005,22594,23170,23731,24279,24811,25329,25832,26319,26790,27245,27683,28105,28510,
+28898,29268,29621,29956,30273,30571,30852,31113,31356,31580,31785,31971,32137,32285,
+32412,32521,32609,32678,32728,32757 };
+static fix sin_lut(int idx) { /* idx 0..255 → 16.16 sine */
+    int q = (idx >> 6) & 3, p = idx & 63; int v;
+    if (q == 0) v = SINTAB[p];
+    else if (q == 1) v = SINTAB[63 - p];
+    else if (q == 2) v = -SINTAB[p];
+    else v = -SINTAB[63 - p];
+    return ((fix)v << 16) / 32768; /* normalize to 16.16 (~1.0 peak) */
+}
+fix psx_sin(fix a) { return sin_lut((F2I(a)) & 255); }
+fix psx_cos(fix a) { return sin_lut((F2I(a) + 64) & 255); }
+
+/* ── camera + model state ── */
+static fix cam_x, cam_y, cam_z, cam_cy, cam_sy, cam_cp, cam_sp;
+static fix mdl_x, mdl_y, mdl_z, mdl_cy, mdl_sy;
+
+void psx_camera(fix ex, fix ey, fix ez, fix yaw, fix pitch)
+{
+    cam_x = ex; cam_y = ey; cam_z = ez;
+    cam_cy = psx_cos(yaw); cam_sy = psx_sin(yaw);
+    cam_cp = psx_cos(pitch); cam_sp = psx_sin(pitch);
+}
+void psx_model(fix tx, fix ty, fix tz, fix yaw)
+{
+    mdl_x = tx; mdl_y = ty; mdl_z = tz;
+    mdl_cy = psx_cos(yaw); mdl_sy = psx_sin(yaw);
+}
+
+/* model-space vertex → camera space (16.16). */
+static Vec3 to_cam(Vec3 v)
+{
+    /* model yaw (around Y) + translate */
+    fix mx = FMUL(v.x, mdl_cy) + FMUL(v.z, mdl_sy);
+    fix mz = -FMUL(v.x, mdl_sy) + FMUL(v.z, mdl_cy);
+    fix wx = mx + mdl_x, wy = v.y + mdl_y, wz = mz + mdl_z;
+    /* world → relative to camera */
+    fix rx = wx - cam_x, ry = wy - cam_y, rz = wz - cam_z;
+    /* camera yaw */
+    fix cx = FMUL(rx, cam_cy) - FMUL(rz, cam_sy);
+    fix cz = FMUL(rx, cam_sy) + FMUL(rz, cam_cy);
+    /* camera pitch */
+    fix cy = FMUL(ry, cam_cp) - FMUL(cz, cam_sp);
+    fix cz2 = FMUL(ry, cam_sp) + FMUL(cz, cam_cp);
+    Vec3 o; o.x = cx; o.y = cy; o.z = cz2; return o;
+}
+
+/* perspective project camera-space → screen. returns 0 if behind/near plane. */
+#define NEAR FIXF(0.5f)
+#define FOV  FIX(220)   /* focal length in pixels-ish */
+static int project(Vec3 c, int *sx, int *sy)
+{
+    if (c.z <= NEAR) return 0;
+    fix sxf = FDIV(FMUL(c.x, FOV), c.z);
+    fix syf = FDIV(FMUL(c.y, FOV), c.z);
+    *sx = (SCREEN_W / 2) + F2I(sxf);
+    *sy = (SCREEN_H / 2) - F2I(syf);
+    return 1;
+}
+
+fix psx_depth3(Vec3 a, Vec3 b, Vec3 c)
+{ Vec3 ca=to_cam(a), cb=to_cam(b), cc=to_cam(c); return (ca.z + cb.z + cc.z) / 3; }
+fix psx_depth4(Vec3 a, Vec3 b, Vec3 c, Vec3 d)
+{ Vec3 ca=to_cam(a),cb=to_cam(b),cc=to_cam(c),cd=to_cam(d); return (ca.z+cb.z+cc.z+cd.z)/4; }
+
+void psx_tri3d(Vec3 a, Vec3 b, Vec3 c, unsigned int bgr)
+{
+    Vec3 ca=to_cam(a), cb=to_cam(b), cc=to_cam(c);
+    int x0,y0,x1,y1,x2,y2;
+    if (!project(ca,&x0,&y0) || !project(cb,&x1,&y1) || !project(cc,&x2,&y2)) return;
+    /* back-face cull (screen-space cross product) */
+    int cross = (x1-x0)*(y2-y0) - (x2-x0)*(y1-y0);
+    if (cross <= 0) return;
+    psx_tri2d(x0,y0,x1,y1,x2,y2,bgr);
+}
+
+void psx_tri3d_nc(Vec3 a, Vec3 b, Vec3 c, unsigned int bgr)
+{
+    Vec3 ca=to_cam(a), cb=to_cam(b), cc=to_cam(c);
+    int x0,y0,x1,y1,x2,y2;
+    if (!project(ca,&x0,&y0) || !project(cb,&x1,&y1) || !project(cc,&x2,&y2)) return;
+    psx_tri2d(x0,y0,x1,y1,x2,y2,bgr); /* no back-face cull */
+}
+void psx_quad3d_nc(Vec3 a, Vec3 b, Vec3 c, Vec3 d, unsigned int bgr)
+{ psx_tri3d_nc(a,b,c,bgr); psx_tri3d_nc(a,c,d,bgr); }
+
+void psx_quad3d(Vec3 a, Vec3 b, Vec3 c, Vec3 d, unsigned int bgr)
+{
+    /* split into two tris; both share the back-face test inside */
+    psx_tri3d(a,b,c,bgr);
+    psx_tri3d(a,c,d,bgr);
+}
+
+/* ── RNG (xorshift) ── */
+static unsigned int rng_state = 0x12345678u;
+void psx_srand(unsigned int s) { rng_state = s ? s : 1; }
+unsigned int psx_rand(void)
+{ unsigned int x = rng_state; x ^= x << 13; x ^= x >> 17; x ^= x << 5; return rng_state = x; }
+
+/* ── blocky decimal number (3x5 cells scaled to 8x10), for HUD/score ── */
+static const unsigned char DIGITS[10][5] = {
+ {0x7,0x5,0x5,0x5,0x7},{0x2,0x6,0x2,0x2,0x7},{0x7,0x1,0x7,0x4,0x7},{0x7,0x1,0x3,0x1,0x7},
+ {0x5,0x5,0x7,0x1,0x1},{0x7,0x4,0x7,0x1,0x7},{0x7,0x4,0x7,0x5,0x7},{0x7,0x1,0x1,0x1,0x1},
+ {0x7,0x5,0x7,0x5,0x7},{0x7,0x5,0x7,0x1,0x7} };
+static void draw_digit(int x, int y, int d, unsigned int bgr)
+{
+    int r, c;
+    for (r = 0; r < 5; r++)
+        for (c = 0; c < 3; c++)
+            if (DIGITS[d][r] & (1 << (2 - c)))
+                psx_rect(x + c*3, y + r*3, 3, 3, bgr);
+}
+void psx_number(int x, int y, unsigned int value, unsigned int bgr)
+{
+    char buf[10]; int n = 0, i;
+    if (value == 0) buf[n++] = 0;
+    while (value && n < 10) { buf[n++] = value % 10; value /= 10; }
+    for (i = 0; i < n; i++) draw_digit(x + (n-1-i)*12, y, buf[i], bgr);
+}

package/src/platforms/ps1/lib/c/psx.h

@@ -0,0 +1,83 @@
+/* psx.h — PS1 (R3000) helper lib with a software 3D pipeline, for romdev.
+ *
+ * A minimal-but-real 3D engine + GPU/pad helpers — what the PlayStation is FOR.
+ * Fixed-point (16.16) vector math, a camera (position + yaw/pitch), perspective
+ * projection, and painter-sorted flat-shaded triangles/quads drawn through the
+ * GPU. No GTE/SDK dependency — pure C math, so the same pipeline ports to N64.
+ *
+ * Build: build({ platform:"ps1", language:"c" }). Output is a PS-EXE the HLE BIOS
+ * loads at 0x80010000; main() loops forever. Color is BGR (GPU native); RGB() packs.
+ *
+ * 2D is also available (psx_rect / psx_sprite) for HUDs + the puzzle game.
+ */
+#ifndef ROMDEV_PSX_H
+#define ROMDEV_PSX_H
+
+/* ── fixed-point (16.16) ── */
+typedef int fix; /* 16.16 */
+#define FIX(n)   ((fix)((n) << 16))
+#define FIXF(f)  ((fix)((f) * 65536.0f))
+#define FMUL(a,b) ((fix)(((long long)(a) * (b)) >> 16))
+#define FDIV(a,b) ((fix)(((long long)(a) << 16) / (b)))
+#define F2I(a)   ((a) >> 16)
+
+typedef struct { fix x, y, z; } Vec3;
+
+/* ── GPU ports ── */
+#define GP0 (*(volatile unsigned int*)0x1F801810)
+#define GP1 (*(volatile unsigned int*)0x1F801814)
+
+/* ── pad (digital, active-HIGH: bit set = pressed) ── */
+#define PAD_SELECT   (1u<<0)
+#define PAD_START    (1u<<3)
+#define PAD_UP       (1u<<4)
+#define PAD_RIGHT    (1u<<5)
+#define PAD_DOWN     (1u<<6)
+#define PAD_LEFT     (1u<<7)
+#define PAD_L1       (1u<<10)
+#define PAD_R1       (1u<<11)
+#define PAD_TRIANGLE (1u<<12)
+#define PAD_CIRCLE   (1u<<13)
+#define PAD_CROSS    (1u<<14)
+#define PAD_SQUARE   (1u<<15)
+
+#define RGB(r,g,b) (((unsigned int)(b)<<16)|((unsigned int)(g)<<8)|(unsigned int)(r))
+#define SCREEN_W 320
+#define SCREEN_H 240
+
+/* ── GPU / 2D ── */
+void psx_init(void);
+void psx_clear(unsigned int bgr);
+void psx_rect(int x, int y, int w, int h, unsigned int bgr);
+void psx_tri2d(int x0,int y0,int x1,int y1,int x2,int y2,unsigned int bgr);
+void psx_vsync(void);
+
+/* ── input ── */
+unsigned int psx_pad(void);          /* current buttons (active-high) */
+int psx_pressed(unsigned int mask);  /* 1 if any of mask is held */
+
+/* ── 3D pipeline ── */
+/* camera: eye position + yaw (around Y) + pitch (around X), all 16.16. */
+void psx_camera(fix ex, fix ey, fix ez, fix yaw, fix pitch);
+/* set a model translation+rotation applied before the camera (simple: yaw only). */
+void psx_model(fix tx, fix ty, fix tz, fix yaw);
+/* draw a flat triangle of 3 model-space vertices; projected + back-face/near
+   culled. Z-buffered by draw order (call back-to-front, or use psx_sort). */
+void psx_tri3d(Vec3 a, Vec3 b, Vec3 c, unsigned int bgr);
+void psx_quad3d(Vec3 a, Vec3 b, Vec3 c, Vec3 d, unsigned int bgr);
+/* no-back-face-cull variants — for ground planes / floors (ambiguous winding). */
+void psx_tri3d_nc(Vec3 a, Vec3 b, Vec3 c, unsigned int bgr);
+void psx_quad3d_nc(Vec3 a, Vec3 b, Vec3 c, Vec3 d, unsigned int bgr);
+/* returns the average camera-space Z of 3/4 model verts (for manual sorting). */
+fix psx_depth3(Vec3 a, Vec3 b, Vec3 c);
+fix psx_depth4(Vec3 a, Vec3 b, Vec3 c, Vec3 d);
+
+/* ── misc ── */
+fix psx_sin(fix a);   /* a in 16.16 turns? no — a in fix radians-ish (see psx.c) */
+fix psx_cos(fix a);
+unsigned int psx_rand(void);
+void psx_srand(unsigned int seed);
+/* draw a small decimal number (HUD/score), 8x8 blocky digits. */
+void psx_number(int x, int y, unsigned int value, unsigned int bgr);
+
+#endif

package/src/toolchains/index.js

@@ -85,6 +85,15 @@ const LANGUAGE_TOOLCHAIN = {
     c:   { toolchain: "sdcc", available: true, note: "C for MSX via SDCC's z80 port. Cartridge ROM with the 'AB' header + INIT pointer at $4000; boots on C-BIOS (open MSX BIOS). MSX2 by default (runs MSX1 carts too)." },
     asm: { toolchain: "sdcc", available: true },
   },
+  ps1: {
+    c: { toolchain: "mips-elf-gcc", available: true, note: "C for PS1 via gcc 14.2.0 + binutils + newlib (mips-elf, little-endian R3000), compiled to WASM. The bare path: a minimal crt0 sets the stack + clears .bss + calls main(); the output is a PS-EXE the HLE BIOS loads (load at 0x80010000). No SDK (PSn00bSDK) yet — bring your own GPU/SPU register writes, or use this for logic. write to GPU ports 0x1F801810/0x1F801814." },
+  },
+  n64: {
+    c: { toolchain: "mips-elf-gcc", available: true, note: "C for N64 via gcc 14.2.0 + binutils + newlib (mips-elf, big-endian R4300), compiled to WASM. Bare path: minimal crt0 (stack + .bss + main()) → flat code image at 0x80000400. NOTE: a fully bootable N64 ROM needs the IPL3 bootcode + a libdragon-style header (libdragon SDK forthcoming) — this path exercises the toolchain + is the basis for the SDK." },
+  },
+  dreamcast: {
+    c: { toolchain: "sh-elf-gcc", available: true, note: "C for Dreamcast via gcc 14.2.0 + binutils + newlib (sh-elf, little-endian SH-4, m4-single-only FP), compiled to WASM. Bare path: a minimal crt0 sets the stack + clears .bss + calls main(); the output is an ELF that Flycast's reios HLE BIOS boots DIRECTLY (no GD-ROM/CDI image, no firmware). No KallistiOS yet — bring up the PowerVR2 framebuffer yourself: program FB_R_CTRL/FB_R_SIZE/FB_R_SOF1 + SPG for 640x480 RGB565 at VRAM 0xA5000000, then write pixels (see the dc.h helper). With flycast_emulate_framebuffer on, a plain pixel-writing program presents — no TA list needed." },
+  },
 };
 
 /**
@@ -115,6 +124,9 @@ const PLATFORM_DEFAULT_LANGUAGE = {
   spc700:     "asm",
   pce:        "c",
   msx:        "c",
+  ps1:        "c",
+  n64:        "c",
+  dreamcast:  "c",
 };
 
 /**
@@ -467,6 +479,59 @@ export async function buildForPlatform(args) {
     // below (SDCC_PORTS["gb"] = sm83 port).
   }
 
+  if (args.platform === "ps1" || args.platform === "n64") {
+    // MIPS C: the bare gcc+newlib+libgcc path (no SDK yet). cc1→as→ld→objcopy
+    // through the mips-elf-gcc WASM toolchain; PS1 (R3000, little-endian) wraps the
+    // image in a PS-EXE the HLE BIOS loads; N64 (R4300, big-endian) emits a flat
+    // .bin (real N64 boot needs libdragon — forthcoming). language defaults to "c".
+    const { buildMipsC } = await import("./mips-c/mips-c.js");
+    const r = await buildMipsC({
+      source: args.source,
+      sources: args.sources,
+      headers: args.includes,
+      platform: args.platform,
+      cc1Options: args.options,
+    });
+    return {
+      ok: r.ok,
+      binary: r.binary,
+      listing: "",
+      symbols: r.symbols ?? "",
+      log: r.log,
+      issues: parseBuildLog(r.log),
+      exitCode: r.exitCode,
+      toolchain: "mips-elf-gcc",
+      stage: r.stage,
+      ...(r.crash ? { crash: r.crash } : {}),
+    };
+  }
+
+  if (args.platform === "dreamcast") {
+    // Dreamcast SH-4 C: the bare gcc+newlib+libgcc path through the sh-elf-gcc WASM
+    // toolchain (cc1→as→ld). The output is an ELF that Flycast's reios HLE BIOS boots
+    // directly (no GD-ROM/CDI image). Bring up the PowerVR2 framebuffer yourself (see
+    // the dc.h helper); language defaults to "c".
+    const { buildShC } = await import("./sh-c/sh-c.js");
+    const r = await buildShC({
+      source: args.source,
+      sources: args.sources,
+      headers: args.includes,
+      cc1Options: args.options,
+    });
+    return {
+      ok: r.ok,
+      binary: r.binary,
+      listing: "",
+      symbols: r.symbols ?? "",
+      log: r.log,
+      issues: parseBuildLog(r.log),
+      exitCode: r.exitCode,
+      toolchain: "sh-elf-gcc",
+      stage: r.stage,
+      ...(r.crash ? { crash: r.crash } : {}),
+    };
+  }
+
   if (args.platform === "gba") {
     // R24 + R28: language:"c" routes through the arm-none-eabi gcc +
     // binutils WASM toolchain (cc1-arm → as → ld → objcopy). Three

package/src/toolchains/mips-c/lib/n64-crt0.s

@@ -0,0 +1,21 @@
+/* Minimal N64 (R4300) crt0 — bare stack + .bss clear + main(). NOTE: a real
+   bootable N64 ROM needs the IPL3 bootcode + a libdragon-style header; this
+   minimal crt0 exercises the mips-elf toolchain (big-endian) and produces a flat
+   code image. Full N64 boot = libdragon (STAGE 3). */
+    .set noreorder
+    .section .text.start, "ax"
+    .global _start
+_start:
+    la      $sp, __sp_top
+    la      $t0, __bss_start
+    la      $t1, __bss_end
+1:  beq     $t0, $t1, 2f
+    nop
+    sw      $zero, 0($t0)
+    addiu   $t0, $t0, 4
+    b       1b
+    nop
+2:  jal     main
+    nop
+3:  b       3b
+    nop

package/src/toolchains/mips-c/lib/n64-ipl3.s

@@ -0,0 +1,30 @@
+/* Minimal N64 IPL3 (clean-room): runs in SP DMEM at 0xA4000040 after the HLE/real
+   PIF boot copies ROM[0x40..0xFFF] here. Its job: PI-DMA the game from cart
+   (0xB0001000) to RDRAM (0x80000400), then jump to the game entry. Assembled to
+   the 0xFC0-byte IPL3 slot. */
+    .set noreorder
+    .set noat
+    .global ipl3_start
+ipl3_start:
+    /* PI DMA: copy GAME_SIZE bytes from cart 0x10001000 to RDRAM 0x00000400 */
+    lui   $t0, 0xA460             /* PI base 0xA4600000 */
+    /* PI_DRAM_ADDR = 0x00000400 (RDRAM dest, phys) */
+    li    $t1, 0x00000400
+    sw    $t1, 0x00($t0)          /* PI_DRAM_ADDR_REG */
+    /* PI_CART_ADDR = 0x10001000 (cart src, phys; game starts at ROM 0x1000) */
+    lui   $t1, 0x1000
+    ori   $t1, $t1, 0x1000
+    sw    $t1, 0x04($t0)          /* PI_CART_ADDR_REG */
+    /* PI_WR_LEN = GAME_SIZE-1 (write to RDRAM) */
+    li    $t1, (GAME_SIZE - 1)
+    sw    $t1, 0x0C($t0)          /* PI_WR_LEN_REG starts the DMA */
+1:  /* wait for PI not busy (PI_STATUS bit0/1) */
+    lw    $t2, 0x10($t0)
+    andi  $t2, $t2, 0x3
+    bnez  $t2, 1b
+    nop
+    /* jump to the game entry in RDRAM (cached kseg0) */
+    lui   $t3, 0x8000
+    ori   $t3, $t3, 0x0400
+    jr    $t3
+    nop

package/src/toolchains/mips-c/lib/n64.ld

@@ -0,0 +1,15 @@
+OUTPUT_FORMAT("elf32-bigmips")
+OUTPUT_ARCH(mips)
+ENTRY(_start)
+MEMORY { ram (rwx) : ORIGIN = 0x80000400, LENGTH = 0x3FFC00 }
+SECTIONS {
+  .text : { *(.text.start) *(.text*) *(.rodata*) } > ram
+  .data : { *(.data*) *(.sdata*) *(.lit8) *(.lit4) *(.scommon) } > ram
+  . = ALIGN(8);
+  __bss_start = .;
+  .bss : { *(.bss*) *(.sbss*) *(.scommon) *(COMMON) } > ram
+  . = ALIGN(8);
+  __bss_end = .;
+  __sp_top = 0x803FFFF0;
+  /DISCARD/ : { *(.MIPS.abiflags) *(.reginfo) *(.comment) }
+}

package/src/toolchains/mips-c/lib/ps1-crt0.s

@@ -0,0 +1,20 @@
+/* Minimal PS1 (R3000) crt0 — sets the stack, clears .bss, calls main(), loops.
+   The PS-EXE header (set by the JS wrapper) points the BIOS entry here. */
+    .set noreorder
+    .section .text.start, "ax"
+    .global _start
+_start:
+    la      $sp, __sp_top          /* stack top */
+    /* zero .bss */
+    la      $t0, __bss_start
+    la      $t1, __bss_end
+1:  beq     $t0, $t1, 2f
+    nop
+    sw      $zero, 0($t0)
+    addiu   $t0, $t0, 4
+    b       1b
+    nop
+2:  jal     main
+    nop
+3:  b       3b                      /* main returned — hang */
+    nop

package/src/toolchains/mips-c/lib/ps1.ld

@@ -0,0 +1,15 @@
+OUTPUT_FORMAT("elf32-littlemips")
+OUTPUT_ARCH(mips)
+ENTRY(_start)
+MEMORY { ram (rwx) : ORIGIN = 0x80010000, LENGTH = 0x1F0000 }
+SECTIONS {
+  .text : { *(.text.start) *(.text*) *(.rodata*) } > ram
+  .data : { *(.data*) *(.sdata*) *(.lit8) *(.lit4) *(.scommon) } > ram
+  . = ALIGN(4);
+  __bss_start = .;
+  .bss : { *(.bss*) *(.sbss*) *(.scommon) *(COMMON) } > ram
+  . = ALIGN(4);
+  __bss_end = .;
+  __sp_top = 0x801FFFF0;
+  /DISCARD/ : { *(.MIPS.abiflags) *(.reginfo) *(.comment) }
+}

package/src/toolchains/mips-c/lib/softint.c

@@ -0,0 +1,37 @@
+/* softint.c — the few libgcc helpers a fixed-point game needs, in plain C, so the
+   build doesn't depend on an endian-specific libgcc.a. Compiled per-build with the
+   target endian. Currently: 64-bit signed/unsigned divide + modulo (__divdi3 etc).
+   MIPS has native 32x32->64 multiply, so __muldi3 isn't needed. */
+typedef long long DItype;
+typedef unsigned long long UDItype;
+
+static UDItype udivmod64(UDItype num, UDItype den, UDItype *rem) {
+  UDItype quot = 0, qbit = 1;
+  if (den == 0) { if (rem) *rem = 0; return 0; }
+  /* normalize: shift den up until > num or top bit set */
+  while ((DItype)den >= 0) { den <<= 1; qbit <<= 1; }
+  while (qbit) {
+    if (den <= num) { num -= den; quot += qbit; }
+    den >>= 1; qbit >>= 1;
+  }
+  if (rem) *rem = num;
+  return quot;
+}
+
+UDItype __udivdi3(UDItype a, UDItype b) { return udivmod64(a, b, 0); }
+UDItype __umoddi3(UDItype a, UDItype b) { UDItype r; udivmod64(a, b, &r); return r; }
+
+DItype __divdi3(DItype a, DItype b) {
+  int neg = 0; UDItype ua, ub, q;
+  if (a < 0) { a = -a; neg ^= 1; } if (b < 0) { b = -b; neg ^= 1; }
+  ua = (UDItype)a; ub = (UDItype)b;
+  q = udivmod64(ua, ub, 0);
+  return neg ? -(DItype)q : (DItype)q;
+}
+DItype __moddi3(DItype a, DItype b) {
+  int neg = 0; UDItype ua, ub, r;
+  if (a < 0) { a = -a; neg = 1; } if (b < 0) { b = -b; }
+  ua = (UDItype)a; ub = (UDItype)b;
+  udivmod64(ua, ub, &r);
+  return neg ? -(DItype)r : (DItype)r;
+}