js-confuser-vm 0.1.0 → 0.1.2

package/dist/runtime.js

@@ -5,29 +5,34 @@ const MAIN_REG_COUNT = 0;
 const CONSTANTS = [];
 const ENCODE_BYTECODE = false;
 const TIMING_CHECKS = false;
+const SENTINELS = {
+  CALL_SPREAD: 0
+};
 // The text above is not included in the compiled output - for type intellisense only
 // @START
 
-function decodeBytecode(s) {
-  if (!ENCODE_BYTECODE) return s;
-  var b = typeof Buffer !== "undefined" ? Buffer.from(s, "base64") : Uint8Array.from(atob(s), function (c) {
+function base64ToBytes(s) {
+  return typeof Buffer !== "undefined" ? Buffer.from(s, "base64") : Uint8Array.from(atob(s), function (c) {
     return c.charCodeAt(0);
   });
-  // Each slot is a u16 stored as 2 little-endian bytes.
-  var r = new Uint16Array(b.length / 2);
-  for (var i = 0; i < r.length; i++) r[i] = b[i * 2] | b[i * 2 + 1] << 8;
+}
+function decodeBytecode(s) {
+  if (!ENCODE_BYTECODE) return s;
+  var b = base64ToBytes(s);
+  // Each slot is a u32 stored as 4 little-endian bytes.
+  var r = new Uint32Array(b.length / 4);
+  for (var i = 0; i < r.length; i++) r[i] = (b[i * 4] | b[i * 4 + 1] << 8 | b[i * 4 + 2] << 16 | b[i * 4 + 3] << 24) >>> 0;
   return r;
 }
 
-// Closure symbol
-// Used to tag shell functions so the VM can fast-path back to the
-// inner Closure instead of going through a sub-VM on internal calls.
-var CLOSURE_SYM = Symbol(); // Nameless for obfuscation
+// Closure map
+// Maps shell functions -> inner Closure so the VM can fast-path instead of going through a sub-VM on internal calls.
+// A WeakMap is used over a Symbol to prevent leaking information to debuggers
+var CLOSURE_MAP = new WeakMap();
 
-// Upvalue — Lua/CPython style.
+// Upvalue (Lua style)
 // While the outer frame is alive: reads/writes go to vm._regs[_absSlot].
 // After the outer frame returns (closed): reads/writes hit this._value.
-// _absSlot is the absolute index in VM._regs (frame._base + local slot).
 function Upvalue(regs, absSlot) {
   this._regs = regs; // shared reference to VM._regs flat array
   this._absSlot = absSlot; // absolute index; stable as long as frame is alive
@@ -52,7 +57,7 @@ function Closure(fn) {
   this.prototype = {}; // <- default prototype object for `new`
 }
 
-// Frame — analogous to Lua CallInfo / CPython PyFrameObject.
+// Frame (Lua CallInfo / CPython PyFrameObject)
 // Does NOT own a register array; registers live in VM._regs[_base .. _base+regCount).
 function Frame(closure, returnPc, parent, thisVal, retDstReg, base) {
   this.closure = closure;
@@ -74,8 +79,8 @@ function VM(bytecode, mainStartPc, mainRegCount, constants, globals) {
   this._frameStack = [];
   this._openUpvalues = [];
 
-  // ── Flat register file (Lua-style) ────────────────────────────────────────
-  // All frames share a single array.  Each Frame records its _base offset.
+  // Flat register array (Lua-style)
+  // Each Frame records its _base offset.
   // _regsTop is the next free slot (= base of the hypothetical next frame).
   // On CALL:   newBase = _regsTop; _regsTop += fn.regCount
   // On RETURN: _regsTop = frame._base   (pop the frame's register window)
@@ -88,7 +93,6 @@ function VM(bytecode, mainStartPc, mainRegCount, constants, globals) {
     startPc: mainStartPc
   };
   this._currentFrame = new Frame(new Closure(mainFn), null, null, undefined, 0, 0);
-  this._internals = {};
 }
 
 // Consume the next slot from the flat bytecode stream and advance the PC.
@@ -109,8 +113,8 @@ VM.prototype.captureUpvalue = function (frame, slot) {
 };
 
 // Reads and decodes a constant from the pool.
-// idx  — pool index (first operand of the constant pair emitted by resolveConstants).
-// key  — conceal key (second operand). 0 means no concealment.
+// idx: pool index (first operand of the constant pair emitted by resolveConstants).
+// key: conceal key (second operand). 0 means no concealment.
 //
 // For integers:  stored value is (original ^ key); XOR again to recover.
 // For strings:   stored value is a base64 string containing u16 LE byte pairs.
@@ -124,9 +128,7 @@ VM.prototype._constant = function (idxIn, keyIn) {
   if (!key) return v;
   if (typeof v === "number") return v ^ key;
   // String: base64-decode to u16 LE byte pairs, then XOR each code with (key+i).
-  var b = typeof Buffer !== "undefined" ? Buffer.from(v, "base64") : Uint8Array.from(atob(v), function (c) {
-    return c.charCodeAt(0);
-  });
+  var b = base64ToBytes(v);
   var out = "";
   for (var i = 0; i < b.length / 2; i++) {
     var code = b[i * 2] | b[i * 2 + 1] << 8; // u16 LE
@@ -164,11 +166,7 @@ VM.prototype.run = function () {
     var pc = frame._pc++;
     var op = this.bytecode[pc];
     var opcode = this.bytecode[pc];
-    // console.log(
-    //   "pc=" + pc,
-    //   "opcode=" + opcode,
-    //   Object.keys(OP).find((key) => OP[key] === opcode),
-    // );
+    // console.log(`[run] pc=${pc}, opcode=${opcode}, name=${Object.keys(OP).find((key) => OP[key] === opcode)}`);
 
     // Debugging protection: Detects debugger by checking for >1s pauses which can only happen from debugger; or extremely slow sync tasks
     if (TIMING_CHECKS) {
@@ -187,6 +185,7 @@ VM.prototype.run = function () {
     try {
       var regs = this._regs;
       var base = frame._base;
+
       /* @SWITCH */
       switch (op) {
         case OP.LOAD_CONST:
@@ -231,8 +230,7 @@ VM.prototype.run = function () {
           }
         case OP.STORE_GLOBAL:
           {
-            // nameIdx and key are consumed inline so the concealConstants runtime
-            // transform can rewrite this._constant() consistently.
+            // globals[globalName] = regs[src]
             this.globals[this._constant()] = regs[base + this._operand()];
             break;
           }
@@ -257,13 +255,14 @@ VM.prototype.run = function () {
             var obj = regs[base + this._operand()];
             var key = regs[base + this._operand()];
             var val = regs[base + this._operand()];
-            // Reflect.set performs [[Set]] without throwing on failure,
-            // correctly simulating sloppy-mode assignment from a strict-mode host.
+            // Reflect.set performs [[Set]] without throwing on failure (non-strict mode behavior)
             Reflect.set(obj, key, val);
             break;
           }
         case OP.DELETE_PROP:
           {
+            // regs[dst] = delete regs[obj][regs[key]]
+            // The delete operator returns true if successful which is most cases
             var dst = this._operand();
             var obj = regs[base + this._operand()];
             var key = regs[base + this._operand()];
@@ -271,7 +270,7 @@ VM.prototype.run = function () {
             break;
           }
 
-        // ── Arithmetic  (dst, src1, src2) ────────────────────────────────────
+        // Arithmetic  (dst, src1, src2)
         case OP.ADD:
           {
             var dst = this._operand();
@@ -307,6 +306,14 @@ VM.prototype.run = function () {
             regs[base + dst] = a % regs[base + this._operand()];
             break;
           }
+        case OP.EXP:
+          {
+            // Math.pow instead of `**`
+            var dst = this._operand();
+            var a = regs[base + this._operand()];
+            regs[base + dst] = Math.pow(a, regs[base + this._operand()]);
+            break;
+          }
         case OP.BAND:
           {
             var dst = this._operand();
@@ -350,7 +357,7 @@ VM.prototype.run = function () {
             break;
           }
 
-        // ── Comparison  (dst, src1, src2) ─────────────────────────────────────
+        // Comparison  (dst, src1, src2)
         case OP.LT:
           {
             var dst = this._operand();
@@ -416,29 +423,15 @@ VM.prototype.run = function () {
           }
         case OP.INSTANCEOF:
           {
+            // regs[dst] = regs[obj] instanceof regs[ctor]
+            // Since VM closures are wrapped in native function shells (MAKE_CLOSURE), the native operator works
             var dst = this._operand();
             var obj = regs[base + this._operand()];
-            var ctor = regs[base + this._operand()];
-            if (typeof ctor === "function") {
-              regs[base + dst] = obj instanceof ctor;
-            } else {
-              // VM Closure - walk prototype chain for identity with ctor.prototype.
-              var proto = ctor.prototype;
-              var target = Object.getPrototypeOf(obj);
-              var result = false;
-              while (target !== null) {
-                if (target === proto) {
-                  result = true;
-                  break;
-                }
-                target = Object.getPrototypeOf(target);
-              }
-              regs[base + dst] = result;
-            }
+            regs[base + dst] = obj instanceof regs[base + this._operand()];
             break;
           }
 
-        // ── Unary  (dst, src) ─────────────────────────────────────────────────
+        // Unary  (dst, src)
         case OP.UNARY_NEG:
           {
             var dst = this._operand();
@@ -472,13 +465,14 @@ VM.prototype.run = function () {
         case OP.VOID:
           {
             var dst = this._operand();
-            this._operand(); // consume src — evaluated for side-effects by compiler
+            this._operand(); // consumes argument (intended)
             regs[base + dst] = undefined;
             break;
           }
         case OP.TYPEOF_SAFE:
           {
-            // dst, nameConstIdx — safe typeof for potentially-undeclared globals.
+            // regs[dst] = typeof window[name]
+            // Never throws ReferenceError, instead returns undefined for undeclared variables
             var dst = this._operand();
             var name = this._constant();
             var val = Object.prototype.hasOwnProperty.call(this.globals, name) ? this.globals[name] : undefined;
@@ -486,7 +480,7 @@ VM.prototype.run = function () {
             break;
           }
 
-        // ── Control flow ──────────────────────────────────────────────────────
+        // Control flow
         case OP.JUMP:
           frame._pc = this._operand();
           break;
@@ -506,23 +500,32 @@ VM.prototype.run = function () {
             break;
           }
 
-        // ── Calls ─────────────────────────────────────────────────────────────
+        // Calls
         case OP.CALL:
           {
-            // dst, calleeReg, argc, [argReg...]
+            // dst, calleeReg, argc, [argReg...]  (argc=-1 means next operand is spread-args array reg)
             var dst = this._operand();
             var callee = regs[base + this._operand()];
             var argc = this._operand();
-            var args = new Array(argc);
-            for (var i = 0; i < argc; i++) args[i] = regs[base + this._operand()];
-            if (callee && callee[CLOSURE_SYM]) {
-              var closure = callee[CLOSURE_SYM];
+            var args;
+            if (argc === SENTINELS.CALL_SPREAD) {
+              args = regs[base + this._operand()];
+            } else {
+              args = new Array(argc);
+              for (var i = 0; i < argc; i++) args[i] = regs[base + this._operand()];
+            }
+            var closure = callee && CLOSURE_MAP.get(callee);
+            if (closure) {
               var newBase = this._regsTop;
               this._ensureRegisterWindow(newBase, closure.fn.regCount);
               this._regsTop = newBase + closure.fn.regCount;
               var f = new Frame(closure, frame._pc, frame, this.globals, dst, newBase);
-              for (var i = 0; i < args.length && i < closure.fn.regCount; i++) {
-                this._regs[newBase + i] = args[i];
+              if (closure.fn.hasRest) {
+                var restSlot = closure.fn.paramCount - 1;
+                for (var i = 0; i < restSlot; i++) this._regs[newBase + i] = i < args.length ? args[i] : undefined;
+                this._regs[newBase + restSlot] = args.slice(restSlot);
+              } else {
+                for (var i = 0; i < args.length && i < closure.fn.regCount; i++) this._regs[newBase + i] = args[i];
               }
               if (closure.fn.paramCount < closure.fn.regCount) {
                 this._regs[newBase + closure.fn.paramCount] = args;
@@ -536,21 +539,30 @@ VM.prototype.run = function () {
           }
         case OP.CALL_METHOD:
           {
-            // dst, receiverReg, calleeReg, argc, [argReg...]
+            // dst, receiverReg, calleeReg, argc, [argReg...]  (argc=SENTINELS.CALL_SPREAD means spread-args array reg)
             var dst = this._operand();
             var receiver = regs[base + this._operand()];
             var callee = regs[base + this._operand()];
             var argc = this._operand();
-            var args = new Array(argc);
-            for (var i = 0; i < argc; i++) args[i] = regs[base + this._operand()];
-            if (callee && callee[CLOSURE_SYM]) {
-              var closure = callee[CLOSURE_SYM];
+            var args;
+            if (argc === SENTINELS.CALL_SPREAD) {
+              args = regs[base + this._operand()];
+            } else {
+              args = new Array(argc);
+              for (var i = 0; i < argc; i++) args[i] = regs[base + this._operand()];
+            }
+            var closure = callee && CLOSURE_MAP.get(callee);
+            if (closure) {
               var newBase = this._regsTop;
               this._ensureRegisterWindow(newBase, closure.fn.regCount);
               this._regsTop = newBase + closure.fn.regCount;
               var f = new Frame(closure, frame._pc, frame, receiver, dst, newBase);
-              for (var i = 0; i < args.length && i < closure.fn.regCount; i++) {
-                this._regs[newBase + i] = args[i];
+              if (closure.fn.hasRest) {
+                var restSlot = closure.fn.paramCount - 1;
+                for (var i = 0; i < restSlot; i++) this._regs[newBase + i] = i < args.length ? args[i] : undefined;
+                this._regs[newBase + restSlot] = args.slice(restSlot);
+              } else {
+                for (var i = 0; i < args.length && i < closure.fn.regCount; i++) this._regs[newBase + i] = args[i];
               }
               if (closure.fn.paramCount < closure.fn.regCount) {
                 this._regs[newBase + closure.fn.paramCount] = args;
@@ -564,21 +576,30 @@ VM.prototype.run = function () {
           }
         case OP.NEW:
           {
-            // dst, calleeReg, argc, [argReg...]
+            // dst, calleeReg, argc, [argReg...]  (argc=SENTINELS.CALL_SPREAD means spread-args array reg)
             var dst = this._operand();
             var callee = regs[base + this._operand()];
             var argc = this._operand();
-            var args = new Array(argc);
-            for (var i = 0; i < argc; i++) args[i] = regs[base + this._operand()];
-            if (callee && callee[CLOSURE_SYM]) {
-              var closure = callee[CLOSURE_SYM];
+            var args;
+            if (argc === SENTINELS.CALL_SPREAD) {
+              args = regs[base + this._operand()];
+            } else {
+              args = new Array(argc);
+              for (var i = 0; i < argc; i++) args[i] = regs[base + this._operand()];
+            }
+            var closure = callee && CLOSURE_MAP.get(callee);
+            if (closure) {
               var newObj = Object.create(closure.prototype || null);
               var newBase = this._regsTop;
               this._ensureRegisterWindow(newBase, closure.fn.regCount);
               this._regsTop = newBase + closure.fn.regCount;
               var f = new Frame(closure, frame._pc, frame, newObj, dst, newBase);
-              for (var i = 0; i < args.length && i < closure.fn.regCount; i++) {
-                this._regs[newBase + i] = args[i];
+              if (closure.fn.hasRest) {
+                var restSlot = closure.fn.paramCount - 1;
+                for (var i = 0; i < restSlot; i++) this._regs[newBase + i] = i < args.length ? args[i] : undefined;
+                this._regs[newBase + restSlot] = args.slice(restSlot);
+              } else {
+                for (var i = 0; i < args.length && i < closure.fn.regCount; i++) this._regs[newBase + i] = args[i];
               }
               if (closure.fn.paramCount < closure.fn.regCount) {
                 this._regs[newBase + closure.fn.paramCount] = args;
@@ -597,10 +618,14 @@ VM.prototype.run = function () {
           {
             var retVal = regs[base + this._operand()];
             this._closeUpvaluesFor(frame); // must happen before frame is abandoned
+
+            // Zero out callee's register window to limit exposing runtime values
+            var hi = frame._base + frame.closure.fn.regCount;
+            for (var i = frame._base; i < hi; i++) this._regs[i] = undefined;
             this._regsTop = frame._base;
             if (this._frameStack.length === 0) return retVal; // main script returning
 
-            // new-call rule: primitive return -> discard, use the constructed object instead
+            // NewExpression: When invoking from the 'new' keyword, the newly constructed object is returned instead (if the original function doesn't return an object)
             if (frame._newObj !== null) {
               if (typeof retVal !== "object" || retVal === null) retVal = frame._newObj;
             }
@@ -612,15 +637,17 @@ VM.prototype.run = function () {
         case OP.THROW:
           throw regs[base + this._operand()];
 
-        // ── Closures ──────────────────────────────────────────────────────────
+        // Closures
         case OP.MAKE_CLOSURE:
           {
-            // dst, startPc, paramCount, regCount, uvCount, [isLocal, idx, ...]
+            // dst, startPc, paramCount, regCount, uvCount, hasRest, [isLocal, idx, ...]
             var dst = this._operand();
             var startPc = this._operand();
             var paramCount = this._operand();
             var regCount = this._operand();
             var uvCount = this._operand();
+            var hasRest = this._operand(); // 1 if last param is a rest element
+
             var uvDescs = new Array(uvCount);
             for (var i = 0; i < uvCount; i++) {
               var isLocalRaw = this._operand();
@@ -634,7 +661,8 @@ VM.prototype.run = function () {
               paramCount: paramCount,
               regCount: regCount,
               startPc: startPc,
-              upvalueDescriptors: uvDescs
+              upvalueDescriptors: uvDescs,
+              hasRest: hasRest
             };
             var closure = new Closure(fn);
             for (var i = 0; i < uvDescs.length; i++) {
@@ -648,7 +676,7 @@ VM.prototype.run = function () {
 
             // Wrap in a native callable shell so host code (array methods,
             // test assertions, setTimeout, etc.) can invoke VM closures.
-            // CLOSURE_SYM lets VM-internal CALL/NEW bypass the sub-VM entirely.
+            // CLOSURE_MAP lets VM-internal CALL/NEW bypass the sub-VM entirely.
             var self = this;
             var shell = function (c) {
               return function () {
@@ -656,8 +684,12 @@ VM.prototype.run = function () {
                 var sub = new VM(self.bytecode, 0, c.fn.regCount, self.constants, self.globals);
                 var f = new Frame(c, null, null, this == null ? self.globals : this, 0, 0);
                 sub._currentFrame = f;
-                for (var i = 0; i < args.length && i < c.fn.regCount; i++) {
-                  sub._regs[i] = args[i];
+                if (c.fn.hasRest) {
+                  var restSlot = c.fn.paramCount - 1;
+                  for (var i = 0; i < restSlot; i++) sub._regs[i] = i < args.length ? args[i] : undefined;
+                  sub._regs[restSlot] = args.slice(restSlot);
+                } else {
+                  for (var i = 0; i < args.length && i < c.fn.regCount; i++) sub._regs[i] = args[i];
                 }
                 if (c.fn.paramCount < c.fn.regCount) {
                   sub._regs[c.fn.paramCount] = args;
@@ -665,13 +697,13 @@ VM.prototype.run = function () {
                 return sub.run();
               };
             }(closure);
-            shell[CLOSURE_SYM] = closure;
+            CLOSURE_MAP.set(shell, closure);
             shell.prototype = closure.prototype; // unified prototype for new/instanceof
             regs[base + dst] = shell;
             break;
           }
 
-        // ── Collections ───────────────────────────────────────────────────────
+        // Collections
         case OP.BUILD_ARRAY:
           {
             // dst, count, [elemReg...]
@@ -697,7 +729,7 @@ VM.prototype.run = function () {
             break;
           }
 
-        // ── Property definitions (getters / setters) ──────────────────────────
+        // Object methods (getters / setters)
         case OP.DEFINE_GETTER:
           {
             // obj, key, fn
@@ -794,12 +826,28 @@ VM.prototype.run = function () {
           }
         case OP.TRY_END:
           {
-            // Normal exit from a try block — disarm the exception handler.
+            // Normal exit from a try block — disarm the top handler record
+            // (works for both catch and finally regions; they share the stack).
             frame._handlerStack.pop();
             break;
           }
+        case OP.FINALLY_SETUP:
+          {
+            // finallyPc, contReg, payloadReg, throwPad
+            // Arm a finalizer for the current region.  Unlike a catch record this
+            // carries no exceptionReg; instead the continuation register (contReg)
+            // receives the resume PC and payloadReg carries the in-flight value.
+            frame._handlerStack.push({
+              finallyPc: this._operand(),
+              contReg: this._operand(),
+              payloadReg: this._operand(),
+              throwPad: this._operand(),
+              frameStackDepth: this._frameStack.length
+            });
+            break;
+          }
 
-        // ── Self-modifying bytecode ───────────────────────────────────────────
+        // Self-modifying bytecode
         case OP.PATCH:
           {
             // destPc, sliceStart, sliceEnd
@@ -813,10 +861,7 @@ VM.prototype.run = function () {
           }
         case OP.JUMP_REG:
           {
-            // Indirect jump: target PC is read from a register rather than a
-            // bytecode immediate. Used by the jumpDispatcher pass so that static
-            // analysis cannot determine the jump destination without tracking the
-            // register value (which contains an encoded PC resolved at runtime).
+            // Indirect jump: allows VM to jump based on runtime values.
             frame._pc = regs[base + this._operand()];
             break;
           }
@@ -829,9 +874,8 @@ VM.prototype.run = function () {
           throw new Error("Unknown opcode: " + op + " at pc " + (frame._pc - 1));
       }
     } catch (err) {
-      // Exception handler unwinding (CPython-style frame walk, Lua-style upvalue close).
-      // Walk from the current frame upward until we find a frame that has an open
-      // exception handler (TRY_SETUP without a matching TRY_END).
+      // Exception handler unwinding
+      // Walk from the current frame upward until we find a frame that has an open exception handler (TRY_SETUP without a matching TRY_END).
       // For every frame we abandon along the way, close its captured upvalues.
       var handledFrame = null;
       var searchFrame = this._currentFrame;
@@ -847,41 +891,38 @@ VM.prototype.run = function () {
         searchFrame = this._frameStack.pop();
         this._currentFrame = searchFrame;
       }
-      if (!handledFrame) throw err; // no handler anywhere — propagate to host
+      if (!handledFrame) throw err; // if there's no handler, propagate back to host
 
       var h = handledFrame._handlerStack.pop();
-      // Discard any call-frames that were pushed inside the try body.
+      // Discard any call-frames that were pushed inside the protected region.
       this._frameStack.length = h.frameStackDepth;
-      // Write the caught exception directly into the designated register.
-      this._regs[handledFrame._base + h.exceptionReg] = err;
-      // Jump to the catch block.
-      handledFrame._pc = h.handlerPc;
-      this._regsTop = handledFrame._base + handledFrame.closure.fn.regCount;
+      var hBase = handledFrame._base;
+      if (h.exceptionReg !== undefined) {
+        // catch region — deliver the exception to the catch binding and run it.
+        this._regs[hBase + h.exceptionReg] = err;
+        handledFrame._pc = h.handlerPc;
+      } else {
+        // finally region: run the finalizer with the exception pending, then
+        // resume at its throw pad (which re-raises and continues unwinding).
+        this._regs[hBase + h.contReg] = h.throwPad;
+        this._regs[hBase + h.payloadReg] = err;
+        handledFrame._pc = h.finallyPc;
+      }
+      this._regsTop = hBase + handledFrame.closure.fn.regCount;
       this._currentFrame = handledFrame;
     }
   }
 };
 
-// Boot
-var globals = {}; // global object for globals
-
-// Always pull built-ins from globalThis so eval() scoping can't shadow them
-// with a local `window` variable (e.g. the test harness fake window).
-for (var k of Object.getOwnPropertyNames(globalThis)) {
-  globals[k] = globalThis[k];
-}
-// If a window object is in scope (browser or test harness), capture it
-// explicitly so VM code can read/write window.TEST_OUTPUT etc.
+/* @BOOT */ // <- This comment can't be removed!
+var globals = globalThis;
 if (typeof window !== "undefined") {
   globals.window = window;
-  for (var k of Object.getOwnPropertyNames(window)) {
-    globals[k] = window[k];
-  }
+  globals.document = typeof document !== "undefined" ? document : undefined;
+}
+if (typeof module !== "undefined") {
+  globals.module = module;
+  globals.exports = typeof exports !== "undefined" ? exports : undefined;
 }
-
-// Transfer common primitives
-globals.undefined = undefined;
-globals.Infinity = Infinity;
-globals.NaN = NaN;
 var vm = new VM(decodeBytecode(BYTECODE), MAIN_START_PC, MAIN_REG_COUNT, CONSTANTS, globals);
 vm.run();