Sort-of backport to 2.1.3 (if we ever release it) of the following.

(The fix looks different, but does the same thing to the 2.1 GC code
that Neil's patch does to the 2.2 GC code.)

This is Neil's fix for SF bug 535905 (Evil Trashcan and GC interaction).

The fix makes it possible to call PyObject_GC_UnTrack() more than once
on the same object, and then move the PyObject_GC_UnTrack() call to
*before* the trashcan code is invoked.

BUGFIX CANDIDATE!

diff --git a/Modules/gcmodule.c b/Modules/gcmodule.c
index e781bdf9e7869d90b0225f7a727756fba0db0143..011bb1461a9cd9e6f82b1fd08c198a3270314195 100644 (file)
--- a/Modules/gcmodule.c
+++ b/Modules/gcmodule.c
@@ -87,12 +87,14 @@ gc_list_append(PyGC_Head *node, PyGC_Head *list)
 static void
 gc_list_remove(PyGC_Head *node)
 {
+       if (node->gc_next == NULL)
+               return;
        node->gc_prev->gc_next = node->gc_next;
        node->gc_next->gc_prev = node->gc_prev;
 #ifdef Py_DEBUG
        node->gc_prev = NULL;
-       node->gc_next = NULL;
 #endif
+       node->gc_next = NULL;
 }
 
 static void 

diff --git a/Objects/dictobject.c b/Objects/dictobject.c
index 8ad44c181cd16d5da7e75d7ae44fdb1d66ee72d7..bac0edfc2de07d0ecaf82f7031a29cf01b524488 100644 (file)
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -619,8 +619,8 @@ dict_dealloc(register dictobject *mp)
 {
        register int i;
        register dictentry *ep;
-       Py_TRASHCAN_SAFE_BEGIN(mp)
        PyObject_GC_Fini(mp);
+       Py_TRASHCAN_SAFE_BEGIN(mp)
        for (i = 0, ep = mp->ma_table; i < mp->ma_size; i++, ep++) {
                if (ep->me_key != NULL) {
                        Py_DECREF(ep->me_key);

diff --git a/Objects/listobject.c b/Objects/listobject.c
index 7044edeea4f6b79744cd8a6f59b27de44414ffce..6868504ab32389de2d58f26bbbf9ab365866e641 100644 (file)
--- a/Objects/listobject.c
+++ b/Objects/listobject.c
@@ -176,8 +176,8 @@ static void
 list_dealloc(PyListObject *op)
 {
        int i;
-       Py_TRASHCAN_SAFE_BEGIN(op)
        PyObject_GC_Fini(op);
+       Py_TRASHCAN_SAFE_BEGIN(op)
        if (op->ob_item != NULL) {
                /* Do it backwards, for Christian Tismer.
                   There's a simple test case where somehow this reduces

diff --git a/Objects/tupleobject.c b/Objects/tupleobject.c
index ca76bb5923ff88549af37ed25ffc9b8ba614ef4e..000856d5f6f5f3b14ae48f54985ac7f61bcc7f5d 100644 (file)
--- a/Objects/tupleobject.c
+++ b/Objects/tupleobject.c
@@ -143,8 +143,8 @@ tupledealloc(register PyTupleObject *op)
 {
        register int i;
        register int len =  op->ob_size;
-       Py_TRASHCAN_SAFE_BEGIN(op)
        PyObject_GC_Fini(op);
+       Py_TRASHCAN_SAFE_BEGIN(op)
        if (len > 0) {
                i = len;
                while (--i >= 0)