Extract skip_caches_if_fallthrough and use cache_entries() in JIT

youknowone · youknowone · commit 0be59d548a34 · 2026-02-28T23:13:29.000+09:00
- Extract duplicated cache-skip logic into skip_caches_if_fallthrough
  helper in frame.rs (3 call sites)
- Use Instruction::cache_entries() in JIT instruction_target instead
  of hard-coded cache widths
diff --git a/crates/jit/src/instructions.rs b/crates/jit/src/instructions.rs
@@ -186,18 +186,20 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
         instruction: Instruction,
         arg: OpArg,
     ) -> Result<Option<Label>, JitCompileError> {
+        let caches = instruction.cache_entries() as u32;
         let target = match instruction {
-            Instruction::JumpForward { .. } => Some(Self::jump_target_forward(offset, 0, arg)?),
-            Instruction::JumpBackward { .. } => Some(Self::jump_target_backward(offset, 1, arg)?),
-            Instruction::JumpBackwardNoInterrupt { .. } => {
-                Some(Self::jump_target_backward(offset, 0, arg)?)
+            Instruction::JumpForward { .. } => {
+                Some(Self::jump_target_forward(offset, caches, arg)?)
+            }
+            Instruction::JumpBackward { .. } | Instruction::JumpBackwardNoInterrupt { .. } => {
+                Some(Self::jump_target_backward(offset, caches, arg)?)
             }
             Instruction::PopJumpIfFalse { .. }
             | Instruction::PopJumpIfTrue { .. }
             | Instruction::PopJumpIfNone { .. }
             | Instruction::PopJumpIfNotNone { .. }
             | Instruction::ForIter { .. }
-            | Instruction::Send { .. } => Some(Self::jump_target_forward(offset, 1, arg)?),
+            | Instruction::Send { .. } => Some(Self::jump_target_forward(offset, caches, arg)?),
             _ => None,
         };
         Ok(target)
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
@@ -580,16 +580,7 @@ impl ExecutingFrame<'_> {
 
             let lasti_before = self.lasti();
             let result = self.execute_instruction(op, arg, &mut do_extend_arg, vm);
-            // Skip past CACHE code units, but only if the instruction did not
-            // modify lasti (i.e., it did not jump). Jump targets already point
-            // past CACHE entries since labels include them.
-            if self.lasti() == lasti_before {
-                let base_op = op.to_base().unwrap_or(op);
-                let caches = base_op.cache_entries();
-                if caches > 0 {
-                    self.update_lasti(|i| *i += caches as u32);
-                }
-            }
+            self.skip_caches_if_fallthrough(op, lasti_before);
             match result {
                 Ok(None) => {}
                 Ok(Some(value)) => {
@@ -2865,14 +2856,7 @@ impl ExecutingFrame<'_> {
                     let mut do_extend_arg = false;
                     self.execute_instruction(original_op, arg, &mut do_extend_arg, vm)
                 };
-                // Skip CACHE entries for the real instruction (only if it didn't jump)
-                if self.lasti() == lasti_before_dispatch {
-                    let base = original_op.to_base().unwrap_or(original_op);
-                    let caches = base.cache_entries();
-                    if caches > 0 {
-                        self.update_lasti(|i| *i += caches as u32);
-                    }
-                }
+                self.skip_caches_if_fallthrough(original_op, lasti_before_dispatch);
                 result
             }
             Instruction::InstrumentedInstruction => {
@@ -2904,14 +2888,7 @@ impl ExecutingFrame<'_> {
                     let mut do_extend_arg = false;
                     self.execute_instruction(original_op, arg, &mut do_extend_arg, vm)
                 };
-                // Skip CACHE entries for the real instruction (only if it didn't jump)
-                if self.lasti() == lasti_before_dispatch {
-                    let base = original_op.to_base().unwrap_or(original_op);
-                    let caches = base.cache_entries();
-                    if caches > 0 {
-                        self.update_lasti(|i| *i += caches as u32);
-                    }
-                }
+                self.skip_caches_if_fallthrough(original_op, lasti_before_dispatch);
                 result
             }
             _ => {
@@ -3575,6 +3552,19 @@ impl ExecutingFrame<'_> {
         self.update_lasti(|i| *i = target);
     }
 
+    /// Skip past CACHE code units after an instruction, but only if the
+    /// instruction did not modify lasti (i.e., it did not jump).
+    #[inline]
+    fn skip_caches_if_fallthrough(&mut self, op: Instruction, lasti_before: u32) {
+        if self.lasti() == lasti_before {
+            let base = op.to_base().unwrap_or(op);
+            let caches = base.cache_entries();
+            if caches > 0 {
+                self.update_lasti(|i| *i += caches as u32);
+            }
+        }
+    }
+
     #[inline]
     fn pop_jump_if_relative(
         &mut self,
