Where Online Learning is simpler!
The C and C++ Include Header Files
cat -n /usr/include/python3.14/internal/pycore_ceval.h
1 #ifndef Py_INTERNAL_CEVAL_H 2 #define Py_INTERNAL_CEVAL_H 3 #ifdef __cplusplus 4 extern "C" { 5 #endif 6 7 #ifndef Py_BUILD_CORE 8 # error "this header requires Py_BUILD_CORE define" 9 #endif 10 11 #include "dynamic_annotations.h" // _Py_ANNOTATE_RWLOCK_CREATE 12 13 #include "pycore_code.h" // _PyCode_GetTLBCFast() 14 #include "pycore_interp.h" // PyInterpreterState.eval_frame 15 #include "pycore_pystate.h" // _PyThreadState_GET() 16 #include "pycore_stats.h" // EVAL_CALL_STAT_INC() 17 #include "pycore_typedefs.h" // _PyInterpreterFrame 18 19 20 /* Forward declarations */ 21 struct _ceval_runtime_state; 22 23 // Export for '_lsprof' shared extension 24 PyAPI_FUNC(int) _PyEval_SetProfile(PyThreadState *tstate, Py_tracefunc func, PyObject *arg); 25 extern int _PyEval_SetProfileAllThreads(PyInterpreterState *interp, Py_tracefunc func, PyObject *arg); 26 27 extern int _PyEval_SetTrace(PyThreadState *tstate, Py_tracefunc func, PyObject *arg); 28 extern int _PyEval_SetTraceAllThreads(PyInterpreterState *interp, Py_tracefunc func, PyObject *arg); 29 30 extern int _PyEval_SetOpcodeTrace(PyFrameObject *f, bool enable); 31 32 // Helper to look up a builtin object 33 // Export for 'array' shared extension 34 PyAPI_FUNC(PyObject*) _PyEval_GetBuiltin(PyObject *); 35 36 extern PyObject* _PyEval_GetBuiltinId(_Py_Identifier *); 37 38 extern void _PyEval_SetSwitchInterval(unsigned long microseconds); 39 extern unsigned long _PyEval_GetSwitchInterval(void); 40 41 // Export for '_queue' shared extension 42 PyAPI_FUNC(int) _PyEval_MakePendingCalls(PyThreadState *); 43 44 #ifndef Py_DEFAULT_RECURSION_LIMIT 45 # define Py_DEFAULT_RECURSION_LIMIT 1000 46 #endif 47 48 extern void _Py_FinishPendingCalls(PyThreadState *tstate); 49 extern void _PyEval_InitState(PyInterpreterState *); 50 extern void _PyEval_SignalReceived(void); 51 52 // bitwise flags: 53 #define _Py_PENDING_MAINTHREADONLY 1 54 #define _Py_PENDING_RAWFREE 2 55 56 typedef int _Py_add_pending_call_result; 57 #define _Py_ADD_PENDING_SUCCESS 0 58 #define _Py_ADD_PENDING_FULL -1 59 60 // Export for '_testinternalcapi' shared extension 61 PyAPI_FUNC(_Py_add_pending_call_result) _PyEval_AddPendingCall( 62 PyInterpreterState *interp, 63 _Py_pending_call_func func, 64 void *arg, 65 int flags); 66 67 #ifdef HAVE_FORK 68 extern PyStatus _PyEval_ReInitThreads(PyThreadState *tstate); 69 #endif 70 71 // Used by sys.call_tracing() 72 extern PyObject* _PyEval_CallTracing(PyObject *func, PyObject *args); 73 74 // Used by sys.get_asyncgen_hooks() 75 extern PyObject* _PyEval_GetAsyncGenFirstiter(void); 76 extern PyObject* _PyEval_GetAsyncGenFinalizer(void); 77 78 // Used by sys.set_asyncgen_hooks() 79 extern int _PyEval_SetAsyncGenFirstiter(PyObject *); 80 extern int _PyEval_SetAsyncGenFinalizer(PyObject *); 81 82 // Used by sys.get_coroutine_origin_tracking_depth() 83 // and sys.set_coroutine_origin_tracking_depth() 84 extern int _PyEval_GetCoroutineOriginTrackingDepth(void); 85 extern int _PyEval_SetCoroutineOriginTrackingDepth(int depth); 86 87 extern void _PyEval_Fini(void); 88 89 90 extern PyObject* _PyEval_GetBuiltins(PyThreadState *tstate); 91 92 // Trampoline API 93 94 typedef struct { 95 // Callback to initialize the trampoline state 96 void* (*init_state)(void); 97 // Callback to register every trampoline being created 98 void (*write_state)(void* state, const void *code_addr, 99 unsigned int code_size, PyCodeObject* code); 100 // Callback to free the trampoline state 101 int (*free_state)(void* state); 102 } _PyPerf_Callbacks; 103 104 extern int _PyPerfTrampoline_SetCallbacks(_PyPerf_Callbacks *); 105 extern void _PyPerfTrampoline_GetCallbacks(_PyPerf_Callbacks *); 106 extern int _PyPerfTrampoline_Init(int activate); 107 extern int _PyPerfTrampoline_Fini(void); 108 extern int _PyIsPerfTrampolineActive(void); 109 extern PyStatus _PyPerfTrampoline_AfterFork_Child(void); 110 #ifdef PY_HAVE_PERF_TRAMPOLINE 111 extern _PyPerf_Callbacks _Py_perfmap_callbacks; 112 extern _PyPerf_Callbacks _Py_perfmap_jit_callbacks; 113 #endif 114 115 static inline PyObject* 116 _PyEval_EvalFrame(PyThreadState *tstate, _PyInterpreterFrame *frame, int throwflag) 117 { 118 EVAL_CALL_STAT_INC(EVAL_CALL_TOTAL); 119 if (tstate->interp->eval_frame == NULL) { 120 return _PyEval_EvalFrameDefault(tstate, frame, throwflag); 121 } 122 return tstate->interp->eval_frame(tstate, frame, throwflag); 123 } 124 125 extern PyObject* 126 _PyEval_Vector(PyThreadState *tstate, 127 PyFunctionObject *func, PyObject *locals, 128 PyObject* const* args, size_t argcount, 129 PyObject *kwnames); 130 131 extern int _PyEval_ThreadsInitialized(void); 132 extern void _PyEval_InitGIL(PyThreadState *tstate, int own_gil); 133 extern void _PyEval_FiniGIL(PyInterpreterState *interp); 134 135 extern void _PyEval_AcquireLock(PyThreadState *tstate); 136 137 extern void _PyEval_ReleaseLock(PyInterpreterState *, PyThreadState *, 138 int final_release); 139 140 #ifdef Py_GIL_DISABLED 141 // Returns 0 or 1 if the GIL for the given thread's interpreter is disabled or 142 // enabled, respectively. 143 // 144 // The enabled state of the GIL will not change while one or more threads are 145 // attached. 146 static inline int 147 _PyEval_IsGILEnabled(PyThreadState *tstate) 148 { 149 struct _gil_runtime_state *gil = tstate->interp->ceval.gil; 150 return _Py_atomic_load_int_relaxed(&gil->enabled) != 0; 151 } 152 153 // Enable or disable the GIL used by the interpreter that owns tstate, which 154 // must be the current thread. This may affect other interpreters, if the GIL 155 // is shared. All three functions will be no-ops (and return 0) if the 156 // interpreter's `enable_gil' config is not _PyConfig_GIL_DEFAULT. 157 // 158 // Every call to _PyEval_EnableGILTransient() must be paired with exactly one 159 // call to either _PyEval_EnableGILPermanent() or 160 // _PyEval_DisableGIL(). _PyEval_EnableGILPermanent() and _PyEval_DisableGIL() 161 // must only be called while the GIL is enabled from a call to 162 // _PyEval_EnableGILTransient(). 163 // 164 // _PyEval_EnableGILTransient() returns 1 if it enabled the GIL, or 0 if the 165 // GIL was already enabled, whether transiently or permanently. The caller will 166 // hold the GIL upon return. 167 // 168 // _PyEval_EnableGILPermanent() returns 1 if it permanently enabled the GIL 169 // (which must already be enabled), or 0 if it was already permanently 170 // enabled. Once _PyEval_EnableGILPermanent() has been called once, all 171 // subsequent calls to any of the three functions will be no-ops. 172 // 173 // _PyEval_DisableGIL() returns 1 if it disabled the GIL, or 0 if the GIL was 174 // kept enabled because of another request, whether transient or permanent. 175 // 176 // All three functions must be called by an attached thread (this implies that 177 // if the GIL is enabled, the current thread must hold it). 178 extern int _PyEval_EnableGILTransient(PyThreadState *tstate); 179 extern int _PyEval_EnableGILPermanent(PyThreadState *tstate); 180 extern int _PyEval_DisableGIL(PyThreadState *state); 181 182 183 static inline _Py_CODEUNIT * 184 _PyEval_GetExecutableCode(PyThreadState *tstate, PyCodeObject *co) 185 { 186 _Py_CODEUNIT *bc = _PyCode_GetTLBCFast(tstate, co); 187 if (bc != NULL) { 188 return bc; 189 } 190 return _PyCode_GetTLBC(co); 191 } 192 193 #endif 194 195 extern void _PyEval_DeactivateOpCache(void); 196 197 198 /* --- _Py_EnterRecursiveCall() ----------------------------------------- */ 199 200 static inline int _Py_MakeRecCheck(PyThreadState *tstate) { 201 uintptr_t here_addr = _Py_get_machine_stack_pointer(); 202 _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate; 203 // Overflow if stack pointer is between soft limit and the base of the hardware stack. 204 // If it is below the hardware stack base, assume that we have the wrong stack limits, and do nothing. 205 // We could have the wrong stack limits because of limited platform support, or user-space threads. 206 #if _Py_STACK_GROWS_DOWN 207 return here_addr < _tstate->c_stack_soft_limit && here_addr >= _tstate->c_stack_soft_limit - 2 * _PyOS_STACK_MARGIN_BYTES; 208 #else 209 return here_addr > _tstate->c_stack_soft_limit && here_addr <= _tstate->c_stack_soft_limit + 2 * _PyOS_STACK_MARGIN_BYTES; 210 #endif 211 } 212 213 // Export for '_json' shared extension, used via _Py_EnterRecursiveCall() 214 // static inline function. 215 PyAPI_FUNC(int) _Py_CheckRecursiveCall( 216 PyThreadState *tstate, 217 const char *where); 218 219 int _Py_CheckRecursiveCallPy( 220 PyThreadState *tstate); 221 222 static inline int _Py_EnterRecursiveCallTstate(PyThreadState *tstate, 223 const char *where) { 224 return (_Py_MakeRecCheck(tstate) && _Py_CheckRecursiveCall(tstate, where)); 225 } 226 227 static inline int _Py_EnterRecursiveCall(const char *where) { 228 PyThreadState *tstate = _PyThreadState_GET(); 229 return _Py_EnterRecursiveCallTstate(tstate, where); 230 } 231 232 static inline void _Py_LeaveRecursiveCallTstate(PyThreadState *tstate) { 233 (void)tstate; 234 } 235 236 PyAPI_FUNC(void) _Py_InitializeRecursionLimits(PyThreadState *tstate); 237 238 static inline int _Py_ReachedRecursionLimit(PyThreadState *tstate) { 239 uintptr_t here_addr = _Py_get_machine_stack_pointer(); 240 _PyThreadStateImpl *_tstate = (_PyThreadStateImpl *)tstate; 241 assert(_tstate->c_stack_hard_limit != 0); 242 #if _Py_STACK_GROWS_DOWN 243 return here_addr <= _tstate->c_stack_soft_limit; 244 #else 245 return here_addr >= _tstate->c_stack_soft_limit; 246 #endif 247 } 248 249 static inline void _Py_LeaveRecursiveCall(void) { 250 } 251 252 extern _PyInterpreterFrame* _PyEval_GetFrame(void); 253 254 extern PyObject * _PyEval_GetGlobalsFromRunningMain(PyThreadState *); 255 extern int _PyEval_EnsureBuiltins( 256 PyThreadState *, 257 PyObject *, 258 PyObject **p_builtins); 259 extern int _PyEval_EnsureBuiltinsWithModule( 260 PyThreadState *, 261 PyObject *, 262 PyObject **p_builtins); 263 264 PyAPI_FUNC(PyObject *)_Py_MakeCoro(PyFunctionObject *func); 265 266 /* Handle signals, pending calls, GIL drop request 267 and asynchronous exception */ 268 PyAPI_FUNC(int) _Py_HandlePending(PyThreadState *tstate); 269 270 extern PyObject * _PyEval_GetFrameLocals(void); 271 272 typedef PyObject *(*conversion_func)(PyObject *); 273 274 PyAPI_DATA(const binaryfunc) _PyEval_BinaryOps[]; 275 PyAPI_DATA(const conversion_func) _PyEval_ConversionFuncs[]; 276 277 typedef struct _special_method { 278 PyObject *name; 279 const char *error; 280 const char *error_suggestion; // improved optional suggestion 281 } _Py_SpecialMethod; 282 283 PyAPI_DATA(const _Py_SpecialMethod) _Py_SpecialMethods[]; 284 PyAPI_DATA(const size_t) _Py_FunctionAttributeOffsets[]; 285 286 PyAPI_FUNC(int) _PyEval_CheckExceptStarTypeValid(PyThreadState *tstate, PyObject* right); 287 PyAPI_FUNC(int) _PyEval_CheckExceptTypeValid(PyThreadState *tstate, PyObject* right); 288 PyAPI_FUNC(int) _PyEval_ExceptionGroupMatch(_PyInterpreterFrame *, PyObject* exc_value, PyObject *match_type, PyObject **match, PyObject **rest); 289 PyAPI_FUNC(void) _PyEval_FormatAwaitableError(PyThreadState *tstate, PyTypeObject *type, int oparg); 290 PyAPI_FUNC(void) _PyEval_FormatExcCheckArg(PyThreadState *tstate, PyObject *exc, const char *format_str, PyObject *obj); 291 PyAPI_FUNC(void) _PyEval_FormatExcUnbound(PyThreadState *tstate, PyCodeObject *co, int oparg); 292 PyAPI_FUNC(void) _PyEval_FormatKwargsError(PyThreadState *tstate, PyObject *func, PyObject *kwargs); 293 PyAPI_FUNC(PyObject *) _PyEval_ImportFrom(PyThreadState *, PyObject *, PyObject *); 294 PyAPI_FUNC(PyObject *) _PyEval_ImportName(PyThreadState *, _PyInterpreterFrame *, PyObject *, PyObject *, PyObject *); 295 PyAPI_FUNC(PyObject *)_PyEval_MatchClass(PyThreadState *tstate, PyObject *subject, PyObject *type, Py_ssize_t nargs, PyObject *kwargs); 296 PyAPI_FUNC(PyObject *)_PyEval_MatchKeys(PyThreadState *tstate, PyObject *map, PyObject *keys); 297 PyAPI_FUNC(void) _PyEval_MonitorRaise(PyThreadState *tstate, _PyInterpreterFrame *frame, _Py_CODEUNIT *instr); 298 PyAPI_FUNC(bool) _PyEval_NoToolsForUnwind(PyThreadState *tstate); 299 PyAPI_FUNC(int) _PyEval_UnpackIterableStackRef(PyThreadState *tstate, PyObject *v, int argcnt, int argcntafter, _PyStackRef *sp); 300 PyAPI_FUNC(void) _PyEval_FrameClearAndPop(PyThreadState *tstate, _PyInterpreterFrame *frame); 301 PyAPI_FUNC(PyObject **) _PyObjectArray_FromStackRefArray(_PyStackRef *input, Py_ssize_t nargs, PyObject **scratch); 302 303 PyAPI_FUNC(void) _PyObjectArray_Free(PyObject **array, PyObject **scratch); 304 305 PyAPI_FUNC(PyObject *) _PyEval_GetANext(PyObject *aiter); 306 PyAPI_FUNC(void) _PyEval_LoadGlobalStackRef(PyObject *globals, PyObject *builtins, PyObject *name, _PyStackRef *writeto); 307 PyAPI_FUNC(PyObject *) _PyEval_GetAwaitable(PyObject *iterable, int oparg); 308 PyAPI_FUNC(PyObject *) _PyEval_LoadName(PyThreadState *tstate, _PyInterpreterFrame *frame, PyObject *name); 309 PyAPI_FUNC(int) 310 _Py_Check_ArgsIterable(PyThreadState *tstate, PyObject *func, PyObject *args); 311 312 /* 313 * Indicate whether a special method of given 'oparg' can use the (improved) 314 * alternative error message instead. Only methods loaded by LOAD_SPECIAL 315 * support alternative error messages. 316 * 317 * Symbol is exported for the JIT (see discussion on GH-132218). 318 */ 319 PyAPI_FUNC(int) 320 _PyEval_SpecialMethodCanSuggest(PyObject *self, int oparg); 321 322 /* Bits that can be set in PyThreadState.eval_breaker */ 323 #define _PY_GIL_DROP_REQUEST_BIT (1U << 0) 324 #define _PY_SIGNALS_PENDING_BIT (1U << 1) 325 #define _PY_CALLS_TO_DO_BIT (1U << 2) 326 #define _PY_ASYNC_EXCEPTION_BIT (1U << 3) 327 #define _PY_GC_SCHEDULED_BIT (1U << 4) 328 #define _PY_EVAL_PLEASE_STOP_BIT (1U << 5) 329 #define _PY_EVAL_EXPLICIT_MERGE_BIT (1U << 6) 330 #define _PY_EVAL_JIT_INVALIDATE_COLD_BIT (1U << 7) 331 332 /* Reserve a few bits for future use */ 333 #define _PY_EVAL_EVENTS_BITS 8 334 #define _PY_EVAL_EVENTS_MASK ((1 << _PY_EVAL_EVENTS_BITS)-1) 335 336 static inline void 337 _Py_set_eval_breaker_bit(PyThreadState *tstate, uintptr_t bit) 338 { 339 _Py_atomic_or_uintptr(&tstate->eval_breaker, bit); 340 } 341 342 static inline void 343 _Py_unset_eval_breaker_bit(PyThreadState *tstate, uintptr_t bit) 344 { 345 _Py_atomic_and_uintptr(&tstate->eval_breaker, ~bit); 346 } 347 348 static inline int 349 _Py_eval_breaker_bit_is_set(PyThreadState *tstate, uintptr_t bit) 350 { 351 uintptr_t b = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker); 352 return (b & bit) != 0; 353 } 354 355 // Free-threaded builds use these functions to set or unset a bit on all 356 // threads in the given interpreter. 357 void _Py_set_eval_breaker_bit_all(PyInterpreterState *interp, uintptr_t bit); 358 void _Py_unset_eval_breaker_bit_all(PyInterpreterState *interp, uintptr_t bit); 359 360 PyAPI_FUNC(_PyStackRef) _PyFloat_FromDouble_ConsumeInputs(_PyStackRef left, _PyStackRef right, double value); 361 362 #ifndef Py_SUPPORTS_REMOTE_DEBUG 363 #if defined(__APPLE__) 364 #include <TargetConditionals.h> 365 # if !defined(TARGET_OS_OSX) 366 // Older macOS SDKs do not define TARGET_OS_OSX 367 # define TARGET_OS_OSX 1 368 # endif 369 #endif 370 #if ((defined(__APPLE__) && TARGET_OS_OSX) || defined(MS_WINDOWS) || (defined(__linux__) && HAVE_PROCESS_VM_READV)) 371 # define Py_SUPPORTS_REMOTE_DEBUG 1 372 #endif 373 #endif 374 375 #if defined(Py_REMOTE_DEBUG) && defined(Py_SUPPORTS_REMOTE_DEBUG) 376 extern int _PyRunRemoteDebugger(PyThreadState *tstate); 377 #endif 378 379 /* Special methods used by LOAD_SPECIAL */ 380 #define SPECIAL___ENTER__ 0 381 #define SPECIAL___EXIT__ 1 382 #define SPECIAL___AENTER__ 2 383 #define SPECIAL___AEXIT__ 3 384 #define SPECIAL_MAX 3 385 386 PyAPI_FUNC(_PyStackRef) 387 _Py_LoadAttr_StackRefSteal( 388 PyThreadState *tstate, _PyStackRef owner, 389 PyObject *name, _PyStackRef *self_or_null); 390 391 #ifdef __cplusplus 392 } 393 #endif 394 #endif /* !Py_INTERNAL_CEVAL_H */
