Remove Py_TPFLAGS_EXPOSED flag and related logic.

This was useful for debugging logic but we don't want to use an
additional type flag.

Author: nascheme

Include/object.h

@@ -576,8 +576,8 @@ given type object has a specified feature.
 /* Objects behave like an unbound method */
 #define Py_TPFLAGS_METHOD_DESCRIPTOR (1UL << 17)
 
-/* Type structure is potentially exposed (revealed) to other threads */
-#define Py_TPFLAGS_EXPOSED  (1UL << 19)
+/* Unused. Legacy flag */
+#define Py_TPFLAGS_VALID_VERSION_TAG  (1UL << 19)
 
 /* Type is abstract and cannot be instantiated */
 #define Py_TPFLAGS_IS_ABSTRACT (1UL << 20)

Objects/typeobject.c

@@ -93,12 +93,6 @@ types_world_is_stopped(void)
     return interp->stoptheworld.world_stopped;
 }
 
-// Checks that either the type has not yet been exposed (revealed) to other
-// threads (it was newly created and the Py_TPFLAGS_EXPOSED flag is not set
-// yet) or the world is stopped and we can safely update it without races.
-#define ASSERT_NEW_OR_STOPPED(tp) \
-    assert((((tp)->tp_flags & Py_TPFLAGS_EXPOSED) == 0) || types_world_is_stopped())
-
 static void
 types_stop_world(void)
 {
@@ -166,7 +160,6 @@ types_mutex_unlock(void)
 #define types_stop_world()
 #define types_start_world()
 #define ASSERT_TYPE_LOCK_HELD()
-#define ASSERT_NEW_OR_STOPPED(tp)
 
 #endif
 
@@ -436,15 +429,13 @@ type_set_flags(PyTypeObject *tp, unsigned long flags)
         // be active).
         ASSERT_TYPE_LOCK_HELD();
     }
-    ASSERT_NEW_OR_STOPPED(tp);
     tp->tp_flags = flags;
 }
 
 static void
 type_set_flags_with_mask(PyTypeObject *tp, unsigned long mask, unsigned long flags)
 {
     ASSERT_TYPE_LOCK_HELD();
-    ASSERT_NEW_OR_STOPPED(tp);
     unsigned long new_flags = (tp->tp_flags & ~mask) | flags;
     type_set_flags(tp, new_flags);
 }
@@ -580,7 +571,6 @@ static inline void
 set_tp_bases(PyTypeObject *self, PyObject *bases, int initial)
 {
     assert(PyTuple_CheckExact(bases));
-    ASSERT_NEW_OR_STOPPED(self);
     if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {
         // XXX tp_bases can probably be statically allocated for each
         // static builtin type.
@@ -638,7 +628,6 @@ _PyType_GetMRO(PyTypeObject *self)
 static inline void
 set_tp_mro(PyTypeObject *self, PyObject *mro, int initial)
 {
-    ASSERT_NEW_OR_STOPPED(self);
     if (mro != NULL) {
         assert(PyTuple_CheckExact(mro));
         if (self->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {
@@ -1717,7 +1706,6 @@ static int
 mro_hierarchy(PyTypeObject *type, PyObject *temp)
 {
     ASSERT_TYPE_LOCK_HELD();
-    ASSERT_NEW_OR_STOPPED(type);
 
     PyObject *old_mro;
     int res = mro_internal(type, &old_mro);
@@ -3564,7 +3552,6 @@ static int
 mro_internal_unlocked(PyTypeObject *type, int initial, PyObject **p_old_mro)
 {
     ASSERT_TYPE_LOCK_HELD();
-    ASSERT_NEW_OR_STOPPED(type);
 
     PyObject *new_mro, *old_mro;
     int reent;
@@ -3614,7 +3601,6 @@ static int
 mro_internal(PyTypeObject *type, PyObject **p_old_mro)
 {
     int res;
-    ASSERT_NEW_OR_STOPPED(type);
     res = mro_internal_unlocked(type, 0, p_old_mro);
     return res;
 }
@@ -4694,8 +4680,6 @@ type_new_impl(type_new_ctx *ctx)
     }
 
     assert(_PyType_CheckConsistency(type));
-    // After this point, other threads can potentally use this type.
-    type->tp_flags |= Py_TPFLAGS_EXPOSED;
 
     return (PyObject *)type;
 
@@ -5409,8 +5393,6 @@ PyType_FromMetaclass(
     }
 
     assert(_PyType_CheckConsistency(type));
-    // After this point, other threads can potentally use this type.
-    type->tp_flags |= Py_TPFLAGS_EXPOSED;
 
  finally:
     if (PyErr_Occurred()) {
@@ -8668,7 +8650,6 @@ static int
 type_ready_mro(PyTypeObject *type, int initial)
 {
     ASSERT_TYPE_LOCK_HELD();
-    ASSERT_NEW_OR_STOPPED(type);
 
     if (type->tp_flags & _Py_TPFLAGS_STATIC_BUILTIN) {
         if (!initial) {
@@ -8744,7 +8725,6 @@ static int
 type_ready_inherit(PyTypeObject *type)
 {
     ASSERT_TYPE_LOCK_HELD();
-    ASSERT_NEW_OR_STOPPED(type);
 
     /* Inherit special flags from dominant base */
     PyTypeObject *base = type->tp_base;
@@ -8942,7 +8922,6 @@ static int
 type_ready(PyTypeObject *type, int initial)
 {
     ASSERT_TYPE_LOCK_HELD();
-    ASSERT_NEW_OR_STOPPED(type);
 
     _PyObject_ASSERT((PyObject *)type, !is_readying(type));
     start_readying(type);
@@ -11275,7 +11254,6 @@ static pytype_slotdef *
 update_one_slot(PyTypeObject *type, pytype_slotdef *p)
 {
     ASSERT_TYPE_LOCK_HELD();
-    ASSERT_NEW_OR_STOPPED(type);
 
     PyObject *descr;
     PyWrapperDescrObject *d;
@@ -11392,7 +11370,6 @@ static int
 update_slots_callback(PyTypeObject *type, void *data)
 {
     ASSERT_TYPE_LOCK_HELD();
-    ASSERT_NEW_OR_STOPPED(type);
 
     pytype_slotdef **pp = (pytype_slotdef **)data;
     for (; *pp; pp++) {
@@ -11411,7 +11388,6 @@ update_slot(PyTypeObject *type, PyObject *name)
     int offset;
 
     ASSERT_TYPE_LOCK_HELD();
-    ASSERT_NEW_OR_STOPPED(type);
     assert(types_world_is_stopped());
     assert(PyUnicode_CheckExact(name));
     assert(PyUnicode_CHECK_INTERNED(name));
@@ -11466,7 +11442,6 @@ update_all_slots(PyTypeObject* type)
     pytype_slotdef *p;
 
     ASSERT_TYPE_LOCK_HELD();
-    ASSERT_NEW_OR_STOPPED(type);
 
     /* Clear the VALID_VERSION flag of 'type' and all its subclasses. */
     type_modified_unlocked(type);