ZJIT: globally remove duplicate CheckInterrupts

This also required updating the effects of Jump and CondBranch, since
`effects::Any` includes `InterruptFlag` (meaning the optimization would
never actually work across blocks).

```
ruby-master-zjit: ruby 4.1.0dev (2026-09-17T20:29:33Z master aca98ee) +ZJIT +PRISM [arm64-darwin25]
ruby-dev-zjit: ruby 4.1.0dev (2026-09-17T21:09:40Z hm-ukpqtuorkpnknmos 203f9cdd52) +ZJIT +PRISM [arm64-darwin25]
last_commit=ZJIT: globally remove duplicate CheckInterrupts

----------  ---------------------  ------------------  ---------------------  ------------------------------
bench       ruby-master-zjit (ms)  ruby-dev-zjit (ms)  ruby-dev-zjit 1st itr  ruby-master-zjit/ruby-dev-zjit
30k_ifelse            44.7 ± 2.8%         42.5 ± 2.7%                  1.045                           1.050
----------  ---------------------  ------------------  ---------------------  ------------------------------
```

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)
@@ -7132,26 +7132,67 @@ 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.
     fn remove_duplicate_check_interrupts(&mut self) {
-        for block_id in self.reverse_post_order() {
-            let mut seen = false;
-            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;
-                } else if insn.effects_of().write_bits().overlaps(abstract_heaps::InterruptFlag) {
-                    seen = false;
+        let cfi = ControlFlowInfo::new(self);
+        let rpo = cfi.reverse_post_order();
+
+        let rpo_index = {
+            let mut order = vec![usize::MAX; self.blocks.len()];
+            for (i, &block_id) in rpo.iter().enumerate() {
+                order[block_id] = i;
+            }
+            order
+        };
+
+        // Start by assuming all blocks are unchecked.
+        let mut checked = vec![false; self.blocks.len()];
+
+        // Iterate until fixpoint: when no CheckInterrupts instruction is removed, and the checked
+        // status of all blocks stays the same.
+        let mut changed = true;
+        while changed {
+            changed = false;
+
+            for &block_id in rpo.iter().rev() {
+                let successors = cfi.successors(block_id);
+
+                // A block can initially be considered checked if
+                // - it has successors
+                // - all successors have been checked
+                // - none of the successors are back edges (i.e. have a lower RPO index than the current block)
+                let mut block_checked = !successors.is_empty()
+                    && successors.iter().all(|&succ| checked[succ] && !(rpo_index[succ] < rpo_index[block_id]));
+
+                let insns = std::mem::take(&mut self.blocks[block_id].insns);
+                let mut new_insns = Vec::with_capacity(insns.len());
+
+                // 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.
+                for insn_id in insns.into_iter().rev() {
+                    let insn = &self.insns[insn_id];
+                    if matches!(insn, Insn::CheckInterrupts { .. }) {
+                        if block_checked {
+                            changed = true;
+                            continue;
+                        }
+                        block_checked = true;
+                    } else if insn.effects_of().write_bits().overlaps(abstract_heaps::InterruptFlag) {
+                        block_checked = false;
+                    }
+                    new_insns.push(insn_id);
+                }
+
+                new_insns.reverse();
+                self.blocks[block_id].insns = new_insns;
+
+                if checked[block_id] != block_checked {
+                    changed = true;
+                    checked[block_id] = block_checked;
                 }
-                new_insns.push(insn_id);
             }
-            new_insns.reverse();
-            self.blocks[block_id].insns = new_insns;
         }
     }
 

zjit/src/hir/opt_tests.rs

@@ -11580,11 +11580,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
@@ -15246,7 +15244,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():
@@ -15264,7 +15261,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():
@@ -21611,10 +21607,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
@@ -22950,7 +22944,6 @@ mod hir_opt_tests {
           StoreField v95, :@y@0x108c, v49
           v172:CShape[0x108d] = Const CShape(0x108d)
           StoreField v95, :shape_id@0x1088, v172
-          CheckInterrupts
           PopInlineFrame
           PatchPoint MethodRedefined(Point@0x1008, ==@0x1098, cme:0x10a0)
           PushInlineFrame :==, v85 (0x10c8), num_args=1
@@ -23371,7 +23364,6 @@ mod hir_opt_tests {
           v59:CInt64[-4] = Const CInt64(-4)
           v60:CInt64 = IntAnd v58, v59
           v61:BasicObject = InvokeBlockIseqDirect (0x1068), v60
-          CheckInterrupts
           PopInlineFrame
           Jump bb4(v61)
         bb6():
@@ -23387,7 +23379,6 @@ mod hir_opt_tests {
           v77:CInt64[-4] = Const CInt64(-4)
           v78:CInt64 = IntAnd v76, v77
           v79:BasicObject = InvokeBlockIseqDirect (0x1068), v78
-          CheckInterrupts
           PopInlineFrame
           Jump bb4(v79)
         bb8():
@@ -23403,7 +23394,6 @@ mod hir_opt_tests {
           v95:CInt64[-4] = Const CInt64(-4)
           v96:CInt64 = IntAnd v94, v95
           v97:BasicObject = InvokeBlockIseqDirect (0x1068), v96
-          CheckInterrupts
           PopInlineFrame
           Jump bb4(v97)
         bb10():