js-confuser-vm 0.0.8 → 0.1.0

package/src/transforms/bytecode/resolveRegisters.ts

@@ -0,0 +1,221 @@
+// resolveRegisters
+// Converts virtual RegisterOperand objects into concrete slot indices and sets
+// each FnDescriptor's regCount.
+//
+// Two-tier slot assignment:
+//
+//   "local::" pool  (params, `arguments`, hoisted vars, upvalue-captured vars)
+//   ─────────────────────────────────────────────────────────────────────────
+//   Sorted by virtual-id, slots assigned sequentially with NO reuse.
+//   This is required because:
+//     • The runtime writes args[i] to regs[base + i] at call time, so params
+//       MUST occupy slots 0..paramCount-1 in virtual-id order.
+//     • Open upvalues hold an absolute slot index and read regs[base+slot] for
+//       the lifetime of the outer frame — reusing a captured slot corrupts reads.
+//
+//   All other pools  (e.g. "temp::", "canary::", pass-introduced pools)
+//   ─────────────────────────────────────────────────────────────────────────
+//   Linear-scan with a free list: registers are sorted by firstUse, and any
+//   slot whose previous occupant's lastUse < current register's firstUse is
+//   recycled. An explicit [null, freeRegOperand(reg)] pseudo-instruction clamps
+//   lastUse early, enabling reuse before the natural end of the live range.
+//
+//   Pools are processed in priority order: "local::" always first (slots
+//   0..N), then remaining pools alphabetically. This keeps temp slots above
+//   the reserved param/local region.
+//
+//   regCount = max concrete slot used across all pools + 1.
+//
+// Run AFTER all IR-level passes but BEFORE resolveLabels / resolveConstants.
+
+import type { Bytecode } from "../../types.ts";
+import { Compiler } from "../../compiler.ts";
+
+export function resolveRegisters(
+  bc: Bytecode,
+  compiler: Compiler,
+): { bytecode: Bytecode } {
+  function registerPoolKey(op: {
+    kind?: string;
+    scopeId?: string | number;
+  }): string {
+    return `${op.kind ?? "local"}::${op.scopeId ?? ""}`;
+  }
+
+  // ── Pass 1: collect live ranges ───────────────────────────────────────────
+  // For each (fnId, virtId) record the first and last instruction index where
+  // the register appears as a real operand.  A freeReg marker clamps lastUse.
+  type RegInfo = {
+    firstUse: number;
+    lastUse: number;
+    poolKey: string;
+    freed: boolean; // true once a freeReg has been seen; prevents further extension
+  };
+  // fnId -> virtId -> RegInfo
+  const fnRegInfo = new Map<number, Map<number, RegInfo>>();
+
+  for (let i = 0; i < bc.length; i++) {
+    const instr = bc[i];
+    for (let j = 1; j < instr.length; j++) {
+      const op = instr[j] as any;
+      if (!op || typeof op !== "object") continue;
+
+      if (op.type === "register") {
+        const { fnId, id } = op;
+        const poolKey = registerPoolKey(op);
+        let fnMap = fnRegInfo.get(fnId);
+        if (!fnMap) {
+          fnMap = new Map();
+          fnRegInfo.set(fnId, fnMap);
+        }
+        const existing = fnMap.get(id);
+        if (!existing) {
+          fnMap.set(id, { firstUse: i, lastUse: i, poolKey, freed: false });
+        } else if (!existing.freed) {
+          // Only extend lastUse if no explicit freeReg has clamped it yet.
+          existing.lastUse = i;
+        }
+      } else if (op.type === "freeReg") {
+        // Explicit end-of-life marker: clamp lastUse and prevent extension.
+        const { fnId, id } = op;
+        const fnMap = fnRegInfo.get(fnId);
+        if (fnMap) {
+          const info = fnMap.get(id);
+          if (info && !info.freed) {
+            info.lastUse = i;
+            info.freed = true;
+          }
+        }
+      }
+    }
+  }
+
+  // ── Pass 2: slot assignment per function ──────────────────────────────────
+  // fnId -> virtId -> concrete slot
+  const fnSlotMaps = new Map<number, Map<number, number>>();
+
+  // Pool ordering: "local::" always first; all other keys sorted alphabetically.
+  function poolSortKey(key: string): [number, string] {
+    return key === "local::" ? [0, ""] : [1, key];
+  }
+
+  for (const [fnId, regMap] of fnRegInfo) {
+    // Group by pool key.
+    const pools = new Map<
+      string,
+      Array<{ id: number; firstUse: number; lastUse: number }>
+    >();
+    for (const [id, info] of regMap) {
+      let pool = pools.get(info.poolKey);
+      if (!pool) {
+        pool = [];
+        pools.set(info.poolKey, pool);
+      }
+      pool.push({ id, firstUse: info.firstUse, lastUse: info.lastUse });
+    }
+
+    const sortedPoolKeys = Array.from(pools.keys()).sort((a, b) => {
+      const [pa, sa] = poolSortKey(a);
+      const [pb, sb] = poolSortKey(b);
+      if (pa !== pb) return pa - pb;
+      return sa < sb ? -1 : sa > sb ? 1 : 0;
+    });
+
+    const slotMap = new Map<number, number>(); // virtId -> slot
+    fnSlotMaps.set(fnId, slotMap);
+
+    // nextSlot is the high-water mark: the next fresh slot to allocate.
+    // It is shared across all pools so each pool's slots start above the
+    // previous pool's maximum slot.
+    let nextSlot = 0;
+
+    for (const poolKey of sortedPoolKeys) {
+      const regs = pools.get(poolKey)!;
+
+      if (poolKey === "local::") {
+        // ── Local pool: virtual-id order, no reuse ────────────────────────
+        // Params must be at the lowest slots (written by the runtime at call
+        // time); upvalue captures must keep their slot for the frame's lifetime.
+        regs.sort((a, b) => a.id - b.id);
+        for (const reg of regs) {
+          slotMap.set(reg.id, nextSlot++);
+        }
+      } else {
+        // ── Non-local pool: firstUse order, linear-scan reuse ─────────────
+        regs.sort((a, b) => a.firstUse - b.firstUse);
+
+        // freeList entries: { slot, freeAt } where freeAt = lastUse of current
+        // occupant.  A slot becomes available when freeAt < next reg's firstUse.
+        const freeList: Array<{ slot: number; freeAt: number }> = [];
+
+        for (const reg of regs) {
+          // Find the lowest-numbered slot whose last occupant has ended.
+          let bestSlot = -1;
+          let bestIdx = -1;
+          for (let k = 0; k < freeList.length; k++) {
+            if (freeList[k].freeAt < reg.firstUse) {
+              if (bestSlot === -1 || freeList[k].slot < bestSlot) {
+                bestSlot = freeList[k].slot;
+                bestIdx = k;
+              }
+            }
+          }
+
+          let assignedSlot: number;
+          if (bestIdx !== -1) {
+            assignedSlot = bestSlot;
+            freeList.splice(bestIdx, 1);
+          } else {
+            assignedSlot = nextSlot++;
+          }
+
+          slotMap.set(reg.id, assignedSlot);
+          freeList.push({ slot: assignedSlot, freeAt: reg.lastUse });
+        }
+        // nextSlot already reflects the high-water mark; reused slots are
+        // always < nextSlot by construction.
+      }
+    }
+  }
+
+  // ── Pass 3: patch register operands ──────────────────────────────────────
+  for (const instr of bc) {
+    for (let i = 1; i < instr.length; i++) {
+      const op = instr[i] as any;
+      if (!op || typeof op !== "object") continue;
+      if (op.type === "register") {
+        op.resolvedValue = fnSlotMaps.get(op.fnId)?.get(op.id);
+      }
+    }
+  }
+
+  // ── Pass 4: set regCount on each FnDescriptor ─────────────────────────────
+  // regCount = max concrete slot used + 1  (not sum of virtual-register counts).
+  for (const desc of compiler.fnDescriptors) {
+    const fnId = desc._fnIdx!;
+    const slotMap = fnSlotMaps.get(fnId);
+    let regCount = 0;
+    if (slotMap) {
+      for (const slot of slotMap.values()) {
+        if (slot + 1 > regCount) regCount = slot + 1;
+      }
+    }
+    desc.regCount = regCount;
+  }
+
+  compiler.mainRegCount = compiler.mainFn?.regCount ?? 0;
+
+  // ── Pass 5: patch fnRegCount operands ────────────────────────────────────
+  for (const instr of bc) {
+    for (let i = 1; i < instr.length; i++) {
+      const op = instr[i] as any;
+      if (!op || typeof op !== "object") continue;
+      if (op.type === "fnRegCount") {
+        const desc = compiler.fnDescriptors[op.fnId];
+        op.resolvedValue = desc?.regCount ?? 0;
+      }
+    }
+  }
+
+  return { bytecode: bc };
+}

package/src/transforms/bytecode/specializedOpcodes.ts

@@ -1,12 +1,6 @@
 import type { Bytecode, InstrOperand, Instruction } from "../../types.ts";
 import { Compiler, SOURCE_NODE_SYM } from "../../compiler.ts";
-import {
-  getInstructionSize,
-  nextFreeSlot,
-  U16_MAX,
-} from "../../utils/op-utils.ts";
-import * as t from "@babel/types";
-import * as b from "../../types.ts";
+import { getInstructionSize, nextFreeSlot } from "../../utils/op-utils.ts";
 
 export const nSizedOps = [
   "MAKE_CLOSURE",
@@ -19,9 +13,11 @@ export const nSizedOps = [
 
 // Creates specialized opcodes for the most frequent (OPCODE + single_integer_operand) pairs.
 // Example: [OP.LOAD_CONST, 1] becomes [SPECIALIZED_LOAD_CONST_1].
-// Only instructions with *exactly one numeric operand* are considered.
+// Only instructions that are fixed-sized are considered.
 // MAKE_CLOSURE and other N-sized instructions cannot be specialized
-// Runs after selfModifying but before resolveLabels (operands stay plain numbers).
+// Operands are converted into objects and marked as 'placeholder' - other passes can mutate and the reference stays intact
+// We need a reference throughout the pipeline so that final AST generation can place the actual value
+// The 'placeholder' flag drops the operand from the final bytecode - any size calculation must not count these
 export function specializedOpcodes(
   bc: Bytecode,
   compiler: Compiler,

package/src/types.ts

@@ -6,17 +6,58 @@
 // All "null" instructions are dropped before assembly time.
 // Instructions may carry any number of operands; the flat output serializes
 // each operand as a separate u16 slot in the bytecode array.
+// A virtual register reference emitted by the compiler.
+// fnId identifies which function's register file this belongs to.
+// resolveRegisters() replaces these with concrete slot indices (type:"number").
+export type RegisterOperand = Op<{
+  type: "register";
+  id: number;
+  fnId: number;
+  kind?: string;
+  scopeId?: string | number;
+}>;
+
+// A placeholder for a function's concrete regCount, emitted in MAKE_CLOSURE.
+// resolveRegisters() fills resolvedValue once it knows the concrete slot count.
+export type FnRegCountOperand = Op<{ type: "fnRegCount"; fnId: number }>;
+
+// IR pseudo-instruction that marks the end of a register's live range.
+// Emitted as [null, FreeRegOperand] so it is dropped before final assembly.
+//
+// NOTE: resolveRegisters() already computes correct lastUse from the last real
+// operand appearance, so freeReg is EXTRANEOUS for any programmatically generated
+// IR — the scanner will find the tightest possible range without it.
+// It is only useful when a register has a late syntactic appearance that does
+// NOT reflect its true logical end-of-life (e.g. a read emitted purely for
+// side-effects long after the value is logically dead). No current pass in this
+// codebase emits freeReg; it is kept as an extension point only.
+export type FreeRegOperand = Op<{
+  type: "freeReg";
+  fnId: number;
+  id: number;
+  kind?: string;
+  scopeId?: string | number;
+}>;
+
 export type InstrOperand =
   | number
   | Op<{ type: "number"; value?: number }>
-  | Op<{ type: "label"; label: string; offset?: number }>
+  | Op<{
+      type: "label";
+      label: string;
+      offset?: number;
+      transform?: (resolvedPC: number) => number;
+    }>
   | Op<{ type: "defineLabel"; label: string }>
-  | Op<{ type: "constant"; value: any }>;
+  | Op<{ type: "constant"; value: any }>
+  | RegisterOperand
+  | FnRegCountOperand
+  | FreeRegOperand;
 
 export interface Operand {
   type: string;
-  placeholder?: boolean;
-  resolvedValue?: number;
+  placeholder?: boolean; // This operand will not be emitted in the final bytecode, but used as a reference
+  resolvedValue?: number; // This operand knows its resolved value, but kept as a object to keep metadata info available
 }
 
 type Op<T extends object> = Operand & T;
@@ -31,3 +72,22 @@ export function constantOperand(value: any): Instruction[1] {
     value: value,
   };
 }
+
+export function registerOperand(
+  id: number,
+  fnId: number,
+  metadata: Partial<Pick<RegisterOperand, "kind" | "scopeId">> = {},
+): RegisterOperand {
+  return { type: "register", id, fnId, ...metadata };
+}
+
+export function fnRegCountOperand(fnId: number): FnRegCountOperand {
+  return { type: "fnRegCount", fnId };
+}
+
+export function freeRegOperand(reg: RegisterOperand): FreeRegOperand {
+  const op: FreeRegOperand = { type: "freeReg", fnId: reg.fnId, id: reg.id };
+  if (reg.kind !== undefined) op.kind = reg.kind;
+  if (reg.scopeId !== undefined) op.scopeId = reg.scopeId;
+  return op;
+}

package/src/utils/op-utils.ts

@@ -40,6 +40,8 @@ export function nextFreeSlot(compiler: Compiler): number {
 }
 
 export function getInstructionSize(instr: b.Instruction): number {
+  if (instr[0] === null) return 0;
+
   const size = instr.filter((op) => (op as any)?.placeholder !== true).length;
 
   return size;

package/dist/transforms/utils/op-utils.js

@@ -1,25 +0,0 @@
-import { getRandomInt } from "./random-utils.js";
-export const U16_MAX = 0xffff; // bytecode operands are u16
-
-/** Returns the next free opcode slot, or -1 when the space is exhausted. */
-export function nextFreeSlot(usedOpcodes) {
-  if (usedOpcodes.size > U16_MAX) return -1;
-  let attempts = 0;
-  while (attempts++ < 512) {
-    const candidate = getRandomInt(0, U16_MAX);
-    if (!usedOpcodes.has(candidate)) {
-      usedOpcodes.add(candidate);
-      return candidate;
-    }
-  }
-  // Fallback: linear scan from a random start
-  const start = getRandomInt(0, U16_MAX);
-  for (let i = 0; i <= U16_MAX; i++) {
-    const v = start + i & U16_MAX;
-    if (!usedOpcodes.has(v)) {
-      usedOpcodes.add(v);
-      return v;
-    }
-  }
-  return -1;
-}

package/dist/transforms/utils/random-utils.js

@@ -1,27 +0,0 @@
-import { ok } from "assert";
-export function getPlaceholder() {
-  return Math.random().toString(36).substring(2, 15);
-}
-export function choice(elements) {
-  ok(elements.length > 0, "choice() called on empty sequence");
-  return elements[Math.floor(Math.random() * elements.length)];
-}
-export function getRandom() {
-  return Math.random();
-}
-export function getRandomInt(min, max) {
-  ok(min <= max, "min must be <= max");
-  return Math.floor(Math.random() * (max - min + 1)) + min;
-}
-
-/**
- * Shuffles an array in-place using the Fisher-Yates algorithm.
- * @param array - The array to shuffle (mutated)
- */
-export function shuffle(array) {
-  for (let i = array.length - 1; i > 0; i--) {
-    const j = Math.floor(Math.random() * (i + 1));
-    [array[i], array[j]] = [array[j], array[i]];
-  }
-  return array;
-}

package/dist/utilts.js

@@ -1,3 +0,0 @@
-export function escapeRegex(s) {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}