/* Execute compiled code */

#define _PY_INTERPRETER

#include "Python.h"

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

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

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

#include "pycore_code.h"

#include "pycore_function.h"

#include "pycore_intrinsics.h"

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

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

#include "pycore_moduleobject.h" // PyModuleObject

#include "pycore_opcode.h" // EXTRA_CASES

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

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

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

#include "pycore_range.h" // _PyRangeIterObject

#include "pycore_sliceobject.h" // _PyBuildSlice_ConsumeRefs

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

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

#include "pycore_emscripten_signal.h" // _Py_CHECK_EMSCRIPTEN_SIGNALS

#include "pycore_dict.h"

#include "dictobject.h"

#include "pycore_frame.h"

#include "opcode.h"

#include "pydtrace.h"

#include "setobject.h"

#include "structmember.h" // struct PyMemberDef, T_OFFSET_EX

#include <ctype.h>

#include <stdbool.h>

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

#define Py_DECREF(arg) \

do { \

_Py_DECREF_STAT_INC(); \

PyObject *op = _PyObject_CAST(arg); \

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 { \

_Py_DECREF_STAT_INC(); \

PyObject *op = _PyObject_CAST(arg); \

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

destructor d = (destructor)(dealloc); \

d(op); \

} \

} while (0)

#endif

// GH-89279: Similar to above, force inlining by using a macro.

#if defined(_MSC_VER) && SIZEOF_INT == 4

#define _Py_atomic_load_relaxed_int32(ATOMIC_VAL) (assert(sizeof((ATOMIC_VAL)->_value) == 4), *((volatile int*)&((ATOMIC_VAL)->_value)))

#else

#define _Py_atomic_load_relaxed_int32(ATOMIC_VAL) _Py_atomic_load_relaxed(ATOMIC_VAL)

#endif

/* Forward declarations */

static PyObject *trace_call_function(

PyThreadState *tstate, PyObject *callable, PyObject **stack,

Py_ssize_t oparg, PyObject *kwnames);

static PyObject * do_call_core(

PyThreadState *tstate, PyObject *func,

PyObject *callargs, PyObject *kwdict, int use_tracing);

#ifdef LLTRACE

static void

dump_stack(_PyInterpreterFrame *frame, PyObject **stack_pointer)

{

PyObject **stack_base = _PyFrame_Stackbase(frame);

PyObject *type, *value, *traceback;

PyErr_Fetch(&type, &value, &traceback);

printf(" stack=[");

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

if (ptr != stack_base) {

printf(", ");

}

if (PyObject_Print(*ptr, stdout, 0) != 0) {

PyErr_Clear();

printf("<%s object at %p>",

Py_TYPE(*ptr)->tp_name, (void *)(*ptr));

}

}

printf("]\n");

fflush(stdout);

PyErr_Restore(type, value, traceback);

}

static void

lltrace_instruction(_PyInterpreterFrame *frame,

PyObject **stack_pointer,

_Py_CODEUNIT *next_instr)

{

/* This dump_stack() operation is risky, since the repr() of some

objects enters the interpreter recursively. It is also slow.

So you might want to comment it out. */

dump_stack(frame, stack_pointer);

int oparg = _Py_OPARG(*next_instr);

int opcode = _Py_OPCODE(*next_instr);

const char *opname = _PyOpcode_OpName[opcode];

assert(opname != NULL);

int offset = (int)(next_instr - _PyCode_CODE(frame->f_code));

if (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 (frame->owner == FRAME_OWNED_BY_CSTACK ||

fobj == NULL ||

!PyFunction_Check(fobj)

) {

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

return;

}

PyFunctionObject *f = (PyFunctionObject *)fobj;

PyObject *type, *value, *traceback;

PyErr_Fetch(&type, &value, &traceback);

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_Restore(type, value, traceback);

}

#endif

static int call_trace(Py_tracefunc, PyObject *,

PyThreadState *, _PyInterpreterFrame *,

int, PyObject *);

static int call_trace_protected(Py_tracefunc, PyObject *,

PyThreadState *, _PyInterpreterFrame *,

int, PyObject *);

static void call_exc_trace(Py_tracefunc, PyObject *,

PyThreadState *, _PyInterpreterFrame *);

static int maybe_call_line_trace(Py_tracefunc, PyObject *,

PyThreadState *, _PyInterpreterFrame *, int);

static void maybe_dtrace_line(_PyInterpreterFrame *, PyTraceInfo *, int);

static void dtrace_function_entry(_PyInterpreterFrame *);

static void dtrace_function_return(_PyInterpreterFrame *);

static PyObject * import_name(PyThreadState *, _PyInterpreterFrame *,

PyObject *, PyObject *, PyObject *);

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

static void format_exc_check_arg(PyThreadState *, PyObject *, const char *, PyObject *);

static void format_exc_unbound(PyThreadState *tstate, PyCodeObject *co, int oparg);

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

static int check_except_type_valid(PyThreadState *tstate, PyObject* right);

static int check_except_star_type_valid(PyThreadState *tstate, PyObject* right);

static void format_kwargs_error(PyThreadState *, PyObject *func, PyObject *kwargs);

static void format_awaitable_error(PyThreadState *, PyTypeObject *, int);

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

static _PyInterpreterFrame *

_PyEvalFramePushAndInit(PyThreadState *tstate, PyFunctionObject *func,

PyObject *locals, PyObject* const* args,

size_t argcount, PyObject *kwnames);

static void

_PyEvalFrameClearAndPop(PyThreadState *tstate, _PyInterpreterFrame *frame);

#define UNBOUNDLOCAL_ERROR_MSG \

"cannot access local variable '%s' where it is not associated with a value"

#define UNBOUNDFREE_ERROR_MSG \

"cannot access free variable '%s' where it is not associated with a" \

" value in enclosing scope"

#ifndef NDEBUG

/* Ensure that tstate is valid: sanity check for PyEval_AcquireThread() and

PyEval_RestoreThread(). Detect if tstate memory was freed. It can happen

when a thread continues to run after Python finalization, especially

daemon threads. */

static int

is_tstate_valid(PyThreadState *tstate)

{

assert(!_PyMem_IsPtrFreed(tstate));

assert(!_PyMem_IsPtrFreed(tstate->interp));

return 1;

}

#endif

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

}

static const binaryfunc binary_ops[] = {

[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,

};

// PEP 634: Structural Pattern Matching

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

// duplicate/missing keys.

static PyObject*

match_keys(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 = PyObject_GetAttr(subject, name);

if (attr == NULL && _PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {

_PyErr_Clear(tstate);

}

return attr;

}

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

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

static PyObject*

match_class(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 type";

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

match_args = PyObject_GetAttrString(type, "__match_args__");

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 if (_PyErr_ExceptionMatches(tstate, PyExc_AttributeError)) {

_PyErr_Clear(tstate);

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

}

else {

goto fail;

}

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.

PyList_Append(attrs, subject);

}

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;

}

PyList_Append(attrs, attr);

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;

}

PyList_Append(attrs, attr);

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

static int exception_group_match(

PyObject* exc_value, PyObject *match_type,

PyObject **match, PyObject **rest);

static int unpack_iterable(PyThreadState *, PyObject *, int, int, PyObject **);

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"

static int

trace_function_entry(PyThreadState *tstate, _PyInterpreterFrame *frame)

{

if (tstate->c_tracefunc != NULL) {

/* tstate->c_tracefunc, if defined, is a

function that will be called on *every* entry

to a code block. Its return value, if not

None, is a function that will be called at

the start of each executed line of code.

(Actually, the function must return itself

in order to continue tracing.) The trace

functions are called with three arguments:

a pointer to the current frame, a string

indicating why the function is called, and

an argument which depends on the situation.

The global trace function is also called

whenever an exception is detected. */

if (call_trace_protected(tstate->c_tracefunc,

tstate->c_traceobj,

tstate, frame,

PyTrace_CALL, Py_None)) {

/* Trace function raised an error */

return -1;

}

}

if (tstate->c_profilefunc != NULL) {

/* Similar for c_profilefunc, except it needn't

return itself and isn't called for "line" events */

if (call_trace_protected(tstate->c_profilefunc,

tstate->c_profileobj,

tstate, frame,

PyTrace_CALL, Py_None)) {

/* Profile function raised an error */

return -1;

}

}

return 0;

}

static int

trace_function_exit(PyThreadState *tstate, _PyInterpreterFrame *frame, PyObject *retval)

{

if (tstate->c_tracefunc) {

if (call_trace_protected(tstate->c_tracefunc, tstate->c_traceobj,

tstate, frame, PyTrace_RETURN, retval)) {

return -1;

}

}

if (tstate->c_profilefunc) {

if (call_trace_protected(tstate->c_profilefunc, tstate->c_profileobj,

tstate, frame, PyTrace_RETURN, retval)) {

return -1;

}

}

return 0;

}

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 inline int _Py_EnterRecursivePy(PyThreadState *tstate) {

return (tstate->py_recursion_remaining-- <= 0) &&

_Py_CheckRecursiveCallPy(tstate);

}

static inline void _Py_LeaveRecursiveCallPy(PyThreadState *tstate) {

tstate->py_recursion_remaining++;

}

// GH-89279: Must be a macro to be sure it's inlined by MSVC.

#define is_method(stack_pointer, args) (PEEK((args)+2) != NULL)

#define KWNAMES_LEN() \

(kwnames == NULL ? 0 : ((int)PyTuple_GET_SIZE(kwnames)))

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

// opcode is an 8-bit value to improve the code generated by MSVC

// for the big switch below (in combination with the EXTRA_CASES macro).

uint8_t opcode; /* Current opcode */

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

_Py_atomic_int * const eval_breaker = &tstate->interp->ceval.eval_breaker;

#ifdef LLTRACE

int lltrace = 0;

#endif

_PyCFrame cframe;

_PyInterpreterFrame entry_frame;

PyObject *kwnames = NULL; // Borrowed reference. Reset by CALL instructions.

/* WARNING: Because the _PyCFrame lives on the C stack,

* but can be accessed from a heap allocated object (tstate)

* strict stack discipline must be maintained.

*/

_PyCFrame *prev_cframe = tstate->cframe;

cframe.use_tracing = prev_cframe->use_tracing;

cframe.previous = prev_cframe;

tstate->cframe = &cframe;

assert(tstate->interp->interpreter_trampoline != NULL);

#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_code = tstate->interp->interpreter_trampoline;

entry_frame.prev_instr =

_PyCode_CODE(tstate->interp->interpreter_trampoline);

entry_frame.stacktop = 0;

entry_frame.owner = FRAME_OWNED_BY_CSTACK;

entry_frame.yield_offset = 0;

/* Push frame */

entry_frame.previous = prev_cframe->current_frame;

frame->previous = &entry_frame;

cframe.current_frame = frame;

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;

}

TRACE_FUNCTION_THROW_ENTRY();

DTRACE_FUNCTION_ENTRY();

goto resume_with_error;

}

/* Local "register" variables.

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

PyObject *names;

PyObject *consts;

_Py_CODEUNIT *next_instr;

PyObject **stack_pointer;

/* Sets the above local variables from the frame */

#define SET_LOCALS_FROM_FRAME() \

{ \

PyCodeObject *co = frame->f_code; \

names = co->co_names; \

consts = co->co_consts; \

} \

assert(_PyInterpreterFrame_LASTI(frame) >= -1); \

/* Jump back to the last instruction executed... */ \

next_instr = frame->prev_instr + 1; \

stack_pointer = _PyFrame_GetStackPointer(frame); \

/* Set stackdepth to -1. \

Update when returning or calling trace function. \

Having stackdepth <= 0 ensures that invalid \

values are not visible to the cycle GC. \

We choose -1 rather than 0 to assist debugging. \

*/ \

frame->stacktop = -1;

start_frame:

if (_Py_EnterRecursivePy(tstate)) {

goto exit_unwind;

}

resume_frame:

SET_LOCALS_FROM_FRAME();

#ifdef LLTRACE

{

if (frame != &entry_frame) {

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

if (r < 0) {

goto exit_unwind;

}

lltrace = r;

}

if (lltrace) {

lltrace_resume_frame(frame);

}

}

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

handle_eval_breaker:

/* Do periodic things, like check for signals and async I/0.

* We need to do reasonably frequently, but not too frequently.

* All loops should include a check of the eval breaker.

* We also check on return from any builtin function.

*/

if (_Py_HandlePending(tstate) != 0) {

goto error;

}

DISPATCH();

{

/* Start instructions */

#if !USE_COMPUTED_GOTOS

dispatch_opcode:

switch (opcode)

#endif

{

#include "generated_cases.c.h"

#if USE_COMPUTED_GOTOS

TARGET_DO_TRACING:

#else

case DO_TRACING:

#endif

{

assert(cframe.use_tracing);

assert(tstate->tracing == 0);

if (INSTR_OFFSET() >= frame->f_code->_co_firsttraceable) {

int instr_prev = _PyInterpreterFrame_LASTI(frame);

frame->prev_instr = next_instr;

NEXTOPARG();

// No _PyOpcode_Deopt here, since RESUME has no optimized forms:

if (opcode == RESUME) {

if (oparg < 2) {

CHECK_EVAL_BREAKER();

}

/* Call tracing */

TRACE_FUNCTION_ENTRY();

DTRACE_FUNCTION_ENTRY();

}

else {

/* line-by-line tracing support */

if (PyDTrace_LINE_ENABLED()) {

maybe_dtrace_line(frame, &tstate->trace_info, instr_prev);

}

if (cframe.use_tracing &&

tstate->c_tracefunc != NULL && !tstate->tracing) {

int err;

/* see maybe_call_line_trace()

for expository comments */

_PyFrame_SetStackPointer(frame, stack_pointer);

err = maybe_call_line_trace(tstate->c_tracefunc,

tstate->c_traceobj,

tstate, frame, instr_prev);

// Reload possibly changed frame fields:

stack_pointer = _PyFrame_GetStackPointer(frame);

frame->stacktop = -1;

// next_instr is only reloaded if tracing *does not* raise.

// This is consistent with the behavior of older Python

// versions. If a trace function sets a new f_lineno and

// *then* raises, we use the *old* location when searching

// for an exception handler, displaying the traceback, and

// so on:

if (err) {

// next_instr wasn't incremented at the start of this

// instruction. Increment it before handling the error,

// so that it looks the same as a "normal" instruction:

next_instr++;

goto error;

}

// Reload next_instr. Don't increment it, though, since

// we're going to re-dispatch to the "true" instruction now:

next_instr = frame->prev_instr;

}

}

}

NEXTOPARG();

PRE_DISPATCH_GOTO();

// No _PyOpcode_Deopt here, since EXTENDED_ARG has no optimized forms:

while (opcode == EXTENDED_ARG) {

// CPython hasn't ever traced the instruction after an EXTENDED_ARG.

// Inline the EXTENDED_ARG here, so we can avoid branching there:

INSTRUCTION_START(EXTENDED_ARG);

opcode = _Py_OPCODE(*next_instr);

oparg = oparg << 8 | _Py_OPARG(*next_instr);

// Make sure the next instruction isn't a RESUME, since that needs

// to trace properly (and shouldn't have an EXTENDED_ARG, anyways):

assert(opcode != RESUME);

PRE_DISPATCH_GOTO();

}

opcode = _PyOpcode_Deopt[opcode];

if (_PyOpcode_Caches[opcode]) {

uint16_t *counter = &next_instr[1].cache;

// The instruction is going to decrement the counter, so we need to

// increment it here to make sure it doesn't try to specialize:

if (!ADAPTIVE_COUNTER_IS_MAX(*counter)) {

INCREMENT_ADAPTIVE_COUNTER(*counter);

}

}

DISPATCH_GOTO();

}

#if USE_COMPUTED_GOTOS

_unknown_opcode:

#else

EXTRA_CASES // From opcode.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 = _Py_OPCODE(*next_instr);

_PyErr_Format(tstate, PyExc_SystemError,

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

frame->f_code->co_filename,

_PyInterpreterFrame_GetLine(frame),

opcode);

goto error;

} /* End instructions */

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

or goto error. */

Py_UNREACHABLE();

unbound_local_error:

{

format_exc_check_arg(tstate, PyExc_UnboundLocalError,

UNBOUNDLOCAL_ERROR_MSG,

PyTuple_GetItem(frame->f_code->co_localsplusnames, oparg)

);

goto error;

}

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:

kwnames = NULL;

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