// It is read by generators stored in Tools/cases_generator/

// to generate Python/generated_cases.c.h and others.

// Note that there is some dummy C code at the top and bottom of the file

// to fool text editors like VS Code into believing this is valid C code.

// The actual instruction definitions start at // BEGIN BYTECODES //.

// See Tools/cases_generator/README.md for more information.

#include "Python.h"

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

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

#include "pycore_moduleobject.h" // PyModuleObject

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

#include "pycore_range.h" // _PyRangeIterObject

#include "pycore_sliceobject.h" // _PyBuildSlice_ConsumeRefs

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

#include "pycore_dict.h"

#include "dictobject.h"

#include "pycore_frame.h"

#include "opcode.h"

#include "pydtrace.h"

#include "setobject.h"

#define USE_COMPUTED_GOTOS 0

#include "ceval_macros.h"

/* Flow control macros */

#define GO_TO_INSTRUCTION(instname) ((void)0)

#define op(name, ...) /* NAME is ignored */

#define macro(name) static int MACRO_##name

/* Annotations */

#define guard

#define override

#define specializing

#define split

#define replicate(TIMES)

#define tier1

#define no_save_ip

// Dummy variables for stack effects.

static PyObject *value, *value1, *value2, *left, *right, *res, *sum, *prod, *sub;

static size_t jump;

// Dummy variables for cache effects

dummy_func(

PyThreadState *tstate,

_PyInterpreterFrame *frame,

unsigned char opcode,

unsigned int oparg,

_Py_CODEUNIT *next_instr,

PyObject **stack_pointer,

int throwflag,

)

{

// Dummy labels.

pop_1_error:

// Dummy locals.

PyObject *attrs;

PyObject *bottom;

PyObject *callable;

PyObject *callargs;

PyObject *codeobj;

PyObject *cond;

PyObject *descr;

PyObject *exc;

PyObject *exit;

PyObject *fget;

PyObject *fmt_spec;

PyObject *func;

uint32_t func_version;

PyObject *getattribute;

PyObject *kwargs;

PyObject *kwdefaults;

PyObject *len_o;

PyObject *match;

PyObject *match_type;

PyObject *method;

PyObject *mgr;

Py_ssize_t min_args;

PyObject *names;

PyObject *new_exc;

PyObject *next;

PyObject *none;

PyObject *null;

PyObject *prev_exc;

PyObject *receiver;

PyObject *rest;

int result;

PyObject *self;

PyObject *seq;

PyObject *slice;

PyObject *step;

PyObject *subject;

PyObject *top;

PyObject *type;

PyObject *val0;

PyObject *val1;

switch (opcode) {

// BEGIN BYTECODES //

}

family(RESUME, 0) = {

RESUME_CHECK,

};

macro(NOT_TAKEN) = NOP;

op(_CHECK_PERIODIC, (--)) {

_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();

if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {

int err = _Py_HandlePending(tstate);

ERROR_IF(err != 0, error);

}

}

op(_CHECK_PERIODIC_IF_NOT_YIELD_FROM, (--)) {

if ((oparg & RESUME_OPARG_LOCATION_MASK) < RESUME_AFTER_YIELD_FROM) {

_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();

QSBR_QUIESCENT_STATE(tstate); \

if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {

int err = _Py_HandlePending(tstate);

ERROR_IF(err != 0, error);

}

}

}

op(_QUICKEN_RESUME, (--)) {

if (tstate->tracing == 0 && this_instr->op.code == RESUME) {

FT_ATOMIC_STORE_UINT8_RELAXED(this_instr->op.code, RESUME_CHECK);

}

}

tier1 op(_MAYBE_INSTRUMENT, (--)) {

uintptr_t global_version = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & ~_PY_EVAL_EVENTS_MASK;

uintptr_t code_version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version);

if (code_version != global_version) {

int err = _Py_Instrument(_PyFrame_GetCode(frame), tstate->interp);

if (err) {

ERROR_NO_POP();

}

next_instr = this_instr;

DISPATCH();

}

op(_LOAD_BYTECODE, (--)) {

#ifdef Py_GIL_DISABLED

if (frame->tlbc_index !=

((_PyThreadStateImpl *)tstate)->tlbc_index) {

_Py_CODEUNIT *bytecode =

_PyEval_GetExecutableCode(tstate, _PyFrame_GetCode(frame));

ERROR_IF(bytecode == NULL, error);

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

frame->instr_ptr = bytecode + off;

// Make sure this_instr gets reset correctley for any uops that

// follow

next_instr = frame->instr_ptr;

DISPATCH();

}

#endif

}

_MAYBE_INSTRUMENT +

_QUICKEN_RESUME +

_CHECK_PERIODIC_IF_NOT_YIELD_FROM;

inst(RESUME_CHECK, (--)) {

#if defined(__EMSCRIPTEN__)

#ifdef Py_GIL_DISABLED

DEOPT_IF(frame->tlbc_index !=

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

#endif

}

op(_MONITOR_RESUME, (--)) {

int err = _Py_call_instrumentation(

tstate, oparg > 0, frame, this_instr);

ERROR_IF(err, error);

if (frame->instr_ptr != this_instr) {

/* Instrumentation has jumped */

next_instr = frame->instr_ptr;

}

}

_MAYBE_INSTRUMENT +

_CHECK_PERIODIC_IF_NOT_YIELD_FROM +

_MONITOR_RESUME;

LOAD_FAST,

};

_PyStackRef value_s = GETLOCAL(oparg);

if (PyStackRef_IsNull(value_s)) {

_PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError,

UNBOUNDLOCAL_ERROR_MSG,

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

);

ERROR_IF(1, error);

}

}

}

inst(LOAD_FAST_AND_CLEAR, (-- value)) {

value = GETLOCAL(oparg);

// do not use SETLOCAL here, it decrefs the old value

}

inst(LOAD_FAST_LOAD_FAST, ( -- value1, value2)) {

uint32_t oparg1 = oparg >> 4;

uint32_t oparg2 = oparg & 15;

value1 = PyStackRef_DUP(GETLOCAL(oparg1));

value2 = PyStackRef_DUP(GETLOCAL(oparg2));

}

LOAD_CONST_IMMORTAL,

};

inst(LOAD_CONST, (-- value)) {

/* We can't do this in the bytecode compiler as

* marshalling can intern strings and make them immortal. */

PyObject *obj = GETITEM(FRAME_CO_CONSTS, oparg);

value = PyStackRef_FromPyObjectNew(obj);

#if ENABLE_SPECIALIZATION

if (this_instr->op.code == LOAD_CONST) {

this_instr->op.code = _Py_IsImmortal(obj) ? LOAD_CONST_IMMORTAL : LOAD_CONST_MORTAL;

}

#endif

}

inst(LOAD_CONST_MORTAL, (-- value)) {

PyObject *obj = GETITEM(FRAME_CO_CONSTS, oparg);

value = PyStackRef_FromPyObjectNew(obj);

}

inst(LOAD_CONST_IMMORTAL, (-- value)) {

PyObject *obj = GETITEM(FRAME_CO_CONSTS, oparg);

assert(_Py_IsImmortal(obj));

value = PyStackRef_FromPyObjectImmortal(obj);

}

replicate(4) inst(LOAD_SMALL_INT, (-- value)) {

assert(oparg < _PY_NSMALLPOSINTS);

PyObject *obj = (PyObject *)&_PyLong_SMALL_INTS[_PY_NSMALLNEGINTS + oparg];

value = PyStackRef_FromPyObjectImmortal(obj);

}

}

STORE_FAST,

};

inst(STORE_FAST_LOAD_FAST, (value1 -- value2)) {

uint32_t oparg1 = oparg >> 4;

uint32_t oparg2 = oparg & 15;

SETLOCAL(oparg1, value1);

}

inst(STORE_FAST_STORE_FAST, (value2, value1 --)) {

uint32_t oparg1 = oparg >> 4;

uint32_t oparg2 = oparg & 15;

SETLOCAL(oparg1, value1);

}

}

pure inst(PUSH_NULL, (-- res)) {

res = PyStackRef_NULL;

}

no_save_ip inst(END_FOR, (value -- )) {

/* Don't update instr_ptr, so that POP_ITER sees

* the FOR_ITER as the previous instruction.

* This has the benign side effect that if value is

* finalized it will see the location as the FOR_ITER's.

*/

PyStackRef_CLOSE(value);

}

macro(POP_ITER) = POP_TOP;

/* Need to create a fake StopIteration error here,

* to conform to PEP 380 */

int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value));

if (err) {

}

}

DECREF_INPUTS();

}

tier1 inst(INSTRUMENTED_POP_ITER, (iter -- )) {

INSTRUMENTED_JUMP(prev_instr, this_instr+1, PY_MONITORING_EVENT_BRANCH_RIGHT);

PyStackRef_CLOSE(iter);

}

val = value;

DEAD(value);

}

PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver);

if (PyGen_Check(receiver_o) || PyCoro_CheckExact(receiver_o)) {

int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value));

if (err) {

}

}

val = value;

DEAD(value);

}

ERROR_IF(res_o == NULL, error);

res = PyStackRef_FromPyObjectSteal(res_o);

}

}

TO_BOOL_ALWAYS_TRUE,

TO_BOOL_BOOL,

TO_BOOL_INT,

TO_BOOL_LIST,

TO_BOOL_NONE,

TO_BOOL_STR,

};

_Py_Specialize_ToBool(value, next_instr);

DISPATCH_SAME_OPARG();

}

}

}

STAT_INC(TO_BOOL, hit);

}

inst(TO_BOOL_INT, (unused/1, unused/2, value -- res)) {

PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);

EXIT_IF(!PyLong_CheckExact(value_o));