Apr 6, 2025 · Apr 16, 2025 · Apr 16, 2025 · Apr 17, 2025 · Apr 18, 2025 · Apr 18, 2025
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
   This returns a strong reference, and might set an exception.
   'error' is set to: -1: error with exception; 0: ok */
 static PyObject *
 find_name_in_mro_new(PyTypeObject *type,PyObject *mro_dict, PyObject *name, int *error)
 find_name_in_mro_new(PyObject *mro_dict, PyObject *name, int *error)
 {
 ASSERT_WORLD_STOPPED_OR_NEW_TYPE(type);
 ASSERT_TYPE_LOCK_HELD();

    PyObject *res = NULL;
    if (PyDict_GetItemRef(mro_dict, name, &res) < 0) {
 static PyObject *
 update_cache(struct type_cache_entry *entry, PyObject *name, unsigned int version_tag, PyObject *value)
 {
    _Py_atomic_store_uint32_relaxed(&entry->version, version_tag);
    _Py_atomic_store_ptr_relaxed(&entry->value, value); /* borrowed */
    assert(_PyASCIIObject_CAST(name)->hash != -1);
    OBJECT_STAT_INC_COND(type_cache_collisions, entry->name != Py_None && entry->name != name);
    // We're releasing this under the lock for simplicity sake because it's always a
    // exact unicode object or Py_None so it's safe to do so.
    PyObject *old_name = entry->name;
    _Py_atomic_store_ptr_relaxed(&entry->name, Py_NewRef(name));
    // We must write the version last to avoid _Py_TryXGetStackRef()
    // operating on an invalid (already deallocated) value inside
    // _PyType_LookupRefAndVersion().  If we write the version first then a
    // reader could pass the "entry_version == type_version" check but could
    // be using the old entry value.
    _Py_atomic_store_uint32_release(&entry->version, version_tag);
    return old_name;
 }

    // synchronize-with other writing threads by doing an acquire load on the sequence
    while (1) {
        uint32_t sequence = _PySeqLock_BeginRead(&entry->sequence);
        uint32_t entry_version =_Py_atomic_load_uint32_acquire(&entry->version);
        uint32_t entry_version =_Py_atomic_load_uint32_relaxed(&entry->version);
        uint32_t type_version = _Py_atomic_load_uint32_acquire(&type->tp_version_tag);
        if (entry_version == type_version &&
            _Py_atomic_load_ptr_relaxed(&entry->name) == name) {
    int has_version = 0;
    unsigned int assigned_version = 0;
    BEGIN_TYPE_LOCK();
    // We must assign the version before doing the lookup.  If
    // find_name_in_mro() blocks and releases the critical section
    // then the type version can change.
    res = find_name_in_mro(type, name, &error);
    if (MCACHE_CACHEABLE_NAME(name)) {
        has_version = assign_version_tag(interp, type);
        assigned_version = type->tp_version_tag;
    }
    res = find_name_in_mro(type, name, &error);
    END_TYPE_LOCK();

    /* Only put NULL results into cache if there was no error. */
        if (mro_dict == NULL) {
            descr = find_name_in_mro(type, p->name_strobj, &error);
        } else {
            descr = find_name_in_mro_new(type,mro_dict, p->name_strobj, &error);
            descr = find_name_in_mro_new(mro_dict, p->name_strobj, &error);
        }
        if (descr == NULL) {
            if (error == -1) {
 static int
 fixup_slot_dispatchers(PyTypeObject *type)
 {
    ASSERT_WORLD_STOPPED_OR_NEW_TYPE(type);

    int res = 0;

    // This lock isn't strictly necessary because the type has not been
    // exposed to anyone else yet, but update_ont_slot calls find_name_in_mro
    // where we'd like to assert that the type is locked.
    BEGIN_TYPE_LOCK();

    PyObject *mro = Py_NewRef(lookup_tp_mro(type));

    // Build MRO dict. We build it in bottom-top manner,
 finish:
    Py_XDECREF(mro_dict);
    Py_DECREF(mro);

    END_TYPE_LOCK();
    return res;
 }
Original file line number	Diff line number	Diff line change
Expand Up		@@ -5663,9 +5663,9 @@ find_name_in_mro(PyTypeObject type, PyObject name, int *error)
		This returns a strong reference, and might set an exception.
		'error' is set to: -1: error with exception; 0: ok */
		static PyObject *
		find_name_in_mro_new(PyTypeObject type,PyObject mro_dict, PyObject name, int error)
		find_name_in_mro_new(PyObject mro_dict, PyObject name, int *error)
		{
		ASSERT_WORLD_STOPPED_OR_NEW_TYPE(type);
		ASSERT_TYPE_LOCK_HELD();

		PyObject *res = NULL;
		if (PyDict_GetItemRef(mro_dict, name, &res) < 0) {
Expand DownExpand Up		@@ -5697,19 +5697,14 @@ is_dunder_name(PyObject *name)
		static PyObject *
		update_cache(struct type_cache_entry entry, PyObject name, unsigned int version_tag, PyObject *value)
		{
		_Py_atomic_store_uint32_relaxed(&entry->version, version_tag);
		_Py_atomic_store_ptr_relaxed(&entry->value, value); /* borrowed */
		assert(_PyASCIIObject_CAST(name)->hash != -1);
		OBJECT_STAT_INC_COND(type_cache_collisions, entry->name != Py_None && entry->name != name);
		// We're releasing this under the lock for simplicity sake because it's always a
		// exact unicode object or Py_None so it's safe to do so.
		PyObject *old_name = entry->name;
		_Py_atomic_store_ptr_relaxed(&entry->name, Py_NewRef(name));
		// We must write the version last to avoid _Py_TryXGetStackRef()
		// operating on an invalid (already deallocated) value inside
		// _PyType_LookupRefAndVersion(). If we write the version first then a
		// reader could pass the "entry_version == type_version" check but could
		// be using the old entry value.
		_Py_atomic_store_uint32_release(&entry->version, version_tag);
		return old_name;
		}

Expand DownExpand Up		@@ -5786,7 +5781,7 @@ _PyType_LookupStackRefAndVersion(PyTypeObject type, PyObject name, _PyStackRef
		// synchronize-with other writing threads by doing an acquire load on the sequence
		while (1) {
		uint32_t sequence = _PySeqLock_BeginRead(&entry->sequence);
		uint32_t entry_version =_Py_atomic_load_uint32_acquire(&entry->version);
		uint32_t entry_version =_Py_atomic_load_uint32_relaxed(&entry->version);
		uint32_t type_version = _Py_atomic_load_uint32_acquire(&type->tp_version_tag);
		if (entry_version == type_version &&
		_Py_atomic_load_ptr_relaxed(&entry->name) == name) {
Expand DownExpand Up		@@ -5833,14 +5828,11 @@ _PyType_LookupStackRefAndVersion(PyTypeObject type, PyObject name, _PyStackRef
		int has_version = 0;
		unsigned int assigned_version = 0;
		BEGIN_TYPE_LOCK();
		// We must assign the version before doing the lookup. If
		// find_name_in_mro() blocks and releases the critical section
		// then the type version can change.
		res = find_name_in_mro(type, name, &error);
		if (MCACHE_CACHEABLE_NAME(name)) {
		has_version = assign_version_tag(interp, type);
		assigned_version = type->tp_version_tag;
		}
		res = find_name_in_mro(type, name, &error);
		END_TYPE_LOCK();

		/* Only put NULL results into cache if there was no error. */
Expand DownExpand Up		@@ -11203,7 +11195,7 @@ update_one_slot(PyTypeObject type, pytype_slotdef p, PyObject *mro_dict)
		if (mro_dict == NULL) {
		descr = find_name_in_mro(type, p->name_strobj, &error);
		} else {
		descr = find_name_in_mro_new(type,mro_dict, p->name_strobj, &error);
		descr = find_name_in_mro_new(mro_dict, p->name_strobj, &error);
		}
		if (descr == NULL) {
		if (error == -1) {
Expand DownExpand Up		@@ -11350,10 +11342,13 @@ update_slot(PyTypeObject type, PyObject name)
		static int
		fixup_slot_dispatchers(PyTypeObject *type)
		{
		ASSERT_WORLD_STOPPED_OR_NEW_TYPE(type);

		int res = 0;

		// This lock isn't strictly necessary because the type has not been
		// exposed to anyone else yet, but update_ont_slot calls find_name_in_mro
		// where we'd like to assert that the type is locked.
		BEGIN_TYPE_LOCK();

		PyObject *mro = Py_NewRef(lookup_tp_mro(type));

		// Build MRO dict. We build it in bottom-top manner,
Expand DownExpand Up		@@ -11394,6 +11389,8 @@ fixup_slot_dispatchers(PyTypeObject *type)
		finish:
		Py_XDECREF(mro_dict);
		Py_DECREF(mro);

		END_TYPE_LOCK();
		return res;
		}

Expand Down