gh-121459: Deferred LOAD_ATTR (methods)

Include/internal/pycore_dict.h

@@ -121,7 +121,9 @@ PyAPI_FUNC(int) _PyDict_SetItem_KnownHash_LockHeld(PyDictObject *mp, PyObject *k
 PyAPI_FUNC(int) _PyDict_GetItemRef_KnownHash_LockHeld(PyDictObject *op, PyObject *key, Py_hash_t hash, PyObject **result);
 extern int _PyDict_GetItemRef_KnownHash(PyDictObject *op, PyObject *key, Py_hash_t hash, PyObject **result);
 extern int _PyDict_GetItemRef_Unicode_LockHeld(PyDictObject *op, PyObject *key, PyObject **result);
+extern int _PyDict_GetItemStackRef_KnownHash(PyDictObject *op, PyObject *key, Py_hash_t hash, _PyStackRef *result);
 extern int _PyObjectDict_SetItem(PyTypeObject *tp, PyObject *obj, PyObject **dictptr, PyObject *name, PyObject *value);
+extern int _PyDict_GetItemStackRef(PyObject *op, PyObject *key, _PyStackRef *result);
 
 extern int _PyDict_Pop_KnownHash(
     PyDictObject *dict,

Include/internal/pycore_object.h

@@ -623,6 +623,24 @@ _Py_TryXGetRef(PyObject **ptr)
     return NULL;
 }
 
+// This belongs here rather than pycore_stackref.h because including pycore_object.h
+// there causes a circular include.
+static inline _PyStackRef
+_Py_TryXGetStackRef(PyObject **ptr)
+{
+    PyObject *value = _Py_atomic_load_ptr(ptr);
+    if (value == NULL) {
+        return PyStackRef_NULL;
+    }
+    if (_Py_IsImmortal(value) || _PyObject_HasDeferredRefcount(value)) {
+        return (_PyStackRef){ .bits = (uintptr_t)value | Py_TAG_DEFERRED };
+    }
+    if (_Py_TryIncrefCompare(ptr, value)) {
+        return PyStackRef_FromPyObjectSteal(value);
+    }
+    return PyStackRef_NULL;
+}
+
 /* Like Py_NewRef but also optimistically sets _Py_REF_MAYBE_WEAKREF
    on objects owned by a different thread. */
 static inline PyObject *
@@ -816,7 +834,8 @@ extern int _PyObject_StoreInstanceAttribute(PyObject *obj,
                                             PyObject *name, PyObject *value);
 extern bool _PyObject_TryGetInstanceAttribute(PyObject *obj, PyObject *name,
                                               PyObject **attr);
-
+extern bool _PyObject_TryGetInstanceAttributeStackRef(PyObject *obj, PyObject *name,
+                                              _PyStackRef *attr);
 #ifdef Py_GIL_DISABLED
 #  define MANAGED_DICT_OFFSET    (((Py_ssize_t)sizeof(PyObject *))*-1)
 #  define MANAGED_WEAKREF_OFFSET (((Py_ssize_t)sizeof(PyObject *))*-2)
@@ -863,6 +882,7 @@ PyAPI_FUNC(PyObject*) _PyObject_LookupSpecialMethod(PyObject *self, PyObject *at
 extern int _PyObject_IsAbstract(PyObject *);
 
 PyAPI_FUNC(int) _PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method);
+PyAPI_FUNC(int) _PyObject_GetMethodStackRef(PyObject *obj, PyObject *name, _PyStackRef *method, _PyStackRef *spare);
 extern PyObject* _PyObject_NextNotImplemented(PyObject *);
 
 // Pickle support.
@@ -900,6 +920,8 @@ PyAPI_DATA(int) _Py_SwappedOp[];
 
 extern void _Py_GetConstant_Init(void);
 
+extern void _PyType_LookupStackRef(PyTypeObject *type, PyObject *name, _PyStackRef *result);
+
 #ifdef __cplusplus
 }
 #endif

Objects/dictobject.c

@@ -2336,6 +2336,21 @@ _PyDict_GetItemRef_KnownHash(PyDictObject *op, PyObject *key, Py_hash_t hash, Py
     return 1;  // key is present
 }
 
+int
+_PyDict_GetItemStackRef_KnownHash(PyDictObject *op, PyObject *key, Py_hash_t hash, _PyStackRef *result)
+{
+    Py_ssize_t ix = _Py_dict_lookup_threadsafe_stackref(op, key, hash, result);
+    assert(ix >= 0 || PyStackRef_IsNull(*result));
+    if (ix == DKIX_ERROR) {
+        *result = PyStackRef_NULL;
+        return -1;
+    }
+    if (PyStackRef_IsNull(*result)) {
+        return 0;  // missing key
+    }
+    return 1;  // key is present
+}
+
 int
 PyDict_GetItemRef(PyObject *op, PyObject *key, PyObject **result)
 {
@@ -2354,6 +2369,24 @@ PyDict_GetItemRef(PyObject *op, PyObject *key, PyObject **result)
     return _PyDict_GetItemRef_KnownHash((PyDictObject *)op, key, hash, result);
 }
 
+int
+_PyDict_GetItemStackRef(PyObject *op, PyObject *key, _PyStackRef *result)
+{
+    if (!PyDict_Check(op)) {
+        PyErr_BadInternalCall();
+        *result = PyStackRef_NULL;
+        return -1;
+    }
+
+    Py_hash_t hash = _PyObject_HashFast(key);
+    if (hash == -1) {
+        *result = PyStackRef_NULL;
+        return -1;
+    }
+
+    return _PyDict_GetItemStackRef_KnownHash((PyDictObject *)op, key, hash, result);
+}
+
 int
 _PyDict_GetItemRef_Unicode_LockHeld(PyDictObject *op, PyObject *key, PyObject **result)
 {
@@ -7097,6 +7130,81 @@ _PyObject_TryGetInstanceAttribute(PyObject *obj, PyObject *name, PyObject **attr
 #endif
 }
 
+bool
+_PyObject_TryGetInstanceAttributeStackRef(PyObject *obj, PyObject *name, _PyStackRef *attr)
+{
+    assert(PyUnicode_CheckExact(name));
+    PyDictValues *values = _PyObject_InlineValues(obj);
+    if (!FT_ATOMIC_LOAD_UINT8(values->valid)) {
+        return false;
+    }
+
+    PyDictKeysObject *keys = CACHED_KEYS(Py_TYPE(obj));
+    assert(keys != NULL);
+    Py_ssize_t ix = _PyDictKeys_StringLookup(keys, name);
+    if (ix == DKIX_EMPTY) {
+        *attr = PyStackRef_NULL;
+        return true;
+    }
+
+#ifdef Py_GIL_DISABLED
+    *attr = _Py_TryXGetStackRef(&values->values[ix]);
+    if (PyStackRef_AsPyObjectBorrow(*attr) == _Py_atomic_load_ptr_acquire(&values->values[ix])) {
+        return true;
+    }
+
+    PyDictObject *dict = _PyObject_GetManagedDict(obj);
+    if (dict == NULL) {
+        // No dict, lock the object to prevent one from being
+        // materialized...
+        bool success = false;
+        Py_BEGIN_CRITICAL_SECTION(obj);
+
+        dict = _PyObject_GetManagedDict(obj);
+        if (dict == NULL) {
+            // Still no dict, we can read from the values
+            assert(values->valid);
+            *attr = _Py_TryXGetStackRef(&values->values[ix]);
+            success = true;
+        }
+
+        Py_END_CRITICAL_SECTION();
+
+        if (success) {
+            return true;
+        }
+    }
+
+    // We have a dictionary, we'll need to lock it to prevent
+    // the values from being resized.
+    assert(dict != NULL);
+
+    bool success;
+    Py_BEGIN_CRITICAL_SECTION(dict);
+
+    if (dict->ma_values == values && FT_ATOMIC_LOAD_UINT8(values->valid)) {
+        *attr = _Py_TryXGetStackRef(&values->values[ix]);
+        success = true;
+    } else {
+        // Caller needs to lookup from the dictionary
+        success = false;
+    }
+
+    Py_END_CRITICAL_SECTION();
+
+    return success;
+#else
+    PyObject *value = values->values[ix];
+    if (value != NULL) {
+        *attr = PyStackRef_FromPyObjectNew(value);
+    }
+    else {
+        *attr = PyStackRef_NULL;
+    }
+    return true;
+#endif
+}
+
 int
 _PyObject_IsInstanceDictEmpty(PyObject *obj)
 {

Objects/object.c

@@ -1620,6 +1620,129 @@ _PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method)
     return 0;
 }
 
+int
+_PyObject_GetMethodStackRef(PyObject *obj, PyObject *name, _PyStackRef *method, _PyStackRef *spare)
+{
+#ifdef Py_GIL_DISABLED
+    int meth_found = 0;
+
+    assert(PyStackRef_IsNull(*method));
+
+    PyTypeObject *tp = Py_TYPE(obj);
+    if (!_PyType_IsReady(tp)) {
+        if (PyType_Ready(tp) < 0) {
+            return 0;
+        }
+    }
+
+    if (tp->tp_getattro != PyObject_GenericGetAttr || !PyUnicode_CheckExact(name)) {
+        PyObject *attr_o = PyObject_GetAttr(obj, name);
+        if (attr_o != NULL) {
+            *method = PyStackRef_FromPyObjectSteal(attr_o);
+        }
+        else {
+            *method = PyStackRef_NULL;
+        }
+        return 0;
+    }
+
+    _PyType_LookupStackRef(tp, name, method);
+    *spare = *method;
+    _PyStackRef descr_st = *method;
+    descrgetfunc f = NULL;
+    if (!PyStackRef_IsNull(descr_st)) {
+        if (_PyType_HasFeature(PyStackRef_TYPE(descr_st), Py_TPFLAGS_METHOD_DESCRIPTOR)) {
+            meth_found = 1;
+        } else {
+            f = PyStackRef_TYPE(descr_st)->tp_descr_get;
+            if (f != NULL && PyDescr_IsData(PyStackRef_AsPyObjectBorrow(descr_st))) {
+                PyObject *call_res_o = f(PyStackRef_AsPyObjectBorrow(descr_st), obj, (PyObject *)Py_TYPE(obj));
+                if (call_res_o != NULL) {
+                    *method = PyStackRef_FromPyObjectSteal(call_res_o);
+                }
+                else {
+                    *method = PyStackRef_NULL;
+                }
+                PyStackRef_CLOSE(descr_st);
+                return 0;
+            }
+        }
+    }
+    PyObject *dict;
+    if ((tp->tp_flags & Py_TPFLAGS_INLINE_VALUES) &&
+        _PyObject_TryGetInstanceAttributeStackRef(obj, name, method)) {
+        if (!PyStackRef_IsNull(*method)) {
+            PyStackRef_XCLOSE(descr_st);
+            return 0;
+        }
+        dict = NULL;
+    }
+    else if ((tp->tp_flags & Py_TPFLAGS_MANAGED_DICT)) {
+        dict = (PyObject *)_PyObject_GetManagedDict(obj);
+    }
+    else {
+        PyObject **dictptr = _PyObject_ComputedDictPointer(obj);
+        if (dictptr != NULL) {
+            dict = *dictptr;
+        }
+        else {
+            dict = NULL;
+        }
+    }
+    if (dict != NULL) {
+        Py_INCREF(dict);
+        if (_PyDict_GetItemStackRef(dict, name, method) != 0) {
+            // found or error
+            Py_DECREF(dict);
+            PyStackRef_CLOSE(descr_st);
+            return 0;
+        }
+        // not found
+        Py_DECREF(dict);
+    }
+
+    if (meth_found) {
+        *method = descr_st;
+        return 1;
+    }
+
+    if (f != NULL) {
+        PyObject *call_res_o = f(PyStackRef_AsPyObjectBorrow(descr_st), obj, (PyObject *)Py_TYPE(obj));
+        if (call_res_o != NULL) {
+            *method = PyStackRef_FromPyObjectSteal(call_res_o);
+        }
+        else {
+            *method = PyStackRef_NULL;
+        }
+        PyStackRef_CLOSE(descr_st);
+        return 0;
+    }
+
+    if (!PyStackRef_IsNull(descr_st)) {
+        *method = descr_st;
+        return 0;
+    }
+
+    *method = PyStackRef_NULL;
+    PyErr_Format(PyExc_AttributeError,
+                 "'%.100s' object has no attribute '%U'",
+                 tp->tp_name, name);
+
+    _PyObject_SetAttributeErrorContext(obj, name);
+    return 0;
+#else
+    PyObject *res = NULL;
+    int err = _PyObject_GetMethod(obj, name, &res);
+    if (res == NULL) {
+        *method = PyStackRef_NULL;
+    }
+    else {
+        *method = PyStackRef_FromPyObjectSteal(res);
+    }
+    return err;
+#endif
+}
+
 /* Generic GetAttr functions - put these in your tp_[gs]etattro slot. */
 
 PyObject *