Use ob_flags for object's GC state

markshannon · markshannon · commit 6b5c405acab7 · 2025-07-10T12:08:49.000+01:00
diff --git a/Include/internal/pycore_freelist.h b/Include/internal/pycore_freelist.h
@@ -13,6 +13,7 @@ extern "C" {
 #include "pycore_pyatomic_ft_wrappers.h" // FT_ATOMIC_STORE_PTR_RELAXED()
 #include "pycore_pystate.h"             // _PyThreadState_GET
 #include "pycore_stats.h"               // OBJECT_STAT_INC
+#include "pycore_gc.h"                  // _Py_GC_OBJECT
 
 static inline struct _Py_freelists *
 _Py_freelists_GET(void)
@@ -38,8 +39,8 @@ _Py_freelists_GET(void)
     _PyFreeList_Push(&_Py_freelists_GET()->NAME, _PyObject_CAST(op), limit)
 
 // Pops a PyObject from the freelist, returns NULL if the freelist is empty.
-#define _Py_FREELIST_POP(TYPE, NAME) \
-    _Py_CAST(TYPE*, _PyFreeList_Pop(&_Py_freelists_GET()->NAME))
+#define _Py_FREELIST_POP(TYPE, NAME, IS_GC) \
+    _Py_CAST(TYPE*, _PyFreeList_Pop(&_Py_freelists_GET()->NAME, (IS_GC) ? _Py_GC_OBJECT : 0))
 
 // Pops a non-PyObject data structure from the freelist, returns NULL if the
 // freelist is empty.
@@ -82,13 +83,28 @@ _PyFreeList_PopNoStats(struct _Py_freelist *fl)
     return obj;
 }
 
+#ifndef NDEBUG
+static int
+consistent_flags(PyObject *op, int flags)
+{
+    if (Py_TYPE(op)->tp_flags & Py_TPFLAGS_HAVE_GC) {
+        return flags == _Py_GC_OBJECT;
+    }
+    else {
+        return flags == 0;
+    }
+}
+#endif
+
 static inline PyObject *
-_PyFreeList_Pop(struct _Py_freelist *fl)
+_PyFreeList_Pop(struct _Py_freelist *fl, int flags)
 {
     PyObject *op = _PyFreeList_PopNoStats(fl);
     if (op != NULL) {
         OBJECT_STAT_INC(from_freelist);
         _Py_NewReference(op);
+        assert(consistent_flags(op, flags));
+        op->ob_flags = flags;
     }
     return op;
 }
diff --git a/Include/internal/pycore_gc.h b/Include/internal/pycore_gc.h
@@ -69,13 +69,16 @@ _PyObject_CLEAR_GC_BITS(PyObject *op, uint8_t bits_to_clear)
 
 #endif
 
+#define _Py_GC_OBJECT (1 << 4)
+#define _Py_GC_TRACKED (1 << 5)
+
+
 /* True if the object is currently tracked by the GC. */
 static inline int _PyObject_GC_IS_TRACKED(PyObject *op) {
 #ifdef Py_GIL_DISABLED
     return _PyObject_HAS_GC_BITS(op, _PyGC_BITS_TRACKED);
 #else
-    PyGC_Head *gc = _Py_AS_GC(op);
-    return (gc->_gc_next != 0);
+    return (op->ob_flags & _Py_GC_TRACKED) != 0;
 #endif
 }
 #define _PyObject_GC_IS_TRACKED(op) _PyObject_GC_IS_TRACKED(_Py_CAST(PyObject*, op))
@@ -246,6 +249,8 @@ static inline void _PyObject_GC_TRACK(
     uintptr_t not_visited = 1 ^ interp->gc.visited_space;
     gc->_gc_next = ((uintptr_t)generation0) | not_visited;
     generation0->_gc_prev = (uintptr_t)gc;
+    assert(op->ob_flags & _Py_GC_OBJECT);
+    op->ob_flags |= _Py_GC_TRACKED;
 #endif
 }
 
@@ -280,6 +285,7 @@ static inline void _PyObject_GC_UNTRACK(
     _PyGCHead_SET_PREV(next, prev);
     gc->_gc_next = 0;
     gc->_gc_prev &= _PyGC_PREV_MASK_FINALIZED;
+    op->ob_flags &= ~_Py_GC_TRACKED;
 #endif
 }
 
diff --git a/Include/internal/pycore_object.h b/Include/internal/pycore_object.h
@@ -853,9 +853,7 @@ _PyObject_GET_WEAKREFS_LISTPTR_FROM_OFFSET(PyObject *op)
 static inline int
 _PyObject_IS_GC(PyObject *obj)
 {
-    PyTypeObject *type = Py_TYPE(obj);
-    return (_PyType_IS_GC(type)
-            && (type->tp_is_gc == NULL || type->tp_is_gc(obj)));
+    return (obj->ob_flags & _Py_GC_OBJECT) != 0;
 }
 
 // Fast inlined version of PyObject_Hash()
diff --git a/Modules/_asynciomodule.c b/Modules/_asynciomodule.c
@@ -2052,7 +2052,7 @@ future_new_iter(PyObject *fut)
     asyncio_state *state = get_asyncio_state_by_def((PyObject *)fut);
     ENSURE_FUTURE_ALIVE(state, fut)
 
-    it = _Py_FREELIST_POP(futureiterobject, futureiters);
+    it = _Py_FREELIST_POP(futureiterobject, futureiters, 1);
     if (it == NULL) {
         it = PyObject_GC_New(futureiterobject, state->FutureIterType);
         if (it == NULL) {
diff --git a/Objects/classobject.c b/Objects/classobject.c
@@ -114,7 +114,7 @@ PyMethod_New(PyObject *func, PyObject *self)
         PyErr_BadInternalCall();
         return NULL;
     }
-    PyMethodObject *im = _Py_FREELIST_POP(PyMethodObject, pymethodobjects);
+    PyMethodObject *im = _Py_FREELIST_POP(PyMethodObject, pymethodobjects, 1);
     if (im == NULL) {
         im = PyObject_GC_New(PyMethodObject, &PyMethod_Type);
         if (im == NULL) {
diff --git a/Objects/complexobject.c b/Objects/complexobject.c
@@ -410,7 +410,7 @@ complex_subtype_from_c_complex(PyTypeObject *type, Py_complex cval)
 PyObject *
 PyComplex_FromCComplex(Py_complex cval)
 {
-    PyComplexObject *op = _Py_FREELIST_POP(PyComplexObject, complexes);
+    PyComplexObject *op = _Py_FREELIST_POP(PyComplexObject, complexes, 0);
 
     if (op == NULL) {
         /* Inline PyObject_New */
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
@@ -872,7 +872,7 @@ new_dict(PyInterpreterState *interp,
          Py_ssize_t used, int free_values_on_failure)
 {
     assert(keys != NULL);
-    PyDictObject *mp = _Py_FREELIST_POP(PyDictObject, dicts);
+    PyDictObject *mp = _Py_FREELIST_POP(PyDictObject, dicts, 1);
     if (mp == NULL) {
         mp = PyObject_GC_New(PyDictObject, &PyDict_Type);
         if (mp == NULL) {
diff --git a/Objects/exceptions.c b/Objects/exceptions.c
@@ -3978,6 +3978,8 @@ get_memory_error(int allow_allocation, PyObject *args, PyObject *kwds)
         self->dict = NULL;
         self->args = (PyObject *)&_Py_SINGLETON(tuple_empty);
         _Py_NewReference((PyObject *)self);
+        assert(((PyObject *)self)->ob_flags == 0);
+        ((PyObject *)self)->ob_flags = _Py_GC_OBJECT;
         _PyObject_GC_TRACK(self);
     }
     MEMERRORS_UNLOCK(state);
diff --git a/Objects/floatobject.c b/Objects/floatobject.c
@@ -123,7 +123,7 @@ PyFloat_GetInfo(void)
 PyObject *
 PyFloat_FromDouble(double fval)
 {
-    PyFloatObject *op = _Py_FREELIST_POP(PyFloatObject, floats);
+    PyFloatObject *op = _Py_FREELIST_POP(PyFloatObject, floats, 0);
     if (op == NULL) {
         op = PyObject_Malloc(sizeof(PyFloatObject));
         if (!op) {
diff --git a/Objects/genobject.c b/Objects/genobject.c
@@ -1972,7 +1972,7 @@ PyTypeObject _PyAsyncGenASend_Type = {
 static PyObject *
 async_gen_asend_new(PyAsyncGenObject *gen, PyObject *sendval)
 {
-    PyAsyncGenASend *ags = _Py_FREELIST_POP(PyAsyncGenASend, async_gen_asends);
+    PyAsyncGenASend *ags = _Py_FREELIST_POP(PyAsyncGenASend, async_gen_asends, 1);
     if (ags == NULL) {
         ags = PyObject_GC_New(PyAsyncGenASend, &_PyAsyncGenASend_Type);
         if (ags == NULL) {
@@ -2059,7 +2059,7 @@ _PyAsyncGenValueWrapperNew(PyThreadState *tstate, PyObject *val)
 {
     assert(val);
 
-    _PyAsyncGenWrappedValue *o = _Py_FREELIST_POP(_PyAsyncGenWrappedValue, async_gens);
+    _PyAsyncGenWrappedValue *o = _Py_FREELIST_POP(_PyAsyncGenWrappedValue, async_gens, 1);
     if (o == NULL) {
         o = PyObject_GC_New(_PyAsyncGenWrappedValue,
                             &_PyAsyncGenWrappedValue_Type);
diff --git a/Objects/listobject.c b/Objects/listobject.c
@@ -239,7 +239,7 @@ PyList_New(Py_ssize_t size)
         return NULL;
     }
 
-    PyListObject *op = _Py_FREELIST_POP(PyListObject, lists);
+    PyListObject *op = _Py_FREELIST_POP(PyListObject, lists, 1);
     if (op == NULL) {
         op = PyObject_GC_New(PyListObject, &PyList_Type);
         if (op == NULL) {
@@ -3976,7 +3976,7 @@ list_iter(PyObject *seq)
         PyErr_BadInternalCall();
         return NULL;
     }
-    _PyListIterObject *it = _Py_FREELIST_POP(_PyListIterObject, list_iters);
+    _PyListIterObject *it = _Py_FREELIST_POP(_PyListIterObject, list_iters, 1);
     if (it == NULL) {
         it = PyObject_GC_New(_PyListIterObject, &PyListIter_Type);
         if (it == NULL) {
diff --git a/Objects/longobject.c b/Objects/longobject.c
@@ -169,7 +169,7 @@ long_alloc(Py_ssize_t size)
     Py_ssize_t ndigits = size ? size : 1;
 
     if (ndigits == 1) {
-        result = (PyLongObject *)_Py_FREELIST_POP(PyLongObject, ints);
+        result = (PyLongObject *)_Py_FREELIST_POP(PyLongObject, ints, 0);
     }
     if (result == NULL) {
         /* Number of bytes needed is: offsetof(PyLongObject, ob_digit) +
@@ -249,7 +249,7 @@ _PyLong_FromMedium(sdigit x)
     assert(!IS_SMALL_INT(x));
     assert(is_medium_int(x));
 
-    PyLongObject *v = (PyLongObject *)_Py_FREELIST_POP(PyLongObject, ints);
+    PyLongObject *v = (PyLongObject *)_Py_FREELIST_POP(PyLongObject, ints, 0);
     if (v == NULL) {
         v = PyObject_Malloc(sizeof(PyLongObject));
         if (v == NULL) {
@@ -329,7 +329,7 @@ medium_from_stwodigits(stwodigits x)
     if(!is_medium_int(x)) {
         return PyStackRef_NULL;
     }
-    PyLongObject *v = (PyLongObject *)_Py_FREELIST_POP(PyLongObject, ints);
+    PyLongObject *v = (PyLongObject *)_Py_FREELIST_POP(PyLongObject, ints, 0);
     if (v == NULL) {
         v = PyObject_Malloc(sizeof(PyLongObject));
         if (v == NULL) {
diff --git a/Objects/methodobject.c b/Objects/methodobject.c
@@ -87,7 +87,7 @@ PyCMethod_New(PyMethodDef *ml, PyObject *self, PyObject *module, PyTypeObject *c
                             "flag but no class");
             return NULL;
         }
-        PyCMethodObject *om = _Py_FREELIST_POP(PyCMethodObject, pycmethodobject);
+        PyCMethodObject *om = _Py_FREELIST_POP(PyCMethodObject, pycmethodobject, 1);
         if (om == NULL) {
             om = PyObject_GC_New(PyCMethodObject, &PyCMethod_Type);
             if (om == NULL) {
@@ -103,7 +103,7 @@ PyCMethod_New(PyMethodDef *ml, PyObject *self, PyObject *module, PyTypeObject *c
                             "but no METH_METHOD flag");
             return NULL;
         }
-        op = _Py_FREELIST_POP(PyCFunctionObject, pycfunctionobject);
+        op = _Py_FREELIST_POP(PyCFunctionObject, pycfunctionobject, 1);
         if (op == NULL) {
             op = PyObject_GC_New(PyCFunctionObject, &PyCFunction_Type);
             if (op == NULL) {
diff --git a/Objects/object.c b/Objects/object.c
@@ -2692,7 +2692,7 @@ _Py_SetImmortalUntracked(PyObject *op)
     op->ob_ref_shared = 0;
     _Py_atomic_or_uint8(&op->ob_gc_bits, _PyGC_BITS_DEFERRED);
 #elif SIZEOF_VOID_P > 4
-    op->ob_flags = _Py_IMMORTAL_FLAGS;
+    op->ob_flags |= _Py_IMMORTAL_FLAGS;
     op->ob_refcnt = _Py_IMMORTAL_INITIAL_REFCNT;
 #else
     op->ob_refcnt = _Py_IMMORTAL_INITIAL_REFCNT;
diff --git a/Objects/rangeobject.c b/Objects/rangeobject.c
@@ -57,7 +57,7 @@ make_range_object(PyTypeObject *type, PyObject *start,
     if (length == NULL) {
         return NULL;
     }
-    rangeobject *obj = _Py_FREELIST_POP(rangeobject, ranges);
+    rangeobject *obj = _Py_FREELIST_POP(rangeobject, ranges, 0);
     if (obj == NULL) {
         obj = PyObject_New(rangeobject, type);
         if (obj == NULL) {
@@ -981,7 +981,7 @@ get_len_of_range(long lo, long hi, long step)
 static PyObject *
 fast_range_iter(long start, long stop, long step, long len)
 {
-    _PyRangeIterObject *it = _Py_FREELIST_POP(_PyRangeIterObject, range_iters);
+    _PyRangeIterObject *it = _Py_FREELIST_POP(_PyRangeIterObject, range_iters, 0);
     if (it == NULL) {
         it = PyObject_New(_PyRangeIterObject, &PyRangeIter_Type);
         if (it == NULL) {
diff --git a/Objects/sliceobject.c b/Objects/sliceobject.c
@@ -120,7 +120,7 @@ static PySliceObject *
 _PyBuildSlice_Consume2(PyObject *start, PyObject *stop, PyObject *step)
 {
     assert(start != NULL && stop != NULL && step != NULL);
-    PySliceObject *obj = _Py_FREELIST_POP(PySliceObject, slices);
+    PySliceObject *obj = _Py_FREELIST_POP(PySliceObject, slices, 1);
     if (obj == NULL) {
         obj = PyObject_GC_New(PySliceObject, &PySlice_Type);
         if (obj == NULL) {
diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
@@ -43,7 +43,7 @@ tuple_alloc(Py_ssize_t size)
     assert(size != 0);    // The empty tuple is statically allocated.
     Py_ssize_t index = size - 1;
     if (index < PyTuple_MAXSAVESIZE) {
-        PyTupleObject *op = _Py_FREELIST_POP(PyTupleObject, tuples[index]);
+        PyTupleObject *op = _Py_FREELIST_POP(PyTupleObject, tuples[index], 1);
         if (op != NULL) {
             _PyTuple_RESET_HASH_CACHE(op);
             return op;
@@ -976,6 +976,8 @@ _PyTuple_Resize(PyObject **pv, Py_ssize_t newsize)
         memset(&sv->ob_item[oldsize], 0,
                sizeof(*sv->ob_item) * (newsize - oldsize));
     *pv = (PyObject *) sv;
+    assert(((PyObject *)sv)->ob_flags == 0);
+    ((PyObject *)sv)->ob_flags = _Py_GC_OBJECT;
     _PyObject_GC_TRACK(sv);
     return 0;
 }
@@ -1138,7 +1140,7 @@ tuple_iter(PyObject *seq)
         PyErr_BadInternalCall();
         return NULL;
     }
-    _PyTupleIterObject *it = _Py_FREELIST_POP(_PyTupleIterObject, tuple_iters);
+    _PyTupleIterObject *it = _Py_FREELIST_POP(_PyTupleIterObject, tuple_iters, 1);
     if (it == NULL) {
         it = PyObject_GC_New(_PyTupleIterObject, &PyTupleIter_Type);
         if (it == NULL)
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
@@ -2485,13 +2485,6 @@ _PyType_AllocNoTrack(PyTypeObject *type, Py_ssize_t nitems)
         return PyErr_NoMemory();
     }
     obj = (PyObject *)(alloc + presize);
-    if (presize) {
-        ((PyObject **)alloc)[0] = NULL;
-        ((PyObject **)alloc)[1] = NULL;
-    }
-    if (PyType_IS_GC(type)) {
-        _PyObject_GC_Link(obj);
-    }
     // Zero out the object after the PyObject header. The header fields are
     // initialized by _PyObject_Init[Var]().
     memset((char *)obj + sizeof(PyObject), 0, size - sizeof(PyObject));
@@ -2502,6 +2495,12 @@ _PyType_AllocNoTrack(PyTypeObject *type, Py_ssize_t nitems)
     else {
         _PyObject_InitVar((PyVarObject *)obj, type, nitems);
     }
+    if (presize) {
+        assert(PyType_IS_GC(type));
+        ((PyObject **)alloc)[0] = NULL;
+        ((PyObject **)alloc)[1] = NULL;
+        _PyObject_GC_Link(obj);
+    }
     if (type->tp_flags & Py_TPFLAGS_INLINE_VALUES) {
         _PyObject_InitInlineValues(obj, type);
     }
diff --git a/Python/context.c b/Python/context.c
@@ -425,7 +425,7 @@ class _contextvars.Context "PyContext *" "&PyContext_Type"
 static inline PyContext *
 _context_alloc(void)
 {
-    PyContext *ctx = _Py_FREELIST_POP(PyContext, contexts);
+    PyContext *ctx = _Py_FREELIST_POP(PyContext, contexts, 1);
     if (ctx == NULL) {
         ctx = PyObject_GC_New(PyContext, &PyContext_Type);
         if (ctx == NULL) {
diff --git a/Python/gc.c b/Python/gc.c
@@ -2260,6 +2260,8 @@ _PyObject_GC_Link(PyObject *op)
     GCState *gcstate = &tstate->interp->gc;
     gc->_gc_next = 0;
     gc->_gc_prev = 0;
+    assert(op->ob_flags == 0);
+    op->ob_flags = _Py_GC_OBJECT;
     gcstate->young.count++; /* number of allocated GC objects */
     gcstate->heap_size++;
     if (gcstate->young.count > gcstate->young.threshold &&
@@ -2295,7 +2297,6 @@ gc_alloc(PyTypeObject *tp, size_t basicsize, size_t presize)
     ((PyObject **)mem)[0] = NULL;
     ((PyObject **)mem)[1] = NULL;
     PyObject *op = (PyObject *)(mem + presize);
-    _PyObject_GC_Link(op);
     return op;
 }
 
@@ -2313,6 +2314,7 @@ _PyObject_GC_New(PyTypeObject *tp)
         return NULL;
     }
     _PyObject_Init(op, tp);
+    _PyObject_GC_Link(op);
     if (tp->tp_flags & Py_TPFLAGS_INLINE_VALUES) {
         _PyObject_InitInlineValues(op, tp);
     }
@@ -2335,6 +2337,7 @@ _PyObject_GC_NewVar(PyTypeObject *tp, Py_ssize_t nitems)
         return NULL;
     }
     _PyObject_InitVar(op, tp, nitems);
+    _PyObject_GC_Link((PyObject *)op);
     return op;
 }
 
@@ -2402,10 +2405,7 @@ PyObject_GC_Del(void *op)
 int
 PyObject_GC_IsTracked(PyObject* obj)
 {
-    if (_PyObject_IS_GC(obj) && _PyObject_GC_IS_TRACKED(obj)) {
-        return 1;
-    }
-    return 0;
+    return (obj->ob_flags & _Py_GC_TRACKED) != 0;
 }
 
 int

Original file line number	Diff line number	Diff line change
`@@ -853,9 +853,7 @@ _PyObject_GET_WEAKREFS_LISTPTR_FROM_OFFSET(PyObject *op)`
`853`	`853`	`static inline int`
`854`	`854`	`_PyObject_IS_GC(PyObject *obj)`
`855`	`855`	`{`
`856`		`- PyTypeObject *type = Py_TYPE(obj);`
`857`		`- return (_PyType_IS_GC(type)`
`858`		`- && (type->tp_is_gc == NULL \|\| type->tp_is_gc(obj)));`
	`856`	`+ return (obj->ob_flags & _Py_GC_OBJECT) != 0;`
`859`	`857`	`}`
`860`	`858`
`861`	`859`	`// Fast inlined version of PyObject_Hash()`
Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ PyMethod_New(PyObject func, PyObject self)`
`114`	`114`	`PyErr_BadInternalCall();`
`115`	`115`	`return NULL;`
`116`	`116`	`}`
`117`		`- PyMethodObject *im = _Py_FREELIST_POP(PyMethodObject, pymethodobjects);`
	`117`	`+ PyMethodObject *im = _Py_FREELIST_POP(PyMethodObject, pymethodobjects, 1);`
`118`	`118`	`if (im == NULL) {`
`119`	`119`	`im = PyObject_GC_New(PyMethodObject, &PyMethod_Type);`
`120`	`120`	`if (im == NULL) {`
Original file line number	Diff line number	Diff line change
`@@ -410,7 +410,7 @@ complex_subtype_from_c_complex(PyTypeObject *type, Py_complex cval)`
`410`	`410`	`PyObject *`
`411`	`411`	`PyComplex_FromCComplex(Py_complex cval)`
`412`	`412`	`{`
`413`		`- PyComplexObject *op = _Py_FREELIST_POP(PyComplexObject, complexes);`
	`413`	`+ PyComplexObject *op = _Py_FREELIST_POP(PyComplexObject, complexes, 0);`
`414`	`414`
`415`	`415`	`if (op == NULL) {`
`416`	`416`	`/* Inline PyObject_New */`
Original file line number	Diff line number	Diff line change
`@@ -872,7 +872,7 @@ new_dict(PyInterpreterState *interp,`
`872`	`872`	`Py_ssize_t used, int free_values_on_failure)`
`873`	`873`	`{`
`874`	`874`	`assert(keys != NULL);`
`875`		`- PyDictObject *mp = _Py_FREELIST_POP(PyDictObject, dicts);`
	`875`	`+ PyDictObject *mp = _Py_FREELIST_POP(PyDictObject, dicts, 1);`
`876`	`876`	`if (mp == NULL) {`
`877`	`877`	`mp = PyObject_GC_New(PyDictObject, &PyDict_Type);`
`878`	`878`	`if (mp == NULL) {`
Original file line number	Diff line number	Diff line change
`@@ -3978,6 +3978,8 @@ get_memory_error(int allow_allocation, PyObject args, PyObject kwds)`
`3978`	`3978`	`self->dict = NULL;`
`3979`	`3979`	`self->args = (PyObject *)&_Py_SINGLETON(tuple_empty);`
`3980`	`3980`	`_Py_NewReference((PyObject *)self);`
	`3981`	`+ assert(((PyObject *)self)->ob_flags == 0);`
	`3982`	`+ ((PyObject *)self)->ob_flags = _Py_GC_OBJECT;`
`3981`	`3983`	`_PyObject_GC_TRACK(self);`
`3982`	`3984`	`}`
`3983`	`3985`	`MEMERRORS_UNLOCK(state);`
Original file line number	Diff line number	Diff line change
`@@ -123,7 +123,7 @@ PyFloat_GetInfo(void)`
`123`	`123`	`PyObject *`
`124`	`124`	`PyFloat_FromDouble(double fval)`
`125`	`125`	`{`
`126`		`- PyFloatObject *op = _Py_FREELIST_POP(PyFloatObject, floats);`
	`126`	`+ PyFloatObject *op = _Py_FREELIST_POP(PyFloatObject, floats, 0);`
`127`	`127`	`if (op == NULL) {`
`128`	`128`	`op = PyObject_Malloc(sizeof(PyFloatObject));`
`129`	`129`	`if (!op) {`