update

Author: CppCXY

crates/luars/src/lua_vm/execute/control_instructions.rs

@@ -865,6 +865,7 @@ pub fn exec_call(
                 arg_count,
                 a,
                 nresults,
+                max_stack_size,
             );
 
             *frame_ptr_ptr = vm.push_frame(new_frame);
@@ -1015,6 +1016,7 @@ fn exec_call_lua_vararg(
         arg_count,
         a,
         nresults,
+        max_stack_size,
     );
 
     *frame_ptr_ptr = vm.push_frame(new_frame);
@@ -1130,6 +1132,7 @@ fn exec_call_lua_function(
             arg_count, // top = number of arguments
             a,         // result_reg
             nresults,
+            max_stack_size,
         );
 
         *frame_ptr_ptr = vm.push_frame(new_frame);
@@ -1199,6 +1202,7 @@ fn exec_call_lua_function(
         actual_arg_count, // top = number of arguments
         a,                // result_reg
         nresults,
+        max_stack_size,
     );
 
     *frame_ptr_ptr = vm.push_frame(new_frame);
@@ -1427,6 +1431,7 @@ pub fn exec_tailcall(
                 arg_count,  // top = number of arguments passed
                 result_reg, // result_reg from the CALLER (not 0!)
                 nresults,
+                max_stack_size,
             );
 
             *frame_ptr_ptr = vm.push_frame(new_frame);

crates/luars/src/lua_vm/execute/load_instructions.rs

@@ -20,18 +20,12 @@ pub fn exec_varargprep(
 ) {
     let a = get_a!(instr); // number of fixed params
 
-    let frame = vm.current_frame();
+    let frame = unsafe { &*frame_ptr };
     let frame_base = frame.base_ptr as usize;
     let top = frame.top as usize;
 
-    // Get max_stack_size from the function using new ObjectPool API
-    let Some(func_id) = frame.get_function_id() else {
-        return; // Invalid function - should not happen
-    };
-    let Some(func_ref) = vm.object_pool.get_function(func_id) else {
-        return; // Invalid function ID - should not happen
-    };
-    let max_stack_size = func_ref.chunk.max_stack_size;
+    // OPTIMIZED: Use cached max_stack from frame instead of object_pool lookup
+    let max_stack_size = frame.max_stack as usize;
 
     // Arguments were placed starting at frame_base by CALL instruction
     // Fixed parameters are at frame_base + 0 to frame_base + a - 1
@@ -69,11 +63,10 @@ pub fn exec_varargprep(
         }
 
         // Set vararg info in frame
-        vm.current_frame_mut().set_vararg(vararg_dest, vararg_count);
+        unsafe { &mut *frame_ptr }.set_vararg(vararg_dest, vararg_count);
     } else {
         // No varargs passed
-        vm.current_frame_mut()
-            .set_vararg(frame_base + max_stack_size, 0);
+        unsafe { &mut *frame_ptr }.set_vararg(frame_base + max_stack_size, 0);
     }
 
     // Initialize local variables (registers from a to max_stack_size) with nil

crates/luars/src/lua_vm/execute/loop_instructions.rs

@@ -382,6 +382,7 @@ pub fn exec_tforcall(
                 2,        // top = 2 (we have 2 arguments)
                 a + 4,    // result goes to R[A+4] relative to caller's base
                 nresults, // expecting c results
+                max_stack_size,
             );
 
             vm.push_frame(new_frame);

crates/luars/src/lua_vm/lua_call_frame.rs

@@ -54,6 +54,7 @@ pub struct LuaCallFrame {
     vararg_start: u32,        // 4 bytes - vararg start position (absolute index)
     nresults: i16,            // 2 bytes - expected return count (-1 = LUA_MULTRET)
     vararg_count: u16,        // 2 bytes - number of vararg arguments
+    pub max_stack: u16,       // 2 bytes - max stack size (for VARARGPREP optimization)
 }
 
 // ============================================================================
@@ -92,6 +93,7 @@ impl Default for LuaCallFrame {
             vararg_start: 0,
             nresults: 0,
             vararg_count: 0,
+            max_stack: 0,
         }
     }
 }
@@ -142,6 +144,7 @@ impl LuaCallFrame {
         top: usize,
         result_reg: usize,
         nresults: i16,
+        max_stack: usize,
     ) -> Self {
         LuaCallFrame {
             func_id_ptr: Self::pack_lua_function(func_id),
@@ -155,6 +158,7 @@ impl LuaCallFrame {
             vararg_start: 0,
             nresults,
             vararg_count: 0,
+            max_stack: max_stack as u16,
         }
     }
 
@@ -173,6 +177,7 @@ impl LuaCallFrame {
             vararg_start: 0,
             nresults: 0,
             vararg_count: 0,
+            max_stack: 0,
         }
     }
 
@@ -335,8 +340,8 @@ mod tests {
 
     #[test]
     fn test_lua_call_frame_size() {
-        // Verify frame size is compact
-        assert_eq!(std::mem::size_of::<LuaCallFrame>(), 56);
+        // Verify frame size is compact (added max_stack u16 + _padding u16)
+        assert_eq!(std::mem::size_of::<LuaCallFrame>(), 64);
     }
 
     #[test]
@@ -351,6 +356,7 @@ mod tests {
             0,
             0,
             0,
+            16,
         );
 
         assert!(frame.is_lua());
@@ -382,6 +388,7 @@ mod tests {
             0,
             0,
             0,
+            16,
         );
 
         // Test fresh flag
@@ -420,6 +427,7 @@ mod tests {
             0,
             0,
             0,
+            16,
         );
 
         // Set all flags

crates/luars/src/lua_vm/mod.rs

@@ -280,6 +280,7 @@ impl LuaVM {
             chunk.max_stack_size, // top
             0,                    // result_reg
             0,                    // nresults
+            chunk.max_stack_size, // max_stack_size
         );
 
         self.push_frame(frame);
@@ -356,6 +357,7 @@ impl LuaVM {
             max_stack,
             0,
             0,
+            max_stack,
         );
 
         self.push_frame(frame);
@@ -1217,6 +1219,7 @@ impl LuaVM {
             max_stack_size,
             0,
             -1,
+            max_stack_size,
         );
         self.push_frame(new_frame);
 
@@ -1286,6 +1289,7 @@ impl LuaVM {
             max_stack_size,
             0,
             -1,
+            max_stack_size,
         );
         self.push_frame(new_frame);
 
@@ -2355,6 +2359,7 @@ impl LuaVM {
                     max_stack_size, // top
                     result_reg,
                     1, // expect 1 result
+                    max_stack_size,
                 );
 
                 self.push_frame(temp_frame);
@@ -2721,6 +2726,7 @@ impl LuaVM {
                     max_stack_size,
                     0,
                     -1,
+                    max_stack_size,
                 );
                 self.push_frame(new_frame);
 
@@ -2901,6 +2907,7 @@ impl LuaVM {
                     max_stack_size,
                     0,  // result_reg unused
                     -1, // LUA_MULTRET
+                    max_stack_size,
                 );
                 self.push_frame(new_frame);