[LOAD_ATTR_CLASS] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG },
[LOAD_ATTR_CLASS_WITH_METACLASS_CHECK] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG },
[LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG },
- [LOAD_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG },
+ [LOAD_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG },
[LOAD_ATTR_METHOD_LAZY_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_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 },
[_GUARD_TYPE_VERSION] = HAS_EXIT_FLAG,
[_GUARD_TYPE_VERSION_AND_LOCK] = HAS_EXIT_FLAG,
[_CHECK_MANAGED_OBJECT_HAS_VALUES] = HAS_DEOPT_FLAG,
- [_LOAD_ATTR_INSTANCE_VALUE] = HAS_DEOPT_FLAG,
+ [_LOAD_ATTR_INSTANCE_VALUE] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG,
[_CHECK_ATTR_MODULE_PUSH_KEYS] = HAS_DEOPT_FLAG,
[_LOAD_ATTR_MODULE_FROM_KEYS] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG,
[_CHECK_ATTR_WITH_HINT] = HAS_EXIT_FLAG,
case _CHECK_METHOD_VERSION:
return 0;
case _EXPAND_METHOD:
- return 2 + oparg;
+ return 0;
case _CHECK_IS_NOT_PY_CALLABLE:
return 0;
case _CALL_NON_PY_GENERAL:
case _CHECK_CALL_BOUND_METHOD_EXACT_ARGS:
return 0;
case _INIT_CALL_BOUND_METHOD_EXACT_ARGS:
- return 2 + oparg;
+ return 0;
case _CHECK_PEP_523:
return 0;
case _CHECK_FUNCTION_EXACT_ARGS:
case _CHECK_METHOD_VERSION_KW:
return 0;
case _EXPAND_METHOD_KW:
- return 3 + oparg;
+ return 0;
case _CHECK_IS_NOT_PY_CALLABLE_KW:
return 0;
case _CALL_KW_NON_PY:
case _BINARY_OP:
return 2;
case _SWAP:
- return 2 + (oparg-2);
+ return 0;
case _GUARD_IS_TRUE_POP:
return 1;
case _GUARD_IS_FALSE_POP:
case _DEOPT:
return 0;
case _ERROR_POP_N:
- return oparg;
+ return 0;
case _TIER2_RESUME_CHECK:
return 0;
default:
frame->instr_ptr = next_instr;
next_instr += 1;
INSTRUCTION_STATS(OP);
- if (cond) goto label;
+ if (cond) {
+ goto label;
+ }
DISPATCH();
}
"""
frame->instr_ptr = next_instr;
next_instr += 1;
INSTRUCTION_STATS(OP);
- if (cond) goto label;
+ if (cond) {
+ goto label;
+ }
// Comment is ok
DISPATCH();
}
right = stack_pointer[-1];
left = stack_pointer[-2];
SPAM(left, right);
- if (cond) goto pop_2_label;
+ if (cond) {
+ goto pop_2_label;
+ }
res = 0;
stack_pointer[-2] = res;
stack_pointer += -1;
right = stack_pointer[-1];
left = stack_pointer[-2];
res = SPAM(left, right);
- if (cond) goto pop_2_label;
+ if (cond) {
+ goto pop_2_label;
+ }
stack_pointer[-2] = res;
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
// THIRD
{
// Mark j and k as used
- if (cond) goto pop_2_error;
+ if (cond) {
+ goto pop_2_error;
+ }
}
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
PyStackRef_CLOSE(self_st);
self_or_null = PyStackRef_NULL;
}
- PyStackRef_CLOSE(class_st);
- PyStackRef_CLOSE(global_super_st);
+ DECREF_INPUTS();
attr = PyStackRef_FromPyObjectSteal(attr_o);
}
attr = PyStackRef_FromPyObjectNew(attr_o);
#endif
STAT_INC(LOAD_ATTR, hit);
- DECREF_INPUTS();
+ PyStackRef_CLOSE(owner);
}
macro(LOAD_ATTR_INSTANCE_VALUE) =
EXIT_IF(!PyStackRef_IsNull(null[0]));
}
- op(_EXPAND_METHOD, (callable[1], null[1], unused[oparg] -- method[1], self[1], unused[oparg])) {
+ op(_EXPAND_METHOD, (callable[1], self_or_null[1], unused[oparg] -- callable[1], self_or_null[1], unused[oparg])) {
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
- assert(PyStackRef_IsNull(null[0]));
- DEAD(null);
+ assert(PyStackRef_IsNull(self_or_null[0]));
assert(Py_TYPE(callable_o) == &PyMethod_Type);
- self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
+ self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
_PyStackRef temp = callable[0];
- method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
- assert(PyStackRef_FunctionCheck(method[0]));
+ callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ assert(PyStackRef_FunctionCheck(callable[0]));
PyStackRef_CLOSE(temp);
}
EXIT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(callable[0])) != &PyMethod_Type);
}
- op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable[1], null[1], unused[oparg] -- func[1], self[1], unused[oparg])) {
- DEAD(null);
+ op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable[1], self_or_null[1], unused[oparg] -- callable[1], self_or_null[1], unused[oparg])) {
+ assert(PyStackRef_IsNull(self_or_null[0]));
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
STAT_INC(CALL, hit);
- self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
+ self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
_PyStackRef temp = callable[0];
- func[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
PyStackRef_CLOSE(temp);
}
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
+ _PyStackRef *arguments = args;
if (!PyStackRef_IsNull(self_or_null[0])) {
- args--;
+ arguments--;
total_args++;
}
EXIT_IF(meth->ml_flags != METH_O);
// CPython promises to check all non-vectorcall function calls.
EXIT_IF(tstate->c_recursion_remaining <= 0);
- _PyStackRef arg_stackref = args[1];
- _PyStackRef self_stackref = args[0];
+ _PyStackRef arg_stackref = arguments[1];
+ _PyStackRef self_stackref = arguments[0];
EXIT_IF(!Py_IS_TYPE(PyStackRef_AsPyObjectBorrow(self_stackref),
method->d_common.d_type));
STAT_INC(CALL, hit);
PyStackRef_AsPyObjectBorrow(arg_stackref));
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(self_stackref);
- PyStackRef_CLOSE(arg_stackref);
- DEAD(args);
- DEAD(self_or_null);
- PyStackRef_CLOSE(callable[0]);
+ DECREF_INPUTS();
ERROR_IF(res_o == NULL, error);
res = PyStackRef_FromPyObjectSteal(res_o);
}
EXIT_IF(!PyStackRef_IsNull(null[0]));
}
- op(_EXPAND_METHOD_KW, (callable[1], null[1], unused[oparg], unused -- method[1], self[1], unused[oparg], unused)) {
+ op(_EXPAND_METHOD_KW, (callable[1], self_or_null[1], unused[oparg], unused -- callable[1], self_or_null[1], unused[oparg], unused)) {
+ assert(PyStackRef_IsNull(self_or_null[0]));
_PyStackRef callable_s = callable[0];
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable_s);
-
- assert(PyStackRef_IsNull(null[0]));
assert(Py_TYPE(callable_o) == &PyMethod_Type);
- self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
- method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
- assert(PyStackRef_FunctionCheck(method[0]));
+ self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
+ callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ assert(PyStackRef_FunctionCheck(callable[0]));
PyStackRef_CLOSE(callable_s);
}
}
}
- op(_DO_CALL_FUNCTION_EX, (func_st, unused, callargs_st, kwargs_st -- result)) {
+ op(_DO_CALL_FUNCTION_EX, (func_st, null, callargs_st, kwargs_st -- result)) {
+ (void)null;
PyObject *func = PyStackRef_AsPyObjectBorrow(func_st);
// DICT_MERGE is called before this opcode if there are kwargs.
result_o = PyObject_Call(func, callargs, kwargs);
}
PyStackRef_XCLOSE(kwargs_st);
- DEAD(kwargs_st);
PyStackRef_CLOSE(callargs_st);
+ DEAD(null);
PyStackRef_CLOSE(func_st);
ERROR_IF(result_o == NULL, error);
result = PyStackRef_FromPyObjectSteal(result_o);
macro(BINARY_OP) = _SPECIALIZE_BINARY_OP + unused/4 + _BINARY_OP;
- pure inst(SWAP, (bottom_in, unused[oparg-2], top_in --
- top_out, unused[oparg-2], bottom_out)) {
- bottom_out = bottom_in;
- DEAD(bottom_in);
- top_out = top_in;
- DEAD(top_in);
+ pure inst(SWAP, (bottom[1], unused[oparg-2], top[1] --
+ bottom[1], unused[oparg-2], top[1])) {
+ _PyStackRef temp = bottom[0];
+ bottom[0] = top[0];
+ top[0] = temp;
assert(oparg >= 2);
}
EXIT_TO_TIER1();
}
- tier2 op(_ERROR_POP_N, (target/2, unused[oparg] --)) {
+ tier2 op(_ERROR_POP_N, (target/2 --)) {
+ assert(oparg == 0);
frame->instr_ptr = _PyFrame_GetBytecode(frame) + target;
SYNC_SP();
GOTO_UNWIND();
}
label(pop_4_error) {
- STACK_SHRINK(1);
- goto pop_3_error;
+ STACK_SHRINK(4);
+ goto error;
}
label(pop_3_error) {
- STACK_SHRINK(1);
- goto pop_2_error;
+ STACK_SHRINK(3);
+ goto error;
}
label(pop_2_error) {
- STACK_SHRINK(1);
- goto pop_1_error;
+ STACK_SHRINK(2);
+ goto error;
}
label(pop_1_error) {
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) JUMP_TO_ERROR();
+ if (err != 0) {
+ JUMP_TO_ERROR();
+ }
}
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) JUMP_TO_ERROR();
+ if (err != 0) {
+ JUMP_TO_ERROR();
+ }
}
}
break;
PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg)
);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (1) JUMP_TO_ERROR();
+ JUMP_TO_ERROR();
}
value = PyStackRef_DUP(value_s);
stack_pointer[0] = value;
* This has the benign side effect that if value is
* finalized it will see the location as the FOR_ITER's.
*/
- PyStackRef_CLOSE(value);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
break;
}
PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
- if (res_o == NULL) JUMP_TO_ERROR();
+ if (res_o == NULL) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-1] = res;
break;
int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
- if (err < 0) JUMP_TO_ERROR();
+ if (err < 0) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
res = err ? PyStackRef_True : PyStackRef_False;
stack_pointer[-1] = res;
break;
PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
- if (res_o == NULL) JUMP_TO_ERROR();
+ if (res_o == NULL) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-1] = res;
break;
PyObject *res_o = _PyLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o);
PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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;
PyObject *res_o = _PyLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o);
PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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;
PyObject *res_o = _PyLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o);
PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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;
((PyFloatObject *)left_o)->ob_fval *
((PyFloatObject *)right_o)->ob_fval;
PyObject *res_o = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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;
((PyFloatObject *)left_o)->ob_fval +
((PyFloatObject *)right_o)->ob_fval;
PyObject *res_o = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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;
((PyFloatObject *)left_o)->ob_fval -
((PyFloatObject *)right_o)->ob_fval;
PyObject *res_o = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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;
PyObject *res_o = PyUnicode_Concat(left_o, right_o);
PyStackRef_CLOSE_SPECIALIZED(right, _PyUnicode_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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;
PyUnicode_Append(&temp, right_o);
*target_local = PyStackRef_FromPyObjectSteal(temp);
PyStackRef_CLOSE_SPECIALIZED(right, _PyUnicode_ExactDealloc);
- if (PyStackRef_IsNull(*target_local)) JUMP_TO_ERROR();
+ if (PyStackRef_IsNull(*target_local)) {
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
#if TIER_ONE
// The STORE_FAST is already done. This is done here in tier one,
// and during trace projection in tier two:
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(container);
PyStackRef_CLOSE(sub);
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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 += 2;
assert(WITHIN_STACK_BOUNDS());
}
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(container);
- if (res_o == NULL) JUMP_TO_ERROR();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (res_o == NULL) {
+ JUMP_TO_ERROR();
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-3] = res;
- stack_pointer += -2;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
}
PyStackRef_CLOSE(v);
PyStackRef_CLOSE(container);
- if (err) JUMP_TO_ERROR();
+ if (err) {
+ stack_pointer += -4;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
stack_pointer += -4;
assert(WITHIN_STACK_BOUNDS());
break;
Py_INCREF(res_o);
#endif
PyStackRef_CLOSE_SPECIALIZED(sub_st, _PyLong_ExactDealloc);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(list_st);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
STAT_INC(BINARY_SUBSCR, hit);
PyObject *res_o = (PyObject*)&_Py_SINGLETON(strings).ascii[c];
PyStackRef_CLOSE_SPECIALIZED(sub_st, _PyLong_ExactDealloc);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(str_st);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
assert(res_o != NULL);
Py_INCREF(res_o);
PyStackRef_CLOSE_SPECIALIZED(sub_st, _PyLong_ExactDealloc);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(tuple_st);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
}
PyStackRef_CLOSE(dict_st);
PyStackRef_CLOSE(sub_st);
- if (rc <= 0) JUMP_TO_ERROR();
+ 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;
list = stack_pointer[-2 - (oparg-1)];
int err = _PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list),
PyStackRef_AsPyObjectSteal(v));
- if (err < 0) JUMP_TO_ERROR();
+ if (err < 0) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
break;
PyStackRef_AsPyObjectBorrow(v));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
- if (err) JUMP_TO_ERROR();
+ if (err) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
break;
PyStackRef_CLOSE(v);
PyStackRef_CLOSE(container);
PyStackRef_CLOSE(sub);
- if (err) JUMP_TO_ERROR();
+ if (err) {
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
stack_pointer += -3;
assert(WITHIN_STACK_BOUNDS());
break;
assert(old_value != NULL);
UNLOCK_OBJECT(list); // unlock before decrefs!
PyStackRef_CLOSE_SPECIALIZED(sub_st, _PyLong_ExactDealloc);
- PyStackRef_CLOSE(list_st);
stack_pointer += -3;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(list_st);
Py_DECREF(old_value);
stack_pointer = _PyFrame_GetStackPointer(frame);
break;
PyStackRef_AsPyObjectSteal(sub),
PyStackRef_AsPyObjectSteal(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(dict_st);
- if (err) JUMP_TO_ERROR();
stack_pointer += -3;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(dict_st);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err) {
+ JUMP_TO_ERROR();
+ }
break;
}
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(container);
PyStackRef_CLOSE(sub);
- if (err) JUMP_TO_ERROR();
+ if (err) {
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
break;
PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
- if (res_o == NULL) JUMP_TO_ERROR();
+ if (res_o == NULL) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-1] = res;
break;
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value2_st);
PyStackRef_CLOSE(value1_st);
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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;
type->tp_name);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(obj);
- if (true) JUMP_TO_ERROR();
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
iter_o = (*getter)(obj_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(obj);
- if (iter_o == NULL) JUMP_TO_ERROR();
+ 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;
Py_TYPE(iter_o)->tp_name);
Py_DECREF(iter_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (true) JUMP_TO_ERROR();
+ JUMP_TO_ERROR();
}
iter = PyStackRef_FromPyObjectSteal(iter_o);
stack_pointer[-1] = iter;
PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(iterable);
- if (iter_o == NULL) JUMP_TO_ERROR();
+ if (iter_o == NULL) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
iter = PyStackRef_FromPyObjectSteal(iter_o);
stack_pointer[-1] = iter;
break;
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err < 0) JUMP_TO_ERROR();
+ if (err < 0) {
+ JUMP_TO_ERROR();
+ }
if (bc_o == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_SetString(tstate, PyExc_NameError,
"__build_class__ not found");
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (true) JUMP_TO_ERROR();
+ JUMP_TO_ERROR();
}
bc = PyStackRef_FromPyObjectSteal(bc_o);
stack_pointer[0] = bc;
"no locals found when storing %R", name);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
- if (true) JUMP_TO_ERROR();
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
}
if (PyDict_CheckExact(ns)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
stack_pointer = _PyFrame_GetStackPointer(frame);
}
PyStackRef_CLOSE(v);
- if (err) JUMP_TO_ERROR();
+ if (err) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
break;
int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(seq);
- if (res == 0) JUMP_TO_ERROR();
+ if (res == 0) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
stack_pointer += -1 + oparg;
assert(WITHIN_STACK_BOUNDS());
break;
int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(seq);
- if (res == 0) JUMP_TO_ERROR();
+ if (res == 0) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
stack_pointer += (oparg & 0xFF) + (oparg >> 8);
assert(WITHIN_STACK_BOUNDS());
break;
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
PyStackRef_CLOSE(owner);
- if (err) JUMP_TO_ERROR();
+ if (err) {
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
break;
int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(owner);
- if (err) JUMP_TO_ERROR();
+ if (err) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
break;
int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
- if (err) JUMP_TO_ERROR();
+ if (err) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
break;
_PyErr_SetString(tstate, PyExc_SystemError,
"no locals found");
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (true) JUMP_TO_ERROR();
+ JUMP_TO_ERROR();
}
locals = PyStackRef_FromPyObjectNew(l);
stack_pointer[0] = locals;
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *v_o = _PyEval_LoadName(tstate, frame, name);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (v_o == NULL) JUMP_TO_ERROR();
+ if (v_o == NULL) {
+ JUMP_TO_ERROR();
+ }
v = PyStackRef_FromPyObjectSteal(v_o);
stack_pointer[0] = v;
stack_pointer += 1;
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_LoadGlobalStackRef(GLOBALS(), BUILTINS(), name, res);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (PyStackRef_IsNull(*res)) JUMP_TO_ERROR();
+ if (PyStackRef_IsNull(*res)) {
+ JUMP_TO_ERROR();
+ }
stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg)
);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (1) JUMP_TO_ERROR();
+ JUMP_TO_ERROR();
}
SETLOCAL(oparg, PyStackRef_NULL);
break;
JUMP_TO_ERROR();
}
}
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(class_dict_st);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
value = PyStackRef_FromPyObjectSteal(value_o);
- stack_pointer[-1] = value;
+ stack_pointer[0] = value;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (true) JUMP_TO_ERROR();
+ JUMP_TO_ERROR();
}
value = PyStackRef_FromPyObjectSteal(value_o);
stack_pointer[0] = value;
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(pieces[_i]);
}
- if (true) JUMP_TO_ERROR();
+ 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);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(pieces[_i]);
}
- if (str_o == NULL) JUMP_TO_ERROR();
+ 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 = _PyFrame_GetStackPointer(frame);
}
PyStackRef_CLOSE(iterable_st);
- if (true) JUMP_TO_ERROR();
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
}
assert(Py_IsNone(none_val));
PyStackRef_CLOSE(iterable_st);
PyStackRef_AsPyObjectBorrow(iterable));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(iterable);
- if (err < 0) JUMP_TO_ERROR();
+ if (err < 0) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
break;
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(values[_i]);
}
- if (true) JUMP_TO_ERROR();
+ stack_pointer += -oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
}
int err = 0;
for (int i = 0; i < oparg; i++) {
_PyFrame_SetStackPointer(frame, stack_pointer);
Py_DECREF(set_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (true) JUMP_TO_ERROR();
+ JUMP_TO_ERROR();
}
set = PyStackRef_FromPyObjectSteal(set_o);
stack_pointer[-oparg] = set;
for (int _i = oparg*2; --_i >= 0;) {
PyStackRef_CLOSE(values[_i]);
}
- if (true) JUMP_TO_ERROR();
+ stack_pointer += -oparg*2;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *map_o = _PyDict_FromItems(
for (int _i = oparg*2; --_i >= 0;) {
PyStackRef_CLOSE(values[_i]);
}
- if (map_o == NULL) JUMP_TO_ERROR();
+ 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;
_PyErr_Format(tstate, PyExc_SystemError,
"no locals found when setting up annotations");
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (true) JUMP_TO_ERROR();
+ JUMP_TO_ERROR();
}
/* check if __annotations__ in locals()... */
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err < 0) JUMP_TO_ERROR();
+ if (err < 0) {
+ JUMP_TO_ERROR();
+ }
if (ann_dict == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
ann_dict = PyDict_New();
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (ann_dict == NULL) JUMP_TO_ERROR();
+ if (ann_dict == NULL) {
+ JUMP_TO_ERROR();
+ }
_PyFrame_SetStackPointer(frame, stack_pointer);
err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__),
ann_dict);
Py_DECREF(ann_dict);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err) JUMP_TO_ERROR();
+ if (err) {
+ JUMP_TO_ERROR();
+ }
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
stack_pointer = _PyFrame_GetStackPointer(frame);
}
PyStackRef_CLOSE(update);
- if (true) JUMP_TO_ERROR();
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
}
PyStackRef_CLOSE(update);
stack_pointer += -1;
_PyEval_FormatKwargsError(tstate, callable_o, update_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(update);
- if (true) JUMP_TO_ERROR();
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
}
PyStackRef_CLOSE(update);
stack_pointer += -1;
PyStackRef_AsPyObjectSteal(value)
);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) JUMP_TO_ERROR();
+ if (err != 0) {
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
break;
PyStackRef_CLOSE(global_super_st);
PyStackRef_CLOSE(class_st);
PyStackRef_CLOSE(self_st);
- if (attr == NULL) JUMP_TO_ERROR();
+ 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;
if (method_found) {
self_or_null = self_st; // transfer ownership
} else {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(self_st);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
self_or_null = PyStackRef_NULL;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
}
- PyStackRef_CLOSE(class_st);
PyStackRef_CLOSE(global_super_st);
+ PyStackRef_CLOSE(class_st);
attr = PyStackRef_FromPyObjectSteal(attr_o);
stack_pointer[-3] = attr;
stack_pointer[-2] = self_or_null;
meth | NULL | arg1 | ... | argN
*/
PyStackRef_CLOSE(owner);
- if (attr_o == NULL) JUMP_TO_ERROR();
+ if (attr_o == NULL) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
self_or_null[0] = PyStackRef_NULL;
}
}
attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(owner);
- if (attr_o == NULL) JUMP_TO_ERROR();
+ if (attr_o == NULL) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
}
attr = PyStackRef_FromPyObjectSteal(attr_o);
stack_pointer[-1] = attr;
attr = PyStackRef_FromPyObjectNew(attr_o);
#endif
STAT_INC(LOAD_ATTR, hit);
- PyStackRef_CLOSE(owner);
stack_pointer[-1] = attr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(owner);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
break;
}
attr = PyStackRef_FromPyObjectSteal(attr_o);
#endif
STAT_INC(LOAD_ATTR, hit);
- PyStackRef_CLOSE(owner);
stack_pointer[-1] = attr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(owner);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
break;
}
_PyDictValues_AddToInsertionOrder(values, index);
}
UNLOCK_OBJECT(owner_o);
- PyStackRef_CLOSE(owner);
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(owner);
Py_XDECREF(old_value);
stack_pointer = _PyFrame_GetStackPointer(frame);
break;
// old_value should be DECREFed after GC track checking is done, if not, it could raise a segmentation fault,
// when dict only holds the strong reference to value in ep->me_value.
STAT_INC(STORE_ATTR, hit);
- PyStackRef_CLOSE(owner);
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(owner);
Py_XDECREF(old_value);
stack_pointer = _PyFrame_GetStackPointer(frame);
break;
PyObject *old_value = *(PyObject **)addr;
FT_ATOMIC_STORE_PTR_RELEASE(*(PyObject **)addr, PyStackRef_AsPyObjectSteal(value));
UNLOCK_OBJECT(owner_o);
- PyStackRef_CLOSE(owner);
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(owner);
Py_XDECREF(old_value);
stack_pointer = _PyFrame_GetStackPointer(frame);
break;
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(left);
PyStackRef_CLOSE(right);
- if (res_o == NULL) JUMP_TO_ERROR();
+ if (res_o == NULL) {
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
if (oparg & 16) {
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
int res_bool = PyObject_IsTrue(res_o);
Py_DECREF(res_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (res_bool < 0) JUMP_TO_ERROR();
+ if (res_bool < 0) {
+ JUMP_TO_ERROR();
+ }
res = res_bool ? PyStackRef_True : PyStackRef_False;
}
else {
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(left);
PyStackRef_CLOSE(right);
- if (res < 0) JUMP_TO_ERROR();
+ 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 = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(left);
PyStackRef_CLOSE(right);
- if (res < 0) JUMP_TO_ERROR();
+ 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 = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(left);
PyStackRef_CLOSE(right);
- if (res < 0) JUMP_TO_ERROR();
+ 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;
if (err < 0) {
PyStackRef_CLOSE(exc_value_st);
PyStackRef_CLOSE(match_type_st);
- if (true) JUMP_TO_ERROR();
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
}
PyObject *match_o = NULL;
PyObject *rest_o = NULL;
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(exc_value_st);
PyStackRef_CLOSE(match_type_st);
- if (res < 0) JUMP_TO_ERROR();
+ if (res < 0) {
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
assert((match_o == NULL) == (rest_o == NULL));
- if (match_o == NULL) JUMP_TO_ERROR();
+ 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());
stack_pointer = _PyFrame_GetStackPointer(frame);
if (err < 0) {
PyStackRef_CLOSE(right);
- if (true) JUMP_TO_ERROR();
+ 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);
PyStackRef_CLOSE(level);
PyStackRef_CLOSE(fromlist);
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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;
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (res_o == NULL) JUMP_TO_ERROR();
+ if (res_o == NULL) {
+ JUMP_TO_ERROR();
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[0] = res;
stack_pointer += 1;
_PyFrame_SetStackPointer(frame, stack_pointer);
Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj));
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (len_i < 0) JUMP_TO_ERROR();
+ if (len_i < 0) {
+ JUMP_TO_ERROR();
+ }
PyObject *len_o = PyLong_FromSsize_t(len_i);
- if (len_o == NULL) JUMP_TO_ERROR();
+ if (len_o == NULL) {
+ JUMP_TO_ERROR();
+ }
len = PyStackRef_FromPyObjectSteal(len_o);
stack_pointer[0] = len;
stack_pointer += 1;
attrs = PyStackRef_FromPyObjectSteal(attrs_o);
}
else {
- if (_PyErr_Occurred(tstate)) JUMP_TO_ERROR();
+ if (_PyErr_Occurred(tstate)) {
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
// Error!
attrs = PyStackRef_None; // Failure!
}
PyObject *values_or_none_o = _PyEval_MatchKeys(tstate,
PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys));
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (values_or_none_o == NULL) JUMP_TO_ERROR();
+ if (values_or_none_o == NULL) {
+ JUMP_TO_ERROR();
+ }
values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o);
stack_pointer[0] = values_or_none;
stack_pointer += 1;
PyObject *iter_o = PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(iterable);
- if (iter_o == NULL) JUMP_TO_ERROR();
+ if (iter_o == NULL) {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
iter = PyStackRef_FromPyObjectSteal(iter_o);
stack_pointer[-1] = iter;
break;
r->start = value + r->step;
r->len--;
PyObject *res = PyLong_FromLong(value);
- if (res == NULL) JUMP_TO_ERROR();
+ if (res == NULL) {
+ JUMP_TO_ERROR();
+ }
next = PyStackRef_FromPyObjectSteal(res);
stack_pointer[0] = next;
stack_pointer += 1;
Py_TYPE(owner_o)->tp_name);
stack_pointer = _PyFrame_GetStackPointer(frame);
}
- if (true) JUMP_TO_ERROR();
+ JUMP_TO_ERROR();
}
attr = PyStackRef_FromPyObjectSteal(attr_o);
self_or_null = self_or_null_o == NULL ?
PyObject *res_o = PyObject_Vectorcall(exit_func_o, stack + 2 - has_self,
(3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (res_o == NULL) JUMP_TO_ERROR();
+ if (res_o == NULL) {
+ JUMP_TO_ERROR();
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[0] = res;
stack_pointer += 1;
PyObject *method = ((PyMethodObject *)callable_o)->im_func;
_PyStackRef temp = callable[0];
func[0] = PyStackRef_FromPyObjectNew(method);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(temp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
break;
}
}
case _EXPAND_METHOD: {
- _PyStackRef *null;
+ _PyStackRef *self_or_null;
_PyStackRef *callable;
- _PyStackRef *method;
- _PyStackRef *self;
oparg = CURRENT_OPARG();
- null = &stack_pointer[-1 - oparg];
+ self_or_null = &stack_pointer[-1 - oparg];
callable = &stack_pointer[-2 - oparg];
- method = &stack_pointer[-2 - oparg];
- self = &stack_pointer[-1 - oparg];
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
- assert(PyStackRef_IsNull(null[0]));
+ assert(PyStackRef_IsNull(self_or_null[0]));
assert(Py_TYPE(callable_o) == &PyMethod_Type);
- self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
+ self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
_PyStackRef temp = callable[0];
- method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
- assert(PyStackRef_FunctionCheck(method[0]));
+ callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ assert(PyStackRef_FunctionCheck(callable[0]));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(temp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
break;
}
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- if (true) JUMP_TO_ERROR();
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Vectorcall(
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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;
}
case _INIT_CALL_BOUND_METHOD_EXACT_ARGS: {
- _PyStackRef *null;
+ _PyStackRef *self_or_null;
_PyStackRef *callable;
- _PyStackRef *func;
- _PyStackRef *self;
oparg = CURRENT_OPARG();
- null = &stack_pointer[-1 - oparg];
+ self_or_null = &stack_pointer[-1 - oparg];
callable = &stack_pointer[-2 - oparg];
- func = &stack_pointer[-2 - oparg];
- self = &stack_pointer[-1 - oparg];
+ assert(PyStackRef_IsNull(self_or_null[0]));
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
STAT_INC(CALL, hit);
- self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
+ self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
_PyStackRef temp = callable[0];
- func[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(temp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
break;
}
}
STAT_INC(CALL, hit);
res = PyStackRef_FromPyObjectSteal(Py_NewRef(Py_TYPE(arg_o)));
- PyStackRef_CLOSE(arg);
stack_pointer[-3] = res;
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Str(arg_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(arg);
- if (res_o == NULL) JUMP_TO_ERROR();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (res_o == NULL) {
+ JUMP_TO_ERROR();
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-3] = res;
- stack_pointer += -2;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PySequence_Tuple(arg_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(arg);
- if (res_o == NULL) JUMP_TO_ERROR();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (res_o == NULL) {
+ JUMP_TO_ERROR();
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-3] = res;
- stack_pointer += -2;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
break;
}
self[0] = PyStackRef_FromPyObjectSteal(self_o);
_PyStackRef temp = callable[0];
init[0] = PyStackRef_FromPyObjectNew(init_func);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(temp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
break;
}
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- if (true) JUMP_TO_ERROR();
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = tp->tp_vectorcall((PyObject *)tp, args_o, total_args, NULL);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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 = _PyFrame_GetStackPointer(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(callable[0]);
- if (res_o == NULL) JUMP_TO_ERROR();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (res_o == NULL) {
+ 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;
}
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- if (true) JUMP_TO_ERROR();
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = ((PyCFunctionFast)(void(*)(void))cfunc)(
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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;
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- if (true) JUMP_TO_ERROR();
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = cfunc(PyCFunction_GET_SELF(callable_o), args_o, total_args, NULL);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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;
if (res_o == NULL) {
GOTO_ERROR(error);
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(arg_stackref);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(callable[0]);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
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;
}
STAT_INC(CALL, hit);
int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg));
UNLOCK_OBJECT(self_o);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(self);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(callable);
- if (err) JUMP_TO_ERROR();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err) {
+ JUMP_TO_ERROR();
+ }
#if TIER_ONE
// Skip the following POP_TOP. This is done here in tier one, and
// during trace projection in tier two:
assert(next_instr->op.code == POP_TOP);
SKIP_OVER(1);
#endif
- stack_pointer += -3;
- assert(WITHIN_STACK_BOUNDS());
break;
}
callable = &stack_pointer[-2 - oparg];
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
+ _PyStackRef *arguments = args;
if (!PyStackRef_IsNull(self_or_null[0])) {
- args--;
+ arguments--;
total_args++;
}
PyMethodDescrObject *method = (PyMethodDescrObject *)callable_o;
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
}
- _PyStackRef arg_stackref = args[1];
- _PyStackRef self_stackref = args[0];
+ _PyStackRef arg_stackref = arguments[1];
+ _PyStackRef self_stackref = arguments[0];
if (!Py_IS_TYPE(PyStackRef_AsPyObjectBorrow(self_stackref),
method->d_common.d_type)) {
UOP_STAT_INC(uopcode, miss);
stack_pointer = _PyFrame_GetStackPointer(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(self_stackref);
- PyStackRef_CLOSE(arg_stackref);
PyStackRef_CLOSE(callable[0]);
- if (res_o == NULL) JUMP_TO_ERROR();
+ PyStackRef_XCLOSE(self_or_null[0]);
+ for (int _i = oparg; --_i >= 0;) {
+ PyStackRef_CLOSE(args[_i]);
+ }
+ 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;
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- if (true) JUMP_TO_ERROR();
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyCFunctionFastWithKeywords cfunc =
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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 = _PyFrame_GetStackPointer(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(self_stackref);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(callable[0]);
- if (res_o == NULL) JUMP_TO_ERROR();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (res_o == NULL) {
+ 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;
}
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- if (true) JUMP_TO_ERROR();
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyCFunctionFast cfunc =
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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;
PyObject *method = ((PyMethodObject *)callable_o)->im_func;
_PyStackRef temp = callable[0];
func[0] = PyStackRef_FromPyObjectNew(method);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(temp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
kwnames_out = kwnames_in;
stack_pointer[-1] = kwnames_out;
arguments, positional_args, kwnames_o, frame
);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(kwnames);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
// The frame has stolen all the arguments from the stack,
// so there is no need to clean them up.
- stack_pointer += -3 - oparg;
+ stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
if (temp == NULL) {
JUMP_TO_ERROR();
}
case _EXPAND_METHOD_KW: {
- _PyStackRef *null;
+ _PyStackRef *self_or_null;
_PyStackRef *callable;
- _PyStackRef *method;
- _PyStackRef *self;
oparg = CURRENT_OPARG();
- null = &stack_pointer[-2 - oparg];
+ self_or_null = &stack_pointer[-2 - oparg];
callable = &stack_pointer[-3 - oparg];
- method = &stack_pointer[-3 - oparg];
- self = &stack_pointer[-2 - oparg];
+ assert(PyStackRef_IsNull(self_or_null[0]));
_PyStackRef callable_s = callable[0];
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable_s);
- assert(PyStackRef_IsNull(null[0]));
assert(Py_TYPE(callable_o) == &PyMethod_Type);
- self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
- method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
- assert(PyStackRef_FunctionCheck(method[0]));
+ self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
+ callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ assert(PyStackRef_FunctionCheck(callable[0]));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(callable_s);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
break;
}
PyStackRef_CLOSE(args[_i]);
}
PyStackRef_CLOSE(kwnames);
- if (true) JUMP_TO_ERROR();
+ stack_pointer += -3 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
}
PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames);
int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o);
positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET,
kwnames_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(kwnames);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
PyStackRef_CLOSE(callable[0]);
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- if (res_o == NULL) JUMP_TO_ERROR();
+ if (res_o == NULL) {
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ JUMP_TO_ERROR();
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-3 - oparg] = res;
- stack_pointer += -2 - oparg;
+ stack_pointer[-2 - oparg] = res;
+ stack_pointer += -1 - oparg;
assert(WITHIN_STACK_BOUNDS());
break;
}
JUMP_TO_ERROR();
}
kwargs_out = kwargs_in;
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(callargs);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
tuple = PyStackRef_FromPyObjectSteal(tuple_o);
+ stack_pointer += 2;
+ assert(WITHIN_STACK_BOUNDS());
}
stack_pointer[-2] = tuple;
stack_pointer[-1] = kwargs_out;
PyFunctionObject *func_obj = (PyFunctionObject *)
PyFunction_New(codeobj, GLOBALS());
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(codeobj_st);
- if (func_obj == NULL) JUMP_TO_ERROR();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (func_obj == NULL) {
+ JUMP_TO_ERROR();
+ }
_PyFunction_SetVersion(
func_obj, ((PyCodeObject *)codeobj)->co_version);
func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj);
- stack_pointer[-1] = func;
+ stack_pointer[0] = func;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (gen == NULL) JUMP_TO_ERROR();
+ if (gen == NULL) {
+ JUMP_TO_ERROR();
+ }
assert(EMPTY());
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyInterpreterFrame *gen_frame = &gen->gi_iframe;
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- if (slice_o == NULL) JUMP_TO_ERROR();
+ 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;
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
- if (result_o == NULL) JUMP_TO_ERROR();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (result_o == NULL) {
+ JUMP_TO_ERROR();
+ }
result = PyStackRef_FromPyObjectSteal(result_o);
- stack_pointer[-1] = result;
+ stack_pointer[0] = result;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Format(value_o, NULL);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
- if (res_o == NULL) JUMP_TO_ERROR();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (res_o == NULL) {
+ JUMP_TO_ERROR();
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
}
else {
res = value;
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
}
- stack_pointer[-1] = res;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
PyStackRef_CLOSE(fmt_spec);
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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 = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(lhs);
PyStackRef_CLOSE(rhs);
- if (res_o == NULL) JUMP_TO_ERROR();
+ 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;
}
case _SWAP: {
- _PyStackRef top_in;
- _PyStackRef bottom_in;
- _PyStackRef top_out;
- _PyStackRef bottom_out;
+ _PyStackRef *top;
+ _PyStackRef *bottom;
oparg = CURRENT_OPARG();
- top_in = stack_pointer[-1];
- bottom_in = stack_pointer[-2 - (oparg-2)];
- bottom_out = bottom_in;
- top_out = top_in;
+ top = &stack_pointer[-1];
+ bottom = &stack_pointer[-2 - (oparg-2)];
+ _PyStackRef temp = bottom[0];
+ bottom[0] = top[0];
+ top[0] = temp;
assert(oparg >= 2);
- stack_pointer[-2 - (oparg-2)] = top_out;
- stack_pointer[-1] = bottom_out;
break;
}
val = stack_pointer[-1];
int is_none = PyStackRef_IsNone(val);
if (!is_none) {
- PyStackRef_CLOSE(val);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(val);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (1) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
_PyStackRef val;
val = stack_pointer[-1];
int is_none = PyStackRef_IsNone(val);
- PyStackRef_CLOSE(val);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(val);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (is_none) {
UOP_STAT_INC(uopcode, miss);
JUMP_TO_JUMP_TARGET();
_PyStackRef value;
pop = stack_pointer[-1];
PyObject *ptr = (PyObject *)CURRENT_OPERAND0();
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(pop);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
value = PyStackRef_FromPyObjectImmortal(ptr);
- stack_pointer[-1] = value;
+ stack_pointer[0] = value;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
break;
}
case _ERROR_POP_N: {
oparg = CURRENT_OPARG();
uint32_t target = (uint32_t)CURRENT_OPERAND0();
- stack_pointer += -oparg;
- assert(WITHIN_STACK_BOUNDS());
+ assert(oparg == 0);
_PyFrame_SetStackPointer(frame, stack_pointer);
frame->instr_ptr = _PyFrame_GetBytecode(frame) + target;
stack_pointer = _PyFrame_GetStackPointer(frame);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(lhs);
PyStackRef_CLOSE(rhs);
- if (res_o == NULL) goto pop_2_error;
+ if (res_o == NULL) {
+ goto pop_2_error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
}
stack_pointer[-2] = res;
((PyFloatObject *)left_o)->ob_fval +
((PyFloatObject *)right_o)->ob_fval;
PyObject *res_o = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
- if (res_o == NULL) goto pop_2_error;
+ if (res_o == NULL) {
+ goto pop_2_error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
}
stack_pointer[-2] = res;
PyObject *res_o = _PyLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o);
PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
- if (res_o == NULL) goto pop_2_error;
+ if (res_o == NULL) {
+ goto pop_2_error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
}
stack_pointer[-2] = res;
PyObject *res_o = PyUnicode_Concat(left_o, right_o);
PyStackRef_CLOSE_SPECIALIZED(right, _PyUnicode_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
- if (res_o == NULL) goto pop_2_error;
+ if (res_o == NULL) {
+ goto pop_2_error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
}
stack_pointer[-2] = res;
PyUnicode_Append(&temp, right_o);
*target_local = PyStackRef_FromPyObjectSteal(temp);
PyStackRef_CLOSE_SPECIALIZED(right, _PyUnicode_ExactDealloc);
- if (PyStackRef_IsNull(*target_local)) goto pop_2_error;
+ if (PyStackRef_IsNull(*target_local)) {
+ goto pop_2_error;
+ }
#if TIER_ONE
// The STORE_FAST is already done. This is done here in tier one,
// and during trace projection in tier two:
((PyFloatObject *)left_o)->ob_fval *
((PyFloatObject *)right_o)->ob_fval;
PyObject *res_o = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
- if (res_o == NULL) goto pop_2_error;
+ if (res_o == NULL) {
+ goto pop_2_error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
}
stack_pointer[-2] = res;
PyObject *res_o = _PyLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o);
PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
- if (res_o == NULL) goto pop_2_error;
+ if (res_o == NULL) {
+ goto pop_2_error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
}
stack_pointer[-2] = res;
((PyFloatObject *)left_o)->ob_fval -
((PyFloatObject *)right_o)->ob_fval;
PyObject *res_o = _PyFloat_FromDouble_ConsumeInputs(left, right, dres);
- if (res_o == NULL) goto pop_2_error;
+ if (res_o == NULL) {
+ goto pop_2_error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
}
stack_pointer[-2] = res;
PyObject *res_o = _PyLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o);
PyStackRef_CLOSE_SPECIALIZED(right, _PyLong_ExactDealloc);
PyStackRef_CLOSE_SPECIALIZED(left, _PyLong_ExactDealloc);
- if (res_o == NULL) goto pop_2_error;
+ if (res_o == NULL) {
+ goto pop_2_error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
}
stack_pointer[-2] = res;
stack_pointer += 2;
assert(WITHIN_STACK_BOUNDS());
}
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(container);
- if (res_o == NULL) goto pop_3_error;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (res_o == NULL) {
+ goto error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
}
- stack_pointer[-3] = res;
- stack_pointer += -2;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(container);
PyStackRef_CLOSE(sub);
- if (res_o == NULL) goto pop_2_error;
+ if (res_o == NULL) {
+ goto pop_2_error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
}
stack_pointer[-2] = res;
}
PyStackRef_CLOSE(dict_st);
PyStackRef_CLOSE(sub_st);
- if (rc <= 0) goto pop_2_error;
+ if (rc <= 0) {
+ goto pop_2_error;
+ }
// not found or error
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2] = res;
Py_INCREF(res_o);
#endif
PyStackRef_CLOSE_SPECIALIZED(sub_st, _PyLong_ExactDealloc);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(list_st);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
STAT_INC(BINARY_SUBSCR, hit);
PyObject *res_o = (PyObject*)&_Py_SINGLETON(strings).ascii[c];
PyStackRef_CLOSE_SPECIALIZED(sub_st, _PyLong_ExactDealloc);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(str_st);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
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(res_o != NULL);
Py_INCREF(res_o);
PyStackRef_CLOSE_SPECIALIZED(sub_st, _PyLong_ExactDealloc);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(tuple_st);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
res = PyStackRef_FromPyObjectSteal(res_o);
- stack_pointer[-2] = res;
- stack_pointer += -1;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
for (int _i = oparg*2; --_i >= 0;) {
PyStackRef_CLOSE(values[_i]);
}
- {
- stack_pointer += -oparg*2;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer += -oparg*2;
+ assert(WITHIN_STACK_BOUNDS());
+ goto error;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *map_o = _PyDict_FromItems(
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(values[_i]);
}
- {
- stack_pointer += -oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer += -oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ goto error;
}
int err = 0;
for (int i = 0; i < oparg; i++) {
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(pieces[_i]);
}
- {
- stack_pointer += -oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer += -oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ goto error;
}
PyObject *str_o = _PyUnicode_JoinArray(&_Py_STR(empty), pieces_o, oparg);
STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o);
PyObject *method = ((PyMethodObject *)callable_o)->im_func;
_PyStackRef temp = callable[0];
func[0] = PyStackRef_FromPyObjectNew(method);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(temp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
}
// _DO_CALL
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ goto error;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Vectorcall(
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
+ if (err != 0) {
+ goto error;
+ }
stack_pointer += 1 + oparg;
assert(WITHIN_STACK_BOUNDS());
}
self[0] = PyStackRef_FromPyObjectSteal(self_o);
_PyStackRef temp = callable[0];
init[0] = PyStackRef_FromPyObjectNew(init_func);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(temp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
// _CREATE_INIT_FRAME
{
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
_PyStackRef *callable;
_PyStackRef *null;
- _PyStackRef *func;
- _PyStackRef *self;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyInterpreterFrame *new_frame;
}
// _INIT_CALL_BOUND_METHOD_EXACT_ARGS
{
- func = &stack_pointer[-2 - oparg];
- self = &stack_pointer[-1 - oparg];
+ self_or_null = null;
+ assert(PyStackRef_IsNull(self_or_null[0]));
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
STAT_INC(CALL, hit);
- self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
+ self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
_PyStackRef temp = callable[0];
- func[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(temp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
// flush
// _CHECK_FUNCTION_VERSION
{
- callable = &stack_pointer[-2 - oparg];
uint32_t func_version = read_u32(&this_instr[2].cache);
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
DEOPT_IF(!PyFunction_Check(callable_o), CALL);
}
// _CHECK_FUNCTION_EXACT_ARGS
{
- self_or_null = &stack_pointer[-1 - oparg];
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
assert(PyFunction_Check(callable_o));
PyFunctionObject *func = (PyFunctionObject *)callable_o;
static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size");
_PyStackRef *callable;
_PyStackRef *null;
- _PyStackRef *method;
- _PyStackRef *self;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyInterpreterFrame *new_frame;
}
// _EXPAND_METHOD
{
- method = &stack_pointer[-2 - oparg];
- self = &stack_pointer[-1 - oparg];
+ self_or_null = null;
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
- assert(PyStackRef_IsNull(null[0]));
+ assert(PyStackRef_IsNull(self_or_null[0]));
assert(Py_TYPE(callable_o) == &PyMethod_Type);
- self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
+ self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
_PyStackRef temp = callable[0];
- method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
- assert(PyStackRef_FunctionCheck(method[0]));
+ callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ assert(PyStackRef_FunctionCheck(callable[0]));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(temp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
// flush
// _PY_FRAME_GENERAL
{
args = &stack_pointer[-oparg];
- self_or_null = &stack_pointer[-1 - oparg];
- callable = &stack_pointer[-2 - oparg];
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
// oparg counts all of the args, but *not* self:
int total_args = oparg;
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ goto error;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = tp->tp_vectorcall((PyObject *)tp, args_o, total_args, NULL);
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
+ if (err != 0) {
+ goto error;
+ }
stack_pointer += 1 + oparg;
assert(WITHIN_STACK_BOUNDS());
}
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ goto error;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = ((PyCFunctionFast)(void(*)(void))cfunc)(
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
+ if (err != 0) {
+ goto error;
+ }
stack_pointer += 1 + oparg;
assert(WITHIN_STACK_BOUNDS());
}
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ goto error;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = cfunc(PyCFunction_GET_SELF(callable_o), args_o, total_args, NULL);
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
+ if (err != 0) {
+ goto error;
+ }
stack_pointer += 1 + oparg;
assert(WITHIN_STACK_BOUNDS());
}
stack_pointer = _PyFrame_GetStackPointer(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(callable[0]);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
goto 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);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
- stack_pointer += 1 + oparg;
+ if (err != 0) {
+ goto error;
+ }
+ 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();
}
_PyStackRef tuple;
_PyStackRef kwargs_out;
_PyStackRef func_st;
+ _PyStackRef null;
_PyStackRef callargs_st;
_PyStackRef kwargs_st;
_PyStackRef result;
goto error;
}
kwargs_out = kwargs_in;
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(callargs);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
tuple = PyStackRef_FromPyObjectSteal(tuple_o);
+ stack_pointer += 2;
+ assert(WITHIN_STACK_BOUNDS());
}
}
// _DO_CALL_FUNCTION_EX
{
kwargs_st = kwargs_out;
callargs_st = tuple;
+ null = stack_pointer[-3];
func_st = func;
+ (void)null;
PyObject *func = PyStackRef_AsPyObjectBorrow(func_st);
// DICT_MERGE is called before this opcode if there are kwargs.
// It converts all dict subtypes in kwargs into regular dicts.
Py_ssize_t nargs = PyTuple_GET_SIZE(callargs);
int code_flags = ((PyCodeObject *)PyFunction_GET_CODE(func))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func));
- stack_pointer += -3;
+ stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(
nargs, callargs, kwargs, frame);
stack_pointer = _PyFrame_GetStackPointer(frame);
// Need to sync the stack since we exit with DISPATCH_INLINED.
- stack_pointer += -1;
+ stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
if (new_frame == NULL) {
goto error;
result_o = PyObject_Call(func, callargs, kwargs);
stack_pointer = _PyFrame_GetStackPointer(frame);
}
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_XCLOSE(kwargs_st);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(callargs_st);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(func_st);
- if (result_o == NULL) goto pop_4_error;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (result_o == NULL) {
+ goto error;
+ }
result = PyStackRef_FromPyObjectSteal(result_o);
}
// _CHECK_PERIODIC
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
- stack_pointer[-4] = result;
- stack_pointer += -3;
+ stack_pointer[0] = result;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
- stack_pointer += 3;
+ if (err != 0) {
+ goto error;
+ }
+ stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
}
}
- stack_pointer[-4] = result;
- stack_pointer += -3;
+ stack_pointer[0] = result;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
- if (res_o == NULL) goto pop_1_error;
+ if (res_o == NULL) {
+ goto pop_1_error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-1] = res;
DISPATCH();
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value2_st);
PyStackRef_CLOSE(value1_st);
- if (res_o == NULL) goto pop_2_error;
+ if (res_o == NULL) {
+ goto pop_2_error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2] = res;
stack_pointer += -1;
PyObject *method = ((PyMethodObject *)callable_o)->im_func;
_PyStackRef temp = callable[0];
func[0] = PyStackRef_FromPyObjectNew(method);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(temp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
kwnames_out = kwnames_in;
}
arguments, positional_args, kwnames_o, frame
);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(kwnames);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
// Sync stack explicitly since we leave using DISPATCH_INLINED().
- stack_pointer += -3 - oparg;
+ stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
// The frame has stolen all the arguments from the stack,
// so there is no need to clean them up.
PyStackRef_CLOSE(args[_i]);
}
PyStackRef_CLOSE(kwnames);
- {
- stack_pointer += -3 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer += -3 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ goto error;
}
stack_pointer[-1] = kwnames;
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyStackRef *callable;
_PyStackRef *null;
_PyStackRef kwnames;
- _PyStackRef *method;
- _PyStackRef *self;
_PyStackRef *self_or_null;
_PyStackRef *args;
_PyInterpreterFrame *new_frame;
}
// _EXPAND_METHOD_KW
{
- method = &stack_pointer[-3 - oparg];
- self = &stack_pointer[-2 - oparg];
+ self_or_null = null;
+ assert(PyStackRef_IsNull(self_or_null[0]));
_PyStackRef callable_s = callable[0];
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable_s);
- assert(PyStackRef_IsNull(null[0]));
assert(Py_TYPE(callable_o) == &PyMethod_Type);
- self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
- method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
- assert(PyStackRef_FunctionCheck(method[0]));
+ self_or_null[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self);
+ callable[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func);
+ assert(PyStackRef_FunctionCheck(callable[0]));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(callable_s);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
// flush
// _PY_FRAME_KW
{
kwnames = stack_pointer[-1];
args = &stack_pointer[-1 - oparg];
- self_or_null = &stack_pointer[-2 - oparg];
- callable = &stack_pointer[-3 - oparg];
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
// oparg counts all of the args, but *not* self:
int total_args = oparg;
arguments, positional_args, kwnames_o, frame
);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(kwnames);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
// The frame has stolen all the arguments from the stack,
// so there is no need to clean them up.
- stack_pointer += -3 - oparg;
+ stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
if (temp == NULL) {
goto error;
PyStackRef_CLOSE(args[_i]);
}
PyStackRef_CLOSE(kwnames);
- {
- stack_pointer += -3 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer += -3 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ goto error;
}
PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames);
int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o);
positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET,
kwnames_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(kwnames);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
STACKREFS_TO_PYOBJECTS_CLEANUP(args_o);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
PyStackRef_CLOSE(callable[0]);
PyStackRef_CLOSE(args[_i]);
}
if (res_o == NULL) {
- stack_pointer += -3 - oparg;
+ stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
goto error;
}
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
- stack_pointer[-3 - oparg] = res;
- stack_pointer += -2 - oparg;
+ stack_pointer[-2 - oparg] = res;
+ stack_pointer += -1 - oparg;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
- stack_pointer += 2 + oparg;
+ if (err != 0) {
+ goto error;
+ }
+ stack_pointer += 1 + oparg;
assert(WITHIN_STACK_BOUNDS());
}
}
- stack_pointer[-3 - oparg] = res;
- stack_pointer += -2 - oparg;
+ stack_pointer[-2 - oparg] = res;
+ stack_pointer += -1 - oparg;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
arguments, positional_args, kwnames_o, frame
);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(kwnames);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
// The frame has stolen all the arguments from the stack,
// so there is no need to clean them up.
- stack_pointer += -3 - oparg;
+ stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
if (temp == NULL) {
goto error;
if (res_o == NULL) {
GOTO_ERROR(error);
}
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(arg_stackref);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(callable[0]);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
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());
DISPATCH();
}
STAT_INC(CALL, hit);
int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg));
UNLOCK_OBJECT(self_o);
+ stack_pointer += -2;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(self);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(callable);
- if (err) goto pop_3_error;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err) {
+ goto error;
+ }
#if TIER_ONE
// Skip the following POP_TOP. This is done here in tier one, and
// during trace projection in tier two:
assert(next_instr->op.code == POP_TOP);
SKIP_OVER(1);
#endif
- stack_pointer += -3;
- assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ goto error;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyCFunctionFast cfunc =
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
+ if (err != 0) {
+ goto error;
+ }
stack_pointer += 1 + oparg;
assert(WITHIN_STACK_BOUNDS());
}
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ goto error;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyCFunctionFastWithKeywords cfunc =
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
+ if (err != 0) {
+ goto error;
+ }
stack_pointer += 1 + oparg;
assert(WITHIN_STACK_BOUNDS());
}
stack_pointer = _PyFrame_GetStackPointer(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(self_stackref);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(callable[0]);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
if (res_o == NULL) {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
goto 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);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
- stack_pointer += 1 + oparg;
+ if (err != 0) {
+ goto error;
+ }
+ 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 = &stack_pointer[-2 - oparg];
PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]);
int total_args = oparg;
+ _PyStackRef *arguments = args;
if (!PyStackRef_IsNull(self_or_null[0])) {
- args--;
+ arguments--;
total_args++;
}
PyMethodDescrObject *method = (PyMethodDescrObject *)callable_o;
DEOPT_IF(meth->ml_flags != METH_O, CALL);
// CPython promises to check all non-vectorcall function calls.
DEOPT_IF(tstate->c_recursion_remaining <= 0, CALL);
- _PyStackRef arg_stackref = args[1];
- _PyStackRef self_stackref = args[0];
+ _PyStackRef arg_stackref = arguments[1];
+ _PyStackRef self_stackref = arguments[0];
DEOPT_IF(!Py_IS_TYPE(PyStackRef_AsPyObjectBorrow(self_stackref),
method->d_common.d_type), CALL);
STAT_INC(CALL, hit);
stack_pointer = _PyFrame_GetStackPointer(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
- PyStackRef_CLOSE(self_stackref);
- PyStackRef_CLOSE(arg_stackref);
PyStackRef_CLOSE(callable[0]);
+ PyStackRef_XCLOSE(self_or_null[0]);
+ for (int _i = oparg; --_i >= 0;) {
+ PyStackRef_CLOSE(args[_i]);
+ }
if (res_o == NULL) {
stack_pointer += -2 - oparg;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
+ if (err != 0) {
+ goto error;
+ }
stack_pointer += 1 + oparg;
assert(WITHIN_STACK_BOUNDS());
}
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ goto error;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Vectorcall(
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
+ if (err != 0) {
+ goto error;
+ }
stack_pointer += 1 + oparg;
assert(WITHIN_STACK_BOUNDS());
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Str(arg_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(arg);
- if (res_o == NULL) goto pop_3_error;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (res_o == NULL) {
+ goto error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
}
// _CHECK_PERIODIC
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
- stack_pointer[-3] = res;
- stack_pointer += -2;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
- stack_pointer += 2;
+ if (err != 0) {
+ goto error;
+ }
+ stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
}
}
- stack_pointer[-3] = res;
- stack_pointer += -2;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PySequence_Tuple(arg_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -3;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(arg);
- if (res_o == NULL) goto pop_3_error;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (res_o == NULL) {
+ goto error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
}
// _CHECK_PERIODIC
_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY();
QSBR_QUIESCENT_STATE(tstate);
if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {
- stack_pointer[-3] = res;
- stack_pointer += -2;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
- stack_pointer += 2;
+ if (err != 0) {
+ goto error;
+ }
+ stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
}
}
- stack_pointer[-3] = res;
- stack_pointer += -2;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
DEOPT_IF(callable_o != (PyObject *)&PyType_Type, CALL);
STAT_INC(CALL, hit);
res = PyStackRef_FromPyObjectSteal(Py_NewRef(Py_TYPE(arg_o)));
- PyStackRef_CLOSE(arg);
stack_pointer[-3] = res;
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(arg);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH();
}
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(exc_value_st);
PyStackRef_CLOSE(match_type_st);
- if (res < 0) goto pop_2_error;
+ if (res < 0) {
+ goto pop_2_error;
+ }
assert((match_o == NULL) == (rest_o == NULL));
- if (match_o == NULL) goto pop_2_error;
+ if (match_o == NULL) {
+ goto pop_2_error;
+ }
if (!Py_IsNone(match_o)) {
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(left);
PyStackRef_CLOSE(right);
- if (res_o == NULL) goto pop_2_error;
+ if (res_o == NULL) {
+ goto pop_2_error;
+ }
if (oparg & 16) {
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
int res_bool = PyObject_IsTrue(res_o);
Py_DECREF(res_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (res_bool < 0) goto error;
+ if (res_bool < 0) {
+ goto error;
+ }
res = res_bool ? PyStackRef_True : PyStackRef_False;
}
else {
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(left);
PyStackRef_CLOSE(right);
- if (res < 0) goto pop_2_error;
+ if (res < 0) {
+ goto pop_2_error;
+ }
b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;
}
stack_pointer[-2] = b;
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(left);
PyStackRef_CLOSE(right);
- if (res < 0) goto pop_2_error;
+ if (res < 0) {
+ goto pop_2_error;
+ }
b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;
stack_pointer[-2] = b;
stack_pointer += -1;
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(left);
PyStackRef_CLOSE(right);
- if (res < 0) goto pop_2_error;
+ if (res < 0) {
+ goto pop_2_error;
+ }
b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;
stack_pointer[-2] = b;
stack_pointer += -1;
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
- if (result_o == NULL) goto pop_1_error;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (result_o == NULL) {
+ goto error;
+ }
result = PyStackRef_FromPyObjectSteal(result_o);
- stack_pointer[-1] = result;
+ stack_pointer[0] = result;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(owner);
- if (err) goto pop_1_error;
+ if (err) {
+ goto pop_1_error;
+ }
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(container);
PyStackRef_CLOSE(sub);
- if (err) goto pop_2_error;
+ if (err) {
+ goto pop_2_error;
+ }
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
* This has the benign side effect that if value is
* finalized it will see the location as the FOR_ITER's.
*/
- PyStackRef_CLOSE(value);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(value);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Format(value_o, NULL);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value);
- if (res_o == NULL) goto pop_1_error;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (res_o == NULL) {
+ goto error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
}
else {
res = value;
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
}
- stack_pointer[-1] = res;
+ stack_pointer[0] = res;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
PyStackRef_CLOSE(fmt_spec);
- if (res_o == NULL) goto pop_2_error;
+ if (res_o == NULL) {
+ goto pop_2_error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2] = res;
stack_pointer += -1;
r->start = value + r->step;
r->len--;
PyObject *res = PyLong_FromLong(value);
- if (res == NULL) goto error;
+ if (res == NULL) {
+ goto error;
+ }
next = PyStackRef_FromPyObjectSteal(res);
}
stack_pointer[0] = next;
iter_o = (*getter)(obj_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(obj);
- if (iter_o == NULL) goto pop_1_error;
+ if (iter_o == NULL) {
+ goto pop_1_error;
+ }
if (Py_TYPE(iter_o)->tp_as_async == NULL ||
Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) {
stack_pointer += -1;
PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(iterable);
- if (iter_o == NULL) goto pop_1_error;
+ if (iter_o == NULL) {
+ goto pop_1_error;
+ }
iter = PyStackRef_FromPyObjectSteal(iter_o);
stack_pointer[-1] = iter;
DISPATCH();
PyObject *iter_o = PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(iterable);
- if (iter_o == NULL) goto pop_1_error;
+ if (iter_o == NULL) {
+ goto pop_1_error;
+ }
iter = PyStackRef_FromPyObjectSteal(iter_o);
stack_pointer[-1] = iter;
DISPATCH();
_PyFrame_SetStackPointer(frame, stack_pointer);
Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj));
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (len_i < 0) goto error;
+ if (len_i < 0) {
+ goto error;
+ }
PyObject *len_o = PyLong_FromSsize_t(len_i);
- if (len_o == NULL) goto error;
+ if (len_o == NULL) {
+ goto error;
+ }
len = PyStackRef_FromPyObjectSteal(len_o);
stack_pointer[0] = len;
stack_pointer += 1;
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (res_o == NULL) goto error;
+ if (res_o == NULL) {
+ goto error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[0] = res;
stack_pointer += 1;
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(level);
PyStackRef_CLOSE(fromlist);
- if (res_o == NULL) goto pop_2_error;
+ if (res_o == NULL) {
+ goto pop_2_error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2] = res;
stack_pointer += -1;
PyObject *method = ((PyMethodObject *)callable_o)->im_func;
_PyStackRef temp = callable[0];
func[0] = PyStackRef_FromPyObjectNew(method);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(temp);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
}
// _MONITOR_CALL
frame, this_instr, function, arg0
);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err) goto error;
+ if (err) {
+ goto error;
+ }
}
// _DO_CALL
{
for (int _i = oparg; --_i >= 0;) {
PyStackRef_CLOSE(args[_i]);
}
- {
- stack_pointer += -2 - oparg;
- assert(WITHIN_STACK_BOUNDS());
- goto error;
- }
+ stack_pointer += -2 - oparg;
+ assert(WITHIN_STACK_BOUNDS());
+ goto error;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *res_o = PyObject_Vectorcall(
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
+ if (err != 0) {
+ goto error;
+ }
stack_pointer += 1 + oparg;
assert(WITHIN_STACK_BOUNDS());
}
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, function, arg);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err) goto error;
+ if (err) {
+ goto error;
+ }
PAUSE_ADAPTIVE_COUNTER(this_instr[1].counter);
goto PREDICTED_CALL_KW;
}
}
}
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();
}
int next_opcode = _Py_call_instrumentation_instruction(
tstate, frame, this_instr);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (next_opcode < 0) goto error;
+ if (next_opcode < 0) {
+ goto error;
+ }
next_instr = this_instr;
if (_PyOpcode_Caches[next_opcode]) {
PAUSE_ADAPTIVE_COUNTER(next_instr[1].counter);
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
+ if (err != 0) {
+ goto error;
+ }
}
}
// _MONITOR_JUMP_BACKWARD
_PyStackRef iter;
iter = stack_pointer[-1];
INSTRUMENTED_JUMP(prev_instr, this_instr+1, PY_MONITORING_EVENT_BRANCH_RIGHT);
- PyStackRef_CLOSE(iter);
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(iter);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH();
}
INSTRUMENTED_JUMP(this_instr, next_instr + oparg, PY_MONITORING_EVENT_BRANCH_RIGHT);
}
else {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value_stackref);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
DISPATCH();
}
int jump = !PyStackRef_IsNone(value_stackref);
RECORD_BRANCH_TAKEN(this_instr[1].cache, jump);
if (jump) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(value_stackref);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
INSTRUMENTED_JUMP(this_instr, next_instr + oparg, PY_MONITORING_EVENT_BRANCH_RIGHT);
}
DISPATCH();
_Py_CODEUNIT *bytecode =
_PyEval_GetExecutableCode(tstate, _PyFrame_GetCode(frame));
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (bytecode == NULL) goto error;
+ if (bytecode == NULL) {
+ goto error;
+ }
_PyFrame_SetStackPointer(frame, stack_pointer);
ptrdiff_t off = this_instr - _PyFrame_GetBytecode(frame);
stack_pointer = _PyFrame_GetStackPointer(frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
+ if (err != 0) {
+ goto error;
+ }
}
}
}
int err = _Py_call_instrumentation(
tstate, oparg > 0, frame, this_instr);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err) goto error;
+ if (err) {
+ goto error;
+ }
if (frame->instr_ptr != this_instr) {
/* Instrumentation has jumped */
next_instr = frame->instr_ptr;
tstate, PY_MONITORING_EVENT_PY_RETURN,
frame, this_instr, PyStackRef_AsPyObjectBorrow(val));
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err) goto error;
+ if (err) {
+ goto error;
+ }
}
// _RETURN_VALUE
{
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
+ if (err != 0) {
+ goto error;
+ }
}
}
// _JUMP_BACKWARD_NO_INTERRUPT
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
+ if (err != 0) {
+ goto error;
+ }
}
}
// _JUMP_BACKWARD_NO_INTERRUPT
stack_pointer = _PyFrame_GetStackPointer(frame);
if (optimized <= 0) {
this_instr[1].counter = restart_backoff_counter(counter);
- if (optimized < 0) goto error;
+ if (optimized < 0) {
+ goto error;
+ }
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
+ if (err != 0) {
+ goto error;
+ }
}
}
// _JUMP_BACKWARD_NO_INTERRUPT
list = stack_pointer[-2 - (oparg-1)];
int err = _PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list),
PyStackRef_AsPyObjectSteal(v));
- if (err < 0) goto pop_1_error;
+ if (err < 0) {
+ goto pop_1_error;
+ }
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
meth | NULL | arg1 | ... | argN
*/
PyStackRef_CLOSE(owner);
- if (attr_o == NULL) goto pop_1_error;
+ if (attr_o == NULL) {
+ goto pop_1_error;
+ }
self_or_null[0] = PyStackRef_NULL;
}
}
attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(owner);
- if (attr_o == NULL) goto pop_1_error;
+ if (attr_o == NULL) {
+ goto pop_1_error;
+ }
}
attr = PyStackRef_FromPyObjectSteal(attr_o);
}
attr = PyStackRef_FromPyObjectNew(attr_o);
#endif
STAT_INC(LOAD_ATTR, hit);
+ stack_pointer[-1] = attr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
/* 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());
attr = PyStackRef_FromPyObjectSteal(attr_o);
#endif
STAT_INC(LOAD_ATTR, hit);
+ stack_pointer[-1] = attr;
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(owner);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
}
/* 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(BUILTINS(), &_Py_ID(__build_class__), &bc_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err < 0) goto error;
+ if (err < 0) {
+ goto error;
+ }
if (bc_o == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyErr_SetString(tstate, PyExc_NameError,
goto error;
}
}
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(class_dict_st);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
value = PyStackRef_FromPyObjectSteal(value_o);
- stack_pointer[-1] = value;
+ stack_pointer[0] = value;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
int err = PyMapping_GetOptionalItem(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &v_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(mod_or_class_dict);
- if (err < 0) goto pop_1_error;
+ if (err < 0) {
+ goto pop_1_error;
+ }
if (v_o == NULL) {
if (PyDict_CheckExact(GLOBALS())
&& PyDict_CheckExact(BUILTINS()))
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyMapping_GetOptionalItem(GLOBALS(), name, &v_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err < 0) goto error;
+ if (err < 0) {
+ goto error;
+ }
if (v_o == NULL) {
/* namespace 2: builtins */
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyMapping_GetOptionalItem(BUILTINS(), name, &v_o);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err < 0) goto error;
+ if (err < 0) {
+ goto error;
+ }
if (v_o == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_FormatExcCheckArg(
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyEval_LoadGlobalStackRef(GLOBALS(), BUILTINS(), name, res);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (PyStackRef_IsNull(*res)) goto error;
+ if (PyStackRef_IsNull(*res)) {
+ goto error;
+ }
}
// _PUSH_NULL_CONDITIONAL
{
_PyFrame_SetStackPointer(frame, stack_pointer);
PyObject *v_o = _PyEval_LoadName(tstate, frame, name);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (v_o == NULL) goto error;
+ if (v_o == NULL) {
+ goto error;
+ }
v = PyStackRef_FromPyObjectSteal(v_o);
stack_pointer[0] = v;
stack_pointer += 1;
PyStackRef_CLOSE(global_super_st);
PyStackRef_CLOSE(class_st);
PyStackRef_CLOSE(self_st);
- if (super == NULL) goto pop_3_error;
+ if (super == NULL) {
+ goto pop_3_error;
+ }
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);
stack_pointer += -3;
assert(WITHIN_STACK_BOUNDS());
PyObject *attr_o = PyObject_GetAttr(super, name);
Py_DECREF(super);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (attr_o == NULL) goto error;
+ if (attr_o == NULL) {
+ goto error;
+ }
attr = PyStackRef_FromPyObjectSteal(attr_o);
}
// _PUSH_NULL_CONDITIONAL
PyStackRef_CLOSE(global_super_st);
PyStackRef_CLOSE(class_st);
PyStackRef_CLOSE(self_st);
- if (attr == NULL) goto pop_3_error;
+ if (attr == NULL) {
+ goto pop_3_error;
+ }
attr_st = PyStackRef_FromPyObjectSteal(attr);
stack_pointer[-3] = attr_st;
stack_pointer += -2;
if (method_found) {
self_or_null = self_st; // transfer ownership
} else {
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(self_st);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
self_or_null = PyStackRef_NULL;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
}
- PyStackRef_CLOSE(class_st);
PyStackRef_CLOSE(global_super_st);
+ PyStackRef_CLOSE(class_st);
attr = PyStackRef_FromPyObjectSteal(attr_o);
stack_pointer[-3] = attr;
stack_pointer[-2] = self_or_null;
PyFunctionObject *func_obj = (PyFunctionObject *)
PyFunction_New(codeobj, GLOBALS());
stack_pointer = _PyFrame_GetStackPointer(frame);
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(codeobj_st);
- if (func_obj == NULL) goto pop_1_error;
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (func_obj == NULL) {
+ goto error;
+ }
_PyFunction_SetVersion(
func_obj, ((PyCodeObject *)codeobj)->co_version);
func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj);
- stack_pointer[-1] = func;
+ stack_pointer[0] = func;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
PyStackRef_AsPyObjectSteal(value)
);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto pop_2_error;
+ if (err != 0) {
+ goto pop_2_error;
+ }
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
attrs = PyStackRef_FromPyObjectSteal(attrs_o);
}
else {
- if (_PyErr_Occurred(tstate)) goto pop_3_error;
+ if (_PyErr_Occurred(tstate)) {
+ goto pop_3_error;
+ }
// Error!
attrs = PyStackRef_None; // Failure!
}
PyObject *values_or_none_o = _PyEval_MatchKeys(tstate,
PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys));
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (values_or_none_o == NULL) goto error;
+ if (values_or_none_o == NULL) {
+ goto error;
+ }
values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o);
stack_pointer[0] = values_or_none;
stack_pointer += 1;
_Py_CODEUNIT *bytecode =
_PyEval_GetExecutableCode(tstate, _PyFrame_GetCode(frame));
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (bytecode == NULL) goto error;
+ if (bytecode == NULL) {
+ goto error;
+ }
_PyFrame_SetStackPointer(frame, stack_pointer);
ptrdiff_t off = this_instr - _PyFrame_GetBytecode(frame);
stack_pointer = _PyFrame_GetStackPointer(frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = _Py_HandlePending(tstate);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err != 0) goto error;
+ if (err != 0) {
+ goto error;
+ }
}
}
}
_PyFrame_SetStackPointer(frame, stack_pointer);
PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (gen == NULL) goto error;
+ if (gen == NULL) {
+ goto error;
+ }
assert(EMPTY());
_PyFrame_SetStackPointer(frame, stack_pointer);
_PyInterpreterFrame *gen_frame = &gen->gi_iframe;
goto pop_1_error;
}
}
+ stack_pointer += -1;
+ assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_CLOSE(v);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
retval = PyStackRef_FromPyObjectSteal(retval_o);
}
- stack_pointer[-1] = retval;
+ stack_pointer[0] = retval;
+ stack_pointer += 1;
+ assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
int err = PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err < 0) goto error;
+ if (err < 0) {
+ goto error;
+ }
if (ann_dict == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
ann_dict = PyDict_New();
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (ann_dict == NULL) goto error;
+ if (ann_dict == NULL) {
+ goto error;
+ }
_PyFrame_SetStackPointer(frame, stack_pointer);
err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__),
ann_dict);
Py_DECREF(ann_dict);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (err) goto error;
+ if (err) {
+ goto error;
+ }
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
PyStackRef_AsPyObjectBorrow(v));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
- if (err) goto pop_1_error;
+ if (err) {
+ goto pop_1_error;
+ }
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
PyStackRef_AsPyObjectBorrow(iterable));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(iterable);
- if (err < 0) goto pop_1_error;
+ if (err < 0) {
+ goto pop_1_error;
+ }
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
PyStackRef_CLOSE(owner);
- if (err) goto pop_2_error;
+ if (err) {
+ goto pop_2_error;
+ }
}
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
_PyDictValues_AddToInsertionOrder(values, index);
}
UNLOCK_OBJECT(owner_o);
- PyStackRef_CLOSE(owner);
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(owner);
Py_XDECREF(old_value);
stack_pointer = _PyFrame_GetStackPointer(frame);
}
PyObject *old_value = *(PyObject **)addr;
FT_ATOMIC_STORE_PTR_RELEASE(*(PyObject **)addr, PyStackRef_AsPyObjectSteal(value));
UNLOCK_OBJECT(owner_o);
- PyStackRef_CLOSE(owner);
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(owner);
Py_XDECREF(old_value);
stack_pointer = _PyFrame_GetStackPointer(frame);
}
// old_value should be DECREFed after GC track checking is done, if not, it could raise a segmentation fault,
// when dict only holds the strong reference to value in ep->me_value.
STAT_INC(STORE_ATTR, hit);
- PyStackRef_CLOSE(owner);
stack_pointer += -2;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(owner);
Py_XDECREF(old_value);
stack_pointer = _PyFrame_GetStackPointer(frame);
}
int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(v);
- if (err) goto pop_1_error;
+ if (err) {
+ goto pop_1_error;
+ }
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
stack_pointer = _PyFrame_GetStackPointer(frame);
}
PyStackRef_CLOSE(v);
- if (err) goto pop_1_error;
+ if (err) {
+ goto pop_1_error;
+ }
stack_pointer += -1;
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
}
PyStackRef_CLOSE(v);
PyStackRef_CLOSE(container);
- if (err) goto pop_4_error;
+ if (err) {
+ goto pop_4_error;
+ }
}
stack_pointer += -4;
assert(WITHIN_STACK_BOUNDS());
PyStackRef_CLOSE(v);
PyStackRef_CLOSE(container);
PyStackRef_CLOSE(sub);
- if (err) goto pop_3_error;
+ if (err) {
+ goto pop_3_error;
+ }
}
stack_pointer += -3;
assert(WITHIN_STACK_BOUNDS());
PyStackRef_AsPyObjectSteal(sub),
PyStackRef_AsPyObjectSteal(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
- PyStackRef_CLOSE(dict_st);
- if (err) goto pop_3_error;
stack_pointer += -3;
assert(WITHIN_STACK_BOUNDS());
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(dict_st);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ if (err) {
+ goto error;
+ }
DISPATCH();
}
assert(old_value != NULL);
UNLOCK_OBJECT(list); // unlock before decrefs!
PyStackRef_CLOSE_SPECIALIZED(sub_st, _PyLong_ExactDealloc);
- PyStackRef_CLOSE(list_st);
stack_pointer += -3;
assert(WITHIN_STACK_BOUNDS());
_PyFrame_SetStackPointer(frame, stack_pointer);
+ PyStackRef_CLOSE(list_st);
Py_DECREF(old_value);
stack_pointer = _PyFrame_GetStackPointer(frame);
DISPATCH();
frame->instr_ptr = next_instr;
next_instr += 1;
INSTRUCTION_STATS(SWAP);
- _PyStackRef bottom_in;
- _PyStackRef top_in;
- _PyStackRef top_out;
- _PyStackRef bottom_out;
- top_in = stack_pointer[-1];
- bottom_in = stack_pointer[-2 - (oparg-2)];
- bottom_out = bottom_in;
- top_out = top_in;
+ _PyStackRef *bottom;
+ _PyStackRef *top;
+ top = &stack_pointer[-1];
+ bottom = &stack_pointer[-2 - (oparg-2)];
+ _PyStackRef temp = bottom[0];
+ bottom[0] = top[0];
+ top[0] = temp;
assert(oparg >= 2);
- stack_pointer[-2 - (oparg-2)] = top_out;
- stack_pointer[-1] = bottom_out;
DISPATCH();
}
int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
- if (err < 0) goto pop_1_error;
+ if (err < 0) {
+ goto pop_1_error;
+ }
res = err ? PyStackRef_True : PyStackRef_False;
}
stack_pointer[-1] = res;
PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
- if (res_o == NULL) goto pop_1_error;
+ if (res_o == NULL) {
+ goto pop_1_error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-1] = res;
DISPATCH();
PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value));
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(value);
- if (res_o == NULL) goto pop_1_error;
+ if (res_o == NULL) {
+ goto pop_1_error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-1] = res;
DISPATCH();
int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(seq);
- if (res == 0) goto pop_1_error;
+ if (res == 0) {
+ goto pop_1_error;
+ }
stack_pointer += (oparg & 0xFF) + (oparg >> 8);
assert(WITHIN_STACK_BOUNDS());
DISPATCH();
int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top);
stack_pointer = _PyFrame_GetStackPointer(frame);
PyStackRef_CLOSE(seq);
- if (res == 0) goto pop_1_error;
+ if (res == 0) {
+ goto pop_1_error;
+ }
}
stack_pointer += -1 + oparg;
assert(WITHIN_STACK_BOUNDS());
PyObject *res_o = PyObject_Vectorcall(exit_func_o, stack + 2 - has_self,
(3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
stack_pointer = _PyFrame_GetStackPointer(frame);
- if (res_o == NULL) goto error;
+ if (res_o == NULL) {
+ goto error;
+ }
res = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[0] = res;
stack_pointer += 1;
pop_4_error:
{
- STACK_SHRINK(1);
- goto pop_3_error;
+ STACK_SHRINK(4);
+ goto error;
}
pop_3_error:
{
- STACK_SHRINK(1);
- goto pop_2_error;
+ STACK_SHRINK(3);
+ goto error;
}
pop_2_error:
{
- STACK_SHRINK(1);
- goto pop_1_error;
+ STACK_SHRINK(2);
+ goto error;
}
pop_1_error:
current_error = next_spare;
current_error_target = target;
make_exit(&buffer[next_spare], _ERROR_POP_N, 0);
- buffer[next_spare].oparg = popped;
buffer[next_spare].operand0 = target;
next_spare++;
}
top = bottom;
}
- op(_SWAP, (bottom_in, unused[oparg-2], top_in --
- top_out, unused[oparg-2], bottom_out)) {
- bottom_out = bottom_in;
- top_out = top_in;
+ op(_SWAP, (bottom[1], unused[oparg-2], top[1] -- bottom[1], unused[oparg-2], top[1])) {
+ JitOptSymbol *temp = bottom[0];
+ bottom[0] = top[0];
+ top[0] = temp;
+ assert(oparg >= 2);
}
op(_LOAD_ATTR_INSTANCE_VALUE, (offset/1, owner -- attr)) {
ctx->done = true;
}
- op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable, unused, unused[oparg] -- func, self, unused[oparg])) {
+ op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable[1], self_or_null[1], unused[oparg] -- callable[1], self_or_null[1], unused[oparg])) {
(void)callable;
- func = sym_new_not_null(ctx);
- self = sym_new_not_null(ctx);
+ callable[0] = sym_new_not_null(ctx);
+ self_or_null[0] = sym_new_not_null(ctx);
}
op(_CHECK_FUNCTION_VERSION, (func_version/2, callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) {
}
case _EXPAND_METHOD: {
- JitOptSymbol **method;
- JitOptSymbol **self;
- method = &stack_pointer[-2 - oparg];
- self = &stack_pointer[-1 - oparg];
- method[0] = sym_new_not_null(ctx);
- self[0] = sym_new_not_null(ctx);
break;
}
}
case _INIT_CALL_BOUND_METHOD_EXACT_ARGS: {
- JitOptSymbol *callable;
- JitOptSymbol *func;
- JitOptSymbol *self;
- callable = stack_pointer[-2 - oparg];
+ JitOptSymbol **self_or_null;
+ JitOptSymbol **callable;
+ self_or_null = &stack_pointer[-1 - oparg];
+ callable = &stack_pointer[-2 - oparg];
(void)callable;
- func = sym_new_not_null(ctx);
- self = sym_new_not_null(ctx);
- stack_pointer[-2 - oparg] = func;
- stack_pointer[-1 - oparg] = self;
+ callable[0] = sym_new_not_null(ctx);
+ self_or_null[0] = sym_new_not_null(ctx);
break;
}
}
case _EXPAND_METHOD_KW: {
- JitOptSymbol **method;
- JitOptSymbol **self;
- method = &stack_pointer[-3 - oparg];
- self = &stack_pointer[-2 - oparg];
- method[0] = sym_new_not_null(ctx);
- self[0] = sym_new_not_null(ctx);
break;
}
}
case _SWAP: {
- JitOptSymbol *top_in;
- JitOptSymbol *bottom_in;
- JitOptSymbol *top_out;
- JitOptSymbol *bottom_out;
- top_in = stack_pointer[-1];
- bottom_in = stack_pointer[-2 - (oparg-2)];
- bottom_out = bottom_in;
- top_out = top_in;
- stack_pointer[-2 - (oparg-2)] = top_out;
- stack_pointer[-1] = bottom_out;
+ JitOptSymbol **top;
+ JitOptSymbol **bottom;
+ top = &stack_pointer[-1];
+ bottom = &stack_pointer[-2 - (oparg-2)];
+ JitOptSymbol *temp = bottom[0];
+ bottom[0] = top[0];
+ top[0] = temp;
+ assert(oparg >= 2);
break;
}
}
case _ERROR_POP_N: {
- stack_pointer += -oparg;
- assert(WITHIN_STACK_BOUNDS());
break;
}
import re
from typing import Optional
+@dataclass
+class EscapingCall:
+ start: lexer.Token
+ call: lexer.Token
+ end: lexer.Token
+ kills: lexer.Token | None
+
@dataclass
class Properties:
- escaping_calls: dict[lexer.Token, tuple[lexer.Token, lexer.Token]]
+ escaping_calls: dict[lexer.Token, EscapingCall]
escapes: bool
error_with_pop: bool
error_without_pop: bool
@staticmethod
def from_list(properties: list["Properties"]) -> "Properties":
- escaping_calls: dict[lexer.Token, tuple[lexer.Token, lexer.Token]] = {}
+ escaping_calls: dict[lexer.Token, EscapingCall] = {}
for p in properties:
escaping_calls.update(p.escaping_calls)
return Properties(
cond = replace_op_arg_1
return StackItem(item.name, item.type, cond, item.size)
+def check_unused(stack: list[StackItem], input_names: dict[str, lexer.Token]) -> None:
+ "Unused items cannot be on the stack above used, non-peek items"
+ seen_unused = False
+ for item in reversed(stack):
+ if item.name == "unused":
+ seen_unused = True
+ elif item.peek:
+ break
+ elif seen_unused:
+ raise analysis_error(f"Cannot have used input '{item.name}' below an unused value on the stack", input_names[item.name])
+
def analyze_stack(
op: parser.InstDef | parser.Pseudo, replace_op_arg_1: str | None = None
for output in outputs:
if variable_used(op, output.name):
output.used = True
+ check_unused(inputs, input_names)
return StackEffect(inputs, outputs)
"PyStackRef_AsPyObjectNew",
"PyStackRef_AsPyObjectSteal",
"PyStackRef_CLEAR",
- "PyStackRef_CLOSE",
"PyStackRef_CLOSE_SPECIALIZED",
"PyStackRef_DUP",
"PyStackRef_False",
if tkn.kind == "SEMI":
return node.block.tokens[idx+1]
-def check_escaping_calls(instr: parser.InstDef, escapes: dict[lexer.Token, tuple[lexer.Token, lexer.Token]]) -> None:
- calls = {escapes[t][0] for t in escapes}
+def check_escaping_calls(instr: parser.InstDef, escapes: dict[lexer.Token, EscapingCall]) -> None:
+ calls = {e.call for e in escapes.values()}
in_if = 0
tkn_iter = iter(instr.block.tokens)
for tkn in tkn_iter:
elif tkn in calls and in_if:
raise analysis_error(f"Escaping call '{tkn.text} in condition", tkn)
-def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, tuple[lexer.Token, lexer.Token]]:
- result: dict[lexer.Token, tuple[lexer.Token, lexer.Token]] = {}
+def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, EscapingCall]:
+ result: dict[lexer.Token, EscapingCall] = {}
tokens = instr.block.tokens
for idx, tkn in enumerate(tokens):
try:
continue
elif tkn.kind != "RBRACKET":
continue
+ if tkn.text in ("PyStackRef_CLOSE", "PyStackRef_XCLOSE"):
+ if len(tokens) <= idx+2:
+ raise analysis_error("Unexpected end of file", next_tkn)
+ kills = tokens[idx+2]
+ if kills.kind != "IDENTIFIER":
+ raise analysis_error(f"Expected identifier, got '{kills.text}'", kills)
+ else:
+ kills = None
start = find_stmt_start(instr, idx)
end = find_stmt_end(instr, idx)
- result[start] = tkn, end
+ result[start] = EscapingCall(start, tkn, end, kills)
check_escaping_calls(instr, result)
return result
variable_used(op, "Py_DECREF") or
variable_used(op, "Py_XDECREF") or
variable_used(op, "Py_CLEAR") or
- variable_used(op, "PyStackRef_CLOSE") or
- variable_used(op, "PyStackRef_XCLOSE") or
- variable_used(op, "PyStackRef_CLEAR") or
variable_used(op, "SETLOCAL")
)
return Properties(
"SYNC_SP": self.sync_sp,
"SAVE_STACK": self.save_stack,
"RELOAD_STACK": self.reload_stack,
- "PyStackRef_CLOSE": self.stackref_close,
- "PyStackRef_XCLOSE": self.stackref_close,
"PyStackRef_CLOSE_SPECIALIZED": self.stackref_close_specialized,
"PyStackRef_AsPyObjectSteal": self.stackref_steal,
"DISPATCH": self.dispatch,
exit_if = deopt_if
+ def goto_error(self, offset: int, label: str, storage: Storage) -> str:
+ if offset > 0:
+ return f"goto pop_{offset}_{label};"
+ if offset < 0:
+ storage.copy().flush(self.out)
+ return f"goto {label};"
+
def error_if(
self,
tkn: Token,
self.out.emit_at("if ", tkn)
self.emit(lparen)
emit_to(self.out, tkn_iter, "COMMA")
- self.out.emit(") ")
+ self.out.emit(") {\n")
label = next(tkn_iter).text
next(tkn_iter) # RPAREN
next(tkn_iter) # Semi colon
storage.clear_inputs("at ERROR_IF")
+
c_offset = storage.stack.peek_offset()
try:
offset = -int(c_offset)
except ValueError:
offset = -1
- if offset > 0:
- self.out.emit(f"goto pop_{offset}_")
- self.out.emit(label)
- self.out.emit(";\n")
- elif offset == 0:
- self.out.emit("goto ")
- self.out.emit(label)
- self.out.emit(";\n")
- else:
- self.out.emit("{\n")
- storage.copy().flush(self.out)
- self.out.emit("goto ")
- self.out.emit(label)
- self.out.emit(";\n")
+ self.out.emit(self.goto_error(offset, label, storage))
+ self.out.emit("\n")
+ if not unconditional:
self.out.emit("}\n")
return not unconditional
next(tkn_iter) # LPAREN
next(tkn_iter) # RPAREN
next(tkn_iter) # Semi colon
- self.out.emit_at("goto error;", tkn)
+ self.out.emit_at(self.goto_error(0, "error", storage), tkn)
return False
def decref_inputs(
live = var.name
return True
- def stackref_close(
- self,
- tkn: Token,
- tkn_iter: TokenIterator,
- uop: Uop,
- storage: Storage,
- inst: Instruction | None,
- ) -> bool:
- self.out.emit(tkn)
- tkn = next(tkn_iter)
- assert tkn.kind == "LPAREN"
- self.out.emit(tkn)
- name = next(tkn_iter)
- self.out.emit(name)
- if name.kind == "IDENTIFIER":
- return self.stackref_kill(name, storage, True)
- rparen = emit_to(self.out, tkn_iter, "RPAREN")
- self.emit(rparen)
- return True
-
def stackref_close_specialized(
self,
tkn: Token,
self.out.start_line()
line = tkn.line
if tkn in escaping_calls:
- if tkn != reload:
+ escape = escaping_calls[tkn]
+ if escape.kills is not None:
+ if tkn == reload:
+ self.emit_reload(storage)
+ self.stackref_kill(escape.kills, storage, True)
+ self.emit_save(storage)
+ elif tkn != reload:
self.emit_save(storage)
- _, reload = escaping_calls[tkn]
+ reload = escape.end
elif tkn == reload:
self.emit_reload(storage)
if tkn.kind == "LBRACE":
raise analysis_error(ex.args[0], tkn) from None
raise analysis_error("Expecting closing brace. Reached end of file", tkn)
-
def emit_tokens(
self,
uop: Uop,
super().__init__(out)
self._replacers["oparg"] = self.oparg
- def error_if(
- self,
- tkn: Token,
- tkn_iter: TokenIterator,
- uop: Uop,
- storage: Storage,
- inst: Instruction | None,
- ) -> bool:
- self.out.emit_at("if ", tkn)
- lparen = next(tkn_iter)
- self.emit(lparen)
- assert lparen.kind == "LPAREN"
- first_tkn = next(tkn_iter)
- self.out.emit(first_tkn)
- emit_to(self.out, tkn_iter, "COMMA")
- label = next(tkn_iter).text
- next(tkn_iter) # RPAREN
- next(tkn_iter) # Semi colon
- self.emit(") JUMP_TO_ERROR();\n")
- return not always_true(first_tkn)
-
-
- def error_no_pop(
- self,
- tkn: Token,
- tkn_iter: TokenIterator,
- uop: Uop,
- storage: Storage,
- inst: Instruction | None,
- ) -> bool:
- next(tkn_iter) # LPAREN
- next(tkn_iter) # RPAREN
- next(tkn_iter) # Semi colon
- self.out.emit_at("JUMP_TO_ERROR();", tkn)
- return False
+ def goto_error(self, offset: int, label: str, storage: Storage) -> str:
+ # To do: Add jump targets for popping values.
+ if offset != 0:
+ storage.copy().flush(self.out)
+ return f"JUMP_TO_ERROR();"
def deopt_if(
self,
projects / thirdparty / Python / cpython.git / commitdiff
