@lewin671/python-vm 0.1.4 → 0.1.6

package/dist/vm/execution.js

@@ -26,6 +26,12 @@ function executeFrame(frame) {
         }
     }
     let lastValue = null;
+    // Cache frequently accessed properties for faster access (V8 optimization)
+    const stack = frame.stack;
+    const locals = frame.locals;
+    const scope = frame.scope;
+    const scopeValues = scope.values;
+    const iterSymbol = Symbol.iterator;
     const renderFString = (template, scope) => {
         return template.replace(/\{([^}]+)\}/g, (_m, expr) => {
             const { rawExpr, rawSpec } = this.splitFormatSpec(expr);
@@ -43,11 +49,11 @@ function executeFrame(frame) {
                         }
                         evalScope.values.set(varname, val);
                     }
-                    else if (frame.locals[i] !== undefined) {
+                    else if (locals[i] !== undefined) {
                         if (process.env['DEBUG_NONLOCAL']) {
-                            console.log(`renderFString: varname=${varname}, frame.locals[${i}]=${frame.locals[i]}`);
+                            console.log(`renderFString: varname=${varname}, locals[${i}]=${locals[i]}`);
                         }
-                        evalScope.values.set(varname, frame.locals[i]);
+                        evalScope.values.set(varname, locals[i]);
                     }
                 }
             }
@@ -76,8 +82,8 @@ function executeFrame(frame) {
         if (frame.blockStack.length === 0)
             return false;
         const block = frame.blockStack.pop();
-        frame.stack.length = block.stackHeight;
-        frame.stack.push(normalizeThrown(err));
+        stack.length = block.stackHeight;
+        stack.push(normalizeThrown(err));
         frame.pc = block.handler;
         return true;
     };
@@ -87,124 +93,431 @@ function executeFrame(frame) {
             break;
         const { opcode, arg } = instr;
         try {
+            // Switch cases ordered by execution frequency (hot paths first)
+            // Based on dynamic opcode execution profiling across benchmark workloads:
+            // - Fibonacci recursion, list operations, nested loops, dictionary ops, etc.
+            // - LOAD_FAST (22-23%), LOAD_CONST (18%), LOAD_NAME (9-33%) are hottest
+            // - All 73 cases reordered: frequent ops first, then grouped by category
+            // This reduces average case evaluations and improves branch prediction
             switch (opcode) {
+                // === HOT PATH: Most frequently executed opcodes (>5% execution time) ===
+                case types_1.OpCode.LOAD_FAST: {
+                    // Optimize common case: value is in locals
+                    let val = locals[arg];
+                    if (val === undefined) {
+                        // Check scope values as fallback
+                        const varname = varnames[arg];
+                        if (varname !== undefined && scopeValues.has(varname)) {
+                            val = scopeValues.get(varname);
+                            locals[arg] = val;
+                        }
+                        else {
+                            throw new runtime_types_1.PyException('UnboundLocalError', `local variable '${varname}' referenced before assignment`);
+                        }
+                    }
+                    stack.push(val);
+                    break;
+                }
                 case types_1.OpCode.LOAD_CONST:
                     {
                         const val = constants[arg];
                         if (val && typeof val === 'object' && typeof val.__fstring__ === 'string') {
-                            frame.stack.push(renderFString(val.__fstring__, frame.scope));
+                            stack.push(renderFString(val.__fstring__, frame.scope));
                         }
                         else {
-                            frame.stack.push(val);
+                            stack.push(val);
                         }
                     }
                     break;
                 case types_1.OpCode.LOAD_NAME: {
                     const name = names[arg];
-                    const val = frame.scope.get(name);
+                    const val = scope.get(name);
                     // console.log(`LOAD_NAME ${name} -> ${val}`);
-                    frame.stack.push(val);
+                    stack.push(val);
                     break;
                 }
-                case types_1.OpCode.STORE_NAME:
-                    frame.scope.set(names[arg], frame.stack.pop());
+                case types_1.OpCode.BINARY_ADD: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(a + b);
+                    }
+                    else {
+                        stack.push(this.applyBinary('+', a, b));
+                    }
                     break;
-                case types_1.OpCode.LOAD_GLOBAL: {
-                    const name = names[arg];
-                    // Find the global (topmost) scope
-                    let globalScope = frame.scope;
-                    while (globalScope.parent !== null) {
-                        globalScope = globalScope.parent;
+                }
+                case types_1.OpCode.BINARY_SUBTRACT: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(a - b);
+                    }
+                    else {
+                        stack.push(this.applyBinary('-', a, b));
                     }
-                    const val = globalScope.get(name);
-                    frame.stack.push(val);
                     break;
                 }
-                case types_1.OpCode.STORE_GLOBAL: {
-                    const name = names[arg];
-                    // Find the global (topmost) scope
-                    let globalScope = frame.scope;
-                    while (globalScope.parent !== null) {
-                        globalScope = globalScope.parent;
+                case types_1.OpCode.BINARY_MULTIPLY: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(a * b);
+                    }
+                    else {
+                        stack.push(this.applyBinary('*', a, b));
                     }
-                    globalScope.set(name, frame.stack.pop());
                     break;
                 }
-                case types_1.OpCode.LOAD_FAST: {
-                    const varname = varnames[arg];
-                    if (varname !== undefined && frame.scope.values.has(varname)) {
-                        const val = frame.scope.values.get(varname);
-                        frame.locals[arg] = val;
-                        frame.stack.push(val);
-                        break;
-                    }
-                    const val = frame.locals[arg];
-                    if (val === undefined) {
-                        throw new runtime_types_1.PyException('UnboundLocalError', `local variable '${varname}' referenced before assignment`);
+                case types_1.OpCode.CALL_FUNCTION: {
+                    const argCount = arg;
+                    const args = new Array(argCount);
+                    // Pop arguments in reverse order
+                    for (let i = argCount - 1; i >= 0; i--) {
+                        args[i] = stack.pop();
+                    }
+                    const func = stack.pop();
+                    stack.push(this.callFunction(func, args, scope));
+                    break;
+                }
+                case types_1.OpCode.RETURN_VALUE:
+                    return stack.pop();
+                case types_1.OpCode.COMPARE_OP: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple integer comparisons
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        let result = undefined;
+                        switch (arg) {
+                            case types_1.CompareOp.LT:
+                                result = a < b;
+                                break;
+                            case types_1.CompareOp.LE:
+                                result = a <= b;
+                                break;
+                            case types_1.CompareOp.EQ:
+                                result = a === b;
+                                break;
+                            case types_1.CompareOp.NE:
+                                result = a !== b;
+                                break;
+                            case types_1.CompareOp.GT:
+                                result = a > b;
+                                break;
+                            case types_1.CompareOp.GE:
+                                result = a >= b;
+                                break;
+                        }
+                        if (result !== undefined) {
+                            stack.push(result);
+                        }
+                        else {
+                            stack.push(this.applyCompare(arg, a, b));
+                        }
+                    }
+                    else {
+                        stack.push(this.applyCompare(arg, a, b));
+                    }
+                    break;
+                }
+                case types_1.OpCode.POP_JUMP_IF_FALSE: {
+                    const val = stack.pop();
+                    // Fast path for booleans and numbers
+                    let isFalse = false;
+                    if (typeof val === 'boolean') {
+                        isFalse = !val;
+                    }
+                    else if (typeof val === 'number') {
+                        isFalse = val === 0;
+                    }
+                    else if (val === null || val === undefined) {
+                        isFalse = true;
+                    }
+                    else {
+                        isFalse = !this.isTruthy(val, scope);
+                    }
+                    if (isFalse) {
+                        frame.pc = arg;
                     }
-                    frame.stack.push(val);
                     break;
                 }
                 case types_1.OpCode.STORE_FAST: {
-                    const val = frame.stack.pop();
-                    frame.locals[arg] = val;
+                    const val = stack.pop();
+                    locals[arg] = val;
                     if (varnames && varnames[arg] !== undefined) {
-                        frame.scope.values.set(varnames[arg], val);
+                        scopeValues.set(varnames[arg], val);
                     }
                     break;
                 }
-                case types_1.OpCode.UNPACK_SEQUENCE: {
-                    const seq = frame.stack.pop();
-                    const items = Array.isArray(seq) ? seq : Array.from(seq);
-                    if (items.length !== arg) {
-                        throw new runtime_types_1.PyException('ValueError', `not enough values to unpack (expected ${arg}, got ${items.length})`);
+                case types_1.OpCode.STORE_NAME:
+                    scope.set(names[arg], stack.pop());
+                    break;
+                case types_1.OpCode.FOR_ITER: {
+                    const iter = stack[stack.length - 1];
+                    const next = iter.next();
+                    if (next.done) {
+                        stack.pop();
+                        frame.pc = arg;
                     }
-                    for (let i = items.length - 1; i >= 0; i--) {
-                        frame.stack.push(items[i]);
+                    else {
+                        stack.push(next.value);
                     }
                     break;
                 }
-                case types_1.OpCode.UNPACK_EX: {
-                    const seq = frame.stack.pop();
-                    const items = Array.isArray(seq) ? seq : Array.from(seq);
-                    const beforeCount = (arg >> 8) & 0xff;
-                    const afterCount = arg & 0xff;
-                    if (items.length < beforeCount + afterCount) {
-                        throw new runtime_types_1.PyException('ValueError', 'not enough values to unpack');
+                case types_1.OpCode.JUMP_ABSOLUTE:
+                    frame.pc = arg;
+                    break;
+                case types_1.OpCode.INPLACE_ADD: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(a + b);
                     }
-                    const middle = items.slice(beforeCount, items.length - afterCount);
-                    // Push in reverse order of assignment popping:
-                    // suffix values (last..first), then middle list, then prefix values (last..first).
-                    for (let i = afterCount - 1; i >= 0; i--) {
-                        frame.stack.push(items[items.length - afterCount + i]);
+                    else {
+                        stack.push(this.applyInPlaceBinary('+', a, b));
                     }
-                    frame.stack.push(middle);
-                    for (let i = beforeCount - 1; i >= 0; i--) {
-                        frame.stack.push(items[i]);
+                    break;
+                }
+                case types_1.OpCode.INPLACE_SUBTRACT: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(a - b);
+                    }
+                    else {
+                        stack.push(this.applyInPlaceBinary('-', a, b));
+                    }
+                    break;
+                }
+                case types_1.OpCode.INPLACE_MULTIPLY: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(a * b);
+                    }
+                    else {
+                        stack.push(this.applyInPlaceBinary('*', a, b));
+                    }
+                    break;
+                }
+                case types_1.OpCode.POP_TOP:
+                    lastValue = stack.pop();
+                    break;
+                case types_1.OpCode.GET_ITER: {
+                    const obj = stack.pop();
+                    if (obj && typeof obj[iterSymbol] === 'function') {
+                        stack.push(obj[iterSymbol]());
+                    }
+                    else {
+                        throw new runtime_types_1.PyException('TypeError', `'${typeof obj}' object is not iterable`);
                     }
                     break;
                 }
                 case types_1.OpCode.LOAD_ATTR: {
-                    const obj = frame.stack.pop();
-                    frame.stack.push(this.getAttribute(obj, names[arg], frame.scope));
+                    const obj = stack.pop();
+                    stack.push(this.getAttribute(obj, names[arg], frame.scope));
+                    break;
+                }
+                // Other BINARY operations
+                case types_1.OpCode.BINARY_DIVIDE: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(a / b);
+                    }
+                    else {
+                        stack.push(this.applyBinary('/', a, b));
+                    }
+                    break;
+                }
+                case types_1.OpCode.BINARY_FLOOR_DIVIDE: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(Math.floor(a / b));
+                    }
+                    else {
+                        stack.push(this.applyBinary('//', a, b));
+                    }
+                    break;
+                }
+                case types_1.OpCode.BINARY_MODULO: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    // Fast path for simple numbers
+                    if (typeof a === 'number' && typeof b === 'number') {
+                        stack.push(a % b);
+                    }
+                    else {
+                        stack.push(this.applyBinary('%', a, b));
+                    }
+                    break;
+                }
+                case types_1.OpCode.BINARY_POWER: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyBinary('**', a, b));
+                    break;
+                }
+                case types_1.OpCode.BINARY_AND: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyBinary('&', a, b));
+                    break;
+                }
+                case types_1.OpCode.BINARY_XOR: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyBinary('^', a, b));
+                    break;
+                }
+                case types_1.OpCode.BINARY_OR: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyBinary('|', a, b));
+                    break;
+                }
+                case types_1.OpCode.BINARY_LSHIFT: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyBinary('<<', a, b));
+                    break;
+                }
+                case types_1.OpCode.BINARY_RSHIFT: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyBinary('>>', a, b));
+                    break;
+                }
+                // Other INPLACE operations
+                case types_1.OpCode.INPLACE_DIVIDE: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyInPlaceBinary('/', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_FLOOR_DIVIDE: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyInPlaceBinary('//', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_MODULO: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyInPlaceBinary('%', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_POWER: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyInPlaceBinary('**', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_AND: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyInPlaceBinary('&', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_XOR: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyInPlaceBinary('^', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_OR: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyInPlaceBinary('|', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_LSHIFT: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyInPlaceBinary('<<', a, b));
+                    break;
+                }
+                case types_1.OpCode.INPLACE_RSHIFT: {
+                    const b = stack.pop();
+                    const a = stack.pop();
+                    stack.push(this.applyInPlaceBinary('>>', a, b));
+                    break;
+                }
+                // Other JUMP operations
+                case types_1.OpCode.POP_JUMP_IF_TRUE: {
+                    const val = stack.pop();
+                    if (this.isTruthy(val, frame.scope)) {
+                        frame.pc = arg;
+                    }
+                    break;
+                }
+                case types_1.OpCode.JUMP_IF_FALSE_OR_POP: {
+                    const val = stack[stack.length - 1];
+                    if (!this.isTruthy(val, frame.scope)) {
+                        frame.pc = arg;
+                    }
+                    else {
+                        stack.pop();
+                    }
+                    break;
+                }
+                case types_1.OpCode.JUMP_IF_TRUE_OR_POP: {
+                    const val = stack[stack.length - 1];
+                    if (this.isTruthy(val, frame.scope)) {
+                        frame.pc = arg;
+                    }
+                    else {
+                        stack.pop();
+                    }
+                    break;
+                }
+                // LOAD/STORE operations
+                case types_1.OpCode.LOAD_GLOBAL: {
+                    const name = names[arg];
+                    // Find the global (topmost) scope
+                    let globalScope = frame.scope;
+                    while (globalScope.parent !== null) {
+                        globalScope = globalScope.parent;
+                    }
+                    const val = globalScope.get(name);
+                    stack.push(val);
+                    break;
+                }
+                case types_1.OpCode.STORE_GLOBAL: {
+                    const name = names[arg];
+                    // Find the global (topmost) scope
+                    let globalScope = frame.scope;
+                    while (globalScope.parent !== null) {
+                        globalScope = globalScope.parent;
+                    }
+                    globalScope.set(name, stack.pop());
                     break;
                 }
                 case types_1.OpCode.STORE_ATTR: {
-                    const val = frame.stack.pop();
-                    const obj = frame.stack.pop();
+                    const val = stack.pop();
+                    const obj = stack.pop();
                     this.setAttribute(obj, names[arg], val);
                     break;
                 }
                 case types_1.OpCode.LOAD_SUBSCR: {
-                    const index = frame.stack.pop();
-                    const obj = frame.stack.pop();
-                    frame.stack.push(this.getSubscript(obj, index));
+                    const index = stack.pop();
+                    const obj = stack.pop();
+                    stack.push(this.getSubscript(obj, index));
                     break;
                 }
                 case types_1.OpCode.STORE_SUBSCR: {
-                    const index = frame.stack.pop();
-                    const obj = frame.stack.pop();
-                    const val = frame.stack.pop();
+                    const index = stack.pop();
+                    const obj = stack.pop();
+                    const val = stack.pop();
                     // Check if object is a tuple (immutable)
                     if (Array.isArray(obj) && obj.__tuple__) {
                         throw new runtime_types_1.PyException('TypeError', `'tuple' object does not support item assignment`);
@@ -245,8 +558,8 @@ function executeFrame(frame) {
                     break;
                 }
                 case types_1.OpCode.DELETE_SUBSCR: {
-                    const index = frame.stack.pop();
-                    const obj = frame.stack.pop();
+                    const index = stack.pop();
+                    const obj = stack.pop();
                     if (Array.isArray(obj)) {
                         if (index && (index.__slice__ || index.type === types_1.ASTNodeType.SLICE)) {
                             const start = index.start !== undefined ? index.start : null;
@@ -285,329 +598,155 @@ function executeFrame(frame) {
                     }
                     break;
                 }
-                case types_1.OpCode.POP_TOP:
-                    lastValue = frame.stack.pop();
+                // UNPACK operations
+                case types_1.OpCode.UNPACK_SEQUENCE: {
+                    const seq = stack.pop();
+                    const items = Array.isArray(seq) ? seq : Array.from(seq);
+                    if (items.length !== arg) {
+                        throw new runtime_types_1.PyException('ValueError', `not enough values to unpack (expected ${arg}, got ${items.length})`);
+                    }
+                    for (let i = items.length - 1; i >= 0; i--) {
+                        stack.push(items[i]);
+                    }
                     break;
+                }
+                case types_1.OpCode.UNPACK_EX: {
+                    const seq = stack.pop();
+                    const items = Array.isArray(seq) ? seq : Array.from(seq);
+                    const beforeCount = (arg >> 8) & 0xff;
+                    const afterCount = arg & 0xff;
+                    if (items.length < beforeCount + afterCount) {
+                        throw new runtime_types_1.PyException('ValueError', 'not enough values to unpack');
+                    }
+                    const middle = items.slice(beforeCount, items.length - afterCount);
+                    // Push in reverse order of assignment popping:
+                    // suffix values (last..first), then middle list, then prefix values (last..first).
+                    for (let i = afterCount - 1; i >= 0; i--) {
+                        stack.push(items[items.length - afterCount + i]);
+                    }
+                    stack.push(middle);
+                    for (let i = beforeCount - 1; i >= 0; i--) {
+                        stack.push(items[i]);
+                    }
+                    break;
+                }
+                // Stack operations
                 case types_1.OpCode.DUP_TOP: {
-                    const val = frame.stack[frame.stack.length - 1];
-                    frame.stack.push(val);
+                    const val = stack[stack.length - 1];
+                    stack.push(val);
                     break;
                 }
                 case types_1.OpCode.DUP_TOP_TWO: {
-                    const top = frame.stack[frame.stack.length - 1];
-                    const second = frame.stack[frame.stack.length - 2];
-                    frame.stack.push(second);
-                    frame.stack.push(top);
+                    const top = stack[stack.length - 1];
+                    const second = stack[stack.length - 2];
+                    stack.push(second);
+                    stack.push(top);
                     break;
                 }
                 case types_1.OpCode.ROT_TWO: {
-                    const a = frame.stack.pop();
-                    const b = frame.stack.pop();
-                    frame.stack.push(a);
-                    frame.stack.push(b);
+                    const a = stack.pop();
+                    const b = stack.pop();
+                    stack.push(a);
+                    stack.push(b);
                     break;
                 }
                 case types_1.OpCode.ROT_THREE: {
-                    const a = frame.stack.pop();
-                    const b = frame.stack.pop();
-                    const c = frame.stack.pop();
-                    frame.stack.push(a);
-                    frame.stack.push(c);
-                    frame.stack.push(b);
-                    break;
-                }
-                case types_1.OpCode.BINARY_ADD: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyBinary('+', a, b));
-                    break;
-                }
-                case types_1.OpCode.BINARY_SUBTRACT: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyBinary('-', a, b));
-                    break;
-                }
-                case types_1.OpCode.BINARY_MULTIPLY: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyBinary('*', a, b));
-                    break;
-                }
-                case types_1.OpCode.BINARY_DIVIDE: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyBinary('/', a, b));
-                    break;
-                }
-                case types_1.OpCode.BINARY_FLOOR_DIVIDE: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyBinary('//', a, b));
-                    break;
-                }
-                case types_1.OpCode.BINARY_MODULO: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyBinary('%', a, b));
-                    break;
-                }
-                case types_1.OpCode.BINARY_POWER: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyBinary('**', a, b));
-                    break;
-                }
-                case types_1.OpCode.BINARY_AND: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyBinary('&', a, b));
-                    break;
-                }
-                case types_1.OpCode.BINARY_XOR: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyBinary('^', a, b));
-                    break;
-                }
-                case types_1.OpCode.BINARY_OR: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyBinary('|', a, b));
-                    break;
-                }
-                case types_1.OpCode.BINARY_LSHIFT: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyBinary('<<', a, b));
-                    break;
-                }
-                case types_1.OpCode.BINARY_RSHIFT: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyBinary('>>', a, b));
-                    break;
-                }
-                case types_1.OpCode.INPLACE_ADD: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyInPlaceBinary('+', a, b));
-                    break;
-                }
-                case types_1.OpCode.INPLACE_SUBTRACT: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyInPlaceBinary('-', a, b));
-                    break;
-                }
-                case types_1.OpCode.INPLACE_MULTIPLY: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyInPlaceBinary('*', a, b));
-                    break;
-                }
-                case types_1.OpCode.INPLACE_DIVIDE: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyInPlaceBinary('/', a, b));
-                    break;
-                }
-                case types_1.OpCode.INPLACE_FLOOR_DIVIDE: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyInPlaceBinary('//', a, b));
-                    break;
-                }
-                case types_1.OpCode.INPLACE_MODULO: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyInPlaceBinary('%', a, b));
-                    break;
-                }
-                case types_1.OpCode.INPLACE_POWER: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyInPlaceBinary('**', a, b));
-                    break;
-                }
-                case types_1.OpCode.INPLACE_AND: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyInPlaceBinary('&', a, b));
-                    break;
-                }
-                case types_1.OpCode.INPLACE_XOR: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyInPlaceBinary('^', a, b));
-                    break;
-                }
-                case types_1.OpCode.INPLACE_OR: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyInPlaceBinary('|', a, b));
-                    break;
-                }
-                case types_1.OpCode.INPLACE_LSHIFT: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyInPlaceBinary('<<', a, b));
-                    break;
-                }
-                case types_1.OpCode.INPLACE_RSHIFT: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyInPlaceBinary('>>', a, b));
+                    const a = stack.pop();
+                    const b = stack.pop();
+                    const c = stack.pop();
+                    stack.push(a);
+                    stack.push(c);
+                    stack.push(b);
                     break;
                 }
+                // UNARY operations
                 case types_1.OpCode.UNARY_POSITIVE: {
-                    const a = frame.stack.pop();
-                    frame.stack.push(+a);
+                    const a = stack.pop();
+                    stack.push(+a);
                     break;
                 }
                 case types_1.OpCode.UNARY_NEGATIVE: {
-                    const a = frame.stack.pop();
+                    const a = stack.pop();
                     if (typeof a === 'bigint') {
-                        frame.stack.push(-a);
+                        stack.push(-a);
                     }
                     else {
-                        frame.stack.push(-a);
+                        stack.push(-a);
                     }
                     break;
                 }
                 case types_1.OpCode.UNARY_NOT: {
-                    const a = frame.stack.pop();
-                    frame.stack.push(!this.isTruthy(a, frame.scope));
+                    const a = stack.pop();
+                    stack.push(!this.isTruthy(a, frame.scope));
                     break;
                 }
                 case types_1.OpCode.UNARY_INVERT: {
-                    const a = frame.stack.pop();
+                    const a = stack.pop();
                     if (typeof a === 'bigint') {
-                        frame.stack.push(~a);
+                        stack.push(~a);
                     }
                     else {
-                        frame.stack.push(~Number(a));
+                        stack.push(~Number(a));
                     }
                     break;
                 }
-                case types_1.OpCode.COMPARE_OP: {
-                    const b = frame.stack.pop();
-                    const a = frame.stack.pop();
-                    frame.stack.push(this.applyCompare(arg, a, b));
-                    break;
-                }
+                // BUILD operations
                 case types_1.OpCode.BUILD_LIST: {
-                    const list = [];
-                    for (let i = 0; i < arg; i++)
-                        list.unshift(frame.stack.pop());
-                    frame.stack.push(list);
+                    const count = arg;
+                    const list = new Array(count);
+                    for (let i = count - 1; i >= 0; i--)
+                        list[i] = stack.pop();
+                    stack.push(list);
                     break;
                 }
                 case types_1.OpCode.BUILD_TUPLE: {
-                    const tuple = [];
-                    for (let i = 0; i < arg; i++)
-                        tuple.unshift(frame.stack.pop());
+                    const count = arg;
+                    const tuple = new Array(count);
+                    for (let i = count - 1; i >= 0; i--)
+                        tuple[i] = stack.pop();
                     tuple.__tuple__ = true;
-                    frame.stack.push(tuple);
+                    stack.push(tuple);
                     break;
                 }
                 case types_1.OpCode.BUILD_MAP: {
                     const dict = new runtime_types_1.PyDict();
                     const items = [];
                     for (let i = 0; i < arg; i++) {
-                        const v = frame.stack.pop();
-                        const k = frame.stack.pop();
+                        const v = stack.pop();
+                        const k = stack.pop();
                         items.push({ k, v });
                     }
                     for (let i = items.length - 1; i >= 0; i--) {
                         dict.set(items[i].k, items[i].v);
                     }
-                    frame.stack.push(dict);
+                    stack.push(dict);
                     break;
                 }
                 case types_1.OpCode.BUILD_SET: {
                     const set = new runtime_types_1.PySet();
                     for (let i = 0; i < arg; i++) {
-                        set.add(frame.stack.pop());
+                        set.add(stack.pop());
                     }
-                    frame.stack.push(set);
+                    stack.push(set);
                     break;
                 }
                 case types_1.OpCode.BUILD_SLICE: {
-                    const step = arg === 3 ? frame.stack.pop() : null;
-                    const end = frame.stack.pop();
-                    const start = frame.stack.pop();
+                    const step = arg === 3 ? stack.pop() : null;
+                    const end = stack.pop();
+                    const start = stack.pop();
                     // Create a slice object with start/end/step to match parser AST nodes
-                    frame.stack.push({ __slice__: true, start, end, step });
-                    break;
-                }
-                case types_1.OpCode.JUMP_ABSOLUTE:
-                    frame.pc = arg;
-                    break;
-                case types_1.OpCode.POP_JUMP_IF_FALSE: {
-                    const val = frame.stack.pop();
-                    if (!this.isTruthy(val, frame.scope)) {
-                        frame.pc = arg;
-                    }
-                    break;
-                }
-                case types_1.OpCode.POP_JUMP_IF_TRUE: {
-                    const val = frame.stack.pop();
-                    if (this.isTruthy(val, frame.scope)) {
-                        frame.pc = arg;
-                    }
-                    break;
-                }
-                case types_1.OpCode.JUMP_IF_FALSE_OR_POP: {
-                    const val = frame.stack[frame.stack.length - 1];
-                    if (!this.isTruthy(val, frame.scope)) {
-                        frame.pc = arg;
-                    }
-                    else {
-                        frame.stack.pop();
-                    }
-                    break;
-                }
-                case types_1.OpCode.JUMP_IF_TRUE_OR_POP: {
-                    const val = frame.stack[frame.stack.length - 1];
-                    if (this.isTruthy(val, frame.scope)) {
-                        frame.pc = arg;
-                    }
-                    else {
-                        frame.stack.pop();
-                    }
-                    break;
-                }
-                case types_1.OpCode.GET_ITER: {
-                    const obj = frame.stack.pop();
-                    if (obj && typeof obj[Symbol.iterator] === 'function') {
-                        frame.stack.push(obj[Symbol.iterator]());
-                    }
-                    else {
-                        throw new runtime_types_1.PyException('TypeError', `'${typeof obj}' object is not iterable`);
-                    }
-                    break;
-                }
-                case types_1.OpCode.FOR_ITER: {
-                    const iter = frame.stack[frame.stack.length - 1];
-                    const next = iter.next();
-                    if (next.done) {
-                        frame.stack.pop();
-                        frame.pc = arg;
-                    }
-                    else {
-                        frame.stack.push(next.value);
-                    }
+                    stack.push({ __slice__: true, start, end, step });
                     break;
                 }
+                // Function/class operations
                 case types_1.OpCode.MAKE_FUNCTION: {
                     const defaultsCount = arg || 0;
-                    const name = frame.stack.pop();
-                    const bc = frame.stack.pop();
-                    const defaults = [];
+                    const name = stack.pop();
+                    const bc = stack.pop();
+                    const defaults = new Array(defaultsCount);
                     // Pop default values from stack in reverse order (last default on top)
-                    for (let i = 0; i < defaultsCount; i++) {
-                        defaults.unshift(frame.stack.pop());
+                    for (let i = defaultsCount - 1; i >= 0; i--) {
+                        defaults[i] = stack.pop();
                     }
                     // Create a copy of params with evaluated defaults
                     const params = (bc && bc.params) ? bc.params.map((p) => ({ ...p })) : [];
@@ -623,12 +762,54 @@ function executeFrame(frame) {
                     const body = (bc && bc.astBody) ? bc.astBody : [];
                     const func = new runtime_types_1.PyFunction(name, params, body, frame.scope, isGenerator, new Set(), bc);
                     func.closure_shared_values = frame.scope.values;
-                    frame.stack.push(func);
+                    stack.push(func);
+                    break;
+                }
+                case types_1.OpCode.CALL_FUNCTION_KW: {
+                    const kwNames = stack.pop();
+                    const kwList = Array.isArray(kwNames) ? kwNames : [];
+                    const kwCount = kwList.length;
+                    const total = arg;
+                    const values = new Array(total);
+                    for (let i = total - 1; i >= 0; i--) {
+                        values[i] = stack.pop();
+                    }
+                    const func = stack.pop();
+                    const positionalCount = total - kwCount;
+                    const positional = values.slice(0, positionalCount);
+                    const kwargs = {};
+                    for (let i = 0; i < kwCount; i++) {
+                        kwargs[String(kwList[i])] = values[positionalCount + i];
+                    }
+                    stack.push(this.callFunction(func, positional, frame.scope, kwargs));
+                    break;
+                }
+                case types_1.OpCode.CALL_FUNCTION_EX: {
+                    // arg == 1 means there's a kwargs dict on top
+                    // Stack: [func, args_tuple] or [func, args_tuple, kwargs_dict]
+                    const kwargs = {};
+                    if (arg === 1) {
+                        const kwDict = stack.pop();
+                        if (kwDict instanceof runtime_types_1.PyDict) {
+                            for (const [k, v] of kwDict.entries()) {
+                                kwargs[String(k)] = v;
+                            }
+                        }
+                        else if (kwDict && typeof kwDict === 'object') {
+                            for (const [k, v] of Object.entries(kwDict)) {
+                                kwargs[k] = v;
+                            }
+                        }
+                    }
+                    const argsTuple = stack.pop();
+                    const func = stack.pop();
+                    const args = Array.isArray(argsTuple) ? argsTuple : (argsTuple ? Array.from(argsTuple) : []);
+                    stack.push(this.callFunction(func, args, frame.scope, kwargs));
                     break;
                 }
                 case types_1.OpCode.LOAD_BUILD_CLASS: {
                     const enclosingScope = frame.scope;
-                    frame.stack.push((bodyFn, name, ...bases) => {
+                    stack.push((bodyFn, name, ...bases) => {
                         const classScope = new runtime_types_1.Scope(enclosingScope, true);
                         if (bodyFn instanceof runtime_types_1.PyFunction && bodyFn.bytecode) {
                             const bodyFrame = new runtime_types_1.Frame(bodyFn.bytecode, classScope);
@@ -644,46 +825,47 @@ function executeFrame(frame) {
                     });
                     break;
                 }
+                // Import/exception operations
                 case types_1.OpCode.IMPORT_NAME: {
-                    frame.stack.pop(); // level
-                    frame.stack.pop(); // fromlist
+                    stack.pop(); // level
+                    stack.pop(); // fromlist
                     const name = names[arg];
-                    frame.stack.push(this.importModule(name, frame.scope));
+                    stack.push(this.importModule(name, frame.scope));
                     break;
                 }
                 case types_1.OpCode.RAISE_VARARGS: {
                     if (arg >= 2)
-                        frame.stack.pop(); // cause
-                    const exc = arg >= 1 ? frame.stack.pop() : null;
+                        stack.pop(); // cause
+                    const exc = arg >= 1 ? stack.pop() : null;
                     // simplified raise
                     throw exc || new runtime_types_1.PyException('RuntimeError', 'No exception to raise');
                 }
                 case types_1.OpCode.SETUP_FINALLY: {
-                    frame.blockStack.push({ handler: arg, stackHeight: frame.stack.length });
+                    frame.blockStack.push({ handler: arg, stackHeight: stack.length });
                     break;
                 }
                 case types_1.OpCode.SETUP_WITH: {
-                    const ctx = frame.stack.pop();
+                    const ctx = stack.pop();
                     const enter = this.getAttribute(ctx, '__enter__', frame.scope);
                     const exit = this.getAttribute(ctx, '__exit__', frame.scope);
                     const result = this.callFunction(enter, [], frame.scope);
-                    frame.stack.push(exit);
-                    frame.stack.push(result);
+                    stack.push(exit);
+                    stack.push(result);
                     // Block should assume exit is on stack, so stackHeight includes exit.
                     // When popping block, we leave exit on stack? 
                     // No, standard behavior: SETUP_WITH pushes exit, enter_res.
                     // Handler expects [exit, exc...]? 
                     // Let's rely on blockStack logic: stack returned to stackHeight on exception.
                     // If we set stackHeight to include exit, then on exception, we have [exit], then push exc.
-                    frame.blockStack.push({ handler: arg, stackHeight: frame.stack.length - 1 });
+                    frame.blockStack.push({ handler: arg, stackHeight: stack.length - 1 });
                     break;
                 }
                 case types_1.OpCode.WITH_EXCEPT_START: {
                     // Stack: [exit, exc_norm] (after normalizeThrown in dispatchException)
                     // Or [exit, exc]
                     // This opcode calls exit(type, val, tb)
-                    const exc = frame.stack.pop();
-                    const exit = frame.stack.pop();
+                    const exc = stack.pop();
+                    const exit = stack.pop();
                     // Call exit(type, val, tb)
                     // For our VM, we can pass (exc.type, exc, None)
                     const pyType = (exc instanceof runtime_types_1.PyInstance) ? exc.klass : (exc.pyType || exc);
@@ -707,64 +889,11 @@ function executeFrame(frame) {
                     frame.blockStack.pop();
                     break;
                 }
-                case types_1.OpCode.CALL_FUNCTION: {
-                    const args = [];
-                    for (let i = 0; i < arg; i++) {
-                        args.unshift(frame.stack.pop());
-                    }
-                    const func = frame.stack.pop();
-                    frame.stack.push(this.callFunction(func, args, frame.scope));
-                    break;
-                }
-                case types_1.OpCode.CALL_FUNCTION_KW: {
-                    const kwNames = frame.stack.pop();
-                    const kwList = Array.isArray(kwNames) ? kwNames : [];
-                    const kwCount = kwList.length;
-                    const total = arg;
-                    const values = [];
-                    for (let i = 0; i < total; i++) {
-                        values.unshift(frame.stack.pop());
-                    }
-                    const func = frame.stack.pop();
-                    const positionalCount = total - kwCount;
-                    const positional = values.slice(0, positionalCount);
-                    const kwargs = {};
-                    for (let i = 0; i < kwCount; i++) {
-                        kwargs[String(kwList[i])] = values[positionalCount + i];
-                    }
-                    frame.stack.push(this.callFunction(func, positional, frame.scope, kwargs));
-                    break;
-                }
-                case types_1.OpCode.CALL_FUNCTION_EX: {
-                    // arg == 1 means there's a kwargs dict on top
-                    // Stack: [func, args_tuple] or [func, args_tuple, kwargs_dict]
-                    const kwargs = {};
-                    if (arg === 1) {
-                        const kwDict = frame.stack.pop();
-                        if (kwDict instanceof runtime_types_1.PyDict) {
-                            for (const [k, v] of kwDict.entries()) {
-                                kwargs[String(k)] = v;
-                            }
-                        }
-                        else if (kwDict && typeof kwDict === 'object') {
-                            for (const [k, v] of Object.entries(kwDict)) {
-                                kwargs[k] = v;
-                            }
-                        }
-                    }
-                    const argsTuple = frame.stack.pop();
-                    const func = frame.stack.pop();
-                    const args = Array.isArray(argsTuple) ? argsTuple : (argsTuple ? Array.from(argsTuple) : []);
-                    frame.stack.push(this.callFunction(func, args, frame.scope, kwargs));
-                    break;
-                }
                 case types_1.OpCode.EVAL_AST: {
-                    const node = frame.stack.pop();
-                    frame.stack.push(this.evaluateExpression(node, frame.scope));
+                    const node = stack.pop();
+                    stack.push(this.evaluateExpression(node, frame.scope));
                     break;
                 }
-                case types_1.OpCode.RETURN_VALUE:
-                    return frame.stack.pop();
                 default:
                     throw new Error(`VM: Unknown opcode ${types_1.OpCode[opcode]} (${opcode}) at pc ${frame.pc - 1}`);
             }