ZJIT: globally remove duplicate CheckInterrupts

```
ruby-master-zjit: ruby 4.1.0dev (2026-09-16T16:27:13Z master 55562be) +ZJIT +PRISM [arm64-darwin25]
ruby-dev-zjit: ruby 4.1.0dev (2026-09-16T16:49:19Z hm-ukpqtuorkpnknmos a6968e9c42) +ZJIT +PRISM [arm64-darwin25]

----------  ---------------------  ------------------  ---------------------  ------------------------------
bench       ruby-master-zjit (ms)  ruby-dev-zjit (ms)  ruby-dev-zjit 1st itr  ruby-master-zjit/ruby-dev-zjit
30k_ifelse            44.0 ± 1.8%         42.2 ± 1.8%                  1.038                           1.044
----------  ---------------------  ------------------  ---------------------  ------------------------------
```

Author: skipkayhil

zjit/src/hir.rs

@@ -1846,8 +1846,8 @@ impl Insn {
             Insn::IsBlockParamModified { .. } => effects::Empty,
             Insn::GetBlockParam { .. } => effects::Any,
             Insn::Snapshot { .. } => effects::Empty,
-            Insn::Jump(_) => effects::Any,
-            Insn::CondBranch { .. } => effects::Any,
+            Insn::Jump(_) => effects::Control,
+            Insn::CondBranch { .. } => effects::Control,
             Insn::CCall { elidable, .. } => {
                 if *elidable {
                     Effect::write(abstract_heaps::Allocator)
@@ -7126,26 +7126,51 @@ impl Function {
         }
     }
 
-    /// Remove duplicate CheckInterrupts instructions within each basic block.
-    /// Only the last CheckInterrupts in a block is needed unless an intervening
-    /// instruction writes to InterruptFlag (e.g. a call), which resets tracking.
+    /// Remove duplicate CheckInterrupts instructions globally.
+    ///
+    /// Only the last CheckInterrupts in a block is needed unless an intervening instruction writes
+    /// to InterruptFlag (e.g. a call), which resets tracking. Checking as late as possible keeps
+    /// fewer values live in the check's frame state, which lets other passes elide more.
+    ///
+    /// This tracking also propagates across blocks: a check is redundant if a later check is
+    /// guaranteed to run on every path forward before any InterruptFlag write or function exit.
+    /// That makes this a backward must-analysis. Blocks are visited so that every forward
+    /// successor is processed first (the reverse of reverse post-order). A back-edge successor has
+    /// not been processed when its source is visited, so its default `false` contribution keeps
+    /// the source block's own check alive and we never rely on a check from a later iteration.
     fn remove_duplicate_check_interrupts(&mut self) {
-        for block_id in self.reverse_post_order() {
-            let mut seen = false;
+        let cfi = ControlFlowInfo::new(self);
+
+        // Whether a check is guaranteed to run on every path leaving each block, before any
+        // InterruptFlag write or function exit. `false` is the conservative default for
+        // unprocessed (back-edge) successors.
+        let mut checked = vec![false; self.blocks.len()];
+
+        for &block_id in cfi.reverse_post_order().iter().rev() {
+            // Must-analysis: require a check on every outgoing path. A block with no successors
+            // (a function exit) provides no such guarantee.
+            let successors = cfi.successors(block_id);
+            let mut block_checked = !successors.is_empty()
+                && successors.iter().all(|&succ| checked[succ]);
+
             let insns = std::mem::take(&mut self.blocks[block_id].insns);
             let mut new_insns = Vec::with_capacity(insns.len());
+
             for insn_id in insns.into_iter().rev() {
                 let insn = &self.insns[insn_id];
                 if matches!(insn, Insn::CheckInterrupts { .. }) {
-                    if seen { continue; }
-                    seen = true;
+                    if block_checked { continue; }
+                    block_checked = true;
                 } else if insn.effects_of().write_bits().overlaps(abstract_heaps::InterruptFlag) {
-                    seen = false;
+                    block_checked = false;
                 }
                 new_insns.push(insn_id);
             }
+
             new_insns.reverse();
             self.blocks[block_id].insns = new_insns;
+
+            checked[block_id] = block_checked;
         }
     }
 

zjit/src/hir/opt_tests.rs

@@ -11519,11 +11519,9 @@ mod hir_opt_tests {
           Jump bb13(v54, v27)
         bb13(v44:BasicObject, v45:BasicObject):
           v57:BasicObject = Send v44, :call # SendFallbackReason: Send: no profile data available
-          CheckInterrupts
           Jump bb4(v57)
         bb6():
           v66:Fixnum[42] = Const Value(42)
-          CheckInterrupts
           Jump bb4(v66)
         bb4(v72:BasicObject):
           PopInlineFrame
@@ -15185,7 +15183,6 @@ mod hir_opt_tests {
           v48:BasicObject = ArrayAref v19, v47
           v49:ArrayExact = NewArray v48
           PushInlineFrame :target, v25 (0x1040), num_args=1
-          CheckInterrupts
           PopInlineFrame
           Jump bb4(v49)
         bb6():
@@ -15203,7 +15200,6 @@ mod hir_opt_tests {
           v59:BasicObject = ArrayAref v19, v58
           v60:ArrayExact = NewArray v59
           PushInlineFrame :target, v31 (0x1090), num_args=1
-          CheckInterrupts
           PopInlineFrame
           Jump bb4(v60)
         bb8():
@@ -21560,10 +21556,8 @@ mod hir_opt_tests {
           CondBranch v37, bb7(), bb6()
         bb7():
           v42:Fixnum[0] = Const Value(0)
-          CheckInterrupts
           Jump bb4(v42)
         bb6():
-          CheckInterrupts
           Jump bb4(v62)
         bb4(v56:Fixnum):
           PopInlineFrame
@@ -22900,7 +22894,6 @@ mod hir_opt_tests {
           StoreField v95, :@y@0x108c, v49
           v176:CShape[0x108d] = Const CShape(0x108d)
           StoreField v95, :shape_id@0x1088, v176
-          CheckInterrupts
           PopInlineFrame
           PatchPoint MethodRedefined(Point@0x1008, ==@0x1098, cme:0x10a0)
           PushInlineFrame :==, v85 (0x10c8), num_args=1