Replace per-instance HAS_EXT bit with type flag checks

youknowone · youknowone · commit 7b836557e527 · 2026-03-04T18:17:53.000+09:00
Remove GcBits::HAS_EXT and determine ObjExt prefix presence from
type flags (HAS_DICT, HAS_WEAKREF, member_count), matching CPython's
Py_TPFLAGS_PREHEADER approach.

Also fix needs_ext to check HAS_DICT flag instead of dict.is_some(),
matching CPython where MANAGED_DICT always allocates the preheader.
diff --git a/crates/vm/src/object/core.rs b/crates/vm/src/object/core.rs
@@ -239,8 +239,6 @@ bitflags::bitflags! {
         const SHARED_INLINE = 1 << 5;
         /// Use deferred reference counting
         const DEFERRED = 1 << 6;
-        /// Object has ObjExt prefix (dict, weak_list, slots)
-        const HAS_EXT = 1 << 7;
     }
 }
 
@@ -285,7 +283,8 @@ impl fmt::Debug for ObjExt {
 const EXT_OFFSET: usize = core::mem::size_of::<ObjExt>();
 // Guarantee: ObjExt size is a multiple of its alignment, and its alignment
 // is >= any PyInner alignment, so Layout::extend produces no inter-padding.
-const _: () = assert!(core::mem::size_of::<ObjExt>().is_multiple_of(core::mem::align_of::<ObjExt>()));
+const _: () =
+    assert!(core::mem::size_of::<ObjExt>().is_multiple_of(core::mem::align_of::<ObjExt>()));
 const _: () = assert!(core::mem::align_of::<ObjExt>() >= core::mem::align_of::<PyInner<()>>());
 
 /// This is an actual python object. It consists of a `typ` which is the
@@ -305,16 +304,34 @@ pub(super) struct PyInner<T> {
 pub(crate) const SIZEOF_PYOBJECT_HEAD: usize = core::mem::size_of::<PyInner<()>>();
 
 impl<T> PyInner<T> {
+    /// Check if this object has an ObjExt prefix by examining type flags.
+    /// Equivalent to Py_TPFLAGS_PREHEADER (MANAGED_DICT | MANAGED_WEAKREF)
+    /// plus member slots.
+    #[inline(always)]
+    fn has_ext(&self) -> bool {
+        let typ = self.typ.deref();
+        typ.slots
+            .flags
+            .has_feature(crate::types::PyTypeFlags::HAS_DICT)
+            || typ
+                .slots
+                .flags
+                .has_feature(crate::types::PyTypeFlags::HAS_WEAKREF)
+            || typ.slots.member_count > 0
+    }
+
     /// Access the ObjExt prefix at a negative offset from this PyInner.
     /// Returns None if this object was allocated without the prefix.
     ///
+    /// Uses type flags (HAS_DICT, HAS_WEAKREF, member_count) to determine
+    /// if the prefix exists, matching CPython's Py_TPFLAGS_PREHEADER approach.
+    ///
     /// Uses exposed provenance to reconstruct a pointer covering the entire
     /// allocation (ObjExt prefix + PyInner). The allocation pointer's provenance
     /// is exposed at allocation time via `expose_provenance()`.
     #[inline(always)]
     pub(super) fn ext_ref(&self) -> Option<&ObjExt> {
-        if !GcBits::from_bits_retain(self.gc_bits.load(Ordering::Relaxed)).contains(GcBits::HAS_EXT)
-        {
+        if !self.has_ext() {
             return None;
         }
         let self_addr = (self as *const Self as *const u8).addr();
@@ -859,10 +876,7 @@ impl<T: PyPayload> PyInner<T> {
     /// `ptr` must be a valid pointer from `PyInner::new` and must not be used after this call.
     unsafe fn dealloc(ptr: *mut Self) {
         unsafe {
-            let has_ext = GcBits::from_bits_retain((*ptr).gc_bits.load(Ordering::Relaxed))
-                .contains(GcBits::HAS_EXT);
-
-            if has_ext {
+            if (*ptr).has_ext() {
                 let ext_layout = core::alloc::Layout::new::<ObjExt>();
                 let inner_layout = core::alloc::Layout::new::<Self>();
                 let (combined, inner_offset) = ext_layout.extend(inner_layout).unwrap();
@@ -887,7 +901,10 @@ impl<T: PyPayload + core::fmt::Debug> PyInner<T> {
     /// For objects with ext, the allocation layout is: [ObjExt][PyInner<T>]
     fn new(payload: T, typ: PyTypeRef, dict: Option<PyDictRef>) -> *mut Self {
         let member_count = typ.slots.member_count;
-        let needs_ext = dict.is_some()
+        let needs_ext = typ
+            .slots
+            .flags
+            .has_feature(crate::types::PyTypeFlags::HAS_DICT)
             || typ
                 .slots
                 .flags
@@ -915,7 +932,7 @@ impl<T: PyPayload + core::fmt::Debug> PyInner<T> {
                 inner_ptr.write(Self {
                     ref_count: RefCount::new(),
                     vtable: PyObjVTable::of::<T>(),
-                    gc_bits: Radium::new(GcBits::HAS_EXT.bits()),
+                    gc_bits: Radium::new(0),
                     typ: PyAtomicRef::from(typ),
                     payload,
                 });
@@ -2132,7 +2149,7 @@ pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
                 PyInner::<PyType> {
                     ref_count: RefCount::new(),
                     vtable: PyObjVTable::of::<PyType>(),
-                    gc_bits: Radium::new(GcBits::HAS_EXT.bits()),
+                    gc_bits: Radium::new(0),
                     payload: type_payload,
                 },
                 Uninit { typ }
@@ -2145,7 +2162,7 @@ pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef, PyTypeRef) {
                 PyInner::<PyType> {
                     ref_count: RefCount::new(),
                     vtable: PyObjVTable::of::<PyType>(),
-                    gc_bits: Radium::new(GcBits::HAS_EXT.bits()),
+                    gc_bits: Radium::new(0),
                     payload: object_payload,
                 },
                 Uninit { typ },
