xbintsc 0.3.4 → 0.3.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xbintsc",
-  "version": "0.3.4",
+  "version": "0.3.6",
   "description": "xbintsc - a TypeScript binary compiler (TypeScript -> LLVM IR -> native binary)",
   "type": "module",
   "license": "MIT",

package/runtime/rt_internal.h

@@ -235,9 +235,11 @@ typedef struct xt_try_frame {
  *    `_setjmp(jmp_buf, void *frame)` itself, so the frame must be passed
  *    explicitly -- exactly what its own `setjmp` macro does.
  *
- * The generated IR always emits the two-argument form, because it is already
- * IR and clang will not rewrite it. `_setjmp` (rather than the `setjmp` macro)
- * is used so it pairs with the plain `longjmp` in `xt_throw`. */
+ * The generated IR emits the two-argument form, because it is already IR and
+ * clang will not rewrite it. On Windows ARM64 it names `_setjmpex` (and the
+ * entry stack pointer from `llvm.sponentry`) instead, matching clang's own
+ * lowering there. `_setjmp`/`_setjmpex` (rather than the `setjmp` macro) is
+ * used so it pairs with the plain `longjmp` in `xt_throw`. */
 #if defined(_WIN32) && !defined(__MINGW32__)
 #define xt_try_setjmp(framePtr) _setjmp(((xt_try_frame *)(framePtr))->buf)
 #elif defined(_WIN32) && defined(__aarch64__)

package/runtime/xt_io.c

@@ -5,20 +5,21 @@
  * innermost frame when one is active and otherwise prints + exits. Also holds
  * `print`/`console` output and the Node-like value inspector.
  *
- * The generated IR calls `_setjmp` with two arguments — the jmp_buf and the
- * caller's frame address (`@llvm.frameaddress(0)`) — paired with `longjmp`
- * here. This is exactly what clang lowers a C `_setjmp(buf)` call to on MSVC:
- * on Windows the UCRT `_setjmp` stores that frame in `_JUMP_BUFFER.Frame` and
- * `longjmp` passes it to `RtlUnwind` to run the unwind, so omitting it makes
- * `longjmp` unwind to a bogus target (`STATUS_BAD_FUNCTION_TABLE`,
- * 0xC00000FF). Because the generated call is IR it must pass the frame
- * explicitly; the C runtime (see `xt_try_setjmp`) instead follows whatever
- * the active `<setjmp.h>` declares -- one argument on MSVC (clang injects the
- * frame) and two on MinGW-w64. `_setjmp` is used
- * rather than the exported `setjmp` symbol, whose Windows ABI is an
- * incompatible two-argument routine; on Linux/macOS `_setjmp` takes only the
- * buffer and pairs with `longjmp` (the XSI `_longjmp` does not exist on
- * Windows).
+ * The generated IR saves each frame with a `setjmp`-family call that passes
+ * the frame explicitly — the jmp_buf plus a frame pointer — because the call
+ * is already IR and clang will not rewrite it. On Linux/macOS that is
+ * `_setjmp(buf, frame)`; the extra argument is ignored. On Windows the UCRT
+ * `_setjmp` stores the frame in `_JUMP_BUFFER.Frame` and `longjmp` passes it
+ * to `RtlUnwind` to run the unwind, so omitting it makes `longjmp` unwind to a
+ * bogus target (`STATUS_BAD_FUNCTION_TABLE`, 0xC00000FF). Windows ARM64 has
+ * no `_setjmp` at all: the generated IR uses `_setjmpex(buf, entry-sp)` with
+ * the stack pointer on entry (`@llvm.sponentry`), exactly as clang lowers a C
+ * `setjmp` there. The C runtime (see `xt_try_setjmp`) calls whatever the
+ * active `<setjmp.h>` declares — one argument on MSVC (clang injects the
+ * frame) and two on MinGW-w64. `_setjmp`/`_setjmpex` are used rather than the
+ * exported `setjmp` symbol, whose Windows ABI is an incompatible two-argument
+ * routine; on Linux/macOS `_setjmp` takes only the buffer and pairs with
+ * `longjmp` (the XSI `_longjmp` does not exist on Windows).
  */
 
 #include "rt_internal.h"

package/src/codegen/generator/calls/invocation.ts

@@ -206,6 +206,14 @@ export const invocationCallMethods: InvocationCallMethods = {
           return result;
         }
       }
+      // Modules with no namespace dispatcher (`fs`, `child_process`, ...): lower
+      // `import fs from "node:fs"; fs.readFileSync(...)` through the module's
+      // named exports, exactly like a named import of `readFileSync`.
+      const moduleExports = this.moduleExportsOfSymbol(targetSymbol);
+      if (moduleExports) {
+        const exported = moduleExports[method];
+        if (exported) return this.emitModuleExport(node, exported);
+      }
     }
 
     void BUILTIN_METHODS;

package/src/codegen/generator/context.ts

@@ -15,9 +15,10 @@ import type {
   BuiltinFunction,
   ExtensionModule,
   ModuleExport,
+  ModuleExports,
 } from "../../extensions/registry.js";
 import type { CodegenOptions, FunctionState } from "./state.js";
-import { escapeBytes, isErrorFamily, kindName, utf8Bytes } from "./tables.js";
+import { escapeBytes, isErrorFamily, kindName, requiresSetjmpex, utf8Bytes } from "./tables.js";
 
 export class GeneratorContext {
   readonly binding: BindResult;
@@ -25,10 +26,19 @@ export class GeneratorContext {
   readonly diagnostics: DiagnosticBag;
   readonly builtins: Readonly<Record<string, BuiltinFunction>>;
   readonly modules: Readonly<Record<string, ExtensionModule>>;
+  /** Host the emitted IR targets (the process by default; see `CodegenOptions`). */
+  readonly target: { readonly platform: string; readonly arch: string };
   /** Imported symbol id -> the module binding it refers to. */
   readonly importExports = new Map<number, ModuleExport>();
   /** Imported symbol id -> the namespace it aliases (e.g. `path`). */
   readonly importNamespaces = new Map<number, string>();
+  /**
+   * Imported symbol id -> the named exports of the module it aliases, for
+   * modules that do not expose a runtime namespace dispatcher (`fs`,
+   * `child_process`, `crypto`, ...). Lets `import fs from "node:fs"` lower
+   * `fs.readFileSync(...)` straight to the module's runtime symbol.
+   */
+  readonly importModuleExports = new Map<number, ModuleExports>();
   readonly globals: string[] = [];
   readonly functions: string[] = [];
   readonly strings = new Map<string, { label: string; length: number }>();
@@ -44,6 +54,7 @@ export class GeneratorContext {
     this.binding = bind(sourceFile);
     this.builtins = options.builtins ?? {};
     this.modules = options.modules ?? {};
+    this.target = options.target ?? { platform: process.platform, arch: process.arch };
     this.resolveImports();
   }
 
@@ -61,9 +72,9 @@ export class GeneratorContext {
       if (!module) continue;
       const clause = declaration.importClause;
       if (!clause) continue;
-      if (clause.name && module.namespace) {
+      if (clause.name) {
         const symbol = this.binding.symbolOfDeclaration.get(clause.name);
-        if (symbol) this.importNamespaces.set(symbol.id, module.namespace);
+        if (symbol) this.bindModuleAlias(symbol, module);
       }
       const bindings = clause.namedBindings;
       if (bindings && bindings.kind === SyntaxKind.NamedImports) {
@@ -73,19 +84,37 @@ export class GeneratorContext {
           const symbol = this.binding.symbolOfDeclaration.get(specifier.name);
           if (symbol && exported) this.importExports.set(symbol.id, exported);
         }
-      } else if (bindings && bindings.kind === SyntaxKind.NamespaceImport && module.namespace) {
+      } else if (bindings && bindings.kind === SyntaxKind.NamespaceImport) {
         const symbol = this.binding.symbolOfDeclaration.get(bindings.name);
-        if (symbol) this.importNamespaces.set(symbol.id, module.namespace);
+        if (symbol) this.bindModuleAlias(symbol, module);
       }
     }
   }
 
+  /**
+   * Bind a default/namespace import to either the module's runtime namespace
+   * dispatcher (when it has one) or its named exports (when it does not).
+   */
+  private bindModuleAlias(symbol: SymbolInfo, module: ExtensionModule): void {
+    if (module.namespace) {
+      this.importNamespaces.set(symbol.id, module.namespace);
+    } else if (module.exports) {
+      this.importModuleExports.set(symbol.id, module.exports);
+    }
+  }
+
   /** Namespace name an imported alias refers to, if any. */
   namespaceOfSymbol(symbol: SymbolInfo | undefined): string | undefined {
     if (!symbol || symbol.kind !== SymbolKind.Import) return undefined;
     return this.importNamespaces.get(symbol.id);
   }
 
+  /** Named exports a default/namespace import aliases, if any. */
+  moduleExportsOfSymbol(symbol: SymbolInfo | undefined): ModuleExports | undefined {
+    if (!symbol || symbol.kind !== SymbolKind.Import) return undefined;
+    return this.importModuleExports.get(symbol.id);
+  }
+
   // -- emission primitives -------------------------------------------------
 
   emit(line: string): void {
@@ -101,6 +130,31 @@ export class GeneratorContext {
     return `%r${this.current.reg++}`;
   }
 
+  /**
+   * Emit the `setjmp` that opens a `try` frame and return the register holding
+   * its result. The frame address is always passed explicitly because Windows
+   * `_setjmp` stores it in `_JUMP_BUFFER.Frame` for `longjmp` to unwind to; the
+   * extra argument is ignored by the one-argument `_setjmp` on Linux/macOS.
+   */
+  emitSetjmp(frame: string): string {
+    if (requiresSetjmpex(this.target.platform, this.target.arch)) {
+      // Windows ARM64 has no `_setjmp`; use `_setjmpex`, which expects the
+      // caller's stack pointer on entry (`llvm.sponentry`).
+      this.extraDeclarations.add("declare i8* @llvm.sponentry()");
+      this.extraDeclarations.add("declare i32 @_setjmpex(i8*, i8*) returns_twice");
+      const entry = this.reg();
+      this.emit(`  ${entry} = call i8* @llvm.sponentry()`);
+      const jump = this.reg();
+      this.emit(`  ${jump} = call i32 @_setjmpex(i8* ${frame}, i8* ${entry})`);
+      return jump;
+    }
+    const frameAddress = this.reg();
+    this.emit(`  ${frameAddress} = call i8* @llvm.frameaddress(i32 0)`);
+    const jump = this.reg();
+    this.emit(`  ${jump} = call i32 @_setjmp(i8* ${frame}, i8* ${frameAddress})`);
+    return jump;
+  }
+
   label(prefix: string): string {
     return `${prefix}.${this.current.label++}`;
   }

package/src/codegen/generator/state.ts

@@ -62,6 +62,11 @@ export interface CodegenOptions {
   readonly builtins?: Readonly<Record<string, BuiltinFunction>>;
   /** Importable modules supplied by registered extensions. */
   readonly modules?: Readonly<Record<string, ExtensionModule>>;
+  /**
+   * Host the IR is generated for. xbintsc builds for its own host, so this
+   * defaults to the running process; it is overridable for tests.
+   */
+  readonly target?: { readonly platform: string; readonly arch: string };
 }
 
 export const RUNTIME_DECLARATIONS: readonly string[] = [

package/src/codegen/generator/statements/control-flow.ts

@@ -166,14 +166,7 @@ export const controlFlowStatementMethods: ControlFlowStatementMethods = {
     this.emit(`  ${frame} = call i8* @xt_try_enter()`);
     this.emit(`  store i8* ${frame}, i8** ${frameSlot}`);
     this.emit(`  store i64 0, i64* ${flagSlot}`);
-    // MSVC's `_setjmp` takes the caller's frame address as a second argument
-    // (`_JUMP_BUFFER.Frame`); `longjmp` uses it to run the unwind. clang lowers
-    // a C call to `_setjmp` exactly like this. The extra argument is ignored by
-    // the one-argument `_setjmp` on Linux/macOS.
-    const frameAddress = this.reg();
-    this.emit(`  ${frameAddress} = call i8* @llvm.frameaddress(i32 0)`);
-    const jump = this.reg();
-    this.emit(`  ${jump} = call i32 @_setjmp(i8* ${frame}, i8* ${frameAddress})`);
+    const jump = this.emitSetjmp(frame);
     const isThrow = this.reg();
     this.emit(`  ${isThrow} = icmp ne i32 ${jump}, 0`);
     const exceptionTarget = hasCatch ? catchLabel : exceptionLabel;

package/src/codegen/generator/tables.ts

@@ -9,6 +9,20 @@ import {
   type Node,
 } from "../../ast/nodes.js";
 
+/**
+ * True when a `try` frame must be saved with `_setjmpex` rather than `_setjmp`.
+ *
+ * 64-bit Windows on ARM has no `_setjmp`: both the UCRT and MinGW-w64 declare
+ * `setjmp` as `_setjmpex(buf, sponentry)` there, so the linker expects
+ * `_setjmpex` (with the caller's stack pointer at entry, `llvm.sponentry`,
+ * instead of its frame pointer). clang lowers a C `setjmp` on this target to
+ * exactly that pair. Checked at code-generation time because xbintsc builds for
+ * its own host.
+ */
+export function requiresSetjmpex(platform: string, arch: string): boolean {
+  return platform === "win32" && arch === "arm64";
+}
+
 export const BINARY_RUNTIME: Record<string, string | undefined> = {
   [BinaryOperator.Add]: "xt_add",
   [BinaryOperator.Subtract]: "xt_sub",

package/src/driver/toolchain-download.ts

@@ -65,6 +65,18 @@ export function toolchainDownload(
     };
   }
 
+  if (platform === "win32" && arch === "arm64") {
+    // The llvm-mingw `aarch64` package is the Windows-on-ARM host build; its
+    // clang targets aarch64 by default, so a native Windows ARM64 runner gets
+    // native MinGW-w64 binaries with no MSVC dependency.
+    return {
+      url: `https://github.com/mstorsjo/llvm-mingw/releases/download/${LLVM_MINGW_VERSION}/llvm-mingw-${LLVM_MINGW_VERSION}-ucrt-aarch64.zip`,
+      archive: `llvm-mingw-${LLVM_MINGW_VERSION}-ucrt-aarch64.zip`,
+      kind: "zip",
+      stripComponents: 1,
+    };
+  }
+
   // macOS (and any other host) uses the system SDK; nothing to bundle.
   return undefined;
 }
@@ -104,5 +116,20 @@ export function toolchainSupportLibraries(
       },
     ];
   }
+  if (platform === "linux" && arch === "arm64") {
+    // The aarch64 release build links the same removed `libtinfo.so.5` soname as
+    // the x86_64 one; arm64 packages live in the Ubuntu ports archive.
+    return [
+      {
+        urls: [
+          "https://ports.ubuntu.com/ubuntu-ports/pool/main/n/ncurses/libtinfo5_6.1-1ubuntu1.18.04.1_arm64.deb",
+          "http://ports.ubuntu.com/ubuntu-ports/pool/main/n/ncurses/libtinfo5_6.1-1ubuntu1.18.04.1_arm64.deb",
+        ],
+        archive: "libtinfo5.deb",
+        member: "lib/aarch64-linux-gnu/libtinfo.so.5.9",
+        dest: "libtinfo.so.5",
+      },
+    ];
+  }
   return [];
 }