pythonGH-128563: Add new frame owner type for interpreter entry frames (pythonGH-129078)

markshannon · web-flow · commit f5b6356a11bd · 2025-01-21T10:15:02.000Z
Add new frame owner type for interpreter entry frames
diff --git a/Include/internal/pycore_frame.h b/Include/internal/pycore_frame.h
@@ -56,7 +56,8 @@ enum _frameowner {
     FRAME_OWNED_BY_THREAD = 0,
     FRAME_OWNED_BY_GENERATOR = 1,
     FRAME_OWNED_BY_FRAME_OBJECT = 2,
-    FRAME_OWNED_BY_CSTACK = 3,
+    FRAME_OWNED_BY_INTERPRETER = 3,
+    FRAME_OWNED_BY_CSTACK = 4,
 };
 
 typedef struct _PyInterpreterFrame {
@@ -264,7 +265,7 @@ _PyFrame_SetStackPointer(_PyInterpreterFrame *frame, _PyStackRef *stack_pointer)
 static inline bool
 _PyFrame_IsIncomplete(_PyInterpreterFrame *frame)
 {
-    if (frame->owner == FRAME_OWNED_BY_CSTACK) {
+    if (frame->owner >= FRAME_OWNED_BY_INTERPRETER) {
         return true;
     }
     return frame->owner != FRAME_OWNED_BY_GENERATOR &&
diff --git a/Modules/_testexternalinspection.c b/Modules/_testexternalinspection.c
@@ -508,7 +508,7 @@ parse_frame_object(
         return -1;
     }
 
-    if (owner == FRAME_OWNED_BY_CSTACK) {
+    if (owner >= FRAME_OWNED_BY_INTERPRETER) {
         return 0;
     }
 
diff --git a/Objects/frameobject.c b/Objects/frameobject.c
@@ -2133,7 +2133,7 @@ _PyFrame_IsEntryFrame(PyFrameObject *frame)
     assert(frame != NULL);
     _PyInterpreterFrame *f = frame->f_frame;
     assert(!_PyFrame_IsIncomplete(f));
-    return f->previous && f->previous->owner == FRAME_OWNED_BY_CSTACK;
+    return f->previous && f->previous->owner == FRAME_OWNED_BY_INTERPRETER;
 }
 
 PyCodeObject *
diff --git a/Python/bytecodes.c b/Python/bytecodes.c
@@ -1090,7 +1090,7 @@ dummy_func(
         }
 
         tier1 inst(INTERPRETER_EXIT, (retval --)) {
-            assert(frame == &entry_frame);
+            assert(frame->owner == FRAME_OWNED_BY_INTERPRETER);
             assert(_PyFrame_IsIncomplete(frame));
             /* Restore previous frame and return. */
             tstate->current_frame = frame->previous;
@@ -1105,9 +1105,7 @@ dummy_func(
         // retval is popped from the stack, but res
         // is pushed to a different frame, the callers' frame.
         inst(RETURN_VALUE, (retval -- res)) {
-            #if TIER_ONE
-            assert(frame != &entry_frame);
-            #endif
+            assert(frame->owner != FRAME_OWNED_BY_INTERPRETER);
             _PyStackRef temp = retval;
             DEAD(retval);
             SAVE_STACK();
@@ -1205,7 +1203,7 @@ dummy_func(
             PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver);
 
             PyObject *retval_o;
-            assert(frame != &entry_frame);
+            assert(frame->owner != FRAME_OWNED_BY_INTERPRETER);
             if ((tstate->interp->eval_frame == NULL) &&
                 (Py_TYPE(receiver_o) == &PyGen_Type || Py_TYPE(receiver_o) == &PyCoro_Type) &&
                 ((PyGenObject *)receiver_o)->gi_frame_state < FRAME_EXECUTING)
@@ -1278,9 +1276,7 @@ dummy_func(
             // NOTE: It's important that YIELD_VALUE never raises an exception!
             // The compiler treats any exception raised here as a failed close()
             // or throw() call.
-            #if TIER_ONE
-            assert(frame != &entry_frame);
-            #endif
+            assert(frame->owner != FRAME_OWNED_BY_INTERPRETER);
             frame->instr_ptr++;
             PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame);
             assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1);
diff --git a/Python/ceval.c b/Python/ceval.c
@@ -178,7 +178,7 @@ lltrace_instruction(_PyInterpreterFrame *frame,
                     int opcode,
                     int oparg)
 {
-    if (frame->owner == FRAME_OWNED_BY_CSTACK) {
+    if (frame->owner >= FRAME_OWNED_BY_INTERPRETER) {
         return;
     }
     dump_stack(frame, stack_pointer);
@@ -229,12 +229,12 @@ lltrace_resume_frame(_PyInterpreterFrame *frame)
 }
 
 static int
-maybe_lltrace_resume_frame(_PyInterpreterFrame *frame, _PyInterpreterFrame *skip_frame, PyObject *globals)
+maybe_lltrace_resume_frame(_PyInterpreterFrame *frame, PyObject *globals)
 {
     if (globals == NULL) {
         return 0;
     }
-    if (frame == skip_frame) {
+    if (frame->owner >= FRAME_OWNED_BY_INTERPRETER) {
         return 0;
     }
     int r = PyDict_Contains(globals, &_Py_ID(__lltrace__));
@@ -818,7 +818,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
     entry_frame.f_executable = PyStackRef_None;
     entry_frame.instr_ptr = (_Py_CODEUNIT *)_Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS + 1;
     entry_frame.stackpointer = entry_frame.localsplus;
-    entry_frame.owner = FRAME_OWNED_BY_CSTACK;
+    entry_frame.owner = FRAME_OWNED_BY_INTERPRETER;
     entry_frame.visited = 0;
     entry_frame.return_offset = 0;
     /* Push frame */
@@ -880,7 +880,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
     stack_pointer = _PyFrame_GetStackPointer(frame);
 
 #ifdef LLTRACE
-    lltrace = maybe_lltrace_resume_frame(frame, &entry_frame, GLOBALS());
+    lltrace = maybe_lltrace_resume_frame(frame, GLOBALS());
     if (lltrace < 0) {
         goto exit_unwind;
     }
diff --git a/Python/ceval_macros.h b/Python/ceval_macros.h
@@ -89,7 +89,7 @@
 #if LLTRACE
 #define LLTRACE_RESUME_FRAME() \
 do { \
-    lltrace = maybe_lltrace_resume_frame(frame, &entry_frame, GLOBALS()); \
+    lltrace = maybe_lltrace_resume_frame(frame, GLOBALS()); \
     if (lltrace < 0) { \
         goto exit_unwind; \
     } \
@@ -238,7 +238,7 @@ GETITEM(PyObject *v, Py_ssize_t i) {
 #endif
 
 #define WITHIN_STACK_BOUNDS() \
-   (frame == &entry_frame || (STACK_LEVEL() >= 0 && STACK_LEVEL() <= STACK_SIZE()))
+   (frame->owner == FRAME_OWNED_BY_INTERPRETER || (STACK_LEVEL() >= 0 && STACK_LEVEL() <= STACK_SIZE()))
 
 /* Data access macros */
 #define FRAME_CO_CONSTS (_PyFrame_GetCode(frame)->co_consts)
diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h
diff --git a/Python/frame.c b/Python/frame.c
@@ -48,7 +48,7 @@ _PyFrame_MakeAndSetFrameObject(_PyInterpreterFrame *frame)
 static void
 take_ownership(PyFrameObject *f, _PyInterpreterFrame *frame)
 {
-    assert(frame->owner != FRAME_OWNED_BY_CSTACK);
+    assert(frame->owner < FRAME_OWNED_BY_INTERPRETER);
     assert(frame->owner != FRAME_OWNED_BY_FRAME_OBJECT);
     Py_ssize_t size = ((char*)frame->stackpointer) - (char *)frame;
     memcpy((_PyInterpreterFrame *)f->_f_frame_data, frame, size);
@@ -69,7 +69,7 @@ take_ownership(PyFrameObject *f, _PyInterpreterFrame *frame)
     _PyInterpreterFrame *prev = _PyFrame_GetFirstComplete(frame->previous);
     frame->previous = NULL;
     if (prev) {
-        assert(prev->owner != FRAME_OWNED_BY_CSTACK);
+        assert(prev->owner < FRAME_OWNED_BY_INTERPRETER);
         /* Link PyFrameObjects.f_back and remove link through _PyInterpreterFrame.previous */
         PyFrameObject *back = _PyFrame_GetFrameObject(prev);
         if (back == NULL) {
diff --git a/Python/gc.c b/Python/gc.c
@@ -1476,7 +1476,7 @@ mark_stacks(PyInterpreterState *interp, PyGC_Head *visited, int visited_space, b
     while (ts) {
         _PyInterpreterFrame *frame = ts->current_frame;
         while (frame) {
-            if (frame->owner == FRAME_OWNED_BY_CSTACK) {
+            if (frame->owner >= FRAME_OWNED_BY_INTERPRETER) {
                 frame = frame->previous;
                 continue;
             }
diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h
diff --git a/Python/instrumentation.c b/Python/instrumentation.c
@@ -1946,7 +1946,7 @@ instrument_all_executing_code_objects(PyInterpreterState *interp) {
     while (ts) {
         _PyInterpreterFrame *frame = ts->current_frame;
         while (frame) {
-            if (frame->owner != FRAME_OWNED_BY_CSTACK) {
+            if (frame->owner < FRAME_OWNED_BY_INTERPRETER) {
                 if (instrument_lock_held(_PyFrame_GetCode(frame), interp)) {
                     return -1;
                 }
diff --git a/Python/traceback.c b/Python/traceback.c
@@ -890,7 +890,7 @@ _Py_DumpASCII(int fd, PyObject *text)
 static void
 dump_frame(int fd, _PyInterpreterFrame *frame)
 {
-    assert(frame->owner != FRAME_OWNED_BY_CSTACK);
+    assert(frame->owner < FRAME_OWNED_BY_INTERPRETER);
 
     PyCodeObject *code =_PyFrame_GetCode(frame);
     PUTS(fd, "  File ");
@@ -965,15 +965,15 @@ dump_traceback(int fd, PyThreadState *tstate, int write_header)
 
     unsigned int depth = 0;
     while (1) {
-        if (frame->owner == FRAME_OWNED_BY_CSTACK) {
+        if (frame->owner == FRAME_OWNED_BY_INTERPRETER) {
             /* Trampoline frame */
             frame = frame->previous;
             if (frame == NULL) {
                 break;
             }
 
             /* Can't have more than one shim frame in a row */
-            assert(frame->owner != FRAME_OWNED_BY_CSTACK);
+            assert(frame->owner != FRAME_OWNED_BY_INTERPRETER);
         }
 
         if (MAX_FRAME_DEPTH <= depth) {
diff --git a/Tools/gdb/libpython.py b/Tools/gdb/libpython.py
@@ -99,7 +99,7 @@ def interp_frame_has_tlbc_index():
 Py_TPFLAGS_TYPE_SUBCLASS     = (1 << 31)
 
 #From pycore_frame.h
-FRAME_OWNED_BY_CSTACK = 3
+FRAME_OWNED_BY_INTERPRETER = 3
 
 MAX_OUTPUT_LEN=1024
 
@@ -1113,7 +1113,7 @@ def _f_lasti(self):
         return int(instr_ptr - first_instr)
 
     def is_shim(self):
-        return self._f_special("owner", int) == FRAME_OWNED_BY_CSTACK
+        return self._f_special("owner", int) == FRAME_OWNED_BY_INTERPRETER
 
     def previous(self):
         return self._f_special("previous", PyFramePtr)

Original file line number	Diff line number	Diff line change
`@@ -508,7 +508,7 @@ parse_frame_object(`
`508`	`508`	`return -1;`
`509`	`509`	`}`
`510`	`510`
`511`		`- if (owner == FRAME_OWNED_BY_CSTACK) {`
	`511`	`+ if (owner >= FRAME_OWNED_BY_INTERPRETER) {`
`512`	`512`	`return 0;`
`513`	`513`	`}`
`514`	`514`
Original file line number	Diff line number	Diff line change
`@@ -2133,7 +2133,7 @@ _PyFrame_IsEntryFrame(PyFrameObject *frame)`
`2133`	`2133`	`assert(frame != NULL);`
`2134`	`2134`	`_PyInterpreterFrame *f = frame->f_frame;`
`2135`	`2135`	`assert(!_PyFrame_IsIncomplete(f));`
`2136`		`- return f->previous && f->previous->owner == FRAME_OWNED_BY_CSTACK;`
	`2136`	`+ return f->previous && f->previous->owner == FRAME_OWNED_BY_INTERPRETER;`
`2137`	`2137`	`}`
`2138`	`2138`
`2139`	`2139`	`PyCodeObject *`
Original file line number	Diff line number	Diff line change
`@@ -178,7 +178,7 @@ lltrace_instruction(_PyInterpreterFrame *frame,`
`178`	`178`	`int opcode,`
`179`	`179`	`int oparg)`
`180`	`180`	`{`
`181`		`- if (frame->owner == FRAME_OWNED_BY_CSTACK) {`
	`181`	`+ if (frame->owner >= FRAME_OWNED_BY_INTERPRETER) {`
`182`	`182`	`return;`
`183`	`183`	`}`
`184`	`184`	`dump_stack(frame, stack_pointer);`
`@@ -229,12 +229,12 @@ lltrace_resume_frame(_PyInterpreterFrame *frame)`
`229`	`229`	`}`
`230`	`230`
`231`	`231`	`static int`
`232`		`-maybe_lltrace_resume_frame(_PyInterpreterFrame frame, _PyInterpreterFrame skip_frame, PyObject *globals)`
	`232`	`+maybe_lltrace_resume_frame(_PyInterpreterFrame frame, PyObject globals)`
`233`	`233`	`{`
`234`	`234`	`if (globals == NULL) {`
`235`	`235`	`return 0;`
`236`	`236`	`}`
`237`		`- if (frame == skip_frame) {`
	`237`	`+ if (frame->owner >= FRAME_OWNED_BY_INTERPRETER) {`
`238`	`238`	`return 0;`
`239`	`239`	`}`
`240`	`240`	`int r = PyDict_Contains(globals, &_Py_ID(__lltrace__));`
`@@ -818,7 +818,7 @@ _PyEval_EvalFrameDefault(PyThreadState tstate, _PyInterpreterFrame frame, int`
`818`	`818`	`entry_frame.f_executable = PyStackRef_None;`
`819`	`819`	`entry_frame.instr_ptr = (_Py_CODEUNIT *)_Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS + 1;`
`820`	`820`	`entry_frame.stackpointer = entry_frame.localsplus;`
`821`		`- entry_frame.owner = FRAME_OWNED_BY_CSTACK;`
	`821`	`+ entry_frame.owner = FRAME_OWNED_BY_INTERPRETER;`
`822`	`822`	`entry_frame.visited = 0;`
`823`	`823`	`entry_frame.return_offset = 0;`
`824`	`824`	`/* Push frame */`
`@@ -880,7 +880,7 @@ _PyEval_EvalFrameDefault(PyThreadState tstate, _PyInterpreterFrame frame, int`
`880`	`880`	`stack_pointer = _PyFrame_GetStackPointer(frame);`
`881`	`881`
`882`	`882`	`#ifdef LLTRACE`
`883`		`- lltrace = maybe_lltrace_resume_frame(frame, &entry_frame, GLOBALS());`
	`883`	`+ lltrace = maybe_lltrace_resume_frame(frame, GLOBALS());`
`884`	`884`	`if (lltrace < 0) {`
`885`	`885`	`goto exit_unwind;`
`886`	`886`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1476,7 +1476,7 @@ mark_stacks(PyInterpreterState interp, PyGC_Head visited, int visited_space, b`
`1476`	`1476`	`while (ts) {`
`1477`	`1477`	`_PyInterpreterFrame *frame = ts->current_frame;`
`1478`	`1478`	`while (frame) {`
`1479`		`- if (frame->owner == FRAME_OWNED_BY_CSTACK) {`
	`1479`	`+ if (frame->owner >= FRAME_OWNED_BY_INTERPRETER) {`
`1480`	`1480`	`frame = frame->previous;`
`1481`	`1481`	`continue;`
`1482`	`1482`	`}`