/* Execute compiled code */

#define _PY_INTERPRETER

#include "Python.h"

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

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

#include "pycore_backoff.h"

#include "pycore_call.h" // _PyObject_CallNoArgs()

#include "pycore_cell.h" // PyCell_GetRef()

#include "pycore_ceval.h"

#include "pycore_code.h"

#include "pycore_emscripten_signal.h" // _Py_CHECK_EMSCRIPTEN_SIGNALS

#include "pycore_function.h"

#include "pycore_instruments.h"

#include "pycore_intrinsics.h"

#include "pycore_jit.h"

#include "pycore_long.h" // _PyLong_GetZero()

#include "pycore_moduleobject.h" // PyModuleObject

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

#include "pycore_opcode_metadata.h" // EXTRA_CASES

#include "pycore_optimizer.h" // _PyUOpExecutor_Type

#include "pycore_opcode_utils.h" // MAKE_FUNCTION_*

#include "pycore_pyatomic_ft_wrappers.h" // FT_ATOMIC_*

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

#include "pycore_pystate.h" // _PyInterpreterState_GET()

#include "pycore_range.h" // _PyRangeIterObject

#include "pycore_setobject.h" // _PySet_Update()

#include "pycore_sliceobject.h" // _PyBuildSlice_ConsumeRefs

#include "pycore_tuple.h" // _PyTuple_ITEMS()

#include "pycore_uop_ids.h" // Uops

#include "pycore_pyerrors.h"

#include "pycore_dict.h"

#include "dictobject.h"

#include "pycore_frame.h"

#include "frameobject.h" // _PyInterpreterFrame_GetLine

#include "opcode.h"

#include "pydtrace.h"

#include "setobject.h"

#include "pycore_stackref.h"

#include <stdbool.h> // bool

#ifdef Py_DEBUG

/* For debugging the interpreter: */

# define LLTRACE 1 /* Low-level trace feature */

#endif

#if !defined(Py_BUILD_CORE)

# error "ceval.c must be build with Py_BUILD_CORE define for best performance"

#endif

#if !defined(Py_DEBUG) && !defined(Py_TRACE_REFS)

// GH-89279: The MSVC compiler does not inline these static inline functions

// in PGO build in _PyEval_EvalFrameDefault(), because this function is over

// the limit of PGO, and that limit cannot be configured.

// Define them as macros to make sure that they are always inlined by the

// preprocessor.

#undef Py_IS_TYPE

#define Py_IS_TYPE(ob, type) \

(_PyObject_CAST(ob)->ob_type == (type))

#undef Py_XDECREF

#define Py_XDECREF(arg) \

do { \

PyObject *xop = _PyObject_CAST(arg); \

if (xop != NULL) { \

Py_DECREF(xop); \

} \

} while (0)

#ifndef Py_GIL_DISABLED

#undef Py_DECREF

#define Py_DECREF(arg) \

do { \

PyObject *op = _PyObject_CAST(arg); \

if (_Py_IsImmortal(op)) { \

_Py_DECREF_IMMORTAL_STAT_INC(); \

break; \

} \

_Py_DECREF_STAT_INC(); \

if (--op->ob_refcnt == 0) { \

destructor dealloc = Py_TYPE(op)->tp_dealloc; \

(*dealloc)(op); \

} \

} while (0)

#undef _Py_DECREF_SPECIALIZED

#define _Py_DECREF_SPECIALIZED(arg, dealloc) \

do { \

PyObject *op = _PyObject_CAST(arg); \

if (_Py_IsImmortal(op)) { \

_Py_DECREF_IMMORTAL_STAT_INC(); \

break; \

} \

_Py_DECREF_STAT_INC(); \

if (--op->ob_refcnt == 0) { \

_PyReftracerTrack(op, PyRefTracer_DESTROY); \

destructor d = (destructor)(dealloc); \

d(op); \

} \

} while (0)

#else // Py_GIL_DISABLED

#undef Py_DECREF

#define Py_DECREF(arg) \

do { \

PyObject *op = _PyObject_CAST(arg); \

uint32_t local = _Py_atomic_load_uint32_relaxed(&op->ob_ref_local); \

if (local == _Py_IMMORTAL_REFCNT_LOCAL) { \

_Py_DECREF_IMMORTAL_STAT_INC(); \

break; \

} \

_Py_DECREF_STAT_INC(); \

if (_Py_IsOwnedByCurrentThread(op)) { \

local--; \

_Py_atomic_store_uint32_relaxed(&op->ob_ref_local, local); \

if (local == 0) { \

_Py_MergeZeroLocalRefcount(op); \

} \

} \

else { \

_Py_DecRefShared(op); \

} \

} while (0)

#undef _Py_DECREF_SPECIALIZED

#define _Py_DECREF_SPECIALIZED(arg, dealloc) Py_DECREF(arg)

#endif

#endif

#ifdef LLTRACE

static void

dump_stack(_PyInterpreterFrame *frame, _PyStackRef *stack_pointer)

{

_PyStackRef *stack_base = _PyFrame_Stackbase(frame);

PyObject *exc = PyErr_GetRaisedException();

printf(" stack=[");

for (_PyStackRef *ptr = stack_base; ptr < stack_pointer; ptr++) {

if (ptr != stack_base) {

printf(", ");

}

PyObject *obj = PyStackRef_AsPyObjectBorrow(*ptr);

if (obj == NULL) {

printf("<nil>");

continue;

}

if (

obj == Py_None

|| PyBool_Check(obj)

|| PyLong_CheckExact(obj)

|| PyFloat_CheckExact(obj)

|| PyUnicode_CheckExact(obj)

) {

if (PyObject_Print(obj, stdout, 0) == 0) {

continue;

}

PyErr_Clear();

}

// Don't call __repr__(), it might recurse into the interpreter.

printf("<%s at %p>", Py_TYPE(obj)->tp_name, (void *)(ptr->bits));

}

printf("]\n");

fflush(stdout);

PyErr_SetRaisedException(exc);

}

static void

lltrace_instruction(_PyInterpreterFrame *frame,

_PyStackRef *stack_pointer,

_Py_CODEUNIT *next_instr,

int opcode,

int oparg)

{

if (frame->owner == FRAME_OWNED_BY_CSTACK) {

return;

}

dump_stack(frame, stack_pointer);

const char *opname = _PyOpcode_OpName[opcode];

assert(opname != NULL);

int offset = (int)(next_instr - _PyFrame_GetBytecode(frame));

if (OPCODE_HAS_ARG((int)_PyOpcode_Deopt[opcode])) {

printf("%d: %s %d\n", offset * 2, opname, oparg);

}

else {

printf("%d: %s\n", offset * 2, opname);

}

fflush(stdout);

}

static void

lltrace_resume_frame(_PyInterpreterFrame *frame)

{

PyObject *fobj = PyStackRef_AsPyObjectBorrow(frame->f_funcobj);

if (!PyStackRef_CodeCheck(frame->f_executable) ||

fobj == NULL ||

!PyFunction_Check(fobj)

) {

printf("\nResuming frame.\n");

return;

}

PyFunctionObject *f = (PyFunctionObject *)fobj;

PyObject *exc = PyErr_GetRaisedException();

PyObject *name = f->func_qualname;

if (name == NULL) {

name = f->func_name;

}

printf("\nResuming frame");

if (name) {

printf(" for ");

if (PyObject_Print(name, stdout, 0) < 0) {

PyErr_Clear();

}

}

if (f->func_module) {

printf(" in module ");

if (PyObject_Print(f->func_module, stdout, 0) < 0) {

PyErr_Clear();

}

}

printf("\n");

fflush(stdout);

PyErr_SetRaisedException(exc);

}

static int

maybe_lltrace_resume_frame(_PyInterpreterFrame *frame, _PyInterpreterFrame *skip_frame, PyObject *globals)

{

if (globals == NULL) {

return 0;

}

if (frame == skip_frame) {

return 0;

}

int r = PyDict_Contains(globals, &_Py_ID(__lltrace__));

if (r < 0) {

return -1;

}

int lltrace = r * 5; // Levels 1-4 only trace uops

if (!lltrace) {

// Can also be controlled by environment variable

char *python_lltrace = Py_GETENV("PYTHON_LLTRACE");

if (python_lltrace != NULL && *python_lltrace >= '0') {

lltrace = *python_lltrace - '0'; // TODO: Parse an int and all that

}

}

if (lltrace >= 5) {

lltrace_resume_frame(frame);

}

return lltrace;

}

#endif

static void monitor_reraise(PyThreadState *tstate,

_PyInterpreterFrame *frame,

_Py_CODEUNIT *instr);

static int monitor_stop_iteration(PyThreadState *tstate,

_PyInterpreterFrame *frame,

_Py_CODEUNIT *instr,

PyObject *value);

static void monitor_unwind(PyThreadState *tstate,

_PyInterpreterFrame *frame,

_Py_CODEUNIT *instr);

static int monitor_handled(PyThreadState *tstate,

_PyInterpreterFrame *frame,

_Py_CODEUNIT *instr, PyObject *exc);

static void monitor_throw(PyThreadState *tstate,

_PyInterpreterFrame *frame,

_Py_CODEUNIT *instr);

static int get_exception_handler(PyCodeObject *, int, int*, int*, int*);

static _PyInterpreterFrame *

_PyEvalFramePushAndInit_Ex(PyThreadState *tstate, _PyStackRef func,

PyObject *locals, Py_ssize_t nargs, PyObject *callargs, PyObject *kwargs, _PyInterpreterFrame *previous);

#ifdef HAVE_ERRNO_H

#include <errno.h>

#endif

int

Py_GetRecursionLimit(void)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

return interp->ceval.recursion_limit;

}

void

Py_SetRecursionLimit(int new_limit)

{

PyInterpreterState *interp = _PyInterpreterState_GET();

interp->ceval.recursion_limit = new_limit;

_Py_FOR_EACH_TSTATE_BEGIN(interp, p) {

int depth = p->py_recursion_limit - p->py_recursion_remaining;

p->py_recursion_limit = new_limit;

p->py_recursion_remaining = new_limit - depth;

}

_Py_FOR_EACH_TSTATE_END(interp);

}

/* The function _Py_EnterRecursiveCallTstate() only calls _Py_CheckRecursiveCall()

if the recursion_depth reaches recursion_limit. */

int

_Py_CheckRecursiveCall(PyThreadState *tstate, const char *where)

{

#ifdef USE_STACKCHECK

if (PyOS_CheckStack()) {

++tstate->c_recursion_remaining;

_PyErr_SetString(tstate, PyExc_MemoryError, "Stack overflow");

return -1;

}

#endif

if (tstate->recursion_headroom) {

if (tstate->c_recursion_remaining < -50) {

/* Overflowing while handling an overflow. Give up. */

Py_FatalError("Cannot recover from stack overflow.");

}

}

else {

if (tstate->c_recursion_remaining <= 0) {

tstate->recursion_headroom++;

_PyErr_Format(tstate, PyExc_RecursionError,

"maximum recursion depth exceeded%s",

where);

tstate->recursion_headroom--;

++tstate->c_recursion_remaining;

return -1;

}

}

return 0;

}

const binaryfunc _PyEval_BinaryOps[] = {

[NB_ADD] = PyNumber_Add,

[NB_AND] = PyNumber_And,

[NB_FLOOR_DIVIDE] = PyNumber_FloorDivide,

[NB_LSHIFT] = PyNumber_Lshift,

[NB_MATRIX_MULTIPLY] = PyNumber_MatrixMultiply,

[NB_MULTIPLY] = PyNumber_Multiply,

[NB_REMAINDER] = PyNumber_Remainder,

[NB_OR] = PyNumber_Or,

[NB_POWER] = _PyNumber_PowerNoMod,

[NB_RSHIFT] = PyNumber_Rshift,

[NB_SUBTRACT] = PyNumber_Subtract,

[NB_TRUE_DIVIDE] = PyNumber_TrueDivide,

[NB_XOR] = PyNumber_Xor,

[NB_INPLACE_ADD] = PyNumber_InPlaceAdd,

[NB_INPLACE_AND] = PyNumber_InPlaceAnd,

[NB_INPLACE_FLOOR_DIVIDE] = PyNumber_InPlaceFloorDivide,

[NB_INPLACE_LSHIFT] = PyNumber_InPlaceLshift,

[NB_INPLACE_MATRIX_MULTIPLY] = PyNumber_InPlaceMatrixMultiply,

[NB_INPLACE_MULTIPLY] = PyNumber_InPlaceMultiply,

[NB_INPLACE_REMAINDER] = PyNumber_InPlaceRemainder,

[NB_INPLACE_OR] = PyNumber_InPlaceOr,

[NB_INPLACE_POWER] = _PyNumber_InPlacePowerNoMod,

[NB_INPLACE_RSHIFT] = PyNumber_InPlaceRshift,

[NB_INPLACE_SUBTRACT] = PyNumber_InPlaceSubtract,

[NB_INPLACE_TRUE_DIVIDE] = PyNumber_InPlaceTrueDivide,

[NB_INPLACE_XOR] = PyNumber_InPlaceXor,

};

const conversion_func _PyEval_ConversionFuncs[4] = {

[FVC_STR] = PyObject_Str,

[FVC_REPR] = PyObject_Repr,

[FVC_ASCII] = PyObject_ASCII

};

const _Py_SpecialMethod _Py_SpecialMethods[] = {

[SPECIAL___ENTER__] = {

.name = &_Py_ID(__enter__),

.error = "'%.200s' object does not support the "

"context manager protocol (missed __enter__ method)",

},

[SPECIAL___EXIT__] = {

.name = &_Py_ID(__exit__),

.error = "'%.200s' object does not support the "

"context manager protocol (missed __exit__ method)",

},

[SPECIAL___AENTER__] = {

.name = &_Py_ID(__aenter__),

.error = "'%.200s' object does not support the asynchronous "

"context manager protocol (missed __aenter__ method)",

},

[SPECIAL___AEXIT__] = {

.name = &_Py_ID(__aexit__),

.error = "'%.200s' object does not support the asynchronous "

"context manager protocol (missed __aexit__ method)",

}

};

const size_t _Py_FunctionAttributeOffsets[] = {

[MAKE_FUNCTION_CLOSURE] = offsetof(PyFunctionObject, func_closure),

[MAKE_FUNCTION_ANNOTATIONS] = offsetof(PyFunctionObject, func_annotations),

[MAKE_FUNCTION_KWDEFAULTS] = offsetof(PyFunctionObject, func_kwdefaults),

[MAKE_FUNCTION_DEFAULTS] = offsetof(PyFunctionObject, func_defaults),

[MAKE_FUNCTION_ANNOTATE] = offsetof(PyFunctionObject, func_annotate),

};

// PEP 634: Structural Pattern Matching

// Return a tuple of values corresponding to keys, with error checks for

// duplicate/missing keys.

PyObject *

_PyEval_MatchKeys(PyThreadState *tstate, PyObject *map, PyObject *keys)

{

assert(PyTuple_CheckExact(keys));

Py_ssize_t nkeys = PyTuple_GET_SIZE(keys);

if (!nkeys) {

// No keys means no items.

return PyTuple_New(0);

}

PyObject *seen = NULL;

PyObject *dummy = NULL;

PyObject *values = NULL;

PyObject *get = NULL;

// We use the two argument form of map.get(key, default) for two reasons:

// - Atomically check for a key and get its value without error handling.

// - Don't cause key creation or resizing in dict subclasses like

// collections.defaultdict that define __missing__ (or similar).

int meth_found = _PyObject_GetMethod(map, &_Py_ID(get), &get);

if (get == NULL) {

goto fail;

}

seen = PySet_New(NULL);

if (seen == NULL) {

goto fail;

}

// dummy = object()

dummy = _PyObject_CallNoArgs((PyObject *)&PyBaseObject_Type);

if (dummy == NULL) {

goto fail;

}

values = PyTuple_New(nkeys);

if (values == NULL) {

goto fail;

}

for (Py_ssize_t i = 0; i < nkeys; i++) {

PyObject *key = PyTuple_GET_ITEM(keys, i);

if (PySet_Contains(seen, key) || PySet_Add(seen, key)) {

if (!_PyErr_Occurred(tstate)) {

// Seen it before!

_PyErr_Format(tstate, PyExc_ValueError,

"mapping pattern checks duplicate key (%R)", key);

}

goto fail;

}

PyObject *args[] = { map, key, dummy };

PyObject *value = NULL;

if (meth_found) {

value = PyObject_Vectorcall(get, args, 3, NULL);

}

else {

value = PyObject_Vectorcall(get, &args[1], 2, NULL);

}

if (value == NULL) {

goto fail;

}

if (value == dummy) {

// key not in map!

Py_DECREF(value);

Py_DECREF(values);

// Return None:

values = Py_NewRef(Py_None);

goto done;

}

PyTuple_SET_ITEM(values, i, value);

}

// Success:

done:

Py_DECREF(get);

Py_DECREF(seen);

Py_DECREF(dummy);

return values;

fail:

Py_XDECREF(get);

Py_XDECREF(seen);

Py_XDECREF(dummy);

Py_XDECREF(values);

return NULL;

}

// Extract a named attribute from the subject, with additional bookkeeping to

// raise TypeErrors for repeated lookups. On failure, return NULL (with no

// error set). Use _PyErr_Occurred(tstate) to disambiguate.

static PyObject *

match_class_attr(PyThreadState *tstate, PyObject *subject, PyObject *type,

PyObject *name, PyObject *seen)

{

assert(PyUnicode_CheckExact(name));

assert(PySet_CheckExact(seen));

if (PySet_Contains(seen, name) || PySet_Add(seen, name)) {

if (!_PyErr_Occurred(tstate)) {

// Seen it before!

_PyErr_Format(tstate, PyExc_TypeError,

"%s() got multiple sub-patterns for attribute %R",

((PyTypeObject*)type)->tp_name, name);

}

return NULL;

}

PyObject *attr;

(void)PyObject_GetOptionalAttr(subject, name, &attr);

return attr;

}

// On success (match), return a tuple of extracted attributes. On failure (no

// match), return NULL. Use _PyErr_Occurred(tstate) to disambiguate.

PyObject*

_PyEval_MatchClass(PyThreadState *tstate, PyObject *subject, PyObject *type,

Py_ssize_t nargs, PyObject *kwargs)

{

if (!PyType_Check(type)) {

const char *e = "called match pattern must be a class";

_PyErr_Format(tstate, PyExc_TypeError, e);

return NULL;

}

assert(PyTuple_CheckExact(kwargs));

// First, an isinstance check:

if (PyObject_IsInstance(subject, type) <= 0) {

return NULL;

}

// So far so good:

PyObject *seen = PySet_New(NULL);

if (seen == NULL) {

return NULL;

}

PyObject *attrs = PyList_New(0);

if (attrs == NULL) {

Py_DECREF(seen);

return NULL;

}

// NOTE: From this point on, goto fail on failure:

PyObject *match_args = NULL;

// First, the positional subpatterns:

if (nargs) {

int match_self = 0;

if (PyObject_GetOptionalAttr(type, &_Py_ID(__match_args__), &match_args) < 0) {

goto fail;

}

if (match_args) {

if (!PyTuple_CheckExact(match_args)) {

const char *e = "%s.__match_args__ must be a tuple (got %s)";

_PyErr_Format(tstate, PyExc_TypeError, e,

((PyTypeObject *)type)->tp_name,

Py_TYPE(match_args)->tp_name);

goto fail;

}

}

else {

// _Py_TPFLAGS_MATCH_SELF is only acknowledged if the type does not

// define __match_args__. This is natural behavior for subclasses:

// it's as if __match_args__ is some "magic" value that is lost as

// soon as they redefine it.

match_args = PyTuple_New(0);

match_self = PyType_HasFeature((PyTypeObject*)type,

_Py_TPFLAGS_MATCH_SELF);

}

assert(PyTuple_CheckExact(match_args));

Py_ssize_t allowed = match_self ? 1 : PyTuple_GET_SIZE(match_args);

if (allowed < nargs) {

const char *plural = (allowed == 1) ? "" : "s";

_PyErr_Format(tstate, PyExc_TypeError,

"%s() accepts %d positional sub-pattern%s (%d given)",

((PyTypeObject*)type)->tp_name,

allowed, plural, nargs);

goto fail;

}

if (match_self) {

// Easy. Copy the subject itself, and move on to kwargs.

if (PyList_Append(attrs, subject) < 0) {

goto fail;

}

}

else {

for (Py_ssize_t i = 0; i < nargs; i++) {

PyObject *name = PyTuple_GET_ITEM(match_args, i);

if (!PyUnicode_CheckExact(name)) {

_PyErr_Format(tstate, PyExc_TypeError,

"__match_args__ elements must be strings "

"(got %s)", Py_TYPE(name)->tp_name);

goto fail;

}

PyObject *attr = match_class_attr(tstate, subject, type, name,

seen);

if (attr == NULL) {

goto fail;

}

if (PyList_Append(attrs, attr) < 0) {

Py_DECREF(attr);

goto fail;

}

Py_DECREF(attr);

}

}

Py_CLEAR(match_args);

}

// Finally, the keyword subpatterns:

for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(kwargs); i++) {

PyObject *name = PyTuple_GET_ITEM(kwargs, i);

PyObject *attr = match_class_attr(tstate, subject, type, name, seen);

if (attr == NULL) {

goto fail;

}

if (PyList_Append(attrs, attr) < 0) {

Py_DECREF(attr);

goto fail;

}

Py_DECREF(attr);

}

Py_SETREF(attrs, PyList_AsTuple(attrs));

Py_DECREF(seen);

return attrs;

fail:

// We really don't care whether an error was raised or not... that's our

// caller's problem. All we know is that the match failed.

Py_XDECREF(match_args);

Py_DECREF(seen);

Py_DECREF(attrs);

return NULL;

}

static int do_raise(PyThreadState *tstate, PyObject *exc, PyObject *cause);

PyObject *

PyEval_EvalCode(PyObject *co, PyObject *globals, PyObject *locals)

{

PyThreadState *tstate = _PyThreadState_GET();

if (locals == NULL) {

locals = globals;

}

PyObject *builtins = _PyDict_LoadBuiltinsFromGlobals(globals);

if (builtins == NULL) {

return NULL;

}

PyFrameConstructor desc = {

.fc_globals = globals,

.fc_builtins = builtins,

.fc_name = ((PyCodeObject *)co)->co_name,

.fc_qualname = ((PyCodeObject *)co)->co_name,

.fc_code = co,

.fc_defaults = NULL,

.fc_kwdefaults = NULL,

.fc_closure = NULL

};

PyFunctionObject *func = _PyFunction_FromConstructor(&desc);

_Py_DECREF_BUILTINS(builtins);

if (func == NULL) {

return NULL;

}

EVAL_CALL_STAT_INC(EVAL_CALL_LEGACY);

PyObject *res = _PyEval_Vector(tstate, func, locals, NULL, 0, NULL);

Py_DECREF(func);

return res;

}

/* Interpreter main loop */

PyObject *

PyEval_EvalFrame(PyFrameObject *f)

{

/* Function kept for backward compatibility */

PyThreadState *tstate = _PyThreadState_GET();

return _PyEval_EvalFrame(tstate, f->f_frame, 0);

}

PyObject *

PyEval_EvalFrameEx(PyFrameObject *f, int throwflag)

{

PyThreadState *tstate = _PyThreadState_GET();

return _PyEval_EvalFrame(tstate, f->f_frame, throwflag);

}

#include "ceval_macros.h"

int _Py_CheckRecursiveCallPy(

PyThreadState *tstate)

{

if (tstate->recursion_headroom) {

if (tstate->py_recursion_remaining < -50) {

/* Overflowing while handling an overflow. Give up. */

Py_FatalError("Cannot recover from Python stack overflow.");

}

}

else {

if (tstate->py_recursion_remaining <= 0) {

tstate->recursion_headroom++;

_PyErr_Format(tstate, PyExc_RecursionError,

"maximum recursion depth exceeded");

tstate->recursion_headroom--;

return -1;

}

}

return 0;

}

static const _Py_CODEUNIT _Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS[] = {

/* Put a NOP at the start, so that the IP points into

* the code, rather than before it */

{ .op.code = NOP, .op.arg = 0 },

{ .op.code = INTERPRETER_EXIT, .op.arg = 0 }, /* reached on return */

{ .op.code = NOP, .op.arg = 0 },

{ .op.code = INTERPRETER_EXIT, .op.arg = 0 }, /* reached on yield */

{ .op.code = RESUME, .op.arg = RESUME_OPARG_DEPTH1_MASK | RESUME_AT_FUNC_START }

};

#ifdef Py_DEBUG

extern void _PyUOpPrint(const _PyUOpInstruction *uop);

#endif

/* Disable unused label warnings. They are handy for debugging, even

if computed gotos aren't used. */

/* TBD - what about other compilers? */

#if defined(__GNUC__)

# pragma GCC diagnostic push

# pragma GCC diagnostic ignored "-Wunused-label"

#elif defined(_MSC_VER) /* MS_WINDOWS */

# pragma warning(push)

# pragma warning(disable:4102)

#endif

PyObject **

_PyObjectArray_FromStackRefArray(_PyStackRef *input, Py_ssize_t nargs, PyObject **scratch)

{

PyObject **result;

if (nargs > MAX_STACKREF_SCRATCH) {

// +1 in case PY_VECTORCALL_ARGUMENTS_OFFSET is set.

result = PyMem_Malloc((nargs + 1) * sizeof(PyObject *));

if (result == NULL) {

return NULL;

}

result++;

}

else {

result = scratch;

}

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

result[i] = PyStackRef_AsPyObjectBorrow(input[i]);

}

return result;

}

void

_PyObjectArray_Free(PyObject **array, PyObject **scratch)

{

if (array != scratch) {

PyMem_Free(array);

}

}

/* _PyEval_EvalFrameDefault() is a *big* function,

* so consume 3 units of C stack */

#define PY_EVAL_C_STACK_UNITS 2

/* _PyEval_EvalFrameDefault is too large to optimize for speed with PGO on MSVC

when the JIT is enabled or GIL is disabled. Disable that optimization around

this function only. If this is fixed upstream, we should gate this on the

version of MSVC.

*/

#if (defined(_MSC_VER) && \

defined(_Py_USING_PGO) && \

(defined(_Py_JIT) || \

defined(Py_GIL_DISABLED)))

#define DO_NOT_OPTIMIZE_INTERP_LOOP

#endif

#ifdef DO_NOT_OPTIMIZE_INTERP_LOOP

# pragma optimize("t", off)

/* This setting is reversed below following _PyEval_EvalFrameDefault */

#endif

PyObject* _Py_HOT_FUNCTION

_PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int throwflag)

{

_Py_EnsureTstateNotNULL(tstate);

CALL_STAT_INC(pyeval_calls);

#if USE_COMPUTED_GOTOS

/* Import the static jump table */

#include "opcode_targets.h"

#endif

#ifdef Py_STATS

int lastopcode = 0;

#endif

uint8_t opcode; /* Current opcode */

int oparg; /* Current opcode argument, if any */

#ifdef LLTRACE

int lltrace = 0;

#endif

_PyInterpreterFrame entry_frame;

#ifdef Py_DEBUG

/* Set these to invalid but identifiable values for debugging. */

entry_frame.f_funcobj = (_PyStackRef){.bits = 0xaaa0};

entry_frame.f_locals = (PyObject*)0xaaa1;

entry_frame.frame_obj = (PyFrameObject*)0xaaa2;

entry_frame.f_globals = (PyObject*)0xaaa3;

entry_frame.f_builtins = (PyObject*)0xaaa4;

#endif

entry_frame.f_executable = PyStackRef_None;

entry_frame.instr_ptr = (_Py_CODEUNIT *)_Py_INTERPRETER_TRAMPOLINE_INSTRUCTIONS + 1;

entry_frame.stackpointer = entry_frame.localsplus;

entry_frame.owner = FRAME_OWNED_BY_CSTACK;

entry_frame.visited = 0;

entry_frame.return_offset = 0;

/* Push frame */

entry_frame.previous = tstate->current_frame;

frame->previous = &entry_frame;

tstate->current_frame = frame;

tstate->c_recursion_remaining -= (PY_EVAL_C_STACK_UNITS - 1);

if (_Py_EnterRecursiveCallTstate(tstate, "")) {

tstate->c_recursion_remaining--;

tstate->py_recursion_remaining--;

goto exit_unwind;

}

/* support for generator.throw() */

if (throwflag) {

if (_Py_EnterRecursivePy(tstate)) {

goto exit_unwind;

}

/* Because this avoids the RESUME,

* we need to update instrumentation */

#ifdef Py_GIL_DISABLED

/* Load thread-local bytecode */

if (frame->tlbc_index != ((_PyThreadStateImpl *)tstate)->tlbc_index) {

_Py_CODEUNIT *bytecode =

_PyEval_GetExecutableCode(tstate, _PyFrame_GetCode(frame));

if (bytecode == NULL) {

goto error;

}

ptrdiff_t off = frame->instr_ptr - _PyFrame_GetBytecode(frame);

frame->tlbc_index = ((_PyThreadStateImpl *)tstate)->tlbc_index;

frame->instr_ptr = bytecode + off;

}

#endif

_Py_Instrument(_PyFrame_GetCode(frame), tstate->interp);

monitor_throw(tstate, frame, frame->instr_ptr);

/* TO DO -- Monitor throw entry. */

goto resume_with_error;

}

/* Local "register" variables.

* These are cached values from the frame and code object. */

_Py_CODEUNIT *next_instr;

_PyStackRef *stack_pointer;

#if defined(_Py_TIER2) && !defined(_Py_JIT)

/* Tier 2 interpreter state */

_PyExecutorObject *current_executor = NULL;

const _PyUOpInstruction *next_uop = NULL;

#endif

start_frame:

if (_Py_EnterRecursivePy(tstate)) {

goto exit_unwind;

}

next_instr = frame->instr_ptr;

resume_frame:

stack_pointer = _PyFrame_GetStackPointer(frame);

#ifdef LLTRACE

lltrace = maybe_lltrace_resume_frame(frame, &entry_frame, GLOBALS());

if (lltrace < 0) {

goto exit_unwind;

}

#endif

#ifdef Py_DEBUG

/* _PyEval_EvalFrameDefault() must not be called with an exception set,

because it can clear it (directly or indirectly) and so the

caller loses its exception */

assert(!_PyErr_Occurred(tstate));

#endif

DISPATCH();

{

/* Start instructions */

#if !USE_COMPUTED_GOTOS

dispatch_opcode:

switch (opcode)

#endif

{

#include "generated_cases.c.h"

#if USE_COMPUTED_GOTOS

_unknown_opcode:

#else

EXTRA_CASES // From pycore_opcode_metadata.h, a 'case' for each unused opcode

#endif

/* Tell C compilers not to hold the opcode variable in the loop.

next_instr points the current instruction without TARGET(). */

opcode = next_instr->op.code;

_PyErr_Format(tstate, PyExc_SystemError,

"%U:%d: unknown opcode %d",

_PyFrame_GetCode(frame)->co_filename,

PyUnstable_InterpreterFrame_GetLine(frame),

opcode);

goto error;

} /* End instructions */

/* This should never be reached. Every opcode should end with DISPATCH()

or goto error. */

Py_UNREACHABLE();

pop_4_error:

STACK_SHRINK(1);

pop_3_error:

STACK_SHRINK(1);

pop_2_error:

STACK_SHRINK(1);

pop_1_error:

STACK_SHRINK(1);

error:

/* Double-check exception status. */

#ifdef NDEBUG

if (!_PyErr_Occurred(tstate)) {

_PyErr_SetString(tstate, PyExc_SystemError,

"error return without exception set");

}

#else

assert(_PyErr_Occurred(tstate));

#endif

/* Log traceback info. */

assert(frame != &entry_frame);

if (!_PyFrame_IsIncomplete(frame)) {

PyFrameObject *f = _PyFrame_GetFrameObject(frame);

if (f != NULL) {

PyTraceBack_Here(f);

}

}

_PyEval_MonitorRaise(tstate, frame, next_instr-1);

exception_unwind:

{

/* We can't use frame->instr_ptr here, as RERAISE may have set it */

int offset = INSTR_OFFSET()-1;

int level, handler, lasti;

if (get_exception_handler(_PyFrame_GetCode(frame), offset, &level, &handler, &lasti) == 0) {

// No handlers, so exit.

assert(_PyErr_Occurred(tstate));

/* Pop remaining stack entries. */

_PyStackRef *stackbase = _PyFrame_Stackbase(frame);

while (stack_pointer > stackbase) {

PyStackRef_XCLOSE(POP());

}

assert(STACK_LEVEL() == 0);

_PyFrame_SetStackPointer(frame, stack_pointer);

monitor_unwind(tstate, frame, next_instr-1);

goto exit_unwind;

}

assert(STACK_LEVEL() >= level);

_PyStackRef *new_top = _PyFrame_Stackbase(frame) + level;

while (stack_pointer > new_top) {

PyStackRef_XCLOSE(POP());

}

if (lasti) {

int frame_lasti = _PyInterpreterFrame_LASTI(frame);

PyObject *lasti = PyLong_FromLong(frame_lasti);

if (lasti == NULL) {

goto exception_unwind;

}

PUSH(PyStackRef_FromPyObjectSteal(lasti));

}

/* Make the raw exception data

available to the handler,

so a program can emulate the

Python main loop. */

PyObject *exc = _PyErr_GetRaisedException(tstate);

PUSH(PyStackRef_FromPyObjectSteal(exc));

next_instr = _PyFrame_GetBytecode(frame) + handler;

if (monitor_handled(tstate, frame, next_instr, exc) < 0) {

goto exception_unwind;

}