js-confuser-vm 0.0.8 → 0.1.0

package/dist/transforms/bytecode/resolveRegisters.js

@@ -0,0 +1,212 @@
+// 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.
+
+export function resolveRegisters(bc, compiler) {
+  function registerPoolKey(op) {
+    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.
+
+  // fnId -> virtId -> RegInfo
+  const fnRegInfo = new Map();
+  for (let i = 0; i < bc.length; i++) {
+    const instr = bc[i];
+    for (let j = 1; j < instr.length; j++) {
+      const op = instr[j];
+      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();
+
+  // Pool ordering: "local::" always first; all other keys sorted alphabetically.
+  function poolSortKey(key) {
+    return key === "local::" ? [0, ""] : [1, key];
+  }
+  for (const [fnId, regMap] of fnRegInfo) {
+    // Group by pool key.
+    const pools = new Map();
+    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(); // 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 = [];
+        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;
+          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];
+      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];
+      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/dist/transforms/bytecode/specializedOpcodes.js

@@ -4,9 +4,11 @@ export const nSizedOps = ["MAKE_CLOSURE", "BUILD_ARRAY", "BUILD_OBJECT", "CALL",
 
 // 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, compiler) {
   const disallowedOps = new Set(nSizedOps.map(name => compiler.OP[name]));
 

package/dist/types.js

@@ -6,10 +6,51 @@
 // 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").
+
+// A placeholder for a function's concrete regCount, emitted in MAKE_CLOSURE.
+// resolveRegisters() fills resolvedValue once it knows the concrete slot count.
+
+// 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 function constantOperand(value) {
   return {
     type: "constant",
     value: value
   };
+}
+export function registerOperand(id, fnId, metadata = {}) {
+  return {
+    type: "register",
+    id,
+    fnId,
+    ...metadata
+  };
+}
+export function fnRegCountOperand(fnId) {
+  return {
+    type: "fnRegCount",
+    fnId
+  };
+}
+export function freeRegOperand(reg) {
+  const op = {
+    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/dist/utils/op-utils.js

@@ -31,6 +31,7 @@ export function nextFreeSlot(compiler) {
   return -1;
 }
 export function getInstructionSize(instr) {
+  if (instr[0] === null) return 0;
   const size = instr.filter(op => op?.placeholder !== true).length;
   return size;
 }

package/index.ts

@@ -13,6 +13,7 @@ async function main() {
     shuffleOpcodes: true, // shuffle order of opcode handlers in the runtime?
     encodeBytecode: true, // encode the bytecode array?
     concealConstants: true, // conceal strings and integers in the constant pool?
+    dispatcher: true, // create middleman blocks to process jumps?
     selfModifying: true, // do self-modifying bytecode for function bodies?
     macroOpcodes: true, // create combined opcodes for repeated instruction sequences?
     microOpcodes: true, // break opcodes into sub-opcodes?

package/jest.config.js

@@ -19,6 +19,10 @@ const OPTIONS_MATRIX = [
     displayName: "concealConstants",
     VM_OPTIONS: { concealConstants: true },
   },
+  {
+    displayName: "dispatcher",
+    VM_OPTIONS: { dispatcher: true },
+  },
   {
     displayName: "all",
     VM_OPTIONS: {
@@ -32,6 +36,7 @@ const OPTIONS_MATRIX = [
       specializedOpcodes: true,
       aliasedOpcodes: true,
       concealConstants: true,
+      dispatcher: true,
     },
   },
 ];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "js-confuser-vm",
-  "version": "0.0.8",
+  "version": "0.1.0",
   "main": "dist/index.js",
   "scripts": {
     "build": "babel src --out-dir dist --extensions \".ts,.js\"",
@@ -23,7 +23,7 @@
   ],
   "author": "MichaelXF",
   "license": "MIT",
-  "description": "",
+  "description": "Experimental JS VM Obfuscator",
   "dependencies": {
     "@babel/generator": "^7.29.1",
     "@babel/parser": "^7.29.0",
@@ -43,6 +43,14 @@
     "glob": "^13.0.6",
     "jest": "^30.2.0"
   },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/MichaelXF/js-confuser-vm"
+  },
+  "bugs": {
+    "url": "https://github.com/MichaelXF/js-confuser-vm/issues"
+  },
+  "homepage": "https://js-confuser.com/vm",
   "engines": {
     "node": ">=18.0.0"
   }