/* Execute compiled code */

#define _PY_INTERPRETER

#include "Python.h"

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

#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_sysmodule.h" // _PySys_Audit()

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

#include "pycore_typeobject.h" // _PySuper_Lookup()

#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) && !defined(Py_GIL_DISABLED)

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

// TODO: implement Py_DECREF macro for Py_GIL_DISABLED

#undef Py_DECREF

#define Py_DECREF(arg) \

do { \

PyObject *op = _PyObject_CAST(arg); \

if (_Py_IsImmortal(op)) { \

break; \

} \

_Py_DECREF_STAT_INC(); \

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

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

(*dealloc)(op); \

} \

} while (0)

#undef Py_XDECREF

#define Py_XDECREF(arg) \

do { \

PyObject *xop = _PyObject_CAST(arg); \

if (xop != NULL) { \

Py_DECREF(xop); \

} \

} while (0)

#undef Py_IS_TYPE

#define Py_IS_TYPE(ob, type) \

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

#undef _Py_DECREF_SPECIALIZED

#define _Py_DECREF_SPECIALIZED(arg, dealloc) \

do { \

PyObject *op = _PyObject_CAST(arg); \

if (_Py_IsImmortal(op)) { \

break; \

} \

_Py_DECREF_STAT_INC(); \

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

destructor d = (destructor)(dealloc); \

d(op); \

} \

} while (0)

#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 - _PyCode_CODE(_PyFrame_GetCode(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 = frame->f_funcobj;

if (!PyCode_Check(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_raise(PyThreadState *tstate,

_PyInterpreterFrame *frame,

_Py_CODEUNIT *instr);

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 PyObject * import_name(PyThreadState *, _PyInterpreterFrame *,

PyObject *, PyObject *, PyObject *);

static PyObject * import_from(PyThreadState *, PyObject *, PyObject *);

static int check_args_iterable(PyThreadState *, PyObject *func, PyObject *vararg);

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

static _PyInterpreterFrame *

_PyEvalFramePushAndInit_Ex(PyThreadState *tstate, PyFunctionObject *func,

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

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

for (PyThreadState *p = interp->threads.head; p != NULL; p = p->next) {

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

p->py_recursion_limit = new_limit;

p->py_recursion_remaining = new_limit - depth;

}

}

/* 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)",

}

};

// 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 = _PyEval_BuiltinsFromGlobals(tstate, globals); // borrowed ref

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

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 }

};

extern const struct _PyCode_DEF(8) _Py_InitCleanup;

#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

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 = (PyObject*)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 = Py_None;

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

entry_frame.stacktop = 0;

entry_frame.owner = FRAME_OWNED_BY_CSTACK;

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

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

/* INSTRUMENTED_LINE has to be here, rather than in bytecodes.c,

* because it needs to capture frame->instr_ptr before it is updated,

* as happens in the standard instruction prologue.

*/

#if USE_COMPUTED_GOTOS

TARGET_INSTRUMENTED_LINE:

#else

case INSTRUMENTED_LINE:

#endif

{

_Py_CODEUNIT *prev = frame->instr_ptr;

_Py_CODEUNIT *here = frame->instr_ptr = next_instr;

int original_opcode = 0;

if (tstate->tracing) {

PyCodeObject *code = _PyFrame_GetCode(frame);

original_opcode = code->_co_monitoring->lines[(int)(here - _PyCode_CODE(code))].original_opcode;

} else {

_PyFrame_SetStackPointer(frame, stack_pointer);

original_opcode = _Py_call_instrumentation_line(

tstate, frame, here, prev);

stack_pointer = _PyFrame_GetStackPointer(frame);

if (original_opcode < 0) {

next_instr = here+1;

goto error;

}

next_instr = frame->instr_ptr;

if (next_instr != here) {

DISPATCH();

}

}

if (_PyOpcode_Caches[original_opcode]) {

_PyBinaryOpCache *cache = (_PyBinaryOpCache *)(next_instr+1);

/* Prevent the underlying instruction from specializing

* and overwriting the instrumentation. */

PAUSE_ADAPTIVE_COUNTER(cache->counter);

}

opcode = original_opcode;

DISPATCH_GOTO();

}

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

}

}

monitor_raise(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 = _PyCode_CODE(_PyFrame_GetCode(frame)) + handler;

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

goto exception_unwind;

}

/* Resume normal execution */

#ifdef LLTRACE

if (lltrace >= 5) {

lltrace_resume_frame(frame);

}

#endif

DISPATCH();

}

}

exit_unwind:

assert(_PyErr_Occurred(tstate));

_Py_LeaveRecursiveCallPy(tstate);

assert(frame != &entry_frame);

// GH-99729: We need to unlink the frame *before* clearing it:

_PyInterpreterFrame *dying = frame;

frame = tstate->current_frame = dying->previous;

_PyEval_FrameClearAndPop(tstate, dying);

frame->return_offset = 0;

if (frame == &entry_frame) {

/* Restore previous frame and exit */

tstate->current_frame = frame->previous;

tstate->c_recursion_remaining += PY_EVAL_C_STACK_UNITS;

return NULL;

}