ZJIT: Box Target::SideExit

Shrink `lir::Insn` from 184 to 144 bytes.

Author: tekknolagi

zjit/src/backend/arm64/mod.rs

@@ -1773,7 +1773,7 @@ mod tests {
 
         let val64 = asm.add(CFP, Opnd::UImm(64));
         asm.store(Opnd::mem(64, SP, 0x10), val64);
-        let side_exit = Target::SideExit { reason: SideExitReason::Interrupt, exit: SideExit { pc: 0.into(), iseq: std::ptr::null(), stack: vec![], locals: vec![], recompile: None } };
+        let side_exit = Target::SideExit { reason: SideExitReason::Interrupt, exit: Box::new(SideExit { pc: 0.into(), iseq: std::ptr::null(), stack: vec![], locals: vec![], recompile: None }) };
         asm.push_insn(Insn::Joz(val64, side_exit));
         asm.mov(C_ARG_OPNDS[0], C_RET_OPND.with_num_bits(32));
         asm.mov(C_ARG_OPNDS[1], Opnd::mem(64, SP, -8));

zjit/src/backend/lir.rs

@@ -577,8 +577,9 @@ pub enum Target
     Block(BranchEdge),
     /// Side exit to the interpreter
     SideExit {
-        /// Context used for compiling the side exit
-        exit: SideExit,
+        /// Context used for compiling the side exit. Boxed to keep `Target`
+        /// (and every `Insn` variant that embeds it) small.
+        exit: Box<SideExit>,
         /// We use this to increment exit counters
         reason: SideExitReason,
     },
@@ -851,9 +852,9 @@ pub enum Insn {
 macro_rules! target_for_each_operand_impl {
     ($self:expr, $visit_many:ident) => {
         match $self {
-            Target::SideExit { exit: SideExit { stack, locals, .. }, .. } => {
-                visit_many!(stack);
-                visit_many!(locals);
+            Target::SideExit { exit, .. } => {
+                visit_many!(exit.stack);
+                visit_many!(exit.locals);
             }
             Target::Block(edge) => {
                 visit_many!(edge.args);
@@ -2711,7 +2712,7 @@ impl Assembler
         for ((block_id, idx), target) in targets {
             // Compile a side exit. Note that this is past register assignment,
             // so you can't use an instruction that returns a VReg.
-            if let Target::SideExit { exit: exit @ SideExit { pc, .. }, reason } = target {
+            if let Target::SideExit { exit, reason } = target {
                 // Only record the exit if `trace_side_exits` is defined and the counter is either the one specified
                 let should_record_exit = get_option!(trace_side_exits).map(|trace| match trace {
                     TraceExits::All => true,
@@ -2755,9 +2756,9 @@ impl Assembler
                 } else {
                     let new_exit = self.new_label("side_exit");
                     self.write_label(new_exit.clone());
-                    asm_comment!(self, "Exit: {pc}");
+                    asm_comment!(self, "Exit: {}", exit.pc);
                     compile_exit(self, &exit, None);
-                    compiled_exits.insert(exit, new_exit.unwrap_label());
+                    compiled_exits.insert(*exit, new_exit.unwrap_label());
                     new_exit
                 };
 
@@ -3838,7 +3839,7 @@ mod tests {
 
     #[test]
     fn test_size_of_insn() {
-        assert_eq!(std::mem::size_of::<Insn>(), 184);
+        assert_eq!(std::mem::size_of::<Insn>(), 144);
     }
 
     #[test]

zjit/src/backend/x86_64/mod.rs

@@ -1387,7 +1387,7 @@ mod tests {
 
         let val64 = asm.add(CFP, Opnd::UImm(64));
         asm.store(Opnd::mem(64, SP, 0x10), val64);
-        let side_exit = Target::SideExit { reason: SideExitReason::Interrupt, exit: SideExit { pc: 0.into(), iseq: std::ptr::null(), stack: vec![], locals: vec![], recompile: None } };
+        let side_exit = Target::SideExit { reason: SideExitReason::Interrupt, exit: Box::new(SideExit { pc: 0.into(), iseq: std::ptr::null(), stack: vec![], locals: vec![], recompile: None }) };
         asm.push_insn(Insn::Joz(val64, side_exit));
         asm.mov(C_ARG_OPNDS[0], C_RET_OPND.with_num_bits(32));
         asm.mov(C_ARG_OPNDS[1], Opnd::mem(64, SP, -8));

zjit/src/codegen.rs

@@ -968,7 +968,7 @@ fn gen_patch_point(jit: &mut JITState, asm: &mut Assembler, invariant: &Invarian
     let exit = build_side_exit(jit, state);
 
     // Let compile_exits compile a side exit. Let scratch_split lower it with split_patch_point.
-    asm.patch_point(Target::SideExit { exit, reason: PatchPoint(invariant) }, invariant, jit.version);
+    asm.patch_point(Target::SideExit { exit: Box::new(exit), reason: PatchPoint(invariant) }, invariant, jit.version);
 }
 
 /// This is used by scratch_split to lower PatchPoint into PadPatchPoint and PosMarker.
@@ -3179,7 +3179,7 @@ fn compile_iseq(iseq: IseqPtr) -> Result<Function, CompileError> {
 /// Build a Target::SideExit
 fn side_exit(jit: &JITState, state: &FrameState, reason: SideExitReason) -> Target {
     let exit = build_side_exit(jit, state);
-    Target::SideExit { exit, reason }
+    Target::SideExit { exit: Box::new(exit), reason }
 }
 
 /// Build a Target::SideExit that optionally triggers exit_recompile on the exit path.
@@ -3189,7 +3189,7 @@ fn side_exit_with_recompile(jit: &JITState, state: &FrameState, reason: SideExit
         compiled_iseq: Opnd::Value(VALUE::from(jit.iseq())),
         insn_idx: state.insn_idx() as u32,
     });
-    Target::SideExit { exit, reason }
+    Target::SideExit { exit: Box::new(exit), reason }
 }
 
 /// Build a side-exit context