gh-128360: Use a portable assertion for holding a thread state

Include/internal/pycore_pystate.h

@@ -300,6 +300,15 @@ PyAPI_FUNC(const PyConfig*) _Py_GetConfig(void);
 // See also PyInterpreterState_Get() and _PyInterpreterState_GET().
 extern PyInterpreterState* _PyGILState_GetInterpreterStateUnsafe(void);
 
+/* Modern equivalent of PyGILState_Check() for use in assertions only. */
+static inline int
+_Py_HoldsTstate(void)
+{
+    PyThreadState *tstate = _PyThreadState_GET();
+    _Py_EnsureTstateNotNULL(tstate);
+    return 1;
+}
+
 #ifdef __cplusplus
 }
 #endif

Modules/socketmodule.c

@@ -110,6 +110,7 @@ Local naming conventions:
 #include "pycore_fileutils.h"     // _Py_set_inheritable()
 #include "pycore_moduleobject.h"  // _PyModule_GetState
 #include "pycore_time.h"          // _PyTime_AsMilliseconds()
+#include "pycore_pystate.h"       // _Py_HoldsTstate()
 #include "pycore_pyatomic_ft_wrappers.h"
 
 #ifdef _Py_MEMORY_SANITIZER
@@ -822,8 +823,8 @@ internal_select(PySocketSockObject *s, int writing, PyTime_t interval,
     struct timeval tv, *tvp;
 #endif
 
-    /* must be called with the GIL held */
-    assert(PyGILState_Check());
+    /* must be called with a thread state */
+    assert(_Py_HoldsTstate());
 
     /* Error condition is for output only */
     assert(!(connect && !writing));
@@ -936,8 +937,8 @@ sock_call_ex(PySocketSockObject *s,
     int deadline_initialized = 0;
     int res;
 
-    /* sock_call() must be called with the GIL held. */
-    assert(PyGILState_Check());
+    /* sock_call() must be called with a thread state. */
+    assert(_Py_HoldsTstate());
 
     /* outer loop to retry select() when select() is interrupted by a signal
        or to retry select()+sock_func() on false positive (see above) */

Objects/object.c

@@ -3074,14 +3074,14 @@ _Py_SetRefcnt(PyObject *ob, Py_ssize_t refcnt)
 }
 
 int PyRefTracer_SetTracer(PyRefTracer tracer, void *data) {
-    assert(PyGILState_Check());
+    assert(_Py_HoldsTstate());
     _PyRuntime.ref_tracer.tracer_func = tracer;
     _PyRuntime.ref_tracer.tracer_data = data;
     return 0;
 }
 
 PyRefTracer PyRefTracer_GetTracer(void** data) {
-    assert(PyGILState_Check());
+    assert(_Py_HoldsTstate());
     if (data != NULL) {
         *data = _PyRuntime.ref_tracer.tracer_data;
     }

Objects/obmalloc.c

@@ -2909,7 +2909,8 @@ _PyMem_DebugRawRealloc(void *ctx, void *p, size_t nbytes)
 static inline void
 _PyMem_DebugCheckGIL(const char *func)
 {
-    if (!PyGILState_Check()) {
+    PyThreadState *tstate = _PyThreadState_GET();
+    if (tstate == NULL) {
 #ifndef Py_GIL_DISABLED
         _Py_FatalErrorFunc(func,
                            "Python memory allocator called "

Python/ceval_gil.c

@@ -995,7 +995,7 @@ _Py_unset_eval_breaker_bit_all(PyInterpreterState *interp, uintptr_t bit)
 void
 _Py_FinishPendingCalls(PyThreadState *tstate)
 {
-    assert(PyGILState_Check());
+    assert(_Py_HoldsTstate());
     assert(_PyThreadState_CheckConsistency(tstate));
 
     struct _pending_calls *pending = &tstate->interp->ceval.pending;
@@ -1056,7 +1056,7 @@ _PyEval_MakePendingCalls(PyThreadState *tstate)
 int
 Py_MakePendingCalls(void)
 {
-    assert(PyGILState_Check());
+    assert(_Py_HoldsTstate());
 
     PyThreadState *tstate = _PyThreadState_GET();
     assert(_PyThreadState_CheckConsistency(tstate));

Python/errors.c

@@ -314,8 +314,8 @@ _PyErr_SetLocaleString(PyObject *exception, const char *string)
 PyObject* _Py_HOT_FUNCTION
 PyErr_Occurred(void)
 {
-    /* The caller must hold the GIL. */
-    assert(PyGILState_Check());
+    /* The caller must hold a thread state. */
+    assert(_Py_HoldsTstate());
 
     PyThreadState *tstate = _PyThreadState_GET();
     return _PyErr_Occurred(tstate);

Python/fileutils.c

@@ -1,6 +1,7 @@
 #include "Python.h"
 #include "pycore_fileutils.h"     // fileutils definitions
 #include "pycore_runtime.h"       // _PyRuntime
+#include "pycore_pystate.h"       // _Py_HoldsTstate
 #include "osdefs.h"               // SEP
 
 #include <stdlib.h>               // mbstowcs()
@@ -1311,7 +1312,7 @@ _Py_fstat(int fd, struct _Py_stat_struct *status)
 {
     int res;
 
-    assert(PyGILState_Check());
+    assert(_Py_HoldsTstate());
 
     Py_BEGIN_ALLOW_THREADS
     res = _Py_fstat_noraise(fd, status);
@@ -1691,7 +1692,7 @@ int
 _Py_open(const char *pathname, int flags)
 {
     /* _Py_open() must be called with the GIL held. */
-    assert(PyGILState_Check());
+    assert(_Py_HoldsTstate());
     return _Py_open_impl(pathname, flags, 1);
 }
 
@@ -1766,7 +1767,7 @@ _Py_wfopen(const wchar_t *path, const wchar_t *mode)
 FILE*
 Py_fopen(PyObject *path, const char *mode)
 {
-    assert(PyGILState_Check());
+    assert(_Py_HoldsTstate());
 
     if (PySys_Audit("open", "Osi", path, mode, 0) < 0) {
         return NULL;
@@ -1881,7 +1882,7 @@ _Py_read(int fd, void *buf, size_t count)
     int err;
     int async_err = 0;
 
-    assert(PyGILState_Check());
+    assert(_Py_HoldsTstate());
 
     /* _Py_read() must not be called with an exception set, otherwise the
      * caller may think that read() was interrupted by a signal and the signal
@@ -2047,7 +2048,7 @@ _Py_write_impl(int fd, const void *buf, size_t count, int gil_held)
 Py_ssize_t
 _Py_write(int fd, const void *buf, size_t count)
 {
-    assert(PyGILState_Check());
+    assert(_Py_HoldsTstate());
 
     /* _Py_write() must not be called with an exception set, otherwise the
      * caller may think that write() was interrupted by a signal and the signal
@@ -2675,7 +2676,7 @@ _Py_dup(int fd)
     HANDLE handle;
 #endif
 
-    assert(PyGILState_Check());
+    assert(_Py_HoldsTstate());
 
 #ifdef MS_WINDOWS
     handle = _Py_get_osfhandle(fd);

Python/legacy_tracing.c

@@ -491,8 +491,8 @@ int
 _PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg)
 {
     assert(is_tstate_valid(tstate));
-    /* The caller must hold the GIL */
-    assert(PyGILState_Check());
+    /* The caller must hold a thread state */
+    assert(_Py_HoldsTstate());
 
     /* Call _PySys_Audit() in the context of the current thread state,
        even if tstate is not the current thread state. */
@@ -586,8 +586,8 @@ int
 _PyEval_SetTrace(PyThreadState *tstate, Py_tracefunc func, PyObject *arg)
 {
     assert(is_tstate_valid(tstate));
-    /* The caller must hold the GIL */
-    assert(PyGILState_Check());
+    /* The caller must hold a thread state */
+    assert(_Py_HoldsTstate());
 
     /* Call _PySys_Audit() in the context of the current thread state,
        even if tstate is not the current thread state. */

Python/pystate.c

@@ -2897,7 +2897,6 @@ _PyInterpreterState_GetConfigCopy(PyConfig *config)
 const PyConfig*
 _Py_GetConfig(void)
 {
-    assert(PyGILState_Check());
     PyThreadState *tstate = current_fast_get();
     _Py_EnsureTstateNotNULL(tstate);
     return _PyInterpreterState_GetConfig(tstate->interp);

Python/pytime.c

@@ -1,5 +1,6 @@
 #include "Python.h"
 #include "pycore_time.h"          // PyTime_t
+#include "pycore_pystate.h"       // _Py_HoldsTstate
 
 #include <time.h>                 // gmtime_r()
 #ifdef HAVE_SYS_TIME_H
@@ -897,14 +898,14 @@ _PyTime_AsTimespec(PyTime_t t, struct timespec *ts)
 #endif
 
 
-// N.B. If raise_exc=0, this may be called without the GIL.
+// N.B. If raise_exc=0, this may be called without a thread state.
 static int
 py_get_system_clock(PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
 {
     assert(info == NULL || raise_exc);
     if (raise_exc) {
-        // raise_exc requires to hold the GIL
-        assert(PyGILState_Check());
+        // raise_exc requires to hold a thread state
+        assert(_Py_HoldsTstate());
     }
 
 #ifdef MS_WINDOWS
@@ -1142,14 +1143,14 @@ py_mach_timebase_info(_PyTimeFraction *base, int raise_exc)
 #endif
 
 
-// N.B. If raise_exc=0, this may be called without the GIL.
+// N.B. If raise_exc=0, this may be called without a thread state.
 static int
 py_get_monotonic_clock(PyTime_t *tp, _Py_clock_info_t *info, int raise_exc)
 {
     assert(info == NULL || raise_exc);
     if (raise_exc) {
-        // raise_exc requires to hold the GIL
-        assert(PyGILState_Check());
+        // raise_exc requires to hold a thread state
+        assert(_Py_HoldsTstate());
     }
 
 #if defined(MS_WINDOWS)

Python/tracemalloc.c

@@ -364,7 +364,7 @@ traceback_new(void)
     traceback_t *traceback;
     _Py_hashtable_entry_t *entry;
 
-    assert(PyGILState_Check());
+    assert(_Py_HoldsTstate());
 
     /* get frames */
     traceback = tracemalloc_traceback;
@@ -782,7 +782,7 @@ static void
 tracemalloc_clear_traces(void)
 {
     /* The GIL protects variables against concurrent access */
-    assert(PyGILState_Check());
+    assert(_Py_HoldsTstate());
 
     TABLES_LOCK();
     _Py_hashtable_clear(tracemalloc_traces);
@@ -1345,7 +1345,7 @@ PyTraceMalloc_Untrack(unsigned int domain, uintptr_t ptr)
 void
 _PyTraceMalloc_Fini(void)
 {
-    assert(PyGILState_Check());
+    assert(_Py_HoldsTstate());
     tracemalloc_deinit();
 }
 
@@ -1362,7 +1362,7 @@ _PyTraceMalloc_TraceRef(PyObject *op, PyRefTracerEvent event, void* Py_UNUSED(ig
         return 0;
     }
 
-    assert(PyGILState_Check());
+    assert(_Py_HoldsTstate());
 
     if (!tracemalloc_config.tracing) {
         /* tracemalloc is not tracing: do nothing */