PyAPI_FUNC(PyObject *)_PyEval_MatchClass(PyThreadState *tstate, PyObject *subject, PyObject *type, Py_ssize_t nargs, PyObject *kwargs);
PyAPI_FUNC(PyObject *)_PyEval_MatchKeys(PyThreadState *tstate, PyObject *map, PyObject *keys);
PyAPI_FUNC(void) _PyEval_MonitorRaise(PyThreadState *tstate, _PyInterpreterFrame *frame, _Py_CODEUNIT *instr);
-PyAPI_FUNC(int) _PyEval_UnpackIterableStackRef(PyThreadState *tstate, _PyStackRef v, int argcnt, int argcntafter, _PyStackRef *sp);
+PyAPI_FUNC(int) _PyEval_UnpackIterableStackRef(PyThreadState *tstate, PyObject *v, int argcnt, int argcntafter, _PyStackRef *sp);
PyAPI_FUNC(void) _PyEval_FrameClearAndPop(PyThreadState *tstate, _PyInterpreterFrame *frame);
PyAPI_FUNC(PyObject **) _PyObjectArray_FromStackRefArray(_PyStackRef *input, Py_ssize_t nargs, PyObject **scratch);
extern const struct opcode_metadata _PyOpcode_opcode_metadata[266];
#ifdef NEED_OPCODE_METADATA
const struct opcode_metadata _PyOpcode_opcode_metadata[266] = {
- [BINARY_OP] = { true, INSTR_FMT_IBC0000, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
+ [BINARY_OP] = { true, INSTR_FMT_IBC0000, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
[BINARY_OP_ADD_FLOAT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG },
- [BINARY_OP_ADD_INT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG },
+ [BINARY_OP_ADD_INT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[BINARY_OP_ADD_UNICODE] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG },
[BINARY_OP_EXTEND] = { true, INSTR_FMT_IXC0000, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG },
- [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC0000, HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG },
+ [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC0000, HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[BINARY_OP_MULTIPLY_FLOAT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG },
- [BINARY_OP_MULTIPLY_INT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG },
+ [BINARY_OP_MULTIPLY_INT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[BINARY_OP_SUBSCR_DICT] = { true, INSTR_FMT_IXC0000, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[BINARY_OP_SUBSCR_GETITEM] = { true, INSTR_FMT_IXC0000, HAS_DEOPT_FLAG },
[BINARY_OP_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC0000, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG },
[BINARY_OP_SUBSCR_STR_INT] = { true, INSTR_FMT_IXC0000, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG },
[BINARY_OP_SUBSCR_TUPLE_INT] = { true, INSTR_FMT_IXC0000, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG },
[BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG },
- [BINARY_OP_SUBTRACT_INT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG },
+ [BINARY_OP_SUBTRACT_INT] = { true, INSTR_FMT_IXC0000, HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[BINARY_SLICE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[BUILD_LIST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG },
[BUILD_MAP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[CALL_TUPLE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[CALL_TYPE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG },
[CHECK_EG_MATCH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
- [CHECK_EXC_MATCH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
+ [CHECK_EXC_MATCH] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
[CLEANUP_THROW] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
[COMPARE_OP] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[COMPARE_OP_FLOAT] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_EXIT_FLAG },
[DICT_UPDATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[END_ASYNC_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
[END_FOR] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_NO_SAVE_IP_FLAG },
- [END_SEND] = { true, INSTR_FMT_IX, HAS_PURE_FLAG },
+ [END_SEND] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_PURE_FLAG },
[ENTER_EXECUTOR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG },
[EXIT_INIT_CHECK] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
[EXTENDED_ARG] = { true, INSTR_FMT_IB, HAS_ARG_FLAG },
[LOAD_ATTR_METHOD_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG },
[LOAD_ATTR_METHOD_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG },
[LOAD_ATTR_MODULE] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG },
- [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG },
- [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG },
+ [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG },
+ [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG },
[LOAD_ATTR_PROPERTY] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG },
[LOAD_ATTR_SLOT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG },
[LOAD_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG },
[NOP] = { true, INSTR_FMT_IX, HAS_PURE_FLAG },
[NOT_TAKEN] = { true, INSTR_FMT_IX, HAS_PURE_FLAG },
[POP_EXCEPT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG },
- [POP_ITER] = { true, INSTR_FMT_IX, HAS_PURE_FLAG },
+ [POP_ITER] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_PURE_FLAG },
[POP_JUMP_IF_FALSE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG },
[POP_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG },
[POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG },
[POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG },
- [POP_TOP] = { true, INSTR_FMT_IX, HAS_PURE_FLAG },
+ [POP_TOP] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_PURE_FLAG },
[PUSH_EXC_INFO] = { true, INSTR_FMT_IX, 0 },
[PUSH_NULL] = { true, INSTR_FMT_IX, HAS_PURE_FLAG },
[RAISE_VARARGS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
[RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
[RESUME_CHECK] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG },
[RETURN_GENERATOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
- [RETURN_VALUE] = { true, INSTR_FMT_IX, 0 },
+ [RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG },
[SEND] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[SEND_GEN] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG },
[SETUP_ANNOTATIONS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[STORE_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG },
[SWAP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_PURE_FLAG },
[TO_BOOL] = { true, INSTR_FMT_IXC00, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
- [TO_BOOL_ALWAYS_TRUE] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG },
+ [TO_BOOL_ALWAYS_TRUE] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG | HAS_ESCAPES_FLAG },
[TO_BOOL_BOOL] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG },
- [TO_BOOL_INT] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG },
+ [TO_BOOL_INT] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG | HAS_ESCAPES_FLAG },
[TO_BOOL_LIST] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG },
[TO_BOOL_NONE] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG },
- [TO_BOOL_STR] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG },
+ [TO_BOOL_STR] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG | HAS_ESCAPES_FLAG },
[UNARY_INVERT] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[UNARY_NEGATIVE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[UNARY_NOT] = { true, INSTR_FMT_IX, HAS_PURE_FLAG },
[UNPACK_SEQUENCE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[UNPACK_SEQUENCE_LIST] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG },
[UNPACK_SEQUENCE_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG },
- [UNPACK_SEQUENCE_TWO_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG },
+ [UNPACK_SEQUENCE_TWO_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG },
[WITH_EXCEPT_START] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG },
[JUMP] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[_STORE_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG,
[_STORE_FAST_LOAD_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG,
[_STORE_FAST_STORE_FAST] = HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_ESCAPES_FLAG,
- [_POP_TOP] = HAS_PURE_FLAG,
+ [_POP_TOP] = HAS_ESCAPES_FLAG | HAS_PURE_FLAG,
[_PUSH_NULL] = HAS_PURE_FLAG,
[_END_FOR] = HAS_ESCAPES_FLAG | HAS_NO_SAVE_IP_FLAG,
- [_END_SEND] = HAS_PURE_FLAG,
+ [_END_SEND] = HAS_ESCAPES_FLAG | HAS_PURE_FLAG,
[_UNARY_NEGATIVE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_UNARY_NOT] = HAS_PURE_FLAG,
[_TO_BOOL] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_TO_BOOL_BOOL] = HAS_EXIT_FLAG,
- [_TO_BOOL_INT] = HAS_EXIT_FLAG,
+ [_TO_BOOL_INT] = HAS_EXIT_FLAG | HAS_ESCAPES_FLAG,
[_TO_BOOL_LIST] = HAS_EXIT_FLAG,
[_TO_BOOL_NONE] = HAS_EXIT_FLAG,
- [_TO_BOOL_STR] = HAS_EXIT_FLAG,
- [_REPLACE_WITH_TRUE] = 0,
+ [_TO_BOOL_STR] = HAS_EXIT_FLAG | HAS_ESCAPES_FLAG,
+ [_REPLACE_WITH_TRUE] = HAS_ESCAPES_FLAG,
[_UNARY_INVERT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_GUARD_BOTH_INT] = HAS_EXIT_FLAG,
[_GUARD_NOS_INT] = HAS_EXIT_FLAG,
[_GUARD_TOS_INT] = HAS_EXIT_FLAG,
- [_BINARY_OP_MULTIPLY_INT] = HAS_ERROR_FLAG | HAS_PURE_FLAG,
- [_BINARY_OP_ADD_INT] = HAS_ERROR_FLAG | HAS_PURE_FLAG,
- [_BINARY_OP_SUBTRACT_INT] = HAS_ERROR_FLAG | HAS_PURE_FLAG,
+ [_BINARY_OP_MULTIPLY_INT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_PURE_FLAG,
+ [_BINARY_OP_ADD_INT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_PURE_FLAG,
+ [_BINARY_OP_SUBTRACT_INT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_PURE_FLAG,
[_GUARD_BOTH_FLOAT] = HAS_EXIT_FLAG,
[_GUARD_NOS_FLOAT] = HAS_EXIT_FLAG,
[_GUARD_TOS_FLOAT] = HAS_EXIT_FLAG,
[_BINARY_OP_SUBTRACT_FLOAT] = HAS_ERROR_FLAG | HAS_PURE_FLAG,
[_GUARD_BOTH_UNICODE] = HAS_EXIT_FLAG,
[_BINARY_OP_ADD_UNICODE] = HAS_ERROR_FLAG | HAS_PURE_FLAG,
- [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG,
+ [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_GUARD_BINARY_OP_EXTEND] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG,
[_BINARY_OP_EXTEND] = HAS_ESCAPES_FLAG | HAS_PURE_FLAG,
[_BINARY_SLICE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_DELETE_SUBSCR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_CALL_INTRINSIC_1] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_CALL_INTRINSIC_2] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
- [_RETURN_VALUE] = 0,
+ [_RETURN_VALUE] = HAS_ESCAPES_FLAG,
[_GET_AITER] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_GET_ANEXT] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
[_GET_AWAITABLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_STORE_NAME] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_DELETE_NAME] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
[_UNPACK_SEQUENCE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
- [_UNPACK_SEQUENCE_TWO_TUPLE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG,
+ [_UNPACK_SEQUENCE_TWO_TUPLE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG,
[_UNPACK_SEQUENCE_TUPLE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG,
[_UNPACK_SEQUENCE_LIST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG,
[_UNPACK_EX] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_CONTAINS_OP_SET] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_CONTAINS_OP_DICT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_CHECK_EG_MATCH] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
- [_CHECK_EXC_MATCH] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
+ [_CHECK_EXC_MATCH] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
[_IMPORT_NAME] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_IMPORT_FROM] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_IS_NONE] = 0,
[_GUARD_KEYS_VERSION] = HAS_DEOPT_FLAG,
[_LOAD_ATTR_METHOD_WITH_VALUES] = HAS_ARG_FLAG,
[_LOAD_ATTR_METHOD_NO_DICT] = HAS_ARG_FLAG,
- [_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = HAS_ARG_FLAG,
- [_LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = HAS_ARG_FLAG,
+ [_LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG,
+ [_LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG,
[_CHECK_ATTR_METHOD_LAZY_DICT] = HAS_DEOPT_FLAG,
[_LOAD_ATTR_METHOD_LAZY_DICT] = HAS_ARG_FLAG,
[_MAYBE_EXPAND_METHOD] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG,
[_FORMAT_SIMPLE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_FORMAT_WITH_SPEC] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_COPY] = HAS_ARG_FLAG | HAS_PURE_FLAG,
- [_BINARY_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
+ [_BINARY_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
[_SWAP] = HAS_ARG_FLAG | HAS_PURE_FLAG,
[_GUARD_IS_TRUE_POP] = HAS_EXIT_FLAG,
[_GUARD_IS_FALSE_POP] = HAS_EXIT_FLAG,
input = """
inst(BALANCED, ( -- )) {
SAVE_STACK();
+ code();
RELOAD_STACK();
}
"""
next_instr += 1;
INSTRUCTION_STATS(BALANCED);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ code();
stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH();
}
"""
self.run_cases_test(input, output)
+ def test_stack_save_reload_paired(self):
+
+ input = """
+ inst(BALANCED, ( -- )) {
+ SAVE_STACK();
+ RELOAD_STACK();
+ }
+ """
+
+ output = """
+ TARGET(BALANCED) {
+ #if defined(Py_TAIL_CALL_INTERP)
+ int opcode = BALANCED;
+ (void)(opcode);
+ #endif
+ frame->instr_ptr = next_instr;
+ next_instr += 1;
+ INSTRUCTION_STATS(BALANCED);
+ DISPATCH();
+ }
+ """
+ self.run_cases_test(input, output)
+
def test_stack_reload_only(self):
input = """
--- /dev/null
+The internal (evaluation) stack is now spilled to memory whenever execution
+esacpes from the interpreter or JIT compiled code. This should have no
+observable effect in either Python or builtin extensions, but will allow
+various important optimizations in the future.
destructor dealloc = type->tp_dealloc;
#ifdef Py_DEBUG
PyThreadState *tstate = _PyThreadState_GET();
+#ifndef Py_GIL_DISABLED
+ /* This assertion doesn't hold for the free-threading build, as
+ * PyStackRef_CLOSE_SPECIALIZED is not implemented */
+ assert(tstate->current_frame == NULL || tstate->current_frame->stackpointer != NULL);
+#endif
PyObject *old_exc = tstate != NULL ? tstate->current_exception : NULL;
// Keep the old exception type alive to prevent undefined behavior
// on (tstate->curexc_type != old_exc_type) below
}
pure inst(POP_TOP, (value --)) {
- DECREF_INPUTS();
+ PyStackRef_CLOSE(value);
}
pure inst(PUSH_NULL, (-- res)) {
ERROR_NO_POP();
}
}
- DECREF_INPUTS();
+ PyStackRef_CLOSE(value);
}
tier1 inst(INSTRUMENTED_POP_ITER, (iter -- )) {
(void)receiver;
val = value;
DEAD(value);
- DECREF_INPUTS();
+ PyStackRef_CLOSE(receiver);
}
tier1 inst(INSTRUMENTED_END_SEND, (receiver, value -- val)) {
inst(UNARY_NEGATIVE, (value -- res)) {
PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value));
- DECREF_INPUTS();
+ PyStackRef_CLOSE(value);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
op(_TO_BOOL, (value -- res)) {
int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value));
- DECREF_INPUTS();
+ PyStackRef_CLOSE(value);
ERROR_IF(err < 0, error);
res = err ? PyStackRef_True : PyStackRef_False;
}
res = PyStackRef_False;
}
else {
- DECREF_INPUTS();
+ PyStackRef_CLOSE(value);
res = PyStackRef_True;
}
}
}
else {
assert(Py_SIZE(value_o));
- DECREF_INPUTS();
+ PyStackRef_CLOSE(value);
res = PyStackRef_True;
}
}
op(_REPLACE_WITH_TRUE, (value -- res)) {
- DECREF_INPUTS();
+ PyStackRef_CLOSE(value);
res = PyStackRef_True;
}
inst(UNARY_INVERT, (value -- res)) {
PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value));
- DECREF_INPUTS();
+ PyStackRef_CLOSE(value);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
// At the end we just skip over the STORE_FAST.
op(_BINARY_OP_INPLACE_ADD_UNICODE, (left, right --)) {
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
- PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
+ PyObject *right_o = PyStackRef_AsPyObjectSteal(right);
assert(PyUnicode_CheckExact(left_o));
assert(PyUnicode_CheckExact(right_o));
PyObject *temp = PyStackRef_AsPyObjectSteal(*target_local);
PyUnicode_Append(&temp, right_o);
*target_local = PyStackRef_FromPyObjectSteal(temp);
- PyStackRef_CLOSE_SPECIALIZED(right, _PyUnicode_ExactDealloc);
- DEAD(right);
+ Py_DECREF(right_o);
ERROR_IF(PyStackRef_IsNull(*target_local), error);
#if TIER_ONE
// The STORE_FAST is already done. This is done here in tier one,
inst(SET_ADD, (set, unused[oparg-1], v -- set, unused[oparg-1])) {
int err = PySet_Add(PyStackRef_AsPyObjectBorrow(set),
PyStackRef_AsPyObjectBorrow(v));
- DECREF_INPUTS();
+ PyStackRef_CLOSE(v);
ERROR_IF(err, error);
}
inst(CALL_INTRINSIC_1, (value -- res)) {
assert(oparg <= MAX_INTRINSIC_1);
PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value));
- DECREF_INPUTS();
+ PyStackRef_CLOSE(value);
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
"'async for' requires an object with "
"__aiter__ method, got %.100s",
type->tp_name);
- DECREF_INPUTS();
+ PyStackRef_CLOSE(obj);
ERROR_IF(true, error);
}
iter_o = (*getter)(obj_o);
- DECREF_INPUTS();
+ PyStackRef_CLOSE(obj);
ERROR_IF(iter_o == NULL, error);
if (Py_TYPE(iter_o)->tp_as_async == NULL ||
inst(GET_AWAITABLE, (iterable -- iter)) {
PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg);
- DECREF_INPUTS();
+ PyStackRef_CLOSE(iterable);
ERROR_IF(iter_o == NULL, error);
iter = PyStackRef_FromPyObjectSteal(iter_o);
}
JUMPBY(oparg);
}
else {
- DECREF_INPUTS();
+ PyStackRef_CLOSE(v);
ERROR_IF(true, error);
}
}
}
}
- tier1 inst(CLEANUP_THROW, (sub_iter_st, last_sent_val_st, exc_value_st -- none, value)) {
+ tier1 inst(CLEANUP_THROW, (sub_iter, last_sent_val, exc_value_st -- none, value)) {
PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st);
#ifndef Py_TAIL_CALL_INTERP
assert(throwflag);
int matches = PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration);
if (matches) {
- none = PyStackRef_None;
value = PyStackRef_FromPyObjectNew(((PyStopIterationObject *)exc_value)->value);
DECREF_INPUTS();
+ none = PyStackRef_None;
}
else {
_PyErr_SetRaisedException(tstate, Py_NewRef(exc_value));
if (ns == NULL) {
_PyErr_Format(tstate, PyExc_SystemError,
"no locals found when storing %R", name);
- DECREF_INPUTS();
+ PyStackRef_CLOSE(v);
ERROR_IF(true, error);
}
if (PyDict_CheckExact(ns)) {
else {
err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
}
- DECREF_INPUTS();
+ PyStackRef_CLOSE(v);
ERROR_IF(err, error);
}
(void)counter;
}
- op(_UNPACK_SEQUENCE, (seq -- output[oparg])) {
- _PyStackRef *top = output + oparg;
- int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top);
- DECREF_INPUTS();
+ op(_UNPACK_SEQUENCE, (seq -- output[oparg], top[0])) {
+ PyObject *seq_o = PyStackRef_AsPyObjectSteal(seq);
+ int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg, -1, top);
+ Py_DECREF(seq_o);
ERROR_IF(res == 0, error);
}
STAT_INC(UNPACK_SEQUENCE, hit);
val0 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 0));
val1 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 1));
- DECREF_INPUTS();
+ PyStackRef_CLOSE(seq);
}
inst(UNPACK_SEQUENCE_TUPLE, (unused/1, seq -- values[oparg])) {
DECREF_INPUTS();
}
- inst(UNPACK_EX, (seq -- left[oparg & 0xFF], unused, right[oparg >> 8])) {
- _PyStackRef *top = right + (oparg >> 8);
- int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top);
- DECREF_INPUTS();
+ inst(UNPACK_EX, (seq -- left[oparg & 0xFF], unused, right[oparg >> 8], top[0])) {
+ PyObject *seq_o = PyStackRef_AsPyObjectSteal(seq);
+ int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg & 0xFF, oparg >> 8, top);
+ Py_DECREF(seq_o);
ERROR_IF(res == 0, error);
}
inst(DELETE_ATTR, (owner --)) {
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name);
- DECREF_INPUTS();
+ PyStackRef_CLOSE(owner);
ERROR_IF(err, error);
}
inst(STORE_GLOBAL, (v --)) {
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v));
- DECREF_INPUTS();
+ PyStackRef_CLOSE(v);
ERROR_IF(err, error);
}
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
PyObject *v_o;
int err = PyMapping_GetOptionalItem(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &v_o);
- DECREF_INPUTS();
+ PyStackRef_CLOSE(mod_or_class_dict);
ERROR_IF(err < 0, error);
if (v_o == NULL) {
if (PyDict_CheckExact(GLOBALS())
"Value after * must be an iterable, not %.200s",
Py_TYPE(iterable)->tp_name);
}
- DECREF_INPUTS();
+ PyStackRef_CLOSE(iterable_st);
ERROR_IF(true, error);
}
assert(Py_IsNone(none_val));
- DECREF_INPUTS();
+ PyStackRef_CLOSE(iterable_st);
}
inst(SET_UPDATE, (set, unused[oparg-1], iterable -- set, unused[oparg-1])) {
int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set),
PyStackRef_AsPyObjectBorrow(iterable));
- DECREF_INPUTS();
+ PyStackRef_CLOSE(iterable);
ERROR_IF(err < 0, error);
}
"'%.200s' object is not a mapping",
Py_TYPE(update_o)->tp_name);
}
- DECREF_INPUTS();
+ PyStackRef_CLOSE(update);
ERROR_IF(true, error);
}
- DECREF_INPUTS();
+ PyStackRef_CLOSE(update);
}
inst(DICT_MERGE, (callable, unused, unused, dict, unused[oparg - 1], update -- callable, unused, unused, dict, unused[oparg - 1])) {
int err = _PyDict_MergeEx(dict_o, update_o, 2);
if (err < 0) {
_PyEval_FormatKwargsError(tstate, callable_o, update_o);
- DECREF_INPUTS();
+ PyStackRef_CLOSE(update);
ERROR_IF(true, error);
}
- DECREF_INPUTS();
+ PyStackRef_CLOSE(update);
}
inst(MAP_ADD, (dict_st, unused[oparg - 1], key, value -- dict_st, unused[oparg - 1])) {
CALL that it's not a method call.
meth | NULL | arg1 | ... | argN
*/
- DECREF_INPUTS();
+ PyStackRef_CLOSE(owner);
ERROR_IF(attr_o == NULL, error);
self_or_null[0] = PyStackRef_NULL;
}
else {
/* Classic, pushes one value. */
attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name);
- DECREF_INPUTS();
+ PyStackRef_CLOSE(owner);
ERROR_IF(attr_o == NULL, error);
}
attr = PyStackRef_FromPyObjectSteal(attr_o);
}
-
macro(LOAD_ATTR) =
_SPECIALIZE_LOAD_ATTR +
unused/8 +
assert(PyExceptionInstance_Check(left_o));
int err = _PyEval_CheckExceptTypeValid(tstate, right_o);
if (err < 0) {
- DECREF_INPUTS();
- ERROR_IF(true, error);
+ ERROR_NO_POP();
}
int res = PyErr_GivenExceptionMatches(left_o, right_o);
- DECREF_INPUTS();
+ PyStackRef_CLOSE(right);
b = res ? PyStackRef_True : PyStackRef_False;
}
inst(GET_ITER, (iterable -- iter)) {
/* before: [obj]; after [getiter(obj)] */
PyObject *iter_o = PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable));
- DECREF_INPUTS();
+ PyStackRef_CLOSE(iterable);
ERROR_IF(iter_o == NULL, error);
iter = PyStackRef_FromPyObjectSteal(iter_o);
}
assert((oparg & 1) == 0);
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
- DECREF_INPUTS();
+ PyStackRef_CLOSE(owner);
attr = PyStackRef_FromPyObjectNew(descr);
}
assert(Py_TYPE(PyStackRef_AsPyObjectBorrow(owner))->tp_dictoffset == 0);
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
- DECREF_INPUTS();
+ PyStackRef_CLOSE(owner);
attr = PyStackRef_FromPyObjectNew(descr);
}
assert(_PyEval_BinaryOps[oparg]);
PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o);
- DECREF_INPUTS();
- ERROR_IF(res_o == NULL, error);
+ if (res_o == NULL) {
+ ERROR_NO_POP();
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
+ DECREF_INPUTS();
}
macro(BINARY_OP) = _SPECIALIZE_BINARY_OP + unused/4 + _BINARY_OP;
goto exit_unwind;
}
next_instr = frame->instr_ptr;
-
- LLTRACE_RESUME_FRAME();
-
#ifdef Py_DEBUG
+ int lltrace = maybe_lltrace_resume_frame(frame, GLOBALS());
+ if (lltrace < 0) {
+ JUMP_TO_LABEL(exit_unwind);
+ }
+ frame->lltrace = lltrace;
/* _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 */
static void
dump_stack(_PyInterpreterFrame *frame, _PyStackRef *stack_pointer)
{
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyStackRef *stack_base = _PyFrame_Stackbase(frame);
PyObject *exc = PyErr_GetRaisedException();
printf(" stack=[");
printf("]\n");
fflush(stdout);
PyErr_SetRaisedException(exc);
+ _PyFrame_GetStackPointer(frame);
}
static void
#ifndef Py_TAIL_CALL_INTERP
uint8_t opcode; /* Current opcode */
int oparg; /* Current opcode argument, if any */
+ assert(tstate->current_frame == NULL || tstate->current_frame->stackpointer != NULL);
#endif
_PyInterpreterFrame entry_frame;
/* Because this avoids the RESUME, we need to update instrumentation */
_Py_Instrument(_PyFrame_GetCode(frame), tstate->interp);
next_instr = frame->instr_ptr;
- stack_pointer = _PyFrame_GetStackPointer(frame);
monitor_throw(tstate, frame, next_instr);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
#ifdef Py_TAIL_CALL_INTERP
return _TAIL_CALL_error(frame, stack_pointer, tstate, next_instr, 0);
#else
*/
int
-_PyEval_UnpackIterableStackRef(PyThreadState *tstate, _PyStackRef v_stackref,
+_PyEval_UnpackIterableStackRef(PyThreadState *tstate, PyObject *v,
int argcnt, int argcntafter, _PyStackRef *sp)
{
int i = 0, j = 0;
PyObject *it; /* iter(v) */
PyObject *w;
PyObject *l = NULL; /* variable list */
-
- PyObject *v = PyStackRef_AsPyObjectBorrow(v_stackref);
assert(v != NULL);
it = PyObject_GetIter(v);
#ifdef Py_DEBUG
#define LLTRACE_RESUME_FRAME() \
do { \
+ _PyFrame_SetStackPointer(frame, stack_pointer); \
int lltrace = maybe_lltrace_resume_frame(frame, GLOBALS()); \
+ stack_pointer = _PyFrame_GetStackPointer(frame); \
if (lltrace < 0) { \
JUMP_TO_LABEL(exit_unwind); \
} \
} while (0)
#endif
-#define GOTO_TIER_ONE(TARGET) \
-do { \
- next_instr = (TARGET); \
- OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); \
- Py_CLEAR(tstate->previous_executor); \
- if (next_instr == NULL) { \
- next_instr = frame->instr_ptr; \
- goto error; \
- } \
- DISPATCH(); \
-} while (0)
+#define GOTO_TIER_ONE(TARGET) \
+ do \
+ { \
+ next_instr = (TARGET); \
+ OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); \
+ _PyFrame_SetStackPointer(frame, stack_pointer); \
+ Py_CLEAR(tstate->previous_executor); \
+ stack_pointer = _PyFrame_GetStackPointer(frame); \
+ if (next_instr == NULL) \
+ { \
+ next_instr = frame->instr_ptr; \
+ goto error; \
+ } \
+ DISPATCH(); \
+ } while (0)
#define CURRENT_OPARG() (next_uop[-1].oparg)
#define CURRENT_OPERAND0() (next_uop[-1].operand0)
case _POP_TOP: {
_PyStackRef value;
value = stack_pointer[-1];
- PyStackRef_CLOSE(value);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
break;
}
receiver = stack_pointer[-2];
(void)receiver;
val = value;
- PyStackRef_CLOSE(receiver);
stack_pointer[-2] = val;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(receiver);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (res_o == NULL) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-1] = res;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
res = err ? PyStackRef_True : PyStackRef_False;
- stack_pointer[-1] = res;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
res = PyStackRef_False;
}
else {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
res = PyStackRef_True;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
}
stack_pointer[-1] = res;
break;
}
STAT_INC(TO_BOOL, hit);
res = PyList_GET_SIZE(value_o) ? PyStackRef_True : PyStackRef_False;
- PyStackRef_CLOSE(value);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = value;
+ value = res;
+ stack_pointer[-1] = value;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer[-1] = res;
break;
}
}
else {
assert(Py_SIZE(value_o));
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
res = PyStackRef_True;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
}
stack_pointer[-1] = res;
break;
_PyStackRef value;
_PyStackRef res;
value = stack_pointer[-1];
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
res = PyStackRef_True;
- stack_pointer[-1] = res;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (res_o == NULL) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-1] = res;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
assert(PyLong_CheckExact(left_o));
assert(PyLong_CheckExact(right_o));
STAT_INC(BINARY_OP, hit);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
if (res_o == NULL) {
assert(PyLong_CheckExact(left_o));
assert(PyLong_CheckExact(right_o));
STAT_INC(BINARY_OP, hit);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
if (res_o == NULL) {
assert(PyLong_CheckExact(left_o));
assert(PyLong_CheckExact(right_o));
STAT_INC(BINARY_OP, hit);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
if (res_o == NULL) {
right = stack_pointer[-1];
left = stack_pointer[-2];
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
- PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
+ PyObject *right_o = PyStackRef_AsPyObjectSteal(right);
assert(PyUnicode_CheckExact(left_o));
assert(PyUnicode_CheckExact(right_o));
int next_oparg;
assert(Py_REFCNT(left_o) >= 2);
PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
PyObject *temp = PyStackRef_AsPyObjectSteal(*target_local);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyUnicode_Append(&temp, right_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
*target_local = PyStackRef_FromPyObjectSteal(temp);
- PyStackRef_CLOSE_SPECIALIZED(right, _PyUnicode_ExactDealloc);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ Py_DECREF(right_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (PyStackRef_IsNull(*target_local)) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
#if TIER_ONE
assert(next_instr->op.code == STORE_FAST);
SKIP_OVER(1);
#endif
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
break;
}
STAT_INC(BINARY_OP, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = d->action(left_o, right_o);
+ _PyStackRef tmp = right;
+ right = PyStackRef_NULL;
+ stack_pointer[-1] = right;
+ PyStackRef_CLOSE(tmp);
+ tmp = left;
+ left = PyStackRef_NULL;
+ stack_pointer[-2] = left;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(left);
- PyStackRef_CLOSE(right);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
stack_pointer += 2;
assert(WITHIN_STACK_BOUNDS());
}
- PyStackRef_CLOSE(v);
- PyStackRef_CLOSE(container);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = container;
+ container = PyStackRef_NULL;
+ stack_pointer[-1] = container;
+ PyStackRef_CLOSE(tmp);
+ tmp = v;
+ v = PyStackRef_NULL;
+ stack_pointer[-2] = v;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (err) {
- stack_pointer += -4;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
- stack_pointer += -4;
- assert(WITHIN_STACK_BOUNDS());
break;
}
_PyErr_SetKeyError(sub);
stack_pointer = _PyFrame_GetStackPointer(frame);
}
- PyStackRef_CLOSE(dict_st);
- PyStackRef_CLOSE(sub_st);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = sub_st;
+ sub_st = PyStackRef_NULL;
+ stack_pointer[-1] = sub_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = dict_st;
+ dict_st = PyStackRef_NULL;
+ stack_pointer[-2] = dict_st;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (rc <= 0) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
// not found or error
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
int err = PySet_Add(PyStackRef_AsPyObjectBorrow(set),
PyStackRef_AsPyObjectBorrow(v));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(v);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
break;
}
/* container[sub] = v */
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v));
+ _PyStackRef tmp = sub;
+ sub = PyStackRef_NULL;
+ stack_pointer[-1] = sub;
+ PyStackRef_CLOSE(tmp);
+ tmp = container;
+ container = PyStackRef_NULL;
+ stack_pointer[-2] = container;
+ PyStackRef_CLOSE(tmp);
+ tmp = v;
+ v = PyStackRef_NULL;
+ stack_pointer[-3] = v;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(v);
- PyStackRef_CLOSE(container);
- PyStackRef_CLOSE(sub);
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
if (err) {
- stack_pointer += -3;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
- stack_pointer += -3;
- assert(WITHIN_STACK_BOUNDS());
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container),
PyStackRef_AsPyObjectBorrow(sub));
+ _PyStackRef tmp = sub;
+ sub = PyStackRef_NULL;
+ stack_pointer[-1] = sub;
+ PyStackRef_CLOSE(tmp);
+ tmp = container;
+ container = PyStackRef_NULL;
+ stack_pointer[-2] = container;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(container);
- PyStackRef_CLOSE(sub);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (err) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (res_o == NULL) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-1] = res;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
PyObject *value2 = PyStackRef_AsPyObjectBorrow(value2_st);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1);
+ _PyStackRef tmp = value1_st;
+ value1_st = PyStackRef_NULL;
+ stack_pointer[-1] = value1_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = value2_st;
+ value2_st = PyStackRef_NULL;
+ stack_pointer[-2] = value2_st;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(value2_st);
- PyStackRef_CLOSE(value1_st);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
"__aiter__ method, got %.100s",
type->tp_name);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(obj);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(obj);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_ERROR();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
iter_o = (*getter)(obj_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(obj);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (iter_o == NULL) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
if (Py_TYPE(iter_o)->tp_as_async == NULL ||
Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_Format(tstate, PyExc_TypeError,
"'async for' received an object from __aiter__ "
JUMP_TO_ERROR();
}
iter = PyStackRef_FromPyObjectSteal(iter_o);
- stack_pointer[-1] = iter;
+ stack_pointer[0] = iter;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(iterable);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (iter_o == NULL) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
iter = PyStackRef_FromPyObjectSteal(iter_o);
- stack_pointer[-1] = iter;
+ stack_pointer[0] = iter;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
_PyErr_Format(tstate, PyExc_SystemError,
"no locals found when storing %R", name);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(v);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(v);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_ERROR();
}
if (PyDict_CheckExact(ns)) {
err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
stack_pointer = _PyFrame_GetStackPointer(frame);
}
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(v);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
break;
}
case _UNPACK_SEQUENCE: {
_PyStackRef seq;
- _PyStackRef *output;
+ _PyStackRef *top;
oparg = CURRENT_OPARG();
seq = stack_pointer[-1];
- output = &stack_pointer[-1];
- _PyStackRef *top = output + oparg;
+ top = &stack_pointer[-1 + oparg];
+ PyObject *seq_o = PyStackRef_AsPyObjectSteal(seq);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
- int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top);
+ int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg, -1, top);
+ Py_DECREF(seq_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(seq);
if (res == 0) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
- stack_pointer += -1 + oparg;
+ stack_pointer += oparg;
assert(WITHIN_STACK_BOUNDS());
break;
}
STAT_INC(UNPACK_SEQUENCE, hit);
val0 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 0));
val1 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 1));
- PyStackRef_CLOSE(seq);
stack_pointer[-1] = val1;
stack_pointer[0] = val0;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(seq);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
break;
}
for (int i = oparg; --i >= 0; ) {
*values++ = PyStackRef_FromPyObjectNew(items[i]);
}
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(seq);
- stack_pointer += -1 + oparg;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += oparg;
assert(WITHIN_STACK_BOUNDS());
break;
}
*values++ = PyStackRef_FromPyObjectNew(items[i]);
}
UNLOCK_OBJECT(seq_o);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(seq);
- stack_pointer += -1 + oparg;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += oparg;
assert(WITHIN_STACK_BOUNDS());
break;
}
case _UNPACK_EX: {
_PyStackRef seq;
- _PyStackRef *right;
+ _PyStackRef *top;
oparg = CURRENT_OPARG();
seq = stack_pointer[-1];
- right = &stack_pointer[(oparg & 0xFF)];
- _PyStackRef *top = right + (oparg >> 8);
+ top = &stack_pointer[(oparg & 0xFF) + (oparg >> 8)];
+ PyObject *seq_o = PyStackRef_AsPyObjectSteal(seq);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
- int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top);
+ int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg & 0xFF, oparg >> 8, top);
+ Py_DECREF(seq_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(seq);
if (res == 0) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
- stack_pointer += (oparg & 0xFF) + (oparg >> 8);
+ stack_pointer += 1 + (oparg & 0xFF) + (oparg >> 8);
assert(WITHIN_STACK_BOUNDS());
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner),
name, PyStackRef_AsPyObjectBorrow(v));
+ _PyStackRef tmp = owner;
+ owner = PyStackRef_NULL;
+ stack_pointer[-1] = owner;
+ PyStackRef_CLOSE(tmp);
+ tmp = v;
+ v = PyStackRef_NULL;
+ stack_pointer[-2] = v;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(v);
- PyStackRef_CLOSE(owner);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (err) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(v);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
break;
}
pieces = &stack_pointer[-oparg];
STACKREFS_TO_PYOBJECTS(pieces, oparg, pieces_o);
if (CONVERSION_FAILED(pieces_o)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(pieces[_i]);
+ tmp = pieces[_i];
+ pieces[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
PyObject *str_o = _PyUnicode_JoinArray(&_Py_STR(empty), pieces_o, oparg);
STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(pieces[_i]);
+ tmp = pieces[_i];
+ pieces[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (str_o == NULL) {
- stack_pointer += -oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
str = PyStackRef_FromPyObjectSteal(str_o);
- stack_pointer[-oparg] = str;
- stack_pointer += 1 - oparg;
+ stack_pointer[0] = str;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
Py_TYPE(iterable)->tp_name);
stack_pointer = _PyFrame_GetStackPointer(frame);
}
- PyStackRef_CLOSE(iterable_st);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(iterable_st);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_ERROR();
}
assert(Py_IsNone(none_val));
- PyStackRef_CLOSE(iterable_st);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(iterable_st);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
break;
}
int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set),
PyStackRef_AsPyObjectBorrow(iterable));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(iterable);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
break;
}
PyObject *set_o = PySet_New(NULL);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (set_o == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(values[_i]);
+ tmp = values[_i];
+ values[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
stack_pointer = _PyFrame_GetStackPointer(frame);
}
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(values[_i]);
+ tmp = values[_i];
+ values[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (err != 0) {
- stack_pointer += -oparg;
- assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
Py_DECREF(set_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_ERROR();
}
set = PyStackRef_FromPyObjectSteal(set_o);
- stack_pointer[-oparg] = set;
- stack_pointer += 1 - oparg;
+ stack_pointer[0] = set;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
values = &stack_pointer[-oparg*2];
STACKREFS_TO_PYOBJECTS(values, oparg*2, values_o);
if (CONVERSION_FAILED(values_o)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg*2; --_i >= 0;) {
- PyStackRef_CLOSE(values[_i]);
+ tmp = values[_i];
+ values[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -oparg*2;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
oparg);
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(values_o);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg*2; --_i >= 0;) {
- PyStackRef_CLOSE(values[_i]);
+ tmp = values[_i];
+ values[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -oparg*2;
+ assert(WITHIN_STACK_BOUNDS());
if (map_o == NULL) {
- stack_pointer += -oparg*2;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
map = PyStackRef_FromPyObjectSteal(map_o);
- stack_pointer[-oparg*2] = map;
- stack_pointer += 1 - oparg*2;
+ stack_pointer[0] = map;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
Py_TYPE(update_o)->tp_name);
stack_pointer = _PyFrame_GetStackPointer(frame);
}
- PyStackRef_CLOSE(update);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(update);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_ERROR();
}
- PyStackRef_CLOSE(update);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(update);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatKwargsError(tstate, callable_o, update_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(update);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(update);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_ERROR();
}
- PyStackRef_CLOSE(update);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(update);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
break;
}
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL);
+ _PyStackRef tmp = self_st;
+ self_st = PyStackRef_NULL;
+ stack_pointer[-1] = self_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = class_st;
+ class_st = PyStackRef_NULL;
+ stack_pointer[-2] = class_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = global_super_st;
+ global_super_st = PyStackRef_NULL;
+ stack_pointer[-3] = global_super_st;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(global_super_st);
- PyStackRef_CLOSE(class_st);
- PyStackRef_CLOSE(self_st);
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
if (attr == NULL) {
- stack_pointer += -3;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
attr_st = PyStackRef_FromPyObjectSteal(attr);
- stack_pointer[-3] = attr_st;
- stack_pointer += -2;
+ stack_pointer[0] = attr_st;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
}
- PyStackRef_CLOSE(global_super_st);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = global_super_st;
+ global_super_st = self_or_null;
+ stack_pointer[-2] = global_super_st;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(class_st);
- attr = PyStackRef_FromPyObjectSteal(attr_o);
- stack_pointer[-3] = attr;
- stack_pointer[-2] = self_or_null;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ attr = PyStackRef_FromPyObjectSteal(attr_o);
+ stack_pointer[0] = attr;
+ stack_pointer[1] = self_or_null;
+ stack_pointer += 2;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
CALL that it's not a method call.
meth | NULL | arg1 | ... | argN
*/
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (attr_o == NULL) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
self_or_null[0] = PyStackRef_NULL;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
}
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (attr_o == NULL) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
}
attr = PyStackRef_FromPyObjectSteal(attr_o);
stack_pointer[-1] = attr;
STAT_INC(LOAD_ATTR, hit);
attr = PyStackRef_FromPyObjectNew(attr_o);
UNLOCK_OBJECT(dict);
- PyStackRef_CLOSE(owner);
- stack_pointer[-2] = attr;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = owner;
+ owner = attr;
+ stack_pointer[-1] = owner;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer[-1] = attr;
break;
}
attr = PyStackRef_FromPyObjectNew(attr_o);
#endif
STAT_INC(LOAD_ATTR, hit);
- PyStackRef_CLOSE(owner);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = owner;
+ owner = attr;
+ stack_pointer[-1] = owner;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer[-1] = attr;
break;
}
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
attr = PyStackRef_FromPyObjectNew(descr);
- PyStackRef_CLOSE(owner);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = owner;
+ owner = attr;
+ stack_pointer[-1] = owner;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer[-1] = attr;
break;
}
assert((oparg >> 5) <= Py_GE);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5);
+ _PyStackRef tmp = right;
+ right = PyStackRef_NULL;
+ stack_pointer[-1] = right;
+ PyStackRef_CLOSE(tmp);
+ tmp = left;
+ left = PyStackRef_NULL;
+ stack_pointer[-2] = left;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(left);
- PyStackRef_CLOSE(right);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
if (oparg & 16) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int res_bool = PyObject_IsTrue(res_o);
Py_DECREF(res_o);
}
else {
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
}
stack_pointer[0] = res;
stack_pointer += 1;
right = stack_pointer[-1];
left = stack_pointer[-2];
int res = Py_Is(PyStackRef_AsPyObjectBorrow(left), PyStackRef_AsPyObjectBorrow(right)) ^ oparg;
- PyStackRef_CLOSE(left);
- PyStackRef_CLOSE(right);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = right;
+ right = PyStackRef_NULL;
+ stack_pointer[-1] = right;
+ PyStackRef_CLOSE(tmp);
+ tmp = left;
+ left = PyStackRef_NULL;
+ stack_pointer[-2] = left;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
b = res ? PyStackRef_True : PyStackRef_False;
- stack_pointer[-2] = b;
- stack_pointer += -1;
+ stack_pointer[0] = b;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
_PyFrame_SetStackPointer(frame, stack_pointer);
int res = PySequence_Contains(right_o, left_o);
+ _PyStackRef tmp = right;
+ right = PyStackRef_NULL;
+ stack_pointer[-1] = right;
+ PyStackRef_CLOSE(tmp);
+ tmp = left;
+ left = PyStackRef_NULL;
+ stack_pointer[-2] = left;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(left);
- PyStackRef_CLOSE(right);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (res < 0) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;
- stack_pointer[-2] = b;
- stack_pointer += -1;
+ stack_pointer[0] = b;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
// Note: both set and frozenset use the same seq_contains method!
_PyFrame_SetStackPointer(frame, stack_pointer);
int res = _PySet_Contains((PySetObject *)right_o, left_o);
+ _PyStackRef tmp = right;
+ right = PyStackRef_NULL;
+ stack_pointer[-1] = right;
+ PyStackRef_CLOSE(tmp);
+ tmp = left;
+ left = PyStackRef_NULL;
+ stack_pointer[-2] = left;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(left);
- PyStackRef_CLOSE(right);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (res < 0) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;
- stack_pointer[-2] = b;
- stack_pointer += -1;
+ stack_pointer[0] = b;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
STAT_INC(CONTAINS_OP, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
int res = PyDict_Contains(right_o, left_o);
+ _PyStackRef tmp = right;
+ right = PyStackRef_NULL;
+ stack_pointer[-1] = right;
+ PyStackRef_CLOSE(tmp);
+ tmp = left;
+ left = PyStackRef_NULL;
+ stack_pointer[-2] = left;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(left);
- PyStackRef_CLOSE(right);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (res < 0) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;
- stack_pointer[-2] = b;
- stack_pointer += -1;
+ stack_pointer[0] = b;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
- PyStackRef_CLOSE(exc_value_st);
- PyStackRef_CLOSE(match_type_st);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = match_type_st;
+ match_type_st = PyStackRef_NULL;
+ stack_pointer[-1] = match_type_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = exc_value_st;
+ exc_value_st = PyStackRef_NULL;
+ stack_pointer[-2] = exc_value_st;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
_PyFrame_SetStackPointer(frame, stack_pointer);
int res = _PyEval_ExceptionGroupMatch(frame, exc_value, match_type,
&match_o, &rest_o);
+ _PyStackRef tmp = match_type_st;
+ match_type_st = PyStackRef_NULL;
+ stack_pointer[-1] = match_type_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = exc_value_st;
+ exc_value_st = PyStackRef_NULL;
+ stack_pointer[-2] = exc_value_st;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(exc_value_st);
- PyStackRef_CLOSE(match_type_st);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (res < 0) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
assert((match_o == NULL) == (rest_o == NULL));
if (match_o == NULL) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
if (!Py_IsNone(match_o)) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
PyErr_SetHandledException(match_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- stack_pointer += 2;
- assert(WITHIN_STACK_BOUNDS());
}
rest = PyStackRef_FromPyObjectSteal(rest_o);
match = PyStackRef_FromPyObjectSteal(match_o);
- stack_pointer[-2] = rest;
- stack_pointer[-1] = match;
+ stack_pointer[0] = rest;
+ stack_pointer[1] = match;
+ stack_pointer += 2;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
int err = _PyEval_CheckExceptTypeValid(tstate, right_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
- PyStackRef_CLOSE(right);
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
int res = PyErr_GivenExceptionMatches(left_o, right_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(right);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
b = res ? PyStackRef_True : PyStackRef_False;
- stack_pointer[-1] = b;
+ stack_pointer[0] = b;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
PyObject *res_o = _PyEval_ImportName(tstate, frame, name,
PyStackRef_AsPyObjectBorrow(fromlist),
PyStackRef_AsPyObjectBorrow(level));
+ _PyStackRef tmp = fromlist;
+ fromlist = PyStackRef_NULL;
+ stack_pointer[-1] = fromlist;
+ PyStackRef_CLOSE(tmp);
+ tmp = level;
+ level = PyStackRef_NULL;
+ stack_pointer[-2] = level;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(level);
- PyStackRef_CLOSE(fromlist);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
}
else {
b = PyStackRef_False;
- PyStackRef_CLOSE(value);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = value;
+ value = b;
+ stack_pointer[-1] = value;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer[-1] = b;
}
stack_pointer[-1] = b;
break;
PyStackRef_AsPyObjectBorrow(subject),
PyStackRef_AsPyObjectBorrow(type), oparg,
PyStackRef_AsPyObjectBorrow(names));
+ _PyStackRef tmp = names;
+ names = PyStackRef_NULL;
+ stack_pointer[-1] = names;
+ PyStackRef_CLOSE(tmp);
+ tmp = type;
+ type = PyStackRef_NULL;
+ stack_pointer[-2] = type;
+ PyStackRef_CLOSE(tmp);
+ tmp = subject;
+ subject = PyStackRef_NULL;
+ stack_pointer[-3] = subject;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(subject);
- PyStackRef_CLOSE(type);
- PyStackRef_CLOSE(names);
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
if (attrs_o) {
assert(PyTuple_CheckExact(attrs_o)); // Success!
attrs = PyStackRef_FromPyObjectSteal(attrs_o);
}
else {
if (_PyErr_Occurred(tstate)) {
- stack_pointer += -3;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
// Error!
attrs = PyStackRef_None; // Failure!
}
- stack_pointer[-3] = attrs;
- stack_pointer += -2;
+ stack_pointer[0] = attrs;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *iter_o = PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(iterable);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (iter_o == NULL) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
iter = PyStackRef_FromPyObjectSteal(iter_o);
- stack_pointer[-1] = iter;
+ stack_pointer[0] = iter;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
JUMP_TO_ERROR();
}
iter = PyStackRef_FromPyObjectSteal(iter_o);
- PyStackRef_CLOSE(iterable);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = iterable;
+ iterable = iter;
+ stack_pointer[-1] = iterable;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer[-1] = iter;
}
}
stack_pointer[-1] = iter;
assert((oparg & 1) == 0);
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
attr = PyStackRef_FromPyObjectNew(descr);
- stack_pointer[-1] = attr;
+ stack_pointer[0] = attr;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
assert(Py_TYPE(PyStackRef_AsPyObjectBorrow(owner))->tp_dictoffset == 0);
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
attr = PyStackRef_FromPyObjectNew(descr);
- stack_pointer[-1] = attr;
+ stack_pointer[0] = attr;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
if (temp == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FrameClearAndPop(tstate, shim);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_ERROR();
}
init_frame = temp;
STAT_INC(CALL, hit);
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
PyObject *res_o = tp->tp_vectorcall((PyObject *)tp, args_o, total_args, NULL);
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
/* res = func(self, args, nargs) */
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
}
res = retval ? PyStackRef_True : PyStackRef_False;
assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = callable[0];
+ callable[0] = res;
+ PyStackRef_CLOSE(tmp);
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer[-2 - oparg] = res;
stack_pointer += -1 - oparg;
assert(WITHIN_STACK_BOUNDS());
stack_pointer = _PyFrame_GetStackPointer(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
int nargs = total_args - 1;
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
int nargs = total_args - 1;
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = kwnames;
+ kwnames = PyStackRef_NULL;
+ stack_pointer[-1] = kwnames;
+ PyStackRef_CLOSE(tmp);
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
- PyStackRef_CLOSE(kwnames);
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -3 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
PyObject *stop_o = PyStackRef_AsPyObjectBorrow(args[1]);
PyObject *step_o = oparg == 3 ? PyStackRef_AsPyObjectBorrow(args[2]) : NULL;
PyObject *slice_o = PySlice_New(start_o, stop_o, step_o);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (slice_o == NULL) {
- stack_pointer += -oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
slice = PyStackRef_FromPyObjectSteal(slice_o);
- stack_pointer[-oparg] = slice;
- stack_pointer += 1 - oparg;
+ stack_pointer[0] = slice;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
value = stack_pointer[-2];
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec));
+ _PyStackRef tmp = fmt_spec;
+ fmt_spec = PyStackRef_NULL;
+ stack_pointer[-1] = fmt_spec;
+ PyStackRef_CLOSE(tmp);
+ tmp = value;
+ value = PyStackRef_NULL;
+ stack_pointer[-2] = value;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(value);
- PyStackRef_CLOSE(fmt_spec);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(lhs);
- PyStackRef_CLOSE(rhs);
if (res_o == NULL) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_ERROR();
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2] = res;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = lhs;
+ lhs = res;
+ stack_pointer[-2] = lhs;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(rhs);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer[-1] = res;
break;
}
STAT_INC(LOAD_ATTR, hit);
Py_INCREF(attr_o);
attr = PyStackRef_FromPyObjectSteal(attr_o);
- PyStackRef_CLOSE(owner);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = owner;
+ owner = attr;
+ stack_pointer[-1] = owner;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer[-1] = attr;
break;
}
_PyGC_Collect(PyThreadState *tstate, int generation, _PyGC_Reason reason)
{
GCState *gcstate = &tstate->interp->gc;
+ assert(tstate->current_frame == NULL || tstate->current_frame->stackpointer != NULL);
int expected = 0;
if (!_Py_atomic_compare_exchange_int(&gcstate->collecting, &expected, 1)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(lhs);
- PyStackRef_CLOSE(rhs);
if (res_o == NULL) {
- JUMP_TO_LABEL(pop_2_error);
+ JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = lhs;
+ lhs = res;
+ stack_pointer[-2] = lhs;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(rhs);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer[-1] = res;
}
- stack_pointer[-2] = res;
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
assert(PyLong_CheckExact(left_o));
assert(PyLong_CheckExact(right_o));
STAT_INC(BINARY_OP, hit);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
if (res_o == NULL) {
STAT_INC(BINARY_OP, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = d->action(left_o, right_o);
+ _PyStackRef tmp = right;
+ right = PyStackRef_NULL;
+ stack_pointer[-1] = right;
+ PyStackRef_CLOSE(tmp);
+ tmp = left;
+ left = PyStackRef_NULL;
+ stack_pointer[-2] = left;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(left);
- PyStackRef_CLOSE(right);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
res = PyStackRef_FromPyObjectSteal(res_o);
}
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
// _BINARY_OP_INPLACE_ADD_UNICODE
{
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
- PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
+ PyObject *right_o = PyStackRef_AsPyObjectSteal(right);
assert(PyUnicode_CheckExact(left_o));
assert(PyUnicode_CheckExact(right_o));
int next_oparg;
assert(Py_REFCNT(left_o) >= 2);
PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
PyObject *temp = PyStackRef_AsPyObjectSteal(*target_local);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyUnicode_Append(&temp, right_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
*target_local = PyStackRef_FromPyObjectSteal(temp);
- PyStackRef_CLOSE_SPECIALIZED(right, _PyUnicode_ExactDealloc);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ Py_DECREF(right_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (PyStackRef_IsNull(*target_local)) {
- JUMP_TO_LABEL(pop_2_error);
+ JUMP_TO_LABEL(error);
}
#if TIER_ONE
// The STORE_FAST is already done. This is done here in tier one,
SKIP_OVER(1);
#endif
}
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
assert(PyLong_CheckExact(left_o));
assert(PyLong_CheckExact(right_o));
STAT_INC(BINARY_OP, hit);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
if (res_o == NULL) {
_PyErr_SetKeyError(sub);
stack_pointer = _PyFrame_GetStackPointer(frame);
}
- PyStackRef_CLOSE(dict_st);
- PyStackRef_CLOSE(sub_st);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = sub_st;
+ sub_st = PyStackRef_NULL;
+ stack_pointer[-1] = sub_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = dict_st;
+ dict_st = PyStackRef_NULL;
+ stack_pointer[-2] = dict_st;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (rc <= 0) {
- JUMP_TO_LABEL(pop_2_error);
+ JUMP_TO_LABEL(error);
}
// not found or error
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
assert(PyLong_CheckExact(left_o));
assert(PyLong_CheckExact(right_o));
STAT_INC(BINARY_OP, hit);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
if (res_o == NULL) {
values = &stack_pointer[-oparg*2];
STACKREFS_TO_PYOBJECTS(values, oparg*2, values_o);
if (CONVERSION_FAILED(values_o)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg*2; --_i >= 0;) {
- PyStackRef_CLOSE(values[_i]);
+ tmp = values[_i];
+ values[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -oparg*2;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
oparg);
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(values_o);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg*2; --_i >= 0;) {
- PyStackRef_CLOSE(values[_i]);
+ tmp = values[_i];
+ values[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -oparg*2;
+ assert(WITHIN_STACK_BOUNDS());
if (map_o == NULL) {
- stack_pointer += -oparg*2;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
map = PyStackRef_FromPyObjectSteal(map_o);
- stack_pointer[-oparg*2] = map;
- stack_pointer += 1 - oparg*2;
+ stack_pointer[0] = map;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
PyObject *set_o = PySet_New(NULL);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (set_o == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(values[_i]);
+ tmp = values[_i];
+ values[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
stack_pointer = _PyFrame_GetStackPointer(frame);
}
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(values[_i]);
+ tmp = values[_i];
+ values[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (err != 0) {
- stack_pointer += -oparg;
- assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
Py_DECREF(set_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_LABEL(error);
}
set = PyStackRef_FromPyObjectSteal(set_o);
- stack_pointer[-oparg] = set;
- stack_pointer += 1 - oparg;
+ stack_pointer[0] = set;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
PyObject *stop_o = PyStackRef_AsPyObjectBorrow(args[1]);
PyObject *step_o = oparg == 3 ? PyStackRef_AsPyObjectBorrow(args[2]) : NULL;
PyObject *slice_o = PySlice_New(start_o, stop_o, step_o);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (slice_o == NULL) {
- stack_pointer += -oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
slice = PyStackRef_FromPyObjectSteal(slice_o);
- stack_pointer[-oparg] = slice;
- stack_pointer += 1 - oparg;
+ stack_pointer[0] = slice;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
pieces = &stack_pointer[-oparg];
STACKREFS_TO_PYOBJECTS(pieces, oparg, pieces_o);
if (CONVERSION_FAILED(pieces_o)) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(pieces[_i]);
+ tmp = pieces[_i];
+ pieces[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
PyObject *str_o = _PyUnicode_JoinArray(&_Py_STR(empty), pieces_o, oparg);
STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(pieces[_i]);
+ tmp = pieces[_i];
+ pieces[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (str_o == NULL) {
- stack_pointer += -oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
str = PyStackRef_FromPyObjectSteal(str_o);
- stack_pointer[-oparg] = str;
- stack_pointer += 1 - oparg;
+ stack_pointer[0] = str;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
}
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
- }
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ }
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
if (err != 0) {
JUMP_TO_LABEL(error);
}
- stack_pointer += 1 + oparg;
+ stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
}
}
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
if (temp == NULL) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FrameClearAndPop(tstate, shim);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
JUMP_TO_LABEL(error);
}
init_frame = temp;
STAT_INC(CALL, hit);
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
PyObject *res_o = tp->tp_vectorcall((PyObject *)tp, args_o, total_args, NULL);
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
- }
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ }
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
if (err != 0) {
JUMP_TO_LABEL(error);
}
- stack_pointer += 1 + oparg;
+ stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
}
}
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
/* res = func(self, args, nargs) */
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
- }
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ }
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
if (err != 0) {
JUMP_TO_LABEL(error);
}
- stack_pointer += 1 + oparg;
+ stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
}
}
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
- }
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ }
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
if (err != 0) {
JUMP_TO_LABEL(error);
}
- stack_pointer += 1 + oparg;
+ stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
}
}
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (res_o == NULL) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-1] = res;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
PyObject *value2 = PyStackRef_AsPyObjectBorrow(value2_st);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1);
+ _PyStackRef tmp = value1_st;
+ value1_st = PyStackRef_NULL;
+ stack_pointer[-1] = value1_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = value2_st;
+ value2_st = PyStackRef_NULL;
+ stack_pointer[-2] = value2_st;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(value2_st);
- PyStackRef_CLOSE(value1_st);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- JUMP_TO_LABEL(pop_2_error);
+ JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
}
res = retval ? PyStackRef_True : PyStackRef_False;
assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = callable[0];
+ callable[0] = res;
+ PyStackRef_CLOSE(tmp);
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer[-2 - oparg] = res;
stack_pointer += -1 - oparg;
assert(WITHIN_STACK_BOUNDS());
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ stack_pointer[-1] = kwnames;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = kwnames;
+ kwnames = PyStackRef_NULL;
+ stack_pointer[-1] = kwnames;
+ PyStackRef_CLOSE(tmp);
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
- PyStackRef_CLOSE(kwnames);
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -3 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
}
}
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = kwnames;
+ kwnames = PyStackRef_NULL;
+ stack_pointer[-1] = kwnames;
+ PyStackRef_CLOSE(tmp);
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
- }
- PyStackRef_CLOSE(kwnames);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ }
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -3 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -3 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
}
- stack_pointer[-3 - oparg] = res;
- stack_pointer += -2 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = kwnames;
+ kwnames = PyStackRef_NULL;
+ stack_pointer[-1] = kwnames;
+ PyStackRef_CLOSE(tmp);
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
- PyStackRef_CLOSE(kwnames);
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -3 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
- }
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ }
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
if (err != 0) {
JUMP_TO_LABEL(error);
}
- stack_pointer += 1 + oparg;
+ stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
}
}
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
int nargs = total_args - 1;
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
- }
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ }
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
if (err != 0) {
JUMP_TO_LABEL(error);
}
- stack_pointer += 1 + oparg;
+ stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
}
}
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
int nargs = total_args - 1;
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
- }
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ }
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
if (err != 0) {
JUMP_TO_LABEL(error);
}
- stack_pointer += 1 + oparg;
+ stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
}
}
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
stack_pointer = _PyFrame_GetStackPointer(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
- }
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ }
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
if (err != 0) {
JUMP_TO_LABEL(error);
}
- stack_pointer += 1 + oparg;
+ stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
}
}
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
- }
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ }
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
if (err != 0) {
JUMP_TO_LABEL(error);
}
- stack_pointer += 1 + oparg;
+ stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
}
}
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
- PyStackRef_CLOSE(exc_value_st);
- PyStackRef_CLOSE(match_type_st);
- JUMP_TO_LABEL(pop_2_error);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = match_type_st;
+ match_type_st = PyStackRef_NULL;
+ stack_pointer[-1] = match_type_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = exc_value_st;
+ exc_value_st = PyStackRef_NULL;
+ stack_pointer[-2] = exc_value_st;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_LABEL(error);
}
PyObject *match_o = NULL;
PyObject *rest_o = NULL;
_PyFrame_SetStackPointer(frame, stack_pointer);
int res = _PyEval_ExceptionGroupMatch(frame, exc_value, match_type,
&match_o, &rest_o);
+ _PyStackRef tmp = match_type_st;
+ match_type_st = PyStackRef_NULL;
+ stack_pointer[-1] = match_type_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = exc_value_st;
+ exc_value_st = PyStackRef_NULL;
+ stack_pointer[-2] = exc_value_st;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(exc_value_st);
- PyStackRef_CLOSE(match_type_st);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (res < 0) {
- JUMP_TO_LABEL(pop_2_error);
+ JUMP_TO_LABEL(error);
}
assert((match_o == NULL) == (rest_o == NULL));
if (match_o == NULL) {
- JUMP_TO_LABEL(pop_2_error);
+ JUMP_TO_LABEL(error);
}
if (!Py_IsNone(match_o)) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
PyErr_SetHandledException(match_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- stack_pointer += 2;
- assert(WITHIN_STACK_BOUNDS());
}
rest = PyStackRef_FromPyObjectSteal(rest_o);
match = PyStackRef_FromPyObjectSteal(match_o);
- stack_pointer[-2] = rest;
- stack_pointer[-1] = match;
+ stack_pointer[0] = rest;
+ stack_pointer[1] = match;
+ stack_pointer += 2;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
int err = _PyEval_CheckExceptTypeValid(tstate, right_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
- PyStackRef_CLOSE(right);
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
_PyFrame_SetStackPointer(frame, stack_pointer);
int res = PyErr_GivenExceptionMatches(left_o, right_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(right);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
b = res ? PyStackRef_True : PyStackRef_False;
- stack_pointer[-1] = b;
+ stack_pointer[0] = b;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
frame->instr_ptr = next_instr;
next_instr += 1;
INSTRUCTION_STATS(CLEANUP_THROW);
- _PyStackRef sub_iter_st;
- _PyStackRef last_sent_val_st;
+ _PyStackRef sub_iter;
+ _PyStackRef last_sent_val;
_PyStackRef exc_value_st;
_PyStackRef none;
_PyStackRef value;
exc_value_st = stack_pointer[-1];
- last_sent_val_st = stack_pointer[-2];
- sub_iter_st = stack_pointer[-3];
+ last_sent_val = stack_pointer[-2];
+ sub_iter = stack_pointer[-3];
PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st);
#ifndef Py_TAIL_CALL_INTERP
assert(throwflag);
int matches = PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (matches) {
- none = PyStackRef_None;
value = PyStackRef_FromPyObjectNew(((PyStopIterationObject *)exc_value)->value);
- PyStackRef_CLOSE(sub_iter_st);
- PyStackRef_CLOSE(last_sent_val_st);
- PyStackRef_CLOSE(exc_value_st);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = sub_iter;
+ sub_iter = value;
+ stack_pointer[-3] = sub_iter;
+ PyStackRef_CLOSE(tmp);
+ tmp = exc_value_st;
+ exc_value_st = PyStackRef_NULL;
+ stack_pointer[-1] = exc_value_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = last_sent_val;
+ last_sent_val = PyStackRef_NULL;
+ stack_pointer[-2] = last_sent_val;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
+ none = PyStackRef_None;
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_SetRaisedException(tstate, Py_NewRef(exc_value));
monitor_reraise(tstate, frame, this_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
- _PyFrame_SetStackPointer(frame, stack_pointer);
JUMP_TO_LABEL(exception_unwind);
}
- stack_pointer[-3] = none;
- stack_pointer[-2] = value;
- stack_pointer += -1;
+ stack_pointer[0] = none;
+ stack_pointer[1] = value;
+ stack_pointer += 2;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
assert((oparg >> 5) <= Py_GE);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5);
+ _PyStackRef tmp = right;
+ right = PyStackRef_NULL;
+ stack_pointer[-1] = right;
+ PyStackRef_CLOSE(tmp);
+ tmp = left;
+ left = PyStackRef_NULL;
+ stack_pointer[-2] = left;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(left);
- PyStackRef_CLOSE(right);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- JUMP_TO_LABEL(pop_2_error);
+ JUMP_TO_LABEL(error);
}
if (oparg & 16) {
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int res_bool = PyObject_IsTrue(res_o);
Py_DECREF(res_o);
}
else {
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
}
}
stack_pointer[0] = res;
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
_PyFrame_SetStackPointer(frame, stack_pointer);
int res = PySequence_Contains(right_o, left_o);
+ _PyStackRef tmp = right;
+ right = PyStackRef_NULL;
+ stack_pointer[-1] = right;
+ PyStackRef_CLOSE(tmp);
+ tmp = left;
+ left = PyStackRef_NULL;
+ stack_pointer[-2] = left;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(left);
- PyStackRef_CLOSE(right);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (res < 0) {
- JUMP_TO_LABEL(pop_2_error);
+ JUMP_TO_LABEL(error);
}
b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;
}
- stack_pointer[-2] = b;
- stack_pointer += -1;
+ stack_pointer[0] = b;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
STAT_INC(CONTAINS_OP, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
int res = PyDict_Contains(right_o, left_o);
+ _PyStackRef tmp = right;
+ right = PyStackRef_NULL;
+ stack_pointer[-1] = right;
+ PyStackRef_CLOSE(tmp);
+ tmp = left;
+ left = PyStackRef_NULL;
+ stack_pointer[-2] = left;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(left);
- PyStackRef_CLOSE(right);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (res < 0) {
- JUMP_TO_LABEL(pop_2_error);
+ JUMP_TO_LABEL(error);
}
b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;
- stack_pointer[-2] = b;
- stack_pointer += -1;
+ stack_pointer[0] = b;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
// Note: both set and frozenset use the same seq_contains method!
_PyFrame_SetStackPointer(frame, stack_pointer);
int res = _PySet_Contains((PySetObject *)right_o, left_o);
+ _PyStackRef tmp = right;
+ right = PyStackRef_NULL;
+ stack_pointer[-1] = right;
+ PyStackRef_CLOSE(tmp);
+ tmp = left;
+ left = PyStackRef_NULL;
+ stack_pointer[-2] = left;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(left);
- PyStackRef_CLOSE(right);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (res < 0) {
- JUMP_TO_LABEL(pop_2_error);
+ JUMP_TO_LABEL(error);
}
b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;
- stack_pointer[-2] = b;
- stack_pointer += -1;
+ stack_pointer[0] = b;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container),
PyStackRef_AsPyObjectBorrow(sub));
+ _PyStackRef tmp = sub;
+ sub = PyStackRef_NULL;
+ stack_pointer[-1] = sub;
+ PyStackRef_CLOSE(tmp);
+ tmp = container;
+ container = PyStackRef_NULL;
+ stack_pointer[-2] = container;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(container);
- PyStackRef_CLOSE(sub);
- if (err) {
- JUMP_TO_LABEL(pop_2_error);
- }
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
+ if (err) {
+ JUMP_TO_LABEL(error);
+ }
DISPATCH();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatKwargsError(tstate, callable_o, update_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(update);
- JUMP_TO_LABEL(pop_1_error);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ JUMP_TO_LABEL(error);
}
- PyStackRef_CLOSE(update);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(update);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH();
}
Py_TYPE(update_o)->tp_name);
stack_pointer = _PyFrame_GetStackPointer(frame);
}
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(update);
- JUMP_TO_LABEL(pop_1_error);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ JUMP_TO_LABEL(error);
}
- PyStackRef_CLOSE(update);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(update);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH();
}
int matches = PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (matches) {
- PyStackRef_CLOSE(awaitable_st);
- PyStackRef_CLOSE(exc_st);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = exc_st;
+ exc_st = PyStackRef_NULL;
+ stack_pointer[-1] = exc_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = awaitable_st;
+ awaitable_st = PyStackRef_NULL;
+ stack_pointer[-2] = awaitable_st;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
}
else {
Py_INCREF(exc);
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_SetRaisedException(tstate, exc);
monitor_reraise(tstate, frame, this_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
- _PyFrame_SetStackPointer(frame, stack_pointer);
JUMP_TO_LABEL(exception_unwind);
}
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
receiver = stack_pointer[-2];
(void)receiver;
val = value;
- PyStackRef_CLOSE(receiver);
stack_pointer[-2] = val;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(receiver);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH();
}
value = stack_pointer[-2];
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec));
+ _PyStackRef tmp = fmt_spec;
+ fmt_spec = PyStackRef_NULL;
+ stack_pointer[-1] = fmt_spec;
+ PyStackRef_CLOSE(tmp);
+ tmp = value;
+ value = PyStackRef_NULL;
+ stack_pointer[-2] = value;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(value);
- PyStackRef_CLOSE(fmt_spec);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- JUMP_TO_LABEL(pop_2_error);
+ JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
"__aiter__ method, got %.100s",
type->tp_name);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(obj);
- JUMP_TO_LABEL(pop_1_error);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ JUMP_TO_LABEL(error);
}
_PyFrame_SetStackPointer(frame, stack_pointer);
iter_o = (*getter)(obj_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(obj);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (iter_o == NULL) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
if (Py_TYPE(iter_o)->tp_as_async == NULL ||
Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) {
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_Format(tstate, PyExc_TypeError,
"'async for' received an object from __aiter__ "
JUMP_TO_LABEL(error);
}
iter = PyStackRef_FromPyObjectSteal(iter_o);
- stack_pointer[-1] = iter;
+ stack_pointer[0] = iter;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(iterable);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (iter_o == NULL) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
iter = PyStackRef_FromPyObjectSteal(iter_o);
- stack_pointer[-1] = iter;
+ stack_pointer[0] = iter;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *iter_o = PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(iterable);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (iter_o == NULL) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
iter = PyStackRef_FromPyObjectSteal(iter_o);
- stack_pointer[-1] = iter;
+ stack_pointer[0] = iter;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
JUMP_TO_LABEL(error);
}
iter = PyStackRef_FromPyObjectSteal(iter_o);
- PyStackRef_CLOSE(iterable);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = iterable;
+ iterable = iter;
+ stack_pointer[-1] = iterable;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer[-1] = iter;
}
}
stack_pointer[-1] = iter;
PyObject *res_o = _PyEval_ImportName(tstate, frame, name,
PyStackRef_AsPyObjectBorrow(fromlist),
PyStackRef_AsPyObjectBorrow(level));
+ _PyStackRef tmp = fromlist;
+ fromlist = PyStackRef_NULL;
+ stack_pointer[-1] = fromlist;
+ PyStackRef_CLOSE(tmp);
+ tmp = level;
+ level = PyStackRef_NULL;
+ stack_pointer[-2] = level;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(level);
- PyStackRef_CLOSE(fromlist);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- JUMP_TO_LABEL(pop_2_error);
+ JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
}
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
- }
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ }
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
if (err != 0) {
JUMP_TO_LABEL(error);
}
- stack_pointer += 1 + oparg;
+ stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
}
}
- stack_pointer[-2 - oparg] = res;
- stack_pointer += -1 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
/* Callable is not a normal Python function */
STACKREFS_TO_PYOBJECTS(arguments, total_args, args_o);
if (CONVERSION_FAILED(args_o)) {
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ stack_pointer[-1] = kwnames;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = kwnames;
+ kwnames = PyStackRef_NULL;
+ stack_pointer[-1] = kwnames;
+ PyStackRef_CLOSE(tmp);
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
}
- PyStackRef_CLOSE(kwnames);
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -3 - oparg;
assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
}
}
- PyStackRef_CLOSE(callable[0]);
- PyStackRef_XCLOSE(self_or_null[0]);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = kwnames;
+ kwnames = PyStackRef_NULL;
+ stack_pointer[-1] = kwnames;
+ PyStackRef_CLOSE(tmp);
for (int _i = oparg; --_i >= 0;) {
- PyStackRef_CLOSE(args[_i]);
- }
- PyStackRef_CLOSE(kwnames);
+ tmp = args[_i];
+ args[_i] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ }
+ tmp = self_or_null[0];
+ self_or_null[0] = PyStackRef_NULL;
+ PyStackRef_XCLOSE(tmp);
+ tmp = callable[0];
+ callable[0] = PyStackRef_NULL;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -3 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
if (res_o == NULL) {
- stack_pointer += -3 - oparg;
- assert(WITHIN_STACK_BOUNDS());
JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
}
- stack_pointer[-3 - oparg] = res;
- stack_pointer += -2 - oparg;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
JUMP_TO_LABEL(error);
}
}
- PyStackRef_CLOSE(value);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH();
}
frame, this_instr, global_super, arg);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) {
- PyStackRef_CLOSE(global_super_st);
- PyStackRef_CLOSE(class_st);
- PyStackRef_CLOSE(self_st);
- JUMP_TO_LABEL(pop_3_error);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = self_st;
+ self_st = PyStackRef_NULL;
+ stack_pointer[-1] = self_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = class_st;
+ class_st = PyStackRef_NULL;
+ stack_pointer[-2] = class_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = global_super_st;
+ global_super_st = PyStackRef_NULL;
+ stack_pointer[-3] = global_super_st;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_LABEL(error);
}
}
// we make no attempt to optimize here; specializations should
}
}
}
- PyStackRef_CLOSE(global_super_st);
- PyStackRef_CLOSE(class_st);
- PyStackRef_CLOSE(self_st);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = self_st;
+ self_st = PyStackRef_NULL;
+ stack_pointer[-1] = self_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = class_st;
+ class_st = PyStackRef_NULL;
+ stack_pointer[-2] = class_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = global_super_st;
+ global_super_st = PyStackRef_NULL;
+ stack_pointer[-3] = global_super_st;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
if (super == NULL) {
- JUMP_TO_LABEL(pop_3_error);
+ JUMP_TO_LABEL(error);
}
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);
- stack_pointer += -3;
- assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *attr_o = PyObject_GetAttr(super, name);
Py_DECREF(super);
right = stack_pointer[-1];
left = stack_pointer[-2];
int res = Py_Is(PyStackRef_AsPyObjectBorrow(left), PyStackRef_AsPyObjectBorrow(right)) ^ oparg;
- PyStackRef_CLOSE(left);
- PyStackRef_CLOSE(right);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = right;
+ right = PyStackRef_NULL;
+ stack_pointer[-1] = right;
+ PyStackRef_CLOSE(tmp);
+ tmp = left;
+ left = PyStackRef_NULL;
+ stack_pointer[-2] = left;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
b = res ? PyStackRef_True : PyStackRef_False;
- stack_pointer[-2] = b;
- stack_pointer += -1;
+ stack_pointer[0] = b;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
Py_TYPE(iterable)->tp_name);
stack_pointer = _PyFrame_GetStackPointer(frame);
}
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(iterable_st);
- JUMP_TO_LABEL(pop_1_error);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ JUMP_TO_LABEL(error);
}
assert(Py_IsNone(none_val));
- PyStackRef_CLOSE(iterable_st);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(iterable_st);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH();
}
CALL that it's not a method call.
meth | NULL | arg1 | ... | argN
*/
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (attr_o == NULL) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
self_or_null[0] = PyStackRef_NULL;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
}
}
else {
/* Classic, pushes one value. */
_PyFrame_SetStackPointer(frame, stack_pointer);
- attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (attr_o == NULL) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
}
attr = PyStackRef_FromPyObjectSteal(attr_o);
}
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
attr = PyStackRef_FromPyObjectNew(descr);
- PyStackRef_CLOSE(owner);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = owner;
+ owner = attr;
+ stack_pointer[-1] = owner;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer[-1] = attr;
}
// _PUSH_NULL_CONDITIONAL
{
null = PyStackRef_NULL;
}
- stack_pointer[-1] = attr;
if (oparg & 1) stack_pointer[0] = null;
stack_pointer += (oparg & 1);
assert(WITHIN_STACK_BOUNDS());
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
attr = PyStackRef_FromPyObjectNew(descr);
- PyStackRef_CLOSE(owner);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = owner;
+ owner = attr;
+ stack_pointer[-1] = owner;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer[-1] = attr;
}
// _PUSH_NULL_CONDITIONAL
{
null = PyStackRef_NULL;
}
- stack_pointer[-1] = attr;
if (oparg & 1) stack_pointer[0] = null;
stack_pointer += (oparg & 1);
assert(WITHIN_STACK_BOUNDS());
assert(Py_TYPE(PyStackRef_AsPyObjectBorrow(owner))->tp_dictoffset == 0);
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
attr = PyStackRef_FromPyObjectNew(descr);
}
- stack_pointer[-1] = attr;
+ stack_pointer[0] = attr;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
assert((oparg & 1) == 0);
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
attr = PyStackRef_FromPyObjectNew(descr);
}
- stack_pointer[-1] = attr;
+ stack_pointer[0] = attr;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
attr = PyStackRef_FromPyObjectNew(attr_o);
#endif
STAT_INC(LOAD_ATTR, hit);
- PyStackRef_CLOSE(owner);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = owner;
+ owner = attr;
+ stack_pointer[-1] = owner;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer[-1] = attr;
}
/* Skip 5 cache entries */
// _PUSH_NULL_CONDITIONAL
{
null = PyStackRef_NULL;
}
- stack_pointer[-1] = attr;
if (oparg & 1) stack_pointer[0] = null;
stack_pointer += (oparg & 1);
assert(WITHIN_STACK_BOUNDS());
STAT_INC(LOAD_ATTR, hit);
attr = PyStackRef_FromPyObjectNew(attr_o);
UNLOCK_OBJECT(dict);
- PyStackRef_CLOSE(owner);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = owner;
+ owner = attr;
+ stack_pointer[-1] = owner;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer[-1] = attr;
}
/* Skip 5 cache entries */
// _PUSH_NULL_CONDITIONAL
{
null = PyStackRef_NULL;
}
- stack_pointer[-1] = attr;
if (oparg & 1) stack_pointer[0] = null;
stack_pointer += (oparg & 1);
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyMapping_GetOptionalItem(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &v_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(mod_or_class_dict);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
if (v_o == NULL) {
if (PyDict_CheckExact(GLOBALS())
&& PyDict_CheckExact(BUILTINS()))
{
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
v_o = _PyDict_LoadGlobal((PyDictObject *)GLOBALS(),
(PyDictObject *)BUILTINS(),
else {
/* Slow-path if globals or builtins is not a dict */
/* namespace 1: globals */
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyMapping_GetOptionalItem(GLOBALS(), name, &v_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
}
}
}
- stack_pointer += 1;
- assert(WITHIN_STACK_BOUNDS());
}
v = PyStackRef_FromPyObjectSteal(v_o);
- stack_pointer[-1] = v;
+ stack_pointer[0] = v;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
frame, this_instr, global_super, arg);
stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) {
- PyStackRef_CLOSE(global_super_st);
- PyStackRef_CLOSE(class_st);
- PyStackRef_CLOSE(self_st);
- JUMP_TO_LABEL(pop_3_error);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = self_st;
+ self_st = PyStackRef_NULL;
+ stack_pointer[-1] = self_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = class_st;
+ class_st = PyStackRef_NULL;
+ stack_pointer[-2] = class_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = global_super_st;
+ global_super_st = PyStackRef_NULL;
+ stack_pointer[-3] = global_super_st;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_LABEL(error);
}
}
// we make no attempt to optimize here; specializations should
}
}
}
- PyStackRef_CLOSE(global_super_st);
- PyStackRef_CLOSE(class_st);
- PyStackRef_CLOSE(self_st);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = self_st;
+ self_st = PyStackRef_NULL;
+ stack_pointer[-1] = self_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = class_st;
+ class_st = PyStackRef_NULL;
+ stack_pointer[-2] = class_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = global_super_st;
+ global_super_st = PyStackRef_NULL;
+ stack_pointer[-3] = global_super_st;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
if (super == NULL) {
- JUMP_TO_LABEL(pop_3_error);
+ JUMP_TO_LABEL(error);
}
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);
- stack_pointer += -3;
- assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *attr_o = PyObject_GetAttr(super, name);
Py_DECREF(super);
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL);
+ _PyStackRef tmp = self_st;
+ self_st = PyStackRef_NULL;
+ stack_pointer[-1] = self_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = class_st;
+ class_st = PyStackRef_NULL;
+ stack_pointer[-2] = class_st;
+ PyStackRef_CLOSE(tmp);
+ tmp = global_super_st;
+ global_super_st = PyStackRef_NULL;
+ stack_pointer[-3] = global_super_st;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(global_super_st);
- PyStackRef_CLOSE(class_st);
- PyStackRef_CLOSE(self_st);
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
if (attr == NULL) {
- JUMP_TO_LABEL(pop_3_error);
+ JUMP_TO_LABEL(error);
}
attr_st = PyStackRef_FromPyObjectSteal(attr);
- stack_pointer[-3] = attr_st;
- stack_pointer += -2;
+ stack_pointer[0] = attr_st;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
}
- PyStackRef_CLOSE(global_super_st);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = global_super_st;
+ global_super_st = self_or_null;
+ stack_pointer[-2] = global_super_st;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(class_st);
- attr = PyStackRef_FromPyObjectSteal(attr_o);
- stack_pointer[-3] = attr;
- stack_pointer[-2] = self_or_null;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ attr = PyStackRef_FromPyObjectSteal(attr_o);
+ stack_pointer[0] = attr;
+ stack_pointer[1] = self_or_null;
+ stack_pointer += 2;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
PyStackRef_AsPyObjectBorrow(subject),
PyStackRef_AsPyObjectBorrow(type), oparg,
PyStackRef_AsPyObjectBorrow(names));
+ _PyStackRef tmp = names;
+ names = PyStackRef_NULL;
+ stack_pointer[-1] = names;
+ PyStackRef_CLOSE(tmp);
+ tmp = type;
+ type = PyStackRef_NULL;
+ stack_pointer[-2] = type;
+ PyStackRef_CLOSE(tmp);
+ tmp = subject;
+ subject = PyStackRef_NULL;
+ stack_pointer[-3] = subject;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(subject);
- PyStackRef_CLOSE(type);
- PyStackRef_CLOSE(names);
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
if (attrs_o) {
assert(PyTuple_CheckExact(attrs_o)); // Success!
attrs = PyStackRef_FromPyObjectSteal(attrs_o);
}
else {
if (_PyErr_Occurred(tstate)) {
- JUMP_TO_LABEL(pop_3_error);
+ JUMP_TO_LABEL(error);
}
// Error!
attrs = PyStackRef_None; // Failure!
}
- stack_pointer[-3] = attrs;
- stack_pointer += -2;
+ stack_pointer[0] = attrs;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
INSTRUCTION_STATS(POP_ITER);
_PyStackRef value;
value = stack_pointer[-1];
- PyStackRef_CLOSE(value);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH();
}
}
else {
b = PyStackRef_False;
- PyStackRef_CLOSE(value);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = value;
+ value = b;
+ stack_pointer[-1] = value;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer[-1] = b;
}
}
// _POP_JUMP_IF_TRUE
}
else {
b = PyStackRef_False;
- PyStackRef_CLOSE(value);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = value;
+ value = b;
+ stack_pointer[-1] = value;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer[-1] = b;
}
}
// _POP_JUMP_IF_FALSE
INSTRUCTION_STATS(POP_TOP);
_PyStackRef value;
value = stack_pointer[-1];
- PyStackRef_CLOSE(value);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH();
}
assert(oparg == 0);
_PyFrame_SetStackPointer(frame, stack_pointer);
monitor_reraise(tstate, frame, this_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
- _PyFrame_SetStackPointer(frame, stack_pointer);
JUMP_TO_LABEL(exception_unwind);
}
JUMP_TO_LABEL(error);
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_SetRaisedException(tstate, exc);
monitor_reraise(tstate, frame, this_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
- _PyFrame_SetStackPointer(frame, stack_pointer);
JUMP_TO_LABEL(exception_unwind);
}
JUMPBY(oparg);
}
else {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(v);
- JUMP_TO_LABEL(pop_1_error);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ JUMP_TO_LABEL(error);
}
}
stack_pointer += -1;
int err = PySet_Add(PyStackRef_AsPyObjectBorrow(set),
PyStackRef_AsPyObjectBorrow(v));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(v);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set),
PyStackRef_AsPyObjectBorrow(iterable));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(iterable);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner),
name, PyStackRef_AsPyObjectBorrow(v));
+ _PyStackRef tmp = owner;
+ owner = PyStackRef_NULL;
+ stack_pointer[-1] = owner;
+ PyStackRef_CLOSE(tmp);
+ tmp = v;
+ v = PyStackRef_NULL;
+ stack_pointer[-2] = v;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(v);
- PyStackRef_CLOSE(owner);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (err) {
- JUMP_TO_LABEL(pop_2_error);
+ JUMP_TO_LABEL(error);
}
}
- stack_pointer += -2;
- assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(v);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
_PyErr_Format(tstate, PyExc_SystemError,
"no locals found when storing %R", name);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(v);
- JUMP_TO_LABEL(pop_1_error);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ JUMP_TO_LABEL(error);
}
if (PyDict_CheckExact(ns)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
stack_pointer = _PyFrame_GetStackPointer(frame);
}
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(v);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
- stack_pointer += -1;
- assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
stack_pointer += 2;
assert(WITHIN_STACK_BOUNDS());
}
- PyStackRef_CLOSE(v);
- PyStackRef_CLOSE(container);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = container;
+ container = PyStackRef_NULL;
+ stack_pointer[-1] = container;
+ PyStackRef_CLOSE(tmp);
+ tmp = v;
+ v = PyStackRef_NULL;
+ stack_pointer[-2] = v;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
if (err) {
- JUMP_TO_LABEL(pop_4_error);
+ JUMP_TO_LABEL(error);
}
}
- stack_pointer += -4;
- assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
/* container[sub] = v */
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v));
+ _PyStackRef tmp = sub;
+ sub = PyStackRef_NULL;
+ stack_pointer[-1] = sub;
+ PyStackRef_CLOSE(tmp);
+ tmp = container;
+ container = PyStackRef_NULL;
+ stack_pointer[-2] = container;
+ PyStackRef_CLOSE(tmp);
+ tmp = v;
+ v = PyStackRef_NULL;
+ stack_pointer[-3] = v;
+ PyStackRef_CLOSE(tmp);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(v);
- PyStackRef_CLOSE(container);
- PyStackRef_CLOSE(sub);
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
if (err) {
- JUMP_TO_LABEL(pop_3_error);
+ JUMP_TO_LABEL(error);
}
}
- stack_pointer += -3;
- assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
res = err ? PyStackRef_True : PyStackRef_False;
}
- stack_pointer[-1] = res;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
// _REPLACE_WITH_TRUE
{
value = owner;
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
res = PyStackRef_True;
}
- stack_pointer[-1] = res;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
res = PyStackRef_False;
}
else {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
res = PyStackRef_True;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
}
stack_pointer[-1] = res;
DISPATCH();
}
STAT_INC(TO_BOOL, hit);
res = PyList_GET_SIZE(value_o) ? PyStackRef_True : PyStackRef_False;
- PyStackRef_CLOSE(value);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyStackRef tmp = value;
+ value = res;
+ stack_pointer[-1] = value;
+ PyStackRef_CLOSE(tmp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer[-1] = res;
DISPATCH();
}
}
else {
assert(Py_SIZE(value_o));
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
res = PyStackRef_True;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
}
stack_pointer[-1] = res;
DISPATCH();
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (res_o == NULL) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-1] = res;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (res_o == NULL) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-1] = res;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
next_instr += 1;
INSTRUCTION_STATS(UNPACK_EX);
_PyStackRef seq;
- _PyStackRef *right;
+ _PyStackRef *top;
seq = stack_pointer[-1];
- right = &stack_pointer[(oparg & 0xFF)];
- _PyStackRef *top = right + (oparg >> 8);
+ top = &stack_pointer[(oparg & 0xFF) + (oparg >> 8)];
+ PyObject *seq_o = PyStackRef_AsPyObjectSteal(seq);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
- int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top);
+ int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg & 0xFF, oparg >> 8, top);
+ Py_DECREF(seq_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(seq);
if (res == 0) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
- stack_pointer += (oparg & 0xFF) + (oparg >> 8);
+ stack_pointer += 1 + (oparg & 0xFF) + (oparg >> 8);
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
_Py_CODEUNIT* const this_instr = next_instr - 2;
(void)this_instr;
_PyStackRef seq;
- _PyStackRef *output;
+ _PyStackRef *top;
// _SPECIALIZE_UNPACK_SEQUENCE
{
seq = stack_pointer[-1];
}
// _UNPACK_SEQUENCE
{
- output = &stack_pointer[-1];
- _PyStackRef *top = output + oparg;
+ top = &stack_pointer[-1 + oparg];
+ PyObject *seq_o = PyStackRef_AsPyObjectSteal(seq);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
- int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top);
+ int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg, -1, top);
+ Py_DECREF(seq_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(seq);
if (res == 0) {
- JUMP_TO_LABEL(pop_1_error);
+ JUMP_TO_LABEL(error);
}
}
- stack_pointer += -1 + oparg;
+ stack_pointer += oparg;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
*values++ = PyStackRef_FromPyObjectNew(items[i]);
}
UNLOCK_OBJECT(seq_o);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(seq);
- stack_pointer += -1 + oparg;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += oparg;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
for (int i = oparg; --i >= 0; ) {
*values++ = PyStackRef_FromPyObjectNew(items[i]);
}
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(seq);
- stack_pointer += -1 + oparg;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += oparg;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
STAT_INC(UNPACK_SEQUENCE, hit);
val0 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 0));
val1 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 1));
- PyStackRef_CLOSE(seq);
stack_pointer[-1] = val1;
stack_pointer[0] = val0;
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(seq);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH();
}
}
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_MonitorRaise(tstate, frame, next_instr-1);
- stack_pointer = _PyFrame_GetStackPointer(frame);
- _PyFrame_SetStackPointer(frame, stack_pointer);
JUMP_TO_LABEL(exception_unwind);
}
JUMP_TO_LABEL(exit_unwind);
}
next_instr = frame->instr_ptr;
- LLTRACE_RESUME_FRAME();
#ifdef Py_DEBUG
+ int lltrace = maybe_lltrace_resume_frame(frame, GLOBALS());
+ if (lltrace < 0) {
+ JUMP_TO_LABEL(exit_unwind);
+ }
+ frame->lltrace = lltrace;
/* _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(PyLong_CheckExact(sym_get_const(left)));
assert(PyLong_CheckExact(sym_get_const(right)));
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
PyObject *temp = _PyLong_Multiply((PyLongObject *)sym_get_const(left),
(PyLongObject *)sym_get_const(right));
if (temp == NULL) {
goto error;
}
res = sym_new_const(ctx, temp);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
Py_DECREF(temp);
// TODO gh-115506:
{
assert(PyLong_CheckExact(sym_get_const(left)));
assert(PyLong_CheckExact(sym_get_const(right)));
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
PyObject *temp = _PyLong_Add((PyLongObject *)sym_get_const(left),
(PyLongObject *)sym_get_const(right));
if (temp == NULL) {
goto error;
}
res = sym_new_const(ctx, temp);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
Py_DECREF(temp);
// TODO gh-115506:
{
assert(PyLong_CheckExact(sym_get_const(left)));
assert(PyLong_CheckExact(sym_get_const(right)));
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
PyObject *temp = _PyLong_Subtract((PyLongObject *)sym_get_const(left),
(PyLongObject *)sym_get_const(right));
if (temp == NULL) {
goto error;
}
res = sym_new_const(ctx, temp);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
Py_DECREF(temp);
// TODO gh-115506:
"PyTuple_GET_ITEM",
"PyTuple_GET_SIZE",
"PyType_HasFeature",
- "PyUnicode_Append",
"PyUnicode_Concat",
"PyUnicode_GET_LENGTH",
"PyUnicode_READ_CHAR",
"_PyCode_CODE",
"_PyDictValues_AddToInsertionOrder",
"_PyErr_Occurred",
- "_PyEval_FrameClearAndPop",
"_PyFloat_FromDouble_ConsumeInputs",
"_PyFrame_GetBytecode",
"_PyFrame_GetCode",
"_PyList_AppendTakeRef",
"_PyList_FromStackRefStealOnSuccess",
"_PyList_ITEMS",
- "_PyLong_Add",
"_PyLong_CompactValue",
"_PyLong_DigitCount",
"_PyLong_IsCompact",
"_PyLong_IsNegative",
"_PyLong_IsNonNegativeCompact",
"_PyLong_IsZero",
- "_PyLong_Multiply",
- "_PyLong_Subtract",
"_PyManagedDictPointer_IsValues",
"_PyObject_GC_IS_TRACKED",
"_PyObject_GC_MAY_BE_TRACKED",
self.line_directives = line_directives
self.last_token = None
self.newline = True
+ self.pending_spill = False
+ self.pending_reload = False
def set_position(self, tkn: Token) -> None:
if self.last_token is not None:
self.newline = False
def emit_at(self, txt: str, where: Token) -> None:
+ self.maybe_write_spill()
self.set_position(where)
self.out.write(txt)
self.last_token = None
def emit(self, txt: str | Token) -> None:
+ self.maybe_write_spill()
if isinstance(txt, Token):
self.emit_token(txt)
elif isinstance(txt, str):
self.newline = True
self.last_token = None
+ def emit_spill(self) -> None:
+ if self.pending_reload:
+ self.pending_reload = False
+ return
+ assert not self.pending_spill
+ self.pending_spill = True
+
+ def maybe_write_spill(self) -> None:
+ if self.pending_spill:
+ self.pending_spill = False
+ self.emit_str("_PyFrame_SetStackPointer(frame, stack_pointer);\n")
+ elif self.pending_reload:
+ self.pending_reload = False
+ self.emit_str("stack_pointer = _PyFrame_GetStackPointer(frame);\n")
+
+ def emit_reload(self) -> None:
+ if self.pending_spill:
+ self.pending_spill = False
+ return
+ assert not self.pending_reload
+ self.pending_reload = True
+
@contextlib.contextmanager
def header_guard(self, name: str) -> Iterator[None]:
self.out.write(
next(tkn_iter)
next(tkn_iter)
next(tkn_iter)
- self.out.emit_at("", tkn)
- for var in storage.inputs:
- if not var.defined:
- continue
- if var.name == "null":
- continue
- close = "PyStackRef_CLOSE"
- if "null" in var.name or var.condition and var.condition != "1":
- close = "PyStackRef_XCLOSE"
- if var.size:
- if var.size == "1":
- self.out.emit(f"{close}({var.name}[0]);\n")
- else:
- self.out.emit(f"for (int _i = {var.size}; --_i >= 0;) {{\n")
- self.out.emit(f"{close}({var.name}[_i]);\n")
- self.out.emit("}\n")
- elif var.condition:
- if var.condition != "0":
- self.out.emit(f"{close}({var.name});\n")
- else:
- self.out.emit(f"{close}({var.name});\n")
- for input in storage.inputs:
- input.defined = False
+ try:
+ storage.close_inputs(self.out)
+ except StackError as ex:
+ raise analysis_error(ex.args[0], tkn)
+ except Exception as ex:
+ ex.args = (ex.args[0] + str(tkn),)
+ raise
return True
def kill_inputs(
var.defined = False
break
else:
- raise analysis_error(f"'{name}' is not a live input-only variable", name_tkn)
+ raise analysis_error(
+ f"'{name}' is not a live input-only variable", name_tkn
+ )
return True
def stackref_kill(
self.out.emit(comma)
dealloc = next(tkn_iter)
if dealloc.kind != "IDENTIFIER":
- raise analysis_error("Expected identifier", dealloc)
+ raise analysis_error("Expected identifier", dealloc)
self.out.emit(dealloc)
if name.kind == "IDENTIFIER":
escapes = dealloc.text not in NON_ESCAPING_DEALLOCS
self.emit(next(tkn_iter))
maybe_if = tkn_iter.peek()
if maybe_if and maybe_if.kind == "IF":
- #Emit extra braces around the if to get scoping right
+ # Emit extra braces around the if to get scoping right
self.emit(" {\n")
self.emit(next(tkn_iter))
else_reachable, rbrace, else_storage = self._emit_if(tkn_iter, uop, storage, inst)
var.defined = False
storage = emitter.emit_tokens(override, storage, None)
out.start_line()
- storage.flush(out, cast_type="JitOptSymbol *")
+ storage.flush(out)
else:
emit_default(out, uop, stack)
out.start_line()
- stack.flush(out, cast_type="JitOptSymbol *")
+ stack.flush(out)
except StackError as ex:
raise analysis_error(ex.args[0], prototype.body[0]) # from None
declare_variables(override, out, skip_inputs=False)
else:
declare_variables(uop, out, skip_inputs=True)
- stack = Stack(False)
+ stack = Stack(extract_bits=False, cast_type="JitOptSymbol *")
write_uop(override, uop, out, stack, debug, skip_inputs=(override is None))
out.start_line()
out.emit("break;\n")
return "array" if var.is_array() else "scalar"
class Stack:
- def __init__(self, extract_bits: bool=True) -> None:
+ def __init__(self, extract_bits: bool=True, cast_type: str = "uintptr_t") -> None:
self.top_offset = StackOffset.empty()
self.base_offset = StackOffset.empty()
self.variables: list[Local] = []
self.defined: set[str] = set()
self.extract_bits = extract_bits
+ self.cast_type = cast_type
def pop(self, var: StackItem) -> tuple[str, Local]:
self.top_offset.pop(var)
out: CWriter,
var: StackItem,
base_offset: StackOffset,
- cast_type: str = "uintptr_t",
- extract_bits: bool = True,
+ cast_type: str,
+ extract_bits: bool,
) -> None:
cast = f"({cast_type})" if var.type else ""
bits = ".bits" if cast and extract_bits else ""
out.emit(f"stack_pointer += {number};\n")
out.emit("assert(WITHIN_STACK_BOUNDS());\n")
- def flush(
- self, out: CWriter, cast_type: str = "uintptr_t"
- ) -> None:
+ def flush(self, out: CWriter) -> None:
out.start_line()
var_offset = self.base_offset.copy()
for var in self.variables:
var.defined and
not var.in_memory
):
- Stack._do_emit(out, var.item, var_offset, cast_type, self.extract_bits)
+ Stack._do_emit(out, var.item, var_offset, self.cast_type, self.extract_bits)
var.in_memory = True
var_offset.push(var.item)
number = self.top_offset.to_c()
)
def copy(self) -> "Stack":
- other = Stack(self.extract_bits)
+ other = Stack(self.extract_bits, self.cast_type)
other.top_offset = self.top_offset.copy()
other.base_offset = self.base_offset.copy()
other.variables = [var.copy() for var in self.variables]
return True
return False
- def flush(self, out: CWriter, cast_type: str = "uintptr_t") -> None:
+ def flush(self, out: CWriter) -> None:
self.clear_dead_inputs()
self._push_defined_outputs()
- self.stack.flush(out, cast_type)
+ self.stack.flush(out)
def save(self, out: CWriter) -> None:
assert self.spilled >= 0
if self.spilled == 0:
self.flush(out)
out.start_line()
- out.emit("_PyFrame_SetStackPointer(frame, stack_pointer);\n")
+ out.emit_spill()
+ self.spilled += 1
+
+ def save_inputs(self, out: CWriter) -> None:
+ assert self.spilled >= 0
+ if self.spilled == 0:
+ self.clear_dead_inputs()
+ self.stack.flush(out)
+ out.start_line()
+ out.emit_spill()
self.spilled += 1
def reload(self, out: CWriter) -> None:
self.spilled -= 1
if self.spilled == 0:
out.start_line()
- out.emit("stack_pointer = _PyFrame_GetStackPointer(frame);\n")
+ out.emit_reload()
@staticmethod
def for_uop(stack: Stack, uop: Uop) -> tuple[list[str], "Storage"]:
outputs = ", ".join([var.compact_str() for var in self.outputs])
peeks = ", ".join([var.name for var in self.peeks])
return f"{stack_comment[:-2]}{next_line}inputs: {inputs}{next_line}outputs: {outputs}{next_line}peeks: {peeks} */"
+
+ def close_inputs(self, out: CWriter) -> None:
+ tmp_defined = False
+ def close_named(close: str, name: str, overwrite: str) -> None:
+ nonlocal tmp_defined
+ if overwrite:
+ if not tmp_defined:
+ out.emit("_PyStackRef ")
+ tmp_defined = True
+ out.emit(f"tmp = {name};\n")
+ out.emit(f"{name} = {overwrite};\n")
+ if not var.is_array():
+ var.in_memory = False
+ self.flush(out)
+ out.emit(f"{close}(tmp);\n")
+ else:
+ out.emit(f"{close}({name});\n")
+
+ def close_variable(var: Local, overwrite: str) -> None:
+ nonlocal tmp_defined
+ close = "PyStackRef_CLOSE"
+ if "null" in var.name or var.condition and var.condition != "1":
+ close = "PyStackRef_XCLOSE"
+ if var.size:
+ if var.size == "1":
+ close_named(close, f"{var.name}[0]", overwrite)
+ else:
+ if overwrite and not tmp_defined:
+ out.emit("_PyStackRef tmp;\n")
+ tmp_defined = True
+ out.emit(f"for (int _i = {var.size}; --_i >= 0;) {{\n")
+ close_named(close, f"{var.name}[_i]", overwrite)
+ out.emit("}\n")
+ else:
+ if var.condition and var.condition == "0":
+ return
+ close_named(close, var.name, overwrite)
+
+ self.clear_dead_inputs()
+ if not self.inputs:
+ return
+ output: Local | None = None
+ for var in self.outputs:
+ if var.is_array():
+ if len(self.inputs) > 1:
+ raise StackError("Cannot call DECREF_INPUTS with multiple live input(s) and array output")
+ elif var.defined:
+ if output is not None:
+ raise StackError("Cannot call DECREF_INPUTS with more than one live output")
+ output = var
+ self.save_inputs(out)
+ if output is not None:
+ lowest = self.inputs[0]
+ if lowest.is_array():
+ try:
+ size = int(lowest.size)
+ except:
+ size = -1
+ if size <= 0:
+ raise StackError("Cannot call DECREF_INPUTS with non fixed size array as lowest input on stack")
+ if size > 1:
+ raise StackError("Cannot call DECREF_INPUTS with array size > 1 as lowest input on stack")
+ output.defined = False
+ close_variable(lowest, output.name)
+ else:
+ lowest.in_memory = False
+ output.defined = False
+ close_variable(lowest, output.name)
+ to_close = self.inputs[: 0 if output is not None else None: -1]
+ if len(to_close) == 1 and not to_close[0].is_array():
+ self.reload(out)
+ to_close[0].defined = False
+ self.flush(out)
+ self.save_inputs(out)
+ close_variable(to_close[0], "")
+ self.reload(out)
+ else:
+ for var in to_close:
+ assert var.defined or var.is_array()
+ close_variable(var, "PyStackRef_NULL")
+ self.reload(out)
+ for var in self.inputs:
+ var.defined = False
+ if output is not None:
+ output.defined = True
+ # MyPy false positive
+ lowest.defined = False # type: ignore[possibly-undefined]
+ self.flush(out)
projects / thirdparty / Python / cpython.git / commitdiff
