#include "Python.h"

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

#include "pycore_ceval.h"

#include "pycore_code.h" // stats

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

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

#include "pycore_emscripten_trampoline.h" // _Py_EmscriptenTrampoline_Init()

#include "pycore_frame.h"

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

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

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

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

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

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

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

#include "pycore_pystate.h"

#include "pycore_runtime_init.h" // _PyRuntimeState_INIT

#include "pycore_sysmodule.h" // _PySys_Audit()

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

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

#ifdef HAVE_DLOPEN

# ifdef HAVE_DLFCN_H

# include <dlfcn.h>

# if !HAVE_DECL_RTLD_LAZY

# define RTLD_LAZY 1

#ifdef HAVE_THREAD_LOCAL

_Py_thread_local PyThreadState *_Py_tss_tstate = NULL;

static inline PyThreadState *

current_fast_get(void)

{

#ifdef HAVE_THREAD_LOCAL

return _Py_tss_tstate;

// XXX Fall back to the PyThread_tss_*() API.

# error "no supported thread-local variable storage classifier"

}

static inline void

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

{

assert(tstate != NULL);

#ifdef HAVE_THREAD_LOCAL

_Py_tss_tstate = tstate;

// XXX Fall back to the PyThread_tss_*() API.

# error "no supported thread-local variable storage classifier"

}

static inline void

current_fast_clear(_PyRuntimeState *Py_UNUSED(runtime))

{

#ifdef HAVE_THREAD_LOCAL

_Py_tss_tstate = NULL;

// XXX Fall back to the PyThread_tss_*() API.

# error "no supported thread-local variable storage classifier"

}

#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 int

tstate_tss_initialized(Py_tss_t *key)

{

return PyThread_tss_is_created(key);

}

static inline int

tstate_tss_init(Py_tss_t *key)

{

assert(!tstate_tss_initialized(key));

return PyThread_tss_create(key);

}

static inline void

tstate_tss_fini(Py_tss_t *key)

{

assert(tstate_tss_initialized(key));

PyThread_tss_delete(key);

}

static inline PyThreadState *

tstate_tss_get(Py_tss_t *key)

{

assert(tstate_tss_initialized(key));

return (PyThreadState *)PyThread_tss_get(key);

}

static inline int

tstate_tss_set(Py_tss_t *key, PyThreadState *tstate)

{

assert(tstate != NULL);

assert(tstate_tss_initialized(key));

return PyThread_tss_set(key, (void *)tstate);

}

static inline int

tstate_tss_clear(Py_tss_t *key)

{

assert(tstate_tss_initialized(key));

return PyThread_tss_set(key, (void *)NULL);

}

#ifdef HAVE_FORK

static PyStatus

tstate_tss_reinit(Py_tss_t *key)

{

if (!tstate_tss_initialized(key)) {

return _PyStatus_OK();

}

PyThreadState *tstate = tstate_tss_get(key);

tstate_tss_fini(key);

if (tstate_tss_init(key) != 0) {

return _PyStatus_NO_MEMORY();

}

/* If the thread had an associated auto thread state, reassociate it with

if (tstate && tstate_tss_set(key, tstate) != 0) {

return _PyStatus_ERR("failed to re-set autoTSSkey");

}

return _PyStatus_OK();

}

#define gilstate_tss_initialized(runtime) \

tstate_tss_initialized(&(runtime)->autoTSSkey)

#define gilstate_tss_init(runtime) \

tstate_tss_init(&(runtime)->autoTSSkey)

#define gilstate_tss_fini(runtime) \

tstate_tss_fini(&(runtime)->autoTSSkey)

#define gilstate_tss_get(runtime) \

tstate_tss_get(&(runtime)->autoTSSkey)

#define _gilstate_tss_set(runtime, tstate) \

tstate_tss_set(&(runtime)->autoTSSkey, tstate)

#define _gilstate_tss_clear(runtime) \

tstate_tss_clear(&(runtime)->autoTSSkey)

#define gilstate_tss_reinit(runtime) \

tstate_tss_reinit(&(runtime)->autoTSSkey)

static inline void

gilstate_tss_set(_PyRuntimeState *runtime, PyThreadState *tstate)

{

assert(tstate != NULL && tstate->interp->runtime == runtime);

if (_gilstate_tss_set(runtime, tstate) != 0) {

Py_FatalError("failed to set current tstate (TSS)");

}

}

static inline void

gilstate_tss_clear(_PyRuntimeState *runtime)

{

if (_gilstate_tss_clear(runtime) != 0) {

Py_FatalError("failed to clear current tstate (TSS)");

}

}

#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_tss_get(tstate->interp->runtime));

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);

_PyRuntimeState *runtime = tstate->interp->runtime;

PyThreadState *tcur = gilstate_tss_get(runtime);

assert(tstate != tcur);

if (tcur != NULL) {

tcur->_status.bound_gilstate = 0;

}

gilstate_tss_set(runtime, 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_tss_get(tstate->interp->runtime));

gilstate_tss_clear(tstate->interp->runtime);

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_tss_get(tstate->interp->runtime));

return tstate == current_fast_get();

}

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

#define LOCKS_INIT(runtime) \

{ \

&(runtime)->interpreters.mutex, \

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

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

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

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

&(runtime)->ceval.sys_trace_profile_mutex, \

&(runtime)->atexit.mutex, \

&(runtime)->audit_hooks.mutex, \

&(runtime)->allocators.mutex, \

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

&(runtime)->_main_interpreter.code_state.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(!runtime->core_initialized);

assert(!runtime->initialized);

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;

#if defined(__EMSCRIPTEN__) && defined(PY_CALL_TRAMPOLINE)

_Py_EmscriptenTrampoline_Init(runtime);

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);

}

if (gilstate_tss_init(runtime) != 0) {

_PyRuntimeState_Fini(runtime);

return _PyStatus_NO_MEMORY();

}

if (PyThread_tss_create(&runtime->trashTSSkey) != 0) {

_PyRuntimeState_Fini(runtime);

return _PyStatus_NO_MEMORY();

}

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);

if (gilstate_tss_initialized(runtime)) {

gilstate_tss_fini(runtime);

}

if (PyThread_tss_is_created(&runtime->trashTSSkey)) {

PyThread_tss_delete(&runtime->trashTSSkey);

}

}

#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();

/* bpo-42540: id_mutex is freed by _PyInterpreterState_Delete, which does

if (_PyThread_at_fork_reinit(&runtime->interpreters.main->id_mutex) < 0) {

return _PyStatus_ERR("Failed to reinitialize runtime locks");

}

PyStatus status = gilstate_tss_reinit(runtime);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

if (PyThread_tss_is_created(&runtime->trashTSSkey)) {

PyThread_tss_delete(&runtime->trashTSSkey);

}

if (PyThread_tss_create(&runtime->trashTSSkey) != 0) {

return _PyStatus_NO_MEMORY();

}

_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)

{

return PyMem_RawCalloc(1, sizeof(PyInterpreterState));

}

static void

free_interpreter(PyInterpreterState *interp)

{

// 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;

}

PyMem_RawFree(interp);

}

}

#ifndef NDEBUG

static inline int check_interpreter_whence(long);

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;

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

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

interp->next = next;

PyStatus status = _PyObject_InitState(interp);

if (_PyStatus_EXCEPTION(status)) {

return status;

}

_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);

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->sys_profile_initialized = false;

interp->sys_trace_initialized = false;

#ifdef _Py_TIER2

(void)_Py_SetOptimizer(interp, NULL);

interp->executor_list_head = NULL;

interp->trace_run_counter = JIT_CLEANUP_THRESHOLD;

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

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

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

}

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;

}

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.

HEAD_LOCK(runtime);

PyThreadState *p = interp->threads.head;

HEAD_UNLOCK(runtime);

while (p != NULL) {

// 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.

PyThreadState_Clear(p);

HEAD_LOCK(runtime);

p = p->next;

HEAD_UNLOCK(runtime);

}

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;

}

#ifdef _Py_TIER2

_PyOptimizerObject *old = _Py_SetOptimizer(interp, NULL);

assert(old != NULL);

Py_DECREF(old);

/* 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);

// At this time, all the threads should be cleared so we don't need atomic

// operations for instrumentation_version or eval_breaker.

interp->ceval.instrumentation_version = 0;

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]);

}

}

interp->sys_profile_initialized = false;

interp->sys_trace_initialized = false;

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

Py_CLEAR(interp->monitoring_tool_names[t]);

}

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);

_PyAST_Fini(interp);

_PyWarnings_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);

/* 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);

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.

}

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)

{

_PyImport_ClearCore(tstate->interp);

interpreter_clear(tstate->interp, tstate);

}

static inline void tstate_deactivate(PyThreadState *tstate);

static void tstate_set_detached(PyThreadState *tstate, int detached_state);

static void zapthreads(PyInterpreterState *interp);

PyInterpreterState_Delete(PyInterpreterState *interp)

{

_PyRuntimeState *runtime = interp->runtime;

struct pyinterpreters *interpreters = &runtime->interpreters;

// XXX Clearing the "current" thread state should happen before

// we start finalizing the interpreter (or the current thread state).

PyThreadState *tcur = current_fast_get();

if (tcur != NULL && interp == tcur->interp) {

/* Unset current thread. After this, many C API calls become crashy. */

_PyThreadState_Detach(tcur);

}

zapthreads(interp);

// XXX These two calls should be done at the end of clear_interpreter(),

// but currently some objects get decref'ed after that.

#ifdef Py_REF_DEBUG

_PyInterpreterState_FinalizeRefTotal(interp);

_PyInterpreterState_FinalizeAllocatedBlocks(interp);

HEAD_LOCK(runtime);

PyInterpreterState **p;

for (p = &interpreters->head; ; p = &(*p)->next) {

if (*p == NULL) {

Py_FatalError("NULL interpreter");

}

if (*p == interp) {

break;

}

}

if (interp->threads.head != NULL) {

Py_FatalError("remaining threads");

}

*p = interp->next;

if (interpreters->main == interp) {

interpreters->main = NULL;

if (interpreters->head != NULL) {

Py_FatalError("remaining subinterpreters");

}

}

HEAD_UNLOCK(runtime);

if (interp->id_mutex != NULL) {

PyThread_free_lock(interp->id_mutex);

}

_Py_qsbr_fini(interp);

_PyObject_FiniState(interp);

free_interpreter(interp);