generators borrowed reference code objects

Author: brijkapadia

Include/internal/pycore_interpframe.h

@@ -159,15 +159,6 @@ static inline void _PyFrame_Copy(_PyInterpreterFrame *src, _PyInterpreterFrame *
     }
 }
 
-/* Generator frames need a strong reference to the code object */
-static inline void
-_PyFrame_CopyForGenerators(_PyInterpreterFrame *old_frame, _PyInterpreterFrame *gen_frame)
-{
-    _PyFrame_Copy(old_frame, gen_frame);
-    gen_frame->owner = FRAME_OWNED_BY_GENERATOR;
-    Py_INCREF(gen_frame->f_executable);
-}
-
 #ifdef Py_GIL_DISABLED
 static inline void
 _PyFrame_InitializeTLBC(PyThreadState *tstate, _PyInterpreterFrame *frame,

Include/internal/pycore_interpframe_structs.h

@@ -27,9 +27,7 @@ enum _frameowner {
 };
 
 struct _PyInterpreterFrame {
-    /* Borrowed reference (code object or None) */
-    /* Strong reference for generators */
-    PyObject *f_executable;
+    PyObject *f_executable; /* Borrowed reference (code object or None) */
     struct _PyInterpreterFrame *previous;
     _PyStackRef f_funcobj; /* Deferred or strong reference. Only valid if not on C stack */
     PyObject *f_globals; /* Borrowed reference. Only valid if not on C stack */

Misc/NEWS.d/next/Core_and_Builtins/2026-07-04-17-04-03.gh-issue-152666.Vo5wJv.rst

@@ -1,3 +1,2 @@
 Avoid reference counting of :class:`code` objects when creating and destroying
 frames by having functions retain a list of all past :class:`code` objects.
-

Modules/_testinternalcapi/test_cases.c.h

@@ -94,9 +94,9 @@ gen_traverse(PyObject *self, visitproc visit, void *arg)
         }
     }
     else {
-        // We still need to visit the code object when the frame is cleared to
+        // We still need to visit the function object when the frame is cleared to
         // ensure that it's kept alive if the reference is deferred.
-        Py_VISIT(gen->gi_iframe.f_executable);
+        _Py_VISIT_STACKREF(gen->gi_iframe.f_funcobj);
     }
     /* No need to visit cr_origin, because it's just tuples/str/int, so can't
        participate in a reference cycle. */
@@ -231,7 +231,7 @@ gen_dealloc(PyObject *self)
         gen_clear_frame(gen);
     }
     assert(gen->gi_exc_state.exc_value == NULL);
-    Py_CLEAR(gen->gi_iframe.f_executable);
+    gen->gi_iframe.f_executable = NULL;
     Py_CLEAR(gen->gi_name);
     Py_CLEAR(gen->gi_qualname);
 
@@ -1176,10 +1176,11 @@ gen_new_with_qualname(PyTypeObject *type, PyFrameObject *f,
     assert(f->f_frame->frame_obj == NULL);
     assert(f->f_frame->owner == FRAME_OWNED_BY_FRAME_OBJECT);
     _PyInterpreterFrame *frame = &gen->gi_iframe;
-    _PyFrame_CopyForGenerators((_PyInterpreterFrame *)f->_f_frame_data, frame);
+    _PyFrame_Copy((_PyInterpreterFrame *)f->_f_frame_data, frame);
     gen->gi_frame_state = FRAME_CREATED;
     assert(frame->frame_obj == f);
     f->f_frame = frame;
+    frame->owner = FRAME_OWNED_BY_GENERATOR;
     assert(PyObject_GC_IsTracked((PyObject *)f));
     Py_DECREF(f);
     gen->gi_weakreflist = NULL;

Objects/genobject.c

@@ -5854,9 +5854,10 @@ dummy_func(
             SAVE_STACK();
             _PyInterpreterFrame *gen_frame = &gen->gi_iframe;
             frame->instr_ptr++;
-            _PyFrame_CopyForGenerators(frame, gen_frame);
+            _PyFrame_Copy(frame, gen_frame);
             assert(frame->frame_obj == NULL);
             gen->gi_frame_state = FRAME_CREATED;
+            gen_frame->owner = FRAME_OWNED_BY_GENERATOR;
             _Py_LeaveRecursiveCallPy(tstate);
             _PyInterpreterFrame *prev = frame->previous;
             _PyThreadState_UpdateLastProfiledFrame(tstate, frame, prev);

Python/bytecodes.c

@@ -1997,6 +1997,9 @@ clear_gen_frame(PyThreadState *tstate, _PyInterpreterFrame * frame)
     gen->gi_exc_state.previous_item = NULL;
     assert(frame->frame_obj == NULL || frame->frame_obj->f_frame == frame);
     frame->previous = NULL;
+    if (PyGen_Check(gen)) {
+        frame->f_funcobj = PyStackRef_DUP(frame->f_funcobj);
+    }
     _PyFrame_ClearExceptCode(frame);
     _PyErr_ClearExcState(&gen->gi_exc_state);
     // gh-143939: There must not be any escaping calls between setting

Python/ceval.c

@@ -51,8 +51,6 @@ take_ownership(PyFrameObject *f, _PyInterpreterFrame *frame)
     assert(frame->owner != FRAME_OWNED_BY_FRAME_OBJECT);
     _PyInterpreterFrame *new_frame = (_PyInterpreterFrame *)f->_f_frame_data;
     _PyFrame_Copy(frame, new_frame);
-    // _PyFrame_Copy takes the reference to the executable,
-    // so we need to restore it.
     f->f_frame = new_frame;
     new_frame->owner = FRAME_OWNED_BY_FRAME_OBJECT;
     if (_PyFrame_IsIncomplete(new_frame)) {