Mark frames as escaped even when the first escape happens after the transition to cached.

Traceback collection counted frames during exception unwinding, but did not
mark them as escaped. In uncached execution, we had the PFrame.Reference links
unconditionally, so this worked when it happened then, and we marked the root
as needing the PFrame.Reference link, so on later cached calls we have them.
But if we raise and escape the frame for the very first time when already
cached we did not preserve the f_back chain and could not reconstruct it
properly later.

This change makes the frames that belong to a traceback mark their current
PFrame.Reference as escaped while the exception is unwinding and the
VirtualFrame is thus still on the stack. The CalleeContext#exit logic then
materializes the frame and propagates to caller frames and this preserves the
f_back chain.

This can be triggered by forcing immediately cached execution, but a regression
test covers the case where functions first transition to cached execution
without raising, then later raises after some time (presumably after we
transitioned to cached) and inspect traceback backrefs.

Author: timfel

graalpython/com.oracle.graal.python.test/src/tests/test_frame_tests.py

@@ -238,6 +238,24 @@ def foo():
         assert e.__traceback__.tb_next.tb_frame.f_back.f_code == test_backref_from_traceback.__code__
 
 
+def test_backref_from_traceback_after_cached_transition():
+    def bar(should_raise):
+        if should_raise:
+            raise RuntimeError
+
+    def foo(should_raise):
+        bar(should_raise)
+
+    for _ in range(64): # we probably do not execute 64-times in uncached
+        foo(False)
+
+    try:
+        foo(True)
+    except Exception as e:
+        assert e.__traceback__.tb_next.tb_next.tb_frame.f_back.f_code == foo.__code__
+        assert e.__traceback__.tb_next.tb_frame.f_back.f_code == test_backref_from_traceback_after_cached_transition.__code__
+
+
 def test_frame_from_another_thread():
     import sys, threading
     event1 = threading.Event()

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/bytecode_dsl/PBytecodeDSLRootNode.java

@@ -589,7 +589,7 @@ public static void doExit(VirtualFrame frame, AbstractTruffleException ate,
                         @Bind PBytecodeDSLRootNode root,
                         @Bind BytecodeNode location) {
             if (ate instanceof PException pe) {
-                pe.notifyAddedTracebackFrame(!root.isInternal());
+                pe.notifyAddedTracebackFrame(frame, !root.isInternal());
             }
             // We cannot use instrumentation for exceptional exit
             if (root.needsTraceAndProfileInstrumentation()) {

graalpython/com.oracle.graal.python/src/com/oracle/graal/python/runtime/exception/PException.java

@@ -363,6 +363,18 @@ private void markFrameEscaped() {
         }
     }
 
+    private void markFrameEscaped(Frame frame) {
+        if (frame != null) {
+            PFrame.Reference currentFrameInfo = PArguments.getCurrentFrameInfo(frame);
+            if (currentFrameInfo != null) {
+                currentFrameInfo.markAsEscaped();
+                if (escapedFrameThread == null) {
+                    escapedFrameThread = Thread.currentThread();
+                }
+            }
+        }
+    }
+
     public Thread getEscapedFrameThread() {
         return escapedFrameThread;
     }
@@ -401,9 +413,10 @@ public int getTracebackFrameCount() {
         return tracebackFrameCount;
     }
 
-    public void notifyAddedTracebackFrame(boolean visible) {
+    public void notifyAddedTracebackFrame(Frame frame, boolean visible) {
         if (visible) {
             tracebackFrameCount++;
+            markFrameEscaped(frame);
         }
     }