#include "opcode_targets.h"
#define TARGET(op) \
- TARGET_##op: \
- case op:
+ op: \
+ TARGET_##op
#define DISPATCH() \
{ \
#endif
#else
-#define TARGET(op) \
- case op:
+#define TARGET(op) op
#define DISPATCH() continue
#define FAST_DISPATCH() goto fast_next_opcode
It is essential that any operation that fails must goto error
and that all operation that succeed call [FAST_]DISPATCH() ! */
- TARGET(NOP)
+ case TARGET(NOP): {
FAST_DISPATCH();
+ }
- TARGET(LOAD_FAST) {
+ case TARGET(LOAD_FAST): {
PyObject *value = GETLOCAL(oparg);
if (value == NULL) {
format_exc_check_arg(PyExc_UnboundLocalError,
FAST_DISPATCH();
}
- PREDICTED(LOAD_CONST);
- TARGET(LOAD_CONST) {
+ case TARGET(LOAD_CONST): {
+ PREDICTED(LOAD_CONST);
PyObject *value = GETITEM(consts, oparg);
Py_INCREF(value);
PUSH(value);
FAST_DISPATCH();
}
- PREDICTED(STORE_FAST);
- TARGET(STORE_FAST) {
+ case TARGET(STORE_FAST): {
+ PREDICTED(STORE_FAST);
PyObject *value = POP();
SETLOCAL(oparg, value);
FAST_DISPATCH();
}
- TARGET(POP_TOP) {
+ case TARGET(POP_TOP): {
PyObject *value = POP();
Py_DECREF(value);
FAST_DISPATCH();
}
- TARGET(ROT_TWO) {
+ case TARGET(ROT_TWO): {
PyObject *top = TOP();
PyObject *second = SECOND();
SET_TOP(second);
FAST_DISPATCH();
}
- TARGET(ROT_THREE) {
+ case TARGET(ROT_THREE): {
PyObject *top = TOP();
PyObject *second = SECOND();
PyObject *third = THIRD();
FAST_DISPATCH();
}
- TARGET(ROT_FOUR) {
+ case TARGET(ROT_FOUR): {
PyObject *top = TOP();
PyObject *second = SECOND();
PyObject *third = THIRD();
FAST_DISPATCH();
}
- TARGET(DUP_TOP) {
+ case TARGET(DUP_TOP): {
PyObject *top = TOP();
Py_INCREF(top);
PUSH(top);
FAST_DISPATCH();
}
- TARGET(DUP_TOP_TWO) {
+ case TARGET(DUP_TOP_TWO): {
PyObject *top = TOP();
PyObject *second = SECOND();
Py_INCREF(top);
FAST_DISPATCH();
}
- TARGET(UNARY_POSITIVE) {
+ case TARGET(UNARY_POSITIVE): {
PyObject *value = TOP();
PyObject *res = PyNumber_Positive(value);
Py_DECREF(value);
DISPATCH();
}
- TARGET(UNARY_NEGATIVE) {
+ case TARGET(UNARY_NEGATIVE): {
PyObject *value = TOP();
PyObject *res = PyNumber_Negative(value);
Py_DECREF(value);
DISPATCH();
}
- TARGET(UNARY_NOT) {
+ case TARGET(UNARY_NOT): {
PyObject *value = TOP();
int err = PyObject_IsTrue(value);
Py_DECREF(value);
goto error;
}
- TARGET(UNARY_INVERT) {
+ case TARGET(UNARY_INVERT): {
PyObject *value = TOP();
PyObject *res = PyNumber_Invert(value);
Py_DECREF(value);
DISPATCH();
}
- TARGET(BINARY_POWER) {
+ case TARGET(BINARY_POWER): {
PyObject *exp = POP();
PyObject *base = TOP();
PyObject *res = PyNumber_Power(base, exp, Py_None);
DISPATCH();
}
- TARGET(BINARY_MULTIPLY) {
+ case TARGET(BINARY_MULTIPLY): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = PyNumber_Multiply(left, right);
DISPATCH();
}
- TARGET(BINARY_MATRIX_MULTIPLY) {
+ case TARGET(BINARY_MATRIX_MULTIPLY): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = PyNumber_MatrixMultiply(left, right);
DISPATCH();
}
- TARGET(BINARY_TRUE_DIVIDE) {
+ case TARGET(BINARY_TRUE_DIVIDE): {
PyObject *divisor = POP();
PyObject *dividend = TOP();
PyObject *quotient = PyNumber_TrueDivide(dividend, divisor);
DISPATCH();
}
- TARGET(BINARY_FLOOR_DIVIDE) {
+ case TARGET(BINARY_FLOOR_DIVIDE): {
PyObject *divisor = POP();
PyObject *dividend = TOP();
PyObject *quotient = PyNumber_FloorDivide(dividend, divisor);
DISPATCH();
}
- TARGET(BINARY_MODULO) {
+ case TARGET(BINARY_MODULO): {
PyObject *divisor = POP();
PyObject *dividend = TOP();
PyObject *res;
DISPATCH();
}
- TARGET(BINARY_ADD) {
+ case TARGET(BINARY_ADD): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *sum;
DISPATCH();
}
- TARGET(BINARY_SUBTRACT) {
+ case TARGET(BINARY_SUBTRACT): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *diff = PyNumber_Subtract(left, right);
DISPATCH();
}
- TARGET(BINARY_SUBSCR) {
+ case TARGET(BINARY_SUBSCR): {
PyObject *sub = POP();
PyObject *container = TOP();
PyObject *res = PyObject_GetItem(container, sub);
DISPATCH();
}
- TARGET(BINARY_LSHIFT) {
+ case TARGET(BINARY_LSHIFT): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = PyNumber_Lshift(left, right);
DISPATCH();
}
- TARGET(BINARY_RSHIFT) {
+ case TARGET(BINARY_RSHIFT): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = PyNumber_Rshift(left, right);
DISPATCH();
}
- TARGET(BINARY_AND) {
+ case TARGET(BINARY_AND): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = PyNumber_And(left, right);
DISPATCH();
}
- TARGET(BINARY_XOR) {
+ case TARGET(BINARY_XOR): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = PyNumber_Xor(left, right);
DISPATCH();
}
- TARGET(BINARY_OR) {
+ case TARGET(BINARY_OR): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = PyNumber_Or(left, right);
DISPATCH();
}
- TARGET(LIST_APPEND) {
+ case TARGET(LIST_APPEND): {
PyObject *v = POP();
PyObject *list = PEEK(oparg);
int err;
DISPATCH();
}
- TARGET(SET_ADD) {
+ case TARGET(SET_ADD): {
PyObject *v = POP();
PyObject *set = PEEK(oparg);
int err;
DISPATCH();
}
- TARGET(INPLACE_POWER) {
+ case TARGET(INPLACE_POWER): {
PyObject *exp = POP();
PyObject *base = TOP();
PyObject *res = PyNumber_InPlacePower(base, exp, Py_None);
DISPATCH();
}
- TARGET(INPLACE_MULTIPLY) {
+ case TARGET(INPLACE_MULTIPLY): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = PyNumber_InPlaceMultiply(left, right);
DISPATCH();
}
- TARGET(INPLACE_MATRIX_MULTIPLY) {
+ case TARGET(INPLACE_MATRIX_MULTIPLY): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = PyNumber_InPlaceMatrixMultiply(left, right);
DISPATCH();
}
- TARGET(INPLACE_TRUE_DIVIDE) {
+ case TARGET(INPLACE_TRUE_DIVIDE): {
PyObject *divisor = POP();
PyObject *dividend = TOP();
PyObject *quotient = PyNumber_InPlaceTrueDivide(dividend, divisor);
DISPATCH();
}
- TARGET(INPLACE_FLOOR_DIVIDE) {
+ case TARGET(INPLACE_FLOOR_DIVIDE): {
PyObject *divisor = POP();
PyObject *dividend = TOP();
PyObject *quotient = PyNumber_InPlaceFloorDivide(dividend, divisor);
DISPATCH();
}
- TARGET(INPLACE_MODULO) {
+ case TARGET(INPLACE_MODULO): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *mod = PyNumber_InPlaceRemainder(left, right);
DISPATCH();
}
- TARGET(INPLACE_ADD) {
+ case TARGET(INPLACE_ADD): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *sum;
DISPATCH();
}
- TARGET(INPLACE_SUBTRACT) {
+ case TARGET(INPLACE_SUBTRACT): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *diff = PyNumber_InPlaceSubtract(left, right);
DISPATCH();
}
- TARGET(INPLACE_LSHIFT) {
+ case TARGET(INPLACE_LSHIFT): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = PyNumber_InPlaceLshift(left, right);
DISPATCH();
}
- TARGET(INPLACE_RSHIFT) {
+ case TARGET(INPLACE_RSHIFT): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = PyNumber_InPlaceRshift(left, right);
DISPATCH();
}
- TARGET(INPLACE_AND) {
+ case TARGET(INPLACE_AND): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = PyNumber_InPlaceAnd(left, right);
DISPATCH();
}
- TARGET(INPLACE_XOR) {
+ case TARGET(INPLACE_XOR): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = PyNumber_InPlaceXor(left, right);
DISPATCH();
}
- TARGET(INPLACE_OR) {
+ case TARGET(INPLACE_OR): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = PyNumber_InPlaceOr(left, right);
DISPATCH();
}
- TARGET(STORE_SUBSCR) {
+ case TARGET(STORE_SUBSCR): {
PyObject *sub = TOP();
PyObject *container = SECOND();
PyObject *v = THIRD();
DISPATCH();
}
- TARGET(DELETE_SUBSCR) {
+ case TARGET(DELETE_SUBSCR): {
PyObject *sub = TOP();
PyObject *container = SECOND();
int err;
DISPATCH();
}
- TARGET(PRINT_EXPR) {
+ case TARGET(PRINT_EXPR): {
_Py_IDENTIFIER(displayhook);
PyObject *value = POP();
PyObject *hook = _PySys_GetObjectId(&PyId_displayhook);
DISPATCH();
}
- TARGET(RAISE_VARARGS) {
+ case TARGET(RAISE_VARARGS): {
PyObject *cause = NULL, *exc = NULL;
switch (oparg) {
case 2:
goto error;
}
- TARGET(RETURN_VALUE) {
+ case TARGET(RETURN_VALUE): {
retval = POP();
assert(f->f_iblock == 0);
goto return_or_yield;
}
- TARGET(GET_AITER) {
+ case TARGET(GET_AITER): {
unaryfunc getter = NULL;
PyObject *iter = NULL;
PyObject *obj = TOP();
DISPATCH();
}
- TARGET(GET_ANEXT) {
+ case TARGET(GET_ANEXT): {
unaryfunc getter = NULL;
PyObject *next_iter = NULL;
PyObject *awaitable = NULL;
DISPATCH();
}
- PREDICTED(GET_AWAITABLE);
- TARGET(GET_AWAITABLE) {
+ case TARGET(GET_AWAITABLE): {
+ PREDICTED(GET_AWAITABLE);
PyObject *iterable = TOP();
PyObject *iter = _PyCoro_GetAwaitableIter(iterable);
DISPATCH();
}
- TARGET(YIELD_FROM) {
+ case TARGET(YIELD_FROM): {
PyObject *v = POP();
PyObject *receiver = TOP();
int err;
goto return_or_yield;
}
- TARGET(YIELD_VALUE) {
+ case TARGET(YIELD_VALUE): {
retval = POP();
if (co->co_flags & CO_ASYNC_GENERATOR) {
goto return_or_yield;
}
- TARGET(POP_EXCEPT) {
+ case TARGET(POP_EXCEPT): {
PyObject *type, *value, *traceback;
_PyErr_StackItem *exc_info;
PyTryBlock *b = PyFrame_BlockPop(f);
DISPATCH();
}
- PREDICTED(POP_BLOCK);
- TARGET(POP_BLOCK) {
+ case TARGET(POP_BLOCK): {
+ PREDICTED(POP_BLOCK);
PyFrame_BlockPop(f);
DISPATCH();
}
- TARGET(POP_FINALLY) {
+ case TARGET(POP_FINALLY): {
/* If oparg is 0 at the top of the stack are 1 or 6 values:
Either:
- TOP = NULL or an integer
DISPATCH();
}
- TARGET(CALL_FINALLY) {
+ case TARGET(CALL_FINALLY): {
PyObject *ret = PyLong_FromLong(INSTR_OFFSET());
if (ret == NULL) {
goto error;
FAST_DISPATCH();
}
- TARGET(BEGIN_FINALLY) {
+ case TARGET(BEGIN_FINALLY): {
/* Push NULL onto the stack for using it in END_FINALLY,
POP_FINALLY, WITH_CLEANUP_START and WITH_CLEANUP_FINISH.
*/
FAST_DISPATCH();
}
- PREDICTED(END_FINALLY);
- TARGET(END_FINALLY) {
+ case TARGET(END_FINALLY): {
+ PREDICTED(END_FINALLY);
/* At the top of the stack are 1 or 6 values:
Either:
- TOP = NULL or an integer
}
}
- TARGET(END_ASYNC_FOR) {
+ case TARGET(END_ASYNC_FOR): {
PyObject *exc = POP();
assert(PyExceptionClass_Check(exc));
if (PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration)) {
}
}
- TARGET(LOAD_BUILD_CLASS) {
+ case TARGET(LOAD_BUILD_CLASS): {
_Py_IDENTIFIER(__build_class__);
PyObject *bc;
DISPATCH();
}
- TARGET(STORE_NAME) {
+ case TARGET(STORE_NAME): {
PyObject *name = GETITEM(names, oparg);
PyObject *v = POP();
PyObject *ns = f->f_locals;
DISPATCH();
}
- TARGET(DELETE_NAME) {
+ case TARGET(DELETE_NAME): {
PyObject *name = GETITEM(names, oparg);
PyObject *ns = f->f_locals;
int err;
DISPATCH();
}
- PREDICTED(UNPACK_SEQUENCE);
- TARGET(UNPACK_SEQUENCE) {
+ case TARGET(UNPACK_SEQUENCE): {
+ PREDICTED(UNPACK_SEQUENCE);
PyObject *seq = POP(), *item, **items;
if (PyTuple_CheckExact(seq) &&
PyTuple_GET_SIZE(seq) == oparg) {
DISPATCH();
}
- TARGET(UNPACK_EX) {
+ case TARGET(UNPACK_EX): {
int totalargs = 1 + (oparg & 0xFF) + (oparg >> 8);
PyObject *seq = POP();
DISPATCH();
}
- TARGET(STORE_ATTR) {
+ case TARGET(STORE_ATTR): {
PyObject *name = GETITEM(names, oparg);
PyObject *owner = TOP();
PyObject *v = SECOND();
DISPATCH();
}
- TARGET(DELETE_ATTR) {
+ case TARGET(DELETE_ATTR): {
PyObject *name = GETITEM(names, oparg);
PyObject *owner = POP();
int err;
DISPATCH();
}
- TARGET(STORE_GLOBAL) {
+ case TARGET(STORE_GLOBAL): {
PyObject *name = GETITEM(names, oparg);
PyObject *v = POP();
int err;
DISPATCH();
}
- TARGET(DELETE_GLOBAL) {
+ case TARGET(DELETE_GLOBAL): {
PyObject *name = GETITEM(names, oparg);
int err;
err = PyDict_DelItem(f->f_globals, name);
DISPATCH();
}
- TARGET(LOAD_NAME) {
+ case TARGET(LOAD_NAME): {
PyObject *name = GETITEM(names, oparg);
PyObject *locals = f->f_locals;
PyObject *v;
DISPATCH();
}
- TARGET(LOAD_GLOBAL) {
+ case TARGET(LOAD_GLOBAL): {
PyObject *name = GETITEM(names, oparg);
PyObject *v;
if (PyDict_CheckExact(f->f_globals)
DISPATCH();
}
- TARGET(DELETE_FAST) {
+ case TARGET(DELETE_FAST): {
PyObject *v = GETLOCAL(oparg);
if (v != NULL) {
SETLOCAL(oparg, NULL);
goto error;
}
- TARGET(DELETE_DEREF) {
+ case TARGET(DELETE_DEREF): {
PyObject *cell = freevars[oparg];
PyObject *oldobj = PyCell_GET(cell);
if (oldobj != NULL) {
goto error;
}
- TARGET(LOAD_CLOSURE) {
+ case TARGET(LOAD_CLOSURE): {
PyObject *cell = freevars[oparg];
Py_INCREF(cell);
PUSH(cell);
DISPATCH();
}
- TARGET(LOAD_CLASSDEREF) {
+ case TARGET(LOAD_CLASSDEREF): {
PyObject *name, *value, *locals = f->f_locals;
Py_ssize_t idx;
assert(locals);
DISPATCH();
}
- TARGET(LOAD_DEREF) {
+ case TARGET(LOAD_DEREF): {
PyObject *cell = freevars[oparg];
PyObject *value = PyCell_GET(cell);
if (value == NULL) {
DISPATCH();
}
- TARGET(STORE_DEREF) {
+ case TARGET(STORE_DEREF): {
PyObject *v = POP();
PyObject *cell = freevars[oparg];
PyObject *oldobj = PyCell_GET(cell);
DISPATCH();
}
- TARGET(BUILD_STRING) {
+ case TARGET(BUILD_STRING): {
PyObject *str;
PyObject *empty = PyUnicode_New(0, 0);
if (empty == NULL) {
DISPATCH();
}
- TARGET(BUILD_TUPLE) {
+ case TARGET(BUILD_TUPLE): {
PyObject *tup = PyTuple_New(oparg);
if (tup == NULL)
goto error;
DISPATCH();
}
- TARGET(BUILD_LIST) {
+ case TARGET(BUILD_LIST): {
PyObject *list = PyList_New(oparg);
if (list == NULL)
goto error;
DISPATCH();
}
- TARGET(BUILD_TUPLE_UNPACK_WITH_CALL)
- TARGET(BUILD_TUPLE_UNPACK)
- TARGET(BUILD_LIST_UNPACK) {
+ case TARGET(BUILD_TUPLE_UNPACK_WITH_CALL):
+ case TARGET(BUILD_TUPLE_UNPACK):
+ case TARGET(BUILD_LIST_UNPACK): {
int convert_to_tuple = opcode != BUILD_LIST_UNPACK;
Py_ssize_t i;
PyObject *sum = PyList_New(0);
DISPATCH();
}
- TARGET(BUILD_SET) {
+ case TARGET(BUILD_SET): {
PyObject *set = PySet_New(NULL);
int err = 0;
int i;
DISPATCH();
}
- TARGET(BUILD_SET_UNPACK) {
+ case TARGET(BUILD_SET_UNPACK): {
Py_ssize_t i;
PyObject *sum = PySet_New(NULL);
if (sum == NULL)
DISPATCH();
}
- TARGET(BUILD_MAP) {
+ case TARGET(BUILD_MAP): {
Py_ssize_t i;
PyObject *map = _PyDict_NewPresized((Py_ssize_t)oparg);
if (map == NULL)
DISPATCH();
}
- TARGET(SETUP_ANNOTATIONS) {
+ case TARGET(SETUP_ANNOTATIONS): {
_Py_IDENTIFIER(__annotations__);
int err;
PyObject *ann_dict;
DISPATCH();
}
- TARGET(BUILD_CONST_KEY_MAP) {
+ case TARGET(BUILD_CONST_KEY_MAP): {
Py_ssize_t i;
PyObject *map;
PyObject *keys = TOP();
DISPATCH();
}
- TARGET(BUILD_MAP_UNPACK) {
+ case TARGET(BUILD_MAP_UNPACK): {
Py_ssize_t i;
PyObject *sum = PyDict_New();
if (sum == NULL)
DISPATCH();
}
- TARGET(BUILD_MAP_UNPACK_WITH_CALL) {
+ case TARGET(BUILD_MAP_UNPACK_WITH_CALL): {
Py_ssize_t i;
PyObject *sum = PyDict_New();
if (sum == NULL)
DISPATCH();
}
- TARGET(MAP_ADD) {
+ case TARGET(MAP_ADD): {
PyObject *key = TOP();
PyObject *value = SECOND();
PyObject *map;
DISPATCH();
}
- TARGET(LOAD_ATTR) {
+ case TARGET(LOAD_ATTR): {
PyObject *name = GETITEM(names, oparg);
PyObject *owner = TOP();
PyObject *res = PyObject_GetAttr(owner, name);
DISPATCH();
}
- TARGET(COMPARE_OP) {
+ case TARGET(COMPARE_OP): {
PyObject *right = POP();
PyObject *left = TOP();
PyObject *res = cmp_outcome(oparg, left, right);
DISPATCH();
}
- TARGET(IMPORT_NAME) {
+ case TARGET(IMPORT_NAME): {
PyObject *name = GETITEM(names, oparg);
PyObject *fromlist = POP();
PyObject *level = TOP();
DISPATCH();
}
- TARGET(IMPORT_STAR) {
+ case TARGET(IMPORT_STAR): {
PyObject *from = POP(), *locals;
int err;
if (PyFrame_FastToLocalsWithError(f) < 0) {
DISPATCH();
}
- TARGET(IMPORT_FROM) {
+ case TARGET(IMPORT_FROM): {
PyObject *name = GETITEM(names, oparg);
PyObject *from = TOP();
PyObject *res;
DISPATCH();
}
- TARGET(JUMP_FORWARD) {
+ case TARGET(JUMP_FORWARD): {
JUMPBY(oparg);
FAST_DISPATCH();
}
- PREDICTED(POP_JUMP_IF_FALSE);
- TARGET(POP_JUMP_IF_FALSE) {
+ case TARGET(POP_JUMP_IF_FALSE): {
+ PREDICTED(POP_JUMP_IF_FALSE);
PyObject *cond = POP();
int err;
if (cond == Py_True) {
DISPATCH();
}
- PREDICTED(POP_JUMP_IF_TRUE);
- TARGET(POP_JUMP_IF_TRUE) {
+ case TARGET(POP_JUMP_IF_TRUE): {
+ PREDICTED(POP_JUMP_IF_TRUE);
PyObject *cond = POP();
int err;
if (cond == Py_False) {
DISPATCH();
}
- TARGET(JUMP_IF_FALSE_OR_POP) {
+ case TARGET(JUMP_IF_FALSE_OR_POP): {
PyObject *cond = TOP();
int err;
if (cond == Py_True) {
DISPATCH();
}
- TARGET(JUMP_IF_TRUE_OR_POP) {
+ case TARGET(JUMP_IF_TRUE_OR_POP): {
PyObject *cond = TOP();
int err;
if (cond == Py_False) {
DISPATCH();
}
- PREDICTED(JUMP_ABSOLUTE);
- TARGET(JUMP_ABSOLUTE) {
+ case TARGET(JUMP_ABSOLUTE): {
+ PREDICTED(JUMP_ABSOLUTE);
JUMPTO(oparg);
#if FAST_LOOPS
/* Enabling this path speeds-up all while and for-loops by bypassing
#endif
}
- TARGET(GET_ITER) {
+ case TARGET(GET_ITER): {
/* before: [obj]; after [getiter(obj)] */
PyObject *iterable = TOP();
PyObject *iter = PyObject_GetIter(iterable);
DISPATCH();
}
- TARGET(GET_YIELD_FROM_ITER) {
+ case TARGET(GET_YIELD_FROM_ITER): {
/* before: [obj]; after [getiter(obj)] */
PyObject *iterable = TOP();
PyObject *iter;
DISPATCH();
}
- PREDICTED(FOR_ITER);
- TARGET(FOR_ITER) {
+ case TARGET(FOR_ITER): {
+ PREDICTED(FOR_ITER);
/* before: [iter]; after: [iter, iter()] *or* [] */
PyObject *iter = TOP();
PyObject *next = (*iter->ob_type->tp_iternext)(iter);
DISPATCH();
}
- TARGET(SETUP_FINALLY) {
+ case TARGET(SETUP_FINALLY): {
/* NOTE: If you add any new block-setup opcodes that
are not try/except/finally handlers, you may need
to update the PyGen_NeedsFinalizing() function.
DISPATCH();
}
- TARGET(BEFORE_ASYNC_WITH) {
+ case TARGET(BEFORE_ASYNC_WITH): {
_Py_IDENTIFIER(__aexit__);
_Py_IDENTIFIER(__aenter__);
DISPATCH();
}
- TARGET(SETUP_ASYNC_WITH) {
+ case TARGET(SETUP_ASYNC_WITH): {
PyObject *res = POP();
/* Setup the finally block before pushing the result
of __aenter__ on the stack. */
DISPATCH();
}
- TARGET(SETUP_WITH) {
+ case TARGET(SETUP_WITH): {
_Py_IDENTIFIER(__exit__);
_Py_IDENTIFIER(__enter__);
PyObject *mgr = TOP();
DISPATCH();
}
- TARGET(WITH_CLEANUP_START) {
+ case TARGET(WITH_CLEANUP_START): {
/* At the top of the stack are 1 or 6 values indicating
how/why we entered the finally clause:
- TOP = NULL
DISPATCH();
}
- PREDICTED(WITH_CLEANUP_FINISH);
- TARGET(WITH_CLEANUP_FINISH) {
+ case TARGET(WITH_CLEANUP_FINISH): {
+ PREDICTED(WITH_CLEANUP_FINISH);
/* TOP = the result of calling the context.__exit__ bound method
SECOND = either None or exception type
DISPATCH();
}
- TARGET(LOAD_METHOD) {
+ case TARGET(LOAD_METHOD): {
/* Designed to work in tamdem with CALL_METHOD. */
PyObject *name = GETITEM(names, oparg);
PyObject *obj = TOP();
DISPATCH();
}
- TARGET(CALL_METHOD) {
+ case TARGET(CALL_METHOD): {
/* Designed to work in tamdem with LOAD_METHOD. */
PyObject **sp, *res, *meth;
DISPATCH();
}
- PREDICTED(CALL_FUNCTION);
- TARGET(CALL_FUNCTION) {
+ case TARGET(CALL_FUNCTION): {
+ PREDICTED(CALL_FUNCTION);
PyObject **sp, *res;
sp = stack_pointer;
res = call_function(&sp, oparg, NULL);
DISPATCH();
}
- TARGET(CALL_FUNCTION_KW) {
+ case TARGET(CALL_FUNCTION_KW): {
PyObject **sp, *res, *names;
names = POP();
DISPATCH();
}
- TARGET(CALL_FUNCTION_EX) {
+ case TARGET(CALL_FUNCTION_EX): {
PyObject *func, *callargs, *kwargs = NULL, *result;
if (oparg & 0x01) {
kwargs = POP();
DISPATCH();
}
- TARGET(MAKE_FUNCTION) {
+ case TARGET(MAKE_FUNCTION): {
PyObject *qualname = POP();
PyObject *codeobj = POP();
PyFunctionObject *func = (PyFunctionObject *)
DISPATCH();
}
- TARGET(BUILD_SLICE) {
+ case TARGET(BUILD_SLICE): {
PyObject *start, *stop, *step, *slice;
if (oparg == 3)
step = POP();
DISPATCH();
}
- TARGET(FORMAT_VALUE) {
+ case TARGET(FORMAT_VALUE): {
/* Handles f-string value formatting. */
PyObject *result;
PyObject *fmt_spec;
DISPATCH();
}
- TARGET(EXTENDED_ARG) {
+ case TARGET(EXTENDED_ARG): {
int oldoparg = oparg;
NEXTOPARG();
oparg |= oldoparg << 8;
projects / thirdparty / Python / cpython.git / commitdiff
