From 36eb4dfb819dbfe90d82e0c6b58bd360c22bcc26 Mon Sep 17 00:00:00 2001
From: Tim Peters <tim.peters@gmail.com>
Date: Sun, 23 Mar 2003 03:33:13 +0000
Subject: [PATCH] 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 33e57a46594..89445c0976b 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 ecc25c7c5ec..059b36ab0a6 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 b0297774b5c..c2ed180499e 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)