RustPython · youknowone · Feb 17, 2026 · Feb 17, 2026 · coderabbitai · Feb 16, 2026
diff --git a/crates/stdlib/src/faulthandler.rs b/crates/stdlib/src/faulthandler.rs
@@ -96,9 +96,8 @@ mod decl {
         all_threads: AtomicBool::new(true),
     };
 
-    /// Arc<Mutex<Vec<FrameRef>>> - shared frame slot for a thread
     #[cfg(feature = "threading")]
-    type ThreadFrameSlot = Arc<parking_lot::Mutex<Vec<crate::vm::frame::FrameRef>>>;
+    type ThreadFrameSlot = Arc<rustpython_vm::vm::thread::ThreadSlot>;
 
     // Watchdog thread state for dump_traceback_later
     struct WatchdogState {
@@ -326,7 +325,7 @@ mod decl {
 
     /// Write a frame's info to an fd using signal-safe I/O.
     #[cfg(any(unix, windows))]
-    fn dump_frame_from_ref(fd: i32, frame: &crate::vm::PyRef<Frame>) {
+    fn dump_frame_from_ref(fd: i32, frame: &crate::vm::Py<Frame>) {
         let funcname = frame.code.obj_name.as_str();
         let filename = frame.code.source_path().as_str();
         let lineno = if frame.lasti() == 0 {
@@ -345,20 +344,23 @@ mod decl {
     }
 
     /// Dump traceback for a thread given its frame stack (for cross-thread dumping).
+    /// # Safety
+    /// Each `FramePtr` must point to a live frame (caller holds the Mutex).
     #[cfg(all(any(unix, windows), feature = "threading"))]
     fn dump_traceback_thread_frames(
         fd: i32,
         thread_id: u64,
         is_current: bool,
-        frames: &[crate::vm::frame::FrameRef],
+        frames: &[rustpython_vm::vm::FramePtr],
     ) {
         write_thread_id(fd, thread_id, is_current);
 
         if frames.is_empty() {
             puts(fd, "  <no Python frame>\n");
         } else {
-            for frame in frames.iter().rev() {
-                dump_frame_from_ref(fd, frame);
+            for fp in frames.iter().rev() {
+                // SAFETY: caller holds the Mutex, so the owning thread can't pop.
+                dump_frame_from_ref(fd, unsafe { fp.as_ref() });
             }
         }
     }
@@ -382,8 +384,9 @@ mod decl {
             } else {
                 puts(fd, "Stack (most recent call first):\n");
                 let frames = vm.frames.borrow();
-                for frame in frames.iter().rev() {
-                    dump_frame_from_ref(fd, frame);
+                for fp in frames.iter().rev() {
+                    // SAFETY: the frame is alive while it's in the Vec
+                    dump_frame_from_ref(fd, unsafe { fp.as_ref() });
                 }
             }
         }
@@ -410,7 +413,7 @@ mod decl {
                 if tid == current_tid {
                     continue;
                 }
-                let frames_guard = slot.lock();
+                let frames_guard = slot.frames.lock();
                 dump_traceback_thread_frames(fd, tid, false, &frames_guard);
                 puts(fd, "\n");
             }
@@ -421,8 +424,8 @@ mod decl {
             if frames.is_empty() {
                 puts(fd, "  <no Python frame>\n");
             } else {
-                for frame in frames.iter().rev() {
-                    dump_frame_from_ref(fd, frame);
+                for fp in frames.iter().rev() {
+                    dump_frame_from_ref(fd, unsafe { fp.as_ref() });
                 }
             }
         }
@@ -431,8 +434,8 @@ mod decl {
         {
             write_thread_id(fd, current_thread_id(), true);
             let frames = vm.frames.borrow();
-            for frame in frames.iter().rev() {
-                dump_frame_from_ref(fd, frame);
+            for fp in frames.iter().rev() {
+                dump_frame_from_ref(fd, unsafe { fp.as_ref() });
             }
         }
     }
@@ -870,7 +873,7 @@ mod decl {
                 #[cfg(feature = "threading")]
                 {
                     for (tid, slot) in &thread_frame_slots {
-                        let frames = slot.lock();
+                        let frames = slot.frames.lock();
                         dump_traceback_thread_frames(fd, *tid, false, &frames);
                     }
                 }

diff --git a/crates/vm/src/builtins/frame.rs b/crates/vm/src/builtins/frame.rs
@@ -4,7 +4,7 @@
 
 use super::{PyCode, PyDictRef, PyIntRef, PyStrRef};
 use crate::{
-    AsObject, Context, Py, PyObjectRef, PyRef, PyResult, VirtualMachine,
+    Context, Py, PyObjectRef, PyRef, PyResult, VirtualMachine,
     class::PyClassImpl,
     frame::{Frame, FrameOwner, FrameRef},
     function::PySetterValue,
@@ -195,16 +195,43 @@ impl Py<Frame> {
 
     #[pygetset]
     pub fn f_back(&self, vm: &VirtualMachine) -> Option<PyRef<Frame>> {
-        // TODO: actually store f_back inside Frame struct
+        let previous = self.previous_frame();
+        if previous.is_null() {
+            return None;
+        }
 
-        // get the frame in the frame stack that appears before this one.
-        // won't work if  this frame isn't in the frame stack, hence the todo above
-        vm.frames
+        if let Some(frame) = vm
+            .frames
             .borrow()
             .iter()
-            .rev()
-            .skip_while(|p| !p.is(self.as_object()))
-            .nth(1)
-            .cloned()
+            .find(|fp| {
+                // SAFETY: the caller keeps the FrameRef alive while it's in the Vec
+                let py: &crate::Py<Frame> = unsafe { fp.as_ref() };
+                let ptr: *const Frame = &**py;
+                core::ptr::eq(ptr, previous)
+            })
+            .map(|fp| unsafe { fp.as_ref() }.to_owned())
+        {
+            return Some(frame);
+        }
+
+        #[cfg(feature = "threading")]
+        {
+            let registry = vm.state.thread_frames.lock();
+            for slot in registry.values() {
+                let frames = slot.frames.lock();
+                // SAFETY: the owning thread can't pop while we hold the Mutex,
+                // so FramePtr is valid for the duration of the lock.
+                if let Some(frame) = frames.iter().find_map(|fp| {
+                    let f = unsafe { fp.as_ref() };
+                    let ptr: *const Frame = &**f;
+                    core::ptr::eq(ptr, previous).then(|| f.to_owned())
+                }) {
+                    return Some(frame);
+                }
+            }
+        }
+
+        None
     }
 }
diff --git a/crates/vm/src/coroutine.rs b/crates/vm/src/coroutine.rs
@@ -1,11 +1,11 @@
 use crate::{
     AsObject, Py, PyObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine,
-    builtins::{PyBaseExceptionRef, PyStrRef},
+    builtins::PyStrRef,
     common::lock::PyMutex,
     exceptions::types::PyBaseException,
-    frame::{ExecutionResult, FrameOwner, FrameRef},
+    frame::{ExecutionResult, Frame, FrameOwner, FrameRef},
     function::OptionalArg,
-    object::{Traverse, TraverseFn},
+    object::{PyAtomicRef, Traverse, TraverseFn},
     protocol::PyIterReturn,
 };
 use crossbeam_utils::atomic::AtomicCell;
@@ -36,15 +36,17 @@ pub struct Coro {
     // _weakreflist
     name: PyMutex<PyStrRef>,
     qualname: PyMutex<PyStrRef>,
-    exception: PyMutex<Option<PyBaseExceptionRef>>, // exc_state
+    exception: PyAtomicRef<Option<PyBaseException>>, // exc_state
 }
 
 unsafe impl Traverse for Coro {
     fn traverse(&self, tracer_fn: &mut TraverseFn<'_>) {
         self.frame.traverse(tracer_fn);
         self.name.traverse(tracer_fn);
         self.qualname.traverse(tracer_fn);
-        self.exception.traverse(tracer_fn);
+        if let Some(exc) = self.exception.deref() {
+            exc.traverse(tracer_fn);
+        }
     }
 }
 
@@ -65,7 +67,7 @@ impl Coro {
             frame,
             closed: AtomicCell::new(false),
             running: AtomicCell::new(false),
-            exception: PyMutex::default(),
+            exception: PyAtomicRef::from(None),
             name: PyMutex::new(name),
             qualname: PyMutex::new(qualname),
         }
@@ -92,33 +94,20 @@ impl Coro {
         func: F,
     ) -> PyResult<ExecutionResult>
     where
-        F: FnOnce(FrameRef) -> PyResult<ExecutionResult>,
+        F: FnOnce(&Py<Frame>) -> PyResult<ExecutionResult>,
     {
         if self.running.compare_exchange(false, true).is_err() {
             return Err(vm.new_value_error(format!("{} already executing", gen_name(jen, vm))));
         }
 
-        // swap exception state
-        // Get generator's saved exception state from last yield
-        let gen_exc = self.exception.lock().take();
-
-        // Use a slot to capture generator's exception state before with_frame pops
-        let exception_slot = &self.exception;
+        // SAFETY: running.compare_exchange guarantees exclusive access
+        let gen_exc = unsafe { self.exception.swap(None) };
+        let exception_ptr = &self.exception as *const PyAtomicRef<Option<PyBaseException>>;
 
-        // Run the generator frame
-        // with_frame does push_exception(None) which creates a new exception context
-        // The caller's exception remains in the chain via prev, so topmost_exception()
-        // will find it if generator's exception is None
-        let result = vm.with_frame(self.frame.clone(), |f| {
-            // with_frame pushed None, creating: { exc: None, prev: caller's exc_info }
-            // Pop None and push generator's exception instead
-            // This maintains the chain: { exc: gen_exc, prev: caller's exc_info }
-            vm.pop_exception();
-            vm.push_exception(gen_exc);
+        let result = vm.resume_gen_frame(&self.frame, gen_exc, |f| {
             let result = func(f);
-            // Save generator's exception state BEFORE with_frame pops
-            // This is the generator's current exception context
-            *exception_slot.lock() = vm.current_exception();
+            // SAFETY: exclusive access guaranteed by running flag
+            let _old = unsafe { (*exception_ptr).swap(vm.current_exception()) };
             result
         });
 

diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
@@ -463,7 +463,7 @@ impl ExecutingFrame<'_> {
         // Execute until return or exception:
         let instructions = &self.code.instructions;
         let mut arg_state = bytecode::OpArgState::default();
-        let mut prev_line: usize = 0;
+        let mut prev_line: u32 = 0;
         loop {
             let idx = self.lasti() as usize;
             // Fire 'line' trace event when line number changes.
@@ -472,9 +472,9 @@ impl ExecutingFrame<'_> {
             if vm.use_tracing.get()
                 && !vm.is_none(&self.object.trace.lock())
                 && let Some((loc, _)) = self.code.locations.get(idx)
-                && loc.line.get() != prev_line
+                && loc.line.get() as u32 != prev_line
             {
-                prev_line = loc.line.get();
+                prev_line = loc.line.get() as u32;
                 vm.trace_event(crate::protocol::TraceEvent::Line, None)?;
             }
             self.update_lasti(|i| *i += 1);
@@ -543,13 +543,16 @@ impl ExecutingFrame<'_> {
                     // Check if this is a RERAISE instruction
                     // Both AnyInstruction::Raise { kind: Reraise/ReraiseFromStack } and
                     // AnyInstruction::Reraise are reraise operations that should not add
-                    // new traceback entries
+                    // new traceback entries.
+                    // EndAsyncFor and CleanupThrow also re-raise non-matching exceptions.
                     let is_reraise = match op {
                         Instruction::RaiseVarargs { kind } => matches!(
                             kind.get(arg),
                             bytecode::RaiseKind::BareRaise | bytecode::RaiseKind::ReraiseFromStack
                         ),
-                        Instruction::Reraise { .. } => true,
+                        Instruction::Reraise { .. }
+                        | Instruction::EndAsyncFor
+                        | Instruction::CleanupThrow => true,
                         _ => false,
                     };
 
@@ -653,6 +656,19 @@ impl ExecutingFrame<'_> {
                     Ok(())
                 };
                 if let Err(err) = close_result {
+                    let idx = self.lasti().saturating_sub(1) as usize;
+                    if idx < self.code.locations.len() {
+                        let (loc, _end_loc) = self.code.locations[idx];
+                        let next = err.__traceback__();
+                        let new_traceback = PyTraceback::new(
+                            next,
+                            self.object.to_owned(),
+                            idx as u32 * 2,
+                            loc.line,
+                        );
+                        err.set_traceback_typed(Some(new_traceback.into_ref(&vm.ctx)));
+                    }
+
                     self.push_value(vm.ctx.none());
                     vm.contextualize_exception(&err);
                     return match self.unwind_blocks(vm, UnwindReason::Raising { exception: err }) {
@@ -678,6 +694,23 @@ impl ExecutingFrame<'_> {
                         Either::B(meth) => meth.call((exc_type, exc_val, exc_tb), vm),
                     };
                     return ret.map(ExecutionResult::Yield).or_else(|err| {
+                        // Add traceback entry for the yield-from/await point.
+                        // gen_send_ex2 resumes the frame with a pending exception,
+                        // which goes through error: → PyTraceBack_Here. We add the
+                        // entry here before calling unwind_blocks.
+                        let idx = self.lasti().saturating_sub(1) as usize;
+                        if idx < self.code.locations.len() {
+                            let (loc, _end_loc) = self.code.locations[idx];
+                            let next = err.__traceback__();
+                            let new_traceback = PyTraceback::new(
+                                next,
+                                self.object.to_owned(),
+                                idx as u32 * 2,
+                                loc.line,
+                            );
+                            err.set_traceback_typed(Some(new_traceback.into_ref(&vm.ctx)));
+                        }
+
                         self.push_value(vm.ctx.none());
                         vm.contextualize_exception(&err);
                         match self.unwind_blocks(vm, UnwindReason::Raising { exception: err }) {

diff --git a/crates/vm/src/protocol/callable.rs b/crates/vm/src/protocol/callable.rs
@@ -2,7 +2,7 @@ use crate::{
     builtins::{PyBoundMethod, PyFunction},
     function::{FuncArgs, IntoFuncArgs},
     types::GenericMethod,
-    {AsObject, PyObject, PyObjectRef, PyResult, VirtualMachine},
+    {PyObject, PyObjectRef, PyResult, VirtualMachine},
 };
 
 impl PyObject {
@@ -111,12 +111,11 @@ impl VirtualMachine {
             return Ok(());
         }
 
-        let frame_ref = self.current_frame();
-        if frame_ref.is_none() {
+        let Some(frame_ref) = self.current_frame() else {
             return Ok(());
-        }
+        };
 
-        let frame = frame_ref.unwrap().as_object().to_owned();
+        let frame: PyObjectRef = frame_ref.into();
         let event = self.ctx.new_str(event.to_string()).into();
         let args = vec![frame, event, arg.unwrap_or_else(|| self.ctx.none())];
 

diff --git a/crates/vm/src/stdlib/builtins.rs b/crates/vm/src/stdlib/builtins.rs
@@ -384,7 +384,7 @@ mod builtins {
                     )
                 }
                 None => (
-                    vm.current_globals().clone(),
+                    vm.current_globals(),
                     if let Some(locals) = self.locals {
                         locals
                     } else {
@@ -503,7 +503,7 @@ mod builtins {
 
     #[pyfunction]
     fn globals(vm: &VirtualMachine) -> PyDictRef {
-        vm.current_globals().clone()
+        vm.current_globals()
     }
 
     #[pyfunction]