gh-154429: Skip fetching the thread state for non-GC types in _Py_Dealloc

_Py_Dealloc() fetched the current thread state and computed the C
recursion margin on every deallocation, but both are only used by the
trashcan mechanism, which applies only to GC-tracked types. Gate them
behind the Py_TPFLAGS_HAVE_GC check so the common non-GC case (int,
float, str and similar atomic types) skips them.

On platforms where _PyThreadState_GET() reads a _Thread_local via a
function call (e.g. macOS TLV), this removes a call from every non-GC
deallocation.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: johng

Misc/NEWS.d/next/Core_and_Builtins/2026-07-22-14-30-00.gh-issue-154429.Qk9mZ2.rst

@@ -0,0 +1,7 @@
+Speed up deallocation of objects that are not tracked by the garbage
+collector (such as :class:`int`, :class:`float` and :class:`str`) by skipping
+the thread-state fetch and recursion-margin computation in the object
+deallocator.  These are only needed by the trashcan mechanism, which applies
+only to GC-tracked types.  On platforms where the current thread state is
+accessed through a function call (for example macOS), this removes a call from
+every non-GC deallocation.

Objects/object.c

@@ -3292,13 +3292,29 @@ _Py_Dealloc(PyObject *op)
     PyTypeObject *type = Py_TYPE(op);
     unsigned long gc_flag = type->tp_flags & Py_TPFLAGS_HAVE_GC;
     destructor dealloc = type->tp_dealloc;
-    PyThreadState *tstate = _PyThreadState_GET();
-    intptr_t margin = _Py_RecursionLimit_GetMargin(tstate);
-    if (margin < 2 && gc_flag) {
-        _PyTrash_thread_deposit_object(tstate, (PyObject *)op);
-        return;
+    // The trashcan mechanism -- and the thread state and recursion margin it
+    // relies on -- only applies to GC-tracked types: only they can form the
+    // deep deallocation chains the trashcan guards against.  Skip fetching the
+    // thread state for the common non-GC case (float/int/str temporaries and
+    // the like).  On platforms where the thread state lives in a thread-local
+    // accessed via a function call (e.g. macOS TLV), this removes a call from
+    // every non-GC deallocation.
+    PyThreadState *tstate = NULL;
+    intptr_t margin = 0;
+    if (gc_flag) {
+        tstate = _PyThreadState_GET();
+        margin = _Py_RecursionLimit_GetMargin(tstate);
+        if (margin < 2) {
+            _PyTrash_thread_deposit_object(tstate, (PyObject *)op);
+            return;
+        }
     }
 #ifdef Py_DEBUG
+    // The non-GC fast path above skips fetching the thread state; the debug
+    // bookkeeping below needs it, so fetch it now if we haven't already.
+    if (tstate == NULL) {
+        tstate = _PyThreadState_GET();
+    }
 #if !defined(Py_GIL_DISABLED) && !defined(Py_STACKREF_DEBUG)
     /* This assertion doesn't hold for the free-threading build, as
      * PyStackRef_CLOSE_SPECIALIZED is not implemented */
@@ -3340,7 +3356,9 @@ _Py_Dealloc(PyObject *op)
     Py_XDECREF(old_exc);
     Py_DECREF(type);
 #endif
-    if (tstate->delete_later && margin >= 4 && gc_flag) {
+    // gc_flag is checked first so tstate (NULL on the non-GC fast path) is
+    // only dereferenced for GC-tracked types, where it was fetched above.
+    if (gc_flag && tstate->delete_later && margin >= 4) {
         _PyTrash_thread_destroy_chain(tstate);
     }
 }