js-confuser-vm 0.1.0 → 0.1.2

package/src/transforms/bytecode/microOpcodes.ts

@@ -1,291 +0,0 @@
-import { parse } from "@babel/parser";
-import traverseImport from "@babel/traverse";
-import * as t from "@babel/types";
-import { ok } from "assert";
-import { Compiler, VM_RUNTIME, SOURCE_NODE_SYM } from "../../compiler.ts";
-import type { Bytecode, Instruction } from "../../types.ts";
-import { nextFreeSlot } from "../../utils/op-utils.ts";
-import { nSizedOps } from "./specializedOpcodes.ts";
-import generate from "@babel/generator";
-
-const traverse = (traverseImport.default ||
-  traverseImport) as typeof traverseImport.default;
-
-// Extract the real statement list from a SwitchCase consequent.
-function extractCaseBody(switchCase: t.SwitchCase): t.Statement[] {
-  let stmts: t.Statement[];
-  if (
-    switchCase.consequent.length === 1 &&
-    t.isBlockStatement(switchCase.consequent[0])
-  ) {
-    stmts = (switchCase.consequent[0] as t.BlockStatement).body;
-  } else {
-    stmts = switchCase.consequent as t.Statement[];
-  }
-  return stmts.filter((s) => !t.isBreakStatement(s) && !t.isEmptyStatement(s));
-}
-
-// Count how many IR-level operands a single statement consumes.
-// Returns null if the statement is ineligible (contains a loop, or has
-// _operand()/_constant() calls inside a conditional branch).
-function countStatementOperands(stmt: t.Statement): number | null {
-  let count = 0;
-  let ineligible = false;
-
-  const file = t.file(t.program([t.cloneNode(stmt, true) as t.Statement]));
-
-  traverse(file, {
-    enter(path) {
-      if (ineligible) {
-        path.stop();
-        return;
-      }
-
-      const nodeType = path.node.type;
-
-      // Don't traverse into nested functions
-      if (
-        nodeType === "FunctionDeclaration" ||
-        nodeType === "FunctionExpression" ||
-        nodeType === "ArrowFunctionExpression"
-      ) {
-        path.skip();
-        return;
-      }
-
-      // Count _operand() and _constant() calls
-      if (nodeType === "CallExpression") {
-        const call = path.node as t.CallExpression;
-        const callee = call.callee;
-        if (
-          t.isMemberExpression(callee) &&
-          t.isThisExpression(callee.object) &&
-          t.isIdentifier(callee.property)
-        ) {
-          const name = (callee.property as t.Identifier).name;
-          const operandsConsumed =
-            name === "_operand" ? 1 : name === "_constant" ? 2 : null;
-
-          if (operandsConsumed) {
-            // You are not allowed to use _operand() in loops or branches
-            const ancestors = path.getAncestry();
-
-            if (
-              ancestors.find(
-                (t) =>
-                  t.isLoop() ||
-                  t.isIfStatement() ||
-                  t.isSwitchStatement() ||
-                  t.isConditionalExpression() ||
-                  t.isLogicalExpression(),
-              )
-            ) {
-              ineligible = true;
-              path.stop();
-              return;
-            }
-
-            count += operandsConsumed;
-          }
-        }
-      }
-    },
-  });
-
-  return ineligible ? null : count;
-}
-
-// Analyse the VM runtime's @SWITCH statement to build a per-opcode map of
-// { stmtIndex → irOperandCount } for every case that can be split.
-// Returns a map: opValue → array of per-statement operand counts (null if ineligible).
-function analyzeRuntimeCases(compiler: Compiler): Map<number, number[]> {
-  // Parse the runtime source
-  const ast = parse(VM_RUNTIME, { sourceType: "unambiguous" });
-
-  // Build reverse name→opValue map from original OPs only
-  const nameToOp = new Map<string, number>();
-  for (const [name, val] of Object.entries(compiler.OP)) {
-    if (val !== undefined) nameToOp.set(name, val as number);
-  }
-
-  let switchStatement: t.SwitchStatement | null = null;
-  traverse(ast, {
-    SwitchStatement(path) {
-      if (path.node.leadingComments?.some((c) => c.value.includes("@SWITCH"))) {
-        switchStatement = path.node;
-        path.stop();
-      }
-    },
-  });
-
-  ok(switchStatement, "Could not find @SWITCH statement for micro opcodes");
-
-  const result = new Map<number, number[]>();
-
-  for (const sc of (switchStatement as t.SwitchStatement).cases) {
-    const test = sc.test;
-    if (
-      !test ||
-      !t.isMemberExpression(test) ||
-      !t.isIdentifier(test.object, { name: "OP" }) ||
-      !t.isIdentifier(test.property)
-    ) {
-      continue;
-    }
-
-    const opName = (test.property as t.Identifier).name;
-    const opVal = nameToOp.get(opName);
-    if (opVal === undefined) continue;
-
-    const stmts = extractCaseBody(sc);
-    if (stmts.length < 2) continue; // need at least 2 statements to split
-
-    const counts: number[] = [];
-    let allEligible = true;
-
-    // Banned patterns:
-    // Return statements (Control flow isn't remembered)
-    traverse(t.file(t.program(stmts)), {
-      ReturnStatement(path) {
-        path.stop();
-        allEligible = false;
-      },
-    });
-
-    for (const stmt of stmts) {
-      const c = countStatementOperands(stmt);
-      if (c === null) {
-        allEligible = false;
-        break;
-      }
-      if (t.isDebuggerStatement(stmt) || t.isThrowStatement(stmt)) {
-        allEligible = false;
-        break;
-      }
-      counts.push(c);
-    }
-
-    if (!allEligible) continue;
-
-    // Verify that the total operand count matches the instruction size expectation
-    // (just store for now; bytecode pass validates operands match)
-    result.set(opVal, counts);
-  }
-
-  return result;
-}
-
-// Main bytecode transform: split frequently-used opcodes into per-statement
-// micro-opcodes so each sub-instruction is as small as possible.
-export function microOpcodes(
-  bc: Bytecode,
-  compiler: Compiler,
-): { bytecode: Bytecode } {
-  // ── Step 1: analyse runtime to discover splittable opcodes ──────────────────
-  const opAnalysis = analyzeRuntimeCases(compiler);
-  if (opAnalysis.size === 0) return { bytecode: bc };
-
-  // ── Step 2: count opcode frequency in bytecode ────────────────────────────
-  const disallowedOps = new Set(nSizedOps.map((name) => compiler.OP[name]));
-
-  disallowedOps.add(compiler.OP.RETURN);
-
-  const freqMap = new Map<number, number>();
-  for (const instr of bc) {
-    const op = instr[0];
-    if (op === null || !opAnalysis.has(op) || disallowedOps.has(op)) continue;
-    freqMap.set(op, (freqMap.get(op) ?? 0) + 1);
-  }
-
-  // ── Step 3: sort by frequency, keep opcodes that actually appear ─────────
-  const candidates = Array.from(freqMap.entries())
-    .filter(([, count]) => count >= 1)
-    .sort(([, a], [, b]) => b - a)
-    .map(([op]) => op);
-
-  if (candidates.length === 0) return { bytecode: bc };
-
-  // ── Step 4: assign free opcode slots for each sub-statement ─────────────
-  // Build: originalOp → [{ microOp, irOperandCount }, ...]
-  const originalToSubOps = new Map<
-    number,
-    { microOp: number; irOperandCount: number }[]
-  >();
-
-  for (const origOp of candidates) {
-    const stmtCounts = opAnalysis.get(origOp)!;
-
-    // Pre-allocate all needed slots; if any slot is unavailable, skip this op.
-    const slots: number[] = [];
-    for (let si = 0; si < stmtCounts.length; si++) {
-      const slot = nextFreeSlot(compiler);
-      if (slot === -1) break;
-
-      compiler.OP_NAME[slot] = `MICRO_${origOp}_${si}`;
-      slots.push(slot);
-    }
-    if (slots.length !== stmtCounts.length) continue;
-
-    const subOps: { microOp: number; irOperandCount: number }[] = [];
-    const origName = compiler.OP_NAME[origOp] ?? `OP_${origOp}`;
-
-    for (let si = 0; si < stmtCounts.length; si++) {
-      const microOp = slots[si];
-      const irOperandCount = stmtCounts[si];
-      subOps.push({ microOp, irOperandCount });
-
-      compiler.OP_NAME[microOp] = `MICRO_${origName}_${si}`;
-      compiler.MICRO_OPS[microOp] = {
-        originalOp: origOp,
-        stmtIndex: si,
-        irOperandCount,
-      };
-    }
-
-    originalToSubOps.set(origOp, subOps);
-  }
-
-  if (originalToSubOps.size === 0) return { bytecode: bc };
-
-  // ── Step 5: replace each matched instruction with sub-instructions ────────
-  const result: Bytecode = [];
-
-  for (const instr of bc) {
-    const op = instr[0];
-    if (op === null || !originalToSubOps.has(op)) {
-      result.push(instr);
-      continue;
-    }
-
-    const subOps = originalToSubOps.get(op)!;
-    const operands = instr.slice(1); // all operands of the original instruction
-
-    // Verify total operand count matches sum of sub-op IR operand counts
-    const expectedTotal = subOps.reduce(
-      (s, { irOperandCount }) => s + irOperandCount,
-      0,
-    );
-    if (operands.length !== expectedTotal) {
-      throw new Error(
-        `Operand count mismatch for opcode ${compiler.OP_NAME[op]}`,
-      );
-    }
-
-    // Split operands among sub-instructions
-    let offset = 0;
-    for (const { microOp, irOperandCount } of subOps) {
-      const subOperands = operands.slice(offset, offset + irOperandCount);
-      offset += irOperandCount;
-
-      const newInstr: Instruction = [microOp, ...subOperands];
-      // Carry source-node info on the first sub-instruction
-      if (offset === irOperandCount) {
-        (newInstr as any)[SOURCE_NODE_SYM] = (instr as any)[SOURCE_NODE_SYM];
-      }
-
-      result.push(newInstr);
-    }
-  }
-
-  return { bytecode: result };
-}

package/src/transforms/bytecode/resolveLabels.ts

@@ -1,112 +0,0 @@
-// --- Label IR ---
-// During compilation, jump targets are symbolic labels instead of hard-coded
-// PC numbers.  Two IR "pseudo operands" carry the label information:
-//
-//   defineLabel operand  : [null, {type:"defineLabel", label:"FN_ENTRY_1"}]
-//     Marks a position in the bytecode array.
-//     resolveLabels() strips these out entirely.
-//
-//   label ref operand      : [OP.JUMP, {type:"label", label:"FN_ENTRY_1"}]
-//     Used as the operand of any jump instruction. resolveLabels() replaces
-//     it with the integer PC that the corresponding defineLabel resolves to.
-//
-// The output bytecode is still a nested array of instructions.
-// Flattening (one u16 slot per op, one per operand) happens in the Serializer.
-// PC values computed here reflect the FLAT slot index so that jump targets,
-// startPc, and LOAD_INT label operands are all correct after flattening.
-
-import type { Instruction } from "../../types.ts";
-import { Compiler, SOURCE_NODE_SYM } from "../../compiler.ts";
-
-// Resolve symbolic labels to absolute flat-PC indices within a bytecode array.
-// defineLabel pseudo-instructions are stripped; label-ref operands become ints.
-// Each instruction [op, ...operands] occupies (1 + operands.length) flat slots,
-// so realPc advances by instr.length for every non-pseudo instruction.
-export function resolveLabels(
-  bc: Instruction[],
-  compiler: Compiler,
-): {
-  bytecode: Instruction[];
-} {
-  // Pass 1 – walk the array and record each label's flat PC, counting
-  // real instructions by their full flat width (1 op + N operands).
-  const labelToPc = new Map<string, number>();
-  let realPc = 0;
-  for (const instr of bc) {
-    const op = instr[0];
-    const operand = instr[1];
-
-    if (
-      op === null &&
-      operand !== null &&
-      typeof operand === "object" &&
-      (operand as any).type === "defineLabel"
-    ) {
-      labelToPc.set((operand as any).label, realPc);
-      continue;
-    }
-
-    if (op === null) continue; // "null" opcodes are never emitted
-
-    // Each instruction occupies 1 slot for the opcode + 1 per operand.
-    // IMPORTANT: 'placeholder' operands are not counted
-    realPc += instr.filter((x) => (x as any)?.placeholder !== true).length;
-  }
-
-  // Pass 2 – build the resolved instruction list.
-  // Label refs may appear at any operand position, so scan all of them.
-  const resolved: any[] = [];
-  for (const instr of bc) {
-    const [op, ...operands] = instr;
-
-    // Replace label-ref and encodedLabel operands with resolved flat PCs.
-    // encodedLabel applies an encoding to the PC before emission so that raw
-    // jump targets are hidden; the dispatcher block reverses it at runtime.
-    // To change the encoding scheme, update both here and in jumpDispatcher.ts.
-    const newOperands = operands.map((operand) => {
-      if (
-        operand === undefined ||
-        operand === null ||
-        typeof operand !== "object"
-      )
-        return operand;
-
-      const type = (operand as any).type;
-
-      if (type === "label") {
-        const pc = labelToPc.get((operand as any).label);
-        if (pc === undefined)
-          throw new Error(`Undefined label: ${(operand as any).label}`);
-
-        let resolvedValue = pc + ((operand as any).offset ?? 0);
-        if ((operand as any).transform) {
-          resolvedValue = (operand as any).transform(resolvedValue);
-        }
-
-        const newOperand = {
-          type: "number",
-          resolvedValue: resolvedValue,
-        };
-        return Object.assign(operand, newOperand);
-      }
-
-      return operand;
-    });
-
-    const newInstr = [op, ...newOperands];
-    (newInstr as any)[SOURCE_NODE_SYM] = (instr as any)[SOURCE_NODE_SYM];
-
-    // Pseudo-op "defineLabel"s are kept within this bytecode as the Serializer is responsible for dropping it, and its useful information for comment generation
-    resolved.push(newInstr);
-  }
-
-  // Patch each function descriptor's startPc now that labels are resolved.
-  for (const desc of compiler.fnDescriptors) {
-    desc.startPc =
-      labelToPc.get(desc.startLabel) ?? labelToPc.get(desc.entryLabel);
-  }
-
-  return {
-    bytecode: resolved,
-  };
-}

package/src/transforms/bytecode/resolveRegisters.ts

@@ -1,221 +0,0 @@
-// 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 };
-}