// visited is GC bookkeeping for the current stack walk, not frame state.
dest->visited = 0;
#ifdef Py_DEBUG
+ dest->stackpointer_valid = src->stackpointer_valid;
dest->lltrace = src->lltrace;
#endif
for (int i = 0; i < stacktop; i++) {
frame->owner = FRAME_OWNED_BY_THREAD;
frame->visited = 0;
#ifdef Py_DEBUG
+ frame->stackpointer_valid = 1;
frame->lltrace = 0;
#endif
static inline _PyStackRef*
_PyFrame_GetStackPointer(_PyInterpreterFrame *frame)
{
+ return frame->stackpointer;
+}
+
+static inline void
+_PyFrame_SetStackPointer(_PyInterpreterFrame *frame, _PyStackRef *stack_pointer)
+{
+ frame->stackpointer = stack_pointer;
+}
+
+static inline void
+_PyFrame_StackPointerValidate(_PyInterpreterFrame *frame)
+{
+#ifdef Py_DEBUG
+/* Avoid bloating the JIT code */
#ifndef _Py_JIT
- assert(frame->stackpointer != NULL);
+ assert(frame->stackpointer_valid == 0);
#endif
- _PyStackRef *sp = frame->stackpointer;
-#ifndef NDEBUG
- frame->stackpointer = NULL;
+ frame->stackpointer_valid = 1;
#endif
- return sp;
}
static inline void
-_PyFrame_SetStackPointer(_PyInterpreterFrame *frame, _PyStackRef *stack_pointer)
+_PyFrame_StackPointerInvalidate(_PyInterpreterFrame *frame)
{
+#ifdef Py_DEBUG
/* Avoid bloating the JIT code */
#ifndef _Py_JIT
- assert(frame->stackpointer == NULL);
+ assert(frame->stackpointer_valid == 1);
+#endif
+ frame->stackpointer_valid = 0;
#endif
- frame->stackpointer = stack_pointer;
}
+static inline void
+_PyFrame_StackAssertInvalid(_PyInterpreterFrame *frame)
+{
+#ifdef Py_DEBUG
+/* Avoid bloating the JIT code */
+#ifndef _Py_JIT
+ assert(frame->stackpointer_valid == 0);
+#endif
+#endif
+}
+
+
/* Determine whether a frame is incomplete.
* A frame is incomplete if it is part way through
* creating cell objects or a generator or coroutine.
frame->owner = FRAME_OWNED_BY_THREAD;
frame->visited = 0;
#ifdef Py_DEBUG
+ frame->stackpointer_valid = 1;
frame->lltrace = 0;
#endif
frame->return_offset = 0;
char owner;
#ifdef Py_DEBUG
uint8_t visited:1;
- uint8_t lltrace:7;
+ uint8_t stackpointer_valid:1;
+ uint8_t lltrace:6;
#else
uint8_t visited;
#endif
[INSTRUMENTED_POP_JUMP_IF_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ESCAPES_FLAG },
[INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ESCAPES_FLAG },
[INSTRUMENTED_POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG },
- [INSTRUMENTED_RESUME] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
- [INSTRUMENTED_RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_NEEDS_GUARD_IP_FLAG },
- [INSTRUMENTED_YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG | HAS_NEEDS_GUARD_IP_FLAG },
+ [INSTRUMENTED_RESUME] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG | HAS_SYNC_SP_FLAG },
+ [INSTRUMENTED_RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_SYNC_SP_FLAG | HAS_NEEDS_GUARD_IP_FLAG },
+ [INSTRUMENTED_YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG | HAS_SYNC_SP_FLAG | HAS_NEEDS_GUARD_IP_FLAG },
[INTERPRETER_EXIT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG },
[IS_OP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG },
[JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[RESUME] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG },
[RESUME_CHECK] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG },
[RESUME_CHECK_JIT] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG },
- [RETURN_GENERATOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_NEEDS_GUARD_IP_FLAG },
- [RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_NEEDS_GUARD_IP_FLAG },
+ [RETURN_GENERATOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_SYNC_SP_FLAG | HAS_NEEDS_GUARD_IP_FLAG },
+ [RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG | HAS_SYNC_SP_FLAG | HAS_NEEDS_GUARD_IP_FLAG },
[SEND] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG | HAS_SYNC_SP_FLAG | HAS_NEEDS_GUARD_IP_FLAG },
[SEND_ASYNC_GEN] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG | HAS_UNPREDICTABLE_JUMP_FLAG },
[SEND_GEN] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_SYNC_SP_FLAG | HAS_NEEDS_GUARD_IP_FLAG | HAS_RECORDS_VALUE_FLAG },
[UNPACK_SEQUENCE_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG },
[UNPACK_SEQUENCE_TWO_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG },
[WITH_EXCEPT_START] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
- [YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG | HAS_NEEDS_GUARD_IP_FLAG },
+ [YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG | HAS_SYNC_SP_FLAG | HAS_NEEDS_GUARD_IP_FLAG },
[ANNOTATIONS_PLACEHOLDER] = { true, -1, HAS_PURE_FLAG },
[JUMP] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
[JUMP_IF_FALSE] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG },
_PyUOpInstruction *input, int trace_len, int curr_stackentries,
_PyUOpInstruction *output, _PyBloomFilter *dependencies);
-extern PyTypeObject _PyUOpExecutor_Type;
+PyAPI_DATA(PyTypeObject) _PyUOpExecutor_Type;
#define UOP_FORMAT_TARGET 0
[_CALL_INTRINSIC_1] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
[_CALL_INTRINSIC_2] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
[_MAKE_HEAP_SAFE] = 0,
- [_RETURN_VALUE] = HAS_ESCAPES_FLAG | HAS_NEEDS_GUARD_IP_FLAG,
+ [_RETURN_VALUE] = HAS_ESCAPES_FLAG | HAS_SYNC_SP_FLAG | HAS_NEEDS_GUARD_IP_FLAG,
[_GET_AITER] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_GET_ANEXT] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
[_GET_AWAITABLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_SEND_VIRTUAL_TIER_TWO] = HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG,
[_GUARD_3OS_ASYNC_GEN_ASEND] = HAS_EXIT_FLAG,
[_SEND_ASYNC_GEN_TIER_TWO] = HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
- [_YIELD_VALUE] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG | HAS_NEEDS_GUARD_IP_FLAG,
+ [_YIELD_VALUE] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG | HAS_SYNC_SP_FLAG | HAS_NEEDS_GUARD_IP_FLAG,
[_POP_EXCEPT] = HAS_ESCAPES_FLAG,
[_LOAD_COMMON_CONSTANT] = HAS_ARG_FLAG,
[_LOAD_BUILD_CLASS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_CALL_FUNCTION_EX_NON_PY_GENERAL] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_MAKE_FUNCTION] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG,
[_SET_FUNCTION_ATTRIBUTE] = HAS_ARG_FLAG,
- [_RETURN_GENERATOR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_NEEDS_GUARD_IP_FLAG,
+ [_RETURN_GENERATOR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG | HAS_SYNC_SP_FLAG | HAS_NEEDS_GUARD_IP_FLAG,
[_BUILD_SLICE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_CONVERT_VALUE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_FORMAT_SIMPLE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG,
[_RETURN_GENERATOR] = {
.best = { 0, 0, 0, 0 },
.entries = {
- { 1, 0, _RETURN_GENERATOR_r01 },
+ { 1, 1, _RETURN_GENERATOR_r01 },
{ -1, -1, -1 },
{ -1, -1, -1 },
{ -1, -1, -1 },
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
escaping_call();
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
res = Py_None;
stack_pointer[0] = res;
stack_pointer += 1;
res = Py_None;
stack_pointer[-1] = res;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
escaping_call();
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
"""
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
op1(left, right);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
/* Skip 2 cache entries */
// OP2
arg2 = stack_pointer[-3];
uint32_t extra = read_u32(&this_instr[4].cache);
(void)extra;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
res = op2(arg2, left, right);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
stack_pointer[-3] = res;
stack_pointer += -2;
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
op1(left, right);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
left = stack_pointer[-2];
arg2 = stack_pointer[-3];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res = op3(arg2, left, right);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer[-3] = res;
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
next_instr += 1;
INSTRUCTION_STATS(BALANCED);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
code();
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
"""
frame->instr_ptr = next_instr;
next_instr += 1;
INSTRUCTION_STATS(BALANCED);
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
"""
frame->instr_ptr = next_instr;
next_instr += 1;
INSTRUCTION_STATS(BALANCED);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ // Explicit stack reload
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackAssertInvalid(frame);
DISPATCH();
}
"""
- with self.assertRaises(SyntaxError):
- self.run_cases_test(input, output)
+ self.run_cases_test(input, output)
def test_stack_save_only(self):
INSTRUCTION_STATS(OP);
#ifdef Py_GIL_DISABLED
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
escaping_call();
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
#else
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
another_escaping_call();
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
#endif
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
yet_another_escaping_call();
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
"""
LABEL(my_label)
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
do_thing();
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (complex) {
JUMP_TO_LABEL(other_label);
}
LABEL(one)
{
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(two);
}
LABEL(two)
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
JUMP_TO_LABEL(one);
}
"""
LABEL(my_label_1)
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
do_thing1();
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(my_label_2);
}
LABEL(my_label_2)
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
do_thing2();
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(my_label_1);
}
"""
_PyStackRef in;
in = stack_pointer[-1];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
temp = use(in);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
in = temp;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(in);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
"""
"non-recording, non-specializing uops"):
self.run_cases_test(input, "")
+ def test_escaping_in_loop(self):
+ input = """
+ inst(TEST_LOOP_SPILL, (a -- a)) {
+ int n = (int)oparg;
+ for (int i = 0; i < n; i++) {
+ escaping_inside_loop(a);
+ }
+ escaping_after_loop(a);
+ }
+ """
+ output = """
+ TARGET(TEST_LOOP_SPILL) {
+ #if _Py_TAIL_CALL_INTERP
+ int opcode = TEST_LOOP_SPILL;
+ (void)(opcode);
+ #endif
+ frame->instr_ptr = next_instr;
+ next_instr += 1;
+ INSTRUCTION_STATS(TEST_LOOP_SPILL);
+ _PyStackRef a;
+ a = stack_pointer[-1];
+ int n = (int)oparg;
+ for (int i = 0; i < n; i++) {
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
+ escaping_inside_loop(a);
+ _PyFrame_StackPointerInvalidate(frame);
+ }
+ _PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
+ escaping_after_loop(a);
+ _PyFrame_StackPointerInvalidate(frame);
+ DISPATCH();
+ }
+ """
+ self.run_cases_test(input, output)
class TestRecorderTableGeneration(unittest.TestCase):
entry.frame.return_offset = 0;
#ifdef Py_DEBUG
entry.frame.lltrace = 0;
+ entry.frame.stackpointer_valid = 1;
#endif
/* Push frame */
entry.frame.previous = tstate->current_frame;
next_instr = frame->instr_ptr;
monitor_throw(tstate, frame, next_instr);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
#if _Py_TAIL_CALL_INTERP
# if Py_STATS
return _TAIL_CALL_error(frame, stack_pointer, tstate, next_instr, instruction_funcptr_handler_table, 0, lastopcode);
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_BinaryOp(lhs, rhs, next_instr, oparg, LOCALS_ARRAY);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(BINARY_OP);
PyObject *rhs_o = PyStackRef_AsPyObjectBorrow(rhs);
assert(_PyEval_BinaryOps[oparg]);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
value = r;
stack_pointer[-2] = res;
stack_pointer[-1] = l;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5);
assert(d != NULL);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int match = (d->guard != NULL)
? d->guard(left_o, right_o)
: (Py_TYPE(left_o) == d->lhs_type && Py_TYPE(right_o) == d->rhs_type);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (!match) {
UPDATE_MISS_STATS(BINARY_OP);
assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));
assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5);
_PyBinaryOpSpecializationDescr *d = (_PyBinaryOpSpecializationDescr*)descr;
STAT_INC(BINARY_OP, hit);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = d->action(left_o, right_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
value = r;
stack_pointer[-2] = res;
stack_pointer[-1] = l;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyUnicode_Append(&temp, right_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
*target_local = PyStackRef_NULL;
if (temp == NULL) {
JUMP_TO_LABEL(error);
assert(Py_TYPE(dict)->tp_as_mapping->mp_subscript == _PyDict_Subscript);
STAT_INC(BINARY_OP, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyDict_Subscript(dict, sub);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
value = ss;
stack_pointer[-2] = res;
stack_pointer[-1] = ds;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
}
#ifdef Py_GIL_DISABLED
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyList_GetItemRef((PyListObject*)list, index);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
UPDATE_MISS_STATS(BINARY_OP);
assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
assert(PySlice_Check(sub));
assert(PyList_CheckExact(list));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyList_SliceSubscript(list, sub);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
STAT_INC(BINARY_OP, hit);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
value = ss;
stack_pointer[-2] = res;
stack_pointer[-1] = ls;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *res_o;
if (PyList_CheckExact(container_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyList_BinarySlice(container_o, start_o, stop_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else if (PyTuple_CheckExact(container_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyTuple_BinarySlice(container_o, start_o, stop_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else if (PyUnicode_CheckExact(container_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyUnicode_BinarySlice(container_o, start_o, stop_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
PyObject *slice = PySlice_New(start_o, stop_o, NULL);
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = PyObject_GetItem(container_o, slice);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(slice);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = stop;
stop = PyStackRef_NULL;
stack_pointer[-1] = stop;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = start;
start = PyStackRef_NULL;
stack_pointer[-2] = start;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = container;
container = PyStackRef_NULL;
stack_pointer[-3] = container;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res_o == NULL) {
format_o = &_Py_STR(empty);
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *interpolation_o = _PyInterpolation_Build(value_o, str_o, conversion, format_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (oparg & 1) {
stack_pointer += -(oparg & 1);
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(format[0]);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
stack_pointer += -(oparg & 1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(str);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (interpolation_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef list;
values = &stack_pointer[-oparg];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *list_o = _PyList_FromStackRefStealOnSuccess(values, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (list_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef map;
values = &stack_pointer[-oparg*2];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *map_o = _Py_BuildMap_StackRefSteal(values, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (map_o == NULL) {
stack_pointer += -oparg*2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyStackRef set;
values = &stack_pointer[-oparg];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *set_o = PySet_New(NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (set_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
tmp = values[_i];
values[_i] = PyStackRef_NULL;
PyStackRef_CLOSE(tmp);
}
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
JUMP_TO_LABEL(error);
_PyStackRef value = values[i];
values[i] = PyStackRef_NULL;
if (err == 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
err = _PySet_AddTakeRef((PySetObject *)set_o, PyStackRef_AsPyObjectSteal(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
if (err) {
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(set_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
set = PyStackRef_FromPyObjectStealMortal(set_o);
PyObject *step_o = oparg == 3 ? PyStackRef_AsPyObjectBorrow(args[2]) : NULL;
PyObject *slice_o = PySlice_New(start_o, stop_o, step_o);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
tmp = args[_i];
args[_i] = PyStackRef_NULL;
PyStackRef_CLOSE(tmp);
}
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (slice_o == NULL) {
_PyStackRef str;
pieces = &stack_pointer[-oparg];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *str_o = _Py_BuildString_StackRefSteal(pieces, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (str_o == NULL) {
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
PyObject *strings_o = PyStackRef_AsPyObjectBorrow(strings);
PyObject *interpolations_o = PyStackRef_AsPyObjectBorrow(interpolations);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *template_o = _PyTemplate_Build(strings_o, interpolations_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(interpolations);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(strings);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (template_o == NULL) {
JUMP_TO_LABEL(error);
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_Call(callable, self_or_null, next_instr, oparg + !PyStackRef_IsNull(self_or_null));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(CALL);
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _DO_CALL
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
tstate, callable, locals,
arguments, total_args, NULL, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (new_frame == NULL) {
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject* res_o = _Py_VectorCallInstrumentation_StackRefSteal(
callable,
arguments,
frame,
this_instr,
tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
}
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *self_o = PyType_GenericAlloc(tp, 0);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (self_o == NULL) {
JUMP_TO_LABEL(error);
}
callable = PyStackRef_FromPyObjectNew(init_func);
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CREATE_INIT_FRAME
{
args = &stack_pointer[-oparg];
self = self_or_null;
init = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked(
tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
assert(_PyFrame_GetBytecode(shim)[0].op.code == EXIT_INIT_CHECK);
assert(_PyFrame_GetBytecode(shim)[1].op.code == RETURN_VALUE);
shim->localsplus[0] = PyStackRef_DUP(self);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
tstate, init, NULL, args-1, oparg+1, NULL, shim);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (temp == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FrameClearAndPop(tstate, shim);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
frame->return_offset = 1 + INLINE_CACHE_ENTRIES_CALL;
assert(!IS_PEP523_HOOKED(tstate));
_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// flush
// _CHECK_FUNCTION_VERSION
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// flush
// _CHECK_RECURSION_REMAINING
assert(Py_TYPE(callable_o) == &PyFunction_Type);
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
tstate, callable, locals,
args, total_args, NULL, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (temp == NULL) {
assert(!IS_PEP523_HOOKED(tstate));
_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
}
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _Py_CallBuiltinClass_StackRef(
callable,
arguments,
total_args);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP_OPARG
{
args = &stack_pointer[-oparg];
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef_CloseStack(args, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
}
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _Py_BuiltinCallFast_StackRef(
callable,
arguments,
total_args
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP_OPARG
{
args = &stack_pointer[-oparg];
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef_CloseStack(args, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
}
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _Py_BuiltinCallFastWithKeywords_StackRef(callable, arguments, total_args);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP_OPARG
{
args = &stack_pointer[-oparg];
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef_CloseStack(args, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o);
_PyStackRef arg = args[0];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
if (res_o == NULL) {
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs);
if (!PyTuple_CheckExact(callargs_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *tuple_o = PySequence_Tuple(callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (tuple_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callargs;
callargs = PyStackRef_FromPyObjectSteal(tuple_o);
stack_pointer[-2] = callargs;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _CALL_FUNCTION_EX_NON_PY_GENERAL
assert(kwargs == NULL || PyDict_CheckExact(kwargs));
stack_pointer[-2] = callargs_st;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *result_o = PyObject_Call(func, callargs, kwargs);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(kwargs_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(callargs_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(func_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (result_o == NULL) {
JUMP_TO_LABEL(error);
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs);
if (!PyTuple_CheckExact(callargs_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *tuple_o = PySequence_Tuple(callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (tuple_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callargs;
callargs = PyStackRef_FromPyObjectSteal(tuple_o);
stack_pointer[-2] = callargs;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _CHECK_IS_PY_CALLABLE_EX
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(
tstate, func_st, locals,
nargs, callargs, kwargs, frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (new_frame == NULL) {
assert(!IS_PEP523_HOOKED(tstate));
_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_CallFunctionEx(func, next_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(CALL_FUNCTION_EX);
PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs);
if (!PyTuple_CheckExact(callargs_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *tuple_o = PySequence_Tuple(callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (tuple_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callargs;
callargs = PyStackRef_FromPyObjectSteal(tuple_o);
stack_pointer[-2] = callargs;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _DO_CALL_FUNCTION_EX
PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING;
stack_pointer[-2] = callargs_st;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, func, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
result_o = PyObject_Call(func, callargs, kwargs);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (!PyFunction_Check(func) && !PyMethod_Check(func)) {
if (result_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_Py_call_instrumentation_exc2(
tstate, PY_MONITORING_EVENT_C_RAISE,
frame, this_instr, func, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_C_RETURN,
frame, this_instr, func, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_CLEAR(result_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(
tstate, func_st, locals,
nargs, callargs, kwargs, frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (new_frame == NULL) {
assert(kwargs == NULL || PyDict_CheckExact(kwargs));
stack_pointer[-2] = callargs_st;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
result_o = PyObject_Call(func, callargs, kwargs);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(kwargs_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(callargs_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(func_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (result_o == NULL) {
JUMP_TO_LABEL(error);
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
value = stack_pointer[-1];
assert(oparg <= MAX_INTRINSIC_1);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
{
value = v;
stack_pointer[-1] = res;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *value1 = PyStackRef_AsPyObjectBorrow(value1_st);
PyObject *value2 = PyStackRef_AsPyObjectBorrow(value2_st);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
value = vs2;
stack_pointer[-2] = res;
stack_pointer[-1] = vs1;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *inst_o = PyStackRef_AsPyObjectBorrow(instance);
PyObject *cls_o = PyStackRef_AsPyObjectBorrow(cls);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int retval = PyObject_IsInstance(inst_o, cls_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (retval < 0) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(cls);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(instance);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(callable);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
res = retval ? PyStackRef_True : PyStackRef_False;
assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL));
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_CallKw(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(CALL_KW);
stack_pointer[-3 - oparg] = callable;
stack_pointer[-2 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _DO_CALL_KW
stack_pointer[-3 - oparg] = callable;
stack_pointer[-2 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
tstate, callable, locals,
arguments, positional_args, kwnames_o, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(kwnames);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (new_frame == NULL) {
JUMP_TO_LABEL(error);
}
stack_pointer[-3 - oparg] = callable;
stack_pointer[-2 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject* res_o = _Py_VectorCallInstrumentation_StackRefSteal(
callable,
arguments,
frame,
this_instr,
tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
stack_pointer += -3 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
stack_pointer[-3 - oparg] = callable;
stack_pointer[-2 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(callable_s);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// flush
// _PY_FRAME_KW
assert(Py_TYPE(callable_o) == &PyFunction_Type);
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
tstate, callable, locals,
arguments, positional_args, kwnames_o, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(kwnames);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (temp == NULL) {
assert(!IS_PEP523_HOOKED(tstate));
_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
total_args++;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _Py_VectorCall_StackRefSteal(
callable,
arguments,
total_args,
kwnames);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
stack_pointer += -3 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
tstate, callable, locals,
arguments, positional_args, kwnames_o, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(kwnames);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (temp == NULL) {
assert(!IS_PEP523_HOOKED(tstate));
_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
STAT_INC(CALL, hit);
PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_ssize_t len_i = PyObject_Length(arg_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (len_i < 0) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
assert(self != NULL);
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyCFunctionFast cfunc = _PyCFunctionFast_CAST(method->d_method->ml_meth);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCallMethodDescriptorFast_StackRef(
callable,
cfunc,
arguments,
total_args
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP_OPARG
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef_CloseStack(args, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
assert(self != NULL);
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyCFunctionFastWithKeywords cfunc = _PyCFunctionFastWithKeywords_CAST(method->d_method->ml_meth);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCallMethodDescriptorFastWithKeywords_StackRef(
callable,
cfunc,
arguments,
total_args
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP_OPARG
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef_CloseStack(args, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
STAT_INC(CALL, hit);
PyCFunction cfunc = method->d_method->ml_meth;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
if (res_o == NULL) {
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
PyObject *self = PyStackRef_AsPyObjectBorrow(arguments[0]);
PyObject *arg = PyStackRef_AsPyObjectBorrow(arguments[1]);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
if (res_o == NULL) {
stack_pointer += 1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
total_args++;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _Py_VectorCall_StackRefSteal(
callable,
arguments,
total_args,
PyStackRef_NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
tstate, callable, locals,
args, total_args, NULL, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (temp == NULL) {
assert(!IS_PEP523_HOOKED(tstate));
_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
assert(oparg == 1);
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyObject_Str(arg_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
assert(oparg == 1);
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PySequence_Tuple(arg_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st);
PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = match_type_st;
match_type_st = PyStackRef_NULL;
stack_pointer[-1] = match_type_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = exc_value_st;
exc_value_st = PyStackRef_NULL;
stack_pointer[-2] = exc_value_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
JUMP_TO_LABEL(error);
}
PyObject *match_o = NULL;
PyObject *rest_o = NULL;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int res = _PyEval_ExceptionGroupMatch(frame, exc_value, match_type,
&match_o, &rest_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = match_type_st;
match_type_st = PyStackRef_NULL;
stack_pointer[-1] = match_type_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = exc_value_st;
exc_value_st = PyStackRef_NULL;
stack_pointer[-2] = exc_value_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res < 0) {
}
if (!Py_IsNone(match_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyErr_SetHandledException(match_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
rest = PyStackRef_FromPyObjectSteal(rest_o);
match = PyStackRef_FromPyObjectSteal(match_o);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
assert(PyExceptionInstance_Check(left_o));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyEval_CheckExceptTypeValid(tstate, right_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int res = PyErr_GivenExceptionMatches(left_o, right_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(right);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
b = res ? PyStackRef_True : PyStackRef_False;
stack_pointer[0] = b;
stack_pointer += 1;
#endif
assert(exc_value && PyExceptionInstance_Check(exc_value));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int matches = PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (matches) {
value = PyStackRef_FromPyObjectNew(((PyStopIterationObject *)exc_value)->value);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = sub_iter;
sub_iter = value;
stack_pointer[-4] = sub_iter;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = exc_value_st;
exc_value_st = PyStackRef_NULL;
stack_pointer[-1] = exc_value_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = last_sent_val;
last_sent_val = PyStackRef_NULL;
stack_pointer[-2] = last_sent_val;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = null_in;
null_in = PyStackRef_NULL;
stack_pointer[-3] = null_in;
PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -4;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
null_out = null_in;
none = PyStackRef_None;
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetRaisedException(tstate, Py_NewRef(exc_value));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
monitor_reraise(tstate, frame, this_instr);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
JUMP_TO_LABEL(exception_unwind);
}
stack_pointer[0] = none;
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_CompareOp(left, right, next_instr, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(COMPARE_OP);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
assert((oparg >> 5) <= Py_GE);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = right;
right = PyStackRef_NULL;
stack_pointer[-1] = right;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = left;
left = PyStackRef_NULL;
stack_pointer[-2] = left;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res_o == NULL) {
}
if (oparg & 16) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res_bool = PyObject_IsTrue(res_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(res_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_bool < 0) {
JUMP_TO_LABEL(error);
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_ContainsOp(right, next_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(CONTAINS_OP);
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res = PySequence_Contains(right_o, left_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res < 0) {
JUMP_TO_LABEL(error);
}
value = r;
stack_pointer[-2] = b;
stack_pointer[-1] = l;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
assert(PyAnyDict_CheckExact(right_o));
STAT_INC(CONTAINS_OP, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res = PyDict_Contains(right_o, left_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res < 0) {
JUMP_TO_LABEL(error);
}
value = r;
stack_pointer[-2] = b;
stack_pointer[-1] = l;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
assert(PyAnySet_CheckExact(right_o));
STAT_INC(CONTAINS_OP, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res = _PySet_Contains((PySetObject *)right_o, left_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res < 0) {
JUMP_TO_LABEL(error);
}
value = r;
stack_pointer[-2] = b;
stack_pointer[-1] = l;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
assert(oparg >= FVC_STR && oparg <= FVC_ASCII);
conv_fn = _PyEval_ConversionFuncs[oparg];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (result_o == NULL) {
JUMP_TO_LABEL(error);
}
owner = stack_pointer[-1];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(owner);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
PyObject *oldobj = PyCell_SwapTakeRef((PyCellObject *)cell, NULL);
if (oldobj == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(oldobj);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
_PyStackRef v = GETLOCAL(oparg);
if (PyStackRef_IsNull(v)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError,
UNBOUNDLOCAL_ERROR_MSG,
PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg)
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
_PyStackRef tmp = GETLOCAL(oparg);
GETLOCAL(oparg) = PyStackRef_NULL;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
INSTRUCTION_STATS(DELETE_GLOBAL);
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyDict_Pop(GLOBALS(), name, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
if (err == 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
NAME_ERROR_MSG, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
DISPATCH();
int err;
if (ns == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_SystemError,
"no locals when deleting %R", name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
err = PyObject_DelItem(ns, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
NAME_ERROR_MSG,
name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
DISPATCH();
sub = stack_pointer[-1];
container = stack_pointer[-2];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container),
PyStackRef_AsPyObjectBorrow(sub));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = sub;
sub = PyStackRef_NULL;
stack_pointer[-1] = sub;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = container;
container = PyStackRef_NULL;
stack_pointer[-2] = container;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (err) {
PyObject *update_o = PyStackRef_AsPyObjectBorrow(update);
PyObject *dupkey = NULL;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyDict_MergeUniq(dict_o, update_o, &dupkey);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatKwargsError(tstate, callable_o, update_o, dupkey);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_XDECREF(dupkey);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
u = update;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict);
PyObject *update_o = PyStackRef_AsPyObjectBorrow(update);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyDict_Update(dict_o, update_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
int matches = _PyErr_ExceptionMatches(tstate, PyExc_AttributeError);
if (matches) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *exc = _PyErr_GetRaisedException(tstate);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int has_keys = PyObject_HasAttrWithError(update_o, &_Py_ID(keys));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (has_keys == 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_TypeError,
"'%T' object is not a mapping",
update_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(exc);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_ChainExceptions1(exc);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
JUMP_TO_LABEL(error);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *exc = PyStackRef_AsPyObjectBorrow(exc_st);
assert(exc && PyExceptionInstance_Check(exc));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int matches = PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (matches) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = exc_st;
exc_st = PyStackRef_NULL;
stack_pointer[-1] = exc_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = awaitable_st;
awaitable_st = PyStackRef_NULL;
stack_pointer[-2] = awaitable_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
}
else {
Py_INCREF(exc);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetRaisedException(tstate, exc);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
monitor_reraise(tstate, frame, this_instr);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
JUMP_TO_LABEL(exception_unwind);
}
DISPATCH();
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(receiver);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
should_be_none = stack_pointer[-1];
if (!PyStackRef_IsNone(should_be_none)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyErr_Format(PyExc_TypeError,
"__init__() should return None, not '%.200s'",
Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);
if (!PyUnicode_CheckExact(value_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyObject_Format(value_o, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
fmt_spec = stack_pointer[-1];
value = stack_pointer[-2];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = fmt_spec;
fmt_spec = PyStackRef_NULL;
stack_pointer[-1] = fmt_spec;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = value;
value = PyStackRef_NULL;
stack_pointer[-2] = value;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res_o == NULL) {
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_ForIter(iter, null_or_index, next_instr, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(FOR_ITER);
// _FOR_ITER
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef item = _PyForIter_VirtualIteratorNext(tstate, frame, iter, &null_or_index);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (!PyStackRef_IsValid(item)) {
if (PyStackRef_IsError(item)) {
JUMP_TO_LABEL(error);
assert(!IS_PEP523_HOOKED(tstate));
_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
_PyObject_GC_IS_SHARED(list_o));
STAT_INC(FOR_ITER, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int result = _PyList_GetItemRefNoLock((PyListObject *)list_o, PyStackRef_UntagInt(null_or_index), &next);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (result < 0) {
UPDATE_MISS_STATS(FOR_ITER);
assert(_PyOpcode_Deopt[opcode] == (FOR_ITER));
PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter);
Py_ssize_t index = PyStackRef_UntagInt(null_or_index);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyObjectIndexPair next_index = Py_TYPE(iter_o)->_tp_iteritem(iter_o, index);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
PyObject *next_o = next_index.object;
index = next_index.index;
if (next_o == NULL) {
}
if (getter == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_TypeError,
"'async for' requires an object with "
"__aiter__ method, got %.100s",
type->tp_name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(obj);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
iter_o = (*getter)(obj_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(obj);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (iter_o == NULL) {
JUMP_TO_LABEL(error);
}
if (Py_TYPE(iter_o)->tp_as_async == NULL ||
Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_TypeError,
"'async for' received an object from __aiter__ "
"that does not implement __anext__: %.100s",
Py_TYPE(iter_o)->tp_name);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(iter_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
iter = PyStackRef_FromPyObjectSteal(iter_o);
_PyStackRef awaitable;
aiter = stack_pointer[-1];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *awaitable_o = _PyEval_GetANext(PyStackRef_AsPyObjectBorrow(aiter));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (awaitable_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef iter;
iterable = stack_pointer[-1];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(iterable);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (iter_o == NULL) {
JUMP_TO_LABEL(error);
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_GetIter(iterable, next_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(GET_ITER);
// _GET_ITER
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef result = _PyEval_GetIter(iterable, &index_or_null, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (PyStackRef_IsError(result)) {
JUMP_TO_LABEL(pop_1_error);
}
_PyStackRef len;
obj = stack_pointer[-1];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (len_i < 0) {
JUMP_TO_LABEL(error);
}
PyObject *res_o;
if (PyLazyImport_CheckExact(PyStackRef_AsPyObjectBorrow(from))) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyEval_LazyImportFrom(
tstate, frame, PyStackRef_AsPyObjectBorrow(from), name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyEval_ImportFrom(
tstate, PyStackRef_AsPyObjectBorrow(from), name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
if (res_o == NULL) {
JUMP_TO_LABEL(error);
PyObject *res_o;
if (!(oparg & 0x02)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyEval_LazyImportName(tstate, BUILTINS(), GLOBALS(),
LOCALS(), name,
PyStackRef_AsPyObjectBorrow(fromlist),
PyStackRef_AsPyObjectBorrow(level),
oparg & 0x01);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyEval_ImportName(tstate, BUILTINS(), GLOBALS(),
LOCALS(), name,
PyStackRef_AsPyObjectBorrow(fromlist),
PyStackRef_AsPyObjectBorrow(level));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = fromlist;
fromlist = PyStackRef_NULL;
stack_pointer[-1] = fromlist;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = level;
level = PyStackRef_NULL;
stack_pointer[-2] = level;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res_o == NULL) {
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _MONITOR_CALL
stack_pointer[-2 - oparg] = func;
stack_pointer[-1 - oparg] = maybe_self;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, function, arg0
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
{
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
tstate, callable, locals,
arguments, total_args, NULL, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (new_frame == NULL) {
frame->return_offset = 4u ;
DISPATCH_INLINED(new_frame);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject* res_o = _Py_VectorCallInstrumentation_StackRefSteal(
callable,
arguments,
frame,
this_instr,
tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs);
if (!PyTuple_CheckExact(callargs_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *tuple_o = PySequence_Tuple(callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (tuple_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callargs;
callargs = PyStackRef_FromPyObjectSteal(tuple_o);
stack_pointer[-2] = callargs;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _DO_CALL_FUNCTION_EX
PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING;
stack_pointer[-2] = callargs_st;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, func, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
result_o = PyObject_Call(func, callargs, kwargs);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (!PyFunction_Check(func) && !PyMethod_Check(func)) {
if (result_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_Py_call_instrumentation_exc2(
tstate, PY_MONITORING_EVENT_C_RAISE,
frame, this_instr, func, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_C_RETURN,
frame, this_instr, func, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_CLEAR(result_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(
tstate, func_st, locals,
nargs, callargs, kwargs, frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (new_frame == NULL) {
assert(kwargs == NULL || PyDict_CheckExact(kwargs));
stack_pointer[-2] = callargs_st;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
result_o = PyObject_Call(func, callargs, kwargs);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(kwargs_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(callargs_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(func_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (result_o == NULL) {
JUMP_TO_LABEL(error);
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
stack_pointer[-3 - oparg] = callable;
stack_pointer[-2 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _MONITOR_CALL_KW
stack_pointer[-3 - oparg] = callable;
stack_pointer[-2 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, function, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
{
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
tstate, callable, locals,
arguments, positional_args, kwnames_o, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(kwnames);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (new_frame == NULL) {
JUMP_TO_LABEL(error);
}
frame->return_offset = 4u ;
DISPATCH_INLINED(new_frame);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject* res_o = _Py_VectorCallInstrumentation_StackRefSteal(
callable,
arguments,
frame,
this_instr,
tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
stack_pointer += -3 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
PyObject *exc = PyStackRef_AsPyObjectBorrow(exc_st);
assert(exc && PyExceptionInstance_Check(exc));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int matches = PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (matches) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = exc_st;
exc_st = PyStackRef_NULL;
stack_pointer[-1] = exc_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = awaitable_st;
awaitable_st = PyStackRef_NULL;
stack_pointer[-2] = awaitable_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
}
else {
Py_INCREF(exc);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetRaisedException(tstate, exc);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
monitor_reraise(tstate, frame, this_instr);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
JUMP_TO_LABEL(exception_unwind);
}
}
receiver = stack_pointer[-3];
if (PyStackRef_GenCheck(receiver)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver);
if (PyGen_Check(receiver_o) || PyCoro_CheckExact(receiver_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(receiver);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
null_or_index = stack_pointer[-1];
iter = stack_pointer[-2];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef item = _PyForIter_VirtualIteratorNext(tstate, frame, iter, &null_or_index);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (!PyStackRef_IsValid(item)) {
if (PyStackRef_IsError(item)) {
JUMP_TO_LABEL(error);
INSTRUCTION_STATS(INSTRUMENTED_INSTRUCTION);
opcode = INSTRUMENTED_INSTRUCTION;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int next_opcode = _Py_call_instrumentation_instruction(
tstate, frame, this_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (next_opcode < 0) {
JUMP_TO_LABEL(error);
}
// _CHECK_PERIODIC
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
next_instr = this_instr;
} else {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
original_opcode = _Py_call_instrumentation_line(
tstate, frame, this_instr, prev_instr);
+ _PyFrame_StackPointerInvalidate(frame);
+ // Explicit stack reload
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackAssertInvalid(frame);
if (original_opcode < 0) {
next_instr = this_instr+1;
JUMP_TO_LABEL(error);
PAUSE_ADAPTIVE_COUNTER(cache->counter);
}
opcode = original_opcode;
+ PRE_DISPATCH_GOTO();
DISPATCH_GOTO();
}
if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) {
PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, global_super, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = self_st;
self_st = PyStackRef_NULL;
stack_pointer[-1] = self_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = class_st;
class_st = PyStackRef_NULL;
stack_pointer[-2] = class_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = global_super_st;
global_super_st = PyStackRef_NULL;
stack_pointer[-3] = global_super_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
JUMP_TO_LABEL(error);
{
PyObject *stack[] = {class, self};
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
super = PyObject_Vectorcall(global_super, stack, oparg & 2, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) {
PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING;
if (super == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_Py_call_instrumentation_exc2(
tstate, PY_MONITORING_EVENT_C_RAISE,
frame, this_instr, global_super, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_C_RETURN,
frame, this_instr, global_super, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_CLEAR(super);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = self_st;
self_st = PyStackRef_NULL;
stack_pointer[-1] = self_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = class_st;
class_st = PyStackRef_NULL;
stack_pointer[-2] = class_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = global_super_st;
global_super_st = PyStackRef_NULL;
stack_pointer[-3] = global_super_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (super == NULL) {
}
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *attr_o = PyObject_GetAttr(super, name);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(super);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (attr_o == NULL) {
JUMP_TO_LABEL(error);
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(iter);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += 1;
}
stack_pointer += -1;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
INSTRUMENTED_JUMP(this_instr, next_instr + oparg, PY_MONITORING_EVENT_BRANCH_RIGHT);
}
else {
if (frame->tlbc_index !=
((_PyThreadStateImpl *)tstate)->tlbc_index) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_CODEUNIT *bytecode =
_PyEval_GetExecutableCode(tstate, _PyFrame_GetCode(frame));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (bytecode == NULL) {
JUMP_TO_LABEL(error);
}
uintptr_t code_version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version);
if (code_version != global_version) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_Instrument(_PyFrame_GetCode(frame), tstate->interp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
Test_EvalFrame_Resumes++;
if ((oparg & RESUME_OPARG_LOCATION_MASK) < RESUME_AFTER_YIELD_FROM) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
// _MONITOR_RESUME
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation(
tstate, oparg == 0 ? PY_MONITORING_EVENT_PY_START : PY_MONITORING_EVENT_PY_RESUME, frame, this_instr);
+ _PyFrame_StackPointerInvalidate(frame);
+ // Explicit stack reload
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackAssertInvalid(frame);
if (err) {
JUMP_TO_LABEL(error);
}
{
val = stack_pointer[-1];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_arg(
tstate, PY_MONITORING_EVENT_PY_RETURN,
frame, this_instr, PyStackRef_AsPyObjectBorrow(val));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(STACK_LEVEL() == 0);
DTRACE_FUNCTION_RETURN();
_Py_LeaveRecursiveCallPy(tstate);
frame = tstate->current_frame = dying->previous;
_PyEval_FrameClearAndPop(tstate, dying);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(frame->return_offset);
res = temp;
LLTRACE_RESUME_FRAME();
{
val = stack_pointer[-1];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_arg(
tstate, PY_MONITORING_EVENT_PY_YIELD,
frame, this_instr, PyStackRef_AsPyObjectBorrow(val));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
+ // Explicit stack reload
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackAssertInvalid(frame);
JUMP_TO_LABEL(error);
}
if (frame->instr_ptr != this_instr) {
+ // Explicit stack reload
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackAssertInvalid(frame);
next_instr = frame->instr_ptr;
DISPATCH();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
DTRACE_FUNCTION_RETURN();
tstate->exc_info = gen->gi_exc_state.previous_item;
gen->gi_exc_state.previous_item = NULL;
}
#endif
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND);
value = temp;
LLTRACE_RESUME_FRAME();
_PyStackRef executor = frame->localsplus[0];
assert(tstate->current_executor == NULL);
if (!PyStackRef_IsNull(executor)) {
+ assert(PyStackRef_TYPE(executor) == &_PyUOpExecutor_Type);
tstate->current_executor = PyStackRef_AsPyObjectBorrow(executor);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(executor);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += 1;
}
#endif
stack_pointer[-2] = b;
stack_pointer[-1] = l;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
// _CHECK_PERIODIC
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
// _CHECK_PERIODIC
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
// _CHECK_PERIODIC
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
PyObject *list = PyStackRef_AsPyObjectBorrow(list_st);
PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (none_val == NULL) {
int matches = _PyErr_ExceptionMatches(tstate, PyExc_TypeError);
if (matches &&
(Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable)))
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Clear(tstate);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_TypeError,
"Value after * must be an iterable, not %.200s",
Py_TYPE(iterable)->tp_name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1);
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_LoadAttr(owner, next_instr, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(LOAD_ATTR);
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 1);
if (oparg & 1) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
attr = _Py_LoadAttr_StackRefSteal(tstate, owner, name, self_or_null);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (PyStackRef_IsNull(attr)) {
JUMP_TO_LABEL(pop_1_error);
}
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
attr = _PyObject_GetAttrStackRef(PyStackRef_AsPyObjectBorrow(owner), name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer[-1] = attr;
stack_pointer += (oparg&1);
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(owner);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (PyStackRef_IsNull(attr)) {
JUMP_TO_LABEL(error);
}
assert(descr != NULL);
attr = PyStackRef_FromPyObjectNew(descr);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = owner;
owner = attr;
stack_pointer[-1] = owner;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _PUSH_NULL_CONDITIONAL
{
assert(descr != NULL);
attr = PyStackRef_FromPyObjectNew(descr);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = owner;
owner = attr;
stack_pointer[-1] = owner;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _PUSH_NULL_CONDITIONAL
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
value = o;
stack_pointer[-1] = attr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
/* Skip 5 cache entries */
// _PUSH_NULL_CONDITIONAL
value = o;
stack_pointer[-1] = attr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
/* Skip 5 cache entries */
// _PUSH_NULL_CONDITIONAL
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(owner);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
attr = PyStackRef_FromPyObjectNew(descr);
}
stack_pointer[0] = attr;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(owner);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
attr = PyStackRef_FromPyObjectNew(descr);
}
stack_pointer[0] = attr;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
value = o;
stack_pointer[-1] = attr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
/* Skip 5 cache entries */
// _PUSH_NULL_CONDITIONAL
value = o;
stack_pointer[-1] = attr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
/* Skip 5 cache entries */
// _PUSH_NULL_CONDITIONAL
_PyStackRef bc;
int err;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *bc_o = _PyMapping_GetOptionalItem2(BUILTINS(), &_Py_ID(__build_class__), &err);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
if (bc_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetString(tstate, PyExc_NameError,
"__build_class__ not found");
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
bc = PyStackRef_FromPyObjectSteal(bc_o);
_PyStackRef value;
PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
value = _PyCell_GetStackRef(cell);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (PyStackRef_IsNull(value)) {
stack_pointer[0] = value;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
stack_pointer[0] = value;
_PyStackRef value_s = GETLOCAL(oparg);
if (PyStackRef_IsNull(value_s)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError,
UNBOUNDLOCAL_ERROR_MSG,
PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg)
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
value = PyStackRef_DUP(value_s);
name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg);
int err;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject* value_o = _PyMapping_GetOptionalItem2(class_dict, name, &err);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));
value_o = PyCell_GetRef(cell);
if (value_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(class_dict_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
value = PyStackRef_FromPyObjectSteal(value_o);
stack_pointer[0] = value;
stack_pointer += 1;
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
int err;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *v_o = _PyMapping_GetOptionalItem2(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &err);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(mod_or_class_dict);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
if (PyDict_CheckExact(GLOBALS())
&& PyDict_CheckExact(BUILTINS()))
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
v_o = _PyDict_LoadGlobal((PyDictObject *)GLOBALS(),
(PyDictObject *)BUILTINS(),
name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (v_o == NULL) {
if (!_PyErr_Occurred(tstate)) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
NAME_ERROR_MSG, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
JUMP_TO_LABEL(error);
}
if (PyLazyImport_CheckExact(v_o)) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *l_v = _PyImport_LoadLazyImportTstate(tstate, v_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_SETREF(v_o, l_v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (v_o == NULL) {
JUMP_TO_LABEL(error);
}
}
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
v_o = _PyMapping_GetOptionalItem2(GLOBALS(), name, &err);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
if (v_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
v_o = _PyMapping_GetOptionalItem2(BUILTINS(), name, &err);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
if (v_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(
tstate, PyExc_NameError,
NAME_ERROR_MSG, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
}
if (PyLazyImport_CheckExact(v_o)) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *l_v = _PyImport_LoadLazyImportTstate(tstate, v_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_SETREF(v_o, l_v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (v_o == NULL) {
JUMP_TO_LABEL(error);
}
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1);
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_LoadGlobal(GLOBALS(), BUILTINS(), next_instr, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(LOAD_GLOBAL);
res = &stack_pointer[0];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_LoadGlobalStackRef(GLOBALS(), BUILTINS(), name, res);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (PyStackRef_IsNull(*res)) {
JUMP_TO_LABEL(error);
}
PyObject *l = LOCALS();
if (l == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetString(tstate, PyExc_SystemError,
"no locals found");
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
locals = PyStackRef_FromPyObjectNew(l);
_PyStackRef v;
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *v_o = _PyEval_LoadName(tstate, frame, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (v_o == NULL) {
JUMP_TO_LABEL(error);
}
if (PyLazyImport_CheckExact(v_o)) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *l_v = _PyImport_LoadLazyImportTstate(tstate, v_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (l_v == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(v_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = PyDict_SetItem(GLOBALS(), name, l_v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(v_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(l_v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_SETREF(v_o, l_v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
v = PyStackRef_FromPyObjectSteal(v_o);
stack_pointer[0] = v;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyObject_LookupSpecialMethod(name, method_and_self);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err <= 0) {
if (err == 0) {
PyObject *owner = PyStackRef_AsPyObjectBorrow(method_and_self[1]);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
const char *errfmt = _PyEval_SpecialMethodCanSuggest(owner, oparg)
? _Py_SpecialMethods[oparg].error_suggestion
: _Py_SpecialMethods[oparg].error;
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
assert(!_PyErr_Occurred(tstate));
assert(errfmt != NULL);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_TypeError, errfmt, owner);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
JUMP_TO_LABEL(error);
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_LoadSuperAttr(global_super_st, class_st, next_instr, load_method);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(LOAD_SUPER_ATTR);
if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) {
PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, global_super, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = self_st;
self_st = PyStackRef_NULL;
stack_pointer[-1] = self_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = class_st;
class_st = PyStackRef_NULL;
stack_pointer[-2] = class_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = global_super_st;
global_super_st = PyStackRef_NULL;
stack_pointer[-3] = global_super_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
JUMP_TO_LABEL(error);
{
PyObject *stack[] = {class, self};
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
super = PyObject_Vectorcall(global_super, stack, oparg & 2, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) {
PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING;
if (super == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_Py_call_instrumentation_exc2(
tstate, PY_MONITORING_EVENT_C_RAISE,
frame, this_instr, global_super, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_C_RETURN,
frame, this_instr, global_super, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_CLEAR(super);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = self_st;
self_st = PyStackRef_NULL;
stack_pointer[-1] = self_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = class_st;
class_st = PyStackRef_NULL;
stack_pointer[-2] = class_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = global_super_st;
global_super_st = PyStackRef_NULL;
stack_pointer[-3] = global_super_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (super == NULL) {
}
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *attr_o = PyObject_GetAttr(super, name);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(super);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (attr_o == NULL) {
JUMP_TO_LABEL(error);
}
STAT_INC(LOAD_SUPER_ATTR, hit);
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = self_st;
self_st = PyStackRef_NULL;
stack_pointer[-1] = self_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = class_st;
class_st = PyStackRef_NULL;
stack_pointer[-2] = class_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = global_super_st;
global_super_st = PyStackRef_NULL;
stack_pointer[-3] = global_super_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (attr == NULL) {
{
int *method_found_ptr = &method_found;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
attr_o = _PySuper_Lookup(cls, self, name,
Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? method_found_ptr : NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
if (attr_o == NULL) {
JUMP_TO_LABEL(error);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(self_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
self_or_null = PyStackRef_NULL;
stack_pointer += 1;
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = global_super_st;
global_super_st = self_or_null;
stack_pointer[-2] = global_super_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = class_st;
class_st = PyStackRef_NULL;
stack_pointer[-1] = class_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
attr = PyStackRef_FromPyObjectSteal(attr_o);
_PyStackRef tmp = GETLOCAL(oparg);
GETLOCAL(oparg) = PyStackRef_FromPyObjectSteal(cell);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
codeobj_st = stack_pointer[-1];
PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyFunctionObject *func_obj = (PyFunctionObject *)
PyFunction_New(codeobj, GLOBALS());
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (func_obj == NULL) {
JUMP_TO_LABEL(error);
}
{
value = co;
stack_pointer[-1] = func;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st);
assert(PyDict_CheckExact(dict));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyDict_SetItem_Take2(
(PyDictObject *)dict,
PyStackRef_AsPyObjectSteal(key),
PyStackRef_AsPyObjectSteal(value)
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(pop_2_error);
}
subject = stack_pointer[-3];
assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names)));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *attrs_o = _PyEval_MatchClass(tstate,
PyStackRef_AsPyObjectBorrow(subject),
PyStackRef_AsPyObjectBorrow(type), oparg,
PyStackRef_AsPyObjectBorrow(names));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (attrs_o) {
assert(PyTuple_CheckExact(attrs_o));
attrs = PyStackRef_FromPyObjectSteal(attrs_o);
stack_pointer[-3] = attrs;
stack_pointer[-2] = s;
stack_pointer[-1] = tp;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
keys = stack_pointer[-1];
subject = stack_pointer[-2];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *values_or_none_o = _PyEval_MatchKeys(tstate,
PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (values_or_none_o == NULL) {
JUMP_TO_LABEL(error);
}
exc_value = stack_pointer[-1];
_PyErr_StackItem *exc_info = tstate->exc_info;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_XSETREF(exc_info->exc_value,
PyStackRef_IsNone(exc_value)
? NULL : PyStackRef_AsPyObjectSteal(exc_value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
DISPATCH();
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(iter);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
else {
b = PyStackRef_False;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = value;
value = b;
stack_pointer[-1] = value;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _POP_JUMP_IF_TRUE
else {
b = PyStackRef_False;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = value;
value = b;
stack_pointer[-1] = value;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _POP_JUMP_IF_FALSE
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = do_raise(tstate, exc, cause);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
assert(oparg == 0);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
monitor_reraise(tstate, frame, this_instr);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
JUMP_TO_LABEL(exception_unwind);
}
JUMP_TO_LABEL(error);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetRaisedException(tstate, exc);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
monitor_reraise(tstate, frame, this_instr);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
JUMP_TO_LABEL(exception_unwind);
}
if (frame->tlbc_index !=
((_PyThreadStateImpl *)tstate)->tlbc_index) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_CODEUNIT *bytecode =
_PyEval_GetExecutableCode(tstate, _PyFrame_GetCode(frame));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (bytecode == NULL) {
JUMP_TO_LABEL(error);
}
uintptr_t code_version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version);
if (code_version != global_version) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_Instrument(_PyFrame_GetCode(frame), tstate->interp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_Resume(this_instr, tstate, frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_IF_NOT_YIELD_FROM
{
Test_EvalFrame_Resumes++;
if ((oparg & RESUME_OPARG_LOCATION_MASK) < RESUME_AFTER_YIELD_FROM) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
assert(PyStackRef_FunctionCheck(frame->f_funcobj));
PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (gen == NULL) {
JUMP_TO_LABEL(error);
}
assert(STACK_LEVEL() <= 2);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *gen_frame = &gen->gi_iframe;
frame->instr_ptr++;
_PyFrame_Copy(frame, gen_frame);
frame = tstate->current_frame = prev;
LOAD_IP(frame->return_offset);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
res = PyStackRef_FromPyObjectStealMortal((PyObject *)gen);
LLTRACE_RESUME_FRAME();
stack_pointer[0] = res;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(STACK_LEVEL() == 0);
DTRACE_FUNCTION_RETURN();
_Py_LeaveRecursiveCallPy(tstate);
frame = tstate->current_frame = dying->previous;
_PyEval_FrameClearAndPop(tstate, dying);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(frame->return_offset);
res = temp;
LLTRACE_RESUME_FRAME();
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_Send(receiver, next_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(SEND);
}
if (!PyStackRef_IsNull(null_or_index) && PyStackRef_IsNone(v)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef item = _PyForIter_VirtualIteratorNext(tstate, frame, receiver, &null_or_index);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (!PyStackRef_IsValid(item)) {
if (PyStackRef_IsError(item)) {
JUMP_TO_LABEL(error);
else {
PyObject *v_o = PyStackRef_AsPyObjectBorrow(v);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PySendResultPair res = _PyIter_Send(receiver_o, v_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res.kind == PYGEN_ERROR) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
retval = PyStackRef_FromPyObjectSteal(res.object);
if (res.kind == PYGEN_RETURN) {
JUMPBY(oparg);
PyObject *val = PyStackRef_AsPyObjectBorrow(v);
PyObject *retval_o;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PySendResult what = _PyAsyncGenASend_Send(iter_o, val, &retval_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (what == PYGEN_ERROR) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
asend = iter;
null_out = null_in;
retval = PyStackRef_FromPyObjectSteal(retval_o);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter);
Py_ssize_t index = PyStackRef_UntagInt(null_or_index);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyObjectIndexPair next_index = Py_TYPE(iter_o)->_tp_iteritem(iter_o, index);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
PyObject *next_o = next_index.object;
index = next_index.index;
if (next_o == NULL) {
INSTRUCTION_STATS(SETUP_ANNOTATIONS);
if (LOCALS() == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_SystemError,
"no locals found when setting up annotations");
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
int err;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject* ann_dict = _PyMapping_GetOptionalItem2(LOCALS(), &_Py_ID(__annotations__), &err);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
if (ann_dict == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
ann_dict = PyDict_New();
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (ann_dict == NULL) {
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__),
ann_dict);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(ann_dict);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(ann_dict);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
v = stack_pointer[-1];
set = stack_pointer[-2 - (oparg-1)];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PySet_AddTakeRef((PySetObject *)PyStackRef_AsPyObjectBorrow(set),
PyStackRef_AsPyObjectSteal(v));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(pop_1_error);
}
iterable = stack_pointer[-1];
set = stack_pointer[-2 - (oparg-1)];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set),
PyStackRef_AsPyObjectBorrow(iterable));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_StoreAttr(owner, next_instr, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(STORE_ATTR);
v = stack_pointer[-2];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner),
name, PyStackRef_AsPyObjectBorrow(v));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = owner;
owner = PyStackRef_NULL;
stack_pointer[-1] = owner;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = v;
v = PyStackRef_NULL;
stack_pointer[-2] = v;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (err) {
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_XDECREF(old_value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_XDECREF(old_value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
}
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyDict_NotifyEvent(PyDict_EVENT_MODIFIED, dict, name, PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
FT_ATOMIC_STORE_PTR_RELEASE(ep->me_value, PyStackRef_AsPyObjectSteal(value));
UNLOCK_OBJECT(dict);
STAT_INC(STORE_ATTR, hit);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_XDECREF(old_value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
v = stack_pointer[-1];
PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
DISPATCH();
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
value2 = PyStackRef_DUP(GETLOCAL(oparg2));
stack_pointer[-1] = value2;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
tmp = GETLOCAL(oparg2);
GETLOCAL(oparg2) = value2;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
v = stack_pointer[-1];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
int err;
if (ns == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_SystemError,
"no locals found when storing %R", name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
if (PyDict_CheckExact(ns)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
container = stack_pointer[-3];
v = stack_pointer[-4];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start),
PyStackRef_AsPyObjectSteal(stop),
Py_None);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
int err;
if (slice == NULL) {
err = 1;
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), slice, PyStackRef_AsPyObjectBorrow(v));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(slice);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += 2;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = container;
container = PyStackRef_NULL;
stack_pointer[-3] = container;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = v;
v = PyStackRef_NULL;
stack_pointer[-4] = v;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -4;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (err) {
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_StoreSubscr(container, sub, next_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(STORE_SUBSCR);
{
v = stack_pointer[-3];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = sub;
sub = PyStackRef_NULL;
stack_pointer[-1] = sub;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = container;
container = PyStackRef_NULL;
stack_pointer[-2] = container;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = v;
v = PyStackRef_NULL;
stack_pointer[-3] = v;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (err) {
assert(Py_TYPE(dict)->tp_as_mapping->mp_ass_subscript == _PyDict_StoreSubscript);
STAT_INC(STORE_SUBSCR, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyDict_SetItem_Take2((PyDictObject *)dict,
PyStackRef_AsPyObjectSteal(sub),
PyStackRef_AsPyObjectSteal(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(dict_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
st = dict_st;
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(old_value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP_INT
{
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_ToBool(value, next_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(TO_BOOL);
// _TO_BOOL
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
value = v;
stack_pointer[-1] = res;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
value = v;
stack_pointer[-1] = res;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
_PyJitTracerState *tracer = _tstate->jit_tracer_state;
assert(tracer != NULL);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int full = !_PyJit_translate_single_bytecode_to_trace(tstate, frame, next_instr, stop_tracing ? _DEOPT : 0);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (full) {
LEAVE_TRACING();
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = stop_tracing_and_jit(tstate, frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
DISPATCH();
}
for (int i = 0; i < tracer->prev_state.recorded_count; i++) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_CLEAR(tracer->prev_state.recorded_values[i]);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
tracer->prev_state.recorded_count = 0;
tracer->prev_state.instr = next_instr;
PyObject *prev_code = PyStackRef_AsPyObjectBorrow(frame->f_executable);
if (tracer->prev_state.instr_code != (PyCodeObject *)prev_code) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_SETREF(tracer->prev_state.instr_code, (PyCodeObject*)Py_NewRef((prev_code)));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
tracer->prev_state.instr_frame = frame;
tracer->prev_state.instr_oparg = oparg;
{
value = stack_pointer[-1];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
{
value = v;
stack_pointer[-1] = res;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
{
value = stack_pointer[-1];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
{
value = v;
stack_pointer[-1] = res;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg & 0xFF, oparg >> 8, top);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(seq_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res == 0) {
JUMP_TO_LABEL(error);
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_UnpackSequence(seq, next_instr, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(UNPACK_SEQUENCE);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg, -1, top);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(seq_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res == 0) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1 + oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(seq);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += -1 + oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(seq);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(seq);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *stack[5] = {NULL, PyStackRef_AsPyObjectBorrow(exit_self), exc, val_o, tb};
int has_self = !PyStackRef_IsNull(exit_self);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = PyObject_Vectorcall(exit_func_o, stack + 2 - has_self,
(3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_XDECREF(original_tb);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
DTRACE_FUNCTION_RETURN();
tstate->exc_info = gen->gi_exc_state.previous_item;
gen->gi_exc_state.previous_item = NULL;
}
#endif
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND);
value = temp;
LLTRACE_RESUME_FRAME();
LABEL(error)
{
+ _PyFrame_StackAssertInvalid(frame);
#ifdef NDEBUG
if (!_PyErr_Occurred(tstate)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetString(tstate, PyExc_SystemError,
"error return without exception set");
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
#else
assert(_PyErr_Occurred(tstate));
#endif
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
STOP_TRACING();
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
assert(frame->owner != FRAME_OWNED_BY_INTERPRETER);
if (!_PyFrame_IsIncomplete(frame)) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyFrameObject *f = _PyFrame_GetFrameObject(frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (f != NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyTraceBack_Here(f);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_MonitorRaise(tstate, frame, next_instr-1);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
JUMP_TO_LABEL(exception_unwind);
}
}
#endif
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
#if _Py_TAIL_CALL_INTERP
int opcode;
#endif
}
next_instr = frame->instr_ptr;
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
LABEL(start_frame)
{
+ #ifdef Py_DEBUG
+ assert(frame->stackpointer_valid == 1);
+ #endif
int too_deep = _Py_EnterRecursivePy(tstate);
if (too_deep) {
JUMP_TO_LABEL(exit_unwind_notrace);
assert(!_PyErr_Occurred(tstate));
#endif
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
#if _Py_TAIL_CALL_INTERP
int opcode;
#endif
assert(IS_JIT_TRACING());
int opcode = next_instr->op.code;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyJit_translate_single_bytecode_to_trace(tstate, frame, NULL, _EXIT_TRACE);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LEAVE_TRACING();
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = stop_tracing_and_jit(tstate, frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
op(_MONITOR_RESUME, (--)) {
int err = _Py_call_instrumentation(
tstate, oparg == 0 ? PY_MONITORING_EVENT_PY_START : PY_MONITORING_EVENT_PY_RESUME, frame, this_instr);
+ RELOAD_STACK();
ERROR_IF(err);
if (frame->instr_ptr != this_instr) {
/* Instrumentation has jumped */
_PyStackRef executor = frame->localsplus[0];
assert(tstate->current_executor == NULL);
if (!PyStackRef_IsNull(executor)) {
+ assert(PyStackRef_TYPE(executor) == &_PyUOpExecutor_Type);
tstate->current_executor = PyStackRef_AsPyObjectBorrow(executor);
PyStackRef_CLOSE(executor);
}
tstate, PY_MONITORING_EVENT_PY_YIELD,
frame, this_instr, PyStackRef_AsPyObjectBorrow(val));
if (err) {
+ RELOAD_STACK();
ERROR_NO_POP();
}
if (frame->instr_ptr != this_instr) {
+ RELOAD_STACK();
next_instr = frame->instr_ptr;
DISPATCH();
}
assert(!IS_PEP523_HOOKED(tstate));
_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
DEAD(new_frame);
- SYNC_SP();
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ SAVE_STACK();
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ RELOAD_STACK();
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
} else {
original_opcode = _Py_call_instrumentation_line(
tstate, frame, this_instr, prev_instr);
+ RELOAD_STACK();
if (original_opcode < 0) {
next_instr = this_instr+1;
goto error;
}
next_instr = frame->instr_ptr;
if (next_instr != this_instr) {
- SYNC_SP();
DISPATCH();
}
}
PAUSE_ADAPTIVE_COUNTER(cache->counter);
}
opcode = original_opcode;
+ PRE_DISPATCH_GOTO();
DISPATCH_GOTO();
}
}
label(error) {
+ _PyFrame_StackAssertInvalid(frame);
/* Double-check exception status. */
#ifdef NDEBUG
if (!_PyErr_Occurred(tstate)) {
}
spilled label(exception_unwind) {
- SAVE_STACK();
STOP_TRACING();
- RELOAD_STACK();
/* We can't use frame->instr_ptr here, as RERAISE may have set it */
int offset = INSTR_OFFSET()-1;
int level, handler, lasti;
}
spilled label(start_frame) {
+ #ifdef Py_DEBUG
+ assert(frame->stackpointer_valid == 1);
+ #endif
int too_deep = _Py_EnterRecursivePy(tstate);
if (too_deep) {
goto exit_unwind_notrace;
entry.frame.return_offset = 0;
#ifdef Py_DEBUG
entry.frame.lltrace = 0;
+ entry.frame.stackpointer_valid = 1;
#endif
/* Push frame */
entry.frame.previous = tstate->current_frame;
entry.frame.localsplus[0] = PyStackRef_NULL;
#ifdef _Py_TIER2
if (tstate->current_executor != NULL) {
+ assert(Py_TYPE(tstate->current_executor) == &_PyUOpExecutor_Type);
entry.frame.localsplus[0] = PyStackRef_FromPyObjectNew(tstate->current_executor);
tstate->current_executor = NULL;
}
next_instr = frame->instr_ptr;
monitor_throw(tstate, frame, next_instr);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
#if _Py_TAIL_CALL_INTERP
# if Py_STATS
return _TAIL_CALL_error(frame, stack_pointer, tstate, next_instr, instruction_funcptr_handler_table, 0, lastopcode);
/* Do interpreter dispatch accounting for tracing and instrumentation */
#define DISPATCH() \
{ \
- assert(frame->stackpointer == NULL); \
+ _PyFrame_StackAssertInvalid(frame); \
NEXTOPARG(); \
PRE_DISPATCH_GOTO(); \
DISPATCH_GOTO(); \
#define DISPATCH_NON_TRACING() \
{ \
- assert(frame->stackpointer == NULL); \
+ _PyFrame_StackAssertInvalid(frame); \
NEXTOPARG(); \
PRE_DISPATCH_GOTO(); \
DISPATCH_GOTO_NON_TRACING(); \
do { \
assert(!IS_PEP523_HOOKED(tstate)); \
_PyFrame_SetStackPointer(frame, stack_pointer); \
+ _PyFrame_StackPointerValidate(frame); \
assert((NEW_FRAME)->previous == frame); \
frame = tstate->current_frame = (NEW_FRAME); \
CALL_STAT_INC(inlined_py_calls); \
STAT_INC(opcode, miss); \
STAT_INC((INSTNAME), miss); \
/* The counter is always the first cache entry: */ \
- if (ADAPTIVE_COUNTER_TRIGGERS(next_instr->cache)) { \
+ if (ADAPTIVE_COUNTER_TRIGGERS(next_instr->cache)) { \
STAT_INC((INSTNAME), deopt); \
} \
} while (0)
CHECK_CURRENT_CACHED_VALUES(0);
ASSERT_WITHIN_STACK_BOUNDS_IGNORING_CACHE(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
oparg = CURRENT_OPARG();
if ((oparg & RESUME_OPARG_LOCATION_MASK) < RESUME_AFTER_YIELD_FROM) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
_PyStackRef value_s = GETLOCAL(oparg);
if (PyStackRef_IsNull(value_s)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError,
UNBOUNDLOCAL_ERROR_MSG,
PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg)
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError,
UNBOUNDLOCAL_ERROR_MSG,
PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg)
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError,
UNBOUNDLOCAL_ERROR_MSG,
PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg)
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
_PyStackRef _stack_item_0 = _tos_cache0;
value = _stack_item_0;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
oparg = CURRENT_OPARG();
args = &stack_pointer[-oparg];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef_CloseStack(args, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
_PyStackRef _stack_item_0 = _tos_cache0;
value = _stack_item_0;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
iter = _stack_item_0;
(void)index_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(iter);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(receiver);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = val;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyErr_SetString(PyExc_ZeroDivisionError,
"float division by zero");
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
PyObject *right_o = PyStackRef_AsPyObjectSteal(right);
PyStackRef_CLOSE_SPECIALIZED(left, _PyUnicode_ExactDealloc);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyUnicode_Append(&temp, right_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
*target_local = PyStackRef_NULL;
if (temp == NULL) {
SET_CURRENT_CACHED_VALUES(0);
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int match = (d->guard != NULL)
? d->guard(left_o, right_o)
: (Py_TYPE(left_o) == d->lhs_type && Py_TYPE(right_o) == d->rhs_type);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (!match) {
UOP_STAT_INC(uopcode, miss);
_tos_cache1 = right;
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = d->action(left_o, right_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyList_BinarySlice(container_o, start_o, stop_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else if (PyTuple_CheckExact(container_o)) {
stack_pointer[0] = container;
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyTuple_BinarySlice(container_o, start_o, stop_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else if (PyUnicode_CheckExact(container_o)) {
stack_pointer[0] = container;
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyUnicode_BinarySlice(container_o, start_o, stop_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
PyObject *slice = PySlice_New(start_o, stop_o, NULL);
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = PyObject_GetItem(container_o, slice);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(slice);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
}
stack_pointer += 3;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = stop;
stop = PyStackRef_NULL;
stack_pointer[-3] = container;
stack_pointer[-2] = start;
stack_pointer[-1] = stop;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = start;
start = PyStackRef_NULL;
stack_pointer[-2] = start;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = container;
container = PyStackRef_NULL;
stack_pointer[-3] = container;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res_o == NULL) {
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start),
PyStackRef_AsPyObjectSteal(stop),
Py_None);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
int err;
if (slice == NULL) {
err = 1;
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), slice, PyStackRef_AsPyObjectBorrow(v));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(slice);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += 2;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = container;
container = PyStackRef_NULL;
stack_pointer[-3] = container;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = v;
v = PyStackRef_NULL;
stack_pointer[-4] = v;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -4;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (err) {
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyList_GetItemRef((PyListObject*)list, index);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
UOP_STAT_INC(uopcode, miss);
_tos_cache1 = sub_st;
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyList_SliceSubscript(list, sub);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
STAT_INC(BINARY_OP, hit);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyDict_SubscriptKnownHash(dict, sub, (Py_hash_t)hash);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyDict_Subscript(dict, sub);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PySet_AddTakeRef((PySetObject *)PyStackRef_AsPyObjectBorrow(set),
PyStackRef_AsPyObjectSteal(v));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = sub;
sub = PyStackRef_NULL;
stack_pointer[-1] = sub;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = container;
container = PyStackRef_NULL;
stack_pointer[-2] = container;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = v;
v = PyStackRef_NULL;
stack_pointer[-3] = v;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (err) {
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(old_value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache1 = ss;
_tos_cache0 = ls;
_tos_cache2 = PyStackRef_ZERO_BITS;
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyDict_SetItem_Take2((PyDictObject *)dict,
PyStackRef_AsPyObjectSteal(sub),
PyStackRef_AsPyObjectSteal(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(dict_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyDict_SetItem_Take2_KnownHash((PyDictObject *)dict,
PyStackRef_AsPyObjectSteal(sub),
PyStackRef_AsPyObjectSteal(value),
(Py_hash_t)hash);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(dict_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container),
PyStackRef_AsPyObjectBorrow(sub));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = sub;
sub = PyStackRef_NULL;
stack_pointer[-1] = sub;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = container;
container = PyStackRef_NULL;
stack_pointer[-2] = container;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (err) {
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
assert(frame->owner != FRAME_OWNED_BY_INTERPRETER);
_PyStackRef temp = retval;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(STACK_LEVEL() == 0);
DTRACE_FUNCTION_RETURN();
_Py_LeaveRecursiveCallPy(tstate);
frame = tstate->current_frame = dying->previous;
_PyEval_FrameClearAndPop(tstate, dying);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(frame->return_offset);
res = temp;
LLTRACE_RESUME_FRAME();
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_TypeError,
"'async for' requires an object with "
"__aiter__ method, got %.100s",
type->tp_name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(obj);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
iter_o = (*getter)(obj_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(obj);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (iter_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
if (Py_TYPE(iter_o)->tp_as_async == NULL ||
Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_TypeError,
"'async for' received an object from __aiter__ "
"that does not implement __anext__: %.100s",
Py_TYPE(iter_o)->tp_name);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(iter_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *awaitable_o = _PyEval_GetANext(PyStackRef_AsPyObjectBorrow(aiter));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (awaitable_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(iterable);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (iter_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PySendResult what = _PyAsyncGenASend_Send(iter_o, val, &retval_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (what == PYGEN_ERROR) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
asend = iter;
null_out = null_in;
retval = PyStackRef_FromPyObjectSteal(retval_o);
assert(oparg == 0 || oparg == 1);
_PyStackRef temp = retval;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
DTRACE_FUNCTION_RETURN();
tstate->exc_info = gen->gi_exc_state.previous_item;
gen->gi_exc_state.previous_item = NULL;
}
#endif
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND);
value = temp;
LLTRACE_RESUME_FRAME();
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_XSETREF(exc_info->exc_value,
PyStackRef_IsNone(exc_value)
? NULL : PyStackRef_AsPyObjectSteal(exc_value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
_PyStackRef bc;
int err;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *bc_o = _PyMapping_GetOptionalItem2(BUILTINS(), &_Py_ID(__build_class__), &err);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
if (bc_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetString(tstate, PyExc_NameError,
"__build_class__ not found");
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_SystemError,
"no locals found when storing %R", name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
stack_pointer[0] = v;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
int err;
if (ns == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_SystemError,
"no locals when deleting %R", name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
err = PyObject_DelItem(ns, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
NAME_ERROR_MSG,
name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
top = &stack_pointer[oparg];
PyObject *seq_o = PyStackRef_AsPyObjectSteal(seq);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg, -1, top);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(seq_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res == 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(seq);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache1 = val0;
_tos_cache0 = val1;
_tos_cache2 = PyStackRef_ZERO_BITS;
stack_pointer += oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(seq);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
stack_pointer += oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(seq);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
top = &stack_pointer[1 + (oparg & 0xFF) + (oparg >> 8)];
PyObject *seq_o = PyStackRef_AsPyObjectSteal(seq);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg & 0xFF, oparg >> 8, top);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(seq_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res == 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner),
name, PyStackRef_AsPyObjectBorrow(v));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = owner;
owner = PyStackRef_NULL;
stack_pointer[-1] = owner;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = v;
v = PyStackRef_NULL;
stack_pointer[-2] = v;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (err) {
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(owner);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
oparg = CURRENT_OPARG();
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyDict_Pop(GLOBALS(), name, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
if (err == 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
NAME_ERROR_MSG, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
PyObject *l = LOCALS();
if (l == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetString(tstate, PyExc_SystemError,
"no locals found");
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetString(tstate, PyExc_SystemError,
"no locals found");
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetString(tstate, PyExc_SystemError,
"no locals found");
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
oparg = CURRENT_OPARG();
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *v_o = _PyEval_LoadName(tstate, frame, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (v_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
if (PyLazyImport_CheckExact(v_o)) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *l_v = _PyImport_LoadLazyImportTstate(tstate, v_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (l_v == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(v_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = PyDict_SetItem(GLOBALS(), name, l_v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(v_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(l_v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_SETREF(v_o, l_v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
v = PyStackRef_FromPyObjectSteal(v_o);
_tos_cache0 = v;
res = &stack_pointer[0];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_LoadGlobalStackRef(GLOBALS(), BUILTINS(), name, res);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (PyStackRef_IsNull(*res)) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
_PyStackRef v = GETLOCAL(oparg);
if (PyStackRef_IsNull(v)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError,
UNBOUNDLOCAL_ERROR_MSG,
PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg)
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
_PyStackRef tmp = GETLOCAL(oparg);
GETLOCAL(oparg) = PyStackRef_NULL;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
_PyStackRef tmp = GETLOCAL(oparg);
GETLOCAL(oparg) = PyStackRef_FromPyObjectSteal(cell);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
PyObject *oldobj = PyCell_SwapTakeRef((PyCellObject *)cell, NULL);
if (oldobj == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(oldobj);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject* value_o = _PyMapping_GetOptionalItem2(class_dict, name, &err);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));
value_o = PyCell_GetRef(cell);
if (value_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(class_dict_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
value = PyStackRef_FromPyObjectSteal(value_o);
_tos_cache0 = value;
_tos_cache1 = PyStackRef_ZERO_BITS;
oparg = CURRENT_OPARG();
PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
value = _PyCell_GetStackRef(cell);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (PyStackRef_IsNull(value)) {
stack_pointer[0] = value;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
oparg = CURRENT_OPARG();
pieces = &stack_pointer[-oparg];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *str_o = _Py_BuildString_StackRefSteal(pieces, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (str_o == NULL) {
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
format_o = &_Py_STR(empty);
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *interpolation_o = _PyInterpolation_Build(value_o, str_o, conversion, format_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (oparg & 1) {
stack_pointer += -(oparg & 1);
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(format[0]);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
stack_pointer += -(oparg & 1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(str);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (interpolation_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *template_o = _PyTemplate_Build(strings_o, interpolations_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(interpolations);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(strings);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (template_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
oparg = CURRENT_OPARG();
values = &stack_pointer[-oparg];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *list_o = _PyList_FromStackRefStealOnSuccess(values, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (list_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (none_val == NULL) {
int matches = _PyErr_ExceptionMatches(tstate, PyExc_TypeError);
if (matches &&
(Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable)))
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Clear(tstate);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_TypeError,
"Value after * must be an iterable, not %.200s",
Py_TYPE(iterable)->tp_name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set),
PyStackRef_AsPyObjectBorrow(iterable));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
oparg = CURRENT_OPARG();
values = &stack_pointer[-oparg];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *set_o = PySet_New(NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (set_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
tmp = values[_i];
values[_i] = PyStackRef_NULL;
PyStackRef_CLOSE(tmp);
}
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
SET_CURRENT_CACHED_VALUES(0);
_PyStackRef value = values[i];
values[i] = PyStackRef_NULL;
if (err == 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
err = _PySet_AddTakeRef((PySetObject *)set_o, PyStackRef_AsPyObjectSteal(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
if (err) {
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(set_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
oparg = CURRENT_OPARG();
values = &stack_pointer[-oparg*2];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *map_o = _Py_BuildMap_StackRefSteal(values, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (map_o == NULL) {
stack_pointer += -oparg*2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
ASSERT_WITHIN_STACK_BOUNDS_IGNORING_CACHE(__FILE__, __LINE__);
if (LOCALS() == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_SystemError,
"no locals found when setting up annotations");
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
int err;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject* ann_dict = _PyMapping_GetOptionalItem2(LOCALS(), &_Py_ID(__annotations__), &err);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
if (ann_dict == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
ann_dict = PyDict_New();
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (ann_dict == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__),
ann_dict);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(ann_dict);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(ann_dict);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyDict_Update(dict_o, update_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
int matches = _PyErr_ExceptionMatches(tstate, PyExc_AttributeError);
if (matches) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *exc = _PyErr_GetRaisedException(tstate);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int has_keys = PyObject_HasAttrWithError(update_o, &_Py_ID(keys));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (has_keys == 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_TypeError,
"'%T' object is not a mapping",
update_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(exc);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_ChainExceptions1(exc);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
SET_CURRENT_CACHED_VALUES(0);
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyDict_MergeUniq(dict_o, update_o, &dupkey);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatKwargsError(tstate, callable_o, update_o, dupkey);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_XDECREF(dupkey);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyDict_SetItem_Take2(
(PyDictObject *)dict,
PyStackRef_AsPyObjectSteal(key),
PyStackRef_AsPyObjectSteal(value)
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = self_st;
self_st = PyStackRef_NULL;
stack_pointer[-1] = self_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = class_st;
class_st = PyStackRef_NULL;
stack_pointer[-2] = class_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = global_super_st;
global_super_st = PyStackRef_NULL;
stack_pointer[-3] = global_super_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (attr == NULL) {
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
attr_o = _PySuper_Lookup(cls, self, name,
Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? method_found_ptr : NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
if (attr_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(self_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
self_or_null = PyStackRef_NULL;
stack_pointer += 1;
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = global_super_st;
global_super_st = self_or_null;
stack_pointer[-2] = global_super_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = class_st;
class_st = PyStackRef_NULL;
stack_pointer[-1] = class_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
attr = PyStackRef_FromPyObjectSteal(attr_o);
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
attr = _Py_LoadAttr_StackRefSteal(tstate, owner, name, self_or_null);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (PyStackRef_IsNull(attr)) {
stack_pointer[-1] = attr;
stack_pointer += (oparg&1);
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
attr = _PyObject_GetAttrStackRef(PyStackRef_AsPyObjectBorrow(owner), name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer[-1] = attr;
stack_pointer += (oparg&1);
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(owner);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (PyStackRef_IsNull(attr)) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = owner;
owner = attr;
stack_pointer[-1] = owner;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = attr;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_XDECREF(old_value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = o;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyDict_NotifyEvent(PyDict_EVENT_MODIFIED, dict, name, PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
FT_ATOMIC_STORE_PTR_RELEASE(ep->me_value, PyStackRef_AsPyObjectSteal(value));
UNLOCK_OBJECT(dict);
STAT_INC(STORE_ATTR, hit);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_XDECREF(old_value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = o;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_XDECREF(old_value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = o;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = right;
right = PyStackRef_NULL;
stack_pointer[-1] = right;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = left;
left = PyStackRef_NULL;
stack_pointer[-2] = left;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res_o == NULL) {
}
if (oparg & 16) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res_bool = PyObject_IsTrue(res_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(res_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_bool < 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res = PySequence_Contains(right_o, left_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res < 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res = _PySet_Contains((PySetObject *)right_o, left_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res < 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res = PyDict_Contains(right_o, left_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res < 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = match_type_st;
match_type_st = PyStackRef_NULL;
stack_pointer[-1] = match_type_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = exc_value_st;
exc_value_st = PyStackRef_NULL;
stack_pointer[-2] = exc_value_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
SET_CURRENT_CACHED_VALUES(0);
}
PyObject *match_o = NULL;
PyObject *rest_o = NULL;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int res = _PyEval_ExceptionGroupMatch(frame, exc_value, match_type,
&match_o, &rest_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = match_type_st;
match_type_st = PyStackRef_NULL;
stack_pointer[-1] = match_type_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = exc_value_st;
exc_value_st = PyStackRef_NULL;
stack_pointer[-2] = exc_value_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res < 0) {
}
if (!Py_IsNone(match_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyErr_SetHandledException(match_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
rest = PyStackRef_FromPyObjectSteal(rest_o);
match = PyStackRef_FromPyObjectSteal(match_o);
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyEval_CheckExceptTypeValid(tstate, right_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int res = PyErr_GivenExceptionMatches(left_o, right_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(right);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
b = res ? PyStackRef_True : PyStackRef_False;
_tos_cache1 = b;
_tos_cache0 = left;
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyEval_LazyImportName(tstate, BUILTINS(), GLOBALS(),
LOCALS(), name,
PyStackRef_AsPyObjectBorrow(fromlist),
PyStackRef_AsPyObjectBorrow(level),
oparg & 0x01);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
stack_pointer[0] = level;
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyEval_ImportName(tstate, BUILTINS(), GLOBALS(),
LOCALS(), name,
PyStackRef_AsPyObjectBorrow(fromlist),
PyStackRef_AsPyObjectBorrow(level));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = fromlist;
fromlist = PyStackRef_NULL;
stack_pointer[-1] = fromlist;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = level;
level = PyStackRef_NULL;
stack_pointer[-2] = level;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res_o == NULL) {
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyEval_LazyImportFrom(
tstate, frame, PyStackRef_AsPyObjectBorrow(from), name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
stack_pointer[0] = from;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyEval_ImportFrom(
tstate, PyStackRef_AsPyObjectBorrow(from), name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
if (res_o == NULL) {
stack_pointer[-1] = from;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = value;
value = b;
stack_pointer[-1] = value;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
}
_tos_cache0 = b;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (len_i < 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *attrs_o = _PyEval_MatchClass(tstate,
PyStackRef_AsPyObjectBorrow(subject),
PyStackRef_AsPyObjectBorrow(type), oparg,
PyStackRef_AsPyObjectBorrow(names));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (attrs_o) {
assert(PyTuple_CheckExact(attrs_o));
attrs = PyStackRef_FromPyObjectSteal(attrs_o);
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *values_or_none_o = _PyEval_MatchKeys(tstate,
PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (values_or_none_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef result = _PyEval_GetIter(iterable, &index_or_null, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (PyStackRef_IsError(result)) {
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *iter_o = PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(iterable);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (iter_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef item = _PyForIter_VirtualIteratorNext(tstate, frame, iter, &null_or_index);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (!PyStackRef_IsValid(item)) {
if (PyStackRef_IsError(item)) {
stack_pointer[-1] = null_or_index;
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *item = iternext_v(PyStackRef_AsPyObjectBorrow(iter));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (item == NULL) {
if (_PyErr_Occurred(tstate)) {
if (_PyErr_ExceptionMatches(tstate, PyExc_StopIteration)) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_MonitorRaise(tstate, frame, frame->instr_ptr);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Clear(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
SET_CURRENT_CACHED_VALUES(0);
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyObjectIndexPair next_index = Py_TYPE(iter_o)->_tp_iteritem(iter_o, index);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
PyObject *next_o = next_index.object;
index = next_index.index;
if (next_o == NULL) {
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int result = _PyList_GetItemRefNoLock((PyListObject *)list_o, PyStackRef_UntagInt(null_or_index), &next);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (result <= 0) {
UOP_STAT_INC(uopcode, miss);
_tos_cache1 = null_or_index;
method_and_self = &stack_pointer[-2];
PyObject *name = _Py_SpecialMethods[oparg].name;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyObject_LookupSpecialMethod(name, method_and_self);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err <= 0) {
if (err == 0) {
PyObject *owner = PyStackRef_AsPyObjectBorrow(method_and_self[1]);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
const char *errfmt = _PyEval_SpecialMethodCanSuggest(owner, oparg)
? _Py_SpecialMethods[oparg].error_suggestion
: _Py_SpecialMethods[oparg].error;
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
assert(!_PyErr_Occurred(tstate));
assert(errfmt != NULL);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_TypeError, errfmt, owner);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = PyObject_Vectorcall(exit_func_o, stack + 2 - has_self,
(3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_XDECREF(original_tb);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(owner);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
attr = PyStackRef_FromPyObjectNew(descr);
_tos_cache0 = attr;
_tos_cache1 = PyStackRef_ZERO_BITS;
STAT_INC(LOAD_ATTR, hit);
assert(descr != NULL);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(owner);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
attr = PyStackRef_FromPyObjectNew(descr);
_tos_cache0 = attr;
_tos_cache1 = PyStackRef_ZERO_BITS;
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
tstate, callable, locals,
args, total_args, NULL, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (temp == NULL) {
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
total_args++;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _Py_VectorCall_StackRefSteal(
callable,
arguments,
total_args,
PyStackRef_NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
assert(!IS_PEP523_HOOKED(tstate));
_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
SET_CURRENT_CACHED_VALUES(0);
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyObject_Str(arg_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PySequence_Tuple(arg_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *self_o = PyType_GenericAlloc(tp, 0);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (self_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
callable = PyStackRef_FromPyObjectNew(init_func);
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
self = stack_pointer[-1 - oparg];
init = stack_pointer[-2 - oparg];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked(
tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
assert(_PyFrame_GetBytecode(shim)[0].op.code == EXIT_INIT_CHECK);
assert(_PyFrame_GetBytecode(shim)[1].op.code == RETURN_VALUE);
shim->localsplus[0] = PyStackRef_DUP(self);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
tstate, init, NULL, args-1, oparg+1, NULL, shim);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (temp == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FrameClearAndPop(tstate, shim);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyErr_Format(PyExc_TypeError,
"__init__() should return None, not '%.200s'",
Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
}
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _Py_CallBuiltinClass_StackRef(
callable,
arguments,
total_args);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o);
_PyStackRef arg = args[0];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
if (res_o == NULL) {
}
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _Py_BuiltinCallFast_StackRef(
callable,
arguments,
total_args
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
}
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _Py_BuiltinCallFastWithKeywords_StackRef(callable, arguments, total_args);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_ssize_t len_i = PyObject_Length(arg_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (len_i < 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int retval = PyObject_IsInstance(inst_o, cls_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (retval < 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(cls);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(instance);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(callable);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
res = retval ? PyStackRef_True : PyStackRef_False;
assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL));
_tos_cache0 = res;
PyObject *self = PyStackRef_AsPyObjectBorrow(arguments[0]);
PyObject *arg = PyStackRef_AsPyObjectBorrow(arguments[1]);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
if (res_o == NULL) {
PyObject *self = PyStackRef_AsPyObjectBorrow(args[0]);
PyObject *arg = PyStackRef_AsPyObjectBorrow(args[1]);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc_v, self, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
if (res_o == NULL) {
assert(self != NULL);
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyCFunctionFastWithKeywords cfunc = _PyCFunctionFastWithKeywords_CAST(method->d_method->ml_meth);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCallMethodDescriptorFastWithKeywords_StackRef(
callable,
cfunc,
arguments,
total_args
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
PyObject *self = PyStackRef_AsPyObjectBorrow(self_st);
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
volatile PyCFunctionFastWithKeywords cfunc_v = _PyCFunctionFastWithKeywords_CAST(cfunc);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCallMethodDescriptorFastWithKeywords_StackRef(
callable,
cfunc_v,
args - 1,
oparg + 1
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
STAT_INC(CALL, hit);
PyCFunction cfunc = method->d_method->ml_meth;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
if (res_o == NULL) {
STAT_INC(CALL, hit);
volatile PyCFunction cfunc_v = (PyCFunction)cfunc;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc_v, self, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
if (res_o == NULL) {
assert(self != NULL);
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyCFunctionFast cfunc = _PyCFunctionFast_CAST(method->d_method->ml_meth);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCallMethodDescriptorFast_StackRef(
callable,
cfunc,
arguments,
total_args
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
assert(self != NULL);
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
volatile PyCFunctionFast cfunc_v = _PyCFunctionFast_CAST(cfunc);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCallMethodDescriptorFast_StackRef(
callable,
cfunc_v,
args - 1,
oparg + 1
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = PyStackRef_ZERO_BITS;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
}
_tos_cache0 = _stack_item_0;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
tstate, callable, locals,
arguments, positional_args, kwnames_o, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(kwnames);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (temp == NULL) {
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(callable_s);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_tos_cache0 = _stack_item_0;
_tos_cache1 = PyStackRef_ZERO_BITS;
_tos_cache2 = PyStackRef_ZERO_BITS;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _Py_VectorCall_StackRefSteal(
callable,
arguments,
total_args,
kwnames);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
stack_pointer += -3 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *tuple_o = PySequence_Tuple(callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (tuple_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
_PyStackRef temp = callargs;
callargs = PyStackRef_FromPyObjectSteal(tuple_o);
stack_pointer[-2] = callargs;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
}
_tos_cache2 = _stack_item_2;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(
tstate, func_st, locals,
nargs, callargs, kwargs, frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (new_frame == NULL) {
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *result_o = PyObject_Call(func, callargs, kwargs);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(kwargs_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(callargs_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(func_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (result_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyFunctionObject *func_obj = (PyFunctionObject *)
PyFunction_New(codeobj, GLOBALS());
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (func_obj == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
assert(PyStackRef_FunctionCheck(frame->f_funcobj));
PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (gen == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
}
assert(STACK_LEVEL() <= 2);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *gen_frame = &gen->gi_iframe;
frame->instr_ptr++;
_PyFrame_Copy(frame, gen_frame);
frame = tstate->current_frame = prev;
LOAD_IP(frame->return_offset);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
res = PyStackRef_FromPyObjectStealMortal((PyObject *)gen);
LLTRACE_RESUME_FRAME();
_tos_cache0 = res;
PyObject *step_o = oparg == 3 ? PyStackRef_AsPyObjectBorrow(args[2]) : NULL;
PyObject *slice_o = PySlice_New(start_o, stop_o, step_o);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
tmp = args[_i];
args[_i] = PyStackRef_NULL;
PyStackRef_CLOSE(tmp);
}
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (slice_o == NULL) {
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (result_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyObject_Format(value_o, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = fmt_spec;
fmt_spec = PyStackRef_NULL;
stack_pointer[-1] = fmt_spec;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = value;
value = PyStackRef_NULL;
stack_pointer[-2] = value;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res_o == NULL) {
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
SET_CURRENT_CACHED_VALUES(0);
JUMP_TO_ERROR();
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(val);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (1) {
UOP_STAT_INC(uopcode, miss);
SET_CURRENT_CACHED_VALUES(0);
int is_none = PyStackRef_IsNone(val);
if (!is_none) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(val);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (1) {
UOP_STAT_INC(uopcode, miss);
SET_CURRENT_CACHED_VALUES(0);
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(val);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (1) {
UOP_STAT_INC(uopcode, miss);
_tos_cache0 = _stack_item_0;
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(val);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (1) {
UOP_STAT_INC(uopcode, miss);
_tos_cache1 = _stack_item_1;
val = _stack_item_0;
int is_none = PyStackRef_IsNone(val);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(val);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (is_none) {
UOP_STAT_INC(uopcode, miss);
SET_CURRENT_CACHED_VALUES(0);
OPT_HIST(trace_uop_execution_counter, trace_run_length_hist);
if (frame->lltrace >= 3) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
printf("SIDE EXIT: [UOp ");
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyUOpPrint(&next_uop[-1]);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
printf(", exit %tu, temp %d, target %d -> %s, is_control_flow %d]\n",
exit - current_executor->exits, exit->temperature.value_and_backoff,
(int)(target - _PyFrame_GetBytecode(frame)),
_PyOpcode_OpName[target->op.code], exit->is_control_flow);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
#endif
tstate->jit_exit = exit;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
printf("SIDE EXIT: [UOp ");
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyUOpPrint(&next_uop[-1]);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
printf(", exit %tu, temp %d, target %d -> %s, is_control_flow %d]\n",
exit - current_executor->exits, exit->temperature.value_and_backoff,
(int)(target - _PyFrame_GetBytecode(frame)),
_PyOpcode_OpName[target->op.code], exit->is_control_flow);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
}
#endif
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
printf("SIDE EXIT: [UOp ");
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyUOpPrint(&next_uop[-1]);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
printf(", exit %tu, temp %d, target %d -> %s, is_control_flow %d]\n",
exit - current_executor->exits, exit->temperature.value_and_backoff,
(int)(target - _PyFrame_GetBytecode(frame)),
_PyOpcode_OpName[target->op.code], exit->is_control_flow);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
}
#endif
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
printf("SIDE EXIT: [UOp ");
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyUOpPrint(&next_uop[-1]);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
printf(", exit %tu, temp %d, target %d -> %s, is_control_flow %d]\n",
exit - current_executor->exits, exit->temperature.value_and_backoff,
(int)(target - _PyFrame_GetBytecode(frame)),
_PyOpcode_OpName[target->op.code], exit->is_control_flow);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
}
#endif
OPT_HIST(trace_uop_execution_counter, trace_run_length_hist);
if (frame->lltrace >= 3) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
printf("DYNAMIC EXIT: [UOp ");
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyUOpPrint(&next_uop[-1]);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
printf(", exit %tu, temp %d, target %d -> %s]\n",
exit - current_executor->exits, exit->temperature.value_and_backoff,
(int)(target - _PyFrame_GetBytecode(frame)),
_PyOpcode_OpName[target->op.code]);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
#endif
SET_CURRENT_CACHED_VALUES(0);
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
printf("DYNAMIC EXIT: [UOp ");
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyUOpPrint(&next_uop[-1]);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
printf(", exit %tu, temp %d, target %d -> %s]\n",
exit - current_executor->exits, exit->temperature.value_and_backoff,
(int)(target - _PyFrame_GetBytecode(frame)),
_PyOpcode_OpName[target->op.code]);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
}
#endif
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
printf("DYNAMIC EXIT: [UOp ");
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyUOpPrint(&next_uop[-1]);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
printf(", exit %tu, temp %d, target %d -> %s]\n",
exit - current_executor->exits, exit->temperature.value_and_backoff,
(int)(target - _PyFrame_GetBytecode(frame)),
_PyOpcode_OpName[target->op.code]);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
}
#endif
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
printf("DYNAMIC EXIT: [UOp ");
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyUOpPrint(&next_uop[-1]);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
printf(", exit %tu, temp %d, target %d -> %s]\n",
exit - current_executor->exits, exit->temperature.value_and_backoff,
(int)(target - _PyFrame_GetBytecode(frame)),
_PyOpcode_OpName[target->op.code]);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
}
#endif
assert(tstate->jit_exit->executor == current_executor);
assert(tstate->current_executor == executor);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyExecutor_ClearExit(tstate->jit_exit);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (true) {
UOP_STAT_INC(uopcode, miss);
SET_CURRENT_CACHED_VALUES(0);
CHECK_CURRENT_CACHED_VALUES(0);
ASSERT_WITHIN_STACK_BOUNDS_IGNORING_CACHE(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_HandlePending(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
GOTO_TIER_ONE(err ? NULL : _PyFrame_GetBytecode(frame) + CURRENT_TARGET());
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_HandlePending(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
GOTO_TIER_ONE(err ? NULL : _PyFrame_GetBytecode(frame) + CURRENT_TARGET());
}
stack_pointer += 2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_HandlePending(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
GOTO_TIER_ONE(err ? NULL : _PyFrame_GetBytecode(frame) + CURRENT_TARGET());
}
stack_pointer += 3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_HandlePending(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
SET_CURRENT_CACHED_VALUES(0);
GOTO_TIER_ONE(err ? NULL : _PyFrame_GetBytecode(frame) + CURRENT_TARGET());
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_BinaryOp(lhs, rhs, next_instr, oparg, LOCALS_ARRAY);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(BINARY_OP);
PyObject *rhs_o = PyStackRef_AsPyObjectBorrow(rhs);
assert(_PyEval_BinaryOps[oparg]);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
value = r;
stack_pointer[-2] = res;
stack_pointer[-1] = l;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5);
assert(d != NULL);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int match = (d->guard != NULL)
? d->guard(left_o, right_o)
: (Py_TYPE(left_o) == d->lhs_type && Py_TYPE(right_o) == d->rhs_type);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (!match) {
UPDATE_MISS_STATS(BINARY_OP);
assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));
assert(INLINE_CACHE_ENTRIES_BINARY_OP == 5);
_PyBinaryOpSpecializationDescr *d = (_PyBinaryOpSpecializationDescr*)descr;
STAT_INC(BINARY_OP, hit);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = d->action(left_o, right_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
value = r;
stack_pointer[-2] = res;
stack_pointer[-1] = l;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyUnicode_Append(&temp, right_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
*target_local = PyStackRef_NULL;
if (temp == NULL) {
JUMP_TO_LABEL(error);
assert(Py_TYPE(dict)->tp_as_mapping->mp_subscript == _PyDict_Subscript);
STAT_INC(BINARY_OP, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyDict_Subscript(dict, sub);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
value = ss;
stack_pointer[-2] = res;
stack_pointer[-1] = ds;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
}
#ifdef Py_GIL_DISABLED
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyList_GetItemRef((PyListObject*)list, index);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
UPDATE_MISS_STATS(BINARY_OP);
assert(_PyOpcode_Deopt[opcode] == (BINARY_OP));
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
assert(PySlice_Check(sub));
assert(PyList_CheckExact(list));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyList_SliceSubscript(list, sub);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
STAT_INC(BINARY_OP, hit);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
value = ss;
stack_pointer[-2] = res;
stack_pointer[-1] = ls;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *res_o;
if (PyList_CheckExact(container_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyList_BinarySlice(container_o, start_o, stop_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else if (PyTuple_CheckExact(container_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyTuple_BinarySlice(container_o, start_o, stop_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else if (PyUnicode_CheckExact(container_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyUnicode_BinarySlice(container_o, start_o, stop_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
PyObject *slice = PySlice_New(start_o, stop_o, NULL);
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = PyObject_GetItem(container_o, slice);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(slice);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = stop;
stop = PyStackRef_NULL;
stack_pointer[-1] = stop;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = start;
start = PyStackRef_NULL;
stack_pointer[-2] = start;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = container;
container = PyStackRef_NULL;
stack_pointer[-3] = container;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res_o == NULL) {
format_o = &_Py_STR(empty);
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *interpolation_o = _PyInterpolation_Build(value_o, str_o, conversion, format_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (oparg & 1) {
stack_pointer += -(oparg & 1);
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(format[0]);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
stack_pointer += -(oparg & 1);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(str);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (interpolation_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef list;
values = &stack_pointer[-oparg];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *list_o = _PyList_FromStackRefStealOnSuccess(values, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (list_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef map;
values = &stack_pointer[-oparg*2];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *map_o = _Py_BuildMap_StackRefSteal(values, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (map_o == NULL) {
stack_pointer += -oparg*2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyStackRef set;
values = &stack_pointer[-oparg];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *set_o = PySet_New(NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (set_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
tmp = values[_i];
values[_i] = PyStackRef_NULL;
PyStackRef_CLOSE(tmp);
}
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
JUMP_TO_LABEL(error);
_PyStackRef value = values[i];
values[i] = PyStackRef_NULL;
if (err == 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
err = _PySet_AddTakeRef((PySetObject *)set_o, PyStackRef_AsPyObjectSteal(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
if (err) {
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(set_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
set = PyStackRef_FromPyObjectStealMortal(set_o);
PyObject *step_o = oparg == 3 ? PyStackRef_AsPyObjectBorrow(args[2]) : NULL;
PyObject *slice_o = PySlice_New(start_o, stop_o, step_o);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp;
for (int _i = oparg; --_i >= 0;) {
tmp = args[_i];
args[_i] = PyStackRef_NULL;
PyStackRef_CLOSE(tmp);
}
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (slice_o == NULL) {
_PyStackRef str;
pieces = &stack_pointer[-oparg];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *str_o = _Py_BuildString_StackRefSteal(pieces, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (str_o == NULL) {
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
PyObject *strings_o = PyStackRef_AsPyObjectBorrow(strings);
PyObject *interpolations_o = PyStackRef_AsPyObjectBorrow(interpolations);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *template_o = _PyTemplate_Build(strings_o, interpolations_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(interpolations);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(strings);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (template_o == NULL) {
JUMP_TO_LABEL(error);
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_Call(callable, self_or_null, next_instr, oparg + !PyStackRef_IsNull(self_or_null));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(CALL);
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _DO_CALL
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
tstate, callable, locals,
arguments, total_args, NULL, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (new_frame == NULL) {
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject* res_o = _Py_VectorCallInstrumentation_StackRefSteal(
callable,
arguments,
frame,
this_instr,
tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
}
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *self_o = PyType_GenericAlloc(tp, 0);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (self_o == NULL) {
JUMP_TO_LABEL(error);
}
callable = PyStackRef_FromPyObjectNew(init_func);
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CREATE_INIT_FRAME
{
args = &stack_pointer[-oparg];
self = self_or_null;
init = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked(
tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
assert(_PyFrame_GetBytecode(shim)[0].op.code == EXIT_INIT_CHECK);
assert(_PyFrame_GetBytecode(shim)[1].op.code == RETURN_VALUE);
shim->localsplus[0] = PyStackRef_DUP(self);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
tstate, init, NULL, args-1, oparg+1, NULL, shim);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (temp == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FrameClearAndPop(tstate, shim);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
frame->return_offset = 1 + INLINE_CACHE_ENTRIES_CALL;
assert(!IS_PEP523_HOOKED(tstate));
_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// flush
// _CHECK_FUNCTION_VERSION
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// flush
// _CHECK_RECURSION_REMAINING
assert(Py_TYPE(callable_o) == &PyFunction_Type);
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
tstate, callable, locals,
args, total_args, NULL, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (temp == NULL) {
assert(!IS_PEP523_HOOKED(tstate));
_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
}
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _Py_CallBuiltinClass_StackRef(
callable,
arguments,
total_args);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP_OPARG
{
args = &stack_pointer[-oparg];
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef_CloseStack(args, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
}
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _Py_BuiltinCallFast_StackRef(
callable,
arguments,
total_args
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP_OPARG
{
args = &stack_pointer[-oparg];
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef_CloseStack(args, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
}
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _Py_BuiltinCallFastWithKeywords_StackRef(callable, arguments, total_args);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP_OPARG
{
args = &stack_pointer[-oparg];
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef_CloseStack(args, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o);
_PyStackRef arg = args[0];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
if (res_o == NULL) {
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs);
if (!PyTuple_CheckExact(callargs_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *tuple_o = PySequence_Tuple(callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (tuple_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callargs;
callargs = PyStackRef_FromPyObjectSteal(tuple_o);
stack_pointer[-2] = callargs;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _CALL_FUNCTION_EX_NON_PY_GENERAL
assert(kwargs == NULL || PyDict_CheckExact(kwargs));
stack_pointer[-2] = callargs_st;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *result_o = PyObject_Call(func, callargs, kwargs);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(kwargs_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(callargs_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(func_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (result_o == NULL) {
JUMP_TO_LABEL(error);
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs);
if (!PyTuple_CheckExact(callargs_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *tuple_o = PySequence_Tuple(callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (tuple_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callargs;
callargs = PyStackRef_FromPyObjectSteal(tuple_o);
stack_pointer[-2] = callargs;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _CHECK_IS_PY_CALLABLE_EX
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(
tstate, func_st, locals,
nargs, callargs, kwargs, frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (new_frame == NULL) {
assert(!IS_PEP523_HOOKED(tstate));
_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_CallFunctionEx(func, next_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(CALL_FUNCTION_EX);
PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs);
if (!PyTuple_CheckExact(callargs_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *tuple_o = PySequence_Tuple(callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (tuple_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callargs;
callargs = PyStackRef_FromPyObjectSteal(tuple_o);
stack_pointer[-2] = callargs;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _DO_CALL_FUNCTION_EX
PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING;
stack_pointer[-2] = callargs_st;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, func, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
result_o = PyObject_Call(func, callargs, kwargs);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (!PyFunction_Check(func) && !PyMethod_Check(func)) {
if (result_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_Py_call_instrumentation_exc2(
tstate, PY_MONITORING_EVENT_C_RAISE,
frame, this_instr, func, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_C_RETURN,
frame, this_instr, func, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_CLEAR(result_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(
tstate, func_st, locals,
nargs, callargs, kwargs, frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (new_frame == NULL) {
assert(kwargs == NULL || PyDict_CheckExact(kwargs));
stack_pointer[-2] = callargs_st;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
result_o = PyObject_Call(func, callargs, kwargs);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(kwargs_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(callargs_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(func_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (result_o == NULL) {
JUMP_TO_LABEL(error);
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
value = stack_pointer[-1];
assert(oparg <= MAX_INTRINSIC_1);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
{
value = v;
stack_pointer[-1] = res;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *value1 = PyStackRef_AsPyObjectBorrow(value1_st);
PyObject *value2 = PyStackRef_AsPyObjectBorrow(value2_st);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
value = vs2;
stack_pointer[-2] = res;
stack_pointer[-1] = vs1;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *inst_o = PyStackRef_AsPyObjectBorrow(instance);
PyObject *cls_o = PyStackRef_AsPyObjectBorrow(cls);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int retval = PyObject_IsInstance(inst_o, cls_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (retval < 0) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(cls);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(instance);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(callable);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
res = retval ? PyStackRef_True : PyStackRef_False;
assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL));
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_CallKw(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(CALL_KW);
stack_pointer[-3 - oparg] = callable;
stack_pointer[-2 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _DO_CALL_KW
stack_pointer[-3 - oparg] = callable;
stack_pointer[-2 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
tstate, callable, locals,
arguments, positional_args, kwnames_o, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(kwnames);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (new_frame == NULL) {
JUMP_TO_LABEL(error);
}
stack_pointer[-3 - oparg] = callable;
stack_pointer[-2 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject* res_o = _Py_VectorCallInstrumentation_StackRefSteal(
callable,
arguments,
frame,
this_instr,
tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
stack_pointer += -3 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
stack_pointer[-3 - oparg] = callable;
stack_pointer[-2 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(callable_s);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// flush
// _PY_FRAME_KW
assert(Py_TYPE(callable_o) == &PyFunction_Type);
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
tstate, callable, locals,
arguments, positional_args, kwnames_o, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(kwnames);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (temp == NULL) {
assert(!IS_PEP523_HOOKED(tstate));
_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
total_args++;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _Py_VectorCall_StackRefSteal(
callable,
arguments,
total_args,
kwnames);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
stack_pointer += -3 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
tstate, callable, locals,
arguments, positional_args, kwnames_o, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(kwnames);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (temp == NULL) {
assert(!IS_PEP523_HOOKED(tstate));
_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
STAT_INC(CALL, hit);
PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_ssize_t len_i = PyObject_Length(arg_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (len_i < 0) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
assert(self != NULL);
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyCFunctionFast cfunc = _PyCFunctionFast_CAST(method->d_method->ml_meth);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCallMethodDescriptorFast_StackRef(
callable,
cfunc,
arguments,
total_args
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP_OPARG
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef_CloseStack(args, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
assert(self != NULL);
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyCFunctionFastWithKeywords cfunc = _PyCFunctionFastWithKeywords_CAST(method->d_method->ml_meth);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCallMethodDescriptorFastWithKeywords_StackRef(
callable,
cfunc,
arguments,
total_args
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callable;
callable = PyStackRef_FromPyObjectSteal(res_o);
stack_pointer[-2 - oparg] = callable;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP_OPARG
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef_CloseStack(args, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
STAT_INC(CALL, hit);
PyCFunction cfunc = method->d_method->ml_meth;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
if (res_o == NULL) {
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
PyObject *self = PyStackRef_AsPyObjectBorrow(arguments[0]);
PyObject *arg = PyStackRef_AsPyObjectBorrow(arguments[1]);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
_Py_LeaveRecursiveCallTstate(tstate);
assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL));
if (res_o == NULL) {
stack_pointer += 1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
total_args++;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = _Py_VectorCall_StackRefSteal(
callable,
arguments,
total_args,
PyStackRef_NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *temp = _PyEvalFramePushAndInit(
tstate, callable, locals,
args, total_args, NULL, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (temp == NULL) {
assert(!IS_PEP523_HOOKED(tstate));
_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
assert(oparg == 1);
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyObject_Str(arg_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
assert(oparg == 1);
STAT_INC(CALL, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PySequence_Tuple(arg_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_AT_END
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st);
PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = match_type_st;
match_type_st = PyStackRef_NULL;
stack_pointer[-1] = match_type_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = exc_value_st;
exc_value_st = PyStackRef_NULL;
stack_pointer[-2] = exc_value_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
JUMP_TO_LABEL(error);
}
PyObject *match_o = NULL;
PyObject *rest_o = NULL;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int res = _PyEval_ExceptionGroupMatch(frame, exc_value, match_type,
&match_o, &rest_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = match_type_st;
match_type_st = PyStackRef_NULL;
stack_pointer[-1] = match_type_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = exc_value_st;
exc_value_st = PyStackRef_NULL;
stack_pointer[-2] = exc_value_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res < 0) {
}
if (!Py_IsNone(match_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyErr_SetHandledException(match_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
rest = PyStackRef_FromPyObjectSteal(rest_o);
match = PyStackRef_FromPyObjectSteal(match_o);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
assert(PyExceptionInstance_Check(left_o));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyEval_CheckExceptTypeValid(tstate, right_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int res = PyErr_GivenExceptionMatches(left_o, right_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(right);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
b = res ? PyStackRef_True : PyStackRef_False;
stack_pointer[0] = b;
stack_pointer += 1;
#endif
assert(exc_value && PyExceptionInstance_Check(exc_value));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int matches = PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (matches) {
value = PyStackRef_FromPyObjectNew(((PyStopIterationObject *)exc_value)->value);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = sub_iter;
sub_iter = value;
stack_pointer[-4] = sub_iter;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = exc_value_st;
exc_value_st = PyStackRef_NULL;
stack_pointer[-1] = exc_value_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = last_sent_val;
last_sent_val = PyStackRef_NULL;
stack_pointer[-2] = last_sent_val;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = null_in;
null_in = PyStackRef_NULL;
stack_pointer[-3] = null_in;
PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -4;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
null_out = null_in;
none = PyStackRef_None;
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetRaisedException(tstate, Py_NewRef(exc_value));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
monitor_reraise(tstate, frame, this_instr);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
JUMP_TO_LABEL(exception_unwind);
}
stack_pointer[0] = none;
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_CompareOp(left, right, next_instr, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(COMPARE_OP);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
assert((oparg >> 5) <= Py_GE);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = right;
right = PyStackRef_NULL;
stack_pointer[-1] = right;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = left;
left = PyStackRef_NULL;
stack_pointer[-2] = left;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res_o == NULL) {
}
if (oparg & 16) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res_bool = PyObject_IsTrue(res_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(res_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_bool < 0) {
JUMP_TO_LABEL(error);
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_ContainsOp(right, next_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(CONTAINS_OP);
PyObject *left_o = PyStackRef_AsPyObjectBorrow(left);
PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res = PySequence_Contains(right_o, left_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res < 0) {
JUMP_TO_LABEL(error);
}
value = r;
stack_pointer[-2] = b;
stack_pointer[-1] = l;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
assert(PyAnyDict_CheckExact(right_o));
STAT_INC(CONTAINS_OP, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res = PyDict_Contains(right_o, left_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res < 0) {
JUMP_TO_LABEL(error);
}
value = r;
stack_pointer[-2] = b;
stack_pointer[-1] = l;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
assert(PyAnySet_CheckExact(right_o));
STAT_INC(CONTAINS_OP, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res = _PySet_Contains((PySetObject *)right_o, left_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res < 0) {
JUMP_TO_LABEL(error);
}
value = r;
stack_pointer[-2] = b;
stack_pointer[-1] = l;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
assert(oparg >= FVC_STR && oparg <= FVC_ASCII);
conv_fn = _PyEval_ConversionFuncs[oparg];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (result_o == NULL) {
JUMP_TO_LABEL(error);
}
owner = stack_pointer[-1];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(owner);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
PyObject *oldobj = PyCell_SwapTakeRef((PyCellObject *)cell, NULL);
if (oldobj == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(oldobj);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
_PyStackRef v = GETLOCAL(oparg);
if (PyStackRef_IsNull(v)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError,
UNBOUNDLOCAL_ERROR_MSG,
PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg)
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
_PyStackRef tmp = GETLOCAL(oparg);
GETLOCAL(oparg) = PyStackRef_NULL;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
INSTRUCTION_STATS(DELETE_GLOBAL);
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyDict_Pop(GLOBALS(), name, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
if (err == 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
NAME_ERROR_MSG, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
DISPATCH();
int err;
if (ns == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_SystemError,
"no locals when deleting %R", name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
err = PyObject_DelItem(ns, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
NAME_ERROR_MSG,
name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
DISPATCH();
sub = stack_pointer[-1];
container = stack_pointer[-2];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container),
PyStackRef_AsPyObjectBorrow(sub));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = sub;
sub = PyStackRef_NULL;
stack_pointer[-1] = sub;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = container;
container = PyStackRef_NULL;
stack_pointer[-2] = container;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (err) {
PyObject *update_o = PyStackRef_AsPyObjectBorrow(update);
PyObject *dupkey = NULL;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyDict_MergeUniq(dict_o, update_o, &dupkey);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatKwargsError(tstate, callable_o, update_o, dupkey);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_XDECREF(dupkey);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
u = update;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict);
PyObject *update_o = PyStackRef_AsPyObjectBorrow(update);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyDict_Update(dict_o, update_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
int matches = _PyErr_ExceptionMatches(tstate, PyExc_AttributeError);
if (matches) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *exc = _PyErr_GetRaisedException(tstate);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int has_keys = PyObject_HasAttrWithError(update_o, &_Py_ID(keys));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (has_keys == 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_TypeError,
"'%T' object is not a mapping",
update_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(exc);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_ChainExceptions1(exc);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
JUMP_TO_LABEL(error);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *exc = PyStackRef_AsPyObjectBorrow(exc_st);
assert(exc && PyExceptionInstance_Check(exc));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int matches = PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (matches) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = exc_st;
exc_st = PyStackRef_NULL;
stack_pointer[-1] = exc_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = awaitable_st;
awaitable_st = PyStackRef_NULL;
stack_pointer[-2] = awaitable_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
}
else {
Py_INCREF(exc);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetRaisedException(tstate, exc);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
monitor_reraise(tstate, frame, this_instr);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
JUMP_TO_LABEL(exception_unwind);
}
DISPATCH();
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(receiver);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
should_be_none = stack_pointer[-1];
if (!PyStackRef_IsNone(should_be_none)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyErr_Format(PyExc_TypeError,
"__init__() should return None, not '%.200s'",
Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
PyObject *value_o = PyStackRef_AsPyObjectBorrow(value);
if (!PyUnicode_CheckExact(value_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyObject_Format(value_o, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
fmt_spec = stack_pointer[-1];
value = stack_pointer[-2];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = fmt_spec;
fmt_spec = PyStackRef_NULL;
stack_pointer[-1] = fmt_spec;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = value;
value = PyStackRef_NULL;
stack_pointer[-2] = value;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res_o == NULL) {
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_ForIter(iter, null_or_index, next_instr, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(FOR_ITER);
// _FOR_ITER
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef item = _PyForIter_VirtualIteratorNext(tstate, frame, iter, &null_or_index);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (!PyStackRef_IsValid(item)) {
if (PyStackRef_IsError(item)) {
JUMP_TO_LABEL(error);
assert(!IS_PEP523_HOOKED(tstate));
_PyInterpreterFrame *temp = PyStackRef_Unwrap(new_frame);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
_PyObject_GC_IS_SHARED(list_o));
STAT_INC(FOR_ITER, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int result = _PyList_GetItemRefNoLock((PyListObject *)list_o, PyStackRef_UntagInt(null_or_index), &next);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (result < 0) {
UPDATE_MISS_STATS(FOR_ITER);
assert(_PyOpcode_Deopt[opcode] == (FOR_ITER));
PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter);
Py_ssize_t index = PyStackRef_UntagInt(null_or_index);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyObjectIndexPair next_index = Py_TYPE(iter_o)->_tp_iteritem(iter_o, index);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
PyObject *next_o = next_index.object;
index = next_index.index;
if (next_o == NULL) {
}
if (getter == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_TypeError,
"'async for' requires an object with "
"__aiter__ method, got %.100s",
type->tp_name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(obj);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
iter_o = (*getter)(obj_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(obj);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (iter_o == NULL) {
JUMP_TO_LABEL(error);
}
if (Py_TYPE(iter_o)->tp_as_async == NULL ||
Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_TypeError,
"'async for' received an object from __aiter__ "
"that does not implement __anext__: %.100s",
Py_TYPE(iter_o)->tp_name);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(iter_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
iter = PyStackRef_FromPyObjectSteal(iter_o);
_PyStackRef awaitable;
aiter = stack_pointer[-1];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *awaitable_o = _PyEval_GetANext(PyStackRef_AsPyObjectBorrow(aiter));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (awaitable_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef iter;
iterable = stack_pointer[-1];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(iterable);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (iter_o == NULL) {
JUMP_TO_LABEL(error);
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_GetIter(iterable, next_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(GET_ITER);
// _GET_ITER
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef result = _PyEval_GetIter(iterable, &index_or_null, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (PyStackRef_IsError(result)) {
JUMP_TO_LABEL(pop_1_error);
}
_PyStackRef len;
obj = stack_pointer[-1];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (len_i < 0) {
JUMP_TO_LABEL(error);
}
PyObject *res_o;
if (PyLazyImport_CheckExact(PyStackRef_AsPyObjectBorrow(from))) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyEval_LazyImportFrom(
tstate, frame, PyStackRef_AsPyObjectBorrow(from), name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyEval_ImportFrom(
tstate, PyStackRef_AsPyObjectBorrow(from), name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
if (res_o == NULL) {
JUMP_TO_LABEL(error);
PyObject *res_o;
if (!(oparg & 0x02)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyEval_LazyImportName(tstate, BUILTINS(), GLOBALS(),
LOCALS(), name,
PyStackRef_AsPyObjectBorrow(fromlist),
PyStackRef_AsPyObjectBorrow(level),
oparg & 0x01);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = _PyEval_ImportName(tstate, BUILTINS(), GLOBALS(),
LOCALS(), name,
PyStackRef_AsPyObjectBorrow(fromlist),
PyStackRef_AsPyObjectBorrow(level));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = fromlist;
fromlist = PyStackRef_NULL;
stack_pointer[-1] = fromlist;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = level;
level = PyStackRef_NULL;
stack_pointer[-2] = level;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (res_o == NULL) {
stack_pointer[-2 - oparg] = callable;
stack_pointer[-1 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _MONITOR_CALL
stack_pointer[-2 - oparg] = func;
stack_pointer[-1 - oparg] = maybe_self;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, function, arg0
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
{
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
tstate, callable, locals,
arguments, total_args, NULL, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (new_frame == NULL) {
frame->return_offset = 4u ;
DISPATCH_INLINED(new_frame);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject* res_o = _Py_VectorCallInstrumentation_StackRefSteal(
callable,
arguments,
frame,
this_instr,
tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
stack_pointer += -2 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
stack_pointer += -1 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs);
if (!PyTuple_CheckExact(callargs_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *tuple_o = PySequence_Tuple(callargs_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (tuple_o == NULL) {
JUMP_TO_LABEL(error);
}
_PyStackRef temp = callargs;
callargs = PyStackRef_FromPyObjectSteal(tuple_o);
stack_pointer[-2] = callargs;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _DO_CALL_FUNCTION_EX
PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING;
stack_pointer[-2] = callargs_st;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, func, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
result_o = PyObject_Call(func, callargs, kwargs);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (!PyFunction_Check(func) && !PyMethod_Check(func)) {
if (result_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_Py_call_instrumentation_exc2(
tstate, PY_MONITORING_EVENT_C_RAISE,
frame, this_instr, func, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_C_RETURN,
frame, this_instr, func, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_CLEAR(result_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(
tstate, func_st, locals,
nargs, callargs, kwargs, frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (new_frame == NULL) {
assert(kwargs == NULL || PyDict_CheckExact(kwargs));
stack_pointer[-2] = callargs_st;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
result_o = PyObject_Call(func, callargs, kwargs);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(kwargs_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(callargs_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(func_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (result_o == NULL) {
JUMP_TO_LABEL(error);
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
stack_pointer[-3 - oparg] = callable;
stack_pointer[-2 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(temp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _MONITOR_CALL_KW
stack_pointer[-3 - oparg] = callable;
stack_pointer[-2 - oparg] = self_or_null;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, function, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
{
int code_flags = ((PyCodeObject*)PyFunction_GET_CODE(callable_o))->co_flags;
PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit(
tstate, callable, locals,
arguments, positional_args, kwnames_o, frame
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(kwnames);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (new_frame == NULL) {
JUMP_TO_LABEL(error);
}
frame->return_offset = 4u ;
DISPATCH_INLINED(new_frame);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject* res_o = _Py_VectorCallInstrumentation_StackRefSteal(
callable,
arguments,
frame,
this_instr,
tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
stack_pointer += -3 - oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
PyObject *exc = PyStackRef_AsPyObjectBorrow(exc_st);
assert(exc && PyExceptionInstance_Check(exc));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int matches = PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (matches) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = exc_st;
exc_st = PyStackRef_NULL;
stack_pointer[-1] = exc_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = awaitable_st;
awaitable_st = PyStackRef_NULL;
stack_pointer[-2] = awaitable_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
}
else {
Py_INCREF(exc);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetRaisedException(tstate, exc);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
monitor_reraise(tstate, frame, this_instr);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
JUMP_TO_LABEL(exception_unwind);
}
}
receiver = stack_pointer[-3];
if (PyStackRef_GenCheck(receiver)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver);
if (PyGen_Check(receiver_o) || PyCoro_CheckExact(receiver_o)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(receiver);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
null_or_index = stack_pointer[-1];
iter = stack_pointer[-2];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef item = _PyForIter_VirtualIteratorNext(tstate, frame, iter, &null_or_index);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (!PyStackRef_IsValid(item)) {
if (PyStackRef_IsError(item)) {
JUMP_TO_LABEL(error);
INSTRUCTION_STATS(INSTRUMENTED_INSTRUCTION);
opcode = INSTRUMENTED_INSTRUCTION;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int next_opcode = _Py_call_instrumentation_instruction(
tstate, frame, this_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (next_opcode < 0) {
JUMP_TO_LABEL(error);
}
// _CHECK_PERIODIC
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
next_instr = this_instr;
} else {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
original_opcode = _Py_call_instrumentation_line(
tstate, frame, this_instr, prev_instr);
+ _PyFrame_StackPointerInvalidate(frame);
+ // Explicit stack reload
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackAssertInvalid(frame);
if (original_opcode < 0) {
next_instr = this_instr+1;
JUMP_TO_LABEL(error);
PAUSE_ADAPTIVE_COUNTER(cache->counter);
}
opcode = original_opcode;
+ PRE_DISPATCH_GOTO();
DISPATCH_GOTO();
}
if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) {
PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, global_super, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = self_st;
self_st = PyStackRef_NULL;
stack_pointer[-1] = self_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = class_st;
class_st = PyStackRef_NULL;
stack_pointer[-2] = class_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = global_super_st;
global_super_st = PyStackRef_NULL;
stack_pointer[-3] = global_super_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
JUMP_TO_LABEL(error);
{
PyObject *stack[] = {class, self};
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
super = PyObject_Vectorcall(global_super, stack, oparg & 2, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) {
PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING;
if (super == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_Py_call_instrumentation_exc2(
tstate, PY_MONITORING_EVENT_C_RAISE,
frame, this_instr, global_super, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_C_RETURN,
frame, this_instr, global_super, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_CLEAR(super);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = self_st;
self_st = PyStackRef_NULL;
stack_pointer[-1] = self_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = class_st;
class_st = PyStackRef_NULL;
stack_pointer[-2] = class_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = global_super_st;
global_super_st = PyStackRef_NULL;
stack_pointer[-3] = global_super_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (super == NULL) {
}
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *attr_o = PyObject_GetAttr(super, name);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(super);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (attr_o == NULL) {
JUMP_TO_LABEL(error);
}
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(iter);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += 1;
}
stack_pointer += -1;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
INSTRUMENTED_JUMP(this_instr, next_instr + oparg, PY_MONITORING_EVENT_BRANCH_RIGHT);
}
else {
if (frame->tlbc_index !=
((_PyThreadStateImpl *)tstate)->tlbc_index) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_CODEUNIT *bytecode =
_PyEval_GetExecutableCode(tstate, _PyFrame_GetCode(frame));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (bytecode == NULL) {
JUMP_TO_LABEL(error);
}
uintptr_t code_version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version);
if (code_version != global_version) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_Instrument(_PyFrame_GetCode(frame), tstate->interp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
{
if ((oparg & RESUME_OPARG_LOCATION_MASK) < RESUME_AFTER_YIELD_FROM) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
// _MONITOR_RESUME
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation(
tstate, oparg == 0 ? PY_MONITORING_EVENT_PY_START : PY_MONITORING_EVENT_PY_RESUME, frame, this_instr);
+ _PyFrame_StackPointerInvalidate(frame);
+ // Explicit stack reload
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackAssertInvalid(frame);
if (err) {
JUMP_TO_LABEL(error);
}
{
val = stack_pointer[-1];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_arg(
tstate, PY_MONITORING_EVENT_PY_RETURN,
frame, this_instr, PyStackRef_AsPyObjectBorrow(val));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(STACK_LEVEL() == 0);
DTRACE_FUNCTION_RETURN();
_Py_LeaveRecursiveCallPy(tstate);
frame = tstate->current_frame = dying->previous;
_PyEval_FrameClearAndPop(tstate, dying);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(frame->return_offset);
res = temp;
LLTRACE_RESUME_FRAME();
{
val = stack_pointer[-1];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_arg(
tstate, PY_MONITORING_EVENT_PY_YIELD,
frame, this_instr, PyStackRef_AsPyObjectBorrow(val));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
+ // Explicit stack reload
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackAssertInvalid(frame);
JUMP_TO_LABEL(error);
}
if (frame->instr_ptr != this_instr) {
+ // Explicit stack reload
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackAssertInvalid(frame);
next_instr = frame->instr_ptr;
DISPATCH();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
DTRACE_FUNCTION_RETURN();
tstate->exc_info = gen->gi_exc_state.previous_item;
gen->gi_exc_state.previous_item = NULL;
}
#endif
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND);
value = temp;
LLTRACE_RESUME_FRAME();
_PyStackRef executor = frame->localsplus[0];
assert(tstate->current_executor == NULL);
if (!PyStackRef_IsNull(executor)) {
+ assert(PyStackRef_TYPE(executor) == &_PyUOpExecutor_Type);
tstate->current_executor = PyStackRef_AsPyObjectBorrow(executor);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(executor);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += 1;
}
#endif
stack_pointer[-2] = b;
stack_pointer[-1] = l;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
// _CHECK_PERIODIC
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
// _CHECK_PERIODIC
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
// _CHECK_PERIODIC
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
PyObject *list = PyStackRef_AsPyObjectBorrow(list_st);
PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (none_val == NULL) {
int matches = _PyErr_ExceptionMatches(tstate, PyExc_TypeError);
if (matches &&
(Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable)))
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Clear(tstate);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_TypeError,
"Value after * must be an iterable, not %.200s",
Py_TYPE(iterable)->tp_name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1);
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_LoadAttr(owner, next_instr, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(LOAD_ATTR);
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 1);
if (oparg & 1) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
attr = _Py_LoadAttr_StackRefSteal(tstate, owner, name, self_or_null);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (PyStackRef_IsNull(attr)) {
JUMP_TO_LABEL(pop_1_error);
}
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
attr = _PyObject_GetAttrStackRef(PyStackRef_AsPyObjectBorrow(owner), name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer[-1] = attr;
stack_pointer += (oparg&1);
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(owner);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (PyStackRef_IsNull(attr)) {
JUMP_TO_LABEL(error);
}
assert(descr != NULL);
attr = PyStackRef_FromPyObjectNew(descr);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = owner;
owner = attr;
stack_pointer[-1] = owner;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _PUSH_NULL_CONDITIONAL
{
assert(descr != NULL);
attr = PyStackRef_FromPyObjectNew(descr);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = owner;
owner = attr;
stack_pointer[-1] = owner;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _PUSH_NULL_CONDITIONAL
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
value = o;
stack_pointer[-1] = attr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
/* Skip 5 cache entries */
// _PUSH_NULL_CONDITIONAL
value = o;
stack_pointer[-1] = attr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
/* Skip 5 cache entries */
// _PUSH_NULL_CONDITIONAL
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(owner);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
attr = PyStackRef_FromPyObjectNew(descr);
}
stack_pointer[0] = attr;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(owner);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
attr = PyStackRef_FromPyObjectNew(descr);
}
stack_pointer[0] = attr;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
value = o;
stack_pointer[-1] = attr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
/* Skip 5 cache entries */
// _PUSH_NULL_CONDITIONAL
value = o;
stack_pointer[-1] = attr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
/* Skip 5 cache entries */
// _PUSH_NULL_CONDITIONAL
_PyStackRef bc;
int err;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *bc_o = _PyMapping_GetOptionalItem2(BUILTINS(), &_Py_ID(__build_class__), &err);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
if (bc_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetString(tstate, PyExc_NameError,
"__build_class__ not found");
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
bc = PyStackRef_FromPyObjectSteal(bc_o);
_PyStackRef value;
PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
value = _PyCell_GetStackRef(cell);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (PyStackRef_IsNull(value)) {
stack_pointer[0] = value;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
stack_pointer[0] = value;
_PyStackRef value_s = GETLOCAL(oparg);
if (PyStackRef_IsNull(value_s)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError,
UNBOUNDLOCAL_ERROR_MSG,
PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg)
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
value = PyStackRef_DUP(value_s);
name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg);
int err;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject* value_o = _PyMapping_GetOptionalItem2(class_dict, name, &err);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));
value_o = PyCell_GetRef(cell);
if (value_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(class_dict_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
value = PyStackRef_FromPyObjectSteal(value_o);
stack_pointer[0] = value;
stack_pointer += 1;
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
int err;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *v_o = _PyMapping_GetOptionalItem2(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &err);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(mod_or_class_dict);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
if (PyDict_CheckExact(GLOBALS())
&& PyDict_CheckExact(BUILTINS()))
{
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
v_o = _PyDict_LoadGlobal((PyDictObject *)GLOBALS(),
(PyDictObject *)BUILTINS(),
name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (v_o == NULL) {
if (!_PyErr_Occurred(tstate)) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(tstate, PyExc_NameError,
NAME_ERROR_MSG, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
JUMP_TO_LABEL(error);
}
if (PyLazyImport_CheckExact(v_o)) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *l_v = _PyImport_LoadLazyImportTstate(tstate, v_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_SETREF(v_o, l_v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (v_o == NULL) {
JUMP_TO_LABEL(error);
}
}
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
v_o = _PyMapping_GetOptionalItem2(GLOBALS(), name, &err);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
if (v_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
v_o = _PyMapping_GetOptionalItem2(BUILTINS(), name, &err);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
if (v_o == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_FormatExcCheckArg(
tstate, PyExc_NameError,
NAME_ERROR_MSG, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
}
if (PyLazyImport_CheckExact(v_o)) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *l_v = _PyImport_LoadLazyImportTstate(tstate, v_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_SETREF(v_o, l_v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (v_o == NULL) {
JUMP_TO_LABEL(error);
}
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1);
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_LoadGlobal(GLOBALS(), BUILTINS(), next_instr, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(LOAD_GLOBAL);
res = &stack_pointer[0];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyEval_LoadGlobalStackRef(GLOBALS(), BUILTINS(), name, res);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (PyStackRef_IsNull(*res)) {
JUMP_TO_LABEL(error);
}
PyObject *l = LOCALS();
if (l == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetString(tstate, PyExc_SystemError,
"no locals found");
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
locals = PyStackRef_FromPyObjectNew(l);
_PyStackRef v;
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *v_o = _PyEval_LoadName(tstate, frame, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (v_o == NULL) {
JUMP_TO_LABEL(error);
}
if (PyLazyImport_CheckExact(v_o)) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyObject *l_v = _PyImport_LoadLazyImportTstate(tstate, v_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (l_v == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(v_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = PyDict_SetItem(GLOBALS(), name, l_v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(v_o);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(l_v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_SETREF(v_o, l_v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
v = PyStackRef_FromPyObjectSteal(v_o);
stack_pointer[0] = v;
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyObject_LookupSpecialMethod(name, method_and_self);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err <= 0) {
if (err == 0) {
PyObject *owner = PyStackRef_AsPyObjectBorrow(method_and_self[1]);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
const char *errfmt = _PyEval_SpecialMethodCanSuggest(owner, oparg)
? _Py_SpecialMethods[oparg].error_suggestion
: _Py_SpecialMethods[oparg].error;
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
assert(!_PyErr_Occurred(tstate));
assert(errfmt != NULL);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_TypeError, errfmt, owner);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
JUMP_TO_LABEL(error);
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_LoadSuperAttr(global_super_st, class_st, next_instr, load_method);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(LOAD_SUPER_ATTR);
if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) {
PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_CALL,
frame, this_instr, global_super, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = self_st;
self_st = PyStackRef_NULL;
stack_pointer[-1] = self_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = class_st;
class_st = PyStackRef_NULL;
stack_pointer[-2] = class_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = global_super_st;
global_super_st = PyStackRef_NULL;
stack_pointer[-3] = global_super_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
JUMP_TO_LABEL(error);
{
PyObject *stack[] = {class, self};
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
super = PyObject_Vectorcall(global_super, stack, oparg & 2, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) {
PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING;
if (super == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_Py_call_instrumentation_exc2(
tstate, PY_MONITORING_EVENT_C_RAISE,
frame, this_instr, global_super, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_call_instrumentation_2args(
tstate, PY_MONITORING_EVENT_C_RETURN,
frame, this_instr, global_super, arg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_CLEAR(super);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = self_st;
self_st = PyStackRef_NULL;
stack_pointer[-1] = self_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = class_st;
class_st = PyStackRef_NULL;
stack_pointer[-2] = class_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = global_super_st;
global_super_st = PyStackRef_NULL;
stack_pointer[-3] = global_super_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (super == NULL) {
}
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *attr_o = PyObject_GetAttr(super, name);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(super);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (attr_o == NULL) {
JUMP_TO_LABEL(error);
}
STAT_INC(LOAD_SUPER_ATTR, hit);
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = self_st;
self_st = PyStackRef_NULL;
stack_pointer[-1] = self_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = class_st;
class_st = PyStackRef_NULL;
stack_pointer[-2] = class_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = global_super_st;
global_super_st = PyStackRef_NULL;
stack_pointer[-3] = global_super_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (attr == NULL) {
{
int *method_found_ptr = &method_found;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
attr_o = _PySuper_Lookup(cls, self, name,
Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? method_found_ptr : NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
if (attr_o == NULL) {
JUMP_TO_LABEL(error);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(self_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
self_or_null = PyStackRef_NULL;
stack_pointer += 1;
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = global_super_st;
global_super_st = self_or_null;
stack_pointer[-2] = global_super_st;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = class_st;
class_st = PyStackRef_NULL;
stack_pointer[-1] = class_st;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
attr = PyStackRef_FromPyObjectSteal(attr_o);
_PyStackRef tmp = GETLOCAL(oparg);
GETLOCAL(oparg) = PyStackRef_FromPyObjectSteal(cell);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
codeobj_st = stack_pointer[-1];
PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyFunctionObject *func_obj = (PyFunctionObject *)
PyFunction_New(codeobj, GLOBALS());
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (func_obj == NULL) {
JUMP_TO_LABEL(error);
}
{
value = co;
stack_pointer[-1] = func;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st);
assert(PyDict_CheckExact(dict));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyDict_SetItem_Take2(
(PyDictObject *)dict,
PyStackRef_AsPyObjectSteal(key),
PyStackRef_AsPyObjectSteal(value)
);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(pop_2_error);
}
subject = stack_pointer[-3];
assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names)));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *attrs_o = _PyEval_MatchClass(tstate,
PyStackRef_AsPyObjectBorrow(subject),
PyStackRef_AsPyObjectBorrow(type), oparg,
PyStackRef_AsPyObjectBorrow(names));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (attrs_o) {
assert(PyTuple_CheckExact(attrs_o));
attrs = PyStackRef_FromPyObjectSteal(attrs_o);
stack_pointer[-3] = attrs;
stack_pointer[-2] = s;
stack_pointer[-1] = tp;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
keys = stack_pointer[-1];
subject = stack_pointer[-2];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *values_or_none_o = _PyEval_MatchKeys(tstate,
PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (values_or_none_o == NULL) {
JUMP_TO_LABEL(error);
}
exc_value = stack_pointer[-1];
_PyErr_StackItem *exc_info = tstate->exc_info;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_XSETREF(exc_info->exc_value,
PyStackRef_IsNone(exc_value)
? NULL : PyStackRef_AsPyObjectSteal(exc_value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
DISPATCH();
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(iter);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
else {
b = PyStackRef_False;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = value;
value = b;
stack_pointer[-1] = value;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _POP_JUMP_IF_TRUE
else {
b = PyStackRef_False;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = value;
value = b;
stack_pointer[-1] = value;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
// _POP_JUMP_IF_FALSE
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
stack_pointer += -oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = do_raise(tstate, exc, cause);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
assert(oparg == 0);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
monitor_reraise(tstate, frame, this_instr);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
JUMP_TO_LABEL(exception_unwind);
}
JUMP_TO_LABEL(error);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetRaisedException(tstate, exc);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
monitor_reraise(tstate, frame, this_instr);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
JUMP_TO_LABEL(exception_unwind);
}
if (frame->tlbc_index !=
((_PyThreadStateImpl *)tstate)->tlbc_index) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_CODEUNIT *bytecode =
_PyEval_GetExecutableCode(tstate, _PyFrame_GetCode(frame));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (bytecode == NULL) {
JUMP_TO_LABEL(error);
}
uintptr_t code_version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version);
if (code_version != global_version) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _Py_Instrument(_PyFrame_GetCode(frame), tstate->interp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
uint16_t counter = read_u16(&this_instr[1].cache);
(void)counter;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_Resume(this_instr, tstate, frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _CHECK_PERIODIC_IF_NOT_YIELD_FROM
{
if ((oparg & RESUME_OPARG_LOCATION_MASK) < RESUME_AFTER_YIELD_FROM) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = check_periodics(tstate);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err != 0) {
JUMP_TO_LABEL(error);
}
assert(PyStackRef_FunctionCheck(frame->f_funcobj));
PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (gen == NULL) {
JUMP_TO_LABEL(error);
}
assert(STACK_LEVEL() <= 2);
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyInterpreterFrame *gen_frame = &gen->gi_iframe;
frame->instr_ptr++;
_PyFrame_Copy(frame, gen_frame);
frame = tstate->current_frame = prev;
LOAD_IP(frame->return_offset);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
res = PyStackRef_FromPyObjectStealMortal((PyObject *)gen);
LLTRACE_RESUME_FRAME();
stack_pointer[0] = res;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(STACK_LEVEL() == 0);
DTRACE_FUNCTION_RETURN();
_Py_LeaveRecursiveCallPy(tstate);
frame = tstate->current_frame = dying->previous;
_PyEval_FrameClearAndPop(tstate, dying);
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(frame->return_offset);
res = temp;
LLTRACE_RESUME_FRAME();
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_Send(receiver, next_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(SEND);
}
if (!PyStackRef_IsNull(null_or_index) && PyStackRef_IsNone(v)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef item = _PyForIter_VirtualIteratorNext(tstate, frame, receiver, &null_or_index);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (!PyStackRef_IsValid(item)) {
if (PyStackRef_IsError(item)) {
JUMP_TO_LABEL(error);
else {
PyObject *v_o = PyStackRef_AsPyObjectBorrow(v);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PySendResultPair res = _PyIter_Send(receiver_o, v_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res.kind == PYGEN_ERROR) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
retval = PyStackRef_FromPyObjectSteal(res.object);
if (res.kind == PYGEN_RETURN) {
JUMPBY(oparg);
PyObject *val = PyStackRef_AsPyObjectBorrow(v);
PyObject *retval_o;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PySendResult what = _PyAsyncGenASend_Send(iter_o, val, &retval_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (what == PYGEN_ERROR) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
asend = iter;
null_out = null_in;
retval = PyStackRef_FromPyObjectSteal(retval_o);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
assert(temp->previous == frame || temp->previous->previous == frame);
CALL_STAT_INC(inlined_py_calls);
frame = tstate->current_frame = temp;
tstate->py_recursion_remaining--;
- LOAD_SP();
+ stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(0);
+ #ifdef Py_DEBUG
+ assert(frame->previous->stackpointer_valid == 1);
+ #endif
DTRACE_FUNCTION_ENTRY();
LLTRACE_RESUME_FRAME();
}
PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter);
Py_ssize_t index = PyStackRef_UntagInt(null_or_index);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyObjectIndexPair next_index = Py_TYPE(iter_o)->_tp_iteritem(iter_o, index);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
PyObject *next_o = next_index.object;
index = next_index.index;
if (next_o == NULL) {
INSTRUCTION_STATS(SETUP_ANNOTATIONS);
if (LOCALS() == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_SystemError,
"no locals found when setting up annotations");
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
int err;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject* ann_dict = _PyMapping_GetOptionalItem2(LOCALS(), &_Py_ID(__annotations__), &err);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
if (ann_dict == NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
ann_dict = PyDict_New();
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (ann_dict == NULL) {
JUMP_TO_LABEL(error);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__),
ann_dict);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(ann_dict);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
}
else {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(ann_dict);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
v = stack_pointer[-1];
set = stack_pointer[-2 - (oparg-1)];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PySet_AddTakeRef((PySetObject *)PyStackRef_AsPyObjectBorrow(set),
PyStackRef_AsPyObjectSteal(v));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(pop_1_error);
}
iterable = stack_pointer[-1];
set = stack_pointer[-2 - (oparg-1)];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set),
PyStackRef_AsPyObjectBorrow(iterable));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_StoreAttr(owner, next_instr, name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(STORE_ATTR);
v = stack_pointer[-2];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner),
name, PyStackRef_AsPyObjectBorrow(v));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = owner;
owner = PyStackRef_NULL;
stack_pointer[-1] = owner;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = v;
v = PyStackRef_NULL;
stack_pointer[-2] = v;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (err) {
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_XDECREF(old_value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_XDECREF(old_value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
}
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyDict_NotifyEvent(PyDict_EVENT_MODIFIED, dict, name, PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
FT_ATOMIC_STORE_PTR_RELEASE(ep->me_value, PyStackRef_AsPyObjectSteal(value));
UNLOCK_OBJECT(dict);
STAT_INC(STORE_ATTR, hit);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_XDECREF(old_value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP
{
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
v = stack_pointer[-1];
PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
DISPATCH();
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
value2 = PyStackRef_DUP(GETLOCAL(oparg2));
stack_pointer[-1] = value2;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
tmp = GETLOCAL(oparg2);
GETLOCAL(oparg2) = value2;
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH();
}
v = stack_pointer[-1];
PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
int err;
if (ns == NULL) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_Format(tstate, PyExc_SystemError,
"no locals found when storing %R", name);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
if (PyDict_CheckExact(ns)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
else {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(v);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
JUMP_TO_LABEL(error);
}
container = stack_pointer[-3];
v = stack_pointer[-4];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start),
PyStackRef_AsPyObjectSteal(stop),
Py_None);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
int err;
if (slice == NULL) {
err = 1;
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), slice, PyStackRef_AsPyObjectBorrow(v));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(slice);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += 2;
}
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = container;
container = PyStackRef_NULL;
stack_pointer[-3] = container;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = v;
v = PyStackRef_NULL;
stack_pointer[-4] = v;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -4;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (err) {
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_StoreSubscr(container, sub, next_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(STORE_SUBSCR);
{
v = stack_pointer[-3];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v));
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyStackRef tmp = sub;
sub = PyStackRef_NULL;
stack_pointer[-1] = sub;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = container;
container = PyStackRef_NULL;
stack_pointer[-2] = container;
PyStackRef_CLOSE(tmp);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
tmp = v;
v = PyStackRef_NULL;
stack_pointer[-3] = v;
PyStackRef_CLOSE(tmp);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
if (err) {
assert(Py_TYPE(dict)->tp_as_mapping->mp_ass_subscript == _PyDict_StoreSubscript);
STAT_INC(STORE_SUBSCR, hit);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = _PyDict_SetItem_Take2((PyDictObject *)dict,
PyStackRef_AsPyObjectSteal(sub),
PyStackRef_AsPyObjectSteal(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err) {
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(dict_st);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
st = dict_st;
stack_pointer += -3;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(old_value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
// _POP_TOP_INT
{
stack_pointer += -2;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_ToBool(value, next_instr);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(TO_BOOL);
// _TO_BOOL
{
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
value = v;
stack_pointer[-1] = res;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
value = v;
stack_pointer[-1] = res;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
_PyJitTracerState *tracer = _tstate->jit_tracer_state;
assert(tracer != NULL);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int full = !_PyJit_translate_single_bytecode_to_trace(tstate, frame, next_instr, stop_tracing ? _DEOPT : 0);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (full) {
LEAVE_TRACING();
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = stop_tracing_and_jit(tstate, frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
DISPATCH();
}
for (int i = 0; i < tracer->prev_state.recorded_count; i++) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_CLEAR(tracer->prev_state.recorded_values[i]);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
tracer->prev_state.recorded_count = 0;
tracer->prev_state.instr = next_instr;
PyObject *prev_code = PyStackRef_AsPyObjectBorrow(frame->f_executable);
if (tracer->prev_state.instr_code != (PyCodeObject *)prev_code) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_SETREF(tracer->prev_state.instr_code, (PyCodeObject*)Py_NewRef((prev_code)));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
tracer->prev_state.instr_frame = frame;
tracer->prev_state.instr_oparg = oparg;
{
value = stack_pointer[-1];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
{
value = v;
stack_pointer[-1] = res;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
{
value = stack_pointer[-1];
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value));
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
{
value = v;
stack_pointer[-1] = res;
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_XCLOSE(value);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg & 0xFF, oparg >> 8, top);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(seq_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res == 0) {
JUMP_TO_LABEL(error);
}
if (ADAPTIVE_COUNTER_TRIGGERS(counter)) {
next_instr = this_instr;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_Py_Specialize_UnpackSequence(seq, next_instr, oparg);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
DISPATCH_SAME_OPARG();
}
OPCODE_DEFERRED_INC(UNPACK_SEQUENCE);
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
int res = _PyEval_UnpackIterableStackRef(tstate, seq_o, oparg, -1, top);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_DECREF(seq_o);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res == 0) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1 + oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(seq);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += -1 + oparg;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(seq);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
stack_pointer += 1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
PyStackRef_CLOSE(seq);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
DISPATCH();
}
PyObject *stack[5] = {NULL, PyStackRef_AsPyObjectBorrow(exit_self), exc, val_o, tb};
int has_self = !PyStackRef_IsNull(exit_self);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
res_o = PyObject_Vectorcall(exit_func_o, stack + 2 - has_self,
(3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
Py_XDECREF(original_tb);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (res_o == NULL) {
JUMP_TO_LABEL(error);
}
stack_pointer += -1;
ASSERT_WITHIN_STACK_BOUNDS(__FILE__, __LINE__);
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
DTRACE_FUNCTION_RETURN();
tstate->exc_info = gen->gi_exc_state.previous_item;
gen->gi_exc_state.previous_item = NULL;
}
#endif
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND);
value = temp;
LLTRACE_RESUME_FRAME();
LABEL(error)
{
+ _PyFrame_StackAssertInvalid(frame);
#ifdef NDEBUG
if (!_PyErr_Occurred(tstate)) {
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyErr_SetString(tstate, PyExc_SystemError,
"error return without exception set");
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
#else
assert(_PyErr_Occurred(tstate));
#endif
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
STOP_TRACING();
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
assert(frame->owner != FRAME_OWNED_BY_INTERPRETER);
if (!_PyFrame_IsIncomplete(frame)) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyFrameObject *f = _PyFrame_GetFrameObject(frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (f != NULL) {
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
PyTraceBack_Here(f);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
}
}
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
_PyEval_MonitorRaise(tstate, frame, next_instr-1);
+ _PyFrame_StackPointerInvalidate(frame);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
JUMP_TO_LABEL(exception_unwind);
}
}
#endif
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
#if _Py_TAIL_CALL_INTERP
int opcode;
#endif
}
next_instr = frame->instr_ptr;
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
JUMP_TO_LABEL(error);
}
LABEL(start_frame)
{
+ #ifdef Py_DEBUG
+ assert(frame->stackpointer_valid == 1);
+ #endif
int too_deep = _Py_EnterRecursivePy(tstate);
if (too_deep) {
JUMP_TO_LABEL(exit_unwind_notrace);
assert(!_PyErr_Occurred(tstate));
#endif
stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
#if _Py_TAIL_CALL_INTERP
int opcode;
#endif
assert(IS_JIT_TRACING());
int opcode = next_instr->op.code;
_PyFrame_SetStackPointer(frame, stack_pointer);
+ _PyFrame_StackPointerValidate(frame);
_PyJit_translate_single_bytecode_to_trace(tstate, frame, NULL, _EXIT_TRACE);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
LEAVE_TRACING();
- _PyFrame_SetStackPointer(frame, stack_pointer);
+ assert(stack_pointer == _PyFrame_GetStackPointer(frame));
+ _PyFrame_StackPointerValidate(frame);
int err = stop_tracing_and_jit(tstate, frame);
- stack_pointer = _PyFrame_GetStackPointer(frame);
+ _PyFrame_StackPointerInvalidate(frame);
if (err < 0) {
JUMP_TO_LABEL(error);
}
"_PyFrame_PushUnchecked",
"_PyFrame_SetStackPointer",
"_PyFrame_StackPush",
+ "_PyFrame_StackAssertInvalid",
"_PyFunction_SetVersion",
"_PyGen_GetGeneratorFromFrame",
"gen_try_set_executing",
eval_breaker="CHECK_PERIODIC" in op.name,
needs_this=variable_used(op, "this_instr"),
always_exits=always_exits(op),
- sync_sp=variable_used(op, "SYNC_SP"),
+ sync_sp=variable_used(op, "SYNC_SP") or variable_used(op, "SAVE_STACK") or variable_used(op, "RELOAD_STACK"),
uses_co_consts=variable_used(op, "FRAME_CO_CONSTS"),
uses_co_names=variable_used(op, "FRAME_CO_NAMES"),
uses_locals=variable_used(op, "GETLOCAL") and not has_free,
self.newline = False
def emit_at(self, txt: str, where: Token) -> None:
- self.maybe_write_spill()
self.set_position(where)
self.out.write(txt)
self.last_token = None
def emit(self, txt: str | Token) -> None:
- self.maybe_write_spill()
if isinstance(txt, Token):
self.emit_token(txt)
elif isinstance(txt, str):
self.newline = True
self.last_token = None
- def emit_spill(self) -> None:
- if self.pending_reload:
- self.pending_reload = False
- return
- assert not self.pending_spill
- self.pending_spill = True
-
- def maybe_write_spill(self) -> None:
- if self.pending_spill:
- self.pending_spill = False
- self.emit_str("_PyFrame_SetStackPointer(frame, stack_pointer);\n")
- elif self.pending_reload:
- self.pending_reload = False
- self.emit_str("stack_pointer = _PyFrame_GetStackPointer(frame);\n")
-
- def emit_reload(self) -> None:
- if self.pending_spill:
- self.pending_spill = False
- return
- assert not self.pending_reload
- self.pending_reload = True
-
@contextlib.contextmanager
def header_guard(self, name: str) -> Iterator[None]:
self.out.write(
next(tkn_iter)
next(tkn_iter)
next(tkn_iter)
- self.emit_reload(storage)
+ storage.flush(self.out)
+ storage.full_reload(self.out)
return True
def instruction_size(self,
self.out.emit(stmt.for_)
for tkn in stmt.header:
self.out.emit(tkn)
- return self._emit_stmt(stmt.body, uop, storage, inst)
+ reachable, brace, body_storage = self._emit_stmt(stmt.body, uop, storage.copy(), inst)
+ body_storage.merge(storage, self.out)
+ if brace is not None:
+ self.out.emit(brace)
+ return reachable, None, storage
def emit_WhileStmt(
self,
def emit_default(out: CWriter, uop: Uop, stack: Stack) -> None:
+ assert stack.physical_sp is not None
null = CWriter.null()
for var in reversed(uop.stack.inputs):
stack.pop(var, null)
def emit_reload(self, storage: Storage) -> None:
pass
+ def reload_stack(
+ self,
+ tkn: Token,
+ tkn_iter: TokenIterator,
+ uop: CodeSection,
+ storage: Storage,
+ inst: Instruction | None,
+ ) -> bool:
+ next(tkn_iter)
+ next(tkn_iter)
+ next(tkn_iter)
+ return True
+
def goto_label(self, goto: Token, label: Token, storage: Storage) -> None:
self.out.emit(goto)
self.out.emit(label)
class Stack:
def __init__(self, check_stack_bounds: bool = False) -> None:
self.base_offset = PointerOffset.zero()
- self.physical_sp = PointerOffset.zero()
+ self.physical_sp:PointerOffset | None = PointerOffset.zero()
+ self.frame_sp:PointerOffset | None = None
self.logical_sp = PointerOffset.zero()
self.variables: list[Local] = []
self.check_stack_bounds = check_stack_bounds
raise StackError(f"Dropping live value '{var.name}'")
def pop(self, var: StackItem, out: CWriter) -> Local:
+ assert self.physical_sp is not None
if self.variables:
top = self.variables[-1]
if var.is_array() != top.is_array() or top.size != var.size:
out.emit(f"stack_pointer[{stack_offset.to_c()}] = {var.name};\n")
def _save_physical_sp(self, out: CWriter) -> None:
+ if self.physical_sp is None:
+ return
if self.physical_sp != self.logical_sp:
diff = self.logical_sp - self.physical_sp
out.start_line()
out.start_line()
var_offset = self.base_offset
for var in self.variables:
+ assert self.physical_sp is not None
if (
var.in_local and
not var.memory_offset and
var_offset = var_offset.push(var.item)
def stack_bound_check(self, out: CWriter) -> None:
+ if self.physical_sp is None:
+ return
if not self.check_stack_bounds:
return
if self.physical_sp != self.logical_sp:
self._save_physical_sp(out)
out.start_line()
+ def emit_spill(self, out: CWriter) -> None:
+ if self.frame_sp != self.physical_sp:
+ out.emit_str("_PyFrame_SetStackPointer(frame, stack_pointer);\n")
+ self.frame_sp = self.physical_sp
+ else:
+ out.emit_str("assert(stack_pointer == _PyFrame_GetStackPointer(frame));\n")
+ out.emit_str("_PyFrame_StackPointerValidate(frame);\n");
+
+ def expected_frame_pointer(self) -> str:
+ assert self.frame_sp is not None
+ assert self.physical_sp is not None
+ diff = self.frame_sp - self.physical_sp
+ return f"(stack_pointer + {diff.to_c()})"
+
+ def emit_reload(self, out: CWriter) -> None:
+ if self.physical_sp is None:
+ out.emit_str("stack_pointer = _PyFrame_GetStackPointer(frame);\n")
+ if self.frame_sp is None:
+ self.frame_sp = PointerOffset.zero()
+ self.physical_sp = self.frame_sp
+ out.emit_str("_PyFrame_StackPointerInvalidate(frame);\n");
+
+ def emit_fullreload(self, out: CWriter, spilled: bool = True) -> None:
+ self._print(out)
+ while self.variables:
+ top = self.variables.pop()
+ if not top.in_memory():
+ raise StackError(f"Cannot reload with live variable: {top.name}")
+ self.base_offset = PointerOffset.zero()
+ self.physical_sp = PointerOffset.zero()
+ self.frame_sp = PointerOffset.zero()
+ self.logical_sp = PointerOffset.zero()
+ out.emit_str("stack_pointer = _PyFrame_GetStackPointer(frame);\n")
+ if spilled:
+ out.emit_str("_PyFrame_StackPointerInvalidate(frame);\n")
+ else:
+ out.emit_str("_PyFrame_StackAssertInvalid(frame);\n")
+
def is_flushed(self) -> bool:
for var in self.variables:
if not var.in_memory():
return self.physical_sp == self.logical_sp
def sp_offset(self) -> str:
+ assert self.physical_sp is not None
return (self.physical_sp - self.logical_sp).to_c()
def as_comment(self) -> str:
variables = ", ".join([v.compact_str() for v in self.variables])
+ sp = "undefined" if self.physical_sp is None else self.physical_sp.to_c()
+ fp = "undefined" if self.frame_sp is None else self.frame_sp.to_c()
return (
- f"/* Variables=[{variables}]; base={self.base_offset.to_c()}; sp={self.physical_sp.to_c()}; logical_sp={self.logical_sp.to_c()} */"
+ f"/* Variables=[{variables}]; base={self.base_offset.to_c()}; sp={sp}; logical_sp={self.logical_sp.to_c()}; frame_sp={fp} */"
)
def _print(self, out: CWriter) -> None:
other.base_offset = self.base_offset
other.physical_sp = self.physical_sp
other.logical_sp = self.logical_sp
+ other.frame_sp = self.frame_sp
other.variables = [var.copy() for var in self.variables]
other.check_stack_bounds = self.check_stack_bounds
return other
def align(self, other: "Stack", out: CWriter) -> None:
if self.logical_sp != other.logical_sp:
raise StackError("Cannot align stacks: differing logical top")
+ if self.physical_sp is None and other.physical_sp is None:
+ return
+ if self.physical_sp is None or other.physical_sp is None:
+ raise StackError("Cannot align stacks: stack_pointer is partly undefined")
if self.physical_sp == other.physical_sp:
return
diff = other.physical_sp - self.physical_sp
out.start_line()
out.emit(f"stack_pointer += {diff.to_c()};\n")
self.physical_sp = other.physical_sp
+ if self.frame_sp != other.frame_sp:
+ self.frame_sp = None
def merge(self, other: "Stack", out: CWriter) -> None:
if len(self.variables) != len(other.variables):
raise StackError(f"Mismatched stack depths for {self_var.name}: {self_var.memory_offset} and {other_var.memory_offset}")
elif other_var.memory_offset is None:
self_var.memory_offset = None
+ if self.frame_sp != other.frame_sp:
+ self.frame_sp = None
+ other.frame_sp = None
def stacks(inst: Instruction | PseudoInstruction) -> Iterator[StackEffect]:
assert self.spilled >= 0
if self.spilled == 0:
out.start_line()
- out.emit_spill()
+ self.stack.emit_spill(out)
self.spilled += 1
def save_inputs(self, out: CWriter) -> None:
self.clear_dead_inputs()
self.stack.flush(out)
out.start_line()
- out.emit_spill()
+ self.stack.emit_spill(out)
self.spilled += 1
def reload(self, out: CWriter) -> None:
self.spilled -= 1
if self.spilled == 0:
out.start_line()
- out.emit_reload()
+ self.stack.emit_reload(out)
+
+ def full_reload(self, out: CWriter) -> None:
+ if self.spilled == 0:
+ # Already spilled, presumably an explicit request
+ # to reload the stack from memory
+ out.start_line()
+ out.emit_str("// Explicit stack reload\n");
+ self.stack.emit_fullreload(out, spilled=False)
+ else:
+ assert self.spilled > 0
+ self.spilled -= 1
+ implicit = True
+ self.stack.emit_fullreload(out)
@staticmethod
def for_uop(stack: Stack, uop: Uop, out: CWriter, check_liveness: bool = True) -> "Storage":
+ if stack.physical_sp is None:
+ raise StackError("stack pointer must be defined for uop")
inputs: list[Local] = []
peeks: list[Local] = []
for input in reversed(uop.stack.inputs):
def push_outputs(self) -> None:
if self.spilled:
- raise StackError(f"Unbalanced stack spills")
+ raise StackError(f"Too many stack spills")
self.clear_inputs("at the end of the micro-op")
if len(self.inputs) > self.peeks and self.check_liveness:
raise StackError(f"Input variable '{self.inputs[-1].name}' is still live")
storage = Storage(Stack(), [], [], 0, False)
if label.spilled:
storage.spilled = 1
+ storage.stack.physical_sp = None
emitter.emit_tokens(label, storage, None)
emitter.emit("\n\n")
projects / thirdparty / Python / cpython.git / commitdiff
