xbintsc 0.3.81 → 0.3.87

package/src/codegen/generator/expressions/operators.ts

@@ -7,15 +7,34 @@ import {
   BinaryOperator,
   PostfixUnaryOperator,
   PrefixUnaryOperator,
+  SyntaxKind,
   type BinaryExpression,
   type ConditionalExpression,
+  type Expression,
+  type Identifier,
   type PostfixUnaryExpression,
   type PrefixUnaryExpression,
 } from "../../../ast/nodes.js";
 import { i64, numberLiteral, XT_UNDEFINED } from "../../values.js";
-import { BINARY_RUNTIME, isAssignmentOperator } from "../tables.js";
+import { BINARY_RUNTIME, BUILTIN_INSTANCEOF, isAssignmentOperator } from "../tables.js";
 import type { Generator } from "../generator.js";
 
+/** True for an expression whose value is known to be a string. */
+function isStringLike(node: Expression): boolean {
+  return node.kind === SyntaxKind.StringLiteral || node.kind === SyntaxKind.NoSubstitutionTemplateLiteral;
+}
+
+/**
+ * The built-in constructor a right-hand `instanceof` operand names, if any.
+ * A user binding with the same name shadows it.
+ */
+function builtinInstanceofId(generator: Generator, expression: Expression): number | undefined {
+  if (expression.kind !== SyntaxKind.Identifier) return undefined;
+  const identifier = expression as Identifier;
+  if (generator.binding.symbolOfIdentifier.get(identifier)) return undefined;
+  return BUILTIN_INSTANCEOF[identifier.text];
+}
+
 export interface OperatorExpressionMethods {
   emitBinaryOrAssignment(this: Generator, node: BinaryExpression): string;
   emitShortCircuit(this: Generator, node: BinaryExpression, kind: "and" | "or" | "nullish"): string;
@@ -44,6 +63,17 @@ export const operatorExpressionMethods: OperatorExpressionMethods = {
       default:
         break;
     }
+    // `x instanceof Array` and friends: the built-in constructor is not a
+    // first-class value, so compare by the value's runtime kind instead.
+    if (operator === BinaryOperator.InstanceOf) {
+      const builtin = builtinInstanceofId(this, node.right);
+      if (builtin !== undefined) {
+        const leftValue = this.emitExpression(node.left);
+        const result = this.reg();
+        this.emit(`  ${result} = call i64 @xt_instance_of_builtin(i64 ${leftValue}, i32 ${builtin})`);
+        return result;
+      }
+    }
     const left = this.emitExpression(node.left);
     const right = this.emitExpression(node.right);
     const runtime = BINARY_RUNTIME[operator];
@@ -51,9 +81,10 @@ export const operatorExpressionMethods: OperatorExpressionMethods = {
       this.unsupported(node, `operator '${operator}'`);
       return i64(XT_UNDEFINED);
     }
-    const result = this.reg();
-    this.emit(`  ${result} = call i64 @${runtime}(i64 ${left}, i64 ${right})`);
-    return result;
+    // `+` concatenates when either side is known to be a string; skip the
+    // numeric tag checks for that shape and call the runtime directly.
+    const knownStringConcat = operator === "+" && (isStringLike(node.left) || isStringLike(node.right));
+    return this.emitBinaryOperation(left, right, operator, runtime, !knownStringConcat);
   },
 
   emitShortCircuit(node: BinaryExpression, kind: "and" | "or" | "nullish"): string {
@@ -159,8 +190,12 @@ export const operatorExpressionMethods: OperatorExpressionMethods = {
         const one = numberLiteral(1);
         const current = this.emitExpression(node.operand);
         const fn = node.operator === PrefixUnaryOperator.PlusPlus ? "xt_add" : "xt_sub";
-        const next = this.reg();
-        this.emit(`  ${next} = call i64 @${fn}(i64 ${current}, i64 ${one})`);
+        const next = this.emitBinaryOperation(
+          current,
+          one,
+          node.operator === PrefixUnaryOperator.PlusPlus ? "+" : "-",
+          fn,
+        );
         this.emitAssignmentTarget(node.operand, next);
         return next;
       }
@@ -174,8 +209,12 @@ export const operatorExpressionMethods: OperatorExpressionMethods = {
     const one = numberLiteral(1);
     const current = this.emitExpression(node.operand);
     const fn = node.operator === PostfixUnaryOperator.PlusPlus ? "xt_add" : "xt_sub";
-    const next = this.reg();
-    this.emit(`  ${next} = call i64 @${fn}(i64 ${current}, i64 ${one})`);
+    const next = this.emitBinaryOperation(
+      current,
+      one,
+      node.operator === PostfixUnaryOperator.PlusPlus ? "+" : "-",
+      fn,
+    );
     this.emitAssignmentTarget(node.operand, next);
     return current;
   },

package/src/codegen/generator/expressions/primary.ts

@@ -193,7 +193,7 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
           DiagnosticCode.CodegenError,
           `Imported binding '${identifier.text}' cannot be used as a value`,
           identifier,
-          this.sourceFile.fileName,
+          this.fileNameOf(identifier),
         );
         return i64(XT_UNDEFINED);
       }
@@ -244,7 +244,7 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
           DiagnosticCode.CannotFindName,
           `Cannot find name '${identifier.text}'`,
           identifier,
-          this.sourceFile.fileName,
+          this.fileNameOf(identifier),
         );
         return i64(XT_UNDEFINED);
       }
@@ -292,6 +292,9 @@ export const primaryExpressionMethods: PrimaryExpressionMethods = {
 
   emitNew(node: NewExpression): string {
     const callee = node.expression;
+    // A `new` expression is where the innermost frame's line should point for
+    // `Error.stack`; harmless for every other constructor.
+    this.emit(`  call void @xt_stack_set_line(i32 ${this.lineOf(node)})`);
     if (callee.kind === SyntaxKind.Identifier) {
       const identifier = callee as Identifier;
       const symbol = this.binding.symbolOfIdentifier.get(identifier);

package/src/codegen/generator/generator.ts

@@ -14,13 +14,29 @@ import { moduleMethods, type ModuleMethods } from "./module.js";
 import { statementMethods, type StatementMethods } from "./statements.js";
 import { expressionMethods, type ExpressionMethods } from "./expressions.js";
 import { callMethods, type CallMethods } from "./calls.js";
+import { numericMethods, type NumericMethods } from "./numeric.js";
+import { debugMethods, type DebugMethods } from "./debug.js";
 import type { CodegenOptions, CodegenResult } from "./state.js";
 
 export class Generator extends GeneratorContext {}
 
-export interface Generator extends ModuleMethods, StatementMethods, ExpressionMethods, CallMethods {}
+export interface Generator
+  extends ModuleMethods,
+    StatementMethods,
+    ExpressionMethods,
+    CallMethods,
+    NumericMethods,
+    DebugMethods {}
 
-Object.assign(Generator.prototype, moduleMethods, statementMethods, expressionMethods, callMethods);
+Object.assign(
+  Generator.prototype,
+  moduleMethods,
+  statementMethods,
+  expressionMethods,
+  callMethods,
+  numericMethods,
+  debugMethods,
+);
 
 export type { CodegenOptions, CodegenResult } from "./state.js";
 

package/src/codegen/generator/module.ts

@@ -29,9 +29,16 @@ function isParameterProperty(parameter: Parameter): boolean {
   );
 }
 
+/** A readable, IR-symbol-safe suffix for a function name. */
+function symbolSuffix(name: string): string {
+  if (name.length === 0 || name.startsWith("<")) return "";
+  return name.replace(/[^A-Za-z0-9_]/g, "_").replace(/^_+/, "").slice(0, 32);
+}
+
 export interface ModuleMethods {
   run(this: Generator): string;
   emitFunction(this: Generator, fn: FunctionInfo): void;
+  emitFunctionReturn(this: Generator, value: string): void;
   emitMain(this: Generator): void;
   functionName(this: Generator, fn: FunctionInfo): string;
   wrapAsync(this: Generator, value: string): string;
@@ -77,13 +84,32 @@ export const moduleMethods: ModuleMethods = {
     ];
     const runtimeDeclarations = new Set(RUNTIME_DECLARATIONS);
     const extraDeclarations = [...this.extraDeclarations].filter((line) => !runtimeDeclarations.has(line));
-    return [...header, ...RUNTIME_DECLARATIONS, ...extraDeclarations, "", ...this.globals, "", ...this.functions, ""].join("\n");
+    return [
+      ...header,
+      ...RUNTIME_DECLARATIONS,
+      ...extraDeclarations,
+      "",
+      ...this.globals,
+      "",
+      ...this.functions,
+      "",
+      ...this.debugMetadataLines(),
+    ].join("\n");
   },
 
   // -- module level --------------------------------------------------------
 
   emitFunction(fn: FunctionInfo): void {
+    this.unsupportedCount = 0;
+    // `async function*` would need an async iterator and a promise-returning
+    // `.next()`; the generator/async lowering below would silently produce a
+    // synchronous generator instead, so reject it rather than miscompile.
+    if (fn.isAsync && fn.isGenerator) {
+      this.unsupported(fn.node, "async generator function");
+      return;
+    }
     const name = this.functionName(fn);
+    const debugSubprogram = this.debugSubprogramFor(fn);
     const state: FunctionState = {
       fn,
       buffer: [],
@@ -98,10 +124,14 @@ export const moduleMethods: ModuleMethods = {
       finallyStack: [],
       escapePointers: [],
       usesTry: false,
+      trackFrames: !fn.isGenerator,
+      ...(debugSubprogram ? { debugSubprogram } : {}),
     };
     this.current = state;
+    if (debugSubprogram) this.setDebugLocation(fn.node);
 
-    const header = `define i64 @${name}(i64 %this, i64 %env, i32 %argc, i64* %argv) {`;
+    const debugSuffix = debugSubprogram ? ` !dbg ${debugSubprogram}` : "";
+    const header = `define i64 @${name}(i64 %this, i64 %env, i32 %argc, i64* %argv)${debugSuffix} {`;
     this.emit(`%saved.env = alloca i64`);
     this.emit(`store i64 %env, i64* %saved.env`);
     this.emit(`%saved.this = alloca i64`);
@@ -112,6 +142,23 @@ export const moduleMethods: ModuleMethods = {
     this.emit(`%saved.argv = alloca i64*`);
     this.emit(`store i64* %argv, i64** %saved.argv`);
 
+    // Shadow-stack frame: `Error.stack` and fatal-signal dumps walk this.
+    if (state.trackFrames) {
+      const displayName = fn.isModule
+        ? "module"
+        : fn.isConstructor && fn.classInfo
+          ? `new ${this.displayNameOf(fn.classInfo.name)}`
+          : this.displayNameOf(fn.name.length > 0 ? fn.name : "anonymous");
+      const namePointer = this.internStatic(displayName);
+      /* Normalise separators like `source_filename`: the compiler may run under
+       * Node (`\`) or as a self-hosted binary (`/`), and the IR must stay
+       * byte-identical across the two. */
+      const filePointer = this.internStatic(this.fileNameOf(fn.node).split("\\").join("/"));
+      this.emit(
+        `  call void @xt_stack_push(i8* ${namePointer}, i8* ${filePointer}, i32 ${this.lineOf(fn.node)})`,
+      );
+    }
+
     // Parameters.
     const parameterNodes = (fn.node as { parameters?: Parameter[] }).parameters ?? [];
     for (let index = 0; index < fn.params.length; index++) {
@@ -207,7 +254,7 @@ export const moduleMethods: ModuleMethods = {
       this.emitStatements(this.sourceFile.statements);
     } else if (fn.node.kind === SyntaxKind.ArrowFunction && (fn.node as ArrowFunction).body.kind !== SyntaxKind.Block) {
       const value = this.emitExpression((fn.node as ArrowFunction).body as Expression);
-      this.terminate(`ret i64 ${fn.isAsync ? this.wrapAsync(value) : value}`);
+      this.emitFunctionReturn(fn.isAsync ? this.wrapAsync(value) : value);
     } else {
       const body = (fn.node as { body: Block }).body;
       if (body) this.emitStatements(body.statements);
@@ -215,7 +262,7 @@ export const moduleMethods: ModuleMethods = {
 
     if (!this.current.terminated) {
       const fallback = fn.isAsync ? this.wrapAsync(i64(XT_UNDEFINED)) : i64(XT_UNDEFINED);
-      this.terminate(`ret i64 ${fallback}`);
+      this.emitFunctionReturn(fallback);
     }
 
     const escapes = state.usesTry
@@ -229,8 +276,22 @@ export const moduleMethods: ModuleMethods = {
     const moduleName = this.functionName(this.binding.moduleFunction);
     // Module bindings and class constructors live in globals; register them as
     // GC roots before the module body runs so a collection cannot free them.
-    const roots = [...this.classGlobals.values(), ...this.moduleGlobals.values()];
+    const stringEntries = [...this.strings.values()];
+    const roots = [
+      ...this.classGlobals.values(),
+      ...this.moduleGlobals.values(),
+      ...stringEntries.map((entry) => entry.slot),
+    ];
     const rootLines = roots.map((name) => `  call void @xt_gc_add_root(i64* ${name})`);
+    // Every interned string literal is materialised once here and shared by all
+    // uses, so property names and other literals stop allocating per access.
+    const stringInit = stringEntries.flatMap((entry) => {
+      const register = `%strv.${entry.slot.replace("@.strv.", "")}`;
+      return [
+        `  ${register} = call i64 @xt_string_new(i8* ${entry.label}, i64 ${entry.length})`,
+        `  store i64 ${register}, i64* ${entry.slot}`,
+      ];
+    });
     this.functions.push(
       [
         "define i32 @main(i32 %argc, i8** %argv) {",
@@ -239,6 +300,7 @@ export const moduleMethods: ModuleMethods = {
         "  call void @xt_gc_set_stack_base(i8* %stackbase.ptr)",
         "  call void @xt_gc_init()",
         ...rootLines,
+        ...stringInit,
         "  call void @xt_gc_arm()",
         "  call void @xt_set_program_args(i32 %argc, i8** %argv)",
         `  %result = call i64 @${moduleName}(i64 ${i64(XT_UNDEFINED)}, i64 ${i64(XT_UNDEFINED)}, i32 0, i64* null)`,
@@ -252,7 +314,17 @@ export const moduleMethods: ModuleMethods = {
   },
 
   functionName(fn: FunctionInfo): string {
-    return fn.isModule ? "xt_module" : `xt_fn_${fn.id}`;
+    if (fn.isModule) return "xt_module";
+    /* Keep the original name in the symbol so native debuggers, crash
+     * backtraces and `--emit ir` are readable (`xt_fn_3_sum`). */
+    const suffix = symbolSuffix(this.displayNameOf(fn.name));
+    return suffix.length > 0 ? `xt_fn_${fn.id}_${suffix}` : `xt_fn_${fn.id}`;
+  },
+
+  /** Emit the function's return, dropping its shadow-stack frame first. */
+  emitFunctionReturn(value: string): void {
+    if (this.current.trackFrames) this.emit("  call void @xt_stack_pop()");
+    this.terminate(`ret i64 ${value}`);
   },
 
   /** Wrap a returned value in a resolved promise (for `async` functions). */

package/src/codegen/generator/numeric.ts

@@ -0,0 +1,158 @@
+/**
+ * Inline fast paths for numeric operators.
+ *
+ * Every JavaScript operator used to be a runtime call (`xt_add`, `xt_lt`, …).
+ * That is correct but expensive in numeric code: a `for` loop paid three calls
+ * per iteration, and clang cannot inline across the generated IR / C runtime
+ * boundary. For two unboxed doubles the operation is just a hardware
+ * instruction, so emit that inline and keep the runtime call as the cold path
+ * for every other combination (strings, BigInt, coercion, …).
+ *
+ * Doubles are stored bit-for-bit in `xt_value`, so the tag check is an integer
+ * mask and the operation is `bitcast` → `fadd`/`fcmp` → `bitcast`.
+ */
+
+import { i64, XT_FALSE, XT_NUMBER_MASK, XT_TRUE } from "../values.js";
+import type { Generator } from "./generator.js";
+
+export interface NumericMethods {
+  /**
+   * Emit `left <operator> right`, using an inline double fast path when both
+   * operands turn out to be numbers and {@link allowFastPath} is set.
+   */
+  emitBinaryOperation(
+    this: Generator,
+    left: string,
+    right: string,
+    operator: string,
+    runtime: string,
+    allowFastPath?: boolean,
+  ): string;
+  emitNumericBinary(this: Generator, left: string, right: string, instruction: string, runtime: string): string;
+  emitNumericComparison(this: Generator, left: string, right: string, predicate: string, runtime: string): string;
+  /** Emit an i1 SSA value that is true when `value` is an unboxed double. */
+  isNumberValue(this: Generator, value: string): string;
+}
+
+/** Canonical quiet NaN; the runtime uses the same pattern in `xt_from_double`. */
+const CANONICAL_NAN = 0x7ff8000000000000n;
+
+const NUMERIC_ARITHMETIC: Record<string, string | undefined> = {
+  "+": "fadd",
+  "-": "fsub",
+  "*": "fmul",
+  "/": "fdiv",
+  "%": "frem",
+};
+
+const NUMERIC_COMPARISON: Record<string, string | undefined> = {
+  "<": "olt",
+  "<=": "ole",
+  ">": "ogt",
+  ">=": "oge",
+  "==": "oeq",
+  "!=": "une",
+  "===": "oeq",
+  "!==": "une",
+};
+
+export const numericMethods: NumericMethods = {
+  emitBinaryOperation(left, right, operator, runtime, allowFastPath = true) {
+    if (allowFastPath) {
+      const instruction = NUMERIC_ARITHMETIC[operator];
+      if (instruction) return this.emitNumericBinary(left, right, instruction, runtime);
+      const predicate = NUMERIC_COMPARISON[operator];
+      if (predicate) return this.emitNumericComparison(left, right, predicate, runtime);
+    }
+    const result = this.reg();
+    this.emit(`  ${result} = call i64 @${runtime}(i64 ${left}, i64 ${right})`);
+    return result;
+  },
+
+  /** Emit an i1 SSA value that is true when `value` is an unboxed double. */
+  isNumberValue(value: string): string {
+    const masked = this.reg();
+    this.emit(`  ${masked} = and i64 ${value}, ${i64(XT_NUMBER_MASK)}`);
+    const result = this.reg();
+    this.emit(`  ${result} = icmp ne i64 ${masked}, ${i64(XT_NUMBER_MASK)}`);
+    return result;
+  },
+
+  emitNumericBinary(left, right, instruction, runtime) {
+    const result = this.alloca();
+    const leftIsNumber = this.isNumberValue(left);
+    const rightIsNumber = this.isNumberValue(right);
+    const bothNumbers = this.reg();
+    this.emit(`  ${bothNumbers} = and i1 ${leftIsNumber}, ${rightIsNumber}`);
+    const fast = this.label("num.fast");
+    const slow = this.label("num.slow");
+    const end = this.label("num.end");
+    this.terminate(`br i1 ${bothNumbers}, label %${fast}, label %${slow}`);
+
+    this.startBlock(fast);
+    const leftDouble = this.reg();
+    this.emit(`  ${leftDouble} = bitcast i64 ${left} to double`);
+    const rightDouble = this.reg();
+    this.emit(`  ${rightDouble} = bitcast i64 ${right} to double`);
+    const computed = this.reg();
+    this.emit(`  ${computed} = ${instruction} double ${leftDouble}, ${rightDouble}`);
+    // Hardware NaNs carry many payloads; the value model only reserves the
+    // canonical quiet NaN, and `-NaN` would otherwise collide with XT_UNDEFINED.
+    const bits = this.reg();
+    this.emit(`  ${bits} = bitcast double ${computed} to i64`);
+    const unordered = this.reg();
+    this.emit(`  ${unordered} = fcmp uno double ${computed}, ${computed}`);
+    const canonical = this.reg();
+    this.emit(`  ${canonical} = select i1 ${unordered}, i64 ${i64(CANONICAL_NAN)}, i64 ${bits}`);
+    this.emit(`  store i64 ${canonical}, i64* ${result}`);
+    this.terminate(`br label %${end}`);
+
+    this.startBlock(slow);
+    const called = this.reg();
+    this.emit(`  ${called} = call i64 @${runtime}(i64 ${left}, i64 ${right})`);
+    this.emit(`  store i64 ${called}, i64* ${result}`);
+    this.terminate(`br label %${end}`);
+
+    this.startBlock(end);
+    const value = this.reg();
+    this.emit(`  ${value} = load i64, i64* ${result}`);
+    return value;
+  },
+
+  emitNumericComparison(left, right, predicate, runtime) {
+    const result = this.alloca();
+    const leftIsNumber = this.isNumberValue(left);
+    const rightIsNumber = this.isNumberValue(right);
+    const bothNumbers = this.reg();
+    this.emit(`  ${bothNumbers} = and i1 ${leftIsNumber}, ${rightIsNumber}`);
+    const fast = this.label("cmp.fast");
+    const slow = this.label("cmp.slow");
+    const end = this.label("cmp.end");
+    this.terminate(`br i1 ${bothNumbers}, label %${fast}, label %${slow}`);
+
+    this.startBlock(fast);
+    const leftDouble = this.reg();
+    this.emit(`  ${leftDouble} = bitcast i64 ${left} to double`);
+    const rightDouble = this.reg();
+    this.emit(`  ${rightDouble} = bitcast i64 ${right} to double`);
+    // Ordered comparisons are false for NaN and unordered `!=` is true, which
+    // is exactly ECMAScript's behaviour for two numbers.
+    const compared = this.reg();
+    this.emit(`  ${compared} = fcmp ${predicate} double ${leftDouble}, ${rightDouble}`);
+    const value = this.reg();
+    this.emit(`  ${value} = select i1 ${compared}, i64 ${i64(XT_TRUE)}, i64 ${i64(XT_FALSE)}`);
+    this.emit(`  store i64 ${value}, i64* ${result}`);
+    this.terminate(`br label %${end}`);
+
+    this.startBlock(slow);
+    const called = this.reg();
+    this.emit(`  ${called} = call i64 @${runtime}(i64 ${left}, i64 ${right})`);
+    this.emit(`  store i64 ${called}, i64* ${result}`);
+    this.terminate(`br label %${end}`);
+
+    this.startBlock(end);
+    const merged = this.reg();
+    this.emit(`  ${merged} = load i64, i64* ${result}`);
+    return merged;
+  },
+};

package/src/codegen/generator/state.ts

@@ -50,6 +50,16 @@ export interface FunctionState {
   thisPtr?: string;
   /** Set when the function contains a `try`, forcing locals to live in memory. */
   usesTry: boolean;
+  /**
+   * True when the function pushes/pops a shadow-stack frame. Generator bodies
+   * are excluded: they switch stacks and can be suspended, so a global shadow
+   * stack would attribute their frames to the wrong caller.
+   */
+  trackFrames: boolean;
+  /** `!DISubprogram` for this function when DWARF emission is enabled. */
+  debugSubprogram?: string;
+  /** Current `!DILocation` attached to every emitted instruction. */
+  debugLocation?: string;
 }
 
 export interface CodegenResult {
@@ -74,6 +84,13 @@ export interface CodegenOptions {
    * defaults to the running process; it is overridable for tests.
    */
   readonly target?: { readonly platform: string; readonly arch: string };
+  /**
+   * Emit LLVM debug metadata (`!DICompileUnit`, `!DISubprogram`,
+   * `!DILocation`) so `clang -g` produces DWARF/CodeView for the generated
+   * program. Off by default: the metadata is large and only useful when
+   * debugging; `xbintsc build --debug` turns it on.
+   */
+  readonly debug?: boolean;
 }
 
 export const RUNTIME_DECLARATIONS: readonly string[] = [
@@ -93,6 +110,7 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_this()",
   "declare i64 @xt_new(i64, i32, i64*)",
   "declare i64 @xt_instance_of(i64, i64)",
+  "declare i64 @xt_instance_of_builtin(i64, i32)",
   "declare i64 @xt_function_set_prototype(i64, i64)",
   "declare i64 @xt_function_get_prototype(i64)",
   "declare i64 @xt_object_new_with_proto(i64)",
@@ -225,6 +243,7 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_object_entries(i64)",
   "declare i64 @xt_object_assign(i32, i64*)",
   "declare i64 @xt_object_spread(i64, i64)",
+  "declare i64 @xt_object_rest(i64, i32, i64*)",
   "declare i64 @xt_call_method(i64, i64, i32, i64*)",
   "declare i64 @xt_math_call(i64, i32, i64*)",
   "declare i64 @xt_parse_int(i32, i64*)",
@@ -298,6 +317,9 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i8* @xt_try_enter()",
   "declare i64 @xt_try_exception(i8*)",
   "declare void @xt_try_leave(i8*)",
+  "declare void @xt_stack_push(i8*, i8*, i32)",
+  "declare void @xt_stack_pop()",
+  "declare void @xt_stack_set_line(i32)",
   "declare void @xt_console_log(i32, i64*)",
   "declare void @xt_console_info(i32, i64*)",
   "declare void @xt_console_warn(i32, i64*)",

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

@@ -255,7 +255,7 @@ export const controlFlowStatementMethods: ControlFlowStatementMethods = {
     this.runFinallysBeforeExit(0);
     if (this.current.terminated) return;
     this.popTryFramesTo(0);
-    this.terminate(`ret i64 ${value}`);
+    this.emitFunctionReturn(value);
   },
 
   /** Emit `xt_try_leave` for every active frame above `depth` (innermost first). */

package/src/codegen/generator/statements/dispatch.ts

@@ -41,6 +41,9 @@ export const statementDispatchMethods: StatementDispatchMethods = {
   },
 
   emitStatement(statement: Statement): void {
+    /* Every instruction emitted while lowering this statement (including
+     * nested expressions) points at its source position when DWARF is on. */
+    this.setDebugLocation(statement);
     switch (statement.kind) {
       case SyntaxKind.ExpressionStatement:
         this.emitExpression((statement as { expression: Expression }).expression);

package/src/codegen/generator/statements/variables.ts

@@ -87,13 +87,19 @@ export const variableStatementMethods: VariableStatementMethods = {
       return;
     }
     const pattern = name as ObjectBindingPattern;
+    /* Keys named by the pattern are excluded from `...rest`. */
+    const excludedKeys: string[] = [];
     for (const element of pattern.elements) {
-      const key = element.propertyName ?? (element.name.kind === SyntaxKind.Identifier ? element.name : undefined);
       if (element.dotDotDotToken) {
-        this.unsupported(element, "object rest destructuring");
+        const rest = this.reg();
+        const keys = this.emitValueArguments(excludedKeys);
+        this.emit(`  ${rest} = call i64 @xt_object_rest(i64 ${value}, i32 ${keys.argc}, i64* ${keys.ptr})`);
+        this.emitBindingPattern(element.name, rest);
         continue;
       }
+      const key = element.propertyName ?? (element.name.kind === SyntaxKind.Identifier ? element.name : undefined);
       const keyValue = this.stringValue(key ? propertyNameText(key) : "undefined");
+      excludedKeys.push(keyValue);
       let elementValue = this.reg();
       this.emit(`  ${elementValue} = call i64 @xt_get(i64 ${value}, i64 ${keyValue})`);
       if (element.initializer) elementValue = this.emitBindingDefault(elementValue, element.initializer);

package/src/codegen/generator/tables.ts

@@ -22,6 +22,32 @@ export function requiresSetjmpex(platform: string, arch: string): boolean {
   return platform === "win32" && arch === "arm64";
 }
 
+/**
+ * Built-in constructors usable on the right of `instanceof`, mapped to the id
+ * `xt_instance_of_builtin` expects. Keep in sync with the `XT_INSTANCE_*` enum
+ * in `runtime/xt_builtins.c`; the typed-array ids follow the runtime's
+ * `XT_TA_*` order (Uint8Array first).
+ */
+export const BUILTIN_INSTANCEOF: Readonly<Record<string, number>> = {
+  Array: 0,
+  Object: 1,
+  Function: 2,
+  Map: 3,
+  Set: 4,
+  Date: 5,
+  RegExp: 6,
+  Promise: 7,
+  Uint8Array: 16,
+  Int8Array: 17,
+  Uint8ClampedArray: 18,
+  Uint16Array: 19,
+  Int16Array: 20,
+  Uint32Array: 21,
+  Int32Array: 22,
+  Float32Array: 23,
+  Float64Array: 24,
+};
+
 export const BINARY_RUNTIME: Record<string, string | undefined> = {
   [BinaryOperator.Add]: "xt_add",
   [BinaryOperator.Subtract]: "xt_sub",