From 36eb4dfb819dbfe90d82e0c6b58bd360c22bcc26 Mon Sep 17 00:00:00 2001 From: Tim Peters Date: Sun, 23 Mar 2003 03:33:13 +0000 Subject: Refactored some of the Py_TRACE_REFS code. New private API function _Py_AddToAllObjects() that simply inserts an object at the front of the doubly-linked list of all objects. Changed PyType_Ready() (the closest thing we've got to a choke point for type objects) to call that. --- Include/object.h | 1 + Objects/object.c | 24 ++++++++++++++---------- Objects/typeobject.c | 12 ++++++++++++ 3 files changed, 27 insertions(+), 10 deletions(-) diff --git a/Include/object.h b/Include/object.h index 33e57a4..89445c0 100644 --- a/Include/object.h +++ b/Include/object.h @@ -582,6 +582,7 @@ PyAPI_FUNC(void) _Py_NewReference(PyObject *); PyAPI_FUNC(void) _Py_ForgetReference(PyObject *); PyAPI_FUNC(void) _Py_Dealloc(PyObject *); PyAPI_FUNC(void) _Py_PrintReferences(FILE *); +PyAPI_FUNC(void) _Py_AddToAllObjects(PyObject *); #else /* Without Py_TRACE_REFS, there's little enough to do that we expand code diff --git a/Objects/object.c b/Objects/object.c index ecc25c7..059b36a 100644 --- a/Objects/object.c +++ b/Objects/object.c @@ -20,6 +20,16 @@ int Py_DivisionWarningFlag; #ifdef Py_TRACE_REFS /* Head of doubly-linked list of all objects. */ static PyObject refchain = {&refchain, &refchain}; + +/* Insert op at the fron of the doubly-linked list of all objects. */ +void +_Py_AddToAllObjects(PyObject *op) +{ + op->_ob_next = refchain._ob_next; + op->_ob_prev = &refchain; + refchain._ob_next->_ob_prev = op; + refchain._ob_next = op; +} #endif #ifdef COUNT_ALLOCS @@ -91,12 +101,9 @@ inc_count(PyTypeObject *tp) type_list = tp; #ifdef Py_TRACE_REFS /* Also insert in the doubly-linked list of all objects. */ - if (tp->_ob_next == NULL) { - PyObject *op = (PyObject *)tp; - op->_ob_next = refchain._ob_next; - op->_ob_prev = &refchain; - refchain._ob_next->_ob_prev = op; - refchain._ob_next = op; + if (tp->_ob_prev == NULL) { + assert(tp->_ob_next == NULL); + _Py_AddToAllObjects((PyObject *)tp); } #endif } @@ -1956,10 +1963,7 @@ _Py_NewReference(PyObject *op) { _Py_INC_REFTOTAL; op->ob_refcnt = 1; - op->_ob_next = refchain._ob_next; - op->_ob_prev = &refchain; - refchain._ob_next->_ob_prev = op; - refchain._ob_next = op; + _Py_AddToAllObjects(op); _Py_INC_TPALLOCS(op); } diff --git a/Objects/typeobject.c b/Objects/typeobject.c index b029777..c2ed180 100644 --- a/Objects/typeobject.c +++ b/Objects/typeobject.c @@ -3052,6 +3052,18 @@ PyType_Ready(PyTypeObject *type) type->tp_flags |= Py_TPFLAGS_READYING; +#ifdef Py_TRACE_REFS + /* PyType_Ready is the closest thing we have to a choke point + * for type objects, so is the best place I can think of to try + * to get type objects into the doubly-linked list of all objects. + * Still, not all type objects go thru PyType_Ready. + */ + if (type->_ob_next == NULL) { + assert(type->_ob_prev == NULL); + _Py_AddToAllObjects((PyObject *)type); + } +#endif + /* Initialize tp_base (defaults to BaseObject unless that's us) */ base = type->tp_base; if (base == NULL && type != &PyBaseObject_Type) -- cgit v0.12