12 files changed, 390 insertions, 332 deletions
diff --git a/Include/Python.h b/Include/Python.h
index e1abdd1..717e27f 100644
--- a/Include/Python.h
+++ b/Include/Python.h
@@ -124,6 +124,7 @@
 #include "pylifecycle.h"
 #include "ceval.h"
 #include "sysmodule.h"
+#include "audit.h"
 #include "osmodule.h"
 #include "intrcheck.h"
 #include "import.h"
diff --git a/Include/audit.h b/Include/audit.h
new file mode 100644
index 0000000..793b707
--- /dev/null
+++ b/Include/audit.h
@@ -0,0 +1,30 @@
+#ifndef Py_AUDIT_H
+#define Py_AUDIT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030d0000
+PyAPI_FUNC(int) PySys_Audit(
+    const char *event,
+    const char *argFormat,
+    ...);
+
+PyAPI_FUNC(int) PySys_AuditTuple(
+    const char *event,
+    PyObject *args);
+#endif
+
+
+#ifndef Py_LIMITED_API
+#  define Py_CPYTHON_AUDIT_H
+#  include "cpython/audit.h"
+#  undef Py_CPYTHON_AUDIT_H
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_AUDIT_H */
diff --git a/Include/cpython/audit.h b/Include/cpython/audit.h
new file mode 100644
index 0000000..3c5c7a8
--- /dev/null
+++ b/Include/cpython/audit.h
@@ -0,0 +1,8 @@
+#ifndef Py_CPYTHON_AUDIT_H
+#  error "this header file must not be included directly"
+#endif
+
+
+typedef int(*Py_AuditHookFunction)(const char *, PyObject *, void *);
+
+PyAPI_FUNC(int) PySys_AddAuditHook(Py_AuditHookFunction, void*);
diff --git a/Include/cpython/ceval.h b/Include/cpython/ceval.h
index 78f7405..ca8109e 100644
--- a/Include/cpython/ceval.h
+++ b/Include/cpython/ceval.h
@@ -23,3 +23,21 @@ _PyEval_RequestCodeExtraIndex(freefunc f) {
 
 PyAPI_FUNC(int) _PyEval_SliceIndex(PyObject *, Py_ssize_t *);
 PyAPI_FUNC(int) _PyEval_SliceIndexNotNone(PyObject *, Py_ssize_t *);
+
+
+// Trampoline API
+
+typedef struct {
+    FILE* perf_map;
+    PyThread_type_lock map_lock;
+} PerfMapState;
+
+PyAPI_FUNC(int) PyUnstable_PerfMapState_Init(void);
+PyAPI_FUNC(int) PyUnstable_WritePerfMapEntry(
+    const void *code_addr,
+    unsigned int code_size,
+    const char *entry_name);
+PyAPI_FUNC(void) PyUnstable_PerfMapState_Fini(void);
+PyAPI_FUNC(int) PyUnstable_CopyPerfMapFile(const char* parent_filename);
+PyAPI_FUNC(int) PyUnstable_PerfTrampoline_CompileCode(PyCodeObject *);
+PyAPI_FUNC(int) PyUnstable_PerfTrampoline_SetPersistAfterFork(int enable);
diff --git a/Include/cpython/sysmodule.h b/Include/cpython/sysmodule.h
deleted file mode 100644
index a3ac07f..0000000
--- a/Include/cpython/sysmodule.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef Py_CPYTHON_SYSMODULE_H
-#  error "this header file must not be included directly"
-#endif
-
-typedef int(*Py_AuditHookFunction)(const char *, PyObject *, void *);
-
-PyAPI_FUNC(int) PySys_AddAuditHook(Py_AuditHookFunction, void*);
-
-typedef struct {
-    FILE* perf_map;
-    PyThread_type_lock map_lock;
-} PerfMapState;
-
-PyAPI_FUNC(int) PyUnstable_PerfMapState_Init(void);
-PyAPI_FUNC(int) PyUnstable_WritePerfMapEntry(
-    const void *code_addr,
-    unsigned int code_size,
-    const char *entry_name);
-PyAPI_FUNC(void) PyUnstable_PerfMapState_Fini(void);
-PyAPI_FUNC(int) PyUnstable_CopyPerfMapFile(const char* parent_filename);
-PyAPI_FUNC(int) PyUnstable_PerfTrampoline_CompileCode(PyCodeObject *);
-PyAPI_FUNC(int) PyUnstable_PerfTrampoline_SetPersistAfterFork(int enable);
diff --git a/Include/internal/pycore_audit.h b/Include/internal/pycore_audit.h
new file mode 100644
index 0000000..2811aaa
--- /dev/null
+++ b/Include/internal/pycore_audit.h
@@ -0,0 +1,35 @@
+#ifndef Py_INTERNAL_AUDIT_H
+#define Py_INTERNAL_AUDIT_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+
+/* Runtime audit hook state */
+
+typedef struct _Py_AuditHookEntry {
+    struct _Py_AuditHookEntry *next;
+    Py_AuditHookFunction hookCFunction;
+    void *userData;
+} _Py_AuditHookEntry;
+
+
+extern int _PySys_Audit(
+    PyThreadState *tstate,
+    const char *event,
+    const char *argFormat,
+    ...);
+
+// _PySys_ClearAuditHooks() must not be exported: use extern rather than
+// PyAPI_FUNC(). We want minimal exposure of this function.
+extern void _PySys_ClearAuditHooks(PyThreadState *tstate);
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_AUDIT_H */
diff --git a/Include/internal/pycore_debug_offsets.h b/Include/internal/pycore_debug_offsets.h
new file mode 100644
index 0000000..184f4b9
--- /dev/null
+++ b/Include/internal/pycore_debug_offsets.h
@@ -0,0 +1,269 @@
+#ifndef Py_INTERNAL_DEBUG_OFFSETS_H
+#define Py_INTERNAL_DEBUG_OFFSETS_H
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef Py_BUILD_CORE
+#  error "this header requires Py_BUILD_CORE define"
+#endif
+
+
+#define _Py_Debug_Cookie "xdebugpy"
+
+#ifdef Py_GIL_DISABLED
+# define _Py_Debug_gilruntimestate_enabled offsetof(struct _gil_runtime_state, enabled)
+# define _Py_Debug_Free_Threaded 1
+#else
+# define _Py_Debug_gilruntimestate_enabled 0
+# define _Py_Debug_Free_Threaded 0
+#endif
+
+
+typedef struct _Py_DebugOffsets {
+    char cookie[8];
+    uint64_t version;
+    uint64_t free_threaded;
+    // Runtime state offset;
+    struct _runtime_state {
+        uint64_t size;
+        uint64_t finalizing;
+        uint64_t interpreters_head;
+    } runtime_state;
+
+    // Interpreter state offset;
+    struct _interpreter_state {
+        uint64_t size;
+        uint64_t id;
+        uint64_t next;
+        uint64_t threads_head;
+        uint64_t gc;
+        uint64_t imports_modules;
+        uint64_t sysdict;
+        uint64_t builtins;
+        uint64_t ceval_gil;
+        uint64_t gil_runtime_state;
+        uint64_t gil_runtime_state_enabled;
+        uint64_t gil_runtime_state_locked;
+        uint64_t gil_runtime_state_holder;
+    } interpreter_state;
+
+    // Thread state offset;
+    struct _thread_state{
+        uint64_t size;
+        uint64_t prev;
+        uint64_t next;
+        uint64_t interp;
+        uint64_t current_frame;
+        uint64_t thread_id;
+        uint64_t native_thread_id;
+        uint64_t datastack_chunk;
+        uint64_t status;
+    } thread_state;
+
+    // InterpreterFrame offset;
+    struct _interpreter_frame {
+        uint64_t size;
+        uint64_t previous;
+        uint64_t executable;
+        uint64_t instr_ptr;
+        uint64_t localsplus;
+        uint64_t owner;
+    } interpreter_frame;
+
+    // Code object offset;
+    struct _code_object {
+        uint64_t size;
+        uint64_t filename;
+        uint64_t name;
+        uint64_t qualname;
+        uint64_t linetable;
+        uint64_t firstlineno;
+        uint64_t argcount;
+        uint64_t localsplusnames;
+        uint64_t localspluskinds;
+        uint64_t co_code_adaptive;
+    } code_object;
+
+    // PyObject offset;
+    struct _pyobject {
+        uint64_t size;
+        uint64_t ob_type;
+    } pyobject;
+
+    // PyTypeObject object offset;
+    struct _type_object {
+        uint64_t size;
+        uint64_t tp_name;
+        uint64_t tp_repr;
+        uint64_t tp_flags;
+    } type_object;
+
+    // PyTuple object offset;
+    struct _tuple_object {
+        uint64_t size;
+        uint64_t ob_item;
+        uint64_t ob_size;
+    } tuple_object;
+
+    // PyList object offset;
+    struct _list_object {
+        uint64_t size;
+        uint64_t ob_item;
+        uint64_t ob_size;
+    } list_object;
+
+    // PyDict object offset;
+    struct _dict_object {
+        uint64_t size;
+        uint64_t ma_keys;
+        uint64_t ma_values;
+    } dict_object;
+
+    // PyFloat object offset;
+    struct _float_object {
+        uint64_t size;
+        uint64_t ob_fval;
+    } float_object;
+
+    // PyLong object offset;
+    struct _long_object {
+        uint64_t size;
+        uint64_t lv_tag;
+        uint64_t ob_digit;
+    } long_object;
+
+    // PyBytes object offset;
+    struct _bytes_object {
+        uint64_t size;
+        uint64_t ob_size;
+        uint64_t ob_sval;
+    } bytes_object;
+
+    // Unicode object offset;
+    struct _unicode_object {
+        uint64_t size;
+        uint64_t state;
+        uint64_t length;
+        uint64_t asciiobject_size;
+    } unicode_object;
+
+    // GC runtime state offset;
+    struct _gc {
+        uint64_t size;
+        uint64_t collecting;
+    } gc;
+} _Py_DebugOffsets;
+
+
+#define _Py_DebugOffsets_INIT(debug_cookie) { \
+    .cookie = debug_cookie, \
+    .version = PY_VERSION_HEX, \
+    .free_threaded = _Py_Debug_Free_Threaded, \
+    .runtime_state = { \
+        .size = sizeof(_PyRuntimeState), \
+        .finalizing = offsetof(_PyRuntimeState, _finalizing), \
+        .interpreters_head = offsetof(_PyRuntimeState, interpreters.head), \
+    }, \
+    .interpreter_state = { \
+        .size = sizeof(PyInterpreterState), \
+        .id = offsetof(PyInterpreterState, id), \
+        .next = offsetof(PyInterpreterState, next), \
+        .threads_head = offsetof(PyInterpreterState, threads.head), \
+        .gc = offsetof(PyInterpreterState, gc), \
+        .imports_modules = offsetof(PyInterpreterState, imports.modules), \
+        .sysdict = offsetof(PyInterpreterState, sysdict), \
+        .builtins = offsetof(PyInterpreterState, builtins), \
+        .ceval_gil = offsetof(PyInterpreterState, ceval.gil), \
+        .gil_runtime_state = offsetof(PyInterpreterState, _gil), \
+        .gil_runtime_state_enabled = _Py_Debug_gilruntimestate_enabled, \
+        .gil_runtime_state_locked = offsetof(PyInterpreterState, _gil.locked), \
+        .gil_runtime_state_holder = offsetof(PyInterpreterState, _gil.last_holder), \
+    }, \
+    .thread_state = { \
+        .size = sizeof(PyThreadState), \
+        .prev = offsetof(PyThreadState, prev), \
+        .next = offsetof(PyThreadState, next), \
+        .interp = offsetof(PyThreadState, interp), \
+        .current_frame = offsetof(PyThreadState, current_frame), \
+        .thread_id = offsetof(PyThreadState, thread_id), \
+        .native_thread_id = offsetof(PyThreadState, native_thread_id), \
+        .datastack_chunk = offsetof(PyThreadState, datastack_chunk), \
+        .status = offsetof(PyThreadState, _status), \
+    }, \
+    .interpreter_frame = { \
+        .size = sizeof(_PyInterpreterFrame), \
+        .previous = offsetof(_PyInterpreterFrame, previous), \
+        .executable = offsetof(_PyInterpreterFrame, f_executable), \
+        .instr_ptr = offsetof(_PyInterpreterFrame, instr_ptr), \
+        .localsplus = offsetof(_PyInterpreterFrame, localsplus), \
+        .owner = offsetof(_PyInterpreterFrame, owner), \
+    }, \
+    .code_object = { \
+        .size = sizeof(PyCodeObject), \
+        .filename = offsetof(PyCodeObject, co_filename), \
+        .name = offsetof(PyCodeObject, co_name), \
+        .qualname = offsetof(PyCodeObject, co_qualname), \
+        .linetable = offsetof(PyCodeObject, co_linetable), \
+        .firstlineno = offsetof(PyCodeObject, co_firstlineno), \
+        .argcount = offsetof(PyCodeObject, co_argcount), \
+        .localsplusnames = offsetof(PyCodeObject, co_localsplusnames), \
+        .localspluskinds = offsetof(PyCodeObject, co_localspluskinds), \
+        .co_code_adaptive = offsetof(PyCodeObject, co_code_adaptive), \
+    }, \
+    .pyobject = { \
+        .size = sizeof(PyObject), \
+        .ob_type = offsetof(PyObject, ob_type), \
+    }, \
+    .type_object = { \
+        .size = sizeof(PyTypeObject), \
+        .tp_name = offsetof(PyTypeObject, tp_name), \
+        .tp_repr = offsetof(PyTypeObject, tp_repr), \
+        .tp_flags = offsetof(PyTypeObject, tp_flags), \
+    }, \
+    .tuple_object = { \
+        .size = sizeof(PyTupleObject), \
+        .ob_item = offsetof(PyTupleObject, ob_item), \
+        .ob_size = offsetof(PyTupleObject, ob_base.ob_size), \
+    }, \
+    .list_object = { \
+        .size = sizeof(PyListObject), \
+        .ob_item = offsetof(PyListObject, ob_item), \
+        .ob_size = offsetof(PyListObject, ob_base.ob_size), \
+    }, \
+    .dict_object = { \
+        .size = sizeof(PyDictObject), \
+        .ma_keys = offsetof(PyDictObject, ma_keys), \
+        .ma_values = offsetof(PyDictObject, ma_values), \
+    }, \
+    .float_object = { \
+        .size = sizeof(PyFloatObject), \
+        .ob_fval = offsetof(PyFloatObject, ob_fval), \
+    }, \
+    .long_object = { \
+        .size = sizeof(PyLongObject), \
+        .lv_tag = offsetof(PyLongObject, long_value.lv_tag), \
+        .ob_digit = offsetof(PyLongObject, long_value.ob_digit), \
+    }, \
+    .bytes_object = { \
+        .size = sizeof(PyBytesObject), \
+        .ob_size = offsetof(PyBytesObject, ob_base.ob_size), \
+        .ob_sval = offsetof(PyBytesObject, ob_sval), \
+    }, \
+    .unicode_object = { \
+        .size = sizeof(PyUnicodeObject), \
+        .state = offsetof(PyUnicodeObject, _base._base.state), \
+        .length = offsetof(PyUnicodeObject, _base._base.length), \
+        .asciiobject_size = sizeof(PyASCIIObject), \
+    }, \
+    .gc = { \
+        .size = sizeof(struct _gc_runtime_state), \
+        .collecting = offsetof(struct _gc_runtime_state, collecting), \
+    }, \
+}
+
+
+#ifdef __cplusplus
+}
+#endif
+#endif /* !Py_INTERNAL_DEBUG_OFFSETS_H */
diff --git a/Include/internal/pycore_object_state.h b/Include/internal/pycore_object_state.h
index e7fa7c1..8a47a6d 100644
--- a/Include/internal/pycore_object_state.h
+++ b/Include/internal/pycore_object_state.h
@@ -11,6 +11,14 @@ extern "C" {
 #include "pycore_freelist_state.h"  // _Py_freelists
 #include "pycore_hashtable.h"       // _Py_hashtable_t
 
+
+/* Reference tracer state */
+struct _reftracer_runtime_state {
+    PyRefTracer tracer_func;
+    void* tracer_data;
+};
+
+
 struct _py_object_runtime_state {
 #ifdef Py_REF_DEBUG
     Py_ssize_t interpreter_leaks;
diff --git a/Include/internal/pycore_runtime.h b/Include/internal/pycore_runtime.h
index d4291b8..7f592aa 100644
--- a/Include/internal/pycore_runtime.h
+++ b/Include/internal/pycore_runtime.h
@@ -9,8 +9,10 @@ extern "C" {
 #endif
 
 #include "pycore_atexit.h"          // struct _atexit_runtime_state
+#include "pycore_audit.h"           // _Py_AuditHookEntry
 #include "pycore_ceval_state.h"     // struct _ceval_runtime_state
-#include "pycore_crossinterp.h"   // struct _xidregistry
+#include "pycore_crossinterp.h"     // struct _xidregistry
+#include "pycore_debug_offsets.h"   // _Py_DebugOffsets
 #include "pycore_faulthandler.h"    // struct _faulthandler_runtime_state
 #include "pycore_floatobject.h"     // struct _Py_float_runtime_state
 #include "pycore_import.h"          // struct _import_runtime_state
@@ -25,185 +27,12 @@ extern "C" {
 #include "pycore_typeobject.h"      // struct _types_runtime_state
 #include "pycore_unicodeobject.h"   // struct _Py_unicode_runtime_state
 
-struct _getargs_runtime_state {
-    struct _PyArg_Parser *static_parsers;
-};
-
-/* GIL state */
-
-struct _gilstate_runtime_state {
-    /* bpo-26558: Flag to disable PyGILState_Check().
-       If set to non-zero, PyGILState_Check() always return 1. */
-    int check_enabled;
-    /* The single PyInterpreterState used by this process'
-       GILState implementation
-    */
-    /* TODO: Given interp_main, it may be possible to kill this ref */
-    PyInterpreterState *autoInterpreterState;
-};
-
-/* Runtime audit hook state */
-
-#define _Py_Debug_Cookie "xdebugpy"
-
-#ifdef Py_GIL_DISABLED
-# define _Py_Debug_gilruntimestate_enabled offsetof(struct _gil_runtime_state, enabled)
-# define _Py_Debug_Free_Threaded 1
-#else
-# define _Py_Debug_gilruntimestate_enabled 0
-# define _Py_Debug_Free_Threaded 0
-#endif
-typedef struct _Py_AuditHookEntry {
-    struct _Py_AuditHookEntry *next;
-    Py_AuditHookFunction hookCFunction;
-    void *userData;
-} _Py_AuditHookEntry;
-
-typedef struct _Py_DebugOffsets {
-    char cookie[8];
-    uint64_t version;
-    uint64_t free_threaded;
-    // Runtime state offset;
-    struct _runtime_state {
-        uint64_t size;
-        uint64_t finalizing;
-        uint64_t interpreters_head;
-    } runtime_state;
-
-    // Interpreter state offset;
-    struct _interpreter_state {
-        uint64_t size;
-        uint64_t id;
-        uint64_t next;
-        uint64_t threads_head;
-        uint64_t gc;
-        uint64_t imports_modules;
-        uint64_t sysdict;
-        uint64_t builtins;
-        uint64_t ceval_gil;
-        uint64_t gil_runtime_state;
-        uint64_t gil_runtime_state_enabled;
-        uint64_t gil_runtime_state_locked;
-        uint64_t gil_runtime_state_holder;
-    } interpreter_state;
-
-    // Thread state offset;
-    struct _thread_state{
-        uint64_t size;
-        uint64_t prev;
-        uint64_t next;
-        uint64_t interp;
-        uint64_t current_frame;
-        uint64_t thread_id;
-        uint64_t native_thread_id;
-        uint64_t datastack_chunk;
-        uint64_t status;
-    } thread_state;
-
-    // InterpreterFrame offset;
-    struct _interpreter_frame {
-        uint64_t size;
-        uint64_t previous;
-        uint64_t executable;
-        uint64_t instr_ptr;
-        uint64_t localsplus;
-        uint64_t owner;
-    } interpreter_frame;
-
-    // Code object offset;
-    struct _code_object {
-        uint64_t size;
-        uint64_t filename;
-        uint64_t name;
-        uint64_t qualname;
-        uint64_t linetable;
-        uint64_t firstlineno;
-        uint64_t argcount;
-        uint64_t localsplusnames;
-        uint64_t localspluskinds;
-        uint64_t co_code_adaptive;
-    } code_object;
-
-    // PyObject offset;
-    struct _pyobject {
-        uint64_t size;
-        uint64_t ob_type;
-    } pyobject;
-
-    // PyTypeObject object offset;
-    struct _type_object {
-        uint64_t size;
-        uint64_t tp_name;
-        uint64_t tp_repr;
-        uint64_t tp_flags;
-    } type_object;
-
-    // PyTuple object offset;
-    struct _tuple_object {
-        uint64_t size;
-        uint64_t ob_item;
-        uint64_t ob_size;
-    } tuple_object;
-
-    // PyList object offset;
-    struct _list_object {
-        uint64_t size;
-        uint64_t ob_item;
-        uint64_t ob_size;
-    } list_object;
-
-    // PyDict object offset;
-    struct _dict_object {
-        uint64_t size;
-        uint64_t ma_keys;
-        uint64_t ma_values;
-    } dict_object;
-
-    // PyFloat object offset;
-    struct _float_object {
-        uint64_t size;
-        uint64_t ob_fval;
-    } float_object;
-
-    // PyLong object offset;
-    struct _long_object {
-        uint64_t size;
-        uint64_t lv_tag;
-        uint64_t ob_digit;
-    } long_object;
-
-    // PyBytes object offset;
-    struct _bytes_object {
-        uint64_t size;
-        uint64_t ob_size;
-        uint64_t ob_sval;
-    } bytes_object;
-
-    // Unicode object offset;
-    struct _unicode_object {
-        uint64_t size;
-        uint64_t state;
-        uint64_t length;
-        uint64_t asciiobject_size;
-    } unicode_object;
-
-    // GC runtime state offset;
-    struct _gc {
-        uint64_t size;
-        uint64_t collecting;
-    } gc;
-} _Py_DebugOffsets;
-
-/* Reference tracer state */
-struct _reftracer_runtime_state {
-    PyRefTracer tracer_func;
-    void* tracer_data;
-};
 
 /* Full Python runtime state */
 
 /* _PyRuntimeState holds the global state for the CPython runtime.
-   That data is exposed in the internal API as a static variable (_PyRuntime).
+   That data is exported by the internal API as a global variable
+   (_PyRuntime, defined near the top of pylifecycle.c).
    */
 typedef struct pyruntimestate {
     /* This field must be first to facilitate locating it by out of process
@@ -299,8 +128,19 @@ typedef struct pyruntimestate {
 
     struct _import_runtime_state imports;
     struct _ceval_runtime_state ceval;
-    struct _gilstate_runtime_state gilstate;
-    struct _getargs_runtime_state getargs;
+    struct _gilstate_runtime_state {
+        /* bpo-26558: Flag to disable PyGILState_Check().
+           If set to non-zero, PyGILState_Check() always return 1. */
+        int check_enabled;
+        /* The single PyInterpreterState used by this process'
+           GILState implementation
+        */
+        /* TODO: Given interp_main, it may be possible to kill this ref */
+        PyInterpreterState *autoInterpreterState;
+    } gilstate;
+    struct _getargs_runtime_state {
+        struct _PyArg_Parser *static_parsers;
+    } getargs;
     struct _fileutils_state fileutils;
     struct _faulthandler_runtime_state faulthandler;
     struct _tracemalloc_runtime_state tracemalloc;
@@ -404,6 +244,7 @@ _PyRuntimeState_SetFinalizing(_PyRuntimeState *runtime, PyThreadState *tstate) {
     }
 }
 
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/Include/internal/pycore_runtime_init.h b/Include/internal/pycore_runtime_init.h
index a17ba46..e99feba 100644
--- a/Include/internal/pycore_runtime_init.h
+++ b/Include/internal/pycore_runtime_init.h
@@ -9,6 +9,7 @@ extern "C" {
 #endif
 
 #include "pycore_ceval_state.h"   // _PyEval_RUNTIME_PERF_INIT
+#include "pycore_debug_offsets.h"  // _Py_DebugOffsets_INIT()
 #include "pycore_faulthandler.h"  // _faulthandler_runtime_state_INIT
 #include "pycore_floatobject.h"   // _py_float_format_unknown
 #include "pycore_function.h"
@@ -32,111 +33,7 @@ extern PyTypeObject _PyExc_MemoryError;
 
 #define _PyRuntimeState_INIT(runtime, debug_cookie) \
     { \
-        .debug_offsets = { \
-            .cookie = debug_cookie, \
-            .version = PY_VERSION_HEX, \
-            .free_threaded = _Py_Debug_Free_Threaded, \
-            .runtime_state = { \
-                .size = sizeof(_PyRuntimeState), \
-                .finalizing = offsetof(_PyRuntimeState, _finalizing), \
-                .interpreters_head = offsetof(_PyRuntimeState, interpreters.head), \
-            }, \
-            .interpreter_state = { \
-                .size = sizeof(PyInterpreterState), \
-                .id = offsetof(PyInterpreterState, id), \
-                .next = offsetof(PyInterpreterState, next), \
-                .threads_head = offsetof(PyInterpreterState, threads.head), \
-                .gc = offsetof(PyInterpreterState, gc), \
-                .imports_modules = offsetof(PyInterpreterState, imports.modules), \
-                .sysdict = offsetof(PyInterpreterState, sysdict), \
-                .builtins = offsetof(PyInterpreterState, builtins), \
-                .ceval_gil = offsetof(PyInterpreterState, ceval.gil), \
-                .gil_runtime_state = offsetof(PyInterpreterState, _gil), \
-                .gil_runtime_state_enabled = _Py_Debug_gilruntimestate_enabled, \
-                .gil_runtime_state_locked = offsetof(PyInterpreterState, _gil.locked), \
-                .gil_runtime_state_holder = offsetof(PyInterpreterState, _gil.last_holder), \
-            }, \
-            .thread_state = { \
-                .size = sizeof(PyThreadState), \
-                .prev = offsetof(PyThreadState, prev), \
-                .next = offsetof(PyThreadState, next), \
-                .interp = offsetof(PyThreadState, interp), \
-                .current_frame = offsetof(PyThreadState, current_frame), \
-                .thread_id = offsetof(PyThreadState, thread_id), \
-                .native_thread_id = offsetof(PyThreadState, native_thread_id), \
-                .datastack_chunk = offsetof(PyThreadState, datastack_chunk), \
-                .status = offsetof(PyThreadState, _status), \
-            }, \
-            .interpreter_frame = { \
-                .size = sizeof(_PyInterpreterFrame), \
-                .previous = offsetof(_PyInterpreterFrame, previous), \
-                .executable = offsetof(_PyInterpreterFrame, f_executable), \
-                .instr_ptr = offsetof(_PyInterpreterFrame, instr_ptr), \
-                .localsplus = offsetof(_PyInterpreterFrame, localsplus), \
-                .owner = offsetof(_PyInterpreterFrame, owner), \
-            }, \
-            .code_object = { \
-                .size = sizeof(PyCodeObject), \
-                .filename = offsetof(PyCodeObject, co_filename), \
-                .name = offsetof(PyCodeObject, co_name), \
-                .qualname = offsetof(PyCodeObject, co_qualname), \
-                .linetable = offsetof(PyCodeObject, co_linetable), \
-                .firstlineno = offsetof(PyCodeObject, co_firstlineno), \
-                .argcount = offsetof(PyCodeObject, co_argcount), \
-                .localsplusnames = offsetof(PyCodeObject, co_localsplusnames), \
-                .localspluskinds = offsetof(PyCodeObject, co_localspluskinds), \
-                .co_code_adaptive = offsetof(PyCodeObject, co_code_adaptive), \
-            }, \
-            .pyobject = { \
-                .size = sizeof(PyObject), \
-                .ob_type = offsetof(PyObject, ob_type), \
-            }, \
-            .type_object = { \
-                .size = sizeof(PyTypeObject), \
-                .tp_name = offsetof(PyTypeObject, tp_name), \
-                .tp_repr = offsetof(PyTypeObject, tp_repr), \
-                .tp_flags = offsetof(PyTypeObject, tp_flags), \
-            }, \
-            .tuple_object = { \
-                .size = sizeof(PyTupleObject), \
-                .ob_item = offsetof(PyTupleObject, ob_item), \
-                .ob_size = offsetof(PyTupleObject, ob_base.ob_size), \
-            }, \
-            .list_object = { \
-                .size = sizeof(PyListObject), \
-                .ob_item = offsetof(PyListObject, ob_item), \
-                .ob_size = offsetof(PyListObject, ob_base.ob_size), \
-            }, \
-            .dict_object = { \
-                .size = sizeof(PyDictObject), \
-                .ma_keys = offsetof(PyDictObject, ma_keys), \
-                .ma_values = offsetof(PyDictObject, ma_values), \
-            }, \
-            .float_object = { \
-                .size = sizeof(PyFloatObject), \
-                .ob_fval = offsetof(PyFloatObject, ob_fval), \
-            }, \
-            .long_object = { \
-                .size = sizeof(PyLongObject), \
-                .lv_tag = offsetof(PyLongObject, long_value.lv_tag), \
-                .ob_digit = offsetof(PyLongObject, long_value.ob_digit), \
-            }, \
-            .bytes_object = { \
-                .size = sizeof(PyBytesObject), \
-                .ob_size = offsetof(PyBytesObject, ob_base.ob_size), \
-                .ob_sval = offsetof(PyBytesObject, ob_sval), \
-            }, \
-            .unicode_object = { \
-                .size = sizeof(PyUnicodeObject), \
-                .state = offsetof(PyUnicodeObject, _base._base.state), \
-                .length = offsetof(PyUnicodeObject, _base._base.length), \
-                .asciiobject_size = sizeof(PyASCIIObject), \
-            }, \
-            .gc = { \
-                .size = sizeof(struct _gc_runtime_state), \
-                .collecting = offsetof(struct _gc_runtime_state, collecting), \
-            }, \
-        }, \
+        .debug_offsets = _Py_DebugOffsets_INIT(debug_cookie), \
         .allocators = { \
             .standard = _pymem_allocators_standard_INIT(runtime), \
             .debug = _pymem_allocators_debug_INIT, \
diff --git a/Include/internal/pycore_sysmodule.h b/Include/internal/pycore_sysmodule.h
index a1d795e..99968df 100644
--- a/Include/internal/pycore_sysmodule.h
+++ b/Include/internal/pycore_sysmodule.h
@@ -14,16 +14,6 @@ PyAPI_FUNC(PyObject*) _PySys_GetAttr(PyThreadState *tstate, PyObject *name);
 // Export for '_pickle' shared extension
 PyAPI_FUNC(size_t) _PySys_GetSizeOf(PyObject *);
 
-extern int _PySys_Audit(
-    PyThreadState *tstate,
-    const char *event,
-    const char *argFormat,
-    ...);
-
-// _PySys_ClearAuditHooks() must not be exported: use extern rather than
-// PyAPI_FUNC(). We want minimal exposure of this function.
-extern void _PySys_ClearAuditHooks(PyThreadState *tstate);
-
 extern int _PySys_SetAttr(PyObject *, PyObject *);
 
 extern int _PySys_ClearAttrString(PyInterpreterState *interp,
diff --git a/Include/sysmodule.h b/Include/sysmodule.h
index 5a0af2e..c1d5f61 100644
--- a/Include/sysmodule.h
+++ b/Include/sysmodule.h
@@ -21,23 +21,6 @@ Py_DEPRECATED(3.13) PyAPI_FUNC(void) PySys_ResetWarnOptions(void);
 
 PyAPI_FUNC(PyObject *) PySys_GetXOptions(void);
 
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x030d0000
-PyAPI_FUNC(int) PySys_Audit(
-    const char *event,
-    const char *argFormat,
-    ...);
-
-PyAPI_FUNC(int) PySys_AuditTuple(
-    const char *event,
-    PyObject *args);
-#endif
-
-#ifndef Py_LIMITED_API
-#  define Py_CPYTHON_SYSMODULE_H
-#  include "cpython/sysmodule.h"
-#  undef Py_CPYTHON_SYSMODULE_H
-#endif
-
 #ifdef __cplusplus
 }
 #endif