Support Py_TPFLAGS_MANAGED_DICT without gc

Author: sergey-miryanov

Include/internal/pycore_object.h

@@ -936,10 +936,12 @@ extern int _PyType_CacheInitForSpecialization(PyHeapTypeObject *type,
 #ifdef Py_GIL_DISABLED
 #  define MANAGED_DICT_OFFSET    (((Py_ssize_t)sizeof(PyObject *))*-1)
 #  define MANAGED_WEAKREF_OFFSET (((Py_ssize_t)sizeof(PyObject *))*-2)
+#  define MANAGED_DICT_OFFSET_NO_GC    (((Py_ssize_t)sizeof(PyObject *))*-1)
 #  define MANAGED_WEAKREF_OFFSET_NO_GC (((Py_ssize_t)sizeof(PyObject *))*-2)
 #else
 #  define MANAGED_DICT_OFFSET    (((Py_ssize_t)sizeof(PyObject *))*-3)
 #  define MANAGED_WEAKREF_OFFSET (((Py_ssize_t)sizeof(PyObject *))*-4)
+#  define MANAGED_DICT_OFFSET_NO_GC    (((Py_ssize_t)sizeof(PyObject *))*-1)
 #  define MANAGED_WEAKREF_OFFSET_NO_GC (((Py_ssize_t)sizeof(PyObject *))*-2)
 #endif
 
@@ -950,8 +952,13 @@ typedef union {
 static inline PyManagedDictPointer *
 _PyObject_ManagedDictPointer(PyObject *obj)
 {
-    assert(Py_TYPE(obj)->tp_flags & Py_TPFLAGS_MANAGED_DICT);
-    return (PyManagedDictPointer *)((char *)obj + MANAGED_DICT_OFFSET);
+    PyTypeObject *type = Py_TYPE(obj);
+    assert(type->tp_flags & Py_TPFLAGS_MANAGED_DICT);
+    Py_ssize_t offset = MANAGED_DICT_OFFSET;
+    if (!_PyType_IS_GC(type)) {
+        offset = MANAGED_DICT_OFFSET_NO_GC;
+    }
+    return (PyManagedDictPointer *)((char *)obj + offset);
 }
 
 static inline PyDictObject *

Lib/test/test_capi/test_type.py

@@ -276,10 +276,15 @@ def test_extension_managed_dict_type(self):
         self.assertEqual(obj.__dict__, {'bar': 3})
         self.assertEqual(obj.bar, 3)
 
-    def test_type_have_weakref_and_no_gc(self):
+    def test_type_have_managed_weakref_and_no_gc(self):
         ManagedWeakrefNoGCType = _testcapi.ManagedWeakrefNoGCType
         obj = ManagedWeakrefNoGCType()
         wr = weakref.ref(obj)
 
         del obj # shouldn't segfault
         del wr
+
+    def test_type_have_managed_dict_and_no_gc(self):
+        ManagedDictNoGCType = _testcapi.ManagedDictNoGCType
+        obj = ManagedDictNoGCType()
+        del obj # shouldn't segfault

Modules/_testcapimodule.c

@@ -3252,6 +3252,30 @@ static PyType_Spec ManagedWeakrefNoGC_spec = {
     .slots = ManagedWeakrefNoGC_slots,
 };
 
+typedef struct {
+    PyObject_HEAD
+} ManagedDictNoGCObject;
+
+static void
+ManagedDictNoGC_dealloc(PyObject *self)
+{
+    PyTypeObject *tp = Py_TYPE(self);
+    tp->tp_free(self);
+    Py_DECREF(tp);
+}
+
+static PyType_Slot ManagedDictNoGC_slots[] = {
+    {Py_tp_dealloc, ManagedDictNoGC_dealloc},
+    {0, 0}
+};
+
+static PyType_Spec ManagedDictNoGC_spec = {
+    .name = "_testcapi.ManagedDictNoGCType",
+    .basicsize = sizeof(ManagedDictNoGCObject),
+    .flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_MANAGED_DICT),
+    .slots = ManagedDictNoGC_slots,
+};
+
 
 static PyObject *
 create_managed_dict_type(void)
@@ -3265,6 +3289,12 @@ create_managed_weakref_no_gc_type(void)
    return PyType_FromSpec(&ManagedWeakrefNoGC_spec);
 }
 
+static PyObject *
+create_managed_dict_no_gc_type(void)
+{
+   return PyType_FromSpec(&ManagedDictNoGC_spec);
+}
+
 static int
 _testcapi_exec(PyObject *m)
 {
@@ -3402,6 +3432,13 @@ _testcapi_exec(PyObject *m)
         return -1;
     }
 
+    PyObject *managed_dict_no_gc_type = create_managed_dict_no_gc_type();
+    if (managed_dict_no_gc_type == NULL) {
+        return -1;
+    }
+    if (PyModule_Add(m, "ManagedDictNoGCType", managed_dict_no_gc_type) < 0) {
+        return -1;
+    }
 
     /* Include tests from the _testcapi/ directory */
     if (_PyTestCapi_Init_Vectorcall(m) < 0) {

Python/bytecodes.c

@@ -3638,7 +3638,13 @@ dummy_func(
             _LOAD_ATTR_NONDESCRIPTOR_NO_DICT;
 
         op(_CHECK_ATTR_METHOD_LAZY_DICT, (dictoffset/1, owner -- owner)) {
-            char *ptr = ((char *)PyStackRef_AsPyObjectBorrow(owner)) + MANAGED_DICT_OFFSET + dictoffset;
+            PyObject *borrowed = PyStackRef_AsPyObjectBorrow(owner);
+            Py_ssize_t offset = MANAGED_DICT_OFFSET;
+            if (!PyType_IS_GC(Py_TYPE(borrowed))) {
+                offset = MANAGED_DICT_OFFSET_NO_GC;
+            }
+
+            char *ptr = ((char *)borrowed) + offset + dictoffset;
             PyObject *dict = FT_ATOMIC_LOAD_PTR_ACQUIRE(*(PyObject **)ptr);
             /* This object has a __dict__, just not yet created */
             DEOPT_IF(dict != NULL);

Python/executor_cases.c.h

@@ -1626,7 +1626,12 @@ specialize_attr_loadclassattr(PyObject *owner, _Py_CODEUNIT *instr,
     else {
         Py_ssize_t dictoffset;
         if (tp_flags & Py_TPFLAGS_MANAGED_DICT) {
-            dictoffset = MANAGED_DICT_OFFSET;
+            if (tp_flags & Py_TPFLAGS_HAVE_GC) {
+                dictoffset = MANAGED_DICT_OFFSET;
+            }
+            else {
+                dictoffset = MANAGED_DICT_OFFSET_NO_GC;
+            }
         }
         else {
             dictoffset = owner_cls->tp_dictoffset;