Rename _PyStackRef_StealIfUnborrowed

Author: mpage

Include/internal/pycore_frame.h

@@ -152,23 +152,21 @@ _PyFrame_NumSlotsForCodeObject(PyCodeObject *code)
     return code->co_framesize - FRAME_SPECIALS_SIZE;
 }
 
-static inline void _PyFrame_Copy(_PyInterpreterFrame *src, _PyInterpreterFrame *dest)
+static inline void
+_PyFrame_Copy(_PyInterpreterFrame *src, _PyInterpreterFrame *dest)
 {
     *dest = *src;
     assert(src->stackpointer != NULL);
     int stacktop = (int)(src->stackpointer - src->localsplus);
     assert(stacktop >= _PyFrame_GetCode(src)->co_nlocalsplus);
     dest->stackpointer = dest->localsplus + stacktop;
+    // The generator may outlive any references that were providing "support"
+    // for borrowed references in the frame. Convert them to strong references.
     for (int i = 0; i < stacktop; i++) {
-        dest->localsplus[i] = _PyStackRef_StealIfUnborrowed(src->localsplus[i]);
-    }
-    // XXX - More efficient version of this?
-    if (_PyStackRef_IsBorrowed(dest->f_executable)) {
-        dest->f_executable = PyStackRef_FromPyObjectNew(PyStackRef_AsPyObjectBorrow(dest->f_executable));
-    }
-    if (_PyStackRef_IsBorrowed(dest->f_funcobj)) {
-        dest->f_funcobj = PyStackRef_FromPyObjectNew(PyStackRef_AsPyObjectBorrow(dest->f_funcobj));
+        dest->localsplus[i] = _PyStackRef_NewIfBorrowedOrSteal(src->localsplus[i]);
     }
+    dest->f_executable = _PyStackRef_NewIfBorrowedOrSteal(dest->f_executable);
+    dest->f_funcobj = _PyStackRef_NewIfBorrowedOrSteal(dest->f_funcobj);
     // Don't leave a dangling pointer to the old frame when creating generators
     // and coroutines:
     dest->previous = NULL;

Include/internal/pycore_stackref.h

@@ -213,24 +213,6 @@ _PyStackRef_FromPyObjectSteal(PyObject *obj)
 }
 #   define PyStackRef_FromPyObjectSteal(obj) _PyStackRef_FromPyObjectSteal(_PyObject_CAST(obj))
 
-static inline _PyStackRef
-_PyStackRef_StealIfUnborrowed(_PyStackRef stackref)
-{
-    if (PyStackRef_IsNull(stackref)) {
-        return stackref;
-    }
-    if (PyStackRef_IsDeferred(stackref)) {
-        PyObject *obj = PyStackRef_AsPyObjectBorrow(stackref);
-        if (_Py_IsImmortal(obj) || _PyObject_HasDeferredRefcount(obj)) {
-            return stackref;
-        }
-        else {
-            return (_PyStackRef){ .bits = (uintptr_t)(Py_NewRef(obj)) | Py_TAG_PTR };
-        }
-    }
-    return stackref;
-}
-
 static inline bool
 _PyStackRef_IsBorrowed(_PyStackRef stackref)
 {
@@ -241,6 +223,17 @@ _PyStackRef_IsBorrowed(_PyStackRef stackref)
     return !(_Py_IsImmortal(obj) || _PyObject_HasDeferredRefcount(obj));
 }
 
+
+static inline _PyStackRef
+_PyStackRef_NewIfBorrowedOrSteal(_PyStackRef stackref)
+{
+    if (_PyStackRef_IsBorrowed(stackref)) {
+        PyObject *obj = PyStackRef_AsPyObjectBorrow(stackref);
+        return (_PyStackRef){ .bits = (uintptr_t)(Py_NewRef(obj)) | Py_TAG_PTR };
+    }
+    return stackref;
+}
+
 static inline _PyStackRef
 PyStackRef_FromPyObjectNew(PyObject *obj)
 {

Python/bytecodes.c

@@ -1103,7 +1103,7 @@ dummy_func(
         // is pushed to a different frame, the callers' frame.
         inst(RETURN_VALUE, (retval -- res)) {
             assert(frame->owner != FRAME_OWNED_BY_INTERPRETER);
-            _PyStackRef temp = _PyStackRef_StealIfUnborrowed(retval);
+            _PyStackRef temp = _PyStackRef_NewIfBorrowedOrSteal(retval);
             DEAD(retval);
             SAVE_STACK();
             assert(EMPTY());
@@ -1201,7 +1201,7 @@ dummy_func(
 
             PyObject *retval_o;
             assert(frame->owner != FRAME_OWNED_BY_INTERPRETER);
-            _PyStackRef tmp = _PyStackRef_StealIfUnborrowed(v);
+            _PyStackRef tmp = _PyStackRef_NewIfBorrowedOrSteal(v);
             DEAD(v);
             if ((tstate->interp->eval_frame == NULL) &&
                 (Py_TYPE(receiver_o) == &PyGen_Type || Py_TYPE(receiver_o) == &PyCoro_Type) &&
@@ -1255,7 +1255,7 @@ dummy_func(
             DEOPT_IF(gen->gi_frame_state >= FRAME_EXECUTING);
             STAT_INC(SEND, hit);
             gen_frame = &gen->gi_iframe;
-            _PyFrame_StackPush(gen_frame, _PyStackRef_StealIfUnborrowed(v));
+            _PyFrame_StackPush(gen_frame, _PyStackRef_NewIfBorrowedOrSteal(v));
             DEAD(v);
             gen->gi_frame_state = FRAME_EXECUTING;
             gen->gi_exc_state.previous_item = tstate->exc_info;
@@ -1302,7 +1302,7 @@ dummy_func(
             #endif
             RELOAD_STACK();
             LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND);
-            value = _PyStackRef_StealIfUnborrowed(temp);
+            value = _PyStackRef_NewIfBorrowedOrSteal(temp);
             LLTRACE_RESUME_FRAME();
         }
 

Python/executor_cases.c.h

@@ -57,15 +57,12 @@ take_ownership(PyFrameObject *f, _PyInterpreterFrame *frame)
     frame->f_executable = PyStackRef_DUP(frame->f_executable);
     int stacktop = (int)(frame->stackpointer - frame->localsplus);
     assert(stacktop >= _PyFrame_GetCode(frame)->co_nlocalsplus);
-    // XXX - Maybe more optimal sequence to do here
-    if (_PyStackRef_IsBorrowed(frame->f_executable)) {
-        frame->f_executable = PyStackRef_FromPyObjectNew(PyStackRef_AsPyObjectBorrow(frame->f_executable));
-    }
-    if (_PyStackRef_IsBorrowed(frame->f_funcobj)) {
-        frame->f_funcobj = PyStackRef_FromPyObjectNew(PyStackRef_AsPyObjectBorrow(frame->f_funcobj));
-    }
+    // The frame object may outlive any references that were providing "support"
+    // for borrowed references in the frame. Convert them to strong references.
+    frame->f_executable = _PyStackRef_NewIfBorrowedOrSteal(frame->f_executable);
+    frame->f_funcobj = _PyStackRef_NewIfBorrowedOrSteal(frame->f_funcobj);
     for (int i = 0; i < stacktop; i++) {
-        frame->localsplus[i] = _PyStackRef_StealIfUnborrowed(frame->localsplus[i]);
+        frame->localsplus[i] = _PyStackRef_NewIfBorrowedOrSteal(frame->localsplus[i]);
     }
     f->f_frame = frame;
     frame->owner = FRAME_OWNED_BY_FRAME_OBJECT;

Python/frame.c

@@ -591,7 +591,6 @@ def has_error_without_pop(op: parser.CodeDef) -> bool:
     "PyStackRef_CLEAR",
     "PyStackRef_CLOSE_SPECIALIZED",
     "PyStackRef_DUP",
-    "_PyStackRef_StealIfUnborrowed",
     "PyStackRef_False",
     "PyStackRef_FromPyObjectImmortal",
     "PyStackRef_FromPyObjectNew",
@@ -649,6 +648,7 @@ def has_error_without_pop(op: parser.CodeDef) -> bool:
     "_PyObject_GetManagedDict",
     "_PyObject_InlineValues",
     "_PyObject_ManagedDictPointer",
+    "_PyStackRef_NewIfBorrowedOrSteal",
     "_PyThreadState_HasStackSpace",
     "_PyTuple_FromStackRefStealOnSuccess",
     "_PyTuple_ITEMS",