Stackless issue #254: replace PyThreadState_GET b _PyThreadState_GET

bpo-35081 added _PyThreadState_GET() internal macro and changed the
C-Python code to use it. This commit updates Stackless code to use
_PyThreadState_GET().

Author: Anselm Kruis

Include/frameobject.h

@@ -17,7 +17,7 @@ typedef PyObject *(PyFrame_ExecFunc) (struct _frame *, int, PyObject *);
  *
  *  PyObject * example(PyFrameObject *f, int exc, PyObject *retval)
  *  {
- *     PyThreadState *ts = PyThreadState_GET();
+ *     PyThreadState *ts = _PyThreadState_GET();
  *
  *     do something ....
  *     if you change retval, use Py_SETREF(retval, new_value) or

Include/internal/pycore_stackless.h

@@ -244,17 +244,14 @@ PyObject * slp_wrap_call_frame(PyFrameObject *frame, int exc, PyObject *retval);
 
 #endif  /* #if (SLP_WITH_FRAME_REF_DEBUG == 2) */
 
-/* Access the thread state without a check for NULL */
-#define _SLP_PyThreadState_Current ((PyThreadState*)_Py_atomic_load_relaxed(&_PyThreadState_Current))
-
 /* Used in _Py_Dealloc() to eventually restore tstate->frame */
 #define SLP_WITH_VALID_CURRENT_FRAME(expr) \
     do { \
-        if (_SLP_PyThreadState_Current != NULL && \
-            (assert(_SLP_FRAME_STATE_IS_CONSISTENT(_SLP_PyThreadState_Current)), \
-            _SLP_FRAME_IN_TRANSFER(_SLP_PyThreadState_Current))) \
+        if (_PyThreadState_GET() != NULL && \
+            (assert(_SLP_FRAME_STATE_IS_CONSISTENT(_PyThreadState_GET())), \
+            _SLP_FRAME_IN_TRANSFER(_PyThreadState_GET()))) \
         { \
-            PyThreadState * ts = _SLP_PyThreadState_Current; \
+            PyThreadState * ts = _PyThreadState_GET(); \
             PyFrameObject * frame = SLP_CLAIM_NEXT_FRAME(ts); \
             (void)(expr); \
             assert(frame == NULL || Py_REFCNT(frame) >= 1); \
@@ -264,8 +261,8 @@ PyObject * slp_wrap_call_frame(PyFrameObject *frame, int exc, PyObject *retval);
             Py_XDECREF(frame); \
         } else { \
             (void)(expr); \
-            assert(_SLP_PyThreadState_Current == NULL || _SLP_FRAME_STATE_IS_CONSISTENT(_SLP_PyThreadState_Current)); \
-            assert(_SLP_PyThreadState_Current == NULL || !_SLP_FRAME_IN_TRANSFER(_SLP_PyThreadState_Current)); \
+            assert(_PyThreadState_GET() == NULL || _SLP_FRAME_STATE_IS_CONSISTENT(_PyThreadState_GET())); \
+            assert(_PyThreadState_GET() == NULL || !_SLP_FRAME_IN_TRANSFER(_PyThreadState_GET())); \
         } \
     } while (0)
 
@@ -446,7 +443,7 @@ PyTaskletObject * slp_get_watchdog(PyThreadState *ts, int interrupt);
 #undef STACKLESS__GETARG_ASSERT
 #endif
 #define STACKLESS__GETARG_ASSERT \
-    assert(SLP_CURRENT_FRAME_IS_VALID(PyThreadState_GET()))
+    assert(SLP_CURRENT_FRAME_IS_VALID(_PyThreadState_GET()))
 
 /* descr must be of type PyWrapperDescrObject, but this type is undocumented.
  * Therefore this macro is in pycore_stackless.h and not in stackless_api.h

Objects/abstract.c

@@ -2591,7 +2591,7 @@ PyIter_Next(PyObject *iter)
     STACKLESS_PROMOTE_METHOD(iter, tp_iternext);
     result = (*iter->ob_type->tp_iternext)(iter);
     STACKLESS_ASSERT();
-    STACKLESS_ASSERT_UNWINDING_VALUE_IS_NOT(PyThreadState_GET(), result, NULL);
+    STACKLESS_ASSERT_UNWINDING_VALUE_IS_NOT(_PyThreadState_GET(), result, NULL);
     if (result == NULL &&
         PyErr_Occurred() &&
         PyErr_ExceptionMatches(PyExc_StopIteration))

Objects/call.c

@@ -37,7 +37,7 @@ _Py_CheckFunctionResult(PyObject *callable, PyObject *result, const char *where)
 
     assert((callable != NULL) ^ (where != NULL));
 
-    if (STACKLESS_RETVAL(PyThreadState_GET(), result) == NULL) {
+    if (STACKLESS_RETVAL(_PyThreadState_GET(), result) == NULL) {
         if (!err_occurred) {
             if (callable)
                 PyErr_Format(PyExc_SystemError,
@@ -56,7 +56,7 @@ _Py_CheckFunctionResult(PyObject *callable, PyObject *result, const char *where)
     }
     else {
         if (err_occurred) {
-            Py_DECREF(STACKLESS_RETVAL(PyThreadState_GET(), result));
+            Py_DECREF(STACKLESS_RETVAL(_PyThreadState_GET(), result));
 
             if (callable) {
                 _PyErr_FormatFromCause(PyExc_SystemError,

Objects/genobject.c

@@ -342,7 +342,7 @@ gen_send_ex2(PyGenObject *gen, PyObject *arg, int exc, int closing, PyObject * o
 static PyObject*
 gen_iternext_callback(PyFrameObject *f, int exc, PyObject *result)
 {
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     PyCFrameObject *cf = (PyCFrameObject *) f;
     PyGenObject *gen = (PyGenObject *) cf->ob1;
     PyObject *arg = cf->ob2;

Objects/typeobject.c

@@ -5899,7 +5899,7 @@ wrap_next(PyObject *self, PyObject *args, void *wrapped)
     STACKLESS_PROMOTE_ALL();
     res = (*func)(self);
     STACKLESS_ASSERT();
-    STACKLESS_ASSERT_UNWINDING_VALUE_IS_NOT(PyThreadState_GET(), res, NULL);
+    STACKLESS_ASSERT_UNWINDING_VALUE_IS_NOT(_PyThreadState_GET(), res, NULL);
     if (res == NULL && !PyErr_Occurred())
         PyErr_SetNone(PyExc_StopIteration);
     return res;
@@ -6762,7 +6762,7 @@ slot_tp_descr_set(PyObject *self, PyObject *target, PyObject *value)
 PyObject *
 slp_tp_init_callback(PyFrameObject *f, int exc, PyObject *retval)
 {
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     PyCFrameObject *cf = (PyCFrameObject *) f;
 
     f = cf->f_back;
@@ -6805,7 +6805,7 @@ slot_tp_init(PyObject *self, PyObject *args, PyObject *kwds)
             return -1;
         Py_INCREF(self);
         f->ob1 = self;
-        SLP_SET_CURRENT_FRAME(PyThreadState_GET(), (PyFrameObject *) f);
+        SLP_SET_CURRENT_FRAME(_PyThreadState_GET(), (PyFrameObject *) f);
         /* f contains the only counted reference to current frame. This reference
          * keeps the fame alive during the following PyObject_Call().
          */
@@ -6823,7 +6823,7 @@ slot_tp_init(PyObject *self, PyObject *args, PyObject *kwds)
 #ifdef STACKLESS
     if (stackless && !STACKLESS_UNWINDING(res)) {
         /* required, because we added a C-frame */
-        PyThreadState *ts = PyThreadState_GET();
+        PyThreadState *ts = _PyThreadState_GET();
         STACKLESS_PACK(ts, res);
         assert(f);
         assert((PyFrameObject *)f == SLP_CURRENT_FRAME(ts));

Python/ceval.c

@@ -3892,7 +3892,7 @@ slp_eval_frame_yield_from(PyFrameObject *f, int throwflag, PyObject *retval)
 static PyObject *
 run_frame_dispatch(PyFrameObject *f, int exc, PyObject *retval)
 {
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     PyCFrameObject *cf = (PyCFrameObject*) f;
     PyFrameObject *f_back;
     int done = cf->i;
@@ -3938,7 +3938,7 @@ _PyEval_EvalFrameDefault(PyFrameObject *f, int throwflag)
      * This method is not used by Stackless Python. It is provided for compatibility
      * with extension modules and Cython.
      */
-    PyThreadState *tstate = PyThreadState_GET();
+    PyThreadState *tstate = _PyThreadState_GET();
     PyObject * retval = NULL;
     PyFrameObject * f_back;
 
@@ -4056,7 +4056,7 @@ _PyEval_EvalFrameDefault(PyFrameObject *f, int throwflag)
 PyObject * _Py_HOT_FUNCTION
 PyEval_EvalFrameEx_slp(PyFrameObject *f, int throwflag, PyObject *retval)
 {
-    PyThreadState *tstate = PyThreadState_GET();
+    PyThreadState *tstate = _PyThreadState_GET();
 
     /* Check, if an extension module has changed tstate->interp->eval_frame.
      * PEP 523 defines this function pointer as an API to customise the frame
@@ -5111,7 +5111,7 @@ PyEval_GetGlobals(void)
     PyFrameObject *current_frame = PyEval_GetFrame();
 #if 1 && defined STACKLESS
     if (current_frame == NULL) {
-        PyThreadState *ts = PyThreadState_GET();
+        PyThreadState *ts = _PyThreadState_GET();
 
         if (ts->st.current != NULL)
             return ts->st.current->def_globals;

Python/context.c

@@ -627,7 +627,7 @@ PyObject* slp_context_run_callback(PyFrameObject *f, int exc, PyObject *result)
 
     if (cf->i) {
         /* called by tasklet.context_run(...) */
-        PyThreadState *ts = PyThreadState_GET();
+        PyThreadState *ts = _PyThreadState_GET();
         assert(ts);
         assert(NULL == context || PyContext_CheckExact(context));
         Py_XSETREF(ts->context, context);
@@ -640,7 +640,7 @@ PyObject* slp_context_run_callback(PyFrameObject *f, int exc, PyObject *result)
         Py_DECREF(context);
     }
 
-    SLP_STORE_NEXT_FRAME(PyThreadState_GET(), cf->f_back);
+    SLP_STORE_NEXT_FRAME(_PyThreadState_GET(), cf->f_back);
     return result;
 }
 
@@ -666,7 +666,7 @@ context_run(PyContext *self, PyObject *const *args,
     }
 
 #ifdef STACKLESS
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     PyCFrameObject *f = NULL;
     if (stackless) {
         f = slp_cframe_new(slp_context_run_callback, 1);

Stackless/core/cframeobject.c

@@ -91,7 +91,7 @@ cframe_clear(PyCFrameObject *cf)
 PyCFrameObject *
 slp_cframe_new(PyFrame_ExecFunc *exec, unsigned int linked)
 {
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     PyCFrameObject *cf;
     PyFrameObject *back;
 
@@ -247,7 +247,7 @@ static PyMethodDef cframe_methods[] = {
 
 static PyObject * run_cframe(PyFrameObject *f, int exc, PyObject *retval)
 {
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     PyCFrameObject *cf = (PyCFrameObject*) f;
     PyTaskletObject *task = ts->st.current;
     int done = cf->i;
@@ -452,7 +452,7 @@ execute_soft_switchable_func(PyFrameObject *f, int exc, PyObject *retval)
      * Special rule for frame execution functions: we now own a reference to retval!
      */
     PyCFrameObject *cf = (PyCFrameObject *)f;
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     PyObject *ob1, *ob2, *ob3;
     PyStacklessFunctionDeclarationObject *ssfd =
             (PyStacklessFunctionDeclarationObject*)cf->any2;
@@ -504,7 +504,7 @@ PyStackless_CallFunction(PyStacklessFunctionDeclarationObject *ssfd, PyObject *a
         PyObject *ob1, PyObject *ob2, PyObject *ob3, long n, void *any)
 {
     STACKLESS_GETARG();
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     PyObject *et=NULL, *ev=NULL, *tb=NULL;
 
     assert(ssfd);

Stackless/core/slp_transfer.c

@@ -101,7 +101,7 @@ climb_stack_and_transfer(PyCStackObject **cstprev, PyCStackObject *cst,
      * need to switch from a higher stacklevel, and the
      * needed stack size becomes *negative* :-))
      */
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     intptr_t probe;
     register ptrdiff_t needed = &probe - ts->st.cstack_base;
     /* in rare cases, the need might have vanished due to the recursion */
@@ -124,7 +124,7 @@ int
 slp_transfer(PyCStackObject **cstprev, PyCStackObject *cst,
              PyTaskletObject *prev)
 {
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     int result;
     /* Use a volatile pointer to prevent inlining of slp_switch().
      * See Stackless issue 183

Stackless/core/stackless_util.c

@@ -58,7 +58,7 @@ slp_get_frame(PyTaskletObject *task)
 
 void slp_check_pending_irq()
 {
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     PyTaskletObject *current = ts->st.current;
 
     /* act only if hard irq is in effect */
@@ -80,7 +80,7 @@ slp_return_wrapper(PyObject *retval)
     if (retval == NULL)
         return -1;
     if (STACKLESS_UNWINDING(retval)) {
-        STACKLESS_UNPACK(PyThreadState_GET(), retval);
+        STACKLESS_UNPACK(_PyThreadState_GET(), retval);
         Py_XDECREF(retval);
         return 1;
     }
@@ -115,7 +115,7 @@ slp_int_wrapper(PyObject *retval)
 int
 slp_current_wrapper( int(*func)(PyTaskletObject*), PyTaskletObject *task )
 {
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
 
     int ret;
     ts->st.main = (PyTaskletObject*)Py_None;

Stackless/core/stacklesseval.c

@@ -41,7 +41,7 @@ static void slp_cstack_cacheclear(void)
 static void
 cstack_dealloc(PyCStackObject *cst)
 {
-    PyThreadState * ts = PyThreadState_GET();
+    PyThreadState * ts = _PyThreadState_GET();
     ts->interp->st.cstack_chain = cst;
     SLP_CHAIN_REMOVE(PyCStackObject, &ts->interp->st.cstack_chain, cst, next,
                      prev);
@@ -77,13 +77,13 @@ slp_cstack_new(PyCStackObject **cst, intptr_t *stackref, PyTaskletObject *task)
         ts = task->cstate->tstate;
     }
     if (ts == NULL) {
-        ts = PyThreadState_GET();
+        ts = _PyThreadState_GET();
     }
 
     stackbase = ts->st.cstack_base;
     size = stackbase - stackref;
 
-    assert(size == 0 || ts == PyThreadState_GET());
+    assert(size == 0 || ts == _PyThreadState_GET());
     assert(size >= 0);
 
     if (*cst != NULL) {
@@ -223,7 +223,7 @@ PyTypeObject PyCStack_Type = {
 static int
 make_initial_stub(void)
 {
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     int result;
 
     Py_CLEAR(ts->st.initial_stub);
@@ -253,7 +253,7 @@ climb_stack_and_eval_frame(PyFrameObject *f)
      * This way, initial_stub is always valid to be
      * used to return to the main c stack.
      */
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     intptr_t probe;
     ptrdiff_t needed = &probe - ts->st.cstack_base;
     /* in rare cases, the need might have vanished due to the recursion */
@@ -279,7 +279,7 @@ slp_run_tasklet(void)
      * slp_transfer_return(). Therefore, this function must not hold
      * any reference during the execution of these sub-functions.
      */
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     PyObject *retval;
 
     SLP_ASSERT_FRAME_IN_TRANSFER(ts);
@@ -314,7 +314,7 @@ slp_run_tasklet(void)
 PyObject * _Py_HOT_FUNCTION
 slp_eval_frame(PyFrameObject *f)
 {
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     PyFrameObject *fprev = f->f_back;
     intptr_t * stackref;
     PyObject *retval;
@@ -405,7 +405,7 @@ get_current_main_and_watchdogs(PyThreadState *ts, PyObject *list)
 {
     PyTaskletObject *t;
 
-    assert(ts != PyThreadState_GET());  /* don't kill ourself */
+    assert(ts != _PyThreadState_GET());  /* don't kill ourself */
     assert(PyList_CheckExact(list));
 
     /* kill watchdogs */
@@ -501,7 +501,7 @@ run_other_threads(PyObject **sleep, Py_ssize_t count)
  */
 void slp_kill_tasks_with_stacks(PyThreadState *target_ts)
 {
-    PyThreadState *cts = PyThreadState_GET();
+    PyThreadState *cts = _PyThreadState_GET();
     PyInterpreterState * interp = cts->interp;
     int in_loop = 0;
 
@@ -845,7 +845,7 @@ void PyStackless_kill_tasks_with_stacks(int allthreads)
 static PyObject *
 eval_frame_callback(PyFrameObject *f, int exc, PyObject *retval)
 {
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     PyTaskletObject *cur = ts->st.current;
     PyCStackObject *cst;
     PyCFrameObject *cf = (PyCFrameObject *) f;
@@ -917,7 +917,7 @@ eval_frame_callback(PyFrameObject *f, int exc, PyObject *retval)
 PyObject *
 slp_eval_frame_newstack(PyFrameObject *f, int exc, PyObject *retval)
 {
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     PyTaskletObject *cur = ts->st.current;
     PyCFrameObject *cf = NULL;
     PyCStackObject *cst;
@@ -1026,7 +1026,7 @@ PyUnwindObject *Py_UnwindToken = &unwind_token;
 PyObject * _Py_HOT_FUNCTION
 slp_frame_dispatch(PyFrameObject *f, PyFrameObject *stopframe, int exc, PyObject *retval)
 {
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     PyFrameObject *first_frame = f;
     ++ts->st.nesting_level;
 
@@ -1070,7 +1070,7 @@ slp_frame_dispatch(PyFrameObject *f, PyFrameObject *stopframe, int exc, PyObject
 static PyObject *
 slp_frame_dispatch_top(PyObject *retval)
 {
-    PyThreadState *ts = PyThreadState_GET();
+    PyThreadState *ts = _PyThreadState_GET();
     PyFrameObject *f = SLP_CLAIM_NEXT_FRAME(ts);
 
     if (f==NULL) return retval;