diff --git a/‎crates/codegen/src/ir.rs‎
Lines changed: 103 additions & 5 deletions b/‎crates/codegen/src/ir.rs‎
Lines changed: 103 additions & 5 deletions
@@ -125,7 +125,7 @@ pub struct ExceptHandlerInfo {
 // spell-checker:ignore petgraph
 // TODO: look into using petgraph for handling blocks and stuff? it's heavier than this, but it
 // might enable more analysis/optimizations
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Block {
     pub instructions: Vec<InstructionInfo>,
     pub next: BlockIdx,
@@ -225,6 +225,8 @@ impl CodeInfo {
         normalize_jumps(&mut self.blocks);
         self.dce(); // re-run within-block DCE after normalize_jumps creates new instructions
         self.eliminate_unreachable_blocks();
+        // TODO: duplicate_exits_without_lineno disabled pending stackdepth fix
+        // duplicate_exits_without_lineno(&mut self.blocks);
         duplicate_end_returns(&mut self.blocks);
         self.dce(); // truncate after terminal in blocks that got return duplicated
         self.eliminate_unreachable_blocks(); // remove now-unreachable last block
@@ -2496,11 +2498,107 @@ fn normalize_jumps(blocks: &mut Vec<Block>) {
     }
 }
 
+#[allow(dead_code)]
+fn is_simple_return_block(block: &Block) -> bool {
+    block.instructions.len() == 1
+        && matches!(
+            block.instructions[0].instr.real(),
+            Some(Instruction::ReturnValue)
+        )
+}
+
+/// Follow chain of empty blocks to find first non-empty block.
+fn next_nonempty_block(blocks: &[Block], mut idx: BlockIdx) -> BlockIdx {
+    while idx != BlockIdx::NULL
+        && blocks[idx.idx()].instructions.is_empty()
+        && blocks[idx.idx()].next != BlockIdx::NULL
+    {
+        idx = blocks[idx.idx()].next;
+    }
+    idx
+}
+
+#[allow(dead_code)]
+fn duplicate_exits_without_lineno(blocks: &mut Vec<Block>) {
+    // Count predecessors for each block
+    let mut predecessors = vec![0u32; blocks.len()];
+    let mut current = BlockIdx(0);
+    while current != BlockIdx::NULL {
+        let block = &blocks[current.idx()];
+        // Fall-through predecessor
+        let next = next_nonempty_block(blocks, block.next);
+        if next != BlockIdx::NULL {
+            let has_fallthrough = block.instructions.last().map_or(true, |ins| {
+                !ins.instr.is_scope_exit() && !ins.instr.is_unconditional_jump()
+            });
+            if has_fallthrough {
+                predecessors[next.idx()] += 1;
+            }
+        }
+        // Jump target predecessor
+        for ins in &block.instructions {
+            if ins.target != BlockIdx::NULL {
+                let target = next_nonempty_block(blocks, ins.target);
+                if target != BlockIdx::NULL {
+                    predecessors[target.idx()] += 1;
+                }
+            }
+        }
+        current = block.next;
+    }
+
+    // For each block, if its last instruction jumps to an exit block without lineno
+    // that has >1 predecessor, copy that exit block.
+    current = BlockIdx(0);
+    while current != BlockIdx::NULL {
+        let block = &blocks[current.idx()];
+        let last = match block.instructions.last() {
+            Some(ins) if ins.target != BlockIdx::NULL => ins,
+            _ => {
+                current = blocks[current.idx()].next;
+                continue;
+            }
+        };
+        if !last.instr.is_unconditional_jump() && !is_conditional_jump(&last.instr) {
+            current = blocks[current.idx()].next;
+            continue;
+        }
+
+        let target = next_nonempty_block(blocks, last.target);
+        if target == BlockIdx::NULL || !is_simple_return_block(&blocks[target.idx()]) {
+            current = blocks[current.idx()].next;
+            continue;
+        }
+        if predecessors[target.idx()] <= 1 {
+            current = blocks[current.idx()].next;
+            continue;
+        }
+
+        // Copy the exit block
+        let new_idx = BlockIdx(blocks.len() as u32);
+        let mut new_block = blocks[target.idx()].clone();
+        // Set location from the jump instruction
+        let jump_loc = blocks[current.idx()].instructions.last().unwrap().location;
+        let jump_end_loc = blocks[current.idx()].instructions.last().unwrap().end_location;
+        if let Some(first) = new_block.instructions.first_mut() {
+            first.location = jump_loc;
+            first.end_location = jump_end_loc;
+        }
+        new_block.next = blocks[target.idx()].next;
+        blocks.push(new_block);
+
+        // Update the jump target
+        let last_mut = blocks[current.idx()].instructions.last_mut().unwrap();
+        last_mut.target = new_idx;
+        predecessors[target.idx()] -= 1;
+
+        current = blocks[current.idx()].next;
+    }
+}
+
 /// Duplicate `LOAD_CONST None + RETURN_VALUE` for blocks that fall through
-/// to the final return block. Matches CPython's behavior of ensuring every
-/// code path that reaches the end of a function/module has its own explicit
-/// return instruction.
-fn duplicate_end_returns(blocks: &mut [Block]) {
+/// to the final return block.
+fn duplicate_end_returns(blocks: &mut Vec<Block>) {
     // Walk the block chain to find the last block
     let mut last_block = BlockIdx(0);
     let mut current = BlockIdx(0);