js-confuser-vm 0.0.6 → 0.0.7

package/src/runtime.ts

@@ -82,6 +82,7 @@ function VM(bytecode, mainStartPc, mainRegCount, constants, globals) {
     startPc: mainStartPc, // <- where main begins
   };
   this._currentFrame = new Frame(new Closure(mainFn), null, null, undefined, 0);
+  this._internals = {};
 }
 
 // Consume the next slot from the flat bytecode stream and advance the PC.
@@ -820,7 +821,10 @@ for (var k of Object.getOwnPropertyNames(globalThis)) {
 // If a window object is in scope (browser or test harness), capture it
 // explicitly so VM code can read/write window.TEST_OUTPUT etc.
 if (typeof window !== "undefined") {
-  globals["window"] = window;
+  globals.window = window;
+  for (var k of Object.getOwnPropertyNames(window)) {
+    globals[k] = window[k];
+  }
 }
 
 // Transfer common primitives

package/src/transforms/bytecode/aliasedOpcodes.ts

@@ -46,15 +46,6 @@ export function aliasedOpcodes(
     baseOpValueToName.set(val as number, name);
   }
 
-  // Collect all currently used opcode slots (base + any dynamically assigned)
-  const usedOpcodes = new Set<number>(
-    Object.keys(compiler.OP_NAME)
-      .map((k) => parseInt(k, 10))
-      .filter((v) => !isNaN(v)),
-  );
-
-  if (usedOpcodes.size > U16_MAX) return { bytecode: bc };
-
   // ── Step 1: count frequency and determine arity for each eligible base opcode ─
   // We scan the actual post-transform bytecode so frequency reflects what's
   // really left (specialized/macro ops already consumed their share).
@@ -92,7 +83,7 @@ export function aliasedOpcodes(
   const aliasedOps: Compiler["ALIASED_OPS"] = {};
 
   for (const [originalOp, stats] of candidates) {
-    const aliasOp = nextFreeSlot(usedOpcodes);
+    const aliasOp = nextFreeSlot(compiler);
     if (aliasOp === -1) break;
 
     const arity = stats.arity!;
@@ -116,8 +107,7 @@ export function aliasedOpcodes(
     aliasMap.set(originalOp, aliasOp);
     aliasedOps[aliasOp] = { originalOp, order };
 
-    const originalName =
-      compiler.OP_NAME[originalOp] ?? `OP_${originalOp}`;
+    const originalName = compiler.OP_NAME[originalOp] ?? `OP_${originalOp}`;
     compiler.OP_NAME[aliasOp] = `ALIAS_${originalName}_${order.join("_")}`;
   }
 

package/src/transforms/bytecode/macroOpcodes.ts

@@ -1,6 +1,7 @@
 import type { Bytecode, Instruction } from "../../types.ts";
 import { Compiler, SOURCE_NODE_SYM } from "../../compiler.ts";
 import { nextFreeSlot, U16_MAX } from "../../utils/op-utils.ts";
+import { ok } from "node:assert";
 
 // Opcodes that must not appear in a non-terminal position inside a macro window.
 // Jump ops: modifying frame._pc mid-execution causes the macro handler to
@@ -21,8 +22,7 @@ import { nextFreeSlot, U16_MAX } from "../../utils/op-utils.ts";
 // Algorithm:
 //   1. Count every eligible window of length 2–5 by its op-code signature.
 //   2. Keep sequences that appear >= 2 times; sort by frequency then length.
-//   3. Assign unused opcode values (0–255, not already claimed by compiler.OP)
-//      to the most-frequent candidates and store in compiler.MACRO_OPS.
+//   3. Use nextFreeSlot() to assign a new opcode to each of the best candidates
 //   4. Re-scan bytecode, replacing each matched sequence with a single
 //      multi-operand instruction:
 //        [macroOpCode, operands_of_instr_0..., operands_of_instr_1..., ...]
@@ -38,43 +38,39 @@ export function macroOpcodes(
     originalOpToName.set(opVal, name);
   }
 
+  // Names are used instead of codes as specialized opcodes may generate based off these and it should not be considered eligible still
+  const alwaysExcluded = [
+    "PATCH",
+    "TRY_SETUP",
+    "TRY_END",
+    "DEBUGGER",
+    "MAKE_CLOSURE",
+  ];
+
+  const nonTerminalExcluded = ["RETURN", "CALL", "CALL_METHOD", "NEW", "THROW"];
+
   function isEligible(
     op: number | null,
     compiler: Compiler,
     isLast: boolean = false,
   ): boolean {
     if (op === null) return false;
-    const { OP, JUMP_OPS } = compiler;
+    const { OP, JUMP_OPS, OP_NAME } = compiler;
     // Infrastructure and variable-length ops are never eligible.
-    const alwaysExcluded = new Set([
-      OP.PATCH,
-      OP.TRY_SETUP,
-      OP.TRY_END,
-      OP.DEBUGGER,
-      OP.MAKE_CLOSURE, // variable-length operands — cannot generate a static handler
-    ]);
-    if (alwaysExcluded.has(op)) return false;
+    const opName = OP_NAME[op];
+    ok(opName, `Unknown opcode ${op} (not in OP_NAME)`);
+    if (alwaysExcluded.find((name) => opName.includes(name))) return false;
+
     // Jump and frame-changing ops are only eligible as the terminal instruction.
     if (!isLast) {
       if (JUMP_OPS.has(op)) return false;
-      const nonTerminalExcluded = new Set([
-        OP.RETURN,
-        OP.CALL,
-        OP.CALL_METHOD,
-        OP.NEW,
-        OP.THROW,
-      ]);
-      if (nonTerminalExcluded.has(op)) return false;
+
+      if (nonTerminalExcluded.find((name) => opName.includes(name)))
+        return false;
     }
-    return originalOpToName.has(op); // Only original Ops are eligible (specialized disallowed)
+    return OP_NAME[op] !== undefined;
   }
 
-  // Collect every opcode value already in use so we can find free slots.
-  const usedOpcodes = new Set<number>(
-    Object.values(compiler.OP).filter((v) => v !== undefined) as number[],
-  );
-  if (usedOpcodes.size > U16_MAX) return { bytecode: bc };
-
   // ── Step 1: count window frequencies ──────────────────────────────────────
   const freqMap = new Map<string, { ops: number[]; count: number }>();
 
@@ -85,7 +81,8 @@ export function macroOpcodes(
       const ops: number[] = [];
       let valid = true;
       for (let j = 0; j < len; j++) {
-        const op = bc[i + j][0];
+        const instr = bc[i + j];
+        const op = instr[0];
         const isLast = j === len - 1;
         if (!isEligible(op, compiler, isLast)) {
           valid = false;
@@ -116,7 +113,7 @@ export function macroOpcodes(
 
   // ── Step 3: assign free opcode slots to the best candidates ───────────────
   for (let i = 0; i < candidates.length; i++) {
-    const macroOp = nextFreeSlot(usedOpcodes);
+    const macroOp = nextFreeSlot(compiler);
     if (macroOp === -1) break;
     const ops = candidates[i].ops;
     compiler.MACRO_OPS[macroOp] = ops;
@@ -169,7 +166,9 @@ export function macroOpcodes(
       // Each instruction contributes instr.slice(1) — zero or more operands.
       const allOperands: any[] = [];
       for (let j = 0; j < len; j++) {
-        allOperands.push(...bc[i + j].slice(1));
+        var instr = bc[i + j];
+        var operands = instr.slice(1);
+        allOperands.push(...operands);
       }
 
       const newInstr: Instruction = [macroOpCode, ...allOperands];

package/src/transforms/bytecode/microOpcodes.ts

@@ -0,0 +1,291 @@
+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/resolveContants.ts

@@ -19,8 +19,7 @@ function concealString(s: string, key: number): string {
   return Buffer.from(bytes).toString("base64");
 }
 
-// Resolve all {type:"constant", value} operands to a PAIR of integer operands:
-//   [constPoolIndex, concealKey]
+// Resolve all {type:"constant", value} (index) and {type:"constant", value, key: true} (key) operands
 //
 // constPoolIndex — index into the constants array (as before).
 // concealKey     — XOR key used to conceal this constant.
@@ -43,8 +42,6 @@ export function resolveConstants(
   const keyMap = new Map<number, number>(); // pool index → conceal key
 
   function intern(operand: b.InstrOperand): [b.InstrOperand, number] {
-    const operandAsObject =
-      typeof operand === "object" && operand ? operand : {};
     const value = (operand as any).value;
 
     let idx = constantsMap.get(value);
@@ -79,13 +76,11 @@ export function resolveConstants(
     }
 
     const idxOperand: any = {
-      ...(operandAsObject as object),
       type: "number",
       resolvedValue: idx,
     };
 
     const keyOperand: any = {
-      ...(operandAsObject as object),
       type: "number",
       resolvedValue: key,
     };
@@ -108,19 +103,17 @@ export function resolveConstants(
 
     if (hasConstant) {
       // 1-to-2 expansion: each {type:"constant"} becomes [constIdx, concealKey].
-      const newOperands: b.InstrOperand[] = [];
-      for (const operand of operands) {
+      const newOperands: b.InstrOperand[] = operands.map((operand) => {
         if ((operand as any)?.type === "constant") {
           const [idxOperand, key] = intern(operand);
-
           const newOperand = (operand as any)?.key ? key : idxOperand;
 
-          newOperands.push(newOperand);
-          // newOperands.push(key); // plain number — serialized as a regular u16 slot
+          return Object.assign(operand, newOperand);
         } else {
-          newOperands.push(operand);
+          return operand;
         }
-      }
+      });
+
       const newInstr = [op, ...newOperands] as b.Instruction;
       (newInstr as any)[SOURCE_NODE_SYM] = (instr as any)[SOURCE_NODE_SYM];
       resolved.push(newInstr);

package/src/transforms/bytecode/resolveLabels.ts

@@ -76,15 +76,16 @@ export function resolveLabels(
         if (pc === undefined)
           throw new Error(`Undefined label: ${(operand as any).label}`);
 
-        var operandAsObject =
-          typeof operand === "object" && operand ? operand : {};
-
         const newOperand = {
-          ...operandAsObject, // Preverse original operand properties
           type: "number",
           resolvedValue: pc + ((operand as any).offset ?? 0),
         };
 
+        // Mutate original object so that references are also updated
+        if (typeof operand === "object" && operand !== null) {
+          return Object.assign(operand, newOperand);
+        }
+
         return newOperand;
       }
       return operand;

package/src/transforms/bytecode/specializedOpcodes.ts

@@ -5,6 +5,17 @@ import {
   nextFreeSlot,
   U16_MAX,
 } from "../../utils/op-utils.ts";
+import * as t from "@babel/types";
+import * as b from "../../types.ts";
+
+export const nSizedOps = [
+  "MAKE_CLOSURE",
+  "BUILD_ARRAY",
+  "BUILD_OBJECT",
+  "CALL",
+  "CALL_METHOD",
+  "NEW",
+];
 
 // Creates specialized opcodes for the most frequent (OPCODE + single_integer_operand) pairs.
 // Example: [OP.LOAD_CONST, 1] becomes [SPECIALIZED_LOAD_CONST_1].
@@ -15,23 +26,7 @@ export function specializedOpcodes(
   bc: Bytecode,
   compiler: Compiler,
 ): { bytecode: Bytecode } {
-  const disallowedOps = new Set([
-    compiler.OP.MAKE_CLOSURE,
-    compiler.OP.BUILD_ARRAY,
-    compiler.OP.BUILD_OBJECT,
-    compiler.OP.CALL,
-    compiler.OP.CALL_METHOD,
-    compiler.OP.NEW,
-  ]);
-
-  // ── Collect used opcodes exactly as specified ─────────────────────────────
-  const usedOpcodes = new Set<number>(
-    Object.keys(compiler.OP_NAME)
-      .map((k) => parseInt(k, 10))
-      .filter((v) => !isNaN(v)) as number[],
-  );
-
-  if (usedOpcodes.size > U16_MAX) return { bytecode: bc };
+  const disallowedOps = new Set(nSizedOps.map((name) => compiler.OP[name]));
 
   // ── Step 1: count frequency of eligible (op, operand) pairs ───────────────
   const freqMap = new Map<
@@ -52,7 +47,22 @@ export function specializedOpcodes(
     const operandCount = getInstructionSize(instr) - 1;
     if (operandCount < 1 || operandCount > 6) continue;
 
-    const operands = instr.slice(1);
+    // Convert numbers into operand objects so they can be modified elsewhere and preserved
+    const oldOperands = instr.slice(1);
+    const operands = oldOperands.map((operand) => {
+      if (typeof operand === "number") {
+        return {
+          type: "number",
+          value: operand,
+          resolvedValue: operand,
+        } as InstrOperand;
+      }
+      return operand;
+    });
+
+    instr.length = 1;
+    instr.push(...operands);
+
     const operandsKey = JSON.stringify(operands);
 
     const key = `${op},${operandsKey}`;
@@ -60,7 +70,12 @@ export function specializedOpcodes(
     if (entry) {
       entry.occurences++;
     } else {
-      freqMap.set(key, { op, operands, operandsKey, occurences: 1 });
+      freqMap.set(key, {
+        op,
+        operands,
+        operandsKey,
+        occurences: 1,
+      });
     }
   }
 
@@ -76,7 +91,7 @@ export function specializedOpcodes(
   const specializedOps: Compiler["SPECIALIZED_OPS"] = {};
 
   for (let i = 0; i < candidates.length; i++) {
-    const specialOp = nextFreeSlot(usedOpcodes);
+    const specialOp = nextFreeSlot(compiler);
     if (specialOp === -1) break;
     const { op: originalOp, operands, operandsKey } = candidates[i];
 
@@ -118,21 +133,16 @@ export function specializedOpcodes(
     }
 
     const newOperands = operands.map((operand) => {
-      const operandAsObject =
+      const operandAsObject: any =
         typeof operand === "object" && operand
           ? operand
           : {
               type: "number",
-              value: operand,
               resolvedValue: operand,
             };
 
-      const newOperand = {
-        ...operandAsObject,
-        placeholder: true,
-      } as any as InstrOperand;
-
-      return newOperand;
+      operandAsObject.placeholder = true;
+      return operandAsObject;
     });
 
     const newInstr: Instruction = [specialOpCode, ...newOperands];