js-confuser-vm 0.1.1 → 0.1.2

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,226 +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;
-    pinned?: boolean;
-  }): string {
-    // Pinned registers must never share a slot with anything else.
-    // Passes set this on registers whose live range crosses a CFF back-edge
-    // that the linear-scan liveness analysis cannot see.
-    if (op.pinned) return "local::";
-    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/selfModifying.ts

@@ -1,121 +0,0 @@
-import type { Bytecode, Instruction } from "../../types.ts";
-import { Compiler } from "../../compiler.ts";
-import { choice } from "../../utils/random-utils.ts";
-import { getInstructionSize } from "../../utils/op-utils.ts";
-
-export function selfModifying(
-  bc: Bytecode,
-  compiler: Compiler,
-): { bytecode: Bytecode } {
-  // Walk the bytecode looking for "defineLabel" pseudo-ops, which start basic
-  // blocks. For each block we collect the body (instructions between the label
-  // and the next label/jump terminator), move it to the end of the bytecode
-  // under a fresh "patch_LXX" label, and replace it in-place with:
-  //
-  //   defineLabel ("originalLabel")               ← kept as-is (pseudo-op)
-  //   PATCH  destPc  sliceStart  sliceEnd          ← 4 flat slots total
-  //   Garbage Opcodes  × bodyFlatSize                         ← placeholder slots
-  //
-  // PATCH reads three inline operands via _operand():
-  //   destPc     = originalLabel + 4  (first slot after PATCH's own 4 slots)
-  //   sliceStart = patchLabel          (flat PC of appended body)
-  //   sliceEnd   = patchLabel + bodyFlatSize
-  //
-  // On first execution PATCH copies bytecode[sliceStart..sliceEnd) over the
-  // placeholder region starting at destPc.  Execution then falls through into
-  // the freshly-patched body.  Subsequent calls are idempotent.
-
-  const { OP, JUMP_OPS } = compiler;
-
-  const result: Bytecode = [];
-  const appended: Bytecode = [];
-  let patchCount = 0;
-
-  let i = 0;
-  while (i < bc.length) {
-    const instr = bc[i];
-    const [op, operand] = instr;
-
-    // Detect a defineLabel pseudo-op — start of a new basic block.
-    if (
-      op === null &&
-      operand !== null &&
-      typeof operand === "object" &&
-      (operand as any).type === "defineLabel"
-    ) {
-      const originalLabel = (operand as any).label as string;
-      result.push(instr); // keep the defineLabel marker
-      i++;
-
-      // Collect body: everything after the label until the next terminator.
-      let j = i;
-      while (j < bc.length) {
-        const [nextOp, nextOperand] = bc[j];
-
-        // Another defineLabel = boundary of the next block.
-        if (
-          nextOp === null &&
-          typeof nextOperand === "object" &&
-          (nextOperand as any)?.type === "defineLabel"
-        ) {
-          break;
-        }
-
-        // Jump instructions, RETURN all terminate the body.
-        if (nextOp !== null && (JUMP_OPS.has(nextOp) || nextOp === OP.RETURN)) {
-          break;
-        }
-
-        j++;
-      }
-
-      const body = bc.slice(i, j);
-      const N = body.length;
-
-      if (N === 0) {
-        // Nothing to transform — label is immediately followed by a terminator.
-        continue;
-      }
-
-      const patchLabel = `patch_${originalLabel}_${patchCount++}`;
-
-      // Flat size of the body (each instruction occupies instr.length slots).
-      const bodyFlatSize = body.reduce(
-        (acc, instr) => acc + getInstructionSize(instr),
-        0,
-      );
-
-      // ── PATCH instruction (4 flat slots: opcode + 3 operands) ───────────
-      //   destPc     = originalLabel + 4  (slot right after PATCH's 4 slots)
-      //   sliceStart = patchLabel
-      //   sliceEnd   = patchLabel + bodyFlatSize
-      result.push([
-        OP.PATCH as number,
-        { type: "label", label: originalLabel, offset: 4 },
-        { type: "label", label: patchLabel },
-        { type: "label", label: patchLabel, offset: bodyFlatSize },
-      ] as unknown as Instruction);
-
-      // ── Placeholders (Garbage Opcodes * bodyFlatSize, each 1 flat slot) ────────────
-      // These are overwritten by PATCH on first execution.
-      for (let p = 0; p < bodyFlatSize; p++) {
-        const randomOpcode = choice(Object.values(compiler.OP));
-        result.push([+randomOpcode]);
-      }
-
-      // ── Append real body at end ─────────────────────────────────────────
-      appended.push([null, { type: "defineLabel", label: patchLabel }]);
-      for (const bodyInstr of body) {
-        appended.push(bodyInstr);
-      }
-
-      i = j; // skip over the original body in the input array
-      continue;
-    }
-
-    result.push(instr);
-    i++;
-  }
-
-  return { bytecode: [...result, ...appended] };
-}

package/src/transforms/bytecode/specializedOpcodes.ts

@@ -1,164 +0,0 @@
-import type { Bytecode, InstrOperand, Instruction } from "../../types.ts";
-import { Compiler, SOURCE_NODE_SYM } from "../../compiler.ts";
-import { getInstructionSize, nextFreeSlot } from "../../utils/op-utils.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].
-// Only instructions that are fixed-sized are considered.
-// MAKE_CLOSURE and other N-sized instructions cannot be specialized
-// 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,
-): { bytecode: Bytecode } {
-  const disallowedOps = new Set(nSizedOps.map((name) => compiler.OP[name]));
-
-  // ── Step 1: count frequency of eligible (op, operand) pairs ───────────────
-  const freqMap = new Map<
-    string,
-    {
-      op: number;
-      operands: InstrOperand[];
-      operandsKey: string;
-      occurences: number;
-    }
-  >();
-
-  const instrToOperandKey = new WeakMap<Instruction, string>();
-
-  for (const instr of bc) {
-    const op = instr[0];
-    if (op === null || disallowedOps.has(op)) continue;
-
-    // Only supports between 1-6 operands
-    const operandCount = getInstructionSize(instr) - 1;
-    if (operandCount < 1 || operandCount > 6) continue;
-
-    // Convert numbers into operand objects so they can be modified elsewhere and preserved
-    const oldOperands = instr.slice(1);
-
-    let operands = [];
-
-    for (const operand of oldOperands) {
-      if (typeof operand === "number") {
-        operands.push({
-          type: "number",
-          value: operand,
-          resolvedValue: operand,
-        } as InstrOperand);
-      } else {
-        operands.push(operand as InstrOperand);
-      }
-    }
-
-    instr.length = 1;
-    instr.push(...operands);
-
-    const operandsKey = JSON.stringify(operands);
-    instrToOperandKey.set(instr, operandsKey);
-
-    const key = `${op},${operandsKey}`;
-    const entry = freqMap.get(key);
-    if (entry) {
-      entry.occurences++;
-    } else {
-      freqMap.set(key, {
-        op,
-        operands,
-        operandsKey,
-        occurences: 1,
-      });
-    }
-  }
-
-  // ── Step 2: keep combinations that appear >= 2 times, sort by frequency ───
-  const candidates = Array.from(freqMap.values())
-    .filter((e) => e.occurences >= 1)
-    .sort((a, b) => b.occurences - a.occurences)
-    .slice(0, 1000);
-
-  if (candidates.length === 0) return { bytecode: bc };
-
-  // ── Step 3: assign free opcode slots to the best candidates ───────────────
-  const sigToSpecial = new Map<string, number>();
-  const specializedOps: Compiler["SPECIALIZED_OPS"] = {};
-
-  for (const candidate of candidates) {
-    const specialOp = nextFreeSlot(compiler);
-    if (specialOp === -1) break;
-    const { op: originalOp, operands, operandsKey } = candidate;
-
-    const key = `${originalOp},${operandsKey}`;
-    sigToSpecial.set(key, specialOp);
-
-    specializedOps[specialOp] = { originalOp, operands };
-
-    // Register a human-readable name for disassembly / debugging
-    const originalName = compiler.OP_NAME[originalOp] ?? `OP_${originalOp}`;
-    compiler.OP_NAME[specialOp] = `${originalName}_${operandsKey}`;
-  }
-
-  // Store mapping so the interpreter knows how to dispatch the specialized op
-  compiler.SPECIALIZED_OPS = specializedOps;
-
-  // ── Step 4: replace matching instructions with the new single-byte opcode ─
-  const result: Bytecode = [];
-
-  for (const instr of bc) {
-    const op = instr[0];
-    // Only consider instructions with one or more operands
-    if (op === null || instr.length <= 1 || op === compiler.OP.MAKE_CLOSURE) {
-      result.push(instr);
-      continue;
-    }
-
-    const operands = instr.slice(1);
-    const operandsKey = instrToOperandKey.get(instr);
-    if (!operandsKey) {
-      result.push(instr);
-      continue;
-    }
-
-    const key = `${op},${operandsKey}`;
-
-    const specialOpCode = sigToSpecial.get(key)!;
-
-    if (!specialOpCode) {
-      result.push(instr);
-      continue;
-    }
-
-    const newOperands = operands.map((operand) => {
-      const operandAsObject: any =
-        typeof operand === "object" && operand
-          ? operand
-          : {
-              type: "number",
-              resolvedValue: operand,
-            };
-
-      operandAsObject.placeholder = true;
-      return operandAsObject;
-    });
-
-    const newInstr: Instruction = [specialOpCode, ...newOperands];
-
-    // Preserve source-node information for error reporting
-    (newInstr as any)[SOURCE_NODE_SYM] = (instr as any)[SOURCE_NODE_SYM];
-
-    result.push(newInstr);
-  }
-
-  return { bytecode: result };
-}