codekingpro/portable-devtools

1/* This file contains the struct definitions for the runtime, interpreter2 * and thread states, plus all smaller structs contained therein */3 4#ifndef Py_INTERNAL_RUNTIME_STRUCTS_H5#define Py_INTERNAL_RUNTIME_STRUCTS_H6#ifdef __cplusplus7extern "C" {8#endif9 10#include "pycore_interp_structs.h" // _PyGC_Head_UNUSED11#include "pycore_obmalloc.h"      // struct _obmalloc_global_state12 13/************ Runtime state ************/14 15typedef struct {16    /* We tag each block with an API ID in order to tag API violations */17    char api_id;18    PyMemAllocatorEx alloc;19} debug_alloc_api_t;20 21struct _pymem_allocators {22    PyMutex mutex;23    struct {24        PyMemAllocatorEx raw;25        PyMemAllocatorEx mem;26        PyMemAllocatorEx obj;27    } standard;28    struct {29        debug_alloc_api_t raw;30        debug_alloc_api_t mem;31        debug_alloc_api_t obj;32    } debug;33    int is_debug_enabled;34    PyObjectArenaAllocator obj_arena;35};36 37enum _py_float_format_type {38    _py_float_format_unknown,39    _py_float_format_ieee_big_endian,40    _py_float_format_ieee_little_endian,41};42 43struct _Py_float_runtime_state {44    enum _py_float_format_type float_format;45    enum _py_float_format_type double_format;46};47 48struct pyhash_runtime_state {49    struct {50#ifndef MS_WINDOWS51        int fd;52        dev_t st_dev;53        ino_t st_ino;54#else55    // This is a placeholder so the struct isn't empty on Windows.56    int _not_used;57#endif58    } urandom_cache;59};60 61#include "pycore_tracemalloc.h"   // struct _tracemalloc_runtime_state62 63struct _fileutils_state {64    int force_ascii;65};66 67#include "pycore_interpframe_structs.h" // _PyInterpreterFrame68#include "pycore_debug_offsets.h" // _Py_DebugOffsets69#include "pycore_signal.h"        // struct _signals_runtime_state70#include "pycore_faulthandler.h"  // struct _faulthandler_runtime_state71#include "pycore_ast.h"           // struct _expr72 73#ifdef Py_DEBUG74#define _PYPEGEN_NSTATISTICS 200075#endif76 77struct _parser_runtime_state {78#ifdef Py_DEBUG79    long memo_statistics[_PYPEGEN_NSTATISTICS];80#ifdef Py_GIL_DISABLED81    PyMutex mutex;82#endif83#else84    int _not_used;85#endif86    struct _expr dummy_name;87};88 89typedef struct {90    PyTime_t numer;91    PyTime_t denom;92} _PyTimeFraction;93 94struct _Py_time_runtime_state {95#if defined(MS_WINDOWS) || defined(__APPLE__)96    _PyTimeFraction base;97#else98    char _unused;99#endif100};101 102 103struct _Py_cached_objects {104    // XXX We could statically allocate the hashtable.105    _Py_hashtable_t *interned_strings;106};107 108// These would be in pycore_long.h if it weren't for an include cycle.109#define _PY_NSMALLPOSINTS           257110#define _PY_NSMALLNEGINTS           5111 112#include "pycore_global_strings.h" // struct _Py_global_strings113 114struct _Py_static_objects {115    struct {116        /* Small integers are preallocated in this array so that they117         * can be shared.118         * The integers that are preallocated are those in the range119         * -_PY_NSMALLNEGINTS (inclusive) to _PY_NSMALLPOSINTS (exclusive).120         */121        PyLongObject small_ints[_PY_NSMALLNEGINTS + _PY_NSMALLPOSINTS];122 123        PyBytesObject bytes_empty;124        struct {125            PyBytesObject ob;126            char eos;127        } bytes_characters[256];128 129        struct _Py_global_strings strings;130 131        _PyGC_Head_UNUSED _tuple_empty_gc_not_used;132        PyTupleObject tuple_empty;133 134        _PyGC_Head_UNUSED _hamt_bitmap_node_empty_gc_not_used;135        PyHamtNode_Bitmap hamt_bitmap_node_empty;136        _PyContextTokenMissing context_token_missing;137    } singletons;138};139 140/* Full Python runtime state */141 142/* _PyRuntimeState holds the global state for the CPython runtime.143   That data is exported by the internal API as a global variable144   (_PyRuntime, defined near the top of pylifecycle.c).145   */146struct pyruntimestate {147    /* This field must be first to facilitate locating it by out of process148     * debuggers. Out of process debuggers will use the offsets contained in this149     * field to be able to locate other fields in several interpreter structures150     * in a way that doesn't require them to know the exact layout of those151     * structures.152     *153     * IMPORTANT:154     * This struct is **NOT** backwards compatible between minor version of the155     * interpreter and the members, order of members and size can change between156     * minor versions. This struct is only guaranteed to be stable between patch157     * versions for a given minor version of the interpreter.158     */159    _Py_DebugOffsets debug_offsets;160 161    /* Has been initialized to a safe state.162 163       In order to be effective, this must be set to 0 during or right164       after allocation. */165    int _initialized;166 167    /* Is running Py_PreInitialize()? */168    int preinitializing;169 170    /* Is Python preinitialized? Set to 1 by Py_PreInitialize() */171    int preinitialized;172 173    /* Is Python core initialized? Set to 1 by _Py_InitializeCore() */174    int core_initialized;175 176    /* Is Python fully initialized? Set to 1 by Py_Initialize() */177    int initialized;178 179    /* Set by Py_FinalizeEx(). Only reset to NULL if Py_Initialize()180       is called again.181 182       Use _PyRuntimeState_GetFinalizing() and _PyRuntimeState_SetFinalizing()183       to access it, don't access it directly. */184    PyThreadState *_finalizing;185    /* The ID of the OS thread in which we are finalizing. */186    unsigned long _finalizing_id;187 188    struct pyinterpreters {189        PyMutex mutex;190        /* The linked list of interpreters, newest first. */191        PyInterpreterState *head;192        /* The runtime's initial interpreter, which has a special role193           in the operation of the runtime.  It is also often the only194           interpreter. */195        PyInterpreterState *main;196        /* next_id is an auto-numbered sequence of small197           integers.  It gets initialized in _PyInterpreterState_Enable(),198           which is called in Py_Initialize(), and used in199           PyInterpreterState_New().  A negative interpreter ID200           indicates an error occurred.  The main interpreter will201           always have an ID of 0.  Overflow results in a RuntimeError.202           If that becomes a problem later then we can adjust, e.g. by203           using a Python int. */204        int64_t next_id;205    } interpreters;206 207    /* Platform-specific identifier and PyThreadState, respectively, for the208       main thread in the main interpreter. */209    unsigned long main_thread;210    PyThreadState *main_tstate;211 212    /* ---------- IMPORTANT ---------------------------213     The fields above this line are declared as early as214     possible to facilitate out-of-process observability215     tools. */216 217    /* cross-interpreter data and utils */218    _PyXI_global_state_t xi;219 220    struct _pymem_allocators allocators;221    struct _obmalloc_global_state obmalloc;222    struct pyhash_runtime_state pyhash_state;223    struct _pythread_runtime_state threads;224    struct _signals_runtime_state signals;225 226    /* Used for the thread state bound to the current thread. */227    Py_tss_t autoTSSkey;228 229    /* Used instead of PyThreadState.trash when there is not current tstate. */230    Py_tss_t trashTSSkey;231 232    PyWideStringList orig_argv;233 234    struct _parser_runtime_state parser;235 236    struct _atexit_runtime_state atexit;237 238    struct _import_runtime_state imports;239    struct _ceval_runtime_state ceval;240    struct _gilstate_runtime_state {241        /* bpo-26558: Flag to disable PyGILState_Check().242           If set to non-zero, PyGILState_Check() always return 1. */243        int check_enabled;244        /* The single PyInterpreterState used by this process'245           GILState implementation246        */247        /* TODO: Given interp_main, it may be possible to kill this ref */248        PyInterpreterState *autoInterpreterState;249    } gilstate;250    struct _getargs_runtime_state {251        struct _PyArg_Parser *static_parsers;252    } getargs;253    struct _fileutils_state fileutils;254    struct _faulthandler_runtime_state faulthandler;255    struct _tracemalloc_runtime_state tracemalloc;256    struct _reftracer_runtime_state ref_tracer;257 258    // The rwmutex is used to prevent overlapping global and per-interpreter259    // stop-the-world events. Global stop-the-world events lock the mutex260    // exclusively (as a "writer"), while per-interpreter stop-the-world events261    // lock it non-exclusively (as "readers").262    _PyRWMutex stoptheworld_mutex;263    struct _stoptheworld_state stoptheworld;264 265    PyPreConfig preconfig;266 267    // Audit values must be preserved when Py_Initialize()/Py_Finalize()268    // is called multiple times.269    Py_OpenCodeHookFunction open_code_hook;270    void *open_code_userdata;271    struct {272        PyMutex mutex;273        struct _Py_AuditHookEntry *head;274    } audit_hooks;275 276    struct _py_object_runtime_state object_state;277    struct _Py_float_runtime_state float_state;278    struct _Py_unicode_runtime_state unicode_state;279    struct _types_runtime_state types;280    struct _Py_time_runtime_state time;281 282#if defined(__EMSCRIPTEN__) && defined(PY_CALL_TRAMPOLINE)283    // Used in "Python/emscripten_trampoline.c" to choose between wasm-gc284    // trampoline and JavaScript trampoline.285    PyObject* (*emscripten_trampoline)(int* success,286                                       PyCFunctionWithKeywords func,287                                       PyObject* self,288                                       PyObject* args,289                                       PyObject* kw);290#endif291 292    /* All the objects that are shared by the runtime's interpreters. */293    struct _Py_cached_objects cached_objects;294    struct _Py_static_objects static_objects;295 296    /* The following fields are here to avoid allocation during init.297       The data is exposed through _PyRuntimeState pointer fields.298       These fields should not be accessed directly outside of init.299 300       All other _PyRuntimeState pointer fields are populated when301       needed and default to NULL.302 303       For now there are some exceptions to that rule, which require304       allocation during init.  These will be addressed on a case-by-case305       basis.  Most notably, we don't pre-allocated the several mutex306       (PyThread_type_lock) fields, because on Windows we only ever get307       a pointer type.308       */309 310    /* _PyRuntimeState.interpreters.main */311    PyInterpreterState _main_interpreter;312    // _main_interpreter should be the last field of _PyRuntimeState.313    // See https://github.com/python/cpython/issues/127117.314};315 316 317#ifdef __cplusplus318}319#endif320#endif /* Py_INTERNAL_RUNTIME_STRUCTS_H */321