From 50b48572d9a90c5bb36e2bef6179548ea927a35a Mon Sep 17 00:00:00 2001 From: Victor Stinner Date: Thu, 1 Nov 2018 01:51:40 +0100 Subject: [PATCH] bpo-35081: Add _PyThreadState_GET() internal macro (GH-10266) If Py_BUILD_CORE is defined, the PyThreadState_GET() macro access _PyRuntime which comes from the internal pycore_state.h header. Public headers must not require internal headers. Move PyThreadState_GET() and _PyInterpreterState_GET_UNSAFE() from Include/pystate.h to Include/internal/pycore_state.h, and rename PyThreadState_GET() to _PyThreadState_GET() there. The PyThreadState_GET() macro of pystate.h is now redefined when pycore_state.h is included, to use the fast _PyThreadState_GET(). Changes: * Add _PyThreadState_GET() macro * Replace "PyThreadState_GET()->interp" with _PyInterpreterState_GET_UNSAFE() * Replace PyThreadState_GET() with _PyThreadState_GET() in internal C files (compiled with Py_BUILD_CORE defined), but keep PyThreadState_GET() in the public header files. * _testcapimodule.c: replace PyThreadState_GET() with PyThreadState_Get(); the module is not compiled with Py_BUILD_CORE defined. * pycore_state.h now requires Py_BUILD_CORE to be defined. --- Include/internal/pycore_state.h | 34 ++++++++++++++++++++ Include/pystate.h | 56 ++++++++++++++++++--------------- Modules/_testcapimodule.c | 2 +- Objects/call.c | 2 +- Objects/dictobject.c | 4 +-- Objects/genobject.c | 6 ++-- Objects/object.c | 4 +-- Objects/odictobject.c | 2 +- Objects/typeobject.c | 4 +-- Parser/myreadline.c | 4 +-- Python/_warnings.c | 2 +- Python/ceval.c | 50 ++++++++++++++--------------- Python/context.c | 8 ++--- Python/errors.c | 12 +++---- Python/pylifecycle.c | 8 ++--- Python/pystate.c | 18 +++++------ Python/symtable.c | 2 +- Python/sysmodule.c | 18 +++++------ Python/thread_nt.h | 6 ++-- Python/thread_pthread.h | 6 ++-- 20 files changed, 144 insertions(+), 104 deletions(-) diff --git a/Include/internal/pycore_state.h b/Include/internal/pycore_state.h index ff25d2ebf44..9a084f7f4d8 100644 --- a/Include/internal/pycore_state.h +++ b/Include/internal/pycore_state.h @@ -4,6 +4,10 @@ extern "C" { #endif +#ifndef Py_BUILD_CORE +# error "Py_BUILD_CORE must be defined to include this header" +#endif + #include "pystate.h" #include "pythread.h" @@ -214,6 +218,36 @@ PyAPI_FUNC(_PyInitError) _PyRuntime_Initialize(void); (_PyRuntime.finalizing == tstate) +/* Variable and macro for in-line access to current thread + and interpreter state */ + +/* Get the current Python thread state. + + Efficient macro reading directly the 'gilstate.tstate_current' atomic + variable. The macro is unsafe: it does not check for error and it can + return NULL. + + The caller must hold the GIL. + + See also PyThreadState_Get() and PyThreadState_GET(). */ +#define _PyThreadState_GET() \ + ((PyThreadState*)_Py_atomic_load_relaxed(&_PyRuntime.gilstate.tstate_current)) + +/* Redefine PyThreadState_GET() as an alias to _PyThreadState_GET() */ +#undef PyThreadState_GET +#define PyThreadState_GET() _PyThreadState_GET() + +/* Get the current interpreter state. + + The macro is unsafe: it does not check for error and it can return NULL. + + The caller must hold the GIL. + + See also _PyInterpreterState_Get() + and _PyGILState_GetInterpreterStateUnsafe(). */ +#define _PyInterpreterState_GET_UNSAFE() (_PyThreadState_GET()->interp) + + /* Other */ PyAPI_FUNC(_PyInitError) _PyInterpreterState_Enable(_PyRuntimeState *); diff --git a/Include/pystate.h b/Include/pystate.h index 7fc921e9ac7..b30c3187b67 100644 --- a/Include/pystate.h +++ b/Include/pystate.h @@ -245,15 +245,17 @@ typedef struct _ts { PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_New(void); PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState *); PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState *); + #if !defined(Py_LIMITED_API) +/* Get the current interpreter state. + + Issue a fatal error if there no current Python thread state or no current + interpreter. It cannot return NULL. + + The caller must hold the GIL.*/ PyAPI_FUNC(PyInterpreterState *) _PyInterpreterState_Get(void); #endif -#ifdef Py_BUILD_CORE - /* Macro which should only be used for performance critical code. - Need "#include "pycore_state.h". See also _PyInterpreterState_Get() - and _PyGILState_GetInterpreterStateUnsafe(). */ -# define _PyInterpreterState_GET_UNSAFE() (PyThreadState_GET()->interp) -#endif + #if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000 /* New in 3.7 */ PyAPI_FUNC(int64_t) PyInterpreterState_GetID(PyInterpreterState *); @@ -286,11 +288,27 @@ PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void); PyAPI_FUNC(void) _PyGILState_Reinit(void); #endif /* !Py_LIMITED_API */ -/* Return the current thread state. The global interpreter lock must be held. - * When the current thread state is NULL, this issues a fatal error (so that - * the caller needn't check for NULL). */ +/* Get the current thread state. + + When the current thread state is NULL, this issues a fatal error (so that + the caller needn't check for NULL). + + The caller must hold the GIL. + + See also PyThreadState_GET() and _PyThreadState_GET(). */ PyAPI_FUNC(PyThreadState *) PyThreadState_Get(void); +/* Get the current Python thread state. + + Macro using PyThreadState_Get() or _PyThreadState_GET() depending if + pycore_state.h is included or not (this header redefines the macro). + + If PyThreadState_Get() is used, issue a fatal error if the current thread + state is NULL. + + See also PyThreadState_Get() and _PyThreadState_GET(). */ +#define PyThreadState_GET() PyThreadState_Get() + #ifndef Py_LIMITED_API /* Similar to PyThreadState_Get(), but don't issue a fatal error * if it is NULL. */ @@ -301,18 +319,6 @@ PyAPI_FUNC(PyThreadState *) PyThreadState_Swap(PyThreadState *); PyAPI_FUNC(PyObject *) PyThreadState_GetDict(void); PyAPI_FUNC(int) PyThreadState_SetAsyncExc(unsigned long, PyObject *); - -/* Variable and macro for in-line access to current thread state */ - -/* Assuming the current thread holds the GIL, this is the - PyThreadState for the current thread. */ -#ifdef Py_BUILD_CORE -# define PyThreadState_GET() \ - ((PyThreadState*)_Py_atomic_load_relaxed(&_PyRuntime.gilstate.tstate_current)) -#else -# define PyThreadState_GET() PyThreadState_Get() -#endif - typedef enum {PyGILState_LOCKED, PyGILState_UNLOCKED} PyGILState_STATE; @@ -366,11 +372,11 @@ PyAPI_FUNC(PyThreadState *) PyGILState_GetThisThreadState(void); The function returns 1 if _PyGILState_check_enabled is non-zero. */ PyAPI_FUNC(int) PyGILState_Check(void); -/* Unsafe function to get the single PyInterpreterState used by this process' - GILState implementation. +/* Get the single PyInterpreterState used by this process' GILState + implementation. - Return NULL before _PyGILState_Init() is called and after _PyGILState_Fini() - is called. + This function doesn't check for error. Return NULL before _PyGILState_Init() + is called and after _PyGILState_Fini() is called. See also _PyInterpreterState_Get() and _PyInterpreterState_GET_UNSAFE(). */ PyAPI_FUNC(PyInterpreterState *) _PyGILState_GetInterpreterStateUnsafe(void); diff --git a/Modules/_testcapimodule.c b/Modules/_testcapimodule.c index b2cda514230..018af4a1370 100644 --- a/Modules/_testcapimodule.c +++ b/Modules/_testcapimodule.c @@ -4160,7 +4160,7 @@ test_PyTime_AsMicroseconds(PyObject *self, PyObject *args) static PyObject* get_recursion_depth(PyObject *self, PyObject *args) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = PyThreadState_Get(); /* subtract one to ignore the frame of the get_recursion_depth() call */ return PyLong_FromLong(tstate->recursion_depth - 1); diff --git a/Objects/call.c b/Objects/call.c index 9061d0b1ac3..48e3aafe5fe 100644 --- a/Objects/call.c +++ b/Objects/call.c @@ -258,7 +258,7 @@ function_code_fastcall(PyCodeObject *co, PyObject *const *args, Py_ssize_t nargs PyObject *globals) { PyFrameObject *f; - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); PyObject **fastlocals; Py_ssize_t i; PyObject *result; diff --git a/Objects/dictobject.c b/Objects/dictobject.c index a9ae907d9f2..ea564a2b7c9 100644 --- a/Objects/dictobject.c +++ b/Objects/dictobject.c @@ -1314,9 +1314,9 @@ PyDict_GetItem(PyObject *op, PyObject *key) /* We can arrive here with a NULL tstate during initialization: try running "python -Wi" for an example related to string interning. Let's just hope that no exception occurs then... This must be - PyThreadState_GET() and not PyThreadState_Get() because the latter + _PyThreadState_GET() and not PyThreadState_Get() because the latter abort Python if tstate is NULL. */ - tstate = PyThreadState_GET(); + tstate = _PyThreadState_GET(); if (tstate != NULL && tstate->curexc_type != NULL) { /* preserve the existing exception */ PyObject *err_type, *err_value, *err_tb; diff --git a/Objects/genobject.c b/Objects/genobject.c index 885b3f2eca7..7c2948bb52d 100644 --- a/Objects/genobject.c +++ b/Objects/genobject.c @@ -151,7 +151,7 @@ gen_dealloc(PyGenObject *gen) static PyObject * gen_send_ex(PyGenObject *gen, PyObject *arg, int exc, int closing) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); PyFrameObject *f = gen->gi_frame; PyObject *result; @@ -1157,7 +1157,7 @@ PyCoro_New(PyFrameObject *f, PyObject *name, PyObject *qualname) return NULL; } - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); int origin_depth = tstate->coroutine_origin_tracking_depth; if (origin_depth == 0) { @@ -1267,7 +1267,7 @@ async_gen_init_hooks(PyAsyncGenObject *o) o->ag_hooks_inited = 1; - tstate = PyThreadState_GET(); + tstate = _PyThreadState_GET(); finalizer = tstate->async_gen_finalizer; if (finalizer) { diff --git a/Objects/object.c b/Objects/object.c index f7395c783ae..d3a97f6c5bd 100644 --- a/Objects/object.c +++ b/Objects/object.c @@ -2136,7 +2136,7 @@ _PyTrash_deposit_object(PyObject *op) void _PyTrash_thread_deposit_object(PyObject *op) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); _PyObject_ASSERT(op, PyObject_IS_GC(op)); _PyObject_ASSERT(op, !_PyObject_GC_IS_TRACKED(op)); _PyObject_ASSERT(op, op->ob_refcnt == 0); @@ -2174,7 +2174,7 @@ _PyTrash_destroy_chain(void) void _PyTrash_thread_destroy_chain(void) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); /* We need to increase trash_delete_nesting here, otherwise, _PyTrash_thread_destroy_chain will be called recursively and then possibly crash. An example that may crash without diff --git a/Objects/odictobject.c b/Objects/odictobject.c index 81c996be561..52ac7e5f88b 100644 --- a/Objects/odictobject.c +++ b/Objects/odictobject.c @@ -1355,7 +1355,7 @@ static PyGetSetDef odict_getset[] = { static void odict_dealloc(PyODictObject *self) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); PyObject_GC_UnTrack(self); Py_TRASHCAN_SAFE_BEGIN(self) diff --git a/Objects/typeobject.c b/Objects/typeobject.c index 9a390b3e507..dedc4f7c876 100644 --- a/Objects/typeobject.c +++ b/Objects/typeobject.c @@ -1115,7 +1115,7 @@ subtype_dealloc(PyObject *self) { PyTypeObject *type, *base; destructor basedealloc; - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); int has_finalizer; /* Extract the type; we expect it to be a heap type */ @@ -7678,7 +7678,7 @@ super_init(PyObject *self, PyObject *args, PyObject *kwds) PyFrameObject *f; PyCodeObject *co; Py_ssize_t i, n; - f = PyThreadState_GET()->frame; + f = _PyThreadState_GET()->frame; if (f == NULL) { PyErr_SetString(PyExc_RuntimeError, "super(): no current frame"); diff --git a/Parser/myreadline.c b/Parser/myreadline.c index d18cf1b61ba..f511319814a 100644 --- a/Parser/myreadline.c +++ b/Parser/myreadline.c @@ -301,7 +301,7 @@ PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, const char *prompt) char *rv, *res; size_t len; - if (_PyOS_ReadlineTState == PyThreadState_GET()) { + if (_PyOS_ReadlineTState == _PyThreadState_GET()) { PyErr_SetString(PyExc_RuntimeError, "can't re-enter readline"); return NULL; @@ -316,7 +316,7 @@ PyOS_Readline(FILE *sys_stdin, FILE *sys_stdout, const char *prompt) _PyOS_ReadlineLock = PyThread_allocate_lock(); } - _PyOS_ReadlineTState = PyThreadState_GET(); + _PyOS_ReadlineTState = _PyThreadState_GET(); Py_BEGIN_ALLOW_THREADS PyThread_acquire_lock(_PyOS_ReadlineLock, 1); diff --git a/Python/_warnings.c b/Python/_warnings.c index 619ec6f26b4..9b50289bb67 100644 --- a/Python/_warnings.c +++ b/Python/_warnings.c @@ -671,7 +671,7 @@ setup_context(Py_ssize_t stack_level, PyObject **filename, int *lineno, PyObject *globals; /* Setup globals, filename and lineno. */ - PyFrameObject *f = PyThreadState_GET()->frame; + PyFrameObject *f = _PyThreadState_GET()->frame; // Stack level comparisons to Python code is off by one as there is no // warnings-related stack level to avoid. if (stack_level <= 0 || is_internal_frame(f)) { diff --git a/Python/ceval.c b/Python/ceval.c index 5599b6efa3e..ac9db1533bf 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -157,7 +157,7 @@ PyEval_InitThreads(void) if (gil_created()) return; create_gil(); - take_gil(PyThreadState_GET()); + take_gil(_PyThreadState_GET()); _PyRuntime.ceval.pending.main_thread = PyThread_get_thread_ident(); if (!_PyRuntime.ceval.pending.lock) _PyRuntime.ceval.pending.lock = PyThread_allocate_lock(); @@ -175,7 +175,7 @@ _PyEval_FiniThreads(void) void PyEval_AcquireLock(void) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); if (tstate == NULL) Py_FatalError("PyEval_AcquireLock: current thread state is NULL"); take_gil(tstate); @@ -185,10 +185,10 @@ void PyEval_ReleaseLock(void) { /* This function must succeed when the current thread state is NULL. - We therefore avoid PyThreadState_GET() which dumps a fatal error + We therefore avoid PyThreadState_Get() which dumps a fatal error in debug mode. */ - drop_gil(PyThreadState_GET()); + drop_gil(_PyThreadState_GET()); } void @@ -222,7 +222,7 @@ PyEval_ReleaseThread(PyThreadState *tstate) void PyEval_ReInitThreads(void) { - PyThreadState *current_tstate = PyThreadState_GET(); + PyThreadState *current_tstate = _PyThreadState_GET(); if (!gil_created()) return; @@ -462,7 +462,7 @@ Py_SetRecursionLimit(int new_limit) int _Py_CheckRecursiveCall(const char *where) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); int recursion_limit = _PyRuntime.ceval.recursion_limit; #ifdef USE_STACKCHECK @@ -543,7 +543,7 @@ _PyEval_EvalFrameDefault(PyFrameObject *f, int throwflag) int oparg; /* Current opcode argument, if any */ PyObject **fastlocals, **freevars; PyObject *retval = NULL; /* Return value */ - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); PyCodeObject *co; /* when tracing we set things up so that @@ -3702,7 +3702,7 @@ _PyEval_EvalCodeWithName(PyObject *_co, PyObject *globals, PyObject *locals, } /* Create the frame */ - tstate = PyThreadState_GET(); + tstate = _PyThreadState_GET(); assert(tstate != NULL); f = _PyFrame_New_NoTrack(tstate, co, globals, locals); if (f == NULL) { @@ -4003,7 +4003,7 @@ do_raise(PyObject *exc, PyObject *cause) if (exc == NULL) { /* Reraise */ - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); _PyErr_StackItem *exc_info = _PyErr_GetTopmostException(tstate); PyObject *tb; type = exc_info->exc_type; @@ -4275,7 +4275,7 @@ call_trace(Py_tracefunc func, PyObject *obj, PyObject * _PyEval_CallTracing(PyObject *func, PyObject *args) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); int save_tracing = tstate->tracing; int save_use_tracing = tstate->use_tracing; PyObject *result; @@ -4329,7 +4329,7 @@ maybe_call_line_trace(Py_tracefunc func, PyObject *obj, void PyEval_SetProfile(Py_tracefunc func, PyObject *arg) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); PyObject *temp = tstate->c_profileobj; Py_XINCREF(arg); tstate->c_profilefunc = NULL; @@ -4346,7 +4346,7 @@ PyEval_SetProfile(Py_tracefunc func, PyObject *arg) void PyEval_SetTrace(Py_tracefunc func, PyObject *arg) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); PyObject *temp = tstate->c_traceobj; _Py_TracingPossible += (func != NULL) - (tstate->c_tracefunc != NULL); Py_XINCREF(arg); @@ -4366,21 +4366,21 @@ void _PyEval_SetCoroutineOriginTrackingDepth(int new_depth) { assert(new_depth >= 0); - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); tstate->coroutine_origin_tracking_depth = new_depth; } int _PyEval_GetCoroutineOriginTrackingDepth(void) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); return tstate->coroutine_origin_tracking_depth; } void _PyEval_SetCoroutineWrapper(PyObject *wrapper) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); Py_XINCREF(wrapper); Py_XSETREF(tstate->coroutine_wrapper, wrapper); @@ -4389,14 +4389,14 @@ _PyEval_SetCoroutineWrapper(PyObject *wrapper) PyObject * _PyEval_GetCoroutineWrapper(void) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); return tstate->coroutine_wrapper; } void _PyEval_SetAsyncGenFirstiter(PyObject *firstiter) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); Py_XINCREF(firstiter); Py_XSETREF(tstate->async_gen_firstiter, firstiter); @@ -4405,14 +4405,14 @@ _PyEval_SetAsyncGenFirstiter(PyObject *firstiter) PyObject * _PyEval_GetAsyncGenFirstiter(void) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); return tstate->async_gen_firstiter; } void _PyEval_SetAsyncGenFinalizer(PyObject *finalizer) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); Py_XINCREF(finalizer); Py_XSETREF(tstate->async_gen_finalizer, finalizer); @@ -4421,7 +4421,7 @@ _PyEval_SetAsyncGenFinalizer(PyObject *finalizer) PyObject * _PyEval_GetAsyncGenFinalizer(void) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); return tstate->async_gen_finalizer; } @@ -4465,7 +4465,7 @@ PyEval_GetGlobals(void) PyFrameObject * PyEval_GetFrame(void) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); return _PyThreadState_GetFrame(tstate); } @@ -4566,11 +4566,11 @@ call_function(PyObject ***pp_stack, Py_ssize_t oparg, PyObject *kwnames) presumed to be the most frequent callable object. */ if (PyCFunction_Check(func)) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); C_TRACE(x, _PyCFunction_FastCallKeywords(func, stack, nargs, kwnames)); } else if (Py_TYPE(func) == &PyMethodDescr_Type) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); if (nargs > 0 && tstate->use_tracing) { /* We need to create a temporary bound method as argument for profiling. @@ -4640,12 +4640,12 @@ do_call_core(PyObject *func, PyObject *callargs, PyObject *kwdict) PyObject *result; if (PyCFunction_Check(func)) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); C_TRACE(result, PyCFunction_Call(func, callargs, kwdict)); return result; } else if (Py_TYPE(func) == &PyMethodDescr_Type) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); Py_ssize_t nargs = PyTuple_GET_SIZE(callargs); if (nargs > 0 && tstate->use_tracing) { /* We need to create a temporary bound method as argument diff --git a/Python/context.c b/Python/context.c index b1f67b5aa75..1fb2a5de2b1 100644 --- a/Python/context.c +++ b/Python/context.c @@ -112,7 +112,7 @@ PyContext_Enter(PyObject *octx) return -1; } - PyThreadState *ts = PyThreadState_GET(); + PyThreadState *ts = _PyThreadState_GET(); assert(ts != NULL); ctx->ctx_prev = (PyContext *)ts->context; /* borrow */ @@ -138,7 +138,7 @@ PyContext_Exit(PyObject *octx) return -1; } - PyThreadState *ts = PyThreadState_GET(); + PyThreadState *ts = _PyThreadState_GET(); assert(ts != NULL); if (ts->context != (PyObject *)ctx) { @@ -178,7 +178,7 @@ PyContextVar_Get(PyObject *ovar, PyObject *def, PyObject **val) ENSURE_ContextVar(ovar, -1) PyContextVar *var = (PyContextVar *)ovar; - PyThreadState *ts = PyThreadState_GET(); + PyThreadState *ts = _PyThreadState_GET(); assert(ts != NULL); if (ts->context == NULL) { goto not_found; @@ -382,7 +382,7 @@ context_new_from_vars(PyHamtObject *vars) static inline PyContext * context_get(void) { - PyThreadState *ts = PyThreadState_GET(); + PyThreadState *ts = _PyThreadState_GET(); assert(ts != NULL); PyContext *current_ctx = (PyContext *)ts->context; if (current_ctx == NULL) { diff --git a/Python/errors.c b/Python/errors.c index 14a70d9ce8e..4c6c34c74fa 100644 --- a/Python/errors.c +++ b/Python/errors.c @@ -28,7 +28,7 @@ _Py_IDENTIFIER(stderr); void PyErr_Restore(PyObject *type, PyObject *value, PyObject *traceback) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); PyObject *oldtype, *oldvalue, *oldtraceback; if (traceback != NULL && !PyTraceBack_Check(traceback)) { @@ -82,7 +82,7 @@ _PyErr_CreateException(PyObject *exception, PyObject *value) void PyErr_SetObject(PyObject *exception, PyObject *value) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); PyObject *exc_value; PyObject *tb = NULL; @@ -175,7 +175,7 @@ PyErr_SetString(PyObject *exception, const char *string) PyObject* _Py_HOT_FUNCTION PyErr_Occurred(void) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); return tstate == NULL ? NULL : tstate->curexc_type; } @@ -334,7 +334,7 @@ PyErr_NormalizeException(PyObject **exc, PyObject **val, PyObject **tb) void PyErr_Fetch(PyObject **p_type, PyObject **p_value, PyObject **p_traceback) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); *p_type = tstate->curexc_type; *p_value = tstate->curexc_value; @@ -354,7 +354,7 @@ PyErr_Clear(void) void PyErr_GetExcInfo(PyObject **p_type, PyObject **p_value, PyObject **p_traceback) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); _PyErr_StackItem *exc_info = _PyErr_GetTopmostException(tstate); *p_type = exc_info->exc_type; @@ -371,7 +371,7 @@ void PyErr_SetExcInfo(PyObject *p_type, PyObject *p_value, PyObject *p_traceback) { PyObject *oldtype, *oldvalue, *oldtraceback; - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); oldtype = tstate->exc_info->exc_type; oldvalue = tstate->exc_info->exc_value; diff --git a/Python/pylifecycle.c b/Python/pylifecycle.c index d349aaf6dec..160f30ce6d6 100644 --- a/Python/pylifecycle.c +++ b/Python/pylifecycle.c @@ -530,7 +530,7 @@ _Py_InitializeCore_impl(PyInterpreterState **interp_p, /* bpo-34008: For backward compatibility reasons, calling Py_Main() after Py_Initialize() ignores the new configuration. */ if (_PyRuntime.core_initialized) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); if (!tstate) { return _Py_INIT_ERR("failed to read thread state"); } @@ -1009,7 +1009,7 @@ Py_FinalizeEx(void) wait_for_thread_shutdown(); /* Get current thread state and interpreter pointer */ - tstate = PyThreadState_GET(); + tstate = _PyThreadState_GET(); interp = tstate->interp; /* The interpreter is still entirely intact at this point, and the @@ -1406,7 +1406,7 @@ Py_EndInterpreter(PyThreadState *tstate) { PyInterpreterState *interp = tstate->interp; - if (tstate != PyThreadState_GET()) + if (tstate != _PyThreadState_GET()) Py_FatalError("Py_EndInterpreter: thread is not current"); if (tstate->frame != NULL) Py_FatalError("Py_EndInterpreter: thread still has a frame"); @@ -1928,7 +1928,7 @@ fatal_error(const char *prefix, const char *msg, int status) and holds the GIL */ PyThreadState *tss_tstate = PyGILState_GetThisThreadState(); if (tss_tstate != NULL) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); if (tss_tstate != tstate) { /* The Python thread does not hold the GIL */ tss_tstate = NULL; diff --git a/Python/pystate.c b/Python/pystate.c index c77902a7f9c..c193a10c8cb 100644 --- a/Python/pystate.c +++ b/Python/pystate.c @@ -307,7 +307,7 @@ _PyInterpreterState_DeleteExceptMain() PyInterpreterState * _PyInterpreterState_Get(void) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); if (tstate == NULL) { Py_FatalError("_PyInterpreterState_Get(): no current thread state"); } @@ -689,7 +689,7 @@ tstate_delete_common(PyThreadState *tstate) void PyThreadState_Delete(PyThreadState *tstate) { - if (tstate == PyThreadState_GET()) + if (tstate == _PyThreadState_GET()) Py_FatalError("PyThreadState_Delete: tstate is still current"); if (_PyRuntime.gilstate.autoInterpreterState && PyThread_tss_get(&_PyRuntime.gilstate.autoTSSkey) == tstate) @@ -703,7 +703,7 @@ PyThreadState_Delete(PyThreadState *tstate) void PyThreadState_DeleteCurrent() { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); if (tstate == NULL) Py_FatalError( "PyThreadState_DeleteCurrent: no current tstate"); @@ -758,14 +758,14 @@ _PyThreadState_DeleteExcept(PyThreadState *tstate) PyThreadState * _PyThreadState_UncheckedGet(void) { - return PyThreadState_GET(); + return _PyThreadState_GET(); } PyThreadState * PyThreadState_Get(void) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); if (tstate == NULL) Py_FatalError("PyThreadState_Get: no current thread"); @@ -776,7 +776,7 @@ PyThreadState_Get(void) PyThreadState * PyThreadState_Swap(PyThreadState *newts) { - PyThreadState *oldts = PyThreadState_GET(); + PyThreadState *oldts = _PyThreadState_GET(); _PyThreadState_SET(newts); /* It should not be possible for more than one thread state @@ -807,7 +807,7 @@ PyThreadState_Swap(PyThreadState *newts) PyObject * PyThreadState_GetDict(void) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); if (tstate == NULL) return NULL; @@ -958,7 +958,7 @@ PyThreadState_IsCurrent(PyThreadState *tstate) { /* Must be the tstate for this thread */ assert(PyGILState_GetThisThreadState()==tstate); - return tstate == PyThreadState_GET(); + return tstate == _PyThreadState_GET(); } /* Internal initialization/finalization functions called by @@ -1085,7 +1085,7 @@ PyGILState_Check(void) return 1; } - tstate = PyThreadState_GET(); + tstate = _PyThreadState_GET(); if (tstate == NULL) return 0; diff --git a/Python/symtable.c b/Python/symtable.c index dae6fda0e4c..48e1515fa3b 100644 --- a/Python/symtable.c +++ b/Python/symtable.c @@ -265,7 +265,7 @@ PySymtable_BuildObject(mod_ty mod, PyObject *filename, PyFutureFeatures *future) st->st_future = future; /* Setup recursion depth check counters */ - tstate = PyThreadState_GET(); + tstate = _PyThreadState_GET(); if (!tstate) { PySymtable_Free(st); return NULL; diff --git a/Python/sysmodule.c b/Python/sysmodule.c index cb13e21c940..830f0a88e4f 100644 --- a/Python/sysmodule.c +++ b/Python/sysmodule.c @@ -336,7 +336,7 @@ PyDoc_STRVAR(excepthook_doc, static PyObject * sys_exc_info(PyObject *self, PyObject *noargs) { - _PyErr_StackItem *err_info = _PyErr_GetTopmostException(PyThreadState_GET()); + _PyErr_StackItem *err_info = _PyErr_GetTopmostException(_PyThreadState_GET()); return Py_BuildValue( "(OOO)", err_info->exc_type != NULL ? err_info->exc_type : Py_None, @@ -565,7 +565,7 @@ function call. See the debugger chapter in the library manual." static PyObject * sys_gettrace(PyObject *self, PyObject *args) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); PyObject *temp = tstate->c_traceobj; if (temp == NULL) @@ -603,7 +603,7 @@ and return. See the profiler chapter in the library manual." static PyObject * sys_getprofile(PyObject *self, PyObject *args) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); PyObject *temp = tstate->c_profileobj; if (temp == NULL) @@ -722,7 +722,7 @@ sys_setrecursionlimit(PyObject *self, PyObject *args) the new low-water mark. Otherwise it may not be possible anymore to reset the overflowed flag to 0. */ mark = _Py_RecursionLimitLowerWaterMark(new_limit); - tstate = PyThreadState_GET(); + tstate = _PyThreadState_GET(); if (tstate->recursion_depth >= mark) { PyErr_Format(PyExc_RecursionError, "cannot set the recursion limit to %i at " @@ -1362,7 +1362,7 @@ purposes only." static PyObject * sys_getframe(PyObject *self, PyObject *args) { - PyFrameObject *f = PyThreadState_GET()->frame; + PyFrameObject *f = _PyThreadState_GET()->frame; int depth = -1; if (!PyArg_ParseTuple(args, "|i:_getframe", &depth)) @@ -1745,7 +1745,7 @@ static int _PySys_ReadPreInitOptions(void) { /* Rerun the add commands with the actual sys module available */ - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); if (tstate == NULL) { /* Still don't have a thread state, so something is wrong! */ return -1; @@ -1796,7 +1796,7 @@ get_warnoptions(void) void PySys_ResetWarnOptions(void) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); if (tstate == NULL) { _clear_preinit_entries(&_preinit_warnoptions); return; @@ -1835,7 +1835,7 @@ PySys_AddWarnOptionUnicode(PyObject *option) void PySys_AddWarnOption(const wchar_t *s) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); if (tstate == NULL) { _append_preinit_entry(&_preinit_warnoptions, s); return; @@ -1922,7 +1922,7 @@ error: void PySys_AddXOption(const wchar_t *s) { - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); if (tstate == NULL) { _append_preinit_entry(&_preinit_xoptions, s); return; diff --git a/Python/thread_nt.h b/Python/thread_nt.h index 61fa8619bc1..21ef5556a6b 100644 --- a/Python/thread_nt.h +++ b/Python/thread_nt.h @@ -189,7 +189,7 @@ PyThread_start_new_thread(void (*func)(void *), void *arg) return PYTHREAD_INVALID_THREAD_ID; obj->func = func; obj->arg = arg; - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); size_t stacksize = tstate ? tstate->interp->pythread_stacksize : 0; hThread = (HANDLE)_beginthreadex(0, Py_SAFE_DOWNCAST(stacksize, Py_ssize_t, unsigned int), @@ -334,13 +334,13 @@ _pythread_nt_set_stacksize(size_t size) { /* set to default */ if (size == 0) { - PyThreadState_GET()->interp->pythread_stacksize = 0; + _PyInterpreterState_GET_UNSAFE()->pythread_stacksize = 0; return 0; } /* valid range? */ if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) { - PyThreadState_GET()->interp->pythread_stacksize = size; + _PyInterpreterState_GET_UNSAFE()->pythread_stacksize = size; return 0; } diff --git a/Python/thread_pthread.h b/Python/thread_pthread.h index 697140558fd..6da8b3a4473 100644 --- a/Python/thread_pthread.h +++ b/Python/thread_pthread.h @@ -174,7 +174,7 @@ PyThread_start_new_thread(void (*func)(void *), void *arg) return PYTHREAD_INVALID_THREAD_ID; #endif #if defined(THREAD_STACK_SIZE) - PyThreadState *tstate = PyThreadState_GET(); + PyThreadState *tstate = _PyThreadState_GET(); size_t stacksize = tstate ? tstate->interp->pythread_stacksize : 0; tss = (stacksize != 0) ? stacksize : THREAD_STACK_SIZE; if (tss != 0) { @@ -591,7 +591,7 @@ _pythread_pthread_set_stacksize(size_t size) /* set to default */ if (size == 0) { - PyThreadState_GET()->interp->pythread_stacksize = 0; + _PyInterpreterState_GET_UNSAFE()->pythread_stacksize = 0; return 0; } @@ -608,7 +608,7 @@ _pythread_pthread_set_stacksize(size_t size) rc = pthread_attr_setstacksize(&attrs, size); pthread_attr_destroy(&attrs); if (rc == 0) { - PyThreadState_GET()->interp->pythread_stacksize = size; + _PyInterpreterState_GET_UNSAFE()->pythread_stacksize = size; return 0; } }