From 70378db2fff0b1bc39a7d2b011da90486579fb0e Mon Sep 17 00:00:00 2001
From: Peter Zhu <peter@peterzhu.ca>
Date: Fri, 15 Aug 2025 11:09:13 -0400
Subject: [PATCH 01/17] Remove impossible case in rb_raw_obj_info_buitin_type
 for array

Since we handle embedded arrays in the if statement above, we don't need
to handle it here.
---
 gc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/gc.c b/gc.c
index 160398f9a6a661..aa3140ed473462 100644
--- a/gc.c
+++ b/gc.c
@@ -4709,7 +4709,7 @@ rb_raw_obj_info_buitin_type(char *const buff, const size_t buff_size, const VALU
                          C(ARY_EMBED_P(obj),  "E"),
                          C(ARY_SHARED_P(obj), "S"),
                          RARRAY_LEN(obj),
-                         ARY_EMBED_P(obj) ? -1L : RARRAY(obj)->as.heap.aux.capa,
+                         RARRAY(obj)->as.heap.aux.capa,
                          (void *)RARRAY_CONST_PTR(obj));
             }
             break;

From ef3fdb04d2be6e0337bea2ca84c7158d32b89719 Mon Sep 17 00:00:00 2001
From: Peter Zhu <peter@peterzhu.ca>
Date: Fri, 15 Aug 2025 11:19:11 -0400
Subject: [PATCH 02/17] Move flags for arrays out of if statements in
 rb_raw_obj_info_buitin_type

---
 gc.c | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/gc.c b/gc.c
index aa3140ed473462..c78ef4de113ef5 100644
--- a/gc.c
+++ b/gc.c
@@ -4698,19 +4698,21 @@ rb_raw_obj_info_buitin_type(char *const buff, const size_t buff_size, const VALU
                 APPEND_S("shared -> ");
                 rb_raw_obj_info(BUFF_ARGS, ARY_SHARED_ROOT(obj));
             }
-            else if (ARY_EMBED_P(obj)) {
-                APPEND_F("[%s%s] len: %ld (embed)",
-                         C(ARY_EMBED_P(obj),  "E"),
-                         C(ARY_SHARED_P(obj), "S"),
-                         RARRAY_LEN(obj));
-            }
             else {
-                APPEND_F("[%s%s] len: %ld, capa:%ld ptr:%p",
+                APPEND_F("[%s%s] ",
                          C(ARY_EMBED_P(obj),  "E"),
-                         C(ARY_SHARED_P(obj), "S"),
-                         RARRAY_LEN(obj),
-                         RARRAY(obj)->as.heap.aux.capa,
-                         (void *)RARRAY_CONST_PTR(obj));
+                         C(ARY_SHARED_P(obj), "S"));
+
+                if (ARY_EMBED_P(obj)) {
+                    APPEND_F("len: %ld (embed)",
+                             RARRAY_LEN(obj));
+                }
+                else {
+                    APPEND_F("len: %ld, capa:%ld ptr:%p",
+                             RARRAY_LEN(obj),
+                             RARRAY(obj)->as.heap.aux.capa,
+                             (void *)RARRAY_CONST_PTR(obj));
+                }
             }
             break;
           case T_STRING: {

From 094fa3ed0922901b5771fc0e1651ecb161b5cdb6 Mon Sep 17 00:00:00 2001
From: Peter Zhu <peter@peterzhu.ca>
Date: Fri, 15 Aug 2025 11:21:09 -0400
Subject: [PATCH 03/17] Output array shared root flag in
 rb_raw_obj_info_buitin_type

---
 gc.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/gc.c b/gc.c
index c78ef4de113ef5..c2fc681253aa36 100644
--- a/gc.c
+++ b/gc.c
@@ -4699,9 +4699,10 @@ rb_raw_obj_info_buitin_type(char *const buff, const size_t buff_size, const VALU
                 rb_raw_obj_info(BUFF_ARGS, ARY_SHARED_ROOT(obj));
             }
             else {
-                APPEND_F("[%s%s] ",
-                         C(ARY_EMBED_P(obj),  "E"),
-                         C(ARY_SHARED_P(obj), "S"));
+                APPEND_F("[%s%s%s] ",
+                         C(ARY_EMBED_P(obj), "E"),
+                         C(ARY_SHARED_P(obj), "S"),
+                         C(ARY_SHARED_ROOT_P(obj), "R"));
 
                 if (ARY_EMBED_P(obj)) {
                     APPEND_F("len: %ld (embed)",

From cb31be5d6a6032da777a8c311469e40c7e26caab Mon Sep 17 00:00:00 2001
From: Donghee Na <donghee.na92@gmail.com>
Date: Mon, 18 Aug 2025 23:59:18 +0900
Subject: [PATCH 04/17] ZJIT: Codegen for NewHash (#14059)

This is my first contribution to ZJIT.

Co-authored-by: Takashi Kokubun <takashikkbn@gmail.com>
Co-authored-by: Max Bernstein <ruby@bernsteinbear.com>
---
 test/.excludes-zjit/TestRubyOptimization.rb |   1 +
 test/ruby/test_zjit.rb                      | 110 ++++++++++++++++++++
 zjit/src/codegen.rs                         |  61 ++++++++++-
 3 files changed, 169 insertions(+), 3 deletions(-)
 create mode 100644 test/.excludes-zjit/TestRubyOptimization.rb

diff --git a/test/.excludes-zjit/TestRubyOptimization.rb b/test/.excludes-zjit/TestRubyOptimization.rb
new file mode 100644
index 00000000000000..5361ab02c7a8af
--- /dev/null
+++ b/test/.excludes-zjit/TestRubyOptimization.rb
@@ -0,0 +1 @@
+exclude(:test_side_effect_in_popped_splat, 'Test fails with ZJIT due to locals invalidation')
diff --git a/test/ruby/test_zjit.rb b/test/ruby/test_zjit.rb
index d30af737c3bde8..485fc403a843d0 100644
--- a/test/ruby/test_zjit.rb
+++ b/test/ruby/test_zjit.rb
@@ -509,6 +509,116 @@ def test(a, b) = a >= b
     }, insns: [:opt_ge], call_threshold: 2
   end
 
+  def test_new_hash_empty
+    assert_compiles '{}', %q{
+      def test = {}
+      test
+    }, insns: [:newhash]
+  end
+
+  def test_new_hash_nonempty
+    assert_compiles '{"key" => "value", 42 => 100}', %q{
+      def test
+        key = "key"
+        value = "value"
+        num = 42
+        result = 100
+        {key => value, num => result}
+      end
+      test
+    }, insns: [:newhash]
+  end
+
+  def test_new_hash_single_key_value
+    assert_compiles '{"key" => "value"}', %q{
+      def test = {"key" => "value"}
+      test
+    }, insns: [:newhash]
+  end
+
+  def test_new_hash_with_computation
+    assert_compiles '{"sum" => 5, "product" => 6}', %q{
+      def test(a, b)
+        {"sum" => a + b, "product" => a * b}
+      end
+      test(2, 3)
+    }, insns: [:newhash]
+  end
+
+  def test_new_hash_with_user_defined_hash_method
+    assert_runs 'true', %q{
+      class CustomKey
+        attr_reader :val
+
+        def initialize(val)
+          @val = val
+        end
+
+        def hash
+          @val.hash
+        end
+
+        def eql?(other)
+          other.is_a?(CustomKey) && @val == other.val
+        end
+      end
+
+      def test
+        key = CustomKey.new("key")
+        hash = {key => "value"}
+        hash[key] == "value"
+      end
+      test
+    }
+  end
+
+  def test_new_hash_with_user_hash_method_exception
+    assert_runs 'RuntimeError', %q{
+      class BadKey
+        def hash
+          raise "Hash method failed!"
+        end
+      end
+
+      def test
+        key = BadKey.new
+        {key => "value"}
+      end
+
+      begin
+        test
+      rescue => e
+        e.class
+      end
+    }
+  end
+
+  def test_new_hash_with_user_eql_method_exception
+    assert_runs 'RuntimeError', %q{
+      class BadKey
+        def hash
+          42
+        end
+
+        def eql?(other)
+          raise "Eql method failed!"
+        end
+      end
+
+      def test
+        key1 = BadKey.new
+        key2 = BadKey.new
+        {key1 => "value1", key2 => "value2"}
+      end
+
+      begin
+        test
+      rescue => e
+        e.class
+      end
+    }
+  end
+
   def test_opt_hash_freeze
     assert_compiles '{}', <<~RUBY, insns: [:opt_hash_freeze]
       def test = {}.freeze
diff --git a/zjit/src/codegen.rs b/zjit/src/codegen.rs
index a58950ab9acb4b..090f843115bd45 100644
--- a/zjit/src/codegen.rs
+++ b/zjit/src/codegen.rs
@@ -1,6 +1,6 @@
 use std::cell::Cell;
 use std::rc::Rc;
-use std::ffi::{c_int, c_void};
+use std::ffi::{c_int, c_long, c_void};
 
 use crate::asm::Label;
 use crate::backend::current::{Reg, ALLOC_REGS};
@@ -332,6 +332,7 @@ fn gen_insn(cb: &mut CodeBlock, jit: &mut JITState, asm: &mut Assembler, functio
     let out_opnd = match insn {
         Insn::Const { val: Const::Value(val) } => gen_const(*val),
         Insn::NewArray { elements, state } => gen_new_array(asm, opnds!(elements), &function.frame_state(*state)),
+        Insn::NewHash { elements, state } => gen_new_hash(jit, asm, elements, &function.frame_state(*state))?,
         Insn::NewRange { low, high, flag, state } => gen_new_range(asm, opnd!(low), opnd!(high), *flag, &function.frame_state(*state)),
         Insn::ArrayDup { val, state } => gen_array_dup(asm, opnd!(val), &function.frame_state(*state)),
         Insn::StringCopy { val, chilled, state } => gen_string_copy(asm, opnd!(val), *chilled, &function.frame_state(*state)),
@@ -388,7 +389,6 @@ fn gen_insn(cb: &mut CodeBlock, jit: &mut JITState, asm: &mut Assembler, functio
         | Insn::FixnumDiv { .. }
         | Insn::FixnumMod { .. }
         | Insn::HashDup { .. }
-        | Insn::NewHash { .. }
         | Insn::Send { .. }
         | Insn::Throw { .. }
         | Insn::ToArray { .. }
@@ -974,7 +974,7 @@ fn gen_new_array(
 ) -> lir::Opnd {
     gen_prepare_call_with_gc(asm, state);
 
-    let length: ::std::os::raw::c_long = elements.len().try_into().expect("Unable to fit length of elements into c_long");
+    let length: c_long = elements.len().try_into().expect("Unable to fit length of elements into c_long");
 
     let new_array = asm_ccall!(asm, rb_ary_new_capa, length.into());
 
@@ -985,6 +985,61 @@ fn gen_new_array(
     new_array
 }
 
+/// Compile a new hash instruction
+fn gen_new_hash(
+    jit: &mut JITState,
+    asm: &mut Assembler,
+    elements: &Vec<(InsnId, InsnId)>,
+    state: &FrameState,
+) -> Option<lir::Opnd> {
+    gen_prepare_non_leaf_call(jit, asm, state)?;
+
+    let cap: c_long = elements.len().try_into().expect("Unable to fit length of elements into c_long");
+    let new_hash = asm_ccall!(asm, rb_hash_new_with_size, lir::Opnd::Imm(cap));
+
+    if !elements.is_empty() {
+        let mut pairs = Vec::new();
+        for (key_id, val_id) in elements.iter() {
+            let key = jit.get_opnd(*key_id)?;
+            let val = jit.get_opnd(*val_id)?;
+            pairs.push(key);
+            pairs.push(val);
+        }
+
+        let n = pairs.len();
+
+        // Calculate the compile-time NATIVE_STACK_PTR offset from NATIVE_BASE_PTR
+        // At this point, frame_setup(&[], jit.c_stack_slots) has been called,
+        // which allocated aligned_stack_bytes(jit.c_stack_slots) on the stack
+        let frame_size = aligned_stack_bytes(jit.c_stack_slots);
+        let allocation_size = aligned_stack_bytes(n);
+
+        asm_comment!(asm, "allocate {} bytes on C stack for {} hash elements", allocation_size, n);
+        asm.sub_into(NATIVE_STACK_PTR, allocation_size.into());
+
+        // Calculate the total offset from NATIVE_BASE_PTR to our buffer
+        let total_offset_from_base = (frame_size + allocation_size) as i32;
+
+        for (idx, &pair_opnd) in pairs.iter().enumerate() {
+            let slot_offset = -total_offset_from_base + (idx as i32 * SIZEOF_VALUE_I32);
+            asm.mov(
+                Opnd::mem(VALUE_BITS, NATIVE_BASE_PTR, slot_offset),
+                pair_opnd
+            );
+        }
+
+        let argv = asm.lea(Opnd::mem(64, NATIVE_BASE_PTR, -total_offset_from_base));
+
+        let argc = (elements.len() * 2) as ::std::os::raw::c_long;
+        asm_ccall!(asm, rb_hash_bulk_insert, lir::Opnd::Imm(argc), argv, new_hash);
+
+        asm_comment!(asm, "restore C stack pointer");
+        asm.add_into(NATIVE_STACK_PTR, allocation_size.into());
+    }
+
+    Some(new_hash)
+}
+
 /// Compile a new range instruction
 fn gen_new_range(
     asm: &mut Assembler,

From d330bcfd49545e586486f773b74be43ee2197192 Mon Sep 17 00:00:00 2001
From: Max Bernstein <rubybugs@bernsteinbear.com>
Date: Mon, 18 Aug 2025 09:01:09 -0700
Subject: [PATCH 05/17] ZJIT: Make sure output operands are not VRegs (#14188)

Make LIR SSA.
---
 zjit/src/backend/lir.rs | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/zjit/src/backend/lir.rs b/zjit/src/backend/lir.rs
index 54bef9d9255184..460e2719dd9a38 100644
--- a/zjit/src/backend/lir.rs
+++ b/zjit/src/backend/lir.rs
@@ -1684,6 +1684,7 @@ impl Assembler {
     }
 
     pub fn cpop_into(&mut self, opnd: Opnd) {
+        assert!(matches!(opnd, Opnd::Reg(_)), "Destination of cpop_into must be a register, got: {opnd:?}");
         self.push_insn(Insn::CPopInto(opnd));
     }
 
@@ -1831,6 +1832,7 @@ impl Assembler {
     }
 
     pub fn lea_into(&mut self, out: Opnd, opnd: Opnd) {
+        assert!(matches!(out, Opnd::Reg(_)), "Destination of lea_into must be a register, got: {out:?}");
         self.push_insn(Insn::Lea { opnd, out });
     }
 
@@ -1856,7 +1858,7 @@ impl Assembler {
     }
 
     pub fn load_into(&mut self, dest: Opnd, opnd: Opnd) {
-        assert!(matches!(dest, Opnd::Reg(_) | Opnd::VReg{..}), "Destination of load_into must be a register");
+        assert!(matches!(dest, Opnd::Reg(_)), "Destination of load_into must be a register, got: {dest:?}");
         match (dest, opnd) {
             (Opnd::Reg(dest), Opnd::Reg(opnd)) if dest == opnd => {}, // skip if noop
             _ => self.push_insn(Insn::LoadInto { dest, opnd }),
@@ -1882,6 +1884,7 @@ impl Assembler {
     }
 
     pub fn mov(&mut self, dest: Opnd, src: Opnd) {
+        assert!(!matches!(dest, Opnd::VReg { .. }), "Destination of mov must not be Opnd::VReg, got: {dest:?}");
         self.push_insn(Insn::Mov { dest, src });
     }
 
@@ -1919,6 +1922,7 @@ impl Assembler {
     }
 
     pub fn store(&mut self, dest: Opnd, src: Opnd) {
+        assert!(!matches!(dest, Opnd::VReg { .. }), "Destination of store must not be Opnd::VReg, got: {dest:?}");
         self.push_insn(Insn::Store { dest, src });
     }
 

From 5b3c87a0b006390cf23c7b53c1688a513a6860b3 Mon Sep 17 00:00:00 2001
From: Max Bernstein <ruby@bernsteinbear.com>
Date: Fri, 15 Aug 2025 10:23:25 -0400
Subject: [PATCH 06/17] ZJIT: Make jit.get_opnd noisily fail

We have a verifier that runs in debug mode that should prevent this.
Simplify a bunch of call sites.
---
 zjit/src/codegen.rs | 32 ++++++++++++++------------------
 1 file changed, 14 insertions(+), 18 deletions(-)

diff --git a/zjit/src/codegen.rs b/zjit/src/codegen.rs
index 090f843115bd45..2a2b4d1ec730e3 100644
--- a/zjit/src/codegen.rs
+++ b/zjit/src/codegen.rs
@@ -46,12 +46,8 @@ impl JITState {
     }
 
     /// Retrieve the output of a given instruction that has been compiled
-    fn get_opnd(&self, insn_id: InsnId) -> Option<lir::Opnd> {
-        let opnd = self.opnds[insn_id.0];
-        if opnd.is_none() {
-            debug!("Failed to get_opnd({insn_id})");
-        }
-        opnd
+    fn get_opnd(&self, insn_id: InsnId) -> lir::Opnd {
+        self.opnds[insn_id.0].expect(&format!("Failed to get_opnd({insn_id})"))
     }
 
     /// Find or create a label for a given BlockId
@@ -313,14 +309,14 @@ fn gen_insn(cb: &mut CodeBlock, jit: &mut JITState, asm: &mut Assembler, functio
     // Convert InsnId to lir::Opnd
     macro_rules! opnd {
         ($insn_id:ident) => {
-            jit.get_opnd($insn_id.clone())?
+            jit.get_opnd($insn_id.clone())
         };
     }
 
     macro_rules! opnds {
         ($insn_ids:ident) => {
             {
-                Option::from_iter($insn_ids.iter().map(|insn_id| jit.get_opnd(*insn_id)))?
+                $insn_ids.iter().map(|insn_id| jit.get_opnd(*insn_id)).collect::<Vec<_>>()
             }
         };
     }
@@ -514,12 +510,12 @@ fn gen_setlocal_with_ep(asm: &mut Assembler, jit: &JITState, function: &Function
     // we can skip the write barrier.
     if function.type_of(val).is_immediate() {
         let offset = -(SIZEOF_VALUE_I32 * i32::try_from(local_ep_offset).ok()?);
-        asm.mov(Opnd::mem(64, ep, offset), jit.get_opnd(val)?);
+        asm.mov(Opnd::mem(64, ep, offset), jit.get_opnd(val));
     } else {
         // We're potentially writing a reference to an IMEMO/env object,
         // so take care of the write barrier with a function.
         let local_index = c_int::try_from(local_ep_offset).ok().and_then(|idx| idx.checked_mul(-1))?;
-        asm_ccall!(asm, rb_vm_env_write, ep, local_index.into(), jit.get_opnd(val)?);
+        asm_ccall!(asm, rb_vm_env_write, ep, local_index.into(), jit.get_opnd(val));
     }
     Some(())
 }
@@ -742,11 +738,11 @@ fn gen_branch_params(jit: &mut JITState, asm: &mut Assembler, branch: &BranchEdg
             match param_opnd(idx) {
                 Opnd::Reg(reg) => {
                     // If a parameter is a register, we need to parallel-move it
-                    moves.push((reg, jit.get_opnd(arg)?));
+                    moves.push((reg, jit.get_opnd(arg)));
                 },
                 param => {
                     // If a parameter is memory, we set it beforehand
-                    asm.mov(param, jit.get_opnd(arg)?);
+                    asm.mov(param, jit.get_opnd(arg));
                 }
             }
         }
@@ -1000,8 +996,8 @@ fn gen_new_hash(
     if !elements.is_empty() {
         let mut pairs = Vec::new();
         for (key_id, val_id) in elements.iter() {
-            let key = jit.get_opnd(*key_id)?;
-            let val = jit.get_opnd(*val_id)?;
+            let key = jit.get_opnd(*key_id);
+            let val = jit.get_opnd(*val_id);
             pairs.push(key);
             pairs.push(val);
         }
@@ -1280,7 +1276,7 @@ fn gen_spill_locals(jit: &JITState, asm: &mut Assembler, state: &FrameState) ->
     // TODO: Avoid spilling locals that have been spilled before and not changed.
     asm_comment!(asm, "spill locals");
     for (idx, &insn_id) in state.locals().enumerate() {
-        asm.mov(Opnd::mem(64, SP, (-local_idx_to_ep_offset(jit.iseq, idx) - 1) * SIZEOF_VALUE_I32), jit.get_opnd(insn_id)?);
+        asm.mov(Opnd::mem(64, SP, (-local_idx_to_ep_offset(jit.iseq, idx) - 1) * SIZEOF_VALUE_I32), jit.get_opnd(insn_id));
     }
     Some(())
 }
@@ -1291,7 +1287,7 @@ fn gen_spill_stack(jit: &JITState, asm: &mut Assembler, state: &FrameState) -> O
     // gen_send_without_block_direct() spills stack slots above SP for arguments.
     asm_comment!(asm, "spill stack");
     for (idx, &insn_id) in state.stack().enumerate() {
-        asm.mov(Opnd::mem(64, SP, idx as i32 * SIZEOF_VALUE_I32), jit.get_opnd(insn_id)?);
+        asm.mov(Opnd::mem(64, SP, idx as i32 * SIZEOF_VALUE_I32), jit.get_opnd(insn_id));
     }
     Some(())
 }
@@ -1416,12 +1412,12 @@ fn side_exit(jit: &mut JITState, state: &FrameState, reason: SideExitReason) ->
 fn build_side_exit(jit: &mut JITState, state: &FrameState, reason: SideExitReason, label: Option<Label>) -> Option<Target> {
     let mut stack = Vec::new();
     for &insn_id in state.stack() {
-        stack.push(jit.get_opnd(insn_id)?);
+        stack.push(jit.get_opnd(insn_id));
     }
 
     let mut locals = Vec::new();
     for &insn_id in state.locals() {
-        locals.push(jit.get_opnd(insn_id)?);
+        locals.push(jit.get_opnd(insn_id));
     }
 
     let target = Target::SideExit {

From ad9fda7a2f7eaed3393ea10d7843721243d1a74f Mon Sep 17 00:00:00 2001
From: Max Bernstein <ruby@bernsteinbear.com>
Date: Fri, 15 Aug 2025 10:24:08 -0400
Subject: [PATCH 07/17] ZJIT: Don't return Option from codegen helper functions

They don't need it anymore; jit.get_opnd doesn't return Option anymore.
---
 zjit/src/codegen.rs | 32 ++++++++++++++------------------
 1 file changed, 14 insertions(+), 18 deletions(-)

diff --git a/zjit/src/codegen.rs b/zjit/src/codegen.rs
index 2a2b4d1ec730e3..670f1cafc69666 100644
--- a/zjit/src/codegen.rs
+++ b/zjit/src/codegen.rs
@@ -443,7 +443,7 @@ fn gen_get_ep(asm: &mut Assembler, level: u32) -> Opnd {
 }
 
 fn gen_objtostring(jit: &mut JITState, asm: &mut Assembler, val: Opnd, cd: *const rb_call_data, state: &FrameState) -> Option<Opnd> {
-    gen_prepare_non_leaf_call(jit, asm, state)?;
+    gen_prepare_non_leaf_call(jit, asm, state);
 
     let iseq_opnd = Opnd::Value(jit.iseq.into());
 
@@ -479,7 +479,7 @@ fn gen_defined(jit: &JITState, asm: &mut Assembler, op_type: usize, obj: VALUE,
         }
         _ => {
             // Save the PC and SP because the callee may allocate or call #respond_to?
-            gen_prepare_non_leaf_call(jit, asm, state)?;
+            gen_prepare_non_leaf_call(jit, asm, state);
 
             // TODO: Inline the cases for each op_type
             // Call vm_defined(ec, reg_cfp, op_type, obj, v)
@@ -526,7 +526,7 @@ fn gen_get_constant_path(jit: &JITState, asm: &mut Assembler, ic: *const iseq_in
     }
 
     // Anything could be called on const_missing
-    gen_prepare_non_leaf_call(jit, asm, state)?;
+    gen_prepare_non_leaf_call(jit, asm, state);
 
     Some(asm_ccall!(asm, rb_vm_opt_getconstant_path, EC, CFP, Opnd::const_ptr(ic)))
 }
@@ -539,7 +539,7 @@ fn gen_invokebuiltin(jit: &JITState, asm: &mut Assembler, state: &FrameState, bf
     }
 
     // Anything can happen inside builtin functions
-    gen_prepare_non_leaf_call(jit, asm, state)?;
+    gen_prepare_non_leaf_call(jit, asm, state);
 
     let mut cargs = vec![EC];
     cargs.extend(args);
@@ -614,7 +614,7 @@ fn gen_intern(asm: &mut Assembler, val: Opnd, state: &FrameState) -> Option<Opnd
 /// Set global variables
 fn gen_setglobal(jit: &mut JITState, asm: &mut Assembler, id: ID, val: Opnd, state: &FrameState) -> Option<()> {
     // When trace_var is used, setting a global variable can cause exceptions
-    gen_prepare_non_leaf_call(jit, asm, state)?;
+    gen_prepare_non_leaf_call(jit, asm, state);
 
     asm_ccall!(asm, rb_gvar_set, id.0.into(), val);
     Some(())
@@ -846,7 +846,7 @@ fn gen_send_without_block(
     self_val: Opnd,
     args: Vec<Opnd>,
 ) -> Option<lir::Opnd> {
-    gen_spill_locals(jit, asm, state)?;
+    gen_spill_locals(jit, asm, state);
     // Spill the receiver and the arguments onto the stack.
     // They need to be on the interpreter stack to let the interpreter access them.
     // TODO: Avoid spilling operands that have been spilled before.
@@ -893,8 +893,8 @@ fn gen_send_without_block_direct(
     gen_save_pc(asm, state);
     gen_save_sp(asm, state.stack().len() - args.len() - 1); // -1 for receiver
 
-    gen_spill_locals(jit, asm, state)?;
-    gen_spill_stack(jit, asm, state)?;
+    gen_spill_locals(jit, asm, state);
+    gen_spill_stack(jit, asm, state);
 
     // Set up the new frame
     // TODO: Lazily materialize caller frames on side exits or when needed
@@ -1272,30 +1272,27 @@ fn gen_save_sp(asm: &mut Assembler, stack_size: usize) {
 }
 
 /// Spill locals onto the stack.
-fn gen_spill_locals(jit: &JITState, asm: &mut Assembler, state: &FrameState) -> Option<()> {
+fn gen_spill_locals(jit: &JITState, asm: &mut Assembler, state: &FrameState) {
     // TODO: Avoid spilling locals that have been spilled before and not changed.
     asm_comment!(asm, "spill locals");
     for (idx, &insn_id) in state.locals().enumerate() {
         asm.mov(Opnd::mem(64, SP, (-local_idx_to_ep_offset(jit.iseq, idx) - 1) * SIZEOF_VALUE_I32), jit.get_opnd(insn_id));
     }
-    Some(())
 }
 
 /// Spill the virtual stack onto the stack.
-fn gen_spill_stack(jit: &JITState, asm: &mut Assembler, state: &FrameState) -> Option<()> {
+fn gen_spill_stack(jit: &JITState, asm: &mut Assembler, state: &FrameState) {
     // This function does not call gen_save_sp() at the moment because
     // gen_send_without_block_direct() spills stack slots above SP for arguments.
     asm_comment!(asm, "spill stack");
     for (idx, &insn_id) in state.stack().enumerate() {
         asm.mov(Opnd::mem(64, SP, idx as i32 * SIZEOF_VALUE_I32), jit.get_opnd(insn_id));
     }
-    Some(())
 }
 
 /// Prepare for calling a C function that may call an arbitrary method.
 /// Use gen_prepare_call_with_gc() if the method is leaf but allocates objects.
-#[must_use]
-fn gen_prepare_non_leaf_call(jit: &JITState, asm: &mut Assembler, state: &FrameState) -> Option<()> {
+fn gen_prepare_non_leaf_call(jit: &JITState, asm: &mut Assembler, state: &FrameState) {
     // TODO: Lazily materialize caller frames when needed
     // Save PC for backtraces and allocation tracing
     gen_save_pc(asm, state);
@@ -1303,11 +1300,10 @@ fn gen_prepare_non_leaf_call(jit: &JITState, asm: &mut Assembler, state: &FrameS
     // Save SP and spill the virtual stack in case it raises an exception
     // and the interpreter uses the stack for handling the exception
     gen_save_sp(asm, state.stack().len());
-    gen_spill_stack(jit, asm, state)?;
+    gen_spill_stack(jit, asm, state);
 
     // Spill locals in case the method looks at caller Bindings
-    gen_spill_locals(jit, asm, state)?;
-    Some(())
+    gen_spill_locals(jit, asm, state);
 }
 
 /// Prepare for calling a C function that may allocate objects and trigger GC.
@@ -1610,7 +1606,7 @@ fn gen_string_concat(jit: &mut JITState, asm: &mut Assembler, strings: Vec<Opnd>
         return None;
     }
 
-    gen_prepare_non_leaf_call(jit, asm, state)?;
+    gen_prepare_non_leaf_call(jit, asm, state);
 
     // Calculate the compile-time NATIVE_STACK_PTR offset from NATIVE_BASE_PTR
     // At this point, frame_setup(&[], jit.c_stack_slots) has been called,

From 1e42f9edc2f7b2b93ff9acd272f858909ee295ef Mon Sep 17 00:00:00 2001
From: Max Bernstein <ruby@bernsteinbear.com>
Date: Fri, 15 Aug 2025 10:27:53 -0400
Subject: [PATCH 08/17] ZJIT: Remove empty returns from control instructions in
 codegen

---
 zjit/src/codegen.rs | 22 ++++++++--------------
 1 file changed, 8 insertions(+), 14 deletions(-)

diff --git a/zjit/src/codegen.rs b/zjit/src/codegen.rs
index 670f1cafc69666..292e688cec95fc 100644
--- a/zjit/src/codegen.rs
+++ b/zjit/src/codegen.rs
@@ -336,16 +336,16 @@ fn gen_insn(cb: &mut CodeBlock, jit: &mut JITState, asm: &mut Assembler, functio
         Insn::StringIntern { val, state } => gen_intern(asm, opnd!(val), &function.frame_state(*state))?,
         Insn::Param { idx } => unreachable!("block.insns should not have Insn::Param({idx})"),
         Insn::Snapshot { .. } => return Some(()), // we don't need to do anything for this instruction at the moment
-        Insn::Jump(branch) => return gen_jump(jit, asm, branch),
-        Insn::IfTrue { val, target } => return gen_if_true(jit, asm, opnd!(val), target),
-        Insn::IfFalse { val, target } => return gen_if_false(jit, asm, opnd!(val), target),
+        Insn::Jump(branch) => { gen_jump(jit, asm, branch); return Some(()); },
+        Insn::IfTrue { val, target } => { gen_if_true(jit, asm, opnd!(val), target); return Some(()); },
+        Insn::IfFalse { val, target } => { gen_if_false(jit, asm, opnd!(val), target); return Some(()); },
         Insn::SendWithoutBlock { cd, state, self_val, args, .. } => gen_send_without_block(jit, asm, *cd, &function.frame_state(*state), opnd!(self_val), opnds!(args))?,
         // Give up SendWithoutBlockDirect for 6+ args since asm.ccall() doesn't support it.
         Insn::SendWithoutBlockDirect { cd, state, self_val, args, .. } if args.len() + 1 > C_ARG_OPNDS.len() => // +1 for self
             gen_send_without_block(jit, asm, *cd, &function.frame_state(*state), opnd!(self_val), opnds!(args))?,
         Insn::SendWithoutBlockDirect { cme, iseq, self_val, args, state, .. } => gen_send_without_block_direct(cb, jit, asm, *cme, *iseq, opnd!(self_val), opnds!(args), &function.frame_state(*state))?,
         Insn::InvokeBuiltin { bf, args, state, .. } => gen_invokebuiltin(jit, asm, &function.frame_state(*state), bf, opnds!(args))?,
-        Insn::Return { val } => return Some(gen_return(asm, opnd!(val))?),
+        Insn::Return { val } => { gen_return(asm, opnd!(val)); return Some(()); },
         Insn::FixnumAdd { left, right, state } => gen_fixnum_add(jit, asm, opnd!(left), opnd!(right), &function.frame_state(*state))?,
         Insn::FixnumSub { left, right, state } => gen_fixnum_sub(jit, asm, opnd!(left), opnd!(right), &function.frame_state(*state))?,
         Insn::FixnumMult { left, right, state } => gen_fixnum_mult(jit, asm, opnd!(left), opnd!(right), &function.frame_state(*state))?,
@@ -791,18 +791,17 @@ fn gen_param(asm: &mut Assembler, idx: usize) -> lir::Opnd {
 }
 
 /// Compile a jump to a basic block
-fn gen_jump(jit: &mut JITState, asm: &mut Assembler, branch: &BranchEdge) -> Option<()> {
+fn gen_jump(jit: &mut JITState, asm: &mut Assembler, branch: &BranchEdge) {
     // Set basic block arguments
     gen_branch_params(jit, asm, branch);
 
     // Jump to the basic block
     let target = jit.get_label(asm, branch.target);
     asm.jmp(target);
-    Some(())
 }
 
 /// Compile a conditional branch to a basic block
-fn gen_if_true(jit: &mut JITState, asm: &mut Assembler, val: lir::Opnd, branch: &BranchEdge) -> Option<()> {
+fn gen_if_true(jit: &mut JITState, asm: &mut Assembler, val: lir::Opnd, branch: &BranchEdge) {
     // If val is zero, move on to the next instruction.
     let if_false = asm.new_label("if_false");
     asm.test(val, val);
@@ -815,12 +814,10 @@ fn gen_if_true(jit: &mut JITState, asm: &mut Assembler, val: lir::Opnd, branch:
     asm.jmp(if_true);
 
     asm.write_label(if_false);
-
-    Some(())
 }
 
 /// Compile a conditional branch to a basic block
-fn gen_if_false(jit: &mut JITState, asm: &mut Assembler, val: lir::Opnd, branch: &BranchEdge) -> Option<()> {
+fn gen_if_false(jit: &mut JITState, asm: &mut Assembler, val: lir::Opnd, branch: &BranchEdge) {
     // If val is not zero, move on to the next instruction.
     let if_true = asm.new_label("if_true");
     asm.test(val, val);
@@ -833,8 +830,6 @@ fn gen_if_false(jit: &mut JITState, asm: &mut Assembler, val: lir::Opnd, branch:
     asm.jmp(if_false);
 
     asm.write_label(if_true);
-
-    Some(())
 }
 
 /// Compile a dynamic dispatch without block
@@ -1051,7 +1046,7 @@ fn gen_new_range(
 }
 
 /// Compile code that exits from JIT code with a return value
-fn gen_return(asm: &mut Assembler, val: lir::Opnd) -> Option<()> {
+fn gen_return(asm: &mut Assembler, val: lir::Opnd) {
     // Pop the current frame (ec->cfp++)
     // Note: the return PC is already in the previous CFP
     asm_comment!(asm, "pop stack frame");
@@ -1066,7 +1061,6 @@ fn gen_return(asm: &mut Assembler, val: lir::Opnd) -> Option<()> {
     // Return from the function
     asm.frame_teardown(&[]); // matching the setup in :bb0-prologue:
     asm.cret(C_RET_OPND);
-    Some(())
 }
 
 /// Compile Fixnum + Fixnum

From 3c2cff629fcd431a50ae4f71391071f9a1880cf0 Mon Sep 17 00:00:00 2001
From: Max Bernstein <ruby@bernsteinbear.com>
Date: Fri, 15 Aug 2025 10:29:19 -0400
Subject: [PATCH 09/17] ZJIT: Don't return Option from side exits

---
 zjit/src/codegen.rs | 39 +++++++++++++++++++--------------------
 1 file changed, 19 insertions(+), 20 deletions(-)

diff --git a/zjit/src/codegen.rs b/zjit/src/codegen.rs
index 292e688cec95fc..c9d80e1ade2c93 100644
--- a/zjit/src/codegen.rs
+++ b/zjit/src/codegen.rs
@@ -370,7 +370,7 @@ fn gen_insn(cb: &mut CodeBlock, jit: &mut JITState, asm: &mut Assembler, functio
         &Insn::SetLocal { val, ep_offset, level } => return gen_setlocal_with_ep(asm, jit, function, val, ep_offset, level),
         Insn::GetConstantPath { ic, state } => gen_get_constant_path(jit, asm, *ic, &function.frame_state(*state))?,
         Insn::SetIvar { self_val, id, val, state: _ } => return gen_setivar(asm, opnd!(self_val), *id, opnd!(val)),
-        Insn::SideExit { state, reason } => return gen_side_exit(jit, asm, reason, &function.frame_state(*state)),
+        Insn::SideExit { state, reason } => { gen_side_exit(jit, asm, reason, &function.frame_state(*state)); return Some(()); },
         Insn::PutSpecialObject { value_type } => gen_putspecialobject(asm, *value_type),
         Insn::AnyToString { val, str, state } => gen_anytostring(asm, opnd!(val), opnd!(str), &function.frame_state(*state))?,
         Insn::Defined { op_type, obj, pushval, v, state } => gen_defined(jit, asm, *op_type, *obj, *pushval, opnd!(v), &function.frame_state(*state))?,
@@ -455,7 +455,7 @@ fn gen_objtostring(jit: &mut JITState, asm: &mut Assembler, val: Opnd, cd: *cons
     // Need to replicate what CALL_SIMPLE_METHOD does
     asm_comment!(asm, "side-exit if rb_vm_objtostring returns Qundef");
     asm.cmp(ret, Qundef.into());
-    asm.je(side_exit(jit, state, ObjToStringFallback)?);
+    asm.je(side_exit(jit, state, ObjToStringFallback));
 
     Some(ret)
 }
@@ -556,7 +556,7 @@ fn gen_patch_point(jit: &mut JITState, asm: &mut Assembler, invariant: &Invarian
     let invariant = invariant.clone();
 
     // Compile a side exit. Fill nop instructions if the last patch point is too close.
-    asm.patch_point(build_side_exit(jit, state, PatchPoint(invariant), Some(label))?);
+    asm.patch_point(build_side_exit(jit, state, PatchPoint(invariant), Some(label)));
 
     // Remember the current address as a patch point
     asm.pos_marker(move |code_ptr, cb| {
@@ -621,9 +621,8 @@ fn gen_setglobal(jit: &mut JITState, asm: &mut Assembler, id: ID, val: Opnd, sta
 }
 
 /// Side-exit into the interpreter
-fn gen_side_exit(jit: &mut JITState, asm: &mut Assembler, reason: &SideExitReason, state: &FrameState) -> Option<()> {
-    asm.jmp(side_exit(jit, state, *reason)?);
-    Some(())
+fn gen_side_exit(jit: &mut JITState, asm: &mut Assembler, reason: &SideExitReason, state: &FrameState) {
+    asm.jmp(side_exit(jit, state, *reason));
 }
 
 /// Emit a special object lookup
@@ -1068,7 +1067,7 @@ fn gen_fixnum_add(jit: &mut JITState, asm: &mut Assembler, left: lir::Opnd, righ
     // Add left + right and test for overflow
     let left_untag = asm.sub(left, Opnd::Imm(1));
     let out_val = asm.add(left_untag, right);
-    asm.jo(side_exit(jit, state, FixnumAddOverflow)?);
+    asm.jo(side_exit(jit, state, FixnumAddOverflow));
 
     Some(out_val)
 }
@@ -1077,7 +1076,7 @@ fn gen_fixnum_add(jit: &mut JITState, asm: &mut Assembler, left: lir::Opnd, righ
 fn gen_fixnum_sub(jit: &mut JITState, asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd, state: &FrameState) -> Option<lir::Opnd> {
     // Subtract left - right and test for overflow
     let val_untag = asm.sub(left, right);
-    asm.jo(side_exit(jit, state, FixnumSubOverflow)?);
+    asm.jo(side_exit(jit, state, FixnumSubOverflow));
     let out_val = asm.add(val_untag, Opnd::Imm(1));
 
     Some(out_val)
@@ -1092,7 +1091,7 @@ fn gen_fixnum_mult(jit: &mut JITState, asm: &mut Assembler, left: lir::Opnd, rig
     let out_val = asm.mul(left_untag, right_untag);
 
     // Test for overflow
-    asm.jo_mul(side_exit(jit, state, FixnumMultOverflow)?);
+    asm.jo_mul(side_exit(jit, state, FixnumMultOverflow));
     let out_val = asm.add(out_val, Opnd::UImm(1));
 
     Some(out_val)
@@ -1172,27 +1171,27 @@ fn gen_test(asm: &mut Assembler, val: lir::Opnd) -> Option<lir::Opnd> {
 fn gen_guard_type(jit: &mut JITState, asm: &mut Assembler, val: lir::Opnd, guard_type: Type, state: &FrameState) -> Option<lir::Opnd> {
     if guard_type.is_subtype(types::Fixnum) {
         asm.test(val, Opnd::UImm(RUBY_FIXNUM_FLAG as u64));
-        asm.jz(side_exit(jit, state, GuardType(guard_type))?);
+        asm.jz(side_exit(jit, state, GuardType(guard_type)));
     } else if guard_type.is_subtype(types::Flonum) {
         // Flonum: (val & RUBY_FLONUM_MASK) == RUBY_FLONUM_FLAG
         let masked = asm.and(val, Opnd::UImm(RUBY_FLONUM_MASK as u64));
         asm.cmp(masked, Opnd::UImm(RUBY_FLONUM_FLAG as u64));
-        asm.jne(side_exit(jit, state, GuardType(guard_type))?);
+        asm.jne(side_exit(jit, state, GuardType(guard_type)));
     } else if guard_type.is_subtype(types::StaticSymbol) {
         // Static symbols have (val & 0xff) == RUBY_SYMBOL_FLAG
         // Use 8-bit comparison like YJIT does
         debug_assert!(val.try_num_bits(8).is_some(), "GuardType should not be used for a known constant, but val was: {val:?}");
         asm.cmp(val.try_num_bits(8)?, Opnd::UImm(RUBY_SYMBOL_FLAG as u64));
-        asm.jne(side_exit(jit, state, GuardType(guard_type))?);
+        asm.jne(side_exit(jit, state, GuardType(guard_type)));
     } else if guard_type.is_subtype(types::NilClass) {
         asm.cmp(val, Qnil.into());
-        asm.jne(side_exit(jit, state, GuardType(guard_type))?);
+        asm.jne(side_exit(jit, state, GuardType(guard_type)));
     } else if guard_type.is_subtype(types::TrueClass) {
         asm.cmp(val, Qtrue.into());
-        asm.jne(side_exit(jit, state, GuardType(guard_type))?);
+        asm.jne(side_exit(jit, state, GuardType(guard_type)));
     } else if guard_type.is_subtype(types::FalseClass) {
         asm.cmp(val, Qfalse.into());
-        asm.jne(side_exit(jit, state, GuardType(guard_type))?);
+        asm.jne(side_exit(jit, state, GuardType(guard_type)));
     } else if guard_type.is_immediate() {
         // All immediate types' guard should have been handled above
         panic!("unexpected immediate guard type: {guard_type}");
@@ -1207,7 +1206,7 @@ fn gen_guard_type(jit: &mut JITState, asm: &mut Assembler, val: lir::Opnd, guard
         };
 
         // Check if it's a special constant
-        let side_exit = side_exit(jit, state, GuardType(guard_type))?;
+        let side_exit = side_exit(jit, state, GuardType(guard_type));
         asm.test(val, (RUBY_IMMEDIATE_MASK as u64).into());
         asm.jnz(side_exit.clone());
 
@@ -1229,7 +1228,7 @@ fn gen_guard_type(jit: &mut JITState, asm: &mut Assembler, val: lir::Opnd, guard
 /// Compile an identity check with a side exit
 fn gen_guard_bit_equals(jit: &mut JITState, asm: &mut Assembler, val: lir::Opnd, expected: VALUE, state: &FrameState) -> Option<lir::Opnd> {
     asm.cmp(val, Opnd::Value(expected));
-    asm.jnz(side_exit(jit, state, GuardBitEquals(expected))?);
+    asm.jnz(side_exit(jit, state, GuardBitEquals(expected)));
     Some(val)
 }
 
@@ -1394,12 +1393,12 @@ fn compile_iseq(iseq: IseqPtr) -> Option<Function> {
 }
 
 /// Build a Target::SideExit for non-PatchPoint instructions
-fn side_exit(jit: &mut JITState, state: &FrameState, reason: SideExitReason) -> Option<Target> {
+fn side_exit(jit: &mut JITState, state: &FrameState, reason: SideExitReason) -> Target {
     build_side_exit(jit, state, reason, None)
 }
 
 /// Build a Target::SideExit out of a FrameState
-fn build_side_exit(jit: &mut JITState, state: &FrameState, reason: SideExitReason, label: Option<Label>) -> Option<Target> {
+fn build_side_exit(jit: &mut JITState, state: &FrameState, reason: SideExitReason, label: Option<Label>) -> Target {
     let mut stack = Vec::new();
     for &insn_id in state.stack() {
         stack.push(jit.get_opnd(insn_id));
@@ -1417,7 +1416,7 @@ fn build_side_exit(jit: &mut JITState, state: &FrameState, reason: SideExitReaso
         reason,
         label,
     };
-    Some(target)
+    target
 }
 
 /// Return true if a given ISEQ is known to escape EP to the heap on entry.

From d2a53c7c3d88961390c846763bce31320cc67a9d Mon Sep 17 00:00:00 2001
From: Max Bernstein <ruby@bernsteinbear.com>
Date: Fri, 15 Aug 2025 10:30:06 -0400
Subject: [PATCH 10/17] ZJIT: Don't return Option from counter increment

---
 zjit/src/codegen.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/zjit/src/codegen.rs b/zjit/src/codegen.rs
index c9d80e1ade2c93..76db03f81914fd 100644
--- a/zjit/src/codegen.rs
+++ b/zjit/src/codegen.rs
@@ -376,7 +376,7 @@ fn gen_insn(cb: &mut CodeBlock, jit: &mut JITState, asm: &mut Assembler, functio
         Insn::Defined { op_type, obj, pushval, v, state } => gen_defined(jit, asm, *op_type, *obj, *pushval, opnd!(v), &function.frame_state(*state))?,
         Insn::GetSpecialSymbol { symbol_type, state: _ } => gen_getspecial_symbol(asm, *symbol_type),
         Insn::GetSpecialNumber { nth, state } => gen_getspecial_number(asm, *nth, &function.frame_state(*state)),
-        &Insn::IncrCounter(counter) => return Some(gen_incr_counter(asm, counter)),
+        &Insn::IncrCounter(counter) => { gen_incr_counter(asm, counter); return Some(()); },
         Insn::ObjToString { val, cd, state, .. } => gen_objtostring(jit, asm, opnd!(val), *cd, &function.frame_state(*state))?,
         Insn::ArrayExtend { .. }
         | Insn::ArrayMax { .. }
@@ -1233,7 +1233,7 @@ fn gen_guard_bit_equals(jit: &mut JITState, asm: &mut Assembler, val: lir::Opnd,
 }
 
 /// Generate code that increments a counter in ZJIT stats
-fn gen_incr_counter(asm: &mut Assembler, counter: Counter) -> () {
+fn gen_incr_counter(asm: &mut Assembler, counter: Counter) {
     let ptr = counter_ptr(counter);
     let ptr_reg = asm.load(Opnd::const_ptr(ptr as *const u8));
     let counter_opnd = Opnd::mem(64, ptr_reg, 0);

From f3dbf7de7bf3865f0f1e03a03a530625e1da31e1 Mon Sep 17 00:00:00 2001
From: Max Bernstein <ruby@bernsteinbear.com>
Date: Fri, 15 Aug 2025 10:43:11 -0400
Subject: [PATCH 11/17] ZJIT: Make a fix a bunch of other cases using Option

---
 zjit/src/codegen.rs | 224 +++++++++++++++++++++-----------------------
 1 file changed, 109 insertions(+), 115 deletions(-)

diff --git a/zjit/src/codegen.rs b/zjit/src/codegen.rs
index 76db03f81914fd..467a45846ef707 100644
--- a/zjit/src/codegen.rs
+++ b/zjit/src/codegen.rs
@@ -321,6 +321,12 @@ fn gen_insn(cb: &mut CodeBlock, jit: &mut JITState, asm: &mut Assembler, functio
         };
     }
 
+    macro_rules! no_output {
+        ($call:expr) => {
+            { let () = $call; return Some(()); }
+        };
+    }
+
     if !matches!(*insn, Insn::Snapshot { .. }) {
         asm_comment!(asm, "Insn: {insn_id} {insn}");
     }
@@ -328,56 +334,59 @@ fn gen_insn(cb: &mut CodeBlock, jit: &mut JITState, asm: &mut Assembler, functio
     let out_opnd = match insn {
         Insn::Const { val: Const::Value(val) } => gen_const(*val),
         Insn::NewArray { elements, state } => gen_new_array(asm, opnds!(elements), &function.frame_state(*state)),
-        Insn::NewHash { elements, state } => gen_new_hash(jit, asm, elements, &function.frame_state(*state))?,
+        Insn::NewHash { elements, state } => gen_new_hash(jit, asm, elements, &function.frame_state(*state)),
         Insn::NewRange { low, high, flag, state } => gen_new_range(asm, opnd!(low), opnd!(high), *flag, &function.frame_state(*state)),
         Insn::ArrayDup { val, state } => gen_array_dup(asm, opnd!(val), &function.frame_state(*state)),
         Insn::StringCopy { val, chilled, state } => gen_string_copy(asm, opnd!(val), *chilled, &function.frame_state(*state)),
-        Insn::StringConcat { strings, state } => gen_string_concat(jit, asm, opnds!(strings), &function.frame_state(*state))?,
-        Insn::StringIntern { val, state } => gen_intern(asm, opnd!(val), &function.frame_state(*state))?,
+        // concatstrings shouldn't have 0 strings
+        // If it happens we abort the compilation for now
+        Insn::StringConcat { strings, .. } if strings.is_empty() => return None,
+        Insn::StringConcat { strings, state } => gen_string_concat(jit, asm, opnds!(strings), &function.frame_state(*state)),
+        Insn::StringIntern { val, state } => gen_intern(asm, opnd!(val), &function.frame_state(*state)),
         Insn::Param { idx } => unreachable!("block.insns should not have Insn::Param({idx})"),
         Insn::Snapshot { .. } => return Some(()), // we don't need to do anything for this instruction at the moment
-        Insn::Jump(branch) => { gen_jump(jit, asm, branch); return Some(()); },
-        Insn::IfTrue { val, target } => { gen_if_true(jit, asm, opnd!(val), target); return Some(()); },
-        Insn::IfFalse { val, target } => { gen_if_false(jit, asm, opnd!(val), target); return Some(()); },
-        Insn::SendWithoutBlock { cd, state, self_val, args, .. } => gen_send_without_block(jit, asm, *cd, &function.frame_state(*state), opnd!(self_val), opnds!(args))?,
+        Insn::Jump(branch) => no_output!(gen_jump(jit, asm, branch)),
+        Insn::IfTrue { val, target } => no_output!(gen_if_true(jit, asm, opnd!(val), target)),
+        Insn::IfFalse { val, target } => no_output!(gen_if_false(jit, asm, opnd!(val), target)),
+        Insn::SendWithoutBlock { cd, state, self_val, args, .. } => gen_send_without_block(jit, asm, *cd, &function.frame_state(*state), opnd!(self_val), opnds!(args)),
         // Give up SendWithoutBlockDirect for 6+ args since asm.ccall() doesn't support it.
         Insn::SendWithoutBlockDirect { cd, state, self_val, args, .. } if args.len() + 1 > C_ARG_OPNDS.len() => // +1 for self
-            gen_send_without_block(jit, asm, *cd, &function.frame_state(*state), opnd!(self_val), opnds!(args))?,
-        Insn::SendWithoutBlockDirect { cme, iseq, self_val, args, state, .. } => gen_send_without_block_direct(cb, jit, asm, *cme, *iseq, opnd!(self_val), opnds!(args), &function.frame_state(*state))?,
+            gen_send_without_block(jit, asm, *cd, &function.frame_state(*state), opnd!(self_val), opnds!(args)),
+        Insn::SendWithoutBlockDirect { cme, iseq, self_val, args, state, .. } => gen_send_without_block_direct(cb, jit, asm, *cme, *iseq, opnd!(self_val), opnds!(args), &function.frame_state(*state)),
         Insn::InvokeBuiltin { bf, args, state, .. } => gen_invokebuiltin(jit, asm, &function.frame_state(*state), bf, opnds!(args))?,
-        Insn::Return { val } => { gen_return(asm, opnd!(val)); return Some(()); },
-        Insn::FixnumAdd { left, right, state } => gen_fixnum_add(jit, asm, opnd!(left), opnd!(right), &function.frame_state(*state))?,
-        Insn::FixnumSub { left, right, state } => gen_fixnum_sub(jit, asm, opnd!(left), opnd!(right), &function.frame_state(*state))?,
-        Insn::FixnumMult { left, right, state } => gen_fixnum_mult(jit, asm, opnd!(left), opnd!(right), &function.frame_state(*state))?,
-        Insn::FixnumEq { left, right } => gen_fixnum_eq(asm, opnd!(left), opnd!(right))?,
-        Insn::FixnumNeq { left, right } => gen_fixnum_neq(asm, opnd!(left), opnd!(right))?,
-        Insn::FixnumLt { left, right } => gen_fixnum_lt(asm, opnd!(left), opnd!(right))?,
-        Insn::FixnumLe { left, right } => gen_fixnum_le(asm, opnd!(left), opnd!(right))?,
-        Insn::FixnumGt { left, right } => gen_fixnum_gt(asm, opnd!(left), opnd!(right))?,
-        Insn::FixnumGe { left, right } => gen_fixnum_ge(asm, opnd!(left), opnd!(right))?,
-        Insn::FixnumAnd { left, right } => gen_fixnum_and(asm, opnd!(left), opnd!(right))?,
-        Insn::FixnumOr { left, right } => gen_fixnum_or(asm, opnd!(left), opnd!(right))?,
-        Insn::IsNil { val } => gen_isnil(asm, opnd!(val))?,
-        Insn::Test { val } => gen_test(asm, opnd!(val))?,
+        Insn::Return { val } => no_output!(gen_return(asm, opnd!(val))),
+        Insn::FixnumAdd { left, right, state } => gen_fixnum_add(jit, asm, opnd!(left), opnd!(right), &function.frame_state(*state)),
+        Insn::FixnumSub { left, right, state } => gen_fixnum_sub(jit, asm, opnd!(left), opnd!(right), &function.frame_state(*state)),
+        Insn::FixnumMult { left, right, state } => gen_fixnum_mult(jit, asm, opnd!(left), opnd!(right), &function.frame_state(*state)),
+        Insn::FixnumEq { left, right } => gen_fixnum_eq(asm, opnd!(left), opnd!(right)),
+        Insn::FixnumNeq { left, right } => gen_fixnum_neq(asm, opnd!(left), opnd!(right)),
+        Insn::FixnumLt { left, right } => gen_fixnum_lt(asm, opnd!(left), opnd!(right)),
+        Insn::FixnumLe { left, right } => gen_fixnum_le(asm, opnd!(left), opnd!(right)),
+        Insn::FixnumGt { left, right } => gen_fixnum_gt(asm, opnd!(left), opnd!(right)),
+        Insn::FixnumGe { left, right } => gen_fixnum_ge(asm, opnd!(left), opnd!(right)),
+        Insn::FixnumAnd { left, right } => gen_fixnum_and(asm, opnd!(left), opnd!(right)),
+        Insn::FixnumOr { left, right } => gen_fixnum_or(asm, opnd!(left), opnd!(right)),
+        Insn::IsNil { val } => gen_isnil(asm, opnd!(val)),
+        Insn::Test { val } => gen_test(asm, opnd!(val)),
         Insn::GuardType { val, guard_type, state } => gen_guard_type(jit, asm, opnd!(val), *guard_type, &function.frame_state(*state))?,
-        Insn::GuardBitEquals { val, expected, state } => gen_guard_bit_equals(jit, asm, opnd!(val), *expected, &function.frame_state(*state))?,
-        Insn::PatchPoint { invariant, state } => return gen_patch_point(jit, asm, invariant, &function.frame_state(*state)),
-        Insn::CCall { cfun, args, name: _, return_type: _, elidable: _ } => gen_ccall(asm, *cfun, opnds!(args))?,
+        Insn::GuardBitEquals { val, expected, state } => gen_guard_bit_equals(jit, asm, opnd!(val), *expected, &function.frame_state(*state)),
+        Insn::PatchPoint { invariant, state } => no_output!(gen_patch_point(jit, asm, invariant, &function.frame_state(*state))),
+        Insn::CCall { cfun, args, name: _, return_type: _, elidable: _ } => gen_ccall(asm, *cfun, opnds!(args)),
         Insn::GetIvar { self_val, id, state: _ } => gen_getivar(asm, opnd!(self_val), *id),
-        Insn::SetGlobal { id, val, state } => return gen_setglobal(jit, asm, *id, opnd!(val), &function.frame_state(*state)),
+        Insn::SetGlobal { id, val, state } => no_output!(gen_setglobal(jit, asm, *id, opnd!(val), &function.frame_state(*state))),
         Insn::GetGlobal { id, state: _ } => gen_getglobal(asm, *id),
-        &Insn::GetLocal { ep_offset, level } => gen_getlocal_with_ep(asm, ep_offset, level)?,
-        &Insn::SetLocal { val, ep_offset, level } => return gen_setlocal_with_ep(asm, jit, function, val, ep_offset, level),
-        Insn::GetConstantPath { ic, state } => gen_get_constant_path(jit, asm, *ic, &function.frame_state(*state))?,
-        Insn::SetIvar { self_val, id, val, state: _ } => return gen_setivar(asm, opnd!(self_val), *id, opnd!(val)),
-        Insn::SideExit { state, reason } => { gen_side_exit(jit, asm, reason, &function.frame_state(*state)); return Some(()); },
+        &Insn::GetLocal { ep_offset, level } => gen_getlocal_with_ep(asm, ep_offset, level),
+        &Insn::SetLocal { val, ep_offset, level } => no_output!(gen_setlocal_with_ep(asm, opnd!(val), function.type_of(val), ep_offset, level)),
+        Insn::GetConstantPath { ic, state } => gen_get_constant_path(jit, asm, *ic, &function.frame_state(*state)),
+        Insn::SetIvar { self_val, id, val, state: _ } => no_output!(gen_setivar(asm, opnd!(self_val), *id, opnd!(val))),
+        Insn::SideExit { state, reason } => no_output!(gen_side_exit(jit, asm, reason, &function.frame_state(*state))),
         Insn::PutSpecialObject { value_type } => gen_putspecialobject(asm, *value_type),
-        Insn::AnyToString { val, str, state } => gen_anytostring(asm, opnd!(val), opnd!(str), &function.frame_state(*state))?,
-        Insn::Defined { op_type, obj, pushval, v, state } => gen_defined(jit, asm, *op_type, *obj, *pushval, opnd!(v), &function.frame_state(*state))?,
+        Insn::AnyToString { val, str, state } => gen_anytostring(asm, opnd!(val), opnd!(str), &function.frame_state(*state)),
+        Insn::Defined { op_type, obj, pushval, v, state } => gen_defined(jit, asm, *op_type, *obj, *pushval, opnd!(v), &function.frame_state(*state)),
         Insn::GetSpecialSymbol { symbol_type, state: _ } => gen_getspecial_symbol(asm, *symbol_type),
         Insn::GetSpecialNumber { nth, state } => gen_getspecial_number(asm, *nth, &function.frame_state(*state)),
-        &Insn::IncrCounter(counter) => { gen_incr_counter(asm, counter); return Some(()); },
-        Insn::ObjToString { val, cd, state, .. } => gen_objtostring(jit, asm, opnd!(val), *cd, &function.frame_state(*state))?,
+        &Insn::IncrCounter(counter) => no_output!(gen_incr_counter(asm, counter)),
+        Insn::ObjToString { val, cd, state, .. } => gen_objtostring(jit, asm, opnd!(val), *cd, &function.frame_state(*state)),
         Insn::ArrayExtend { .. }
         | Insn::ArrayMax { .. }
         | Insn::ArrayPush { .. }
@@ -442,7 +451,7 @@ fn gen_get_ep(asm: &mut Assembler, level: u32) -> Opnd {
     ep_opnd
 }
 
-fn gen_objtostring(jit: &mut JITState, asm: &mut Assembler, val: Opnd, cd: *const rb_call_data, state: &FrameState) -> Option<Opnd> {
+fn gen_objtostring(jit: &mut JITState, asm: &mut Assembler, val: Opnd, cd: *const rb_call_data, state: &FrameState) -> Opnd {
     gen_prepare_non_leaf_call(jit, asm, state);
 
     let iseq_opnd = Opnd::Value(jit.iseq.into());
@@ -457,10 +466,10 @@ fn gen_objtostring(jit: &mut JITState, asm: &mut Assembler, val: Opnd, cd: *cons
     asm.cmp(ret, Qundef.into());
     asm.je(side_exit(jit, state, ObjToStringFallback));
 
-    Some(ret)
+    ret
 }
 
-fn gen_defined(jit: &JITState, asm: &mut Assembler, op_type: usize, obj: VALUE, pushval: VALUE, tested_value: Opnd, state: &FrameState) -> Option<Opnd> {
+fn gen_defined(jit: &JITState, asm: &mut Assembler, op_type: usize, obj: VALUE, pushval: VALUE, tested_value: Opnd, state: &FrameState) -> Opnd {
     match op_type as defined_type {
         DEFINED_YIELD => {
             // `yield` goes to the block handler stowed in the "local" iseq which is
@@ -472,9 +481,9 @@ fn gen_defined(jit: &JITState, asm: &mut Assembler, op_type: usize, obj: VALUE,
                 let block_handler = asm.load(Opnd::mem(64, lep, SIZEOF_VALUE_I32 * VM_ENV_DATA_INDEX_SPECVAL));
                 let pushval = asm.load(pushval.into());
                 asm.cmp(block_handler, VM_BLOCK_HANDLER_NONE.into());
-                Some(asm.csel_e(Qnil.into(), pushval.into()))
+                asm.csel_e(Qnil.into(), pushval.into())
             } else {
-                Some(Qnil.into())
+                Qnil.into()
             }
         }
         _ => {
@@ -486,7 +495,7 @@ fn gen_defined(jit: &JITState, asm: &mut Assembler, op_type: usize, obj: VALUE,
             let def_result = asm_ccall!(asm, rb_vm_defined, EC, CFP, op_type.into(), obj.into(), tested_value);
 
             asm.cmp(def_result.with_num_bits(8), 0.into());
-            Some(asm.csel_ne(pushval.into(), Qnil.into()))
+            asm.csel_ne(pushval.into(), Qnil.into())
         }
     }
 }
@@ -494,33 +503,32 @@ fn gen_defined(jit: &JITState, asm: &mut Assembler, op_type: usize, obj: VALUE,
 /// Get a local variable from a higher scope or the heap. `local_ep_offset` is in number of VALUEs.
 /// We generate this instruction with level=0 only when the local variable is on the heap, so we
 /// can't optimize the level=0 case using the SP register.
-fn gen_getlocal_with_ep(asm: &mut Assembler, local_ep_offset: u32, level: u32) -> Option<lir::Opnd> {
+fn gen_getlocal_with_ep(asm: &mut Assembler, local_ep_offset: u32, level: u32) -> lir::Opnd {
     let ep = gen_get_ep(asm, level);
-    let offset = -(SIZEOF_VALUE_I32 * i32::try_from(local_ep_offset).ok()?);
-    Some(asm.load(Opnd::mem(64, ep, offset)))
+    let offset = -(SIZEOF_VALUE_I32 * i32::try_from(local_ep_offset).expect(&format!("Could not convert local_ep_offset {local_ep_offset} to i32")));
+    asm.load(Opnd::mem(64, ep, offset))
 }
 
 /// Set a local variable from a higher scope or the heap. `local_ep_offset` is in number of VALUEs.
 /// We generate this instruction with level=0 only when the local variable is on the heap, so we
 /// can't optimize the level=0 case using the SP register.
-fn gen_setlocal_with_ep(asm: &mut Assembler, jit: &JITState, function: &Function, val: InsnId, local_ep_offset: u32, level: u32) -> Option<()> {
+fn gen_setlocal_with_ep(asm: &mut Assembler, val: Opnd, val_type: Type, local_ep_offset: u32, level: u32) {
     let ep = gen_get_ep(asm, level);
 
     // When we've proved that we're writing an immediate,
     // we can skip the write barrier.
-    if function.type_of(val).is_immediate() {
-        let offset = -(SIZEOF_VALUE_I32 * i32::try_from(local_ep_offset).ok()?);
-        asm.mov(Opnd::mem(64, ep, offset), jit.get_opnd(val));
+    if val_type.is_immediate() {
+        let offset = -(SIZEOF_VALUE_I32 * i32::try_from(local_ep_offset).expect(&format!("Could not convert local_ep_offset {local_ep_offset} to i32")));
+        asm.mov(Opnd::mem(64, ep, offset), val);
     } else {
         // We're potentially writing a reference to an IMEMO/env object,
         // so take care of the write barrier with a function.
-        let local_index = c_int::try_from(local_ep_offset).ok().and_then(|idx| idx.checked_mul(-1))?;
-        asm_ccall!(asm, rb_vm_env_write, ep, local_index.into(), jit.get_opnd(val));
+        let local_index = c_int::try_from(local_ep_offset).ok().and_then(|idx| idx.checked_mul(-1)).expect(&format!("Could not turn {local_ep_offset} into a negative c_int"));
+        asm_ccall!(asm, rb_vm_env_write, ep, local_index.into(), val);
     }
-    Some(())
 }
 
-fn gen_get_constant_path(jit: &JITState, asm: &mut Assembler, ic: *const iseq_inline_constant_cache, state: &FrameState) -> Option<Opnd> {
+fn gen_get_constant_path(jit: &JITState, asm: &mut Assembler, ic: *const iseq_inline_constant_cache, state: &FrameState) -> Opnd {
     unsafe extern "C" {
         fn rb_vm_opt_getconstant_path(ec: EcPtr, cfp: CfpPtr, ic: *const iseq_inline_constant_cache) -> VALUE;
     }
@@ -528,7 +536,7 @@ fn gen_get_constant_path(jit: &JITState, asm: &mut Assembler, ic: *const iseq_in
     // Anything could be called on const_missing
     gen_prepare_non_leaf_call(jit, asm, state);
 
-    Some(asm_ccall!(asm, rb_vm_opt_getconstant_path, EC, CFP, Opnd::const_ptr(ic)))
+    asm_ccall!(asm, rb_vm_opt_getconstant_path, EC, CFP, Opnd::const_ptr(ic))
 }
 
 fn gen_invokebuiltin(jit: &JITState, asm: &mut Assembler, state: &FrameState, bf: &rb_builtin_function, args: Vec<Opnd>) -> Option<lir::Opnd> {
@@ -550,7 +558,7 @@ fn gen_invokebuiltin(jit: &JITState, asm: &mut Assembler, state: &FrameState, bf
 }
 
 /// Record a patch point that should be invalidated on a given invariant
-fn gen_patch_point(jit: &mut JITState, asm: &mut Assembler, invariant: &Invariant, state: &FrameState) -> Option<()> {
+fn gen_patch_point(jit: &mut JITState, asm: &mut Assembler, invariant: &Invariant, state: &FrameState) {
     let payload_ptr = get_or_create_iseq_payload_ptr(jit.iseq);
     let label = asm.new_label("patch_point").unwrap_label();
     let invariant = invariant.clone();
@@ -579,13 +587,12 @@ fn gen_patch_point(jit: &mut JITState, asm: &mut Assembler, invariant: &Invarian
             }
         }
     });
-    Some(())
 }
 
 /// Lowering for [`Insn::CCall`]. This is a low-level raw call that doesn't know
 /// anything about the callee, so handling for e.g. GC safety is dealt with elsewhere.
-fn gen_ccall(asm: &mut Assembler, cfun: *const u8, args: Vec<Opnd>) -> Option<lir::Opnd> {
-    Some(asm.ccall(cfun, args))
+fn gen_ccall(asm: &mut Assembler, cfun: *const u8, args: Vec<Opnd>) -> lir::Opnd {
+    asm.ccall(cfun, args)
 }
 
 /// Emit an uncached instance variable lookup
@@ -594,9 +601,8 @@ fn gen_getivar(asm: &mut Assembler, recv: Opnd, id: ID) -> Opnd {
 }
 
 /// Emit an uncached instance variable store
-fn gen_setivar(asm: &mut Assembler, recv: Opnd, id: ID, val: Opnd) -> Option<()> {
+fn gen_setivar(asm: &mut Assembler, recv: Opnd, id: ID, val: Opnd) {
     asm_ccall!(asm, rb_ivar_set, recv, id.0.into(), val);
-    Some(())
 }
 
 /// Look up global variables
@@ -605,19 +611,18 @@ fn gen_getglobal(asm: &mut Assembler, id: ID) -> Opnd {
 }
 
 /// Intern a string
-fn gen_intern(asm: &mut Assembler, val: Opnd, state: &FrameState) -> Option<Opnd> {
+fn gen_intern(asm: &mut Assembler, val: Opnd, state: &FrameState) -> Opnd {
     gen_prepare_call_with_gc(asm, state);
 
-    Some(asm_ccall!(asm, rb_str_intern, val))
+    asm_ccall!(asm, rb_str_intern, val)
 }
 
 /// Set global variables
-fn gen_setglobal(jit: &mut JITState, asm: &mut Assembler, id: ID, val: Opnd, state: &FrameState) -> Option<()> {
+fn gen_setglobal(jit: &mut JITState, asm: &mut Assembler, id: ID, val: Opnd, state: &FrameState) {
     // When trace_var is used, setting a global variable can cause exceptions
     gen_prepare_non_leaf_call(jit, asm, state);
 
     asm_ccall!(asm, rb_gvar_set, id.0.into(), val);
-    Some(())
 }
 
 /// Side-exit into the interpreter
@@ -839,7 +844,7 @@ fn gen_send_without_block(
     state: &FrameState,
     self_val: Opnd,
     args: Vec<Opnd>,
-) -> Option<lir::Opnd> {
+) -> lir::Opnd {
     gen_spill_locals(jit, asm, state);
     // Spill the receiver and the arguments onto the stack.
     // They need to be on the interpreter stack to let the interpreter access them.
@@ -869,7 +874,7 @@ fn gen_send_without_block(
     // TODO(max): Add a PatchPoint here that can side-exit the function if the callee messed with
     // the frame's locals
 
-    Some(ret)
+    ret
 }
 
 /// Compile a direct jump to an ISEQ call without block
@@ -882,7 +887,7 @@ fn gen_send_without_block_direct(
     recv: Opnd,
     args: Vec<Opnd>,
     state: &FrameState,
-) -> Option<lir::Opnd> {
+) -> lir::Opnd {
     // Save cfp->pc and cfp->sp for the caller frame
     gen_save_pc(asm, state);
     gen_save_sp(asm, state.stack().len() - args.len() - 1); // -1 for receiver
@@ -934,7 +939,7 @@ fn gen_send_without_block_direct(
     let new_sp = asm.sub(SP, sp_offset.into());
     asm.mov(SP, new_sp);
 
-    Some(ret)
+    ret
 }
 
 /// Compile a string resurrection
@@ -981,8 +986,8 @@ fn gen_new_hash(
     asm: &mut Assembler,
     elements: &Vec<(InsnId, InsnId)>,
     state: &FrameState,
-) -> Option<lir::Opnd> {
-    gen_prepare_non_leaf_call(jit, asm, state)?;
+) -> lir::Opnd {
+    gen_prepare_non_leaf_call(jit, asm, state);
 
     let cap: c_long = elements.len().try_into().expect("Unable to fit length of elements into c_long");
     let new_hash = asm_ccall!(asm, rb_hash_new_with_size, lir::Opnd::Imm(cap));
@@ -1027,7 +1032,7 @@ fn gen_new_hash(
         asm.add_into(NATIVE_STACK_PTR, allocation_size.into());
     }
 
-    Some(new_hash)
+    new_hash
 }
 
 /// Compile a new range instruction
@@ -1063,27 +1068,25 @@ fn gen_return(asm: &mut Assembler, val: lir::Opnd) {
 }
 
 /// Compile Fixnum + Fixnum
-fn gen_fixnum_add(jit: &mut JITState, asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd, state: &FrameState) -> Option<lir::Opnd> {
+fn gen_fixnum_add(jit: &mut JITState, asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd, state: &FrameState) -> lir::Opnd {
     // Add left + right and test for overflow
     let left_untag = asm.sub(left, Opnd::Imm(1));
     let out_val = asm.add(left_untag, right);
     asm.jo(side_exit(jit, state, FixnumAddOverflow));
 
-    Some(out_val)
+    out_val
 }
 
 /// Compile Fixnum - Fixnum
-fn gen_fixnum_sub(jit: &mut JITState, asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd, state: &FrameState) -> Option<lir::Opnd> {
+fn gen_fixnum_sub(jit: &mut JITState, asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd, state: &FrameState) -> lir::Opnd {
     // Subtract left - right and test for overflow
     let val_untag = asm.sub(left, right);
     asm.jo(side_exit(jit, state, FixnumSubOverflow));
-    let out_val = asm.add(val_untag, Opnd::Imm(1));
-
-    Some(out_val)
+    asm.add(val_untag, Opnd::Imm(1))
 }
 
 /// Compile Fixnum * Fixnum
-fn gen_fixnum_mult(jit: &mut JITState, asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd, state: &FrameState) -> Option<lir::Opnd> {
+fn gen_fixnum_mult(jit: &mut JITState, asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd, state: &FrameState) -> lir::Opnd {
     // Do some bitwise gymnastics to handle tag bits
     // x * y is translated to (x >> 1) * (y - 1) + 1
     let left_untag = asm.rshift(left, Opnd::UImm(1));
@@ -1092,79 +1095,77 @@ fn gen_fixnum_mult(jit: &mut JITState, asm: &mut Assembler, left: lir::Opnd, rig
 
     // Test for overflow
     asm.jo_mul(side_exit(jit, state, FixnumMultOverflow));
-    let out_val = asm.add(out_val, Opnd::UImm(1));
-
-    Some(out_val)
+    asm.add(out_val, Opnd::UImm(1))
 }
 
 /// Compile Fixnum == Fixnum
-fn gen_fixnum_eq(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd) -> Option<lir::Opnd> {
+fn gen_fixnum_eq(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd) -> lir::Opnd {
     asm.cmp(left, right);
-    Some(asm.csel_e(Qtrue.into(), Qfalse.into()))
+    asm.csel_e(Qtrue.into(), Qfalse.into())
 }
 
 /// Compile Fixnum != Fixnum
-fn gen_fixnum_neq(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd) -> Option<lir::Opnd> {
+fn gen_fixnum_neq(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd) -> lir::Opnd {
     asm.cmp(left, right);
-    Some(asm.csel_ne(Qtrue.into(), Qfalse.into()))
+    asm.csel_ne(Qtrue.into(), Qfalse.into())
 }
 
 /// Compile Fixnum < Fixnum
-fn gen_fixnum_lt(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd) -> Option<lir::Opnd> {
+fn gen_fixnum_lt(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd) -> lir::Opnd {
     asm.cmp(left, right);
-    Some(asm.csel_l(Qtrue.into(), Qfalse.into()))
+    asm.csel_l(Qtrue.into(), Qfalse.into())
 }
 
 /// Compile Fixnum <= Fixnum
-fn gen_fixnum_le(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd) -> Option<lir::Opnd> {
+fn gen_fixnum_le(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd) -> lir::Opnd {
     asm.cmp(left, right);
-    Some(asm.csel_le(Qtrue.into(), Qfalse.into()))
+    asm.csel_le(Qtrue.into(), Qfalse.into())
 }
 
 /// Compile Fixnum > Fixnum
-fn gen_fixnum_gt(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd) -> Option<lir::Opnd> {
+fn gen_fixnum_gt(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd) -> lir::Opnd {
     asm.cmp(left, right);
-    Some(asm.csel_g(Qtrue.into(), Qfalse.into()))
+    asm.csel_g(Qtrue.into(), Qfalse.into())
 }
 
 /// Compile Fixnum >= Fixnum
-fn gen_fixnum_ge(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd) -> Option<lir::Opnd> {
+fn gen_fixnum_ge(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd) -> lir::Opnd {
     asm.cmp(left, right);
-    Some(asm.csel_ge(Qtrue.into(), Qfalse.into()))
+    asm.csel_ge(Qtrue.into(), Qfalse.into())
 }
 
 /// Compile Fixnum & Fixnum
-fn gen_fixnum_and(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd) -> Option<lir::Opnd> {
-    Some(asm.and(left, right))
+fn gen_fixnum_and(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd) -> lir::Opnd {
+    asm.and(left, right)
 }
 
 /// Compile Fixnum | Fixnum
-fn gen_fixnum_or(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd) -> Option<lir::Opnd> {
-    Some(asm.or(left, right))
+fn gen_fixnum_or(asm: &mut Assembler, left: lir::Opnd, right: lir::Opnd) -> lir::Opnd {
+    asm.or(left, right)
 }
 
 // Compile val == nil
-fn gen_isnil(asm: &mut Assembler, val: lir::Opnd) -> Option<lir::Opnd> {
+fn gen_isnil(asm: &mut Assembler, val: lir::Opnd) -> lir::Opnd {
     asm.cmp(val, Qnil.into());
     // TODO: Implement and use setcc
-    Some(asm.csel_e(Opnd::Imm(1), Opnd::Imm(0)))
+    asm.csel_e(Opnd::Imm(1), Opnd::Imm(0))
 }
 
-fn gen_anytostring(asm: &mut Assembler, val: lir::Opnd, str: lir::Opnd, state: &FrameState) -> Option<lir::Opnd> {
+fn gen_anytostring(asm: &mut Assembler, val: lir::Opnd, str: lir::Opnd, state: &FrameState) -> lir::Opnd {
     gen_prepare_call_with_gc(asm, state);
 
-    Some(asm_ccall!(asm, rb_obj_as_string_result, str, val))
+    asm_ccall!(asm, rb_obj_as_string_result, str, val)
 }
 
 /// Evaluate if a value is truthy
 /// Produces a CBool type (0 or 1)
 /// In Ruby, only nil and false are falsy
 /// Everything else evaluates to true
-fn gen_test(asm: &mut Assembler, val: lir::Opnd) -> Option<lir::Opnd> {
+fn gen_test(asm: &mut Assembler, val: lir::Opnd) -> lir::Opnd {
     // Test if any bit (outside of the Qnil bit) is on
     // See RB_TEST(), include/ruby/internal/special_consts.h
     asm.test(val, Opnd::Imm(!Qnil.as_i64()));
-    Some(asm.csel_e(0.into(), 1.into()))
+    asm.csel_e(0.into(), 1.into())
 }
 
 /// Compile a type check with a side exit
@@ -1226,10 +1227,10 @@ fn gen_guard_type(jit: &mut JITState, asm: &mut Assembler, val: lir::Opnd, guard
 }
 
 /// Compile an identity check with a side exit
-fn gen_guard_bit_equals(jit: &mut JITState, asm: &mut Assembler, val: lir::Opnd, expected: VALUE, state: &FrameState) -> Option<lir::Opnd> {
+fn gen_guard_bit_equals(jit: &mut JITState, asm: &mut Assembler, val: lir::Opnd, expected: VALUE, state: &FrameState) -> lir::Opnd {
     asm.cmp(val, Opnd::Value(expected));
     asm.jnz(side_exit(jit, state, GuardBitEquals(expected)));
-    Some(val)
+    val
 }
 
 /// Generate code that increments a counter in ZJIT stats
@@ -1590,21 +1591,14 @@ pub fn gen_exit_trampoline(cb: &mut CodeBlock) -> Option<CodePtr> {
     })
 }
 
-fn gen_string_concat(jit: &mut JITState, asm: &mut Assembler, strings: Vec<Opnd>, state: &FrameState) -> Option<Opnd> {
-    let n = strings.len();
-
-    // concatstrings shouldn't have 0 strings
-    // If it happens we abort the compilation for now
-    if n == 0 {
-        return None;
-    }
-
+fn gen_string_concat(jit: &mut JITState, asm: &mut Assembler, strings: Vec<Opnd>, state: &FrameState) -> Opnd {
     gen_prepare_non_leaf_call(jit, asm, state);
 
     // Calculate the compile-time NATIVE_STACK_PTR offset from NATIVE_BASE_PTR
     // At this point, frame_setup(&[], jit.c_stack_slots) has been called,
     // which allocated aligned_stack_bytes(jit.c_stack_slots) on the stack
     let frame_size = aligned_stack_bytes(jit.c_stack_slots);
+    let n = strings.len();
     let allocation_size = aligned_stack_bytes(n);
 
     asm_comment!(asm, "allocate {} bytes on C stack for {} strings", allocation_size, n);
@@ -1628,7 +1622,7 @@ fn gen_string_concat(jit: &mut JITState, asm: &mut Assembler, strings: Vec<Opnd>
     asm_comment!(asm, "restore C stack pointer");
     asm.add_into(NATIVE_STACK_PTR, allocation_size.into());
 
-    Some(result)
+    result
 }
 
 /// Given the number of spill slots needed for a function, return the number of bytes

From c663fe1eed36fec59dc3359576a63d39bb484efe Mon Sep 17 00:00:00 2001
From: Max Bernstein <ruby@bernsteinbear.com>
Date: Fri, 15 Aug 2025 10:51:18 -0400
Subject: [PATCH 12/17] ZJIT: Make Defined retain its Snapshot

---
 zjit/src/hir.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/zjit/src/hir.rs b/zjit/src/hir.rs
index c50c1ce985a69c..ecb5a37e1fa033 100644
--- a/zjit/src/hir.rs
+++ b/zjit/src/hir.rs
@@ -1940,12 +1940,12 @@ impl Function {
             }
             | &Insn::Return { val }
             | &Insn::Throw { val, .. }
-            | &Insn::Defined { v: val, .. }
             | &Insn::Test { val }
             | &Insn::SetLocal { val, .. }
             | &Insn::IsNil { val } =>
                 worklist.push_back(val),
             &Insn::SetGlobal { val, state, .. }
+            | &Insn::Defined { v: val, state, .. }
             | &Insn::StringIntern { val, state }
             | &Insn::StringCopy { val, state, .. }
             | &Insn::GuardType { val, state, .. }

From 33224236e1a2f813bfb7ca56322a44853310f1d6 Mon Sep 17 00:00:00 2001
From: Max Bernstein <ruby@bernsteinbear.com>
Date: Fri, 15 Aug 2025 10:54:13 -0400
Subject: [PATCH 13/17] ZJIT: Refine type of Defined

---
 zjit/src/hir.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/zjit/src/hir.rs b/zjit/src/hir.rs
index ecb5a37e1fa033..a2304e4caedaac 100644
--- a/zjit/src/hir.rs
+++ b/zjit/src/hir.rs
@@ -1330,7 +1330,7 @@ impl Function {
             Insn::SendWithoutBlockDirect { .. } => types::BasicObject,
             Insn::Send { .. } => types::BasicObject,
             Insn::InvokeBuiltin { return_type, .. } => return_type.unwrap_or(types::BasicObject),
-            Insn::Defined { .. } => types::BasicObject,
+            Insn::Defined { pushval, .. } => Type::from_value(*pushval).union(types::NilClass),
             Insn::DefinedIvar { .. } => types::BasicObject,
             Insn::GetConstantPath { .. } => types::BasicObject,
             Insn::ArrayMax { .. } => types::BasicObject,
@@ -4204,10 +4204,10 @@ mod tests {
             fn test@<compiled>:2:
             bb0(v0:BasicObject):
               v2:NilClass = Const Value(nil)
-              v4:BasicObject = Defined constant, v2
-              v6:BasicObject = Defined func, v0
+              v4:StringExact|NilClass = Defined constant, v2
+              v6:StringExact|NilClass = Defined func, v0
               v7:NilClass = Const Value(nil)
-              v9:BasicObject = Defined global-variable, v7
+              v9:StringExact|NilClass = Defined global-variable, v7
               v11:ArrayExact = NewArray v4, v6, v9
               Return v11
         "#]]);

From 68c7f10b86b9ff10a3193c62c67e92fdde5cf107 Mon Sep 17 00:00:00 2001
From: Max Bernstein <ruby@bernsteinbear.com>
Date: Fri, 15 Aug 2025 15:06:08 -0400
Subject: [PATCH 14/17] ZJIT: Temporarily disable buggy defined? codegen

---
 test/ruby/test_zjit.rb | 8 ++++++++
 zjit/src/hir.rs        | 6 ++++++
 2 files changed, 14 insertions(+)

diff --git a/test/ruby/test_zjit.rb b/test/ruby/test_zjit.rb
index 485fc403a843d0..96ac99b6db6195 100644
--- a/test/ruby/test_zjit.rb
+++ b/test/ruby/test_zjit.rb
@@ -1245,6 +1245,14 @@ def test = return defined?(Foo), defined?(bar), defined?($ruby)
     }, insns: [:defined]
   end
 
+  def test_defined_with_method_call
+    assert_compiles '["method", nil]', %q{
+      def test = return defined?("x".reverse(1)), defined?("x".reverse(1).reverse)
+
+      test
+    }, insns: [:defined]
+  end
+
   def test_defined_yield
     assert_compiles "nil", "defined?(yield)"
     assert_compiles '[nil, nil, "yield"]', %q{
diff --git a/zjit/src/hir.rs b/zjit/src/hir.rs
index a2304e4caedaac..afe358ec1d6a86 100644
--- a/zjit/src/hir.rs
+++ b/zjit/src/hir.rs
@@ -439,6 +439,7 @@ pub enum SideExitReason {
     CalleeSideExit,
     ObjToStringFallback,
     UnknownSpecialVariable(u64),
+    UnhandledDefinedType(usize),
 }
 
 impl std::fmt::Display for SideExitReason {
@@ -2957,6 +2958,11 @@ pub fn iseq_to_hir(iseq: *const rb_iseq_t) -> Result<Function, ParseError> {
                     let pushval = get_arg(pc, 2);
                     let v = state.stack_pop()?;
                     let exit_id = fun.push_insn(block, Insn::Snapshot { state: exit_state });
+                    if op_type == DEFINED_METHOD.try_into().unwrap() {
+                        // TODO(Shopify/ruby#703): Fix codegen for defined?(method call expr)
+                        fun.push_insn(block, Insn::SideExit { state: exit_id, reason: SideExitReason::UnhandledDefinedType(op_type)});
+                        break; // End the block
+                    }
                     state.stack_push(fun.push_insn(block, Insn::Defined { op_type, obj, pushval, v, state: exit_id }));
                 }
                 YARVINSN_definedivar => {

From f38ba24bda8d3a80c636fba2ad99a2d5a3254bc6 Mon Sep 17 00:00:00 2001
From: Takashi Kokubun <takashikkbn@gmail.com>
Date: Mon, 18 Aug 2025 09:21:26 -0700
Subject: [PATCH 15/17] ZJIT: Handle ISEQ moves (#14250)

* ZJIT: Handle ISEQ moves in IseqCall

* ZJIT: Handle ISEQ moves in Invariants

* Let gen_iseq_call take a reference

* Avoid unneeded iter()
---
 zjit/src/codegen.rs    | 61 ++++++++++++++++++++++--------------------
 zjit/src/gc.rs         | 33 +++++++++++++++++++++--
 zjit/src/invariants.rs | 27 ++++++++++++++++++-
 3 files changed, 89 insertions(+), 32 deletions(-)

diff --git a/zjit/src/codegen.rs b/zjit/src/codegen.rs
index 467a45846ef707..d2810cddb7bb72 100644
--- a/zjit/src/codegen.rs
+++ b/zjit/src/codegen.rs
@@ -1,4 +1,4 @@
-use std::cell::Cell;
+use std::cell::{Cell, RefCell};
 use std::rc::Rc;
 use std::ffi::{c_int, c_long, c_void};
 
@@ -27,7 +27,7 @@ struct JITState {
     labels: Vec<Option<Target>>,
 
     /// ISEQ calls that need to be compiled later
-    iseq_calls: Vec<Rc<IseqCall>>,
+    iseq_calls: Vec<Rc<RefCell<IseqCall>>>,
 
     /// The number of bytes allocated for basic block arguments spilled onto the C stack
     c_stack_slots: usize,
@@ -126,13 +126,14 @@ fn gen_iseq_entry_point_body(cb: &mut CodeBlock, iseq: IseqPtr) -> Option<CodePt
     };
 
     // Stub callee ISEQs for JIT-to-JIT calls
-    for iseq_call in jit.iseq_calls.into_iter() {
+    for iseq_call in jit.iseq_calls.iter() {
         gen_iseq_call(cb, iseq, iseq_call)?;
     }
 
     // Remember the block address to reuse it later
     let payload = get_or_create_iseq_payload(iseq);
     payload.status = IseqStatus::Compiled(start_ptr);
+    payload.iseq_calls.extend(jit.iseq_calls);
     append_gc_offsets(iseq, &gc_offsets);
 
     // Return a JIT code address
@@ -140,19 +141,19 @@ fn gen_iseq_entry_point_body(cb: &mut CodeBlock, iseq: IseqPtr) -> Option<CodePt
 }
 
 /// Stub a branch for a JIT-to-JIT call
-fn gen_iseq_call(cb: &mut CodeBlock, caller_iseq: IseqPtr, iseq_call: Rc<IseqCall>) -> Option<()> {
+fn gen_iseq_call(cb: &mut CodeBlock, caller_iseq: IseqPtr, iseq_call: &Rc<RefCell<IseqCall>>) -> Option<()> {
     // Compile a function stub
     let Some(stub_ptr) = gen_function_stub(cb, iseq_call.clone()) else {
         // Failed to compile the stub. Bail out of compiling the caller ISEQ.
         debug!("Failed to compile iseq: could not compile stub: {} -> {}",
-               iseq_get_location(caller_iseq, 0), iseq_get_location(iseq_call.iseq, 0));
+               iseq_get_location(caller_iseq, 0), iseq_get_location(iseq_call.borrow().iseq, 0));
         return None;
     };
 
     // Update the JIT-to-JIT call to call the stub
     let stub_addr = stub_ptr.raw_ptr(cb);
-    iseq_call.regenerate(cb, |asm| {
-        asm_comment!(asm, "call function stub: {}", iseq_get_location(iseq_call.iseq, 0));
+    iseq_call.borrow_mut().regenerate(cb, |asm| {
+        asm_comment!(asm, "call function stub: {}", iseq_get_location(iseq_call.borrow().iseq, 0));
         asm.ccall(stub_addr, vec![]);
     });
     Some(())
@@ -205,7 +206,7 @@ fn gen_entry(cb: &mut CodeBlock, iseq: IseqPtr, function: &Function, function_pt
 }
 
 /// Compile an ISEQ into machine code
-fn gen_iseq(cb: &mut CodeBlock, iseq: IseqPtr) -> Option<(CodePtr, Vec<Rc<IseqCall>>)> {
+fn gen_iseq(cb: &mut CodeBlock, iseq: IseqPtr) -> Option<(CodePtr, Vec<Rc<RefCell<IseqCall>>>)> {
     // Return an existing pointer if it's already compiled
     let payload = get_or_create_iseq_payload(iseq);
     match payload.status {
@@ -227,6 +228,7 @@ fn gen_iseq(cb: &mut CodeBlock, iseq: IseqPtr) -> Option<(CodePtr, Vec<Rc<IseqCa
     let result = gen_function(cb, iseq, &function);
     if let Some((start_ptr, gc_offsets, jit)) = result {
         payload.status = IseqStatus::Compiled(start_ptr);
+        payload.iseq_calls.extend(jit.iseq_calls.clone());
         append_gc_offsets(iseq, &gc_offsets);
         Some((start_ptr, jit.iseq_calls))
     } else {
@@ -1470,9 +1472,9 @@ c_callable! {
         with_vm_lock(src_loc!(), || {
             // gen_push_frame() doesn't set PC and SP, so we need to set them before exit.
             // function_stub_hit_body() may allocate and call gc_validate_pc(), so we always set PC.
-            let iseq_call = unsafe { Rc::from_raw(iseq_call_ptr as *const IseqCall) };
+            let iseq_call = unsafe { Rc::from_raw(iseq_call_ptr as *const RefCell<IseqCall>) };
             let cfp = unsafe { get_ec_cfp(ec) };
-            let pc = unsafe { rb_iseq_pc_at_idx(iseq_call.iseq, 0) }; // TODO: handle opt_pc once supported
+            let pc = unsafe { rb_iseq_pc_at_idx(iseq_call.borrow().iseq, 0) }; // TODO: handle opt_pc once supported
             unsafe { rb_set_cfp_pc(cfp, pc) };
             unsafe { rb_set_cfp_sp(cfp, sp) };
 
@@ -1480,10 +1482,10 @@ c_callable! {
             // TODO: Alan thinks the payload status part of this check can happen without the VM lock, since the whole
             // code path can be made read-only. But you still need the check as is while holding the VM lock in any case.
             let cb = ZJITState::get_code_block();
-            let payload = get_or_create_iseq_payload(iseq_call.iseq);
+            let payload = get_or_create_iseq_payload(iseq_call.borrow().iseq);
             if cb.has_dropped_bytes() || payload.status == IseqStatus::CantCompile {
                 // We'll use this Rc again, so increment the ref count decremented by from_raw.
-                unsafe { Rc::increment_strong_count(iseq_call_ptr as *const IseqCall); }
+                unsafe { Rc::increment_strong_count(iseq_call_ptr as *const RefCell<IseqCall>); }
 
                 // Exit to the interpreter
                 return ZJITState::get_exit_trampoline().raw_ptr(cb);
@@ -1504,22 +1506,22 @@ c_callable! {
 }
 
 /// Compile an ISEQ for a function stub
-fn function_stub_hit_body(cb: &mut CodeBlock, iseq_call: &Rc<IseqCall>) -> Option<CodePtr> {
+fn function_stub_hit_body(cb: &mut CodeBlock, iseq_call: &Rc<RefCell<IseqCall>>) -> Option<CodePtr> {
     // Compile the stubbed ISEQ
-    let Some((code_ptr, iseq_calls)) = gen_iseq(cb, iseq_call.iseq) else {
-        debug!("Failed to compile iseq: gen_iseq failed: {}", iseq_get_location(iseq_call.iseq, 0));
+    let Some((code_ptr, iseq_calls)) = gen_iseq(cb, iseq_call.borrow().iseq) else {
+        debug!("Failed to compile iseq: gen_iseq failed: {}", iseq_get_location(iseq_call.borrow().iseq, 0));
         return None;
     };
 
     // Stub callee ISEQs for JIT-to-JIT calls
-    for callee_iseq_call in iseq_calls.into_iter() {
-        gen_iseq_call(cb, iseq_call.iseq, callee_iseq_call)?;
+    for callee_iseq_call in iseq_calls.iter() {
+        gen_iseq_call(cb, iseq_call.borrow().iseq, callee_iseq_call)?;
     }
 
     // Update the stub to call the code pointer
     let code_addr = code_ptr.raw_ptr(cb);
-    iseq_call.regenerate(cb, |asm| {
-        asm_comment!(asm, "call compiled function: {}", iseq_get_location(iseq_call.iseq, 0));
+    iseq_call.borrow_mut().regenerate(cb, |asm| {
+        asm_comment!(asm, "call compiled function: {}", iseq_get_location(iseq_call.borrow().iseq, 0));
         asm.ccall(code_addr, vec![]);
     });
 
@@ -1527,9 +1529,9 @@ fn function_stub_hit_body(cb: &mut CodeBlock, iseq_call: &Rc<IseqCall>) -> Optio
 }
 
 /// Compile a stub for an ISEQ called by SendWithoutBlockDirect
-fn gen_function_stub(cb: &mut CodeBlock, iseq_call: Rc<IseqCall>) -> Option<CodePtr> {
+fn gen_function_stub(cb: &mut CodeBlock, iseq_call: Rc<RefCell<IseqCall>>) -> Option<CodePtr> {
     let mut asm = Assembler::new();
-    asm_comment!(asm, "Stub: {}", iseq_get_location(iseq_call.iseq, 0));
+    asm_comment!(asm, "Stub: {}", iseq_get_location(iseq_call.borrow().iseq, 0));
 
     // Call function_stub_hit using the shared trampoline. See `gen_function_stub_hit_trampoline`.
     // Use load_into instead of mov, which is split on arm64, to avoid clobbering ALLOC_REGS.
@@ -1636,7 +1638,7 @@ fn aligned_stack_bytes(num_slots: usize) -> usize {
 
 impl Assembler {
     /// Make a C call while marking the start and end positions for IseqCall
-    fn ccall_with_iseq_call(&mut self, fptr: *const u8, opnds: Vec<Opnd>, iseq_call: &Rc<IseqCall>) -> Opnd {
+    fn ccall_with_iseq_call(&mut self, fptr: *const u8, opnds: Vec<Opnd>, iseq_call: &Rc<RefCell<IseqCall>>) -> Opnd {
         // We need to create our own branch rc objects so that we can move the closure below
         let start_iseq_call = iseq_call.clone();
         let end_iseq_call = iseq_call.clone();
@@ -1645,10 +1647,10 @@ impl Assembler {
             fptr,
             opnds,
             move |code_ptr, _| {
-                start_iseq_call.start_addr.set(Some(code_ptr));
+                start_iseq_call.borrow_mut().start_addr.set(Some(code_ptr));
             },
             move |code_ptr, _| {
-                end_iseq_call.end_addr.set(Some(code_ptr));
+                end_iseq_call.borrow_mut().end_addr.set(Some(code_ptr));
             },
         )
     }
@@ -1656,9 +1658,9 @@ impl Assembler {
 
 /// Store info about a JIT-to-JIT call
 #[derive(Debug)]
-struct IseqCall {
+pub struct IseqCall {
     /// Callee ISEQ that start_addr jumps to
-    iseq: IseqPtr,
+    pub iseq: IseqPtr,
 
     /// Position where the call instruction starts
     start_addr: Cell<Option<CodePtr>>,
@@ -1669,12 +1671,13 @@ struct IseqCall {
 
 impl IseqCall {
     /// Allocate a new IseqCall
-    fn new(iseq: IseqPtr) -> Rc<Self> {
-        Rc::new(IseqCall {
+    fn new(iseq: IseqPtr) -> Rc<RefCell<Self>> {
+        let iseq_call = IseqCall {
             iseq,
             start_addr: Cell::new(None),
             end_addr: Cell::new(None),
-        })
+        };
+        Rc::new(RefCell::new(iseq_call))
     }
 
     /// Regenerate a IseqCall with a given callback
diff --git a/zjit/src/gc.rs b/zjit/src/gc.rs
index 52a036d49e52bb..3462b80232ba43 100644
--- a/zjit/src/gc.rs
+++ b/zjit/src/gc.rs
@@ -1,6 +1,9 @@
 // This module is responsible for marking/moving objects on GC.
 
+use std::cell::RefCell;
+use std::rc::Rc;
 use std::{ffi::c_void, ops::Range};
+use crate::codegen::IseqCall;
 use crate::{cruby::*, profile::IseqProfile, state::ZJITState, stats::with_time_stat, virtualmem::CodePtr};
 use crate::stats::Counter::gc_time_ns;
 
@@ -15,6 +18,9 @@ pub struct IseqPayload {
 
     /// GC offsets of the JIT code. These are the addresses of objects that need to be marked.
     pub gc_offsets: Vec<CodePtr>,
+
+    /// JIT-to-JIT calls in the ISEQ. The IseqPayload's ISEQ is the caller of it.
+    pub iseq_calls: Vec<Rc<RefCell<IseqCall>>>,
 }
 
 impl IseqPayload {
@@ -23,6 +29,7 @@ impl IseqPayload {
             status: IseqStatus::NotCompiled,
             profile: IseqProfile::new(iseq_size),
             gc_offsets: vec![],
+            iseq_calls: vec![],
         }
     }
 }
@@ -112,6 +119,16 @@ pub extern "C" fn rb_zjit_iseq_update_references(payload: *mut c_void) {
     with_time_stat(gc_time_ns, || iseq_update_references(payload));
 }
 
+/// GC callback for updating object references after all object moves
+#[unsafe(no_mangle)]
+pub extern "C" fn rb_zjit_root_update_references() {
+    if !ZJITState::has_instance() {
+        return;
+    }
+    let invariants = ZJITState::get_invariants();
+    invariants.update_references();
+}
+
 fn iseq_mark(payload: &IseqPayload) {
     // Mark objects retained by profiling instructions
     payload.profile.each_object(|object| {
@@ -135,10 +152,22 @@ fn iseq_mark(payload: &IseqPayload) {
 /// This is a mirror of [iseq_mark].
 fn iseq_update_references(payload: &mut IseqPayload) {
     // Move objects retained by profiling instructions
-    payload.profile.each_object_mut(|object| {
-        *object = unsafe { rb_gc_location(*object) };
+    payload.profile.each_object_mut(|old_object| {
+        let new_object = unsafe { rb_gc_location(*old_object) };
+        if *old_object != new_object {
+            *old_object = new_object;
+        }
     });
 
+    // Move ISEQ references in IseqCall
+    for iseq_call in payload.iseq_calls.iter_mut() {
+        let old_iseq = iseq_call.borrow().iseq;
+        let new_iseq = unsafe { rb_gc_location(VALUE(old_iseq as usize)) }.0 as IseqPtr;
+        if old_iseq != new_iseq {
+            iseq_call.borrow_mut().iseq = new_iseq;
+        }
+    }
+
     // Move objects baked in JIT code
     let cb = ZJITState::get_code_block();
     for &offset in payload.gc_offsets.iter() {
diff --git a/zjit/src/invariants.rs b/zjit/src/invariants.rs
index 3f291415be6306..14fea76d1b499c 100644
--- a/zjit/src/invariants.rs
+++ b/zjit/src/invariants.rs
@@ -1,6 +1,6 @@
 use std::{collections::{HashMap, HashSet}, mem};
 
-use crate::{backend::lir::{asm_comment, Assembler}, cruby::{rb_callable_method_entry_t, ruby_basic_operators, src_loc, with_vm_lock, IseqPtr, RedefinitionFlag, ID}, gc::IseqPayload, hir::Invariant, options::debug, state::{zjit_enabled_p, ZJITState}, virtualmem::CodePtr};
+use crate::{backend::lir::{asm_comment, Assembler}, cruby::{rb_callable_method_entry_t, rb_gc_location, ruby_basic_operators, src_loc, with_vm_lock, IseqPtr, RedefinitionFlag, ID, VALUE}, gc::IseqPayload, hir::Invariant, options::debug, state::{zjit_enabled_p, ZJITState}, virtualmem::CodePtr};
 use crate::stats::with_time_stat;
 use crate::stats::Counter::invalidation_time_ns;
 use crate::gc::remove_gc_offsets;
@@ -56,6 +56,31 @@ pub struct Invariants {
     single_ractor_patch_points: HashSet<PatchPoint>,
 }
 
+impl Invariants {
+    /// Update object references in Invariants
+    pub fn update_references(&mut self) {
+        Self::update_iseq_references(&mut self.ep_escape_iseqs);
+        Self::update_iseq_references(&mut self.no_ep_escape_iseqs);
+    }
+
+    /// Update ISEQ references in a given HashSet<IseqPtr>
+    fn update_iseq_references(iseqs: &mut HashSet<IseqPtr>) {
+        let mut moved: Vec<IseqPtr> = Vec::with_capacity(iseqs.len());
+
+        iseqs.retain(|&old_iseq| {
+            let new_iseq = unsafe { rb_gc_location(VALUE(old_iseq as usize)) }.0 as IseqPtr;
+            if old_iseq != new_iseq {
+                moved.push(new_iseq);
+            }
+            old_iseq == new_iseq
+        });
+
+        for new_iseq in moved {
+            iseqs.insert(new_iseq);
+        }
+    }
+}
+
 /// Called when a basic operator is redefined. Note that all the blocks assuming
 /// the stability of different operators are invalidated together and we don't
 /// do fine-grained tracking.

From 0df9a460451ed614f28660e69410edcb328d85be Mon Sep 17 00:00:00 2001
From: Max Bernstein <rubybugs@bernsteinbear.com>
Date: Mon, 18 Aug 2025 09:21:42 -0700
Subject: [PATCH 16/17] Increase timeout on slow tests (#14264)

---
 test/ruby/test_gc.rb      | 2 +-
 test/ruby/test_keyword.rb | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/ruby/test_gc.rb b/test/ruby/test_gc.rb
index 5fc9ea508c7142..7aba333e92377f 100644
--- a/test/ruby/test_gc.rb
+++ b/test/ruby/test_gc.rb
@@ -447,7 +447,7 @@ def obj.bar() raise "obj.foo is called, but this is obj.bar" end
   end
 
   def test_singleton_method_added
-    assert_in_out_err([], <<-EOS, [], [], "[ruby-dev:44436]")
+    assert_in_out_err([], <<-EOS, [], [], "[ruby-dev:44436]", timeout: 30)
       class BasicObject
         undef singleton_method_added
         def singleton_method_added(mid)
diff --git a/test/ruby/test_keyword.rb b/test/ruby/test_keyword.rb
index 4563308fa2ec97..1e3e0e53b129a4 100644
--- a/test/ruby/test_keyword.rb
+++ b/test/ruby/test_keyword.rb
@@ -4033,7 +4033,7 @@ def m(a: [])
       tap { m }
       GC.start
       tap { m }
-    }, bug8964
+    }, bug8964, timeout: 30
     assert_normal_exit %q{
       prc = Proc.new {|a: []|}
       GC.stress = true

From e6f3334f42fd9dfb1f89ed6afcb95789b50b3405 Mon Sep 17 00:00:00 2001
From: Peter Zhu <peter@peterzhu.ca>
Date: Thu, 14 Aug 2025 21:58:31 -0400
Subject: [PATCH 17/17] Use mark and move for iseqw

---
 iseq.c | 15 ++++-----------
 1 file changed, 4 insertions(+), 11 deletions(-)

diff --git a/iseq.c b/iseq.c
index 4334bdd7953970..09346994dd180b 100644
--- a/iseq.c
+++ b/iseq.c
@@ -1497,9 +1497,9 @@ rb_iseq_remove_coverage_all(void)
 /* define wrapper class methods (RubyVM::InstructionSequence) */
 
 static void
-iseqw_mark(void *ptr)
+iseqw_mark_and_move(void *ptr)
 {
-    rb_gc_mark_movable(*(VALUE *)ptr);
+    rb_gc_mark_and_move((VALUE *)ptr);
 }
 
 static size_t
@@ -1508,20 +1508,13 @@ iseqw_memsize(const void *ptr)
     return rb_iseq_memsize(*(const rb_iseq_t **)ptr);
 }
 
-static void
-iseqw_ref_update(void *ptr)
-{
-    VALUE *vptr = ptr;
-    *vptr = rb_gc_location(*vptr);
-}
-
 static const rb_data_type_t iseqw_data_type = {
     "T_IMEMO/iseq",
     {
-        iseqw_mark,
+        iseqw_mark_and_move,
         RUBY_TYPED_DEFAULT_FREE,
         iseqw_memsize,
-        iseqw_ref_update,
+        iseqw_mark_and_move,
     },
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY|RUBY_TYPED_WB_PROTECTED
 };