int total_args,

_PyStackRef kwnames);

PyAPI_FUNC(PyObject*)

_Py_VectorCallInstrumentation_StackRefSteal(

_PyStackRef callable,

_PyStackRef* arguments,

int total_args,

_PyStackRef kwnames,

bool call_instrumentation,

_PyInterpreterFrame* frame,

_Py_CODEUNIT* this_instr,

PyThreadState* tstate);

PyAPI_FUNC(PyObject *)

_Py_BuiltinCallFast_StackRefSteal(

_PyStackRef callable,

_PyInterpreterFrame *frame, _PyStackRef *stack_pointer,

const char *filename, int lineno);

PyAPI_FUNC(PyObject*) _PyMapping_GetOptionalItem2(PyObject* obj, PyObject* key, int* err);

#ifdef __cplusplus

}

Allow building CPython with the tail calling interpreter on Visual Studio 2026 MSVC. This provides a performance gain over the prior interpreter for MSVC. Patch by Ken Jin, Brandt Bucher, and Chris Eibl. With help from the MSVC team including Hulon Jenkins.

return 0;

}

_PyMapping_GetOptionalItem2(PyObject *obj, PyObject *key, int *err)

{

PyObject* result;

*err = PyMapping_GetOptionalItem(obj, key, &result);

return result;

}

PyObject_SetItem(PyObject *o, PyObject *key, PyObject *value)

{

<ClCompile Include="..\Python\bltinmodule.c" />

<ClCompile Include="..\Python\bootstrap_hash.c" />

<ClCompile Include="..\Python\brc.c" />

<ClCompile Include="..\Python\ceval.c">

<AdditionalOptions Condition="'$(UseTailCallInterp)' == 'true' and $(PlatformToolset) != 'ClangCL'">/std:clatest %(AdditionalOptions)</AdditionalOptions>

</ClCompile>

<ClCompile Include="..\Python\codecs.c" />

<ClCompile Include="..\Python\codegen.c" />

<ClCompile Include="..\Python\compile.c" />

}

inst(LOAD_BUILD_CLASS, ( -- bc)) {

int err;

PyObject *bc_o = _PyMapping_GetOptionalItem2(BUILTINS(), &_Py_ID(__build_class__), &err);

ERROR_IF(err < 0);

if (bc_o == NULL) {

_PyErr_SetString(tstate, PyExc_NameError,

inst(LOAD_FROM_DICT_OR_GLOBALS, (mod_or_class_dict -- v)) {

PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);

int err;

PyObject *v_o = _PyMapping_GetOptionalItem2(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &err);

PyStackRef_CLOSE(mod_or_class_dict);

ERROR_IF(err < 0);

if (v_o == NULL) {

else {

/* Slow-path if globals or builtins is not a dict */

/* namespace 1: globals */

v_o = _PyMapping_GetOptionalItem2(GLOBALS(), name, &err);

ERROR_IF(err < 0);

if (v_o == NULL) {

/* namespace 2: builtins */

v_o = _PyMapping_GetOptionalItem2(BUILTINS(), name, &err);

ERROR_IF(err < 0);

if (v_o == NULL) {

_PyEval_FormatExcCheckArg(

}

inst(LOAD_FROM_DICT_OR_DEREF, (class_dict_st -- value)) {

PyObject *name;

PyObject *class_dict = PyStackRef_AsPyObjectBorrow(class_dict_st);

assert(class_dict);

assert(oparg >= 0 && oparg < _PyFrame_GetCode(frame)->co_nlocalsplus);

name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg);

int err;

PyObject* value_o = _PyMapping_GetOptionalItem2(class_dict, name, &err);

if (err < 0) {

ERROR_NO_POP();

}

}

inst(SETUP_ANNOTATIONS, (--)) {

if (LOCALS() == NULL) {

_PyErr_Format(tstate, PyExc_SystemError,

"no locals found when setting up annotations");

ERROR_IF(true);

}

/* check if __annotations__ in locals()... */

int err;

PyObject* ann_dict = _PyMapping_GetOptionalItem2(LOCALS(), &_Py_ID(__annotations__), &err);

ERROR_IF(err < 0);

if (ann_dict == NULL) {

ann_dict = PyDict_New();

}

// we make no attempt to optimize here; specializations should

// handle any case whose performance we care about

PyObject *super;

{

// scope to tell MSVC that stack is not escaping

PyObject *stack[] = {class, self};

super = PyObject_Vectorcall(global_super, stack, oparg & 2, NULL);

}

if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) {

PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING;

if (super == NULL) {

PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);

PyTypeObject *cls = (PyTypeObject *)class;

int method_found = 0;

PyObject *attr_o;

{

// scope to tell MSVC that method_found_ptr is not escaping

int *method_found_ptr = &method_found;

attr_o = _PySuper_Lookup(cls, self, name,

Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? method_found_ptr : NULL);

}

if (attr_o == NULL) {

ERROR_NO_POP();

}

}

assert(PyStackRef_IsTaggedInt(lasti));

(void)lasti; // Shut up compiler warning if asserts are off

PyObject* res_o;

{

// scope to tell MSVC that stack is not escaping

PyObject *stack[5] = {NULL, PyStackRef_AsPyObjectBorrow(exit_self), exc, val_o, tb};

int has_self = !PyStackRef_IsNull(exit_self);

res_o = PyObject_Vectorcall(exit_func_o, stack + 2 - has_self,

(3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);

}

Py_XDECREF(original_tb);

ERROR_IF(res_o == NULL);

res = PyStackRef_FromPyObjectSteal(res_o);

frame->return_offset = INSTRUCTION_SIZE;

DISPATCH_INLINED(new_frame);

}

PyObject* res_o = _Py_VectorCallInstrumentation_StackRefSteal(

callable,

arguments,

total_args,

PyStackRef_NULL,

opcode == INSTRUMENTED_CALL,

frame,

this_instr,

tstate);

DEAD(args);

DEAD(self_or_null);

DEAD(callable);

ERROR_IF(res_o == NULL);

res = PyStackRef_FromPyObjectSteal(res_o);

}

frame->return_offset = INSTRUCTION_SIZE;

DISPATCH_INLINED(new_frame);

}

PyObject* res_o = _Py_VectorCallInstrumentation_StackRefSteal(

callable,

arguments,

total_args,

kwnames,

opcode == INSTRUMENTED_CALL_KW,

frame,

this_instr,

tstate);

DEAD(kwnames);

DEAD(args);

DEAD(self_or_null);

DEAD(callable);

ERROR_IF(res_o == NULL);

res = PyStackRef_FromPyObjectSteal(res_o);

}

return res;

}

_Py_VectorCallInstrumentation_StackRefSteal(

_PyStackRef callable,

_PyStackRef* arguments,

int total_args,

_PyStackRef kwnames,

bool call_instrumentation,

_PyInterpreterFrame* frame,

_Py_CODEUNIT* this_instr,

PyThreadState* tstate)

{

PyObject* res;

STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);

if (CONVERSION_FAILED(args_o)) {

res = NULL;

goto cleanup;

}

PyObject* callable_o = PyStackRef_AsPyObjectBorrow(callable);

PyObject* kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames);

int positional_args = total_args;

if (kwnames_o != NULL) {

positional_args -= (int)PyTuple_GET_SIZE(kwnames_o);

}

res = PyObject_Vectorcall(

callable_o, args_o,

positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET,

kwnames_o);

STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);

if (call_instrumentation) {

PyObject* arg = total_args == 0 ?

&_PyInstrumentation_MISSING : PyStackRef_AsPyObjectBorrow(arguments[0]);

if (res == NULL) {

_Py_call_instrumentation_exc2(

tstate, PY_MONITORING_EVENT_C_RAISE,

frame, this_instr, callable_o, arg);

}

else {

int err = _Py_call_instrumentation_2args(

tstate, PY_MONITORING_EVENT_C_RETURN,

frame, this_instr, callable_o, arg);

if (err < 0) {

Py_CLEAR(res);

}

}

}

assert((res != NULL) ^ (PyErr_Occurred() != NULL));

cleanup:

PyStackRef_XCLOSE(kwnames);

// arguments is a pointer into the GC visible stack,

// so we must NULL out values as we clear them.

for (int i = total_args - 1; i >= 0; i--) {

_PyStackRef tmp = arguments[i];

arguments[i] = PyStackRef_NULL;

PyStackRef_CLOSE(tmp);

}

PyStackRef_CLOSE(callable);

return res;

}

PyObject *

_Py_BuiltinCallFast_StackRefSteal(

_PyStackRef callable,

# elif defined(_MSC_VER) && (_MSC_VER < 1950)

# error "You need at least VS 2026 / PlatformToolset v145 for tail calling."

# if defined(_MSC_VER) && !defined(__clang__)

# define Py_MUSTTAIL [[msvc::musttail]]

# define Py_PRESERVE_NONE_CC __preserve_none

# define Py_MUSTTAIL __attribute__((musttail))

# define Py_PRESERVE_NONE_CC __attribute__((preserve_none))

typedef PyObject *(Py_PRESERVE_NONE_CC *py_tail_call_funcptr)(TAIL_CALL_PARAMS);

# define DISPATCH_TABLE_VAR instruction_funcptr_table

# define DISPATCH_TABLE instruction_funcptr_handler_table

# define TRACING_DISPATCH_TABLE instruction_funcptr_tracing_table

# define TARGET(op) Py_NO_INLINE PyObject *Py_PRESERVE_NONE_CC _TAIL_CALL_##op(TAIL_CALL_PARAMS)

# define DISPATCH_GOTO() \

do { \