romdevtools 0.44.0 → 0.56.1

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,12 @@ 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." },
+  },
 };
 
 /**
@@ -115,6 +121,8 @@ const PLATFORM_DEFAULT_LANGUAGE = {
   spc700:     "asm",
   pce:        "c",
   msx:        "c",
+  ps1:        "c",
+  n64:        "c",
 };
 
 /**
@@ -467,6 +475,33 @@ 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 === "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;
+}

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 } : {}) };
+}