#include "Python.h"

#include "pycore_abstract.h" // _PyIndex_Check()

#include "pycore_audit.h" // _Py_AuditHookEntry

#include "pycore_backoff.h" // JUMP_BACKWARD_INITIAL_VALUE, SIDE_EXIT_INITIAL_VALUE

#include "pycore_ceval.h" // _PyEval_AcquireLock()

#include "pycore_codecs.h" // _PyCodec_Fini()

#include "pycore_critical_section.h" // _PyCriticalSection_Resume()

#include "pycore_dtoa.h" // _dtoa_state_INIT()

#include "pycore_freelist.h" // _PyObject_ClearFreeLists()

#include "pycore_initconfig.h" // _PyStatus_OK()

#include "pycore_interpframe.h" // _PyThreadState_HasStackSpace()

#include "pycore_object.h" // _PyType_InitCache(), _Py_ClearImmortal()

#include "pycore_obmalloc.h" // _PyMem_obmalloc_state_on_heap()

#include "pycore_opcode_utils.h" // NUM_COMMON_CONSTANTS

#include "pycore_optimizer.h" // JIT_CLEANUP_THRESHOLD

#include "pycore_parking_lot.h" // _PyParkingLot_AfterFork()

#include "pycore_pyerrors.h" // _PyErr_Clear()

#include "pycore_pylifecycle.h" // _PyAST_Fini()

#include "pycore_pymem.h" // _PyMem_DebugEnabled()

#include "pycore_runtime.h" // _PyRuntime

#include "pycore_runtime_init.h" // _PyRuntimeState_INIT

#include "pycore_stackref.h" // PyStackRef_AsPyObjectBorrow()

#include "pycore_stats.h" // FT_STAT_WORLD_STOP_INC()

#include "pycore_time.h" // _PyTime_Init()

#include "pycore_uniqueid.h" // _PyObject_FinalizePerThreadRefcounts()

#ifdef HAVE_DLOPEN

# ifdef HAVE_DLFCN_H

# include <dlfcn.h>

# if !HAVE_DECL_RTLD_LAZY

# define RTLD_LAZY 1

_Py_thread_local PyThreadState *_Py_tss_tstate = NULL;

_Py_thread_local PyThreadState *_Py_tss_gilstate = NULL;

_Py_thread_local PyInterpreterState *_Py_tss_interp = NULL;

static inline PyThreadState *

current_fast_get(void)

{

return _Py_tss_tstate;

}

static inline void

current_fast_set(_PyRuntimeState *Py_UNUSED(runtime), PyThreadState *tstate)

{

assert(tstate != NULL);

_Py_tss_tstate = tstate;

assert(tstate->interp != NULL);

_Py_tss_interp = tstate->interp;

}

static inline void

current_fast_clear(_PyRuntimeState *Py_UNUSED(runtime))

{

_Py_tss_tstate = NULL;

_Py_tss_interp = NULL;

}

#define tstate_verify_not_active(tstate) \

if (tstate == current_fast_get()) { \

_Py_FatalErrorFormat(__func__, "tstate %p is still current", tstate); \

}

PyThreadState *

_PyThreadState_GetCurrent(void)

{

return current_fast_get();

}

static inline PyThreadState *

gilstate_get(void)

{

return _Py_tss_gilstate;

}

static inline void

gilstate_set(PyThreadState *tstate)

{

assert(tstate != NULL);

_Py_tss_gilstate = tstate;

}

static inline void

gilstate_clear(void)

{

_Py_tss_gilstate = NULL;

}

#ifndef NDEBUG

static inline int tstate_is_alive(PyThreadState *tstate);

static inline int

tstate_is_bound(PyThreadState *tstate)

{

return tstate->_status.bound && !tstate->_status.unbound;

}

#endif // !NDEBUG

static void bind_gilstate_tstate(PyThreadState *);

static void unbind_gilstate_tstate(PyThreadState *);

static void tstate_mimalloc_bind(PyThreadState *);

static void

bind_tstate(PyThreadState *tstate)

{

assert(tstate != NULL);

assert(tstate_is_alive(tstate) && !tstate->_status.bound);

assert(!tstate->_status.unbound); // just in case

assert(!tstate->_status.bound_gilstate);

assert(tstate != gilstate_get());

assert(!tstate->_status.active);

assert(tstate->thread_id == 0);

assert(tstate->native_thread_id == 0);

// Currently we don't necessarily store the thread state

// in thread-local storage (e.g. per-interpreter).

tstate->thread_id = PyThread_get_thread_ident();

#ifdef PY_HAVE_THREAD_NATIVE_ID

tstate->native_thread_id = PyThread_get_thread_native_id();

#ifdef Py_GIL_DISABLED

// Initialize biased reference counting inter-thread queue. Note that this

// needs to be initialized from the active thread.

_Py_brc_init_thread(tstate);

// mimalloc state needs to be initialized from the active thread.

tstate_mimalloc_bind(tstate);

tstate->_status.bound = 1;

}

static void

unbind_tstate(PyThreadState *tstate)

{

assert(tstate != NULL);

assert(tstate_is_bound(tstate));

#ifndef HAVE_PTHREAD_STUBS

assert(tstate->thread_id > 0);

#ifdef PY_HAVE_THREAD_NATIVE_ID

assert(tstate->native_thread_id > 0);

// We leave thread_id and native_thread_id alone

// since they can be useful for debugging.

// Check the `_status` field to know if these values

// are still valid.

// We leave tstate->_status.bound set to 1

// to indicate it was previously bound.

tstate->_status.unbound = 1;

}

static void

bind_gilstate_tstate(PyThreadState *tstate)

{

assert(tstate != NULL);

assert(tstate_is_alive(tstate));

assert(tstate_is_bound(tstate));

// XXX assert(!tstate->_status.active);

assert(!tstate->_status.bound_gilstate);

PyThreadState *tcur = gilstate_get();

assert(tstate != tcur);

if (tcur != NULL) {

tcur->_status.bound_gilstate = 0;

}

gilstate_set(tstate);

tstate->_status.bound_gilstate = 1;

}

static void

unbind_gilstate_tstate(PyThreadState *tstate)

{

assert(tstate != NULL);

// XXX assert(tstate_is_alive(tstate));

assert(tstate_is_bound(tstate));

// XXX assert(!tstate->_status.active);

assert(tstate->_status.bound_gilstate);

assert(tstate == gilstate_get());

gilstate_clear();

tstate->_status.bound_gilstate = 0;

}

static int

holds_gil(PyThreadState *tstate)

{

// XXX Fall back to tstate->interp->runtime->ceval.gil.last_holder

// (and tstate->interp->runtime->ceval.gil.locked).

assert(tstate != NULL);

/* Must be the tstate for this thread */

assert(tstate == gilstate_get());

return tstate == current_fast_get();

}

static const _PyRuntimeState initial = _PyRuntimeState_INIT(_PyRuntime, "");

#define LOCKS_INIT(runtime) \

{ \

&(runtime)->interpreters.mutex, \

&(runtime)->xi.data_lookup.registry.mutex, \

&(runtime)->unicode_state.ids.mutex, \

&(runtime)->imports.extensions.mutex, \

&(runtime)->ceval.pending_mainthread.mutex, \

&(runtime)->atexit.mutex, \

&(runtime)->audit_hooks.mutex, \

&(runtime)->allocators.mutex, \

&(runtime)->_main_interpreter.types.mutex, \

&(runtime)->_main_interpreter.code_state.mutex, \

&(runtime)->_main_interpreter.dict_state.watcher_mutex, \

}

static void

init_runtime(_PyRuntimeState *runtime,

void *open_code_hook, void *open_code_userdata,

_Py_AuditHookEntry *audit_hook_head,

Py_ssize_t unicode_next_index)

{

assert(!runtime->preinitializing);

assert(!runtime->preinitialized);

assert(!_PyRuntimeState_GetCoreInitialized(runtime));

assert(!_PyRuntimeState_GetInitialized(runtime));

assert(!runtime->_initialized);

runtime->open_code_hook = open_code_hook;

runtime->open_code_userdata = open_code_userdata;

runtime->audit_hooks.head = audit_hook_head;

PyPreConfig_InitPythonConfig(&runtime->preconfig);

// Set it to the ID of the main thread of the main interpreter.

runtime->main_thread = PyThread_get_thread_ident();

runtime->unicode_state.ids.next_index = unicode_next_index;

runtime->_initialized = 1;

}

_PyRuntimeState_Init(_PyRuntimeState *runtime)

{

/* We preserve the hook across init, because there is

void *open_code_hook = runtime->open_code_hook;

void *open_code_userdata = runtime->open_code_userdata;

_Py_AuditHookEntry *audit_hook_head = runtime->audit_hooks.head;

// bpo-42882: Preserve next_index value if Py_Initialize()/Py_Finalize()

// is called multiple times.

Py_ssize_t unicode_next_index = runtime->unicode_state.ids.next_index;

if (runtime->_initialized) {

// Py_Initialize() must be running again.

// Reset to _PyRuntimeState_INIT.

memcpy(runtime, &initial, sizeof(*runtime));

// Preserve the cookie from the original runtime.

memcpy(runtime->debug_offsets.cookie, _Py_Debug_Cookie, 8);

assert(!runtime->_initialized);

}

PyStatus status = _PyTime_Init(&runtime->time);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

init_runtime(runtime, open_code_hook, open_code_userdata, audit_hook_head,

unicode_next_index);

return _PyStatus_OK();

}

_PyRuntimeState_Fini(_PyRuntimeState *runtime)

{

#ifdef Py_REF_DEBUG

/* The count is cleared by _Py_FinalizeRefTotal(). */

assert(runtime->object_state.interpreter_leaks == 0);

gilstate_clear();

}

#ifdef HAVE_FORK

_PyRuntimeState_ReInitThreads(_PyRuntimeState *runtime)

{

// This was initially set in _PyRuntimeState_Init().

runtime->main_thread = PyThread_get_thread_ident();

// Clears the parking lot. Any waiting threads are dead. This must be

// called before releasing any locks that use the parking lot.

_PyParkingLot_AfterFork();

// Re-initialize global locks

PyMutex *locks[] = LOCKS_INIT(runtime);

for (size_t i = 0; i < Py_ARRAY_LENGTH(locks); i++) {

_PyMutex_at_fork_reinit(locks[i]);

}

#ifdef Py_GIL_DISABLED

for (PyInterpreterState *interp = runtime->interpreters.head;

interp != NULL; interp = interp->next)

{

for (int i = 0; i < NUM_WEAKREF_LIST_LOCKS; i++) {

_PyMutex_at_fork_reinit(&interp->weakref_locks[i]);

}

}

_PyTypes_AfterFork();

_PyThread_AfterFork(&runtime->threads);

return _PyStatus_OK();

}

_PyInterpreterState_Enable(_PyRuntimeState *runtime)

{

struct pyinterpreters *interpreters = &runtime->interpreters;

interpreters->next_id = 0;

return _PyStatus_OK();

}

static PyInterpreterState *

alloc_interpreter(void)

{

// Aligned allocation for PyInterpreterState.

// the first word of the memory block is used to store

// the original pointer to be used later to free the memory.

size_t alignment = _Alignof(PyInterpreterState);

size_t allocsize = sizeof(PyInterpreterState) + sizeof(void *) + alignment - 1;

void *mem = PyMem_RawCalloc(1, allocsize);

if (mem == NULL) {

return NULL;

}

void *ptr = _Py_ALIGN_UP((char *)mem + sizeof(void *), alignment);

((void **)ptr)[-1] = mem;

assert(_Py_IS_ALIGNED(ptr, alignment));

return ptr;

}

static void

free_interpreter(PyInterpreterState *interp)

{

#ifdef Py_STATS

if (interp->pystats_struct) {

PyMem_RawFree(interp->pystats_struct);

interp->pystats_struct = NULL;

}

// The main interpreter is statically allocated so

// should not be freed.

if (interp != &_PyRuntime._main_interpreter) {

if (_PyMem_obmalloc_state_on_heap(interp)) {

// interpreter has its own obmalloc state, free it

PyMem_RawFree(interp->obmalloc);

interp->obmalloc = NULL;

}

assert(_Py_IS_ALIGNED(interp, _Alignof(PyInterpreterState)));

PyMem_RawFree(((void **)interp)[-1]);

}

}

#ifndef NDEBUG

static inline int check_interpreter_whence(long);

static inline bool

is_env_enabled(const char *env_name)

{

char *env = Py_GETENV(env_name);

return env && *env != '\0' && *env != '0';

}

static inline bool

is_env_disabled(const char *env_name)

{

char *env = Py_GETENV(env_name);

return env != NULL && *env == '0';

}

static inline void

init_policy(uint16_t *target, const char *env_name, uint16_t default_value,

long min_value, long max_value)

{

*target = default_value;

char *env = Py_GETENV(env_name);

if (env && *env != '\0') {

long value = atol(env);

if (value >= min_value && value <= max_value) {

*target = (uint16_t)value;

}

}

}

static PyStatus

init_interpreter(PyInterpreterState *interp,

_PyRuntimeState *runtime, int64_t id,

PyInterpreterState *next,

long whence)

{

if (interp->_initialized) {

return _PyStatus_ERR("interpreter already initialized");

}

assert(interp->_whence == _PyInterpreterState_WHENCE_NOTSET);

assert(check_interpreter_whence(whence) == 0);

interp->_whence = whence;

assert(runtime != NULL);

interp->runtime = runtime;

assert(id > 0 || (id == 0 && interp == runtime->interpreters.main));

interp->id = id;

interp->id_refcount = 0;

assert(runtime->interpreters.head == interp);

assert(next != NULL || (interp == runtime->interpreters.main));

interp->next = next;

interp->threads.preallocated = &interp->_initial_thread;

// We would call _PyObject_InitState() at this point

// if interp->feature_flags were alredy set.

_PyEval_InitState(interp);

_PyGC_InitState(&interp->gc);

PyConfig_InitPythonConfig(&interp->config);

_PyType_InitCache(interp);

#ifdef Py_GIL_DISABLED

_Py_brc_init_state(interp);

llist_init(&interp->mem_free_queue.head);

llist_init(&interp->asyncio_tasks_head);

interp->asyncio_tasks_lock = (PyMutex){0};

for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {

interp->monitors.tools[i] = 0;

}

for (int t = 0; t < PY_MONITORING_TOOL_IDS; t++) {

for (int e = 0; e < _PY_MONITORING_EVENTS; e++) {

interp->monitoring_callables[t][e] = NULL;

}

interp->monitoring_tool_versions[t] = 0;

}

interp->_code_object_generation = 0;

interp->jit = false;

interp->compiling = false;

interp->executor_blooms = NULL;

interp->executor_ptrs = NULL;

interp->executor_count = 0;

interp->executor_capacity = 0;

interp->executor_deletion_list_head = NULL;

interp->executor_creation_counter = JIT_CLEANUP_THRESHOLD;

// Initialize optimization configuration from environment variables

// PYTHON_JIT_STRESS sets aggressive defaults for testing, but can be overridden

uint16_t jump_default = JUMP_BACKWARD_INITIAL_VALUE;

uint16_t resume_default = RESUME_INITIAL_VALUE;

uint16_t side_exit_default = SIDE_EXIT_INITIAL_VALUE;

if (is_env_enabled("PYTHON_JIT_STRESS")) {

jump_default = 63;

side_exit_default = 63;

resume_default = 127;

}

init_policy(&interp->opt_config.jump_backward_initial_value,

"PYTHON_JIT_JUMP_BACKWARD_INITIAL_VALUE",

jump_default, 1, MAX_VALUE);

init_policy(&interp->opt_config.jump_backward_initial_backoff,

"PYTHON_JIT_JUMP_BACKWARD_INITIAL_BACKOFF",

JUMP_BACKWARD_INITIAL_BACKOFF, 0, MAX_BACKOFF);

init_policy(&interp->opt_config.resume_initial_value,

"PYTHON_JIT_RESUME_INITIAL_VALUE",

resume_default, 1, MAX_VALUE);

init_policy(&interp->opt_config.resume_initial_backoff,

"PYTHON_JIT_RESUME_INITIAL_BACKOFF",

RESUME_INITIAL_BACKOFF, 0, MAX_BACKOFF);

init_policy(&interp->opt_config.side_exit_initial_value,

"PYTHON_JIT_SIDE_EXIT_INITIAL_VALUE",

side_exit_default, 1, MAX_VALUE);

init_policy(&interp->opt_config.side_exit_initial_backoff,

"PYTHON_JIT_SIDE_EXIT_INITIAL_BACKOFF",

SIDE_EXIT_INITIAL_BACKOFF, 0, MAX_BACKOFF);

// Trace fitness configuration

init_policy(&interp->opt_config.fitness_initial,

"PYTHON_JIT_FITNESS_INITIAL",

FITNESS_INITIAL, EXIT_QUALITY_CLOSE_LOOP, FITNESS_INITIAL);

interp->opt_config.specialization_enabled = !is_env_enabled("PYTHON_SPECIALIZATION_OFF");

interp->opt_config.uops_optimize_enabled = !is_env_disabled("PYTHON_UOPS_OPTIMIZE");

if (interp != &runtime->_main_interpreter) {

/* Fix the self-referential, statically initialized fields. */

interp->dtoa = (struct _dtoa_state)_dtoa_state_INIT(interp);

}

#if !defined(Py_GIL_DISABLED) && defined(Py_STACKREF_DEBUG)

interp->next_stackref = INITIAL_STACKREF_INDEX;

_Py_hashtable_allocator_t alloc = {

.malloc = malloc,

.free = free,

};

interp->open_stackrefs_table = _Py_hashtable_new_full(

_Py_hashtable_hash_ptr,

_Py_hashtable_compare_direct,

NULL,

NULL,

&alloc

);

# ifdef Py_STACKREF_CLOSE_DEBUG

interp->closed_stackrefs_table = _Py_hashtable_new_full(

_Py_hashtable_hash_ptr,

_Py_hashtable_compare_direct,

NULL,

NULL,

&alloc

);

_Py_stackref_associate(interp, Py_None, PyStackRef_None);

_Py_stackref_associate(interp, Py_False, PyStackRef_False);

_Py_stackref_associate(interp, Py_True, PyStackRef_True);

interp->_initialized = 1;

return _PyStatus_OK();

}

_PyInterpreterState_New(PyThreadState *tstate, PyInterpreterState **pinterp)

{

*pinterp = NULL;

// Don't get runtime from tstate since tstate can be NULL

_PyRuntimeState *runtime = &_PyRuntime;

// tstate is NULL when pycore_create_interpreter() calls

// _PyInterpreterState_New() to create the main interpreter.

if (tstate != NULL) {

if (_PySys_Audit(tstate, "cpython.PyInterpreterState_New", NULL) < 0) {

return _PyStatus_ERR("sys.audit failed");

}

}

/* We completely serialize creation of multiple interpreters, since

HEAD_LOCK(runtime);

struct pyinterpreters *interpreters = &runtime->interpreters;

int64_t id = interpreters->next_id;

interpreters->next_id += 1;

// Allocate the interpreter and add it to the runtime state.

PyInterpreterState *interp;

PyStatus status;

PyInterpreterState *old_head = interpreters->head;

if (old_head == NULL) {

// We are creating the main interpreter.

assert(interpreters->main == NULL);

assert(id == 0);

interp = &runtime->_main_interpreter;

assert(interp->id == 0);

assert(interp->next == NULL);

interpreters->main = interp;

}

else {

assert(interpreters->main != NULL);

assert(id != 0);

interp = alloc_interpreter();

if (interp == NULL) {

status = _PyStatus_NO_MEMORY();

goto error;

}

// Set to _PyInterpreterState_INIT.

memcpy(interp, &initial._main_interpreter, sizeof(*interp));

if (id < 0) {

/* overflow or Py_Initialize() not called yet! */

status = _PyStatus_ERR("failed to get an interpreter ID");

goto error;

}

}

interpreters->head = interp;

long whence = _PyInterpreterState_WHENCE_UNKNOWN;

status = init_interpreter(interp, runtime,

id, old_head, whence);

if (_PyStatus_EXCEPTION(status)) {

goto error;

}

HEAD_UNLOCK(runtime);

assert(interp != NULL);

*pinterp = interp;

return _PyStatus_OK();

error:

HEAD_UNLOCK(runtime);

if (interp != NULL) {

free_interpreter(interp);

}

return status;

}

PyInterpreterState *

PyInterpreterState_New(void)

{

// tstate can be NULL

PyThreadState *tstate = current_fast_get();

PyInterpreterState *interp;

PyStatus status = _PyInterpreterState_New(tstate, &interp);

if (_PyStatus_EXCEPTION(status)) {

Py_ExitStatusException(status);

}

assert(interp != NULL);

return interp;

}

#if !defined(Py_GIL_DISABLED) && defined(Py_STACKREF_DEBUG)

extern void

_Py_stackref_report_leaks(PyInterpreterState *interp);

static int

common_const_is_initialized(_PyStackRef ref)

{

#if !defined(Py_GIL_DISABLED) && defined(Py_STACKREF_DEBUG)

return !PyStackRef_IsNull(ref);

return ref.bits != 0 && !PyStackRef_IsNull(ref);

}

static void

common_constants_clear(PyInterpreterState *interp)

{

for (int i = 0; i < NUM_COMMON_CONSTANTS; i++) {

_PyStackRef ref = interp->common_consts[i];

if (!common_const_is_initialized(ref)) {

continue;

}

PyObject *obj = PyStackRef_AsPyObjectBorrow(ref);

PyStackRef_XCLOSE(ref);

interp->common_consts[i] = PyStackRef_NULL;

// Refcount reclamation skips heap immortals; release manually.

if (_Py_IsImmortal(obj) && !_Py_IsStaticImmortal(obj)) {

_Py_ClearImmortal(obj);

}

}

}

static void

interpreter_clear(PyInterpreterState *interp, PyThreadState *tstate)

{

assert(interp != NULL);

assert(tstate != NULL);

_PyRuntimeState *runtime = interp->runtime;

/* XXX Conditions we need to enforce:

// XXX Ideally, we would not rely on any thread state in this function

// (and we would drop the "tstate" argument).

if (_PySys_Audit(tstate, "cpython.PyInterpreterState_Clear", NULL) < 0) {

_PyErr_Clear(tstate);

}

// Clear the current/main thread state last.

_Py_FOR_EACH_TSTATE_BEGIN(interp, p) {

// See https://github.com/python/cpython/issues/102126

// Must be called without HEAD_LOCK held as it can deadlock

// if any finalizer tries to acquire that lock.

HEAD_UNLOCK(runtime);

PyThreadState_Clear(p);

HEAD_LOCK(runtime);

}

_Py_FOR_EACH_TSTATE_END(interp);

if (tstate->interp == interp) {

/* We fix tstate->_status below when we for sure aren't using it

// XXX Eliminate the need to do this.

tstate->_status.cleared = 0;

}

/* It is possible that any of the objects below have a finalizer

// XXX Make sure we properly deal with problematic finalizers.

Py_CLEAR(interp->audit_hooks);

// gh-140257: Threads have already been cleared, but daemon threads may

// still access eval_breaker atomically via take_gil() right before they

// hang. Use an atomic store to prevent data races during finalization.

interp->ceval.instrumentation_version = 0;

_Py_atomic_store_uintptr(&tstate->eval_breaker, 0);

for (int i = 0; i < _PY_MONITORING_UNGROUPED_EVENTS; i++) {

interp->monitors.tools[i] = 0;

}

for (int t = 0; t < PY_MONITORING_TOOL_IDS; t++) {

for (int e = 0; e < _PY_MONITORING_EVENTS; e++) {

Py_CLEAR(interp->monitoring_callables[t][e]);

}

}

for (int t = 0; t < PY_MONITORING_TOOL_IDS; t++) {

Py_CLEAR(interp->monitoring_tool_names[t]);

}

interp->_code_object_generation = 0;

#ifdef Py_GIL_DISABLED

interp->tlbc_indices.tlbc_generation = 0;

PyConfig_Clear(&interp->config);

_PyCodec_Fini(interp);

assert(interp->imports.modules == NULL);

assert(interp->imports.modules_by_index == NULL);

assert(interp->imports.importlib == NULL);

assert(interp->imports.import_func == NULL);

Py_CLEAR(interp->sysdict_copy);

Py_CLEAR(interp->builtins_copy);

Py_CLEAR(interp->dict);

#ifdef HAVE_FORK

Py_CLEAR(interp->before_forkers);

Py_CLEAR(interp->after_forkers_parent);

Py_CLEAR(interp->after_forkers_child);

#ifdef _Py_TIER2

_Py_ClearExecutorDeletionList(interp);

_PyAST_Fini(interp);

_PyAtExit_Fini(interp);

// All Python types must be destroyed before the last GC collection. Python

// types create a reference cycle to themselves in their in their

// PyTypeObject.tp_mro member (the tuple contains the type).

/* Last garbage collection on this interpreter */

_PyGC_CollectNoFail(tstate);

_PyGC_Fini(interp);

// Finalize warnings after last gc so that any finalizers can

// access warnings state

_PyWarnings_Fini(interp);

struct _PyExecutorObject *cold = interp->cold_executor;

if (cold != NULL) {

interp->cold_executor = NULL;

assert(cold->vm_data.valid);

assert(!cold->vm_data.cold);

_PyExecutor_Free(cold);

}

struct _PyExecutorObject *cold_dynamic = interp->cold_dynamic_executor;

if (cold_dynamic != NULL) {

interp->cold_dynamic_executor = NULL;

assert(cold_dynamic->vm_data.valid);

assert(!cold_dynamic->vm_data.cold);

_PyExecutor_Free(cold_dynamic);

}

/* We don't clear sysdict and builtins until the end of this function.

PyDict_Clear(interp->sysdict);

PyDict_Clear(interp->builtins);

Py_CLEAR(interp->sysdict);

Py_CLEAR(interp->builtins);

common_constants_clear(interp);

#if !defined(Py_GIL_DISABLED) && defined(Py_STACKREF_DEBUG)

# ifdef Py_STACKREF_CLOSE_DEBUG

_Py_hashtable_destroy(interp->closed_stackrefs_table);

interp->closed_stackrefs_table = NULL;

_Py_stackref_report_leaks(interp);

_Py_hashtable_destroy(interp->open_stackrefs_table);

interp->open_stackrefs_table = NULL;

if (tstate->interp == interp) {

/* We are now safe to fix tstate->_status.cleared. */

// XXX Do this (much) earlier?

tstate->_status.cleared = 1;

}

for (int i=0; i < DICT_MAX_WATCHERS; i++) {

interp->dict_state.watchers[i] = NULL;

}

for (int i=0; i < TYPE_MAX_WATCHERS; i++) {

interp->type_watchers[i] = NULL;

}

for (int i=0; i < FUNC_MAX_WATCHERS; i++) {

interp->func_watchers[i] = NULL;

}

interp->active_func_watchers = 0;

for (int i=0; i < CODE_MAX_WATCHERS; i++) {

interp->code_watchers[i] = NULL;

}

interp->active_code_watchers = 0;

for (int i=0; i < CONTEXT_MAX_WATCHERS; i++) {

interp->context_watchers[i] = NULL;

}

interp->active_context_watchers = 0;

// XXX Once we have one allocator per interpreter (i.e.

// per-interpreter GC) we must ensure that all of the interpreter's

// objects have been cleaned up at the point.

// We could clear interp->threads.freelist here

// if it held more than just the initial thread state.

}

PyInterpreterState_Clear(PyInterpreterState *interp)

{

// Use the current Python thread state to call audit hooks and to collect

// garbage. It can be different than the current Python thread state

// of 'interp'.

PyThreadState *current_tstate = current_fast_get();

_PyImport_ClearCore(interp);

interpreter_clear(interp, current_tstate);

}

_PyInterpreterState_Clear(PyThreadState *tstate)