From 75bda2803addd6513c2187ed754ff73adbd1ff77 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Wed, 7 Aug 2024 16:13:24 +0100 Subject: [PATCH 01/53] Add copy and == support to Stack class --- Tools/cases_generator/stack.py | 36 ++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index d2d598a120892d..d5f6a18baa8116 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -75,6 +75,19 @@ def condition(self) -> str | None: def is_array(self) -> bool: return self.item.is_array() + def copy(self) -> Local: + return Local(self.item, self.cached, self.in_memory, self.defined) + + def __eq__(self, other: object) -> bool: + if not isinstance(other, Local): + return NotImplemented + return ( + self.item is other.item and + self.cached is other.cached and + self.in_memory is other.in_memory and + self.defined is other.defined + ) + @dataclass class StackOffset: "The stack offset of the virtual base of the stack from the physical stack pointer" @@ -159,12 +172,17 @@ def clear(self) -> None: self.popped = [] self.pushed = [] + def __eq__(self, other: object) -> bool: + if not isinstance(other, StackOffset): + return NotImplemented + return self.to_c() == other.to_c() class StackError(Exception): pass class Stack: + def __init__(self) -> None: self.top_offset = StackOffset.empty() self.base_offset = StackOffset.empty() @@ -296,6 +314,24 @@ def peek_offset(self) -> str: def as_comment(self) -> str: return f"/* Variables: {[v.name for v in self.variables]}. Base offset: {self.base_offset.to_c()}. Top offset: {self.top_offset.to_c()} */" + def copy(self) -> Stack: + other = Stack() + other.top_offset = self.top_offset.copy() + other.base_offset = self.base_offset.copy() + other.variables = [ var.copy() for var in self.variables ] + other.defined = set(self.defined) + return other + + def __eq__(self, other: object) -> bool: + if not isinstance(other, Stack): + return NotImplemented + return ( + self.top_offset == other.top_offset and + self.base_offset == other.base_offset and + self.variables == other.variables and + self.defined == other.defined + ) + def get_stack_effect(inst: Instruction | PseudoInstruction) -> Stack: stack = Stack() From d331371fa404a1a9989e22d3cf7edad87a0c1570 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 8 Aug 2024 11:00:16 +0100 Subject: [PATCH 02/53] blacken stack.py --- Tools/cases_generator/stack.py | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index 7ad043122dae4b..aebc60db0a9ded 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -75,17 +75,16 @@ def condition(self) -> str | None: def is_array(self) -> bool: return self.item.is_array() - return Local(self.item, self.cached, self.in_memory, self.defined) def __eq__(self, other: object) -> bool: if not isinstance(other, Local): return NotImplemented return ( - self.item is other.item and - self.cached is other.cached and - self.in_memory is other.in_memory and - self.defined is other.defined + self.item is other.item + and self.cached is other.cached + and self.in_memory is other.in_memory + and self.defined is other.defined ) @@ -178,12 +177,12 @@ def __eq__(self, other: object) -> bool: return NotImplemented return self.to_c() == other.to_c() + class StackError(Exception): pass class Stack: - def __init__(self) -> None: self.top_offset = StackOffset.empty() self.base_offset = StackOffset.empty() @@ -366,7 +365,7 @@ def copy(self) -> Stack: other = Stack() other.top_offset = self.top_offset.copy() other.base_offset = self.base_offset.copy() - other.variables = [ var.copy() for var in self.variables ] + other.variables = [var.copy() for var in self.variables] other.defined = set(self.defined) return other @@ -374,10 +373,10 @@ def __eq__(self, other: object) -> bool: if not isinstance(other, Stack): return NotImplemented return ( - self.top_offset == other.top_offset and - self.base_offset == other.base_offset and - self.variables == other.variables and - self.defined == other.defined + self.top_offset == other.top_offset + and self.base_offset == other.base_offset + and self.variables == other.variables + and self.defined == other.defined ) From 4673d8a929988bf0f867a2e37b2a4db91fac072c Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 8 Aug 2024 16:53:26 +0100 Subject: [PATCH 03/53] Cases generator: Track reachability and divergent stacks in if statements. --- Python/bytecodes.c | 18 +- Python/executor_cases.c.h | 10 +- Python/generated_cases.c.h | 142 +++++++------- Tools/cases_generator/analyzer.py | 9 - Tools/cases_generator/generators_common.py | 188 +++++++++++++++---- Tools/cases_generator/optimizer_generator.py | 3 +- Tools/cases_generator/stack.py | 29 +-- Tools/cases_generator/tier1_generator.py | 3 +- Tools/cases_generator/tier2_generator.py | 48 +++-- 9 files changed, 302 insertions(+), 148 deletions(-) diff --git a/Python/bytecodes.c b/Python/bytecodes.c index b68f9327d898c2..fbaa894a30ac51 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -961,7 +961,9 @@ dummy_func( int err = _Py_call_instrumentation_arg( tstate, PY_MONITORING_EVENT_PY_RETURN, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); - if (err) ERROR_NO_POP(); + if (err) { + ERROR_NO_POP(); + } } macro(INSTRUMENTED_RETURN_VALUE) = @@ -1154,7 +1156,9 @@ dummy_func( tstate, PY_MONITORING_EVENT_PY_YIELD, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); LOAD_SP(); - if (err) ERROR_NO_POP(); + if (err) { + ERROR_NO_POP(); + } if (frame->instr_ptr != this_instr) { next_instr = frame->instr_ptr; DISPATCH(); @@ -1262,10 +1266,12 @@ dummy_func( DECREF_INPUTS(); ERROR_IF(true, error); } - if (PyDict_CheckExact(ns)) + if (PyDict_CheckExact(ns)) { err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); - else + } + else { err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); + } DECREF_INPUTS(); ERROR_IF(err, error); } @@ -4134,7 +4140,9 @@ dummy_func( int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, func, arg); - if (err) ERROR_NO_POP(); + if (err) { + ERROR_NO_POP(); + } result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); if (!PyFunction_Check(func) && !PyMethod_Check(func)) { diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index f2741286d60197..893f86684ddd12 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -1404,10 +1404,12 @@ PyStackRef_CLOSE(v); if (true) JUMP_TO_ERROR(); } - if (PyDict_CheckExact(ns)) - err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); - else - err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); + if (PyDict_CheckExact(ns)) { + err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); + } + else { + err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); + } PyStackRef_CLOSE(v); if (err) JUMP_TO_ERROR(); stack_pointer += -1; diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index d0aa0f9fe83182..929ecb8f6193e7 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -963,11 +963,11 @@ } // _CHECK_PERIODIC { + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); + CHECK_EVAL_BREAKER(); } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - CHECK_EVAL_BREAKER(); DISPATCH(); } @@ -1289,11 +1289,11 @@ } // _CHECK_PERIODIC { + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); + CHECK_EVAL_BREAKER(); } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - CHECK_EVAL_BREAKER(); DISPATCH(); } @@ -1358,11 +1358,11 @@ } // _CHECK_PERIODIC { + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); + CHECK_EVAL_BREAKER(); } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - CHECK_EVAL_BREAKER(); DISPATCH(); } @@ -1426,11 +1426,11 @@ } // _CHECK_PERIODIC { + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); + CHECK_EVAL_BREAKER(); } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - CHECK_EVAL_BREAKER(); DISPATCH(); } @@ -1480,11 +1480,11 @@ } // _CHECK_PERIODIC { + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); + CHECK_EVAL_BREAKER(); } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - CHECK_EVAL_BREAKER(); DISPATCH(); } @@ -1529,7 +1529,9 @@ int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, func, arg); - if (err) goto error; + if (err) { + goto error; + } result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); if (!PyFunction_Check(func) && !PyMethod_Check(func)) { if (PyStackRef_IsNull(result)) { @@ -1578,10 +1580,12 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - stack_pointer[-3 - (oparg & 1)] = result; - stack_pointer += -2 - (oparg & 1); + stack_pointer += -3 - (oparg & 1); assert(WITHIN_STACK_BOUNDS()); CHECK_EVAL_BREAKER(); + stack_pointer[0] = result; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -1775,10 +1779,12 @@ goto error; } res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-3 - oparg] = res; - stack_pointer += -2 - oparg; + stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); CHECK_EVAL_BREAKER(); + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -1926,11 +1932,11 @@ } // _CHECK_PERIODIC { + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); + CHECK_EVAL_BREAKER(); } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - CHECK_EVAL_BREAKER(); DISPATCH(); } @@ -1997,11 +2003,11 @@ } // _CHECK_PERIODIC { + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); + CHECK_EVAL_BREAKER(); } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - CHECK_EVAL_BREAKER(); DISPATCH(); } @@ -2055,11 +2061,11 @@ } // _CHECK_PERIODIC { + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); + CHECK_EVAL_BREAKER(); } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - CHECK_EVAL_BREAKER(); DISPATCH(); } @@ -2116,11 +2122,11 @@ } // _CHECK_PERIODIC { + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); + CHECK_EVAL_BREAKER(); } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - CHECK_EVAL_BREAKER(); DISPATCH(); } @@ -2189,11 +2195,11 @@ } // _CHECK_PERIODIC { + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); + CHECK_EVAL_BREAKER(); } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - CHECK_EVAL_BREAKER(); DISPATCH(); } @@ -2383,11 +2389,11 @@ } // _CHECK_PERIODIC { + stack_pointer[-3] = res; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); + CHECK_EVAL_BREAKER(); } - stack_pointer[-3] = res; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); - CHECK_EVAL_BREAKER(); DISPATCH(); } @@ -2419,11 +2425,11 @@ } // _CHECK_PERIODIC { + stack_pointer[-3] = res; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); + CHECK_EVAL_BREAKER(); } - stack_pointer[-3] = res; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); - CHECK_EVAL_BREAKER(); DISPATCH(); } @@ -3751,11 +3757,11 @@ } // _CHECK_PERIODIC { + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); + CHECK_EVAL_BREAKER(); } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - CHECK_EVAL_BREAKER(); DISPATCH(); } @@ -4080,7 +4086,9 @@ int err = _Py_call_instrumentation_arg( tstate, PY_MONITORING_EVENT_PY_RETURN, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); - if (err) goto error; + if (err) { + goto error; + } } // _RETURN_VALUE retval = val; @@ -4120,7 +4128,9 @@ int err = _Py_call_instrumentation_arg( tstate, PY_MONITORING_EVENT_PY_RETURN, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); - if (err) goto error; + if (err) { + goto error; + } } // _RETURN_VALUE retval = val; @@ -4164,7 +4174,9 @@ tstate, PY_MONITORING_EVENT_PY_YIELD, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); LOAD_SP(); - if (err) goto error; + if (err) { + goto error; + } if (frame->instr_ptr != this_instr) { next_instr = frame->instr_ptr; DISPATCH(); @@ -6538,10 +6550,12 @@ PyStackRef_CLOSE(v); if (true) goto pop_1_error; } - if (PyDict_CheckExact(ns)) - err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); - else - err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); + if (PyDict_CheckExact(ns)) { + err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); + } + else { + err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); + } PyStackRef_CLOSE(v); if (err) goto pop_1_error; stack_pointer += -1; diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index c91edff24bc665..fea4e45e049303 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -4,7 +4,6 @@ import re from typing import Optional - @dataclass class Properties: escapes: bool @@ -14,7 +13,6 @@ class Properties: oparg: bool jumps: bool eval_breaker: bool - ends_with_eval_breaker: bool needs_this: bool always_exits: bool stores_sp: bool @@ -44,7 +42,6 @@ def from_list(properties: list["Properties"]) -> "Properties": oparg=any(p.oparg for p in properties), jumps=any(p.jumps for p in properties), eval_breaker=any(p.eval_breaker for p in properties), - ends_with_eval_breaker=any(p.ends_with_eval_breaker for p in properties), needs_this=any(p.needs_this for p in properties), always_exits=any(p.always_exits for p in properties), stores_sp=any(p.stores_sp for p in properties), @@ -70,7 +67,6 @@ def infallible(self) -> bool: oparg=False, jumps=False, eval_breaker=False, - ends_with_eval_breaker=False, needs_this=False, always_exits=False, stores_sp=False, @@ -587,10 +583,6 @@ def makes_escaping_api_call(instr: parser.InstDef) -> bool: } -def eval_breaker_at_end(op: parser.InstDef) -> bool: - return op.tokens[-5].text == "CHECK_EVAL_BREAKER" - - def always_exits(op: parser.InstDef) -> bool: depth = 0 tkn_iter = iter(op.tokens) @@ -679,7 +671,6 @@ def compute_properties(op: parser.InstDef) -> Properties: oparg=oparg_used(op), jumps=variable_used(op, "JUMPBY"), eval_breaker=variable_used(op, "CHECK_EVAL_BREAKER"), - ends_with_eval_breaker=eval_breaker_at_end(op), needs_this=variable_used(op, "this_instr"), always_exits=always_exits(op), stores_sp=variable_used(op, "SYNC_SP"), diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 6ed9d836cbbabe..4a4648ef574b22 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -9,11 +9,39 @@ analysis_error, ) from cwriter import CWriter -from typing import Callable, Mapping, TextIO, Iterator +from typing import Callable, Mapping, TextIO, Iterator, Iterable from lexer import Token from stack import Stack +class TokenIterator: + + ahead: Token | None + iterator: Iterator[Token] + + def __init__(self, tkns: Iterable[Token]): + self.iterator = iter(tkns) + self.ahead = None + + def __iter__(self) -> "TokenIterator": + return self + + def __next__(self) -> Token: + if self.ahead is None: + return next(self.iterator) + else: + res = self.ahead + self.ahead = None + return res + + def peek(self) -> Token | None: + if self.ahead is None: + try: + self.ahead = next(self.iterator) + except StopIteration: + pass + return self.ahead + ROOT = Path(__file__).parent.parent.parent DEFAULT_INPUT = (ROOT / "Python/bytecodes.c").absolute().as_posix() @@ -47,22 +75,27 @@ def write_header( ) -def emit_to(out: CWriter, tkn_iter: Iterator[Token], end: str) -> None: +def emit_to(out: CWriter, tkn_iter: TokenIterator, end: str) -> Token: parens = 0 for tkn in tkn_iter: if tkn.kind == end and parens == 0: - return + return tkn if tkn.kind == "LPAREN": parens += 1 if tkn.kind == "RPAREN": parens -= 1 out.emit(tkn) + raise analysis_error(f"Expecting {end}. Reached end of file", tkn) ReplacementFunctionType = Callable[ - [Token, Iterator[Token], Uop, Stack, Instruction | None], None + [Token, TokenIterator, Uop, Stack, Instruction | None], bool ] +def always_true(tkn: Token | None) -> bool: + if tkn is None: + return False + return tkn.text == "true" or tkn.text == "1" class Emitter: out: CWriter @@ -84,13 +117,16 @@ def __init__(self, out: CWriter): def deopt_if( self, tkn: Token, - tkn_iter: Iterator[Token], + tkn_iter: TokenIterator, uop: Uop, unused: Stack, inst: Instruction | None, - ) -> None: + ) -> bool: self.out.emit_at("DEOPT_IF", tkn) - self.out.emit(next(tkn_iter)) + lparen = next(tkn_iter) + self.emit(lparen) + assert(lparen.kind == "LPAREN") + first_tkn = tkn_iter.peek() emit_to(self.out, tkn_iter, "RPAREN") next(tkn_iter) # Semi colon self.out.emit(", ") @@ -98,19 +134,23 @@ def deopt_if( assert inst.family is not None self.out.emit(inst.family.name) self.out.emit(");\n") + return not always_true(first_tkn) exit_if = deopt_if def error_if( self, tkn: Token, - tkn_iter: Iterator[Token], + tkn_iter: TokenIterator, uop: Uop, stack: Stack, inst: Instruction | None, - ) -> None: + ) -> bool: self.out.emit_at("if ", tkn) - self.out.emit(next(tkn_iter)) + lparen = next(tkn_iter) + self.emit(lparen) + assert(lparen.kind == "LPAREN") + first_tkn = tkn_iter.peek() emit_to(self.out, tkn_iter, "COMMA") label = next(tkn_iter).text next(tkn_iter) # RPAREN @@ -131,33 +171,35 @@ def error_if( self.out.emit(";\n") else: self.out.emit("{\n") - stack.flush_locally(self.out) + stack.copy().flush(self.out) self.out.emit("goto ") self.out.emit(label) self.out.emit(";\n") self.out.emit("}\n") + return first_tkn.text != "true" and first_tkn.text != "1" def error_no_pop( self, tkn: Token, - tkn_iter: Iterator[Token], + tkn_iter: TokenIterator, uop: Uop, stack: Stack, inst: Instruction | None, - ) -> None: + ) -> bool: next(tkn_iter) # LPAREN next(tkn_iter) # RPAREN next(tkn_iter) # Semi colon self.out.emit_at("goto error;", tkn) + return False def decref_inputs( self, tkn: Token, - tkn_iter: Iterator[Token], + tkn_iter: TokenIterator, uop: Uop, stack: Stack, inst: Instruction | None, - ) -> None: + ) -> bool: next(tkn_iter) next(tkn_iter) next(tkn_iter) @@ -176,42 +218,45 @@ def decref_inputs( self.out.emit(f"PyStackRef_XCLOSE({var.name});\n") else: self.out.emit(f"PyStackRef_CLOSE({var.name});\n") + return True def sync_sp( self, tkn: Token, - tkn_iter: Iterator[Token], + tkn_iter: TokenIterator, uop: Uop, stack: Stack, inst: Instruction | None, - ) -> None: + ) -> bool: next(tkn_iter) next(tkn_iter) next(tkn_iter) stack.flush(self.out) + return True def check_eval_breaker( self, tkn: Token, - tkn_iter: Iterator[Token], + tkn_iter: TokenIterator, uop: Uop, stack: Stack, inst: Instruction | None, - ) -> None: + ) -> bool: next(tkn_iter) next(tkn_iter) next(tkn_iter) - if not uop.properties.ends_with_eval_breaker: - self.out.emit_at("CHECK_EVAL_BREAKER();", tkn) + stack.flush(self.out) + self.out.emit_at("CHECK_EVAL_BREAKER();", tkn) + return True def py_stack_ref_from_py_object_new( self, tkn: Token, - tkn_iter: Iterator[Token], + tkn_iter: TokenIterator, uop: Uop, stack: Stack, inst: Instruction | None, - ) -> None: + ) -> bool: self.out.emit(tkn) emit_to(self.out, tkn_iter, "SEMI") self.out.emit(";\n") @@ -219,29 +264,106 @@ def py_stack_ref_from_py_object_new( target = uop.deferred_refs[tkn] if target is None: # An assignment we don't handle, such as to a pointer or array. - return + return True # Flush the assignment to the stack. Note that we don't flush the # stack pointer here, and instead are currently relying on initializing # unused portions of the stack to NULL. stack.flush_single_var(self.out, target, uop.stack.outputs) + return True - def emit_tokens( + def _emit_if( self, + tkn_iter: TokenIterator, uop: Uop, stack: Stack, inst: Instruction | None, - ) -> None: - tkns = uop.body[1:-1] - if not tkns: - return - tkn_iter = iter(tkns) - self.out.start_line() + ) -> tuple[bool, Token, Stack]: + """ Returns (reachable?, closing '}', stack).""" + tkn = next(tkn_iter) + assert (tkn.kind == "LPAREN") + self.out.emit(tkn) + rparen = emit_to(self.out, tkn_iter, "RPAREN") + self.emit(rparen) + if_stack = stack.copy() + reachable, rbrace, if_stack = self._emit_block(tkn_iter, uop, if_stack, inst, True) + maybe_else = tkn_iter.peek() + if maybe_else and maybe_else.kind == "ELSE": + self.emit(rbrace) + self.emit(next(tkn_iter)) + maybe_if = tkn_iter.peek() + if maybe_if and maybe_if.kind == "IF": + self.emit(next(tkn_iter)) + else_reachable, rbrace, stack = self._emit_if(tkn_iter, uop, stack, inst) + else: + else_reachable, rbrace, stack = self._emit_block(tkn_iter, uop, stack, inst, True) + if not reachable: + # Discard the if stack + reachable = else_reachable + elif not else_reachable: + # Discard the else stack + stack = if_stack + else: + stack = stack.merge(if_stack) + else: + if reachable: + stack = stack.merge(if_stack) + else: + # Discard the if stack + reachable = True + return reachable, rbrace, stack + + def _emit_block( + self, + tkn_iter: TokenIterator, + uop: Uop, + stack: Stack, + inst: Instruction | None, + emit_first_brace: bool + ) -> tuple[bool, Token, Stack]: + """ Returns (reachable?, closing '}', stack).""" + braces = 1 + tkn = next(tkn_iter) + reachable = True + if tkn.kind != "LBRACE": + raise analysis_error(f"Expected '{{' found {tkn.text}", tkn) + if emit_first_brace: + self.emit(tkn) for tkn in tkn_iter: - if tkn.kind == "IDENTIFIER" and tkn.text in self._replacers: - self._replacers[tkn.text](tkn, tkn_iter, uop, stack, inst) + if tkn.kind == "LBRACE": + self.out.emit(tkn) + braces += 1 + elif tkn.kind == "RBRACE": + braces -= 1 + if braces == 0: + return reachable, tkn, stack + self.out.emit(tkn) + elif tkn.kind == "GOTO": + reachable = False; + self.out.emit(tkn) + elif tkn.kind == "IDENTIFIER" and tkn.text in self._replacers: + if not self._replacers[tkn.text](tkn, tkn_iter, uop, stack, inst): + reachable = False + elif tkn.kind == "IF": + self.out.emit(tkn) + if_reachable, rbrace, stack = self._emit_if(tkn_iter, uop, stack, inst) + if reachable: + reachable = if_reachable + self.out.emit(rbrace) else: self.out.emit(tkn) + raise analysis_error("Expecting closing brace. Reached end of file", tkn) + + + def emit_tokens( + self, + uop: Uop, + stack: Stack, + inst: Instruction | None, + ) -> None: + tkn_iter = TokenIterator(uop.body) + self.out.start_line() + self._emit_block(tkn_iter, uop, stack, inst, False) def emit(self, txt: str | Token) -> None: self.out.emit(txt) diff --git a/Tools/cases_generator/optimizer_generator.py b/Tools/cases_generator/optimizer_generator.py index b74f627235ad84..78074b8d262f03 100644 --- a/Tools/cases_generator/optimizer_generator.py +++ b/Tools/cases_generator/optimizer_generator.py @@ -18,6 +18,7 @@ ROOT, write_header, Emitter, + TokenIterator, ) from cwriter import CWriter from typing import TextIO, Iterator @@ -65,7 +66,7 @@ def declare_variables(uop: Uop, out: CWriter, skip_inputs: bool) -> None: def decref_inputs( out: CWriter, tkn: Token, - tkn_iter: Iterator[Token], + tkn_iter: TokenIterator, uop: Uop, stack: Stack, inst: Instruction | None, diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index aebc60db0a9ded..50327d1d1623bc 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -60,6 +60,14 @@ def redefinition(var: StackItem, prev: "Local") -> "Local": assert var.is_array() == prev.is_array() return Local(var, prev.cached, prev.in_memory, True) + def copy(self) -> "Local": + return Local( + self.item, + self.cached, + self.in_memory, + self.defined + ) + @property def size(self) -> str: return self.item.size @@ -302,18 +310,6 @@ def _do_flush( out.emit("assert(WITHIN_STACK_BOUNDS());\n") out.start_line() - def flush_locally( - self, out: CWriter, cast_type: str = "uintptr_t", extract_bits: bool = False - ) -> None: - self._do_flush( - out, - self.variables[:], - self.base_offset.copy(), - self.top_offset.copy(), - cast_type, - extract_bits, - ) - def flush( self, out: CWriter, cast_type: str = "uintptr_t", extract_bits: bool = False ) -> None: @@ -361,7 +357,7 @@ def peek_offset(self) -> str: def as_comment(self) -> str: return f"/* Variables: {[v.name for v in self.variables]}. Base offset: {self.base_offset.to_c()}. Top offset: {self.top_offset.to_c()} */" - def copy(self) -> Stack: + def copy(self) -> "Stack": other = Stack() other.top_offset = self.top_offset.copy() other.base_offset = self.base_offset.copy() @@ -380,6 +376,11 @@ def __eq__(self, other: object) -> bool: ) + def merge(self, other:"Stack") -> "Stack": + if self != other: + raise StackError("unequal stacks") + return self + def get_stack_effect(inst: Instruction | PseudoInstruction) -> Stack: stack = Stack() @@ -405,3 +406,5 @@ def stacks(inst: Instruction | PseudoInstruction) -> Iterator[StackEffect]: local = Local.unused(var) stack.push(local) return stack + +UNREACHABLE = Stack() diff --git a/Tools/cases_generator/tier1_generator.py b/Tools/cases_generator/tier1_generator.py index c3456cd39ffc3b..130cf18df8eb05 100644 --- a/Tools/cases_generator/tier1_generator.py +++ b/Tools/cases_generator/tier1_generator.py @@ -22,6 +22,7 @@ write_header, type_and_null, Emitter, + TokenIterator, ) from cwriter import CWriter from typing import TextIO @@ -201,8 +202,6 @@ def generate_tier1( out.start_line() if not inst.parts[-1].properties.always_exits: stack.flush(out) - if inst.parts[-1].properties.ends_with_eval_breaker: - out.emit("CHECK_EVAL_BREAKER();\n") out.emit("DISPATCH();\n") out.start_line() out.emit("}") diff --git a/Tools/cases_generator/tier2_generator.py b/Tools/cases_generator/tier2_generator.py index 7ed937636ee855..0b9e0d47f31b1e 100644 --- a/Tools/cases_generator/tier2_generator.py +++ b/Tools/cases_generator/tier2_generator.py @@ -20,6 +20,7 @@ write_header, type_and_null, Emitter, + TokenIterator, ) from cwriter import CWriter from typing import TextIO, Iterator @@ -69,85 +70,100 @@ def __init__(self, out: CWriter): def error_if( self, tkn: Token, - tkn_iter: Iterator[Token], + tkn_iter: TokenIterator, uop: Uop, stack: Stack, inst: Instruction | None, - ) -> None: + ) -> bool: self.out.emit_at("if ", tkn) - self.emit(next(tkn_iter)) + lparen = next(tkn_iter) + self.emit(lparen) + assert(lparen.kind == "LPAREN") + first_tkn = next(tkn_iter) + self.out.emit(first_tkn) emit_to(self.out, tkn_iter, "COMMA") label = next(tkn_iter).text next(tkn_iter) # RPAREN next(tkn_iter) # Semi colon self.emit(") JUMP_TO_ERROR();\n") + return first_tkn.text != "true" and first_tkn.text != "1" + def error_no_pop( self, tkn: Token, - tkn_iter: Iterator[Token], + tkn_iter: TokenIterator, uop: Uop, stack: Stack, inst: Instruction | None, - ) -> None: + ) -> bool: next(tkn_iter) # LPAREN next(tkn_iter) # RPAREN next(tkn_iter) # Semi colon self.out.emit_at("JUMP_TO_ERROR();", tkn) + return False def deopt_if( self, tkn: Token, - tkn_iter: Iterator[Token], + tkn_iter: TokenIterator, uop: Uop, unused: Stack, inst: Instruction | None, - ) -> None: + ) -> bool: self.out.emit_at("if ", tkn) - self.emit(next(tkn_iter)) + lparen = next(tkn_iter) + self.emit(lparen) + assert(lparen.kind == "LPAREN") + first_tkn = tkn_iter.peek() emit_to(self.out, tkn_iter, "RPAREN") next(tkn_iter) # Semi colon self.emit(") {\n") self.emit("UOP_STAT_INC(uopcode, miss);\n") self.emit("JUMP_TO_JUMP_TARGET();\n") self.emit("}\n") + return first_tkn.text != "true" and first_tkn.text != "1" def exit_if( # type: ignore[override] self, tkn: Token, - tkn_iter: Iterator[Token], + tkn_iter: TokenIterator, uop: Uop, unused: Stack, inst: Instruction | None, - ) -> None: + ) -> bool: self.out.emit_at("if ", tkn) - self.emit(next(tkn_iter)) + lparen = next(tkn_iter) + self.emit(lparen) + first_tkn = tkn_iter.peek() emit_to(self.out, tkn_iter, "RPAREN") next(tkn_iter) # Semi colon self.emit(") {\n") self.emit("UOP_STAT_INC(uopcode, miss);\n") self.emit("JUMP_TO_JUMP_TARGET();\n") self.emit("}\n") + return first_tkn.text != "true" and first_tkn.text != "1" def oparg( self, tkn: Token, - tkn_iter: Iterator[Token], + tkn_iter: TokenIterator, uop: Uop, unused: Stack, inst: Instruction | None, - ) -> None: + ) -> bool: if not uop.name.endswith("_0") and not uop.name.endswith("_1"): self.emit(tkn) - return + return True amp = next(tkn_iter) if amp.text != "&": self.emit(tkn) self.emit(amp) - return + return True one = next(tkn_iter) assert one.text == "1" self.out.emit_at(uop.name[-1], tkn) + return True def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> None: @@ -230,8 +246,6 @@ def generate_tier2( out.start_line() if not uop.properties.always_exits: stack.flush(out) - if uop.properties.ends_with_eval_breaker: - out.emit("CHECK_EVAL_BREAKER();\n") out.emit("break;\n") out.start_line() out.emit("}") From 132df06a740ad37296d5396efd7c15dd5d65a3a7 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 9 Aug 2024 10:06:56 +0100 Subject: [PATCH 04/53] Fix type errors and rename ahead to look_ahead --- Tools/cases_generator/generators_common.py | 18 +++++++++--------- Tools/cases_generator/tier2_generator.py | 5 +++-- 2 files changed, 12 insertions(+), 11 deletions(-) diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 4a4648ef574b22..b7730b8072d42d 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -16,31 +16,31 @@ class TokenIterator: - ahead: Token | None + look_ahead: Token | None iterator: Iterator[Token] def __init__(self, tkns: Iterable[Token]): self.iterator = iter(tkns) - self.ahead = None + self.look_ahead = None def __iter__(self) -> "TokenIterator": return self def __next__(self) -> Token: - if self.ahead is None: + if self.look_ahead is None: return next(self.iterator) else: - res = self.ahead - self.ahead = None + res = self.look_ahead + self.look_ahead = None return res def peek(self) -> Token | None: - if self.ahead is None: + if self.look_ahead is None: try: - self.ahead = next(self.iterator) + self.look_ahead = next(self.iterator) except StopIteration: pass - return self.ahead + return self.look_ahead ROOT = Path(__file__).parent.parent.parent DEFAULT_INPUT = (ROOT / "Python/bytecodes.c").absolute().as_posix() @@ -176,7 +176,7 @@ def error_if( self.out.emit(label) self.out.emit(";\n") self.out.emit("}\n") - return first_tkn.text != "true" and first_tkn.text != "1" + return not always_true(first_tkn) def error_no_pop( self, diff --git a/Tools/cases_generator/tier2_generator.py b/Tools/cases_generator/tier2_generator.py index 0b9e0d47f31b1e..cb7f5c38edbcd4 100644 --- a/Tools/cases_generator/tier2_generator.py +++ b/Tools/cases_generator/tier2_generator.py @@ -21,6 +21,7 @@ type_and_null, Emitter, TokenIterator, + always_true, ) from cwriter import CWriter from typing import TextIO, Iterator @@ -122,7 +123,7 @@ def deopt_if( self.emit("UOP_STAT_INC(uopcode, miss);\n") self.emit("JUMP_TO_JUMP_TARGET();\n") self.emit("}\n") - return first_tkn.text != "true" and first_tkn.text != "1" + return not always_true(first_tkn) def exit_if( # type: ignore[override] self, @@ -142,7 +143,7 @@ def exit_if( # type: ignore[override] self.emit("UOP_STAT_INC(uopcode, miss);\n") self.emit("JUMP_TO_JUMP_TARGET();\n") self.emit("}\n") - return first_tkn.text != "true" and first_tkn.text != "1" + return not always_true(first_tkn) def oparg( self, From b7f71d43c6d828d0173070bfe69a54d55e8ee8a7 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 9 Aug 2024 14:09:55 +0100 Subject: [PATCH 05/53] Track state of output variables --- Lib/test/test_generated_cases.py | 44 +++++++++++++- Python/generated_cases.c.h | 12 ++-- Tools/cases_generator/analyzer.py | 40 +++++++++---- Tools/cases_generator/generators_common.py | 62 ++++++++++++++++---- Tools/cases_generator/optimizer_generator.py | 4 +- Tools/cases_generator/stack.py | 4 +- Tools/cases_generator/tier1_generator.py | 4 +- Tools/cases_generator/tier2_generator.py | 9 ++- 8 files changed, 140 insertions(+), 39 deletions(-) diff --git a/Lib/test/test_generated_cases.py b/Lib/test/test_generated_cases.py index beafa544aaacb7..09b49246d59204 100644 --- a/Lib/test/test_generated_cases.py +++ b/Lib/test/test_generated_cases.py @@ -60,7 +60,7 @@ def test_effect_sizes(self): stack.pop(y) stack.pop(x) for out in outputs: - stack.push(Local.local(out)) + stack.push(Local.undefined(out)) self.assertEqual(stack.base_offset.to_c(), "-1 - oparg - oparg*2") self.assertEqual(stack.top_offset.to_c(), "1 - oparg - oparg*2 + oparg*4") @@ -247,14 +247,13 @@ def test_overlap(self): """ self.run_cases_test(input, output) - def test_predictions_and_eval_breaker(self): + def test_predictions(self): input = """ inst(OP1, (arg -- rest)) { } inst(OP3, (arg -- res)) { DEOPT_IF(xxx); res = Py_None; - CHECK_EVAL_BREAKER(); } family(OP1, INLINE_CACHE_ENTRIES_OP1) = { OP3 }; """ @@ -277,6 +276,45 @@ def test_predictions_and_eval_breaker(self): DEOPT_IF(xxx, OP1); res = Py_None; stack_pointer[-1] = res; + DISPATCH(); + } + """ + self.run_cases_test(input, output) + + def test_eval_breaker(self): + input = """ + inst(A, (arg -- res)) { + CHECK_EVAL_BREAKER(); + res = Py_None; + } + inst(B, (arg -- res)) { + res = Py_None; + CHECK_EVAL_BREAKER(); + } + """ + output = """ + TARGET(A) { + frame->instr_ptr = next_instr; + next_instr += 1; + INSTRUCTION_STATS(A); + _PyStackRef res; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + CHECK_EVAL_BREAKER(); + res = Py_None; + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + DISPATCH(); + } + + TARGET(B) { + frame->instr_ptr = next_instr; + next_instr += 1; + INSTRUCTION_STATS(B); + _PyStackRef res; + res = Py_None; + stack_pointer[-1] = res; CHECK_EVAL_BREAKER(); DISPATCH(); } diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 929ecb8f6193e7..9a2e4846a55b7c 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -1580,12 +1580,10 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - stack_pointer += -3 - (oparg & 1); + stack_pointer[-3 - (oparg & 1)] = result; + stack_pointer += -2 - (oparg & 1); assert(WITHIN_STACK_BOUNDS()); CHECK_EVAL_BREAKER(); - stack_pointer[0] = result; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -1779,12 +1777,10 @@ goto error; } res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer += -3 - oparg; + stack_pointer[-3 - oparg] = res; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); CHECK_EVAL_BREAKER(); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index fea4e45e049303..eb1f010ddb40fb 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -155,6 +155,7 @@ class Uop: stack: StackEffect caches: list[CacheEntry] deferred_refs: dict[lexer.Token, str | None] + output_stores: list[lexer.Token] body: list[lexer.Token] properties: Properties _size: int = -1 @@ -359,18 +360,34 @@ def analyze_caches(inputs: list[parser.InputEffect]) -> list[CacheEntry]: return [CacheEntry(i.name, int(i.size)) for i in caches] +def find_assignment_target(node: parser.InstDef, idx: int) -> list[lexer.Token]: + """Find the tokens that make up the left-hand side of an assignment""" + offset = 0 + for tkn in reversed(node.block.tokens[: idx]): + if tkn.kind == "SEMI" or tkn.kind == "LBRACE" or tkn.kind == "RBRACE": + return node.block.tokens[idx - offset : idx] + offset += 1 + return [] + + +def find_stores_outputs(node: parser.InstDef) -> list[lexer.Token]: + res: list[lexer.Token] = [] + outnames = [ out.name for out in node.outputs ] + for idx, tkn in enumerate(node.block.tokens): + if tkn.kind != "EQUALS": + continue + lhs = find_assignment_target(node, idx) + assert lhs + if len(lhs) != 1 or lhs[0].kind != "IDENTIFIER": + continue + name = lhs[0] + if name.text in outnames: + res.append(name) + return res + def analyze_deferred_refs(node: parser.InstDef) -> dict[lexer.Token, str | None]: """Look for PyStackRef_FromPyObjectNew() calls""" - def find_assignment_target(idx: int) -> list[lexer.Token]: - """Find the tokens that make up the left-hand side of an assignment""" - offset = 1 - for tkn in reversed(node.block.tokens[: idx - 1]): - if tkn.kind == "SEMI" or tkn.kind == "LBRACE" or tkn.kind == "RBRACE": - return node.block.tokens[idx - offset : idx - 1] - offset += 1 - return [] - refs: dict[lexer.Token, str | None] = {} for idx, tkn in enumerate(node.block.tokens): if tkn.kind != "IDENTIFIER" or tkn.text != "PyStackRef_FromPyObjectNew": @@ -379,7 +396,7 @@ def find_assignment_target(idx: int) -> list[lexer.Token]: if idx == 0 or node.block.tokens[idx - 1].kind != "EQUALS": raise analysis_error("Expected '=' before PyStackRef_FromPyObjectNew", tkn) - lhs = find_assignment_target(idx) + lhs = find_assignment_target(node, idx - 1) if len(lhs) == 0: raise analysis_error( "PyStackRef_FromPyObjectNew() must be assigned to an output", tkn @@ -698,6 +715,7 @@ def make_uop( stack=analyze_stack(op), caches=analyze_caches(inputs), deferred_refs=analyze_deferred_refs(op), + output_stores=find_stores_outputs(op), body=op.block.tokens, properties=compute_properties(op), ) @@ -718,6 +736,7 @@ def make_uop( stack=analyze_stack(op, bit), caches=analyze_caches(inputs), deferred_refs=analyze_deferred_refs(op), + output_stores=find_stores_outputs(op), body=op.block.tokens, properties=properties, ) @@ -741,6 +760,7 @@ def make_uop( stack=analyze_stack(op), caches=analyze_caches(inputs), deferred_refs=analyze_deferred_refs(op), + output_stores=find_stores_outputs(op), body=op.block.tokens, properties=properties, ) diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index b7730b8072d42d..16fcffa48651cf 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -11,7 +11,7 @@ from cwriter import CWriter from typing import Callable, Mapping, TextIO, Iterator, Iterable from lexer import Token -from stack import Stack +from stack import Stack, Local class TokenIterator: @@ -89,7 +89,7 @@ def emit_to(out: CWriter, tkn_iter: TokenIterator, end: str) -> Token: ReplacementFunctionType = Callable[ - [Token, TokenIterator, Uop, Stack, Instruction | None], bool + [Token, TokenIterator, Uop, Stack, list[Local], Instruction | None], bool ] def always_true(tkn: Token | None) -> bool: @@ -97,6 +97,27 @@ def always_true(tkn: Token | None) -> bool: return False return tkn.text == "true" or tkn.text == "1" +def push_defined_locals(outputs: list[Local], stack:Stack, tkn: Token) -> None: + while outputs: + out = outputs[0] + if out.defined: + stack.push(out) + outputs.pop(0) + else: + break + undefined = "" + for out in outputs: + if out.defined: + raise analysis_error( + f"Locals not defined in stack order. " + f"Expected '{out.name}' is defined before '{undefined}'", + tkn + ) + else: + undefined = out.name + + + class Emitter: out: CWriter _replacers: dict[str, ReplacementFunctionType] @@ -120,6 +141,7 @@ def deopt_if( tkn_iter: TokenIterator, uop: Uop, unused: Stack, + outputs: list[Local], inst: Instruction | None, ) -> bool: self.out.emit_at("DEOPT_IF", tkn) @@ -144,6 +166,7 @@ def error_if( tkn_iter: TokenIterator, uop: Uop, stack: Stack, + outputs: list[Local], inst: Instruction | None, ) -> bool: self.out.emit_at("if ", tkn) @@ -184,6 +207,7 @@ def error_no_pop( tkn_iter: TokenIterator, uop: Uop, stack: Stack, + outputs: list[Local], inst: Instruction | None, ) -> bool: next(tkn_iter) # LPAREN @@ -198,6 +222,7 @@ def decref_inputs( tkn_iter: TokenIterator, uop: Uop, stack: Stack, + outputs: list[Local], inst: Instruction | None, ) -> bool: next(tkn_iter) @@ -226,6 +251,7 @@ def sync_sp( tkn_iter: TokenIterator, uop: Uop, stack: Stack, + outputs: list[Local], inst: Instruction | None, ) -> bool: next(tkn_iter) @@ -240,11 +266,13 @@ def check_eval_breaker( tkn_iter: TokenIterator, uop: Uop, stack: Stack, + outputs: list[Local], inst: Instruction | None, ) -> bool: next(tkn_iter) next(tkn_iter) next(tkn_iter) + push_defined_locals(outputs, stack, tkn) stack.flush(self.out) self.out.emit_at("CHECK_EVAL_BREAKER();", tkn) return True @@ -255,6 +283,7 @@ def py_stack_ref_from_py_object_new( tkn_iter: TokenIterator, uop: Uop, stack: Stack, + outputs: list[Local], inst: Instruction | None, ) -> bool: self.out.emit(tkn) @@ -277,6 +306,7 @@ def _emit_if( tkn_iter: TokenIterator, uop: Uop, stack: Stack, + outputs: list[Local], inst: Instruction | None, ) -> tuple[bool, Token, Stack]: """ Returns (reachable?, closing '}', stack).""" @@ -286,7 +316,7 @@ def _emit_if( rparen = emit_to(self.out, tkn_iter, "RPAREN") self.emit(rparen) if_stack = stack.copy() - reachable, rbrace, if_stack = self._emit_block(tkn_iter, uop, if_stack, inst, True) + reachable, rbrace, if_stack = self._emit_block(tkn_iter, uop, if_stack, outputs, inst, True) maybe_else = tkn_iter.peek() if maybe_else and maybe_else.kind == "ELSE": self.emit(rbrace) @@ -294,9 +324,9 @@ def _emit_if( maybe_if = tkn_iter.peek() if maybe_if and maybe_if.kind == "IF": self.emit(next(tkn_iter)) - else_reachable, rbrace, stack = self._emit_if(tkn_iter, uop, stack, inst) + else_reachable, rbrace, stack = self._emit_if(tkn_iter, uop, stack, outputs, inst) else: - else_reachable, rbrace, stack = self._emit_block(tkn_iter, uop, stack, inst, True) + else_reachable, rbrace, stack = self._emit_block(tkn_iter, uop, stack, outputs, inst, True) if not reachable: # Discard the if stack reachable = else_reachable @@ -318,11 +348,13 @@ def _emit_block( tkn_iter: TokenIterator, uop: Uop, stack: Stack, + outputs: list[Local], inst: Instruction | None, emit_first_brace: bool ) -> tuple[bool, Token, Stack]: """ Returns (reachable?, closing '}', stack).""" braces = 1 + out_stores = set(uop.output_stores) tkn = next(tkn_iter) reachable = True if tkn.kind != "LBRACE": @@ -341,12 +373,21 @@ def _emit_block( elif tkn.kind == "GOTO": reachable = False; self.out.emit(tkn) - elif tkn.kind == "IDENTIFIER" and tkn.text in self._replacers: - if not self._replacers[tkn.text](tkn, tkn_iter, uop, stack, inst): - reachable = False + elif tkn.kind == "IDENTIFIER": + if tkn.text in self._replacers: + if not self._replacers[tkn.text](tkn, tkn_iter, uop, stack, outputs, inst): + reachable = False + else: + if tkn in out_stores: + for out in outputs: + if out.name == tkn.text: + out.defined = True + out.in_memory = False + break + self.out.emit(tkn) elif tkn.kind == "IF": self.out.emit(tkn) - if_reachable, rbrace, stack = self._emit_if(tkn_iter, uop, stack, inst) + if_reachable, rbrace, stack = self._emit_if(tkn_iter, uop, stack, outputs, inst) if reachable: reachable = if_reachable self.out.emit(rbrace) @@ -359,11 +400,12 @@ def emit_tokens( self, uop: Uop, stack: Stack, + outputs: list[Local], inst: Instruction | None, ) -> None: tkn_iter = TokenIterator(uop.body) self.out.start_line() - self._emit_block(tkn_iter, uop, stack, inst, False) + self._emit_block(tkn_iter, uop, stack, outputs, inst, False) def emit(self, txt: str | Token) -> None: self.out.emit(txt) diff --git a/Tools/cases_generator/optimizer_generator.py b/Tools/cases_generator/optimizer_generator.py index 78074b8d262f03..2916382d829ba7 100644 --- a/Tools/cases_generator/optimizer_generator.py +++ b/Tools/cases_generator/optimizer_generator.py @@ -131,7 +131,7 @@ def write_uop( out.emit(f"{type}{cache.name} = ({cast})this_instr->operand;\n") if override: emitter = OptimizerEmitter(out) - emitter.emit_tokens(override, stack, None) + emitter.emit_tokens(override, stack, [], None) else: emit_default(out, uop) @@ -139,7 +139,7 @@ def write_uop( if var.name in locals: local = locals[var.name] else: - local = Local.local(var) + local = Local.undefined(var) stack.push(local) out.start_line() stack.flush(out, cast_type="_Py_UopsSymbol *", extract_bits=True) diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index 50327d1d1623bc..ee7d55f5483b7e 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -51,9 +51,9 @@ def unused(defn: StackItem) -> "Local": return Local(defn, False, defn.is_array(), False) @staticmethod - def local(defn: StackItem) -> "Local": + def undefined(defn: StackItem) -> "Local": array = defn.is_array() - return Local(defn, not array, array, True) + return Local(defn, not array, array, False) @staticmethod def redefinition(var: StackItem, prev: "Local") -> "Local": diff --git a/Tools/cases_generator/tier1_generator.py b/Tools/cases_generator/tier1_generator.py index 130cf18df8eb05..b94e4aeebe889e 100644 --- a/Tools/cases_generator/tier1_generator.py +++ b/Tools/cases_generator/tier1_generator.py @@ -109,7 +109,7 @@ def write_uop( elif var.name == "unused": local = Local.unused(var) else: - local = Local.local(var) + local = Local.undefined(var) outputs.append(local) for cache in uop.caches: @@ -126,7 +126,7 @@ def write_uop( if inst.family is None: emitter.emit(f"(void){cache.name};\n") offset += cache.size - emitter.emit_tokens(uop, stack, inst) + emitter.emit_tokens(uop, stack, outputs, inst) for output in outputs: if output.name in uop.deferred_refs.values(): # We've already spilled this when emitting tokens diff --git a/Tools/cases_generator/tier2_generator.py b/Tools/cases_generator/tier2_generator.py index cb7f5c38edbcd4..731155ee27d325 100644 --- a/Tools/cases_generator/tier2_generator.py +++ b/Tools/cases_generator/tier2_generator.py @@ -74,6 +74,7 @@ def error_if( tkn_iter: TokenIterator, uop: Uop, stack: Stack, + outputs: list[Local], inst: Instruction | None, ) -> bool: self.out.emit_at("if ", tkn) @@ -96,6 +97,7 @@ def error_no_pop( tkn_iter: TokenIterator, uop: Uop, stack: Stack, + outputs: list[Local], inst: Instruction | None, ) -> bool: next(tkn_iter) # LPAREN @@ -110,6 +112,7 @@ def deopt_if( tkn_iter: TokenIterator, uop: Uop, unused: Stack, + outputs: list[Local], inst: Instruction | None, ) -> bool: self.out.emit_at("if ", tkn) @@ -131,6 +134,7 @@ def exit_if( # type: ignore[override] tkn_iter: TokenIterator, uop: Uop, unused: Stack, + outputs: list[Local], inst: Instruction | None, ) -> bool: self.out.emit_at("if ", tkn) @@ -151,6 +155,7 @@ def oparg( tkn_iter: TokenIterator, uop: Uop, unused: Stack, + outputs: list[Local], inst: Instruction | None, ) -> bool: if not uop.name.endswith("_0") and not uop.name.endswith("_1"): @@ -188,7 +193,7 @@ def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> None: if var.name in locals: local = locals[var.name] else: - local = Local.local(var) + local = Local.undefined(var) outputs.append(local) for cache in uop.caches: if cache.name != "unused": @@ -198,7 +203,7 @@ def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> None: type = f"uint{cache.size*16}_t " cast = f"uint{cache.size*16}_t" emitter.emit(f"{type}{cache.name} = ({cast})CURRENT_OPERAND();\n") - emitter.emit_tokens(uop, stack, None) + emitter.emit_tokens(uop, stack, outputs, None) for output in outputs: if output.name in uop.deferred_refs.values(): # We've already spilled this when emitting tokens From b97dea982a9a117839fa9a5a469509ab3297e5f7 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 9 Aug 2024 16:13:58 +0100 Subject: [PATCH 06/53] Handle stack and output locals togather as Storage class --- Python/optimizer_cases.c.h | 139 +++++++++++-------- Tools/cases_generator/generators_common.py | 63 ++++----- Tools/cases_generator/optimizer_generator.py | 16 +-- Tools/cases_generator/stack.py | 42 +++++- Tools/cases_generator/tier1_generator.py | 20 +-- Tools/cases_generator/tier2_generator.py | 38 +++-- 6 files changed, 178 insertions(+), 140 deletions(-) diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 50aa9728cf2939..1e308d5a60da3e 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -52,7 +52,6 @@ int opcode = _Py_IsImmortal(val) ? _LOAD_CONST_INLINE_BORROW : _LOAD_CONST_INLINE; REPLACE_OP(this_instr, opcode, 0, (uintptr_t)val); value = sym_new_const(ctx, val); - stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; @@ -210,14 +209,20 @@ } sym_set_type(left, &PyLong_Type); sym_set_type(right, &PyLong_Type); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } case _GUARD_NOS_INT: { + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } case _GUARD_TOS_INT: { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -331,14 +336,20 @@ } sym_set_type(left, &PyFloat_Type); sym_set_type(right, &PyFloat_Type); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } case _GUARD_NOS_FLOAT: { + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } case _GUARD_TOS_FLOAT: { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -446,6 +457,8 @@ } sym_set_type(left, &PyUnicode_Type); sym_set_type(left, &PyUnicode_Type); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -540,6 +553,8 @@ } case _BINARY_SUBSCR_CHECK_FUNC: { + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -553,13 +568,13 @@ } case _LIST_APPEND: { - stack_pointer += -1; + stack_pointer += -2 - (oparg-1); assert(WITHIN_STACK_BOUNDS()); break; } case _SET_ADD: { - stack_pointer += -1; + stack_pointer += -2 - (oparg-1); assert(WITHIN_STACK_BOUNDS()); break; } @@ -642,9 +657,7 @@ case _GET_ANEXT: { _Py_UopsSymbol *awaitable; awaitable = sym_new_not_null(ctx); - stack_pointer[0] = awaitable; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = awaitable; break; } @@ -724,8 +737,6 @@ _Py_UopsSymbol *val0; val1 = sym_new_not_null(ctx); val0 = sym_new_not_null(ctx); - stack_pointer[-1] = val1; - stack_pointer[0] = val0; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; @@ -794,7 +805,6 @@ case _LOAD_LOCALS: { _Py_UopsSymbol *locals; locals = sym_new_not_null(ctx); - stack_pointer[0] = locals; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; @@ -921,13 +931,13 @@ } case _LIST_EXTEND: { - stack_pointer += -1; + stack_pointer += -2 - (oparg-1); assert(WITHIN_STACK_BOUNDS()); break; } case _SET_UPDATE: { - stack_pointer += -1; + stack_pointer += -2 - (oparg-1); assert(WITHIN_STACK_BOUNDS()); break; } @@ -955,19 +965,19 @@ } case _DICT_UPDATE: { - stack_pointer += -1; + stack_pointer += -2 - (oparg - 1); assert(WITHIN_STACK_BOUNDS()); break; } case _DICT_MERGE: { - stack_pointer += -1; + stack_pointer += -5 - (oparg - 1); assert(WITHIN_STACK_BOUNDS()); break; } case _MAP_ADD: { - stack_pointer += -2; + stack_pointer += -3 - (oparg - 1); assert(WITHIN_STACK_BOUNDS()); break; } @@ -1035,10 +1045,14 @@ } } } + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _CHECK_MANAGED_OBJECT_HAS_VALUES: { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1077,6 +1091,8 @@ } } } + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1113,6 +1129,8 @@ } case _CHECK_ATTR_WITH_HINT: { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1143,7 +1161,6 @@ null = sym_new_null(ctx); (void)index; (void)owner; - stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); @@ -1151,6 +1168,8 @@ } case _CHECK_ATTR_CLASS: { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1164,7 +1183,6 @@ null = sym_new_null(ctx); (void)descr; (void)owner; - stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); @@ -1181,6 +1199,8 @@ /* _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN is not a viable micro-op for tier 2 */ case _GUARD_DORV_NO_DICT: { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1328,7 +1348,9 @@ case _CHECK_EXC_MATCH: { _Py_UopsSymbol *b; b = sym_new_not_null(ctx); - stack_pointer[-1] = b; + stack_pointer[-2] = b; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1344,9 +1366,7 @@ case _IMPORT_FROM: { _Py_UopsSymbol *res; res = sym_new_not_null(ctx); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; break; } @@ -1364,9 +1384,7 @@ case _GET_LEN: { _Py_UopsSymbol *len; len = sym_new_not_null(ctx); - stack_pointer[0] = len; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = len; break; } @@ -1382,26 +1400,22 @@ case _MATCH_MAPPING: { _Py_UopsSymbol *res; res = sym_new_not_null(ctx); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; break; } case _MATCH_SEQUENCE: { _Py_UopsSymbol *res; res = sym_new_not_null(ctx); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; break; } case _MATCH_KEYS: { _Py_UopsSymbol *values_or_none; values_or_none = sym_new_not_null(ctx); - stack_pointer[0] = values_or_none; - stack_pointer += 1; + stack_pointer[-2] = values_or_none; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1425,59 +1439,63 @@ case _FOR_ITER_TIER_TWO: { _Py_UopsSymbol *next; next = sym_new_not_null(ctx); - stack_pointer[0] = next; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = next; break; } /* _INSTRUMENTED_FOR_ITER is not a viable micro-op for tier 2 */ case _ITER_CHECK_LIST: { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } /* _ITER_JUMP_LIST is not a viable micro-op for tier 2 */ case _GUARD_NOT_EXHAUSTED_LIST: { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _ITER_NEXT_LIST: { _Py_UopsSymbol *next; next = sym_new_not_null(ctx); - stack_pointer[0] = next; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } case _ITER_CHECK_TUPLE: { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } /* _ITER_JUMP_TUPLE is not a viable micro-op for tier 2 */ case _GUARD_NOT_EXHAUSTED_TUPLE: { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _ITER_NEXT_TUPLE: { _Py_UopsSymbol *next; next = sym_new_not_null(ctx); - stack_pointer[0] = next; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } case _ITER_CHECK_RANGE: { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } /* _ITER_JUMP_RANGE is not a viable micro-op for tier 2 */ case _GUARD_NOT_EXHAUSTED_RANGE: { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1487,9 +1505,7 @@ iter = stack_pointer[-1]; next = sym_new_type(ctx, &PyLong_Type); (void)iter; - stack_pointer[0] = next; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = next; break; } @@ -1517,8 +1533,8 @@ case _WITH_EXCEPT_START: { _Py_UopsSymbol *res; res = sym_new_not_null(ctx); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-5] = res; + stack_pointer += -4; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1536,10 +1552,14 @@ } case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT: { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _GUARD_KEYS_VERSION: { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1552,7 +1572,6 @@ (void)descr; attr = sym_new_not_null(ctx); self = owner; - stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1568,7 +1587,6 @@ (void)descr; attr = sym_new_not_null(ctx); self = owner; - stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1578,18 +1596,18 @@ case _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: { _Py_UopsSymbol *attr; attr = sym_new_not_null(ctx); - stack_pointer[-1] = attr; break; } case _LOAD_ATTR_NONDESCRIPTOR_NO_DICT: { _Py_UopsSymbol *attr; attr = sym_new_not_null(ctx); - stack_pointer[-1] = attr; break; } case _CHECK_ATTR_METHOD_LAZY_DICT: { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1602,7 +1620,6 @@ (void)descr; attr = sym_new_not_null(ctx); self = owner; - stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1624,8 +1641,6 @@ (void)args; func = sym_new_not_null(ctx); maybe_self = sym_new_not_null(ctx); - stack_pointer[-2 - oparg] = func; - stack_pointer[-1 - oparg] = maybe_self; break; } @@ -1658,10 +1673,14 @@ } case _CHECK_FUNCTION_VERSION: { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } case _CHECK_METHOD_VERSION: { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1670,12 +1689,12 @@ _Py_UopsSymbol *self; method = sym_new_not_null(ctx); self = sym_new_not_null(ctx); - stack_pointer[-2 - oparg] = method; - stack_pointer[-1 - oparg] = self; break; } case _CHECK_IS_NOT_PY_CALLABLE: { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1695,6 +1714,8 @@ callable = stack_pointer[-2 - oparg]; sym_set_null(null); sym_set_type(callable, &PyMethod_Type); + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1706,8 +1727,6 @@ (void)callable; func = sym_new_not_null(ctx); self = sym_new_not_null(ctx); - stack_pointer[-2 - oparg] = func; - stack_pointer[-1 - oparg] = self; break; } @@ -1727,6 +1746,8 @@ callable = stack_pointer[-2 - oparg]; sym_set_type(callable, &PyFunction_Type); (void)self_or_null; + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -2037,8 +2058,8 @@ bottom = stack_pointer[-1 - (oparg-1)]; assert(oparg > 0); top = bottom; - stack_pointer[0] = top; - stack_pointer += 1; + stack_pointer[-1 - (oparg-1)] = top; + stack_pointer += -(oparg-1); assert(WITHIN_STACK_BOUNDS()); break; } @@ -2194,7 +2215,6 @@ _Py_UopsSymbol *value; PyObject *ptr = (PyObject *)this_instr->operand; value = sym_new_const(ctx, ptr); - stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; @@ -2223,7 +2243,6 @@ PyObject *ptr = (PyObject *)this_instr->operand; value = sym_new_const(ctx, ptr); null = sym_new_null(ctx); - stack_pointer[0] = value; stack_pointer[1] = null; stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 16fcffa48651cf..f02763ab81457e 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -11,7 +11,7 @@ from cwriter import CWriter from typing import Callable, Mapping, TextIO, Iterator, Iterable from lexer import Token -from stack import Stack, Local +from stack import Stack, Local, Storage class TokenIterator: @@ -89,7 +89,7 @@ def emit_to(out: CWriter, tkn_iter: TokenIterator, end: str) -> Token: ReplacementFunctionType = Callable[ - [Token, TokenIterator, Uop, Stack, list[Local], Instruction | None], bool + [Token, TokenIterator, Uop, Storage, Instruction | None], bool ] def always_true(tkn: Token | None) -> bool: @@ -117,7 +117,6 @@ def push_defined_locals(outputs: list[Local], stack:Stack, tkn: Token) -> None: undefined = out.name - class Emitter: out: CWriter _replacers: dict[str, ReplacementFunctionType] @@ -140,8 +139,7 @@ def deopt_if( tkn: Token, tkn_iter: TokenIterator, uop: Uop, - unused: Stack, - outputs: list[Local], + storage: Storage, inst: Instruction | None, ) -> bool: self.out.emit_at("DEOPT_IF", tkn) @@ -165,8 +163,7 @@ def error_if( tkn: Token, tkn_iter: TokenIterator, uop: Uop, - stack: Stack, - outputs: list[Local], + storage: Storage, inst: Instruction | None, ) -> bool: self.out.emit_at("if ", tkn) @@ -179,7 +176,7 @@ def error_if( next(tkn_iter) # RPAREN next(tkn_iter) # Semi colon self.out.emit(") ") - c_offset = stack.peek_offset() + c_offset = storage.stack.peek_offset() try: offset = -int(c_offset) except ValueError: @@ -194,7 +191,7 @@ def error_if( self.out.emit(";\n") else: self.out.emit("{\n") - stack.copy().flush(self.out) + storage.stack.copy().flush(self.out) self.out.emit("goto ") self.out.emit(label) self.out.emit(";\n") @@ -206,8 +203,7 @@ def error_no_pop( tkn: Token, tkn_iter: TokenIterator, uop: Uop, - stack: Stack, - outputs: list[Local], + storage: Storage, inst: Instruction | None, ) -> bool: next(tkn_iter) # LPAREN @@ -221,8 +217,7 @@ def decref_inputs( tkn: Token, tkn_iter: TokenIterator, uop: Uop, - stack: Stack, - outputs: list[Local], + storage: Storage, inst: Instruction | None, ) -> bool: next(tkn_iter) @@ -250,14 +245,13 @@ def sync_sp( tkn: Token, tkn_iter: TokenIterator, uop: Uop, - stack: Stack, - outputs: list[Local], + storage: Storage, inst: Instruction | None, ) -> bool: next(tkn_iter) next(tkn_iter) next(tkn_iter) - stack.flush(self.out) + storage.stack.flush(self.out) return True def check_eval_breaker( @@ -265,15 +259,13 @@ def check_eval_breaker( tkn: Token, tkn_iter: TokenIterator, uop: Uop, - stack: Stack, - outputs: list[Local], + storage: Storage, inst: Instruction | None, ) -> bool: next(tkn_iter) next(tkn_iter) next(tkn_iter) - push_defined_locals(outputs, stack, tkn) - stack.flush(self.out) + storage.flush(self.out) self.out.emit_at("CHECK_EVAL_BREAKER();", tkn) return True @@ -282,8 +274,7 @@ def py_stack_ref_from_py_object_new( tkn: Token, tkn_iter: TokenIterator, uop: Uop, - stack: Stack, - outputs: list[Local], + storage: Storage, inst: Instruction | None, ) -> bool: self.out.emit(tkn) @@ -298,15 +289,14 @@ def py_stack_ref_from_py_object_new( # Flush the assignment to the stack. Note that we don't flush the # stack pointer here, and instead are currently relying on initializing # unused portions of the stack to NULL. - stack.flush_single_var(self.out, target, uop.stack.outputs) + storage.stack.flush_single_var(self.out, target, uop.stack.outputs) return True def _emit_if( self, tkn_iter: TokenIterator, uop: Uop, - stack: Stack, - outputs: list[Local], + storage: Storage, inst: Instruction | None, ) -> tuple[bool, Token, Stack]: """ Returns (reachable?, closing '}', stack).""" @@ -315,8 +305,10 @@ def _emit_if( self.out.emit(tkn) rparen = emit_to(self.out, tkn_iter, "RPAREN") self.emit(rparen) + stack = storage.stack if_stack = stack.copy() - reachable, rbrace, if_stack = self._emit_block(tkn_iter, uop, if_stack, outputs, inst, True) + if_storage = Storage(if_stack, storage.outputs) + reachable, rbrace, if_stack = self._emit_block(tkn_iter, uop, if_storage, inst, True) maybe_else = tkn_iter.peek() if maybe_else and maybe_else.kind == "ELSE": self.emit(rbrace) @@ -324,9 +316,9 @@ def _emit_if( maybe_if = tkn_iter.peek() if maybe_if and maybe_if.kind == "IF": self.emit(next(tkn_iter)) - else_reachable, rbrace, stack = self._emit_if(tkn_iter, uop, stack, outputs, inst) + else_reachable, rbrace, stack = self._emit_if(tkn_iter, uop, storage, inst) else: - else_reachable, rbrace, stack = self._emit_block(tkn_iter, uop, stack, outputs, inst, True) + else_reachable, rbrace, stack = self._emit_block(tkn_iter, uop, storage, inst, True) if not reachable: # Discard the if stack reachable = else_reachable @@ -347,8 +339,7 @@ def _emit_block( self, tkn_iter: TokenIterator, uop: Uop, - stack: Stack, - outputs: list[Local], + storage: Storage, inst: Instruction | None, emit_first_brace: bool ) -> tuple[bool, Token, Stack]: @@ -356,6 +347,7 @@ def _emit_block( braces = 1 out_stores = set(uop.output_stores) tkn = next(tkn_iter) + stack = storage.stack reachable = True if tkn.kind != "LBRACE": raise analysis_error(f"Expected '{{' found {tkn.text}", tkn) @@ -375,11 +367,11 @@ def _emit_block( self.out.emit(tkn) elif tkn.kind == "IDENTIFIER": if tkn.text in self._replacers: - if not self._replacers[tkn.text](tkn, tkn_iter, uop, stack, outputs, inst): + if not self._replacers[tkn.text](tkn, tkn_iter, uop, storage, inst): reachable = False else: if tkn in out_stores: - for out in outputs: + for out in storage.outputs: if out.name == tkn.text: out.defined = True out.in_memory = False @@ -387,7 +379,7 @@ def _emit_block( self.out.emit(tkn) elif tkn.kind == "IF": self.out.emit(tkn) - if_reachable, rbrace, stack = self._emit_if(tkn_iter, uop, stack, outputs, inst) + if_reachable, rbrace, stack = self._emit_if(tkn_iter, uop, storage, inst) if reachable: reachable = if_reachable self.out.emit(rbrace) @@ -399,13 +391,12 @@ def _emit_block( def emit_tokens( self, uop: Uop, - stack: Stack, - outputs: list[Local], + storage: Storage, inst: Instruction | None, ) -> None: tkn_iter = TokenIterator(uop.body) self.out.start_line() - self._emit_block(tkn_iter, uop, stack, outputs, inst, False) + self._emit_block(tkn_iter, uop, storage, inst, False) def emit(self, txt: str | Token) -> None: self.out.emit(txt) diff --git a/Tools/cases_generator/optimizer_generator.py b/Tools/cases_generator/optimizer_generator.py index 2916382d829ba7..a1378424248f2f 100644 --- a/Tools/cases_generator/optimizer_generator.py +++ b/Tools/cases_generator/optimizer_generator.py @@ -23,7 +23,7 @@ from cwriter import CWriter from typing import TextIO, Iterator from lexer import Token -from stack import Local, Stack, StackError +from stack import Local, Stack, StackError, Storage DEFAULT_OUTPUT = ROOT / "Python/optimizer_cases.c.h" DEFAULT_ABSTRACT_INPUT = (ROOT / "Python/optimizer_bytecodes.c").absolute().as_posix() @@ -114,6 +114,7 @@ def write_uop( if local.defined: locals[local.name] = local out.emit(stack.define_output_arrays(prototype.stack.outputs)) + storage = Storage.for_uop(stack, prototype, locals) if debug: args = [] for var in prototype.stack.inputs: @@ -131,16 +132,15 @@ def write_uop( out.emit(f"{type}{cache.name} = ({cast})this_instr->operand;\n") if override: emitter = OptimizerEmitter(out) - emitter.emit_tokens(override, stack, [], None) + emitter.emit_tokens(override, storage, None) else: emit_default(out, uop) - for var in prototype.stack.outputs: - if var.name in locals: - local = locals[var.name] - else: - local = Local.undefined(var) - stack.push(local) + for output in storage.outputs: + if output.name in uop.deferred_refs.values(): + # We've already spilled this when emitting tokens + output.cached = False + stack.push(output) out.start_line() stack.flush(out, cast_type="_Py_UopsSymbol *", extract_bits=True) except StackError as ex: diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index ee7d55f5483b7e..227a320bbab3d3 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -407,4 +407,44 @@ def stacks(inst: Instruction | PseudoInstruction) -> Iterator[StackEffect]: stack.push(local) return stack -UNREACHABLE = Stack() +@dataclass +class Storage: + + stack: Stack + outputs: list[Local] + + def _push_defined_locals(self) -> None: + while self.outputs: + out = self.outputs[0] + if out.defined: + self.stack.push(out) + self.outputs.pop(0) + else: + break + undefined = "" + for out in self.outputs: + if out.defined: + raise StackError( + f"Locals not defined in stack order. " + f"Expected '{out.name}' is defined before '{undefined}'" + ) + else: + undefined = out.name + + def flush(self, out: CWriter) -> None: + self._push_defined_locals() + self.stack.flush(out) + + @staticmethod + def for_uop(stack: Stack, uop: Uop, locals: dict[str, Local]) -> "Storage": + outputs: list[Local] = [] + for var in uop.stack.outputs: + if not var.peek: + if var.name in locals: + local = locals[var.name] + elif var.name == "unused": + local = Local.unused(var) + else: + local = Local.undefined(var) + outputs.append(local) + return Storage(stack, outputs) diff --git a/Tools/cases_generator/tier1_generator.py b/Tools/cases_generator/tier1_generator.py index b94e4aeebe889e..41a9373c64d749 100644 --- a/Tools/cases_generator/tier1_generator.py +++ b/Tools/cases_generator/tier1_generator.py @@ -26,7 +26,7 @@ ) from cwriter import CWriter from typing import TextIO -from stack import Local, Stack, StackError, get_stack_effect +from stack import Local, Stack, StackError, get_stack_effect, Storage DEFAULT_OUTPUT = ROOT / "Python/generated_cases.c.h" @@ -100,17 +100,8 @@ def write_uop( stack.push(peeks.pop()) if braces: emitter.emit("{\n") - emitter.out.emit(stack.define_output_arrays(uop.stack.outputs)) - outputs: list[Local] = [] - for var in uop.stack.outputs: - if not var.peek: - if var.name in locals: - local = locals[var.name] - elif var.name == "unused": - local = Local.unused(var) - else: - local = Local.undefined(var) - outputs.append(local) + emitter.emit(stack.define_output_arrays(uop.stack.outputs)) + storage = Storage.for_uop(stack, uop, locals) for cache in uop.caches: if cache.name != "unused": @@ -126,8 +117,9 @@ def write_uop( if inst.family is None: emitter.emit(f"(void){cache.name};\n") offset += cache.size - emitter.emit_tokens(uop, stack, outputs, inst) - for output in outputs: + + emitter.emit_tokens(uop, storage, inst) + for output in storage.outputs: if output.name in uop.deferred_refs.values(): # We've already spilled this when emitting tokens output.cached = False diff --git a/Tools/cases_generator/tier2_generator.py b/Tools/cases_generator/tier2_generator.py index 731155ee27d325..1f2df958bf32c9 100644 --- a/Tools/cases_generator/tier2_generator.py +++ b/Tools/cases_generator/tier2_generator.py @@ -26,7 +26,7 @@ from cwriter import CWriter from typing import TextIO, Iterator from lexer import Token -from stack import Local, Stack, StackError, get_stack_effect +from stack import Local, Stack, StackError, Storage DEFAULT_OUTPUT = ROOT / "Python/executor_cases.c.h" @@ -54,7 +54,7 @@ def declare_variables(uop: Uop, out: CWriter) -> None: for var in reversed(uop.stack.inputs): stack.pop(var) for var in uop.stack.outputs: - stack.push(Local.unused(var)) + stack.push(Local.undefined(var)) required = set(stack.defined) required.discard("unused") for var in reversed(uop.stack.inputs): @@ -73,8 +73,7 @@ def error_if( tkn: Token, tkn_iter: TokenIterator, uop: Uop, - stack: Stack, - outputs: list[Local], + storage: Storage, inst: Instruction | None, ) -> bool: self.out.emit_at("if ", tkn) @@ -96,8 +95,7 @@ def error_no_pop( tkn: Token, tkn_iter: TokenIterator, uop: Uop, - stack: Stack, - outputs: list[Local], + storage: Storage, inst: Instruction | None, ) -> bool: next(tkn_iter) # LPAREN @@ -111,8 +109,7 @@ def deopt_if( tkn: Token, tkn_iter: TokenIterator, uop: Uop, - unused: Stack, - outputs: list[Local], + storage: Storage, inst: Instruction | None, ) -> bool: self.out.emit_at("if ", tkn) @@ -133,8 +130,7 @@ def exit_if( # type: ignore[override] tkn: Token, tkn_iter: TokenIterator, uop: Uop, - unused: Stack, - outputs: list[Local], + storage: Storage, inst: Instruction | None, ) -> bool: self.out.emit_at("if ", tkn) @@ -154,8 +150,7 @@ def oparg( tkn: Token, tkn_iter: TokenIterator, uop: Uop, - unused: Stack, - outputs: list[Local], + storage: Storage, inst: Instruction | None, ) -> bool: if not uop.name.endswith("_0") and not uop.name.endswith("_1"): @@ -182,19 +177,20 @@ def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> None: elif uop.properties.const_oparg >= 0: emitter.emit(f"oparg = {uop.properties.const_oparg};\n") emitter.emit(f"assert(oparg == CURRENT_OPARG());\n") + peeks: list[Local] = [] for var in reversed(uop.stack.inputs): code, local = stack.pop(var) emitter.emit(code) + if var.peek: + peeks.append(local) if local.defined: locals[local.name] = local + # Push back the peeks, so that they remain on the logical + # stack, but their values are cached. + while peeks: + stack.push(peeks.pop()) emitter.emit(stack.define_output_arrays(uop.stack.outputs)) - outputs: list[Local] = [] - for var in uop.stack.outputs: - if var.name in locals: - local = locals[var.name] - else: - local = Local.undefined(var) - outputs.append(local) + storage = Storage.for_uop(stack, uop, locals) for cache in uop.caches: if cache.name != "unused": if cache.size == 4: @@ -203,8 +199,8 @@ def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> None: type = f"uint{cache.size*16}_t " cast = f"uint{cache.size*16}_t" emitter.emit(f"{type}{cache.name} = ({cast})CURRENT_OPERAND();\n") - emitter.emit_tokens(uop, stack, outputs, None) - for output in outputs: + emitter.emit_tokens(uop, storage, None) + for output in storage.outputs: if output.name in uop.deferred_refs.values(): # We've already spilled this when emitting tokens output.cached = False From 9838a05a681f1ce8700e5444a0dda93a8cc4acbf Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 9 Aug 2024 17:53:19 +0100 Subject: [PATCH 07/53] Track locals as well as stack on differing paths --- Python/bytecodes.c | 2 ++ Python/executor_cases.c.h | 2 ++ Python/generated_cases.c.h | 2 ++ Python/optimizer_bytecodes.c | 25 ++++++++++---- Python/optimizer_cases.c.h | 25 ++++++++++---- Tools/cases_generator/analyzer.py | 6 ++++ Tools/cases_generator/generators_common.py | 35 ++++++++++++-------- Tools/cases_generator/optimizer_generator.py | 6 ++-- Tools/cases_generator/stack.py | 14 ++++++++ 9 files changed, 87 insertions(+), 30 deletions(-) diff --git a/Python/bytecodes.c b/Python/bytecodes.c index fbaa894a30ac51..c0aadb6bac1962 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -1991,6 +1991,8 @@ dummy_func( attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); DECREF_INPUTS(); ERROR_IF(attr_o == NULL, error); + /* We need to define self_or_null on all paths */ + self_or_null = PyStackRef_NULL; } attr = PyStackRef_FromPyObjectSteal(attr_o); } diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 893f86684ddd12..1914efd9c7eadb 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -2221,6 +2221,8 @@ attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); PyStackRef_CLOSE(owner); if (attr_o == NULL) JUMP_TO_ERROR(); + /* We need to define self_or_null on all paths */ + self_or_null = PyStackRef_NULL; } attr = PyStackRef_FromPyObjectSteal(attr_o); stack_pointer[-1] = attr; diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 9a2e4846a55b7c..ca7c7b1f563a47 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -4428,6 +4428,8 @@ attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); PyStackRef_CLOSE(owner); if (attr_o == NULL) goto pop_1_error; + /* We need to define self_or_null on all paths */ + self_or_null = PyStackRef_NULL; } attr = PyStackRef_FromPyObjectSteal(attr_o); } diff --git a/Python/optimizer_bytecodes.c b/Python/optimizer_bytecodes.c index c982e37182157a..ef58c0d868cb45 100644 --- a/Python/optimizer_bytecodes.c +++ b/Python/optimizer_bytecodes.c @@ -182,7 +182,9 @@ dummy_func(void) { res = sym_new_type(ctx, &PyFloat_Type); } } - res = sym_new_unknown(ctx); + else { + res = sym_new_unknown(ctx); + } } op(_BINARY_OP_ADD_INT, (left, right -- res)) { @@ -330,41 +332,47 @@ dummy_func(void) { } op(_TO_BOOL, (value -- res)) { - if (!optimize_to_bool(this_instr, ctx, value, &res)) { + int opt = optimize_to_bool(this_instr, ctx, value, &res); + if (!opt) { res = sym_new_type(ctx, &PyBool_Type); } } op(_TO_BOOL_BOOL, (value -- res)) { - if (!optimize_to_bool(this_instr, ctx, value, &res)) { + int opt = optimize_to_bool(this_instr, ctx, value, &res); + if (!opt) { sym_set_type(value, &PyBool_Type); res = value; } } op(_TO_BOOL_INT, (value -- res)) { - if (!optimize_to_bool(this_instr, ctx, value, &res)) { + int opt = optimize_to_bool(this_instr, ctx, value, &res); + if (!opt) { sym_set_type(value, &PyLong_Type); res = sym_new_type(ctx, &PyBool_Type); } } op(_TO_BOOL_LIST, (value -- res)) { - if (!optimize_to_bool(this_instr, ctx, value, &res)) { + int opt = optimize_to_bool(this_instr, ctx, value, &res); + if (!opt) { sym_set_type(value, &PyList_Type); res = sym_new_type(ctx, &PyBool_Type); } } op(_TO_BOOL_NONE, (value -- res)) { - if (!optimize_to_bool(this_instr, ctx, value, &res)) { + int opt = optimize_to_bool(this_instr, ctx, value, &res); + if (!opt) { sym_set_const(value, Py_None); res = sym_new_const(ctx, Py_False); } } op(_TO_BOOL_STR, (value -- res)) { - if (!optimize_to_bool(this_instr, ctx, value, &res)) { + int opt = optimize_to_bool(this_instr, ctx, value, &res); + if (!opt) { res = sym_new_type(ctx, &PyBool_Type); sym_set_type(value, &PyUnicode_Type); } @@ -475,6 +483,9 @@ dummy_func(void) { if (oparg & 1) { self_or_null = sym_new_unknown(ctx); } + else { + self_or_null = NULL; + } } op(_LOAD_ATTR_MODULE, (index/1, owner -- attr, null if (oparg & 1))) { diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 1e308d5a60da3e..2a85ca56d89157 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -108,7 +108,8 @@ _Py_UopsSymbol *value; _Py_UopsSymbol *res; value = stack_pointer[-1]; - if (!optimize_to_bool(this_instr, ctx, value, &res)) { + int opt = optimize_to_bool(this_instr, ctx, value, &res); + if (!opt) { res = sym_new_type(ctx, &PyBool_Type); } stack_pointer[-1] = res; @@ -119,7 +120,8 @@ _Py_UopsSymbol *value; _Py_UopsSymbol *res; value = stack_pointer[-1]; - if (!optimize_to_bool(this_instr, ctx, value, &res)) { + int opt = optimize_to_bool(this_instr, ctx, value, &res); + if (!opt) { sym_set_type(value, &PyBool_Type); res = value; } @@ -131,7 +133,8 @@ _Py_UopsSymbol *value; _Py_UopsSymbol *res; value = stack_pointer[-1]; - if (!optimize_to_bool(this_instr, ctx, value, &res)) { + int opt = optimize_to_bool(this_instr, ctx, value, &res); + if (!opt) { sym_set_type(value, &PyLong_Type); res = sym_new_type(ctx, &PyBool_Type); } @@ -143,7 +146,8 @@ _Py_UopsSymbol *value; _Py_UopsSymbol *res; value = stack_pointer[-1]; - if (!optimize_to_bool(this_instr, ctx, value, &res)) { + int opt = optimize_to_bool(this_instr, ctx, value, &res); + if (!opt) { sym_set_type(value, &PyList_Type); res = sym_new_type(ctx, &PyBool_Type); } @@ -155,7 +159,8 @@ _Py_UopsSymbol *value; _Py_UopsSymbol *res; value = stack_pointer[-1]; - if (!optimize_to_bool(this_instr, ctx, value, &res)) { + int opt = optimize_to_bool(this_instr, ctx, value, &res); + if (!opt) { sym_set_const(value, Py_None); res = sym_new_const(ctx, Py_False); } @@ -167,7 +172,8 @@ _Py_UopsSymbol *value; _Py_UopsSymbol *res; value = stack_pointer[-1]; - if (!optimize_to_bool(this_instr, ctx, value, &res)) { + int opt = optimize_to_bool(this_instr, ctx, value, &res); + if (!opt) { res = sym_new_type(ctx, &PyBool_Type); sym_set_type(value, &PyUnicode_Type); } @@ -1015,6 +1021,9 @@ if (oparg & 1) { self_or_null = sym_new_unknown(ctx); } + else { + self_or_null = NULL; + } stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = self_or_null; stack_pointer += (oparg & 1); @@ -2085,7 +2094,9 @@ res = sym_new_type(ctx, &PyFloat_Type); } } - res = sym_new_unknown(ctx); + else { + res = sym_new_unknown(ctx); + } stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index eb1f010ddb40fb..bce7a47b83f6e6 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -374,10 +374,16 @@ def find_stores_outputs(node: parser.InstDef) -> list[lexer.Token]: res: list[lexer.Token] = [] outnames = [ out.name for out in node.outputs ] for idx, tkn in enumerate(node.block.tokens): + if tkn.kind == "AND": + name = node.block.tokens[idx+1] + if name.text in outnames: + res.append(name) if tkn.kind != "EQUALS": continue lhs = find_assignment_target(node, idx) assert lhs + while lhs and lhs[0].kind == "COMMENT": + lhs = lhs[1:] if len(lhs) != 1 or lhs[0].kind != "IDENTIFIER": continue name = lhs[0] diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index f02763ab81457e..67d2097f759010 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -131,9 +131,21 @@ def __init__(self, out: CWriter): "CHECK_EVAL_BREAKER": self.check_eval_breaker, "SYNC_SP": self.sync_sp, "PyStackRef_FromPyObjectNew": self.py_stack_ref_from_py_object_new, + "DISPATCH": self.dispatch } self.out = out + def dispatch( + self, + tkn: Token, + tkn_iter: TokenIterator, + uop: Uop, + storage: Storage, + inst: Instruction | None, + ) -> bool: + self.emit(tkn) + return False + def deopt_if( self, tkn: Token, @@ -298,16 +310,14 @@ def _emit_if( uop: Uop, storage: Storage, inst: Instruction | None, - ) -> tuple[bool, Token, Stack]: + ) -> tuple[bool, Token, Storage]: """ Returns (reachable?, closing '}', stack).""" tkn = next(tkn_iter) assert (tkn.kind == "LPAREN") self.out.emit(tkn) rparen = emit_to(self.out, tkn_iter, "RPAREN") self.emit(rparen) - stack = storage.stack - if_stack = stack.copy() - if_storage = Storage(if_stack, storage.outputs) + if_storage = storage.copy() reachable, rbrace, if_stack = self._emit_block(tkn_iter, uop, if_storage, inst, True) maybe_else = tkn_iter.peek() if maybe_else and maybe_else.kind == "ELSE": @@ -320,20 +330,20 @@ def _emit_if( else: else_reachable, rbrace, stack = self._emit_block(tkn_iter, uop, storage, inst, True) if not reachable: - # Discard the if stack + # Discard the if storage reachable = else_reachable elif not else_reachable: - # Discard the else stack - stack = if_stack + # Discard the else storage + storage = if_storage else: - stack = stack.merge(if_stack) + storage = storage.merge(if_storage, self.out) else: if reachable: - stack = stack.merge(if_stack) + storage = storage.merge(if_storage, self.out) else: # Discard the if stack reachable = True - return reachable, rbrace, stack + return reachable, rbrace, storage def _emit_block( self, @@ -342,12 +352,11 @@ def _emit_block( storage: Storage, inst: Instruction | None, emit_first_brace: bool - ) -> tuple[bool, Token, Stack]: + ) -> tuple[bool, Token, Storage]: """ Returns (reachable?, closing '}', stack).""" braces = 1 out_stores = set(uop.output_stores) tkn = next(tkn_iter) - stack = storage.stack reachable = True if tkn.kind != "LBRACE": raise analysis_error(f"Expected '{{' found {tkn.text}", tkn) @@ -360,7 +369,7 @@ def _emit_block( elif tkn.kind == "RBRACE": braces -= 1 if braces == 0: - return reachable, tkn, stack + return reachable, tkn, storage self.out.emit(tkn) elif tkn.kind == "GOTO": reachable = False; diff --git a/Tools/cases_generator/optimizer_generator.py b/Tools/cases_generator/optimizer_generator.py index a1378424248f2f..9388eb3bef65ec 100644 --- a/Tools/cases_generator/optimizer_generator.py +++ b/Tools/cases_generator/optimizer_generator.py @@ -103,9 +103,9 @@ def write_uop( skip_inputs: bool, ) -> None: locals: dict[str, Local] = {} + prototype = override if override else uop + is_override = override is not None try: - prototype = override if override else uop - is_override = override is not None out.start_line() for var in reversed(prototype.stack.inputs): code, local = stack.pop(var, extract_bits=True) @@ -144,7 +144,7 @@ def write_uop( out.start_line() stack.flush(out, cast_type="_Py_UopsSymbol *", extract_bits=True) except StackError as ex: - raise analysis_error(ex.args[0], uop.body[0]) + raise analysis_error(ex.args[0], prototype.body[0]) SKIPS = ("_EXTENDED_ARG",) diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index 227a320bbab3d3..eac6804b52c466 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -448,3 +448,17 @@ def for_uop(stack: Stack, uop: Uop, locals: dict[str, Local]) -> "Storage": local = Local.undefined(var) outputs.append(local) return Storage(stack, outputs) + + def copy(self) -> "Storage": + return Storage(self.stack.copy(), [ l.copy() for l in self.outputs]) + + def merge(self, other: "Storage", out: CWriter) -> "Storage": + self.stack.merge(other.stack) + if self.outputs != other.outputs: + raise StackError("unequal locals") + return self + + def as_comment(self) -> str: + stack_comment = self.stack.as_comment() + return stack_comment[:-2] + str(self.outputs) + " */" + From 1f829be66afd7575533f92137bc909b9d8aa43d9 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Tue, 27 Aug 2024 11:57:26 +0100 Subject: [PATCH 08/53] Use 'PEP 7' in syntax error, to make it clear that this is not a C syntax error, just a tool limitation. --- Tools/cases_generator/generators_common.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 67d2097f759010..224359d129c4b7 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -359,7 +359,7 @@ def _emit_block( tkn = next(tkn_iter) reachable = True if tkn.kind != "LBRACE": - raise analysis_error(f"Expected '{{' found {tkn.text}", tkn) + raise analysis_error(f"PEP 7: expected '{{' found {tkn.text}", tkn) if emit_first_brace: self.emit(tkn) for tkn in tkn_iter: From d2e5f129ab67e88f76e43ca642fcf0ad1ca070e5 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Tue, 27 Aug 2024 13:47:13 +0100 Subject: [PATCH 09/53] Push peeks back to stack in optimizer code gen --- Python/optimizer_cases.c.h | 139 ++++++++----------- Tools/cases_generator/optimizer_generator.py | 13 +- 2 files changed, 68 insertions(+), 84 deletions(-) diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 2a85ca56d89157..07c3b44bbe9acd 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -52,6 +52,7 @@ int opcode = _Py_IsImmortal(val) ? _LOAD_CONST_INLINE_BORROW : _LOAD_CONST_INLINE; REPLACE_OP(this_instr, opcode, 0, (uintptr_t)val); value = sym_new_const(ctx, val); + stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; @@ -215,20 +216,14 @@ } sym_set_type(left, &PyLong_Type); sym_set_type(right, &PyLong_Type); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } case _GUARD_NOS_INT: { - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } case _GUARD_TOS_INT: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -342,20 +337,14 @@ } sym_set_type(left, &PyFloat_Type); sym_set_type(right, &PyFloat_Type); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } case _GUARD_NOS_FLOAT: { - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } case _GUARD_TOS_FLOAT: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -463,8 +452,6 @@ } sym_set_type(left, &PyUnicode_Type); sym_set_type(left, &PyUnicode_Type); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -559,8 +546,6 @@ } case _BINARY_SUBSCR_CHECK_FUNC: { - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -574,13 +559,13 @@ } case _LIST_APPEND: { - stack_pointer += -2 - (oparg-1); + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } case _SET_ADD: { - stack_pointer += -2 - (oparg-1); + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -663,7 +648,9 @@ case _GET_ANEXT: { _Py_UopsSymbol *awaitable; awaitable = sym_new_not_null(ctx); - stack_pointer[-1] = awaitable; + stack_pointer[0] = awaitable; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -743,6 +730,8 @@ _Py_UopsSymbol *val0; val1 = sym_new_not_null(ctx); val0 = sym_new_not_null(ctx); + stack_pointer[-1] = val1; + stack_pointer[0] = val0; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; @@ -811,6 +800,7 @@ case _LOAD_LOCALS: { _Py_UopsSymbol *locals; locals = sym_new_not_null(ctx); + stack_pointer[0] = locals; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; @@ -937,13 +927,13 @@ } case _LIST_EXTEND: { - stack_pointer += -2 - (oparg-1); + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } case _SET_UPDATE: { - stack_pointer += -2 - (oparg-1); + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -971,19 +961,19 @@ } case _DICT_UPDATE: { - stack_pointer += -2 - (oparg - 1); + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } case _DICT_MERGE: { - stack_pointer += -5 - (oparg - 1); + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } case _MAP_ADD: { - stack_pointer += -3 - (oparg - 1); + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1054,14 +1044,10 @@ } } } - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } case _CHECK_MANAGED_OBJECT_HAS_VALUES: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1100,8 +1086,6 @@ } } } - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1138,8 +1122,6 @@ } case _CHECK_ATTR_WITH_HINT: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1170,6 +1152,7 @@ null = sym_new_null(ctx); (void)index; (void)owner; + stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); @@ -1177,8 +1160,6 @@ } case _CHECK_ATTR_CLASS: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1192,6 +1173,7 @@ null = sym_new_null(ctx); (void)descr; (void)owner; + stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); @@ -1208,8 +1190,6 @@ /* _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN is not a viable micro-op for tier 2 */ case _GUARD_DORV_NO_DICT: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1357,9 +1337,7 @@ case _CHECK_EXC_MATCH: { _Py_UopsSymbol *b; b = sym_new_not_null(ctx); - stack_pointer[-2] = b; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = b; break; } @@ -1375,7 +1353,9 @@ case _IMPORT_FROM: { _Py_UopsSymbol *res; res = sym_new_not_null(ctx); - stack_pointer[-1] = res; + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1393,7 +1373,9 @@ case _GET_LEN: { _Py_UopsSymbol *len; len = sym_new_not_null(ctx); - stack_pointer[-1] = len; + stack_pointer[0] = len; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1409,22 +1391,26 @@ case _MATCH_MAPPING: { _Py_UopsSymbol *res; res = sym_new_not_null(ctx); - stack_pointer[-1] = res; + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _MATCH_SEQUENCE: { _Py_UopsSymbol *res; res = sym_new_not_null(ctx); - stack_pointer[-1] = res; + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _MATCH_KEYS: { _Py_UopsSymbol *values_or_none; values_or_none = sym_new_not_null(ctx); - stack_pointer[-2] = values_or_none; - stack_pointer += -1; + stack_pointer[0] = values_or_none; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1448,63 +1434,59 @@ case _FOR_ITER_TIER_TWO: { _Py_UopsSymbol *next; next = sym_new_not_null(ctx); - stack_pointer[-1] = next; + stack_pointer[0] = next; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } /* _INSTRUMENTED_FOR_ITER is not a viable micro-op for tier 2 */ case _ITER_CHECK_LIST: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } /* _ITER_JUMP_LIST is not a viable micro-op for tier 2 */ case _GUARD_NOT_EXHAUSTED_LIST: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } case _ITER_NEXT_LIST: { _Py_UopsSymbol *next; next = sym_new_not_null(ctx); + stack_pointer[0] = next; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _ITER_CHECK_TUPLE: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } /* _ITER_JUMP_TUPLE is not a viable micro-op for tier 2 */ case _GUARD_NOT_EXHAUSTED_TUPLE: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } case _ITER_NEXT_TUPLE: { _Py_UopsSymbol *next; next = sym_new_not_null(ctx); + stack_pointer[0] = next; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _ITER_CHECK_RANGE: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } /* _ITER_JUMP_RANGE is not a viable micro-op for tier 2 */ case _GUARD_NOT_EXHAUSTED_RANGE: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1514,7 +1496,9 @@ iter = stack_pointer[-1]; next = sym_new_type(ctx, &PyLong_Type); (void)iter; - stack_pointer[-1] = next; + stack_pointer[0] = next; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1542,8 +1526,8 @@ case _WITH_EXCEPT_START: { _Py_UopsSymbol *res; res = sym_new_not_null(ctx); - stack_pointer[-5] = res; - stack_pointer += -4; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1561,14 +1545,10 @@ } case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } case _GUARD_KEYS_VERSION: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1581,6 +1561,7 @@ (void)descr; attr = sym_new_not_null(ctx); self = owner; + stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1596,6 +1577,7 @@ (void)descr; attr = sym_new_not_null(ctx); self = owner; + stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1605,18 +1587,18 @@ case _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: { _Py_UopsSymbol *attr; attr = sym_new_not_null(ctx); + stack_pointer[-1] = attr; break; } case _LOAD_ATTR_NONDESCRIPTOR_NO_DICT: { _Py_UopsSymbol *attr; attr = sym_new_not_null(ctx); + stack_pointer[-1] = attr; break; } case _CHECK_ATTR_METHOD_LAZY_DICT: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1629,6 +1611,7 @@ (void)descr; attr = sym_new_not_null(ctx); self = owner; + stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1650,6 +1633,8 @@ (void)args; func = sym_new_not_null(ctx); maybe_self = sym_new_not_null(ctx); + stack_pointer[-2 - oparg] = func; + stack_pointer[-1 - oparg] = maybe_self; break; } @@ -1682,14 +1667,10 @@ } case _CHECK_FUNCTION_VERSION: { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } case _CHECK_METHOD_VERSION: { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1698,12 +1679,12 @@ _Py_UopsSymbol *self; method = sym_new_not_null(ctx); self = sym_new_not_null(ctx); + stack_pointer[-2 - oparg] = method; + stack_pointer[-1 - oparg] = self; break; } case _CHECK_IS_NOT_PY_CALLABLE: { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1723,8 +1704,6 @@ callable = stack_pointer[-2 - oparg]; sym_set_null(null); sym_set_type(callable, &PyMethod_Type); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1736,6 +1715,8 @@ (void)callable; func = sym_new_not_null(ctx); self = sym_new_not_null(ctx); + stack_pointer[-2 - oparg] = func; + stack_pointer[-1 - oparg] = self; break; } @@ -1755,8 +1736,6 @@ callable = stack_pointer[-2 - oparg]; sym_set_type(callable, &PyFunction_Type); (void)self_or_null; - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -2067,8 +2046,8 @@ bottom = stack_pointer[-1 - (oparg-1)]; assert(oparg > 0); top = bottom; - stack_pointer[-1 - (oparg-1)] = top; - stack_pointer += -(oparg-1); + stack_pointer[0] = top; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -2226,6 +2205,7 @@ _Py_UopsSymbol *value; PyObject *ptr = (PyObject *)this_instr->operand; value = sym_new_const(ctx, ptr); + stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; @@ -2254,6 +2234,7 @@ PyObject *ptr = (PyObject *)this_instr->operand; value = sym_new_const(ctx, ptr); null = sym_new_null(ctx); + stack_pointer[0] = value; stack_pointer[1] = null; stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); diff --git a/Tools/cases_generator/optimizer_generator.py b/Tools/cases_generator/optimizer_generator.py index 9388eb3bef65ec..c5c52f0f8f1333 100644 --- a/Tools/cases_generator/optimizer_generator.py +++ b/Tools/cases_generator/optimizer_generator.py @@ -104,21 +104,27 @@ def write_uop( ) -> None: locals: dict[str, Local] = {} prototype = override if override else uop - is_override = override is not None try: out.start_line() + peeks: list[Local] = [] for var in reversed(prototype.stack.inputs): code, local = stack.pop(var, extract_bits=True) if not skip_inputs: out.emit(code) + if var.peek: + peeks.append(local) if local.defined: locals[local.name] = local + # Push back the peeks, so that they remain on the logical + # stack, but their values are cached. + while peeks: + stack.push(peeks.pop()) out.emit(stack.define_output_arrays(prototype.stack.outputs)) storage = Storage.for_uop(stack, prototype, locals) if debug: args = [] for var in prototype.stack.inputs: - if not var.peek or is_override: + if not var.peek or override: args.append(var.name) out.emit(f'DEBUG_PRINTF({", ".join(args)});\n') if override: @@ -137,9 +143,6 @@ def write_uop( emit_default(out, uop) for output in storage.outputs: - if output.name in uop.deferred_refs.values(): - # We've already spilled this when emitting tokens - output.cached = False stack.push(output) out.start_line() stack.flush(out, cast_type="_Py_UopsSymbol *", extract_bits=True) From 1754fc4c8116959de0fe43f69a7d4837941b0208 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Tue, 27 Aug 2024 14:22:25 +0100 Subject: [PATCH 10/53] Update test --- Lib/test/test_generated_cases.py | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/Lib/test/test_generated_cases.py b/Lib/test/test_generated_cases.py index 12e9a395af7dbb..8f0012b40bc77d 100644 --- a/Lib/test/test_generated_cases.py +++ b/Lib/test/test_generated_cases.py @@ -281,17 +281,17 @@ def test_predictions(self): """ self.run_cases_test(input, output) - def test_eval_breaker(self): + def test_sync_sp(self): input = """ inst(A, (arg -- res)) { SYNC_SP(); - CHECK_EVAL_BREAKER(); + escaping_call(); res = Py_None; } inst(B, (arg -- res)) { res = Py_None; SYNC_SP(); - CHECK_EVAL_BREAKER(); + escaping_call(); } """ output = """ @@ -302,7 +302,7 @@ def test_eval_breaker(self): _PyStackRef res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - CHECK_EVAL_BREAKER(); + escaping_call(); res = Py_None; stack_pointer[0] = res; stack_pointer += 1; @@ -318,7 +318,7 @@ def test_eval_breaker(self): res = Py_None; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - CHECK_EVAL_BREAKER(); + escaping_call(); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); From 98f9720959e99a3f4e210a312ea8717102e2a87f Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Tue, 27 Aug 2024 15:09:55 +0100 Subject: [PATCH 11/53] Cleanup whitespace --- Tools/cases_generator/stack.py | 1 - 1 file changed, 1 deletion(-) diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index eac6804b52c466..4fc429b13fb3a6 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -461,4 +461,3 @@ def merge(self, other: "Storage", out: CWriter) -> "Storage": def as_comment(self) -> str: stack_comment = self.stack.as_comment() return stack_comment[:-2] + str(self.outputs) + " */" - From 0284b3fc9cf6eb3de38d548f67ec7c87dcbb15f8 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Tue, 27 Aug 2024 15:52:24 +0100 Subject: [PATCH 12/53] Add tests for PEP 7 parsing and escaping call in condition --- Lib/test/test_generated_cases.py | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/Lib/test/test_generated_cases.py b/Lib/test/test_generated_cases.py index 8f0012b40bc77d..c2f60267d9d787 100644 --- a/Lib/test/test_generated_cases.py +++ b/Lib/test/test_generated_cases.py @@ -327,6 +327,38 @@ def test_sync_sp(self): """ self.run_cases_test(input, output) + + def test_pep7_condition(self): + input = """ + inst(OP, (arg1 -- out)) { + if (arg1) + out = 0; + else { + out = 1; + } + } + """ + output = "" + with self.assertRaises(Exception): + self.run_cases_test(input, output) + + + def test_escapes_in_condition(self): + input = """ + inst(OP, (arg1 -- out)) { + if (escaping_call(arg1)) { + out = 0; + } + else { + out = 1; + } + } + """ + output = "" + with self.assertRaises(Exception): + self.run_cases_test(input, output) + + def test_error_if_plain(self): input = """ inst(OP, (--)) { From 03bea71e0fbca5f3a7acc62b0ee54ceac9a78ac5 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Tue, 27 Aug 2024 16:50:58 +0100 Subject: [PATCH 13/53] Remove merge artifact --- Tools/cases_generator/stack.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index 4fc429b13fb3a6..bd959c95ae6ce6 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -83,8 +83,6 @@ def condition(self) -> str | None: def is_array(self) -> bool: return self.item.is_array() - return Local(self.item, self.cached, self.in_memory, self.defined) - def __eq__(self, other: object) -> bool: if not isinstance(other, Local): return NotImplemented From ca2f457cfefbf57eac87aeb20df66905ed293196 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Tue, 27 Aug 2024 17:01:29 +0100 Subject: [PATCH 14/53] Remove test for escaping calls in conditions --- Lib/test/test_generated_cases.py | 21 ++------------------- 1 file changed, 2 insertions(+), 19 deletions(-) diff --git a/Lib/test/test_generated_cases.py b/Lib/test/test_generated_cases.py index c2f60267d9d787..ce0d9c791eeb4c 100644 --- a/Lib/test/test_generated_cases.py +++ b/Lib/test/test_generated_cases.py @@ -339,26 +339,9 @@ def test_pep7_condition(self): } """ output = "" - with self.assertRaises(Exception): - self.run_cases_test(input, output) - - - def test_escapes_in_condition(self): - input = """ - inst(OP, (arg1 -- out)) { - if (escaping_call(arg1)) { - out = 0; - } - else { - out = 1; - } - } - """ - output = "" - with self.assertRaises(Exception): + with self.assertRaises(SyntaxError): self.run_cases_test(input, output) - def test_error_if_plain(self): input = """ inst(OP, (--)) { @@ -888,7 +871,7 @@ def test_deopt_and_exit(self): } """ output = "" - with self.assertRaises(Exception): + with self.assertRaises(SyntaxError): self.run_cases_test(input, output) def test_array_of_one(self): From 57de61ff7102b2998bbc38dd71ea2b685b51ea0a Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 29 Aug 2024 10:52:17 +0100 Subject: [PATCH 15/53] Spill before escaping calls. Initial attempt --- Include/internal/pycore_opcode_metadata.h | 4 +- Include/internal/pycore_uop_metadata.h | 8 +- Python/bytecodes.c | 4 +- Python/executor_cases.c.h | 42 ++-- Python/generated_cases.c.h | 67 +++---- Tools/cases_generator/analyzer.py | 59 +++--- Tools/cases_generator/generators_common.py | 211 ++++++++++---------- Tools/cases_generator/stack.py | 215 +++++++++++++-------- Tools/cases_generator/tier1_generator.py | 7 +- Tools/cases_generator/tier2_generator.py | 7 +- 10 files changed, 342 insertions(+), 282 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 97a8e4a00a9d55..b3936cf07f7050 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -1040,8 +1040,8 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_BUILTIN_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_FUNCTION_EX] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, - [CALL_INTRINSIC_1] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_INTRINSIC_2] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_INTRINSIC_1] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, + [CALL_INTRINSIC_2] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [CALL_ISINSTANCE] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [CALL_KW] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [CALL_KW_BOUND_METHOD] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index e2cba4dc0dfc81..bc9ac523131960 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -90,8 +90,8 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_STORE_SUBSCR_LIST_INT] = HAS_DEOPT_FLAG, [_STORE_SUBSCR_DICT] = HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_DELETE_SUBSCR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_INTRINSIC_1] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_INTRINSIC_2] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_INTRINSIC_1] = HAS_ARG_FLAG | HAS_ERROR_FLAG, + [_CALL_INTRINSIC_2] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_RETURN_VALUE] = 0, [_GET_AITER] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GET_ANEXT] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, @@ -228,7 +228,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CHECK_AND_ALLOCATE_OBJECT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CREATE_INIT_FRAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_EXIT_INIT_CHECK] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, - [_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, [_CALL_BUILTIN_O] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_BUILTIN_FAST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -253,7 +253,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_FORMAT_SIMPLE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_FORMAT_WITH_SPEC] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_COPY] = HAS_ARG_FLAG | HAS_PURE_FLAG, - [_BINARY_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BINARY_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_SWAP] = HAS_ARG_FLAG | HAS_PURE_FLAG, [_GUARD_IS_TRUE_POP] = HAS_EXIT_FLAG, [_GUARD_IS_FALSE_POP] = HAS_EXIT_FLAG, diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 6ec07f42ff28bf..b0c162a911ee3b 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -3214,10 +3214,10 @@ dummy_func( op(_MAYBE_EXPAND_METHOD, (callable, self_or_null, args[oparg] -- func, maybe_self, args[oparg])) { if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) { PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyObject *self = ((PyMethodObject *)callable_o)->im_self; - maybe_self = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; func = PyStackRef_FromPyObjectNew(method); + PyObject *self = ((PyMethodObject *)callable_o)->im_self; + maybe_self = PyStackRef_FromPyObjectNew(self); /* Make sure that callable and all args are in memory */ args[-2] = func; args[-1] = maybe_self; diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index cb3ab9a85921ba..9b5cd521f28bbd 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -1499,10 +1499,10 @@ } STAT_INC(UNPACK_SEQUENCE, hit); val0 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 0)); - stack_pointer[0] = val0; val1 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 1)); - stack_pointer[-1] = val1; PyStackRef_CLOSE(seq); + stack_pointer[-1] = val1; + stack_pointer[0] = val0; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; @@ -2447,8 +2447,8 @@ STAT_INC(LOAD_ATTR, hit); null = PyStackRef_NULL; attr = PyStackRef_FromPyObjectNew(attr_o); - stack_pointer[-1] = attr; PyStackRef_CLOSE(owner); + stack_pointer[-1] = attr; break; } @@ -2469,8 +2469,8 @@ STAT_INC(LOAD_ATTR, hit); null = PyStackRef_NULL; attr = PyStackRef_FromPyObjectNew(attr_o); - stack_pointer[-1] = attr; PyStackRef_CLOSE(owner); + stack_pointer[-1] = attr; stack_pointer[0] = null; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2506,9 +2506,9 @@ STAT_INC(LOAD_ATTR, hit); assert(descr != NULL); attr = PyStackRef_FromPyObjectNew(descr); - stack_pointer[-1] = attr; null = PyStackRef_NULL; PyStackRef_CLOSE(owner); + stack_pointer[-1] = attr; break; } @@ -2522,9 +2522,9 @@ STAT_INC(LOAD_ATTR, hit); assert(descr != NULL); attr = PyStackRef_FromPyObjectNew(descr); - stack_pointer[-1] = attr; null = PyStackRef_NULL; PyStackRef_CLOSE(owner); + stack_pointer[-1] = attr; stack_pointer[0] = null; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3466,8 +3466,8 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - stack_pointer[-1] = attr; self = owner; + stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3487,8 +3487,8 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - stack_pointer[-1] = attr; self = owner; + stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3552,8 +3552,8 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - stack_pointer[-1] = attr; self = owner; + stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3573,12 +3573,10 @@ args = &stack_pointer[-oparg]; if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) { PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyObject *self = ((PyMethodObject *)callable_o)->im_self; - maybe_self = PyStackRef_FromPyObjectNew(self); - stack_pointer[-1 - oparg] = maybe_self; PyObject *method = ((PyMethodObject *)callable_o)->im_func; func = PyStackRef_FromPyObjectNew(method); - stack_pointer[-2 - oparg] = func; + PyObject *self = ((PyMethodObject *)callable_o)->im_self; + maybe_self = PyStackRef_FromPyObjectNew(self); /* Make sure that callable and all args are in memory */ args[-2] = func; args[-1] = maybe_self; @@ -3588,6 +3586,8 @@ func = callable; maybe_self = self_or_null; } + stack_pointer[-2 - oparg] = func; + stack_pointer[-1 - oparg] = maybe_self; break; } @@ -3690,11 +3690,11 @@ assert(PyStackRef_IsNull(null)); assert(Py_TYPE(callable_o) == &PyMethod_Type); self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - stack_pointer[-1 - oparg] = self; method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - stack_pointer[-2 - oparg] = method; assert(PyStackRef_FunctionCheck(method)); PyStackRef_CLOSE(callable); + stack_pointer[-2 - oparg] = method; + stack_pointer[-1 - oparg] = self; break; } @@ -3787,10 +3787,10 @@ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); STAT_INC(CALL, hit); self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - stack_pointer[-1 - oparg] = self; func = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - stack_pointer[-2 - oparg] = func; PyStackRef_CLOSE(callable); + stack_pointer[-2 - oparg] = func; + stack_pointer[-1 - oparg] = self; break; } @@ -4140,8 +4140,8 @@ } PyStackRef_CLOSE(callable); init = PyStackRef_FromPyObjectNew(init_func); - stack_pointer[-1 - oparg] = init; stack_pointer[-2 - oparg] = self; + stack_pointer[-1 - oparg] = init; break; } @@ -4872,11 +4872,11 @@ assert(PyStackRef_IsNull(null)); assert(Py_TYPE(callable_o) == &PyMethod_Type); self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - stack_pointer[-2 - oparg] = self; method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - stack_pointer[-3 - oparg] = method; assert(PyStackRef_FunctionCheck(method)); PyStackRef_CLOSE(callable); + stack_pointer[-3 - oparg] = method; + stack_pointer[-2 - oparg] = self; stack_pointer[-1] = kwnames; break; } @@ -5371,8 +5371,8 @@ _PyStackRef null; PyObject *ptr = (PyObject *)CURRENT_OPERAND(); value = PyStackRef_FromPyObjectNew(ptr); - stack_pointer[0] = value; null = PyStackRef_NULL; + stack_pointer[0] = value; stack_pointer[1] = null; stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 475134c4dc3aa2..1059e6ed01946a 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -853,12 +853,10 @@ args = &stack_pointer[-oparg]; if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) { PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyObject *self = ((PyMethodObject *)callable_o)->im_self; - maybe_self = PyStackRef_FromPyObjectNew(self); - stack_pointer[-1 - oparg] = maybe_self; PyObject *method = ((PyMethodObject *)callable_o)->im_func; func = PyStackRef_FromPyObjectNew(method); - stack_pointer[-2 - oparg] = func; + PyObject *self = ((PyMethodObject *)callable_o)->im_self; + maybe_self = PyStackRef_FromPyObjectNew(self); /* Make sure that callable and all args are in memory */ args[-2] = func; args[-1] = maybe_self; @@ -1008,7 +1006,6 @@ } PyStackRef_CLOSE(callable); init = PyStackRef_FromPyObjectNew(init_func); - stack_pointer[-1 - oparg] = init; } // _CREATE_INIT_FRAME { @@ -1080,14 +1077,14 @@ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); STAT_INC(CALL, hit); self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - stack_pointer[-1 - oparg] = self; func = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - stack_pointer[-2 - oparg] = func; PyStackRef_CLOSE(callable); } // flush + stack_pointer[-2 - oparg] = func; + stack_pointer[-1 - oparg] = self; // _CHECK_FUNCTION_VERSION - callable = stack_pointer[-2 - oparg]; + callable = func; { uint32_t func_version = read_u32(&this_instr[2].cache); PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); @@ -1096,7 +1093,7 @@ DEOPT_IF(func->func_version != func_version, CALL); } // _CHECK_FUNCTION_EXACT_ARGS - self_or_null = stack_pointer[-1 - oparg]; + self_or_null = self; { PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); assert(PyFunction_Check(callable_o)); @@ -1189,17 +1186,17 @@ assert(PyStackRef_IsNull(null)); assert(Py_TYPE(callable_o) == &PyMethod_Type); self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - stack_pointer[-1 - oparg] = self; method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - stack_pointer[-2 - oparg] = method; assert(PyStackRef_FunctionCheck(method)); PyStackRef_CLOSE(callable); } // flush + stack_pointer[-2 - oparg] = method; + stack_pointer[-1 - oparg] = self; // _PY_FRAME_GENERAL args = &stack_pointer[-oparg]; - self_or_null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + self_or_null = self; + callable = method; { PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *self_or_null_o = PyStackRef_AsPyObjectBorrow(self_or_null); @@ -1910,18 +1907,18 @@ assert(PyStackRef_IsNull(null)); assert(Py_TYPE(callable_o) == &PyMethod_Type); self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - stack_pointer[-2 - oparg] = self; method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - stack_pointer[-3 - oparg] = method; assert(PyStackRef_FunctionCheck(method)); PyStackRef_CLOSE(callable); } // flush + stack_pointer[-3 - oparg] = method; + stack_pointer[-2 - oparg] = self; + stack_pointer[-1] = kwnames; // _PY_FRAME_KW - kwnames = stack_pointer[-1]; args = &stack_pointer[-1 - oparg]; - self_or_null = stack_pointer[-2 - oparg]; - callable = stack_pointer[-3 - oparg]; + self_or_null = self; + callable = method; { PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *self_or_null_o = PyStackRef_AsPyObjectBorrow(self_or_null); @@ -2958,7 +2955,6 @@ int matches = PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration); if (matches) { value = PyStackRef_FromPyObjectNew(((PyStopIterationObject *)exc_value)->value); - stack_pointer[-2] = value; PyStackRef_CLOSE(sub_iter_st); PyStackRef_CLOSE(last_sent_val_st); PyStackRef_CLOSE(exc_value_st); @@ -2970,6 +2966,7 @@ goto exception_unwind; } stack_pointer[-3] = none; + stack_pointer[-2] = value; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -3755,8 +3752,8 @@ assert(seq); assert(it->it_index < PyList_GET_SIZE(seq)); next = PyStackRef_FromPyObjectNew(PyList_GET_ITEM(seq, it->it_index++)); - stack_pointer[0] = next; } + stack_pointer[0] = next; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -3848,8 +3845,8 @@ assert(seq); assert(it->it_index < PyTuple_GET_SIZE(seq)); next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq, it->it_index++)); - stack_pointer[0] = next; } + stack_pointer[0] = next; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -4057,12 +4054,10 @@ args = &stack_pointer[-oparg]; if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null)) { PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - PyObject *self = ((PyMethodObject *)callable_o)->im_self; - maybe_self = PyStackRef_FromPyObjectNew(self); - stack_pointer[-1 - oparg] = maybe_self; PyObject *method = ((PyMethodObject *)callable_o)->im_func; func = PyStackRef_FromPyObjectNew(method); - stack_pointer[-2 - oparg] = func; + PyObject *self = ((PyMethodObject *)callable_o)->im_self; + maybe_self = PyStackRef_FromPyObjectNew(self); /* Make sure that callable and all args are in memory */ args[-2] = func; args[-1] = maybe_self; @@ -4535,7 +4530,6 @@ // _LOAD_CONST { value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg)); - stack_pointer[0] = value; } // _RETURN_VALUE_EVENT val = value; @@ -4938,10 +4932,10 @@ STAT_INC(LOAD_ATTR, hit); assert(descr != NULL); attr = PyStackRef_FromPyObjectNew(descr); - stack_pointer[-1] = attr; null = PyStackRef_NULL; PyStackRef_CLOSE(owner); } + stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); @@ -4979,10 +4973,10 @@ STAT_INC(LOAD_ATTR, hit); assert(descr != NULL); attr = PyStackRef_FromPyObjectNew(descr); - stack_pointer[-1] = attr; null = PyStackRef_NULL; PyStackRef_CLOSE(owner); } + stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); @@ -5104,9 +5098,9 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - stack_pointer[-1] = attr; self = owner; } + stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5140,9 +5134,9 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - stack_pointer[-1] = attr; self = owner; } + stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5188,9 +5182,9 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - stack_pointer[-1] = attr; self = owner; } + stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5266,8 +5260,8 @@ assert(descr != NULL); PyStackRef_CLOSE(owner); attr = PyStackRef_FromPyObjectNew(descr); - stack_pointer[-1] = attr; } + stack_pointer[-1] = attr; DISPATCH(); } @@ -5308,8 +5302,8 @@ assert(descr != NULL); PyStackRef_CLOSE(owner); attr = PyStackRef_FromPyObjectNew(descr); - stack_pointer[-1] = attr; } + stack_pointer[-1] = attr; DISPATCH(); } @@ -5405,10 +5399,10 @@ STAT_INC(LOAD_ATTR, hit); null = PyStackRef_NULL; attr = PyStackRef_FromPyObjectNew(attr_o); - stack_pointer[-1] = attr; PyStackRef_CLOSE(owner); } /* Skip 5 cache entries */ + stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); @@ -6492,7 +6486,6 @@ // _LOAD_CONST { value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg)); - stack_pointer[0] = value; } // _RETURN_VALUE retval = value; @@ -7562,10 +7555,10 @@ DEOPT_IF(PyTuple_GET_SIZE(seq_o) != 2, UNPACK_SEQUENCE); STAT_INC(UNPACK_SEQUENCE, hit); val0 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 0)); - stack_pointer[0] = val0; val1 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 1)); - stack_pointer[-1] = val1; PyStackRef_CLOSE(seq); + stack_pointer[-1] = val1; + stack_pointer[0] = val0; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 07ee411e0457af..ff37ef58ae99a9 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -1,4 +1,4 @@ -from dataclasses import dataclass +from dataclasses import dataclass, field import lexer import parser import re @@ -6,7 +6,7 @@ @dataclass class Properties: - escapes: bool + escaping_calls: dict[lexer.Token, lexer.Token] error_with_pop: bool error_without_pop: bool deopts: bool @@ -34,8 +34,11 @@ def dump(self, indent: str) -> None: @staticmethod def from_list(properties: list["Properties"]) -> "Properties": + escaping_calls: dict[lexer.Token, lexer.Token] = {} + for p in properties: + escaping_calls.update(p.escaping_calls) return Properties( - escapes=any(p.escapes for p in properties), + escaping_calls=escaping_calls, error_with_pop=any(p.error_with_pop for p in properties), error_without_pop=any(p.error_without_pop for p in properties), deopts=any(p.deopts for p in properties), @@ -58,9 +61,12 @@ def from_list(properties: list["Properties"]) -> "Properties": def infallible(self) -> bool: return not self.error_with_pop and not self.error_without_pop + @property + def escapes(self) -> bool: + return bool(self.escaping_calls) SKIP_PROPERTIES = Properties( - escapes=False, + escaping_calls=[], error_with_pop=False, error_without_pop=False, deopts=False, @@ -549,33 +555,32 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "_PyList_FromStackRefSteal", "_PyTuple_FromArraySteal", "_PyTuple_FromStackRefSteal", -) - -ESCAPING_FUNCTIONS = ( - "import_name", - "import_from", + "PyFunction_GET_CODE", + "_PyErr_Occurred", ) -def makes_escaping_api_call(instr: parser.InstDef) -> bool: - if "CALL_INTRINSIC" in instr.name: - return True - if instr.name == "_BINARY_OP": - return True - tkns = iter(instr.tokens) - for tkn in tkns: +def find_start_stmt(node: parser.InstDef, idx: int) -> lexer.Token: + assert idx < len(node.block.tokens) + while True: + tkn = node.block.tokens[idx-1] + if tkn.kind == "SEMI" or tkn.kind == "LBRACE" or tkn.kind == "RBRACE": + return node.block.tokens[idx] + idx -= 1 + assert idx > 0 + +def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, lexer.Token]: + result: dict[lexer.Token, lexer.Token] = {} + tokens = instr.block.tokens + for idx, tkn in enumerate(tokens): if tkn.kind != lexer.IDENTIFIER: continue try: - next_tkn = next(tkns) - except StopIteration: - return False + next_tkn = tokens[idx+1] + except IndexError: + return result if next_tkn.kind != lexer.LPAREN: continue - if tkn.text in ESCAPING_FUNCTIONS: - return True - if tkn.text == "tp_vectorcall": - return True if not tkn.text.startswith("Py") and not tkn.text.startswith("_Py"): continue if tkn.text.endswith("Check"): @@ -586,8 +591,9 @@ def makes_escaping_api_call(instr: parser.InstDef) -> bool: continue if tkn.text in NON_ESCAPING_FUNCTIONS: continue - return True - return False + start = find_start_stmt(instr, idx) + result[start] = tkn + return result EXITS = { @@ -659,6 +665,7 @@ def effect_depends_on_oparg_1(op: parser.InstDef) -> bool: def compute_properties(op: parser.InstDef) -> Properties: + escaping_calls = find_escaping_api_calls(op) has_free = ( variable_used(op, "PyCell_New") or variable_used(op, "PyCell_GetRef") @@ -679,7 +686,7 @@ def compute_properties(op: parser.InstDef) -> Properties: error_with_pop = has_error_with_pop(op) error_without_pop = has_error_without_pop(op) return Properties( - escapes=makes_escaping_api_call(op), + escaping_calls=escaping_calls, error_with_pop=error_with_pop, error_without_pop=error_without_pop, deopts=deopts_if, diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index a913f3af11b190..2edf738f55cc6f 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -11,8 +11,10 @@ from cwriter import CWriter from typing import Callable, Mapping, TextIO, Iterator, Iterable from lexer import Token -from stack import Stack, Local, Storage +from stack import Stack, Local, Storage, StackError +# Set this to true for voluminous output showing state of stack and locals +PRINT_STACKS = False class TokenIterator: @@ -97,25 +99,6 @@ def always_true(tkn: Token | None) -> bool: return False return tkn.text == "true" or tkn.text == "1" -def push_defined_locals(outputs: list[Local], stack:Stack, tkn: Token) -> None: - while outputs: - out = outputs[0] - if out.defined: - stack.push(out) - outputs.pop(0) - else: - break - undefined = "" - for out in outputs: - if out.defined: - raise analysis_error( - f"Locals not defined in stack order. " - f"Expected '{out.name}' is defined before '{undefined}'", - tkn - ) - else: - undefined = out.name - class Emitter: out: CWriter @@ -129,7 +112,7 @@ def __init__(self, out: CWriter): "ERROR_NO_POP": self.error_no_pop, "DECREF_INPUTS": self.decref_inputs, "SYNC_SP": self.sync_sp, - "PyStackRef_FromPyObjectNew": self.py_stack_ref_from_py_object_new, + # "PyStackRef_FromPyObjectNew": self.py_stack_ref_from_py_object_new, "DISPATCH": self.dispatch } self.out = out @@ -263,30 +246,14 @@ def sync_sp( next(tkn_iter) next(tkn_iter) storage.stack.flush(self.out) + self._print_storage(storage) return True - def py_stack_ref_from_py_object_new( - self, - tkn: Token, - tkn_iter: TokenIterator, - uop: Uop, - storage: Storage, - inst: Instruction | None, - ) -> bool: - self.out.emit(tkn) - emit_to(self.out, tkn_iter, "SEMI") - self.out.emit(";\n") - - target = uop.deferred_refs[tkn] - if target is None: - # An assignment we don't handle, such as to a pointer or array. - return True - - # Flush the assignment to the stack. Note that we don't flush the - # stack pointer here, and instead are currently relying on initializing - # unused portions of the stack to NULL. - storage.stack.flush_single_var(self.out, target, uop.stack.outputs) - return True + def _print_storage(self, storage: Storage): + if PRINT_STACKS: + self.out.start_line() + self.emit(storage.as_comment()) + self.out.start_line() def _emit_if( self, @@ -302,31 +269,50 @@ def _emit_if( rparen = emit_to(self.out, tkn_iter, "RPAREN") self.emit(rparen) if_storage = storage.copy() - reachable, rbrace, if_stack = self._emit_block(tkn_iter, uop, if_storage, inst, True) - maybe_else = tkn_iter.peek() - if maybe_else and maybe_else.kind == "ELSE": - self.emit(rbrace) - self.emit(next(tkn_iter)) - maybe_if = tkn_iter.peek() - if maybe_if and maybe_if.kind == "IF": + reachable, rbrace, if_storage = self._emit_block(tkn_iter, uop, if_storage, inst, True) + try: + maybe_else = tkn_iter.peek() + if maybe_else and maybe_else.kind == "ELSE": + self._print_storage(storage) + self.emit(rbrace) self.emit(next(tkn_iter)) - else_reachable, rbrace, stack = self._emit_if(tkn_iter, uop, storage, inst) - else: - else_reachable, rbrace, stack = self._emit_block(tkn_iter, uop, storage, inst, True) - if not reachable: - # Discard the if storage - reachable = else_reachable - elif not else_reachable: - # Discard the else storage - storage = if_storage - else: - storage = storage.merge(if_storage, self.out) - else: - if reachable: - storage = storage.merge(if_storage, self.out) + maybe_if = tkn_iter.peek() + if maybe_if and maybe_if.kind == "IF": + self.emit(next(tkn_iter)) + else_reachable, rbrace, storage = self._emit_if(tkn_iter, uop, storage, inst) + else: + else_reachable, rbrace, storage = self._emit_block(tkn_iter, uop, storage, inst, True) + if not reachable: + # Discard the if storage + reachable = else_reachable + elif not else_reachable: + # Discard the else storage + storage = if_storage + else: + if PRINT_STACKS: + self.emit("Converting storage:\n") + self._print_storage(if_storage) + self._print_storage(storage) + storage.merge(if_storage, self.out) + if PRINT_STACKS: + self.emit("Converted:\n") + self._print_storage(storage) else: - # Discard the if stack - reachable = True + if reachable: + if PRINT_STACKS: + self.emit("Converting storage:\n") + self._print_storage(if_storage) + self._print_storage(storage) + if_storage.merge(storage, self.out) + self._print_storage(storage) + if PRINT_STACKS: + self.emit("Converted:\n") + self._print_storage(storage) + else: + # Discard the if storage + reachable = True + except StackError as ex: + raise analysis_error(ex.args[0], rbrace) from None return reachable, rbrace, storage def _emit_block( @@ -341,43 +327,63 @@ def _emit_block( braces = 1 out_stores = set(uop.output_stores) tkn = next(tkn_iter) - reachable = True - if tkn.kind != "LBRACE": - raise analysis_error(f"PEP 7: expected '{{' found {tkn.text}", tkn) - if emit_first_brace: - self.emit(tkn) - for tkn in tkn_iter: - if tkn.kind == "LBRACE": - self.out.emit(tkn) - braces += 1 - elif tkn.kind == "RBRACE": - braces -= 1 - if braces == 0: - return reachable, tkn, storage - self.out.emit(tkn) - elif tkn.kind == "GOTO": - reachable = False; - self.out.emit(tkn) - elif tkn.kind == "IDENTIFIER": - if tkn.text in self._replacers: - if not self._replacers[tkn.text](tkn, tkn_iter, uop, storage, inst): - reachable = False + try: + reachable = True + line : int = -1 + if tkn.kind != "LBRACE": + raise analysis_error(f"PEP 7: expected '{{' found {tkn.text}", tkn) + escaping_calls = uop.properties.escaping_calls + if emit_first_brace: + self.emit(tkn) + self._print_storage(storage) + for tkn in tkn_iter: + if PRINT_STACKS and tkn.line != line: + self.out.start_line() + self.emit(storage.as_comment()) + self.out.start_line() + line = tkn.line + if tkn.kind == "LBRACE": + self.out.emit(tkn) + braces += 1 + elif tkn.kind == "RBRACE": + self._print_storage(storage) + braces -= 1 + if braces == 0: + return reachable, tkn, storage + self.out.emit(tkn) + elif tkn.kind == "GOTO": + reachable = False; + self.out.emit(tkn) + elif tkn.kind == "IDENTIFIER": + if tkn.text in self._replacers: + if not self._replacers[tkn.text](tkn, tkn_iter, uop, storage, inst): + reachable = False + else: + if tkn in out_stores: + for out in storage.outputs: + if out.name == tkn.text: + out.defined = True + out.in_memory = False + break + if tkn.text.startswith("DISPATCH"): + self._print_storage(storage) + reachable = False + self.out.emit(tkn) + #elif tkn in escaping_calls: + #self.out.emit(f"/* ESCAPING CALL {escaping_calls[tkn].text} */\n") + #storage.flush(self.out) + #self._print_storage(storage) + #self.out.emit(tkn) + elif tkn.kind == "IF": + self.out.emit(tkn) + if_reachable, rbrace, stack = self._emit_if(tkn_iter, uop, storage, inst) + if reachable: + reachable = if_reachable + self.out.emit(rbrace) else: - if tkn in out_stores: - for out in storage.outputs: - if out.name == tkn.text: - out.defined = True - out.in_memory = False - break self.out.emit(tkn) - elif tkn.kind == "IF": - self.out.emit(tkn) - if_reachable, rbrace, stack = self._emit_if(tkn_iter, uop, storage, inst) - if reachable: - reachable = if_reachable - self.out.emit(rbrace) - else: - self.out.emit(tkn) + except StackError as ex: + raise analysis_error(ex.args[0], tkn) from None raise analysis_error("Expecting closing brace. Reached end of file", tkn) @@ -390,6 +396,9 @@ def emit_tokens( tkn_iter = TokenIterator(uop.body) self.out.start_line() self._emit_block(tkn_iter, uop, storage, inst, False) + for output in storage.outputs: + storage.stack.push(output) + storage.outputs = [] def emit(self, txt: str | Token) -> None: self.out.emit(txt) diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index bd959c95ae6ce6..4336bdc06a3f24 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -46,6 +46,9 @@ class Local: in_memory: bool defined: bool + def __repr__(self): + return f"Local('{self.item.name}', in_memory={self.in_memory}, defined={self.defined})" + @staticmethod def unused(defn: StackItem) -> "Local": return Local(defn, False, defn.is_array(), False) @@ -174,10 +177,29 @@ def to_c(self) -> str: res = "-" + res[3:] return res + def as_int(self) -> int | None: + self.simplify() + int_offset = 0 + for item in self.popped: + try: + int_offset -= int(item) + except ValueError: + return None + for item in self.pushed: + try: + int_offset += int(item) + except ValueError: + return None + return int_offset + def clear(self) -> None: self.popped = [] self.pushed = [] + def __bool__(self): + self.simplify() + return bool(self.popped) or bool(self.pushed) + def __eq__(self, other: object) -> bool: if not isinstance(other, StackOffset): return NotImplemented @@ -280,80 +302,42 @@ def _do_emit( out.emit(f"if ({var.condition}) ") out.emit(f"stack_pointer[{base_offset.to_c()}]{bits} = {cast}{var.name};\n") - @staticmethod - def _do_flush( - out: CWriter, - variables: list[Local], - base_offset: StackOffset, - top_offset: StackOffset, - cast_type: str = "uintptr_t", - extract_bits: bool = False, - ) -> None: - out.start_line() - for var in variables: - if ( - var.cached - and not var.in_memory - and not var.item.peek - and not var.name in UNUSED - ): - Stack._do_emit(out, var.item, base_offset, cast_type, extract_bits) - base_offset.push(var.item) - if base_offset.to_c() != top_offset.to_c(): - print("base", base_offset, "top", top_offset) - assert False - number = base_offset.to_c() + def _adjust_stack_pointer(self, out: CWriter, number: str): if number != "0": out.emit(f"stack_pointer += {number};\n") out.emit("assert(WITHIN_STACK_BOUNDS());\n") - out.start_line() def flush( self, out: CWriter, cast_type: str = "uintptr_t", extract_bits: bool = False ) -> None: - self._do_flush( - out, - self.variables, - self.base_offset, - self.top_offset, - cast_type, - extract_bits, - ) - self.variables = [] - self.base_offset.clear() + out.start_line() + var_offset = self.base_offset.copy() + for var in self.variables: + if ( + not var.in_memory + and not var.item.peek + and not var.name in UNUSED + ): + Stack._do_emit(out, var.item, var_offset, cast_type, extract_bits) + var.in_memory = True + var_offset.push(var.item) + number = self.top_offset.to_c() + self._adjust_stack_pointer(out, number) + self.base_offset -= self.top_offset self.top_offset.clear() + out.start_line() - def flush_single_var( - self, - out: CWriter, - var_name: str, - outputs: list[StackItem], - cast_type: str = "uintptr_t", - extract_bits: bool = False, - ) -> None: - assert any(var.name == var_name for var in outputs) - base_offset = self.base_offset.copy() - top_offset = self.top_offset.copy() - for var in self.variables: - base_offset.push(var.item) - for output in outputs: - if any(output == v.item for v in self.variables): - # The variable is already on the stack, such as a peeked value - # in the tier1 generator - continue - if output.name == var_name: - Stack._do_emit(out, output, base_offset, cast_type, extract_bits) - base_offset.push(output) - top_offset.push(output) - if base_offset.to_c() != top_offset.to_c(): - print("base", base_offset, "top", top_offset) - assert False + def is_flushed(self): + return not self.variables and not self.base_offset and not self.top_offset def peek_offset(self) -> str: return self.top_offset.to_c() def as_comment(self) -> str: - return f"/* Variables: {[v.name for v in self.variables]}. Base offset: {self.base_offset.to_c()}. Top offset: {self.top_offset.to_c()} */" + return ( + f"/* Variables: {[v.name for v in self.variables]}. " + f"Base offset: {self.base_offset.to_c()}. Top offset: {self.top_offset.to_c()} */" + ) def copy(self) -> "Stack": other = Stack() @@ -370,14 +354,20 @@ def __eq__(self, other: object) -> bool: self.top_offset == other.top_offset and self.base_offset == other.base_offset and self.variables == other.variables - and self.defined == other.defined ) - - def merge(self, other:"Stack") -> "Stack": - if self != other: - raise StackError("unequal stacks") - return self + def align(self, other: "Stack", out: CWriter) -> None: + if len(self.variables) != len(other.variables): + raise StackError("Cannot align stacks: differing variables") + if self.top_offset == other.top_offset: + return + diff = self.top_offset - other.top_offset + try: + self.top_offset -= diff + self.base_offset -= diff + self._adjust_stack_pointer(out, diff.to_c()) + except ValueError: + raise StackError("Cannot align stacks: cannot adjust stack pointer") def get_stack_effect(inst: Instruction | PseudoInstruction) -> Stack: stack = Stack() @@ -413,14 +403,14 @@ class Storage: def _push_defined_locals(self) -> None: while self.outputs: - out = self.outputs[0] - if out.defined: - self.stack.push(out) - self.outputs.pop(0) - else: + if not self.outputs[0].defined: break + out = self.outputs.pop(0) + self.stack.push(out) undefined = "" for out in self.outputs: + if out.is_array(): + continue if out.defined: raise StackError( f"Locals not defined in stack order. " @@ -450,12 +440,83 @@ def for_uop(stack: Stack, uop: Uop, locals: dict[str, Local]) -> "Storage": def copy(self) -> "Storage": return Storage(self.stack.copy(), [ l.copy() for l in self.outputs]) - def merge(self, other: "Storage", out: CWriter) -> "Storage": - self.stack.merge(other.stack) - if self.outputs != other.outputs: - raise StackError("unequal locals") - return self + def sanity_check(self): + names: set[str] = set() + for var in self.stack.variables: + if var.name in names: + raise StackError(f"Duplicate name {var.name}") + names.add(var.name) + for var in self.outputs: + if var.name in names: + raise StackError(f"Duplicate name {var.name}") + names.add(var.name) + + def is_flushed(self): + for var in self.outputs: + if var.defined and not var.in_memory: + return False + return self.stack.is_flushed() + + def merge(self, other: "Storage", out: CWriter) -> None: + self.sanity_check() + locally_defined_set: set[str] = set() + for var in self.outputs: + if var.defined and not var.in_memory: + locally_defined_set.add(var.name) + for var in other.outputs: + if var.defined and not var.in_memory: + locally_defined_set.add(var.name) + while self.stack.variables and self.stack.variables[0].item.name in locally_defined_set: + code, var = self.stack.pop(self.stack.variables[0].item) + out.emit(code) + self.outputs.append(var) + while other.stack.variables and other.stack.variables[0].item.name in locally_defined_set: + code, var = other.stack.pop(other.stack.variables[0].item) + assert code == "" + other.outputs.append(var) + s1, s2 = self.stack, other.stack + l1, l2 = self.outputs, other.outputs + if len(s1.variables) != len(s2.variables): + # Make sure s2 is the larger stack. + if len(s1.variables) > len(s2.variables): + s1, s2 = s2, s1 + l1, l2 = l2, l1 + while len(s2.variables) > len(s1.variables): + top = s2.variables[-1] + if top.defined: + code, var = s2.pop(top.item) + assert code == "" and var == top + l2.insert(0, top) + else: + for l in l1: + if l.name == top.name: + break + else: + raise StackError(f"Missing local {top.name} when attempting to merge storage") + if l.in_memory: + s1.push(l) + l1.remove(l) + else: + raise StackError(f"Local {top.name} is not in memory, so cannot be merged") + # Now merge locals: + self_live = [var for var in self.outputs if not var.item.peek and var.defined] + other_live = [var for var in other.outputs if not var.item.peek and var.defined] + self.stack.align(other.stack, out) + if len(self_live) != len(other_live): + if other.stack.is_flushed(): + self.stack.flush(out) + return self + else: + raise StackError(f"Mismatched locals: {self_live} and {other_live}") + for self_out, other_out in zip(self_live, other_live): + if self_out.name != other_out.name: + raise StackError(f"Mismatched local: {self_out.name} and {other_out.name}") + if self_out.defined ^ other_out.defined: + raise StackError(f"Local {self_out.name} defined on only one path") + self_out.in_memory = other_out.in_memory = self_out.in_memory and other_out.in_memory + self_out.cached = other_out.cached = self_out.cached and other_out.cached + self.sanity_check() def as_comment(self) -> str: stack_comment = self.stack.as_comment() - return stack_comment[:-2] + str(self.outputs) + " */" + return stack_comment[:-2] + "\n LOCALS: " + str(self.outputs) + " */" diff --git a/Tools/cases_generator/tier1_generator.py b/Tools/cases_generator/tier1_generator.py index 41a9373c64d749..9cb80bf901f518 100644 --- a/Tools/cases_generator/tier1_generator.py +++ b/Tools/cases_generator/tier1_generator.py @@ -48,7 +48,7 @@ def declare_variables(inst: Instruction, out: CWriter) -> None: try: stack = get_stack_effect(inst) except StackError as ex: - raise analysis_error(ex.args[0], inst.where) + raise analysis_error(ex.args[0], inst.where) from None required = set(stack.defined) required.discard("unused") for part in inst.parts: @@ -119,11 +119,6 @@ def write_uop( offset += cache.size emitter.emit_tokens(uop, storage, inst) - for output in storage.outputs: - if output.name in uop.deferred_refs.values(): - # We've already spilled this when emitting tokens - output.cached = False - stack.push(output) if braces: emitter.out.start_line() emitter.emit("}\n") diff --git a/Tools/cases_generator/tier2_generator.py b/Tools/cases_generator/tier2_generator.py index 1f2df958bf32c9..1678989e7be0da 100644 --- a/Tools/cases_generator/tier2_generator.py +++ b/Tools/cases_generator/tier2_generator.py @@ -87,7 +87,7 @@ def error_if( next(tkn_iter) # RPAREN next(tkn_iter) # Semi colon self.emit(") JUMP_TO_ERROR();\n") - return first_tkn.text != "true" and first_tkn.text != "1" + return not always_true(first_tkn) def error_no_pop( @@ -200,11 +200,6 @@ def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> None: cast = f"uint{cache.size*16}_t" emitter.emit(f"{type}{cache.name} = ({cast})CURRENT_OPERAND();\n") emitter.emit_tokens(uop, storage, None) - for output in storage.outputs: - if output.name in uop.deferred_refs.values(): - # We've already spilled this when emitting tokens - output.cached = False - stack.push(output) except StackError as ex: raise analysis_error(ex.args[0], uop.body[0]) from None From a2e430a1fc7587e56774616e8ba101a9bab12636 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 29 Aug 2024 12:03:55 +0100 Subject: [PATCH 16/53] Clean up asserts --- Tools/cases_generator/generators_common.py | 4 ++-- Tools/cases_generator/tier2_generator.py | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 2edf738f55cc6f..67ef9cfc53147b 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -139,7 +139,7 @@ def deopt_if( self.out.emit_at("DEOPT_IF", tkn) lparen = next(tkn_iter) self.emit(lparen) - assert(lparen.kind == "LPAREN") + assert lparen.kind == "LPAREN" first_tkn = tkn_iter.peek() emit_to(self.out, tkn_iter, "RPAREN") next(tkn_iter) # Semi colon @@ -163,7 +163,7 @@ def error_if( self.out.emit_at("if ", tkn) lparen = next(tkn_iter) self.emit(lparen) - assert(lparen.kind == "LPAREN") + assert lparen.kind == "LPAREN" first_tkn = tkn_iter.peek() emit_to(self.out, tkn_iter, "COMMA") label = next(tkn_iter).text diff --git a/Tools/cases_generator/tier2_generator.py b/Tools/cases_generator/tier2_generator.py index 1678989e7be0da..91c9352abcbd70 100644 --- a/Tools/cases_generator/tier2_generator.py +++ b/Tools/cases_generator/tier2_generator.py @@ -79,7 +79,7 @@ def error_if( self.out.emit_at("if ", tkn) lparen = next(tkn_iter) self.emit(lparen) - assert(lparen.kind == "LPAREN") + assert lparen.kind == "LPAREN" first_tkn = next(tkn_iter) self.out.emit(first_tkn) emit_to(self.out, tkn_iter, "COMMA") @@ -115,7 +115,7 @@ def deopt_if( self.out.emit_at("if ", tkn) lparen = next(tkn_iter) self.emit(lparen) - assert(lparen.kind == "LPAREN") + assert lparen.kind == "LPAREN" first_tkn = tkn_iter.peek() emit_to(self.out, tkn_iter, "RPAREN") next(tkn_iter) # Semi colon From 95408d32a39dd114cbbb894433077e819567d626 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 29 Aug 2024 16:24:30 +0100 Subject: [PATCH 17/53] Update test --- Lib/test/test_generated_cases.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/Lib/test/test_generated_cases.py b/Lib/test/test_generated_cases.py index ce0d9c791eeb4c..529ff0cd330d62 100644 --- a/Lib/test/test_generated_cases.py +++ b/Lib/test/test_generated_cases.py @@ -1061,8 +1061,6 @@ def test_flush(self): stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); // SECOND - b = stack_pointer[-1]; - a = stack_pointer[-2]; { use(a, b); } From eb3a645dc2c90fe0135f25e0e32aa40eaae5fdba Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 29 Aug 2024 16:32:16 +0100 Subject: [PATCH 18/53] Flush locals as well on error --- Lib/test/test_generated_cases.py | 3 ++- Python/generated_cases.c.h | 6 ++++-- Tools/cases_generator/generators_common.py | 17 ++--------------- 3 files changed, 8 insertions(+), 18 deletions(-) diff --git a/Lib/test/test_generated_cases.py b/Lib/test/test_generated_cases.py index 529ff0cd330d62..43e56741c4d295 100644 --- a/Lib/test/test_generated_cases.py +++ b/Lib/test/test_generated_cases.py @@ -1155,7 +1155,8 @@ def test_push_then_error(self): b = 1; if (cond) { stack_pointer[0] = a; - stack_pointer += 1; + stack_pointer[1] = b; + stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); goto error; } diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 1059e6ed01946a..f768ce96d76f68 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -1631,7 +1631,8 @@ PyStackRef_XCLOSE(kwargs_st); assert(PyStackRef_AsPyObjectBorrow(PEEK(2 + (oparg & 1))) == NULL); if (PyStackRef_IsNull(result)) { - stack_pointer += -3 - (oparg & 1); + stack_pointer[-3 - (oparg & 1)] = result; + stack_pointer += -2 - (oparg & 1); assert(WITHIN_STACK_BOUNDS()); goto error; } @@ -7744,7 +7745,8 @@ PyStackRef_XCLOSE(kwargs_st); assert(PyStackRef_AsPyObjectBorrow(PEEK(2 + (oparg & 1))) == NULL); if (PyStackRef_IsNull(result)) { - stack_pointer += -3 - (oparg & 1); + stack_pointer[-3 - (oparg & 1)] = result; + stack_pointer += -2 - (oparg & 1); assert(WITHIN_STACK_BOUNDS()); goto error; } diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 67ef9cfc53147b..5fee03c865e2dc 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -185,7 +185,7 @@ def error_if( self.out.emit(";\n") else: self.out.emit("{\n") - storage.stack.copy().flush(self.out) + storage.copy().flush(self.out) self.out.emit("goto ") self.out.emit(label) self.out.emit(";\n") @@ -289,25 +289,12 @@ def _emit_if( # Discard the else storage storage = if_storage else: - if PRINT_STACKS: - self.emit("Converting storage:\n") - self._print_storage(if_storage) - self._print_storage(storage) storage.merge(if_storage, self.out) - if PRINT_STACKS: - self.emit("Converted:\n") - self._print_storage(storage) + self._print_storage(storage) else: if reachable: - if PRINT_STACKS: - self.emit("Converting storage:\n") - self._print_storage(if_storage) - self._print_storage(storage) if_storage.merge(storage, self.out) self._print_storage(storage) - if PRINT_STACKS: - self.emit("Converted:\n") - self._print_storage(storage) else: # Discard the if storage reachable = True From 00f52655183c75ade5044a605030192e62968f12 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 29 Aug 2024 16:56:32 +0100 Subject: [PATCH 19/53] Spill stack on escaping calls. Preparatory work --- Include/internal/pycore_ceval.h | 1 + Include/internal/pycore_opcode_metadata.h | 2 +- Include/internal/pycore_uop_metadata.h | 2 +- Python/bytecodes.c | 33 ++++------------------ Python/ceval.c | 7 +++++ Python/executor_cases.c.h | 33 ++++------------------ Python/generated_cases.c.h | 33 ++++------------------ Tools/cases_generator/analyzer.py | 8 ++++-- Tools/cases_generator/generators_common.py | 9 +++--- 9 files changed, 35 insertions(+), 93 deletions(-) diff --git a/Include/internal/pycore_ceval.h b/Include/internal/pycore_ceval.h index e4af731be0e87f..ffc9a8875f7816 100644 --- a/Include/internal/pycore_ceval.h +++ b/Include/internal/pycore_ceval.h @@ -251,6 +251,7 @@ typedef struct _special_method { } _Py_SpecialMethod; PyAPI_DATA(const _Py_SpecialMethod) _Py_SpecialMethods[]; +PyAPI_DATA(const size_t) _Py_FunctionAttributeOffsets[]; PyAPI_FUNC(int) _PyEval_CheckExceptStarTypeValid(PyThreadState *tstate, PyObject* right); PyAPI_FUNC(int) _PyEval_CheckExceptTypeValid(PyThreadState *tstate, PyObject* right); diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index b3936cf07f7050..14dc6b2173fbce 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -1188,7 +1188,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [SEND_GEN] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, [SETUP_ANNOTATIONS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [SET_ADD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [SET_FUNCTION_ATTRIBUTE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ESCAPES_FLAG }, + [SET_FUNCTION_ATTRIBUTE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, [SET_UPDATE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [STORE_ATTR] = { true, INSTR_FMT_IBC000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [STORE_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IXC000, HAS_EXIT_FLAG }, diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index bc9ac523131960..febffda26d509e 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -246,7 +246,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CHECK_IS_NOT_PY_CALLABLE_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG, [_CALL_KW_NON_PY] = HAS_ARG_FLAG | 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 | HAS_ESCAPES_FLAG, + [_SET_FUNCTION_ATTRIBUTE] = HAS_ARG_FLAG, [_RETURN_GENERATOR] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_BUILD_SLICE] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_CONVERT_VALUE] = HAS_ARG_FLAG | HAS_ERROR_FLAG, diff --git a/Python/bytecodes.c b/Python/bytecodes.c index b0c162a911ee3b..3356b3d3b83433 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -4380,34 +4380,11 @@ dummy_func( PyObject *attr = PyStackRef_AsPyObjectBorrow(attr_st); assert(PyFunction_Check(func)); - PyFunctionObject *func_obj = (PyFunctionObject *)func; - switch(oparg) { - case MAKE_FUNCTION_CLOSURE: - assert(func_obj->func_closure == NULL); - func_obj->func_closure = attr; - break; - case MAKE_FUNCTION_ANNOTATIONS: - assert(func_obj->func_annotations == NULL); - func_obj->func_annotations = attr; - break; - case MAKE_FUNCTION_KWDEFAULTS: - assert(PyDict_CheckExact(attr)); - assert(func_obj->func_kwdefaults == NULL); - func_obj->func_kwdefaults = attr; - break; - case MAKE_FUNCTION_DEFAULTS: - assert(PyTuple_CheckExact(attr)); - assert(func_obj->func_defaults == NULL); - func_obj->func_defaults = attr; - break; - case MAKE_FUNCTION_ANNOTATE: - assert(PyCallable_Check(attr)); - assert(func_obj->func_annotate == NULL); - func_obj->func_annotate = attr; - break; - default: - Py_UNREACHABLE(); - } + size_t offset = _Py_FunctionAttributeOffsets[oparg]; + assert(offset != 0); + PyObject **ptr = (PyObject **)(((char *)func) + offset); + assert(*ptr == NULL); + *ptr = attr; } inst(RETURN_GENERATOR, (-- res)) { diff --git a/Python/ceval.c b/Python/ceval.c index 2a5c16aa101985..7d69cd18bd3c8d 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -391,6 +391,13 @@ const _Py_SpecialMethod _Py_SpecialMethods[] = { } }; +const size_t _Py_FunctionAttributeOffsets[] = { + [MAKE_FUNCTION_CLOSURE] = offsetof(PyFunctionObject, func_closure), + [MAKE_FUNCTION_ANNOTATIONS] = offsetof(PyFunctionObject, func_annotations), + [MAKE_FUNCTION_KWDEFAULTS] = offsetof(PyFunctionObject, func_kwdefaults), + [MAKE_FUNCTION_DEFAULTS] = offsetof(PyFunctionObject, func_defaults), + [MAKE_FUNCTION_ANNOTATE] = offsetof(PyFunctionObject, func_annotate), +}; // PEP 634: Structural Pattern Matching diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 9b5cd521f28bbd..0d3590bd68cf6c 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -4981,34 +4981,11 @@ PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); PyObject *attr = PyStackRef_AsPyObjectBorrow(attr_st); assert(PyFunction_Check(func)); - PyFunctionObject *func_obj = (PyFunctionObject *)func; - switch(oparg) { - case MAKE_FUNCTION_CLOSURE: - assert(func_obj->func_closure == NULL); - func_obj->func_closure = attr; - break; - case MAKE_FUNCTION_ANNOTATIONS: - assert(func_obj->func_annotations == NULL); - func_obj->func_annotations = attr; - break; - case MAKE_FUNCTION_KWDEFAULTS: - assert(PyDict_CheckExact(attr)); - assert(func_obj->func_kwdefaults == NULL); - func_obj->func_kwdefaults = attr; - break; - case MAKE_FUNCTION_DEFAULTS: - assert(PyTuple_CheckExact(attr)); - assert(func_obj->func_defaults == NULL); - func_obj->func_defaults = attr; - break; - case MAKE_FUNCTION_ANNOTATE: - assert(PyCallable_Check(attr)); - assert(func_obj->func_annotate == NULL); - func_obj->func_annotate = attr; - break; - default: - Py_UNREACHABLE(); - } + size_t offset = _Py_FunctionAttributeOffsets[oparg]; + assert(offset != 0); + PyObject **ptr = (PyObject **)(((char *)func) + offset); + assert(*ptr == NULL); + *ptr = attr; stack_pointer[-2] = func_st; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index f768ce96d76f68..7ee07b4adb0de7 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -6757,34 +6757,11 @@ PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); PyObject *attr = PyStackRef_AsPyObjectBorrow(attr_st); assert(PyFunction_Check(func)); - PyFunctionObject *func_obj = (PyFunctionObject *)func; - switch(oparg) { - case MAKE_FUNCTION_CLOSURE: - assert(func_obj->func_closure == NULL); - func_obj->func_closure = attr; - break; - case MAKE_FUNCTION_ANNOTATIONS: - assert(func_obj->func_annotations == NULL); - func_obj->func_annotations = attr; - break; - case MAKE_FUNCTION_KWDEFAULTS: - assert(PyDict_CheckExact(attr)); - assert(func_obj->func_kwdefaults == NULL); - func_obj->func_kwdefaults = attr; - break; - case MAKE_FUNCTION_DEFAULTS: - assert(PyTuple_CheckExact(attr)); - assert(func_obj->func_defaults == NULL); - func_obj->func_defaults = attr; - break; - case MAKE_FUNCTION_ANNOTATE: - assert(PyCallable_Check(attr)); - assert(func_obj->func_annotate == NULL); - func_obj->func_annotate = attr; - break; - default: - Py_UNREACHABLE(); - } + size_t offset = _Py_FunctionAttributeOffsets[oparg]; + assert(offset != 0); + PyObject **ptr = (PyObject **)(((char *)func) + offset); + assert(*ptr == NULL); + *ptr = attr; stack_pointer[-2] = func_st; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index ff37ef58ae99a9..365181a30a9c27 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -557,17 +557,21 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "_PyTuple_FromStackRefSteal", "PyFunction_GET_CODE", "_PyErr_Occurred", + "PyCFunction_GET_FUNCTION", ) - def find_start_stmt(node: parser.InstDef, idx: int) -> lexer.Token: assert idx < len(node.block.tokens) while True: tkn = node.block.tokens[idx-1] if tkn.kind == "SEMI" or tkn.kind == "LBRACE" or tkn.kind == "RBRACE": - return node.block.tokens[idx] + break idx -= 1 assert idx > 0 + while node.block.tokens[idx].kind == "COMMENT": + idx += 1 + return node.block.tokens[idx] + def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, lexer.Token]: result: dict[lexer.Token, lexer.Token] = {} diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 5fee03c865e2dc..65b9af20a6c117 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -329,6 +329,10 @@ def _emit_block( self.emit(storage.as_comment()) self.out.start_line() line = tkn.line + #if tkn in escaping_calls: + # self.out.emit(f"/* ESCAPING CALL {escaping_calls[tkn].text} starting at {tkn.text} */\n") + # storage.flush(self.out) + # self._print_storage(storage) if tkn.kind == "LBRACE": self.out.emit(tkn) braces += 1 @@ -356,11 +360,6 @@ def _emit_block( self._print_storage(storage) reachable = False self.out.emit(tkn) - #elif tkn in escaping_calls: - #self.out.emit(f"/* ESCAPING CALL {escaping_calls[tkn].text} */\n") - #storage.flush(self.out) - #self._print_storage(storage) - #self.out.emit(tkn) elif tkn.kind == "IF": self.out.emit(tkn) if_reachable, rbrace, stack = self._emit_if(tkn_iter, uop, storage, inst) From 7de1e60826d03237ff4ca17318e435b7e8a1640c Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 30 Aug 2024 10:47:49 +0100 Subject: [PATCH 20/53] Spill stack contents on escaping calls --- Include/internal/pycore_opcode_metadata.h | 6 +- Include/internal/pycore_uop_metadata.h | 10 +- Python/bytecodes.c | 38 +- Python/ceval.c | 1 + Python/executor_cases.c.h | 349 +++++--- Python/generated_cases.c.h | 884 ++++++++++++--------- Python/optimizer_cases.c.h | 32 +- Tools/cases_generator/analyzer.py | 6 + Tools/cases_generator/generators_common.py | 7 +- 9 files changed, 798 insertions(+), 535 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 14dc6b2173fbce..47a7f1461941df 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -1130,7 +1130,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [LOAD_ATTR] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_ATTR_CLASS] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG }, [LOAD_ATTR_CLASS_WITH_METACLASS_CHECK] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG }, - [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG }, [LOAD_ATTR_INSTANCE_VALUE] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, [LOAD_ATTR_METHOD_LAZY_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, [LOAD_ATTR_METHOD_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG }, @@ -1138,7 +1138,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [LOAD_ATTR_MODULE] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, [LOAD_ATTR_NONDESCRIPTOR_NO_DICT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_EXIT_FLAG }, [LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, - [LOAD_ATTR_PROPERTY] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [LOAD_ATTR_PROPERTY] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, [LOAD_ATTR_SLOT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, [LOAD_ATTR_WITH_HINT] = { true, INSTR_FMT_IBC00000000, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, [LOAD_BUILD_CLASS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -1176,7 +1176,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [POP_TOP] = { true, INSTR_FMT_IX, HAS_PURE_FLAG }, [PUSH_EXC_INFO] = { true, INSTR_FMT_IX, 0 }, [PUSH_NULL] = { true, INSTR_FMT_IX, HAS_PURE_FLAG }, - [RAISE_VARARGS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [RAISE_VARARGS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG }, [RERAISE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [RESERVED] = { true, INSTR_FMT_IX, 0 }, [RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index febffda26d509e..b457e8e385fb02 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -156,7 +156,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_LOAD_ATTR_CLASS_0] = 0, [_LOAD_ATTR_CLASS_1] = 0, [_LOAD_ATTR_CLASS] = HAS_ARG_FLAG | HAS_OPARG_AND_1_FLAG, - [_LOAD_ATTR_PROPERTY_FRAME] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_LOAD_ATTR_PROPERTY_FRAME] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_GUARD_DORV_NO_DICT] = HAS_EXIT_FLAG, [_STORE_ATTR_INSTANCE_VALUE] = 0, [_STORE_ATTR_WITH_HINT] = HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, @@ -230,15 +230,15 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_EXIT_INIT_CHECK] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, [_CALL_BUILTIN_O] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_BUILTIN_FAST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_BUILTIN_FAST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, + [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, [_CALL_LEN] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CALL_ISINSTANCE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CALL_LIST_APPEND] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, [_CALL_METHOD_DESCRIPTOR_O] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG, [_CALL_METHOD_DESCRIPTOR_NOARGS] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG, [_PY_FRAME_KW] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CHECK_FUNCTION_VERSION_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG, [_CHECK_METHOD_VERSION_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG, diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 3356b3d3b83433..a48054b787d23b 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -914,24 +914,13 @@ dummy_func( tier1 inst(RAISE_VARARGS, (args[oparg] -- )) { PyObject *cause = NULL, *exc = NULL; - switch (oparg) { - case 2: - cause = PyStackRef_AsPyObjectSteal(args[1]); - _Py_FALLTHROUGH; - case 1: - exc = PyStackRef_AsPyObjectSteal(args[0]); - _Py_FALLTHROUGH; - case 0: - if (do_raise(tstate, exc, cause)) { - assert(oparg == 0); - monitor_reraise(tstate, frame, this_instr); - goto exception_unwind; - } - break; - default: - _PyErr_SetString(tstate, PyExc_SystemError, - "bad RAISE_VARARGS oparg"); - break; + assert(oparg < 3); + PyObject *cause = oparg == 2 ? PyStackRef_AsPyObjectSteal(args[1]) : NULL; + PyObject *exc = oparg > 0 ? PyStackRef_AsPyObjectSteal(args[0]) : NULL; + if (do_raise(tstate, exc, cause)) { + assert(oparg == 0); + monitor_reraise(tstate, frame, this_instr); + goto exception_unwind; } ERROR_IF(true, error); } @@ -3251,7 +3240,7 @@ dummy_func( args, total_args, NULL, frame ); // Manipulate stack directly since we leave using DISPATCH_INLINED(). - STACK_SHRINK(oparg + 2); + SYNC_SP(); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { @@ -4083,8 +4072,8 @@ dummy_func( args, positional_args, kwnames_o, frame ); PyStackRef_CLOSE(kwnames); - // Manipulate stack directly since we leave using DISPATCH_INLINED(). - STACK_SHRINK(oparg + 3); + // Sync stack explicitly since we leave using DISPATCH_INLINED(). + SYNC_SP(); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { @@ -4338,8 +4327,8 @@ dummy_func( _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(func_st), locals, nargs, callargs, kwargs, frame); - // Need to manually shrink the stack since we exit with DISPATCH_INLINED. - STACK_SHRINK(oparg + 3); + // Need to sync the stack since we exit with DISPATCH_INLINED. + SYNC_SP(); if (new_frame == NULL) { ERROR_NO_POP(); } @@ -4350,7 +4339,6 @@ dummy_func( result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); } DECREF_INPUTS(); - assert(PyStackRef_AsPyObjectBorrow(PEEK(2 + (oparg & 1))) == NULL); ERROR_IF(PyStackRef_IsNull(result), error); } @@ -4403,12 +4391,12 @@ dummy_func( gen->gi_frame_state = FRAME_CREATED; gen_frame->owner = FRAME_OWNED_BY_GENERATOR; _Py_LeaveRecursiveCallPy(tstate); - res = PyStackRef_FromPyObjectSteal((PyObject *)gen); _PyInterpreterFrame *prev = frame->previous; _PyThreadState_PopFrame(tstate, frame); frame = tstate->current_frame = prev; LOAD_IP(frame->return_offset); LOAD_SP(); + res = PyStackRef_FromPyObjectSteal((PyObject *)gen); LLTRACE_RESUME_FRAME(); } diff --git a/Python/ceval.c b/Python/ceval.c index 7d69cd18bd3c8d..a1c7dcb9100b28 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -246,6 +246,7 @@ maybe_lltrace_resume_frame(_PyInterpreterFrame *frame, _PyInterpreterFrame *skip lltrace = *python_lltrace - '0'; // TODO: Parse an int and all that } } + lltrace = 5; if (lltrace >= 5) { lltrace_resume_frame(frame); } diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 0d3590bd68cf6c..7d030968190d97 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -337,11 +337,15 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value)); PyStackRef_CLOSE(value); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-1] = res; + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -360,11 +364,15 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value)); PyStackRef_CLOSE(value); if (err < 0) JUMP_TO_ERROR(); res = err ? PyStackRef_True : PyStackRef_False; - stack_pointer[-1] = res; + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -469,11 +477,15 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value)); PyStackRef_CLOSE(value); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-1] = res; + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -749,6 +761,8 @@ * only the locals reference, so PyUnicode_Append knows * that the string is safe to mutate. */ + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); assert(Py_REFCNT(left_o) >= 2); _Py_DECREF_NO_DEALLOC(left_o); PyObject *temp = PyStackRef_AsPyObjectBorrow(*target_local); @@ -762,8 +776,6 @@ assert(next_instr->op.code == STORE_FAST); SKIP_OVER(1); #endif - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -775,13 +787,15 @@ container = stack_pointer[-2]; PyObject *container_o = PyStackRef_AsPyObjectBorrow(container); PyObject *sub_o = PyStackRef_AsPyObjectBorrow(sub); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyObject_GetItem(container_o, sub_o); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -794,6 +808,8 @@ stop = stack_pointer[-1]; start = stack_pointer[-2]; container = stack_pointer[-3]; + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); PyObject *res_o; @@ -810,8 +826,8 @@ PyStackRef_CLOSE(container); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-3] = res; - stack_pointer += -2; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -825,6 +841,8 @@ start = stack_pointer[-2]; container = stack_pointer[-3]; v = stack_pointer[-4]; + stack_pointer += -4; + assert(WITHIN_STACK_BOUNDS()); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); OPCODE_DEFERRED_INC(STORE_SLICE); @@ -839,8 +857,6 @@ PyStackRef_CLOSE(v); PyStackRef_CLOSE(container); if (err) JUMP_TO_ERROR(); - stack_pointer += -4; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -978,6 +994,8 @@ } STAT_INC(BINARY_SUBSCR, hit); PyObject *res_o; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); int rc = PyDict_GetItemRef(dict, sub, &res_o); if (rc == 0) { _PyErr_SetKeyError(sub); @@ -987,8 +1005,8 @@ if (rc <= 0) JUMP_TO_ERROR(); // not found or error res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1064,12 +1082,12 @@ oparg = CURRENT_OPARG(); v = stack_pointer[-1]; set = stack_pointer[-2 - (oparg-1)]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = PySet_Add(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(v)); PyStackRef_CLOSE(v); if (err) JUMP_TO_ERROR(); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1081,13 +1099,13 @@ container = stack_pointer[-2]; v = stack_pointer[-3]; /* container[sub] = v */ + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v)); PyStackRef_CLOSE(v); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); if (err) JUMP_TO_ERROR(); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1144,13 +1162,13 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(STORE_SUBSCR, hit); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); int err = _PyDict_SetItem_Take2((PyDictObject *)dict, PyStackRef_AsPyObjectSteal(sub), PyStackRef_AsPyObjectSteal(value)); PyStackRef_CLOSE(dict_st); if (err) JUMP_TO_ERROR(); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1160,13 +1178,13 @@ sub = stack_pointer[-1]; container = stack_pointer[-2]; /* del container[sub] */ + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub)); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); if (err) JUMP_TO_ERROR(); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1243,6 +1261,8 @@ getter = type->tp_as_async->am_aiter; } if (getter == NULL) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyErr_Format(tstate, PyExc_TypeError, "'async for' requires an object with " "__aiter__ method, got %.100s", @@ -1255,6 +1275,8 @@ if (iter_o == NULL) JUMP_TO_ERROR(); if (Py_TYPE(iter_o)->tp_as_async == NULL || Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyErr_Format(tstate, PyExc_TypeError, "'async for' received an object from __aiter__ " "that does not implement __anext__: %.100s", @@ -1287,11 +1309,15 @@ _PyStackRef iter; oparg = CURRENT_OPARG(); iterable = stack_pointer[-1]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg); PyStackRef_CLOSE(iterable); if (iter_o == NULL) JUMP_TO_ERROR(); iter = PyStackRef_FromPyObjectSteal(iter_o); - stack_pointer[-1] = iter; + stack_pointer[0] = iter; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1338,12 +1364,12 @@ assert(frame != &entry_frame); #endif frame->instr_ptr++; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); tstate->exc_info = gen->gi_exc_state.previous_item; gen->gi_exc_state.previous_item = NULL; @@ -1375,11 +1401,11 @@ _PyStackRef exc_value; exc_value = stack_pointer[-1]; _PyErr_StackItem *exc_info = tstate->exc_info; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); Py_XSETREF(exc_info->exc_value, PyStackRef_Is(exc_value, PyStackRef_None) ? NULL : PyStackRef_AsPyObjectSteal(exc_value)); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1427,21 +1453,25 @@ PyObject *ns = LOCALS(); int err; if (ns == NULL) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when storing %R", name); PyStackRef_CLOSE(v); if (true) JUMP_TO_ERROR(); } if (PyDict_CheckExact(ns)) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); } else { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); } PyStackRef_CLOSE(v); if (err) JUMP_TO_ERROR(); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1473,10 +1503,12 @@ seq = stack_pointer[-1]; output = &stack_pointer[-1]; _PyStackRef *top = output + oparg; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top); PyStackRef_CLOSE(seq); if (res == 0) JUMP_TO_ERROR(); - stack_pointer += -1 + oparg; + stack_pointer += oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1567,10 +1599,12 @@ seq = stack_pointer[-1]; right = &stack_pointer[(oparg & 0xFF)]; _PyStackRef *top = right + (oparg >> 8); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top); PyStackRef_CLOSE(seq); if (res == 0) JUMP_TO_ERROR(); - stack_pointer += (oparg & 0xFF) + (oparg >> 8); + stack_pointer += 1 + (oparg & 0xFF) + (oparg >> 8); assert(WITHIN_STACK_BOUNDS()); break; } @@ -1582,13 +1616,13 @@ owner = stack_pointer[-1]; v = stack_pointer[-2]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner), name, PyStackRef_AsPyObjectBorrow(v)); PyStackRef_CLOSE(v); PyStackRef_CLOSE(owner); if (err) JUMP_TO_ERROR(); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1597,11 +1631,11 @@ oparg = CURRENT_OPARG(); owner = stack_pointer[-1]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); PyStackRef_CLOSE(owner); if (err) JUMP_TO_ERROR(); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1610,11 +1644,11 @@ oparg = CURRENT_OPARG(); v = stack_pointer[-1]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); PyStackRef_CLOSE(v); if (err) JUMP_TO_ERROR(); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1808,6 +1842,8 @@ assert(class_dict); assert(oparg >= 0 && oparg < _PyFrame_GetCode(frame)->co_nlocalsplus); name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = PyMapping_GetOptionalItem(class_dict, name, &value_o); if (err < 0) { JUMP_TO_ERROR(); @@ -1822,7 +1858,9 @@ } PyStackRef_CLOSE(class_dict_st); value = PyStackRef_FromPyObjectSteal(value_o); - stack_pointer[-1] = value; + stack_pointer[0] = value; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1847,9 +1885,9 @@ oparg = CURRENT_OPARG(); v = stack_pointer[-1]; PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); - PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v)); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v)); break; } @@ -1929,6 +1967,8 @@ list_st = stack_pointer[-2 - (oparg-1)]; PyObject *list = PyStackRef_AsPyObjectBorrow(list_st); PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable); if (none_val == NULL) { int matches = _PyErr_ExceptionMatches(tstate, PyExc_TypeError); @@ -1945,8 +1985,6 @@ } assert(Py_IsNone(none_val)); PyStackRef_CLOSE(iterable_st); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1956,12 +1994,12 @@ oparg = CURRENT_OPARG(); iterable = stack_pointer[-1]; set = stack_pointer[-2 - (oparg-1)]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(iterable)); PyStackRef_CLOSE(iterable); if (err < 0) JUMP_TO_ERROR(); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1970,6 +2008,8 @@ _PyStackRef set; oparg = CURRENT_OPARG(); values = &stack_pointer[-oparg]; + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); PyObject *set_o = PySet_New(NULL); if (set_o == NULL) { for (int _i = oparg; --_i >= 0;) { @@ -1989,8 +2029,8 @@ if (true) JUMP_TO_ERROR(); } set = PyStackRef_FromPyObjectSteal(set_o); - stack_pointer[-oparg] = set; - stack_pointer += 1 - oparg; + stack_pointer[0] = set; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -2007,6 +2047,8 @@ } if (true) JUMP_TO_ERROR(); } + stack_pointer += -oparg*2; + assert(WITHIN_STACK_BOUNDS()); PyObject *map_o = _PyDict_FromItems( values_o, 2, values_o+1, 2, @@ -2017,8 +2059,8 @@ } if (map_o == NULL) JUMP_TO_ERROR(); map = PyStackRef_FromPyObjectSteal(map_o); - stack_pointer[-oparg*2] = map; - stack_pointer += 1 - oparg*2; + stack_pointer[0] = map; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -2055,6 +2097,8 @@ dict = stack_pointer[-2 - (oparg - 1)]; PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = PyDict_Update(dict_o, update_o); if (err < 0) { int matches = _PyErr_ExceptionMatches(tstate, PyExc_AttributeError); @@ -2067,8 +2111,6 @@ if (true) JUMP_TO_ERROR(); } PyStackRef_CLOSE(update); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -2083,6 +2125,8 @@ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = _PyDict_MergeEx(dict_o, update_o, 2); if (err < 0) { _PyEval_FormatKwargsError(tstate, callable_o, update_o); @@ -2090,8 +2134,6 @@ if (true) JUMP_TO_ERROR(); } PyStackRef_CLOSE(update); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -2107,14 +2149,14 @@ assert(PyDict_CheckExact(dict)); /* dict[key] = value */ // Do not DECREF INPUTS because the function steals the references + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); int err = _PyDict_SetItem_Take2( (PyDictObject *)dict, PyStackRef_AsPyObjectSteal(key), PyStackRef_AsPyObjectSteal(value) ); if (err != 0) JUMP_TO_ERROR(); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -2143,14 +2185,16 @@ } STAT_INC(LOAD_SUPER_ATTR, hit); PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL); PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); PyStackRef_CLOSE(self_st); if (attr == NULL) JUMP_TO_ERROR(); attr_st = PyStackRef_FromPyObjectSteal(attr); - stack_pointer[-3] = attr_st; - stack_pointer += -2; + stack_pointer[0] = attr_st; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -2181,6 +2225,8 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); PyTypeObject *cls = (PyTypeObject *)class; int method_found = 0; + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); PyObject *attr_o = _PySuper_Lookup(cls, self, name, Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? &method_found : NULL); PyStackRef_CLOSE(global_super_st); @@ -2196,9 +2242,9 @@ self_or_null = PyStackRef_NULL; } attr = PyStackRef_FromPyObjectSteal(attr_o); - stack_pointer[-3] = attr; - stack_pointer[-2] = self_or_null; - stack_pointer += -1; + stack_pointer[0] = attr; + stack_pointer[1] = self_or_null; + stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); break; } @@ -2214,6 +2260,8 @@ if (oparg & 1) { /* Designed to work in tandem with CALL, pushes two values. */ attr_o = NULL; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int is_meth = _PyObject_GetMethod(PyStackRef_AsPyObjectBorrow(owner), name, &attr_o); if (is_meth) { /* We can bypass temporary bound method object. @@ -2237,6 +2285,8 @@ } else { /* Classic, pushes one value. */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); PyStackRef_CLOSE(owner); if (attr_o == NULL) JUMP_TO_ERROR(); @@ -2244,9 +2294,9 @@ self_or_null = PyStackRef_NULL; } attr = PyStackRef_FromPyObjectSteal(attr_o); - stack_pointer[-1] = attr; - if (oparg & 1) stack_pointer[0] = self_or_null; - stack_pointer += (oparg & 1); + stack_pointer[0] = attr; + if (oparg & 1) stack_pointer[1] = self_or_null; + stack_pointer += 1 + (oparg & 1); assert(WITHIN_STACK_BOUNDS()); break; } @@ -2644,6 +2694,8 @@ JUMP_TO_JUMP_TARGET(); } /* Ensure dict is GC tracked if it needs to be */ + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(PyStackRef_AsPyObjectBorrow(value))) { _PyObject_GC_TRACK(dict); } @@ -2657,8 +2709,6 @@ Py_XDECREF(old_value); STAT_INC(STORE_ATTR, hit); PyStackRef_CLOSE(owner); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -2690,6 +2740,8 @@ PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); assert((oparg >> 5) <= Py_GE); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); @@ -2703,8 +2755,8 @@ else { res = PyStackRef_FromPyObjectSteal(res_o); } - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -2824,13 +2876,15 @@ left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); int res = PySequence_Contains(right_o, left_o); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res < 0) JUMP_TO_ERROR(); b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; - stack_pointer[-2] = b; - stack_pointer += -1; + stack_pointer[0] = b; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -2850,13 +2904,15 @@ } STAT_INC(CONTAINS_OP, hit); // Note: both set and frozenset use the same seq_contains method! + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); int res = _PySet_Contains((PySetObject *)right_o, left_o); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res < 0) JUMP_TO_ERROR(); b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; - stack_pointer[-2] = b; - stack_pointer += -1; + stack_pointer[0] = b; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -2875,13 +2931,15 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(CONTAINS_OP, hit); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); int res = PyDict_Contains(right_o, left_o); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res < 0) JUMP_TO_ERROR(); b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; - stack_pointer[-2] = b; - stack_pointer += -1; + stack_pointer[0] = b; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -2895,6 +2953,8 @@ exc_value_st = stack_pointer[-2]; PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st); PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type); if (err < 0) { PyStackRef_CLOSE(exc_value_st); @@ -2915,8 +2975,10 @@ } rest = PyStackRef_FromPyObjectSteal(rest_o); match = PyStackRef_FromPyObjectSteal(match_o); - stack_pointer[-2] = rest; - stack_pointer[-1] = match; + stack_pointer[0] = rest; + stack_pointer[1] = match; + stack_pointer += 2; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -2929,6 +2991,8 @@ PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); assert(PyExceptionInstance_Check(left_o)); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = _PyEval_CheckExceptTypeValid(tstate, right_o); if (err < 0) { PyStackRef_CLOSE(right); @@ -2937,7 +3001,9 @@ int res = PyErr_GivenExceptionMatches(left_o, right_o); PyStackRef_CLOSE(right); b = res ? PyStackRef_True : PyStackRef_False; - stack_pointer[-1] = b; + stack_pointer[0] = b; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -2949,6 +3015,8 @@ fromlist = stack_pointer[-1]; level = stack_pointer[-2]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = _PyEval_ImportName(tstate, frame, name, PyStackRef_AsPyObjectBorrow(fromlist), PyStackRef_AsPyObjectBorrow(level)); @@ -2956,8 +3024,8 @@ PyStackRef_CLOSE(fromlist); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -3024,6 +3092,8 @@ // Pop TOS and TOS1. Set TOS to a tuple of attributes on success, or // None on failure. assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names))); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); PyObject *attrs_o = _PyEval_MatchClass(tstate, PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(type), oparg, @@ -3040,8 +3110,8 @@ // Error! attrs = PyStackRef_None; // Failure! } - stack_pointer[-3] = attrs; - stack_pointer += -2; + stack_pointer[0] = attrs; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -3092,10 +3162,14 @@ _PyStackRef iter; iterable = stack_pointer[-1]; /* before: [obj]; after [getiter(obj)] */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable))); PyStackRef_CLOSE(iterable); if (PyStackRef_IsNull(iter)) JUMP_TO_ERROR(); - stack_pointer[-1] = iter; + stack_pointer[0] = iter; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -3110,6 +3184,8 @@ if (!(_PyFrame_GetCode(frame)->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) { /* and it is used in a 'yield from' expression of a regular generator. */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyErr_SetString(tstate, PyExc_TypeError, "cannot 'yield from' a coroutine object " "in a non-coroutine generator"); @@ -3122,11 +3198,15 @@ } else { /* `iterable` is not a generator. */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); if (PyStackRef_IsNull(iter)) { JUMP_TO_ERROR(); } PyStackRef_CLOSE(iterable); + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); } stack_pointer[-1] = iter; break; @@ -3347,19 +3427,25 @@ PyObject *owner_o = PyStackRef_AsPyObjectSteal(owner); PyObject *name = _Py_SpecialMethods[oparg].name; PyObject *self_or_null_o; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); attr = PyStackRef_FromPyObjectSteal(_PyObject_LookupSpecialMethod(owner_o, name, &self_or_null_o)); if (PyStackRef_IsNull(attr)) { if (!_PyErr_Occurred(tstate)) { + stack_pointer[0] = attr; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); _PyErr_Format(tstate, PyExc_TypeError, _Py_SpecialMethods[oparg].error, - Py_TYPE(owner_o)->tp_name); + Py_TYPE(owner_o)->tp_name);stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } } if (PyStackRef_IsNull(attr)) JUMP_TO_ERROR(); self_or_null = PyStackRef_FromPyObjectSteal(self_or_null_o); - stack_pointer[-1] = attr; - stack_pointer[0] = self_or_null; - stack_pointer += 1; + stack_pointer[0] = attr; + stack_pointer[1] = self_or_null; + stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); break; } @@ -3615,14 +3701,14 @@ 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)); + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, total_args, NULL, frame ); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (new_frame == NULL) { JUMP_TO_ERROR(); } @@ -3743,6 +3829,8 @@ } if (true) JUMP_TO_ERROR(); } + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, total_args | PY_VECTORCALL_ARGUMENTS_OFFSET, @@ -3755,8 +3843,8 @@ } if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4061,11 +4149,13 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(CALL, hit); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o)); PyStackRef_CLOSE(arg); if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); - stack_pointer[-3] = res; - stack_pointer += -2; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4091,11 +4181,13 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(CALL, hit); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o)); PyStackRef_CLOSE(arg); if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); - stack_pointer[-3] = res; - stack_pointer += -2; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4134,14 +4226,18 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(CALL, hit); + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); self = PyStackRef_FromPyObjectSteal(_PyType_NewManagedObject(tp)); if (PyStackRef_IsNull(self)) { JUMP_TO_ERROR(); } PyStackRef_CLOSE(callable); init = PyStackRef_FromPyObjectNew(init_func); - stack_pointer[-2 - oparg] = self; - stack_pointer[-1 - oparg] = init; + stack_pointer[0] = self; + stack_pointer[1] = init; + stack_pointer += 2 + oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -4154,6 +4250,8 @@ args = &stack_pointer[-oparg]; init = stack_pointer[-1 - oparg]; self = stack_pointer[-2 - oparg]; + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame); assert(_PyCode_CODE((PyCodeObject *)shim->f_executable)[0].op.code == EXIT_INIT_CHECK); @@ -4163,8 +4261,6 @@ args[-1] = self; init_frame = _PyEvalFramePushAndInit( tstate, init_func, NULL, args-1, oparg+1, NULL, shim); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (init_frame == NULL) { _PyEval_FrameClearAndPop(tstate, shim); JUMP_TO_ERROR(); @@ -4185,6 +4281,8 @@ should_be_none = stack_pointer[-1]; assert(STACK_LEVEL() == 2); if (!PyStackRef_Is(should_be_none, PyStackRef_None)) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); PyErr_Format(PyExc_TypeError, "__init__() should return None, not '%.200s'", Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name); @@ -4280,6 +4378,8 @@ STAT_INC(CALL, hit); PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o); _PyStackRef arg = args[0]; + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); _Py_EnterRecursiveCallTstateUnchecked(tstate); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg)); _Py_LeaveRecursiveCallTstate(tstate); @@ -4288,8 +4388,8 @@ PyStackRef_CLOSE(callable); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4431,6 +4531,8 @@ STAT_INC(CALL, hit); _PyStackRef arg_stackref = args[0]; PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref); + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); Py_ssize_t len_i = PyObject_Length(arg); if (len_i < 0) { JUMP_TO_ERROR(); @@ -4443,8 +4545,8 @@ PyStackRef_CLOSE(callable); PyStackRef_CLOSE(arg_stackref); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4477,6 +4579,8 @@ STAT_INC(CALL, hit); _PyStackRef cls_stackref = args[1]; _PyStackRef inst_stackref = args[0]; + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref)); if (retval < 0) { JUMP_TO_ERROR(); @@ -4486,8 +4590,8 @@ PyStackRef_CLOSE(inst_stackref); PyStackRef_CLOSE(cls_stackref); PyStackRef_CLOSE(callable); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4572,6 +4676,8 @@ } STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); _Py_EnterRecursiveCallTstateUnchecked(tstate); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyStackRef_AsPyObjectBorrow(self_stackref), @@ -4583,8 +4689,8 @@ PyStackRef_CLOSE(callable); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4692,6 +4798,8 @@ } STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); _Py_EnterRecursiveCallTstateUnchecked(tstate); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL); _Py_LeaveRecursiveCallTstate(tstate); @@ -4700,8 +4808,8 @@ PyStackRef_CLOSE(callable); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4794,6 +4902,8 @@ 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)); + stack_pointer += -3 - oparg; + assert(WITHIN_STACK_BOUNDS()); new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, positional_args, kwnames_o, frame @@ -4801,8 +4911,6 @@ PyStackRef_CLOSE(kwnames); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (new_frame == NULL) { JUMP_TO_ERROR(); } @@ -4931,6 +5039,8 @@ } PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); + stack_pointer += -3 - oparg; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET, @@ -4944,8 +5054,8 @@ } if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-3 - oparg] = res; - stack_pointer += -2 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4959,6 +5069,8 @@ _PyStackRef func; codeobj_st = stack_pointer[-1]; PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); PyFunctionObject *func_obj = (PyFunctionObject *) PyFunction_New(codeobj, GLOBALS()); PyStackRef_CLOSE(codeobj_st); @@ -4968,7 +5080,9 @@ _PyFunction_SetVersion( func_obj, ((PyCodeObject *)codeobj)->co_version); func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj); - stack_pointer[-1] = func; + stack_pointer[0] = func; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -5009,12 +5123,12 @@ gen->gi_frame_state = FRAME_CREATED; gen_frame->owner = FRAME_OWNED_BY_GENERATOR; _Py_LeaveRecursiveCallPy(tstate); - res = PyStackRef_FromPyObjectSteal((PyObject *)gen); _PyInterpreterFrame *prev = frame->previous; _PyThreadState_PopFrame(tstate, frame); frame = tstate->current_frame = prev; LOAD_IP(frame->return_offset); LOAD_SP(); + res = PyStackRef_FromPyObjectSteal((PyObject *)gen); LLTRACE_RESUME_FRAME(); stack_pointer[0] = res; stack_pointer += 1; @@ -5070,14 +5184,19 @@ /* If value is a unicode object, then we know the result * of format(value) is value itself. */ if (!PyUnicode_CheckExact(value_o)) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); res = PyStackRef_FromPyObjectSteal(PyObject_Format(value_o, NULL)); PyStackRef_CLOSE(value); if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); } else { - res = value; + res = value;stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } - stack_pointer[-1] = res; + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -5087,13 +5206,15 @@ _PyStackRef res; fmt_spec = stack_pointer[-1]; value = stack_pointer[-2]; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec)); PyStackRef_CLOSE(value); PyStackRef_CLOSE(fmt_spec); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 7ee07b4adb0de7..1a0870fd81fba4 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -202,13 +202,15 @@ * only the locals reference, so PyUnicode_Append knows * that the string is safe to mutate. */ + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); assert(Py_REFCNT(left_o) >= 2); _Py_DECREF_NO_DEALLOC(left_o); PyObject *temp = PyStackRef_AsPyObjectBorrow(*target_local); PyUnicode_Append(&temp, right_o); *target_local = PyStackRef_FromPyObjectSteal(temp); _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); - if (PyStackRef_IsNull(*target_local)) goto pop_2_error; + if (PyStackRef_IsNull(*target_local)) goto error; #if TIER_ONE // The STORE_FAST is already done. This is done here in tier one, // and during trace projection in tier two: @@ -216,8 +218,6 @@ SKIP_OVER(1); #endif } - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -374,6 +374,8 @@ stop = stack_pointer[-1]; start = stack_pointer[-2]; container = stack_pointer[-3]; + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); PyObject *res_o; @@ -388,10 +390,10 @@ Py_DECREF(slice); } PyStackRef_CLOSE(container); - if (res_o == NULL) goto pop_3_error; + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-3] = res; - stack_pointer += -2; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -426,14 +428,16 @@ { PyObject *container_o = PyStackRef_AsPyObjectBorrow(container); PyObject *sub_o = PyStackRef_AsPyObjectBorrow(sub); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyObject_GetItem(container_o, sub_o); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); - if (res_o == NULL) goto pop_2_error; + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -454,17 +458,19 @@ DEOPT_IF(!PyDict_CheckExact(dict), BINARY_SUBSCR); STAT_INC(BINARY_SUBSCR, hit); PyObject *res_o; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); int rc = PyDict_GetItemRef(dict, sub, &res_o); if (rc == 0) { _PyErr_SetKeyError(sub); } PyStackRef_CLOSE(dict_st); PyStackRef_CLOSE(sub_st); - if (rc <= 0) goto pop_2_error; + if (rc <= 0) goto error; // not found or error res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -663,6 +669,8 @@ goto error; } } + stack_pointer += -oparg*2; + assert(WITHIN_STACK_BOUNDS()); PyObject *map_o = _PyDict_FromItems( values_o, 2, values_o+1, 2, @@ -671,14 +679,10 @@ for (int _i = oparg*2; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } - if (map_o == NULL) { - stack_pointer += -oparg*2; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (map_o == NULL) goto error; map = PyStackRef_FromPyObjectSteal(map_o); - stack_pointer[-oparg*2] = map; - stack_pointer += 1 - oparg*2; + stack_pointer[0] = map; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -690,16 +694,14 @@ _PyStackRef *values; _PyStackRef set; values = &stack_pointer[-oparg]; + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); PyObject *set_o = PySet_New(NULL); if (set_o == NULL) { for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } - if (true) { - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (true) goto error; } int err = 0; for (int i = 0; i < oparg; i++) { @@ -710,15 +712,11 @@ } if (err != 0) { Py_DECREF(set_o); - if (true) { - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (true) goto error; } set = PyStackRef_FromPyObjectSteal(set_o); - stack_pointer[-oparg] = set; - stack_pointer += 1 - oparg; + stack_pointer[0] = set; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -885,12 +883,13 @@ { 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)); + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, total_args, NULL, frame ); // Manipulate stack directly since we leave using DISPATCH_INLINED(). - STACK_SHRINK(oparg + 2); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { @@ -912,6 +911,8 @@ goto error; } } + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, total_args | PY_VECTORCALL_ARGUMENTS_OFFSET, @@ -939,11 +940,7 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - if (res_o == NULL) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -951,17 +948,17 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_HandlePending(tstate); - if (err != 0) { - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (err != 0) goto error; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -1000,6 +997,8 @@ PyCodeObject *code = (PyCodeObject *)init_func->func_code; DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize + _Py_InitCleanup.co_framesize), CALL); STAT_INC(CALL, hit); + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); self = PyStackRef_FromPyObjectSteal(_PyType_NewManagedObject(tp)); if (PyStackRef_IsNull(self)) { goto error; @@ -1018,8 +1017,6 @@ args[-1] = self; init_frame = _PyEvalFramePushAndInit( tstate, init_func, NULL, args-1, oparg+1, NULL, shim); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (init_frame == NULL) { _PyEval_FrameClearAndPop(tstate, shim); goto error; @@ -1209,14 +1206,14 @@ 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)); + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, total_args, NULL, frame ); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (new_frame == NULL) { goto error; } @@ -1305,13 +1302,13 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_HandlePending(tstate); - if (err != 0) { - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (err != 0) goto error; + stack_pointer += 1 + oparg; + assert(WITHIN_STACK_BOUNDS()); } } stack_pointer[-2 - oparg] = res; @@ -1384,13 +1381,13 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_HandlePending(tstate); - if (err != 0) { - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (err != 0) goto error; + stack_pointer += 1 + oparg; + assert(WITHIN_STACK_BOUNDS()); } } stack_pointer[-2 - oparg] = res; @@ -1462,13 +1459,13 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_HandlePending(tstate); - if (err != 0) { - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (err != 0) goto error; + stack_pointer += 1 + oparg; + assert(WITHIN_STACK_BOUNDS()); } } stack_pointer[-2 - oparg] = res; @@ -1508,17 +1505,15 @@ STAT_INC(CALL, hit); PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o); _PyStackRef arg = args[0]; + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); _Py_EnterRecursiveCallTstateUnchecked(tstate); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg)); _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(arg); PyStackRef_CLOSE(callable); - if (res_o == NULL) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -1526,17 +1521,17 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_HandlePending(tstate); - if (err != 0) { - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (err != 0) goto error; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -1568,19 +1563,24 @@ if (err < 0) { goto error; } + stack_pointer += -3 - (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); PyObject *tuple = PySequence_Tuple(callargs); if (tuple == NULL) { goto error; } PyStackRef_CLOSE(callargs_st); callargs_st = PyStackRef_FromPyObjectSteal(tuple); - callargs = tuple; + callargs = tuple;stack_pointer += 3 + (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); } assert(PyTuple_CheckExact(callargs)); EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_FUNCTION_EX, func); if (opcode == INSTRUMENTED_CALL_FUNCTION_EX) { PyObject *arg = PyTuple_GET_SIZE(callargs) > 0 ? PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING; + stack_pointer += -3 - (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, func, arg); @@ -1590,18 +1590,25 @@ result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); if (!PyFunction_Check(func) && !PyMethod_Check(func)) { if (PyStackRef_IsNull(result)) { + stack_pointer[0] = result; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, func, arg); } else { + stack_pointer[0] = result; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, func, arg); if (err < 0) { PyStackRef_CLEAR(result); } - } + }stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } } else { @@ -1612,11 +1619,12 @@ Py_ssize_t nargs = PyTuple_GET_SIZE(callargs); int code_flags = ((PyCodeObject *)PyFunction_GET_CODE(func))->co_flags; PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func)); + stack_pointer += -3 - (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(func_st), locals, nargs, callargs, kwargs, frame); - // Need to manually shrink the stack since we exit with DISPATCH_INLINED. - STACK_SHRINK(oparg + 3); + // Need to sync the stack since we exit with DISPATCH_INLINED. if (new_frame == NULL) { goto error; } @@ -1624,35 +1632,31 @@ frame->return_offset = 1; DISPATCH_INLINED(new_frame); } + stack_pointer += -3 - (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); } PyStackRef_CLOSE(func_st); PyStackRef_CLOSE(callargs_st); PyStackRef_XCLOSE(kwargs_st); - assert(PyStackRef_AsPyObjectBorrow(PEEK(2 + (oparg & 1))) == NULL); - if (PyStackRef_IsNull(result)) { - stack_pointer[-3 - (oparg & 1)] = result; - stack_pointer += -2 - (oparg & 1); - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (PyStackRef_IsNull(result)) goto error; } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + stack_pointer[0] = result; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_HandlePending(tstate); - if (err != 0) { - stack_pointer[-3 - (oparg & 1)] = result; - stack_pointer += -2 - (oparg & 1); - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (err != 0) goto error; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } } - stack_pointer[-3 - (oparg & 1)] = result; - stack_pointer += -2 - (oparg & 1); + stack_pointer[0] = result; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -1723,6 +1727,8 @@ STAT_INC(CALL, hit); _PyStackRef cls_stackref = args[1]; _PyStackRef inst_stackref = args[0]; + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref)); if (retval < 0) { goto error; @@ -1732,8 +1738,8 @@ PyStackRef_CLOSE(inst_stackref); PyStackRef_CLOSE(cls_stackref); PyStackRef_CLOSE(callable); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -1799,13 +1805,14 @@ { 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)); + stack_pointer += -3 - oparg; + assert(WITHIN_STACK_BOUNDS()); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, positional_args, kwnames_o, frame ); PyStackRef_CLOSE(kwnames); - // Manipulate stack directly since we leave using DISPATCH_INLINED(). - STACK_SHRINK(oparg + 3); + // Sync stack explicitly since we leave using DISPATCH_INLINED(). // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { @@ -1830,6 +1837,8 @@ goto error; } } + stack_pointer += -3 - oparg; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET, @@ -1858,15 +1867,11 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - if (res_o == NULL) { - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } - stack_pointer[-3 - oparg] = res; - stack_pointer += -2 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -1934,6 +1939,8 @@ 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)); + stack_pointer += -3 - oparg; + assert(WITHIN_STACK_BOUNDS()); new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, positional_args, kwnames_o, frame @@ -1941,8 +1948,6 @@ PyStackRef_CLOSE(kwnames); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (new_frame == NULL) { goto error; } @@ -2024,6 +2029,8 @@ } PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); + stack_pointer += -3 - oparg; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET, @@ -2035,11 +2042,7 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - if (res_o == NULL) { - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -2047,17 +2050,17 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_HandlePending(tstate); - if (err != 0) { - stack_pointer[-3 - oparg] = res; - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (err != 0) goto error; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } } - stack_pointer[-3 - oparg] = res; - stack_pointer += -2 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -2104,6 +2107,8 @@ 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)); + stack_pointer += -3 - oparg; + assert(WITHIN_STACK_BOUNDS()); new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, positional_args, kwnames_o, frame @@ -2111,8 +2116,6 @@ PyStackRef_CLOSE(kwnames); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (new_frame == NULL) { goto error; } @@ -2170,6 +2173,8 @@ STAT_INC(CALL, hit); _PyStackRef arg_stackref = args[0]; PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref); + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); Py_ssize_t len_i = PyObject_Length(arg); if (len_i < 0) { goto error; @@ -2182,8 +2187,8 @@ PyStackRef_CLOSE(callable); PyStackRef_CLOSE(arg_stackref); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -2290,13 +2295,13 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_HandlePending(tstate); - if (err != 0) { - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (err != 0) goto error; + stack_pointer += 1 + oparg; + assert(WITHIN_STACK_BOUNDS()); } } stack_pointer[-2 - oparg] = res; @@ -2371,13 +2376,13 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_HandlePending(tstate); - if (err != 0) { - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (err != 0) goto error; + stack_pointer += 1 + oparg; + assert(WITHIN_STACK_BOUNDS()); } } stack_pointer[-2 - oparg] = res; @@ -2421,17 +2426,15 @@ DEOPT_IF(tstate->c_recursion_remaining <= 0, CALL); STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); _Py_EnterRecursiveCallTstateUnchecked(tstate); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL); _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); PyStackRef_CLOSE(callable); - if (res_o == NULL) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -2439,17 +2442,17 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_HandlePending(tstate); - if (err != 0) { - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (err != 0) goto error; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -2489,6 +2492,8 @@ method->d_common.d_type), CALL); STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); _Py_EnterRecursiveCallTstateUnchecked(tstate); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyStackRef_AsPyObjectBorrow(self_stackref), @@ -2498,11 +2503,7 @@ PyStackRef_CLOSE(self_stackref); PyStackRef_CLOSE(arg_stackref); PyStackRef_CLOSE(callable); - if (res_o == NULL) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -2510,17 +2511,17 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_HandlePending(tstate); - if (err != 0) { - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (err != 0) goto error; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -2571,6 +2572,8 @@ goto error; } } + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, total_args | PY_VECTORCALL_ARGUMENTS_OFFSET, @@ -2581,11 +2584,7 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - if (res_o == NULL) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -2593,17 +2592,17 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_HandlePending(tstate); - if (err != 0) { - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (err != 0) goto error; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -2728,14 +2727,14 @@ 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)); + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, total_args, NULL, frame ); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (new_frame == NULL) { goto error; } @@ -2788,21 +2787,28 @@ DEOPT_IF(!PyStackRef_IsNull(null), CALL); DEOPT_IF(callable_o != (PyObject *)&PyUnicode_Type, CALL); STAT_INC(CALL, hit); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o)); PyStackRef_CLOSE(arg); - if (PyStackRef_IsNull(res)) goto pop_3_error; + if (PyStackRef_IsNull(res)) goto error; } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_HandlePending(tstate); - if (err != 0) goto pop_2_error; + if (err != 0) goto error; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } } - stack_pointer[-3] = res; - stack_pointer += -2; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -2829,21 +2835,28 @@ DEOPT_IF(!PyStackRef_IsNull(null), CALL); DEOPT_IF(callable_o != (PyObject *)&PyTuple_Type, CALL); STAT_INC(CALL, hit); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o)); PyStackRef_CLOSE(arg); - if (PyStackRef_IsNull(res)) goto pop_3_error; + if (PyStackRef_IsNull(res)) goto error; } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_HandlePending(tstate); - if (err != 0) goto pop_2_error; + if (err != 0) goto error; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } } - stack_pointer[-3] = res; - stack_pointer += -2; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -2888,11 +2901,13 @@ exc_value_st = stack_pointer[-2]; PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st); PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type); if (err < 0) { PyStackRef_CLOSE(exc_value_st); PyStackRef_CLOSE(match_type_st); - if (true) goto pop_2_error; + if (true) goto error; } PyObject *match_o = NULL; PyObject *rest_o = NULL; @@ -2900,16 +2915,18 @@ &match_o, &rest_o); PyStackRef_CLOSE(exc_value_st); PyStackRef_CLOSE(match_type_st); - if (res < 0) goto pop_2_error; + if (res < 0) goto error; assert((match_o == NULL) == (rest_o == NULL)); - if (match_o == NULL) goto pop_2_error; + if (match_o == NULL) goto error; if (!Py_IsNone(match_o)) { PyErr_SetHandledException(match_o); } rest = PyStackRef_FromPyObjectSteal(rest_o); match = PyStackRef_FromPyObjectSteal(match_o); - stack_pointer[-2] = rest; - stack_pointer[-1] = match; + stack_pointer[0] = rest; + stack_pointer[1] = match; + stack_pointer += 2; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -2925,15 +2942,19 @@ PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); assert(PyExceptionInstance_Check(left_o)); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = _PyEval_CheckExceptTypeValid(tstate, right_o); if (err < 0) { PyStackRef_CLOSE(right); - if (true) goto pop_1_error; + if (true) goto error; } int res = PyErr_GivenExceptionMatches(left_o, right_o); PyStackRef_CLOSE(right); b = res ? PyStackRef_True : PyStackRef_False; - stack_pointer[-1] = b; + stack_pointer[0] = b; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -2953,6 +2974,8 @@ PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st); assert(throwflag); assert(exc_value && PyExceptionInstance_Check(exc_value)); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); int matches = PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration); if (matches) { value = PyStackRef_FromPyObjectNew(((PyStopIterationObject *)exc_value)->value); @@ -2966,9 +2989,9 @@ monitor_reraise(tstate, frame, this_instr); goto exception_unwind; } - stack_pointer[-3] = none; - stack_pointer[-2] = value; - stack_pointer += -1; + stack_pointer[0] = none; + stack_pointer[1] = value; + stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3004,22 +3027,24 @@ PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); assert((oparg >> 5) <= Py_GE); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - if (res_o == NULL) goto pop_2_error; + if (res_o == NULL) goto error; if (oparg & 16) { int res_bool = PyObject_IsTrue(res_o); Py_DECREF(res_o); - if (res_bool < 0) goto pop_2_error; + if (res_bool < 0) goto error; res = res_bool ? PyStackRef_True : PyStackRef_False; } else { res = PyStackRef_FromPyObjectSteal(res_o); } } - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3173,14 +3198,16 @@ { PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); int res = PySequence_Contains(right_o, left_o); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - if (res < 0) goto pop_2_error; + if (res < 0) goto error; b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; } - stack_pointer[-2] = b; - stack_pointer += -1; + stack_pointer[0] = b; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3200,13 +3227,15 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyDict_CheckExact(right_o), CONTAINS_OP); STAT_INC(CONTAINS_OP, hit); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); int res = PyDict_Contains(right_o, left_o); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - if (res < 0) goto pop_2_error; + if (res < 0) goto error; b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; - stack_pointer[-2] = b; - stack_pointer += -1; + stack_pointer[0] = b; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3227,13 +3256,15 @@ DEOPT_IF(!(PySet_CheckExact(right_o) || PyFrozenSet_CheckExact(right_o)), CONTAINS_OP); STAT_INC(CONTAINS_OP, hit); // Note: both set and frozenset use the same seq_contains method! + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); int res = _PySet_Contains((PySetObject *)right_o, left_o); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - if (res < 0) goto pop_2_error; + if (res < 0) goto error; b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; - stack_pointer[-2] = b; - stack_pointer += -1; + stack_pointer[0] = b; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3295,11 +3326,11 @@ _PyStackRef owner; owner = stack_pointer[-1]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); - PyStackRef_CLOSE(owner); - if (err) goto pop_1_error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); + PyStackRef_CLOSE(owner); + if (err) goto error; DISPATCH(); } @@ -3385,13 +3416,13 @@ sub = stack_pointer[-1]; container = stack_pointer[-2]; /* del container[sub] */ + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub)); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); - if (err) goto pop_2_error; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + if (err) goto error; DISPATCH(); } @@ -3408,15 +3439,15 @@ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = _PyDict_MergeEx(dict_o, update_o, 2); if (err < 0) { _PyEval_FormatKwargsError(tstate, callable_o, update_o); PyStackRef_CLOSE(update); - if (true) goto pop_1_error; + if (true) goto error; } PyStackRef_CLOSE(update); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3430,6 +3461,8 @@ dict = stack_pointer[-2 - (oparg - 1)]; PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = PyDict_Update(dict_o, update_o); if (err < 0) { int matches = _PyErr_ExceptionMatches(tstate, PyExc_AttributeError); @@ -3439,11 +3472,9 @@ Py_TYPE(update_o)->tp_name); } PyStackRef_CLOSE(update); - if (true) goto pop_1_error; + if (true) goto error; } PyStackRef_CLOSE(update); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3458,6 +3489,8 @@ awaitable_st = stack_pointer[-2]; PyObject *exc = PyStackRef_AsPyObjectBorrow(exc_st); assert(exc && PyExceptionInstance_Check(exc)); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration)) { PyStackRef_CLOSE(awaitable_st); PyStackRef_CLOSE(exc_st); @@ -3468,8 +3501,6 @@ monitor_reraise(tstate, frame, this_instr); goto exception_unwind; } - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3542,6 +3573,8 @@ should_be_none = stack_pointer[-1]; assert(STACK_LEVEL() == 2); if (!PyStackRef_Is(should_be_none, PyStackRef_None)) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); PyErr_Format(PyExc_TypeError, "__init__() should return None, not '%.200s'", Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name); @@ -3574,14 +3607,19 @@ /* If value is a unicode object, then we know the result * of format(value) is value itself. */ if (!PyUnicode_CheckExact(value_o)) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); res = PyStackRef_FromPyObjectSteal(PyObject_Format(value_o, NULL)); PyStackRef_CLOSE(value); - if (PyStackRef_IsNull(res)) goto pop_1_error; + if (PyStackRef_IsNull(res)) goto error; } else { - res = value; + res = value;stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } - stack_pointer[-1] = res; + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3594,13 +3632,15 @@ _PyStackRef res; fmt_spec = stack_pointer[-1]; value = stack_pointer[-2]; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec)); PyStackRef_CLOSE(value); PyStackRef_CLOSE(fmt_spec); - if (res_o == NULL) goto pop_2_error; + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3637,12 +3677,16 @@ if (next_o == NULL) { next = PyStackRef_NULL; if (_PyErr_Occurred(tstate)) { + stack_pointer[0] = next; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); if (!matches) { goto error; } _PyEval_MonitorRaise(tstate, frame, this_instr); - _PyErr_Clear(tstate); + _PyErr_Clear(tstate);stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } /* iterator ended normally */ assert(next_instr[oparg].op.code == END_FOR || @@ -3868,24 +3912,28 @@ getter = type->tp_as_async->am_aiter; } if (getter == NULL) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyErr_Format(tstate, PyExc_TypeError, "'async for' requires an object with " "__aiter__ method, got %.100s", type->tp_name); PyStackRef_CLOSE(obj); - if (true) goto pop_1_error; + if (true) goto error; } iter_o = (*getter)(obj_o); PyStackRef_CLOSE(obj); if (iter_o == NULL) goto pop_1_error; if (Py_TYPE(iter_o)->tp_as_async == NULL || Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyErr_Format(tstate, PyExc_TypeError, "'async for' received an object from __aiter__ " "that does not implement __anext__: %.100s", Py_TYPE(iter_o)->tp_name); Py_DECREF(iter_o); - if (true) goto pop_1_error; + if (true) goto error; } iter = PyStackRef_FromPyObjectSteal(iter_o); stack_pointer[-1] = iter; @@ -3917,11 +3965,15 @@ _PyStackRef iterable; _PyStackRef iter; iterable = stack_pointer[-1]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg); PyStackRef_CLOSE(iterable); - if (iter_o == NULL) goto pop_1_error; + if (iter_o == NULL) goto error; iter = PyStackRef_FromPyObjectSteal(iter_o); - stack_pointer[-1] = iter; + stack_pointer[0] = iter; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3933,10 +3985,14 @@ _PyStackRef iter; iterable = stack_pointer[-1]; /* before: [obj]; after [getiter(obj)] */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable))); PyStackRef_CLOSE(iterable); - if (PyStackRef_IsNull(iter)) goto pop_1_error; - stack_pointer[-1] = iter; + if (PyStackRef_IsNull(iter)) goto error; + stack_pointer[0] = iter; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3973,6 +4029,8 @@ if (!(_PyFrame_GetCode(frame)->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) { /* and it is used in a 'yield from' expression of a regular generator. */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyErr_SetString(tstate, PyExc_TypeError, "cannot 'yield from' a coroutine object " "in a non-coroutine generator"); @@ -3985,11 +4043,15 @@ } else { /* `iterable` is not a generator. */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); if (PyStackRef_IsNull(iter)) { goto error; } PyStackRef_CLOSE(iterable); + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); } stack_pointer[-1] = iter; DISPATCH(); @@ -4022,15 +4084,17 @@ fromlist = stack_pointer[-1]; level = stack_pointer[-2]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = _PyEval_ImportName(tstate, frame, name, PyStackRef_AsPyObjectBorrow(fromlist), PyStackRef_AsPyObjectBorrow(level)); PyStackRef_CLOSE(level); PyStackRef_CLOSE(fromlist); - if (res_o == NULL) goto pop_2_error; + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -4083,6 +4147,8 @@ else { arg0 = &_PyInstrumentation_MISSING; } + stack_pointer[-2 - oparg] = func; + stack_pointer[-1 - oparg] = maybe_self; int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, function, arg0 @@ -4107,12 +4173,13 @@ { 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)); + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, total_args, NULL, frame ); // Manipulate stack directly since we leave using DISPATCH_INLINED(). - STACK_SHRINK(oparg + 2); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { @@ -4134,6 +4201,8 @@ goto error; } } + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, total_args | PY_VECTORCALL_ARGUMENTS_OFFSET, @@ -4161,11 +4230,7 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - if (res_o == NULL) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -4173,17 +4238,17 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_HandlePending(tstate); - if (err != 0) { - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (err != 0) goto error; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } } - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -4535,6 +4600,8 @@ // _RETURN_VALUE_EVENT val = value; { + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_call_instrumentation_arg( tstate, PY_MONITORING_EVENT_PY_RETURN, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); @@ -4548,6 +4615,8 @@ #if TIER_ONE assert(frame != &entry_frame); #endif + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); assert(EMPTY()); _Py_LeaveRecursiveCallPy(tstate); @@ -4644,12 +4713,12 @@ assert(frame != &entry_frame); #endif frame->instr_ptr++; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); tstate->exc_info = gen->gi_exc_state.previous_item; gen->gi_exc_state.previous_item = NULL; @@ -4685,6 +4754,8 @@ _PyStackRef retval; retval = stack_pointer[-1]; assert(frame == &entry_frame); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); assert(_PyFrame_IsIncomplete(frame)); /* Restore previous frame and return. */ tstate->current_frame = frame->previous; @@ -4815,6 +4886,8 @@ list_st = stack_pointer[-2 - (oparg-1)]; PyObject *list = PyStackRef_AsPyObjectBorrow(list_st); PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable); if (none_val == NULL) { int matches = _PyErr_ExceptionMatches(tstate, PyExc_TypeError); @@ -4827,12 +4900,10 @@ Py_TYPE(iterable)->tp_name); } PyStackRef_CLOSE(iterable_st); - if (true) goto pop_1_error; + if (true) goto error; } assert(Py_IsNone(none_val)); PyStackRef_CLOSE(iterable_st); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -4870,6 +4941,8 @@ if (oparg & 1) { /* Designed to work in tandem with CALL, pushes two values. */ attr_o = NULL; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int is_meth = _PyObject_GetMethod(PyStackRef_AsPyObjectBorrow(owner), name, &attr_o); if (is_meth) { /* We can bypass temporary bound method object. @@ -4887,23 +4960,25 @@ meth | NULL | arg1 | ... | argN */ PyStackRef_CLOSE(owner); - if (attr_o == NULL) goto pop_1_error; + if (attr_o == NULL) goto error; self_or_null = PyStackRef_NULL; } } else { /* Classic, pushes one value. */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); PyStackRef_CLOSE(owner); - if (attr_o == NULL) goto pop_1_error; + if (attr_o == NULL) goto error; /* We need to define self_or_null on all paths */ self_or_null = PyStackRef_NULL; } attr = PyStackRef_FromPyObjectSteal(attr_o); } - stack_pointer[-1] = attr; - if (oparg & 1) stack_pointer[0] = self_or_null; - stack_pointer += (oparg & 1); + stack_pointer[0] = attr; + if (oparg & 1) stack_pointer[1] = self_or_null; + stack_pointer += 1 + (oparg & 1); assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -5610,6 +5685,8 @@ assert(class_dict); assert(oparg >= 0 && oparg < _PyFrame_GetCode(frame)->co_nlocalsplus); name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = PyMapping_GetOptionalItem(class_dict, name, &value_o); if (err < 0) { goto error; @@ -5624,7 +5701,9 @@ } PyStackRef_CLOSE(class_dict_st); value = PyStackRef_FromPyObjectSteal(value_o); - stack_pointer[-1] = value; + stack_pointer[0] = value; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -5637,6 +5716,8 @@ mod_or_class_dict = stack_pointer[-1]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); PyObject *v_o; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = PyMapping_GetOptionalItem(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &v_o); if (err < 0) { goto error; @@ -5661,22 +5742,24 @@ else { /* Slow-path if globals or builtins is not a dict */ /* namespace 1: globals */ - if (PyMapping_GetOptionalItem(GLOBALS(), name, &v_o) < 0) goto pop_1_error; + if (PyMapping_GetOptionalItem(GLOBALS(), name, &v_o) < 0) goto error; if (v_o == NULL) { /* namespace 2: builtins */ - if (PyMapping_GetOptionalItem(BUILTINS(), name, &v_o) < 0) goto pop_1_error; + if (PyMapping_GetOptionalItem(BUILTINS(), name, &v_o) < 0) goto error; if (v_o == NULL) { _PyEval_FormatExcCheckArg( tstate, PyExc_NameError, NAME_ERROR_MSG, name); - if (true) goto pop_1_error; + if (true) goto error; } } } } PyStackRef_CLOSE(mod_or_class_dict); v = PyStackRef_FromPyObjectSteal(v_o); - stack_pointer[-1] = v; + stack_pointer[0] = v; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -5846,19 +5929,25 @@ PyObject *owner_o = PyStackRef_AsPyObjectSteal(owner); PyObject *name = _Py_SpecialMethods[oparg].name; PyObject *self_or_null_o; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); attr = PyStackRef_FromPyObjectSteal(_PyObject_LookupSpecialMethod(owner_o, name, &self_or_null_o)); if (PyStackRef_IsNull(attr)) { if (!_PyErr_Occurred(tstate)) { + stack_pointer[0] = attr; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); _PyErr_Format(tstate, PyExc_TypeError, _Py_SpecialMethods[oparg].error, - Py_TYPE(owner_o)->tp_name); + Py_TYPE(owner_o)->tp_name);stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } } - if (PyStackRef_IsNull(attr)) goto pop_1_error; + if (PyStackRef_IsNull(attr)) goto error; self_or_null = PyStackRef_FromPyObjectSteal(self_or_null_o); - stack_pointer[-1] = attr; - stack_pointer[0] = self_or_null; - stack_pointer += 1; + stack_pointer[0] = attr; + stack_pointer[1] = self_or_null; + stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -5900,14 +5989,20 @@ PyObject *self = PyStackRef_AsPyObjectBorrow(self_st); if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) { PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING; + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, global_super, arg); - if (err) goto pop_3_error; + if (err) goto error; + stack_pointer += 3; + assert(WITHIN_STACK_BOUNDS()); } // we make no attempt to optimize here; specializations should // handle any case whose performance we care about PyObject *stack[] = {class, self}; + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); PyObject *super = PyObject_Vectorcall(global_super, stack, oparg & 2, NULL); if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) { PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING; @@ -5928,16 +6023,16 @@ PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); PyStackRef_CLOSE(self_st); - if (super == NULL) goto pop_3_error; + if (super == NULL) goto error; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); attr = PyStackRef_FromPyObjectSteal(PyObject_GetAttr(super, name)); Py_DECREF(super); - if (PyStackRef_IsNull(attr)) goto pop_3_error; + if (PyStackRef_IsNull(attr)) goto error; null = PyStackRef_NULL; } - stack_pointer[-3] = attr; - if (oparg & 1) stack_pointer[-2] = null; - stack_pointer += -2 + (oparg & 1); + stack_pointer[0] = attr; + if (oparg & 1) stack_pointer[1] = null; + stack_pointer += 1 + (oparg & 1); assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -5963,14 +6058,16 @@ DEOPT_IF(!PyType_Check(class), LOAD_SUPER_ATTR); STAT_INC(LOAD_SUPER_ATTR, hit); PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL); PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); PyStackRef_CLOSE(self_st); - if (attr == NULL) goto pop_3_error; + if (attr == NULL) goto error; attr_st = PyStackRef_FromPyObjectSteal(attr); - stack_pointer[-3] = attr_st; - stack_pointer += -2; + stack_pointer[0] = attr_st; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -5999,13 +6096,15 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); PyTypeObject *cls = (PyTypeObject *)class; int method_found = 0; + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); PyObject *attr_o = _PySuper_Lookup(cls, self, name, Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? &method_found : NULL); PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); if (attr_o == NULL) { PyStackRef_CLOSE(self_st); - if (true) goto pop_3_error; + if (true) goto error; } if (method_found) { self_or_null = self_st; // transfer ownership @@ -6014,9 +6113,9 @@ self_or_null = PyStackRef_NULL; } attr = PyStackRef_FromPyObjectSteal(attr_o); - stack_pointer[-3] = attr; - stack_pointer[-2] = self_or_null; - stack_pointer += -1; + stack_pointer[0] = attr; + stack_pointer[1] = self_or_null; + stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -6044,6 +6143,8 @@ _PyStackRef func; codeobj_st = stack_pointer[-1]; PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); PyFunctionObject *func_obj = (PyFunctionObject *) PyFunction_New(codeobj, GLOBALS()); PyStackRef_CLOSE(codeobj_st); @@ -6053,7 +6154,9 @@ _PyFunction_SetVersion( func_obj, ((PyCodeObject *)codeobj)->co_version); func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj); - stack_pointer[-1] = func; + stack_pointer[0] = func; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -6071,14 +6174,14 @@ assert(PyDict_CheckExact(dict)); /* dict[key] = value */ // Do not DECREF INPUTS because the function steals the references + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); int err = _PyDict_SetItem_Take2( (PyDictObject *)dict, PyStackRef_AsPyObjectSteal(key), PyStackRef_AsPyObjectSteal(value) ); - if (err != 0) goto pop_2_error; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + if (err != 0) goto error; DISPATCH(); } @@ -6096,6 +6199,8 @@ // Pop TOS and TOS1. Set TOS to a tuple of attributes on success, or // None on failure. assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names))); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); PyObject *attrs_o = _PyEval_MatchClass(tstate, PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(type), oparg, @@ -6108,12 +6213,12 @@ attrs = PyStackRef_FromPyObjectSteal(attrs_o); } else { - if (_PyErr_Occurred(tstate)) goto pop_3_error; + if (_PyErr_Occurred(tstate)) goto error; // Error! attrs = PyStackRef_None; // Failure! } - stack_pointer[-3] = attrs; - stack_pointer += -2; + stack_pointer[0] = attrs; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -6182,11 +6287,11 @@ _PyStackRef exc_value; exc_value = stack_pointer[-1]; _PyErr_StackItem *exc_info = tstate->exc_info; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); Py_XSETREF(exc_info->exc_value, PyStackRef_Is(exc_value, PyStackRef_None) ? NULL : PyStackRef_AsPyObjectSteal(exc_value)); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -6353,24 +6458,13 @@ _PyStackRef *args; args = &stack_pointer[-oparg]; PyObject *cause = NULL, *exc = NULL; - switch (oparg) { - case 2: - cause = PyStackRef_AsPyObjectSteal(args[1]); - _Py_FALLTHROUGH; - case 1: - exc = PyStackRef_AsPyObjectSteal(args[0]); - _Py_FALLTHROUGH; - case 0: - if (do_raise(tstate, exc, cause)) { - assert(oparg == 0); - monitor_reraise(tstate, frame, this_instr); - goto exception_unwind; - } - break; - default: - _PyErr_SetString(tstate, PyExc_SystemError, - "bad RAISE_VARARGS oparg"); - break; + assert(oparg < 3); + PyObject *cause = oparg == 2 ? PyStackRef_AsPyObjectSteal(args[1]) : NULL; + PyObject *exc = oparg > 0 ? PyStackRef_AsPyObjectSteal(args[0]) : NULL; + if (do_raise(tstate, exc, cause)) { + assert(oparg == 0); + monitor_reraise(tstate, frame, this_instr); + goto exception_unwind; } if (true) { stack_pointer += -oparg; @@ -6393,16 +6487,23 @@ if (oparg) { PyObject *lasti = PyStackRef_AsPyObjectBorrow(values[0]); if (PyLong_Check(lasti)) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); frame->instr_ptr = _PyCode_CODE(_PyFrame_GetCode(frame)) + PyLong_AsLong(lasti); assert(!_PyErr_Occurred(tstate)); } else { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyErr_SetString(tstate, PyExc_SystemError, "lasti is not an int"); goto error; - } + }stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); } assert(exc && PyExceptionInstance_Check(exc)); Py_INCREF(exc); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyErr_SetRaisedException(tstate, exc); monitor_reraise(tstate, frame, this_instr); goto exception_unwind; @@ -6532,12 +6633,12 @@ gen->gi_frame_state = FRAME_CREATED; gen_frame->owner = FRAME_OWNED_BY_GENERATOR; _Py_LeaveRecursiveCallPy(tstate); - res = PyStackRef_FromPyObjectSteal((PyObject *)gen); _PyInterpreterFrame *prev = frame->previous; _PyThreadState_PopFrame(tstate, frame); frame = tstate->current_frame = prev; LOAD_IP(frame->return_offset); LOAD_SP(); + res = PyStackRef_FromPyObjectSteal((PyObject *)gen); LLTRACE_RESUME_FRAME(); stack_pointer[0] = res; stack_pointer += 1; @@ -6626,11 +6727,16 @@ retval_o = Py_TYPE(receiver_o)->tp_iternext(receiver_o); } else { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); retval_o = PyObject_CallMethodOneArg(receiver_o, &_Py_ID(send), - PyStackRef_AsPyObjectBorrow(v)); + PyStackRef_AsPyObjectBorrow(v));stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); } if (retval_o == NULL) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); if (matches) { _PyEval_MonitorRaise(tstate, frame, this_instr); @@ -6642,7 +6748,8 @@ } else { goto error; - } + }stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); } PyStackRef_CLOSE(v); retval = PyStackRef_FromPyObjectSteal(retval_o); @@ -6737,12 +6844,12 @@ _PyStackRef v; v = stack_pointer[-1]; set = stack_pointer[-2 - (oparg-1)]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = PySet_Add(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(v)); PyStackRef_CLOSE(v); - if (err) goto pop_1_error; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + if (err) goto error; DISPATCH(); } @@ -6776,12 +6883,12 @@ _PyStackRef iterable; iterable = stack_pointer[-1]; set = stack_pointer[-2 - (oparg-1)]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(iterable)); PyStackRef_CLOSE(iterable); - if (err < 0) goto pop_1_error; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + if (err < 0) goto error; DISPATCH(); } @@ -6815,14 +6922,14 @@ v = stack_pointer[-2]; { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner), name, PyStackRef_AsPyObjectBorrow(v)); PyStackRef_CLOSE(v); PyStackRef_CLOSE(owner); - if (err) goto pop_2_error; + if (err) goto error; } - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -6941,6 +7048,8 @@ PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dict->ma_keys) + hint; DEOPT_IF(ep->me_key != name, STORE_ATTR); /* Ensure dict is GC tracked if it needs to be */ + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(PyStackRef_AsPyObjectBorrow(value))) { _PyObject_GC_TRACK(dict); } @@ -6955,8 +7064,6 @@ STAT_INC(STORE_ATTR, hit); PyStackRef_CLOSE(owner); } - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -6967,9 +7074,9 @@ _PyStackRef v; v = stack_pointer[-1]; PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); - PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v)); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v)); DISPATCH(); } @@ -7024,11 +7131,11 @@ _PyStackRef v; v = stack_pointer[-1]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); - PyStackRef_CLOSE(v); - if (err) goto pop_1_error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); + PyStackRef_CLOSE(v); + if (err) goto error; DISPATCH(); } @@ -7042,21 +7149,25 @@ PyObject *ns = LOCALS(); int err; if (ns == NULL) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when storing %R", name); PyStackRef_CLOSE(v); - if (true) goto pop_1_error; + if (true) goto error; } if (PyDict_CheckExact(ns)) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); } else { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); } PyStackRef_CLOSE(v); - if (err) goto pop_1_error; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + if (err) goto error; DISPATCH(); } @@ -7072,6 +7183,8 @@ start = stack_pointer[-2]; container = stack_pointer[-3]; v = stack_pointer[-4]; + stack_pointer += -4; + assert(WITHIN_STACK_BOUNDS()); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); OPCODE_DEFERRED_INC(STORE_SLICE); @@ -7085,9 +7198,7 @@ } PyStackRef_CLOSE(v); PyStackRef_CLOSE(container); - if (err) goto pop_4_error; - stack_pointer += -4; - assert(WITHIN_STACK_BOUNDS()); + if (err) goto error; DISPATCH(); } @@ -7121,14 +7232,14 @@ v = stack_pointer[-3]; { /* container[sub] = v */ + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v)); PyStackRef_CLOSE(v); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); - if (err) goto pop_3_error; + if (err) goto error; } - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -7147,13 +7258,13 @@ PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st); DEOPT_IF(!PyDict_CheckExact(dict), STORE_SUBSCR); STAT_INC(STORE_SUBSCR, hit); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); int err = _PyDict_SetItem_Take2((PyDictObject *)dict, PyStackRef_AsPyObjectSteal(sub), PyStackRef_AsPyObjectSteal(value)); PyStackRef_CLOSE(dict_st); - if (err) goto pop_3_error; - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); + if (err) goto error; DISPATCH(); } @@ -7231,12 +7342,16 @@ /* Skip 2 cache entries */ // _TO_BOOL { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value)); PyStackRef_CLOSE(value); - if (err < 0) goto pop_1_error; + if (err < 0) goto error; res = err ? PyStackRef_True : PyStackRef_False; } - stack_pointer[-1] = res; + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -7376,11 +7491,15 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value)); PyStackRef_CLOSE(value); - if (res_o == NULL) goto pop_1_error; + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-1] = res; + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -7391,11 +7510,15 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value)); PyStackRef_CLOSE(value); - if (res_o == NULL) goto pop_1_error; + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-1] = res; + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -7422,10 +7545,12 @@ seq = stack_pointer[-1]; right = &stack_pointer[(oparg & 0xFF)]; _PyStackRef *top = right + (oparg >> 8); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top); PyStackRef_CLOSE(seq); - if (res == 0) goto pop_1_error; - stack_pointer += (oparg & 0xFF) + (oparg >> 8); + if (res == 0) goto error; + stack_pointer += 1 + (oparg & 0xFF) + (oparg >> 8); assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -7460,11 +7585,13 @@ { output = &stack_pointer[-1]; _PyStackRef *top = output + oparg; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top); PyStackRef_CLOSE(seq); - if (res == 0) goto pop_1_error; + if (res == 0) goto error; } - stack_pointer += -1 + oparg; + stack_pointer += oparg; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -7603,12 +7730,12 @@ assert(frame != &entry_frame); #endif frame->instr_ptr++; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); tstate->exc_info = gen->gi_exc_state.previous_item; gen->gi_exc_state.previous_item = NULL; @@ -7659,19 +7786,24 @@ if (err < 0) { goto error; } + stack_pointer += -3 - (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); PyObject *tuple = PySequence_Tuple(callargs); if (tuple == NULL) { goto error; } PyStackRef_CLOSE(callargs_st); callargs_st = PyStackRef_FromPyObjectSteal(tuple); - callargs = tuple; + callargs = tuple;stack_pointer += 3 + (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); } assert(PyTuple_CheckExact(callargs)); EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_FUNCTION_EX, func); if (opcode == INSTRUMENTED_CALL_FUNCTION_EX) { PyObject *arg = PyTuple_GET_SIZE(callargs) > 0 ? PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING; + stack_pointer += -3 - (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, func, arg); @@ -7681,18 +7813,25 @@ result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); if (!PyFunction_Check(func) && !PyMethod_Check(func)) { if (PyStackRef_IsNull(result)) { + stack_pointer[0] = result; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, func, arg); } else { + stack_pointer[0] = result; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, func, arg); if (err < 0) { PyStackRef_CLEAR(result); } - } + }stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } } else { @@ -7703,11 +7842,12 @@ Py_ssize_t nargs = PyTuple_GET_SIZE(callargs); int code_flags = ((PyCodeObject *)PyFunction_GET_CODE(func))->co_flags; PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func)); + stack_pointer += -3 - (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(func_st), locals, nargs, callargs, kwargs, frame); - // Need to manually shrink the stack since we exit with DISPATCH_INLINED. - STACK_SHRINK(oparg + 3); + // Need to sync the stack since we exit with DISPATCH_INLINED. if (new_frame == NULL) { goto error; } @@ -7715,20 +7855,16 @@ frame->return_offset = 1; DISPATCH_INLINED(new_frame); } + stack_pointer += -3 - (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); } PyStackRef_CLOSE(func_st); PyStackRef_CLOSE(callargs_st); PyStackRef_XCLOSE(kwargs_st); - assert(PyStackRef_AsPyObjectBorrow(PEEK(2 + (oparg & 1))) == NULL); - if (PyStackRef_IsNull(result)) { - stack_pointer[-3 - (oparg & 1)] = result; - stack_pointer += -2 - (oparg & 1); - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - stack_pointer[-3 - (oparg & 1)] = result; - stack_pointer += -2 - (oparg & 1); + if (PyStackRef_IsNull(result)) goto error; + stack_pointer[0] = result; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 3f12e22d033692..864af03a854727 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -369,6 +369,8 @@ { assert(PyFloat_CheckExact(sym_get_const(left))); assert(PyFloat_CheckExact(sym_get_const(right))); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( PyFloat_AS_DOUBLE(sym_get_const(left)) * PyFloat_AS_DOUBLE(sym_get_const(right))); @@ -381,10 +383,11 @@ // replace opcode with constant propagated one and update tests! } else { - res = sym_new_type(ctx, &PyFloat_Type); + res = sym_new_type(ctx, &PyFloat_Type);stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); } - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -400,6 +403,8 @@ { assert(PyFloat_CheckExact(sym_get_const(left))); assert(PyFloat_CheckExact(sym_get_const(right))); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( PyFloat_AS_DOUBLE(sym_get_const(left)) + PyFloat_AS_DOUBLE(sym_get_const(right))); @@ -412,10 +417,11 @@ // replace opcode with constant propagated one and update tests! } else { - res = sym_new_type(ctx, &PyFloat_Type); + res = sym_new_type(ctx, &PyFloat_Type);stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); } - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -431,6 +437,8 @@ { assert(PyFloat_CheckExact(sym_get_const(left))); assert(PyFloat_CheckExact(sym_get_const(right))); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( PyFloat_AS_DOUBLE(sym_get_const(left)) - PyFloat_AS_DOUBLE(sym_get_const(right))); @@ -443,10 +451,11 @@ // replace opcode with constant propagated one and update tests! } else { - res = sym_new_type(ctx, &PyFloat_Type); + res = sym_new_type(ctx, &PyFloat_Type);stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); } - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1246,7 +1255,10 @@ res = sym_new_type(ctx, &PyBool_Type); } else { - res = _Py_uop_sym_new_not_null(ctx); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); + res = _Py_uop_sym_new_not_null(ctx);stack_pointer += 2; + assert(WITHIN_STACK_BOUNDS()); } stack_pointer[-2] = res; stack_pointer += -1; diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 365181a30a9c27..5b574f836cf2b5 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -505,6 +505,7 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "_PyLong_IsZero", "Py_SIZE", "Py_TYPE", + "Py_IS_TYPE", "PyList_GET_ITEM", "PyList_SET_ITEM", "PyTuple_GET_ITEM", @@ -556,8 +557,13 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "_PyTuple_FromArraySteal", "_PyTuple_FromStackRefSteal", "PyFunction_GET_CODE", + "PyFunction_GET_GLOBALS", "_PyErr_Occurred", "PyCFunction_GET_FUNCTION", + "PyCFunction_GET_FLAGS", + "PyCFunction_GET_SELF", + "_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY", + "PyCell_GetRef", ) def find_start_stmt(node: parser.InstDef, idx: int) -> lexer.Token: diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 65b9af20a6c117..9bbfbdc01ac8d6 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -329,10 +329,9 @@ def _emit_block( self.emit(storage.as_comment()) self.out.start_line() line = tkn.line - #if tkn in escaping_calls: - # self.out.emit(f"/* ESCAPING CALL {escaping_calls[tkn].text} starting at {tkn.text} */\n") - # storage.flush(self.out) - # self._print_storage(storage) + if tkn in escaping_calls: + storage.flush(self.out) + self._print_storage(storage) if tkn.kind == "LBRACE": self.out.emit(tkn) braces += 1 From 3bfed1b37ddb2785593b01ae2360d3bad2de2734 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Fri, 30 Aug 2024 11:51:44 +0100 Subject: [PATCH 21/53] Find end of statement when anlyzing escaping calls --- Python/bytecodes.c | 1 - Python/ceval.c | 1 - Python/generated_cases.c.h | 1 - Tools/cases_generator/analyzer.py | 18 +++++++++++++++--- 4 files changed, 15 insertions(+), 6 deletions(-) diff --git a/Python/bytecodes.c b/Python/bytecodes.c index a48054b787d23b..f291e5b9da6673 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -913,7 +913,6 @@ dummy_func( } tier1 inst(RAISE_VARARGS, (args[oparg] -- )) { - PyObject *cause = NULL, *exc = NULL; assert(oparg < 3); PyObject *cause = oparg == 2 ? PyStackRef_AsPyObjectSteal(args[1]) : NULL; PyObject *exc = oparg > 0 ? PyStackRef_AsPyObjectSteal(args[0]) : NULL; diff --git a/Python/ceval.c b/Python/ceval.c index a1c7dcb9100b28..7d69cd18bd3c8d 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -246,7 +246,6 @@ maybe_lltrace_resume_frame(_PyInterpreterFrame *frame, _PyInterpreterFrame *skip lltrace = *python_lltrace - '0'; // TODO: Parse an int and all that } } - lltrace = 5; if (lltrace >= 5) { lltrace_resume_frame(frame); } diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 1a0870fd81fba4..21c9e792ec6965 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -6457,7 +6457,6 @@ INSTRUCTION_STATS(RAISE_VARARGS); _PyStackRef *args; args = &stack_pointer[-oparg]; - PyObject *cause = NULL, *exc = NULL; assert(oparg < 3); PyObject *cause = oparg == 2 ? PyStackRef_AsPyObjectSteal(args[1]) : NULL; PyObject *exc = oparg > 0 ? PyStackRef_AsPyObjectSteal(args[0]) : NULL; diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 5b574f836cf2b5..5903d866d6c2d1 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -566,7 +566,7 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "PyCell_GetRef", ) -def find_start_stmt(node: parser.InstDef, idx: int) -> lexer.Token: +def find_stmt_start(node: parser.InstDef, idx: int) -> lexer.Token: assert idx < len(node.block.tokens) while True: tkn = node.block.tokens[idx-1] @@ -578,6 +578,17 @@ def find_start_stmt(node: parser.InstDef, idx: int) -> lexer.Token: idx += 1 return node.block.tokens[idx] +def find_stmt_end(node: parser.InstDef, idx: int) -> lexer.Token: + assert idx < len(node.block.tokens) + while True: + idx += 1 + tkn = node.block.tokens[idx] + if tkn.kind == "SEMI" or tkn.kind == "LBRACE" or tkn.kind == "RBRACE": + break + while node.block.tokens[idx].kind == "COMMENT": + idx -= 1 + return node.block.tokens[idx] + def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, lexer.Token]: result: dict[lexer.Token, lexer.Token] = {} @@ -601,8 +612,9 @@ def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, lexer.To continue if tkn.text in NON_ESCAPING_FUNCTIONS: continue - start = find_start_stmt(instr, idx) - result[start] = tkn + start = find_stmt_start(instr, idx) + end = find_stmt_end(instr, idx) + result[start] = tkn, end return result From d7e1c826f00299838d55a445e1295986e41509a3 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Sat, 31 Aug 2024 09:13:13 +0100 Subject: [PATCH 22/53] Spill stack pointer as well. Work in progress --- Python/bytecodes.c | 14 +- Python/ceval_macros.h | 1 + Python/executor_cases.c.h | 446 ++++++++++++++--- Python/generated_cases.c.h | 478 ++++++++++++++++++- Python/optimizer.c | 2 +- Python/optimizer_cases.c.h | 32 +- Tools/cases_generator/analyzer.py | 37 +- Tools/cases_generator/generators_common.py | 46 +- Tools/cases_generator/optimizer_generator.py | 7 +- Tools/cases_generator/stack.py | 20 + Tools/cases_generator/tier2_generator.py | 1 + 11 files changed, 971 insertions(+), 113 deletions(-) diff --git a/Python/bytecodes.c b/Python/bytecodes.c index f291e5b9da6673..f2ce5bebaa0809 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -1204,7 +1204,8 @@ dummy_func( PyObject *exc = PyStackRef_AsPyObjectBorrow(exc_st); assert(exc && PyExceptionInstance_Check(exc)); - if (PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration)) { + int matches = PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration); + if (matches) { DECREF_INPUTS(); } else { @@ -4382,7 +4383,7 @@ dummy_func( ERROR_NO_POP(); } assert(EMPTY()); - _PyFrame_SetStackPointer(frame, stack_pointer); + SAVE_STACK(); _PyInterpreterFrame *gen_frame = &gen->gi_iframe; frame->instr_ptr++; _PyFrame_Copy(frame, gen_frame); @@ -4394,7 +4395,7 @@ dummy_func( _PyThreadState_PopFrame(tstate, frame); frame = tstate->current_frame = prev; LOAD_IP(frame->return_offset); - LOAD_SP(); + RELOAD_STACK(); res = PyStackRef_FromPyObjectSteal((PyObject *)gen); LLTRACE_RESUME_FRAME(); } @@ -4818,6 +4819,13 @@ dummy_func( tier2 op(_ERROR_POP_N, (target/2, unused[oparg] --)) { frame->instr_ptr = ((_Py_CODEUNIT *)_PyFrame_GetCode(frame)->co_code_adaptive) + target; + { + stack_pointer -= oparg; + if (!WITHIN_STACK_BOUNDS()) { + printf("Stacke level: %d, oparg: %d\n", STACK_LEVEL(), oparg); + } + stack_pointer += oparg; + } SYNC_SP(); GOTO_UNWIND(); } diff --git a/Python/ceval_macros.h b/Python/ceval_macros.h index 9e1540674d4219..e0e9cc156ed62f 100644 --- a/Python/ceval_macros.h +++ b/Python/ceval_macros.h @@ -108,6 +108,7 @@ do { \ /* Do interpreter dispatch accounting for tracing and instrumentation */ #define DISPATCH() \ { \ + assert(frame->stackpointer == NULL); \ NEXTOPARG(); \ PRE_DISPATCH_GOTO(); \ DISPATCH_GOTO(); \ diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 7d030968190d97..793bf5a5d09557 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -16,7 +16,9 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) JUMP_TO_ERROR(); } break; @@ -28,7 +30,9 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) JUMP_TO_ERROR(); } } @@ -62,10 +66,12 @@ oparg = CURRENT_OPARG(); _PyStackRef value_s = GETLOCAL(oparg); if (PyStackRef_IsNull(value_s)) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError, UNBOUNDLOCAL_ERROR_MSG, PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg) ); + stack_pointer = _PyFrame_GetStackPointer(frame); if (1) JUMP_TO_ERROR(); } value = PyStackRef_DUP(value_s); @@ -339,7 +345,9 @@ value = stack_pointer[-1]; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); @@ -366,7 +374,9 @@ value = stack_pointer[-1]; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); if (err < 0) JUMP_TO_ERROR(); res = err ? PyStackRef_True : PyStackRef_False; @@ -479,7 +489,9 @@ value = stack_pointer[-1]; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); @@ -541,10 +553,12 @@ PyObject *res_o = _PyLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -561,10 +575,12 @@ PyObject *res_o = _PyLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -581,10 +597,12 @@ PyObject *res_o = _PyLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -722,10 +740,12 @@ PyObject *res_o = PyUnicode_Concat(left_o, right_o); _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc); _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -763,8 +783,10 @@ */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); assert(Py_REFCNT(left_o) >= 2); _Py_DECREF_NO_DEALLOC(left_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyObject *temp = PyStackRef_AsPyObjectBorrow(*target_local); PyUnicode_Append(&temp, right_o); *target_local = PyStackRef_FromPyObjectSteal(temp); @@ -789,7 +811,9 @@ PyObject *sub_o = PyStackRef_AsPyObjectBorrow(sub); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_GetItem(container_o, sub_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); if (res_o == NULL) JUMP_TO_ERROR(); @@ -810,8 +834,10 @@ container = stack_pointer[-3]; stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyObject *res_o; OPCODE_DEFERRED_INC(BINARY_SLICE); // Can't use ERROR_IF() here, because we haven't @@ -820,7 +846,9 @@ res_o = NULL; } else { + _PyFrame_SetStackPointer(frame, stack_pointer); res_o = PyObject_GetItem(PyStackRef_AsPyObjectBorrow(container), slice); + stack_pointer = _PyFrame_GetStackPointer(frame); Py_DECREF(slice); } PyStackRef_CLOSE(container); @@ -843,15 +871,19 @@ v = stack_pointer[-4]; stack_pointer += -4; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); + stack_pointer = _PyFrame_GetStackPointer(frame); OPCODE_DEFERRED_INC(STORE_SLICE); int err; if (slice == NULL) { err = 1; } else { + _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), slice, PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); Py_DECREF(slice); } PyStackRef_CLOSE(v); @@ -996,9 +1028,13 @@ PyObject *res_o; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int rc = PyDict_GetItemRef(dict, sub, &res_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (rc == 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetKeyError(sub); + stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(dict_st); PyStackRef_CLOSE(sub_st); @@ -1015,10 +1051,12 @@ _PyStackRef container; container = stack_pointer[-2]; PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(container)); + _PyFrame_SetStackPointer(frame, stack_pointer); if (!PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + stack_pointer = _PyFrame_GetStackPointer(frame); PyHeapTypeObject *ht = (PyHeapTypeObject *)tp; PyObject *getitem = ht->_spec_cache.getitem; if (getitem == NULL) { @@ -1069,10 +1107,10 @@ oparg = CURRENT_OPARG(); v = stack_pointer[-1]; list = stack_pointer[-2 - (oparg-1)]; - if (_PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list), - PyStackRef_AsPyObjectSteal(v)) < 0) JUMP_TO_ERROR(); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + if (_PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list), + PyStackRef_AsPyObjectSteal(v)) < 0) JUMP_TO_ERROR(); break; } @@ -1084,8 +1122,10 @@ set = stack_pointer[-2 - (oparg-1)]; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PySet_Add(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); if (err) JUMP_TO_ERROR(); break; @@ -1101,7 +1141,9 @@ /* container[sub] = v */ stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); @@ -1164,9 +1206,11 @@ STAT_INC(STORE_SUBSCR, hit); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_SetItem_Take2((PyDictObject *)dict, PyStackRef_AsPyObjectSteal(sub), PyStackRef_AsPyObjectSteal(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(dict_st); if (err) JUMP_TO_ERROR(); break; @@ -1180,8 +1224,10 @@ /* del container[sub] */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); if (err) JUMP_TO_ERROR(); @@ -1196,9 +1242,13 @@ assert(oparg <= MAX_INTRINSIC_1); PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value)); PyStackRef_CLOSE(value); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-1] = res; + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1215,10 +1265,12 @@ PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1); PyStackRef_CLOSE(value2_st); PyStackRef_CLOSE(value1_st); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1263,29 +1315,35 @@ if (getter == NULL) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'async for' requires an object with " "__aiter__ method, got %.100s", type->tp_name); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(obj); if (true) JUMP_TO_ERROR(); } iter_o = (*getter)(obj_o); PyStackRef_CLOSE(obj); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (iter_o == NULL) JUMP_TO_ERROR(); if (Py_TYPE(iter_o)->tp_as_async == NULL || Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'async for' received an object from __aiter__ " "that does not implement __anext__: %.100s", Py_TYPE(iter_o)->tp_name); + stack_pointer = _PyFrame_GetStackPointer(frame); Py_DECREF(iter_o); if (true) JUMP_TO_ERROR(); } iter = PyStackRef_FromPyObjectSteal(iter_o); - stack_pointer[-1] = iter; + stack_pointer[0] = iter; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1293,7 +1351,9 @@ _PyStackRef aiter; _PyStackRef awaitable; aiter = stack_pointer[-1]; + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *awaitable_o = _PyEval_GetANext(PyStackRef_AsPyObjectBorrow(aiter)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (awaitable_o == NULL) { JUMP_TO_ERROR(); } @@ -1311,7 +1371,9 @@ iterable = stack_pointer[-1]; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); if (iter_o == NULL) JUMP_TO_ERROR(); iter = PyStackRef_FromPyObjectSteal(iter_o); @@ -1366,7 +1428,9 @@ frame->instr_ptr++; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); + stack_pointer = _PyFrame_GetStackPointer(frame); assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; @@ -1403,9 +1467,11 @@ _PyErr_StackItem *exc_info = tstate->exc_info; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); Py_XSETREF(exc_info->exc_value, PyStackRef_Is(exc_value, PyStackRef_None) ? NULL : PyStackRef_AsPyObjectSteal(exc_value)); + stack_pointer = _PyFrame_GetStackPointer(frame); break; } @@ -1432,10 +1498,14 @@ case _LOAD_BUILD_CLASS: { _PyStackRef bc; PyObject *bc_o; + _PyFrame_SetStackPointer(frame, stack_pointer); if (PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o) < 0) JUMP_TO_ERROR(); + stack_pointer = _PyFrame_GetStackPointer(frame); if (bc_o == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_NameError, "__build_class__ not found"); + stack_pointer = _PyFrame_GetStackPointer(frame); if (true) JUMP_TO_ERROR(); } bc = PyStackRef_FromPyObjectSteal(bc_o); @@ -1455,20 +1525,26 @@ if (ns == NULL) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when storing %R", name); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); if (true) JUMP_TO_ERROR(); } if (PyDict_CheckExact(ns)) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); } else { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(v); if (err) JUMP_TO_ERROR(); @@ -1481,16 +1557,22 @@ PyObject *ns = LOCALS(); int err; if (ns == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals when deleting %R", name); + stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); } + _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_DelItem(ns, name); + stack_pointer = _PyFrame_GetStackPointer(frame); // Can't use ERROR_IF here. if (err != 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, name); + stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); } break; @@ -1505,7 +1587,9 @@ _PyStackRef *top = output + oparg; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(seq); if (res == 0) JUMP_TO_ERROR(); stack_pointer += oparg; @@ -1601,7 +1685,9 @@ _PyStackRef *top = right + (oparg >> 8); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(seq); if (res == 0) JUMP_TO_ERROR(); stack_pointer += 1 + (oparg & 0xFF) + (oparg >> 8); @@ -1618,8 +1704,10 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner), name, PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); PyStackRef_CLOSE(owner); if (err) JUMP_TO_ERROR(); @@ -1633,7 +1721,9 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(owner); if (err) JUMP_TO_ERROR(); break; @@ -1646,7 +1736,9 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); if (err) JUMP_TO_ERROR(); break; @@ -1655,14 +1747,18 @@ case _DELETE_GLOBAL: { oparg = CURRENT_OPARG(); PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_Pop(GLOBALS(), name, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); // Can't use ERROR_IF here. if (err < 0) { JUMP_TO_ERROR(); } if (err == 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, name); + stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); } break; @@ -1672,8 +1768,10 @@ _PyStackRef locals; PyObject *l = LOCALS(); if (l == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_SystemError, "no locals found"); + stack_pointer = _PyFrame_GetStackPointer(frame); if (true) JUMP_TO_ERROR(); } locals = PyStackRef_FromPyObjectNew(l); @@ -1689,7 +1787,9 @@ _PyStackRef v; oparg = CURRENT_OPARG(); PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *v_o = _PyEval_LoadName(tstate, frame, name); + stack_pointer = _PyFrame_GetStackPointer(frame); if (v_o == NULL) JUMP_TO_ERROR(); v = PyStackRef_FromPyObjectSteal(v_o); stack_pointer[0] = v; @@ -1703,7 +1803,9 @@ _PyStackRef null = PyStackRef_NULL; oparg = CURRENT_OPARG(); PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_LoadGlobal(GLOBALS(), BUILTINS(), name); + stack_pointer = _PyFrame_GetStackPointer(frame); if (res_o == NULL) JUMP_TO_ERROR(); null = PyStackRef_NULL; res = PyStackRef_FromPyObjectSteal(res_o); @@ -1794,10 +1896,12 @@ oparg = CURRENT_OPARG(); _PyStackRef v = GETLOCAL(oparg); if (PyStackRef_IsNull(v)) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError, UNBOUNDLOCAL_ERROR_MSG, PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg) ); + stack_pointer = _PyFrame_GetStackPointer(frame); if (1) JUMP_TO_ERROR(); } SETLOCAL(oparg, PyStackRef_NULL); @@ -1822,9 +1926,13 @@ PyObject *cell = PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); // Can't use ERROR_IF here. // Fortunately we don't need its superpower. + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *oldobj = PyCell_SwapTakeRef((PyCellObject *)cell, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); if (oldobj == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); } Py_DECREF(oldobj); @@ -1844,7 +1952,9 @@ name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(class_dict, name, &value_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { JUMP_TO_ERROR(); } @@ -1852,7 +1962,9 @@ PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); value_o = PyCell_GetRef(cell); if (value_o == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); } } @@ -1870,7 +1982,9 @@ PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); PyObject *value_o = PyCell_GetRef(cell); if (value_o == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); if (true) JUMP_TO_ERROR(); } value = PyStackRef_FromPyObjectSteal(value_o); @@ -1887,7 +2001,9 @@ PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); break; } @@ -1916,6 +2032,8 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(pieces[_i]); } + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyObject *str_o = _PyUnicode_JoinArray(&_Py_STR(empty), pieces_o, oparg); @@ -1923,10 +2041,12 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(pieces[_i]); } + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); if (str_o == NULL) JUMP_TO_ERROR(); str = PyStackRef_FromPyObjectSteal(str_o); - stack_pointer[-oparg] = str; - stack_pointer += 1 - oparg; + stack_pointer[0] = str; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1937,10 +2057,12 @@ oparg = CURRENT_OPARG(); values = &stack_pointer[-oparg]; PyObject *tup_o = _PyTuple_FromStackRefSteal(values, oparg); + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); if (tup_o == NULL) JUMP_TO_ERROR(); tup = PyStackRef_FromPyObjectSteal(tup_o); - stack_pointer[-oparg] = tup; - stack_pointer += 1 - oparg; + stack_pointer[0] = tup; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1951,10 +2073,12 @@ oparg = CURRENT_OPARG(); values = &stack_pointer[-oparg]; PyObject *list_o = _PyList_FromStackRefSteal(values, oparg); + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); if (list_o == NULL) JUMP_TO_ERROR(); list = PyStackRef_FromPyObjectSteal(list_o); - stack_pointer[-oparg] = list; - stack_pointer += 1 - oparg; + stack_pointer[0] = list; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1969,16 +2093,22 @@ PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable); + stack_pointer = _PyFrame_GetStackPointer(frame); if (none_val == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_TypeError); + stack_pointer = _PyFrame_GetStackPointer(frame); if (matches && (Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable))) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Clear(tstate); _PyErr_Format(tstate, PyExc_TypeError, "Value after * must be an iterable, not %.200s", Py_TYPE(iterable)->tp_name); + stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(iterable_st); if (true) JUMP_TO_ERROR(); @@ -1996,8 +2126,10 @@ set = stack_pointer[-2 - (oparg-1)]; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(iterable)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); if (err < 0) JUMP_TO_ERROR(); break; @@ -2010,7 +2142,9 @@ values = &stack_pointer[-oparg]; stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *set_o = PySet_New(NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); if (set_o == NULL) { for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); @@ -2020,7 +2154,9 @@ int err = 0; for (int i = 0; i < oparg; i++) { if (err == 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); err = PySet_Add(set_o, PyStackRef_AsPyObjectBorrow(values[i])); + stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(values[i]); } @@ -2045,14 +2181,18 @@ for (int _i = oparg*2; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } + stack_pointer += -oparg*2; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } stack_pointer += -oparg*2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *map_o = _PyDict_FromItems( values_o, 2, values_o+1, 2, oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(values_o); for (int _i = oparg*2; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); @@ -2069,17 +2209,25 @@ int err; PyObject *ann_dict; if (LOCALS() == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when setting up annotations"); + stack_pointer = _PyFrame_GetStackPointer(frame); if (true) JUMP_TO_ERROR(); } /* check if __annotations__ in locals()... */ + _PyFrame_SetStackPointer(frame, stack_pointer); if (PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict) < 0) JUMP_TO_ERROR(); + stack_pointer = _PyFrame_GetStackPointer(frame); if (ann_dict == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); ann_dict = PyDict_New(); + stack_pointer = _PyFrame_GetStackPointer(frame); if (ann_dict == NULL) JUMP_TO_ERROR(); + _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__), ann_dict); + stack_pointer = _PyFrame_GetStackPointer(frame); Py_DECREF(ann_dict); if (err) JUMP_TO_ERROR(); } @@ -2099,13 +2247,19 @@ PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_Update(dict_o, update_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_AttributeError); + stack_pointer = _PyFrame_GetStackPointer(frame); if (matches) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'%.200s' object is not a mapping", Py_TYPE(update_o)->tp_name); + stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(update); if (true) JUMP_TO_ERROR(); @@ -2127,9 +2281,13 @@ PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_MergeEx(dict_o, update_o, 2); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatKwargsError(tstate, callable_o, update_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(update); if (true) JUMP_TO_ERROR(); } @@ -2151,11 +2309,13 @@ // Do not DECREF INPUTS because the function steals the references stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_SetItem_Take2( (PyDictObject *)dict, PyStackRef_AsPyObjectSteal(key), PyStackRef_AsPyObjectSteal(value) ); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) JUMP_TO_ERROR(); break; } @@ -2187,7 +2347,9 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); PyStackRef_CLOSE(self_st); @@ -2227,8 +2389,10 @@ int method_found = 0; stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attr_o = _PySuper_Lookup(cls, self, name, Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? &method_found : NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); if (attr_o == NULL) { @@ -2262,7 +2426,9 @@ attr_o = NULL; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int is_meth = _PyObject_GetMethod(PyStackRef_AsPyObjectBorrow(owner), name, &attr_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (is_meth) { /* We can bypass temporary bound method object. meth is unbound method and obj is self. @@ -2287,7 +2453,9 @@ /* Classic, pushes one value. */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(owner); if (attr_o == NULL) JUMP_TO_ERROR(); /* We need to define self_or_null on all paths */ @@ -2694,14 +2862,22 @@ JUMP_TO_JUMP_TARGET(); } /* Ensure dict is GC tracked if it needs to be */ - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(PyStackRef_AsPyObjectBorrow(value))) { + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyObject_GC_TRACK(dict); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += 2; + assert(WITHIN_STACK_BOUNDS()); } old_value = ep->me_value; PyDict_WatchEvent event = old_value == NULL ? PyDict_EVENT_ADDED : PyDict_EVENT_MODIFIED; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); new_version = _PyDict_NotifyEvent(tstate->interp, event, dict, name, PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); ep->me_value = PyStackRef_AsPyObjectSteal(value); dict->ma_version_tag = new_version; // PEP 509 // old_value should be DECREFed after GC track checking is done, if not, it could raise a segmentation fault, @@ -2742,12 +2918,16 @@ assert((oparg >> 5) <= Py_GE); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res_o == NULL) JUMP_TO_ERROR(); if (oparg & 16) { + _PyFrame_SetStackPointer(frame, stack_pointer); int res_bool = PyObject_IsTrue(res_o); + stack_pointer = _PyFrame_GetStackPointer(frame); Py_DECREF(res_o); if (res_bool < 0) JUMP_TO_ERROR(); res = res_bool ? PyStackRef_True : PyStackRef_False; @@ -2878,7 +3058,9 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int res = PySequence_Contains(right_o, left_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res < 0) JUMP_TO_ERROR(); @@ -2906,7 +3088,9 @@ // Note: both set and frozenset use the same seq_contains method! stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PySet_Contains((PySetObject *)right_o, left_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res < 0) JUMP_TO_ERROR(); @@ -2933,7 +3117,9 @@ STAT_INC(CONTAINS_OP, hit); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyDict_Contains(right_o, left_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res < 0) JUMP_TO_ERROR(); @@ -2955,7 +3141,9 @@ PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { PyStackRef_CLOSE(exc_value_st); PyStackRef_CLOSE(match_type_st); @@ -2963,15 +3151,19 @@ } PyObject *match_o = NULL; PyObject *rest_o = NULL; + _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_ExceptionGroupMatch(exc_value, match_type, &match_o, &rest_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(exc_value_st); PyStackRef_CLOSE(match_type_st); if (res < 0) JUMP_TO_ERROR(); assert((match_o == NULL) == (rest_o == NULL)); if (match_o == NULL) JUMP_TO_ERROR(); if (!Py_IsNone(match_o)) { + _PyFrame_SetStackPointer(frame, stack_pointer); PyErr_SetHandledException(match_o); + stack_pointer = _PyFrame_GetStackPointer(frame); } rest = PyStackRef_FromPyObjectSteal(rest_o); match = PyStackRef_FromPyObjectSteal(match_o); @@ -2993,12 +3185,16 @@ assert(PyExceptionInstance_Check(left_o)); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyEval_CheckExceptTypeValid(tstate, right_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { PyStackRef_CLOSE(right); if (true) JUMP_TO_ERROR(); } + _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyErr_GivenExceptionMatches(left_o, right_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(right); b = res ? PyStackRef_True : PyStackRef_False; stack_pointer[0] = b; @@ -3017,9 +3213,11 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_ImportName(tstate, frame, name, PyStackRef_AsPyObjectBorrow(fromlist), PyStackRef_AsPyObjectBorrow(level)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(level); PyStackRef_CLOSE(fromlist); if (res_o == NULL) JUMP_TO_ERROR(); @@ -3036,7 +3234,9 @@ oparg = CURRENT_OPARG(); from = stack_pointer[-1]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name); + stack_pointer = _PyFrame_GetStackPointer(frame); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; @@ -3069,9 +3269,13 @@ _PyStackRef len; obj = stack_pointer[-1]; // PUSH(len(TOS)) + _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (len_i < 0) JUMP_TO_ERROR(); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *len_o = PyLong_FromSsize_t(len_i); + stack_pointer = _PyFrame_GetStackPointer(frame); if (len_o == NULL) JUMP_TO_ERROR(); len = PyStackRef_FromPyObjectSteal(len_o); stack_pointer[0] = len; @@ -3094,10 +3298,12 @@ assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names))); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attrs_o = _PyEval_MatchClass(tstate, PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(type), oparg, PyStackRef_AsPyObjectBorrow(names)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(subject); PyStackRef_CLOSE(type); PyStackRef_CLOSE(names); @@ -3147,8 +3353,10 @@ keys = stack_pointer[-1]; subject = stack_pointer[-2]; // On successful match, PUSH(values). Otherwise, PUSH(None). + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *values_or_none_o = _PyEval_MatchKeys(tstate, PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (values_or_none_o == NULL) JUMP_TO_ERROR(); values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o); stack_pointer[0] = values_or_none; @@ -3164,12 +3372,14 @@ /* before: [obj]; after [getiter(obj)] */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable))); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); - if (PyStackRef_IsNull(iter)) JUMP_TO_ERROR(); stack_pointer[0] = iter; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + if (PyStackRef_IsNull(iter)) JUMP_TO_ERROR(); break; } @@ -3186,9 +3396,11 @@ regular generator. */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_TypeError, "cannot 'yield from' a coroutine object " "in a non-coroutine generator"); + stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); } iter = iterable; @@ -3200,7 +3412,9 @@ /* `iterable` is not a generator. */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (PyStackRef_IsNull(iter)) { JUMP_TO_ERROR(); } @@ -3223,12 +3437,16 @@ PyObject *next_o = (*Py_TYPE(iter_o)->tp_iternext)(iter_o); if (next_o == NULL) { if (_PyErr_Occurred(tstate)) { + _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); + stack_pointer = _PyFrame_GetStackPointer(frame); if (!matches) { JUMP_TO_ERROR(); } + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_MonitorRaise(tstate, frame, frame->instr_ptr); _PyErr_Clear(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); } /* iterator ended normally */ /* The translator sets the deopt target just past the matching END_FOR */ @@ -3429,23 +3647,30 @@ PyObject *self_or_null_o; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); attr = PyStackRef_FromPyObjectSteal(_PyObject_LookupSpecialMethod(owner_o, name, &self_or_null_o)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (PyStackRef_IsNull(attr)) { if (!_PyErr_Occurred(tstate)) { stack_pointer[0] = attr; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, _Py_SpecialMethods[oparg].error, - Py_TYPE(owner_o)->tp_name);stack_pointer += -1; + Py_TYPE(owner_o)->tp_name); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } } + stack_pointer[0] = attr; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(attr)) JUMP_TO_ERROR(); self_or_null = PyStackRef_FromPyObjectSteal(self_or_null_o); - stack_pointer[0] = attr; - stack_pointer[1] = self_or_null; - stack_pointer += 2; + stack_pointer[0] = self_or_null; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -3473,8 +3698,10 @@ PyObject *val_o = PyStackRef_AsPyObjectBorrow(val); PyObject *exit_func_o = PyStackRef_AsPyObjectBorrow(exit_func); assert(val_o && PyExceptionInstance_Check(val_o)); + _PyFrame_SetStackPointer(frame, stack_pointer); exc = PyExceptionInstance_Class(val_o); tb = PyException_GetTraceback(val_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (tb == NULL) { tb = Py_None; } @@ -3485,12 +3712,14 @@ (void)lasti; // Shut up compiler warning if asserts are off PyObject *stack[5] = {NULL, PyStackRef_AsPyObjectBorrow(exit_self), exc, val_o, tb}; int has_self = !PyStackRef_IsNull(exit_self); + _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Vectorcall(exit_func_o, stack + 2 - has_self, (3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL)); - if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); + stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); break; } @@ -3703,10 +3932,12 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, total_args, NULL, frame ); + stack_pointer = _PyFrame_GetStackPointer(frame); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { @@ -3827,14 +4058,18 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, total_args | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(callable); @@ -4151,12 +4386,14 @@ STAT_INC(CALL, hit); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(arg); - if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); break; } @@ -4183,12 +4420,14 @@ STAT_INC(CALL, hit); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(arg); - if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); break; } @@ -4228,7 +4467,9 @@ STAT_INC(CALL, hit); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); self = PyStackRef_FromPyObjectSteal(_PyType_NewManagedObject(tp)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (PyStackRef_IsNull(self)) { JUMP_TO_ERROR(); } @@ -4252,15 +4493,19 @@ self = stack_pointer[-2 - oparg]; stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame); assert(_PyCode_CODE((PyCodeObject *)shim->f_executable)[0].op.code == EXIT_INIT_CHECK); + stack_pointer = _PyFrame_GetStackPointer(frame); /* Push self onto stack of shim */ shim->localsplus[0] = PyStackRef_DUP(self); PyFunctionObject *init_func = (PyFunctionObject *)PyStackRef_AsPyObjectSteal(init); args[-1] = self; + _PyFrame_SetStackPointer(frame, stack_pointer); init_frame = _PyEvalFramePushAndInit( tstate, init_func, NULL, args-1, oparg+1, NULL, shim); + stack_pointer = _PyFrame_GetStackPointer(frame); if (init_frame == NULL) { _PyEval_FrameClearAndPop(tstate, shim); JUMP_TO_ERROR(); @@ -4283,9 +4528,11 @@ if (!PyStackRef_Is(should_be_none, PyStackRef_None)) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyErr_Format(PyExc_TypeError, "__init__() should return None, not '%.200s'", Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name); + stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); } stack_pointer += -1; @@ -4325,6 +4572,8 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyObject *res_o = tp->tp_vectorcall((PyObject *)tp, args_o, total_args, NULL); @@ -4334,10 +4583,12 @@ PyStackRef_CLOSE(args[i]); } PyStackRef_CLOSE(callable); + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4378,10 +4629,12 @@ STAT_INC(CALL, hit); PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o); _PyStackRef arg = args[0]; + _Py_EnterRecursiveCallTstateUnchecked(tstate); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); - _Py_EnterRecursiveCallTstateUnchecked(tstate); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg)); + stack_pointer = _PyFrame_GetStackPointer(frame); _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(arg); @@ -4428,6 +4681,8 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyObject *res_o = ((PyCFunctionFast)(void(*)(void))cfunc)( @@ -4441,10 +4696,12 @@ PyStackRef_CLOSE(args[i]); } PyStackRef_CLOSE(callable); + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4485,6 +4742,8 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyObject *res_o = cfunc(PyCFunction_GET_SELF(callable_o), args_o, total_args, NULL); @@ -4495,10 +4754,12 @@ PyStackRef_CLOSE(args[i]); } PyStackRef_CLOSE(callable); + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4533,11 +4794,15 @@ PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(arg); + stack_pointer = _PyFrame_GetStackPointer(frame); if (len_i < 0) { JUMP_TO_ERROR(); } + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyLong_FromSsize_t(len_i); + stack_pointer = _PyFrame_GetStackPointer(frame); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); if (res_o == NULL) { GOTO_ERROR(error); @@ -4581,7 +4846,9 @@ _PyStackRef inst_stackref = args[0]; stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (retval < 0) { JUMP_TO_ERROR(); } @@ -4621,6 +4888,8 @@ int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg)); PyStackRef_CLOSE(self); PyStackRef_CLOSE(callable); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); #if TIER_ONE // Skip the following POP_TOP. This is done here in tier one, and @@ -4628,8 +4897,6 @@ assert(next_instr->op.code == POP_TOP); SKIP_OVER(1); #endif - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -4676,12 +4943,14 @@ } STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; + _Py_EnterRecursiveCallTstateUnchecked(tstate); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); - _Py_EnterRecursiveCallTstateUnchecked(tstate); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyStackRef_AsPyObjectBorrow(self_stackref), PyStackRef_AsPyObjectBorrow(arg_stackref)); + stack_pointer = _PyFrame_GetStackPointer(frame); _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); @@ -4737,6 +5006,8 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyObject *res_o = cfunc(self, (args_o + 1), nargs, NULL); @@ -4747,10 +5018,12 @@ PyStackRef_CLOSE(args[i]); } PyStackRef_CLOSE(callable); + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4798,10 +5071,12 @@ } STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; + _Py_EnterRecursiveCallTstateUnchecked(tstate); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); - _Py_EnterRecursiveCallTstateUnchecked(tstate); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); @@ -4856,6 +5131,8 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyObject *res_o = cfunc(self, (args_o + 1), nargs); @@ -4866,10 +5143,12 @@ PyStackRef_CLOSE(args[i]); } PyStackRef_CLOSE(callable); + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4904,10 +5183,12 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, positional_args, kwnames_o, frame ); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(kwnames); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. @@ -5035,16 +5316,20 @@ PyStackRef_CLOSE(args[_i]); } PyStackRef_CLOSE(kwnames); + stack_pointer += -3 - oparg; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(kwnames); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); @@ -5071,14 +5356,18 @@ PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyFunctionObject *func_obj = (PyFunctionObject *) PyFunction_New(codeobj, GLOBALS()); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(codeobj_st); if (func_obj == NULL) { JUMP_TO_ERROR(); } + _PyFrame_SetStackPointer(frame, stack_pointer); _PyFunction_SetVersion( func_obj, ((PyCodeObject *)codeobj)->co_version); + stack_pointer = _PyFrame_GetStackPointer(frame); func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj); stack_pointer[0] = func; stack_pointer += 1; @@ -5110,24 +5399,26 @@ _PyStackRef res; assert(PyFunction_Check(frame->f_funcobj)); PyFunctionObject *func = (PyFunctionObject *)frame->f_funcobj; + _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func); + stack_pointer = _PyFrame_GetStackPointer(frame); if (gen == NULL) { JUMP_TO_ERROR(); } assert(EMPTY()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *gen_frame = &gen->gi_iframe; - frame->instr_ptr++; - _PyFrame_Copy(frame, gen_frame); + frame->instr_ptr++;/* Virtual flush 1 */ + _PyFrame_Copy(frame, gen_frame);/* Virtual reload 1 */ assert(frame->frame_obj == NULL); gen->gi_frame_state = FRAME_CREATED; gen_frame->owner = FRAME_OWNED_BY_GENERATOR; _Py_LeaveRecursiveCallPy(tstate); - _PyInterpreterFrame *prev = frame->previous; - _PyThreadState_PopFrame(tstate, frame); + _PyInterpreterFrame *prev = frame->previous;/* Virtual flush 1 */ + _PyThreadState_PopFrame(tstate, frame);/* Virtual reload 1 */ frame = tstate->current_frame = prev; LOAD_IP(frame->return_offset); - LOAD_SP(); + stack_pointer = _PyFrame_GetStackPointer(frame); res = PyStackRef_FromPyObjectSteal((PyObject *)gen); LLTRACE_RESUME_FRAME(); stack_pointer[0] = res; @@ -5152,10 +5443,12 @@ PyStackRef_CLOSE(start); PyStackRef_CLOSE(stop); PyStackRef_XCLOSE(step); + stack_pointer += -2 - ((oparg == 3) ? 1 : 0); + assert(WITHIN_STACK_BOUNDS()); if (slice_o == NULL) JUMP_TO_ERROR(); slice = PyStackRef_FromPyObjectSteal(slice_o); - stack_pointer[-2 - ((oparg == 3) ? 1 : 0)] = slice; - stack_pointer += -1 - ((oparg == 3) ? 1 : 0); + stack_pointer[0] = slice; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -5170,9 +5463,13 @@ conv_fn = _PyEval_ConversionFuncs[oparg]; PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value)); PyStackRef_CLOSE(value); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (result_o == NULL) JUMP_TO_ERROR(); result = PyStackRef_FromPyObjectSteal(result_o); - stack_pointer[-1] = result; + stack_pointer[0] = result; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -5186,17 +5483,19 @@ if (!PyUnicode_CheckExact(value_o)) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Format(value_o, NULL)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); } else { - res = value;stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + res = value; } - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; break; } @@ -5208,7 +5507,9 @@ value = stack_pointer[-2]; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); PyStackRef_CLOSE(fmt_spec); if (res_o == NULL) JUMP_TO_ERROR(); @@ -5245,10 +5546,12 @@ PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o); PyStackRef_CLOSE(lhs); PyStackRef_CLOSE(rhs); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[-2] = res; - stack_pointer += -1; + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -5375,21 +5678,27 @@ PyObject *exit_p = (PyObject *)CURRENT_OPERAND(); _PyExitData *exit = (_PyExitData *)exit_p; PyCodeObject *code = _PyFrame_GetCode(frame); + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_CODEUNIT *target = _PyCode_CODE(code) + exit->target; + stack_pointer = _PyFrame_GetStackPointer(frame); #if defined(Py_DEBUG) && !defined(_Py_JIT) OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); if (lltrace >= 2) { printf("SIDE EXIT: [UOp "); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyUOpPrint(&next_uop[-1]); printf(", exit %u, temp %d, target %d -> %s]\n", exit - current_executor->exits, exit->temperature.as_counter, (int)(target - _PyCode_CODE(code)), _PyOpcode_OpName[target->op.code]); + stack_pointer = _PyFrame_GetStackPointer(frame); } #endif if (exit->executor && !exit->executor->vm_data.valid) { exit->temperature = initial_temperature_backoff_counter(); + _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(exit->executor); + stack_pointer = _PyFrame_GetStackPointer(frame); } if (exit->executor == NULL) { _Py_BackoffCounter temperature = exit->temperature; @@ -5405,7 +5714,9 @@ } else { int chain_depth = current_executor->vm_data.chain_depth + 1; + _PyFrame_SetStackPointer(frame, stack_pointer); int optimized = _PyOptimizer_Optimize(frame, target, stack_pointer, &executor, chain_depth); + stack_pointer = _PyFrame_GetStackPointer(frame); if (optimized <= 0) { exit->temperature = restart_backoff_counter(temperature); if (optimized < 0) { @@ -5519,11 +5830,13 @@ OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); if (lltrace >= 2) { printf("DYNAMIC EXIT: [UOp "); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyUOpPrint(&next_uop[-1]); printf(", exit %u, temp %d, target %d -> %s]\n", exit - current_executor->exits, exit->temperature.as_counter, (int)(target - _PyCode_CODE(_PyFrame_GetCode(frame))), _PyOpcode_OpName[target->op.code]); + stack_pointer = _PyFrame_GetStackPointer(frame); } #endif _PyExecutorObject *executor; @@ -5537,7 +5850,9 @@ exit->temperature = advance_backoff_counter(exit->temperature); GOTO_TIER_ONE(target); } + _PyFrame_SetStackPointer(frame, stack_pointer); int optimized = _PyOptimizer_Optimize(frame, target, stack_pointer, &executor, 0); + stack_pointer = _PyFrame_GetStackPointer(frame); if (optimized <= 0) { exit->temperature = restart_backoff_counter(exit->temperature); if (optimized < 0) { @@ -5591,6 +5906,13 @@ oparg = CURRENT_OPARG(); uint32_t target = (uint32_t)CURRENT_OPERAND(); frame->instr_ptr = ((_Py_CODEUNIT *)_PyFrame_GetCode(frame)->co_code_adaptive) + target; + { + stack_pointer -= oparg; + if (!WITHIN_STACK_BOUNDS()) { + printf("Stacke level: %d, oparg: %d\n", STACK_LEVEL(), oparg); + } + stack_pointer += oparg; + } stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); GOTO_UNWIND(); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 21c9e792ec6965..d78632d077bf97 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -28,7 +28,9 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_BinaryOp(lhs, rhs, next_instr, oparg, LOCALS_ARRAY); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(BINARY_OP); @@ -204,8 +206,10 @@ */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); assert(Py_REFCNT(left_o) >= 2); _Py_DECREF_NO_DEALLOC(left_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyObject *temp = PyStackRef_AsPyObjectBorrow(*target_local); PyUnicode_Append(&temp, right_o); *target_local = PyStackRef_FromPyObjectSteal(temp); @@ -376,8 +380,10 @@ container = stack_pointer[-3]; stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyObject *res_o; OPCODE_DEFERRED_INC(BINARY_SLICE); // Can't use ERROR_IF() here, because we haven't @@ -386,7 +392,9 @@ res_o = NULL; } else { + _PyFrame_SetStackPointer(frame, stack_pointer); res_o = PyObject_GetItem(PyStackRef_AsPyObjectBorrow(container), slice); + stack_pointer = _PyFrame_GetStackPointer(frame); Py_DECREF(slice); } PyStackRef_CLOSE(container); @@ -417,7 +425,9 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_BinarySubscr(container, sub, next_instr); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(BINARY_SUBSCR); @@ -430,7 +440,9 @@ PyObject *sub_o = PyStackRef_AsPyObjectBorrow(sub); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_GetItem(container_o, sub_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); if (res_o == NULL) goto error; @@ -460,9 +472,13 @@ PyObject *res_o; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int rc = PyDict_GetItemRef(dict, sub, &res_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (rc == 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetKeyError(sub); + stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(dict_st); PyStackRef_CLOSE(sub_st); @@ -492,7 +508,9 @@ container = stack_pointer[-2]; { PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(container)); + _PyFrame_SetStackPointer(frame, stack_pointer); DEOPT_IF(!PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE), BINARY_SUBSCR); + stack_pointer = _PyFrame_GetStackPointer(frame); PyHeapTypeObject *ht = (PyHeapTypeObject *)tp; PyObject *getitem = ht->_spec_cache.getitem; DEOPT_IF(getitem == NULL, BINARY_SUBSCR); @@ -671,10 +689,12 @@ } stack_pointer += -oparg*2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *map_o = _PyDict_FromItems( values_o, 2, values_o+1, 2, oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(values_o); for (int _i = oparg*2; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); @@ -696,7 +716,9 @@ values = &stack_pointer[-oparg]; stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *set_o = PySet_New(NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); if (set_o == NULL) { for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); @@ -706,7 +728,9 @@ int err = 0; for (int i = 0; i < oparg; i++) { if (err == 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); err = PySet_Add(set_o, PyStackRef_AsPyObjectBorrow(values[i])); + stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(values[i]); } @@ -837,7 +861,9 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_Call(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null)); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(CALL); @@ -885,10 +911,12 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, total_args, NULL, frame ); + stack_pointer = _PyFrame_GetStackPointer(frame); // Manipulate stack directly since we leave using DISPATCH_INLINED(). // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. @@ -913,25 +941,33 @@ } stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, total_args | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); if (opcode == INSTRUMENTED_CALL) { PyObject *arg = total_args == 0 ? &_PyInstrumentation_MISSING : PyStackRef_AsPyObjectBorrow(args[0]); if (res_o == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, callable_o, arg); + stack_pointer = _PyFrame_GetStackPointer(frame); } else { + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, callable_o, arg); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(res_o); + stack_pointer = _PyFrame_GetStackPointer(frame); } } } @@ -951,7 +987,9 @@ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -999,7 +1037,9 @@ STAT_INC(CALL, hit); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); self = PyStackRef_FromPyObjectSteal(_PyType_NewManagedObject(tp)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (PyStackRef_IsNull(self)) { goto error; } @@ -1008,15 +1048,19 @@ } // _CREATE_INIT_FRAME { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame); assert(_PyCode_CODE((PyCodeObject *)shim->f_executable)[0].op.code == EXIT_INIT_CHECK); + stack_pointer = _PyFrame_GetStackPointer(frame); /* Push self onto stack of shim */ shim->localsplus[0] = PyStackRef_DUP(self); PyFunctionObject *init_func = (PyFunctionObject *)PyStackRef_AsPyObjectSteal(init); args[-1] = self; + _PyFrame_SetStackPointer(frame, stack_pointer); init_frame = _PyEvalFramePushAndInit( tstate, init_func, NULL, args-1, oparg+1, NULL, shim); + stack_pointer = _PyFrame_GetStackPointer(frame); if (init_frame == NULL) { _PyEval_FrameClearAndPop(tstate, shim); goto error; @@ -1208,10 +1252,12 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, total_args, NULL, frame ); + stack_pointer = _PyFrame_GetStackPointer(frame); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { @@ -1305,7 +1351,9 @@ stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1384,7 +1432,9 @@ stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1462,7 +1512,9 @@ stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1505,10 +1557,12 @@ STAT_INC(CALL, hit); PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o); _PyStackRef arg = args[0]; + _Py_EnterRecursiveCallTstateUnchecked(tstate); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); - _Py_EnterRecursiveCallTstateUnchecked(tstate); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg)); + stack_pointer = _PyFrame_GetStackPointer(frame); _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(arg); @@ -1524,7 +1578,9 @@ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1565,7 +1621,9 @@ } stack_pointer += -3 - (oparg & 1); assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *tuple = PySequence_Tuple(callargs); + stack_pointer = _PyFrame_GetStackPointer(frame); if (tuple == NULL) { goto error; } @@ -1581,29 +1639,37 @@ PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING; stack_pointer += -3 - (oparg & 1); assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, func, arg); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { goto error; } + _PyFrame_SetStackPointer(frame, stack_pointer); result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (!PyFunction_Check(func) && !PyMethod_Check(func)) { if (PyStackRef_IsNull(result)) { stack_pointer[0] = result; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, func, arg); + stack_pointer = _PyFrame_GetStackPointer(frame); } else { stack_pointer[0] = result; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, func, arg); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { PyStackRef_CLEAR(result); } @@ -1621,9 +1687,11 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func)); stack_pointer += -3 - (oparg & 1); assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(func_st), locals, nargs, callargs, kwargs, frame); + stack_pointer = _PyFrame_GetStackPointer(frame); // Need to sync the stack since we exit with DISPATCH_INLINED. if (new_frame == NULL) { goto error; @@ -1634,7 +1702,9 @@ } stack_pointer += -3 - (oparg & 1); assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); + stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(func_st); PyStackRef_CLOSE(callargs_st); @@ -1649,7 +1719,9 @@ stack_pointer[0] = result; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1729,7 +1801,9 @@ _PyStackRef inst_stackref = args[0]; stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (retval < 0) { goto error; } @@ -1765,7 +1839,9 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_CallKw(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null)); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(CALL_KW); @@ -1807,10 +1883,12 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, positional_args, kwnames_o, frame ); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(kwnames); // Sync stack explicitly since we leave using DISPATCH_INLINED(). // The frame has stolen all the arguments from the stack, @@ -1839,25 +1917,33 @@ } stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames_o); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); if (opcode == INSTRUMENTED_CALL_KW) { PyObject *arg = total_args == 0 ? &_PyInstrumentation_MISSING : PyStackRef_AsPyObjectBorrow(args[0]); if (res_o == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, callable_o, arg); + stack_pointer = _PyFrame_GetStackPointer(frame); } else { + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, callable_o, arg); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(res_o); + stack_pointer = _PyFrame_GetStackPointer(frame); } } } @@ -1941,10 +2027,12 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, positional_args, kwnames_o, frame ); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(kwnames); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. @@ -2031,10 +2119,12 @@ int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, positional_args | PY_VECTORCALL_ARGUMENTS_OFFSET, kwnames_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(kwnames); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); @@ -2053,7 +2143,9 @@ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -2109,10 +2201,12 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, positional_args, kwnames_o, frame ); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(kwnames); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. @@ -2175,11 +2269,15 @@ PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(arg); + stack_pointer = _PyFrame_GetStackPointer(frame); if (len_i < 0) { goto error; } + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyLong_FromSsize_t(len_i); + stack_pointer = _PyFrame_GetStackPointer(frame); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); if (res_o == NULL) { GOTO_ERROR(error); @@ -2298,7 +2396,9 @@ stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2379,7 +2479,9 @@ stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2426,10 +2528,12 @@ DEOPT_IF(tstate->c_recursion_remaining <= 0, CALL); STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; + _Py_EnterRecursiveCallTstateUnchecked(tstate); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); - _Py_EnterRecursiveCallTstateUnchecked(tstate); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); @@ -2445,7 +2549,9 @@ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -2492,12 +2598,14 @@ method->d_common.d_type), CALL); STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; + _Py_EnterRecursiveCallTstateUnchecked(tstate); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); - _Py_EnterRecursiveCallTstateUnchecked(tstate); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyStackRef_AsPyObjectBorrow(self_stackref), PyStackRef_AsPyObjectBorrow(arg_stackref)); + stack_pointer = _PyFrame_GetStackPointer(frame); _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); @@ -2514,7 +2622,9 @@ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -2574,10 +2684,12 @@ } stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, total_args | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(callable); @@ -2595,7 +2707,9 @@ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -2729,10 +2843,12 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, total_args, NULL, frame ); + stack_pointer = _PyFrame_GetStackPointer(frame); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { @@ -2789,7 +2905,9 @@ STAT_INC(CALL, hit); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(arg); if (PyStackRef_IsNull(res)) goto error; } @@ -2801,7 +2919,9 @@ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -2837,7 +2957,9 @@ STAT_INC(CALL, hit); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(arg); if (PyStackRef_IsNull(res)) goto error; } @@ -2849,7 +2971,9 @@ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -2903,7 +3027,9 @@ PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { PyStackRef_CLOSE(exc_value_st); PyStackRef_CLOSE(match_type_st); @@ -2911,15 +3037,19 @@ } PyObject *match_o = NULL; PyObject *rest_o = NULL; + _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_ExceptionGroupMatch(exc_value, match_type, &match_o, &rest_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(exc_value_st); PyStackRef_CLOSE(match_type_st); if (res < 0) goto error; assert((match_o == NULL) == (rest_o == NULL)); if (match_o == NULL) goto error; if (!Py_IsNone(match_o)) { + _PyFrame_SetStackPointer(frame, stack_pointer); PyErr_SetHandledException(match_o); + stack_pointer = _PyFrame_GetStackPointer(frame); } rest = PyStackRef_FromPyObjectSteal(rest_o); match = PyStackRef_FromPyObjectSteal(match_o); @@ -2944,12 +3074,16 @@ assert(PyExceptionInstance_Check(left_o)); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyEval_CheckExceptTypeValid(tstate, right_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { PyStackRef_CLOSE(right); if (true) goto error; } + _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyErr_GivenExceptionMatches(left_o, right_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(right); b = res ? PyStackRef_True : PyStackRef_False; stack_pointer[0] = b; @@ -2976,7 +3110,9 @@ assert(exc_value && PyExceptionInstance_Check(exc_value)); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int matches = PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration); + stack_pointer = _PyFrame_GetStackPointer(frame); if (matches) { value = PyStackRef_FromPyObjectNew(((PyStopIterationObject *)exc_value)->value); PyStackRef_CLOSE(sub_iter_st); @@ -2985,7 +3121,9 @@ none = PyStackRef_None; } else { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetRaisedException(tstate, Py_NewRef(exc_value)); + stack_pointer = _PyFrame_GetStackPointer(frame); monitor_reraise(tstate, frame, this_instr); goto exception_unwind; } @@ -3015,7 +3153,9 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_CompareOp(left, right, next_instr, oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(COMPARE_OP); @@ -3029,12 +3169,16 @@ assert((oparg >> 5) <= Py_GE); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res_o == NULL) goto error; if (oparg & 16) { + _PyFrame_SetStackPointer(frame, stack_pointer); int res_bool = PyObject_IsTrue(res_o); + stack_pointer = _PyFrame_GetStackPointer(frame); Py_DECREF(res_o); if (res_bool < 0) goto error; res = res_bool ? PyStackRef_True : PyStackRef_False; @@ -3186,7 +3330,9 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_ContainsOp(right, next_instr); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(CONTAINS_OP); @@ -3200,7 +3346,9 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int res = PySequence_Contains(right_o, left_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res < 0) goto error; @@ -3229,7 +3377,9 @@ STAT_INC(CONTAINS_OP, hit); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyDict_Contains(right_o, left_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res < 0) goto error; @@ -3258,7 +3408,9 @@ // Note: both set and frozenset use the same seq_contains method! stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PySet_Contains((PySetObject *)right_o, left_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res < 0) goto error; @@ -3328,7 +3480,9 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(owner); if (err) goto error; DISPATCH(); @@ -3341,9 +3495,13 @@ PyObject *cell = PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); // Can't use ERROR_IF here. // Fortunately we don't need its superpower. + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *oldobj = PyCell_SwapTakeRef((PyCellObject *)cell, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); if (oldobj == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); goto error; } Py_DECREF(oldobj); @@ -3356,10 +3514,12 @@ INSTRUCTION_STATS(DELETE_FAST); _PyStackRef v = GETLOCAL(oparg); if (PyStackRef_IsNull(v)) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError, UNBOUNDLOCAL_ERROR_MSG, PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg) ); + stack_pointer = _PyFrame_GetStackPointer(frame); if (1) goto error; } SETLOCAL(oparg, PyStackRef_NULL); @@ -3371,14 +3531,18 @@ next_instr += 1; INSTRUCTION_STATS(DELETE_GLOBAL); PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_Pop(GLOBALS(), name, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); // Can't use ERROR_IF here. if (err < 0) { goto error; } if (err == 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, name); + stack_pointer = _PyFrame_GetStackPointer(frame); goto error; } DISPATCH(); @@ -3392,16 +3556,22 @@ PyObject *ns = LOCALS(); int err; if (ns == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals when deleting %R", name); + stack_pointer = _PyFrame_GetStackPointer(frame); goto error; } + _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_DelItem(ns, name); + stack_pointer = _PyFrame_GetStackPointer(frame); // Can't use ERROR_IF here. if (err != 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, name); + stack_pointer = _PyFrame_GetStackPointer(frame); goto error; } DISPATCH(); @@ -3418,8 +3588,10 @@ /* del container[sub] */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); if (err) goto error; @@ -3441,9 +3613,13 @@ PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_MergeEx(dict_o, update_o, 2); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatKwargsError(tstate, callable_o, update_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(update); if (true) goto error; } @@ -3463,13 +3639,19 @@ PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_Update(dict_o, update_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_AttributeError); + stack_pointer = _PyFrame_GetStackPointer(frame); if (matches) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'%.200s' object is not a mapping", Py_TYPE(update_o)->tp_name); + stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(update); if (true) goto error; @@ -3491,13 +3673,18 @@ assert(exc && PyExceptionInstance_Check(exc)); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); - if (PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration)) { + _PyFrame_SetStackPointer(frame, stack_pointer); + int matches = PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (matches) { PyStackRef_CLOSE(awaitable_st); PyStackRef_CLOSE(exc_st); } else { Py_INCREF(exc); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetRaisedException(tstate, exc); + stack_pointer = _PyFrame_GetStackPointer(frame); monitor_reraise(tstate, frame, this_instr); goto exception_unwind; } @@ -3575,9 +3762,11 @@ if (!PyStackRef_Is(should_be_none, PyStackRef_None)) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyErr_Format(PyExc_TypeError, "__init__() should return None, not '%.200s'", Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name); + stack_pointer = _PyFrame_GetStackPointer(frame); goto error; } stack_pointer += -1; @@ -3609,7 +3798,9 @@ if (!PyUnicode_CheckExact(value_o)) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Format(value_o, NULL)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); if (PyStackRef_IsNull(res)) goto error; } @@ -3634,7 +3825,9 @@ value = stack_pointer[-2]; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); PyStackRef_CLOSE(fmt_spec); if (res_o == NULL) goto error; @@ -3662,7 +3855,9 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_ForIter(iter, next_instr, oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(FOR_ITER); @@ -3680,12 +3875,17 @@ stack_pointer[0] = next; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); + stack_pointer = _PyFrame_GetStackPointer(frame); if (!matches) { goto error; } + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_MonitorRaise(tstate, frame, this_instr); - _PyErr_Clear(tstate);stack_pointer += -1; + _PyErr_Clear(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } /* iterator ended normally */ @@ -3914,10 +4114,12 @@ if (getter == NULL) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'async for' requires an object with " "__aiter__ method, got %.100s", type->tp_name); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(obj); if (true) goto error; } @@ -3928,10 +4130,12 @@ Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'async for' received an object from __aiter__ " "that does not implement __anext__: %.100s", Py_TYPE(iter_o)->tp_name); + stack_pointer = _PyFrame_GetStackPointer(frame); Py_DECREF(iter_o); if (true) goto error; } @@ -3947,7 +4151,9 @@ _PyStackRef aiter; _PyStackRef awaitable; aiter = stack_pointer[-1]; + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *awaitable_o = _PyEval_GetANext(PyStackRef_AsPyObjectBorrow(aiter)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (awaitable_o == NULL) { goto error; } @@ -3967,7 +4173,9 @@ iterable = stack_pointer[-1]; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); if (iter_o == NULL) goto error; iter = PyStackRef_FromPyObjectSteal(iter_o); @@ -3987,7 +4195,9 @@ /* before: [obj]; after [getiter(obj)] */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable))); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); if (PyStackRef_IsNull(iter)) goto error; stack_pointer[0] = iter; @@ -4004,9 +4214,13 @@ _PyStackRef len; obj = stack_pointer[-1]; // PUSH(len(TOS)) + _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (len_i < 0) goto error; + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *len_o = PyLong_FromSsize_t(len_i); + stack_pointer = _PyFrame_GetStackPointer(frame); if (len_o == NULL) goto error; len = PyStackRef_FromPyObjectSteal(len_o); stack_pointer[0] = len; @@ -4031,9 +4245,11 @@ regular generator. */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_TypeError, "cannot 'yield from' a coroutine object " "in a non-coroutine generator"); + stack_pointer = _PyFrame_GetStackPointer(frame); goto error; } iter = iterable; @@ -4045,7 +4261,9 @@ /* `iterable` is not a generator. */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (PyStackRef_IsNull(iter)) { goto error; } @@ -4065,7 +4283,9 @@ _PyStackRef res; from = stack_pointer[-1]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name); + stack_pointer = _PyFrame_GetStackPointer(frame); if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; @@ -4086,9 +4306,11 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_ImportName(tstate, frame, name, PyStackRef_AsPyObjectBorrow(fromlist), PyStackRef_AsPyObjectBorrow(level)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(level); PyStackRef_CLOSE(fromlist); if (res_o == NULL) goto error; @@ -4149,10 +4371,12 @@ } stack_pointer[-2 - oparg] = func; stack_pointer[-1 - oparg] = maybe_self; + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, function, arg0 ); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err) goto error; } // _DO_CALL @@ -4175,10 +4399,12 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, args, total_args, NULL, frame ); + stack_pointer = _PyFrame_GetStackPointer(frame); // Manipulate stack directly since we leave using DISPATCH_INLINED(). // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. @@ -4203,25 +4429,33 @@ } stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, total_args | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); if (opcode == INSTRUMENTED_CALL) { PyObject *arg = total_args == 0 ? &_PyInstrumentation_MISSING : PyStackRef_AsPyObjectBorrow(args[0]); if (res_o == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, callable_o, arg); + stack_pointer = _PyFrame_GetStackPointer(frame); } else { + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, callable_o, arg); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(res_o); + stack_pointer = _PyFrame_GetStackPointer(frame); } } } @@ -4241,7 +4475,9 @@ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -4274,9 +4510,11 @@ PyObject *function = PyStackRef_AsPyObjectBorrow(PEEK(oparg + 3)); PyObject *arg = total_args == 0 ? &_PyInstrumentation_MISSING : PyStackRef_AsPyObjectBorrow(PEEK(total_args + 1)); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, function, arg); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err) goto error; PAUSE_ADAPTIVE_COUNTER(this_instr[1].counter); GO_TO_INSTRUCTION(CALL_KW); @@ -4344,12 +4582,16 @@ } else { if (_PyErr_Occurred(tstate)) { + _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); + stack_pointer = _PyFrame_GetStackPointer(frame); if (!matches) { goto error; } + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_MonitorRaise(tstate, frame, this_instr); _PyErr_Clear(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); } /* iterator ended normally */ assert(next_instr[oparg].op.code == END_FOR || @@ -4368,8 +4610,10 @@ (void)this_instr; next_instr += 1; INSTRUCTION_STATS(INSTRUMENTED_INSTRUCTION); + _PyFrame_SetStackPointer(frame, stack_pointer); int next_opcode = _Py_call_instrumentation_instruction( tstate, frame, this_instr); + stack_pointer = _PyFrame_GetStackPointer(frame); if (next_opcode < 0) goto error; next_instr = this_instr; if (_PyOpcode_Caches[next_opcode]) { @@ -4391,7 +4635,9 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; } } @@ -4420,13 +4666,17 @@ int original_opcode = 0; if (tstate->tracing) { PyCodeObject *code = _PyFrame_GetCode(frame); + _PyFrame_SetStackPointer(frame, stack_pointer); original_opcode = code->_co_monitoring->lines[(int)(this_instr - _PyCode_CODE(code))].original_opcode; + stack_pointer = _PyFrame_GetStackPointer(frame); next_instr = this_instr; } else { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyFrame_SetStackPointer(frame, stack_pointer); original_opcode = _Py_call_instrumentation_line( tstate, frame, this_instr, prev_instr); stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer = _PyFrame_GetStackPointer(frame); if (original_opcode < 0) { next_instr = this_instr+1; goto error; @@ -4549,7 +4799,9 @@ uintptr_t global_version = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & ~_PY_EVAL_EVENTS_MASK; uintptr_t code_version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version); if (code_version != global_version) { + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_Instrument(_PyFrame_GetCode(frame), tstate->interp); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { goto error; } @@ -4564,17 +4816,21 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; } } } // _MONITOR_RESUME { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation( tstate, oparg > 0, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err) goto error; if (frame->instr_ptr != this_instr) { /* Instrumentation has jumped */ @@ -4602,9 +4858,11 @@ { stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_arg( tstate, PY_MONITORING_EVENT_PY_RETURN, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { goto error; } @@ -4646,9 +4904,11 @@ // _RETURN_VALUE_EVENT val = stack_pointer[-1]; { + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_arg( tstate, PY_MONITORING_EVENT_PY_RETURN, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { goto error; } @@ -4691,9 +4951,11 @@ val = stack_pointer[-1]; { SAVE_SP(); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_arg( tstate, PY_MONITORING_EVENT_PY_YIELD, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); + stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_SP(); if (err) { goto error; @@ -4715,7 +4977,9 @@ frame->instr_ptr++; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); + stack_pointer = _PyFrame_GetStackPointer(frame); assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; @@ -4756,7 +5020,9 @@ assert(frame == &entry_frame); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); assert(_PyFrame_IsIncomplete(frame)); + stack_pointer = _PyFrame_GetStackPointer(frame); /* Restore previous frame and return. */ tstate->current_frame = frame->previous; assert(!_PyErr_Occurred(tstate)); @@ -4799,7 +5065,9 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; } } @@ -4820,7 +5088,9 @@ start--; } _PyExecutorObject *executor; + _PyFrame_SetStackPointer(frame, stack_pointer); int optimized = _PyOptimizer_Optimize(frame, start, stack_pointer, &executor, 0); + stack_pointer = _PyFrame_GetStackPointer(frame); if (optimized < 0) goto error; if (optimized) { assert(tstate->previous_executor == NULL); @@ -4888,16 +5158,22 @@ PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable); + stack_pointer = _PyFrame_GetStackPointer(frame); if (none_val == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_TypeError); + stack_pointer = _PyFrame_GetStackPointer(frame); if (matches && (Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable))) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Clear(tstate); _PyErr_Format(tstate, PyExc_TypeError, "Value after * must be an iterable, not %.200s", Py_TYPE(iterable)->tp_name); + stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(iterable_st); if (true) goto error; @@ -4926,7 +5202,9 @@ if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); next_instr = this_instr; + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_LoadAttr(owner, next_instr, name); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(LOAD_ATTR); @@ -4943,7 +5221,9 @@ attr_o = NULL; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int is_meth = _PyObject_GetMethod(PyStackRef_AsPyObjectBorrow(owner), name, &attr_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (is_meth) { /* We can bypass temporary bound method object. meth is unbound method and obj is self. @@ -4968,7 +5248,9 @@ /* Classic, pushes one value. */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(owner); if (attr_o == NULL) goto error; /* We need to define self_or_null on all paths */ @@ -5543,10 +5825,14 @@ INSTRUCTION_STATS(LOAD_BUILD_CLASS); _PyStackRef bc; PyObject *bc_o; + _PyFrame_SetStackPointer(frame, stack_pointer); if (PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o) < 0) goto error; + stack_pointer = _PyFrame_GetStackPointer(frame); if (bc_o == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_NameError, "__build_class__ not found"); + stack_pointer = _PyFrame_GetStackPointer(frame); if (true) goto error; } bc = PyStackRef_FromPyObjectSteal(bc_o); @@ -5598,7 +5884,9 @@ PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); PyObject *value_o = PyCell_GetRef(cell); if (value_o == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); if (true) goto error; } value = PyStackRef_FromPyObjectSteal(value_o); @@ -5642,10 +5930,12 @@ _PyStackRef value; _PyStackRef value_s = GETLOCAL(oparg); if (PyStackRef_IsNull(value_s)) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError, UNBOUNDLOCAL_ERROR_MSG, PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg) ); + stack_pointer = _PyFrame_GetStackPointer(frame); if (1) goto error; } value = PyStackRef_DUP(value_s); @@ -5687,7 +5977,9 @@ name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(class_dict, name, &value_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { goto error; } @@ -5695,7 +5987,9 @@ PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); value_o = PyCell_GetRef(cell); if (value_o == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); goto error; } } @@ -5718,7 +6012,9 @@ PyObject *v_o; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &v_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { goto error; } @@ -5726,15 +6022,19 @@ if (PyDict_CheckExact(GLOBALS()) && PyDict_CheckExact(BUILTINS())) { + _PyFrame_SetStackPointer(frame, stack_pointer); v_o = _PyDict_LoadGlobal((PyDictObject *)GLOBALS(), (PyDictObject *)BUILTINS(), name); + stack_pointer = _PyFrame_GetStackPointer(frame); if (v_o == NULL) { if (!_PyErr_Occurred(tstate)) { /* _PyDict_LoadGlobal() returns NULL without raising * an exception if the key doesn't exist */ + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, name); + stack_pointer = _PyFrame_GetStackPointer(frame); } goto error; } @@ -5742,14 +6042,20 @@ else { /* Slow-path if globals or builtins is not a dict */ /* namespace 1: globals */ + _PyFrame_SetStackPointer(frame, stack_pointer); if (PyMapping_GetOptionalItem(GLOBALS(), name, &v_o) < 0) goto error; + stack_pointer = _PyFrame_GetStackPointer(frame); if (v_o == NULL) { /* namespace 2: builtins */ + _PyFrame_SetStackPointer(frame, stack_pointer); if (PyMapping_GetOptionalItem(BUILTINS(), name, &v_o) < 0) goto error; + stack_pointer = _PyFrame_GetStackPointer(frame); if (v_o == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg( tstate, PyExc_NameError, NAME_ERROR_MSG, name); + stack_pointer = _PyFrame_GetStackPointer(frame); if (true) goto error; } } @@ -5780,7 +6086,9 @@ if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); next_instr = this_instr; + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_LoadGlobal(GLOBALS(), BUILTINS(), next_instr, name); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(LOAD_GLOBAL); @@ -5793,7 +6101,9 @@ // _LOAD_GLOBAL { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_LoadGlobal(GLOBALS(), BUILTINS(), name); + stack_pointer = _PyFrame_GetStackPointer(frame); if (res_o == NULL) goto error; null = PyStackRef_NULL; res = PyStackRef_FromPyObjectSteal(res_o); @@ -5891,8 +6201,10 @@ _PyStackRef locals; PyObject *l = LOCALS(); if (l == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_SystemError, "no locals found"); + stack_pointer = _PyFrame_GetStackPointer(frame); if (true) goto error; } locals = PyStackRef_FromPyObjectNew(l); @@ -5908,7 +6220,9 @@ INSTRUCTION_STATS(LOAD_NAME); _PyStackRef v; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *v_o = _PyEval_LoadName(tstate, frame, name); + stack_pointer = _PyFrame_GetStackPointer(frame); if (v_o == NULL) goto error; v = PyStackRef_FromPyObjectSteal(v_o); stack_pointer[0] = v; @@ -5931,15 +6245,20 @@ PyObject *self_or_null_o; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); attr = PyStackRef_FromPyObjectSteal(_PyObject_LookupSpecialMethod(owner_o, name, &self_or_null_o)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (PyStackRef_IsNull(attr)) { if (!_PyErr_Occurred(tstate)) { stack_pointer[0] = attr; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, _Py_SpecialMethods[oparg].error, - Py_TYPE(owner_o)->tp_name);stack_pointer += -1; + Py_TYPE(owner_o)->tp_name); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } } @@ -5974,7 +6293,9 @@ int load_method = oparg & 1; if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_LoadSuperAttr(global_super_st, class_st, next_instr, load_method); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(LOAD_SUPER_ATTR); @@ -5991,9 +6312,11 @@ PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING; stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, global_super, arg); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err) goto error; stack_pointer += 3; assert(WITHIN_STACK_BOUNDS()); @@ -6003,20 +6326,28 @@ PyObject *stack[] = {class, self}; stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *super = PyObject_Vectorcall(global_super, stack, oparg & 2, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) { PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING; if (super == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, global_super, arg); + stack_pointer = _PyFrame_GetStackPointer(frame); } else { + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, global_super, arg); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { + _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(super); + stack_pointer = _PyFrame_GetStackPointer(frame); } } } @@ -6025,7 +6356,9 @@ PyStackRef_CLOSE(self_st); if (super == NULL) goto error; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); + _PyFrame_SetStackPointer(frame, stack_pointer); attr = PyStackRef_FromPyObjectSteal(PyObject_GetAttr(super, name)); + stack_pointer = _PyFrame_GetStackPointer(frame); Py_DECREF(super); if (PyStackRef_IsNull(attr)) goto error; null = PyStackRef_NULL; @@ -6060,7 +6393,9 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); PyStackRef_CLOSE(self_st); @@ -6098,8 +6433,10 @@ int method_found = 0; stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attr_o = _PySuper_Lookup(cls, self, name, Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? &method_found : NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); if (attr_o == NULL) { @@ -6145,14 +6482,18 @@ PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyFunctionObject *func_obj = (PyFunctionObject *) PyFunction_New(codeobj, GLOBALS()); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(codeobj_st); if (func_obj == NULL) { goto error; } + _PyFrame_SetStackPointer(frame, stack_pointer); _PyFunction_SetVersion( func_obj, ((PyCodeObject *)codeobj)->co_version); + stack_pointer = _PyFrame_GetStackPointer(frame); func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj); stack_pointer[0] = func; stack_pointer += 1; @@ -6176,11 +6517,13 @@ // Do not DECREF INPUTS because the function steals the references stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_SetItem_Take2( (PyDictObject *)dict, PyStackRef_AsPyObjectSteal(key), PyStackRef_AsPyObjectSteal(value) ); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; DISPATCH(); } @@ -6201,10 +6544,12 @@ assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names))); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attrs_o = _PyEval_MatchClass(tstate, PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(type), oparg, PyStackRef_AsPyObjectBorrow(names)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(subject); PyStackRef_CLOSE(type); PyStackRef_CLOSE(names); @@ -6233,8 +6578,10 @@ keys = stack_pointer[-1]; subject = stack_pointer[-2]; // On successful match, PUSH(values). Otherwise, PUSH(None). + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *values_or_none_o = _PyEval_MatchKeys(tstate, PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (values_or_none_o == NULL) goto error; values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o); stack_pointer[0] = values_or_none; @@ -6289,9 +6636,11 @@ _PyErr_StackItem *exc_info = tstate->exc_info; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); Py_XSETREF(exc_info->exc_value, PyStackRef_Is(exc_value, PyStackRef_None) ? NULL : PyStackRef_AsPyObjectSteal(exc_value)); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH(); } @@ -6488,13 +6837,17 @@ if (PyLong_Check(lasti)) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); frame->instr_ptr = _PyCode_CODE(_PyFrame_GetCode(frame)) + PyLong_AsLong(lasti); + stack_pointer = _PyFrame_GetStackPointer(frame); assert(!_PyErr_Occurred(tstate)); } else { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_SystemError, "lasti is not an int"); + stack_pointer = _PyFrame_GetStackPointer(frame); goto error; }stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6503,7 +6856,9 @@ Py_INCREF(exc); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetRaisedException(tstate, exc); + stack_pointer = _PyFrame_GetStackPointer(frame); monitor_reraise(tstate, frame, this_instr); goto exception_unwind; } @@ -6530,7 +6885,9 @@ uintptr_t global_version = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & ~_PY_EVAL_EVENTS_MASK; uintptr_t code_version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version); if (code_version != global_version) { + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_Instrument(_PyFrame_GetCode(frame), tstate->interp); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { goto error; } @@ -6553,7 +6910,9 @@ _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; } } @@ -6619,24 +6978,26 @@ _PyStackRef res; assert(PyFunction_Check(frame->f_funcobj)); PyFunctionObject *func = (PyFunctionObject *)frame->f_funcobj; + _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func); + stack_pointer = _PyFrame_GetStackPointer(frame); if (gen == NULL) { goto error; } assert(EMPTY()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *gen_frame = &gen->gi_iframe; - frame->instr_ptr++; - _PyFrame_Copy(frame, gen_frame); + frame->instr_ptr++;/* Virtual flush 1 */ + _PyFrame_Copy(frame, gen_frame);/* Virtual reload 1 */ assert(frame->frame_obj == NULL); gen->gi_frame_state = FRAME_CREATED; gen_frame->owner = FRAME_OWNED_BY_GENERATOR; _Py_LeaveRecursiveCallPy(tstate); - _PyInterpreterFrame *prev = frame->previous; - _PyThreadState_PopFrame(tstate, frame); + _PyInterpreterFrame *prev = frame->previous;/* Virtual flush 1 */ + _PyThreadState_PopFrame(tstate, frame);/* Virtual reload 1 */ frame = tstate->current_frame = prev; LOAD_IP(frame->return_offset); - LOAD_SP(); + stack_pointer = _PyFrame_GetStackPointer(frame); res = PyStackRef_FromPyObjectSteal((PyObject *)gen); LLTRACE_RESUME_FRAME(); stack_pointer[0] = res; @@ -6692,7 +7053,9 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_Send(receiver, next_instr); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(SEND); @@ -6728,19 +7091,28 @@ else { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); retval_o = PyObject_CallMethodOneArg(receiver_o, &_Py_ID(send), - PyStackRef_AsPyObjectBorrow(v));stack_pointer += 1; + PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); } if (retval_o == NULL) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); + stack_pointer = _PyFrame_GetStackPointer(frame); if (matches) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_MonitorRaise(tstate, frame, this_instr); + stack_pointer = _PyFrame_GetStackPointer(frame); } + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyGen_FetchStopIterationValue(&retval_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err == 0) { assert(retval_o != NULL); JUMPBY(oparg); @@ -6815,17 +7187,25 @@ int err; PyObject *ann_dict; if (LOCALS() == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when setting up annotations"); + stack_pointer = _PyFrame_GetStackPointer(frame); if (true) goto error; } /* check if __annotations__ in locals()... */ + _PyFrame_SetStackPointer(frame, stack_pointer); if (PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict) < 0) goto error; + stack_pointer = _PyFrame_GetStackPointer(frame); if (ann_dict == NULL) { + _PyFrame_SetStackPointer(frame, stack_pointer); ann_dict = PyDict_New(); + stack_pointer = _PyFrame_GetStackPointer(frame); if (ann_dict == NULL) goto error; + _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__), ann_dict); + stack_pointer = _PyFrame_GetStackPointer(frame); Py_DECREF(ann_dict); if (err) goto error; } @@ -6845,8 +7225,10 @@ set = stack_pointer[-2 - (oparg-1)]; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PySet_Add(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); if (err) goto error; DISPATCH(); @@ -6884,8 +7266,10 @@ set = stack_pointer[-2 - (oparg-1)]; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(iterable)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); if (err < 0) goto error; DISPATCH(); @@ -6909,7 +7293,9 @@ if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); next_instr = this_instr; + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_StoreAttr(owner, next_instr, name); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(STORE_ATTR); @@ -6923,8 +7309,10 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner), name, PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); PyStackRef_CLOSE(owner); if (err) goto error; @@ -7047,14 +7435,22 @@ PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dict->ma_keys) + hint; DEOPT_IF(ep->me_key != name, STORE_ATTR); /* Ensure dict is GC tracked if it needs to be */ - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(PyStackRef_AsPyObjectBorrow(value))) { + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyObject_GC_TRACK(dict); + stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += 2; + assert(WITHIN_STACK_BOUNDS()); } old_value = ep->me_value; PyDict_WatchEvent event = old_value == NULL ? PyDict_EVENT_ADDED : PyDict_EVENT_MODIFIED; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); new_version = _PyDict_NotifyEvent(tstate->interp, event, dict, name, PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); ep->me_value = PyStackRef_AsPyObjectSteal(value); dict->ma_version_tag = new_version; // PEP 509 // old_value should be DECREFed after GC track checking is done, if not, it could raise a segmentation fault, @@ -7075,7 +7471,9 @@ PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH(); } @@ -7132,7 +7530,9 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); if (err) goto error; DISPATCH(); @@ -7150,20 +7550,26 @@ if (ns == NULL) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when storing %R", name); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); if (true) goto error; } if (PyDict_CheckExact(ns)) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); } else { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(v); if (err) goto error; @@ -7184,15 +7590,19 @@ v = stack_pointer[-4]; stack_pointer += -4; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); + stack_pointer = _PyFrame_GetStackPointer(frame); OPCODE_DEFERRED_INC(STORE_SLICE); int err; if (slice == NULL) { err = 1; } else { + _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), slice, PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); Py_DECREF(slice); } PyStackRef_CLOSE(v); @@ -7220,7 +7630,9 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_StoreSubscr(container, sub, next_instr); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(STORE_SUBSCR); @@ -7233,7 +7645,9 @@ /* container[sub] = v */ stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); @@ -7259,9 +7673,11 @@ STAT_INC(STORE_SUBSCR, hit); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_SetItem_Take2((PyDictObject *)dict, PyStackRef_AsPyObjectSteal(sub), PyStackRef_AsPyObjectSteal(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(dict_st); if (err) goto error; DISPATCH(); @@ -7331,7 +7747,9 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_ToBool(value, next_instr); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(TO_BOOL); @@ -7343,7 +7761,9 @@ { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); if (err < 0) goto error; res = err ? PyStackRef_True : PyStackRef_False; @@ -7492,7 +7912,9 @@ value = stack_pointer[-1]; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); @@ -7511,7 +7933,9 @@ value = stack_pointer[-1]; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); @@ -7546,7 +7970,9 @@ _PyStackRef *top = right + (oparg >> 8); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(seq); if (res == 0) goto error; stack_pointer += 1 + (oparg & 0xFF) + (oparg >> 8); @@ -7571,7 +7997,9 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_UnpackSequence(seq, next_instr, oparg); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(UNPACK_SEQUENCE); @@ -7586,7 +8014,9 @@ _PyStackRef *top = output + oparg; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(seq); if (res == 0) goto error; } @@ -7694,8 +8124,10 @@ PyObject *val_o = PyStackRef_AsPyObjectBorrow(val); PyObject *exit_func_o = PyStackRef_AsPyObjectBorrow(exit_func); assert(val_o && PyExceptionInstance_Check(val_o)); + _PyFrame_SetStackPointer(frame, stack_pointer); exc = PyExceptionInstance_Class(val_o); tb = PyException_GetTraceback(val_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (tb == NULL) { tb = Py_None; } @@ -7706,8 +8138,10 @@ (void)lasti; // Shut up compiler warning if asserts are off PyObject *stack[5] = {NULL, PyStackRef_AsPyObjectBorrow(exit_self), exc, val_o, tb}; int has_self = !PyStackRef_IsNull(exit_self); + _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Vectorcall(exit_func_o, stack + 2 - has_self, (3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (PyStackRef_IsNull(res)) goto error; stack_pointer[0] = res; stack_pointer += 1; @@ -7731,7 +8165,9 @@ frame->instr_ptr++; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); + stack_pointer = _PyFrame_GetStackPointer(frame); assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; @@ -7787,7 +8223,9 @@ } stack_pointer += -3 - (oparg & 1); assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *tuple = PySequence_Tuple(callargs); + stack_pointer = _PyFrame_GetStackPointer(frame); if (tuple == NULL) { goto error; } @@ -7803,29 +8241,37 @@ PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING; stack_pointer += -3 - (oparg & 1); assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, func, arg); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { goto error; } + _PyFrame_SetStackPointer(frame, stack_pointer); result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (!PyFunction_Check(func) && !PyMethod_Check(func)) { if (PyStackRef_IsNull(result)) { stack_pointer[0] = result; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, func, arg); + stack_pointer = _PyFrame_GetStackPointer(frame); } else { stack_pointer[0] = result; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, func, arg); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { PyStackRef_CLEAR(result); } @@ -7843,9 +8289,11 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func)); stack_pointer += -3 - (oparg & 1); assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(func_st), locals, nargs, callargs, kwargs, frame); + stack_pointer = _PyFrame_GetStackPointer(frame); // Need to sync the stack since we exit with DISPATCH_INLINED. if (new_frame == NULL) { goto error; @@ -7856,7 +8304,9 @@ } stack_pointer += -3 - (oparg & 1); assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); + stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(func_st); PyStackRef_CLOSE(callargs_st); diff --git a/Python/optimizer.c b/Python/optimizer.c index 9198e410627dd4..6a4510ad929767 100644 --- a/Python/optimizer.c +++ b/Python/optimizer.c @@ -1033,7 +1033,7 @@ prepare_for_execution(_PyUOpInstruction *buffer, int length) current_error = next_spare; current_error_target = target; make_exit(&buffer[next_spare], _ERROR_POP_N, 0); - buffer[next_spare].oparg = popped; + buffer[next_spare].oparg = 0; buffer[next_spare].operand = target; next_spare++; } diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 864af03a854727..3f12e22d033692 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -369,8 +369,6 @@ { assert(PyFloat_CheckExact(sym_get_const(left))); assert(PyFloat_CheckExact(sym_get_const(right))); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( PyFloat_AS_DOUBLE(sym_get_const(left)) * PyFloat_AS_DOUBLE(sym_get_const(right))); @@ -383,11 +381,10 @@ // replace opcode with constant propagated one and update tests! } else { - res = sym_new_type(ctx, &PyFloat_Type);stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + res = sym_new_type(ctx, &PyFloat_Type); } - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -403,8 +400,6 @@ { assert(PyFloat_CheckExact(sym_get_const(left))); assert(PyFloat_CheckExact(sym_get_const(right))); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( PyFloat_AS_DOUBLE(sym_get_const(left)) + PyFloat_AS_DOUBLE(sym_get_const(right))); @@ -417,11 +412,10 @@ // replace opcode with constant propagated one and update tests! } else { - res = sym_new_type(ctx, &PyFloat_Type);stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + res = sym_new_type(ctx, &PyFloat_Type); } - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -437,8 +431,6 @@ { assert(PyFloat_CheckExact(sym_get_const(left))); assert(PyFloat_CheckExact(sym_get_const(right))); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( PyFloat_AS_DOUBLE(sym_get_const(left)) - PyFloat_AS_DOUBLE(sym_get_const(right))); @@ -451,11 +443,10 @@ // replace opcode with constant propagated one and update tests! } else { - res = sym_new_type(ctx, &PyFloat_Type);stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + res = sym_new_type(ctx, &PyFloat_Type); } - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1255,10 +1246,7 @@ res = sym_new_type(ctx, &PyBool_Type); } else { - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); - res = _Py_uop_sym_new_not_null(ctx);stack_pointer += 2; - assert(WITHIN_STACK_BOUNDS()); + res = _Py_uop_sym_new_not_null(ctx); } stack_pointer[-2] = res; stack_pointer += -1; diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 5903d866d6c2d1..36783c6b283617 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -6,7 +6,7 @@ @dataclass class Properties: - escaping_calls: dict[lexer.Token, lexer.Token] + escaping_calls: dict[lexer.Token, tuple[lexer.Token, lexer.Token]] error_with_pop: bool error_without_pop: bool deopts: bool @@ -34,7 +34,7 @@ def dump(self, indent: str) -> None: @staticmethod def from_list(properties: list["Properties"]) -> "Properties": - escaping_calls: dict[lexer.Token, lexer.Token] = {} + escaping_calls: dict[lexer.Token, tuple[lexer.Token, lexer.Token]] = {} for p in properties: escaping_calls.update(p.escaping_calls) return Properties( @@ -564,6 +564,13 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "PyCFunction_GET_SELF", "_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY", "PyCell_GetRef", + "Py_UNREACHABLE", + "_Py_LeaveRecursiveCallTstate", + "_Py_EnterRecursiveCallTstateUnchecked", + "_PyObject_GC_IS_TRACKED", + "_PyObject_GC_MAY_BE_TRACKED", + "ADAPTIVE_COUNTER_TRIGGERS", + "_PyInterpreterState_GET", ) def find_stmt_start(node: parser.InstDef, idx: int) -> lexer.Token: @@ -578,17 +585,30 @@ def find_stmt_start(node: parser.InstDef, idx: int) -> lexer.Token: idx += 1 return node.block.tokens[idx] + def find_stmt_end(node: parser.InstDef, idx: int) -> lexer.Token: assert idx < len(node.block.tokens) while True: idx += 1 tkn = node.block.tokens[idx] - if tkn.kind == "SEMI" or tkn.kind == "LBRACE" or tkn.kind == "RBRACE": - break - while node.block.tokens[idx].kind == "COMMENT": - idx -= 1 - return node.block.tokens[idx] + if tkn.kind == "SEMI": + return node.block.tokens[idx+1] +def check_escaping_calls(instr: parser.InstDef, escapes: dict[lexer.Token, lexer.Token]) -> None: + calls = {escapes[t][0] for t in escapes} + in_if = 0 + tkn_iter = iter(instr.block.tokens) + for tkn in tkn_iter: + if tkn.kind == "IF": + next(tkn_iter) + in_if = 1 + elif tkn.kind == "LPAREN" and in_if: + in_if += 1 + elif tkn.kind == "RPAREN": + if in_if: + in_if -= 1 + elif tkn in calls and in_if: + raise analysis_error(f"Escaping call '{tkn.text} in condition", tkn) def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, lexer.Token]: result: dict[lexer.Token, lexer.Token] = {} @@ -599,7 +619,7 @@ def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, lexer.To try: next_tkn = tokens[idx+1] except IndexError: - return result + break if next_tkn.kind != lexer.LPAREN: continue if not tkn.text.startswith("Py") and not tkn.text.startswith("_Py"): @@ -615,6 +635,7 @@ def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, lexer.To start = find_stmt_start(instr, idx) end = find_stmt_end(instr, idx) result[start] = tkn, end + check_escaping_calls(instr, result) return result diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 9bbfbdc01ac8d6..bd8dde0e9e461e 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -112,6 +112,8 @@ def __init__(self, out: CWriter): "ERROR_NO_POP": self.error_no_pop, "DECREF_INPUTS": self.decref_inputs, "SYNC_SP": self.sync_sp, + "SAVE_STACK": self.save_stack, + "RELOAD_STACK": self.reload_stack, # "PyStackRef_FromPyObjectNew": self.py_stack_ref_from_py_object_new, "DISPATCH": self.dispatch } @@ -249,6 +251,42 @@ def sync_sp( self._print_storage(storage) return True + def emit_save(self, storage: Storage): + storage.save(self.out) + self._print_storage(storage) + + def save_stack( + self, + tkn: Token, + tkn_iter: TokenIterator, + uop: Uop, + storage: Storage, + inst: Instruction | None, + ) -> bool: + next(tkn_iter) + next(tkn_iter) + next(tkn_iter) + self.emit_save(storage) + return True + + def emit_reload(self, storage: Storage): + storage.reload(self.out) + self._print_storage(storage) + + def reload_stack( + self, + tkn: Token, + tkn_iter: TokenIterator, + uop: Uop, + storage: Storage, + inst: Instruction | None, + ) -> bool: + next(tkn_iter) + next(tkn_iter) + next(tkn_iter) + self.emit_reload(storage) + return True + def _print_storage(self, storage: Storage): if PRINT_STACKS: self.out.start_line() @@ -314,6 +352,7 @@ def _emit_block( braces = 1 out_stores = set(uop.output_stores) tkn = next(tkn_iter) + reload: Token | None = None try: reachable = True line : int = -1 @@ -330,8 +369,11 @@ def _emit_block( self.out.start_line() line = tkn.line if tkn in escaping_calls: - storage.flush(self.out) - self._print_storage(storage) + if tkn != reload: + self.emit_save(storage) + _, reload = escaping_calls[tkn] + elif tkn == reload: + self.emit_reload(storage) if tkn.kind == "LBRACE": self.out.emit(tkn) braces += 1 diff --git a/Tools/cases_generator/optimizer_generator.py b/Tools/cases_generator/optimizer_generator.py index c5c52f0f8f1333..5566a68868e239 100644 --- a/Tools/cases_generator/optimizer_generator.py +++ b/Tools/cases_generator/optimizer_generator.py @@ -91,7 +91,12 @@ def emit_default(out: CWriter, uop: Uop) -> None: class OptimizerEmitter(Emitter): - pass + + def emit_save(self, storage: Storage): + pass + + def emit_reload(self, storage: Storage): + pass def write_uop( diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index 4336bdc06a3f24..4ef33ecfcc99d9 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -400,6 +400,7 @@ class Storage: stack: Stack outputs: list[Local] + spilled: int = 0 def _push_defined_locals(self) -> None: while self.outputs: @@ -423,6 +424,25 @@ def flush(self, out: CWriter) -> None: self._push_defined_locals() self.stack.flush(out) + def save(self, out: CWriter) -> None: + assert self.spilled >= 0 + if self.spilled == 0: + self.flush(out) + out.start_line() + out.emit("_PyFrame_SetStackPointer(frame, stack_pointer);\n") + else: + out.emit(f"/* Virtual flush {self.spilled} */\n") + self.spilled += 1 + + def reload(self, out: CWriter) -> None: + assert self.spilled > 0 + self.spilled -= 1 + if self.spilled == 0: + out.start_line() + out.emit("stack_pointer = _PyFrame_GetStackPointer(frame);\n") + else: + out.emit(f"/* Virtual reload {self.spilled} */\n") + @staticmethod def for_uop(stack: Stack, uop: Uop, locals: dict[str, Local]) -> "Storage": outputs: list[Local] = [] diff --git a/Tools/cases_generator/tier2_generator.py b/Tools/cases_generator/tier2_generator.py index 91c9352abcbd70..65e4d6dcc01b83 100644 --- a/Tools/cases_generator/tier2_generator.py +++ b/Tools/cases_generator/tier2_generator.py @@ -76,6 +76,7 @@ def error_if( storage: Storage, inst: Instruction | None, ) -> bool: + storage.flush(self.out) self.out.emit_at("if ", tkn) lparen = next(tkn_iter) self.emit(lparen) From 2cc4f64e5f054d16a2f28471aa887fb1b30ca0ac Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Mon, 9 Sep 2024 12:36:52 +0100 Subject: [PATCH 23/53] Don't allow escaping calls in ERROR_IF or DEOPT_IF --- Include/internal/pycore_opcode_metadata.h | 12 +- Include/internal/pycore_uop_metadata.h | 2 +- Lib/test/test_monitoring.py | 1 + Python/bytecodes.c | 24 +- Python/executor_cases.c.h | 9 +- Python/generated_cases.c.h | 560 +++++++++++++-------- Tools/cases_generator/analyzer.py | 7 +- Tools/cases_generator/generators_common.py | 12 +- Tools/cases_generator/stack.py | 6 + 9 files changed, 399 insertions(+), 234 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 47a7f1461941df..2325fd747f413c 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -1020,7 +1020,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [BINARY_SLICE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BINARY_SUBSCR] = { true, INSTR_FMT_IXC, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [BINARY_SUBSCR_DICT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [BINARY_SUBSCR_GETITEM] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_SUBSCR_GETITEM] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_SUBSCR_LIST_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_SUBSCR_STR_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, [BINARY_SUBSCR_TUPLE_INT] = { true, INSTR_FMT_IXC, HAS_DEOPT_FLAG }, @@ -1104,8 +1104,8 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [INSTRUMENTED_CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_CALL_FUNCTION_EX] = { true, INSTR_FMT_IX, 0 }, [INSTRUMENTED_CALL_KW] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_END_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG }, - [INSTRUMENTED_END_SEND] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG }, + [INSTRUMENTED_END_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_END_SEND] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_INSTRUCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -1117,8 +1117,8 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [INSTRUMENTED_POP_JUMP_IF_NOT_NONE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, [INSTRUMENTED_POP_JUMP_IF_TRUE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG }, [INSTRUMENTED_RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [INTERPRETER_EXIT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, [IS_OP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, @@ -1176,7 +1176,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [POP_TOP] = { true, INSTR_FMT_IX, HAS_PURE_FLAG }, [PUSH_EXC_INFO] = { true, INSTR_FMT_IX, 0 }, [PUSH_NULL] = { true, INSTR_FMT_IX, HAS_PURE_FLAG }, - [RAISE_VARARGS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG }, + [RAISE_VARARGS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [RERAISE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [RESERVED] = { true, INSTR_FMT_IX, 0 }, [RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index b457e8e385fb02..f0e9629cac293d 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -82,7 +82,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_BINARY_SUBSCR_STR_INT] = HAS_DEOPT_FLAG, [_BINARY_SUBSCR_TUPLE_INT] = HAS_DEOPT_FLAG, [_BINARY_SUBSCR_DICT] = HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_BINARY_SUBSCR_CHECK_FUNC] = HAS_DEOPT_FLAG | HAS_ESCAPES_FLAG, + [_BINARY_SUBSCR_CHECK_FUNC] = HAS_DEOPT_FLAG, [_BINARY_SUBSCR_INIT_CALL] = 0, [_LIST_APPEND] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_SET_ADD] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, diff --git a/Lib/test/test_monitoring.py b/Lib/test/test_monitoring.py index 351f1067c10343..e84a65126f8fae 100644 --- a/Lib/test/test_monitoring.py +++ b/Lib/test/test_monitoring.py @@ -2088,6 +2088,7 @@ def test_fire_event_failing_callback(self): args_ = (self.codelike, offset) + tuple(args) exc = OSError(42) with self.assertRaises(type(exc)): + print(event) self.check_event_count(event, function, args_, expected, callback_raises=exc) diff --git a/Python/bytecodes.c b/Python/bytecodes.c index f2ce5bebaa0809..5b0ca89ae13575 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -207,10 +207,8 @@ dummy_func( } op(_MONITOR_RESUME, (--)) { - _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation( tstate, oparg > 0, frame, this_instr); - stack_pointer = _PyFrame_GetStackPointer(frame); ERROR_IF(err, error); if (frame->instr_ptr != this_instr) { /* Instrumentation has jumped */ @@ -645,6 +643,7 @@ dummy_func( }; specializing op(_SPECIALIZE_BINARY_SUBSCR, (counter/1, container, sub -- container, sub)) { + assert(frame->stackpointer == NULL); #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; @@ -960,9 +959,7 @@ dummy_func( int err = _Py_call_instrumentation_arg( tstate, PY_MONITORING_EVENT_PY_RETURN, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); - if (err) { - ERROR_NO_POP(); - } + ERROR_IF(err, error); } macro(INSTRUMENTED_RETURN_VALUE) = @@ -1153,11 +1150,9 @@ dummy_func( } tier1 op(_YIELD_VALUE_EVENT, (val -- val)) { - SAVE_SP(); int err = _Py_call_instrumentation_arg( tstate, PY_MONITORING_EVENT_PY_YIELD, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); - LOAD_SP(); if (err) { ERROR_NO_POP(); } @@ -1250,7 +1245,8 @@ dummy_func( inst(LOAD_BUILD_CLASS, ( -- bc)) { PyObject *bc_o; - ERROR_IF(PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o) < 0, error); + int err = PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o); + ERROR_IF(err < 0, error); if (bc_o == NULL) { _PyErr_SetString(tstate, PyExc_NameError, "__build_class__ not found"); @@ -1463,10 +1459,12 @@ dummy_func( else { /* Slow-path if globals or builtins is not a dict */ /* namespace 1: globals */ - ERROR_IF(PyMapping_GetOptionalItem(GLOBALS(), name, &v_o) < 0, error); + int err = PyMapping_GetOptionalItem(GLOBALS(), name, &v_o); + ERROR_IF(err < 0, error); if (v_o == NULL) { /* namespace 2: builtins */ - ERROR_IF(PyMapping_GetOptionalItem(BUILTINS(), name, &v_o) < 0, error); + int err = PyMapping_GetOptionalItem(BUILTINS(), name, &v_o); + ERROR_IF(err < 0, error); if (v_o == NULL) { _PyEval_FormatExcCheckArg( tstate, PyExc_NameError, @@ -1746,7 +1744,6 @@ dummy_func( } inst(SETUP_ANNOTATIONS, (--)) { - int err; PyObject *ann_dict; if (LOCALS() == NULL) { _PyErr_Format(tstate, PyExc_SystemError, @@ -1754,7 +1751,8 @@ dummy_func( ERROR_IF(true, error); } /* check if __annotations__ in locals()... */ - ERROR_IF(PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict) < 0, error); + int err = PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict); + ERROR_IF(err < 0, error); if (ann_dict == NULL) { ann_dict = PyDict_New(); ERROR_IF(ann_dict == NULL, error); @@ -4487,10 +4485,8 @@ dummy_func( original_opcode = code->_co_monitoring->lines[(int)(this_instr - _PyCode_CODE(code))].original_opcode; next_instr = this_instr; } else { - _PyFrame_SetStackPointer(frame, stack_pointer); original_opcode = _Py_call_instrumentation_line( tstate, frame, this_instr, prev_instr); - stack_pointer = _PyFrame_GetStackPointer(frame); if (original_opcode < 0) { next_instr = this_instr+1; goto error; diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 793bf5a5d09557..9838699187df1b 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -1051,12 +1051,10 @@ _PyStackRef container; container = stack_pointer[-2]; PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(container)); - _PyFrame_SetStackPointer(frame, stack_pointer); if (!PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - stack_pointer = _PyFrame_GetStackPointer(frame); PyHeapTypeObject *ht = (PyHeapTypeObject *)tp; PyObject *getitem = ht->_spec_cache.getitem; if (getitem == NULL) { @@ -1499,8 +1497,9 @@ _PyStackRef bc; PyObject *bc_o; _PyFrame_SetStackPointer(frame, stack_pointer); - if (PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o) < 0) JUMP_TO_ERROR(); + int err = PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o); stack_pointer = _PyFrame_GetStackPointer(frame); + if (err < 0) JUMP_TO_ERROR(); if (bc_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_NameError, @@ -2206,7 +2205,6 @@ } case _SETUP_ANNOTATIONS: { - int err; PyObject *ann_dict; if (LOCALS() == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); @@ -2217,8 +2215,9 @@ } /* check if __annotations__ in locals()... */ _PyFrame_SetStackPointer(frame, stack_pointer); - if (PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict) < 0) JUMP_TO_ERROR(); + int err = PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict); stack_pointer = _PyFrame_GetStackPointer(frame); + if (err < 0) JUMP_TO_ERROR(); if (ann_dict == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); ann_dict = PyDict_New(); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index d78632d077bf97..ab9cd2cc6a4067 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -47,7 +47,8 @@ PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o); PyStackRef_CLOSE(lhs); PyStackRef_CLOSE(rhs); - if (res_o == NULL) goto pop_2_error; + /* Variables: []. Base offset: -2. Top offset: -2 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto pop_2_error; res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; @@ -117,8 +118,8 @@ STAT_INC(BINARY_OP, hit); PyObject *res_o = _PyLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); - _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); - if (res_o == NULL) goto pop_2_error; + _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);/* Variables: []. Base offset: -2. Top offset: -2 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto pop_2_error; res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; @@ -152,8 +153,8 @@ STAT_INC(BINARY_OP, hit); PyObject *res_o = PyUnicode_Concat(left_o, right_o); _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc); - _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); - if (res_o == NULL) goto pop_2_error; + _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);/* Variables: []. Base offset: -2. Top offset: -2 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto pop_2_error; res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; @@ -213,8 +214,8 @@ PyObject *temp = PyStackRef_AsPyObjectBorrow(*target_local); PyUnicode_Append(&temp, right_o); *target_local = PyStackRef_FromPyObjectSteal(temp); - _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); - if (PyStackRef_IsNull(*target_local)) goto error; + _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (PyStackRef_IsNull(*target_local)) goto error; #if TIER_ONE // The STORE_FAST is already done. This is done here in tier one, // and during trace projection in tier two: @@ -286,8 +287,8 @@ STAT_INC(BINARY_OP, hit); PyObject *res_o = _PyLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); - _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); - if (res_o == NULL) goto pop_2_error; + _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);/* Variables: []. Base offset: -2. Top offset: -2 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto pop_2_error; res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; @@ -357,8 +358,8 @@ STAT_INC(BINARY_OP, hit); PyObject *res_o = _PyLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); - _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);; - if (res_o == NULL) goto pop_2_error; + _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);;/* Variables: []. Base offset: -2. Top offset: -2 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto pop_2_error; res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; @@ -397,8 +398,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); Py_DECREF(slice); } - PyStackRef_CLOSE(container); - if (res_o == NULL) goto error; + PyStackRef_CLOSE(container);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; @@ -422,6 +423,7 @@ { uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; + assert(frame->stackpointer == NULL); #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; @@ -445,7 +447,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); - if (res_o == NULL) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[0] = res; @@ -482,7 +485,8 @@ } PyStackRef_CLOSE(dict_st); PyStackRef_CLOSE(sub_st); - if (rc <= 0) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (rc <= 0) goto error; // not found or error res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; @@ -508,9 +512,7 @@ container = stack_pointer[-2]; { PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(container)); - _PyFrame_SetStackPointer(frame, stack_pointer); DEOPT_IF(!PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE), BINARY_SUBSCR); - stack_pointer = _PyFrame_GetStackPointer(frame); PyHeapTypeObject *ht = (PyHeapTypeObject *)tp; PyObject *getitem = ht->_spec_cache.getitem; DEOPT_IF(getitem == NULL, BINARY_SUBSCR); @@ -656,8 +658,8 @@ _PyStackRef *values; _PyStackRef list; values = &stack_pointer[-oparg]; - PyObject *list_o = _PyList_FromStackRefSteal(values, oparg); - if (list_o == NULL) { + PyObject *list_o = _PyList_FromStackRefSteal(values, oparg);/* Variables: []. Base offset: -oparg. Top offset: -oparg + LOCALS: [Local('list', in_memory=False, defined=False)] */if (list_o == NULL) { stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -681,7 +683,8 @@ for (int _i = oparg*2; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } - if (true) { + /* Variables: []. Base offset: -oparg*2. Top offset: -oparg*2 + LOCALS: [Local('map', in_memory=False, defined=False)] */if (true) { stack_pointer += -oparg*2; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -699,7 +702,8 @@ for (int _i = oparg*2; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } - if (map_o == NULL) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('map', in_memory=False, defined=False)] */if (map_o == NULL) goto error; map = PyStackRef_FromPyObjectSteal(map_o); stack_pointer[0] = map; stack_pointer += 1; @@ -723,7 +727,8 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } - if (true) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('set', in_memory=False, defined=False)] */if (true) goto error; } int err = 0; for (int i = 0; i < oparg; i++) { @@ -735,8 +740,8 @@ PyStackRef_CLOSE(values[i]); } if (err != 0) { - Py_DECREF(set_o); - if (true) goto error; + Py_DECREF(set_o);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('set', in_memory=False, defined=False)] */if (true) goto error; } set = PyStackRef_FromPyObjectSteal(set_o); stack_pointer[0] = set; @@ -763,7 +768,8 @@ PyStackRef_CLOSE(start); PyStackRef_CLOSE(stop); PyStackRef_XCLOSE(step); - if (slice_o == NULL) { + /* Variables: []. Base offset: -2 - ((oparg == 3) ? 1 : 0). Top offset: -2 - ((oparg == 3) ? 1 : 0) + LOCALS: [Local('slice', in_memory=False, defined=False)] */if (slice_o == NULL) { stack_pointer += -2 - ((oparg == 3) ? 1 : 0); assert(WITHIN_STACK_BOUNDS()); goto error; @@ -787,7 +793,8 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(pieces[_i]); } - if (true) { + /* Variables: []. Base offset: -oparg. Top offset: -oparg + LOCALS: [Local('str', in_memory=False, defined=False)] */if (true) { stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -798,7 +805,8 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(pieces[_i]); } - if (str_o == NULL) { + /* Variables: []. Base offset: -oparg. Top offset: -oparg + LOCALS: [Local('str', in_memory=False, defined=False)] */if (str_o == NULL) { stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -817,8 +825,8 @@ _PyStackRef *values; _PyStackRef tup; values = &stack_pointer[-oparg]; - PyObject *tup_o = _PyTuple_FromStackRefSteal(values, oparg); - if (tup_o == NULL) { + PyObject *tup_o = _PyTuple_FromStackRefSteal(values, oparg);/* Variables: []. Base offset: -oparg. Top offset: -oparg + LOCALS: [Local('tup', in_memory=False, defined=False)] */if (tup_o == NULL) { stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -932,8 +940,8 @@ PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - } - if (true) { + }/* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg + LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -975,8 +983,8 @@ PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - } - if (res_o == NULL) goto error; + }/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -990,7 +998,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: ['res']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -1323,7 +1332,8 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) { + /* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg + LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -1335,8 +1345,8 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable); - if (res_o == NULL) { + PyStackRef_CLOSE(callable);/* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -1354,7 +1364,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: ['res']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); } @@ -1400,7 +1411,8 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) { + /* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg + LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -1416,8 +1428,8 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable); - if (res_o == NULL) { + PyStackRef_CLOSE(callable);/* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -1435,7 +1447,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: ['res']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); } @@ -1483,7 +1496,8 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) { + /* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg + LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -1496,8 +1510,8 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable); - if (res_o == NULL) { + PyStackRef_CLOSE(callable);/* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -1515,7 +1529,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: ['res']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); } @@ -1566,8 +1581,8 @@ _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(arg); - PyStackRef_CLOSE(callable); - if (res_o == NULL) goto error; + PyStackRef_CLOSE(callable);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -1581,7 +1596,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: ['res']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -1709,7 +1725,13 @@ PyStackRef_CLOSE(func_st); PyStackRef_CLOSE(callargs_st); PyStackRef_XCLOSE(kwargs_st); - if (PyStackRef_IsNull(result)) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('result', in_memory=False, defined=True)] */if (PyStackRef_IsNull(result)) { + stack_pointer[0] = result; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } // _CHECK_PERIODIC { @@ -1722,7 +1744,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: ['result']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -1743,7 +1766,8 @@ assert(oparg <= MAX_INTRINSIC_1); PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value)); PyStackRef_CLOSE(value); - if (res_o == NULL) goto pop_1_error; + /* Variables: []. Base offset: -1. Top offset: -1 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto pop_1_error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-1] = res; DISPATCH(); @@ -1764,7 +1788,8 @@ PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1); PyStackRef_CLOSE(value2_st); PyStackRef_CLOSE(value1_st); - if (res_o == NULL) goto pop_2_error; + /* Variables: []. Base offset: -2. Top offset: -2 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto pop_2_error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; stack_pointer += -1; @@ -1909,7 +1934,8 @@ PyStackRef_CLOSE(args[_i]); } PyStackRef_CLOSE(kwnames); - if (true) { + /* Variables: []. Base offset: -3 - oparg. Top offset: -3 - oparg + LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -1952,8 +1978,8 @@ PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - } - if (res_o == NULL) goto error; + }/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[0] = res; @@ -2109,7 +2135,8 @@ PyStackRef_CLOSE(args[_i]); } PyStackRef_CLOSE(kwnames); - if (true) { + /* Variables: []. Base offset: -3 - oparg. Top offset: -3 - oparg + LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -2131,8 +2158,8 @@ PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - } - if (res_o == NULL) goto error; + }/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -2146,7 +2173,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: ['res']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -2314,8 +2342,8 @@ STAT_INC(CALL, hit); int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg)); PyStackRef_CLOSE(self); - PyStackRef_CLOSE(callable); - if (err) goto pop_3_error; + PyStackRef_CLOSE(callable);/* Variables: []. Base offset: -3. Top offset: -3 + LOCALS: [] */if (err) goto pop_3_error; #if TIER_ONE // Skip the following POP_TOP. This is done here in tier one, and // during trace projection in tier two: @@ -2367,7 +2395,8 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) { + /* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg + LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -2380,8 +2409,8 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable); - if (res_o == NULL) { + PyStackRef_CLOSE(callable);/* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -2399,7 +2428,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: ['res']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); } @@ -2450,7 +2480,8 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) { + /* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg + LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -2463,8 +2494,8 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable); - if (res_o == NULL) { + PyStackRef_CLOSE(callable);/* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -2482,7 +2513,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: ['res']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); } @@ -2537,8 +2569,8 @@ _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); - PyStackRef_CLOSE(callable); - if (res_o == NULL) goto error; + PyStackRef_CLOSE(callable);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -2552,7 +2584,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: ['res']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -2610,8 +2643,8 @@ assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); PyStackRef_CLOSE(arg_stackref); - PyStackRef_CLOSE(callable); - if (res_o == NULL) goto error; + PyStackRef_CLOSE(callable);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -2625,7 +2658,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: ['res']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -2676,7 +2710,8 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) { + /* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg + LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -2695,8 +2730,8 @@ PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - } - if (res_o == NULL) goto error; + }/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -2710,7 +2745,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: ['res']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -2908,8 +2944,13 @@ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); - PyStackRef_CLOSE(arg); - if (PyStackRef_IsNull(res)) goto error; + PyStackRef_CLOSE(arg);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=True)] */if (PyStackRef_IsNull(res)) { + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } // _CHECK_PERIODIC { @@ -2922,7 +2963,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: ['res']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -2960,8 +3002,13 @@ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); - PyStackRef_CLOSE(arg); - if (PyStackRef_IsNull(res)) goto error; + PyStackRef_CLOSE(arg);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=True)] */if (PyStackRef_IsNull(res)) { + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } // _CHECK_PERIODIC { @@ -2974,7 +3021,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: ['res']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -3033,7 +3081,8 @@ if (err < 0) { PyStackRef_CLOSE(exc_value_st); PyStackRef_CLOSE(match_type_st); - if (true) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('rest', in_memory=False, defined=False), Local('match', in_memory=False, defined=False)] */if (true) goto error; } PyObject *match_o = NULL; PyObject *rest_o = NULL; @@ -3043,9 +3092,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(exc_value_st); PyStackRef_CLOSE(match_type_st); - if (res < 0) goto error; - assert((match_o == NULL) == (rest_o == NULL)); - if (match_o == NULL) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('rest', in_memory=False, defined=False), Local('match', in_memory=False, defined=False)] */if (res < 0) goto error; + assert((match_o == NULL) == (rest_o == NULL));/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('rest', in_memory=False, defined=False), Local('match', in_memory=False, defined=False)] */if (match_o == NULL) goto error; if (!Py_IsNone(match_o)) { _PyFrame_SetStackPointer(frame, stack_pointer); PyErr_SetHandledException(match_o); @@ -3079,7 +3129,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { PyStackRef_CLOSE(right); - if (true) goto error; + /* Variables: ['left']. Base offset: -1. Top offset: 0 + LOCALS: [Local('b', in_memory=False, defined=False)] */if (true) goto error; } _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyErr_GivenExceptionMatches(left_o, right_o); @@ -3123,8 +3174,8 @@ else { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetRaisedException(tstate, Py_NewRef(exc_value)); - stack_pointer = _PyFrame_GetStackPointer(frame); monitor_reraise(tstate, frame, this_instr); + stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; } stack_pointer[0] = none; @@ -3174,13 +3225,14 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - if (res_o == NULL) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; if (oparg & 16) { _PyFrame_SetStackPointer(frame, stack_pointer); int res_bool = PyObject_IsTrue(res_o); stack_pointer = _PyFrame_GetStackPointer(frame); - Py_DECREF(res_o); - if (res_bool < 0) goto error; + Py_DECREF(res_o);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_bool < 0) goto error; res = res_bool ? PyStackRef_True : PyStackRef_False; } else { @@ -3351,7 +3403,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - if (res < 0) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('b', in_memory=False, defined=False)] */if (res < 0) goto error; b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; } stack_pointer[0] = b; @@ -3382,7 +3435,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - if (res < 0) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('b', in_memory=False, defined=False)] */if (res < 0) goto error; b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; stack_pointer[0] = b; stack_pointer += 1; @@ -3413,7 +3467,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - if (res < 0) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('b', in_memory=False, defined=False)] */if (res < 0) goto error; b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; stack_pointer[0] = b; stack_pointer += 1; @@ -3432,8 +3487,8 @@ assert(oparg >= FVC_STR && oparg <= FVC_ASCII); conv_fn = _PyEval_ConversionFuncs[oparg]; PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value)); - PyStackRef_CLOSE(value); - if (result_o == NULL) goto pop_1_error; + PyStackRef_CLOSE(value);/* Variables: []. Base offset: -1. Top offset: -1 + LOCALS: [Local('result', in_memory=False, defined=False)] */if (result_o == NULL) goto pop_1_error; result = PyStackRef_FromPyObjectSteal(result_o); stack_pointer[-1] = result; DISPATCH(); @@ -3484,7 +3539,8 @@ int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(owner); - if (err) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (err) goto error; DISPATCH(); } @@ -3520,7 +3576,8 @@ PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg) ); stack_pointer = _PyFrame_GetStackPointer(frame); - if (1) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (1) goto error; } SETLOCAL(oparg, PyStackRef_NULL); DISPATCH(); @@ -3594,7 +3651,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); - if (err) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (err) goto error; DISPATCH(); } @@ -3621,7 +3679,8 @@ _PyEval_FormatKwargsError(tstate, callable_o, update_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(update); - if (true) goto error; + /* Variables: ['callable', 'unused', 'unused', 'dict', 'unused']. Base offset: -4 - (oparg - 1). Top offset: 0 + LOCALS: [] */if (true) goto error; } PyStackRef_CLOSE(update); DISPATCH(); @@ -3654,7 +3713,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(update); - if (true) goto error; + /* Variables: ['dict', 'unused']. Base offset: -1 - (oparg - 1). Top offset: 0 + LOCALS: [] */if (true) goto error; } PyStackRef_CLOSE(update); DISPATCH(); @@ -3684,8 +3744,8 @@ Py_INCREF(exc); _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetRaisedException(tstate, exc); - stack_pointer = _PyFrame_GetStackPointer(frame); monitor_reraise(tstate, frame, this_instr); + stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; } DISPATCH(); @@ -3801,8 +3861,13 @@ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Format(value_o, NULL)); stack_pointer = _PyFrame_GetStackPointer(frame); - PyStackRef_CLOSE(value); - if (PyStackRef_IsNull(res)) goto error; + PyStackRef_CLOSE(value);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=True)] */if (PyStackRef_IsNull(res)) { + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } else { res = value;stack_pointer += -1; @@ -3829,8 +3894,8 @@ PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - PyStackRef_CLOSE(fmt_spec); - if (res_o == NULL) goto error; + PyStackRef_CLOSE(fmt_spec);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; @@ -4039,8 +4104,8 @@ long value = r->start; r->start = value + r->step; r->len--; - PyObject *res = PyLong_FromLong(value); - if (res == NULL) goto error; + PyObject *res = PyLong_FromLong(value);/* Variables: ['iter']. Base offset: -1. Top offset: 0 + LOCALS: [Local('next', in_memory=False, defined=False)] */if (res == NULL) goto error; next = PyStackRef_FromPyObjectSteal(res); } stack_pointer[0] = next; @@ -4121,11 +4186,13 @@ type->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(obj); - if (true) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('iter', in_memory=False, defined=False)] */if (true) goto error; } iter_o = (*getter)(obj_o); PyStackRef_CLOSE(obj); - if (iter_o == NULL) goto pop_1_error; + /* Variables: []. Base offset: -1. Top offset: -1 + LOCALS: [Local('iter', in_memory=False, defined=False)] */if (iter_o == NULL) goto pop_1_error; if (Py_TYPE(iter_o)->tp_as_async == NULL || Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) { stack_pointer += -1; @@ -4136,8 +4203,8 @@ "that does not implement __anext__: %.100s", Py_TYPE(iter_o)->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); - Py_DECREF(iter_o); - if (true) goto error; + Py_DECREF(iter_o);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('iter', in_memory=False, defined=False)] */if (true) goto error; } iter = PyStackRef_FromPyObjectSteal(iter_o); stack_pointer[-1] = iter; @@ -4177,7 +4244,8 @@ PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); - if (iter_o == NULL) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('iter', in_memory=False, defined=False)] */if (iter_o == NULL) goto error; iter = PyStackRef_FromPyObjectSteal(iter_o); stack_pointer[0] = iter; stack_pointer += 1; @@ -4199,7 +4267,13 @@ iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable))); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); - if (PyStackRef_IsNull(iter)) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('iter', in_memory=False, defined=True)] */if (PyStackRef_IsNull(iter)) { + stack_pointer[0] = iter; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } stack_pointer[0] = iter; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -4217,11 +4291,13 @@ _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj)); stack_pointer = _PyFrame_GetStackPointer(frame); - if (len_i < 0) goto error; + /* Variables: ['obj']. Base offset: -1. Top offset: 0 + LOCALS: [Local('len', in_memory=False, defined=False)] */if (len_i < 0) goto error; _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *len_o = PyLong_FromSsize_t(len_i); stack_pointer = _PyFrame_GetStackPointer(frame); - if (len_o == NULL) goto error; + /* Variables: ['obj']. Base offset: -1. Top offset: 0 + LOCALS: [Local('len', in_memory=False, defined=False)] */if (len_o == NULL) goto error; len = PyStackRef_FromPyObjectSteal(len_o); stack_pointer[0] = len; stack_pointer += 1; @@ -4286,7 +4362,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name); stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) goto error; + /* Variables: ['from']. Base offset: -1. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; @@ -4313,7 +4390,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(level); PyStackRef_CLOSE(fromlist); - if (res_o == NULL) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; @@ -4377,7 +4455,8 @@ frame, this_instr, function, arg0 ); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) goto error; + /* Variables: ['func', 'maybe_self', 'args']. Base offset: -2 - oparg. Top offset: 0 + LOCALS: [] */if (err) goto error; } // _DO_CALL self_or_null = maybe_self; @@ -4420,8 +4499,8 @@ PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - } - if (true) { + }/* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg + LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -4463,8 +4542,8 @@ PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - } - if (res_o == NULL) goto error; + }/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -4478,7 +4557,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: ['res']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -4515,7 +4595,8 @@ tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, function, arg); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (err) goto error; PAUSE_ADAPTIVE_COUNTER(this_instr[1].counter); GO_TO_INSTRUCTION(CALL_KW); } @@ -4532,10 +4613,15 @@ /* Need to create a fake StopIteration error here, * to conform to PEP 380 */ if (PyStackRef_GenCheck(receiver)) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { goto error; - } + }stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); } PyStackRef_CLOSE(value); stack_pointer += -1; @@ -4554,10 +4640,16 @@ receiver = stack_pointer[-2]; PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver); if (PyGen_Check(receiver_o) || PyCoro_CheckExact(receiver_o)) { + stack_pointer[-2] = value; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { goto error; - } + }stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); } PyStackRef_CLOSE(receiver); stack_pointer[-2] = value; @@ -4614,7 +4706,8 @@ int next_opcode = _Py_call_instrumentation_instruction( tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); - if (next_opcode < 0) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (next_opcode < 0) goto error; next_instr = this_instr; if (_PyOpcode_Caches[next_opcode]) { PAUSE_ADAPTIVE_COUNTER(next_instr[1].counter); @@ -4638,7 +4731,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; } } // _MONITOR_JUMP_BACKWARD @@ -4671,12 +4765,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); next_instr = this_instr; } else { - _PyFrame_SetStackPointer(frame, stack_pointer); _PyFrame_SetStackPointer(frame, stack_pointer); original_opcode = _Py_call_instrumentation_line( tstate, frame, this_instr, prev_instr); stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer = _PyFrame_GetStackPointer(frame); if (original_opcode < 0) { next_instr = this_instr+1; goto error; @@ -4819,19 +4911,19 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; } } } // _MONITOR_RESUME { - _PyFrame_SetStackPointer(frame, stack_pointer); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation( tstate, oparg > 0, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (err) goto error; if (frame->instr_ptr != this_instr) { /* Instrumentation has jumped */ next_instr = frame->instr_ptr; @@ -4863,9 +4955,8 @@ tstate, PY_MONITORING_EVENT_PY_RETURN, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) { - goto error; - } + /* Variables: ['val']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err) goto error; } // _RETURN_VALUE retval = val; @@ -4909,9 +5000,8 @@ tstate, PY_MONITORING_EVENT_PY_RETURN, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) { - goto error; - } + /* Variables: ['val']. Base offset: -1. Top offset: 0 + LOCALS: [] */if (err) goto error; } // _RETURN_VALUE retval = val; @@ -4950,13 +5040,11 @@ // _YIELD_VALUE_EVENT val = stack_pointer[-1]; { - SAVE_SP(); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_arg( tstate, PY_MONITORING_EVENT_PY_YIELD, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); stack_pointer = _PyFrame_GetStackPointer(frame); - LOAD_SP(); if (err) { goto error; } @@ -5068,7 +5156,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; } } // _JUMP_BACKWARD @@ -5091,7 +5180,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int optimized = _PyOptimizer_Optimize(frame, start, stack_pointer, &executor, 0); stack_pointer = _PyFrame_GetStackPointer(frame); - if (optimized < 0) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (optimized < 0) goto error; if (optimized) { assert(tstate->previous_executor == NULL); tstate->previous_executor = Py_None; @@ -5139,7 +5229,8 @@ _PyStackRef v; v = stack_pointer[-1]; list = stack_pointer[-2 - (oparg-1)]; - if (_PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list), + /* Variables: ['list', 'unused']. Base offset: -2 - (oparg-1). Top offset: -1 + LOCALS: [] */if (_PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list), PyStackRef_AsPyObjectSteal(v)) < 0) goto pop_1_error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -5176,7 +5267,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(iterable_st); - if (true) goto error; + /* Variables: ['list_st', 'unused']. Base offset: -1 - (oparg-1). Top offset: 0 + LOCALS: [] */if (true) goto error; } assert(Py_IsNone(none_val)); PyStackRef_CLOSE(iterable_st); @@ -5240,7 +5332,8 @@ meth | NULL | arg1 | ... | argN */ PyStackRef_CLOSE(owner); - if (attr_o == NULL) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('attr', in_memory=False, defined=False), Local('self_or_null', in_memory=False, defined=False)] */if (attr_o == NULL) goto error; self_or_null = PyStackRef_NULL; } } @@ -5252,7 +5345,8 @@ attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(owner); - if (attr_o == NULL) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('attr', in_memory=False, defined=False), Local('self_or_null', in_memory=False, defined=False)] */if (attr_o == NULL) goto error; /* We need to define self_or_null on all paths */ self_or_null = PyStackRef_NULL; } @@ -5826,14 +5920,17 @@ _PyStackRef bc; PyObject *bc_o; _PyFrame_SetStackPointer(frame, stack_pointer); - if (PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o) < 0) goto error; + int err = PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o); stack_pointer = _PyFrame_GetStackPointer(frame); + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('bc', in_memory=False, defined=False)] */if (err < 0) goto error; if (bc_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_NameError, "__build_class__ not found"); stack_pointer = _PyFrame_GetStackPointer(frame); - if (true) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('bc', in_memory=False, defined=False)] */if (true) goto error; } bc = PyStackRef_FromPyObjectSteal(bc_o); stack_pointer[0] = bc; @@ -5887,7 +5984,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); - if (true) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('value', in_memory=False, defined=False)] */if (true) goto error; } value = PyStackRef_FromPyObjectSteal(value_o); stack_pointer[0] = value; @@ -5936,7 +6034,8 @@ PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg) ); stack_pointer = _PyFrame_GetStackPointer(frame); - if (1) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('value', in_memory=False, defined=False)] */if (1) goto error; } value = PyStackRef_DUP(value_s); stack_pointer[0] = value; @@ -6043,20 +6142,25 @@ /* Slow-path if globals or builtins is not a dict */ /* namespace 1: globals */ _PyFrame_SetStackPointer(frame, stack_pointer); - if (PyMapping_GetOptionalItem(GLOBALS(), name, &v_o) < 0) goto error; + int err = PyMapping_GetOptionalItem(GLOBALS(), name, &v_o); stack_pointer = _PyFrame_GetStackPointer(frame); + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('v', in_memory=False, defined=False)] */if (err < 0) goto error; if (v_o == NULL) { /* namespace 2: builtins */ _PyFrame_SetStackPointer(frame, stack_pointer); - if (PyMapping_GetOptionalItem(BUILTINS(), name, &v_o) < 0) goto error; + int err = PyMapping_GetOptionalItem(BUILTINS(), name, &v_o); stack_pointer = _PyFrame_GetStackPointer(frame); + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('v', in_memory=False, defined=False)] */if (err < 0) goto error; if (v_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg( tstate, PyExc_NameError, NAME_ERROR_MSG, name); stack_pointer = _PyFrame_GetStackPointer(frame); - if (true) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('v', in_memory=False, defined=False)] */if (true) goto error; } } } @@ -6104,7 +6208,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_LoadGlobal(GLOBALS(), BUILTINS(), name); stack_pointer = _PyFrame_GetStackPointer(frame); - if (res_o == NULL) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False), Local('null', in_memory=False, defined=False)] */if (res_o == NULL) goto error; null = PyStackRef_NULL; res = PyStackRef_FromPyObjectSteal(res_o); } @@ -6205,7 +6310,8 @@ _PyErr_SetString(tstate, PyExc_SystemError, "no locals found"); stack_pointer = _PyFrame_GetStackPointer(frame); - if (true) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('locals', in_memory=False, defined=False)] */if (true) goto error; } locals = PyStackRef_FromPyObjectNew(l); stack_pointer[0] = locals; @@ -6223,7 +6329,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *v_o = _PyEval_LoadName(tstate, frame, name); stack_pointer = _PyFrame_GetStackPointer(frame); - if (v_o == NULL) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('v', in_memory=False, defined=False)] */if (v_o == NULL) goto error; v = PyStackRef_FromPyObjectSteal(v_o); stack_pointer[0] = v; stack_pointer += 1; @@ -6261,8 +6368,13 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } + }/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('attr', in_memory=False, defined=True), Local('self_or_null', in_memory=False, defined=False)] */if (PyStackRef_IsNull(attr)) { + stack_pointer[0] = attr; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; } - if (PyStackRef_IsNull(attr)) goto error; self_or_null = PyStackRef_FromPyObjectSteal(self_or_null_o); stack_pointer[0] = attr; stack_pointer[1] = self_or_null; @@ -6317,7 +6429,8 @@ tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, global_super, arg); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('attr', in_memory=False, defined=False), Local('null', in_memory=False, defined=False)] */if (err) goto error; stack_pointer += 3; assert(WITHIN_STACK_BOUNDS()); } @@ -6354,13 +6467,19 @@ PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); PyStackRef_CLOSE(self_st); - if (super == NULL) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('attr', in_memory=False, defined=False), Local('null', in_memory=False, defined=False)] */if (super == NULL) goto error; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); _PyFrame_SetStackPointer(frame, stack_pointer); attr = PyStackRef_FromPyObjectSteal(PyObject_GetAttr(super, name)); stack_pointer = _PyFrame_GetStackPointer(frame); - Py_DECREF(super); - if (PyStackRef_IsNull(attr)) goto error; + Py_DECREF(super);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('attr', in_memory=False, defined=True), Local('null', in_memory=False, defined=False)] */if (PyStackRef_IsNull(attr)) { + stack_pointer[0] = attr; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } null = PyStackRef_NULL; } stack_pointer[0] = attr; @@ -6399,7 +6518,8 @@ PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); PyStackRef_CLOSE(self_st); - if (attr == NULL) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('attr_st', in_memory=False, defined=False), Local('unused', in_memory=False, defined=False)] */if (attr == NULL) goto error; attr_st = PyStackRef_FromPyObjectSteal(attr); stack_pointer[0] = attr_st; stack_pointer += 1; @@ -6440,8 +6560,8 @@ PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); if (attr_o == NULL) { - PyStackRef_CLOSE(self_st); - if (true) goto error; + PyStackRef_CLOSE(self_st);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('attr', in_memory=False, defined=False), Local('self_or_null', in_memory=False, defined=False)] */if (true) goto error; } if (method_found) { self_or_null = self_st; // transfer ownership @@ -6524,7 +6644,8 @@ PyStackRef_AsPyObjectSteal(value) ); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: ['dict_st', 'unused']. Base offset: -1 - (oparg - 1). Top offset: 0 + LOCALS: [] */if (err != 0) goto error; DISPATCH(); } @@ -6557,8 +6678,8 @@ assert(PyTuple_CheckExact(attrs_o)); // Success! attrs = PyStackRef_FromPyObjectSteal(attrs_o); } - else { - if (_PyErr_Occurred(tstate)) goto error; + else {/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('attrs', in_memory=False, defined=False)] */if (_PyErr_Occurred(tstate)) goto error; // Error! attrs = PyStackRef_None; // Failure! } @@ -6582,7 +6703,8 @@ PyObject *values_or_none_o = _PyEval_MatchKeys(tstate, PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys)); stack_pointer = _PyFrame_GetStackPointer(frame); - if (values_or_none_o == NULL) goto error; + /* Variables: ['subject', 'keys']. Base offset: -2. Top offset: 0 + LOCALS: [Local('values_or_none', in_memory=False, defined=False)] */if (values_or_none_o == NULL) goto error; values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o); stack_pointer[0] = values_or_none; stack_pointer += 1; @@ -6811,10 +6933,14 @@ PyObject *exc = oparg > 0 ? PyStackRef_AsPyObjectSteal(args[0]) : NULL; if (do_raise(tstate, exc, cause)) { assert(oparg == 0); + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); monitor_reraise(tstate, frame, this_instr); + stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; - } - if (true) { + }/* Variables: []. Base offset: -oparg. Top offset: -oparg + LOCALS: [] */if (true) { stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -6858,8 +6984,8 @@ assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetRaisedException(tstate, exc); - stack_pointer = _PyFrame_GetStackPointer(frame); monitor_reraise(tstate, frame, this_instr); + stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; } @@ -6913,7 +7039,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (err != 0) goto error; } } } @@ -7184,30 +7311,33 @@ frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(SETUP_ANNOTATIONS); - int err; PyObject *ann_dict; if (LOCALS() == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when setting up annotations"); stack_pointer = _PyFrame_GetStackPointer(frame); - if (true) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (true) goto error; } /* check if __annotations__ in locals()... */ _PyFrame_SetStackPointer(frame, stack_pointer); - if (PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict) < 0) goto error; + int err = PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict); stack_pointer = _PyFrame_GetStackPointer(frame); + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (err < 0) goto error; if (ann_dict == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); ann_dict = PyDict_New(); stack_pointer = _PyFrame_GetStackPointer(frame); - if (ann_dict == NULL) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (ann_dict == NULL) goto error; _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__), ann_dict); stack_pointer = _PyFrame_GetStackPointer(frame); - Py_DECREF(ann_dict); - if (err) goto error; + Py_DECREF(ann_dict);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (err) goto error; } else { Py_DECREF(ann_dict); @@ -7230,7 +7360,8 @@ PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); - if (err) goto error; + /* Variables: ['set', 'unused']. Base offset: -1 - (oparg-1). Top offset: 0 + LOCALS: [] */if (err) goto error; DISPATCH(); } @@ -7271,7 +7402,8 @@ PyStackRef_AsPyObjectBorrow(iterable)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); - if (err < 0) goto error; + /* Variables: ['set', 'unused']. Base offset: -1 - (oparg-1). Top offset: 0 + LOCALS: [] */if (err < 0) goto error; DISPATCH(); } @@ -7315,7 +7447,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); PyStackRef_CLOSE(owner); - if (err) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (err) goto error; } DISPATCH(); } @@ -7534,7 +7667,8 @@ int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); - if (err) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (err) goto error; DISPATCH(); } @@ -7555,7 +7689,8 @@ "no locals found when storing %R", name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); - if (true) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (true) goto error; } if (PyDict_CheckExact(ns)) { stack_pointer += -1; @@ -7572,7 +7707,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(v); - if (err) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (err) goto error; DISPATCH(); } @@ -7606,8 +7742,8 @@ Py_DECREF(slice); } PyStackRef_CLOSE(v); - PyStackRef_CLOSE(container); - if (err) goto error; + PyStackRef_CLOSE(container);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (err) goto error; DISPATCH(); } @@ -7651,7 +7787,8 @@ PyStackRef_CLOSE(v); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); - if (err) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (err) goto error; } DISPATCH(); } @@ -7678,8 +7815,8 @@ PyStackRef_AsPyObjectSteal(sub), PyStackRef_AsPyObjectSteal(value)); stack_pointer = _PyFrame_GetStackPointer(frame); - PyStackRef_CLOSE(dict_st); - if (err) goto error; + PyStackRef_CLOSE(dict_st);/* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [] */if (err) goto error; DISPATCH(); } @@ -7765,7 +7902,8 @@ int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - if (err < 0) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (err < 0) goto error; res = err ? PyStackRef_True : PyStackRef_False; } stack_pointer[0] = res; @@ -7916,7 +8054,8 @@ PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - if (res_o == NULL) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; @@ -7937,7 +8076,8 @@ PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - if (res_o == NULL) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; @@ -7974,7 +8114,8 @@ int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(seq); - if (res == 0) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('left', in_memory=True, defined=False), Local('unused', in_memory=False, defined=False), Local('right', in_memory=True, defined=False)] */if (res == 0) goto error; stack_pointer += 1 + (oparg & 0xFF) + (oparg >> 8); assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -8018,7 +8159,8 @@ int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(seq); - if (res == 0) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('output', in_memory=True, defined=False)] */if (res == 0) goto error; } stack_pointer += oparg; assert(WITHIN_STACK_BOUNDS()); @@ -8142,7 +8284,13 @@ res = PyStackRef_FromPyObjectSteal(PyObject_Vectorcall(exit_func_o, stack + 2 - has_self, (3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL)); stack_pointer = _PyFrame_GetStackPointer(frame); - if (PyStackRef_IsNull(res)) goto error; + /* Variables: ['exit_func', 'exit_self', 'lasti', 'unused', 'val']. Base offset: -5. Top offset: 0 + LOCALS: [Local('res', in_memory=False, defined=True)] */if (PyStackRef_IsNull(res)) { + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -8311,7 +8459,13 @@ PyStackRef_CLOSE(func_st); PyStackRef_CLOSE(callargs_st); PyStackRef_XCLOSE(kwargs_st); - if (PyStackRef_IsNull(result)) goto error; + /* Variables: []. Base offset: 0. Top offset: 0 + LOCALS: [Local('result', in_memory=False, defined=True)] */if (PyStackRef_IsNull(result)) { + stack_pointer[0] = result; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } stack_pointer[0] = result; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 36783c6b283617..e48178124e1e67 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -571,6 +571,8 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "_PyObject_GC_MAY_BE_TRACKED", "ADAPTIVE_COUNTER_TRIGGERS", "_PyInterpreterState_GET", + "PyType_HasFeature", + "_Py_ID", ) def find_stmt_start(node: parser.InstDef, idx: int) -> lexer.Token: @@ -602,6 +604,9 @@ def check_escaping_calls(instr: parser.InstDef, escapes: dict[lexer.Token, lexer if tkn.kind == "IF": next(tkn_iter) in_if = 1 + if tkn.kind == "IDENTIFIER" and tkn.text in ("DEOPT_IF", "ERROR_IF"): + next(tkn_iter) + in_if = 1 elif tkn.kind == "LPAREN" and in_if: in_if += 1 elif tkn.kind == "RPAREN": @@ -622,7 +627,7 @@ def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, lexer.To break if next_tkn.kind != lexer.LPAREN: continue - if not tkn.text.startswith("Py") and not tkn.text.startswith("_Py"): + if not tkn.text.startswith("Py") and not tkn.text.startswith("_Py") and not tkn.text.startswith("monitor"): continue if tkn.text.endswith("Check"): continue diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index bd8dde0e9e461e..4e07ad3bc2d41d 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -162,6 +162,7 @@ def error_if( storage: Storage, inst: Instruction | None, ) -> bool: + self.emit(storage.as_comment()) self.out.emit_at("if ", tkn) lparen = next(tkn_iter) self.emit(lparen) @@ -172,11 +173,14 @@ def error_if( next(tkn_iter) # RPAREN next(tkn_iter) # Semi colon self.out.emit(") ") - c_offset = storage.stack.peek_offset() - try: - offset = -int(c_offset) - except ValueError: + if storage.locals_cached(): offset = -1 + else: + c_offset = storage.stack.peek_offset() + try: + offset = -int(c_offset) + except ValueError: + offset = -1 if offset > 0: self.out.emit(f"goto pop_{offset}_") self.out.emit(label) diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index 4ef33ecfcc99d9..d2a9b187f8db83 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -420,6 +420,12 @@ def _push_defined_locals(self) -> None: else: undefined = out.name + def locals_cached(self) -> bool: + for out in self.outputs: + if out.defined: + return True + return False + def flush(self, out: CWriter) -> None: self._push_defined_locals() self.stack.flush(out) From 8e258ad4821aa4f36c4671754ae65f33e331eefb Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Tue, 10 Sep 2024 14:17:38 +0100 Subject: [PATCH 24/53] Improve tracking of stack and locals in conditional flow --- Lib/test/test_generated_cases.py | 67 ++- Python/bytecodes.c | 8 +- Python/executor_cases.c.h | 79 ++- Python/generated_cases.c.h | 484 ++++++++----------- Python/optimizer_cases.c.h | 1 - Tools/cases_generator/generators_common.py | 23 +- Tools/cases_generator/optimizer_generator.py | 11 +- Tools/cases_generator/stack.py | 51 +- Tools/cases_generator/tier1_generator.py | 12 +- 9 files changed, 347 insertions(+), 389 deletions(-) diff --git a/Lib/test/test_generated_cases.py b/Lib/test/test_generated_cases.py index 43e56741c4d295..ab0d1cfaba3497 100644 --- a/Lib/test/test_generated_cases.py +++ b/Lib/test/test_generated_cases.py @@ -249,7 +249,8 @@ def test_overlap(self): def test_predictions(self): input = """ - inst(OP1, (arg -- rest)) { + inst(OP1, (arg -- res)) { + res = Py_None; } inst(OP3, (arg -- res)) { DEOPT_IF(xxx); @@ -263,7 +264,9 @@ def test_predictions(self): next_instr += 1; INSTRUCTION_STATS(OP1); PREDICTED(OP1); - stack_pointer[-1] = rest; + _PyStackRef res; + res = Py_None; + stack_pointer[-1] = res; DISPATCH(); } @@ -378,6 +381,35 @@ def test_error_if_plain_with_comment(self): self.run_cases_test(input, output) def test_error_if_pop(self): + input = """ + inst(OP, (left, right -- res)) { + spam(left, right); + ERROR_IF(cond, label); + res = 0; + } + """ + output = """ + TARGET(OP) { + frame->instr_ptr = next_instr; + next_instr += 1; + INSTRUCTION_STATS(OP); + _PyStackRef left; + _PyStackRef right; + _PyStackRef res; + right = stack_pointer[-1]; + left = stack_pointer[-2]; + spam(left, right); + if (cond) goto pop_2_label; + res = 0; + stack_pointer[-2] = res; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + DISPATCH(); + } + """ + self.run_cases_test(input, output) + + def test_error_if_pop_with_result(self): input = """ inst(OP, (left, right -- res)) { res = spam(left, right); @@ -395,7 +427,12 @@ def test_error_if_pop(self): right = stack_pointer[-1]; left = stack_pointer[-2]; res = spam(left, right); - if (cond) goto pop_2_label; + if (cond) { + stack_pointer[-2] = res; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + goto label; + } stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -609,6 +646,8 @@ def test_array_output(self): input = """ inst(OP, (unused, unused -- below, values[oparg*3], above)) { spam(values, oparg); + below = 0; + above = 0; } """ output = """ @@ -616,9 +655,13 @@ def test_array_output(self): frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(OP); + _PyStackRef below; _PyStackRef *values; + _PyStackRef above; values = &stack_pointer[-1]; spam(values, oparg); + below = 0; + above = 0; stack_pointer[-2] = below; stack_pointer[-1 + oparg*3] = above; stack_pointer += oparg*3; @@ -632,6 +675,7 @@ def test_array_input_output(self): input = """ inst(OP, (values[oparg] -- values[oparg], above)) { spam(values, oparg); + above = 0; } """ output = """ @@ -640,8 +684,10 @@ def test_array_input_output(self): next_instr += 1; INSTRUCTION_STATS(OP); _PyStackRef *values; + _PyStackRef above; values = &stack_pointer[-oparg]; spam(values, oparg); + above = 0; stack_pointer[0] = above; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -677,6 +723,8 @@ def test_cond_effect(self): input = """ inst(OP, (aa, input if ((oparg & 1) == 1), cc -- xx, output if (oparg & 2), zz)) { output = spam(oparg, aa, cc, input); + xx = 0; + zz = 0; } """ output = """ @@ -687,11 +735,15 @@ def test_cond_effect(self): _PyStackRef aa; _PyStackRef input = PyStackRef_NULL; _PyStackRef cc; + _PyStackRef xx; _PyStackRef output = PyStackRef_NULL; + _PyStackRef zz; cc = stack_pointer[-1]; if ((oparg & 1) == 1) { input = stack_pointer[-1 - (((oparg & 1) == 1) ? 1 : 0)]; } aa = stack_pointer[-2 - (((oparg & 1) == 1) ? 1 : 0)]; output = spam(oparg, aa, cc, input); + xx = 0; + zz = 0; stack_pointer[-2 - (((oparg & 1) == 1) ? 1 : 0)] = xx; if (oparg & 2) stack_pointer[-1 - (((oparg & 1) == 1) ? 1 : 0)] = output; stack_pointer[-1 - (((oparg & 1) == 1) ? 1 : 0) + ((oparg & 2) ? 1 : 0)] = zz; @@ -708,6 +760,7 @@ def test_macro_cond_effect(self): use(left, middle, right); } op(B, (-- deep, extra if (oparg), res)) { + deep = -1; res = 0; extra = 1; } @@ -721,6 +774,7 @@ def test_macro_cond_effect(self): _PyStackRef left; _PyStackRef middle; _PyStackRef right; + _PyStackRef deep; _PyStackRef extra = PyStackRef_NULL; _PyStackRef res; // A @@ -732,6 +786,7 @@ def test_macro_cond_effect(self): } // B { + deep = -1; res = 0; extra = 1; } @@ -1251,14 +1306,14 @@ def test_overridden_abstract_args(self): """ input2 = """ op(OP, (arg1 -- out)) { - eggs(); + out = eggs(); } """ output = """ case OP: { _Py_UopsSymbol *arg1; _Py_UopsSymbol *out; - eggs(); + out = eggs(); stack_pointer[-1] = out; break; } @@ -1284,6 +1339,7 @@ def test_no_overridden_case(self): """ input2 = """ pure op(OP2, (arg1 -- out)) { + out = NULL; } """ output = """ @@ -1297,6 +1353,7 @@ def test_no_overridden_case(self): case OP2: { _Py_UopsSymbol *arg1; _Py_UopsSymbol *out; + out = NULL; stack_pointer[-1] = out; break; } diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 5b0ca89ae13575..19c2e9bd8194ec 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -1218,9 +1218,9 @@ dummy_func( int matches = PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration); if (matches) { + none = PyStackRef_None; value = PyStackRef_FromPyObjectNew(((PyStopIterationObject *)exc_value)->value); DECREF_INPUTS(); - none = PyStackRef_None; } else { _PyErr_SetRaisedException(tstate, Py_NewRef(exc_value)); @@ -1231,16 +1231,18 @@ dummy_func( inst(LOAD_COMMON_CONSTANT, ( -- value)) { // Keep in sync with _common_constants in opcode.py + PyObject *val; switch(oparg) { case CONSTANT_ASSERTIONERROR: - value = PyStackRef_FromPyObjectImmortal(PyExc_AssertionError); + val = PyExc_AssertionError; break; case CONSTANT_NOTIMPLEMENTEDERROR: - value = PyStackRef_FromPyObjectImmortal(PyExc_NotImplementedError); + val = PyExc_NotImplementedError; break; default: Py_FatalError("bad LOAD_COMMON_CONSTANT oparg"); } + value = PyStackRef_FromPyObjectImmortal(val); } inst(LOAD_BUILD_CLASS, ( -- bc)) { diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 9838699187df1b..525b490a800bfc 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -1041,9 +1041,6 @@ if (rc <= 0) JUMP_TO_ERROR(); // not found or error res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1339,8 +1336,7 @@ if (true) JUMP_TO_ERROR(); } iter = PyStackRef_FromPyObjectSteal(iter_o); - stack_pointer[0] = iter; - stack_pointer += 1; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1477,16 +1473,18 @@ _PyStackRef value; oparg = CURRENT_OPARG(); // Keep in sync with _common_constants in opcode.py + PyObject *val; switch(oparg) { case CONSTANT_ASSERTIONERROR: - value = PyStackRef_FromPyObjectImmortal(PyExc_AssertionError); + val = PyExc_AssertionError; break; case CONSTANT_NOTIMPLEMENTEDERROR: - value = PyStackRef_FromPyObjectImmortal(PyExc_NotImplementedError); + val = PyExc_NotImplementedError; break; default: Py_FatalError("bad LOAD_COMMON_CONSTANT oparg"); } + value = PyStackRef_FromPyObjectImmortal(val); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1969,9 +1967,6 @@ } PyStackRef_CLOSE(class_dict_st); value = PyStackRef_FromPyObjectSteal(value_o); - stack_pointer[0] = value; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -2164,9 +2159,6 @@ if (true) JUMP_TO_ERROR(); } set = PyStackRef_FromPyObjectSteal(set_o); - stack_pointer[0] = set; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -2884,6 +2876,8 @@ Py_XDECREF(old_value); STAT_INC(STORE_ATTR, hit); PyStackRef_CLOSE(owner); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -3166,10 +3160,6 @@ } rest = PyStackRef_FromPyObjectSteal(rest_o); match = PyStackRef_FromPyObjectSteal(match_o); - stack_pointer[0] = rest; - stack_pointer[1] = match; - stack_pointer += 2; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -3379,6 +3369,8 @@ stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(iter)) JUMP_TO_ERROR(); + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -3668,9 +3660,6 @@ assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(attr)) JUMP_TO_ERROR(); self_or_null = PyStackRef_FromPyObjectSteal(self_or_null_o); - stack_pointer[0] = self_or_null; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -3719,6 +3708,8 @@ stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -3942,8 +3933,7 @@ if (new_frame == NULL) { JUMP_TO_ERROR(); } - stack_pointer[0].bits = (uintptr_t)new_frame; - stack_pointer += 1; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4077,8 +4067,7 @@ } if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4393,6 +4382,8 @@ stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -4427,6 +4418,8 @@ stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -4586,8 +4579,7 @@ assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4640,8 +4632,7 @@ PyStackRef_CLOSE(callable); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4699,8 +4690,7 @@ assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4757,8 +4747,7 @@ assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4809,8 +4798,7 @@ PyStackRef_CLOSE(callable); PyStackRef_CLOSE(arg_stackref); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4856,8 +4844,7 @@ PyStackRef_CLOSE(inst_stackref); PyStackRef_CLOSE(cls_stackref); PyStackRef_CLOSE(callable); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4957,8 +4944,7 @@ PyStackRef_CLOSE(callable); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -5021,8 +5007,7 @@ assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -5082,8 +5067,7 @@ PyStackRef_CLOSE(callable); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -5146,8 +5130,7 @@ assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -5194,8 +5177,7 @@ if (new_frame == NULL) { JUMP_TO_ERROR(); } - stack_pointer[0].bits = (uintptr_t)new_frame; - stack_pointer += 1; + stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -5338,8 +5320,7 @@ } if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -5915,6 +5896,8 @@ stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); GOTO_UNWIND(); + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); break; } diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index ab9cd2cc6a4067..9856592811091b 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -47,8 +47,7 @@ PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o); PyStackRef_CLOSE(lhs); PyStackRef_CLOSE(rhs); - /* Variables: []. Base offset: -2. Top offset: -2 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto pop_2_error; + if (res_o == NULL) goto pop_2_error; res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; @@ -118,8 +117,8 @@ STAT_INC(BINARY_OP, hit); PyObject *res_o = _PyLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); - _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);/* Variables: []. Base offset: -2. Top offset: -2 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto pop_2_error; + _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); + if (res_o == NULL) goto pop_2_error; res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; @@ -153,8 +152,8 @@ STAT_INC(BINARY_OP, hit); PyObject *res_o = PyUnicode_Concat(left_o, right_o); _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc); - _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);/* Variables: []. Base offset: -2. Top offset: -2 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto pop_2_error; + _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); + if (res_o == NULL) goto pop_2_error; res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; @@ -214,8 +213,8 @@ PyObject *temp = PyStackRef_AsPyObjectBorrow(*target_local); PyUnicode_Append(&temp, right_o); *target_local = PyStackRef_FromPyObjectSteal(temp); - _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (PyStackRef_IsNull(*target_local)) goto error; + _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); + if (PyStackRef_IsNull(*target_local)) goto error; #if TIER_ONE // The STORE_FAST is already done. This is done here in tier one, // and during trace projection in tier two: @@ -287,8 +286,8 @@ STAT_INC(BINARY_OP, hit); PyObject *res_o = _PyLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); - _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);/* Variables: []. Base offset: -2. Top offset: -2 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto pop_2_error; + _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); + if (res_o == NULL) goto pop_2_error; res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; @@ -358,8 +357,8 @@ STAT_INC(BINARY_OP, hit); PyObject *res_o = _PyLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); - _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);;/* Variables: []. Base offset: -2. Top offset: -2 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto pop_2_error; + _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);; + if (res_o == NULL) goto pop_2_error; res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; @@ -398,8 +397,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); Py_DECREF(slice); } - PyStackRef_CLOSE(container);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + PyStackRef_CLOSE(container); + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; @@ -447,8 +446,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[0] = res; @@ -485,8 +483,7 @@ } PyStackRef_CLOSE(dict_st); PyStackRef_CLOSE(sub_st); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (rc <= 0) goto error; + if (rc <= 0) goto error; // not found or error res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; @@ -658,8 +655,8 @@ _PyStackRef *values; _PyStackRef list; values = &stack_pointer[-oparg]; - PyObject *list_o = _PyList_FromStackRefSteal(values, oparg);/* Variables: []. Base offset: -oparg. Top offset: -oparg - LOCALS: [Local('list', in_memory=False, defined=False)] */if (list_o == NULL) { + PyObject *list_o = _PyList_FromStackRefSteal(values, oparg); + if (list_o == NULL) { stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -683,8 +680,7 @@ for (int _i = oparg*2; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } - /* Variables: []. Base offset: -oparg*2. Top offset: -oparg*2 - LOCALS: [Local('map', in_memory=False, defined=False)] */if (true) { + if (true) { stack_pointer += -oparg*2; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -702,8 +698,7 @@ for (int _i = oparg*2; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('map', in_memory=False, defined=False)] */if (map_o == NULL) goto error; + if (map_o == NULL) goto error; map = PyStackRef_FromPyObjectSteal(map_o); stack_pointer[0] = map; stack_pointer += 1; @@ -727,8 +722,7 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('set', in_memory=False, defined=False)] */if (true) goto error; + if (true) goto error; } int err = 0; for (int i = 0; i < oparg; i++) { @@ -740,8 +734,8 @@ PyStackRef_CLOSE(values[i]); } if (err != 0) { - Py_DECREF(set_o);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('set', in_memory=False, defined=False)] */if (true) goto error; + Py_DECREF(set_o); + if (true) goto error; } set = PyStackRef_FromPyObjectSteal(set_o); stack_pointer[0] = set; @@ -768,8 +762,7 @@ PyStackRef_CLOSE(start); PyStackRef_CLOSE(stop); PyStackRef_XCLOSE(step); - /* Variables: []. Base offset: -2 - ((oparg == 3) ? 1 : 0). Top offset: -2 - ((oparg == 3) ? 1 : 0) - LOCALS: [Local('slice', in_memory=False, defined=False)] */if (slice_o == NULL) { + if (slice_o == NULL) { stack_pointer += -2 - ((oparg == 3) ? 1 : 0); assert(WITHIN_STACK_BOUNDS()); goto error; @@ -793,8 +786,7 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(pieces[_i]); } - /* Variables: []. Base offset: -oparg. Top offset: -oparg - LOCALS: [Local('str', in_memory=False, defined=False)] */if (true) { + if (true) { stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -805,8 +797,7 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(pieces[_i]); } - /* Variables: []. Base offset: -oparg. Top offset: -oparg - LOCALS: [Local('str', in_memory=False, defined=False)] */if (str_o == NULL) { + if (str_o == NULL) { stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -825,8 +816,8 @@ _PyStackRef *values; _PyStackRef tup; values = &stack_pointer[-oparg]; - PyObject *tup_o = _PyTuple_FromStackRefSteal(values, oparg);/* Variables: []. Base offset: -oparg. Top offset: -oparg - LOCALS: [Local('tup', in_memory=False, defined=False)] */if (tup_o == NULL) { + PyObject *tup_o = _PyTuple_FromStackRefSteal(values, oparg); + if (tup_o == NULL) { stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -940,8 +931,8 @@ PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }/* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg - LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { + } + if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -983,8 +974,8 @@ PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + } + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -998,8 +989,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['res']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -1332,8 +1322,7 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - /* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg - LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { + if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -1345,8 +1334,8 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable);/* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) { + PyStackRef_CLOSE(callable); + if (res_o == NULL) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -1364,8 +1353,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['res']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); } @@ -1411,8 +1399,7 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - /* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg - LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { + if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -1428,8 +1415,8 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable);/* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) { + PyStackRef_CLOSE(callable); + if (res_o == NULL) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -1447,8 +1434,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['res']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); } @@ -1496,8 +1482,7 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - /* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg - LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { + if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -1510,8 +1495,8 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable);/* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) { + PyStackRef_CLOSE(callable); + if (res_o == NULL) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -1529,8 +1514,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['res']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); } @@ -1581,8 +1565,8 @@ _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(arg); - PyStackRef_CLOSE(callable);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + PyStackRef_CLOSE(callable); + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -1596,8 +1580,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['res']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -1725,8 +1708,7 @@ PyStackRef_CLOSE(func_st); PyStackRef_CLOSE(callargs_st); PyStackRef_XCLOSE(kwargs_st); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('result', in_memory=False, defined=True)] */if (PyStackRef_IsNull(result)) { + if (PyStackRef_IsNull(result)) { stack_pointer[0] = result; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1744,8 +1726,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['result']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -1766,8 +1747,7 @@ assert(oparg <= MAX_INTRINSIC_1); PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value)); PyStackRef_CLOSE(value); - /* Variables: []. Base offset: -1. Top offset: -1 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto pop_1_error; + if (res_o == NULL) goto pop_1_error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-1] = res; DISPATCH(); @@ -1788,8 +1768,7 @@ PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1); PyStackRef_CLOSE(value2_st); PyStackRef_CLOSE(value1_st); - /* Variables: []. Base offset: -2. Top offset: -2 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto pop_2_error; + if (res_o == NULL) goto pop_2_error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; stack_pointer += -1; @@ -1934,8 +1913,7 @@ PyStackRef_CLOSE(args[_i]); } PyStackRef_CLOSE(kwnames); - /* Variables: []. Base offset: -3 - oparg. Top offset: -3 - oparg - LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { + if (true) { stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -1978,8 +1956,8 @@ PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + } + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[0] = res; @@ -2032,7 +2010,6 @@ // flush stack_pointer[-3 - oparg] = method; stack_pointer[-2 - oparg] = self; - stack_pointer[-1] = kwnames; // _PY_FRAME_KW args = &stack_pointer[-1 - oparg]; self_or_null = self; @@ -2135,8 +2112,7 @@ PyStackRef_CLOSE(args[_i]); } PyStackRef_CLOSE(kwnames); - /* Variables: []. Base offset: -3 - oparg. Top offset: -3 - oparg - LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { + if (true) { stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -2158,8 +2134,8 @@ PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + } + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -2173,8 +2149,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['res']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -2342,8 +2317,8 @@ STAT_INC(CALL, hit); int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg)); PyStackRef_CLOSE(self); - PyStackRef_CLOSE(callable);/* Variables: []. Base offset: -3. Top offset: -3 - LOCALS: [] */if (err) goto pop_3_error; + PyStackRef_CLOSE(callable); + if (err) goto pop_3_error; #if TIER_ONE // Skip the following POP_TOP. This is done here in tier one, and // during trace projection in tier two: @@ -2395,8 +2370,7 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - /* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg - LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { + if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -2409,8 +2383,8 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable);/* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) { + PyStackRef_CLOSE(callable); + if (res_o == NULL) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -2428,8 +2402,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['res']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); } @@ -2480,8 +2453,7 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - /* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg - LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { + if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -2494,8 +2466,8 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable);/* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) { + PyStackRef_CLOSE(callable); + if (res_o == NULL) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -2513,8 +2485,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['res']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); } @@ -2569,8 +2540,8 @@ _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); - PyStackRef_CLOSE(callable);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + PyStackRef_CLOSE(callable); + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -2584,8 +2555,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['res']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -2643,8 +2613,8 @@ assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); PyStackRef_CLOSE(arg_stackref); - PyStackRef_CLOSE(callable);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + PyStackRef_CLOSE(callable); + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -2658,8 +2628,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['res']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -2710,8 +2679,7 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - /* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg - LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { + if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -2730,8 +2698,8 @@ PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + } + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -2745,8 +2713,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['res']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -2944,8 +2911,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); - PyStackRef_CLOSE(arg);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=True)] */if (PyStackRef_IsNull(res)) { + PyStackRef_CLOSE(arg); + if (PyStackRef_IsNull(res)) { stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2963,8 +2930,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['res']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -3002,8 +2968,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); - PyStackRef_CLOSE(arg);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=True)] */if (PyStackRef_IsNull(res)) { + PyStackRef_CLOSE(arg); + if (PyStackRef_IsNull(res)) { stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3021,8 +2987,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['res']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -3081,8 +3046,7 @@ if (err < 0) { PyStackRef_CLOSE(exc_value_st); PyStackRef_CLOSE(match_type_st); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('rest', in_memory=False, defined=False), Local('match', in_memory=False, defined=False)] */if (true) goto error; + if (true) goto error; } PyObject *match_o = NULL; PyObject *rest_o = NULL; @@ -3092,10 +3056,9 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(exc_value_st); PyStackRef_CLOSE(match_type_st); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('rest', in_memory=False, defined=False), Local('match', in_memory=False, defined=False)] */if (res < 0) goto error; - assert((match_o == NULL) == (rest_o == NULL));/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('rest', in_memory=False, defined=False), Local('match', in_memory=False, defined=False)] */if (match_o == NULL) goto error; + if (res < 0) goto error; + assert((match_o == NULL) == (rest_o == NULL)); + if (match_o == NULL) goto error; if (!Py_IsNone(match_o)) { _PyFrame_SetStackPointer(frame, stack_pointer); PyErr_SetHandledException(match_o); @@ -3129,8 +3092,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { PyStackRef_CLOSE(right); - /* Variables: ['left']. Base offset: -1. Top offset: 0 - LOCALS: [Local('b', in_memory=False, defined=False)] */if (true) goto error; + if (true) goto error; } _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyErr_GivenExceptionMatches(left_o, right_o); @@ -3165,11 +3127,11 @@ int matches = PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration); stack_pointer = _PyFrame_GetStackPointer(frame); if (matches) { + none = PyStackRef_None; value = PyStackRef_FromPyObjectNew(((PyStopIterationObject *)exc_value)->value); PyStackRef_CLOSE(sub_iter_st); PyStackRef_CLOSE(last_sent_val_st); PyStackRef_CLOSE(exc_value_st); - none = PyStackRef_None; } else { _PyFrame_SetStackPointer(frame, stack_pointer); @@ -3225,14 +3187,13 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + if (res_o == NULL) goto error; if (oparg & 16) { _PyFrame_SetStackPointer(frame, stack_pointer); int res_bool = PyObject_IsTrue(res_o); stack_pointer = _PyFrame_GetStackPointer(frame); - Py_DECREF(res_o);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_bool < 0) goto error; + Py_DECREF(res_o); + if (res_bool < 0) goto error; res = res_bool ? PyStackRef_True : PyStackRef_False; } else { @@ -3403,8 +3364,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('b', in_memory=False, defined=False)] */if (res < 0) goto error; + if (res < 0) goto error; b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; } stack_pointer[0] = b; @@ -3435,8 +3395,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('b', in_memory=False, defined=False)] */if (res < 0) goto error; + if (res < 0) goto error; b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; stack_pointer[0] = b; stack_pointer += 1; @@ -3467,8 +3426,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('b', in_memory=False, defined=False)] */if (res < 0) goto error; + if (res < 0) goto error; b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; stack_pointer[0] = b; stack_pointer += 1; @@ -3487,8 +3445,8 @@ assert(oparg >= FVC_STR && oparg <= FVC_ASCII); conv_fn = _PyEval_ConversionFuncs[oparg]; PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value)); - PyStackRef_CLOSE(value);/* Variables: []. Base offset: -1. Top offset: -1 - LOCALS: [Local('result', in_memory=False, defined=False)] */if (result_o == NULL) goto pop_1_error; + PyStackRef_CLOSE(value); + if (result_o == NULL) goto pop_1_error; result = PyStackRef_FromPyObjectSteal(result_o); stack_pointer[-1] = result; DISPATCH(); @@ -3539,8 +3497,7 @@ int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(owner); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (err) goto error; + if (err) goto error; DISPATCH(); } @@ -3576,8 +3533,7 @@ PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg) ); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (1) goto error; + if (1) goto error; } SETLOCAL(oparg, PyStackRef_NULL); DISPATCH(); @@ -3651,8 +3607,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (err) goto error; + if (err) goto error; DISPATCH(); } @@ -3679,8 +3634,7 @@ _PyEval_FormatKwargsError(tstate, callable_o, update_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(update); - /* Variables: ['callable', 'unused', 'unused', 'dict', 'unused']. Base offset: -4 - (oparg - 1). Top offset: 0 - LOCALS: [] */if (true) goto error; + if (true) goto error; } PyStackRef_CLOSE(update); DISPATCH(); @@ -3713,8 +3667,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(update); - /* Variables: ['dict', 'unused']. Base offset: -1 - (oparg - 1). Top offset: 0 - LOCALS: [] */if (true) goto error; + if (true) goto error; } PyStackRef_CLOSE(update); DISPATCH(); @@ -3861,8 +3814,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Format(value_o, NULL)); stack_pointer = _PyFrame_GetStackPointer(frame); - PyStackRef_CLOSE(value);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=True)] */if (PyStackRef_IsNull(res)) { + PyStackRef_CLOSE(value); + if (PyStackRef_IsNull(res)) { stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3894,8 +3847,8 @@ PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - PyStackRef_CLOSE(fmt_spec);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + PyStackRef_CLOSE(fmt_spec); + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; @@ -4104,8 +4057,8 @@ long value = r->start; r->start = value + r->step; r->len--; - PyObject *res = PyLong_FromLong(value);/* Variables: ['iter']. Base offset: -1. Top offset: 0 - LOCALS: [Local('next', in_memory=False, defined=False)] */if (res == NULL) goto error; + PyObject *res = PyLong_FromLong(value); + if (res == NULL) goto error; next = PyStackRef_FromPyObjectSteal(res); } stack_pointer[0] = next; @@ -4186,13 +4139,11 @@ type->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(obj); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('iter', in_memory=False, defined=False)] */if (true) goto error; + if (true) goto error; } iter_o = (*getter)(obj_o); PyStackRef_CLOSE(obj); - /* Variables: []. Base offset: -1. Top offset: -1 - LOCALS: [Local('iter', in_memory=False, defined=False)] */if (iter_o == NULL) goto pop_1_error; + if (iter_o == NULL) goto pop_1_error; if (Py_TYPE(iter_o)->tp_as_async == NULL || Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) { stack_pointer += -1; @@ -4203,8 +4154,8 @@ "that does not implement __anext__: %.100s", Py_TYPE(iter_o)->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); - Py_DECREF(iter_o);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('iter', in_memory=False, defined=False)] */if (true) goto error; + Py_DECREF(iter_o); + if (true) goto error; } iter = PyStackRef_FromPyObjectSteal(iter_o); stack_pointer[-1] = iter; @@ -4244,8 +4195,7 @@ PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('iter', in_memory=False, defined=False)] */if (iter_o == NULL) goto error; + if (iter_o == NULL) goto error; iter = PyStackRef_FromPyObjectSteal(iter_o); stack_pointer[0] = iter; stack_pointer += 1; @@ -4267,8 +4217,7 @@ iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable))); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('iter', in_memory=False, defined=True)] */if (PyStackRef_IsNull(iter)) { + if (PyStackRef_IsNull(iter)) { stack_pointer[0] = iter; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -4291,13 +4240,11 @@ _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj)); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['obj']. Base offset: -1. Top offset: 0 - LOCALS: [Local('len', in_memory=False, defined=False)] */if (len_i < 0) goto error; + if (len_i < 0) goto error; _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *len_o = PyLong_FromSsize_t(len_i); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['obj']. Base offset: -1. Top offset: 0 - LOCALS: [Local('len', in_memory=False, defined=False)] */if (len_o == NULL) goto error; + if (len_o == NULL) goto error; len = PyStackRef_FromPyObjectSteal(len_o); stack_pointer[0] = len; stack_pointer += 1; @@ -4362,8 +4309,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['from']. Base offset: -1. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; @@ -4390,8 +4336,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(level); PyStackRef_CLOSE(fromlist); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; @@ -4455,8 +4400,7 @@ frame, this_instr, function, arg0 ); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['func', 'maybe_self', 'args']. Base offset: -2 - oparg. Top offset: 0 - LOCALS: [] */if (err) goto error; + if (err) goto error; } // _DO_CALL self_or_null = maybe_self; @@ -4499,8 +4443,8 @@ PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }/* Variables: []. Base offset: -2 - oparg. Top offset: -2 - oparg - LOCALS: [Local('res', in_memory=False, defined=False)] */if (true) { + } + if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -4542,8 +4486,8 @@ PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + } + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC @@ -4557,8 +4501,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['res']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -4595,8 +4538,7 @@ tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, function, arg); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (err) goto error; + if (err) goto error; PAUSE_ADAPTIVE_COUNTER(this_instr[1].counter); GO_TO_INSTRUCTION(CALL_KW); } @@ -4706,8 +4648,7 @@ int next_opcode = _Py_call_instrumentation_instruction( tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (next_opcode < 0) goto error; + if (next_opcode < 0) goto error; next_instr = this_instr; if (_PyOpcode_Caches[next_opcode]) { PAUSE_ADAPTIVE_COUNTER(next_instr[1].counter); @@ -4731,8 +4672,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; } } // _MONITOR_JUMP_BACKWARD @@ -4911,8 +4851,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; } } } @@ -4922,8 +4861,7 @@ int err = _Py_call_instrumentation( tstate, oparg > 0, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (err) goto error; + if (err) goto error; if (frame->instr_ptr != this_instr) { /* Instrumentation has jumped */ next_instr = frame->instr_ptr; @@ -4948,6 +4886,7 @@ // _RETURN_VALUE_EVENT val = value; { + stack_pointer[0] = val; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -4955,8 +4894,7 @@ tstate, PY_MONITORING_EVENT_PY_RETURN, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['val']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err) goto error; + if (err) goto error; } // _RETURN_VALUE retval = val; @@ -5000,8 +4938,7 @@ tstate, PY_MONITORING_EVENT_PY_RETURN, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['val']. Base offset: -1. Top offset: 0 - LOCALS: [] */if (err) goto error; + if (err) goto error; } // _RETURN_VALUE retval = val; @@ -5156,8 +5093,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; } } // _JUMP_BACKWARD @@ -5180,8 +5116,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int optimized = _PyOptimizer_Optimize(frame, start, stack_pointer, &executor, 0); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (optimized < 0) goto error; + if (optimized < 0) goto error; if (optimized) { assert(tstate->previous_executor == NULL); tstate->previous_executor = Py_None; @@ -5229,8 +5164,7 @@ _PyStackRef v; v = stack_pointer[-1]; list = stack_pointer[-2 - (oparg-1)]; - /* Variables: ['list', 'unused']. Base offset: -2 - (oparg-1). Top offset: -1 - LOCALS: [] */if (_PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list), + if (_PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list), PyStackRef_AsPyObjectSteal(v)) < 0) goto pop_1_error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -5267,8 +5201,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(iterable_st); - /* Variables: ['list_st', 'unused']. Base offset: -1 - (oparg-1). Top offset: 0 - LOCALS: [] */if (true) goto error; + if (true) goto error; } assert(Py_IsNone(none_val)); PyStackRef_CLOSE(iterable_st); @@ -5332,8 +5265,7 @@ meth | NULL | arg1 | ... | argN */ PyStackRef_CLOSE(owner); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('attr', in_memory=False, defined=False), Local('self_or_null', in_memory=False, defined=False)] */if (attr_o == NULL) goto error; + if (attr_o == NULL) goto error; self_or_null = PyStackRef_NULL; } } @@ -5345,8 +5277,7 @@ attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(owner); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('attr', in_memory=False, defined=False), Local('self_or_null', in_memory=False, defined=False)] */if (attr_o == NULL) goto error; + if (attr_o == NULL) goto error; /* We need to define self_or_null on all paths */ self_or_null = PyStackRef_NULL; } @@ -5922,15 +5853,13 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('bc', in_memory=False, defined=False)] */if (err < 0) goto error; + if (err < 0) goto error; if (bc_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_NameError, "__build_class__ not found"); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('bc', in_memory=False, defined=False)] */if (true) goto error; + if (true) goto error; } bc = PyStackRef_FromPyObjectSteal(bc_o); stack_pointer[0] = bc; @@ -5945,16 +5874,18 @@ INSTRUCTION_STATS(LOAD_COMMON_CONSTANT); _PyStackRef value; // Keep in sync with _common_constants in opcode.py + PyObject *val; switch(oparg) { case CONSTANT_ASSERTIONERROR: - value = PyStackRef_FromPyObjectImmortal(PyExc_AssertionError); + val = PyExc_AssertionError; break; case CONSTANT_NOTIMPLEMENTEDERROR: - value = PyStackRef_FromPyObjectImmortal(PyExc_NotImplementedError); + val = PyExc_NotImplementedError; break; default: Py_FatalError("bad LOAD_COMMON_CONSTANT oparg"); } + value = PyStackRef_FromPyObjectImmortal(val); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5984,8 +5915,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('value', in_memory=False, defined=False)] */if (true) goto error; + if (true) goto error; } value = PyStackRef_FromPyObjectSteal(value_o); stack_pointer[0] = value; @@ -6034,8 +5964,7 @@ PyTuple_GetItem(_PyFrame_GetCode(frame)->co_localsplusnames, oparg) ); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('value', in_memory=False, defined=False)] */if (1) goto error; + if (1) goto error; } value = PyStackRef_DUP(value_s); stack_pointer[0] = value; @@ -6144,23 +6073,20 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(GLOBALS(), name, &v_o); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('v', in_memory=False, defined=False)] */if (err < 0) goto error; + if (err < 0) goto error; if (v_o == NULL) { /* namespace 2: builtins */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(BUILTINS(), name, &v_o); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('v', in_memory=False, defined=False)] */if (err < 0) goto error; + if (err < 0) goto error; if (v_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg( tstate, PyExc_NameError, NAME_ERROR_MSG, name); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('v', in_memory=False, defined=False)] */if (true) goto error; + if (true) goto error; } } } @@ -6208,8 +6134,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_LoadGlobal(GLOBALS(), BUILTINS(), name); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False), Local('null', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + if (res_o == NULL) goto error; null = PyStackRef_NULL; res = PyStackRef_FromPyObjectSteal(res_o); } @@ -6310,8 +6235,7 @@ _PyErr_SetString(tstate, PyExc_SystemError, "no locals found"); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('locals', in_memory=False, defined=False)] */if (true) goto error; + if (true) goto error; } locals = PyStackRef_FromPyObjectNew(l); stack_pointer[0] = locals; @@ -6329,8 +6253,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *v_o = _PyEval_LoadName(tstate, frame, name); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('v', in_memory=False, defined=False)] */if (v_o == NULL) goto error; + if (v_o == NULL) goto error; v = PyStackRef_FromPyObjectSteal(v_o); stack_pointer[0] = v; stack_pointer += 1; @@ -6368,8 +6291,8 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } - }/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('attr', in_memory=False, defined=True), Local('self_or_null', in_memory=False, defined=False)] */if (PyStackRef_IsNull(attr)) { + } + if (PyStackRef_IsNull(attr)) { stack_pointer[0] = attr; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6429,8 +6352,7 @@ tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, global_super, arg); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('attr', in_memory=False, defined=False), Local('null', in_memory=False, defined=False)] */if (err) goto error; + if (err) goto error; stack_pointer += 3; assert(WITHIN_STACK_BOUNDS()); } @@ -6467,14 +6389,13 @@ PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); PyStackRef_CLOSE(self_st); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('attr', in_memory=False, defined=False), Local('null', in_memory=False, defined=False)] */if (super == NULL) goto error; + if (super == NULL) goto error; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); _PyFrame_SetStackPointer(frame, stack_pointer); attr = PyStackRef_FromPyObjectSteal(PyObject_GetAttr(super, name)); stack_pointer = _PyFrame_GetStackPointer(frame); - Py_DECREF(super);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('attr', in_memory=False, defined=True), Local('null', in_memory=False, defined=False)] */if (PyStackRef_IsNull(attr)) { + Py_DECREF(super); + if (PyStackRef_IsNull(attr)) { stack_pointer[0] = attr; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6518,8 +6439,7 @@ PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); PyStackRef_CLOSE(self_st); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('attr_st', in_memory=False, defined=False), Local('unused', in_memory=False, defined=False)] */if (attr == NULL) goto error; + if (attr == NULL) goto error; attr_st = PyStackRef_FromPyObjectSteal(attr); stack_pointer[0] = attr_st; stack_pointer += 1; @@ -6560,8 +6480,8 @@ PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); if (attr_o == NULL) { - PyStackRef_CLOSE(self_st);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('attr', in_memory=False, defined=False), Local('self_or_null', in_memory=False, defined=False)] */if (true) goto error; + PyStackRef_CLOSE(self_st); + if (true) goto error; } if (method_found) { self_or_null = self_st; // transfer ownership @@ -6644,8 +6564,7 @@ PyStackRef_AsPyObjectSteal(value) ); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['dict_st', 'unused']. Base offset: -1 - (oparg - 1). Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; DISPATCH(); } @@ -6678,8 +6597,8 @@ assert(PyTuple_CheckExact(attrs_o)); // Success! attrs = PyStackRef_FromPyObjectSteal(attrs_o); } - else {/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('attrs', in_memory=False, defined=False)] */if (_PyErr_Occurred(tstate)) goto error; + else { + if (_PyErr_Occurred(tstate)) goto error; // Error! attrs = PyStackRef_None; // Failure! } @@ -6703,8 +6622,7 @@ PyObject *values_or_none_o = _PyEval_MatchKeys(tstate, PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys)); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['subject', 'keys']. Base offset: -2. Top offset: 0 - LOCALS: [Local('values_or_none', in_memory=False, defined=False)] */if (values_or_none_o == NULL) goto error; + if (values_or_none_o == NULL) goto error; values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o); stack_pointer[0] = values_or_none; stack_pointer += 1; @@ -6939,8 +6857,8 @@ monitor_reraise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; - }/* Variables: []. Base offset: -oparg. Top offset: -oparg - LOCALS: [] */if (true) { + } + if (true) { stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); goto error; @@ -7039,8 +6957,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (err != 0) goto error; + if (err != 0) goto error; } } } @@ -7317,27 +7234,24 @@ _PyErr_Format(tstate, PyExc_SystemError, "no locals found when setting up annotations"); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (true) goto error; + if (true) goto error; } /* check if __annotations__ in locals()... */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (err < 0) goto error; + if (err < 0) goto error; if (ann_dict == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); ann_dict = PyDict_New(); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (ann_dict == NULL) goto error; + if (ann_dict == NULL) goto error; _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__), ann_dict); stack_pointer = _PyFrame_GetStackPointer(frame); - Py_DECREF(ann_dict);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (err) goto error; + Py_DECREF(ann_dict); + if (err) goto error; } else { Py_DECREF(ann_dict); @@ -7360,8 +7274,7 @@ PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); - /* Variables: ['set', 'unused']. Base offset: -1 - (oparg-1). Top offset: 0 - LOCALS: [] */if (err) goto error; + if (err) goto error; DISPATCH(); } @@ -7402,8 +7315,7 @@ PyStackRef_AsPyObjectBorrow(iterable)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); - /* Variables: ['set', 'unused']. Base offset: -1 - (oparg-1). Top offset: 0 - LOCALS: [] */if (err < 0) goto error; + if (err < 0) goto error; DISPATCH(); } @@ -7447,8 +7359,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); PyStackRef_CLOSE(owner); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (err) goto error; + if (err) goto error; } DISPATCH(); } @@ -7667,8 +7578,7 @@ int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (err) goto error; + if (err) goto error; DISPATCH(); } @@ -7689,8 +7599,7 @@ "no locals found when storing %R", name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (true) goto error; + if (true) goto error; } if (PyDict_CheckExact(ns)) { stack_pointer += -1; @@ -7707,8 +7616,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(v); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (err) goto error; + if (err) goto error; DISPATCH(); } @@ -7742,8 +7650,8 @@ Py_DECREF(slice); } PyStackRef_CLOSE(v); - PyStackRef_CLOSE(container);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (err) goto error; + PyStackRef_CLOSE(container); + if (err) goto error; DISPATCH(); } @@ -7787,8 +7695,7 @@ PyStackRef_CLOSE(v); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (err) goto error; + if (err) goto error; } DISPATCH(); } @@ -7815,8 +7722,8 @@ PyStackRef_AsPyObjectSteal(sub), PyStackRef_AsPyObjectSteal(value)); stack_pointer = _PyFrame_GetStackPointer(frame); - PyStackRef_CLOSE(dict_st);/* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [] */if (err) goto error; + PyStackRef_CLOSE(dict_st); + if (err) goto error; DISPATCH(); } @@ -7902,8 +7809,7 @@ int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (err < 0) goto error; + if (err < 0) goto error; res = err ? PyStackRef_True : PyStackRef_False; } stack_pointer[0] = res; @@ -8054,8 +7960,7 @@ PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; @@ -8076,8 +7981,7 @@ PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=False)] */if (res_o == NULL) goto error; + if (res_o == NULL) goto error; res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; @@ -8114,8 +8018,7 @@ int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(seq); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('left', in_memory=True, defined=False), Local('unused', in_memory=False, defined=False), Local('right', in_memory=True, defined=False)] */if (res == 0) goto error; + if (res == 0) goto error; stack_pointer += 1 + (oparg & 0xFF) + (oparg >> 8); assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -8159,8 +8062,7 @@ int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(seq); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('output', in_memory=True, defined=False)] */if (res == 0) goto error; + if (res == 0) goto error; } stack_pointer += oparg; assert(WITHIN_STACK_BOUNDS()); @@ -8284,8 +8186,7 @@ res = PyStackRef_FromPyObjectSteal(PyObject_Vectorcall(exit_func_o, stack + 2 - has_self, (3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL)); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Variables: ['exit_func', 'exit_self', 'lasti', 'unused', 'val']. Base offset: -5. Top offset: 0 - LOCALS: [Local('res', in_memory=False, defined=True)] */if (PyStackRef_IsNull(res)) { + if (PyStackRef_IsNull(res)) { stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -8459,8 +8360,7 @@ PyStackRef_CLOSE(func_st); PyStackRef_CLOSE(callargs_st); PyStackRef_XCLOSE(kwargs_st); - /* Variables: []. Base offset: 0. Top offset: 0 - LOCALS: [Local('result', in_memory=False, defined=True)] */if (PyStackRef_IsNull(result)) { + if (PyStackRef_IsNull(result)) { stack_pointer[0] = result; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 3f12e22d033692..86c13803b04616 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -1806,7 +1806,6 @@ } else { new_frame = frame_new(ctx, co, 0, NULL, 0); } - stack_pointer[-2 - oparg] = (_Py_UopsSymbol *)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); break; diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 4e07ad3bc2d41d..60cc4e0c03c217 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -162,7 +162,6 @@ def error_if( storage: Storage, inst: Instruction | None, ) -> bool: - self.emit(storage.as_comment()) self.out.emit_at("if ", tkn) lparen = next(tkn_iter) self.emit(lparen) @@ -321,21 +320,29 @@ def _emit_if( maybe_if = tkn_iter.peek() if maybe_if and maybe_if.kind == "IF": self.emit(next(tkn_iter)) - else_reachable, rbrace, storage = self._emit_if(tkn_iter, uop, storage, inst) + else_reachable, rbrace, else_storage = self._emit_if(tkn_iter, uop, storage, inst) else: - else_reachable, rbrace, storage = self._emit_block(tkn_iter, uop, storage, inst, True) + else_reachable, rbrace, else_storage = self._emit_block(tkn_iter, uop, storage, inst, True) if not reachable: # Discard the if storage reachable = else_reachable + storage = else_storage elif not else_reachable: # Discard the else storage storage = if_storage + reachable = True else: - storage.merge(if_storage, self.out) + if PRINT_STACKS: + self.emit("/* Merge */\n") + else_storage.merge(if_storage, self.out) + storage = else_storage self._print_storage(storage) else: if reachable: + if PRINT_STACKS: + self.emit("/* Merge */\n") if_storage.merge(storage, self.out) + storage = if_storage self._print_storage(storage) else: # Discard the if storage @@ -407,14 +414,14 @@ def _emit_block( self.out.emit(tkn) elif tkn.kind == "IF": self.out.emit(tkn) - if_reachable, rbrace, stack = self._emit_if(tkn_iter, uop, storage, inst) + if_reachable, rbrace, storage = self._emit_if(tkn_iter, uop, storage, inst) if reachable: reachable = if_reachable self.out.emit(rbrace) else: self.out.emit(tkn) except StackError as ex: - raise analysis_error(ex.args[0], tkn) from None + raise analysis_error(ex.args[0], tkn) # from None raise analysis_error("Expecting closing brace. Reached end of file", tkn) @@ -426,10 +433,12 @@ def emit_tokens( ) -> None: tkn_iter = TokenIterator(uop.body) self.out.start_line() - self._emit_block(tkn_iter, uop, storage, inst, False) + _, _, storage = self._emit_block(tkn_iter, uop, storage, inst, False) for output in storage.outputs: storage.stack.push(output) storage.outputs = [] + self._print_storage(storage) + return storage.stack def emit(self, txt: str | Token) -> None: self.out.emit(txt) diff --git a/Tools/cases_generator/optimizer_generator.py b/Tools/cases_generator/optimizer_generator.py index 5566a68868e239..1a7bc00833e7c2 100644 --- a/Tools/cases_generator/optimizer_generator.py +++ b/Tools/cases_generator/optimizer_generator.py @@ -77,17 +77,19 @@ def decref_inputs( out.emit_at("", tkn) -def emit_default(out: CWriter, uop: Uop) -> None: - for i, var in enumerate(uop.stack.outputs): - if var.name != "unused" and not var.peek: +def emit_default(out: CWriter, uop: Uop, storage: Storage) -> None: + for var in storage.outputs: + if var.name != "unused" and not var.item.peek: if var.is_array(): out.emit(f"for (int _i = {var.size}; --_i >= 0;) {{\n") out.emit(f"{var.name}[_i] = sym_new_not_null(ctx);\n") out.emit("}\n") elif var.name == "null": out.emit(f"{var.name} = sym_new_null(ctx);\n") + var.defined = True else: out.emit(f"{var.name} = sym_new_not_null(ctx);\n") + var.defined = True class OptimizerEmitter(Emitter): @@ -145,8 +147,7 @@ def write_uop( emitter = OptimizerEmitter(out) emitter.emit_tokens(override, storage, None) else: - emit_default(out, uop) - + emit_default(out, uop, storage) for output in storage.outputs: stack.push(output) out.start_line() diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index d2a9b187f8db83..4c48e0f12911dc 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -246,6 +246,7 @@ def pop(self, var: StackItem, extract_bits: bool = False) -> tuple[str, Local]: defn = f"{var.name} = &stack_pointer[{self.top_offset.to_c()}];\n" else: defn = f"{var.name} = stack_pointer[{self.top_offset.to_c()}];\n" + popped.in_memory = True return defn, Local.redefinition(var, popped) self.base_offset.pop(var) @@ -272,7 +273,6 @@ def push(self, var: Local) -> None: self.top_offset.push(var.item) if var.item.used: self.defined.add(var.name) - var.defined = True def define_output_arrays(self, outputs: list[StackItem]) -> str: res = [] @@ -314,9 +314,8 @@ def flush( var_offset = self.base_offset.copy() for var in self.variables: if ( + var.defined and not var.in_memory - and not var.item.peek - and not var.name in UNUSED ): Stack._do_emit(out, var.item, var_offset, cast_type, extract_bits) var.in_memory = True @@ -335,7 +334,7 @@ def peek_offset(self) -> str: def as_comment(self) -> str: return ( - f"/* Variables: {[v.name for v in self.variables]}. " + f"/* Variables: {", ".join([str(v) for v in self.variables])}. " f"Base offset: {self.base_offset.to_c()}. Top offset: {self.top_offset.to_c()} */" ) @@ -369,6 +368,16 @@ def align(self, other: "Stack", out: CWriter) -> None: except ValueError: raise StackError("Cannot align stacks: cannot adjust stack pointer") + def merge(self, other: "Stack") -> None: + if len(self.variables) != len(other.variables): + raise StackError("Cannot merge stacks: differing variables") + for self_var, other_var in zip(self.variables, other.variables): + if self_var.name != other_var.name: + raise StackError(f"Mismatched variables on stack: {self_var.name} and {other_var.name}") + self_var.defined = self_var.defined and other_var.defined + self_var.in_memory = self_var.in_memory and other_var.in_memory + + def get_stack_effect(inst: Instruction | PseudoInstruction) -> Stack: stack = Stack() @@ -403,20 +412,14 @@ class Storage: spilled: int = 0 def _push_defined_locals(self) -> None: - while self.outputs: - if not self.outputs[0].defined: - break - out = self.outputs.pop(0) - self.stack.push(out) undefined = "" for out in self.outputs: - if out.is_array(): - continue if out.defined: - raise StackError( + if not out.in_memory: + self.stack.push(out) + if undefined: f"Locals not defined in stack order. " - f"Expected '{out.name}' is defined before '{undefined}'" - ) + f"Expected '{undefined}' to be defined before '{out.name}'" else: undefined = out.name @@ -472,6 +475,7 @@ def sanity_check(self): if var.name in names: raise StackError(f"Duplicate name {var.name}") names.add(var.name) + names = set() for var in self.outputs: if var.name in names: raise StackError(f"Duplicate name {var.name}") @@ -492,14 +496,16 @@ def merge(self, other: "Storage", out: CWriter) -> None: for var in other.outputs: if var.defined and not var.in_memory: locally_defined_set.add(var.name) - while self.stack.variables and self.stack.variables[0].item.name in locally_defined_set: - code, var = self.stack.pop(self.stack.variables[0].item) + while self.stack.variables and self.stack.variables[-1].item.name in locally_defined_set: + code, var = self.stack.pop(self.stack.variables[-1].item) out.emit(code) - self.outputs.append(var) - while other.stack.variables and other.stack.variables[0].item.name in locally_defined_set: - code, var = other.stack.pop(other.stack.variables[0].item) + if var not in self.outputs: + self.outputs.append(var) + while other.stack.variables and other.stack.variables[-1].item.name in locally_defined_set: + code, var = other.stack.pop(other.stack.variables[-1].item) assert code == "" - other.outputs.append(var) + if var not in other.outputs: + other.outputs.append(var) s1, s2 = self.stack, other.stack l1, l2 = self.outputs, other.outputs if len(s1.variables) != len(s2.variables): @@ -539,10 +545,11 @@ def merge(self, other: "Storage", out: CWriter) -> None: raise StackError(f"Mismatched local: {self_out.name} and {other_out.name}") if self_out.defined ^ other_out.defined: raise StackError(f"Local {self_out.name} defined on only one path") - self_out.in_memory = other_out.in_memory = self_out.in_memory and other_out.in_memory + self_out.in_memory = self_out.in_memory and other_out.in_memory self_out.cached = other_out.cached = self_out.cached and other_out.cached + self.stack.merge(other.stack) self.sanity_check() def as_comment(self) -> str: stack_comment = self.stack.as_comment() - return stack_comment[:-2] + "\n LOCALS: " + str(self.outputs) + " */" + return stack_comment[:-2] + "\n LOCALS: " + ", ".join([str(out) for out in self.outputs]) + " */" diff --git a/Tools/cases_generator/tier1_generator.py b/Tools/cases_generator/tier1_generator.py index 9cb80bf901f518..e02052e9ca97af 100644 --- a/Tools/cases_generator/tier1_generator.py +++ b/Tools/cases_generator/tier1_generator.py @@ -71,16 +71,16 @@ def write_uop( stack: Stack, inst: Instruction, braces: bool, -) -> int: +) -> tuple[int, Stack]: # out.emit(stack.as_comment() + "\n") if isinstance(uop, Skip): entries = "entries" if uop.size > 1 else "entry" emitter.emit(f"/* Skip {uop.size} cache {entries} */\n") - return offset + uop.size + return (offset + uop.size), stack if isinstance(uop, Flush): emitter.emit(f"// flush\n") stack.flush(emitter.out) - return offset + return offset, stack try: locals: dict[str, Local] = {} emitter.out.start_line() @@ -118,12 +118,12 @@ def write_uop( emitter.emit(f"(void){cache.name};\n") offset += cache.size - emitter.emit_tokens(uop, storage, inst) + stack = emitter.emit_tokens(uop, storage, inst) if braces: emitter.out.start_line() emitter.emit("}\n") # emitter.emit(stack.as_comment() + "\n") - return offset + return offset, stack except StackError as ex: raise analysis_error(ex.args[0], uop.body[0]) @@ -185,7 +185,7 @@ def generate_tier1( for part in inst.parts: # Only emit braces if more than one uop insert_braces = len([p for p in inst.parts if isinstance(p, Uop)]) > 1 - offset = write_uop(part, emitter, offset, stack, inst, insert_braces) + offset, stack = write_uop(part, emitter, offset, stack, inst, insert_braces) out.start_line() if not inst.parts[-1].properties.always_exits: stack.flush(out) From 6da3fc6b0a4de3b44e5c2daf5b21fe7b2b69f1bb Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Tue, 10 Sep 2024 16:09:00 +0100 Subject: [PATCH 25/53] Handle ERROR_NO_POP correctly --- Include/internal/pycore_opcode_metadata.h | 16 +- Include/internal/pycore_uop_metadata.h | 8 +- Python/bytecodes.c | 26 +-- Python/executor_cases.c.h | 25 +-- Python/generated_cases.c.h | 189 ++++++++++++++++----- Tools/cases_generator/analyzer.py | 2 + Tools/cases_generator/generators_common.py | 48 +++--- Tools/cases_generator/stack.py | 5 + 8 files changed, 215 insertions(+), 104 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 2325fd747f413c..3a6de48fc1a322 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -1012,7 +1012,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [BINARY_OP_ADD_FLOAT] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG }, [BINARY_OP_ADD_INT] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG | HAS_ERROR_FLAG }, [BINARY_OP_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG | HAS_ERROR_FLAG }, - [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [BINARY_OP_INPLACE_ADD_UNICODE] = { true, INSTR_FMT_IXC, HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG }, [BINARY_OP_MULTIPLY_FLOAT] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG }, [BINARY_OP_MULTIPLY_INT] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG | HAS_ERROR_FLAG }, [BINARY_OP_SUBTRACT_FLOAT] = { true, INSTR_FMT_IXC, HAS_EXIT_FLAG }, @@ -1031,10 +1031,10 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [BUILD_STRING] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [BUILD_TUPLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [CACHE] = { true, INSTR_FMT_IX, 0 }, - [CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_ALLOC_AND_ENTER_INIT] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [CALL_BOUND_METHOD_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, - [CALL_BOUND_METHOD_GENERAL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BOUND_METHOD_GENERAL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_BUILTIN_CLASS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_BUILTIN_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -1043,10 +1043,10 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [CALL_INTRINSIC_1] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [CALL_INTRINSIC_2] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [CALL_ISINSTANCE] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, - [CALL_KW] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, - [CALL_KW_BOUND_METHOD] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [CALL_KW] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_KW_BOUND_METHOD] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_KW_NON_PY] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_KW_PY] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [CALL_KW_PY] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_LEN] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [CALL_LIST_APPEND] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, [CALL_METHOD_DESCRIPTOR_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -1055,7 +1055,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [CALL_METHOD_DESCRIPTOR_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_NON_PY_GENERAL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_PY_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, - [CALL_PY_GENERAL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [CALL_PY_GENERAL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_STR_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_TUPLE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_TYPE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, @@ -1101,7 +1101,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [GET_YIELD_FROM_ITER] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [IMPORT_FROM] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [IMPORT_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_CALL_FUNCTION_EX] = { true, INSTR_FMT_IX, 0 }, [INSTRUMENTED_CALL_KW] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_END_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index f0e9629cac293d..ca78d036d2b16e 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -74,7 +74,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_BINARY_OP_SUBTRACT_FLOAT] = HAS_PURE_FLAG, [_GUARD_BOTH_UNICODE] = HAS_EXIT_FLAG, [_BINARY_OP_ADD_UNICODE] = HAS_ERROR_FLAG | HAS_PURE_FLAG, - [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_BINARY_OP_INPLACE_ADD_UNICODE] = HAS_LOCAL_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, [_BINARY_SUBSCR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BINARY_SLICE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_STORE_SLICE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -204,7 +204,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CHECK_ATTR_METHOD_LAZY_DICT] = HAS_DEOPT_FLAG, [_LOAD_ATTR_METHOD_LAZY_DICT] = HAS_ARG_FLAG, [_MAYBE_EXPAND_METHOD] = HAS_ARG_FLAG, - [_PY_FRAME_GENERAL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_PY_FRAME_GENERAL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CHECK_FUNCTION_VERSION] = HAS_ARG_FLAG | HAS_EXIT_FLAG, [_CHECK_METHOD_VERSION] = HAS_ARG_FLAG | HAS_EXIT_FLAG, [_EXPAND_METHOD] = HAS_ARG_FLAG, @@ -226,7 +226,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CALL_STR_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_TUPLE_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CHECK_AND_ALLOCATE_OBJECT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, - [_CREATE_INIT_FRAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_CREATE_INIT_FRAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_EXIT_INIT_CHECK] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, [_CALL_BUILTIN_O] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -239,7 +239,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG, [_CALL_METHOD_DESCRIPTOR_NOARGS] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG, - [_PY_FRAME_KW] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_PY_FRAME_KW] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CHECK_FUNCTION_VERSION_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG, [_CHECK_METHOD_VERSION_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG, [_EXPAND_METHOD_KW] = HAS_ARG_FLAG, diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 19c2e9bd8194ec..57fed44781c697 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -3240,12 +3240,10 @@ dummy_func( args, total_args, NULL, frame ); // Manipulate stack directly since we leave using DISPATCH_INLINED(). - SYNC_SP(); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - if (new_frame == NULL) { - ERROR_NO_POP(); - } + SYNC_SP(); + ERROR_IF(new_frame == NULL, error); frame->return_offset = (uint16_t)(next_instr - this_instr); DISPATCH_INLINED(new_frame); } @@ -3332,9 +3330,7 @@ dummy_func( // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. SYNC_SP(); - if (new_frame == NULL) { - ERROR_NO_POP(); - } + ERROR_IF(new_frame == NULL, error); } op(_CHECK_FUNCTION_VERSION, (func_version/2, callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) { @@ -3595,7 +3591,7 @@ dummy_func( SYNC_SP(); if (init_frame == NULL) { _PyEval_FrameClearAndPop(tstate, shim); - ERROR_NO_POP(); + ERROR_IF(true, error); } frame->return_offset = 1 + INLINE_CACHE_ENTRIES_CALL; /* Account for pushing the extra frame. @@ -4073,12 +4069,10 @@ dummy_func( ); PyStackRef_CLOSE(kwnames); // Sync stack explicitly since we leave using DISPATCH_INLINED(). - SYNC_SP(); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - if (new_frame == NULL) { - ERROR_NO_POP(); - } + SYNC_SP(); + ERROR_IF(new_frame == NULL, error); assert(next_instr - this_instr == 1 + INLINE_CACHE_ENTRIES_CALL_KW); frame->return_offset = 1 + INLINE_CACHE_ENTRIES_CALL_KW; DISPATCH_INLINED(new_frame); @@ -4144,9 +4138,7 @@ dummy_func( // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. SYNC_SP(); - if (new_frame == NULL) { - ERROR_NO_POP(); - } + ERROR_IF(new_frame == NULL, error); } op(_CHECK_FUNCTION_VERSION_KW, (func_version/2, callable, self_or_null, unused[oparg], kwnames -- callable, self_or_null, unused[oparg], kwnames)) { @@ -4329,9 +4321,7 @@ dummy_func( nargs, callargs, kwargs, frame); // Need to sync the stack since we exit with DISPATCH_INLINED. SYNC_SP(); - if (new_frame == NULL) { - ERROR_NO_POP(); - } + ERROR_IF(new_frame == NULL, error); assert(next_instr - this_instr == 1); frame->return_offset = 1; DISPATCH_INLINED(new_frame); diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 525b490a800bfc..0d7223b79aed8a 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -781,16 +781,14 @@ * only the locals reference, so PyUnicode_Append knows * that the string is safe to mutate. */ - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); - _PyFrame_SetStackPointer(frame, stack_pointer); assert(Py_REFCNT(left_o) >= 2); _Py_DECREF_NO_DEALLOC(left_o); - stack_pointer = _PyFrame_GetStackPointer(frame); PyObject *temp = PyStackRef_AsPyObjectBorrow(*target_local); PyUnicode_Append(&temp, right_o); *target_local = PyStackRef_FromPyObjectSteal(temp); _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(*target_local)) JUMP_TO_ERROR(); #if TIER_ONE // The STORE_FAST is already done. This is done here in tier one, @@ -3930,9 +3928,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - if (new_frame == NULL) { - JUMP_TO_ERROR(); - } + stack_pointer[0].bits = (uintptr_t)new_frame; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + if (new_frame == NULL) JUMP_TO_ERROR(); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); break; @@ -4500,7 +4499,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (init_frame == NULL) { _PyEval_FrameClearAndPop(tstate, shim); - JUMP_TO_ERROR(); + stack_pointer[0].bits = (uintptr_t)init_frame; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + if (true) JUMP_TO_ERROR(); } frame->return_offset = 1 + INLINE_CACHE_ENTRIES_CALL; /* Account for pushing the extra frame. @@ -5174,9 +5176,10 @@ PyStackRef_CLOSE(kwnames); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - if (new_frame == NULL) { - JUMP_TO_ERROR(); - } + stack_pointer[0].bits = (uintptr_t)new_frame; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + if (new_frame == NULL) JUMP_TO_ERROR(); stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); break; diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 9856592811091b..256fd03290e37c 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -204,17 +204,13 @@ * only the locals reference, so PyUnicode_Append knows * that the string is safe to mutate. */ - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); - _PyFrame_SetStackPointer(frame, stack_pointer); assert(Py_REFCNT(left_o) >= 2); _Py_DECREF_NO_DEALLOC(left_o); - stack_pointer = _PyFrame_GetStackPointer(frame); PyObject *temp = PyStackRef_AsPyObjectBorrow(*target_local); PyUnicode_Append(&temp, right_o); *target_local = PyStackRef_FromPyObjectSteal(temp); _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); - if (PyStackRef_IsNull(*target_local)) goto error; + if (PyStackRef_IsNull(*target_local)) goto pop_2_error; #if TIER_ONE // The STORE_FAST is already done. This is done here in tier one, // and during trace projection in tier two: @@ -222,6 +218,8 @@ SKIP_OVER(1); #endif } + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -919,9 +917,7 @@ // Manipulate stack directly since we leave using DISPATCH_INLINED(). // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - if (new_frame == NULL) { - goto error; - } + if (new_frame == NULL) goto error; frame->return_offset = (uint16_t)(next_instr - this_instr); DISPATCH_INLINED(new_frame); } @@ -1040,7 +1036,12 @@ self = PyStackRef_FromPyObjectSteal(_PyType_NewManagedObject(tp)); stack_pointer = _PyFrame_GetStackPointer(frame); if (PyStackRef_IsNull(self)) { - goto error; + { + stack_pointer[2 + oparg] = self; + stack_pointer += 3 + oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } PyStackRef_CLOSE(callable); init = PyStackRef_FromPyObjectNew(init_func); @@ -1062,7 +1063,12 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (init_frame == NULL) { _PyEval_FrameClearAndPop(tstate, shim); - goto error; + if (true) { + stack_pointer[0].bits = (uintptr_t)init_frame; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } frame->return_offset = 1 + INLINE_CACHE_ENTRIES_CALL; /* Account for pushing the extra frame. @@ -1260,6 +1266,9 @@ // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { + stack_pointer[0].bits = (uintptr_t)new_frame; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); goto error; } } @@ -1624,7 +1633,11 @@ PyObject *tuple = PySequence_Tuple(callargs); stack_pointer = _PyFrame_GetStackPointer(frame); if (tuple == NULL) { - goto error; + { + stack_pointer += 3 + (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } PyStackRef_CLOSE(callargs_st); callargs_st = PyStackRef_FromPyObjectSteal(tuple); @@ -1644,7 +1657,11 @@ frame, this_instr, func, arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { - goto error; + { + stack_pointer += 3 + (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } _PyFrame_SetStackPointer(frame, stack_pointer); result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); @@ -1692,9 +1709,7 @@ nargs, callargs, kwargs, frame); stack_pointer = _PyFrame_GetStackPointer(frame); // Need to sync the stack since we exit with DISPATCH_INLINED. - if (new_frame == NULL) { - goto error; - } + if (new_frame == NULL) goto error; assert(next_instr - this_instr == 1); frame->return_offset = 1; DISPATCH_INLINED(new_frame); @@ -1809,7 +1824,11 @@ int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref)); stack_pointer = _PyFrame_GetStackPointer(frame); if (retval < 0) { - goto error; + { + stack_pointer += 2 + oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } res = retval ? PyStackRef_True : PyStackRef_False; assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL)); @@ -1897,9 +1916,7 @@ // Sync stack explicitly since we leave using DISPATCH_INLINED(). // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - if (new_frame == NULL) { - goto error; - } + if (new_frame == NULL) goto error; assert(next_instr - this_instr == 1 + INLINE_CACHE_ENTRIES_CALL_KW); frame->return_offset = 1 + INLINE_CACHE_ENTRIES_CALL_KW; DISPATCH_INLINED(new_frame); @@ -2040,6 +2057,9 @@ // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { + stack_pointer[0].bits = (uintptr_t)new_frame; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); goto error; } } @@ -2214,6 +2234,9 @@ // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { + stack_pointer[0].bits = (uintptr_t)new_frame; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); goto error; } } @@ -2276,7 +2299,11 @@ Py_ssize_t len_i = PyObject_Length(arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (len_i < 0) { - goto error; + { + stack_pointer += 2 + oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyLong_FromSsize_t(len_i); @@ -2855,6 +2882,9 @@ // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { + stack_pointer[0].bits = (uintptr_t)new_frame; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); goto error; } } @@ -3515,6 +3545,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); + goto error; } Py_DECREF(oldobj); @@ -3556,6 +3587,7 @@ _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, name); stack_pointer = _PyFrame_GetStackPointer(frame); + goto error; } DISPATCH(); @@ -3573,6 +3605,7 @@ _PyErr_Format(tstate, PyExc_SystemError, "no locals when deleting %R", name); stack_pointer = _PyFrame_GetStackPointer(frame); + goto error; } _PyFrame_SetStackPointer(frame, stack_pointer); @@ -3585,6 +3618,7 @@ NAME_ERROR_MSG, name); stack_pointer = _PyFrame_GetStackPointer(frame); + goto error; } DISPATCH(); @@ -3780,7 +3814,12 @@ "__init__() should return None, not '%.200s'", Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); - goto error; + + { + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -3897,7 +3936,11 @@ int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); stack_pointer = _PyFrame_GetStackPointer(frame); if (!matches) { - goto error; + { + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_MonitorRaise(tstate, frame, this_instr); @@ -4173,7 +4216,11 @@ PyObject *awaitable_o = _PyEval_GetANext(PyStackRef_AsPyObjectBorrow(aiter)); stack_pointer = _PyFrame_GetStackPointer(frame); if (awaitable_o == NULL) { - goto error; + { + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } awaitable = PyStackRef_FromPyObjectSteal(awaitable_o); stack_pointer[0] = awaitable; @@ -4273,7 +4320,12 @@ "cannot 'yield from' a coroutine object " "in a non-coroutine generator"); stack_pointer = _PyFrame_GetStackPointer(frame); - goto error; + + { + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } iter = iterable; } @@ -4288,7 +4340,12 @@ iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); stack_pointer = _PyFrame_GetStackPointer(frame); if (PyStackRef_IsNull(iter)) { - goto error; + { + stack_pointer[1] = iter; + stack_pointer += 2; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } PyStackRef_CLOSE(iterable); stack_pointer += 1; @@ -4431,9 +4488,7 @@ // Manipulate stack directly since we leave using DISPATCH_INLINED(). // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - if (new_frame == NULL) { - goto error; - } + if (new_frame == NULL) goto error; frame->return_offset = (uint16_t)(next_instr - this_instr); DISPATCH_INLINED(new_frame); } @@ -4561,7 +4616,11 @@ int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { - goto error; + { + stack_pointer += 2; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } }stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); } @@ -4589,7 +4648,11 @@ int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { - goto error; + { + stack_pointer += 2; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } }stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); } @@ -4983,7 +5046,11 @@ frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { - goto error; + { + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } if (frame->instr_ptr != this_instr) { next_instr = frame->instr_ptr; @@ -6009,7 +6076,11 @@ int err = PyMapping_GetOptionalItem(class_dict, name, &value_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { - goto error; + { + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } if (!value_o) { PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); @@ -6018,7 +6089,12 @@ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); - goto error; + + { + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } } PyStackRef_CLOSE(class_dict_st); @@ -6044,7 +6120,11 @@ int err = PyMapping_GetOptionalItem(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &v_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { - goto error; + { + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } if (v_o == NULL) { if (PyDict_CheckExact(GLOBALS()) @@ -6064,7 +6144,11 @@ NAME_ERROR_MSG, name); stack_pointer = _PyFrame_GetStackPointer(frame); } - goto error; + { + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } } else { @@ -6528,7 +6612,11 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(codeobj_st); if (func_obj == NULL) { - goto error; + { + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } _PyFrame_SetStackPointer(frame, stack_pointer); _PyFunction_SetVersion( @@ -6892,7 +6980,12 @@ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_SystemError, "lasti is not an int"); stack_pointer = _PyFrame_GetStackPointer(frame); - goto error; + + { + stack_pointer += 1 + oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } }stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); } @@ -7162,7 +7255,11 @@ JUMPBY(oparg); } else { - goto error; + { + stack_pointer += 2; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } }stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); } @@ -8276,7 +8373,11 @@ PyObject *tuple = PySequence_Tuple(callargs); stack_pointer = _PyFrame_GetStackPointer(frame); if (tuple == NULL) { - goto error; + { + stack_pointer += 3 + (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } PyStackRef_CLOSE(callargs_st); callargs_st = PyStackRef_FromPyObjectSteal(tuple); @@ -8296,7 +8397,11 @@ frame, this_instr, func, arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { - goto error; + { + stack_pointer += 3 + (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } _PyFrame_SetStackPointer(frame, stack_pointer); result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); @@ -8344,9 +8449,7 @@ nargs, callargs, kwargs, frame); stack_pointer = _PyFrame_GetStackPointer(frame); // Need to sync the stack since we exit with DISPATCH_INLINED. - if (new_frame == NULL) { - goto error; - } + if (new_frame == NULL) goto error; assert(next_instr - this_instr == 1); frame->return_offset = 1; DISPATCH_INLINED(new_frame); diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index e48178124e1e67..631ae3b248b92f 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -499,6 +499,7 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "_PyDictValues_AddToInsertionOrder", "Py_DECREF", "Py_XDECREF", + "Py_REFCNT", "_Py_DECREF_SPECIALIZED", "DECREF_INPUTS_AND_REUSE_FLOAT", "PyUnicode_Append", @@ -573,6 +574,7 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "_PyInterpreterState_GET", "PyType_HasFeature", "_Py_ID", + "_Py_DECREF_NO_DEALLOC", ) def find_stmt_start(node: parser.InstDef, idx: int) -> lexer.Token: diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 60cc4e0c03c217..e536b9cce6b77d 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -154,24 +154,7 @@ def deopt_if( exit_if = deopt_if - def error_if( - self, - tkn: Token, - tkn_iter: TokenIterator, - uop: Uop, - storage: Storage, - inst: Instruction | None, - ) -> bool: - self.out.emit_at("if ", tkn) - lparen = next(tkn_iter) - self.emit(lparen) - assert lparen.kind == "LPAREN" - first_tkn = tkn_iter.peek() - emit_to(self.out, tkn_iter, "COMMA") - label = next(tkn_iter).text - next(tkn_iter) # RPAREN - next(tkn_iter) # Semi colon - self.out.emit(") ") + def _flush_and_goto_error(self, storage: Storage, label: Token): if storage.locals_cached(): offset = -1 else: @@ -190,11 +173,32 @@ def error_if( self.out.emit(";\n") else: self.out.emit("{\n") - storage.copy().flush(self.out) + storage.flush(self.out) self.out.emit("goto ") self.out.emit(label) self.out.emit(";\n") self.out.emit("}\n") + + + def error_if( + self, + tkn: Token, + tkn_iter: TokenIterator, + uop: Uop, + storage: Storage, + inst: Instruction | None, + ) -> bool: + self.out.emit_at("if ", tkn) + lparen = next(tkn_iter) + self.emit(lparen) + assert lparen.kind == "LPAREN" + first_tkn = tkn_iter.peek() + emit_to(self.out, tkn_iter, "COMMA") + label = next(tkn_iter).text + next(tkn_iter) # RPAREN + next(tkn_iter) # Semi colon + self.out.emit(") ") + self._flush_and_goto_error(storage.copy(), label) return not always_true(first_tkn) def error_no_pop( @@ -208,7 +212,11 @@ def error_no_pop( next(tkn_iter) # LPAREN next(tkn_iter) # RPAREN next(tkn_iter) # Semi colon - self.out.emit_at("goto error;", tkn) + storage = storage.copy() + self.out.emit("\n") + for input in uop.stack.inputs: + storage.stack.push(Local.memory(input)) + self._flush_and_goto_error(storage, tkn.replaceText("error")) return False def decref_inputs( diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index 4c48e0f12911dc..287f13cd570474 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -63,6 +63,11 @@ def redefinition(var: StackItem, prev: "Local") -> "Local": assert var.is_array() == prev.is_array() return Local(var, prev.cached, prev.in_memory, True) + @staticmethod + def memory(defn: StackItem) -> "Local": + array = defn.is_array() + return Local(defn, True, array, False) + def copy(self) -> "Local": return Local( self.item, From 60ee3e9ae243bd20d29cabb5aa04324eb53055db Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 12 Sep 2024 11:08:41 +0100 Subject: [PATCH 26/53] Fix up handling of liveness --- Include/internal/pycore_opcode_metadata.h | 22 +- Include/internal/pycore_uop_metadata.h | 10 +- Python/bytecodes.c | 133 ++++++++---- Python/executor_cases.c.h | 27 +-- Python/generated_cases.c.h | 211 +++++-------------- Tools/cases_generator/analyzer.py | 21 +- Tools/cases_generator/generators_common.py | 124 ++++++++--- Tools/cases_generator/optimizer_generator.py | 20 +- Tools/cases_generator/stack.py | 160 +++++++------- Tools/cases_generator/tier1_generator.py | 18 +- Tools/cases_generator/tier2_generator.py | 4 +- 11 files changed, 369 insertions(+), 381 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 3a6de48fc1a322..e2987986f01f86 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -1031,10 +1031,10 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [BUILD_STRING] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [BUILD_TUPLE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [CACHE] = { true, INSTR_FMT_IX, 0 }, - [CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [CALL_ALLOC_AND_ENTER_INIT] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [CALL_BOUND_METHOD_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, - [CALL_BOUND_METHOD_GENERAL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_BOUND_METHOD_GENERAL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [CALL_BUILTIN_CLASS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_BUILTIN_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -1043,10 +1043,10 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [CALL_INTRINSIC_1] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [CALL_INTRINSIC_2] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, [CALL_ISINSTANCE] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, - [CALL_KW] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_KW_BOUND_METHOD] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_KW] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [CALL_KW_BOUND_METHOD] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [CALL_KW_NON_PY] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CALL_KW_PY] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_KW_PY] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [CALL_LEN] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [CALL_LIST_APPEND] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG }, [CALL_METHOD_DESCRIPTOR_FAST] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -1055,7 +1055,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [CALL_METHOD_DESCRIPTOR_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_NON_PY_GENERAL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_PY_EXACT_ARGS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG }, - [CALL_PY_GENERAL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_PY_GENERAL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [CALL_STR_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_TUPLE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_TYPE_1] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, @@ -1101,10 +1101,10 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [GET_YIELD_FROM_ITER] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [IMPORT_FROM] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [IMPORT_NAME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_CALL_FUNCTION_EX] = { true, INSTR_FMT_IX, 0 }, [INSTRUMENTED_CALL_KW] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_END_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_END_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_END_SEND] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_INSTRUCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -1161,7 +1161,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [LOAD_SUPER_ATTR_ATTR] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [LOAD_SUPER_ATTR_METHOD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [MAKE_CELL] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_FREE_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG }, - [MAKE_FUNCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [MAKE_FUNCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [MAP_ADD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [MATCH_CLASS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [MATCH_KEYS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -1182,9 +1182,9 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [RESUME] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [RESUME_CHECK] = { true, INSTR_FMT_IX, HAS_DEOPT_FLAG }, [RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG }, - [RETURN_GENERATOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [RETURN_GENERATOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [RETURN_VALUE] = { true, INSTR_FMT_IX, 0 }, - [SEND] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [SEND] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [SEND_GEN] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, [SETUP_ANNOTATIONS] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [SET_ADD] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index ca78d036d2b16e..1a6518b97fce15 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -204,7 +204,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CHECK_ATTR_METHOD_LAZY_DICT] = HAS_DEOPT_FLAG, [_LOAD_ATTR_METHOD_LAZY_DICT] = HAS_ARG_FLAG, [_MAYBE_EXPAND_METHOD] = HAS_ARG_FLAG, - [_PY_FRAME_GENERAL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_PY_FRAME_GENERAL] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CHECK_FUNCTION_VERSION] = HAS_ARG_FLAG | HAS_EXIT_FLAG, [_CHECK_METHOD_VERSION] = HAS_ARG_FLAG | HAS_EXIT_FLAG, [_EXPAND_METHOD] = HAS_ARG_FLAG, @@ -226,7 +226,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CALL_STR_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_TUPLE_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CHECK_AND_ALLOCATE_OBJECT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, - [_CREATE_INIT_FRAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CREATE_INIT_FRAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_EXIT_INIT_CHECK] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, [_CALL_BUILTIN_O] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -239,15 +239,15 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG, [_CALL_METHOD_DESCRIPTOR_NOARGS] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG, - [_PY_FRAME_KW] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_PY_FRAME_KW] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CHECK_FUNCTION_VERSION_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG, [_CHECK_METHOD_VERSION_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG, [_EXPAND_METHOD_KW] = HAS_ARG_FLAG, [_CHECK_IS_NOT_PY_CALLABLE_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG, [_CALL_KW_NON_PY] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_MAKE_FUNCTION] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_MAKE_FUNCTION] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_SET_FUNCTION_ATTRIBUTE] = HAS_ARG_FLAG, - [_RETURN_GENERATOR] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_RETURN_GENERATOR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_SLICE] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_CONVERT_VALUE] = HAS_ARG_FLAG | HAS_ERROR_FLAG, [_FORMAT_SIMPLE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 57fed44781c697..b2e891e0b19ab4 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -294,25 +294,29 @@ dummy_func( tier1 inst(INSTRUMENTED_END_FOR, (receiver, value -- receiver)) { /* Need to create a fake StopIteration error here, * to conform to PEP 380 */ + SYNC_SP(); if (PyStackRef_GenCheck(receiver)) { int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); - if (err) { - ERROR_NO_POP(); - } + DECREF_INPUTS(); + ERROR_IF(err, error); } DECREF_INPUTS(); } - pure inst(END_SEND, (receiver, value -- value)) { + pure inst(END_SEND, (receiver, value -- val)) { (void)receiver; + val = value; PyStackRef_CLOSE(receiver); } - tier1 inst(INSTRUMENTED_END_SEND, (receiver, value -- value)) { + tier1 inst(INSTRUMENTED_END_SEND, (receiver, value -- val)) { + SYNC_SP(); + val = value; PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver); if (PyGen_Check(receiver_o) || PyCoro_CheckExact(receiver_o)) { int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); if (err) { + PyStackRef_CLOSE(receiver); ERROR_NO_POP(); } } @@ -464,6 +468,7 @@ dummy_func( PyObject *res_o = _PyLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); + KILL_INPUTS(); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -476,6 +481,7 @@ dummy_func( PyObject *res_o = _PyLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); + KILL_INPUTS(); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -487,7 +493,8 @@ dummy_func( STAT_INC(BINARY_OP, hit); PyObject *res_o = _PyLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); - _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);; + _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); + KILL_INPUTS(); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -526,6 +533,7 @@ dummy_func( ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); + KILL_INPUTS(); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -539,6 +547,7 @@ dummy_func( ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); + KILL_INPUTS(); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -552,6 +561,7 @@ dummy_func( ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); + KILL_INPUTS(); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -578,6 +588,7 @@ dummy_func( PyObject *res_o = PyUnicode_Concat(left_o, right_o); _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc); _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); + KILL_INPUTS(); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -670,6 +681,8 @@ dummy_func( inst(BINARY_SLICE, (container, start, stop -- res)) { PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); + KILL(start); + KILL(stop); PyObject *res_o; OPCODE_DEFERRED_INC(BINARY_SLICE); // Can't use ERROR_IF() here, because we haven't @@ -719,6 +732,7 @@ dummy_func( assert(res_o != NULL); Py_INCREF(res_o); _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); + KILL(sub_st); PyStackRef_CLOSE(list_st); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -738,6 +752,7 @@ dummy_func( STAT_INC(BINARY_SUBSCR, hit); PyObject *res_o = (PyObject*)&_Py_SINGLETON(strings).ascii[c]; _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); + KILL(sub_st); PyStackRef_CLOSE(str_st); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -758,6 +773,7 @@ dummy_func( assert(res_o != NULL); Py_INCREF(res_o); _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); + KILL(sub_st); PyStackRef_CLOSE(tuple_st); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -802,6 +818,7 @@ dummy_func( SYNC_SP(); new_frame->localsplus[0] = container; new_frame->localsplus[1] = sub; + KILL_INPUTS(); frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_BINARY_SUBSCR); } @@ -1083,7 +1100,8 @@ dummy_func( JUMPBY(oparg); } else { - ERROR_NO_POP(); + DECREF_INPUTS(); + ERROR_IF(true, error); } } PyStackRef_CLOSE(v); @@ -1670,12 +1688,14 @@ dummy_func( inst(BUILD_TUPLE, (values[oparg] -- tup)) { PyObject *tup_o = _PyTuple_FromStackRefSteal(values, oparg); + KILL_INPUTS(); ERROR_IF(tup_o == NULL, error); tup = PyStackRef_FromPyObjectSteal(tup_o); } inst(BUILD_LIST, (values[oparg] -- list)) { PyObject *list_o = _PyList_FromStackRefSteal(values, oparg); + KILL_INPUTS(); ERROR_IF(list_o == NULL, error); list = PyStackRef_FromPyObjectSteal(list_o); } @@ -1722,6 +1742,7 @@ dummy_func( } PyStackRef_CLOSE(values[i]); } + KILL(values); if (err != 0) { Py_DECREF(set_o); ERROR_IF(true, error); @@ -3052,7 +3073,7 @@ dummy_func( NOP, }; - inst(PUSH_EXC_INFO, (new_exc -- prev_exc, new_exc)) { + inst(PUSH_EXC_INFO, (exc -- prev_exc, new_exc)) { _PyErr_StackItem *exc_info = tstate->exc_info; if (exc_info->exc_value != NULL) { @@ -3062,7 +3083,8 @@ dummy_func( prev_exc = PyStackRef_None; } assert(PyStackRef_ExceptionInstanceCheck(new_exc)); - exc_info->exc_value = PyStackRef_AsPyObjectNew(new_exc); + exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); + new_exc = exc; } op(_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, (owner -- owner)) { @@ -3211,10 +3233,13 @@ dummy_func( args[-2] = func; args[-1] = maybe_self; PyStackRef_CLOSE(callable); + KILL(self_or_null); } else { func = callable; maybe_self = self_or_null; + KILL(callable); + KILL(self_or_null); } } @@ -3240,13 +3265,17 @@ dummy_func( args, total_args, NULL, frame ); // Manipulate stack directly since we leave using DISPATCH_INLINED(). + SYNC_SP(); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - SYNC_SP(); - ERROR_IF(new_frame == NULL, error); + if (new_frame == NULL) { + ERROR_NO_POP(); + } frame->return_offset = (uint16_t)(next_instr - this_instr); DISPATCH_INLINED(new_frame); } + SAVE_STACK(); + KILL(self_or_null); /* Callable is not a normal Python function */ STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { @@ -3300,6 +3329,7 @@ dummy_func( else { arg0 = &_PyInstrumentation_MISSING; } + SYNC_SP(); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, function, arg0 @@ -3320,6 +3350,7 @@ dummy_func( args--; total_args++; } + SAVE_STACK(); 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)); @@ -3330,7 +3361,10 @@ dummy_func( // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. SYNC_SP(); - ERROR_IF(new_frame == NULL, error); + KILL_INPUTS(); + if (new_frame == NULL) { + ERROR_NO_POP(); + } } op(_CHECK_FUNCTION_VERSION, (func_version/2, callable, self_or_null, unused[oparg] -- callable, self_or_null, unused[oparg])) { @@ -3360,8 +3394,8 @@ dummy_func( op(_EXPAND_METHOD, (callable, null, unused[oparg] -- method, self, unused[oparg])) { PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - assert(PyStackRef_IsNull(null)); + KILL(null); assert(Py_TYPE(callable_o) == &PyMethod_Type); self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); @@ -3430,6 +3464,7 @@ dummy_func( } op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable, null, unused[oparg] -- func, self, unused[oparg])) { + KILL(null); PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); STAT_INC(CALL, hit); self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); @@ -3468,6 +3503,7 @@ dummy_func( for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; } + KILL_INPUTS(); } op(_PUSH_FRAME, (new_frame: _PyInterpreterFrame* -- )) { @@ -3561,6 +3597,7 @@ dummy_func( op(_CHECK_AND_ALLOCATE_OBJECT, (type_version/2, callable, null, args[oparg] -- self, init, args[oparg])) { PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); DEOPT_IF(!PyStackRef_IsNull(null)); + KILL(null); DEOPT_IF(!PyType_Check(callable_o)); PyTypeObject *tp = (PyTypeObject *)callable_o; DEOPT_IF(tp->tp_version_tag != type_version); @@ -3586,12 +3623,13 @@ dummy_func( shim->localsplus[0] = PyStackRef_DUP(self); PyFunctionObject *init_func = (PyFunctionObject *)PyStackRef_AsPyObjectSteal(init); args[-1] = self; + KILL(self); init_frame = _PyEvalFramePushAndInit( tstate, init_func, NULL, args-1, oparg+1, NULL, shim); SYNC_SP(); if (init_frame == NULL) { _PyEval_FrameClearAndPop(tstate, shim); - ERROR_IF(true, error); + ERROR_NO_POP(); } frame->return_offset = 1 + INLINE_CACHE_ENTRIES_CALL; /* Account for pushing the extra frame. @@ -3625,6 +3663,8 @@ dummy_func( args--; total_args++; } + SAVE_STACK(); + KILL(self_or_null); DEOPT_IF(!PyType_Check(callable_o)); PyTypeObject *tp = (PyTypeObject *)callable_o; DEOPT_IF(tp->tp_vectorcall == NULL); @@ -3651,12 +3691,12 @@ dummy_func( _CALL_BUILTIN_CLASS + _CHECK_PERIODIC; - op(_CALL_BUILTIN_O, (callable, self_or_null, args[oparg] -- res)) { + op(_CALL_BUILTIN_O, (callable, self_or_null[1], args[oparg] -- res)) { /* Builtin METH_O functions */ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null)) { + if (!PyStackRef_IsNull(self_or_null[0])) { args--; total_args++; } @@ -3694,6 +3734,8 @@ dummy_func( args--; total_args++; } + SAVE_STACK(); + KILL(self_or_null); DEOPT_IF(!PyCFunction_CheckExact(callable_o)); DEOPT_IF(PyCFunction_GET_FLAGS(callable_o) != METH_FASTCALL); STAT_INC(CALL, hit); @@ -3726,12 +3768,12 @@ dummy_func( _CALL_BUILTIN_FAST + _CHECK_PERIODIC; - op(_CALL_BUILTIN_FAST_WITH_KEYWORDS, (callable, self_or_null, args[oparg] -- res)) { + op(_CALL_BUILTIN_FAST_WITH_KEYWORDS, (callable, self_or_null[1], args[oparg] -- res)) { /* Builtin METH_FASTCALL | METH_KEYWORDS functions */ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null)) { + if (!PyStackRef_IsNull(self_or_null[0])) { args--; total_args++; } @@ -3797,12 +3839,12 @@ dummy_func( res = PyStackRef_FromPyObjectSteal(res_o); } - inst(CALL_ISINSTANCE, (unused/1, unused/2, callable, self_or_null, args[oparg] -- res)) { + inst(CALL_ISINSTANCE, (unused/1, unused/2, callable, self_or_null[1], args[oparg] -- res)) { /* isinstance(o, o2) */ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null)) { + if (!PyStackRef_IsNull(self_or_null[0])) { args--; total_args++; } @@ -3887,11 +3929,11 @@ dummy_func( _CALL_METHOD_DESCRIPTOR_O + _CHECK_PERIODIC; - op(_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, (callable, self_or_null, args[oparg] -- res)) { + op(_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, (callable, self_or_null[1], args[oparg] -- res)) { PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; - if (!PyStackRef_IsNull(self_or_null)) { + if (!PyStackRef_IsNull(self_or_null[0])) { args--; total_args++; } @@ -4044,7 +4086,7 @@ dummy_func( args--; total_args++; } - if (self_or_null_o == NULL && Py_TYPE(callable_o) == &PyMethod_Type) { + else if (Py_TYPE(callable_o) == &PyMethod_Type) { args--; total_args++; PyObject *self = ((PyMethodObject *)callable_o)->im_self; @@ -4069,10 +4111,12 @@ dummy_func( ); PyStackRef_CLOSE(kwnames); // Sync stack explicitly since we leave using DISPATCH_INLINED(). + SYNC_SP(); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - SYNC_SP(); - ERROR_IF(new_frame == NULL, error); + if (new_frame == NULL) { + ERROR_NO_POP(); + } assert(next_instr - this_instr == 1 + INLINE_CACHE_ENTRIES_CALL_KW); frame->return_offset = 1 + INLINE_CACHE_ENTRIES_CALL_KW; DISPATCH_INLINED(new_frame); @@ -4138,7 +4182,9 @@ dummy_func( // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. SYNC_SP(); - ERROR_IF(new_frame == NULL, error); + if (new_frame == NULL) { + ERROR_NO_POP(); + } } op(_CHECK_FUNCTION_VERSION_KW, (func_version/2, callable, self_or_null, unused[oparg], kwnames -- callable, self_or_null, unused[oparg], kwnames)) { @@ -4261,6 +4307,7 @@ dummy_func( PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); PyObject *callargs = PyStackRef_AsPyObjectBorrow(callargs_st); PyObject *kwargs = PyStackRef_AsPyObjectBorrow(kwargs_st); + PyObject *result_o; // DICT_MERGE is called before this opcode if there are kwargs. // It converts all dict subtypes in kwargs into regular dicts. @@ -4274,8 +4321,10 @@ dummy_func( if (tuple == NULL) { ERROR_NO_POP(); } - PyStackRef_CLOSE(callargs_st); + PyStackRef temp; + temp = callargs_st; callargs_st = PyStackRef_FromPyObjectSteal(tuple); + PyStackRef_CLOSE(temp); callargs = tuple; } assert(PyTuple_CheckExact(callargs)); @@ -4289,7 +4338,7 @@ dummy_func( if (err) { ERROR_NO_POP(); } - result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); + PyObject *result_o = PyObject_Call(func, callargs, kwargs); if (!PyFunction_Check(func) && !PyMethod_Check(func)) { if (PyStackRef_IsNull(result)) { @@ -4306,6 +4355,7 @@ dummy_func( } } } + } else { if (Py_TYPE(func) == &PyFunction_Type && @@ -4321,14 +4371,17 @@ dummy_func( nargs, callargs, kwargs, frame); // Need to sync the stack since we exit with DISPATCH_INLINED. SYNC_SP(); - ERROR_IF(new_frame == NULL, error); + if (new_frame == NULL) { + ERROR_NO_POP(); + } assert(next_instr - this_instr == 1); frame->return_offset = 1; DISPATCH_INLINED(new_frame); } - result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); + result_o = PyObject_Call(func, callargs, kwargs); } DECREF_INPUTS(); + result = PyStackRef_FromPyObjectSteal(result_o); ERROR_IF(PyStackRef_IsNull(result), error); } @@ -4344,19 +4397,17 @@ dummy_func( PyFunction_New(codeobj, GLOBALS()); PyStackRef_CLOSE(codeobj_st); - if (func_obj == NULL) { - ERROR_NO_POP(); - } + ERROR_IF(func_obj == NULL, error); _PyFunction_SetVersion( func_obj, ((PyCodeObject *)codeobj)->co_version); func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj); } - inst(SET_FUNCTION_ATTRIBUTE, (attr_st, func_st -- func_st)) { - PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + inst(SET_FUNCTION_ATTRIBUTE, (attr_st, func_in -- func_out)) { + PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); PyObject *attr = PyStackRef_AsPyObjectBorrow(attr_st); - + func_out = func_in; assert(PyFunction_Check(func)); size_t offset = _Py_FunctionAttributeOffsets[oparg]; assert(offset != 0); @@ -4369,9 +4420,7 @@ dummy_func( assert(PyFunction_Check(frame->f_funcobj)); PyFunctionObject *func = (PyFunctionObject *)frame->f_funcobj; PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func); - if (gen == NULL) { - ERROR_NO_POP(); - } + ERROR_IF(gen == NULL, error); assert(EMPTY()); SAVE_STACK(); _PyInterpreterFrame *gen_frame = &gen->gi_iframe; @@ -4465,8 +4514,10 @@ dummy_func( macro(BINARY_OP) = _SPECIALIZE_BINARY_OP + _BINARY_OP; - pure inst(SWAP, (bottom, unused[oparg-2], top -- - top, unused[oparg-2], bottom)) { + pure inst(SWAP, (bottom_in, unused[oparg-2], top_in -- + top_out, unused[oparg-2], bottom_out)) { + bottom_out = bottom_in; + top_out = top_in; assert(oparg >= 2); } diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 0d7223b79aed8a..65034bdcb94662 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -3928,10 +3928,9 @@ stack_pointer = _PyFrame_GetStackPointer(frame); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - stack_pointer[0].bits = (uintptr_t)new_frame; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - if (new_frame == NULL) JUMP_TO_ERROR(); + if (new_frame == NULL) { + JUMP_TO_ERROR(); + } stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); break; @@ -4499,10 +4498,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (init_frame == NULL) { _PyEval_FrameClearAndPop(tstate, shim); - stack_pointer[0].bits = (uintptr_t)init_frame; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - if (true) JUMP_TO_ERROR(); + JUMP_TO_ERROR(); } frame->return_offset = 1 + INLINE_CACHE_ENTRIES_CALL; /* Account for pushing the extra frame. @@ -5176,10 +5172,9 @@ PyStackRef_CLOSE(kwnames); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - stack_pointer[0].bits = (uintptr_t)new_frame; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - if (new_frame == NULL) JUMP_TO_ERROR(); + if (new_frame == NULL) { + JUMP_TO_ERROR(); + } stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); break; @@ -5344,9 +5339,7 @@ PyFunction_New(codeobj, GLOBALS()); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(codeobj_st); - if (func_obj == NULL) { - JUMP_TO_ERROR(); - } + if (func_obj == NULL) JUMP_TO_ERROR(); _PyFrame_SetStackPointer(frame, stack_pointer); _PyFunction_SetVersion( func_obj, ((PyCodeObject *)codeobj)->co_version); @@ -5385,9 +5378,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func); stack_pointer = _PyFrame_GetStackPointer(frame); - if (gen == NULL) { - JUMP_TO_ERROR(); - } + if (gen == NULL) JUMP_TO_ERROR(); assert(EMPTY()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *gen_frame = &gen->gi_iframe; diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 256fd03290e37c..23b2393d122409 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -917,7 +917,9 @@ // Manipulate stack directly since we leave using DISPATCH_INLINED(). // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - if (new_frame == NULL) goto error; + if (new_frame == NULL) { + goto error; + } frame->return_offset = (uint16_t)(next_instr - this_instr); DISPATCH_INLINED(new_frame); } @@ -1036,12 +1038,7 @@ self = PyStackRef_FromPyObjectSteal(_PyType_NewManagedObject(tp)); stack_pointer = _PyFrame_GetStackPointer(frame); if (PyStackRef_IsNull(self)) { - { - stack_pointer[2 + oparg] = self; - stack_pointer += 3 + oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } PyStackRef_CLOSE(callable); init = PyStackRef_FromPyObjectNew(init_func); @@ -1063,12 +1060,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (init_frame == NULL) { _PyEval_FrameClearAndPop(tstate, shim); - if (true) { - stack_pointer[0].bits = (uintptr_t)init_frame; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } frame->return_offset = 1 + INLINE_CACHE_ENTRIES_CALL; /* Account for pushing the extra frame. @@ -1266,9 +1258,6 @@ // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { - stack_pointer[0].bits = (uintptr_t)new_frame; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); goto error; } } @@ -1633,11 +1622,7 @@ PyObject *tuple = PySequence_Tuple(callargs); stack_pointer = _PyFrame_GetStackPointer(frame); if (tuple == NULL) { - { - stack_pointer += 3 + (oparg & 1); - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } PyStackRef_CLOSE(callargs_st); callargs_st = PyStackRef_FromPyObjectSteal(tuple); @@ -1657,11 +1642,7 @@ frame, this_instr, func, arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { - { - stack_pointer += 3 + (oparg & 1); - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } _PyFrame_SetStackPointer(frame, stack_pointer); result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); @@ -1709,7 +1690,9 @@ nargs, callargs, kwargs, frame); stack_pointer = _PyFrame_GetStackPointer(frame); // Need to sync the stack since we exit with DISPATCH_INLINED. - if (new_frame == NULL) goto error; + if (new_frame == NULL) { + goto error; + } assert(next_instr - this_instr == 1); frame->return_offset = 1; DISPATCH_INLINED(new_frame); @@ -1824,11 +1807,7 @@ int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref)); stack_pointer = _PyFrame_GetStackPointer(frame); if (retval < 0) { - { - stack_pointer += 2 + oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } res = retval ? PyStackRef_True : PyStackRef_False; assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL)); @@ -1916,7 +1895,9 @@ // Sync stack explicitly since we leave using DISPATCH_INLINED(). // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - if (new_frame == NULL) goto error; + if (new_frame == NULL) { + goto error; + } assert(next_instr - this_instr == 1 + INLINE_CACHE_ENTRIES_CALL_KW); frame->return_offset = 1 + INLINE_CACHE_ENTRIES_CALL_KW; DISPATCH_INLINED(new_frame); @@ -2057,9 +2038,6 @@ // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { - stack_pointer[0].bits = (uintptr_t)new_frame; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); goto error; } } @@ -2234,9 +2212,6 @@ // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { - stack_pointer[0].bits = (uintptr_t)new_frame; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); goto error; } } @@ -2299,11 +2274,7 @@ Py_ssize_t len_i = PyObject_Length(arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (len_i < 0) { - { - stack_pointer += 2 + oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyLong_FromSsize_t(len_i); @@ -2882,9 +2853,6 @@ // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { - stack_pointer[0].bits = (uintptr_t)new_frame; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); goto error; } } @@ -3545,7 +3513,6 @@ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); - goto error; } Py_DECREF(oldobj); @@ -3587,7 +3554,6 @@ _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, name); stack_pointer = _PyFrame_GetStackPointer(frame); - goto error; } DISPATCH(); @@ -3605,7 +3571,6 @@ _PyErr_Format(tstate, PyExc_SystemError, "no locals when deleting %R", name); stack_pointer = _PyFrame_GetStackPointer(frame); - goto error; } _PyFrame_SetStackPointer(frame, stack_pointer); @@ -3618,7 +3583,6 @@ NAME_ERROR_MSG, name); stack_pointer = _PyFrame_GetStackPointer(frame); - goto error; } DISPATCH(); @@ -3814,12 +3778,7 @@ "__init__() should return None, not '%.200s'", Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); - - { - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -3936,11 +3895,7 @@ int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); stack_pointer = _PyFrame_GetStackPointer(frame); if (!matches) { - { - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_MonitorRaise(tstate, frame, this_instr); @@ -4216,11 +4171,7 @@ PyObject *awaitable_o = _PyEval_GetANext(PyStackRef_AsPyObjectBorrow(aiter)); stack_pointer = _PyFrame_GetStackPointer(frame); if (awaitable_o == NULL) { - { - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } awaitable = PyStackRef_FromPyObjectSteal(awaitable_o); stack_pointer[0] = awaitable; @@ -4320,12 +4271,7 @@ "cannot 'yield from' a coroutine object " "in a non-coroutine generator"); stack_pointer = _PyFrame_GetStackPointer(frame); - - { - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } iter = iterable; } @@ -4340,12 +4286,7 @@ iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); stack_pointer = _PyFrame_GetStackPointer(frame); if (PyStackRef_IsNull(iter)) { - { - stack_pointer[1] = iter; - stack_pointer += 2; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } PyStackRef_CLOSE(iterable); stack_pointer += 1; @@ -4488,7 +4429,9 @@ // Manipulate stack directly since we leave using DISPATCH_INLINED(). // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - if (new_frame == NULL) goto error; + if (new_frame == NULL) { + goto error; + } frame->return_offset = (uint16_t)(next_instr - this_instr); DISPATCH_INLINED(new_frame); } @@ -4609,24 +4552,16 @@ receiver = stack_pointer[-2]; /* Need to create a fake StopIteration error here, * to conform to PEP 380 */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_GenCheck(receiver)) { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) { - { - stack_pointer += 2; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - }stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + PyStackRef_CLOSE(value); + if (err) goto error; } PyStackRef_CLOSE(value); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -4639,26 +4574,25 @@ _PyStackRef value; value = stack_pointer[-1]; receiver = stack_pointer[-2]; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver); if (PyGen_Check(receiver_o) || PyCoro_CheckExact(receiver_o)) { - stack_pointer[-2] = value; - stack_pointer += -1; + stack_pointer[0] = value; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { - { - stack_pointer += 2; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - }stack_pointer += 1; + PyStackRef_CLOSE(receiver); + goto error; + }stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } PyStackRef_CLOSE(receiver); - stack_pointer[-2] = value; - stack_pointer += -1; + stack_pointer[0] = value; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -5046,11 +4980,7 @@ frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { - { - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } if (frame->instr_ptr != this_instr) { next_instr = frame->instr_ptr; @@ -6076,11 +6006,7 @@ int err = PyMapping_GetOptionalItem(class_dict, name, &value_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { - { - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } if (!value_o) { PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); @@ -6089,12 +6015,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); - - { - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } } PyStackRef_CLOSE(class_dict_st); @@ -6120,11 +6041,7 @@ int err = PyMapping_GetOptionalItem(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &v_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { - { - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } if (v_o == NULL) { if (PyDict_CheckExact(GLOBALS()) @@ -6144,11 +6061,7 @@ NAME_ERROR_MSG, name); stack_pointer = _PyFrame_GetStackPointer(frame); } - { - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } } else { @@ -6611,13 +6524,7 @@ PyFunction_New(codeobj, GLOBALS()); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(codeobj_st); - if (func_obj == NULL) { - { - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - } + if (func_obj == NULL) goto error; _PyFrame_SetStackPointer(frame, stack_pointer); _PyFunction_SetVersion( func_obj, ((PyCodeObject *)codeobj)->co_version); @@ -6980,12 +6887,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_SystemError, "lasti is not an int"); stack_pointer = _PyFrame_GetStackPointer(frame); - - { - stack_pointer += 1 + oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; }stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); } @@ -7118,9 +7020,7 @@ _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func); stack_pointer = _PyFrame_GetStackPointer(frame); - if (gen == NULL) { - goto error; - } + if (gen == NULL) goto error; assert(EMPTY()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *gen_frame = &gen->gi_iframe; @@ -7255,11 +7155,8 @@ JUMPBY(oparg); } else { - { - stack_pointer += 2; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + PyStackRef_CLOSE(v); + if (true) goto error; }stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); } @@ -8373,11 +8270,7 @@ PyObject *tuple = PySequence_Tuple(callargs); stack_pointer = _PyFrame_GetStackPointer(frame); if (tuple == NULL) { - { - stack_pointer += 3 + (oparg & 1); - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } PyStackRef_CLOSE(callargs_st); callargs_st = PyStackRef_FromPyObjectSteal(tuple); @@ -8397,11 +8290,7 @@ frame, this_instr, func, arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { - { - stack_pointer += 3 + (oparg & 1); - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + goto error; } _PyFrame_SetStackPointer(frame, stack_pointer); result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); @@ -8449,7 +8338,9 @@ nargs, callargs, kwargs, frame); stack_pointer = _PyFrame_GetStackPointer(frame); // Need to sync the stack since we exit with DISPATCH_INLINED. - if (new_frame == NULL) goto error; + if (new_frame == NULL) { + goto error; + } assert(next_instr - this_instr == 1); frame->return_offset = 1; DISPATCH_INLINED(new_frame); diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 631ae3b248b92f..00674214538247 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -1,4 +1,5 @@ from dataclasses import dataclass, field +import itertools import lexer import parser import re @@ -327,11 +328,25 @@ def analyze_stack( ] # Mark variables with matching names at the base of the stack as "peek" modified = False - for input, output in zip(inputs, outputs): - if input.name == output.name and not modified: - input.peek = output.peek = True + input_names: dict[str, lexer.Token] = { i.name : i.first_token for i in op.inputs if i.name != "unused" } + input_names + for input, output in itertools.zip_longest(inputs, outputs): + if output is None: + pass + elif input is None: + if output.name in input_names: + raise analysis_error( + f"Reuse of variable '{output.name}' at different stack location", + input_names[output.name]) + elif input.name == output.name: + if not modified: + input.peek = output.peek = True else: modified = True + if output.name in input_names: + raise analysis_error( + f"Reuse of variable '{output.name}' at different stack location", + input_names[output.name]) if isinstance(op, parser.InstDef): output_names = [out.name for out in outputs] for input in inputs: diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index e536b9cce6b77d..3455d97c5ba5ed 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -14,7 +14,7 @@ from stack import Stack, Local, Storage, StackError # Set this to true for voluminous output showing state of stack and locals -PRINT_STACKS = False +PRINT_STACKS = 1 #False class TokenIterator: @@ -111,9 +111,13 @@ def __init__(self, out: CWriter): "ERROR_IF": self.error_if, "ERROR_NO_POP": self.error_no_pop, "DECREF_INPUTS": self.decref_inputs, + "KILL": self.kill, + "KILL_INPUTS": self.kill_inputs, "SYNC_SP": self.sync_sp, "SAVE_STACK": self.save_stack, "RELOAD_STACK": self.reload_stack, + "PyStackRef_CLOSE": self.stackref_close, + "PyStackRef_AsPyObjectSteal": self.stackref_steal, # "PyStackRef_FromPyObjectNew": self.py_stack_ref_from_py_object_new, "DISPATCH": self.dispatch } @@ -154,7 +158,24 @@ def deopt_if( exit_if = deopt_if - def _flush_and_goto_error(self, storage: Storage, label: Token): + def error_if( + self, + tkn: Token, + tkn_iter: TokenIterator, + uop: Uop, + storage: Storage, + inst: Instruction | None, + ) -> bool: + self.out.emit_at("if ", tkn) + lparen = next(tkn_iter) + self.emit(lparen) + assert lparen.kind == "LPAREN" + first_tkn = tkn_iter.peek() + emit_to(self.out, tkn_iter, "COMMA") + label = next(tkn_iter).text + next(tkn_iter) # RPAREN + next(tkn_iter) # Semi colon + self.out.emit(") ") if storage.locals_cached(): offset = -1 else: @@ -173,32 +194,11 @@ def _flush_and_goto_error(self, storage: Storage, label: Token): self.out.emit(";\n") else: self.out.emit("{\n") - storage.flush(self.out) + storage.copy().flush(self.out) self.out.emit("goto ") self.out.emit(label) self.out.emit(";\n") self.out.emit("}\n") - - - def error_if( - self, - tkn: Token, - tkn_iter: TokenIterator, - uop: Uop, - storage: Storage, - inst: Instruction | None, - ) -> bool: - self.out.emit_at("if ", tkn) - lparen = next(tkn_iter) - self.emit(lparen) - assert lparen.kind == "LPAREN" - first_tkn = tkn_iter.peek() - emit_to(self.out, tkn_iter, "COMMA") - label = next(tkn_iter).text - next(tkn_iter) # RPAREN - next(tkn_iter) # Semi colon - self.out.emit(") ") - self._flush_and_goto_error(storage.copy(), label) return not always_true(first_tkn) def error_no_pop( @@ -212,11 +212,7 @@ def error_no_pop( next(tkn_iter) # LPAREN next(tkn_iter) # RPAREN next(tkn_iter) # Semi colon - storage = storage.copy() - self.out.emit("\n") - for input in uop.stack.inputs: - storage.stack.push(Local.memory(input)) - self._flush_and_goto_error(storage, tkn.replaceText("error")) + self.out.emit_at("goto error;", tkn) return False def decref_inputs( @@ -245,8 +241,73 @@ def decref_inputs( self.out.emit(f"PyStackRef_XCLOSE({var.name});\n") else: self.out.emit(f"PyStackRef_CLOSE({var.name});\n") + for var in storage.inputs: + var.defined = False return True + def kill_inputs( + self, + tkn: Token, + tkn_iter: TokenIterator, + uop: Uop, + storage: Storage, + inst: Instruction | None, + ) -> bool: + next(tkn_iter) + next(tkn_iter) + next(tkn_iter) + for var in storage.inputs: + var.defined = False + return True + + def kill( + self, + tkn: Token, + tkn_iter: TokenIterator, + uop: Uop, + storage: Storage, + inst: Instruction | None, + ) -> bool: + next(tkn_iter) + name_tkn = next(tkn_iter) + name = name_tkn.text + next(tkn_iter) + next(tkn_iter) + for var in storage.inputs: + if var.name == name: + var.defined = False + break + else: + raise analysis_error(f"'{name} is not an input-only variable", name_tkn) + return True + + def stackref_close( + self, + tkn: Token, + tkn_iter: TokenIterator, + uop: Uop, + storage: Storage, + inst: Instruction | None, + ) -> bool: + tkn = next(tkn_iter) + assert (tkn.kind == "LPAREN") + self.out.emit(tkn) + name = next(tkn_iter) + self.out.emit(name) + rparen = next(tkn_iter) + self.out.emit(rparen) + if rparen.kind == "RPAREN": + if name.kind == "IDENTIFIER": + for var in storage.inputs: + if var.name == name.text: + var.defined = False + else: + rparen = emit_to(self.out, tkn_iter, "RPAREN") + self.emit(rparen) + return True + + stackref_steal = stackref_close + def sync_sp( self, tkn: Token, @@ -429,7 +490,7 @@ def _emit_block( else: self.out.emit(tkn) except StackError as ex: - raise analysis_error(ex.args[0], tkn) # from None + raise analysis_error(ex.args[0], tkn) from None raise analysis_error("Expecting closing brace. Reached end of file", tkn) @@ -443,8 +504,7 @@ def emit_tokens( self.out.start_line() _, _, storage = self._emit_block(tkn_iter, uop, storage, inst, False) for output in storage.outputs: - storage.stack.push(output) - storage.outputs = [] + storage.push_outputs() self._print_storage(storage) return storage.stack diff --git a/Tools/cases_generator/optimizer_generator.py b/Tools/cases_generator/optimizer_generator.py index 1a7bc00833e7c2..9e16164e19f7c7 100644 --- a/Tools/cases_generator/optimizer_generator.py +++ b/Tools/cases_generator/optimizer_generator.py @@ -113,21 +113,10 @@ def write_uop( prototype = override if override else uop try: out.start_line() - peeks: list[Local] = [] - for var in reversed(prototype.stack.inputs): - code, local = stack.pop(var, extract_bits=True) - if not skip_inputs: - out.emit(code) - if var.peek: - peeks.append(local) - if local.defined: - locals[local.name] = local - # Push back the peeks, so that they remain on the logical - # stack, but their values are cached. - while peeks: - stack.push(peeks.pop()) out.emit(stack.define_output_arrays(prototype.stack.outputs)) - storage = Storage.for_uop(stack, prototype, locals) + code_list, storage = Storage.for_uop(stack, prototype) + for code in code_list: + out.emit(code) if debug: args = [] for var in prototype.stack.inputs: @@ -148,8 +137,7 @@ def write_uop( emitter.emit_tokens(override, storage, None) else: emit_default(out, uop, storage) - for output in storage.outputs: - stack.push(output) + storage.push_outputs() out.start_line() stack.flush(out, cast_type="_Py_UopsSymbol *", extract_bits=True) except StackError as ex: diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index 287f13cd570474..6819d0c9ac0c33 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -230,7 +230,7 @@ def pop(self, var: StackItem, extract_bits: bool = False) -> tuple[str, Local]: if popped.size != var.size: raise StackError( f"Size mismatch when popping '{popped.name}' from stack to assign to {var.name}. " - f"Expected {var.size} got {popped.size}" + f"Expected '{var.size}' got '{var_size(popped)}'" ) if var.name in UNUSED: if popped.name not in UNUSED and popped.name in self.defined: @@ -274,6 +274,7 @@ def pop(self, var: StackItem, extract_bits: bool = False) -> tuple[str, Local]: return assign, Local(var, not var.is_array(), in_memory, True) def push(self, var: Local) -> None: + assert(var not in self.variables) self.variables.append(var) self.top_offset.push(var.item) if var.item.used: @@ -338,8 +339,9 @@ def peek_offset(self) -> str: return self.top_offset.to_c() def as_comment(self) -> str: + variables = ", ".join([str(v) for v in self.variables]) return ( - f"/* Variables: {", ".join([str(v) for v in self.variables])}. " + f"/* Variables: {variables}. " f"Base offset: {self.base_offset.to_c()}. Top offset: {self.top_offset.to_c()} */" ) @@ -413,20 +415,37 @@ def stacks(inst: Instruction | PseudoInstruction) -> Iterator[StackEffect]: class Storage: stack: Stack + inputs: list[Local] outputs: list[Local] + peeks: list[Local] spilled: int = 0 def _push_defined_locals(self) -> None: + defined_output = "" + for output in self.outputs: + if output.defined and not output.in_memory: + defined_output = output.name + if not defined_output: + return + while self.inputs: + tos = self.inputs.pop() + if tos.defined and not tos.is_array(): + raise StackError( + f"Input '{tos.name}' is not cleared " + f"when output '{defined_output}' is defined" + ) + self.stack.pop(tos.item) undefined = "" for out in self.outputs: if out.defined: - if not out.in_memory: - self.stack.push(out) if undefined: f"Locals not defined in stack order. " f"Expected '{undefined}' to be defined before '{out.name}'" else: undefined = out.name + while self.outputs and (self.outputs[0].defined or self.outputs[0].is_array()) : + out = self.outputs.pop(0) + self.stack.push(out) def locals_cached(self) -> bool: for out in self.outputs: @@ -458,25 +477,42 @@ def reload(self, out: CWriter) -> None: out.emit(f"/* Virtual reload {self.spilled} */\n") @staticmethod - def for_uop(stack: Stack, uop: Uop, locals: dict[str, Local]) -> "Storage": - outputs: list[Local] = [] - for var in uop.stack.outputs: - if not var.peek: - if var.name in locals: - local = locals[var.name] - elif var.name == "unused": - local = Local.unused(var) - else: - local = Local.undefined(var) - outputs.append(local) - return Storage(stack, outputs) + def for_uop(stack: Stack, uop: Uop) -> tuple[list[str], "Storage"]: + code_list: list[str] = [] + inputs: list[Local] = [] + peeks: list[Local] = [] + for var in reversed(uop.stack.inputs): + code, local = stack.pop(var) + code_list.append(code) + if var.peek: + peeks.append(local) + else: + inputs.append(local) + inputs.reverse() + peeks.reverse() + code_list.append(stack.as_comment()) + for var in peeks: + stack.push(var) + code_list.append(stack.as_comment()) + for var in inputs: + stack.push(var) + code_list.append(stack.as_comment()) + outputs = [ Local.undefined(var) for var in uop.stack.outputs if not var.peek ] + return code_list, Storage(stack, inputs, outputs, peeks) + + @staticmethod + def copy_list(arg: list[Local]) -> list[Local]: + return [ l.copy() for l in arg ] def copy(self) -> "Storage": - return Storage(self.stack.copy(), [ l.copy() for l in self.outputs]) + return Storage( + self.stack.copy(), self.copy_list(self.inputs), + self.copy_list(self.outputs), self.copy_list(self.peeks) + ) - def sanity_check(self): - names: set[str] = set() - for var in self.stack.variables: + def sanity_check(self) -> None: + names = set() + for var in self.inputs: if var.name in names: raise StackError(f"Duplicate name {var.name}") names.add(var.name) @@ -485,8 +521,13 @@ def sanity_check(self): if var.name in names: raise StackError(f"Duplicate name {var.name}") names.add(var.name) + names: set[str] = set() + for var in self.stack.variables: + if var.name in names: + raise StackError(f"Duplicate name {var.name}") + names.add(var.name) - def is_flushed(self): + def is_flushed(self) -> None: for var in self.outputs: if var.defined and not var.in_memory: return False @@ -494,67 +535,26 @@ def is_flushed(self): def merge(self, other: "Storage", out: CWriter) -> None: self.sanity_check() - locally_defined_set: set[str] = set() - for var in self.outputs: - if var.defined and not var.in_memory: - locally_defined_set.add(var.name) - for var in other.outputs: - if var.defined and not var.in_memory: - locally_defined_set.add(var.name) - while self.stack.variables and self.stack.variables[-1].item.name in locally_defined_set: - code, var = self.stack.pop(self.stack.variables[-1].item) - out.emit(code) - if var not in self.outputs: - self.outputs.append(var) - while other.stack.variables and other.stack.variables[-1].item.name in locally_defined_set: - code, var = other.stack.pop(other.stack.variables[-1].item) - assert code == "" - if var not in other.outputs: - other.outputs.append(var) - s1, s2 = self.stack, other.stack - l1, l2 = self.outputs, other.outputs - if len(s1.variables) != len(s2.variables): - # Make sure s2 is the larger stack. - if len(s1.variables) > len(s2.variables): - s1, s2 = s2, s1 - l1, l2 = l2, l1 - while len(s2.variables) > len(s1.variables): - top = s2.variables[-1] - if top.defined: - code, var = s2.pop(top.item) - assert code == "" and var == top - l2.insert(0, top) - else: - for l in l1: - if l.name == top.name: - break - else: - raise StackError(f"Missing local {top.name} when attempting to merge storage") - if l.in_memory: - s1.push(l) - l1.remove(l) - else: - raise StackError(f"Local {top.name} is not in memory, so cannot be merged") - # Now merge locals: - self_live = [var for var in self.outputs if not var.item.peek and var.defined] - other_live = [var for var in other.outputs if not var.item.peek and var.defined] - self.stack.align(other.stack, out) - if len(self_live) != len(other_live): - if other.stack.is_flushed(): - self.stack.flush(out) - return self - else: - raise StackError(f"Mismatched locals: {self_live} and {other_live}") - for self_out, other_out in zip(self_live, other_live): - if self_out.name != other_out.name: - raise StackError(f"Mismatched local: {self_out.name} and {other_out.name}") - if self_out.defined ^ other_out.defined: - raise StackError(f"Local {self_out.name} defined on only one path") - self_out.in_memory = self_out.in_memory and other_out.in_memory - self_out.cached = other_out.cached = self_out.cached and other_out.cached + if len(self.inputs) != len(other.inputs): + raise StackError(f"Inputs clearing is not consistent") + for var, other_var in zip(self.inputs, other.inputs): + if var.defined != other_var.defined: + raise StackError(f"'{var.name}' is cleared on some paths, but not all") + for var, other_var in zip(self.outputs, other.outputs): + if var.defined != other_var.defined: + raise StackError(f"'{var.name}' is set on some paths, but not all") self.stack.merge(other.stack) self.sanity_check() + def push_outputs(self): + self._push_defined_locals() + if self.outputs: + raise StackError(f"'{self.outputs[0].name}' is not defined") + def as_comment(self) -> str: stack_comment = self.stack.as_comment() - return stack_comment[:-2] + "\n LOCALS: " + ", ".join([str(out) for out in self.outputs]) + " */" + next_line = "\n " + inputs = ", ".join([var.name for var in self.inputs]) + outputs = ", ".join([var.name for var in self.outputs]) + peeks = ", ".join([var.name for var in self.peeks]) + return f"{stack_comment[:-2]}{next_line}inputs: {inputs}{next_line}outputs: {outputs}{next_line}peeks: {peeks} */" diff --git a/Tools/cases_generator/tier1_generator.py b/Tools/cases_generator/tier1_generator.py index e02052e9ca97af..219a1c238338a3 100644 --- a/Tools/cases_generator/tier1_generator.py +++ b/Tools/cases_generator/tier1_generator.py @@ -86,22 +86,12 @@ def write_uop( emitter.out.start_line() if braces: emitter.out.emit(f"// {uop.name}\n") - peeks: list[Local] = [] - for var in reversed(uop.stack.inputs): - code, local = stack.pop(var) - emitter.emit(code) - if var.peek: - peeks.append(local) - if local.defined: - locals[local.name] = local - # Push back the peeks, so that they remain on the logical - # stack, but their values are cached. - while peeks: - stack.push(peeks.pop()) - if braces: emitter.emit("{\n") + emitter.emit(stack.as_comment()) + code_list, storage = Storage.for_uop(stack, uop) emitter.emit(stack.define_output_arrays(uop.stack.outputs)) - storage = Storage.for_uop(stack, uop, locals) + for code in code_list: + emitter.emit(code) for cache in uop.caches: if cache.name != "unused": diff --git a/Tools/cases_generator/tier2_generator.py b/Tools/cases_generator/tier2_generator.py index 65e4d6dcc01b83..f0ba89bf409a48 100644 --- a/Tools/cases_generator/tier2_generator.py +++ b/Tools/cases_generator/tier2_generator.py @@ -191,7 +191,9 @@ def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> None: while peeks: stack.push(peeks.pop()) emitter.emit(stack.define_output_arrays(uop.stack.outputs)) - storage = Storage.for_uop(stack, uop, locals) + code_list, storage = Storage.for_uop(stack, uop, locals) + of code in code_list: + emitter.emit(code) for cache in uop.caches: if cache.name != "unused": if cache.size == 4: From 9f2f3bb79493666b76fb15c76974cd962aa401ab Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 12 Sep 2024 13:52:56 +0100 Subject: [PATCH 27/53] Allow assignments of new refs to input as well as output variables. --- Python/bytecodes.c | 6 +++--- Tools/cases_generator/analyzer.py | 13 +++++++++++-- Tools/cases_generator/tier2_generator.py | 2 +- 3 files changed, 15 insertions(+), 6 deletions(-) diff --git a/Python/bytecodes.c b/Python/bytecodes.c index b2e891e0b19ab4..a7344273604249 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -4092,10 +4092,10 @@ dummy_func( PyObject *self = ((PyMethodObject *)callable_o)->im_self; args[0] = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; - args[-1] = PyStackRef_FromPyObjectNew(method); - PyStackRef_CLOSE(callable); + PyStackRef temp = callable; + callable = PyStackRef_FromPyObjectNew(method); + PyStackRef_CLOSE(temp); callable_o = method; - callable = args[-1]; } int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); // Check if the call can be inlined or not diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 00674214538247..05d9c5b154941d 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -436,9 +436,18 @@ def analyze_deferred_refs(node: parser.InstDef) -> dict[lexer.Token, str | None] ) name = lhs[0].text - if not any(var.name == name for var in node.outputs): + match = False + for var in node.inputs: + if var.name == name: + match = True + break + for var in node.outputs: + if var.name == name: + match = True + break + if not match: raise analysis_error( - f"PyStackRef_FromPyObjectNew() must be assigned to an output, not '{name}'", + f"PyStackRef_FromPyObjectNew() must be assigned to an input or output, not '{name}'", tkn, ) diff --git a/Tools/cases_generator/tier2_generator.py b/Tools/cases_generator/tier2_generator.py index f0ba89bf409a48..e28464fa05a141 100644 --- a/Tools/cases_generator/tier2_generator.py +++ b/Tools/cases_generator/tier2_generator.py @@ -192,7 +192,7 @@ def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> None: stack.push(peeks.pop()) emitter.emit(stack.define_output_arrays(uop.stack.outputs)) code_list, storage = Storage.for_uop(stack, uop, locals) - of code in code_list: + for code in code_list: emitter.emit(code) for cache in uop.caches: if cache.name != "unused": From 9dda555a2ff5efb728aa6f8cba83db9b403600b8 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Mon, 16 Sep 2024 10:33:37 +0100 Subject: [PATCH 28/53] Add explicit kills and more stack tracking --- Include/internal/pycore_uop_ids.h | 69 +- Include/internal/pycore_uop_metadata.h | 4 + Python/bytecodes.c | 158 +- Python/ceval.c | 1 + Python/executor_cases.c.h | 1030 +++++---- Python/generated_cases.c.h | 2157 ++++++++---------- Python/optimizer_bytecodes.c | 8 +- Python/optimizer_cases.c.h | 716 +++--- Tools/cases_generator/analyzer.py | 5 + Tools/cases_generator/generators_common.py | 23 +- Tools/cases_generator/optimizer_generator.py | 6 +- Tools/cases_generator/stack.py | 113 +- Tools/cases_generator/tier1_generator.py | 5 +- 13 files changed, 2121 insertions(+), 2174 deletions(-) diff --git a/Include/internal/pycore_uop_ids.h b/Include/internal/pycore_uop_ids.h index b950f760d74ac7..05b78d38545f2e 100644 --- a/Include/internal/pycore_uop_ids.h +++ b/Include/internal/pycore_uop_ids.h @@ -228,58 +228,59 @@ extern "C" { #define _MATCH_MAPPING MATCH_MAPPING #define _MATCH_SEQUENCE MATCH_SEQUENCE #define _MAYBE_EXPAND_METHOD 439 -#define _MONITOR_CALL 440 -#define _MONITOR_JUMP_BACKWARD 441 -#define _MONITOR_RESUME 442 +#define _MAYBE_EXPAND_METHOD_KW 440 +#define _MONITOR_CALL 441 +#define _MONITOR_JUMP_BACKWARD 442 +#define _MONITOR_RESUME 443 #define _NOP NOP #define _POP_EXCEPT POP_EXCEPT -#define _POP_JUMP_IF_FALSE 443 -#define _POP_JUMP_IF_TRUE 444 +#define _POP_JUMP_IF_FALSE 444 +#define _POP_JUMP_IF_TRUE 445 #define _POP_TOP POP_TOP -#define _POP_TOP_LOAD_CONST_INLINE_BORROW 445 +#define _POP_TOP_LOAD_CONST_INLINE_BORROW 446 #define _PUSH_EXC_INFO PUSH_EXC_INFO -#define _PUSH_FRAME 446 +#define _PUSH_FRAME 447 #define _PUSH_NULL PUSH_NULL -#define _PY_FRAME_GENERAL 447 -#define _PY_FRAME_KW 448 -#define _QUICKEN_RESUME 449 -#define _REPLACE_WITH_TRUE 450 +#define _PY_FRAME_GENERAL 448 +#define _PY_FRAME_KW 449 +#define _QUICKEN_RESUME 450 +#define _REPLACE_WITH_TRUE 451 #define _RESUME_CHECK RESUME_CHECK #define _RETURN_GENERATOR RETURN_GENERATOR #define _RETURN_VALUE RETURN_VALUE -#define _SAVE_RETURN_OFFSET 451 -#define _SEND 452 -#define _SEND_GEN_FRAME 453 +#define _SAVE_RETURN_OFFSET 452 +#define _SEND 453 +#define _SEND_GEN_FRAME 454 #define _SETUP_ANNOTATIONS SETUP_ANNOTATIONS #define _SET_ADD SET_ADD #define _SET_FUNCTION_ATTRIBUTE SET_FUNCTION_ATTRIBUTE #define _SET_UPDATE SET_UPDATE -#define _START_EXECUTOR 454 -#define _STORE_ATTR 455 -#define _STORE_ATTR_INSTANCE_VALUE 456 -#define _STORE_ATTR_SLOT 457 -#define _STORE_ATTR_WITH_HINT 458 +#define _START_EXECUTOR 455 +#define _STORE_ATTR 456 +#define _STORE_ATTR_INSTANCE_VALUE 457 +#define _STORE_ATTR_SLOT 458 +#define _STORE_ATTR_WITH_HINT 459 #define _STORE_DEREF STORE_DEREF -#define _STORE_FAST 459 -#define _STORE_FAST_0 460 -#define _STORE_FAST_1 461 -#define _STORE_FAST_2 462 -#define _STORE_FAST_3 463 -#define _STORE_FAST_4 464 -#define _STORE_FAST_5 465 -#define _STORE_FAST_6 466 -#define _STORE_FAST_7 467 +#define _STORE_FAST 460 +#define _STORE_FAST_0 461 +#define _STORE_FAST_1 462 +#define _STORE_FAST_2 463 +#define _STORE_FAST_3 464 +#define _STORE_FAST_4 465 +#define _STORE_FAST_5 466 +#define _STORE_FAST_6 467 +#define _STORE_FAST_7 468 #define _STORE_FAST_LOAD_FAST STORE_FAST_LOAD_FAST #define _STORE_FAST_STORE_FAST STORE_FAST_STORE_FAST #define _STORE_GLOBAL STORE_GLOBAL #define _STORE_NAME STORE_NAME -#define _STORE_SLICE 468 -#define _STORE_SUBSCR 469 +#define _STORE_SLICE 469 +#define _STORE_SUBSCR 470 #define _STORE_SUBSCR_DICT STORE_SUBSCR_DICT #define _STORE_SUBSCR_LIST_INT STORE_SUBSCR_LIST_INT #define _SWAP SWAP -#define _TIER2_RESUME_CHECK 470 -#define _TO_BOOL 471 +#define _TIER2_RESUME_CHECK 471 +#define _TO_BOOL 472 #define _TO_BOOL_BOOL TO_BOOL_BOOL #define _TO_BOOL_INT TO_BOOL_INT #define _TO_BOOL_LIST TO_BOOL_LIST @@ -289,14 +290,14 @@ extern "C" { #define _UNARY_NEGATIVE UNARY_NEGATIVE #define _UNARY_NOT UNARY_NOT #define _UNPACK_EX UNPACK_EX -#define _UNPACK_SEQUENCE 472 +#define _UNPACK_SEQUENCE 473 #define _UNPACK_SEQUENCE_LIST UNPACK_SEQUENCE_LIST #define _UNPACK_SEQUENCE_TUPLE UNPACK_SEQUENCE_TUPLE #define _UNPACK_SEQUENCE_TWO_TUPLE UNPACK_SEQUENCE_TWO_TUPLE #define _WITH_EXCEPT_START WITH_EXCEPT_START #define _YIELD_VALUE YIELD_VALUE #define __DO_CALL_FUNCTION_EX _DO_CALL_FUNCTION_EX -#define MAX_UOP_ID 472 +#define MAX_UOP_ID 473 #ifdef __cplusplus } diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index d690c74b7211b9..e54c58abcc1032 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -239,6 +239,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG, [_CALL_METHOD_DESCRIPTOR_NOARGS] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG, + [_MAYBE_EXPAND_METHOD_KW] = HAS_ARG_FLAG, [_PY_FRAME_KW] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CHECK_FUNCTION_VERSION_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG, [_CHECK_METHOD_VERSION_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG, @@ -487,6 +488,7 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { [_MATCH_MAPPING] = "_MATCH_MAPPING", [_MATCH_SEQUENCE] = "_MATCH_SEQUENCE", [_MAYBE_EXPAND_METHOD] = "_MAYBE_EXPAND_METHOD", + [_MAYBE_EXPAND_METHOD_KW] = "_MAYBE_EXPAND_METHOD_KW", [_NOP] = "_NOP", [_POP_EXCEPT] = "_POP_EXCEPT", [_POP_TOP] = "_POP_TOP", @@ -992,6 +994,8 @@ int _PyUop_num_popped(int opcode, int oparg) return 2 + oparg; case _CALL_METHOD_DESCRIPTOR_FAST: return 2 + oparg; + case _MAYBE_EXPAND_METHOD_KW: + return 3 + oparg; case _PY_FRAME_KW: return 3 + oparg; case _CHECK_FUNCTION_VERSION_KW: diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 80ddfbca61972f..4d9f45b9204b07 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -149,7 +149,7 @@ dummy_func( op(_CHECK_PERIODIC, (--)) { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { int err = _Py_HandlePending(tstate); ERROR_IF(err != 0, error); @@ -261,6 +261,7 @@ dummy_func( replicate(8) inst(STORE_FAST, (value --)) { SETLOCAL(oparg, value); + KILL(value); } pseudo(STORE_FAST_MAYBE_NULL, (unused --)) = { @@ -271,6 +272,7 @@ dummy_func( uint32_t oparg1 = oparg >> 4; uint32_t oparg2 = oparg & 15; SETLOCAL(oparg1, value1); + KILL(value1); value2 = PyStackRef_DUP(GETLOCAL(oparg2)); } @@ -278,7 +280,9 @@ dummy_func( uint32_t oparg1 = oparg >> 4; uint32_t oparg2 = oparg & 15; SETLOCAL(oparg1, value1); + KILL(value1); SETLOCAL(oparg2, value2); + KILL(value2); } pure inst(POP_TOP, (value --)) { @@ -294,7 +298,6 @@ dummy_func( tier1 inst(INSTRUMENTED_END_FOR, (receiver, value -- receiver)) { /* Need to create a fake StopIteration error here, * to conform to PEP 380 */ - SYNC_SP(); if (PyStackRef_GenCheck(receiver)) { int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); ERROR_IF(err, error); @@ -310,7 +313,6 @@ dummy_func( } tier1 inst(INSTRUMENTED_END_SEND, (receiver, value -- val)) { - SYNC_SP(); PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver); if (PyGen_Check(receiver_o) || PyCoro_CheckExact(receiver_o)) { int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); @@ -332,6 +334,7 @@ dummy_func( assert(PyStackRef_BoolCheck(value)); res = PyStackRef_Is(value, PyStackRef_False) ? PyStackRef_True : PyStackRef_False; + KILL(value); } family(TO_BOOL, INLINE_CACHE_ENTRIES_TO_BOOL) = { @@ -375,6 +378,7 @@ dummy_func( STAT_INC(TO_BOOL, hit); if (_PyLong_IsZero((PyLongObject *)value_o)) { assert(_Py_IsImmortalLoose(value_o)); + KILL(value); res = PyStackRef_False; } else { @@ -394,6 +398,7 @@ dummy_func( inst(TO_BOOL_NONE, (unused/1, unused/2, value -- res)) { // This one is a bit weird, because we expect *some* failures: EXIT_IF(!PyStackRef_Is(value, PyStackRef_None)); + KILL(value); STAT_INC(TO_BOOL, hit); res = PyStackRef_False; } @@ -404,6 +409,7 @@ dummy_func( STAT_INC(TO_BOOL, hit); if (value_o == &_Py_STR(empty)) { assert(_Py_IsImmortalLoose(value_o)); + KILL(value); res = PyStackRef_False; } else { @@ -627,10 +633,12 @@ dummy_func( */ assert(Py_REFCNT(left_o) >= 2); _Py_DECREF_NO_DEALLOC(left_o); + KILL(left); PyObject *temp = PyStackRef_AsPyObjectBorrow(*target_local); PyUnicode_Append(&temp, right_o); *target_local = PyStackRef_FromPyObjectSteal(temp); _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); + KILL(right); ERROR_IF(PyStackRef_IsNull(*target_local), error); #if TIER_ONE // The STORE_FAST is already done. This is done here in tier one, @@ -686,8 +694,6 @@ dummy_func( op(_BINARY_SLICE, (container, start, stop -- res)) { PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); - KILL(start); - KILL(stop); PyObject *res_o; // Can't use ERROR_IF() here, because we haven't // DECREF'ed container yet, and we still own slice. @@ -829,7 +835,6 @@ dummy_func( PyHeapTypeObject *ht = (PyHeapTypeObject *)tp; PyObject *getitem = ht->_spec_cache.getitem; new_frame = _PyFrame_PushUnchecked(tstate, (PyFunctionObject *)getitem, 2, frame); - SYNC_SP(); new_frame->localsplus[0] = container; new_frame->localsplus[1] = sub; KILL_INPUTS(); @@ -844,8 +849,9 @@ dummy_func( _PUSH_FRAME; inst(LIST_APPEND, (list, unused[oparg-1], v -- list, unused[oparg-1])) { - ERROR_IF(_PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list), - PyStackRef_AsPyObjectSteal(v)) < 0, error); + int err = _PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list), + PyStackRef_AsPyObjectSteal(v)); + ERROR_IF(err < 0, error); } inst(SET_ADD, (set, unused[oparg-1], v -- set, unused[oparg-1])) { @@ -900,6 +906,7 @@ dummy_func( assert(old_value != NULL); Py_DECREF(old_value); _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); + KILL(sub_st); PyStackRef_CLOSE(list_st); } @@ -972,18 +979,18 @@ dummy_func( #if TIER_ONE assert(frame != &entry_frame); #endif - SYNC_SP(); - _PyFrame_SetStackPointer(frame, stack_pointer); + _PyStackRef temp = retval; + KILL(retval); + SAVE_STACK(); assert(EMPTY()); _Py_LeaveRecursiveCallPy(tstate); // GH-99729: We need to unlink the frame *before* clearing it: _PyInterpreterFrame *dying = frame; frame = tstate->current_frame = dying->previous; _PyEval_FrameClearAndPop(tstate, dying); - LOAD_SP(); + RELOAD_STACK(); LOAD_IP(frame->return_offset); - res = retval; - KILL(retval); + res = temp; LLTRACE_RESUME_FRAME(); } @@ -1132,6 +1139,7 @@ dummy_func( STAT_INC(SEND, hit); gen_frame = &gen->gi_iframe; _PyFrame_StackPush(gen_frame, v); + KILL(v); gen->gi_frame_state = FRAME_EXECUTING; gen->gi_exc_state.previous_item = tstate->exc_info; tstate->exc_info = &gen->gi_exc_state; @@ -1158,8 +1166,9 @@ dummy_func( assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; - SYNC_SP(); - _PyFrame_SetStackPointer(frame, stack_pointer); + _PyStackRef temp = retval; + KILL(retval); + SAVE_STACK(); tstate->exc_info = gen->gi_exc_state.previous_item; gen->gi_exc_state.previous_item = NULL; _Py_LeaveRecursiveCallPy(tstate); @@ -1176,10 +1185,9 @@ dummy_func( _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT || _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR); #endif + RELOAD_STACK(); LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND); - LOAD_SP(); - value = retval; - KILL(retval); + value = temp; LLTRACE_RESUME_FRAME(); } @@ -1208,7 +1216,7 @@ dummy_func( } tier1 inst(RERAISE, (values[oparg], exc_st -- values[oparg])) { - PyObject *exc = PyStackRef_AsPyObjectBorrow(exc_st); + PyObject *exc = PyStackRef_AsPyObjectSteal(exc_st); assert(oparg >= 0 && oparg <= 2); if (oparg) { @@ -1219,11 +1227,11 @@ dummy_func( } else { _PyErr_SetString(tstate, PyExc_SystemError, "lasti is not an int"); + Py_DECREF(exc); ERROR_NO_POP(); } } assert(exc && PyExceptionInstance_Check(exc)); - Py_INCREF(exc); _PyErr_SetRaisedException(tstate, exc); monitor_reraise(tstate, frame, this_instr); goto exception_unwind; @@ -1758,7 +1766,6 @@ dummy_func( } PyStackRef_CLOSE(values[i]); } - KILL(values); if (err != 0) { Py_DECREF(set_o); ERROR_IF(true, error); @@ -1956,6 +1963,7 @@ dummy_func( } if (method_found) { self_or_null = self_st; // transfer ownership + KILL(self_st); } else { PyStackRef_CLOSE(self_st); self_or_null = PyStackRef_NULL; @@ -2192,6 +2200,7 @@ dummy_func( Py_INCREF(fget); new_frame = _PyFrame_PushUnchecked(tstate, f, 1, frame); new_frame->localsplus[0] = owner; + KILL(owner); } macro(LOAD_ATTR_PROPERTY) = @@ -2226,6 +2235,7 @@ dummy_func( // Manipulate stack directly because we exit with DISPATCH_INLINED(). STACK_SHRINK(1); new_frame->localsplus[0] = owner; + KILL(owner); new_frame->localsplus[1] = PyStackRef_FromPyObjectNew(name); frame->return_offset = (uint16_t)(next_instr - this_instr); DISPATCH_INLINED(new_frame); @@ -2627,6 +2637,7 @@ dummy_func( replaced op(_POP_JUMP_IF_FALSE, (cond -- )) { assert(PyStackRef_BoolCheck(cond)); int flag = PyStackRef_Is(cond, PyStackRef_False); + KILL(cond); #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif @@ -2636,6 +2647,7 @@ dummy_func( replaced op(_POP_JUMP_IF_TRUE, (cond -- )) { assert(PyStackRef_BoolCheck(cond)); int flag = PyStackRef_Is(cond, PyStackRef_True); + KILL(cond); #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif @@ -2645,6 +2657,7 @@ dummy_func( op(_IS_NONE, (value -- b)) { if (PyStackRef_Is(value, PyStackRef_None)) { b = PyStackRef_True; + KILL(value); } else { b = PyStackRef_False; @@ -3107,9 +3120,10 @@ dummy_func( else { prev_exc = PyStackRef_None; } - assert(PyStackRef_ExceptionInstanceCheck(new_exc)); + assert(PyStackRef_ExceptionInstanceCheck(exc)); exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); new_exc = exc; + KILL(exc); } op(_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, (owner -- owner)) { @@ -3132,6 +3146,7 @@ dummy_func( assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); self = owner; + KILL(owner); } macro(LOAD_ATTR_METHOD_WITH_VALUES) = @@ -3149,6 +3164,7 @@ dummy_func( assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); self = owner; + KILL(owner); } macro(LOAD_ATTR_METHOD_NO_DICT) = @@ -3201,6 +3217,7 @@ dummy_func( assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); self = owner; + KILL(owner); } macro(LOAD_ATTR_METHOD_LAZY_DICT) = @@ -3295,8 +3312,6 @@ dummy_func( frame->return_offset = (uint16_t)(next_instr - this_instr); DISPATCH_INLINED(new_frame); } - SAVE_STACK(); - KILL(self_or_null); /* Callable is not a normal Python function */ STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { @@ -3370,7 +3385,6 @@ dummy_func( args--; total_args++; } - SAVE_STACK(); 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)); @@ -3380,8 +3394,8 @@ dummy_func( ); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. - SYNC_SP(); KILL_INPUTS(); + SYNC_SP(); if (new_frame == NULL) { ERROR_NO_POP(); } @@ -3529,11 +3543,13 @@ dummy_func( // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); + _PyInterpreterFrame *temp = new_frame; + KILL(new_frame); SYNC_SP(); _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); - frame = tstate->current_frame = new_frame; + frame = tstate->current_frame = temp; tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); @@ -3583,11 +3599,11 @@ dummy_func( assert(oparg == 1); DEOPT_IF(!PyStackRef_IsNull(null)); - KILL(null); DEOPT_IF(callable_o != (PyObject *)&PyUnicode_Type); - KILL(callable); STAT_INC(CALL, hit); res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o)); + KILL(null); + KILL(callable); PyStackRef_CLOSE(arg); ERROR_IF(PyStackRef_IsNull(res), error); } @@ -3604,11 +3620,11 @@ dummy_func( assert(oparg == 1); DEOPT_IF(!PyStackRef_IsNull(null)); - KILL(null); DEOPT_IF(callable_o != (PyObject *)&PyTuple_Type); - KILL(callable); STAT_INC(CALL, hit); res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o)); + KILL(null); + KILL(callable); PyStackRef_CLOSE(arg); ERROR_IF(PyStackRef_IsNull(res), error); } @@ -3678,6 +3694,7 @@ dummy_func( Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name); ERROR_NO_POP(); } + KILL(should_be_none); } op(_CALL_BUILTIN_CLASS, (callable, self_or_null[1], args[oparg] -- res)) { @@ -3688,7 +3705,6 @@ dummy_func( args--; total_args++; } - SAVE_STACK(); KILL(self_or_null); DEOPT_IF(!PyType_Check(callable_o)); PyTypeObject *tp = (PyTypeObject *)callable_o; @@ -3759,7 +3775,6 @@ dummy_func( args--; total_args++; } - SAVE_STACK(); KILL(self_or_null); DEOPT_IF(!PyCFunction_CheckExact(callable_o)); DEOPT_IF(PyCFunction_GET_FLAGS(callable_o) != METH_FASTCALL); @@ -4100,6 +4115,23 @@ dummy_func( GO_TO_INSTRUCTION(CALL_KW); } + op(_MAYBE_EXPAND_METHOD_KW, (callable, self_or_null[1], args[oparg], kwnames_in -- func, maybe_self[1], args[oparg], kwnames_out)) { + if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *self = ((PyMethodObject *)callable_o)->im_self; + maybe_self[0] = PyStackRef_FromPyObjectNew(self); + PyObject *method = ((PyMethodObject *)callable_o)->im_func; + func = PyStackRef_FromPyObjectNew(method); + PyStackRef_CLOSE(callable); + } + else { + func = callable; + KILL(callable); + } + kwnames_out = kwnames_in; + KILL(kwnames_in); + } + op(_DO_CALL_KW, (callable, self_or_null[1], args[oparg], kwnames -- res)) { PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); @@ -4110,17 +4142,6 @@ dummy_func( args--; total_args++; } - else if (Py_TYPE(callable_o) == &PyMethod_Type) { - args--; - total_args++; - PyObject *self = ((PyMethodObject *)callable_o)->im_self; - args[0] = PyStackRef_FromPyObjectNew(self); - PyObject *method = ((PyMethodObject *)callable_o)->im_func; - PyStackRef temp = callable; - callable = PyStackRef_FromPyObjectNew(method); - PyStackRef_CLOSE(temp); - callable_o = method; - } int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); // Check if the call can be inlined or not if (Py_TYPE(callable_o) == &PyFunction_Type && @@ -4271,6 +4292,7 @@ dummy_func( macro(CALL_KW) = _SPECIALIZE_CALL_KW + unused/2 + + _MAYBE_EXPAND_METHOD_KW + _DO_CALL_KW; op(_CHECK_IS_NOT_PY_CALLABLE_KW, (callable, unused[1], unused[oparg], kwnames -- callable, unused[1], unused[oparg], kwnames)) { @@ -4328,8 +4350,7 @@ dummy_func( inst(_DO_CALL_FUNCTION_EX, (func_st, unused, callargs_st, kwargs_st if (oparg & 1) -- result)) { PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); PyObject *callargs = PyStackRef_AsPyObjectBorrow(callargs_st); - PyObject *kwargs = PyStackRef_AsPyObjectBorrow(kwargs_st); - PyObject *result_o; + PyObject *kwargs = PyStackRef_AsPyObjectSteal(kwargs_st); // DICT_MERGE is called before this opcode if there are kwargs. // It converts all dict subtypes in kwargs into regular dicts. @@ -4343,14 +4364,15 @@ dummy_func( if (tuple == NULL) { ERROR_NO_POP(); } - PyStackRef temp; - temp = callargs_st; - callargs_st = PyStackRef_FromPyObjectSteal(tuple); - PyStackRef_CLOSE(temp); + PyStackRef_CLOSE(callargs_st); callargs = tuple; } + else { + callargs = PyStackRef_AsPyObjectSteal(callargs_st); + } assert(PyTuple_CheckExact(callargs)); EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_FUNCTION_EX, func); + PyObject *result_o; if (opcode == INSTRUMENTED_CALL_FUNCTION_EX) { PyObject *arg = PyTuple_GET_SIZE(callargs) > 0 ? PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING; @@ -4360,7 +4382,7 @@ dummy_func( if (err) { ERROR_NO_POP(); } - PyObject *result_o = PyObject_Call(func, callargs, kwargs); + result_o = PyObject_Call(func, callargs, kwargs); if (!PyFunction_Check(func) && !PyMethod_Check(func)) { if (PyStackRef_IsNull(result)) { @@ -4373,7 +4395,7 @@ dummy_func( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, func, arg); if (err < 0) { - PyStackRef_CLEAR(result); + Py_CLEAR(result_o); } } } @@ -4392,6 +4414,7 @@ dummy_func( (PyFunctionObject *)PyStackRef_AsPyObjectSteal(func_st), locals, nargs, callargs, kwargs, frame); // Need to sync the stack since we exit with DISPATCH_INLINED. + KILL_INPUTS(); SYNC_SP(); if (new_frame == NULL) { ERROR_NO_POP(); @@ -4402,7 +4425,9 @@ dummy_func( } result_o = PyObject_Call(func, callargs, kwargs); } - DECREF_INPUTS(); + Py_DECREF(callargs); + PyStackRef_CLOSE(func_st); + Py_XDECREF(kwargs); result = PyStackRef_FromPyObjectSteal(result_o); ERROR_IF(PyStackRef_IsNull(result), error); } @@ -4428,8 +4453,9 @@ dummy_func( inst(SET_FUNCTION_ATTRIBUTE, (attr_st, func_in -- func_out)) { PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); - PyObject *attr = PyStackRef_AsPyObjectBorrow(attr_st); + PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st); func_out = func_in; + KILL(func_in); assert(PyFunction_Check(func)); size_t offset = _Py_FunctionAttributeOffsets[oparg]; assert(offset != 0); @@ -4540,7 +4566,9 @@ dummy_func( pure inst(SWAP, (bottom_in, unused[oparg-2], top_in -- top_out, unused[oparg-2], bottom_out)) { bottom_out = bottom_in; + KILL(bottom_in); top_out = top_in; + KILL(top_in); assert(oparg >= 2); } @@ -4675,28 +4703,29 @@ dummy_func( ///////// Tier-2 only opcodes ///////// op (_GUARD_IS_TRUE_POP, (flag -- )) { - SYNC_SP(); - EXIT_IF(!PyStackRef_Is(flag, PyStackRef_True)); - assert(PyStackRef_Is(flag, PyStackRef_True)); + int is_true = PyStackRef_Is(flag, PyStackRef_True); + KILL(flag); + EXIT_IF(!is_true); } op (_GUARD_IS_FALSE_POP, (flag -- )) { - SYNC_SP(); - EXIT_IF(!PyStackRef_Is(flag, PyStackRef_False)); - assert(PyStackRef_Is(flag, PyStackRef_False)); + int is_false = PyStackRef_Is(flag, PyStackRef_False); + KILL(flag); + EXIT_IF(!is_false); } op (_GUARD_IS_NONE_POP, (val -- )) { - SYNC_SP(); - if (!PyStackRef_Is(val, PyStackRef_None)) { + int is_none = PyStackRef_Is(val, PyStackRef_None); + if (!is_none) { PyStackRef_CLOSE(val); EXIT_IF(1); } + KILL(val); } op (_GUARD_IS_NOT_NONE_POP, (val -- )) { - SYNC_SP(); - EXIT_IF(PyStackRef_Is(val, PyStackRef_None)); + int is_none = PyStackRef_Is(val, PyStackRef_None); + EXIT_IF(is_none); PyStackRef_CLOSE(val); } @@ -4809,6 +4838,7 @@ dummy_func( op(_INTERNAL_INCREMENT_OPT_COUNTER, (opt --)) { _PyCounterOptimizerObject *exe = (_PyCounterOptimizerObject *)PyStackRef_AsPyObjectBorrow(opt); exe->count++; + KILL(opt); } tier2 op(_DYNAMIC_EXIT, (exit_p/4 --)) { diff --git a/Python/ceval.c b/Python/ceval.c index d9ede2816fc02f..675b7083646a9a 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -246,6 +246,7 @@ maybe_lltrace_resume_frame(_PyInterpreterFrame *frame, _PyInterpreterFrame *skip lltrace = *python_lltrace - '0'; // TODO: Parse an int and all that } } + lltrace = 5; if (lltrace >= 5) { lltrace_resume_frame(frame); } diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 494828714f9ee1..0b10c2f1b2eca0 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -9,18 +9,19 @@ #define TIER_TWO 2 case _NOP: { + /* Pushed outputs */ break; } case _CHECK_PERIODIC: { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) JUMP_TO_ERROR(); - } + }/* Pushed outputs */ break; } @@ -35,7 +36,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) JUMP_TO_ERROR(); } - } + }/* Pushed outputs */ break; } @@ -56,6 +57,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -74,7 +76,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (1) JUMP_TO_ERROR(); } - value = PyStackRef_DUP(value_s); + value = PyStackRef_DUP(value_s);/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -86,7 +88,7 @@ oparg = 0; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -98,7 +100,7 @@ oparg = 1; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -110,7 +112,7 @@ oparg = 2; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -122,7 +124,7 @@ oparg = 3; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -134,7 +136,7 @@ oparg = 4; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -146,7 +148,7 @@ oparg = 5; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -158,7 +160,7 @@ oparg = 6; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -170,7 +172,7 @@ oparg = 7; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -181,7 +183,7 @@ _PyStackRef value; oparg = CURRENT_OPARG(); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -193,7 +195,7 @@ oparg = CURRENT_OPARG(); value = GETLOCAL(oparg); // do not use SETLOCAL here, it decrefs the old value - GETLOCAL(oparg) = PyStackRef_NULL; + GETLOCAL(oparg) = PyStackRef_NULL;/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -203,7 +205,7 @@ case _LOAD_CONST: { _PyStackRef value; oparg = CURRENT_OPARG(); - value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg)); + value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg));/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -215,7 +217,7 @@ oparg = 0; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value); + SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -226,7 +228,7 @@ oparg = 1; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value); + SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -237,7 +239,7 @@ oparg = 2; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value); + SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -248,7 +250,7 @@ oparg = 3; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value); + SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -259,7 +261,7 @@ oparg = 4; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value); + SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -270,7 +272,7 @@ oparg = 5; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value); + SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -281,7 +283,7 @@ oparg = 6; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value); + SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -292,7 +294,7 @@ oparg = 7; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value); + SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -302,7 +304,7 @@ _PyStackRef value; oparg = CURRENT_OPARG(); value = stack_pointer[-1]; - SETLOCAL(oparg, value); + SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -312,6 +314,7 @@ _PyStackRef value; value = stack_pointer[-1]; PyStackRef_CLOSE(value); + /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -319,7 +322,7 @@ case _PUSH_NULL: { _PyStackRef res; - res = PyStackRef_NULL; + res = PyStackRef_NULL;/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -329,11 +332,13 @@ case _END_SEND: { _PyStackRef value; _PyStackRef receiver; + _PyStackRef val; value = stack_pointer[-1]; receiver = stack_pointer[-2]; (void)receiver; - PyStackRef_CLOSE(receiver); - stack_pointer[-2] = value; + val = value;(void)value ; + PyStackRef_CLOSE(receiver);/* Pushed outputs */ + stack_pointer[-2] = val; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -343,14 +348,14 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -363,7 +368,7 @@ value = stack_pointer[-1]; assert(PyStackRef_BoolCheck(value)); res = PyStackRef_Is(value, PyStackRef_False) - ? PyStackRef_True : PyStackRef_False; + ? PyStackRef_True : PyStackRef_False;(void)value ;/* Pushed outputs */ stack_pointer[-1] = res; break; } @@ -372,14 +377,14 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (err < 0) JUMP_TO_ERROR(); - res = err ? PyStackRef_True : PyStackRef_False; + res = err ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -393,7 +398,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - STAT_INC(TO_BOOL, hit); + STAT_INC(TO_BOOL, hit);/* Pushed outputs */ break; } @@ -408,13 +413,16 @@ } STAT_INC(TO_BOOL, hit); if (_PyLong_IsZero((PyLongObject *)value_o)) { + _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); + stack_pointer = _PyFrame_GetStackPointer(frame); + (void)value ; res = PyStackRef_False; } else { PyStackRef_CLOSE(value); res = PyStackRef_True; - } + }/* Pushed outputs */ stack_pointer[-1] = res; break; } @@ -431,6 +439,7 @@ STAT_INC(TO_BOOL, hit); res = Py_SIZE(value_o) ? PyStackRef_True : PyStackRef_False; PyStackRef_CLOSE(value); + /* Pushed outputs */ stack_pointer[-1] = res; break; } @@ -444,8 +453,9 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + (void)value ; STAT_INC(TO_BOOL, hit); - res = PyStackRef_False; + res = PyStackRef_False;/* Pushed outputs */ stack_pointer[-1] = res; break; } @@ -461,14 +471,17 @@ } STAT_INC(TO_BOOL, hit); if (value_o == &_Py_STR(empty)) { + _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); + stack_pointer = _PyFrame_GetStackPointer(frame); + (void)value ; res = PyStackRef_False; } else { assert(Py_SIZE(value_o)); PyStackRef_CLOSE(value); res = PyStackRef_True; - } + }/* Pushed outputs */ stack_pointer[-1] = res; break; } @@ -478,7 +491,7 @@ _PyStackRef res; value = stack_pointer[-1]; PyStackRef_CLOSE(value); - res = PyStackRef_True; + res = PyStackRef_True;/* Pushed outputs */ stack_pointer[-1] = res; break; } @@ -487,14 +500,14 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -516,6 +529,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -527,6 +541,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -538,6 +553,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -556,7 +572,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -578,7 +594,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -596,11 +612,11 @@ STAT_INC(BINARY_OP, hit); PyObject *res_o = _PyLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); - _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);; + _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -622,6 +638,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -633,6 +650,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -644,6 +662,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -661,7 +680,7 @@ ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -682,7 +701,7 @@ ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -703,7 +722,7 @@ ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -725,6 +744,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -743,7 +763,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -782,11 +802,11 @@ * that the string is safe to mutate. */ assert(Py_REFCNT(left_o) >= 2); - _Py_DECREF_NO_DEALLOC(left_o); + _Py_DECREF_NO_DEALLOC(left_o);(void)left ; PyObject *temp = PyStackRef_AsPyObjectBorrow(*target_local); PyUnicode_Append(&temp, right_o); *target_local = PyStackRef_FromPyObjectSteal(temp); - _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); + _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);(void)right ; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(*target_local)) JUMP_TO_ERROR(); @@ -795,7 +815,7 @@ // and during trace projection in tier two: assert(next_instr->op.code == STORE_FAST); SKIP_OVER(1); - #endif + #endif/* Pushed outputs */ break; } @@ -807,15 +827,15 @@ container = stack_pointer[-2]; PyObject *container_o = PyStackRef_AsPyObjectBorrow(container); PyObject *sub_o = PyStackRef_AsPyObjectBorrow(sub); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_GetItem(container_o, sub_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -830,8 +850,6 @@ stop = stack_pointer[-1]; start = stack_pointer[-2]; container = stack_pointer[-3]; - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); @@ -843,14 +861,19 @@ res_o = NULL; } else { + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); res_o = PyObject_GetItem(PyStackRef_AsPyObjectBorrow(container), slice); stack_pointer = _PyFrame_GetStackPointer(frame); - Py_DECREF(slice); + Py_DECREF(slice);stack_pointer += 2; + assert(WITHIN_STACK_BOUNDS()); } PyStackRef_CLOSE(container); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -866,29 +889,29 @@ start = stack_pointer[-2]; container = stack_pointer[-3]; v = stack_pointer[-4]; - stack_pointer += -4; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); -<<<<<<< HEAD stack_pointer = _PyFrame_GetStackPointer(frame); - OPCODE_DEFERRED_INC(STORE_SLICE); -======= ->>>>>>> main int err; if (slice == NULL) { err = 1; } else { + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), slice, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); - Py_DECREF(slice); + Py_DECREF(slice);stack_pointer += 2; + assert(WITHIN_STACK_BOUNDS()); } PyStackRef_CLOSE(v); PyStackRef_CLOSE(container); + stack_pointer += -4; + assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); + /* Pushed outputs */ break; } @@ -922,9 +945,9 @@ PyObject *res_o = PyList_GET_ITEM(list, index); assert(res_o != NULL); Py_INCREF(res_o); - _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); + _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; PyStackRef_CLOSE(list_st); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -964,9 +987,9 @@ } STAT_INC(BINARY_SUBSCR, hit); PyObject *res_o = (PyObject*)&_Py_SINGLETON(strings).ascii[c]; - _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); + _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; PyStackRef_CLOSE(str_st); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1003,9 +1026,9 @@ PyObject *res_o = PyTuple_GET_ITEM(tuple, index); assert(res_o != NULL); Py_INCREF(res_o); - _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); + _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; PyStackRef_CLOSE(tuple_st); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1026,8 +1049,6 @@ } STAT_INC(BINARY_SUBSCR, hit); PyObject *res_o; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int rc = PyDict_GetItemRef(dict, sub, &res_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1038,9 +1059,11 @@ } PyStackRef_CLOSE(dict_st); PyStackRef_CLOSE(sub_st); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (rc <= 0) JUMP_TO_ERROR(); // not found or error - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ break; } @@ -1071,7 +1094,7 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(BINARY_SUBSCR, hit); - Py_INCREF(getitem); + Py_INCREF(getitem);/* Pushed outputs */ break; } @@ -1085,13 +1108,11 @@ PyHeapTypeObject *ht = (PyHeapTypeObject *)tp; PyObject *getitem = ht->_spec_cache.getitem; new_frame = _PyFrame_PushUnchecked(tstate, (PyFunctionObject *)getitem, 2, frame); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); new_frame->localsplus[0] = container; new_frame->localsplus[1] = sub; - frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_BINARY_SUBSCR); - stack_pointer[0].bits = (uintptr_t)new_frame; - stack_pointer += 1; + frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_BINARY_SUBSCR);/* Pushed outputs */ + stack_pointer[-2].bits = (uintptr_t)new_frame; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1102,10 +1123,12 @@ oparg = CURRENT_OPARG(); v = stack_pointer[-1]; list = stack_pointer[-2 - (oparg-1)]; + int err = _PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list), + PyStackRef_AsPyObjectSteal(v)); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - if (_PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list), - PyStackRef_AsPyObjectSteal(v)) < 0) JUMP_TO_ERROR(); + if (err < 0) JUMP_TO_ERROR(); + /* Pushed outputs */ break; } @@ -1115,14 +1138,15 @@ oparg = CURRENT_OPARG(); v = stack_pointer[-1]; set = stack_pointer[-2 - (oparg-1)]; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PySet_Add(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); + /* Pushed outputs */ break; } @@ -1134,15 +1158,16 @@ container = stack_pointer[-2]; v = stack_pointer[-3]; /* container[sub] = v */ - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); + /* Pushed outputs */ break; } @@ -1179,8 +1204,8 @@ PyList_SET_ITEM(list, index, PyStackRef_AsPyObjectSteal(value)); assert(old_value != NULL); Py_DECREF(old_value); - _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); - PyStackRef_CLOSE(list_st); + _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; + PyStackRef_CLOSE(list_st);/* Pushed outputs */ stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); break; @@ -1199,15 +1224,16 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(STORE_SUBSCR, hit); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_SetItem_Take2((PyDictObject *)dict, PyStackRef_AsPyObjectSteal(sub), PyStackRef_AsPyObjectSteal(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(dict_st); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); + /* Pushed outputs */ break; } @@ -1217,15 +1243,16 @@ sub = stack_pointer[-1]; container = stack_pointer[-2]; /* del container[sub] */ - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); + /* Pushed outputs */ break; } @@ -1240,7 +1267,7 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1263,7 +1290,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1277,6 +1304,7 @@ #if TIER_ONE assert(frame != &entry_frame); #endif + _PyStackRef temp = retval;(void)retval ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -1286,10 +1314,10 @@ _PyInterpreterFrame *dying = frame; frame = tstate->current_frame = dying->previous; _PyEval_FrameClearAndPop(tstate, dying); - LOAD_SP(); + stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(frame->return_offset); - res = retval; - LLTRACE_RESUME_FRAME(); + res = temp; + LLTRACE_RESUME_FRAME();/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1308,8 +1336,6 @@ getter = type->tp_as_async->am_aiter; } if (getter == NULL) { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'async for' requires an object with " @@ -1317,6 +1343,8 @@ type->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(obj); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } iter_o = (*getter)(obj_o); @@ -1335,9 +1363,7 @@ Py_DECREF(iter_o); if (true) JUMP_TO_ERROR(); } - iter = PyStackRef_FromPyObjectSteal(iter_o); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + iter = PyStackRef_FromPyObjectSteal(iter_o);/* Pushed outputs */ break; } @@ -1351,7 +1377,7 @@ if (awaitable_o == NULL) { JUMP_TO_ERROR(); } - awaitable = PyStackRef_FromPyObjectSteal(awaitable_o); + awaitable = PyStackRef_FromPyObjectSteal(awaitable_o);/* Pushed outputs */ stack_pointer[0] = awaitable; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1363,14 +1389,14 @@ _PyStackRef iter; oparg = CURRENT_OPARG(); iterable = stack_pointer[-1]; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (iter_o == NULL) JUMP_TO_ERROR(); - iter = PyStackRef_FromPyObjectSteal(iter_o); + iter = PyStackRef_FromPyObjectSteal(iter_o);/* Pushed outputs */ stack_pointer[0] = iter; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1397,13 +1423,13 @@ } STAT_INC(SEND, hit); gen_frame = &gen->gi_iframe; - _PyFrame_StackPush(gen_frame, v); + _PyFrame_StackPush(gen_frame, v);(void)v ; gen->gi_frame_state = FRAME_EXECUTING; gen->gi_exc_state.previous_item = tstate->exc_info; tstate->exc_info = &gen->gi_exc_state; assert(1 + INLINE_CACHE_ENTRIES_SEND + oparg <= UINT16_MAX); frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_SEND + oparg); - gen_frame->previous = frame; + gen_frame->previous = frame;/* Pushed outputs */ stack_pointer[-1].bits = (uintptr_t)gen_frame; break; } @@ -1420,14 +1446,15 @@ assert(frame != &entry_frame); #endif frame->instr_ptr++; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); stack_pointer = _PyFrame_GetStackPointer(frame); assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; + _PyStackRef temp = retval;(void)retval ; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); tstate->exc_info = gen->gi_exc_state.previous_item; gen->gi_exc_state.previous_item = NULL; @@ -1445,10 +1472,10 @@ _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT || _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR); #endif + stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND); - LOAD_SP(); - value = retval; - LLTRACE_RESUME_FRAME(); + value = temp; + LLTRACE_RESUME_FRAME();/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1459,13 +1486,14 @@ _PyStackRef exc_value; exc_value = stack_pointer[-1]; _PyErr_StackItem *exc_info = tstate->exc_info; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); Py_XSETREF(exc_info->exc_value, PyStackRef_Is(exc_value, PyStackRef_None) ? NULL : PyStackRef_AsPyObjectSteal(exc_value)); stack_pointer = _PyFrame_GetStackPointer(frame); + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1484,7 +1512,7 @@ default: Py_FatalError("bad LOAD_COMMON_CONSTANT oparg"); } - value = PyStackRef_FromPyObjectImmortal(val); + value = PyStackRef_FromPyObjectImmortal(val);/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1505,7 +1533,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (true) JUMP_TO_ERROR(); } - bc = PyStackRef_FromPyObjectSteal(bc_o); + bc = PyStackRef_FromPyObjectSteal(bc_o);/* Pushed outputs */ stack_pointer[0] = bc; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1520,31 +1548,30 @@ PyObject *ns = LOCALS(); int err; if (ns == NULL) { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when storing %R", name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } if (PyDict_CheckExact(ns)) { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); } else { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(v); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); + /* Pushed outputs */ break; } @@ -1571,7 +1598,7 @@ name); stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); - } + }/* Pushed outputs */ break; } @@ -1579,16 +1606,17 @@ _PyStackRef seq; _PyStackRef *output; oparg = CURRENT_OPARG(); + output = &stack_pointer[0]; seq = stack_pointer[-1]; - output = &stack_pointer[-1]; _PyStackRef *top = output + oparg; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(seq); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (res == 0) JUMP_TO_ERROR(); + /* Pushed outputs */ stack_pointer += oparg; assert(WITHIN_STACK_BOUNDS()); break; @@ -1614,6 +1642,7 @@ val0 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 0)); val1 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 1)); PyStackRef_CLOSE(seq); + /* Pushed outputs */ stack_pointer[-1] = val1; stack_pointer[0] = val0; stack_pointer += 1; @@ -1625,8 +1654,8 @@ _PyStackRef seq; _PyStackRef *values; oparg = CURRENT_OPARG(); + values = &stack_pointer[0]; seq = stack_pointer[-1]; - values = &stack_pointer[-1]; PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq); if (!PyTuple_CheckExact(seq_o)) { UOP_STAT_INC(uopcode, miss); @@ -1642,6 +1671,7 @@ *values++ = PyStackRef_FromPyObjectNew(items[i]); } PyStackRef_CLOSE(seq); + /* Pushed outputs */ stack_pointer += -1 + oparg; assert(WITHIN_STACK_BOUNDS()); break; @@ -1651,8 +1681,8 @@ _PyStackRef seq; _PyStackRef *values; oparg = CURRENT_OPARG(); + values = &stack_pointer[0]; seq = stack_pointer[-1]; - values = &stack_pointer[-1]; PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq); if (!PyList_CheckExact(seq_o)) { UOP_STAT_INC(uopcode, miss); @@ -1668,6 +1698,7 @@ *values++ = PyStackRef_FromPyObjectNew(items[i]); } PyStackRef_CLOSE(seq); + /* Pushed outputs */ stack_pointer += -1 + oparg; assert(WITHIN_STACK_BOUNDS()); break; @@ -1677,16 +1708,17 @@ _PyStackRef seq; _PyStackRef *right; oparg = CURRENT_OPARG(); + right = &stack_pointer[1 + (oparg & 0xFF)]; seq = stack_pointer[-1]; - right = &stack_pointer[(oparg & 0xFF)]; _PyStackRef *top = right + (oparg >> 8); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(seq); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (res == 0) JUMP_TO_ERROR(); + /* Pushed outputs */ stack_pointer += 1 + (oparg & 0xFF) + (oparg >> 8); assert(WITHIN_STACK_BOUNDS()); break; @@ -1699,15 +1731,16 @@ owner = stack_pointer[-1]; v = stack_pointer[-2]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner), name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); PyStackRef_CLOSE(owner); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); + /* Pushed outputs */ break; } @@ -1716,13 +1749,14 @@ oparg = CURRENT_OPARG(); owner = stack_pointer[-1]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(owner); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); + /* Pushed outputs */ break; } @@ -1731,13 +1765,14 @@ oparg = CURRENT_OPARG(); v = stack_pointer[-1]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); + /* Pushed outputs */ break; } @@ -1757,7 +1792,7 @@ NAME_ERROR_MSG, name); stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); - } + }/* Pushed outputs */ break; } @@ -1771,7 +1806,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (true) JUMP_TO_ERROR(); } - locals = PyStackRef_FromPyObjectNew(l); + locals = PyStackRef_FromPyObjectNew(l);/* Pushed outputs */ stack_pointer[0] = locals; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1788,7 +1823,7 @@ PyObject *v_o = _PyEval_LoadName(tstate, frame, name); stack_pointer = _PyFrame_GetStackPointer(frame); if (v_o == NULL) JUMP_TO_ERROR(); - v = PyStackRef_FromPyObjectSteal(v_o); + v = PyStackRef_FromPyObjectSteal(v_o);/* Pushed outputs */ stack_pointer[0] = v; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1805,7 +1840,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (res_o == NULL) JUMP_TO_ERROR(); null = PyStackRef_NULL; - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; if (oparg & 1) stack_pointer[1] = null; stack_pointer += 1 + (oparg & 1); @@ -1824,7 +1859,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - assert(DK_IS_UNICODE(dict->ma_keys)); + assert(DK_IS_UNICODE(dict->ma_keys));/* Pushed outputs */ break; } @@ -1839,7 +1874,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - assert(DK_IS_UNICODE(dict->ma_keys)); + assert(DK_IS_UNICODE(dict->ma_keys));/* Pushed outputs */ break; } @@ -1858,7 +1893,7 @@ Py_INCREF(res_o); STAT_INC(LOAD_GLOBAL, hit); null = PyStackRef_NULL; - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; if (oparg & 1) stack_pointer[1] = null; stack_pointer += 1 + (oparg & 1); @@ -1881,7 +1916,7 @@ Py_INCREF(res_o); STAT_INC(LOAD_GLOBAL, hit); null = PyStackRef_NULL; - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; if (oparg & 1) stack_pointer[1] = null; stack_pointer += 1 + (oparg & 1); @@ -1901,7 +1936,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (1) JUMP_TO_ERROR(); } - SETLOCAL(oparg, PyStackRef_NULL); + SETLOCAL(oparg, PyStackRef_NULL);/* Pushed outputs */ break; } @@ -1914,7 +1949,7 @@ if (cell == NULL) { JUMP_TO_ERROR(); } - SETLOCAL(oparg, PyStackRef_FromPyObjectSteal(cell)); + SETLOCAL(oparg, PyStackRef_FromPyObjectSteal(cell));/* Pushed outputs */ break; } @@ -1932,7 +1967,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); } - Py_DECREF(oldobj); + Py_DECREF(oldobj);/* Pushed outputs */ break; } @@ -1947,8 +1982,6 @@ assert(class_dict); assert(oparg >= 0 && oparg < _PyFrame_GetCode(frame)->co_nlocalsplus); name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(class_dict, name, &value_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1966,7 +1999,7 @@ } } PyStackRef_CLOSE(class_dict_st); - value = PyStackRef_FromPyObjectSteal(value_o); + value = PyStackRef_FromPyObjectSteal(value_o);/* Pushed outputs */ break; } @@ -1981,7 +2014,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (true) JUMP_TO_ERROR(); } - value = PyStackRef_FromPyObjectSteal(value_o); + value = PyStackRef_FromPyObjectSteal(value_o);/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1993,11 +2026,12 @@ oparg = CURRENT_OPARG(); v = stack_pointer[-1]; PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v)); stack_pointer = _PyFrame_GetStackPointer(frame); + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -2012,7 +2046,7 @@ for (int i = 0; i < oparg; ++i) { PyObject *o = PyTuple_GET_ITEM(closure, i); frame->localsplus[offset + i] = PyStackRef_FromPyObjectNew(o); - } + }/* Pushed outputs */ break; } @@ -2038,7 +2072,7 @@ stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); if (str_o == NULL) JUMP_TO_ERROR(); - str = PyStackRef_FromPyObjectSteal(str_o); + str = PyStackRef_FromPyObjectSteal(str_o);/* Pushed outputs */ stack_pointer[0] = str; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2054,7 +2088,7 @@ stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); if (tup_o == NULL) JUMP_TO_ERROR(); - tup = PyStackRef_FromPyObjectSteal(tup_o); + tup = PyStackRef_FromPyObjectSteal(tup_o);/* Pushed outputs */ stack_pointer[0] = tup; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2070,7 +2104,7 @@ stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); if (list_o == NULL) JUMP_TO_ERROR(); - list = PyStackRef_FromPyObjectSteal(list_o); + list = PyStackRef_FromPyObjectSteal(list_o);/* Pushed outputs */ stack_pointer[0] = list; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2085,8 +2119,6 @@ list_st = stack_pointer[-2 - (oparg-1)]; PyObject *list = PyStackRef_AsPyObjectBorrow(list_st); PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2105,10 +2137,15 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(iterable_st); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } assert(Py_IsNone(none_val)); PyStackRef_CLOSE(iterable_st); + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -2118,14 +2155,15 @@ oparg = CURRENT_OPARG(); iterable = stack_pointer[-1]; set = stack_pointer[-2 - (oparg-1)]; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(iterable)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (err < 0) JUMP_TO_ERROR(); + /* Pushed outputs */ break; } @@ -2158,7 +2196,7 @@ Py_DECREF(set_o); if (true) JUMP_TO_ERROR(); } - set = PyStackRef_FromPyObjectSteal(set_o); + set = PyStackRef_FromPyObjectSteal(set_o);/* Pushed outputs */ break; } @@ -2189,7 +2227,7 @@ PyStackRef_CLOSE(values[_i]); } if (map_o == NULL) JUMP_TO_ERROR(); - map = PyStackRef_FromPyObjectSteal(map_o); + map = PyStackRef_FromPyObjectSteal(map_o);/* Pushed outputs */ stack_pointer[0] = map; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2224,7 +2262,7 @@ } else { Py_DECREF(ann_dict); - } + }/* Pushed outputs */ break; } @@ -2236,8 +2274,6 @@ dict = stack_pointer[-2 - (oparg - 1)]; PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_Update(dict_o, update_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2253,9 +2289,14 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(update); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyStackRef_CLOSE(update); + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -2270,8 +2311,6 @@ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_MergeEx(dict_o, update_o, 2); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2280,9 +2319,14 @@ _PyEval_FormatKwargsError(tstate, callable_o, update_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(update); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyStackRef_CLOSE(update); + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -2298,8 +2342,6 @@ assert(PyDict_CheckExact(dict)); /* dict[key] = value */ // Do not DECREF INPUTS because the function steals the references - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_SetItem_Take2( (PyDictObject *)dict, @@ -2307,7 +2349,10 @@ PyStackRef_AsPyObjectSteal(value) ); stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (err != 0) JUMP_TO_ERROR(); + /* Pushed outputs */ break; } @@ -2336,16 +2381,16 @@ } STAT_INC(LOAD_SUPER_ATTR, hit); PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); PyStackRef_CLOSE(self_st); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); if (attr == NULL) JUMP_TO_ERROR(); - attr_st = PyStackRef_FromPyObjectSteal(attr); + attr_st = PyStackRef_FromPyObjectSteal(attr);/* Pushed outputs */ stack_pointer[0] = attr_st; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2378,8 +2423,6 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); PyTypeObject *cls = (PyTypeObject *)class; int method_found = 0; - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attr_o = _PySuper_Lookup(cls, self, name, Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? &method_found : NULL); @@ -2388,18 +2431,20 @@ PyStackRef_CLOSE(class_st); if (attr_o == NULL) { PyStackRef_CLOSE(self_st); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } if (method_found) { - self_or_null = self_st; // transfer ownership + self_or_null = self_st; // transfer ownership(void)self_st ; } else { PyStackRef_CLOSE(self_st); self_or_null = PyStackRef_NULL; } - attr = PyStackRef_FromPyObjectSteal(attr_o); - stack_pointer[0] = attr; - stack_pointer[1] = self_or_null; - stack_pointer += 2; + attr = PyStackRef_FromPyObjectSteal(attr_o);/* Pushed outputs */ + stack_pointer[-3] = attr; + stack_pointer[-2] = self_or_null; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -2415,8 +2460,6 @@ if (oparg & 1) { /* Designed to work in tandem with CALL, pushes two values. */ attr_o = NULL; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int is_meth = _PyObject_GetMethod(PyStackRef_AsPyObjectBorrow(owner), name, &attr_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2426,7 +2469,7 @@ meth | self | arg1 | ... | argN */ assert(attr_o != NULL); // No errors on this branch - self_or_null = owner; // Transfer ownership + self_or_null = owner; // Transfer ownership(void)owner ; } else { /* meth is not an unbound method (but a regular attr, or @@ -2436,26 +2479,30 @@ meth | NULL | arg1 | ... | argN */ PyStackRef_CLOSE(owner); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (attr_o == NULL) JUMP_TO_ERROR(); - self_or_null = PyStackRef_NULL; + self_or_null = PyStackRef_NULL;stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); } } else { /* Classic, pushes one value. */ - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(owner); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (attr_o == NULL) JUMP_TO_ERROR(); /* We need to define self_or_null on all paths */ - self_or_null = PyStackRef_NULL; + self_or_null = PyStackRef_NULL;stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); } - attr = PyStackRef_FromPyObjectSteal(attr_o); - stack_pointer[0] = attr; - if (oparg & 1) stack_pointer[1] = self_or_null; - stack_pointer += 1 + (oparg & 1); + attr = PyStackRef_FromPyObjectSteal(attr_o);/* Pushed outputs */ + stack_pointer[-1] = attr; + if (oparg & 1) stack_pointer[0] = self_or_null; + stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); break; } @@ -2470,6 +2517,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -2483,6 +2531,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -2505,6 +2554,7 @@ null = PyStackRef_NULL; attr = PyStackRef_FromPyObjectSteal(attr_o); PyStackRef_CLOSE(owner); + /* Pushed outputs */ stack_pointer[-1] = attr; break; } @@ -2528,6 +2578,7 @@ null = PyStackRef_NULL; attr = PyStackRef_FromPyObjectSteal(attr_o); PyStackRef_CLOSE(owner); + /* Pushed outputs */ stack_pointer[-1] = attr; stack_pointer[0] = null; stack_pointer += 1; @@ -2552,6 +2603,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -2577,6 +2629,7 @@ attr = PyStackRef_FromPyObjectSteal(attr_o); null = PyStackRef_NULL; PyStackRef_CLOSE(owner); + /* Pushed outputs */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); @@ -2594,7 +2647,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - assert(PyDict_CheckExact((PyObject *)dict)); + assert(PyDict_CheckExact((PyObject *)dict));/* Pushed outputs */ break; } @@ -2632,6 +2685,7 @@ attr = PyStackRef_FromPyObjectSteal(attr_o); null = PyStackRef_NULL; PyStackRef_CLOSE(owner); + /* Pushed outputs */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); @@ -2657,6 +2711,7 @@ null = PyStackRef_NULL; attr = PyStackRef_FromPyObjectNew(attr_o); PyStackRef_CLOSE(owner); + /* Pushed outputs */ stack_pointer[-1] = attr; break; } @@ -2679,6 +2734,7 @@ null = PyStackRef_NULL; attr = PyStackRef_FromPyObjectNew(attr_o); PyStackRef_CLOSE(owner); + /* Pushed outputs */ stack_pointer[-1] = attr; stack_pointer[0] = null; stack_pointer += 1; @@ -2702,6 +2758,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -2717,6 +2774,7 @@ attr = PyStackRef_FromPyObjectNew(descr); null = PyStackRef_NULL; PyStackRef_CLOSE(owner); + /* Pushed outputs */ stack_pointer[-1] = attr; break; } @@ -2733,6 +2791,7 @@ attr = PyStackRef_FromPyObjectNew(descr); null = PyStackRef_NULL; PyStackRef_CLOSE(owner); + /* Pushed outputs */ stack_pointer[-1] = attr; stack_pointer[0] = null; stack_pointer += 1; @@ -2771,7 +2830,7 @@ STAT_INC(LOAD_ATTR, hit); Py_INCREF(fget); new_frame = _PyFrame_PushUnchecked(tstate, f, 1, frame); - new_frame->localsplus[0] = owner; + new_frame->localsplus[0] = owner;(void)owner ;/* Pushed outputs */ stack_pointer[-1].bits = (uintptr_t)new_frame; break; } @@ -2792,6 +2851,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -2815,7 +2875,7 @@ else { Py_DECREF(old_value); } - PyStackRef_CLOSE(owner); + PyStackRef_CLOSE(owner);/* Pushed outputs */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); break; @@ -2854,18 +2914,12 @@ } /* Ensure dict is GC tracked if it needs to be */ if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(PyStackRef_AsPyObjectBorrow(value))) { - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyObject_GC_TRACK(dict); stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += 2; - assert(WITHIN_STACK_BOUNDS()); } old_value = ep->me_value; PyDict_WatchEvent event = old_value == NULL ? PyDict_EVENT_ADDED : PyDict_EVENT_MODIFIED; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); new_version = _PyDict_NotifyEvent(tstate->interp, event, dict, name, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2875,9 +2929,7 @@ // when dict only holds the strong reference to value in ep->me_value. Py_XDECREF(old_value); STAT_INC(STORE_ATTR, hit); - PyStackRef_CLOSE(owner); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + PyStackRef_CLOSE(owner);/* Pushed outputs */ break; } @@ -2893,7 +2945,7 @@ PyObject *old_value = *(PyObject **)addr; *(PyObject **)addr = PyStackRef_AsPyObjectSteal(value); Py_XDECREF(old_value); - PyStackRef_CLOSE(owner); + PyStackRef_CLOSE(owner);/* Pushed outputs */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); break; @@ -2909,13 +2961,13 @@ PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); assert((oparg >> 5) <= Py_GE); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); if (oparg & 16) { _PyFrame_SetStackPointer(frame, stack_pointer); @@ -2927,7 +2979,7 @@ } else { res = PyStackRef_FromPyObjectSteal(res_o); - } + }/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2948,10 +3000,10 @@ double dright = PyFloat_AS_DOUBLE(right_o); // 1 if NaN, 2 if <, 4 if >, 8 if ==; this matches low four bits of the oparg int sign_ish = COMPARISON_BIT(dleft, dright); - _Py_DECREF_SPECIALIZED(left_o, _PyFloat_ExactDealloc); - _Py_DECREF_SPECIALIZED(right_o, _PyFloat_ExactDealloc); + _Py_DECREF_SPECIALIZED(left_o, _PyFloat_ExactDealloc);(void)left ; + _Py_DECREF_SPECIALIZED(right_o, _PyFloat_ExactDealloc);(void)right ; res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; - // It's always a bool, so we don't care about oparg & 16. + // It's always a bool, so we don't care about oparg & 16./* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -2982,10 +3034,10 @@ Py_ssize_t iright = _PyLong_CompactValue((PyLongObject *)right_o); // 2 if <, 4 if >, 8 if ==; this matches the low 4 bits of the oparg int sign_ish = COMPARISON_BIT(ileft, iright); - _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); - _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); + _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);(void)left ; + _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free);(void)right ; res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; - // It's always a bool, so we don't care about oparg & 16. + // It's always a bool, so we don't care about oparg & 16./* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -3004,13 +3056,13 @@ STAT_INC(COMPARE_OP, hit); int eq = _PyUnicode_Equal(left_o, right_o); assert((oparg >> 5) == Py_EQ || (oparg >> 5) == Py_NE); - _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc); - _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); + _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc);(void)left ; + _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);(void)right ; assert(eq == 0 || eq == 1); assert((oparg & 0xf) == COMPARISON_NOT_EQUALS || (oparg & 0xf) == COMPARISON_EQUALS); assert(COMPARISON_NOT_EQUALS + 1 == COMPARISON_EQUALS); res = ((COMPARISON_NOT_EQUALS + eq) & oparg) ? PyStackRef_True : PyStackRef_False; - // It's always a bool, so we don't care about oparg & 16. + // It's always a bool, so we don't care about oparg & 16./* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -3033,7 +3085,7 @@ #endif PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - b = res ? PyStackRef_True : PyStackRef_False; + b = res ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ stack_pointer[-2] = b; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -3049,15 +3101,15 @@ left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int res = PySequence_Contains(right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (res < 0) JUMP_TO_ERROR(); - b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; + b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ stack_pointer[0] = b; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3079,15 +3131,15 @@ } STAT_INC(CONTAINS_OP, hit); // Note: both set and frozenset use the same seq_contains method! - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PySet_Contains((PySetObject *)right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (res < 0) JUMP_TO_ERROR(); - b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; + b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ stack_pointer[0] = b; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3108,15 +3160,15 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(CONTAINS_OP, hit); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyDict_Contains(right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (res < 0) JUMP_TO_ERROR(); - b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; + b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ stack_pointer[0] = b; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3132,14 +3184,14 @@ exc_value_st = stack_pointer[-2]; PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st); PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { PyStackRef_CLOSE(exc_value_st); PyStackRef_CLOSE(match_type_st); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyObject *match_o = NULL; @@ -3150,6 +3202,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(exc_value_st); PyStackRef_CLOSE(match_type_st); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (res < 0) JUMP_TO_ERROR(); assert((match_o == NULL) == (rest_o == NULL)); if (match_o == NULL) JUMP_TO_ERROR(); @@ -3159,7 +3213,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } rest = PyStackRef_FromPyObjectSteal(rest_o); - match = PyStackRef_FromPyObjectSteal(match_o); + match = PyStackRef_FromPyObjectSteal(match_o);/* Pushed outputs */ break; } @@ -3172,23 +3226,21 @@ PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); assert(PyExceptionInstance_Check(left_o)); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyEval_CheckExceptTypeValid(tstate, right_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { PyStackRef_CLOSE(right); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyErr_GivenExceptionMatches(left_o, right_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(right); - b = res ? PyStackRef_True : PyStackRef_False; - stack_pointer[0] = b; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + b = res ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + stack_pointer[-1] = b; break; } @@ -3200,8 +3252,6 @@ fromlist = stack_pointer[-1]; level = stack_pointer[-2]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_ImportName(tstate, frame, name, PyStackRef_AsPyObjectBorrow(fromlist), @@ -3209,8 +3259,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(level); PyStackRef_CLOSE(fromlist); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3227,7 +3279,7 @@ PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name); stack_pointer = _PyFrame_GetStackPointer(frame); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3243,12 +3295,12 @@ _PyStackRef b; value = stack_pointer[-1]; if (PyStackRef_Is(value, PyStackRef_None)) { - b = PyStackRef_True; + b = PyStackRef_True;(void)value ; } else { b = PyStackRef_False; PyStackRef_CLOSE(value); - } + }/* Pushed outputs */ stack_pointer[-1] = b; break; } @@ -3266,7 +3318,7 @@ PyObject *len_o = PyLong_FromSsize_t(len_i); stack_pointer = _PyFrame_GetStackPointer(frame); if (len_o == NULL) JUMP_TO_ERROR(); - len = PyStackRef_FromPyObjectSteal(len_o); + len = PyStackRef_FromPyObjectSteal(len_o);/* Pushed outputs */ stack_pointer[0] = len; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3285,8 +3337,6 @@ // Pop TOS and TOS1. Set TOS to a tuple of attributes on success, or // None on failure. assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names))); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attrs_o = _PyEval_MatchClass(tstate, PyStackRef_AsPyObjectBorrow(subject), @@ -3301,12 +3351,15 @@ attrs = PyStackRef_FromPyObjectSteal(attrs_o); } else { + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); if (_PyErr_Occurred(tstate)) JUMP_TO_ERROR(); // Error! - attrs = PyStackRef_None; // Failure! - } - stack_pointer[0] = attrs; - stack_pointer += 1; + attrs = PyStackRef_None; // Failure!stack_pointer += 3; + assert(WITHIN_STACK_BOUNDS()); + }/* Pushed outputs */ + stack_pointer[-3] = attrs; + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); break; } @@ -3316,7 +3369,7 @@ _PyStackRef res; subject = stack_pointer[-1]; int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING; - res = match ? PyStackRef_True : PyStackRef_False; + res = match ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3328,7 +3381,7 @@ _PyStackRef res; subject = stack_pointer[-1]; int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE; - res = match ? PyStackRef_True : PyStackRef_False; + res = match ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3347,7 +3400,7 @@ PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys)); stack_pointer = _PyFrame_GetStackPointer(frame); if (values_or_none_o == NULL) JUMP_TO_ERROR(); - values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o); + values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o);/* Pushed outputs */ stack_pointer[0] = values_or_none; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3359,18 +3412,13 @@ _PyStackRef iter; iterable = stack_pointer[-1]; /* before: [obj]; after [getiter(obj)] */ - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable))); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); - stack_pointer[0] = iter; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = iter; if (PyStackRef_IsNull(iter)) JUMP_TO_ERROR(); - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + /* Pushed outputs */ break; } @@ -3385,8 +3433,6 @@ if (!(_PyFrame_GetCode(frame)->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) { /* and it is used in a 'yield from' expression of a regular generator. */ - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_TypeError, "cannot 'yield from' a coroutine object " @@ -3394,25 +3440,22 @@ stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); } - iter = iterable; + iter = iterable;(void)iterable ; } else if (PyGen_CheckExact(iterable_o)) { - iter = iterable; + iter = iterable;(void)iterable ; } else { /* `iterable` is not a generator. */ - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); stack_pointer = _PyFrame_GetStackPointer(frame); + (void)iterable ; if (PyStackRef_IsNull(iter)) { JUMP_TO_ERROR(); } PyStackRef_CLOSE(iterable); - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - } + }/* Pushed outputs */ stack_pointer[-1] = iter; break; } @@ -3447,7 +3490,7 @@ } } next = PyStackRef_FromPyObjectSteal(next_o); - // Common case: no jump, leave it to the code generator + // Common case: no jump, leave it to the code generator/* Pushed outputs */ stack_pointer[0] = next; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3463,6 +3506,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -3485,7 +3529,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - } + }/* Pushed outputs */ break; } @@ -3499,7 +3543,7 @@ PyListObject *seq = it->it_seq; assert(seq); assert(it->it_index < PyList_GET_SIZE(seq)); - next = PyStackRef_FromPyObjectNew(PyList_GET_ITEM(seq, it->it_index++)); + next = PyStackRef_FromPyObjectNew(PyList_GET_ITEM(seq, it->it_index++));/* Pushed outputs */ stack_pointer[0] = next; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3513,6 +3557,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -3533,6 +3578,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -3546,7 +3592,7 @@ PyTupleObject *seq = it->it_seq; assert(seq); assert(it->it_index < PyTuple_GET_SIZE(seq)); - next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq, it->it_index++)); + next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq, it->it_index++));/* Pushed outputs */ stack_pointer[0] = next; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3561,6 +3607,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -3575,6 +3622,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -3590,7 +3638,7 @@ r->len--; PyObject *res = PyLong_FromLong(value); if (res == NULL) JUMP_TO_ERROR(); - next = PyStackRef_FromPyObjectSteal(res); + next = PyStackRef_FromPyObjectSteal(res);/* Pushed outputs */ stack_pointer[0] = next; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3619,7 +3667,7 @@ tstate->exc_info = &gen->gi_exc_state; gen_frame->previous = frame; // oparg is the return offset from the next instruction. - frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_FOR_ITER + oparg); + frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_FOR_ITER + oparg);/* Pushed outputs */ stack_pointer[0].bits = (uintptr_t)gen_frame; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3659,7 +3707,10 @@ stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(attr)) JUMP_TO_ERROR(); - self_or_null = PyStackRef_FromPyObjectSteal(self_or_null_o); + self_or_null = PyStackRef_FromPyObjectSteal(self_or_null_o);/* Pushed outputs */ + stack_pointer[0] = attr; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -3708,15 +3759,15 @@ stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + /* Pushed outputs */ break; } case _PUSH_EXC_INFO: { - _PyStackRef new_exc; + _PyStackRef exc; _PyStackRef prev_exc; - new_exc = stack_pointer[-1]; + _PyStackRef new_exc; + exc = stack_pointer[-1]; _PyErr_StackItem *exc_info = tstate->exc_info; if (exc_info->exc_value != NULL) { prev_exc = PyStackRef_FromPyObjectSteal(exc_info->exc_value); @@ -3724,8 +3775,9 @@ else { prev_exc = PyStackRef_None; } - assert(PyStackRef_ExceptionInstanceCheck(new_exc)); - exc_info->exc_value = PyStackRef_AsPyObjectNew(new_exc); + assert(PyStackRef_ExceptionInstanceCheck(exc)); + exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); + new_exc = exc;(void)exc ;/* Pushed outputs */ stack_pointer[-1] = prev_exc; stack_pointer[0] = new_exc; stack_pointer += 1; @@ -3742,6 +3794,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -3755,6 +3808,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -3771,7 +3825,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner; + self = owner;(void)owner ;/* Pushed outputs */ stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; @@ -3792,7 +3846,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner; + self = owner;(void)owner ;/* Pushed outputs */ stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; @@ -3810,7 +3864,7 @@ STAT_INC(LOAD_ATTR, hit); assert(descr != NULL); PyStackRef_CLOSE(owner); - attr = PyStackRef_FromPyObjectNew(descr); + attr = PyStackRef_FromPyObjectNew(descr);/* Pushed outputs */ stack_pointer[-1] = attr; break; } @@ -3826,7 +3880,7 @@ STAT_INC(LOAD_ATTR, hit); assert(descr != NULL); PyStackRef_CLOSE(owner); - attr = PyStackRef_FromPyObjectNew(descr); + attr = PyStackRef_FromPyObjectNew(descr);/* Pushed outputs */ stack_pointer[-1] = attr; break; } @@ -3842,6 +3896,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -3857,7 +3912,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner; + self = owner;(void)owner ;/* Pushed outputs */ stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; @@ -3872,34 +3927,22 @@ _PyStackRef func; _PyStackRef *maybe_self; oparg = CURRENT_OPARG(); + maybe_self = &stack_pointer[1]; args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; - maybe_self = &stack_pointer[-1 - oparg]; if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); -<<<<<<< HEAD - PyObject *method = ((PyMethodObject *)callable_o)->im_func; - func = PyStackRef_FromPyObjectNew(method); - PyObject *self = ((PyMethodObject *)callable_o)->im_self; - maybe_self = PyStackRef_FromPyObjectNew(self); - /* Make sure that callable and all args are in memory */ - args[-2] = func; - args[-1] = maybe_self; -======= PyObject *self = ((PyMethodObject *)callable_o)->im_self; maybe_self[0] = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; func = PyStackRef_FromPyObjectNew(method); - stack_pointer[-2 - oparg] = func; ->>>>>>> main - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable);(void)self_or_null ; } else { - func = callable; - } + func = callable;(void)callable ;(void)self_or_null ; + }/* Pushed outputs */ stack_pointer[-2 - oparg] = func; - stack_pointer[-1 - oparg] = maybe_self; break; } @@ -3926,7 +3969,7 @@ 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)); - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( @@ -3936,11 +3979,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. + stack_pointer[-1].bits = (uintptr_t)new_frame; if (new_frame == NULL) { JUMP_TO_ERROR(); - } - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); + }/* Pushed outputs */ break; } @@ -3959,6 +4001,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -3987,6 +4030,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -3996,22 +4040,17 @@ _PyStackRef method; _PyStackRef *self; oparg = CURRENT_OPARG(); + self = &stack_pointer[1]; null = &stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; - self = &stack_pointer[-1 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - assert(PyStackRef_IsNull(null[0])); + assert(PyStackRef_IsNull(null[0]));(void)null ; assert(Py_TYPE(callable_o) == &PyMethod_Type); -<<<<<<< HEAD - self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); -======= self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); ->>>>>>> main method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); assert(PyStackRef_FunctionCheck(method)); - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable);/* Pushed outputs */ stack_pointer[-2 - oparg] = method; - stack_pointer[-1 - oparg] = self; break; } @@ -4028,6 +4067,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -4061,7 +4101,7 @@ assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( @@ -4075,10 +4115,10 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer += -2 - oparg; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + if (res_o == NULL) JUMP_TO_ERROR(); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ break; } @@ -4096,27 +4136,26 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } case _INIT_CALL_BOUND_METHOD_EXACT_ARGS: { + _PyStackRef *null; _PyStackRef callable; _PyStackRef func; _PyStackRef *self; oparg = CURRENT_OPARG(); + self = &stack_pointer[1]; + null = &stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; - self = &stack_pointer[-1 - oparg]; + (void)null ; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); STAT_INC(CALL, hit); -<<<<<<< HEAD - self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); -======= self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); ->>>>>>> main func = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable);/* Pushed outputs */ stack_pointer[-2 - oparg] = func; - stack_pointer[-1 - oparg] = self; break; } @@ -4125,6 +4164,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -4142,6 +4182,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -4160,6 +4201,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -4182,7 +4224,7 @@ new_frame->localsplus[0] = self_or_null[0]; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; - } + }/* Pushed outputs */ stack_pointer[-2 - oparg].bits = (uintptr_t)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -4208,7 +4250,7 @@ new_frame->localsplus[0] = self_or_null[0]; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; - } + }/* Pushed outputs */ stack_pointer[-2 - oparg].bits = (uintptr_t)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -4234,7 +4276,7 @@ new_frame->localsplus[0] = self_or_null[0]; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; - } + }/* Pushed outputs */ stack_pointer[-2 - oparg].bits = (uintptr_t)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -4260,7 +4302,7 @@ new_frame->localsplus[0] = self_or_null[0]; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; - } + }/* Pushed outputs */ stack_pointer[-2 - oparg].bits = (uintptr_t)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -4286,7 +4328,7 @@ new_frame->localsplus[0] = self_or_null[0]; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; - } + }/* Pushed outputs */ stack_pointer[-2 - oparg].bits = (uintptr_t)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -4311,7 +4353,7 @@ new_frame->localsplus[0] = self_or_null[0]; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; - } + }/* Pushed outputs */ stack_pointer[-2 - oparg].bits = (uintptr_t)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -4324,16 +4366,17 @@ // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); + _PyInterpreterFrame *temp = new_frame;(void)new_frame ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); - frame = tstate->current_frame = new_frame; + frame = tstate->current_frame = temp; tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME(); + LLTRACE_RESUME_FRAME();/* Pushed outputs */ break; } @@ -4353,13 +4396,15 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + (void)null ; if (callable_o != (PyObject *)&PyType_Type) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + (void)callable ; STAT_INC(CALL, hit); res = PyStackRef_FromPyObjectSteal(Py_NewRef(Py_TYPE(arg_o))); - PyStackRef_CLOSE(arg); + PyStackRef_CLOSE(arg);/* Pushed outputs */ stack_pointer[-3] = res; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -4387,18 +4432,16 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(CALL, hit); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); + (void)null ;(void)callable ; PyStackRef_CLOSE(arg); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-3] = res; + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + /* Pushed outputs */ break; } @@ -4423,18 +4466,16 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(CALL, hit); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); + (void)null ;(void)callable ; PyStackRef_CLOSE(arg); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-3] = res; + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + /* Pushed outputs */ break; } @@ -4454,6 +4495,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + (void)null ; if (!PyType_Check(callable_o)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -4472,7 +4514,7 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(CALL, hit); - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); self = PyStackRef_FromPyObjectSteal(_PyType_NewManagedObject(tp)); @@ -4481,10 +4523,10 @@ JUMP_TO_ERROR(); } PyStackRef_CLOSE(callable); - init = PyStackRef_FromPyObjectNew(init_func); - stack_pointer[0] = self; - stack_pointer[1] = init; - stack_pointer += 2 + oparg; + init = PyStackRef_FromPyObjectNew(init_func);/* Pushed outputs */ + stack_pointer[-1] = self; + stack_pointer[0] = init; + stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -4498,7 +4540,7 @@ args = &stack_pointer[-oparg]; init = stack_pointer[-1 - oparg]; self = stack_pointer[-2 - oparg]; - stack_pointer += -2 - oparg; + stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( @@ -4508,11 +4550,16 @@ /* Push self onto stack of shim */ shim->localsplus[0] = PyStackRef_DUP(self); PyFunctionObject *init_func = (PyFunctionObject *)PyStackRef_AsPyObjectSteal(init); - args[-1] = self; + args[-1] = self;(void)self ; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); init_frame = _PyEvalFramePushAndInit( tstate, init_func, NULL, args-1, oparg+1, NULL, shim); stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer[0].bits = (uintptr_t)init_frame; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); if (init_frame == NULL) { _PyEval_FrameClearAndPop(tstate, shim); JUMP_TO_ERROR(); @@ -4521,10 +4568,7 @@ /* Account for pushing the extra frame. * We don't check recursion depth here, * as it will be checked after start_frame */ - tstate->py_recursion_remaining--; - stack_pointer[0].bits = (uintptr_t)init_frame; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + tstate->py_recursion_remaining--;/* Pushed outputs */ break; } @@ -4533,15 +4577,13 @@ should_be_none = stack_pointer[-1]; assert(STACK_LEVEL() == 2); if (!PyStackRef_Is(should_be_none, PyStackRef_None)) { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyErr_Format(PyExc_TypeError, "__init__() should return None, not '%.200s'", Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); - } + }(void)should_be_none ;/* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -4561,7 +4603,7 @@ if (!PyStackRef_IsNull(self_or_null[0])) { args--; total_args++; - } + }(void)self_or_null ; if (!PyType_Check(callable_o)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -4593,9 +4635,7 @@ stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ break; } @@ -4636,7 +4676,7 @@ PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o); _PyStackRef arg = args[0]; _Py_EnterRecursiveCallTstateUnchecked(tstate); - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg)); @@ -4645,10 +4685,10 @@ assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(arg); PyStackRef_CLOSE(callable); - if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer += -2 - oparg; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + if (res_o == NULL) JUMP_TO_ERROR(); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ break; } @@ -4667,7 +4707,7 @@ if (!PyStackRef_IsNull(self_or_null[0])) { args--; total_args++; - } + }(void)self_or_null ; if (!PyCFunction_CheckExact(callable_o)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -4704,9 +4744,7 @@ stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ break; } @@ -4761,9 +4799,7 @@ stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ break; } @@ -4795,7 +4831,7 @@ STAT_INC(CALL, hit); _PyStackRef arg_stackref = args[0]; PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref); - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(arg); @@ -4812,9 +4848,7 @@ } PyStackRef_CLOSE(callable); PyStackRef_CLOSE(arg_stackref); - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ break; } @@ -4846,7 +4880,7 @@ STAT_INC(CALL, hit); _PyStackRef cls_stackref = args[1]; _PyStackRef inst_stackref = args[0]; - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref)); @@ -4858,9 +4892,7 @@ assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(inst_stackref); PyStackRef_CLOSE(cls_stackref); - PyStackRef_CLOSE(callable); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); + PyStackRef_CLOSE(callable);/* Pushed outputs */ break; } @@ -4897,7 +4929,7 @@ // during trace projection in tier two: assert(next_instr->op.code == POP_TOP); SKIP_OVER(1); - #endif + #endif/* Pushed outputs */ break; } @@ -4945,7 +4977,7 @@ STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; _Py_EnterRecursiveCallTstateUnchecked(tstate); - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, @@ -4957,10 +4989,10 @@ PyStackRef_CLOSE(self_stackref); PyStackRef_CLOSE(arg_stackref); PyStackRef_CLOSE(callable); - if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer += -2 - oparg; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + if (res_o == NULL) JUMP_TO_ERROR(); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ break; } @@ -5021,9 +5053,7 @@ stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ break; } @@ -5071,7 +5101,7 @@ STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; _Py_EnterRecursiveCallTstateUnchecked(tstate); - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL); @@ -5080,10 +5110,10 @@ assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); PyStackRef_CLOSE(callable); - if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer += -2 - oparg; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + if (res_o == NULL) JUMP_TO_ERROR(); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ break; } @@ -5144,14 +5174,43 @@ stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ break; } /* _INSTRUMENTED_CALL_KW is not a viable micro-op for tier 2 because it is instrumented */ + case _MAYBE_EXPAND_METHOD_KW: { + _PyStackRef kwnames_in; + _PyStackRef *args; + _PyStackRef *self_or_null; + _PyStackRef callable; + _PyStackRef func; + _PyStackRef *maybe_self; + _PyStackRef kwnames_out; + oparg = CURRENT_OPARG(); + maybe_self = &stack_pointer[1]; + kwnames_in = stack_pointer[-1]; + args = &stack_pointer[-1 - oparg]; + self_or_null = &stack_pointer[-2 - oparg]; + callable = stack_pointer[-3 - oparg]; + if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *self = ((PyMethodObject *)callable_o)->im_self; + maybe_self[0] = PyStackRef_FromPyObjectNew(self); + PyObject *method = ((PyMethodObject *)callable_o)->im_func; + func = PyStackRef_FromPyObjectNew(method); + PyStackRef_CLOSE(callable); + } + else { + func = callable;(void)callable ; + } + kwnames_out = kwnames_in;(void)kwnames_in ;/* Pushed outputs */ + stack_pointer[-3 - oparg] = func; + stack_pointer[-1] = kwnames_out; + break; + } + /* _DO_CALL_KW is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ case _PY_FRAME_KW: { @@ -5177,8 +5236,6 @@ 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)); - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, @@ -5188,11 +5245,12 @@ PyStackRef_CLOSE(kwnames); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. + stack_pointer[-3 - oparg].bits = (uintptr_t)new_frame; + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); if (new_frame == NULL) { JUMP_TO_ERROR(); - } - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); + }/* Pushed outputs */ break; } @@ -5211,6 +5269,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -5239,34 +5298,27 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } case _EXPAND_METHOD_KW: { - _PyStackRef kwnames; _PyStackRef *null; _PyStackRef callable; _PyStackRef method; _PyStackRef *self; oparg = CURRENT_OPARG(); - kwnames = stack_pointer[-1]; + self = &stack_pointer[1]; null = &stack_pointer[-2 - oparg]; callable = stack_pointer[-3 - oparg]; - self = &stack_pointer[-2 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); assert(PyStackRef_IsNull(null[0])); assert(Py_TYPE(callable_o) == &PyMethod_Type); -<<<<<<< HEAD - self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); -======= self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); ->>>>>>> main method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); assert(PyStackRef_FunctionCheck(method)); - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable);/* Pushed outputs */ stack_pointer[-3 - oparg] = method; - stack_pointer[-2 - oparg] = self; - stack_pointer[-1] = kwnames; break; } @@ -5283,6 +5335,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -5321,8 +5374,6 @@ } PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -5336,10 +5387,10 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); + if (res_o == NULL) JUMP_TO_ERROR(); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ break; } @@ -5352,19 +5403,19 @@ _PyStackRef func; codeobj_st = stack_pointer[-1]; PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyFunctionObject *func_obj = (PyFunctionObject *) PyFunction_New(codeobj, GLOBALS()); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(codeobj_st); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (func_obj == NULL) JUMP_TO_ERROR(); _PyFrame_SetStackPointer(frame, stack_pointer); _PyFunction_SetVersion( func_obj, ((PyCodeObject *)codeobj)->co_version); stack_pointer = _PyFrame_GetStackPointer(frame); - func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj); + func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj);/* Pushed outputs */ stack_pointer[0] = func; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5372,20 +5423,22 @@ } case _SET_FUNCTION_ATTRIBUTE: { - _PyStackRef func_st; + _PyStackRef func_in; _PyStackRef attr_st; + _PyStackRef func_out; oparg = CURRENT_OPARG(); - func_st = stack_pointer[-1]; + func_in = stack_pointer[-1]; attr_st = stack_pointer[-2]; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); - PyObject *attr = PyStackRef_AsPyObjectBorrow(attr_st); + PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); + PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st); + func_out = func_in;(void)func_in ; assert(PyFunction_Check(func)); size_t offset = _Py_FunctionAttributeOffsets[oparg]; assert(offset != 0); PyObject **ptr = (PyObject **)(((char *)func) + offset); assert(*ptr == NULL); - *ptr = attr; - stack_pointer[-2] = func_st; + *ptr = attr;/* Pushed outputs */ + stack_pointer[-2] = func_out; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -5414,7 +5467,7 @@ LOAD_IP(frame->return_offset); stack_pointer = _PyFrame_GetStackPointer(frame); res = PyStackRef_FromPyObjectSteal((PyObject *)gen); - LLTRACE_RESUME_FRAME(); + LLTRACE_RESUME_FRAME();/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5440,7 +5493,7 @@ stack_pointer += -2 - ((oparg == 3) ? 1 : 0); assert(WITHIN_STACK_BOUNDS()); if (slice_o == NULL) JUMP_TO_ERROR(); - slice = PyStackRef_FromPyObjectSteal(slice_o); + slice = PyStackRef_FromPyObjectSteal(slice_o);/* Pushed outputs */ stack_pointer[0] = slice; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5460,7 +5513,7 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); if (result_o == NULL) JUMP_TO_ERROR(); - result = PyStackRef_FromPyObjectSteal(result_o); + result = PyStackRef_FromPyObjectSteal(result_o);/* Pushed outputs */ stack_pointer[0] = result; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5475,20 +5528,16 @@ /* If value is a unicode object, then we know the result * of format(value) is value itself. */ if (!PyUnicode_CheckExact(value_o)) { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Format(value_o, NULL)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); } else { - res = value; - } + res = value;(void)value ; + }/* Pushed outputs */ stack_pointer[-1] = res; break; } @@ -5499,15 +5548,15 @@ _PyStackRef res; fmt_spec = stack_pointer[-1]; value = stack_pointer[-2]; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); PyStackRef_CLOSE(fmt_spec); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5520,7 +5569,7 @@ oparg = CURRENT_OPARG(); bottom = stack_pointer[-1 - (oparg-1)]; assert(oparg > 0); - top = PyStackRef_DUP(bottom); + top = PyStackRef_DUP(bottom);/* Pushed outputs */ stack_pointer[0] = top; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5543,7 +5592,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5551,14 +5600,18 @@ } case _SWAP: { - _PyStackRef top; - _PyStackRef bottom; + _PyStackRef top_in; + _PyStackRef bottom_in; + _PyStackRef top_out; + _PyStackRef bottom_out; oparg = CURRENT_OPARG(); - top = stack_pointer[-1]; - bottom = stack_pointer[-2 - (oparg-2)]; - assert(oparg >= 2); - stack_pointer[-2 - (oparg-2)] = top; - stack_pointer[-1] = bottom; + top_in = stack_pointer[-1]; + bottom_in = stack_pointer[-2 - (oparg-2)]; + bottom_out = bottom_in;(void)bottom_in ; + top_out = top_in;(void)top_in ; + assert(oparg >= 2);/* Pushed outputs */ + stack_pointer[-2 - (oparg-2)] = top_out; + stack_pointer[-1] = bottom_out; break; } @@ -5581,65 +5634,69 @@ case _GUARD_IS_TRUE_POP: { _PyStackRef flag; flag = stack_pointer[-1]; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - if (!PyStackRef_Is(flag, PyStackRef_True)) { + int is_true = PyStackRef_Is(flag, PyStackRef_True);(void)flag ; + if (!is_true) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - assert(PyStackRef_Is(flag, PyStackRef_True)); + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _GUARD_IS_FALSE_POP: { _PyStackRef flag; flag = stack_pointer[-1]; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - if (!PyStackRef_Is(flag, PyStackRef_False)) { + int is_false = PyStackRef_Is(flag, PyStackRef_False);(void)flag ; + if (!is_false) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - assert(PyStackRef_Is(flag, PyStackRef_False)); + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _GUARD_IS_NONE_POP: { _PyStackRef val; val = stack_pointer[-1]; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - if (!PyStackRef_Is(val, PyStackRef_None)) { + int is_none = PyStackRef_Is(val, PyStackRef_None); + if (!is_none) { PyStackRef_CLOSE(val); if (1) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - } + }(void)val ;/* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _GUARD_IS_NOT_NONE_POP: { _PyStackRef val; val = stack_pointer[-1]; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - if (PyStackRef_Is(val, PyStackRef_None)) { + int is_none = PyStackRef_Is(val, PyStackRef_None); + if (is_none) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - PyStackRef_CLOSE(val); + PyStackRef_CLOSE(val);/* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _JUMP_TO_TOP: { - JUMP_TO_JUMP_TARGET(); + JUMP_TO_JUMP_TARGET();/* Pushed outputs */ break; } case _SET_IP: { PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND(); - frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr; + frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr;/* Pushed outputs */ break; } @@ -5654,6 +5711,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -5664,7 +5722,7 @@ #endif #if TIER_TWO frame->return_offset = oparg; - #endif + #endif/* Pushed outputs */ break; } @@ -5724,7 +5782,7 @@ } Py_INCREF(exit->executor); tstate->previous_executor = (PyObject *)current_executor; - GOTO_TIER_TWO(exit->executor); + GOTO_TIER_TWO(exit->executor);/* Pushed outputs */ break; } @@ -5733,13 +5791,14 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } case _LOAD_CONST_INLINE: { _PyStackRef value; PyObject *ptr = (PyObject *)CURRENT_OPERAND(); - value = PyStackRef_FromPyObjectNew(ptr); + value = PyStackRef_FromPyObjectNew(ptr);/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5749,7 +5808,7 @@ case _LOAD_CONST_INLINE_BORROW: { _PyStackRef value; PyObject *ptr = (PyObject *)CURRENT_OPERAND(); - value = PyStackRef_FromPyObjectImmortal(ptr); + value = PyStackRef_FromPyObjectImmortal(ptr);/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5762,7 +5821,7 @@ pop = stack_pointer[-1]; PyObject *ptr = (PyObject *)CURRENT_OPERAND(); PyStackRef_CLOSE(pop); - value = PyStackRef_FromPyObjectImmortal(ptr); + value = PyStackRef_FromPyObjectImmortal(ptr);/* Pushed outputs */ stack_pointer[-1] = value; break; } @@ -5772,7 +5831,7 @@ _PyStackRef null; PyObject *ptr = (PyObject *)CURRENT_OPERAND(); value = PyStackRef_FromPyObjectNew(ptr); - null = PyStackRef_NULL; + null = PyStackRef_NULL;/* Pushed outputs */ stack_pointer[0] = value; stack_pointer[1] = null; stack_pointer += 2; @@ -5785,7 +5844,7 @@ _PyStackRef null; PyObject *ptr = (PyObject *)CURRENT_OPERAND(); value = PyStackRef_FromPyObjectImmortal(ptr); - null = PyStackRef_NULL; + null = PyStackRef_NULL;/* Pushed outputs */ stack_pointer[0] = value; stack_pointer[1] = null; stack_pointer += 2; @@ -5800,6 +5859,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } + /* Pushed outputs */ break; } @@ -5807,7 +5867,7 @@ _PyStackRef opt; opt = stack_pointer[-1]; _PyCounterOptimizerObject *exe = (_PyCounterOptimizerObject *)PyStackRef_AsPyObjectBorrow(opt); - exe->count++; + exe->count++;(void)opt ;/* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -5856,7 +5916,7 @@ exit->temperature = initial_temperature_backoff_counter(); } } - GOTO_TIER_TWO(executor); + GOTO_TIER_TWO(executor);/* Pushed outputs */ break; } @@ -5867,13 +5927,13 @@ #ifndef _Py_JIT current_executor = (_PyExecutorObject*)executor; #endif - assert(((_PyExecutorObject *)executor)->vm_data.valid); + assert(((_PyExecutorObject *)executor)->vm_data.valid);/* Pushed outputs */ break; } case _FATAL_ERROR: { assert(0); - Py_FatalError("Fatal error uop executed."); + Py_FatalError("Fatal error uop executed.");/* Pushed outputs */ break; } @@ -5883,12 +5943,12 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr; + frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr;/* Pushed outputs */ break; } case _DEOPT: { - EXIT_TO_TIER1(); + EXIT_TO_TIER1();/* Pushed outputs */ break; } @@ -5905,9 +5965,7 @@ } stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); - GOTO_UNWIND(); - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); + GOTO_UNWIND();/* Pushed outputs */ break; } @@ -5924,7 +5982,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - assert(tstate->tracing || eval_breaker == FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version)); + assert(tstate->tracing || eval_breaker == FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version));/* Pushed outputs */ break; } diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 4e9707c95de1bd..d6b2b195273c7c 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -20,9 +20,9 @@ _PyStackRef rhs; _PyStackRef res; // _SPECIALIZE_BINARY_OP - rhs = stack_pointer[-1]; - lhs = stack_pointer[-2]; { + rhs = stack_pointer[-1]; + lhs = stack_pointer[-2]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; #if ENABLE_SPECIALIZATION @@ -37,7 +37,7 @@ ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); #endif /* ENABLE_SPECIALIZATION */ assert(NB_ADD <= oparg); - assert(oparg <= NB_INPLACE_XOR); + assert(oparg <= NB_INPLACE_XOR);/* Pushed outputs */ } // _BINARY_OP { @@ -47,8 +47,8 @@ PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o); PyStackRef_CLOSE(lhs); PyStackRef_CLOSE(rhs); - if (res_o == NULL) goto pop_2_error; - res = PyStackRef_FromPyObjectSteal(res_o); + if (res_o == NULL) goto error; + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } stack_pointer[-2] = res; stack_pointer += -1; @@ -65,13 +65,14 @@ _PyStackRef right; _PyStackRef res; // _GUARD_BOTH_FLOAT - right = stack_pointer[-1]; - left = stack_pointer[-2]; { + right = stack_pointer[-1]; + left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyFloat_CheckExact(left_o), BINARY_OP); DEOPT_IF(!PyFloat_CheckExact(right_o), BINARY_OP); + /* Pushed outputs */ } /* Skip 1 cache entry */ // _BINARY_OP_ADD_FLOAT @@ -84,7 +85,7 @@ ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } stack_pointer[-2] = res; stack_pointer += -1; @@ -101,13 +102,14 @@ _PyStackRef right; _PyStackRef res; // _GUARD_BOTH_INT - right = stack_pointer[-1]; - left = stack_pointer[-2]; { + right = stack_pointer[-1]; + left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyLong_CheckExact(left_o), BINARY_OP); DEOPT_IF(!PyLong_CheckExact(right_o), BINARY_OP); + /* Pushed outputs */ } /* Skip 1 cache entry */ // _BINARY_OP_ADD_INT @@ -118,8 +120,8 @@ PyObject *res_o = _PyLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); - if (res_o == NULL) goto pop_2_error; - res = PyStackRef_FromPyObjectSteal(res_o); + if (res_o == NULL) goto error; + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } stack_pointer[-2] = res; stack_pointer += -1; @@ -136,13 +138,14 @@ _PyStackRef right; _PyStackRef res; // _GUARD_BOTH_UNICODE - right = stack_pointer[-1]; - left = stack_pointer[-2]; { + right = stack_pointer[-1]; + left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyUnicode_CheckExact(left_o), BINARY_OP); DEOPT_IF(!PyUnicode_CheckExact(right_o), BINARY_OP); + /* Pushed outputs */ } /* Skip 1 cache entry */ // _BINARY_OP_ADD_UNICODE @@ -153,8 +156,8 @@ PyObject *res_o = PyUnicode_Concat(left_o, right_o); _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc); _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); - if (res_o == NULL) goto pop_2_error; - res = PyStackRef_FromPyObjectSteal(res_o); + if (res_o == NULL) goto error; + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } stack_pointer[-2] = res; stack_pointer += -1; @@ -170,13 +173,14 @@ _PyStackRef left; _PyStackRef right; // _GUARD_BOTH_UNICODE - right = stack_pointer[-1]; - left = stack_pointer[-2]; { + right = stack_pointer[-1]; + left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyUnicode_CheckExact(left_o), BINARY_OP); DEOPT_IF(!PyUnicode_CheckExact(right_o), BINARY_OP); + /* Pushed outputs */ } /* Skip 1 cache entry */ // _BINARY_OP_INPLACE_ADD_UNICODE @@ -205,18 +209,18 @@ * that the string is safe to mutate. */ assert(Py_REFCNT(left_o) >= 2); - _Py_DECREF_NO_DEALLOC(left_o); + _Py_DECREF_NO_DEALLOC(left_o);(void)left ; PyObject *temp = PyStackRef_AsPyObjectBorrow(*target_local); PyUnicode_Append(&temp, right_o); *target_local = PyStackRef_FromPyObjectSteal(temp); - _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); - if (PyStackRef_IsNull(*target_local)) goto pop_2_error; + _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);(void)right ; + if (PyStackRef_IsNull(*target_local)) goto error; #if TIER_ONE // The STORE_FAST is already done. This is done here in tier one, // and during trace projection in tier two: assert(next_instr->op.code == STORE_FAST); SKIP_OVER(1); - #endif + #endif/* Pushed outputs */ } stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -232,13 +236,14 @@ _PyStackRef right; _PyStackRef res; // _GUARD_BOTH_FLOAT - right = stack_pointer[-1]; - left = stack_pointer[-2]; { + right = stack_pointer[-1]; + left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyFloat_CheckExact(left_o), BINARY_OP); DEOPT_IF(!PyFloat_CheckExact(right_o), BINARY_OP); + /* Pushed outputs */ } /* Skip 1 cache entry */ // _BINARY_OP_MULTIPLY_FLOAT @@ -251,7 +256,7 @@ ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } stack_pointer[-2] = res; stack_pointer += -1; @@ -268,13 +273,14 @@ _PyStackRef right; _PyStackRef res; // _GUARD_BOTH_INT - right = stack_pointer[-1]; - left = stack_pointer[-2]; { + right = stack_pointer[-1]; + left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyLong_CheckExact(left_o), BINARY_OP); DEOPT_IF(!PyLong_CheckExact(right_o), BINARY_OP); + /* Pushed outputs */ } /* Skip 1 cache entry */ // _BINARY_OP_MULTIPLY_INT @@ -285,8 +291,8 @@ PyObject *res_o = _PyLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); - if (res_o == NULL) goto pop_2_error; - res = PyStackRef_FromPyObjectSteal(res_o); + if (res_o == NULL) goto error; + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } stack_pointer[-2] = res; stack_pointer += -1; @@ -303,13 +309,14 @@ _PyStackRef right; _PyStackRef res; // _GUARD_BOTH_FLOAT - right = stack_pointer[-1]; - left = stack_pointer[-2]; { + right = stack_pointer[-1]; + left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyFloat_CheckExact(left_o), BINARY_OP); DEOPT_IF(!PyFloat_CheckExact(right_o), BINARY_OP); + /* Pushed outputs */ } /* Skip 1 cache entry */ // _BINARY_OP_SUBTRACT_FLOAT @@ -322,7 +329,7 @@ ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } stack_pointer[-2] = res; stack_pointer += -1; @@ -339,13 +346,14 @@ _PyStackRef right; _PyStackRef res; // _GUARD_BOTH_INT - right = stack_pointer[-1]; - left = stack_pointer[-2]; { + right = stack_pointer[-1]; + left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyLong_CheckExact(left_o), BINARY_OP); DEOPT_IF(!PyLong_CheckExact(right_o), BINARY_OP); + /* Pushed outputs */ } /* Skip 1 cache entry */ // _BINARY_OP_SUBTRACT_INT @@ -355,9 +363,9 @@ STAT_INC(BINARY_OP, hit); PyObject *res_o = _PyLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); - _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);; - if (res_o == NULL) goto pop_2_error; - res = PyStackRef_FromPyObjectSteal(res_o); + _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); + if (res_o == NULL) goto error; + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } stack_pointer[-2] = res; stack_pointer += -1; @@ -378,41 +386,17 @@ // Placeholder until we implement BINARY_SLICE specialization #if ENABLE_SPECIALIZATION OPCODE_DEFERRED_INC(BINARY_SLICE); - #endif /* ENABLE_SPECIALIZATION */ + #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ } // _BINARY_SLICE - stop = stack_pointer[-1]; - start = stack_pointer[-2]; - container = stack_pointer[-3]; -<<<<<<< HEAD - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), - PyStackRef_AsPyObjectSteal(stop)); - stack_pointer = _PyFrame_GetStackPointer(frame); - PyObject *res_o; - OPCODE_DEFERRED_INC(BINARY_SLICE); - // Can't use ERROR_IF() here, because we haven't - // DECREF'ed container yet, and we still own slice. - if (slice == NULL) { - res_o = NULL; - } - else { - _PyFrame_SetStackPointer(frame, stack_pointer); - res_o = PyObject_GetItem(PyStackRef_AsPyObjectBorrow(container), slice); - stack_pointer = _PyFrame_GetStackPointer(frame); - Py_DECREF(slice); - } - PyStackRef_CLOSE(container); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; -======= { + stop = stack_pointer[-1]; + start = stack_pointer[-2]; + container = stack_pointer[-3]; + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyObject *res_o; // Can't use ERROR_IF() here, because we haven't // DECREF'ed container yet, and we still own slice. @@ -420,16 +404,20 @@ res_o = NULL; } else { + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); res_o = PyObject_GetItem(PyStackRef_AsPyObjectBorrow(container), slice); - Py_DECREF(slice); + stack_pointer = _PyFrame_GetStackPointer(frame); + Py_DECREF(slice);stack_pointer += 2; + assert(WITHIN_STACK_BOUNDS()); } PyStackRef_CLOSE(container); - if (res_o == NULL) goto pop_3_error; - res = PyStackRef_FromPyObjectSteal(res_o); + if (res_o == NULL) goto pop_2_error; + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } stack_pointer[-3] = res; stack_pointer += -2; ->>>>>>> main assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -445,9 +433,9 @@ _PyStackRef sub; _PyStackRef res; // _SPECIALIZE_BINARY_SUBSCR - sub = stack_pointer[-1]; - container = stack_pointer[-2]; { + sub = stack_pointer[-1]; + container = stack_pointer[-2]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; assert(frame->stackpointer == NULL); @@ -461,24 +449,22 @@ } OPCODE_DEFERRED_INC(BINARY_SUBSCR); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION */ + #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ } // _BINARY_SUBSCR { PyObject *container_o = PyStackRef_AsPyObjectBorrow(container); PyObject *sub_o = PyStackRef_AsPyObjectBorrow(sub); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_GetItem(container_o, sub_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -499,8 +485,6 @@ DEOPT_IF(!PyDict_CheckExact(dict), BINARY_SUBSCR); STAT_INC(BINARY_SUBSCR, hit); PyObject *res_o; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int rc = PyDict_GetItemRef(dict, sub, &res_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -513,9 +497,9 @@ PyStackRef_CLOSE(sub_st); if (rc <= 0) goto error; // not found or error - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -532,10 +516,11 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, BINARY_SUBSCR); + /* Pushed outputs */ } // _BINARY_SUBSCR_CHECK_FUNC - container = stack_pointer[-2]; { + container = stack_pointer[-2]; PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(container)); DEOPT_IF(!PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE), BINARY_SUBSCR); PyHeapTypeObject *ht = (PyHeapTypeObject *)tp; @@ -548,34 +533,35 @@ assert(code->co_argcount == 2); DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), BINARY_SUBSCR); STAT_INC(BINARY_SUBSCR, hit); - Py_INCREF(getitem); + Py_INCREF(getitem);/* Pushed outputs */ } // _BINARY_SUBSCR_INIT_CALL - sub = stack_pointer[-1]; { + sub = stack_pointer[-1]; PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(container)); PyHeapTypeObject *ht = (PyHeapTypeObject *)tp; PyObject *getitem = ht->_spec_cache.getitem; new_frame = _PyFrame_PushUnchecked(tstate, (PyFunctionObject *)getitem, 2, frame); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); new_frame->localsplus[0] = container; new_frame->localsplus[1] = sub; - frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_BINARY_SUBSCR); + frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_BINARY_SUBSCR);/* Pushed outputs */ } // _PUSH_FRAME { // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); + _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); - frame = tstate->current_frame = new_frame; + frame = tstate->current_frame = temp; tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME(); + LLTRACE_RESUME_FRAME();/* Pushed outputs */ } DISPATCH(); } @@ -603,9 +589,9 @@ PyObject *res_o = PyList_GET_ITEM(list, index); assert(res_o != NULL); Py_INCREF(res_o); - _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); + _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; PyStackRef_CLOSE(list_st); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -635,9 +621,9 @@ DEOPT_IF(Py_ARRAY_LENGTH(_Py_SINGLETON(strings).ascii) <= c, BINARY_SUBSCR); STAT_INC(BINARY_SUBSCR, hit); PyObject *res_o = (PyObject*)&_Py_SINGLETON(strings).ascii[c]; - _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); + _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; PyStackRef_CLOSE(str_st); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -667,9 +653,9 @@ PyObject *res_o = PyTuple_GET_ITEM(tuple, index); assert(res_o != NULL); Py_INCREF(res_o); - _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); + _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; PyStackRef_CLOSE(tuple_st); - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -684,12 +670,8 @@ _PyStackRef list; values = &stack_pointer[-oparg]; PyObject *list_o = _PyList_FromStackRefSteal(values, oparg); - if (list_o == NULL) { - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - list = PyStackRef_FromPyObjectSteal(list_o); + if (list_o == NULL) goto error; + list = PyStackRef_FromPyObjectSteal(list_o);/* Pushed outputs */ stack_pointer[-oparg] = list; stack_pointer += 1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -708,11 +690,7 @@ for (int _i = oparg*2; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } - if (true) { - stack_pointer += -oparg*2; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (true) goto error; } stack_pointer += -oparg*2; assert(WITHIN_STACK_BOUNDS()); @@ -727,7 +705,7 @@ PyStackRef_CLOSE(values[_i]); } if (map_o == NULL) goto error; - map = PyStackRef_FromPyObjectSteal(map_o); + map = PyStackRef_FromPyObjectSteal(map_o);/* Pushed outputs */ stack_pointer[0] = map; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -765,7 +743,7 @@ Py_DECREF(set_o); if (true) goto error; } - set = PyStackRef_FromPyObjectSteal(set_o); + set = PyStackRef_FromPyObjectSteal(set_o);/* Pushed outputs */ stack_pointer[0] = set; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -790,12 +768,8 @@ PyStackRef_CLOSE(start); PyStackRef_CLOSE(stop); PyStackRef_XCLOSE(step); - if (slice_o == NULL) { - stack_pointer += -2 - ((oparg == 3) ? 1 : 0); - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - slice = PyStackRef_FromPyObjectSteal(slice_o); + if (slice_o == NULL) goto error; + slice = PyStackRef_FromPyObjectSteal(slice_o);/* Pushed outputs */ stack_pointer[-2 - ((oparg == 3) ? 1 : 0)] = slice; stack_pointer += -1 - ((oparg == 3) ? 1 : 0); assert(WITHIN_STACK_BOUNDS()); @@ -814,23 +788,15 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(pieces[_i]); } - if (true) { - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (true) goto error; } PyObject *str_o = _PyUnicode_JoinArray(&_Py_STR(empty), pieces_o, oparg); STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(pieces[_i]); } - if (str_o == NULL) { - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - str = PyStackRef_FromPyObjectSteal(str_o); + if (str_o == NULL) goto error; + str = PyStackRef_FromPyObjectSteal(str_o);/* Pushed outputs */ stack_pointer[-oparg] = str; stack_pointer += 1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -845,12 +811,8 @@ _PyStackRef tup; values = &stack_pointer[-oparg]; PyObject *tup_o = _PyTuple_FromStackRefSteal(values, oparg); - if (tup_o == NULL) { - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - tup = PyStackRef_FromPyObjectSteal(tup_o); + if (tup_o == NULL) goto error; + tup = PyStackRef_FromPyObjectSteal(tup_o);/* Pushed outputs */ stack_pointer[-oparg] = tup; stack_pointer += 1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -862,7 +824,7 @@ next_instr += 1; INSTRUCTION_STATS(CACHE); assert(0 && "Executing a cache."); - Py_FatalError("Executing a cache."); + Py_FatalError("Executing a cache.");/* Pushed outputs */ DISPATCH(); } @@ -880,59 +842,45 @@ _PyStackRef *maybe_self; _PyStackRef res; // _SPECIALIZE_CALL - self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; { + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; -<<<<<<< HEAD _PyFrame_SetStackPointer(frame, stack_pointer); - _Py_Specialize_Call(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null)); - stack_pointer = _PyFrame_GetStackPointer(frame); -======= _Py_Specialize_Call(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); ->>>>>>> main + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(CALL); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION */ + #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ } /* Skip 2 cache entries */ // _MAYBE_EXPAND_METHOD - args = &stack_pointer[-oparg]; { - maybe_self = &stack_pointer[-1 - oparg]; + maybe_self = &stack_pointer[1]; + args = &stack_pointer[-oparg]; if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); -<<<<<<< HEAD - PyObject *method = ((PyMethodObject *)callable_o)->im_func; - func = PyStackRef_FromPyObjectNew(method); - PyObject *self = ((PyMethodObject *)callable_o)->im_self; - maybe_self = PyStackRef_FromPyObjectNew(self); - /* Make sure that callable and all args are in memory */ - args[-2] = func; - args[-1] = maybe_self; -======= PyObject *self = ((PyMethodObject *)callable_o)->im_self; maybe_self[0] = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; func = PyStackRef_FromPyObjectNew(method); - stack_pointer[-2 - oparg] = func; ->>>>>>> main - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable);(void)self_or_null ; } else { - func = callable; - } + func = callable;(void)callable ;(void)self_or_null ; + }/* Pushed outputs */ } // _DO_CALL - self_or_null = maybe_self; - callable = func; { + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = func; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); // oparg counts all of the args, but *not* self: int total_args = oparg; @@ -947,7 +895,8 @@ { 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)); - stack_pointer += -2 - oparg; + stack_pointer[-2 - oparg] = callable; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( @@ -956,6 +905,8 @@ ); stack_pointer = _PyFrame_GetStackPointer(frame); // Manipulate stack directly since we leave using DISPATCH_INLINED(). + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { @@ -971,13 +922,10 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - if (true) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (true) goto error; } - stack_pointer += -2 - oparg; + stack_pointer[-2 - oparg] = callable; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( @@ -1015,27 +963,21 @@ PyStackRef_CLOSE(args[i]); } if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - } + }/* Pushed outputs */ } - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; DISPATCH(); } @@ -1055,15 +997,17 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, CALL); + /* Pushed outputs */ } // _CHECK_AND_ALLOCATE_OBJECT - args = &stack_pointer[-oparg]; - null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; { + args = &stack_pointer[-oparg]; + null = stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; uint32_t type_version = read_u32(&this_instr[2].cache); PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); DEOPT_IF(!PyStackRef_IsNull(null), CALL); + (void)null ; DEOPT_IF(!PyType_Check(callable_o), CALL); PyTypeObject *tp = (PyTypeObject *)callable_o; DEOPT_IF(tp->tp_version_tag != type_version, CALL); @@ -1073,7 +1017,7 @@ PyCodeObject *code = (PyCodeObject *)init_func->func_code; DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize + _Py_InitCleanup.co_framesize), CALL); STAT_INC(CALL, hit); - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); self = PyStackRef_FromPyObjectSteal(_PyType_NewManagedObject(tp)); @@ -1082,10 +1026,15 @@ goto error; } PyStackRef_CLOSE(callable); - init = PyStackRef_FromPyObjectNew(init_func); + init = PyStackRef_FromPyObjectNew(init_func);/* Pushed outputs */ } // _CREATE_INIT_FRAME { + args = &stack_pointer[1]; + stack_pointer[-1] = self; + stack_pointer[0] = init; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame); @@ -1094,11 +1043,16 @@ /* Push self onto stack of shim */ shim->localsplus[0] = PyStackRef_DUP(self); PyFunctionObject *init_func = (PyFunctionObject *)PyStackRef_AsPyObjectSteal(init); - args[-1] = self; + args[-1] = self;(void)self ; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); init_frame = _PyEvalFramePushAndInit( tstate, init_func, NULL, args-1, oparg+1, NULL, shim); stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer[0].bits = (uintptr_t)init_frame; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); if (init_frame == NULL) { _PyEval_FrameClearAndPop(tstate, shim); goto error; @@ -1107,22 +1061,25 @@ /* Account for pushing the extra frame. * We don't check recursion depth here, * as it will be checked after start_frame */ - tstate->py_recursion_remaining--; + tstate->py_recursion_remaining--;/* Pushed outputs */ } // _PUSH_FRAME - new_frame = init_frame; { + new_frame = init_frame; // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); + _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); - frame = tstate->current_frame = new_frame; + frame = tstate->current_frame = temp; tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME(); + LLTRACE_RESUME_FRAME();/* Pushed outputs */ } DISPATCH(); } @@ -1143,51 +1100,47 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, CALL); + /* Pushed outputs */ } // _CHECK_CALL_BOUND_METHOD_EXACT_ARGS - null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; { + null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; DEOPT_IF(!PyStackRef_IsNull(null[0]), CALL); DEOPT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(callable)) != &PyMethod_Type, CALL); + /* Pushed outputs */ } // _INIT_CALL_BOUND_METHOD_EXACT_ARGS { - self = &stack_pointer[-1 - oparg]; + self = &stack_pointer[1]; + (void)null ; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); STAT_INC(CALL, hit); -<<<<<<< HEAD - self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); -======= self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); ->>>>>>> main func = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable);/* Pushed outputs */ } // flush stack_pointer[-2 - oparg] = func; - stack_pointer[-1 - oparg] = self; // _CHECK_FUNCTION_VERSION - callable = func; { + callable = func; uint32_t func_version = read_u32(&this_instr[2].cache); PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); DEOPT_IF(!PyFunction_Check(callable_o), CALL); PyFunctionObject *func = (PyFunctionObject *)callable_o; DEOPT_IF(func->func_version != func_version, CALL); + /* Pushed outputs */ } // _CHECK_FUNCTION_EXACT_ARGS -<<<<<<< HEAD - self_or_null = self; -======= - self_or_null = &stack_pointer[-1 - oparg]; ->>>>>>> main { + self_or_null = &stack_pointer[-1 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); assert(PyFunction_Check(callable_o)); PyFunctionObject *func = (PyFunctionObject *)callable_o; PyCodeObject *code = (PyCodeObject *)func->func_code; DEOPT_IF(code->co_argcount != oparg + (!PyStackRef_IsNull(self_or_null[0])), CALL); + /* Pushed outputs */ } // _CHECK_STACK_SPACE { @@ -1196,10 +1149,11 @@ PyCodeObject *code = (PyCodeObject *)func->func_code; DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), CALL); DEOPT_IF(tstate->py_recursion_remaining <= 1, CALL); + /* Pushed outputs */ } // _INIT_CALL_PY_EXACT_ARGS - args = &stack_pointer[-oparg]; { + args = &stack_pointer[-oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int has_self = !PyStackRef_IsNull(self_or_null[0]); STAT_INC(CALL, hit); @@ -1209,7 +1163,7 @@ new_frame->localsplus[0] = self_or_null[0]; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; - } + }/* Pushed outputs */ } // _SAVE_RETURN_OFFSET { @@ -1218,23 +1172,24 @@ #endif #if TIER_TWO frame->return_offset = oparg; - #endif + #endif/* Pushed outputs */ } // _PUSH_FRAME { // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); + _PyInterpreterFrame *temp = new_frame;(void)new_frame ; stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); - frame = tstate->current_frame = new_frame; + frame = tstate->current_frame = temp; tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME(); + LLTRACE_RESUME_FRAME();/* Pushed outputs */ } DISPATCH(); } @@ -1255,11 +1210,12 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, CALL); + /* Pushed outputs */ } // _CHECK_METHOD_VERSION - null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; { + null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; uint32_t func_version = read_u32(&this_instr[2].cache); PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); DEOPT_IF(Py_TYPE(callable_o) != &PyMethod_Type, CALL); @@ -1267,35 +1223,26 @@ DEOPT_IF(!PyFunction_Check(func), CALL); DEOPT_IF(((PyFunctionObject *)func)->func_version != func_version, CALL); DEOPT_IF(!PyStackRef_IsNull(null[0]), CALL); + /* Pushed outputs */ } // _EXPAND_METHOD { - self = &stack_pointer[-1 - oparg]; + self = &stack_pointer[1]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - assert(PyStackRef_IsNull(null[0])); + assert(PyStackRef_IsNull(null[0]));(void)null ; assert(Py_TYPE(callable_o) == &PyMethod_Type); -<<<<<<< HEAD - self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); -======= self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); ->>>>>>> main method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); assert(PyStackRef_FunctionCheck(method)); - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable);/* Pushed outputs */ } // flush stack_pointer[-2 - oparg] = method; - stack_pointer[-1 - oparg] = self; // _PY_FRAME_GENERAL - args = &stack_pointer[-oparg]; -<<<<<<< HEAD - self_or_null = self; - callable = method; -======= - self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; ->>>>>>> main { + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = method; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); // oparg counts all of the args, but *not* self: int total_args = oparg; @@ -1306,7 +1253,7 @@ 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)); - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( @@ -1316,9 +1263,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. + stack_pointer[-1].bits = (uintptr_t)new_frame; if (new_frame == NULL) { goto error; - } + }/* Pushed outputs */ } // _SAVE_RETURN_OFFSET { @@ -1327,21 +1275,24 @@ #endif #if TIER_TWO frame->return_offset = oparg; - #endif + #endif/* Pushed outputs */ } // _PUSH_FRAME { // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); + _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); - frame = tstate->current_frame = new_frame; + frame = tstate->current_frame = temp; tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME(); + LLTRACE_RESUME_FRAME();/* Pushed outputs */ } DISPATCH(); } @@ -1358,16 +1309,16 @@ /* Skip 1 cache entry */ /* Skip 2 cache entries */ // _CALL_BUILTIN_CLASS - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; { + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; total_args++; - } + }(void)self_or_null ; DEOPT_IF(!PyType_Check(callable_o), CALL); PyTypeObject *tp = (PyTypeObject *)callable_o; DEOPT_IF(tp->tp_vectorcall == NULL, CALL); @@ -1379,11 +1330,7 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (true) goto error; } PyObject *res_o = tp->tp_vectorcall((PyObject *)tp, args_o, total_args, NULL); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); @@ -1392,17 +1339,13 @@ PyStackRef_CLOSE(args[i]); } PyStackRef_CLOSE(callable); - if (res_o == NULL) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - res = PyStackRef_FromPyObjectSteal(res_o); + if (res_o == NULL) goto error; + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; @@ -1413,7 +1356,7 @@ if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); - } + }/* Pushed outputs */ } stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; @@ -1433,17 +1376,17 @@ /* Skip 1 cache entry */ /* Skip 2 cache entries */ // _CALL_BUILTIN_FAST - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; { + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; /* Builtin METH_FASTCALL functions, without keywords */ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; total_args++; - } + }(void)self_or_null ; DEOPT_IF(!PyCFunction_CheckExact(callable_o), CALL); DEOPT_IF(PyCFunction_GET_FLAGS(callable_o) != METH_FASTCALL, CALL); STAT_INC(CALL, hit); @@ -1456,11 +1399,7 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (true) goto error; } PyObject *res_o = ((PyCFunctionFast)(void(*)(void))cfunc)( PyCFunction_GET_SELF(callable_o), @@ -1473,17 +1412,13 @@ PyStackRef_CLOSE(args[i]); } PyStackRef_CLOSE(callable); - if (res_o == NULL) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - res = PyStackRef_FromPyObjectSteal(res_o); + if (res_o == NULL) goto error; + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; @@ -1494,7 +1429,7 @@ if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); - } + }/* Pushed outputs */ } stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; @@ -1514,10 +1449,10 @@ /* Skip 1 cache entry */ /* Skip 2 cache entries */ // _CALL_BUILTIN_FAST_WITH_KEYWORDS - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; { + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; /* Builtin METH_FASTCALL | METH_KEYWORDS functions */ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; @@ -1539,11 +1474,7 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (true) goto error; } PyObject *res_o = cfunc(PyCFunction_GET_SELF(callable_o), args_o, total_args, NULL); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); @@ -1553,17 +1484,13 @@ PyStackRef_CLOSE(args[i]); } PyStackRef_CLOSE(callable); - if (res_o == NULL) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - res = PyStackRef_FromPyObjectSteal(res_o); + if (res_o == NULL) goto error; + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; @@ -1574,7 +1501,7 @@ if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); - } + }/* Pushed outputs */ } stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; @@ -1594,10 +1521,10 @@ /* Skip 1 cache entry */ /* Skip 2 cache entries */ // _CALL_BUILTIN_O - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; { + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; /* Builtin METH_O functions */ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; @@ -1614,7 +1541,7 @@ PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o); _PyStackRef arg = args[0]; _Py_EnterRecursiveCallTstateUnchecked(tstate); - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg)); @@ -1624,27 +1551,21 @@ PyStackRef_CLOSE(arg); PyStackRef_CLOSE(callable); if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - } + }/* Pushed outputs */ } - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; DISPATCH(); } @@ -1660,13 +1581,13 @@ _PyStackRef kwargs_st = PyStackRef_NULL; _PyStackRef result; // __DO_CALL_FUNCTION_EX - if (oparg & 1) { kwargs_st = stack_pointer[-(oparg & 1)]; } - callargs_st = stack_pointer[-1 - (oparg & 1)]; - func_st = stack_pointer[-3 - (oparg & 1)]; { + if (oparg & 1) { kwargs_st = stack_pointer[-(oparg & 1)]; } + callargs_st = stack_pointer[-1 - (oparg & 1)]; + func_st = stack_pointer[-3 - (oparg & 1)]; PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); PyObject *callargs = PyStackRef_AsPyObjectBorrow(callargs_st); - PyObject *kwargs = PyStackRef_AsPyObjectBorrow(kwargs_st); + PyObject *kwargs = PyStackRef_AsPyObjectSteal(kwargs_st); // DICT_MERGE is called before this opcode if there are kwargs. // It converts all dict subtypes in kwargs into regular dicts. assert(kwargs == NULL || PyDict_CheckExact(kwargs)); @@ -1675,7 +1596,7 @@ if (err < 0) { goto error; } - stack_pointer += -3 - (oparg & 1); + stack_pointer += -(oparg & 1); assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *tuple = PySequence_Tuple(callargs); @@ -1684,16 +1605,19 @@ goto error; } PyStackRef_CLOSE(callargs_st); - callargs_st = PyStackRef_FromPyObjectSteal(tuple); - callargs = tuple;stack_pointer += 3 + (oparg & 1); + callargs = tuple; + } + else { + callargs = PyStackRef_AsPyObjectSteal(callargs_st);stack_pointer += -(oparg & 1); assert(WITHIN_STACK_BOUNDS()); } assert(PyTuple_CheckExact(callargs)); EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_FUNCTION_EX, func); + PyObject *result_o; if (opcode == INSTRUMENTED_CALL_FUNCTION_EX) { PyObject *arg = PyTuple_GET_SIZE(callargs) > 0 ? PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING; - stack_pointer += -3 - (oparg & 1); + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( @@ -1704,13 +1628,10 @@ goto error; } _PyFrame_SetStackPointer(frame, stack_pointer); - result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); + result_o = PyObject_Call(func, callargs, kwargs); stack_pointer = _PyFrame_GetStackPointer(frame); if (!PyFunction_Check(func) && !PyMethod_Check(func)) { if (PyStackRef_IsNull(result)) { - stack_pointer[0] = result; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, @@ -1718,19 +1639,17 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } else { - stack_pointer[0] = result; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, func, arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { - PyStackRef_CLEAR(result); + _PyFrame_SetStackPointer(frame, stack_pointer); + Py_CLEAR(result_o); + stack_pointer = _PyFrame_GetStackPointer(frame); } - }stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + } } } else { @@ -1741,7 +1660,7 @@ Py_ssize_t nargs = PyTuple_GET_SIZE(callargs); int code_flags = ((PyCodeObject *)PyFunction_GET_CODE(func))->co_flags; PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func)); - stack_pointer += -3 - (oparg & 1); + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(tstate, @@ -1749,6 +1668,8 @@ nargs, callargs, kwargs, frame); stack_pointer = _PyFrame_GetStackPointer(frame); // Need to sync the stack since we exit with DISPATCH_INLINED. + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (new_frame == NULL) { goto error; } @@ -1756,41 +1677,35 @@ frame->return_offset = 1; DISPATCH_INLINED(new_frame); } - stack_pointer += -3 - (oparg & 1); + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); + result_o = PyObject_Call(func, callargs, kwargs); stack_pointer = _PyFrame_GetStackPointer(frame); } + Py_DECREF(callargs); PyStackRef_CLOSE(func_st); - PyStackRef_CLOSE(callargs_st); - PyStackRef_XCLOSE(kwargs_st); + Py_XDECREF(kwargs); + result = PyStackRef_FromPyObjectSteal(result_o); if (PyStackRef_IsNull(result)) { - stack_pointer[0] = result; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = result; goto error; } + /* Pushed outputs */ } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[0] = result; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = result; _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - } + }/* Pushed outputs */ } - stack_pointer[0] = result; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = result; DISPATCH(); } @@ -1804,8 +1719,8 @@ assert(oparg <= MAX_INTRINSIC_1); PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value)); PyStackRef_CLOSE(value); - if (res_o == NULL) goto pop_1_error; - res = PyStackRef_FromPyObjectSteal(res_o); + if (res_o == NULL) goto error; + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[-1] = res; DISPATCH(); } @@ -1825,8 +1740,8 @@ PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1); PyStackRef_CLOSE(value2_st); PyStackRef_CLOSE(value1_st); - if (res_o == NULL) goto pop_2_error; - res = PyStackRef_FromPyObjectSteal(res_o); + if (res_o == NULL) goto error; + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1860,7 +1775,7 @@ STAT_INC(CALL, hit); _PyStackRef cls_stackref = args[1]; _PyStackRef inst_stackref = args[0]; - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref)); @@ -1872,10 +1787,8 @@ assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(inst_stackref); PyStackRef_CLOSE(cls_stackref); - PyStackRef_CLOSE(callable); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + PyStackRef_CLOSE(callable);/* Pushed outputs */ + stack_pointer[-1] = res; DISPATCH(); } @@ -1890,34 +1803,54 @@ _PyStackRef *self_or_null; _PyStackRef *args; _PyStackRef kwnames; + _PyStackRef kwnames_in; + _PyStackRef func; + _PyStackRef *maybe_self; + _PyStackRef kwnames_out; _PyStackRef res; // _SPECIALIZE_CALL_KW - self_or_null = &stack_pointer[-2 - oparg]; - callable = stack_pointer[-3 - oparg]; { + self_or_null = &stack_pointer[-2 - oparg]; + callable = stack_pointer[-3 - oparg]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; -<<<<<<< HEAD _PyFrame_SetStackPointer(frame, stack_pointer); - _Py_Specialize_CallKw(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null)); - stack_pointer = _PyFrame_GetStackPointer(frame); -======= _Py_Specialize_CallKw(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); ->>>>>>> main + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(CALL_KW); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION */ + #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ } /* Skip 2 cache entries */ + // _MAYBE_EXPAND_METHOD_KW + { + maybe_self = &stack_pointer[1]; + kwnames_in = stack_pointer[-1]; + args = &stack_pointer[-1 - oparg]; + if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *self = ((PyMethodObject *)callable_o)->im_self; + maybe_self[0] = PyStackRef_FromPyObjectNew(self); + PyObject *method = ((PyMethodObject *)callable_o)->im_func; + func = PyStackRef_FromPyObjectNew(method); + PyStackRef_CLOSE(callable); + } + else { + func = callable;(void)callable ; + } + kwnames_out = kwnames_in;(void)kwnames_in ;/* Pushed outputs */ + } // _DO_CALL_KW - kwnames = stack_pointer[-1]; - args = &stack_pointer[-1 - oparg]; { + kwnames = kwnames_out; + args = &stack_pointer[-1 - oparg]; + self_or_null = &stack_pointer[-2 - oparg]; + callable = func; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); // oparg counts all of the args, but *not* self: @@ -1926,17 +1859,6 @@ args--; total_args++; } - else if (Py_TYPE(callable_o) == &PyMethod_Type) { - args--; - total_args++; - PyObject *self = ((PyMethodObject *)callable_o)->im_self; - args[0] = PyStackRef_FromPyObjectNew(self); - PyObject *method = ((PyMethodObject *)callable_o)->im_func; - args[-1] = PyStackRef_FromPyObjectNew(method); - PyStackRef_CLOSE(callable); - callable_o = method; - callable = args[-1]; - } int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); // Check if the call can be inlined or not if (Py_TYPE(callable_o) == &PyFunction_Type && @@ -1945,8 +1867,8 @@ { 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)); - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-3 - oparg] = callable; + stack_pointer[-1] = kwnames; _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, @@ -1955,6 +1877,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(kwnames); // Sync stack explicitly since we leave using DISPATCH_INLINED(). + stack_pointer += -3 - oparg; + assert(WITHIN_STACK_BOUNDS()); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { @@ -1973,14 +1897,10 @@ PyStackRef_CLOSE(args[_i]); } PyStackRef_CLOSE(kwnames); - if (true) { - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (true) goto error; } - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-3 - oparg] = callable; + stack_pointer[-1] = kwnames; _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -2018,10 +1938,10 @@ PyStackRef_CLOSE(args[i]); } if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-3 - oparg] = res; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -2043,11 +1963,12 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, CALL_KW); + /* Pushed outputs */ } // _CHECK_METHOD_VERSION_KW - null = &stack_pointer[-2 - oparg]; - callable = stack_pointer[-3 - oparg]; { + null = &stack_pointer[-2 - oparg]; + callable = stack_pointer[-3 - oparg]; uint32_t func_version = read_u32(&this_instr[2].cache); PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); DEOPT_IF(Py_TYPE(callable_o) != &PyMethod_Type, CALL_KW); @@ -2055,36 +1976,27 @@ DEOPT_IF(!PyFunction_Check(func), CALL_KW); DEOPT_IF(((PyFunctionObject *)func)->func_version != func_version, CALL_KW); DEOPT_IF(!PyStackRef_IsNull(null[0]), CALL_KW); + /* Pushed outputs */ } // _EXPAND_METHOD_KW - kwnames = stack_pointer[-1]; { - self = &stack_pointer[-2 - oparg]; + self = &stack_pointer[1]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); assert(PyStackRef_IsNull(null[0])); assert(Py_TYPE(callable_o) == &PyMethod_Type); -<<<<<<< HEAD - self = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); -======= self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); ->>>>>>> main method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); assert(PyStackRef_FunctionCheck(method)); - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable);/* Pushed outputs */ } // flush stack_pointer[-3 - oparg] = method; - stack_pointer[-2 - oparg] = self; // _PY_FRAME_KW - args = &stack_pointer[-1 - oparg]; -<<<<<<< HEAD - self_or_null = self; - callable = method; -======= - self_or_null = &stack_pointer[-2 - oparg]; - callable = stack_pointer[-3 - oparg]; ->>>>>>> main { + kwnames = stack_pointer[-1]; + args = &stack_pointer[-1 - oparg]; + self_or_null = &stack_pointer[-2 - oparg]; + callable = method; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); // oparg counts all of the args, but *not* self: int total_args = oparg; @@ -2097,8 +2009,6 @@ 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)); - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, @@ -2108,9 +2018,12 @@ PyStackRef_CLOSE(kwnames); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. + stack_pointer[-3 - oparg].bits = (uintptr_t)new_frame; + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); if (new_frame == NULL) { goto error; - } + }/* Pushed outputs */ } // _SAVE_RETURN_OFFSET { @@ -2119,21 +2032,24 @@ #endif #if TIER_TWO frame->return_offset = oparg; - #endif + #endif/* Pushed outputs */ } // _PUSH_FRAME { // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); + _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); - frame = tstate->current_frame = new_frame; + frame = tstate->current_frame = temp; tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME(); + LLTRACE_RESUME_FRAME();/* Pushed outputs */ } DISPATCH(); } @@ -2151,17 +2067,18 @@ /* Skip 1 cache entry */ /* Skip 2 cache entries */ // _CHECK_IS_NOT_PY_CALLABLE_KW - callable = stack_pointer[-3 - oparg]; { + callable = stack_pointer[-3 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); DEOPT_IF(PyFunction_Check(callable_o), CALL_KW); DEOPT_IF(Py_TYPE(callable_o) == &PyMethod_Type, CALL_KW); + /* Pushed outputs */ } // _CALL_KW_NON_PY - kwnames = stack_pointer[-1]; - args = &stack_pointer[-1 - oparg]; - self_or_null = &stack_pointer[-2 - oparg]; { + kwnames = stack_pointer[-1]; + args = &stack_pointer[-1 - oparg]; + self_or_null = &stack_pointer[-2 - oparg]; #if TIER_ONE assert(opcode != INSTRUMENTED_CALL); #endif @@ -2180,16 +2097,10 @@ PyStackRef_CLOSE(args[_i]); } PyStackRef_CLOSE(kwnames); - if (true) { - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (true) goto error; } PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -2204,26 +2115,26 @@ PyStackRef_CLOSE(args[i]); } if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-3 - oparg] = res; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - stack_pointer += -1; + stack_pointer += 2 + oparg; assert(WITHIN_STACK_BOUNDS()); - } + }/* Pushed outputs */ } - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-3 - oparg] = res; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -2242,21 +2153,23 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, CALL_KW); + /* Pushed outputs */ } // _CHECK_FUNCTION_VERSION_KW - callable = stack_pointer[-3 - oparg]; { + callable = stack_pointer[-3 - oparg]; uint32_t func_version = read_u32(&this_instr[2].cache); PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); DEOPT_IF(!PyFunction_Check(callable_o), CALL_KW); PyFunctionObject *func = (PyFunctionObject *)callable_o; DEOPT_IF(func->func_version != func_version, CALL_KW); + /* Pushed outputs */ } // _PY_FRAME_KW - kwnames = stack_pointer[-1]; - args = &stack_pointer[-1 - oparg]; - self_or_null = &stack_pointer[-2 - oparg]; { + kwnames = stack_pointer[-1]; + args = &stack_pointer[-1 - oparg]; + self_or_null = &stack_pointer[-2 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); // oparg counts all of the args, but *not* self: int total_args = oparg; @@ -2269,8 +2182,6 @@ 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)); - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, @@ -2280,9 +2191,12 @@ PyStackRef_CLOSE(kwnames); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. + stack_pointer[-3 - oparg].bits = (uintptr_t)new_frame; + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); if (new_frame == NULL) { goto error; - } + }/* Pushed outputs */ } // _SAVE_RETURN_OFFSET { @@ -2291,21 +2205,24 @@ #endif #if TIER_TWO frame->return_offset = oparg; - #endif + #endif/* Pushed outputs */ } // _PUSH_FRAME { // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); + _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); - frame = tstate->current_frame = new_frame; + frame = tstate->current_frame = temp; tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME(); + LLTRACE_RESUME_FRAME();/* Pushed outputs */ } DISPATCH(); } @@ -2337,7 +2254,7 @@ STAT_INC(CALL, hit); _PyStackRef arg_stackref = args[0]; PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref); - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(arg); @@ -2354,10 +2271,8 @@ } PyStackRef_CLOSE(callable); PyStackRef_CLOSE(arg_stackref); - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + stack_pointer[-1] = res; DISPATCH(); } @@ -2385,13 +2300,13 @@ int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg)); PyStackRef_CLOSE(self); PyStackRef_CLOSE(callable); - if (err) goto pop_3_error; + if (err) goto error; #if TIER_ONE // Skip the following POP_TOP. This is done here in tier one, and // during trace projection in tier two: assert(next_instr->op.code == POP_TOP); SKIP_OVER(1); - #endif + #endif/* Pushed outputs */ stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -2409,10 +2324,10 @@ /* Skip 1 cache entry */ /* Skip 2 cache entries */ // _CALL_METHOD_DESCRIPTOR_FAST - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; { + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -2437,11 +2352,7 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (true) goto error; } PyObject *res_o = cfunc(self, (args_o + 1), nargs); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); @@ -2451,17 +2362,13 @@ PyStackRef_CLOSE(args[i]); } PyStackRef_CLOSE(callable); - if (res_o == NULL) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - res = PyStackRef_FromPyObjectSteal(res_o); + if (res_o == NULL) goto error; + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; @@ -2472,7 +2379,7 @@ if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); - } + }/* Pushed outputs */ } stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; @@ -2492,10 +2399,10 @@ /* Skip 1 cache entry */ /* Skip 2 cache entries */ // _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; { + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -2520,11 +2427,7 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (true) goto error; } PyObject *res_o = cfunc(self, (args_o + 1), nargs, NULL); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); @@ -2534,17 +2437,13 @@ PyStackRef_CLOSE(args[i]); } PyStackRef_CLOSE(callable); - if (res_o == NULL) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - res = PyStackRef_FromPyObjectSteal(res_o); + if (res_o == NULL) goto error; + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; @@ -2555,7 +2454,7 @@ if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); - } + }/* Pushed outputs */ } stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; @@ -2575,10 +2474,10 @@ /* Skip 1 cache entry */ /* Skip 2 cache entries */ // _CALL_METHOD_DESCRIPTOR_NOARGS - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; { + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; assert(oparg == 0 || oparg == 1); PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; @@ -2599,7 +2498,7 @@ STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; _Py_EnterRecursiveCallTstateUnchecked(tstate); - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL); @@ -2609,27 +2508,21 @@ PyStackRef_CLOSE(self_stackref); PyStackRef_CLOSE(callable); if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - } + }/* Pushed outputs */ } - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; DISPATCH(); } @@ -2645,10 +2538,10 @@ /* Skip 1 cache entry */ /* Skip 2 cache entries */ // _CALL_METHOD_DESCRIPTOR_O - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; { + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -2669,7 +2562,7 @@ STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; _Py_EnterRecursiveCallTstateUnchecked(tstate); - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, @@ -2682,27 +2575,21 @@ PyStackRef_CLOSE(arg_stackref); PyStackRef_CLOSE(callable); if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - } + }/* Pushed outputs */ } - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; DISPATCH(); } @@ -2718,16 +2605,17 @@ /* Skip 1 cache entry */ /* Skip 2 cache entries */ // _CHECK_IS_NOT_PY_CALLABLE - callable = stack_pointer[-2 - oparg]; { + callable = stack_pointer[-2 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); DEOPT_IF(PyFunction_Check(callable_o), CALL); DEOPT_IF(Py_TYPE(callable_o) == &PyMethod_Type, CALL); + /* Pushed outputs */ } // _CALL_NON_PY_GENERAL - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; { + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; #if TIER_ONE assert(opcode != INSTRUMENTED_CALL); #endif @@ -2745,13 +2633,9 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (true) goto error; } - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( @@ -2766,27 +2650,21 @@ PyStackRef_CLOSE(args[i]); } if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - } - } - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + if (err != 0) goto error; + }/* Pushed outputs */ + } + stack_pointer[-1] = res; DISPATCH(); } @@ -2803,24 +2681,27 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, CALL); + /* Pushed outputs */ } // _CHECK_FUNCTION_VERSION - callable = stack_pointer[-2 - oparg]; { + callable = stack_pointer[-2 - oparg]; uint32_t func_version = read_u32(&this_instr[2].cache); PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); DEOPT_IF(!PyFunction_Check(callable_o), CALL); PyFunctionObject *func = (PyFunctionObject *)callable_o; DEOPT_IF(func->func_version != func_version, CALL); + /* Pushed outputs */ } // _CHECK_FUNCTION_EXACT_ARGS - self_or_null = &stack_pointer[-1 - oparg]; { + self_or_null = &stack_pointer[-1 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); assert(PyFunction_Check(callable_o)); PyFunctionObject *func = (PyFunctionObject *)callable_o; PyCodeObject *code = (PyCodeObject *)func->func_code; DEOPT_IF(code->co_argcount != oparg + (!PyStackRef_IsNull(self_or_null[0])), CALL); + /* Pushed outputs */ } // _CHECK_STACK_SPACE { @@ -2829,10 +2710,11 @@ PyCodeObject *code = (PyCodeObject *)func->func_code; DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), CALL); DEOPT_IF(tstate->py_recursion_remaining <= 1, CALL); + /* Pushed outputs */ } // _INIT_CALL_PY_EXACT_ARGS - args = &stack_pointer[-oparg]; { + args = &stack_pointer[-oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); int has_self = !PyStackRef_IsNull(self_or_null[0]); STAT_INC(CALL, hit); @@ -2842,7 +2724,7 @@ new_frame->localsplus[0] = self_or_null[0]; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; - } + }/* Pushed outputs */ } // _SAVE_RETURN_OFFSET { @@ -2851,23 +2733,24 @@ #endif #if TIER_TWO frame->return_offset = oparg; - #endif + #endif/* Pushed outputs */ } // _PUSH_FRAME { // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); + _PyInterpreterFrame *temp = new_frame;(void)new_frame ; stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); - frame = tstate->current_frame = new_frame; + frame = tstate->current_frame = temp; tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME(); + LLTRACE_RESUME_FRAME();/* Pushed outputs */ } DISPATCH(); } @@ -2885,20 +2768,22 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, CALL); + /* Pushed outputs */ } // _CHECK_FUNCTION_VERSION - callable = stack_pointer[-2 - oparg]; { + callable = stack_pointer[-2 - oparg]; uint32_t func_version = read_u32(&this_instr[2].cache); PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); DEOPT_IF(!PyFunction_Check(callable_o), CALL); PyFunctionObject *func = (PyFunctionObject *)callable_o; DEOPT_IF(func->func_version != func_version, CALL); + /* Pushed outputs */ } // _PY_FRAME_GENERAL - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; { + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); // oparg counts all of the args, but *not* self: int total_args = oparg; @@ -2909,7 +2794,7 @@ 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)); - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( @@ -2919,9 +2804,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. + stack_pointer[-1].bits = (uintptr_t)new_frame; if (new_frame == NULL) { goto error; - } + }/* Pushed outputs */ } // _SAVE_RETURN_OFFSET { @@ -2930,21 +2816,24 @@ #endif #if TIER_TWO frame->return_offset = oparg; - #endif + #endif/* Pushed outputs */ } // _PUSH_FRAME { // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); + _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); - frame = tstate->current_frame = new_frame; + frame = tstate->current_frame = temp; tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME(); + LLTRACE_RESUME_FRAME();/* Pushed outputs */ } DISPATCH(); } @@ -2961,47 +2850,47 @@ /* Skip 1 cache entry */ /* Skip 2 cache entries */ // _CALL_STR_1 - arg = stack_pointer[-1]; - null = stack_pointer[-2]; - callable = stack_pointer[-3]; { + arg = stack_pointer[-1]; + null = stack_pointer[-2]; + callable = stack_pointer[-3]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); assert(oparg == 1); DEOPT_IF(!PyStackRef_IsNull(null), CALL); DEOPT_IF(callable_o != (PyObject *)&PyUnicode_Type, CALL); STAT_INC(CALL, hit); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); + (void)null ;(void)callable ; PyStackRef_CLOSE(arg); if (PyStackRef_IsNull(res)) { - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-3] = res; + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); goto error; } + /* Pushed outputs */ } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-3] = res; + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - stack_pointer += -1; + stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); - } + }/* Pushed outputs */ } - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-3] = res; + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3018,47 +2907,47 @@ /* Skip 1 cache entry */ /* Skip 2 cache entries */ // _CALL_TUPLE_1 - arg = stack_pointer[-1]; - null = stack_pointer[-2]; - callable = stack_pointer[-3]; { + arg = stack_pointer[-1]; + null = stack_pointer[-2]; + callable = stack_pointer[-3]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); assert(oparg == 1); DEOPT_IF(!PyStackRef_IsNull(null), CALL); DEOPT_IF(callable_o != (PyObject *)&PyTuple_Type, CALL); STAT_INC(CALL, hit); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); + (void)null ;(void)callable ; PyStackRef_CLOSE(arg); if (PyStackRef_IsNull(res)) { - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-3] = res; + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); goto error; } + /* Pushed outputs */ } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-3] = res; + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - stack_pointer += -1; + stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); - } + }/* Pushed outputs */ } - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-3] = res; + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3081,10 +2970,12 @@ PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); assert(oparg == 1); DEOPT_IF(!PyStackRef_IsNull(null), CALL); + (void)null ; DEOPT_IF(callable_o != (PyObject *)&PyType_Type, CALL); + (void)callable ; STAT_INC(CALL, hit); res = PyStackRef_FromPyObjectSteal(Py_NewRef(Py_TYPE(arg_o))); - PyStackRef_CLOSE(arg); + PyStackRef_CLOSE(arg);/* Pushed outputs */ stack_pointer[-3] = res; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -3103,8 +2994,6 @@ exc_value_st = stack_pointer[-2]; PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st); PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3125,16 +3014,18 @@ assert((match_o == NULL) == (rest_o == NULL)); if (match_o == NULL) goto error; if (!Py_IsNone(match_o)) { + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyErr_SetHandledException(match_o); stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += 2; + assert(WITHIN_STACK_BOUNDS()); } rest = PyStackRef_FromPyObjectSteal(rest_o); - match = PyStackRef_FromPyObjectSteal(match_o); - stack_pointer[0] = rest; - stack_pointer[1] = match; - stack_pointer += 2; - assert(WITHIN_STACK_BOUNDS()); + match = PyStackRef_FromPyObjectSteal(match_o);/* Pushed outputs */ + stack_pointer[-2] = rest; + stack_pointer[-1] = match; DISPATCH(); } @@ -3150,8 +3041,6 @@ PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); assert(PyExceptionInstance_Check(left_o)); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyEval_CheckExceptTypeValid(tstate, right_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3163,10 +3052,8 @@ int res = PyErr_GivenExceptionMatches(left_o, right_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(right); - b = res ? PyStackRef_True : PyStackRef_False; - stack_pointer[0] = b; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + b = res ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + stack_pointer[-1] = b; DISPATCH(); } @@ -3186,8 +3073,6 @@ PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st); assert(throwflag); assert(exc_value && PyExceptionInstance_Check(exc_value)); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int matches = PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3204,10 +3089,10 @@ monitor_reraise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; - } - stack_pointer[0] = none; - stack_pointer[1] = value; - stack_pointer += 2; + }/* Pushed outputs */ + stack_pointer[-3] = none; + stack_pointer[-2] = value; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3223,9 +3108,9 @@ _PyStackRef right; _PyStackRef res; // _SPECIALIZE_COMPARE_OP - right = stack_pointer[-1]; - left = stack_pointer[-2]; { + right = stack_pointer[-1]; + left = stack_pointer[-2]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; #if ENABLE_SPECIALIZATION @@ -3238,15 +3123,13 @@ } OPCODE_DEFERRED_INC(COMPARE_OP); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION */ + #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ } // _COMPARE_OP { PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); assert((oparg >> 5) <= Py_GE); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3254,6 +3137,8 @@ PyStackRef_CLOSE(right); if (res_o == NULL) goto error; if (oparg & 16) { + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int res_bool = PyObject_IsTrue(res_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3262,8 +3147,9 @@ res = res_bool ? PyStackRef_True : PyStackRef_False; } else { - res = PyStackRef_FromPyObjectSteal(res_o); - } + res = PyStackRef_FromPyObjectSteal(res_o);stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); + }/* Pushed outputs */ } stack_pointer[0] = res; stack_pointer += 1; @@ -3280,13 +3166,14 @@ _PyStackRef right; _PyStackRef res; // _GUARD_BOTH_FLOAT - right = stack_pointer[-1]; - left = stack_pointer[-2]; { + right = stack_pointer[-1]; + left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyFloat_CheckExact(left_o), COMPARE_OP); DEOPT_IF(!PyFloat_CheckExact(right_o), COMPARE_OP); + /* Pushed outputs */ } /* Skip 1 cache entry */ // _COMPARE_OP_FLOAT @@ -3298,10 +3185,10 @@ double dright = PyFloat_AS_DOUBLE(right_o); // 1 if NaN, 2 if <, 4 if >, 8 if ==; this matches low four bits of the oparg int sign_ish = COMPARISON_BIT(dleft, dright); - _Py_DECREF_SPECIALIZED(left_o, _PyFloat_ExactDealloc); - _Py_DECREF_SPECIALIZED(right_o, _PyFloat_ExactDealloc); + _Py_DECREF_SPECIALIZED(left_o, _PyFloat_ExactDealloc);(void)left ; + _Py_DECREF_SPECIALIZED(right_o, _PyFloat_ExactDealloc);(void)right ; res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; - // It's always a bool, so we don't care about oparg & 16. + // It's always a bool, so we don't care about oparg & 16./* Pushed outputs */ } stack_pointer[-2] = res; stack_pointer += -1; @@ -3318,13 +3205,14 @@ _PyStackRef right; _PyStackRef res; // _GUARD_BOTH_INT - right = stack_pointer[-1]; - left = stack_pointer[-2]; { + right = stack_pointer[-1]; + left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyLong_CheckExact(left_o), COMPARE_OP); DEOPT_IF(!PyLong_CheckExact(right_o), COMPARE_OP); + /* Pushed outputs */ } /* Skip 1 cache entry */ // _COMPARE_OP_INT @@ -3340,10 +3228,10 @@ Py_ssize_t iright = _PyLong_CompactValue((PyLongObject *)right_o); // 2 if <, 4 if >, 8 if ==; this matches the low 4 bits of the oparg int sign_ish = COMPARISON_BIT(ileft, iright); - _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); - _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); + _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);(void)left ; + _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free);(void)right ; res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; - // It's always a bool, so we don't care about oparg & 16. + // It's always a bool, so we don't care about oparg & 16./* Pushed outputs */ } stack_pointer[-2] = res; stack_pointer += -1; @@ -3360,13 +3248,14 @@ _PyStackRef right; _PyStackRef res; // _GUARD_BOTH_UNICODE - right = stack_pointer[-1]; - left = stack_pointer[-2]; { + right = stack_pointer[-1]; + left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyUnicode_CheckExact(left_o), COMPARE_OP); DEOPT_IF(!PyUnicode_CheckExact(right_o), COMPARE_OP); + /* Pushed outputs */ } /* Skip 1 cache entry */ // _COMPARE_OP_STR @@ -3376,13 +3265,13 @@ STAT_INC(COMPARE_OP, hit); int eq = _PyUnicode_Equal(left_o, right_o); assert((oparg >> 5) == Py_EQ || (oparg >> 5) == Py_NE); - _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc); - _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); + _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc);(void)left ; + _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);(void)right ; assert(eq == 0 || eq == 1); assert((oparg & 0xf) == COMPARISON_NOT_EQUALS || (oparg & 0xf) == COMPARISON_EQUALS); assert(COMPARISON_NOT_EQUALS + 1 == COMPARISON_EQUALS); res = ((COMPARISON_NOT_EQUALS + eq) & oparg) ? PyStackRef_True : PyStackRef_False; - // It's always a bool, so we don't care about oparg & 16. + // It's always a bool, so we don't care about oparg & 16./* Pushed outputs */ } stack_pointer[-2] = res; stack_pointer += -1; @@ -3401,8 +3290,8 @@ _PyStackRef right; _PyStackRef b; // _SPECIALIZE_CONTAINS_OP - right = stack_pointer[-1]; { + right = stack_pointer[-1]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; #if ENABLE_SPECIALIZATION @@ -3415,25 +3304,23 @@ } OPCODE_DEFERRED_INC(CONTAINS_OP); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION */ + #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ } // _CONTAINS_OP - left = stack_pointer[-2]; { + left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int res = PySequence_Contains(right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res < 0) goto error; - b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; + b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ } - stack_pointer[0] = b; - stack_pointer += 1; + stack_pointer[-2] = b; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3453,17 +3340,15 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyDict_CheckExact(right_o), CONTAINS_OP); STAT_INC(CONTAINS_OP, hit); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyDict_Contains(right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res < 0) goto error; - b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; - stack_pointer[0] = b; - stack_pointer += 1; + b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + stack_pointer[-2] = b; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3484,17 +3369,15 @@ DEOPT_IF(!(PySet_CheckExact(right_o) || PyFrozenSet_CheckExact(right_o)), CONTAINS_OP); STAT_INC(CONTAINS_OP, hit); // Note: both set and frozenset use the same seq_contains method! - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PySet_Contains((PySetObject *)right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res < 0) goto error; - b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; - stack_pointer[0] = b; - stack_pointer += 1; + b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + stack_pointer[-2] = b; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3511,8 +3394,8 @@ conv_fn = _PyEval_ConversionFuncs[oparg]; PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value)); PyStackRef_CLOSE(value); - if (result_o == NULL) goto pop_1_error; - result = PyStackRef_FromPyObjectSteal(result_o); + if (result_o == NULL) goto error; + result = PyStackRef_FromPyObjectSteal(result_o);/* Pushed outputs */ stack_pointer[-1] = result; DISPATCH(); } @@ -3525,7 +3408,7 @@ _PyStackRef top; bottom = stack_pointer[-1 - (oparg-1)]; assert(oparg > 0); - top = PyStackRef_DUP(bottom); + top = PyStackRef_DUP(bottom);/* Pushed outputs */ stack_pointer[0] = top; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3545,7 +3428,7 @@ for (int i = 0; i < oparg; ++i) { PyObject *o = PyTuple_GET_ITEM(closure, i); frame->localsplus[offset + i] = PyStackRef_FromPyObjectNew(o); - } + }/* Pushed outputs */ DISPATCH(); } @@ -3556,13 +3439,14 @@ _PyStackRef owner; owner = stack_pointer[-1]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(owner); if (err) goto error; + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3582,7 +3466,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); goto error; } - Py_DECREF(oldobj); + Py_DECREF(oldobj);/* Pushed outputs */ DISPATCH(); } @@ -3600,7 +3484,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (1) goto error; } - SETLOCAL(oparg, PyStackRef_NULL); + SETLOCAL(oparg, PyStackRef_NULL);/* Pushed outputs */ DISPATCH(); } @@ -3622,7 +3506,7 @@ NAME_ERROR_MSG, name); stack_pointer = _PyFrame_GetStackPointer(frame); goto error; - } + }/* Pushed outputs */ DISPATCH(); } @@ -3651,7 +3535,7 @@ name); stack_pointer = _PyFrame_GetStackPointer(frame); goto error; - } + }/* Pushed outputs */ DISPATCH(); } @@ -3664,8 +3548,6 @@ sub = stack_pointer[-1]; container = stack_pointer[-2]; /* del container[sub] */ - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub)); @@ -3673,6 +3555,9 @@ PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); if (err) goto error; + /* Pushed outputs */ + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3689,8 +3574,6 @@ PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_MergeEx(dict_o, update_o, 2); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3702,6 +3585,9 @@ if (true) goto error; } PyStackRef_CLOSE(update); + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3715,8 +3601,6 @@ dict = stack_pointer[-2 - (oparg - 1)]; PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_Update(dict_o, update_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3735,6 +3619,9 @@ if (true) goto error; } PyStackRef_CLOSE(update); + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3749,8 +3636,6 @@ awaitable_st = stack_pointer[-2]; PyObject *exc = PyStackRef_AsPyObjectBorrow(exc_st); assert(exc && PyExceptionInstance_Check(exc)); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int matches = PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3765,7 +3650,9 @@ monitor_reraise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; - } + }/* Pushed outputs */ + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3776,6 +3663,7 @@ _PyStackRef value; value = stack_pointer[-1]; PyStackRef_CLOSE(value); + /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -3787,11 +3675,13 @@ INSTRUCTION_STATS(END_SEND); _PyStackRef receiver; _PyStackRef value; + _PyStackRef val; value = stack_pointer[-1]; receiver = stack_pointer[-2]; (void)receiver; - PyStackRef_CLOSE(receiver); - stack_pointer[-2] = value; + val = value;(void)value ; + PyStackRef_CLOSE(receiver);/* Pushed outputs */ + stack_pointer[-2] = val; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -3826,7 +3716,7 @@ GOTO_TIER_TWO(executor); #else Py_FatalError("ENTER_EXECUTOR is not supported in this build"); - #endif /* _Py_TIER2 */ + #endif /* _Py_TIER2 *//* Pushed outputs */ DISPATCH(); } @@ -3838,15 +3728,13 @@ should_be_none = stack_pointer[-1]; assert(STACK_LEVEL() == 2); if (!PyStackRef_Is(should_be_none, PyStackRef_None)) { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyErr_Format(PyExc_TypeError, "__init__() should return None, not '%.200s'", Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); goto error; - } + }(void)should_be_none ;/* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -3860,7 +3748,7 @@ opcode = next_instr->op.code; oparg = oparg << 8 | next_instr->op.arg; PRE_DISPATCH_GOTO(); - DISPATCH_GOTO(); + DISPATCH_GOTO();/* Pushed outputs */ } TARGET(FORMAT_SIMPLE) { @@ -3874,26 +3762,19 @@ /* If value is a unicode object, then we know the result * of format(value) is value itself. */ if (!PyUnicode_CheckExact(value_o)) { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Format(value_o, NULL)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); if (PyStackRef_IsNull(res)) { - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; goto error; } } else { - res = value;stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - } - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + res = value;(void)value ; + }/* Pushed outputs */ + stack_pointer[-1] = res; DISPATCH(); } @@ -3906,17 +3787,15 @@ _PyStackRef res; fmt_spec = stack_pointer[-1]; value = stack_pointer[-2]; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); PyStackRef_CLOSE(fmt_spec); if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -3931,8 +3810,8 @@ _PyStackRef iter; _PyStackRef next; // _SPECIALIZE_FOR_ITER - iter = stack_pointer[-1]; { + iter = stack_pointer[-1]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; #if ENABLE_SPECIALIZATION @@ -3945,7 +3824,7 @@ } OPCODE_DEFERRED_INC(FOR_ITER); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION */ + #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ } // _FOR_ITER { @@ -3953,11 +3832,7 @@ PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); PyObject *next_o = (*Py_TYPE(iter_o)->tp_iternext)(iter_o); if (next_o == NULL) { - next = PyStackRef_NULL; if (_PyErr_Occurred(tstate)) { - stack_pointer[0] = next; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3968,8 +3843,6 @@ _PyEval_MonitorRaise(tstate, frame, this_instr); _PyErr_Clear(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); } /* iterator ended normally */ assert(next_instr[oparg].op.code == END_FOR || @@ -3981,7 +3854,7 @@ DISPATCH(); } next = PyStackRef_FromPyObjectSteal(next_o); - // Common case: no jump, leave it to the code generator + // Common case: no jump, leave it to the code generator/* Pushed outputs */ } stack_pointer[0] = next; stack_pointer += 1; @@ -4001,10 +3874,11 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, FOR_ITER); + /* Pushed outputs */ } // _FOR_ITER_GEN_FRAME - iter = stack_pointer[-1]; { + iter = stack_pointer[-1]; PyGenObject *gen = (PyGenObject *)PyStackRef_AsPyObjectBorrow(iter); DEOPT_IF(Py_TYPE(gen) != &PyGen_Type, FOR_ITER); DEOPT_IF(gen->gi_frame_state >= FRAME_EXECUTING, FOR_ITER); @@ -4016,22 +3890,23 @@ tstate->exc_info = &gen->gi_exc_state; gen_frame->previous = frame; // oparg is the return offset from the next instruction. - frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_FOR_ITER + oparg); + frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_FOR_ITER + oparg);/* Pushed outputs */ } // _PUSH_FRAME - new_frame = gen_frame; { + new_frame = gen_frame; // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); + _PyInterpreterFrame *temp = new_frame;(void)new_frame ; _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); - frame = tstate->current_frame = new_frame; + frame = tstate->current_frame = temp; tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME(); + LLTRACE_RESUME_FRAME();/* Pushed outputs */ } DISPATCH(); } @@ -4045,9 +3920,10 @@ _PyStackRef next; /* Skip 1 cache entry */ // _ITER_CHECK_LIST - iter = stack_pointer[-1]; { + iter = stack_pointer[-1]; DEOPT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(iter)) != &PyListIter_Type, FOR_ITER); + /* Pushed outputs */ } // _ITER_JUMP_LIST { @@ -4069,7 +3945,7 @@ /* Jump forward oparg, then skip following END_FOR and POP_TOP instructions */ JUMPBY(oparg + 2); DISPATCH(); - } + }/* Pushed outputs */ } // _ITER_NEXT_LIST { @@ -4079,7 +3955,7 @@ PyListObject *seq = it->it_seq; assert(seq); assert(it->it_index < PyList_GET_SIZE(seq)); - next = PyStackRef_FromPyObjectNew(PyList_GET_ITEM(seq, it->it_index++)); + next = PyStackRef_FromPyObjectNew(PyList_GET_ITEM(seq, it->it_index++));/* Pushed outputs */ } stack_pointer[0] = next; stack_pointer += 1; @@ -4096,10 +3972,11 @@ _PyStackRef next; /* Skip 1 cache entry */ // _ITER_CHECK_RANGE - iter = stack_pointer[-1]; { + iter = stack_pointer[-1]; _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); DEOPT_IF(Py_TYPE(r) != &PyRangeIter_Type, FOR_ITER); + /* Pushed outputs */ } // _ITER_JUMP_RANGE { @@ -4112,7 +3989,7 @@ // Jump over END_FOR and POP_TOP instructions. JUMPBY(oparg + 2); DISPATCH(); - } + }/* Pushed outputs */ } // _ITER_NEXT_RANGE { @@ -4124,7 +4001,7 @@ r->len--; PyObject *res = PyLong_FromLong(value); if (res == NULL) goto error; - next = PyStackRef_FromPyObjectSteal(res); + next = PyStackRef_FromPyObjectSteal(res);/* Pushed outputs */ } stack_pointer[0] = next; stack_pointer += 1; @@ -4141,9 +4018,10 @@ _PyStackRef next; /* Skip 1 cache entry */ // _ITER_CHECK_TUPLE - iter = stack_pointer[-1]; { + iter = stack_pointer[-1]; DEOPT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(iter)) != &PyTupleIter_Type, FOR_ITER); + /* Pushed outputs */ } // _ITER_JUMP_TUPLE { @@ -4162,7 +4040,7 @@ /* Jump forward oparg, then skip following END_FOR and POP_TOP instructions */ JUMPBY(oparg + 2); DISPATCH(); - } + }/* Pushed outputs */ } // _ITER_NEXT_TUPLE { @@ -4172,7 +4050,7 @@ PyTupleObject *seq = it->it_seq; assert(seq); assert(it->it_index < PyTuple_GET_SIZE(seq)); - next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq, it->it_index++)); + next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq, it->it_index++));/* Pushed outputs */ } stack_pointer[0] = next; stack_pointer += 1; @@ -4195,8 +4073,6 @@ getter = type->tp_as_async->am_aiter; } if (getter == NULL) { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'async for' requires an object with " @@ -4208,7 +4084,7 @@ } iter_o = (*getter)(obj_o); PyStackRef_CLOSE(obj); - if (iter_o == NULL) goto pop_1_error; + if (iter_o == NULL) goto error; if (Py_TYPE(iter_o)->tp_as_async == NULL || Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) { stack_pointer += -1; @@ -4222,7 +4098,7 @@ Py_DECREF(iter_o); if (true) goto error; } - iter = PyStackRef_FromPyObjectSteal(iter_o); + iter = PyStackRef_FromPyObjectSteal(iter_o);/* Pushed outputs */ stack_pointer[-1] = iter; DISPATCH(); } @@ -4240,7 +4116,7 @@ if (awaitable_o == NULL) { goto error; } - awaitable = PyStackRef_FromPyObjectSteal(awaitable_o); + awaitable = PyStackRef_FromPyObjectSteal(awaitable_o);/* Pushed outputs */ stack_pointer[0] = awaitable; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -4254,17 +4130,13 @@ _PyStackRef iterable; _PyStackRef iter; iterable = stack_pointer[-1]; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); if (iter_o == NULL) goto error; - iter = PyStackRef_FromPyObjectSteal(iter_o); - stack_pointer[0] = iter; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + iter = PyStackRef_FromPyObjectSteal(iter_o);/* Pushed outputs */ + stack_pointer[-1] = iter; DISPATCH(); } @@ -4276,21 +4148,16 @@ _PyStackRef iter; iterable = stack_pointer[-1]; /* before: [obj]; after [getiter(obj)] */ - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable))); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); if (PyStackRef_IsNull(iter)) { - stack_pointer[0] = iter; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = iter; goto error; } - stack_pointer[0] = iter; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + /* Pushed outputs */ + stack_pointer[-1] = iter; DISPATCH(); } @@ -4310,7 +4177,7 @@ PyObject *len_o = PyLong_FromSsize_t(len_i); stack_pointer = _PyFrame_GetStackPointer(frame); if (len_o == NULL) goto error; - len = PyStackRef_FromPyObjectSteal(len_o); + len = PyStackRef_FromPyObjectSteal(len_o);/* Pushed outputs */ stack_pointer[0] = len; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -4331,8 +4198,6 @@ if (!(_PyFrame_GetCode(frame)->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) { /* and it is used in a 'yield from' expression of a regular generator. */ - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_TypeError, "cannot 'yield from' a coroutine object " @@ -4340,25 +4205,22 @@ stack_pointer = _PyFrame_GetStackPointer(frame); goto error; } - iter = iterable; + iter = iterable;(void)iterable ; } else if (PyGen_CheckExact(iterable_o)) { - iter = iterable; + iter = iterable;(void)iterable ; } else { /* `iterable` is not a generator. */ - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); stack_pointer = _PyFrame_GetStackPointer(frame); + (void)iterable ; if (PyStackRef_IsNull(iter)) { goto error; } PyStackRef_CLOSE(iterable); - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - } + }/* Pushed outputs */ stack_pointer[-1] = iter; DISPATCH(); } @@ -4375,7 +4237,7 @@ PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name); stack_pointer = _PyFrame_GetStackPointer(frame); if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -4392,8 +4254,6 @@ fromlist = stack_pointer[-1]; level = stack_pointer[-2]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_ImportName(tstate, frame, name, PyStackRef_AsPyObjectBorrow(fromlist), @@ -4402,9 +4262,9 @@ PyStackRef_CLOSE(level); PyStackRef_CLOSE(fromlist); if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -4422,36 +4282,27 @@ _PyStackRef res; /* Skip 3 cache entries */ // _MAYBE_EXPAND_METHOD - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; { - maybe_self = &stack_pointer[-1 - oparg]; + maybe_self = &stack_pointer[1]; + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); -<<<<<<< HEAD - PyObject *method = ((PyMethodObject *)callable_o)->im_func; - func = PyStackRef_FromPyObjectNew(method); - PyObject *self = ((PyMethodObject *)callable_o)->im_self; - maybe_self = PyStackRef_FromPyObjectNew(self); - /* Make sure that callable and all args are in memory */ - args[-2] = func; - args[-1] = maybe_self; -======= PyObject *self = ((PyMethodObject *)callable_o)->im_self; maybe_self[0] = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; func = PyStackRef_FromPyObjectNew(method); - stack_pointer[-2 - oparg] = func; ->>>>>>> main - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable);(void)self_or_null ; } else { - func = callable; - } + func = callable;(void)callable ;(void)self_or_null ; + }/* Pushed outputs */ } // _MONITOR_CALL { + args = &stack_pointer[-oparg]; + maybe_self = &stack_pointer[-1 - oparg]; int is_meth = !PyStackRef_IsNull(maybe_self[0]); PyObject *function = PyStackRef_AsPyObjectBorrow(func); PyObject *arg0; @@ -4465,7 +4316,6 @@ arg0 = &_PyInstrumentation_MISSING; } stack_pointer[-2 - oparg] = func; - stack_pointer[-1 - oparg] = maybe_self; _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, @@ -4473,11 +4323,12 @@ ); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) goto error; + /* Pushed outputs */ } // _DO_CALL - self_or_null = maybe_self; - callable = func; { + self_or_null = maybe_self; + callable = func; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); // oparg counts all of the args, but *not* self: int total_args = oparg; @@ -4492,7 +4343,7 @@ { 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)); - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( @@ -4501,6 +4352,8 @@ ); stack_pointer = _PyFrame_GetStackPointer(frame); // Manipulate stack directly since we leave using DISPATCH_INLINED(). + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. if (new_frame == NULL) { @@ -4516,13 +4369,9 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - if (true) { - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (true) goto error; } - stack_pointer += -2 - oparg; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( @@ -4560,27 +4409,21 @@ PyStackRef_CLOSE(args[i]); } if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - } + }/* Pushed outputs */ } - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; DISPATCH(); } @@ -4588,7 +4431,7 @@ frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(INSTRUMENTED_CALL_FUNCTION_EX); - GO_TO_INSTRUCTION(CALL_FUNCTION_EX); + GO_TO_INSTRUCTION(CALL_FUNCTION_EX);/* Pushed outputs */ } TARGET(INSTRUMENTED_CALL_KW) { @@ -4612,7 +4455,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (err) goto error; PAUSE_ADAPTIVE_COUNTER(this_instr[1].counter); - GO_TO_INSTRUCTION(CALL_KW); + GO_TO_INSTRUCTION(CALL_KW);/* Pushed outputs */ } TARGET(INSTRUMENTED_END_FOR) { @@ -4626,16 +4469,16 @@ receiver = stack_pointer[-2]; /* Need to create a fake StopIteration error here, * to conform to PEP 380 */ - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_GenCheck(receiver)) { _PyFrame_SetStackPointer(frame, stack_pointer); int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); - PyStackRef_CLOSE(value); if (err) goto error; } PyStackRef_CLOSE(value); + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -4646,27 +4489,20 @@ INSTRUCTION_STATS(INSTRUMENTED_END_SEND); _PyStackRef receiver; _PyStackRef value; + _PyStackRef val; value = stack_pointer[-1]; receiver = stack_pointer[-2]; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver); if (PyGen_Check(receiver_o) || PyCoro_CheckExact(receiver_o)) { - stack_pointer[0] = value; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) { - PyStackRef_CLOSE(receiver); - goto error; - }stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + if (err) goto error; } - PyStackRef_CLOSE(receiver); - stack_pointer[0] = value; - stack_pointer += 1; + val = value;(void)value ; + PyStackRef_CLOSE(receiver);/* Pushed outputs */ + stack_pointer[-2] = val; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -4706,7 +4542,7 @@ /* Skip END_FOR and POP_TOP */ target = next_instr + oparg + 2; } - INSTRUMENTED_JUMP(this_instr, target, PY_MONITORING_EVENT_BRANCH); + INSTRUMENTED_JUMP(this_instr, target, PY_MONITORING_EVENT_BRANCH);/* Pushed outputs */ DISPATCH(); } @@ -4726,7 +4562,7 @@ } assert(next_opcode > 0 && next_opcode < 256); opcode = next_opcode; - DISPATCH_GOTO(); + DISPATCH_GOTO();/* Pushed outputs */ } TARGET(INSTRUMENTED_JUMP_BACKWARD) { @@ -4738,17 +4574,17 @@ // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - } + }/* Pushed outputs */ } // _MONITOR_JUMP_BACKWARD { - INSTRUMENTED_JUMP(this_instr, next_instr - oparg, PY_MONITORING_EVENT_JUMP); + INSTRUMENTED_JUMP(this_instr, next_instr - oparg, PY_MONITORING_EVENT_JUMP);/* Pushed outputs */ } DISPATCH(); } @@ -4758,7 +4594,7 @@ (void)this_instr; next_instr += 1; INSTRUCTION_STATS(INSTRUMENTED_JUMP_FORWARD); - INSTRUMENTED_JUMP(this_instr, next_instr + oparg, PY_MONITORING_EVENT_JUMP); + INSTRUMENTED_JUMP(this_instr, next_instr + oparg, PY_MONITORING_EVENT_JUMP);/* Pushed outputs */ DISPATCH(); } @@ -4796,7 +4632,7 @@ PAUSE_ADAPTIVE_COUNTER(cache->counter); } opcode = original_opcode; - DISPATCH_GOTO(); + DISPATCH_GOTO();/* Pushed outputs */ } TARGET(INSTRUMENTED_LOAD_SUPER_ATTR) { @@ -4808,7 +4644,9 @@ // cancel out the decrement that will happen in LOAD_SUPER_ATTR; we // don't want to specialize instrumented instructions PAUSE_ADAPTIVE_COUNTER(this_instr[1].counter); - GO_TO_INSTRUCTION(LOAD_SUPER_ATTR); + GO_TO_INSTRUCTION(LOAD_SUPER_ATTR);/* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } TARGET(INSTRUMENTED_POP_JUMP_IF_FALSE) { @@ -4824,7 +4662,7 @@ #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif - INSTRUMENTED_JUMP(this_instr, next_instr + offset, PY_MONITORING_EVENT_BRANCH); + INSTRUMENTED_JUMP(this_instr, next_instr + offset, PY_MONITORING_EVENT_BRANCH);/* Pushed outputs */ DISPATCH(); } @@ -4847,7 +4685,7 @@ #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif - INSTRUMENTED_JUMP(this_instr, next_instr + offset, PY_MONITORING_EVENT_BRANCH); + INSTRUMENTED_JUMP(this_instr, next_instr + offset, PY_MONITORING_EVENT_BRANCH);/* Pushed outputs */ DISPATCH(); } @@ -4870,7 +4708,7 @@ #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | !nflag; #endif - INSTRUMENTED_JUMP(this_instr, next_instr + offset, PY_MONITORING_EVENT_BRANCH); + INSTRUMENTED_JUMP(this_instr, next_instr + offset, PY_MONITORING_EVENT_BRANCH);/* Pushed outputs */ DISPATCH(); } @@ -4887,7 +4725,7 @@ #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif - INSTRUMENTED_JUMP(this_instr, next_instr + offset, PY_MONITORING_EVENT_BRANCH); + INSTRUMENTED_JUMP(this_instr, next_instr + offset, PY_MONITORING_EVENT_BRANCH);/* Pushed outputs */ DISPATCH(); } @@ -4911,7 +4749,7 @@ next_instr = this_instr; DISPATCH(); } - } + }/* Pushed outputs */ } // _CHECK_PERIODIC_IF_NOT_YIELD_FROM { @@ -4924,7 +4762,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; } - } + }/* Pushed outputs */ } // _MONITOR_RESUME { @@ -4936,7 +4774,7 @@ if (frame->instr_ptr != this_instr) { /* Instrumentation has jumped */ next_instr = frame->instr_ptr; - } + }/* Pushed outputs */ } DISPATCH(); } @@ -4952,11 +4790,11 @@ _PyStackRef res; // _LOAD_CONST { - value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg)); + value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg));/* Pushed outputs */ } // _RETURN_VALUE_EVENT - val = value; { + val = value; stack_pointer[0] = val; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -4966,13 +4804,15 @@ frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) goto error; + /* Pushed outputs */ } // _RETURN_VALUE - retval = val; { + retval = val; #if TIER_ONE assert(frame != &entry_frame); #endif + _PyStackRef temp = retval;(void)retval ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -4982,10 +4822,10 @@ _PyInterpreterFrame *dying = frame; frame = tstate->current_frame = dying->previous; _PyEval_FrameClearAndPop(tstate, dying); - LOAD_SP(); + stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(frame->return_offset); - res = retval; - LLTRACE_RESUME_FRAME(); + res = temp; + LLTRACE_RESUME_FRAME();/* Pushed outputs */ } stack_pointer[0] = res; stack_pointer += 1; @@ -5002,21 +4842,23 @@ _PyStackRef retval; _PyStackRef res; // _RETURN_VALUE_EVENT - val = stack_pointer[-1]; { + val = stack_pointer[-1]; _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_arg( tstate, PY_MONITORING_EVENT_PY_RETURN, frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) goto error; + /* Pushed outputs */ } // _RETURN_VALUE - retval = val; { + retval = val; #if TIER_ONE assert(frame != &entry_frame); #endif + _PyStackRef temp = retval;(void)retval ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -5026,10 +4868,10 @@ _PyInterpreterFrame *dying = frame; frame = tstate->current_frame = dying->previous; _PyEval_FrameClearAndPop(tstate, dying); - LOAD_SP(); + stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(frame->return_offset); - res = retval; - LLTRACE_RESUME_FRAME(); + res = temp; + LLTRACE_RESUME_FRAME();/* Pushed outputs */ } stack_pointer[0] = res; stack_pointer += 1; @@ -5046,8 +4888,8 @@ _PyStackRef retval; _PyStackRef value; // _YIELD_VALUE_EVENT - val = stack_pointer[-1]; { + val = stack_pointer[-1]; _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_arg( tstate, PY_MONITORING_EVENT_PY_YIELD, @@ -5059,11 +4901,11 @@ if (frame->instr_ptr != this_instr) { next_instr = frame->instr_ptr; DISPATCH(); - } + }/* Pushed outputs */ } // _YIELD_VALUE - retval = val; { + retval = val; // NOTE: It's important that YIELD_VALUE never raises an exception! // The compiler treats any exception raised here as a failed close() // or throw() call. @@ -5071,14 +4913,15 @@ assert(frame != &entry_frame); #endif frame->instr_ptr++; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); stack_pointer = _PyFrame_GetStackPointer(frame); assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; + _PyStackRef temp = retval;(void)retval ; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); tstate->exc_info = gen->gi_exc_state.previous_item; gen->gi_exc_state.previous_item = NULL; @@ -5096,10 +4939,10 @@ _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT || _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR); #endif + stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND); - LOAD_SP(); - value = retval; - LLTRACE_RESUME_FRAME(); + value = temp; + LLTRACE_RESUME_FRAME();/* Pushed outputs */ } stack_pointer[0] = value; stack_pointer += 1; @@ -5114,8 +4957,6 @@ _PyStackRef retval; retval = stack_pointer[-1]; assert(frame == &entry_frame); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); assert(_PyFrame_IsIncomplete(frame)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5123,7 +4964,9 @@ tstate->current_frame = frame->previous; assert(!_PyErr_Occurred(tstate)); tstate->c_recursion_remaining += PY_EVAL_C_STACK_UNITS; - return PyStackRef_AsPyObjectSteal(retval); + return PyStackRef_AsPyObjectSteal(retval);/* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } TARGET(IS_OP) { @@ -5144,7 +4987,7 @@ #endif PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - b = res ? PyStackRef_True : PyStackRef_False; + b = res ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ stack_pointer[-2] = b; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -5159,13 +5002,13 @@ // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); - QSBR_QUIESCENT_STATE(tstate); \ + QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - } + }/* Pushed outputs */ } // _JUMP_BACKWARD { @@ -5201,7 +5044,7 @@ ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); } #endif /* ENABLE_SPECIALIZATION */ - #endif /* _Py_TIER2 */ + #endif /* _Py_TIER2 *//* Pushed outputs */ } DISPATCH(); } @@ -5215,7 +5058,7 @@ * generator or coroutine, so we deliberately do not check it here. * (see bpo-30039). */ - JUMPBY(-oparg); + JUMPBY(-oparg);/* Pushed outputs */ DISPATCH(); } @@ -5223,7 +5066,7 @@ frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(JUMP_FORWARD); - JUMPBY(oparg); + JUMPBY(oparg);/* Pushed outputs */ DISPATCH(); } @@ -5235,8 +5078,10 @@ _PyStackRef v; v = stack_pointer[-1]; list = stack_pointer[-2 - (oparg-1)]; - if (_PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list), - PyStackRef_AsPyObjectSteal(v)) < 0) goto pop_1_error; + int err = _PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list), + PyStackRef_AsPyObjectSteal(v)); + if (err < 0) goto error; + /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -5252,8 +5097,6 @@ list_st = stack_pointer[-2 - (oparg-1)]; PyObject *list = PyStackRef_AsPyObjectBorrow(list_st); PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5276,6 +5119,9 @@ } assert(Py_IsNone(none_val)); PyStackRef_CLOSE(iterable_st); + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -5290,8 +5136,8 @@ _PyStackRef attr; _PyStackRef self_or_null = PyStackRef_NULL; // _SPECIALIZE_LOAD_ATTR - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; #if ENABLE_SPECIALIZATION @@ -5305,7 +5151,7 @@ } OPCODE_DEFERRED_INC(LOAD_ATTR); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION */ + #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ } /* Skip 8 cache entries */ // _LOAD_ATTR @@ -5315,8 +5161,6 @@ if (oparg & 1) { /* Designed to work in tandem with CALL, pushes two values. */ attr_o = NULL; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int is_meth = _PyObject_GetMethod(PyStackRef_AsPyObjectBorrow(owner), name, &attr_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5326,7 +5170,7 @@ meth | self | arg1 | ... | argN */ assert(attr_o != NULL); // No errors on this branch - self_or_null = owner; // Transfer ownership + self_or_null = owner; // Transfer ownership(void)owner ; } else { /* meth is not an unbound method (but a regular attr, or @@ -5342,8 +5186,6 @@ } else { /* Classic, pushes one value. */ - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5352,11 +5194,11 @@ /* We need to define self_or_null on all paths */ self_or_null = PyStackRef_NULL; } - attr = PyStackRef_FromPyObjectSteal(attr_o); + attr = PyStackRef_FromPyObjectSteal(attr_o);/* Pushed outputs */ } - stack_pointer[0] = attr; - if (oparg & 1) stack_pointer[1] = self_or_null; - stack_pointer += 1 + (oparg & 1); + stack_pointer[-1] = attr; + if (oparg & 1) stack_pointer[0] = self_or_null; + stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -5371,13 +5213,14 @@ _PyStackRef null = PyStackRef_NULL; /* Skip 1 cache entry */ // _CHECK_ATTR_CLASS - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint32_t type_version = read_u32(&this_instr[2].cache); PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); DEOPT_IF(!PyType_Check(owner_o), LOAD_ATTR); assert(type_version != 0); DEOPT_IF(((PyTypeObject *)owner_o)->tp_version_tag != type_version, LOAD_ATTR); + /* Pushed outputs */ } /* Skip 2 cache entries */ // _LOAD_ATTR_CLASS @@ -5388,6 +5231,7 @@ attr = PyStackRef_FromPyObjectNew(descr); null = PyStackRef_NULL; PyStackRef_CLOSE(owner); + /* Pushed outputs */ } stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; @@ -5406,13 +5250,14 @@ _PyStackRef null = PyStackRef_NULL; /* Skip 1 cache entry */ // _CHECK_ATTR_CLASS - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint32_t type_version = read_u32(&this_instr[2].cache); PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); DEOPT_IF(!PyType_Check(owner_o), LOAD_ATTR); assert(type_version != 0); DEOPT_IF(((PyTypeObject *)owner_o)->tp_version_tag != type_version, LOAD_ATTR); + /* Pushed outputs */ } // _GUARD_TYPE_VERSION { @@ -5420,6 +5265,7 @@ PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); + /* Pushed outputs */ } // _LOAD_ATTR_CLASS { @@ -5429,6 +5275,7 @@ attr = PyStackRef_FromPyObjectNew(descr); null = PyStackRef_NULL; PyStackRef_CLOSE(owner); + /* Pushed outputs */ } stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; @@ -5467,10 +5314,10 @@ _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, f, 2, frame); // Manipulate stack directly because we exit with DISPATCH_INLINED(). STACK_SHRINK(1); - new_frame->localsplus[0] = owner; + new_frame->localsplus[0] = owner;(void)owner ; new_frame->localsplus[1] = PyStackRef_FromPyObjectNew(name); frame->return_offset = (uint16_t)(next_instr - this_instr); - DISPATCH_INLINED(new_frame); + DISPATCH_INLINED(new_frame);/* Pushed outputs */ } TARGET(LOAD_ATTR_INSTANCE_VALUE) { @@ -5483,12 +5330,13 @@ _PyStackRef null = PyStackRef_NULL; /* Skip 1 cache entry */ // _GUARD_TYPE_VERSION - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint32_t type_version = read_u32(&this_instr[2].cache); PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); + /* Pushed outputs */ } // _CHECK_MANAGED_OBJECT_HAS_VALUES { @@ -5496,6 +5344,7 @@ assert(Py_TYPE(owner_o)->tp_dictoffset < 0); assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); DEOPT_IF(!_PyObject_InlineValues(owner_o)->valid, LOAD_ATTR); + /* Pushed outputs */ } // _LOAD_ATTR_INSTANCE_VALUE { @@ -5509,6 +5358,7 @@ null = PyStackRef_NULL; attr = PyStackRef_FromPyObjectSteal(attr_o); PyStackRef_CLOSE(owner); + /* Pushed outputs */ } /* Skip 5 cache entries */ stack_pointer[-1] = attr; @@ -5528,12 +5378,13 @@ _PyStackRef self = PyStackRef_NULL; /* Skip 1 cache entry */ // _GUARD_TYPE_VERSION - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint32_t type_version = read_u32(&this_instr[2].cache); PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); + /* Pushed outputs */ } // _CHECK_ATTR_METHOD_LAZY_DICT { @@ -5542,6 +5393,7 @@ PyObject *dict = *(PyObject **)ptr; /* This object has a __dict__, just not yet created */ DEOPT_IF(dict != NULL, LOAD_ATTR); + /* Pushed outputs */ } /* Skip 1 cache entry */ // _LOAD_ATTR_METHOD_LAZY_DICT @@ -5552,7 +5404,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner; + self = owner;(void)owner ;/* Pushed outputs */ } stack_pointer[-1] = attr; stack_pointer[0] = self; @@ -5571,12 +5423,13 @@ _PyStackRef self = PyStackRef_NULL; /* Skip 1 cache entry */ // _GUARD_TYPE_VERSION - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint32_t type_version = read_u32(&this_instr[2].cache); PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); + /* Pushed outputs */ } /* Skip 2 cache entries */ // _LOAD_ATTR_METHOD_NO_DICT @@ -5588,7 +5441,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner; + self = owner;(void)owner ;/* Pushed outputs */ } stack_pointer[-1] = attr; stack_pointer[0] = self; @@ -5607,18 +5460,20 @@ _PyStackRef self = PyStackRef_NULL; /* Skip 1 cache entry */ // _GUARD_TYPE_VERSION - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint32_t type_version = read_u32(&this_instr[2].cache); PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); + /* Pushed outputs */ } // _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT { PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); DEOPT_IF(!_PyObject_InlineValues(owner_o)->valid, LOAD_ATTR); + /* Pushed outputs */ } // _GUARD_KEYS_VERSION { @@ -5626,6 +5481,7 @@ PyTypeObject *owner_cls = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); PyHeapTypeObject *owner_heap_type = (PyHeapTypeObject *)owner_cls; DEOPT_IF(owner_heap_type->ht_cached_keys->dk_version != keys_version, LOAD_ATTR); + /* Pushed outputs */ } // _LOAD_ATTR_METHOD_WITH_VALUES { @@ -5636,7 +5492,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner; + self = owner;(void)owner ;/* Pushed outputs */ } stack_pointer[-1] = attr; stack_pointer[0] = self; @@ -5655,14 +5511,15 @@ _PyStackRef null = PyStackRef_NULL; /* Skip 1 cache entry */ // _CHECK_ATTR_MODULE - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint32_t dict_version = read_u32(&this_instr[2].cache); PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); DEOPT_IF(!PyModule_CheckExact(owner_o), LOAD_ATTR); PyDictObject *dict = (PyDictObject *)((PyModuleObject *)owner_o)->md_dict; assert(dict != NULL); DEOPT_IF(dict->ma_keys->dk_version != dict_version, LOAD_ATTR); + /* Pushed outputs */ } // _LOAD_ATTR_MODULE { @@ -5679,6 +5536,7 @@ attr = PyStackRef_FromPyObjectSteal(attr_o); null = PyStackRef_NULL; PyStackRef_CLOSE(owner); + /* Pushed outputs */ } /* Skip 5 cache entries */ stack_pointer[-1] = attr; @@ -5697,12 +5555,13 @@ _PyStackRef attr; /* Skip 1 cache entry */ // _GUARD_TYPE_VERSION - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint32_t type_version = read_u32(&this_instr[2].cache); PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); + /* Pushed outputs */ } /* Skip 2 cache entries */ // _LOAD_ATTR_NONDESCRIPTOR_NO_DICT @@ -5713,7 +5572,7 @@ STAT_INC(LOAD_ATTR, hit); assert(descr != NULL); PyStackRef_CLOSE(owner); - attr = PyStackRef_FromPyObjectNew(descr); + attr = PyStackRef_FromPyObjectNew(descr);/* Pushed outputs */ } stack_pointer[-1] = attr; DISPATCH(); @@ -5728,18 +5587,20 @@ _PyStackRef attr; /* Skip 1 cache entry */ // _GUARD_TYPE_VERSION - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint32_t type_version = read_u32(&this_instr[2].cache); PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); + /* Pushed outputs */ } // _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT { PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); DEOPT_IF(!_PyObject_InlineValues(owner_o)->valid, LOAD_ATTR); + /* Pushed outputs */ } // _GUARD_KEYS_VERSION { @@ -5747,6 +5608,7 @@ PyTypeObject *owner_cls = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); PyHeapTypeObject *owner_heap_type = (PyHeapTypeObject *)owner_cls; DEOPT_IF(owner_heap_type->ht_cached_keys->dk_version != keys_version, LOAD_ATTR); + /* Pushed outputs */ } // _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES { @@ -5755,7 +5617,7 @@ STAT_INC(LOAD_ATTR, hit); assert(descr != NULL); PyStackRef_CLOSE(owner); - attr = PyStackRef_FromPyObjectNew(descr); + attr = PyStackRef_FromPyObjectNew(descr);/* Pushed outputs */ } stack_pointer[-1] = attr; DISPATCH(); @@ -5772,14 +5634,16 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, LOAD_ATTR); + /* Pushed outputs */ } // _GUARD_TYPE_VERSION - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint32_t type_version = read_u32(&this_instr[2].cache); PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); + /* Pushed outputs */ } /* Skip 2 cache entries */ // _LOAD_ATTR_PROPERTY_FRAME @@ -5796,7 +5660,7 @@ STAT_INC(LOAD_ATTR, hit); Py_INCREF(fget); new_frame = _PyFrame_PushUnchecked(tstate, f, 1, frame); - new_frame->localsplus[0] = owner; + new_frame->localsplus[0] = owner;(void)owner ;/* Pushed outputs */ } // _SAVE_RETURN_OFFSET { @@ -5805,23 +5669,24 @@ #endif #if TIER_TWO frame->return_offset = oparg; - #endif + #endif/* Pushed outputs */ } // _PUSH_FRAME { // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); + _PyInterpreterFrame *temp = new_frame;(void)new_frame ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); - frame = tstate->current_frame = new_frame; + frame = tstate->current_frame = temp; tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME(); + LLTRACE_RESUME_FRAME();/* Pushed outputs */ } DISPATCH(); } @@ -5836,12 +5701,13 @@ _PyStackRef null = PyStackRef_NULL; /* Skip 1 cache entry */ // _GUARD_TYPE_VERSION - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint32_t type_version = read_u32(&this_instr[2].cache); PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); + /* Pushed outputs */ } // _LOAD_ATTR_SLOT { @@ -5854,6 +5720,7 @@ null = PyStackRef_NULL; attr = PyStackRef_FromPyObjectNew(attr_o); PyStackRef_CLOSE(owner); + /* Pushed outputs */ } /* Skip 5 cache entries */ stack_pointer[-1] = attr; @@ -5873,12 +5740,13 @@ _PyStackRef null = PyStackRef_NULL; /* Skip 1 cache entry */ // _GUARD_TYPE_VERSION - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint32_t type_version = read_u32(&this_instr[2].cache); PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); + /* Pushed outputs */ } // _CHECK_ATTR_WITH_HINT { @@ -5886,7 +5754,7 @@ assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_MANAGED_DICT); PyDictObject *dict = _PyObject_GetManagedDict(owner_o); DEOPT_IF(dict == NULL, LOAD_ATTR); - assert(PyDict_CheckExact((PyObject *)dict)); + assert(PyDict_CheckExact((PyObject *)dict));/* Pushed outputs */ } // _LOAD_ATTR_WITH_HINT { @@ -5906,6 +5774,7 @@ attr = PyStackRef_FromPyObjectSteal(attr_o); null = PyStackRef_NULL; PyStackRef_CLOSE(owner); + /* Pushed outputs */ } /* Skip 5 cache entries */ stack_pointer[-1] = attr; @@ -5932,7 +5801,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (true) goto error; } - bc = PyStackRef_FromPyObjectSteal(bc_o); + bc = PyStackRef_FromPyObjectSteal(bc_o);/* Pushed outputs */ stack_pointer[0] = bc; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5956,7 +5825,7 @@ default: Py_FatalError("bad LOAD_COMMON_CONSTANT oparg"); } - value = PyStackRef_FromPyObjectImmortal(val); + value = PyStackRef_FromPyObjectImmortal(val);/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5968,7 +5837,7 @@ next_instr += 1; INSTRUCTION_STATS(LOAD_CONST); _PyStackRef value; - value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg)); + value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg));/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5988,7 +5857,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (true) goto error; } - value = PyStackRef_FromPyObjectSteal(value_o); + value = PyStackRef_FromPyObjectSteal(value_o);/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6001,7 +5870,7 @@ INSTRUCTION_STATS(LOAD_FAST); _PyStackRef value; assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg)); + value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6015,7 +5884,7 @@ _PyStackRef value; value = GETLOCAL(oparg); // do not use SETLOCAL here, it decrefs the old value - GETLOCAL(oparg) = PyStackRef_NULL; + GETLOCAL(oparg) = PyStackRef_NULL;/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6037,7 +5906,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (1) goto error; } - value = PyStackRef_DUP(value_s); + value = PyStackRef_DUP(value_s);/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6053,7 +5922,7 @@ uint32_t oparg1 = oparg >> 4; uint32_t oparg2 = oparg & 15; value1 = PyStackRef_DUP(GETLOCAL(oparg1)); - value2 = PyStackRef_DUP(GETLOCAL(oparg2)); + value2 = PyStackRef_DUP(GETLOCAL(oparg2));/* Pushed outputs */ stack_pointer[0] = value1; stack_pointer[1] = value2; stack_pointer += 2; @@ -6074,8 +5943,6 @@ assert(class_dict); assert(oparg >= 0 && oparg < _PyFrame_GetCode(frame)->co_nlocalsplus); name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(class_dict, name, &value_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6093,10 +5960,8 @@ } } PyStackRef_CLOSE(class_dict_st); - value = PyStackRef_FromPyObjectSteal(value_o); - stack_pointer[0] = value; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + value = PyStackRef_FromPyObjectSteal(value_o);/* Pushed outputs */ + stack_pointer[-1] = value; DISPATCH(); } @@ -6109,8 +5974,6 @@ mod_or_class_dict = stack_pointer[-1]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); PyObject *v_o; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &v_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6163,10 +6026,8 @@ } } PyStackRef_CLOSE(mod_or_class_dict); - v = PyStackRef_FromPyObjectSteal(v_o); - stack_pointer[0] = v; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + v = PyStackRef_FromPyObjectSteal(v_o);/* Pushed outputs */ + stack_pointer[-1] = v; DISPATCH(); } @@ -6194,7 +6055,7 @@ } OPCODE_DEFERRED_INC(LOAD_GLOBAL); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION */ + #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ } /* Skip 1 cache entry */ /* Skip 1 cache entry */ @@ -6207,7 +6068,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (res_o == NULL) goto error; null = PyStackRef_NULL; - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } stack_pointer[0] = res; if (oparg & 1) stack_pointer[1] = null; @@ -6230,7 +6091,7 @@ PyDictObject *dict = (PyDictObject *)GLOBALS(); DEOPT_IF(!PyDict_CheckExact(dict), LOAD_GLOBAL); DEOPT_IF(dict->ma_keys->dk_version != version, LOAD_GLOBAL); - assert(DK_IS_UNICODE(dict->ma_keys)); + assert(DK_IS_UNICODE(dict->ma_keys));/* Pushed outputs */ } // _GUARD_BUILTINS_VERSION { @@ -6238,7 +6099,7 @@ PyDictObject *dict = (PyDictObject *)BUILTINS(); DEOPT_IF(!PyDict_CheckExact(dict), LOAD_GLOBAL); DEOPT_IF(dict->ma_keys->dk_version != version, LOAD_GLOBAL); - assert(DK_IS_UNICODE(dict->ma_keys)); + assert(DK_IS_UNICODE(dict->ma_keys));/* Pushed outputs */ } // _LOAD_GLOBAL_BUILTINS { @@ -6250,7 +6111,7 @@ Py_INCREF(res_o); STAT_INC(LOAD_GLOBAL, hit); null = PyStackRef_NULL; - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } stack_pointer[0] = res; if (oparg & 1) stack_pointer[1] = null; @@ -6273,7 +6134,7 @@ PyDictObject *dict = (PyDictObject *)GLOBALS(); DEOPT_IF(!PyDict_CheckExact(dict), LOAD_GLOBAL); DEOPT_IF(dict->ma_keys->dk_version != version, LOAD_GLOBAL); - assert(DK_IS_UNICODE(dict->ma_keys)); + assert(DK_IS_UNICODE(dict->ma_keys));/* Pushed outputs */ } /* Skip 1 cache entry */ // _LOAD_GLOBAL_MODULE @@ -6286,7 +6147,7 @@ Py_INCREF(res_o); STAT_INC(LOAD_GLOBAL, hit); null = PyStackRef_NULL; - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ } stack_pointer[0] = res; if (oparg & 1) stack_pointer[1] = null; @@ -6308,7 +6169,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (true) goto error; } - locals = PyStackRef_FromPyObjectNew(l); + locals = PyStackRef_FromPyObjectNew(l);/* Pushed outputs */ stack_pointer[0] = locals; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6325,7 +6186,7 @@ PyObject *v_o = _PyEval_LoadName(tstate, frame, name); stack_pointer = _PyFrame_GetStackPointer(frame); if (v_o == NULL) goto error; - v = PyStackRef_FromPyObjectSteal(v_o); + v = PyStackRef_FromPyObjectSteal(v_o);/* Pushed outputs */ stack_pointer[0] = v; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6369,7 +6230,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - self_or_null = PyStackRef_FromPyObjectSteal(self_or_null_o); + self_or_null = PyStackRef_FromPyObjectSteal(self_or_null_o);/* Pushed outputs */ stack_pointer[0] = attr; stack_pointer[1] = self_or_null; stack_pointer += 2; @@ -6390,9 +6251,9 @@ _PyStackRef attr; _PyStackRef null = PyStackRef_NULL; // _SPECIALIZE_LOAD_SUPER_ATTR - class_st = stack_pointer[-2]; - global_super_st = stack_pointer[-3]; { + class_st = stack_pointer[-2]; + global_super_st = stack_pointer[-3]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; #if ENABLE_SPECIALIZATION @@ -6406,32 +6267,26 @@ } OPCODE_DEFERRED_INC(LOAD_SUPER_ATTR); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION */ + #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ } // _LOAD_SUPER_ATTR - self_st = stack_pointer[-1]; { + self_st = stack_pointer[-1]; PyObject *global_super = PyStackRef_AsPyObjectBorrow(global_super_st); PyObject *class = PyStackRef_AsPyObjectBorrow(class_st); PyObject *self = PyStackRef_AsPyObjectBorrow(self_st); if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) { PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING; - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, global_super, arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) goto error; - stack_pointer += 3; - assert(WITHIN_STACK_BOUNDS()); } // we make no attempt to optimize here; specializations should // handle any case whose performance we care about PyObject *stack[] = {class, self}; - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *super = PyObject_Vectorcall(global_super, stack, oparg & 2, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6462,6 +6317,8 @@ PyStackRef_CLOSE(self_st); if (super == NULL) goto error; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); attr = PyStackRef_FromPyObjectSteal(PyObject_GetAttr(super, name)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6472,7 +6329,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - null = PyStackRef_NULL; + null = PyStackRef_NULL;/* Pushed outputs */ } stack_pointer[0] = attr; if (oparg & 1) stack_pointer[1] = null; @@ -6502,8 +6359,6 @@ DEOPT_IF(!PyType_Check(class), LOAD_SUPER_ATTR); STAT_INC(LOAD_SUPER_ATTR, hit); PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6511,9 +6366,9 @@ PyStackRef_CLOSE(class_st); PyStackRef_CLOSE(self_st); if (attr == NULL) goto error; - attr_st = PyStackRef_FromPyObjectSteal(attr); - stack_pointer[0] = attr_st; - stack_pointer += 1; + attr_st = PyStackRef_FromPyObjectSteal(attr);/* Pushed outputs */ + stack_pointer[-3] = attr_st; + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -6542,8 +6397,6 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); PyTypeObject *cls = (PyTypeObject *)class; int method_found = 0; - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attr_o = _PySuper_Lookup(cls, self, name, Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? &method_found : NULL); @@ -6555,15 +6408,15 @@ if (true) goto error; } if (method_found) { - self_or_null = self_st; // transfer ownership + self_or_null = self_st; // transfer ownership(void)self_st ; } else { PyStackRef_CLOSE(self_st); self_or_null = PyStackRef_NULL; } - attr = PyStackRef_FromPyObjectSteal(attr_o); - stack_pointer[0] = attr; - stack_pointer[1] = self_or_null; - stack_pointer += 2; + attr = PyStackRef_FromPyObjectSteal(attr_o);/* Pushed outputs */ + stack_pointer[-3] = attr; + stack_pointer[-2] = self_or_null; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -6579,7 +6432,7 @@ if (cell == NULL) { goto error; } - SETLOCAL(oparg, PyStackRef_FromPyObjectSteal(cell)); + SETLOCAL(oparg, PyStackRef_FromPyObjectSteal(cell));/* Pushed outputs */ DISPATCH(); } @@ -6591,19 +6444,19 @@ _PyStackRef func; codeobj_st = stack_pointer[-1]; PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyFunctionObject *func_obj = (PyFunctionObject *) PyFunction_New(codeobj, GLOBALS()); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(codeobj_st); if (func_obj == NULL) goto error; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyFunction_SetVersion( func_obj, ((PyCodeObject *)codeobj)->co_version); stack_pointer = _PyFrame_GetStackPointer(frame); - func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj); + func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj);/* Pushed outputs */ stack_pointer[0] = func; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6624,8 +6477,6 @@ assert(PyDict_CheckExact(dict)); /* dict[key] = value */ // Do not DECREF INPUTS because the function steals the references - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_SetItem_Take2( (PyDictObject *)dict, @@ -6634,6 +6485,9 @@ ); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; + /* Pushed outputs */ + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -6651,8 +6505,6 @@ // Pop TOS and TOS1. Set TOS to a tuple of attributes on success, or // None on failure. assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names))); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attrs_o = _PyEval_MatchClass(tstate, PyStackRef_AsPyObjectBorrow(subject), @@ -6670,9 +6522,9 @@ if (_PyErr_Occurred(tstate)) goto error; // Error! attrs = PyStackRef_None; // Failure! - } - stack_pointer[0] = attrs; - stack_pointer += 1; + }/* Pushed outputs */ + stack_pointer[-3] = attrs; + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -6692,7 +6544,7 @@ PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys)); stack_pointer = _PyFrame_GetStackPointer(frame); if (values_or_none_o == NULL) goto error; - values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o); + values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o);/* Pushed outputs */ stack_pointer[0] = values_or_none; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6707,7 +6559,7 @@ _PyStackRef res; subject = stack_pointer[-1]; int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING; - res = match ? PyStackRef_True : PyStackRef_False; + res = match ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6722,7 +6574,7 @@ _PyStackRef res; subject = stack_pointer[-1]; int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE; - res = match ? PyStackRef_True : PyStackRef_False; + res = match ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6733,6 +6585,7 @@ frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(NOP); + /* Pushed outputs */ DISPATCH(); } @@ -6743,13 +6596,14 @@ _PyStackRef exc_value; exc_value = stack_pointer[-1]; _PyErr_StackItem *exc_info = tstate->exc_info; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); Py_XSETREF(exc_info->exc_value, PyStackRef_Is(exc_value, PyStackRef_None) ? NULL : PyStackRef_AsPyObjectSteal(exc_value)); stack_pointer = _PyFrame_GetStackPointer(frame); + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -6762,11 +6616,11 @@ /* Skip 1 cache entry */ cond = stack_pointer[-1]; assert(PyStackRef_BoolCheck(cond)); - int flag = PyStackRef_Is(cond, PyStackRef_False); + int flag = PyStackRef_Is(cond, PyStackRef_False);(void)cond ; #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif - JUMPBY(oparg * flag); + JUMPBY(oparg * flag);/* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -6782,25 +6636,25 @@ _PyStackRef cond; /* Skip 1 cache entry */ // _IS_NONE - value = stack_pointer[-1]; { + value = stack_pointer[-1]; if (PyStackRef_Is(value, PyStackRef_None)) { - b = PyStackRef_True; + b = PyStackRef_True;(void)value ; } else { b = PyStackRef_False; PyStackRef_CLOSE(value); - } + }/* Pushed outputs */ } // _POP_JUMP_IF_TRUE - cond = b; { + cond = b; assert(PyStackRef_BoolCheck(cond)); - int flag = PyStackRef_Is(cond, PyStackRef_True); + int flag = PyStackRef_Is(cond, PyStackRef_True);(void)cond ; #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif - JUMPBY(oparg * flag); + JUMPBY(oparg * flag);/* Pushed outputs */ } stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -6817,25 +6671,25 @@ _PyStackRef cond; /* Skip 1 cache entry */ // _IS_NONE - value = stack_pointer[-1]; { + value = stack_pointer[-1]; if (PyStackRef_Is(value, PyStackRef_None)) { - b = PyStackRef_True; + b = PyStackRef_True;(void)value ; } else { b = PyStackRef_False; PyStackRef_CLOSE(value); - } + }/* Pushed outputs */ } // _POP_JUMP_IF_FALSE - cond = b; { + cond = b; assert(PyStackRef_BoolCheck(cond)); - int flag = PyStackRef_Is(cond, PyStackRef_False); + int flag = PyStackRef_Is(cond, PyStackRef_False);(void)cond ; #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif - JUMPBY(oparg * flag); + JUMPBY(oparg * flag);/* Pushed outputs */ } stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -6851,11 +6705,11 @@ /* Skip 1 cache entry */ cond = stack_pointer[-1]; assert(PyStackRef_BoolCheck(cond)); - int flag = PyStackRef_Is(cond, PyStackRef_True); + int flag = PyStackRef_Is(cond, PyStackRef_True);(void)cond ; #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif - JUMPBY(oparg * flag); + JUMPBY(oparg * flag);/* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -6868,6 +6722,7 @@ _PyStackRef value; value = stack_pointer[-1]; PyStackRef_CLOSE(value); + /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -6877,9 +6732,10 @@ frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(PUSH_EXC_INFO); - _PyStackRef new_exc; + _PyStackRef exc; _PyStackRef prev_exc; - new_exc = stack_pointer[-1]; + _PyStackRef new_exc; + exc = stack_pointer[-1]; _PyErr_StackItem *exc_info = tstate->exc_info; if (exc_info->exc_value != NULL) { prev_exc = PyStackRef_FromPyObjectSteal(exc_info->exc_value); @@ -6887,8 +6743,9 @@ else { prev_exc = PyStackRef_None; } - assert(PyStackRef_ExceptionInstanceCheck(new_exc)); - exc_info->exc_value = PyStackRef_AsPyObjectNew(new_exc); + assert(PyStackRef_ExceptionInstanceCheck(exc)); + exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); + new_exc = exc;(void)exc ;/* Pushed outputs */ stack_pointer[-1] = prev_exc; stack_pointer[0] = new_exc; stack_pointer += 1; @@ -6901,7 +6758,7 @@ next_instr += 1; INSTRUCTION_STATS(PUSH_NULL); _PyStackRef res; - res = PyStackRef_NULL; + res = PyStackRef_NULL;/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6927,11 +6784,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; } - if (true) { - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } + if (true) goto error; + /* Pushed outputs */ + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); } TARGET(RERAISE) { @@ -6943,7 +6799,7 @@ _PyStackRef exc_st; exc_st = stack_pointer[-1]; values = &stack_pointer[-1 - oparg]; - PyObject *exc = PyStackRef_AsPyObjectBorrow(exc_st); + PyObject *exc = PyStackRef_AsPyObjectSteal(exc_st); assert(oparg >= 0 && oparg <= 2); if (oparg) { PyObject *lasti = PyStackRef_AsPyObjectBorrow(values[0]); @@ -6961,19 +6817,19 @@ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_SystemError, "lasti is not an int"); stack_pointer = _PyFrame_GetStackPointer(frame); + Py_DECREF(exc); goto error; }stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); } assert(exc && PyExceptionInstance_Check(exc)); - Py_INCREF(exc); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetRaisedException(tstate, exc); monitor_reraise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); - goto exception_unwind; + goto exception_unwind;/* Pushed outputs */ } TARGET(RESERVED) { @@ -6981,7 +6837,7 @@ next_instr += 1; INSTRUCTION_STATS(RESERVED); assert(0 && "Executing RESERVED instruction."); - Py_FatalError("Executing RESERVED instruction."); + Py_FatalError("Executing RESERVED instruction.");/* Pushed outputs */ DISPATCH(); } @@ -7007,7 +6863,7 @@ next_instr = this_instr; DISPATCH(); } - } + }/* Pushed outputs */ } // _QUICKEN_RESUME { @@ -7015,7 +6871,7 @@ if (tstate->tracing == 0 && this_instr->op.code == RESUME) { FT_ATOMIC_STORE_UINT8_RELAXED(this_instr->op.code, RESUME_CHECK); } - #endif /* ENABLE_SPECIALIZATION */ + #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ } // _CHECK_PERIODIC_IF_NOT_YIELD_FROM { @@ -7028,7 +6884,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; } - } + }/* Pushed outputs */ } DISPATCH(); } @@ -7046,6 +6902,7 @@ uintptr_t version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version); assert((version & _PY_EVAL_EVENTS_MASK) == 0); DEOPT_IF(eval_breaker != version, RESUME); + /* Pushed outputs */ DISPATCH(); } @@ -7058,14 +6915,15 @@ _PyStackRef res; // _LOAD_CONST { - value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg)); + value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg));/* Pushed outputs */ } // _RETURN_VALUE - retval = value; { + retval = value; #if TIER_ONE assert(frame != &entry_frame); #endif + _PyStackRef temp = retval;(void)retval ; _PyFrame_SetStackPointer(frame, stack_pointer); assert(EMPTY()); _Py_LeaveRecursiveCallPy(tstate); @@ -7073,10 +6931,10 @@ _PyInterpreterFrame *dying = frame; frame = tstate->current_frame = dying->previous; _PyEval_FrameClearAndPop(tstate, dying); - LOAD_SP(); + stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(frame->return_offset); - res = retval; - LLTRACE_RESUME_FRAME(); + res = temp; + LLTRACE_RESUME_FRAME();/* Pushed outputs */ } stack_pointer[0] = res; stack_pointer += 1; @@ -7110,7 +6968,7 @@ LOAD_IP(frame->return_offset); stack_pointer = _PyFrame_GetStackPointer(frame); res = PyStackRef_FromPyObjectSteal((PyObject *)gen); - LLTRACE_RESUME_FRAME(); + LLTRACE_RESUME_FRAME();/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -7127,6 +6985,7 @@ #if TIER_ONE assert(frame != &entry_frame); #endif + _PyStackRef temp = retval;(void)retval ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -7136,10 +6995,10 @@ _PyInterpreterFrame *dying = frame; frame = tstate->current_frame = dying->previous; _PyEval_FrameClearAndPop(tstate, dying); - LOAD_SP(); + stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(frame->return_offset); - res = retval; - LLTRACE_RESUME_FRAME(); + res = temp; + LLTRACE_RESUME_FRAME();/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -7157,8 +7016,8 @@ _PyStackRef v; _PyStackRef retval; // _SPECIALIZE_SEND - receiver = stack_pointer[-2]; { + receiver = stack_pointer[-2]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; #if ENABLE_SPECIALIZATION @@ -7171,11 +7030,11 @@ } OPCODE_DEFERRED_INC(SEND); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION */ + #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ } // _SEND - v = stack_pointer[-1]; { + v = stack_pointer[-1]; PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver); PyObject *retval_o; assert(frame != &entry_frame); @@ -7200,19 +7059,13 @@ retval_o = Py_TYPE(receiver_o)->tp_iternext(receiver_o); } else { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); retval_o = PyObject_CallMethodOneArg(receiver_o, &_Py_ID(send), PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); } if (retval_o == NULL) { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7231,11 +7084,10 @@ else { PyStackRef_CLOSE(v); if (true) goto error; - }stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + } } PyStackRef_CLOSE(v); - retval = PyStackRef_FromPyObjectSteal(retval_o); + retval = PyStackRef_FromPyObjectSteal(retval_o);/* Pushed outputs */ } stack_pointer[-1] = retval; DISPATCH(); @@ -7254,40 +7106,42 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, SEND); + /* Pushed outputs */ } // _SEND_GEN_FRAME - v = stack_pointer[-1]; - receiver = stack_pointer[-2]; { + v = stack_pointer[-1]; + receiver = stack_pointer[-2]; PyGenObject *gen = (PyGenObject *)PyStackRef_AsPyObjectBorrow(receiver); DEOPT_IF(Py_TYPE(gen) != &PyGen_Type && Py_TYPE(gen) != &PyCoro_Type, SEND); DEOPT_IF(gen->gi_frame_state >= FRAME_EXECUTING, SEND); STAT_INC(SEND, hit); gen_frame = &gen->gi_iframe; - _PyFrame_StackPush(gen_frame, v); + _PyFrame_StackPush(gen_frame, v);(void)v ; gen->gi_frame_state = FRAME_EXECUTING; gen->gi_exc_state.previous_item = tstate->exc_info; tstate->exc_info = &gen->gi_exc_state; assert(1 + INLINE_CACHE_ENTRIES_SEND + oparg <= UINT16_MAX); frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_SEND + oparg); - gen_frame->previous = frame; + gen_frame->previous = frame;/* Pushed outputs */ } // _PUSH_FRAME - new_frame = gen_frame; { + new_frame = gen_frame; // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); + _PyInterpreterFrame *temp = new_frame;(void)new_frame ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); - frame = tstate->current_frame = new_frame; + frame = tstate->current_frame = temp; tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME(); + LLTRACE_RESUME_FRAME();/* Pushed outputs */ } DISPATCH(); } @@ -7323,7 +7177,7 @@ } else { Py_DECREF(ann_dict); - } + }/* Pushed outputs */ DISPATCH(); } @@ -7335,14 +7189,15 @@ _PyStackRef v; v = stack_pointer[-1]; set = stack_pointer[-2 - (oparg-1)]; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PySet_Add(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); if (err) goto error; + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -7351,18 +7206,20 @@ next_instr += 1; INSTRUCTION_STATS(SET_FUNCTION_ATTRIBUTE); _PyStackRef attr_st; - _PyStackRef func_st; - func_st = stack_pointer[-1]; + _PyStackRef func_in; + _PyStackRef func_out; + func_in = stack_pointer[-1]; attr_st = stack_pointer[-2]; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); - PyObject *attr = PyStackRef_AsPyObjectBorrow(attr_st); + PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); + PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st); + func_out = func_in;(void)func_in ; assert(PyFunction_Check(func)); size_t offset = _Py_FunctionAttributeOffsets[oparg]; assert(offset != 0); PyObject **ptr = (PyObject **)(((char *)func) + offset); assert(*ptr == NULL); - *ptr = attr; - stack_pointer[-2] = func_st; + *ptr = attr;/* Pushed outputs */ + stack_pointer[-2] = func_out; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -7376,14 +7233,15 @@ _PyStackRef iterable; iterable = stack_pointer[-1]; set = stack_pointer[-2 - (oparg-1)]; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(iterable)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); if (err < 0) goto error; + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -7397,8 +7255,8 @@ _PyStackRef owner; _PyStackRef v; // _SPECIALIZE_STORE_ATTR - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; #if ENABLE_SPECIALIZATION @@ -7412,15 +7270,13 @@ } OPCODE_DEFERRED_INC(STORE_ATTR); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION */ + #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ } /* Skip 3 cache entries */ // _STORE_ATTR - v = stack_pointer[-2]; { + v = stack_pointer[-2]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner), name, PyStackRef_AsPyObjectBorrow(v)); @@ -7428,7 +7284,10 @@ PyStackRef_CLOSE(v); PyStackRef_CLOSE(owner); if (err) goto error; + /* Pushed outputs */ } + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -7441,12 +7300,13 @@ _PyStackRef value; /* Skip 1 cache entry */ // _GUARD_TYPE_VERSION - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint32_t type_version = read_u32(&this_instr[2].cache); PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR); + /* Pushed outputs */ } // _GUARD_DORV_NO_DICT { @@ -7455,10 +7315,11 @@ assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); DEOPT_IF(_PyObject_GetManagedDict(owner_o), STORE_ATTR); DEOPT_IF(_PyObject_InlineValues(owner_o)->valid == 0, STORE_ATTR); + /* Pushed outputs */ } // _STORE_ATTR_INSTANCE_VALUE - value = stack_pointer[-2]; { + value = stack_pointer[-2]; uint16_t offset = read_u16(&this_instr[4].cache); PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); STAT_INC(STORE_ATTR, hit); @@ -7474,7 +7335,7 @@ else { Py_DECREF(old_value); } - PyStackRef_CLOSE(owner); + PyStackRef_CLOSE(owner);/* Pushed outputs */ } stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -7490,16 +7351,17 @@ _PyStackRef value; /* Skip 1 cache entry */ // _GUARD_TYPE_VERSION - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint32_t type_version = read_u32(&this_instr[2].cache); PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR); + /* Pushed outputs */ } // _STORE_ATTR_SLOT - value = stack_pointer[-2]; { + value = stack_pointer[-2]; uint16_t index = read_u16(&this_instr[4].cache); PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); char *addr = (char *)owner_o + index; @@ -7507,7 +7369,7 @@ PyObject *old_value = *(PyObject **)addr; *(PyObject **)addr = PyStackRef_AsPyObjectSteal(value); Py_XDECREF(old_value); - PyStackRef_CLOSE(owner); + PyStackRef_CLOSE(owner);/* Pushed outputs */ } stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -7523,16 +7385,17 @@ _PyStackRef value; /* Skip 1 cache entry */ // _GUARD_TYPE_VERSION - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint32_t type_version = read_u32(&this_instr[2].cache); PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR); + /* Pushed outputs */ } // _STORE_ATTR_WITH_HINT - value = stack_pointer[-2]; { + value = stack_pointer[-2]; uint16_t hint = read_u16(&this_instr[4].cache); PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_MANAGED_DICT); @@ -7548,18 +7411,12 @@ DEOPT_IF(ep->me_key != name, STORE_ATTR); /* Ensure dict is GC tracked if it needs to be */ if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(PyStackRef_AsPyObjectBorrow(value))) { - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyObject_GC_TRACK(dict); stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer += 2; - assert(WITHIN_STACK_BOUNDS()); } old_value = ep->me_value; PyDict_WatchEvent event = old_value == NULL ? PyDict_EVENT_ADDED : PyDict_EVENT_MODIFIED; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); new_version = _PyDict_NotifyEvent(tstate->interp, event, dict, name, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7569,8 +7426,10 @@ // when dict only holds the strong reference to value in ep->me_value. Py_XDECREF(old_value); STAT_INC(STORE_ATTR, hit); - PyStackRef_CLOSE(owner); + PyStackRef_CLOSE(owner);/* Pushed outputs */ } + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -7581,11 +7440,12 @@ _PyStackRef v; v = stack_pointer[-1]; PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v)); stack_pointer = _PyFrame_GetStackPointer(frame); + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -7595,7 +7455,7 @@ INSTRUCTION_STATS(STORE_FAST); _PyStackRef value; value = stack_pointer[-1]; - SETLOCAL(oparg, value); + SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -7610,8 +7470,8 @@ value1 = stack_pointer[-1]; uint32_t oparg1 = oparg >> 4; uint32_t oparg2 = oparg & 15; - SETLOCAL(oparg1, value1); - value2 = PyStackRef_DUP(GETLOCAL(oparg2)); + SETLOCAL(oparg1, value1);(void)value1 ; + value2 = PyStackRef_DUP(GETLOCAL(oparg2));/* Pushed outputs */ stack_pointer[-1] = value2; DISPATCH(); } @@ -7626,8 +7486,8 @@ value2 = stack_pointer[-2]; uint32_t oparg1 = oparg >> 4; uint32_t oparg2 = oparg & 15; - SETLOCAL(oparg1, value1); - SETLOCAL(oparg2, value2); + SETLOCAL(oparg1, value1);(void)value1 ; + SETLOCAL(oparg2, value2);(void)value2 ;/* Pushed outputs */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -7640,13 +7500,14 @@ _PyStackRef v; v = stack_pointer[-1]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); if (err) goto error; + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -7660,8 +7521,6 @@ PyObject *ns = LOCALS(); int err; if (ns == NULL) { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when storing %R", name); @@ -7670,21 +7529,20 @@ if (true) goto error; } if (PyDict_CheckExact(ns)) { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); } else { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(v); if (err) goto error; + /* Pushed outputs */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -7701,53 +7559,38 @@ // Placeholder until we implement STORE_SLICE specialization #if ENABLE_SPECIALIZATION OPCODE_DEFERRED_INC(STORE_SLICE); - #endif /* ENABLE_SPECIALIZATION */ + #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ } // _STORE_SLICE - stop = stack_pointer[-1]; - start = stack_pointer[-2]; - container = stack_pointer[-3]; - v = stack_pointer[-4]; -<<<<<<< HEAD - stack_pointer += -4; - assert(WITHIN_STACK_BOUNDS()); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), - PyStackRef_AsPyObjectSteal(stop)); - stack_pointer = _PyFrame_GetStackPointer(frame); - OPCODE_DEFERRED_INC(STORE_SLICE); - int err; - if (slice == NULL) { - err = 1; - } - else { - _PyFrame_SetStackPointer(frame, stack_pointer); - err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), slice, PyStackRef_AsPyObjectBorrow(v)); - stack_pointer = _PyFrame_GetStackPointer(frame); - Py_DECREF(slice); - } - PyStackRef_CLOSE(v); - PyStackRef_CLOSE(container); - if (err) goto error; -======= { + stop = stack_pointer[-1]; + start = stack_pointer[-2]; + container = stack_pointer[-3]; + v = stack_pointer[-4]; + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); + stack_pointer = _PyFrame_GetStackPointer(frame); int err; if (slice == NULL) { err = 1; } else { + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), slice, PyStackRef_AsPyObjectBorrow(v)); - Py_DECREF(slice); + stack_pointer = _PyFrame_GetStackPointer(frame); + Py_DECREF(slice);stack_pointer += 2; + assert(WITHIN_STACK_BOUNDS()); } PyStackRef_CLOSE(v); PyStackRef_CLOSE(container); - if (err) goto pop_4_error; + if (err) goto pop_2_error; + /* Pushed outputs */ } stack_pointer += -4; assert(WITHIN_STACK_BOUNDS()); ->>>>>>> main DISPATCH(); } @@ -7762,9 +7605,9 @@ _PyStackRef sub; _PyStackRef v; // _SPECIALIZE_STORE_SUBSCR - sub = stack_pointer[-1]; - container = stack_pointer[-2]; { + sub = stack_pointer[-1]; + container = stack_pointer[-2]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; #if ENABLE_SPECIALIZATION @@ -7777,14 +7620,12 @@ } OPCODE_DEFERRED_INC(STORE_SUBSCR); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION */ + #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ } // _STORE_SUBSCR - v = stack_pointer[-3]; { + v = stack_pointer[-3]; /* container[sub] = v */ - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7792,7 +7633,10 @@ PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); if (err) goto error; + /* Pushed outputs */ } + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -7811,8 +7655,6 @@ PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st); DEOPT_IF(!PyDict_CheckExact(dict), STORE_SUBSCR); STAT_INC(STORE_SUBSCR, hit); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_SetItem_Take2((PyDictObject *)dict, PyStackRef_AsPyObjectSteal(sub), @@ -7820,6 +7662,9 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(dict_st); if (err) goto error; + /* Pushed outputs */ + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -7849,8 +7694,8 @@ PyList_SET_ITEM(list, index, PyStackRef_AsPyObjectSteal(value)); assert(old_value != NULL); Py_DECREF(old_value); - _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); - PyStackRef_CLOSE(list_st); + _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; + PyStackRef_CLOSE(list_st);/* Pushed outputs */ stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -7860,13 +7705,17 @@ frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(SWAP); - _PyStackRef bottom; - _PyStackRef top; - top = stack_pointer[-1]; - bottom = stack_pointer[-2 - (oparg-2)]; - assert(oparg >= 2); - stack_pointer[-2 - (oparg-2)] = top; - stack_pointer[-1] = bottom; + _PyStackRef bottom_in; + _PyStackRef top_in; + _PyStackRef top_out; + _PyStackRef bottom_out; + top_in = stack_pointer[-1]; + bottom_in = stack_pointer[-2 - (oparg-2)]; + bottom_out = bottom_in;(void)bottom_in ; + top_out = top_in;(void)top_in ; + assert(oparg >= 2);/* Pushed outputs */ + stack_pointer[-2 - (oparg-2)] = top_out; + stack_pointer[-1] = bottom_out; DISPATCH(); } @@ -7880,8 +7729,8 @@ _PyStackRef value; _PyStackRef res; // _SPECIALIZE_TO_BOOL - value = stack_pointer[-1]; { + value = stack_pointer[-1]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; #if ENABLE_SPECIALIZATION @@ -7894,23 +7743,19 @@ } OPCODE_DEFERRED_INC(TO_BOOL); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION */ + #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ } /* Skip 2 cache entries */ // _TO_BOOL { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); if (err < 0) goto error; - res = err ? PyStackRef_True : PyStackRef_False; + res = err ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ } - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; DISPATCH(); } @@ -7924,18 +7769,19 @@ _PyStackRef res; /* Skip 1 cache entry */ // _GUARD_TYPE_VERSION - owner = stack_pointer[-1]; { + owner = stack_pointer[-1]; uint32_t type_version = read_u32(&this_instr[2].cache); PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, TO_BOOL); + /* Pushed outputs */ } // _REPLACE_WITH_TRUE - value = owner; { + value = owner; PyStackRef_CLOSE(value); - res = PyStackRef_True; + res = PyStackRef_True;/* Pushed outputs */ } stack_pointer[-1] = res; DISPATCH(); @@ -7951,7 +7797,7 @@ /* Skip 2 cache entries */ value = stack_pointer[-1]; DEOPT_IF(!PyStackRef_BoolCheck(value), TO_BOOL); - STAT_INC(TO_BOOL, hit); + STAT_INC(TO_BOOL, hit);/* Pushed outputs */ DISPATCH(); } @@ -7969,13 +7815,16 @@ DEOPT_IF(!PyLong_CheckExact(value_o), TO_BOOL); STAT_INC(TO_BOOL, hit); if (_PyLong_IsZero((PyLongObject *)value_o)) { + _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); + stack_pointer = _PyFrame_GetStackPointer(frame); + (void)value ; res = PyStackRef_False; } else { PyStackRef_CLOSE(value); res = PyStackRef_True; - } + }/* Pushed outputs */ stack_pointer[-1] = res; DISPATCH(); } @@ -7995,6 +7844,7 @@ STAT_INC(TO_BOOL, hit); res = Py_SIZE(value_o) ? PyStackRef_True : PyStackRef_False; PyStackRef_CLOSE(value); + /* Pushed outputs */ stack_pointer[-1] = res; DISPATCH(); } @@ -8011,8 +7861,9 @@ value = stack_pointer[-1]; // This one is a bit weird, because we expect *some* failures: DEOPT_IF(!PyStackRef_Is(value, PyStackRef_None), TO_BOOL); + (void)value ; STAT_INC(TO_BOOL, hit); - res = PyStackRef_False; + res = PyStackRef_False;/* Pushed outputs */ stack_pointer[-1] = res; DISPATCH(); } @@ -8031,14 +7882,17 @@ DEOPT_IF(!PyUnicode_CheckExact(value_o), TO_BOOL); STAT_INC(TO_BOOL, hit); if (value_o == &_Py_STR(empty)) { + _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); + stack_pointer = _PyFrame_GetStackPointer(frame); + (void)value ; res = PyStackRef_False; } else { assert(Py_SIZE(value_o)); PyStackRef_CLOSE(value); res = PyStackRef_True; - } + }/* Pushed outputs */ stack_pointer[-1] = res; DISPATCH(); } @@ -8050,17 +7904,13 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + stack_pointer[-1] = res; DISPATCH(); } @@ -8071,17 +7921,13 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + stack_pointer[-1] = res; DISPATCH(); } @@ -8094,7 +7940,7 @@ value = stack_pointer[-1]; assert(PyStackRef_BoolCheck(value)); res = PyStackRef_Is(value, PyStackRef_False) - ? PyStackRef_True : PyStackRef_False; + ? PyStackRef_True : PyStackRef_False;(void)value ;/* Pushed outputs */ stack_pointer[-1] = res; DISPATCH(); } @@ -8105,17 +7951,16 @@ INSTRUCTION_STATS(UNPACK_EX); _PyStackRef seq; _PyStackRef *right; + right = &stack_pointer[1 + (oparg & 0xFF)]; seq = stack_pointer[-1]; - right = &stack_pointer[(oparg & 0xFF)]; _PyStackRef *top = right + (oparg >> 8); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(seq); if (res == 0) goto error; - stack_pointer += 1 + (oparg & 0xFF) + (oparg >> 8); + /* Pushed outputs */ + stack_pointer += (oparg & 0xFF) + (oparg >> 8); assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -8130,8 +7975,8 @@ _PyStackRef seq; _PyStackRef *output; // _SPECIALIZE_UNPACK_SEQUENCE - seq = stack_pointer[-1]; { + seq = stack_pointer[-1]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; #if ENABLE_SPECIALIZATION @@ -8146,21 +7991,20 @@ ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); #endif /* ENABLE_SPECIALIZATION */ (void)seq; - (void)counter; + (void)counter;/* Pushed outputs */ } // _UNPACK_SEQUENCE { - output = &stack_pointer[-1]; + output = &stack_pointer[0]; _PyStackRef *top = output + oparg; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(seq); if (res == 0) goto error; + /* Pushed outputs */ } - stack_pointer += oparg; + stack_pointer += -1 + oparg; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -8173,8 +8017,8 @@ _PyStackRef seq; _PyStackRef *values; /* Skip 1 cache entry */ + values = &stack_pointer[0]; seq = stack_pointer[-1]; - values = &stack_pointer[-1]; PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq); DEOPT_IF(!PyList_CheckExact(seq_o), UNPACK_SEQUENCE); DEOPT_IF(PyList_GET_SIZE(seq_o) != oparg, UNPACK_SEQUENCE); @@ -8184,6 +8028,7 @@ *values++ = PyStackRef_FromPyObjectNew(items[i]); } PyStackRef_CLOSE(seq); + /* Pushed outputs */ stack_pointer += -1 + oparg; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -8197,8 +8042,8 @@ _PyStackRef seq; _PyStackRef *values; /* Skip 1 cache entry */ + values = &stack_pointer[0]; seq = stack_pointer[-1]; - values = &stack_pointer[-1]; PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq); DEOPT_IF(!PyTuple_CheckExact(seq_o), UNPACK_SEQUENCE); DEOPT_IF(PyTuple_GET_SIZE(seq_o) != oparg, UNPACK_SEQUENCE); @@ -8208,6 +8053,7 @@ *values++ = PyStackRef_FromPyObjectNew(items[i]); } PyStackRef_CLOSE(seq); + /* Pushed outputs */ stack_pointer += -1 + oparg; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -8231,6 +8077,7 @@ val0 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 0)); val1 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 1)); PyStackRef_CLOSE(seq); + /* Pushed outputs */ stack_pointer[-1] = val1; stack_pointer[0] = val0; stack_pointer += 1; @@ -8288,6 +8135,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } + /* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -8308,14 +8156,15 @@ assert(frame != &entry_frame); #endif frame->instr_ptr++; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); stack_pointer = _PyFrame_GetStackPointer(frame); assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; + _PyStackRef temp = retval;(void)retval ; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); tstate->exc_info = gen->gi_exc_state.previous_item; gen->gi_exc_state.previous_item = NULL; @@ -8333,10 +8182,10 @@ _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT || _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR); #endif + stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND); - LOAD_SP(); - value = retval; - LLTRACE_RESUME_FRAME(); + value = temp; + LLTRACE_RESUME_FRAME();/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -8357,7 +8206,7 @@ func_st = stack_pointer[-3 - (oparg & 1)]; PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); PyObject *callargs = PyStackRef_AsPyObjectBorrow(callargs_st); - PyObject *kwargs = PyStackRef_AsPyObjectBorrow(kwargs_st); + PyObject *kwargs = PyStackRef_AsPyObjectSteal(kwargs_st); // DICT_MERGE is called before this opcode if there are kwargs. // It converts all dict subtypes in kwargs into regular dicts. assert(kwargs == NULL || PyDict_CheckExact(kwargs)); @@ -8366,7 +8215,7 @@ if (err < 0) { goto error; } - stack_pointer += -3 - (oparg & 1); + stack_pointer += -(oparg & 1); assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *tuple = PySequence_Tuple(callargs); @@ -8375,16 +8224,19 @@ goto error; } PyStackRef_CLOSE(callargs_st); - callargs_st = PyStackRef_FromPyObjectSteal(tuple); - callargs = tuple;stack_pointer += 3 + (oparg & 1); + callargs = tuple; + } + else { + callargs = PyStackRef_AsPyObjectSteal(callargs_st);stack_pointer += -(oparg & 1); assert(WITHIN_STACK_BOUNDS()); } assert(PyTuple_CheckExact(callargs)); EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_FUNCTION_EX, func); + PyObject *result_o; if (opcode == INSTRUMENTED_CALL_FUNCTION_EX) { PyObject *arg = PyTuple_GET_SIZE(callargs) > 0 ? PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING; - stack_pointer += -3 - (oparg & 1); + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( @@ -8395,13 +8247,10 @@ goto error; } _PyFrame_SetStackPointer(frame, stack_pointer); - result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); + result_o = PyObject_Call(func, callargs, kwargs); stack_pointer = _PyFrame_GetStackPointer(frame); if (!PyFunction_Check(func) && !PyMethod_Check(func)) { if (PyStackRef_IsNull(result)) { - stack_pointer[0] = result; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, @@ -8409,19 +8258,17 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } else { - stack_pointer[0] = result; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, func, arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { - PyStackRef_CLEAR(result); + _PyFrame_SetStackPointer(frame, stack_pointer); + Py_CLEAR(result_o); + stack_pointer = _PyFrame_GetStackPointer(frame); } - }stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + } } } else { @@ -8432,7 +8279,7 @@ Py_ssize_t nargs = PyTuple_GET_SIZE(callargs); int code_flags = ((PyCodeObject *)PyFunction_GET_CODE(func))->co_flags; PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func)); - stack_pointer += -3 - (oparg & 1); + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(tstate, @@ -8440,6 +8287,8 @@ nargs, callargs, kwargs, frame); stack_pointer = _PyFrame_GetStackPointer(frame); // Need to sync the stack since we exit with DISPATCH_INLINED. + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (new_frame == NULL) { goto error; } @@ -8447,24 +8296,22 @@ frame->return_offset = 1; DISPATCH_INLINED(new_frame); } - stack_pointer += -3 - (oparg & 1); + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - result = PyStackRef_FromPyObjectSteal(PyObject_Call(func, callargs, kwargs)); + result_o = PyObject_Call(func, callargs, kwargs); stack_pointer = _PyFrame_GetStackPointer(frame); } + Py_DECREF(callargs); PyStackRef_CLOSE(func_st); - PyStackRef_CLOSE(callargs_st); - PyStackRef_XCLOSE(kwargs_st); + Py_XDECREF(kwargs); + result = PyStackRef_FromPyObjectSteal(result_o); if (PyStackRef_IsNull(result)) { - stack_pointer[0] = result; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = result; goto error; } - stack_pointer[0] = result; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + /* Pushed outputs */ + stack_pointer[-1] = result; DISPATCH(); } #undef TIER_ONE diff --git a/Python/optimizer_bytecodes.c b/Python/optimizer_bytecodes.c index f347a6d81e91a4..b51027b3ea95b5 100644 --- a/Python/optimizer_bytecodes.c +++ b/Python/optimizer_bytecodes.c @@ -456,8 +456,10 @@ dummy_func(void) { top = bottom; } - op(_SWAP, (bottom, unused[oparg-2], top -- - top, unused[oparg-2], bottom)) { + op(_SWAP, (bottom_in, unused[oparg-2], top_in -- + top_out, unused[oparg-2], bottom_out)) { + bottom_out = bottom_in; + top_out = top_in; } op(_LOAD_ATTR_INSTANCE_VALUE, (offset/1, owner -- attr, null if (oparg & 1))) { @@ -582,7 +584,7 @@ dummy_func(void) { op(_INIT_CALL_PY_EXACT_ARGS, (callable, self_or_null, args[oparg] -- new_frame: _Py_UOpsAbstractFrame *)) { int argcount = oparg; - (void)callable; + KILL(callable); PyCodeObject *co = NULL; assert((this_instr + 2)->opcode == _PUSH_FRAME); diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 8f8d40f975e0d0..3eac66da236b62 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -29,16 +29,13 @@ // We guarantee this will error - just bail and don't optimize it. if (sym_is_null(value)) { ctx->done = true; - } - stack_pointer[0] = value; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + }/* Pushed outputs */ break; } case _LOAD_FAST: { _Py_UopsSymbol *value; - value = GETLOCAL(oparg); + value = GETLOCAL(oparg);/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -49,7 +46,7 @@ _Py_UopsSymbol *value; value = GETLOCAL(oparg); _Py_UopsSymbol *temp = sym_new_null(ctx); - GETLOCAL(oparg) = temp; + GETLOCAL(oparg) = temp;/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -61,7 +58,7 @@ PyObject *val = PyTuple_GET_ITEM(co->co_consts, this_instr->oparg); int opcode = _Py_IsImmortal(val) ? _LOAD_CONST_INLINE_BORROW : _LOAD_CONST_INLINE; REPLACE_OP(this_instr, opcode, 0, (uintptr_t)val); - value = sym_new_const(ctx, val); + value = sym_new_const(ctx, val);/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -71,21 +68,20 @@ case _STORE_FAST: { _Py_UopsSymbol *value; value = stack_pointer[-1]; - GETLOCAL(oparg) = value; + GETLOCAL(oparg) = value;/* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } case _POP_TOP: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + value = stack_pointer[-1]; break; } case _PUSH_NULL: { _Py_UopsSymbol *res; - res = sym_new_null(ctx); + res = sym_new_null(ctx);/* Pushed outputs */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -93,25 +89,24 @@ } case _END_SEND: { - _Py_UopsSymbol *value; - value = sym_new_not_null(ctx); - stack_pointer[-2] = value; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + _Py_UopsSymbol *val; + value = stack_pointer[-1]; + receiver = stack_pointer[-2]; + val = sym_new_not_null(ctx); break; } case _UNARY_NEGATIVE: { _Py_UopsSymbol *res; + value = stack_pointer[-1]; res = sym_new_not_null(ctx); - stack_pointer[-1] = res; break; } case _UNARY_NOT: { _Py_UopsSymbol *res; + value = stack_pointer[-1]; res = sym_new_not_null(ctx); - stack_pointer[-1] = res; break; } @@ -122,8 +117,7 @@ int opt = optimize_to_bool(this_instr, ctx, value, &res); if (!opt) { res = sym_new_type(ctx, &PyBool_Type); - } - stack_pointer[-1] = res; + }/* Pushed outputs */ break; } @@ -135,8 +129,7 @@ if (!opt) { sym_set_type(value, &PyBool_Type); res = value; - } - stack_pointer[-1] = res; + }/* Pushed outputs */ break; } @@ -148,8 +141,7 @@ if (!opt) { sym_set_type(value, &PyLong_Type); res = sym_new_type(ctx, &PyBool_Type); - } - stack_pointer[-1] = res; + }/* Pushed outputs */ break; } @@ -161,8 +153,7 @@ if (!opt) { sym_set_type(value, &PyList_Type); res = sym_new_type(ctx, &PyBool_Type); - } - stack_pointer[-1] = res; + }/* Pushed outputs */ break; } @@ -174,8 +165,7 @@ if (!opt) { sym_set_const(value, Py_None); res = sym_new_const(ctx, Py_False); - } - stack_pointer[-1] = res; + }/* Pushed outputs */ break; } @@ -187,22 +177,21 @@ if (!opt) { res = sym_new_type(ctx, &PyBool_Type); sym_set_type(value, &PyUnicode_Type); - } - stack_pointer[-1] = res; + }/* Pushed outputs */ break; } case _REPLACE_WITH_TRUE: { _Py_UopsSymbol *res; + value = stack_pointer[-1]; res = sym_new_not_null(ctx); - stack_pointer[-1] = res; break; } case _UNARY_INVERT: { _Py_UopsSymbol *res; + value = stack_pointer[-1]; res = sym_new_not_null(ctx); - stack_pointer[-1] = res; break; } @@ -225,15 +214,17 @@ } } sym_set_type(left, &PyLong_Type); - sym_set_type(right, &PyLong_Type); + sym_set_type(right, &PyLong_Type);/* Pushed outputs */ break; } case _GUARD_NOS_INT: { + left = stack_pointer[-2]; break; } case _GUARD_TOS_INT: { + value = stack_pointer[-1]; break; } @@ -260,7 +251,7 @@ } else { res = sym_new_type(ctx, &PyLong_Type); - } + }/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -290,7 +281,7 @@ } else { res = sym_new_type(ctx, &PyLong_Type); - } + }/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -320,7 +311,7 @@ } else { res = sym_new_type(ctx, &PyLong_Type); - } + }/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -346,15 +337,17 @@ } } sym_set_type(left, &PyFloat_Type); - sym_set_type(right, &PyFloat_Type); + sym_set_type(right, &PyFloat_Type);/* Pushed outputs */ break; } case _GUARD_NOS_FLOAT: { + left = stack_pointer[-2]; break; } case _GUARD_TOS_FLOAT: { + value = stack_pointer[-1]; break; } @@ -382,7 +375,7 @@ } else { res = sym_new_type(ctx, &PyFloat_Type); - } + }/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -413,7 +406,7 @@ } else { res = sym_new_type(ctx, &PyFloat_Type); - } + }/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -444,7 +437,7 @@ } else { res = sym_new_type(ctx, &PyFloat_Type); - } + }/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -461,7 +454,7 @@ REPLACE_OP(this_instr, _NOP, 0 ,0); } sym_set_type(left, &PyUnicode_Type); - sym_set_type(left, &PyUnicode_Type); + sym_set_type(left, &PyUnicode_Type);/* Pushed outputs */ break; } @@ -482,7 +475,7 @@ } else { res = sym_new_type(ctx, &PyUnicode_Type); - } + }/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -490,72 +483,70 @@ } case _BINARY_OP_INPLACE_ADD_UNICODE: { - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + right = stack_pointer[-1]; + left = stack_pointer[-2]; break; } case _BINARY_SUBSCR: { _Py_UopsSymbol *res; + sub = stack_pointer[-1]; + container = stack_pointer[-2]; res = sym_new_not_null(ctx); - stack_pointer[-2] = res; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } case _BINARY_SLICE: { _Py_UopsSymbol *res; + stop = stack_pointer[-1]; + start = stack_pointer[-2]; + container = stack_pointer[-3]; res = sym_new_not_null(ctx); - stack_pointer[-3] = res; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } case _STORE_SLICE: { - stack_pointer += -4; - assert(WITHIN_STACK_BOUNDS()); + stop = stack_pointer[-1]; + start = stack_pointer[-2]; + container = stack_pointer[-3]; + v = stack_pointer[-4]; break; } case _BINARY_SUBSCR_LIST_INT: { _Py_UopsSymbol *res; + sub_st = stack_pointer[-1]; + list_st = stack_pointer[-2]; res = sym_new_not_null(ctx); - stack_pointer[-2] = res; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } case _BINARY_SUBSCR_STR_INT: { _Py_UopsSymbol *res; + sub_st = stack_pointer[-1]; + str_st = stack_pointer[-2]; res = sym_new_not_null(ctx); - stack_pointer[-2] = res; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } case _BINARY_SUBSCR_TUPLE_INT: { _Py_UopsSymbol *res; + sub_st = stack_pointer[-1]; + tuple_st = stack_pointer[-2]; res = sym_new_not_null(ctx); - stack_pointer[-2] = res; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } case _BINARY_SUBSCR_DICT: { _Py_UopsSymbol *res; + sub_st = stack_pointer[-1]; + dict_st = stack_pointer[-2]; res = sym_new_not_null(ctx); - stack_pointer[-2] = res; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } case _BINARY_SUBSCR_CHECK_FUNC: { + container = stack_pointer[-2]; break; } @@ -568,7 +559,7 @@ (void)container; (void)sub; new_frame = NULL; - ctx->done = true; + ctx->done = true;/* Pushed outputs */ stack_pointer[-2] = (_Py_UopsSymbol *)new_frame; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -576,54 +567,56 @@ } case _LIST_APPEND: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + v = stack_pointer[-1]; + list = stack_pointer[-2 - (oparg-1)]; break; } case _SET_ADD: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + v = stack_pointer[-1]; + set = stack_pointer[-2 - (oparg-1)]; break; } case _STORE_SUBSCR: { - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); + sub = stack_pointer[-1]; + container = stack_pointer[-2]; + v = stack_pointer[-3]; break; } case _STORE_SUBSCR_LIST_INT: { - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); + sub_st = stack_pointer[-1]; + list_st = stack_pointer[-2]; + value = stack_pointer[-3]; break; } case _STORE_SUBSCR_DICT: { - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); + sub = stack_pointer[-1]; + dict_st = stack_pointer[-2]; + value = stack_pointer[-3]; break; } case _DELETE_SUBSCR: { - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + sub = stack_pointer[-1]; + container = stack_pointer[-2]; break; } case _CALL_INTRINSIC_1: { _Py_UopsSymbol *res; + value = stack_pointer[-1]; res = sym_new_not_null(ctx); - stack_pointer[-1] = res; break; } case _CALL_INTRINSIC_2: { _Py_UopsSymbol *res; + value1_st = stack_pointer[-1]; + value2_st = stack_pointer[-2]; res = sym_new_not_null(ctx); - stack_pointer[-2] = res; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -648,33 +641,28 @@ if (co == NULL) { // might be impossible, but bailing is still safe ctx->done = true; - } - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + }/* Pushed outputs */ break; } case _GET_AITER: { _Py_UopsSymbol *iter; + obj = stack_pointer[-1]; iter = sym_new_not_null(ctx); - stack_pointer[-1] = iter; break; } case _GET_ANEXT: { _Py_UopsSymbol *awaitable; + aiter = stack_pointer[-1]; awaitable = sym_new_not_null(ctx); - stack_pointer[0] = awaitable; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } case _GET_AWAITABLE: { _Py_UopsSymbol *iter; + iterable = stack_pointer[-1]; iter = sym_new_not_null(ctx); - stack_pointer[-1] = iter; break; } @@ -682,44 +670,36 @@ case _SEND_GEN_FRAME: { // We are about to hit the end of the trace: - ctx->done = true; + ctx->done = true;/* Pushed outputs */ break; } case _YIELD_VALUE: { _Py_UopsSymbol *res; - res = sym_new_unknown(ctx); + res = sym_new_unknown(ctx);/* Pushed outputs */ stack_pointer[-1] = res; break; } case _POP_EXCEPT: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + exc_value = stack_pointer[-1]; break; } case _LOAD_COMMON_CONSTANT: { _Py_UopsSymbol *value; value = sym_new_not_null(ctx); - stack_pointer[0] = value; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } case _LOAD_BUILD_CLASS: { _Py_UopsSymbol *bc; bc = sym_new_not_null(ctx); - stack_pointer[0] = bc; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } case _STORE_NAME: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + v = stack_pointer[-1]; break; } @@ -730,13 +710,13 @@ case _UNPACK_SEQUENCE: { _Py_UopsSymbol *seq; _Py_UopsSymbol **values; + values = &stack_pointer[0]; seq = stack_pointer[-1]; - values = &stack_pointer[-1]; /* This has to be done manually */ (void)seq; for (int i = 0; i < oparg; i++) { values[i] = sym_new_unknown(ctx); - } + }/* Pushed outputs */ stack_pointer += -1 + oparg; assert(WITHIN_STACK_BOUNDS()); break; @@ -745,68 +725,61 @@ case _UNPACK_SEQUENCE_TWO_TUPLE: { _Py_UopsSymbol *val1; _Py_UopsSymbol *val0; + seq = stack_pointer[-1]; val1 = sym_new_not_null(ctx); val0 = sym_new_not_null(ctx); - stack_pointer[-1] = val1; - stack_pointer[0] = val0; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } case _UNPACK_SEQUENCE_TUPLE: { _Py_UopsSymbol **values; - values = &stack_pointer[-1]; + values = &stack_pointer[0]; + seq = stack_pointer[-1]; for (int _i = oparg; --_i >= 0;) { values[_i] = sym_new_not_null(ctx); } - stack_pointer += -1 + oparg; - assert(WITHIN_STACK_BOUNDS()); break; } case _UNPACK_SEQUENCE_LIST: { _Py_UopsSymbol **values; - values = &stack_pointer[-1]; + values = &stack_pointer[0]; + seq = stack_pointer[-1]; for (int _i = oparg; --_i >= 0;) { values[_i] = sym_new_not_null(ctx); } - stack_pointer += -1 + oparg; - assert(WITHIN_STACK_BOUNDS()); break; } case _UNPACK_EX: { _Py_UopsSymbol *seq; _Py_UopsSymbol **values; + values = &stack_pointer[0]; seq = stack_pointer[-1]; - values = &stack_pointer[-1]; /* This has to be done manually */ (void)seq; int totalargs = (oparg & 0xFF) + (oparg >> 8) + 1; for (int i = 0; i < totalargs; i++) { values[i] = sym_new_unknown(ctx); - } + }/* Pushed outputs */ stack_pointer += (oparg & 0xFF) + (oparg >> 8); assert(WITHIN_STACK_BOUNDS()); break; } case _STORE_ATTR: { - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + owner = stack_pointer[-1]; + v = stack_pointer[-2]; break; } case _DELETE_ATTR: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + owner = stack_pointer[-1]; break; } case _STORE_GLOBAL: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + v = stack_pointer[-1]; break; } @@ -817,9 +790,6 @@ case _LOAD_LOCALS: { _Py_UopsSymbol *locals; locals = sym_new_not_null(ctx); - stack_pointer[0] = locals; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -828,9 +798,6 @@ case _LOAD_NAME: { _Py_UopsSymbol *v; v = sym_new_not_null(ctx); - stack_pointer[0] = v; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -839,10 +806,6 @@ _Py_UopsSymbol *null = NULL; res = sym_new_not_null(ctx); null = sym_new_null(ctx); - stack_pointer[0] = res; - if (oparg & 1) stack_pointer[1] = null; - stack_pointer += 1 + (oparg & 1); - assert(WITHIN_STACK_BOUNDS()); break; } @@ -859,10 +822,6 @@ _Py_UopsSymbol *null = NULL; res = sym_new_not_null(ctx); null = sym_new_null(ctx); - stack_pointer[0] = res; - if (oparg & 1) stack_pointer[1] = null; - stack_pointer += 1 + (oparg & 1); - assert(WITHIN_STACK_BOUNDS()); break; } @@ -871,10 +830,6 @@ _Py_UopsSymbol *null = NULL; res = sym_new_not_null(ctx); null = sym_new_null(ctx); - stack_pointer[0] = res; - if (oparg & 1) stack_pointer[1] = null; - stack_pointer += 1 + (oparg & 1); - assert(WITHIN_STACK_BOUNDS()); break; } @@ -892,23 +847,19 @@ case _LOAD_FROM_DICT_OR_DEREF: { _Py_UopsSymbol *value; + class_dict_st = stack_pointer[-1]; value = sym_new_not_null(ctx); - stack_pointer[-1] = value; break; } case _LOAD_DEREF: { _Py_UopsSymbol *value; value = sym_new_not_null(ctx); - stack_pointer[0] = value; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } case _STORE_DEREF: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + v = stack_pointer[-1]; break; } @@ -918,58 +869,48 @@ case _BUILD_STRING: { _Py_UopsSymbol *str; + pieces = &stack_pointer[-oparg]; str = sym_new_not_null(ctx); - stack_pointer[-oparg] = str; - stack_pointer += 1 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } case _BUILD_TUPLE: { _Py_UopsSymbol *tup; + values = &stack_pointer[-oparg]; tup = sym_new_not_null(ctx); - stack_pointer[-oparg] = tup; - stack_pointer += 1 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } case _BUILD_LIST: { _Py_UopsSymbol *list; + values = &stack_pointer[-oparg]; list = sym_new_not_null(ctx); - stack_pointer[-oparg] = list; - stack_pointer += 1 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } case _LIST_EXTEND: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + iterable_st = stack_pointer[-1]; + list_st = stack_pointer[-2 - (oparg-1)]; break; } case _SET_UPDATE: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + iterable = stack_pointer[-1]; + set = stack_pointer[-2 - (oparg-1)]; break; } case _BUILD_SET: { _Py_UopsSymbol *set; + values = &stack_pointer[-oparg]; set = sym_new_not_null(ctx); - stack_pointer[-oparg] = set; - stack_pointer += 1 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } case _BUILD_MAP: { _Py_UopsSymbol *map; + values = &stack_pointer[-oparg*2]; map = sym_new_not_null(ctx); - stack_pointer[-oparg*2] = map; - stack_pointer += 1 - oparg*2; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -978,20 +919,22 @@ } case _DICT_UPDATE: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + update = stack_pointer[-1]; + dict = stack_pointer[-2 - (oparg - 1)]; break; } case _DICT_MERGE: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + update = stack_pointer[-1]; + dict = stack_pointer[-2 - (oparg - 1)]; + callable = stack_pointer[-5 - (oparg - 1)]; break; } case _MAP_ADD: { - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + value = stack_pointer[-1]; + key = stack_pointer[-2]; + dict_st = stack_pointer[-3 - (oparg - 1)]; break; } @@ -999,22 +942,21 @@ case _LOAD_SUPER_ATTR_ATTR: { _Py_UopsSymbol *attr_st; + self_st = stack_pointer[-1]; + class_st = stack_pointer[-2]; + global_super_st = stack_pointer[-3]; attr_st = sym_new_not_null(ctx); - stack_pointer[-3] = attr_st; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } case _LOAD_SUPER_ATTR_METHOD: { _Py_UopsSymbol *attr; _Py_UopsSymbol *self_or_null; + self_st = stack_pointer[-1]; + class_st = stack_pointer[-2]; + global_super_st = stack_pointer[-3]; attr = sym_new_not_null(ctx); self_or_null = sym_new_not_null(ctx); - stack_pointer[-3] = attr; - stack_pointer[-2] = self_or_null; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1030,7 +972,7 @@ } else { self_or_null = NULL; - } + }/* Pushed outputs */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = self_or_null; stack_pointer += (oparg & 1); @@ -1060,11 +1002,12 @@ _Py_BloomFilter_Add(dependencies, type); } } - } + }/* Pushed outputs */ break; } case _CHECK_MANAGED_OBJECT_HAS_VALUES: { + owner = stack_pointer[-1]; break; } @@ -1077,7 +1020,7 @@ attr = sym_new_not_null(ctx); null = sym_new_null(ctx); (void)offset; - (void)owner; + (void)owner;/* Pushed outputs */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); @@ -1102,7 +1045,7 @@ this_instr->opcode = _NOP; } } - } + }/* Pushed outputs */ break; } @@ -1130,15 +1073,12 @@ if (attr == NULL) { /* No conversion made. We don't know what `attr` is. */ attr = sym_new_not_null(ctx); - } - stack_pointer[-1] = attr; - if (oparg & 1) stack_pointer[0] = null; - stack_pointer += (oparg & 1); - assert(WITHIN_STACK_BOUNDS()); + }/* Pushed outputs */ break; } case _CHECK_ATTR_WITH_HINT: { + owner = stack_pointer[-1]; break; } @@ -1151,7 +1091,7 @@ attr = sym_new_not_null(ctx); null = sym_new_null(ctx); (void)hint; - (void)owner; + (void)owner;/* Pushed outputs */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); @@ -1168,7 +1108,7 @@ attr = sym_new_not_null(ctx); null = sym_new_null(ctx); (void)index; - (void)owner; + (void)owner;/* Pushed outputs */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); @@ -1177,6 +1117,7 @@ } case _CHECK_ATTR_CLASS: { + owner = stack_pointer[-1]; break; } @@ -1189,7 +1130,7 @@ attr = sym_new_not_null(ctx); null = sym_new_null(ctx); (void)descr; - (void)owner; + (void)owner;/* Pushed outputs */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); @@ -1205,7 +1146,7 @@ (void)fget; (void)owner; new_frame = NULL; - ctx->done = true; + ctx->done = true;/* Pushed outputs */ stack_pointer[-1] = (_Py_UopsSymbol *)new_frame; break; } @@ -1213,24 +1154,25 @@ /* _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN is not a viable micro-op for tier 2 */ case _GUARD_DORV_NO_DICT: { + owner = stack_pointer[-1]; break; } case _STORE_ATTR_INSTANCE_VALUE: { - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + owner = stack_pointer[-1]; + value = stack_pointer[-2]; break; } case _STORE_ATTR_WITH_HINT: { - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + owner = stack_pointer[-1]; + value = stack_pointer[-2]; break; } case _STORE_ATTR_SLOT: { - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + owner = stack_pointer[-1]; + value = stack_pointer[-2]; break; } @@ -1247,7 +1189,7 @@ } else { res = _Py_uop_sym_new_not_null(ctx); - } + }/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1262,7 +1204,7 @@ left = stack_pointer[-2]; (void)left; (void)right; - res = sym_new_type(ctx, &PyBool_Type); + res = sym_new_type(ctx, &PyBool_Type);/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1277,7 +1219,7 @@ left = stack_pointer[-2]; (void)left; (void)right; - res = sym_new_type(ctx, &PyBool_Type); + res = sym_new_type(ctx, &PyBool_Type);/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1292,7 +1234,7 @@ left = stack_pointer[-2]; (void)left; (void)right; - res = sym_new_type(ctx, &PyBool_Type); + res = sym_new_type(ctx, &PyBool_Type);/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1307,7 +1249,7 @@ left = stack_pointer[-2]; (void)left; (void)right; - res = sym_new_type(ctx, &PyBool_Type); + res = sym_new_type(ctx, &PyBool_Type);/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1322,7 +1264,7 @@ left = stack_pointer[-2]; (void)left; (void)right; - res = sym_new_type(ctx, &PyBool_Type); + res = sym_new_type(ctx, &PyBool_Type);/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1331,54 +1273,50 @@ case _CONTAINS_OP_SET: { _Py_UopsSymbol *b; + right = stack_pointer[-1]; + left = stack_pointer[-2]; b = sym_new_not_null(ctx); - stack_pointer[-2] = b; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } case _CONTAINS_OP_DICT: { _Py_UopsSymbol *b; + right = stack_pointer[-1]; + left = stack_pointer[-2]; b = sym_new_not_null(ctx); - stack_pointer[-2] = b; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } case _CHECK_EG_MATCH: { _Py_UopsSymbol *rest; _Py_UopsSymbol *match; + match_type_st = stack_pointer[-1]; + exc_value_st = stack_pointer[-2]; rest = sym_new_not_null(ctx); match = sym_new_not_null(ctx); - stack_pointer[-2] = rest; - stack_pointer[-1] = match; break; } case _CHECK_EXC_MATCH: { _Py_UopsSymbol *b; + right = stack_pointer[-1]; + left = stack_pointer[-2]; b = sym_new_not_null(ctx); - stack_pointer[-1] = b; break; } case _IMPORT_NAME: { _Py_UopsSymbol *res; + fromlist = stack_pointer[-1]; + level = stack_pointer[-2]; res = sym_new_not_null(ctx); - stack_pointer[-2] = res; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } case _IMPORT_FROM: { _Py_UopsSymbol *res; + from = stack_pointer[-1]; res = sym_new_not_null(ctx); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1388,67 +1326,60 @@ case _IS_NONE: { _Py_UopsSymbol *b; + value = stack_pointer[-1]; b = sym_new_not_null(ctx); - stack_pointer[-1] = b; break; } case _GET_LEN: { _Py_UopsSymbol *len; + obj = stack_pointer[-1]; len = sym_new_not_null(ctx); - stack_pointer[0] = len; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } case _MATCH_CLASS: { _Py_UopsSymbol *attrs; + names = stack_pointer[-1]; + type = stack_pointer[-2]; + subject = stack_pointer[-3]; attrs = sym_new_not_null(ctx); - stack_pointer[-3] = attrs; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } case _MATCH_MAPPING: { _Py_UopsSymbol *res; + subject = stack_pointer[-1]; res = sym_new_not_null(ctx); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } case _MATCH_SEQUENCE: { _Py_UopsSymbol *res; + subject = stack_pointer[-1]; res = sym_new_not_null(ctx); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } case _MATCH_KEYS: { _Py_UopsSymbol *values_or_none; + keys = stack_pointer[-1]; + subject = stack_pointer[-2]; values_or_none = sym_new_not_null(ctx); - stack_pointer[0] = values_or_none; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } case _GET_ITER: { _Py_UopsSymbol *iter; + iterable = stack_pointer[-1]; iter = sym_new_not_null(ctx); - stack_pointer[-1] = iter; break; } case _GET_YIELD_FROM_ITER: { _Py_UopsSymbol *iter; + iterable = stack_pointer[-1]; iter = sym_new_not_null(ctx); - stack_pointer[-1] = iter; break; } @@ -1456,60 +1387,60 @@ case _FOR_ITER_TIER_TWO: { _Py_UopsSymbol *next; + iter = stack_pointer[-1]; next = sym_new_not_null(ctx); - stack_pointer[0] = next; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } /* _INSTRUMENTED_FOR_ITER is not a viable micro-op for tier 2 */ case _ITER_CHECK_LIST: { + iter = stack_pointer[-1]; break; } /* _ITER_JUMP_LIST is not a viable micro-op for tier 2 */ case _GUARD_NOT_EXHAUSTED_LIST: { + iter = stack_pointer[-1]; break; } case _ITER_NEXT_LIST: { _Py_UopsSymbol *next; + iter = stack_pointer[-1]; next = sym_new_not_null(ctx); - stack_pointer[0] = next; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } case _ITER_CHECK_TUPLE: { + iter = stack_pointer[-1]; break; } /* _ITER_JUMP_TUPLE is not a viable micro-op for tier 2 */ case _GUARD_NOT_EXHAUSTED_TUPLE: { + iter = stack_pointer[-1]; break; } case _ITER_NEXT_TUPLE: { _Py_UopsSymbol *next; + iter = stack_pointer[-1]; next = sym_new_not_null(ctx); - stack_pointer[0] = next; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } case _ITER_CHECK_RANGE: { + iter = stack_pointer[-1]; break; } /* _ITER_JUMP_RANGE is not a viable micro-op for tier 2 */ case _GUARD_NOT_EXHAUSTED_RANGE: { + iter = stack_pointer[-1]; break; } @@ -1518,7 +1449,7 @@ _Py_UopsSymbol *next; iter = stack_pointer[-1]; next = sym_new_type(ctx, &PyLong_Type); - (void)iter; + (void)iter;/* Pushed outputs */ stack_pointer[0] = next; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1527,7 +1458,7 @@ case _FOR_ITER_GEN_FRAME: { /* We are about to hit the end of the trace */ - ctx->done = true; + ctx->done = true;/* Pushed outputs */ break; } @@ -1538,7 +1469,7 @@ owner = stack_pointer[-1]; (void)owner; attr = sym_new_not_null(ctx); - self_or_null = sym_new_unknown(ctx); + self_or_null = sym_new_unknown(ctx);/* Pushed outputs */ stack_pointer[-1] = attr; stack_pointer[0] = self_or_null; stack_pointer += 1; @@ -1548,30 +1479,30 @@ case _WITH_EXCEPT_START: { _Py_UopsSymbol *res; + val = stack_pointer[-1]; + lasti = stack_pointer[-3]; + exit_self = stack_pointer[-4]; + exit_func = stack_pointer[-5]; res = sym_new_not_null(ctx); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } case _PUSH_EXC_INFO: { _Py_UopsSymbol *prev_exc; _Py_UopsSymbol *new_exc; + exc = stack_pointer[-1]; prev_exc = sym_new_not_null(ctx); new_exc = sym_new_not_null(ctx); - stack_pointer[-1] = prev_exc; - stack_pointer[0] = new_exc; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT: { + owner = stack_pointer[-1]; break; } case _GUARD_KEYS_VERSION: { + owner = stack_pointer[-1]; break; } @@ -1583,7 +1514,7 @@ PyObject *descr = (PyObject *)this_instr->operand; (void)descr; attr = sym_new_not_null(ctx); - self = owner; + self = owner;/* Pushed outputs */ stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; @@ -1599,7 +1530,7 @@ PyObject *descr = (PyObject *)this_instr->operand; (void)descr; attr = sym_new_not_null(ctx); - self = owner; + self = owner;/* Pushed outputs */ stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; @@ -1609,19 +1540,20 @@ case _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: { _Py_UopsSymbol *attr; + owner = stack_pointer[-1]; attr = sym_new_not_null(ctx); - stack_pointer[-1] = attr; break; } case _LOAD_ATTR_NONDESCRIPTOR_NO_DICT: { _Py_UopsSymbol *attr; + owner = stack_pointer[-1]; attr = sym_new_not_null(ctx); - stack_pointer[-1] = attr; break; } case _CHECK_ATTR_METHOD_LAZY_DICT: { + owner = stack_pointer[-1]; break; } @@ -1633,7 +1565,7 @@ PyObject *descr = (PyObject *)this_instr->operand; (void)descr; attr = sym_new_not_null(ctx); - self = owner; + self = owner;/* Pushed outputs */ stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; @@ -1647,15 +1579,15 @@ _Py_UopsSymbol *callable; _Py_UopsSymbol *func; _Py_UopsSymbol *maybe_self; + args = &stack_pointer[2]; args = &stack_pointer[-oparg]; self_or_null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; - args = &stack_pointer[-oparg]; (void)callable; (void)self_or_null; (void)args; func = sym_new_not_null(ctx); - maybe_self = sym_new_not_null(ctx); + maybe_self = sym_new_not_null(ctx);/* Pushed outputs */ stack_pointer[-2 - oparg] = func; stack_pointer[-1 - oparg] = maybe_self; break; @@ -1678,7 +1610,7 @@ (void)self_or_null; (void)args; new_frame = NULL; - ctx->done = true; + ctx->done = true;/* Pushed outputs */ stack_pointer[-2 - oparg] = (_Py_UopsSymbol *)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1686,35 +1618,40 @@ } case _CHECK_FUNCTION_VERSION: { + callable = stack_pointer[-2 - oparg]; break; } case _CHECK_METHOD_VERSION: { + null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; break; } case _EXPAND_METHOD: { _Py_UopsSymbol *method; _Py_UopsSymbol **self; - self = &stack_pointer[-1 - oparg]; + self = &stack_pointer[1]; + null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; method = sym_new_not_null(ctx); for (int _i = 1; --_i >= 0;) { self[_i] = sym_new_not_null(ctx); } - stack_pointer[-2 - oparg] = method; break; } case _CHECK_IS_NOT_PY_CALLABLE: { + callable = stack_pointer[-2 - oparg]; break; } case _CALL_NON_PY_GENERAL: { _Py_UopsSymbol *res; + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1724,7 +1661,7 @@ null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; sym_set_null(null); - sym_set_type(callable, &PyMethod_Type); + sym_set_type(callable, &PyMethod_Type);/* Pushed outputs */ break; } @@ -1735,7 +1672,7 @@ callable = stack_pointer[-2 - oparg]; (void)callable; func = sym_new_not_null(ctx); - self = sym_new_not_null(ctx); + self = sym_new_not_null(ctx);/* Pushed outputs */ stack_pointer[-2 - oparg] = func; stack_pointer[-1 - oparg] = self; break; @@ -1746,7 +1683,7 @@ * all executors, so no need to check dynamically */ if (_PyInterpreterState_GET()->eval_frame == NULL) { REPLACE_OP(this_instr, _NOP, 0 ,0); - } + }/* Pushed outputs */ break; } @@ -1756,13 +1693,13 @@ self_or_null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; sym_set_type(callable, &PyFunction_Type); - (void)self_or_null; + (void)self_or_null;/* Pushed outputs */ break; } case _CHECK_STACK_SPACE: { assert(corresponding_check_stack == NULL); - corresponding_check_stack = this_instr; + corresponding_check_stack = this_instr;/* Pushed outputs */ break; } @@ -1774,8 +1711,7 @@ args = &stack_pointer[-oparg]; self_or_null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; - int argcount = oparg; - (void)callable; + int argcount = oparg;(void)callable ; PyCodeObject *co = NULL; assert((this_instr + 2)->opcode == _PUSH_FRAME); uint64_t push_operand = (this_instr + 2)->operand; @@ -1807,15 +1743,13 @@ new_frame = frame_new(ctx, co, 0, args, argcount); } else { new_frame = frame_new(ctx, co, 0, NULL, 0); - } - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); + }/* Pushed outputs */ break; } case _PUSH_FRAME: { _Py_UOpsAbstractFrame *new_frame; - new_frame = (_Py_UOpsAbstractFrame *)stack_pointer[-1]; + new_frame = (_Py_UOpsAbstractFrame *)stack_pointer[-1].bits; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); ctx->frame->stack_pointer = stack_pointer; @@ -1845,34 +1779,34 @@ // delete all but the first valid _CHECK_STACK_SPACE corresponding_check_stack->opcode = _NOP; } - corresponding_check_stack = NULL; + corresponding_check_stack = NULL;/* Pushed outputs */ break; } case _CALL_TYPE_1: { _Py_UopsSymbol *res; + arg = stack_pointer[-1]; + null = stack_pointer[-2]; + callable = stack_pointer[-3]; res = sym_new_not_null(ctx); - stack_pointer[-3] = res; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_STR_1: { _Py_UopsSymbol *res; + arg = stack_pointer[-1]; + null = stack_pointer[-2]; + callable = stack_pointer[-3]; res = sym_new_not_null(ctx); - stack_pointer[-3] = res; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_TUPLE_1: { _Py_UopsSymbol *res; + arg = stack_pointer[-1]; + null = stack_pointer[-2]; + callable = stack_pointer[-3]; res = sym_new_not_null(ctx); - stack_pointer[-3] = res; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -1882,17 +1816,17 @@ _Py_UopsSymbol *callable; _Py_UopsSymbol *self; _Py_UopsSymbol *init; + args = &stack_pointer[2]; args = &stack_pointer[-oparg]; null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; - args = &stack_pointer[-oparg]; uint32_t type_version = (uint32_t)this_instr->operand; (void)type_version; (void)callable; (void)null; (void)args; self = sym_new_not_null(ctx); - init = sym_new_not_null(ctx); + init = sym_new_not_null(ctx);/* Pushed outputs */ stack_pointer[-2 - oparg] = self; stack_pointer[-1 - oparg] = init; break; @@ -1910,7 +1844,7 @@ (void)init; (void)args; init_frame = NULL; - ctx->done = true; + ctx->done = true;/* Pushed outputs */ stack_pointer[-2 - oparg] = (_Py_UopsSymbol *)init_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1918,109 +1852,130 @@ } case _EXIT_INIT_CHECK: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + should_be_none = stack_pointer[-1]; break; } case _CALL_BUILTIN_CLASS: { _Py_UopsSymbol *res; + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_BUILTIN_O: { _Py_UopsSymbol *res; + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_BUILTIN_FAST: { _Py_UopsSymbol *res; + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_BUILTIN_FAST_WITH_KEYWORDS: { _Py_UopsSymbol *res; + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_LEN: { _Py_UopsSymbol *res; + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_ISINSTANCE: { _Py_UopsSymbol *res; + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_LIST_APPEND: { - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); + arg = stack_pointer[-1]; + self = stack_pointer[-2]; + callable = stack_pointer[-3]; break; } case _CALL_METHOD_DESCRIPTOR_O: { _Py_UopsSymbol *res; + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: { _Py_UopsSymbol *res; + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_METHOD_DESCRIPTOR_NOARGS: { _Py_UopsSymbol *res; + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_METHOD_DESCRIPTOR_FAST: { _Py_UopsSymbol *res; + args = &stack_pointer[-oparg]; + self_or_null = &stack_pointer[-1 - oparg]; + callable = stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); - stack_pointer[-2 - oparg] = res; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } /* _INSTRUMENTED_CALL_KW is not a viable micro-op for tier 2 */ + case _MAYBE_EXPAND_METHOD_KW: { + _Py_UopsSymbol *func; + _Py_UopsSymbol **maybe_self; + _Py_UopsSymbol **args; + _Py_UopsSymbol *kwnames_out; + maybe_self = &stack_pointer[1]; + kwnames_in = stack_pointer[-1]; + args = &stack_pointer[-1 - oparg]; + self_or_null = &stack_pointer[-2 - oparg]; + callable = stack_pointer[-3 - oparg]; + func = sym_new_not_null(ctx); + for (int _i = 1; --_i >= 0;) { + maybe_self[_i] = sym_new_not_null(ctx); + } + for (int _i = oparg; --_i >= 0;) { + args[_i] = sym_new_not_null(ctx); + } + kwnames_out = sym_new_not_null(ctx); + break; + } + /* _DO_CALL_KW is not a viable micro-op for tier 2 */ case _PY_FRAME_KW: { @@ -2038,7 +1993,7 @@ (void)args; (void)kwnames; new_frame = NULL; - ctx->done = true; + ctx->done = true;/* Pushed outputs */ stack_pointer[-3 - oparg] = (_Py_UopsSymbol *)new_frame; stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2046,38 +2001,41 @@ } case _CHECK_FUNCTION_VERSION_KW: { + callable = stack_pointer[-3 - oparg]; break; } case _CHECK_METHOD_VERSION_KW: { + null = &stack_pointer[-2 - oparg]; + callable = stack_pointer[-3 - oparg]; break; } case _EXPAND_METHOD_KW: { _Py_UopsSymbol *method; _Py_UopsSymbol **self; - _Py_UopsSymbol *kwnames; - self = &stack_pointer[-2 - oparg]; + self = &stack_pointer[1]; + null = &stack_pointer[-2 - oparg]; + callable = stack_pointer[-3 - oparg]; method = sym_new_not_null(ctx); for (int _i = 1; --_i >= 0;) { self[_i] = sym_new_not_null(ctx); } - kwnames = sym_new_not_null(ctx); - stack_pointer[-3 - oparg] = method; - stack_pointer[-1] = kwnames; break; } case _CHECK_IS_NOT_PY_CALLABLE_KW: { + callable = stack_pointer[-3 - oparg]; break; } case _CALL_KW_NON_PY: { _Py_UopsSymbol *res; + kwnames = stack_pointer[-1]; + args = &stack_pointer[-1 - oparg]; + self_or_null = &stack_pointer[-2 - oparg]; + callable = stack_pointer[-3 - oparg]; res = sym_new_not_null(ctx); - stack_pointer[-3 - oparg] = res; - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -2087,17 +2045,16 @@ case _MAKE_FUNCTION: { _Py_UopsSymbol *func; + codeobj_st = stack_pointer[-1]; func = sym_new_not_null(ctx); - stack_pointer[-1] = func; break; } case _SET_FUNCTION_ATTRIBUTE: { - _Py_UopsSymbol *func_st; - func_st = sym_new_not_null(ctx); - stack_pointer[-2] = func_st; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + _Py_UopsSymbol *func_out; + func_in = stack_pointer[-1]; + attr_st = stack_pointer[-2]; + func_out = sym_new_not_null(ctx); break; } @@ -2118,42 +2075,38 @@ if (co == NULL) { // might be impossible, but bailing is still safe ctx->done = true; - } - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + }/* Pushed outputs */ break; } case _BUILD_SLICE: { _Py_UopsSymbol *slice; + if (oparg == 3) { step = stack_pointer[-((oparg == 3) ? 1 : 0)]; } + stop = stack_pointer[-1 - ((oparg == 3) ? 1 : 0)]; + start = stack_pointer[-2 - ((oparg == 3) ? 1 : 0)]; slice = sym_new_not_null(ctx); - stack_pointer[-2 - ((oparg == 3) ? 1 : 0)] = slice; - stack_pointer += -1 - ((oparg == 3) ? 1 : 0); - assert(WITHIN_STACK_BOUNDS()); break; } case _CONVERT_VALUE: { _Py_UopsSymbol *result; + value = stack_pointer[-1]; result = sym_new_not_null(ctx); - stack_pointer[-1] = result; break; } case _FORMAT_SIMPLE: { _Py_UopsSymbol *res; + value = stack_pointer[-1]; res = sym_new_not_null(ctx); - stack_pointer[-1] = res; break; } case _FORMAT_WITH_SPEC: { _Py_UopsSymbol *res; + fmt_spec = stack_pointer[-1]; + value = stack_pointer[-2]; res = sym_new_not_null(ctx); - stack_pointer[-2] = res; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -2162,7 +2115,7 @@ _Py_UopsSymbol *top; bottom = stack_pointer[-1 - (oparg-1)]; assert(oparg > 0); - top = bottom; + top = bottom;/* Pushed outputs */ stack_pointer[0] = top; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2192,7 +2145,7 @@ } else { res = sym_new_unknown(ctx); - } + }/* Pushed outputs */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -2200,12 +2153,16 @@ } case _SWAP: { - _Py_UopsSymbol *top; - _Py_UopsSymbol *bottom; - top = stack_pointer[-1]; - bottom = stack_pointer[-2 - (oparg-2)]; - stack_pointer[-2 - (oparg-2)] = top; - stack_pointer[-1] = bottom; + _Py_UopsSymbol *top_in; + _Py_UopsSymbol *bottom_in; + _Py_UopsSymbol *top_out; + _Py_UopsSymbol *bottom_out; + top_in = stack_pointer[-1]; + bottom_in = stack_pointer[-2 - (oparg-2)]; + bottom_out = bottom_in; + top_out = top_in;/* Pushed outputs */ + stack_pointer[-2 - (oparg-2)] = top_out; + stack_pointer[-1] = bottom_out; break; } @@ -2232,9 +2189,7 @@ PyObject *value = sym_get_const(flag); assert(value != NULL); eliminate_pop_guard(this_instr, value != Py_True); - } - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + }/* Pushed outputs */ break; } @@ -2245,9 +2200,7 @@ PyObject *value = sym_get_const(flag); assert(value != NULL); eliminate_pop_guard(this_instr, value != Py_False); - } - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + }/* Pushed outputs */ break; } @@ -2262,9 +2215,7 @@ else if (sym_has_type(flag)) { assert(!sym_matches_type(flag, &_PyNone_Type)); eliminate_pop_guard(this_instr, true); - } - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + }/* Pushed outputs */ break; } @@ -2279,14 +2230,12 @@ else if (sym_has_type(flag)) { assert(!sym_matches_type(flag, &_PyNone_Type)); eliminate_pop_guard(this_instr, false); - } - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + }/* Pushed outputs */ break; } case _JUMP_TO_TOP: { - ctx->done = true; + ctx->done = true;/* Pushed outputs */ break; } @@ -2299,7 +2248,7 @@ (void)framesize; /* We should never see _CHECK_STACK_SPACE_OPERANDs. * They are only created at the end of this pass. */ - Py_UNREACHABLE(); + Py_UNREACHABLE();/* Pushed outputs */ break; } @@ -2310,7 +2259,7 @@ case _EXIT_TRACE: { PyObject *exit_p = (PyObject *)this_instr->operand; (void)exit_p; - ctx->done = true; + ctx->done = true;/* Pushed outputs */ break; } @@ -2321,7 +2270,7 @@ case _LOAD_CONST_INLINE: { _Py_UopsSymbol *value; PyObject *ptr = (PyObject *)this_instr->operand; - value = sym_new_const(ctx, ptr); + value = sym_new_const(ctx, ptr);/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2331,7 +2280,7 @@ case _LOAD_CONST_INLINE_BORROW: { _Py_UopsSymbol *value; PyObject *ptr = (PyObject *)this_instr->operand; - value = sym_new_const(ctx, ptr); + value = sym_new_const(ctx, ptr);/* Pushed outputs */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2340,8 +2289,8 @@ case _POP_TOP_LOAD_CONST_INLINE_BORROW: { _Py_UopsSymbol *value; + pop = stack_pointer[-1]; value = sym_new_not_null(ctx); - stack_pointer[-1] = value; break; } @@ -2350,7 +2299,7 @@ _Py_UopsSymbol *null; PyObject *ptr = (PyObject *)this_instr->operand; value = sym_new_const(ctx, ptr); - null = sym_new_null(ctx); + null = sym_new_null(ctx);/* Pushed outputs */ stack_pointer[0] = value; stack_pointer[1] = null; stack_pointer += 2; @@ -2363,7 +2312,7 @@ _Py_UopsSymbol *null; PyObject *ptr = (PyObject *)this_instr->operand; value = sym_new_const(ctx, ptr); - null = sym_new_null(ctx); + null = sym_new_null(ctx);/* Pushed outputs */ stack_pointer[0] = value; stack_pointer[1] = null; stack_pointer += 2; @@ -2376,8 +2325,7 @@ } case _INTERNAL_INCREMENT_OPT_COUNTER: { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + opt = stack_pointer[-1]; break; } @@ -2402,8 +2350,6 @@ } case _ERROR_POP_N: { - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); break; } diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 05d9c5b154941d..a44aae1d196dc5 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -387,6 +387,7 @@ def find_assignment_target(node: parser.InstDef, idx: int) -> list[lexer.Token]: def find_stores_outputs(node: parser.InstDef) -> list[lexer.Token]: res: list[lexer.Token] = [] outnames = [ out.name for out in node.outputs ] + innames = [ out.name for out in node.inputs ] for idx, tkn in enumerate(node.block.tokens): if tkn.kind == "AND": name = node.block.tokens[idx+1] @@ -401,6 +402,8 @@ def find_stores_outputs(node: parser.InstDef) -> list[lexer.Token]: if len(lhs) != 1 or lhs[0].kind != "IDENTIFIER": continue name = lhs[0] + if name.text in innames: + raise analysis_error(f"Cannot assign to input variable '{name.text}'", name) if name.text in outnames: res.append(name) return res @@ -599,6 +602,8 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "PyType_HasFeature", "_Py_ID", "_Py_DECREF_NO_DEALLOC", + "EMPTY", + "assert", ) def find_stmt_start(node: parser.InstDef, idx: int) -> lexer.Token: diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index ea3e1bc158b815..66f24ae1f6ceab 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -14,7 +14,7 @@ from stack import Stack, Local, Storage, StackError # Set this to true for voluminous output showing state of stack and locals -PRINT_STACKS = 1 #False +PRINT_STACKS = False class TokenIterator: @@ -275,13 +275,14 @@ def kill( name_tkn = next(tkn_iter) name = name_tkn.text next(tkn_iter) - next(tkn_iter) + self.out.emit("(void)") + self.out.emit(name_tkn) for var in storage.inputs: if var.name == name: var.defined = False break else: - raise analysis_error(f"'{name} is not an input-only variable", name_tkn) + raise analysis_error(f"'{name} is not a live input-only variable", name_tkn) return True def stackref_close( @@ -292,6 +293,7 @@ def stackref_close( storage: Storage, inst: Instruction | None, ) -> bool: + self.out.emit(tkn) tkn = next(tkn_iter) assert (tkn.kind == "LPAREN") self.out.emit(tkn) @@ -322,7 +324,8 @@ def sync_sp( next(tkn_iter) next(tkn_iter) next(tkn_iter) - storage.stack.flush(self.out) + storage.clear_inputs(" when syncing stack") + storage.flush(self.out) self._print_storage(storage) return True @@ -420,7 +423,8 @@ def _emit_if( # Discard the if storage reachable = True except StackError as ex: - raise analysis_error(ex.args[0], rbrace) from None + self._print_storage(if_storage) + raise analysis_error(ex.args[0], rbrace) # from None return reachable, rbrace, storage def _emit_block( @@ -505,10 +509,13 @@ def emit_tokens( ) -> None: tkn_iter = TokenIterator(uop.body) self.out.start_line() - _, _, storage = self._emit_block(tkn_iter, uop, storage, inst, False) - for output in storage.outputs: + _, rbrace, storage = self._emit_block(tkn_iter, uop, storage, inst, False) + try: storage.push_outputs() - self._print_storage(storage) + self.emit("/* Pushed outputs */") + self._print_storage(storage) + except StackError as ex: + raise analysis_error(ex.args[0], rbrace) return storage.stack def emit(self, txt: str | Token) -> None: diff --git a/Tools/cases_generator/optimizer_generator.py b/Tools/cases_generator/optimizer_generator.py index 9e16164e19f7c7..16fdb9ad162221 100644 --- a/Tools/cases_generator/optimizer_generator.py +++ b/Tools/cases_generator/optimizer_generator.py @@ -134,14 +134,16 @@ def write_uop( out.emit(f"{type}{cache.name} = ({cast})this_instr->operand;\n") if override: emitter = OptimizerEmitter(out) + # No reference management needed. + for var in storage.inputs: + var.defined = False emitter.emit_tokens(override, storage, None) else: emit_default(out, uop, storage) - storage.push_outputs() out.start_line() stack.flush(out, cast_type="_Py_UopsSymbol *", extract_bits=True) except StackError as ex: - raise analysis_error(ex.args[0], prototype.body[0]) + raise analysis_error(ex.args[0], prototype.body[0]) # from None SKIPS = ("_EXTENDED_ARG",) diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index f4e1923f125901..0e1752eae65983 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -47,7 +47,7 @@ class Local: defined: bool def __repr__(self): - return f"Local('{self.item.name}', in_memory={self.in_memory}, defined={self.defined})" + return f"Local('{self.item.name}', mem={self.in_memory}, defined={self.defined}, array={self.is_array()})" @staticmethod def unused(defn: StackItem) -> "Local": @@ -64,9 +64,8 @@ def redefinition(var: StackItem, prev: "Local") -> "Local": return Local(var, prev.cached, prev.in_memory, True) @staticmethod - def memory(defn: StackItem) -> "Local": - array = defn.is_array() - return Local(defn, True, array, False) + def from_memory(defn: StackItem) -> "Local": + return Local(defn, True, True, True) def copy(self) -> "Local": return Local( @@ -242,7 +241,7 @@ def pop(self, var: StackItem, extract_bits: bool = False) -> tuple[str, Local]: if var.name in UNUSED: if popped.name not in UNUSED and popped.name in self.defined: raise StackError( - f"Value is declared unused, but is already cached by prior operation" + f"Value is declared unused, but is already cached by prior operation as '{popped.name}'" ) return "", popped if not var.used: @@ -277,7 +276,7 @@ def pop(self, var: StackItem, extract_bits: bool = False) -> tuple[str, Local]: assign = f"if ({var.condition}) {{ {assign} }}\n" else: assign = f"{assign}\n" - return assign, Local.memory(var) + return assign, Local.from_memory(var) def push(self, var: Local) -> None: assert(var not in self.variables) @@ -381,7 +380,7 @@ def align(self, other: "Stack", out: CWriter) -> None: except ValueError: raise StackError("Cannot align stacks: cannot adjust stack pointer") - def merge(self, other: "Stack") -> None: + def merge(self, other: "Stack", out: CWriter) -> None: if len(self.variables) != len(other.variables): raise StackError("Cannot merge stacks: differing variables") for self_var, other_var in zip(self.variables, other.variables): @@ -389,6 +388,7 @@ def merge(self, other: "Stack") -> None: raise StackError(f"Mismatched variables on stack: {self_var.name} and {other_var.name}") self_var.defined = self_var.defined and other_var.defined self_var.in_memory = self_var.in_memory and other_var.in_memory + self.align(other, out) def get_stack_effect(inst: Instruction | PseudoInstruction) -> Stack: @@ -427,28 +427,53 @@ class Storage: spilled: int = 0 @staticmethod - def doesnt_need_defining(var: Local): + def needs_defining(var: Local): + return ( + not var.defined and + not var.is_array() and + var.name != "unused" + ) + + @staticmethod + def is_live(var: Local): return ( - var.defined or - var.is_array() or - var.name == "unused" + var.defined and + not var.is_array() and + var.name != "unused" ) - def _push_defined_locals(self) -> None: + def clear_inputs(self, reason:str) -> None: + while self.inputs: + tos = self.inputs.pop() + if self.is_live(tos): + raise StackError( + f"Input '{tos.name}' is still live {reason}" + ) + self.stack.pop(tos.item) + + def clear_dead_inputs(self) -> None: + live = "" + while self.inputs: + tos = self.inputs[-1] + if self.is_live(tos): + live = tos.name + break + self.inputs.pop() + self.stack.pop(tos.item) + for var in self.inputs: + if not var.defined and not var.is_array() and var.name != "unused": + raise StackError( + f"Input '{var.name}' is not live, but '{live}' is" + ) + + def _push_defined_outputs(self) -> None: defined_output = "" for output in self.outputs: if output.defined and not output.in_memory: defined_output = output.name if not defined_output: return - while self.inputs: - tos = self.inputs.pop() - if tos.defined and not tos.is_array(): - raise StackError( - f"Input '{tos.name}' is not cleared " - f"when output '{defined_output}' is defined" - ) - self.stack.pop(tos.item) + self.clear_inputs(f"when output '{defined_output}' is defined") undefined = "" for out in self.outputs: if out.defined: @@ -457,7 +482,7 @@ def _push_defined_locals(self) -> None: f"Expected '{undefined}' to be defined before '{out.name}'" else: undefined = out.name - while self.outputs and self.doesnt_need_defining(self.outputs[0]): + while self.outputs and not self.needs_defining(self.outputs[0]): out = self.outputs.pop(0) self.stack.push(out) @@ -468,7 +493,8 @@ def locals_cached(self) -> bool: return False def flush(self, out: CWriter) -> None: - self._push_defined_locals() + self.clear_dead_inputs() + self._push_defined_outputs() self.stack.flush(out) def save(self, out: CWriter) -> None: @@ -504,13 +530,10 @@ def for_uop(stack: Stack, uop: Uop) -> tuple[list[str], "Storage"]: inputs.append(local) inputs.reverse() peeks.reverse() - code_list.append(stack.as_comment()) for var in peeks: stack.push(var) - code_list.append(stack.as_comment()) for var in inputs: stack.push(var) - code_list.append(stack.as_comment()) outputs = [ Local.undefined(var) for var in uop.stack.outputs if not var.peek ] return code_list, Storage(stack, inputs, outputs, peeks) @@ -519,8 +542,12 @@ def copy_list(arg: list[Local]) -> list[Local]: return [ l.copy() for l in arg ] def copy(self) -> "Storage": + new_stack = self.stack.copy() + variables = { var.name: var for var in new_stack.variables } + inputs = [ variables[var.name] for var in self.inputs] + assert [v.name for v in inputs] == [v.name for v in self.inputs], (inputs, self.inputs) return Storage( - self.stack.copy(), self.copy_list(self.inputs), + new_stack, inputs, self.copy_list(self.outputs), self.copy_list(self.peeks) ) @@ -550,25 +577,41 @@ def is_flushed(self) -> None: def merge(self, other: "Storage", out: CWriter) -> None: self.sanity_check() if len(self.inputs) != len(other.inputs): - raise StackError(f"Inputs clearing is not consistent") + self.clear_dead_inputs() + other.clear_dead_inputs() + if len(self.inputs) != len(other.inputs): + diff = self.inputs[-1] if len(self.inputs) > len(other.inputs) else other.inputs[-1] + raise StackError(f"Unmergeable inputs. Differing state of '{diff.name}'") for var, other_var in zip(self.inputs, other.inputs): if var.defined != other_var.defined: raise StackError(f"'{var.name}' is cleared on some paths, but not all") - for var, other_var in zip(self.outputs, other.outputs): - if var.defined != other_var.defined: - raise StackError(f"'{var.name}' is set on some paths, but not all") - self.stack.merge(other.stack) + if len(self.outputs) != len(other.outputs): + self._push_defined_outputs() + other._push_defined_outputs() + if len(self.outputs) != len(other.outputs): + var = self.outputs[0] if len(self.outputs) > len(other.outputs) else other.outputs[0] + raise StackError(f"'{var.name}' is set on some paths, but not all") + self.stack.merge(other.stack, out) self.sanity_check() def push_outputs(self): - self._push_defined_locals() + if self.spilled: + raise StackError(f"Unbalanced stack spills") + self.clear_inputs("at the end of the micro-op") + if self.inputs: + raise StackError(f"Input variable '{self.inputs[-1].name}' is still live") + self._push_defined_outputs() if self.outputs: - raise StackError(f"'{self.outputs[0].name}' is not defined") + for out in self.outputs: + if self.needs_defining(out): + raise StackError(f"Output variable '{self.outputs[0].name}' is not defined") + self.stack.push(out) + self.outputs = [] def as_comment(self) -> str: stack_comment = self.stack.as_comment() next_line = "\n " - inputs = ", ".join([var.name for var in self.inputs]) - outputs = ", ".join([var.name for var in self.outputs]) + inputs = ", ".join([str(var) for var in self.inputs]) + outputs = ", ".join([str(var) for var in self.outputs]) peeks = ", ".join([var.name for var in self.peeks]) return f"{stack_comment[:-2]}{next_line}inputs: {inputs}{next_line}outputs: {outputs}{next_line}peeks: {peeks} */" diff --git a/Tools/cases_generator/tier1_generator.py b/Tools/cases_generator/tier1_generator.py index 219a1c238338a3..738b89935115fb 100644 --- a/Tools/cases_generator/tier1_generator.py +++ b/Tools/cases_generator/tier1_generator.py @@ -87,8 +87,8 @@ def write_uop( if braces: emitter.out.emit(f"// {uop.name}\n") emitter.emit("{\n") - emitter.emit(stack.as_comment()) code_list, storage = Storage.for_uop(stack, uop) + emitter._print_storage(storage) emitter.emit(stack.define_output_arrays(uop.stack.outputs)) for code in code_list: emitter.emit(code) @@ -177,8 +177,9 @@ def generate_tier1( insert_braces = len([p for p in inst.parts if isinstance(p, Uop)]) > 1 offset, stack = write_uop(part, emitter, offset, stack, inst, insert_braces) out.start_line() + + stack.flush(out) if not inst.parts[-1].properties.always_exits: - stack.flush(out) out.emit("DISPATCH();\n") out.start_line() out.emit("}") From a387cb2e14ac508c9a2ba39c29cf80664764a98b Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Mon, 16 Sep 2024 16:38:41 +0100 Subject: [PATCH 29/53] Final fixups --- Include/internal/pycore_opcode_metadata.h | 12 +- Include/internal/pycore_uop_ids.h | 239 +-- Include/internal/pycore_uop_metadata.h | 4 + Include/opcode_ids.h | 1 - Lib/_opcode_metadata.py | 1 - Lib/test/test_generated_cases.py | 23 +- Python/bytecodes.c | 344 ++-- Python/ceval.c | 1 - Python/executor_cases.c.h | 909 +++++----- Python/generated_cases.c.h | 1717 +++++++++--------- Python/opcode_targets.h | 2 +- Python/optimizer_cases.c.h | 246 +-- Tools/cases_generator/generators_common.py | 29 +- Tools/cases_generator/optimizer_generator.py | 1 - Tools/cases_generator/stack.py | 44 +- Tools/cases_generator/tier1_generator.py | 1 - Tools/cases_generator/tier2_generator.py | 1 - 17 files changed, 1733 insertions(+), 1842 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index fb8658eb154cc8..2c38b163699dcb 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -477,8 +477,6 @@ int _PyOpcode_num_popped(int opcode, int oparg) { return 5; case YIELD_VALUE: return 1; - case _DO_CALL_FUNCTION_EX: - return 3 + (oparg & 1); default: return -1; } @@ -934,8 +932,6 @@ int _PyOpcode_num_pushed(int opcode, int oparg) { return 6; case YIELD_VALUE: return 1; - case _DO_CALL_FUNCTION_EX: - return 1; default: return -1; } @@ -1104,8 +1100,8 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [INSTRUMENTED_CALL] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_CALL_FUNCTION_EX] = { true, INSTR_FMT_IX, 0 }, [INSTRUMENTED_CALL_KW] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_END_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [INSTRUMENTED_END_SEND] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_END_FOR] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, + [INSTRUMENTED_END_SEND] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_FOR_ITER] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_INSTRUCTION] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, @@ -1222,7 +1218,6 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [UNPACK_SEQUENCE_TWO_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_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 }, - [_DO_CALL_FUNCTION_EX] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [JUMP] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [JUMP_NO_INTERRUPT] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG }, [LOAD_CLOSURE] = { true, -1, HAS_ARG_FLAG | HAS_LOCAL_FLAG | HAS_PURE_FLAG }, @@ -1647,7 +1642,6 @@ const char *_PyOpcode_OpName[264] = { [UNPACK_SEQUENCE_TWO_TUPLE] = "UNPACK_SEQUENCE_TWO_TUPLE", [WITH_EXCEPT_START] = "WITH_EXCEPT_START", [YIELD_VALUE] = "YIELD_VALUE", - [_DO_CALL_FUNCTION_EX] = "_DO_CALL_FUNCTION_EX", }; #endif @@ -1894,12 +1888,12 @@ const uint8_t _PyOpcode_Deopt[256] = { [UNPACK_SEQUENCE_TWO_TUPLE] = UNPACK_SEQUENCE, [WITH_EXCEPT_START] = WITH_EXCEPT_START, [YIELD_VALUE] = YIELD_VALUE, - [_DO_CALL_FUNCTION_EX] = _DO_CALL_FUNCTION_EX, }; #endif // NEED_OPCODE_METADATA #define EXTRA_CASES \ + case 116: \ case 117: \ case 118: \ case 119: \ diff --git a/Include/internal/pycore_uop_ids.h b/Include/internal/pycore_uop_ids.h index 05b78d38545f2e..1ba1f8b2b3223d 100644 --- a/Include/internal/pycore_uop_ids.h +++ b/Include/internal/pycore_uop_ids.h @@ -97,54 +97,55 @@ extern "C" { #define _DICT_MERGE DICT_MERGE #define _DICT_UPDATE DICT_UPDATE #define _DO_CALL 356 -#define _DO_CALL_KW 357 -#define _DYNAMIC_EXIT 358 +#define _DO_CALL_FUNCTION_EX 357 +#define _DO_CALL_KW 358 +#define _DYNAMIC_EXIT 359 #define _END_SEND END_SEND -#define _ERROR_POP_N 359 +#define _ERROR_POP_N 360 #define _EXIT_INIT_CHECK EXIT_INIT_CHECK -#define _EXPAND_METHOD 360 -#define _EXPAND_METHOD_KW 361 -#define _FATAL_ERROR 362 +#define _EXPAND_METHOD 361 +#define _EXPAND_METHOD_KW 362 +#define _FATAL_ERROR 363 #define _FORMAT_SIMPLE FORMAT_SIMPLE #define _FORMAT_WITH_SPEC FORMAT_WITH_SPEC -#define _FOR_ITER 363 -#define _FOR_ITER_GEN_FRAME 364 -#define _FOR_ITER_TIER_TWO 365 +#define _FOR_ITER 364 +#define _FOR_ITER_GEN_FRAME 365 +#define _FOR_ITER_TIER_TWO 366 #define _GET_AITER GET_AITER #define _GET_ANEXT GET_ANEXT #define _GET_AWAITABLE GET_AWAITABLE #define _GET_ITER GET_ITER #define _GET_LEN GET_LEN #define _GET_YIELD_FROM_ITER GET_YIELD_FROM_ITER -#define _GUARD_BOTH_FLOAT 366 -#define _GUARD_BOTH_INT 367 -#define _GUARD_BOTH_UNICODE 368 -#define _GUARD_BUILTINS_VERSION 369 -#define _GUARD_DORV_NO_DICT 370 -#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT 371 -#define _GUARD_GLOBALS_VERSION 372 -#define _GUARD_IS_FALSE_POP 373 -#define _GUARD_IS_NONE_POP 374 -#define _GUARD_IS_NOT_NONE_POP 375 -#define _GUARD_IS_TRUE_POP 376 -#define _GUARD_KEYS_VERSION 377 -#define _GUARD_NOS_FLOAT 378 -#define _GUARD_NOS_INT 379 -#define _GUARD_NOT_EXHAUSTED_LIST 380 -#define _GUARD_NOT_EXHAUSTED_RANGE 381 -#define _GUARD_NOT_EXHAUSTED_TUPLE 382 -#define _GUARD_TOS_FLOAT 383 -#define _GUARD_TOS_INT 384 -#define _GUARD_TYPE_VERSION 385 +#define _GUARD_BOTH_FLOAT 367 +#define _GUARD_BOTH_INT 368 +#define _GUARD_BOTH_UNICODE 369 +#define _GUARD_BUILTINS_VERSION 370 +#define _GUARD_DORV_NO_DICT 371 +#define _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT 372 +#define _GUARD_GLOBALS_VERSION 373 +#define _GUARD_IS_FALSE_POP 374 +#define _GUARD_IS_NONE_POP 375 +#define _GUARD_IS_NOT_NONE_POP 376 +#define _GUARD_IS_TRUE_POP 377 +#define _GUARD_KEYS_VERSION 378 +#define _GUARD_NOS_FLOAT 379 +#define _GUARD_NOS_INT 380 +#define _GUARD_NOT_EXHAUSTED_LIST 381 +#define _GUARD_NOT_EXHAUSTED_RANGE 382 +#define _GUARD_NOT_EXHAUSTED_TUPLE 383 +#define _GUARD_TOS_FLOAT 384 +#define _GUARD_TOS_INT 385 +#define _GUARD_TYPE_VERSION 386 #define _IMPORT_FROM IMPORT_FROM #define _IMPORT_NAME IMPORT_NAME -#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS 386 -#define _INIT_CALL_PY_EXACT_ARGS 387 -#define _INIT_CALL_PY_EXACT_ARGS_0 388 -#define _INIT_CALL_PY_EXACT_ARGS_1 389 -#define _INIT_CALL_PY_EXACT_ARGS_2 390 -#define _INIT_CALL_PY_EXACT_ARGS_3 391 -#define _INIT_CALL_PY_EXACT_ARGS_4 392 +#define _INIT_CALL_BOUND_METHOD_EXACT_ARGS 387 +#define _INIT_CALL_PY_EXACT_ARGS 388 +#define _INIT_CALL_PY_EXACT_ARGS_0 389 +#define _INIT_CALL_PY_EXACT_ARGS_1 390 +#define _INIT_CALL_PY_EXACT_ARGS_2 391 +#define _INIT_CALL_PY_EXACT_ARGS_3 392 +#define _INIT_CALL_PY_EXACT_ARGS_4 393 #define _INSTRUMENTED_CALL_FUNCTION_EX INSTRUMENTED_CALL_FUNCTION_EX #define _INSTRUMENTED_CALL_KW INSTRUMENTED_CALL_KW #define _INSTRUMENTED_FOR_ITER INSTRUMENTED_FOR_ITER @@ -156,70 +157,71 @@ extern "C" { #define _INSTRUMENTED_POP_JUMP_IF_NONE INSTRUMENTED_POP_JUMP_IF_NONE #define _INSTRUMENTED_POP_JUMP_IF_NOT_NONE INSTRUMENTED_POP_JUMP_IF_NOT_NONE #define _INSTRUMENTED_POP_JUMP_IF_TRUE INSTRUMENTED_POP_JUMP_IF_TRUE -#define _INTERNAL_INCREMENT_OPT_COUNTER 393 -#define _IS_NONE 394 +#define _INTERNAL_INCREMENT_OPT_COUNTER 394 +#define _IS_NONE 395 #define _IS_OP IS_OP -#define _ITER_CHECK_LIST 395 -#define _ITER_CHECK_RANGE 396 -#define _ITER_CHECK_TUPLE 397 -#define _ITER_JUMP_LIST 398 -#define _ITER_JUMP_RANGE 399 -#define _ITER_JUMP_TUPLE 400 -#define _ITER_NEXT_LIST 401 -#define _ITER_NEXT_RANGE 402 -#define _ITER_NEXT_TUPLE 403 -#define _JUMP_TO_TOP 404 +#define _ITER_CHECK_LIST 396 +#define _ITER_CHECK_RANGE 397 +#define _ITER_CHECK_TUPLE 398 +#define _ITER_JUMP_LIST 399 +#define _ITER_JUMP_RANGE 400 +#define _ITER_JUMP_TUPLE 401 +#define _ITER_NEXT_LIST 402 +#define _ITER_NEXT_RANGE 403 +#define _ITER_NEXT_TUPLE 404 +#define _JUMP_TO_TOP 405 #define _LIST_APPEND LIST_APPEND #define _LIST_EXTEND LIST_EXTEND -#define _LOAD_ATTR 405 -#define _LOAD_ATTR_CLASS 406 -#define _LOAD_ATTR_CLASS_0 407 -#define _LOAD_ATTR_CLASS_1 408 +#define _LOAD_ATTR 406 +#define _LOAD_ATTR_CLASS 407 +#define _LOAD_ATTR_CLASS_0 408 +#define _LOAD_ATTR_CLASS_1 409 #define _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN -#define _LOAD_ATTR_INSTANCE_VALUE 409 -#define _LOAD_ATTR_INSTANCE_VALUE_0 410 -#define _LOAD_ATTR_INSTANCE_VALUE_1 411 -#define _LOAD_ATTR_METHOD_LAZY_DICT 412 -#define _LOAD_ATTR_METHOD_NO_DICT 413 -#define _LOAD_ATTR_METHOD_WITH_VALUES 414 -#define _LOAD_ATTR_MODULE 415 -#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT 416 -#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES 417 -#define _LOAD_ATTR_PROPERTY_FRAME 418 -#define _LOAD_ATTR_SLOT 419 -#define _LOAD_ATTR_SLOT_0 420 -#define _LOAD_ATTR_SLOT_1 421 -#define _LOAD_ATTR_WITH_HINT 422 +#define _LOAD_ATTR_INSTANCE_VALUE 410 +#define _LOAD_ATTR_INSTANCE_VALUE_0 411 +#define _LOAD_ATTR_INSTANCE_VALUE_1 412 +#define _LOAD_ATTR_METHOD_LAZY_DICT 413 +#define _LOAD_ATTR_METHOD_NO_DICT 414 +#define _LOAD_ATTR_METHOD_WITH_VALUES 415 +#define _LOAD_ATTR_MODULE 416 +#define _LOAD_ATTR_NONDESCRIPTOR_NO_DICT 417 +#define _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES 418 +#define _LOAD_ATTR_PROPERTY_FRAME 419 +#define _LOAD_ATTR_SLOT 420 +#define _LOAD_ATTR_SLOT_0 421 +#define _LOAD_ATTR_SLOT_1 422 +#define _LOAD_ATTR_WITH_HINT 423 #define _LOAD_BUILD_CLASS LOAD_BUILD_CLASS #define _LOAD_COMMON_CONSTANT LOAD_COMMON_CONSTANT #define _LOAD_CONST LOAD_CONST -#define _LOAD_CONST_INLINE 423 -#define _LOAD_CONST_INLINE_BORROW 424 -#define _LOAD_CONST_INLINE_BORROW_WITH_NULL 425 -#define _LOAD_CONST_INLINE_WITH_NULL 426 +#define _LOAD_CONST_INLINE 424 +#define _LOAD_CONST_INLINE_BORROW 425 +#define _LOAD_CONST_INLINE_BORROW_WITH_NULL 426 +#define _LOAD_CONST_INLINE_WITH_NULL 427 #define _LOAD_DEREF LOAD_DEREF -#define _LOAD_FAST 427 -#define _LOAD_FAST_0 428 -#define _LOAD_FAST_1 429 -#define _LOAD_FAST_2 430 -#define _LOAD_FAST_3 431 -#define _LOAD_FAST_4 432 -#define _LOAD_FAST_5 433 -#define _LOAD_FAST_6 434 -#define _LOAD_FAST_7 435 +#define _LOAD_FAST 428 +#define _LOAD_FAST_0 429 +#define _LOAD_FAST_1 430 +#define _LOAD_FAST_2 431 +#define _LOAD_FAST_3 432 +#define _LOAD_FAST_4 433 +#define _LOAD_FAST_5 434 +#define _LOAD_FAST_6 435 +#define _LOAD_FAST_7 436 #define _LOAD_FAST_AND_CLEAR LOAD_FAST_AND_CLEAR #define _LOAD_FAST_CHECK LOAD_FAST_CHECK #define _LOAD_FAST_LOAD_FAST LOAD_FAST_LOAD_FAST #define _LOAD_FROM_DICT_OR_DEREF LOAD_FROM_DICT_OR_DEREF #define _LOAD_FROM_DICT_OR_GLOBALS LOAD_FROM_DICT_OR_GLOBALS -#define _LOAD_GLOBAL 436 -#define _LOAD_GLOBAL_BUILTINS 437 -#define _LOAD_GLOBAL_MODULE 438 +#define _LOAD_GLOBAL 437 +#define _LOAD_GLOBAL_BUILTINS 438 +#define _LOAD_GLOBAL_MODULE 439 #define _LOAD_LOCALS LOAD_LOCALS #define _LOAD_NAME LOAD_NAME #define _LOAD_SPECIAL LOAD_SPECIAL #define _LOAD_SUPER_ATTR_ATTR LOAD_SUPER_ATTR_ATTR #define _LOAD_SUPER_ATTR_METHOD LOAD_SUPER_ATTR_METHOD +#define _MAKE_CALLARGS_A_TUPLE 440 #define _MAKE_CELL MAKE_CELL #define _MAKE_FUNCTION MAKE_FUNCTION #define _MAP_ADD MAP_ADD @@ -227,60 +229,60 @@ extern "C" { #define _MATCH_KEYS MATCH_KEYS #define _MATCH_MAPPING MATCH_MAPPING #define _MATCH_SEQUENCE MATCH_SEQUENCE -#define _MAYBE_EXPAND_METHOD 439 -#define _MAYBE_EXPAND_METHOD_KW 440 -#define _MONITOR_CALL 441 -#define _MONITOR_JUMP_BACKWARD 442 -#define _MONITOR_RESUME 443 +#define _MAYBE_EXPAND_METHOD 441 +#define _MAYBE_EXPAND_METHOD_KW 442 +#define _MONITOR_CALL 443 +#define _MONITOR_JUMP_BACKWARD 444 +#define _MONITOR_RESUME 445 #define _NOP NOP #define _POP_EXCEPT POP_EXCEPT -#define _POP_JUMP_IF_FALSE 444 -#define _POP_JUMP_IF_TRUE 445 +#define _POP_JUMP_IF_FALSE 446 +#define _POP_JUMP_IF_TRUE 447 #define _POP_TOP POP_TOP -#define _POP_TOP_LOAD_CONST_INLINE_BORROW 446 +#define _POP_TOP_LOAD_CONST_INLINE_BORROW 448 #define _PUSH_EXC_INFO PUSH_EXC_INFO -#define _PUSH_FRAME 447 +#define _PUSH_FRAME 449 #define _PUSH_NULL PUSH_NULL -#define _PY_FRAME_GENERAL 448 -#define _PY_FRAME_KW 449 -#define _QUICKEN_RESUME 450 -#define _REPLACE_WITH_TRUE 451 +#define _PY_FRAME_GENERAL 450 +#define _PY_FRAME_KW 451 +#define _QUICKEN_RESUME 452 +#define _REPLACE_WITH_TRUE 453 #define _RESUME_CHECK RESUME_CHECK #define _RETURN_GENERATOR RETURN_GENERATOR #define _RETURN_VALUE RETURN_VALUE -#define _SAVE_RETURN_OFFSET 452 -#define _SEND 453 -#define _SEND_GEN_FRAME 454 +#define _SAVE_RETURN_OFFSET 454 +#define _SEND 455 +#define _SEND_GEN_FRAME 456 #define _SETUP_ANNOTATIONS SETUP_ANNOTATIONS #define _SET_ADD SET_ADD #define _SET_FUNCTION_ATTRIBUTE SET_FUNCTION_ATTRIBUTE #define _SET_UPDATE SET_UPDATE -#define _START_EXECUTOR 455 -#define _STORE_ATTR 456 -#define _STORE_ATTR_INSTANCE_VALUE 457 -#define _STORE_ATTR_SLOT 458 -#define _STORE_ATTR_WITH_HINT 459 +#define _START_EXECUTOR 457 +#define _STORE_ATTR 458 +#define _STORE_ATTR_INSTANCE_VALUE 459 +#define _STORE_ATTR_SLOT 460 +#define _STORE_ATTR_WITH_HINT 461 #define _STORE_DEREF STORE_DEREF -#define _STORE_FAST 460 -#define _STORE_FAST_0 461 -#define _STORE_FAST_1 462 -#define _STORE_FAST_2 463 -#define _STORE_FAST_3 464 -#define _STORE_FAST_4 465 -#define _STORE_FAST_5 466 -#define _STORE_FAST_6 467 -#define _STORE_FAST_7 468 +#define _STORE_FAST 462 +#define _STORE_FAST_0 463 +#define _STORE_FAST_1 464 +#define _STORE_FAST_2 465 +#define _STORE_FAST_3 466 +#define _STORE_FAST_4 467 +#define _STORE_FAST_5 468 +#define _STORE_FAST_6 469 +#define _STORE_FAST_7 470 #define _STORE_FAST_LOAD_FAST STORE_FAST_LOAD_FAST #define _STORE_FAST_STORE_FAST STORE_FAST_STORE_FAST #define _STORE_GLOBAL STORE_GLOBAL #define _STORE_NAME STORE_NAME -#define _STORE_SLICE 469 -#define _STORE_SUBSCR 470 +#define _STORE_SLICE 471 +#define _STORE_SUBSCR 472 #define _STORE_SUBSCR_DICT STORE_SUBSCR_DICT #define _STORE_SUBSCR_LIST_INT STORE_SUBSCR_LIST_INT #define _SWAP SWAP -#define _TIER2_RESUME_CHECK 471 -#define _TO_BOOL 472 +#define _TIER2_RESUME_CHECK 473 +#define _TO_BOOL 474 #define _TO_BOOL_BOOL TO_BOOL_BOOL #define _TO_BOOL_INT TO_BOOL_INT #define _TO_BOOL_LIST TO_BOOL_LIST @@ -290,14 +292,13 @@ extern "C" { #define _UNARY_NEGATIVE UNARY_NEGATIVE #define _UNARY_NOT UNARY_NOT #define _UNPACK_EX UNPACK_EX -#define _UNPACK_SEQUENCE 473 +#define _UNPACK_SEQUENCE 475 #define _UNPACK_SEQUENCE_LIST UNPACK_SEQUENCE_LIST #define _UNPACK_SEQUENCE_TUPLE UNPACK_SEQUENCE_TUPLE #define _UNPACK_SEQUENCE_TWO_TUPLE UNPACK_SEQUENCE_TWO_TUPLE #define _WITH_EXCEPT_START WITH_EXCEPT_START #define _YIELD_VALUE YIELD_VALUE -#define __DO_CALL_FUNCTION_EX _DO_CALL_FUNCTION_EX -#define MAX_UOP_ID 473 +#define MAX_UOP_ID 475 #ifdef __cplusplus } diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index e54c58abcc1032..6d035230fcfcd9 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -246,6 +246,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_EXPAND_METHOD_KW] = HAS_ARG_FLAG, [_CHECK_IS_NOT_PY_CALLABLE_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG, [_CALL_KW_NON_PY] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_MAKE_CALLARGS_A_TUPLE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_MAKE_FUNCTION] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_SET_FUNCTION_ATTRIBUTE] = HAS_ARG_FLAG, [_RETURN_GENERATOR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -480,6 +481,7 @@ const char *const _PyOpcode_uop_name[MAX_UOP_ID+1] = { [_LOAD_SPECIAL] = "_LOAD_SPECIAL", [_LOAD_SUPER_ATTR_ATTR] = "_LOAD_SUPER_ATTR_ATTR", [_LOAD_SUPER_ATTR_METHOD] = "_LOAD_SUPER_ATTR_METHOD", + [_MAKE_CALLARGS_A_TUPLE] = "_MAKE_CALLARGS_A_TUPLE", [_MAKE_CELL] = "_MAKE_CELL", [_MAKE_FUNCTION] = "_MAKE_FUNCTION", [_MAP_ADD] = "_MAP_ADD", @@ -1008,6 +1010,8 @@ int _PyUop_num_popped(int opcode, int oparg) return 3 + oparg; case _CALL_KW_NON_PY: return 3 + oparg; + case _MAKE_CALLARGS_A_TUPLE: + return 3 + (oparg & 1); case _MAKE_FUNCTION: return 1; case _SET_FUNCTION_ATTRIBUTE: diff --git a/Include/opcode_ids.h b/Include/opcode_ids.h index 5ded0b41b4830e..c37c70d6f4317e 100644 --- a/Include/opcode_ids.h +++ b/Include/opcode_ids.h @@ -126,7 +126,6 @@ extern "C" { #define UNPACK_EX 113 #define UNPACK_SEQUENCE 114 #define YIELD_VALUE 115 -#define _DO_CALL_FUNCTION_EX 116 #define RESUME 149 #define BINARY_OP_ADD_FLOAT 150 #define BINARY_OP_ADD_INT 151 diff --git a/Lib/_opcode_metadata.py b/Lib/_opcode_metadata.py index 6e4b33921863cb..7a2a66fe0a122f 100644 --- a/Lib/_opcode_metadata.py +++ b/Lib/_opcode_metadata.py @@ -315,7 +315,6 @@ 'UNPACK_EX': 113, 'UNPACK_SEQUENCE': 114, 'YIELD_VALUE': 115, - '_DO_CALL_FUNCTION_EX': 116, 'INSTRUMENTED_END_FOR': 236, 'INSTRUMENTED_END_SEND': 237, 'INSTRUMENTED_LOAD_SUPER_ATTR': 238, diff --git a/Lib/test/test_generated_cases.py b/Lib/test/test_generated_cases.py index 5e5967ece80124..8d18786701a6b9 100644 --- a/Lib/test/test_generated_cases.py +++ b/Lib/test/test_generated_cases.py @@ -1028,16 +1028,16 @@ def test_used_unused_used(self): _PyStackRef w; _PyStackRef y; // FIRST - w = stack_pointer[-1]; { + w = stack_pointer[-1]; use(w); } // SECOND { } // THIRD - y = w; { + y = w; use(y); } DISPATCH(); @@ -1071,13 +1071,13 @@ def test_unused_used_used(self): { } // SECOND - x = stack_pointer[-1]; { + x = stack_pointer[-1]; use(x); } // THIRD - y = x; { + y = x; use(y); } DISPATCH(); @@ -1131,7 +1131,9 @@ def test_pop_on_error_peeks(self): input = """ op(FIRST, (x, y -- a, b)) { a = x; + KILL(x); b = y; + KILL(y); } op(SECOND, (a, b -- a, b)) { @@ -1263,6 +1265,19 @@ def test_array_size_inconsistency(self): with self.assertRaises(SyntaxError): self.run_cases_test(input, output) + def test_save_reload(self): + + input = """ + inst(BALANCED, ( -- )) { + SAVE_STACK(); + RELOAD_STACK(); + } + """ + + output = """ + """ + self.run_cases_test(input, output) + class TestGeneratedAbstractCases(unittest.TestCase): def setUp(self) -> None: diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 4d9f45b9204b07..7cbc3a36e33619 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -300,7 +300,9 @@ dummy_func( * to conform to PEP 380 */ if (PyStackRef_GenCheck(receiver)) { int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); - ERROR_IF(err, error); + if (err) { + ERROR_NO_POP(); + } } DECREF_INPUTS(); } @@ -316,7 +318,9 @@ dummy_func( PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver); if (PyGen_Check(receiver_o) || PyCoro_CheckExact(receiver_o)) { int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); - ERROR_IF(err, error); + if (err) { + ERROR_NO_POP(); + } } val = value; KILL(value); @@ -1480,9 +1484,8 @@ dummy_func( PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); PyObject *v_o; int err = PyMapping_GetOptionalItem(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &v_o); - if (err < 0) { - ERROR_NO_POP(); - } + DECREF_INPUTS(); + ERROR_IF(err < 0, error); if (v_o == NULL) { if (PyDict_CheckExact(GLOBALS()) && PyDict_CheckExact(BUILTINS())) @@ -1518,7 +1521,6 @@ dummy_func( } } } - DECREF_INPUTS(); v = PyStackRef_FromPyObjectSteal(v_o); } @@ -1766,6 +1768,7 @@ dummy_func( } PyStackRef_CLOSE(values[i]); } + KILL(values); if (err != 0) { Py_DECREF(set_o); ERROR_IF(true, error); @@ -1892,7 +1895,10 @@ dummy_func( int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, global_super, arg); - ERROR_IF(err, error); + if (err) { + DECREF_INPUTS(); + ERROR_IF(true, error); + } } // we make no attempt to optimize here; specializations should // handle any case whose performance we care about @@ -3252,11 +3258,11 @@ dummy_func( CALL_NON_PY_GENERAL, }; - specializing op(_SPECIALIZE_CALL, (counter/1, callable, self_or_null[1], args[oparg] -- callable, self_or_null[1], args[oparg])) { + specializing op(_SPECIALIZE_CALL, (counter/1, callable[1], self_or_null[1], args[oparg] -- callable[1], self_or_null[1], args[oparg])) { #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; - _Py_Specialize_Call(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); + _Py_Specialize_Call(callable[0], next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(CALL); @@ -3264,26 +3270,21 @@ dummy_func( #endif /* ENABLE_SPECIALIZATION */ } - op(_MAYBE_EXPAND_METHOD, (callable, self_or_null[1], args[oparg] -- func, maybe_self[1], args[oparg])) { - if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_MAYBE_EXPAND_METHOD, (callable[1], self_or_null[1], args[oparg] -- func[1], maybe_self[1], args[oparg])) { + if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); PyObject *self = ((PyMethodObject *)callable_o)->im_self; maybe_self[0] = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; - func = PyStackRef_FromPyObjectNew(method); - PyStackRef_CLOSE(callable); - KILL(self_or_null); - } - else { - func = callable; - KILL(callable); - KILL(self_or_null); + _PyStackRef temp = callable[0]; + func[0] = PyStackRef_FromPyObjectNew(method); + PyStackRef_CLOSE(temp); } } // When calling Python, inline the call using DISPATCH_INLINED(). - op(_DO_CALL, (callable, self_or_null[1], args[oparg] -- res)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_DO_CALL, (callable[1], self_or_null[1], args[oparg] -- res)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); // oparg counts all of the args, but *not* self: int total_args = oparg; @@ -3299,7 +3300,7 @@ dummy_func( 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)); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( - tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, + tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable[0]), locals, args, total_args, NULL, frame ); // Manipulate stack directly since we leave using DISPATCH_INLINED(). @@ -3315,10 +3316,11 @@ dummy_func( /* Callable is not a normal Python function */ STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } + KILL(self_or_null); ERROR_IF(true, error); } PyObject *res_o = PyObject_Vectorcall( @@ -3344,17 +3346,18 @@ dummy_func( } } assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } + KILL(self_or_null); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } - op(_MONITOR_CALL, (func, maybe_self[1], args[oparg] -- func, maybe_self[1], args[oparg])) { + op(_MONITOR_CALL, (func[1], maybe_self[1], args[oparg] -- func[1], maybe_self[1], args[oparg])) { int is_meth = !PyStackRef_IsNull(maybe_self[0]); - PyObject *function = PyStackRef_AsPyObjectBorrow(func); + PyObject *function = PyStackRef_AsPyObjectBorrow(func[0]); PyObject *arg0; if (is_meth) { arg0 = PyStackRef_AsPyObjectBorrow(maybe_self[0]); @@ -3376,8 +3379,8 @@ dummy_func( macro(CALL) = _SPECIALIZE_CALL + unused/2 + _MAYBE_EXPAND_METHOD + _DO_CALL + _CHECK_PERIODIC; macro(INSTRUMENTED_CALL) = unused/3 + _MAYBE_EXPAND_METHOD + _MONITOR_CALL + _DO_CALL + _CHECK_PERIODIC; - op(_PY_FRAME_GENERAL, (callable, self_or_null[1], args[oparg] -- new_frame: _PyInterpreterFrame*)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_PY_FRAME_GENERAL, (callable[1], self_or_null[1], args[oparg] -- new_frame: _PyInterpreterFrame*)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); // oparg counts all of the args, but *not* self: int total_args = oparg; @@ -3388,21 +3391,21 @@ dummy_func( 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)); - new_frame = _PyEvalFramePushAndInit( - tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, + _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( + tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable[0]), locals, args, total_args, NULL, frame ); - // The frame has stolen all the arguments from the stack, - // so there is no need to clean them up. + // The frame has stolen all the arguments from the stack. KILL_INPUTS(); SYNC_SP(); - if (new_frame == NULL) { + if (temp == NULL) { ERROR_NO_POP(); } + new_frame = temp; } - op(_CHECK_FUNCTION_VERSION, (func_version/2, callable, self_or_null[1], unused[oparg] -- callable, self_or_null[1], unused[oparg])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_CHECK_FUNCTION_VERSION, (func_version/2, callable[1], self_or_null[1], unused[oparg] -- callable[1], self_or_null[1], unused[oparg])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); EXIT_IF(!PyFunction_Check(callable_o)); PyFunctionObject *func = (PyFunctionObject *)callable_o; EXIT_IF(func->func_version != func_version); @@ -3416,8 +3419,8 @@ dummy_func( _SAVE_RETURN_OFFSET + _PUSH_FRAME; - op(_CHECK_METHOD_VERSION, (func_version/2, callable, null[1], unused[oparg] -- callable, null[1], unused[oparg])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_CHECK_METHOD_VERSION, (func_version/2, callable[1], null[1], unused[oparg] -- callable[1], null[1], unused[oparg])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); EXIT_IF(Py_TYPE(callable_o) != &PyMethod_Type); PyObject *func = ((PyMethodObject *)callable_o)->im_func; @@ -3426,15 +3429,16 @@ dummy_func( EXIT_IF(!PyStackRef_IsNull(null[0])); } - op(_EXPAND_METHOD, (callable, null[1], unused[oparg] -- method, self[1], unused[oparg])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_EXPAND_METHOD, (callable[1], null[1], unused[oparg] -- method[1], self[1], unused[oparg])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); assert(PyStackRef_IsNull(null[0])); KILL(null); assert(Py_TYPE(callable_o) == &PyMethod_Type); self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - assert(PyStackRef_FunctionCheck(method)); - PyStackRef_CLOSE(callable); + _PyStackRef temp = callable[0]; + method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + assert(PyStackRef_FunctionCheck(method[0])); + PyStackRef_CLOSE(temp); } macro(CALL_BOUND_METHOD_GENERAL) = @@ -3447,17 +3451,17 @@ dummy_func( _SAVE_RETURN_OFFSET + _PUSH_FRAME; - op(_CHECK_IS_NOT_PY_CALLABLE, (callable, unused[1], unused[oparg] -- callable, unused[1], unused[oparg])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_CHECK_IS_NOT_PY_CALLABLE, (callable[1], unused[1], unused[oparg] -- callable[1], unused[1], unused[oparg])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); EXIT_IF(PyFunction_Check(callable_o)); EXIT_IF(Py_TYPE(callable_o) == &PyMethod_Type); } - op(_CALL_NON_PY_GENERAL, (callable, self_or_null[1], args[oparg] -- res)) { + op(_CALL_NON_PY_GENERAL, (callable[1], self_or_null[1], args[oparg] -- res)) { #if TIER_ONE assert(opcode != INSTRUMENTED_CALL); #endif - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -3476,10 +3480,11 @@ dummy_func( NULL); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } + KILL(self_or_null); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -3491,42 +3496,43 @@ dummy_func( _CALL_NON_PY_GENERAL + _CHECK_PERIODIC; - op(_CHECK_CALL_BOUND_METHOD_EXACT_ARGS, (callable, null[1], unused[oparg] -- callable, null[1], unused[oparg])) { + op(_CHECK_CALL_BOUND_METHOD_EXACT_ARGS, (callable[1], null[1], unused[oparg] -- callable[1], null[1], unused[oparg])) { EXIT_IF(!PyStackRef_IsNull(null[0])); - EXIT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(callable)) != &PyMethod_Type); + EXIT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(callable[0])) != &PyMethod_Type); } - op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable, null[1], unused[oparg] -- func, self[1], unused[oparg])) { + op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable[1], null[1], unused[oparg] -- func[1], self[1], unused[oparg])) { KILL(null); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); STAT_INC(CALL, hit); self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - func = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - PyStackRef_CLOSE(callable); + _PyStackRef temp = callable[0]; + func[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + PyStackRef_CLOSE(temp); } op(_CHECK_PEP_523, (--)) { DEOPT_IF(tstate->interp->eval_frame); } - op(_CHECK_FUNCTION_EXACT_ARGS, (callable, self_or_null[1], unused[oparg] -- callable, self_or_null[1], unused[oparg])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_CHECK_FUNCTION_EXACT_ARGS, (callable[1], self_or_null[1], unused[oparg] -- callable[1], self_or_null[1], unused[oparg])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); assert(PyFunction_Check(callable_o)); PyFunctionObject *func = (PyFunctionObject *)callable_o; PyCodeObject *code = (PyCodeObject *)func->func_code; EXIT_IF(code->co_argcount != oparg + (!PyStackRef_IsNull(self_or_null[0]))); } - op(_CHECK_STACK_SPACE, (callable, self_or_null[1], unused[oparg] -- callable, self_or_null[1], unused[oparg])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_CHECK_STACK_SPACE, (callable[1], self_or_null[1], unused[oparg] -- callable[1], self_or_null[1], unused[oparg])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); PyFunctionObject *func = (PyFunctionObject *)callable_o; PyCodeObject *code = (PyCodeObject *)func->func_code; DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize)); DEOPT_IF(tstate->py_recursion_remaining <= 1); } - replicate(5) pure op(_INIT_CALL_PY_EXACT_ARGS, (callable, self_or_null[1], args[oparg] -- new_frame: _PyInterpreterFrame*)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + replicate(5) pure op(_INIT_CALL_PY_EXACT_ARGS, (callable[1], self_or_null[1], args[oparg] -- new_frame: _PyInterpreterFrame*)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int has_self = !PyStackRef_IsNull(self_or_null[0]); STAT_INC(CALL, hit); PyFunctionObject *func = (PyFunctionObject *)callable_o; @@ -3635,10 +3641,9 @@ dummy_func( _CALL_TUPLE_1 + _CHECK_PERIODIC; - op(_CHECK_AND_ALLOCATE_OBJECT, (type_version/2, callable, null, args[oparg] -- self, init, args[oparg])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - DEOPT_IF(!PyStackRef_IsNull(null)); - KILL(null); + op(_CHECK_AND_ALLOCATE_OBJECT, (type_version/2, callable[1], null[1], args[oparg] -- init[1], self[1], args[oparg])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + DEOPT_IF(!PyStackRef_IsNull(null[0])); DEOPT_IF(!PyType_Check(callable_o)); PyTypeObject *tp = (PyTypeObject *)callable_o; DEOPT_IF(tp->tp_version_tag != type_version); @@ -3648,22 +3653,24 @@ dummy_func( PyCodeObject *code = (PyCodeObject *)init_func->func_code; DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize + _Py_InitCleanup.co_framesize)); STAT_INC(CALL, hit); - self = PyStackRef_FromPyObjectSteal(_PyType_NewManagedObject(tp)); - if (PyStackRef_IsNull(self)) { + PyObject *self_o = _PyType_NewManagedObject(tp); + if (self_o == NULL) { ERROR_NO_POP(); } - PyStackRef_CLOSE(callable); - init = PyStackRef_FromPyObjectNew(init_func); + self[0] = PyStackRef_FromPyObjectSteal(self_o); + _PyStackRef temp = callable[0]; + init[0] = PyStackRef_FromPyObjectNew(init_func); + PyStackRef_CLOSE(temp); } - op(_CREATE_INIT_FRAME, (self, init, args[oparg] -- init_frame: _PyInterpreterFrame *)) { + op(_CREATE_INIT_FRAME, (init[1], self[1], args[oparg] -- init_frame: _PyInterpreterFrame *)) { _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame); assert(_PyCode_CODE((PyCodeObject *)shim->f_executable)[0].op.code == EXIT_INIT_CHECK); /* Push self onto stack of shim */ - shim->localsplus[0] = PyStackRef_DUP(self); - PyFunctionObject *init_func = (PyFunctionObject *)PyStackRef_AsPyObjectSteal(init); - args[-1] = self; + shim->localsplus[0] = PyStackRef_DUP(self[0]); + PyFunctionObject *init_func = (PyFunctionObject *)PyStackRef_AsPyObjectSteal(init[0]); + KILL(init); KILL(self); init_frame = _PyEvalFramePushAndInit( tstate, init_func, NULL, args-1, oparg+1, NULL, shim); @@ -3697,8 +3704,8 @@ dummy_func( KILL(should_be_none); } - op(_CALL_BUILTIN_CLASS, (callable, self_or_null[1], args[oparg] -- res)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_CALL_BUILTIN_CLASS, (callable[1], self_or_null[1], args[oparg] -- res)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -3721,7 +3728,7 @@ dummy_func( for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -3732,9 +3739,9 @@ dummy_func( _CALL_BUILTIN_CLASS + _CHECK_PERIODIC; - op(_CALL_BUILTIN_O, (callable, self_or_null[1], args[oparg] -- res)) { + op(_CALL_BUILTIN_O, (callable[1], self_or_null[1], args[oparg] -- res)) { /* Builtin METH_O functions */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -3755,7 +3762,9 @@ dummy_func( assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(arg); - PyStackRef_CLOSE(callable); + KILL(args); + KILL(self_or_null); + PyStackRef_CLOSE(callable[0]); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -3766,9 +3775,9 @@ dummy_func( _CALL_BUILTIN_O + _CHECK_PERIODIC; - op(_CALL_BUILTIN_FAST, (callable, self_or_null[1], args[oparg] -- res)) { + op(_CALL_BUILTIN_FAST, (callable[1], self_or_null[1], args[oparg] -- res)) { /* Builtin METH_FASTCALL functions, without keywords */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -3797,7 +3806,7 @@ dummy_func( for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -3808,9 +3817,9 @@ dummy_func( _CALL_BUILTIN_FAST + _CHECK_PERIODIC; - op(_CALL_BUILTIN_FAST_WITH_KEYWORDS, (callable, self_or_null[1], args[oparg] -- res)) { + op(_CALL_BUILTIN_FAST_WITH_KEYWORDS, (callable[1], self_or_null[1], args[oparg] -- res)) { /* Builtin METH_FASTCALL | METH_KEYWORDS functions */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -3839,7 +3848,8 @@ dummy_func( for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable); + KILL(self_or_null); + PyStackRef_CLOSE(callable[0]); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -3850,9 +3860,9 @@ dummy_func( _CALL_BUILTIN_FAST_WITH_KEYWORDS + _CHECK_PERIODIC; - inst(CALL_LEN, (unused/1, unused/2, callable, self_or_null[1], args[oparg] -- res)) { + inst(CALL_LEN, (unused/1, unused/2, callable[1], self_or_null[1], args[oparg] -- res)) { /* len(o) */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -3874,14 +3884,14 @@ dummy_func( if (res_o == NULL) { GOTO_ERROR(error); } - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(arg_stackref); res = PyStackRef_FromPyObjectSteal(res_o); } - inst(CALL_ISINSTANCE, (unused/1, unused/2, callable, self_or_null[1], args[oparg] -- res)) { + inst(CALL_ISINSTANCE, (unused/1, unused/2, callable[1], self_or_null[1], args[oparg] -- res)) { /* isinstance(o, o2) */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -3902,7 +3912,7 @@ dummy_func( assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(inst_stackref); PyStackRef_CLOSE(cls_stackref); - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); } // This is secretly a super-instruction @@ -3928,8 +3938,8 @@ dummy_func( #endif } - op(_CALL_METHOD_DESCRIPTOR_O, (callable, self_or_null[1], args[oparg] -- res)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_CALL_METHOD_DESCRIPTOR_O, (callable[1], self_or_null[1], args[oparg] -- res)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -3958,7 +3968,9 @@ dummy_func( assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); PyStackRef_CLOSE(arg_stackref); - PyStackRef_CLOSE(callable); + KILL(args); + KILL(self_or_null); + PyStackRef_CLOSE(callable[0]); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -3969,8 +3981,8 @@ dummy_func( _CALL_METHOD_DESCRIPTOR_O + _CHECK_PERIODIC; - op(_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, (callable, self_or_null[1], args[oparg] -- res)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS, (callable[1], self_or_null[1], args[oparg] -- res)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -4002,7 +4014,8 @@ dummy_func( for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable); + KILL(self_or_null); + PyStackRef_CLOSE(callable[0]); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -4013,9 +4026,9 @@ dummy_func( _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS + _CHECK_PERIODIC; - op(_CALL_METHOD_DESCRIPTOR_NOARGS, (callable, self_or_null[1], args[oparg] -- res)) { + op(_CALL_METHOD_DESCRIPTOR_NOARGS, (callable[1], self_or_null[1], args[oparg] -- res)) { assert(oparg == 0 || oparg == 1); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -4039,7 +4052,9 @@ dummy_func( _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); - PyStackRef_CLOSE(callable); + KILL(args); + KILL(self_or_null); + PyStackRef_CLOSE(callable[0]); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -4050,8 +4065,8 @@ dummy_func( _CALL_METHOD_DESCRIPTOR_NOARGS + _CHECK_PERIODIC; - op(_CALL_METHOD_DESCRIPTOR_FAST, (callable, self_or_null[1], args[oparg] -- res)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_CALL_METHOD_DESCRIPTOR_FAST, (callable[1], self_or_null[1], args[oparg] -- res)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -4083,7 +4098,8 @@ dummy_func( for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable); + KILL(self_or_null); + PyStackRef_CLOSE(callable[0]); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -4115,25 +4131,22 @@ dummy_func( GO_TO_INSTRUCTION(CALL_KW); } - op(_MAYBE_EXPAND_METHOD_KW, (callable, self_or_null[1], args[oparg], kwnames_in -- func, maybe_self[1], args[oparg], kwnames_out)) { - if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_MAYBE_EXPAND_METHOD_KW, (callable[1], self_or_null[1], args[oparg], kwnames_in -- func[1], maybe_self[1], args[oparg], kwnames_out)) { + if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); PyObject *self = ((PyMethodObject *)callable_o)->im_self; maybe_self[0] = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; - func = PyStackRef_FromPyObjectNew(method); - PyStackRef_CLOSE(callable); - } - else { - func = callable; - KILL(callable); + _PyStackRef temp = callable[0]; + func[0] = PyStackRef_FromPyObjectNew(method); + PyStackRef_CLOSE(temp); } kwnames_out = kwnames_in; KILL(kwnames_in); } - op(_DO_CALL_KW, (callable, self_or_null[1], args[oparg], kwnames -- res)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_DO_CALL_KW, (callable[1], self_or_null[1], args[oparg], kwnames -- res)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); // oparg counts all of the args, but *not* self: @@ -4151,7 +4164,7 @@ dummy_func( 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)); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( - tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, + tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable[0]), locals, args, positional_args, kwnames_o, frame ); PyStackRef_CLOSE(kwnames); @@ -4196,16 +4209,17 @@ dummy_func( } PyStackRef_CLOSE(kwnames); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } + KILL(self_or_null); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } - op(_PY_FRAME_KW, (callable, self_or_null[1], args[oparg], kwnames -- new_frame: _PyInterpreterFrame*)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_PY_FRAME_KW, (callable[1], self_or_null[1], args[oparg], kwnames -- new_frame: _PyInterpreterFrame*)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); // oparg counts all of the args, but *not* self: int total_args = oparg; @@ -4219,7 +4233,7 @@ dummy_func( 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)); new_frame = _PyEvalFramePushAndInit( - tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, + tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable[0]), locals, args, positional_args, kwnames_o, frame ); PyStackRef_CLOSE(kwnames); @@ -4231,8 +4245,8 @@ dummy_func( } } - op(_CHECK_FUNCTION_VERSION_KW, (func_version/2, callable, self_or_null[1], unused[oparg], kwnames -- callable, self_or_null[1], unused[oparg], kwnames)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_CHECK_FUNCTION_VERSION_KW, (func_version/2, callable[1], self_or_null[1], unused[oparg], kwnames -- callable[1], self_or_null[1], unused[oparg], kwnames)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); EXIT_IF(!PyFunction_Check(callable_o)); PyFunctionObject *func = (PyFunctionObject *)callable_o; EXIT_IF(func->func_version != func_version); @@ -4246,8 +4260,8 @@ dummy_func( _SAVE_RETURN_OFFSET + _PUSH_FRAME; - op(_CHECK_METHOD_VERSION_KW, (func_version/2, callable, null[1], unused[oparg], kwnames -- callable, null[1], unused[oparg], kwnames)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_CHECK_METHOD_VERSION_KW, (func_version/2, callable[1], null[1], unused[oparg], kwnames -- callable[1], null[1], unused[oparg], kwnames)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); EXIT_IF(Py_TYPE(callable_o) != &PyMethod_Type); PyObject *func = ((PyMethodObject *)callable_o)->im_func; @@ -4256,15 +4270,16 @@ dummy_func( EXIT_IF(!PyStackRef_IsNull(null[0])); } - op(_EXPAND_METHOD_KW, (callable, null[1], unused[oparg], unused -- method, self[1], unused[oparg], unused)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_EXPAND_METHOD_KW, (callable[1], null[1], unused[oparg], unused -- method[1], self[1], unused[oparg], unused)) { + _PyStackRef callable_s = callable[0]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable_s); assert(PyStackRef_IsNull(null[0])); assert(Py_TYPE(callable_o) == &PyMethod_Type); self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - assert(PyStackRef_FunctionCheck(method)); - PyStackRef_CLOSE(callable); + method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + assert(PyStackRef_FunctionCheck(method[0])); + PyStackRef_CLOSE(callable_s); } macro(CALL_KW_BOUND_METHOD) = @@ -4277,11 +4292,11 @@ dummy_func( _SAVE_RETURN_OFFSET + _PUSH_FRAME; - specializing op(_SPECIALIZE_CALL_KW, (counter/1, callable, self_or_null[1], args[oparg], kwnames -- callable, self_or_null[1], args[oparg], kwnames)) { + specializing op(_SPECIALIZE_CALL_KW, (counter/1, callable[1], self_or_null[1], args[oparg], kwnames -- callable[1], self_or_null[1], args[oparg], kwnames)) { #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; - _Py_Specialize_CallKw(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); + _Py_Specialize_CallKw(callable[0], next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(CALL_KW); @@ -4295,18 +4310,18 @@ dummy_func( _MAYBE_EXPAND_METHOD_KW + _DO_CALL_KW; - op(_CHECK_IS_NOT_PY_CALLABLE_KW, (callable, unused[1], unused[oparg], kwnames -- callable, unused[1], unused[oparg], kwnames)) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + op(_CHECK_IS_NOT_PY_CALLABLE_KW, (callable[1], unused[1], unused[oparg], kwnames -- callable[1], unused[1], unused[oparg], kwnames)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); EXIT_IF(PyFunction_Check(callable_o)); EXIT_IF(Py_TYPE(callable_o) == &PyMethod_Type); } - op(_CALL_KW_NON_PY, (callable, self_or_null[1], args[oparg], kwnames -- res)) { + op(_CALL_KW_NON_PY, (callable[1], self_or_null[1], args[oparg], kwnames -- res)) { #if TIER_ONE assert(opcode != INSTRUMENTED_CALL); #endif - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -4328,10 +4343,11 @@ dummy_func( PyStackRef_CLOSE(kwnames); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } + KILL(self_or_null); + PyStackRef_CLOSE(callable[0]); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -4347,32 +4363,40 @@ dummy_func( GO_TO_INSTRUCTION(CALL_FUNCTION_EX); } - inst(_DO_CALL_FUNCTION_EX, (func_st, unused, callargs_st, kwargs_st if (oparg & 1) -- result)) { - PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); - PyObject *callargs = PyStackRef_AsPyObjectBorrow(callargs_st); - PyObject *kwargs = PyStackRef_AsPyObjectSteal(kwargs_st); - - // DICT_MERGE is called before this opcode if there are kwargs. - // It converts all dict subtypes in kwargs into regular dicts. - assert(kwargs == NULL || PyDict_CheckExact(kwargs)); - if (!PyTuple_CheckExact(callargs)) { - int err = check_args_iterable(tstate, func, callargs); + op(_MAKE_CALLARGS_A_TUPLE, (func, unused, callargs, kwargs_in if (oparg & 1) -- func, unused, tuple, kwargs_out if (oparg & 1))) { + PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs); + if (PyTuple_CheckExact(callargs_o)) { + tuple = callargs; + KILL(callargs); + } + else { + int err = check_args_iterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); if (err < 0) { ERROR_NO_POP(); } - PyObject *tuple = PySequence_Tuple(callargs); - if (tuple == NULL) { + PyObject *tuple_o = PySequence_Tuple(callargs_o); + if (tuple_o == NULL) { ERROR_NO_POP(); } - PyStackRef_CLOSE(callargs_st); - callargs = tuple; - } - else { - callargs = PyStackRef_AsPyObjectSteal(callargs_st); + PyStackRef_CLOSE(callargs); + tuple = PyStackRef_FromPyObjectSteal(tuple_o); } + kwargs_out = kwargs_in; + KILL(kwargs_in); + } + + op(_DO_CALL_FUNCTION_EX, (func_st, unused, callargs_st, kwargs_st if (oparg & 1) -- result)) { + PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + PyObject *callargs = PyStackRef_AsPyObjectBorrow(callargs_st); + PyObject *kwargs = PyStackRef_AsPyObjectBorrow(kwargs_st); + + // DICT_MERGE is called before this opcode if there are kwargs. + // It converts all dict subtypes in kwargs into regular dicts. + assert(kwargs == NULL || PyDict_CheckExact(kwargs)); assert(PyTuple_CheckExact(callargs)); EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_FUNCTION_EX, func); PyObject *result_o; + assert(!_PyErr_Occurred(tstate)); if (opcode == INSTRUMENTED_CALL_FUNCTION_EX) { PyObject *arg = PyTuple_GET_SIZE(callargs) > 0 ? PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING; @@ -4385,7 +4409,7 @@ dummy_func( result_o = PyObject_Call(func, callargs, kwargs); if (!PyFunction_Check(func) && !PyMethod_Check(func)) { - if (PyStackRef_IsNull(result)) { + if (result_o == NULL) { _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, func, arg); @@ -4399,7 +4423,6 @@ dummy_func( } } } - } else { if (Py_TYPE(func) == &PyFunction_Type && @@ -4425,14 +4448,16 @@ dummy_func( } result_o = PyObject_Call(func, callargs, kwargs); } - Py_DECREF(callargs); + PyStackRef_XCLOSE(kwargs_st); + KILL(kwargs_st); + PyStackRef_CLOSE(callargs_st); PyStackRef_CLOSE(func_st); - Py_XDECREF(kwargs); + ERROR_IF(result_o == NULL, error); result = PyStackRef_FromPyObjectSteal(result_o); - ERROR_IF(PyStackRef_IsNull(result), error); } macro(CALL_FUNCTION_EX) = + _MAKE_CALLARGS_A_TUPLE + _DO_CALL_FUNCTION_EX + _CHECK_PERIODIC; @@ -4907,13 +4932,6 @@ dummy_func( tier2 op(_ERROR_POP_N, (target/2, unused[oparg] --)) { frame->instr_ptr = ((_Py_CODEUNIT *)_PyFrame_GetCode(frame)->co_code_adaptive) + target; - { - stack_pointer -= oparg; - if (!WITHIN_STACK_BOUNDS()) { - printf("Stacke level: %d, oparg: %d\n", STACK_LEVEL(), oparg); - } - stack_pointer += oparg; - } SYNC_SP(); GOTO_UNWIND(); } diff --git a/Python/ceval.c b/Python/ceval.c index 675b7083646a9a..d9ede2816fc02f 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -246,7 +246,6 @@ maybe_lltrace_resume_frame(_PyInterpreterFrame *frame, _PyInterpreterFrame *skip lltrace = *python_lltrace - '0'; // TODO: Parse an int and all that } } - lltrace = 5; if (lltrace >= 5) { lltrace_resume_frame(frame); } diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 0b10c2f1b2eca0..c92aea6f5f0c53 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -9,7 +9,6 @@ #define TIER_TWO 2 case _NOP: { - /* Pushed outputs */ break; } @@ -21,7 +20,7 @@ int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) JUMP_TO_ERROR(); - }/* Pushed outputs */ + } break; } @@ -36,7 +35,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) JUMP_TO_ERROR(); } - }/* Pushed outputs */ + } break; } @@ -57,7 +56,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -76,7 +74,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (1) JUMP_TO_ERROR(); } - value = PyStackRef_DUP(value_s);/* Pushed outputs */ + value = PyStackRef_DUP(value_s); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -88,7 +86,7 @@ oparg = 0; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ + value = PyStackRef_DUP(GETLOCAL(oparg)); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -100,7 +98,7 @@ oparg = 1; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ + value = PyStackRef_DUP(GETLOCAL(oparg)); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -112,7 +110,7 @@ oparg = 2; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ + value = PyStackRef_DUP(GETLOCAL(oparg)); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -124,7 +122,7 @@ oparg = 3; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ + value = PyStackRef_DUP(GETLOCAL(oparg)); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -136,7 +134,7 @@ oparg = 4; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ + value = PyStackRef_DUP(GETLOCAL(oparg)); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -148,7 +146,7 @@ oparg = 5; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ + value = PyStackRef_DUP(GETLOCAL(oparg)); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -160,7 +158,7 @@ oparg = 6; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ + value = PyStackRef_DUP(GETLOCAL(oparg)); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -172,7 +170,7 @@ oparg = 7; assert(oparg == CURRENT_OPARG()); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ + value = PyStackRef_DUP(GETLOCAL(oparg)); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -183,7 +181,7 @@ _PyStackRef value; oparg = CURRENT_OPARG(); assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ + value = PyStackRef_DUP(GETLOCAL(oparg)); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -195,7 +193,7 @@ oparg = CURRENT_OPARG(); value = GETLOCAL(oparg); // do not use SETLOCAL here, it decrefs the old value - GETLOCAL(oparg) = PyStackRef_NULL;/* Pushed outputs */ + GETLOCAL(oparg) = PyStackRef_NULL; stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -205,7 +203,7 @@ case _LOAD_CONST: { _PyStackRef value; oparg = CURRENT_OPARG(); - value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg));/* Pushed outputs */ + value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg)); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -217,7 +215,7 @@ oparg = 0; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ + SETLOCAL(oparg, value);(void)value ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -228,7 +226,7 @@ oparg = 1; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ + SETLOCAL(oparg, value);(void)value ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -239,7 +237,7 @@ oparg = 2; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ + SETLOCAL(oparg, value);(void)value ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -250,7 +248,7 @@ oparg = 3; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ + SETLOCAL(oparg, value);(void)value ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -261,7 +259,7 @@ oparg = 4; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ + SETLOCAL(oparg, value);(void)value ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -272,7 +270,7 @@ oparg = 5; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ + SETLOCAL(oparg, value);(void)value ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -283,7 +281,7 @@ oparg = 6; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ + SETLOCAL(oparg, value);(void)value ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -294,7 +292,7 @@ oparg = 7; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ + SETLOCAL(oparg, value);(void)value ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -304,7 +302,7 @@ _PyStackRef value; oparg = CURRENT_OPARG(); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ + SETLOCAL(oparg, value);(void)value ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -314,7 +312,6 @@ _PyStackRef value; value = stack_pointer[-1]; PyStackRef_CLOSE(value); - /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -322,7 +319,7 @@ case _PUSH_NULL: { _PyStackRef res; - res = PyStackRef_NULL;/* Pushed outputs */ + res = PyStackRef_NULL; stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -337,7 +334,7 @@ receiver = stack_pointer[-2]; (void)receiver; val = value;(void)value ; - PyStackRef_CLOSE(receiver);/* Pushed outputs */ + PyStackRef_CLOSE(receiver); stack_pointer[-2] = val; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -355,7 +352,7 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -368,7 +365,7 @@ value = stack_pointer[-1]; assert(PyStackRef_BoolCheck(value)); res = PyStackRef_Is(value, PyStackRef_False) - ? PyStackRef_True : PyStackRef_False;(void)value ;/* Pushed outputs */ + ? PyStackRef_True : PyStackRef_False;(void)value ; stack_pointer[-1] = res; break; } @@ -384,7 +381,7 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); if (err < 0) JUMP_TO_ERROR(); - res = err ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + res = err ? PyStackRef_True : PyStackRef_False; stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -398,7 +395,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - STAT_INC(TO_BOOL, hit);/* Pushed outputs */ + STAT_INC(TO_BOOL, hit); break; } @@ -422,7 +419,7 @@ else { PyStackRef_CLOSE(value); res = PyStackRef_True; - }/* Pushed outputs */ + } stack_pointer[-1] = res; break; } @@ -439,7 +436,6 @@ STAT_INC(TO_BOOL, hit); res = Py_SIZE(value_o) ? PyStackRef_True : PyStackRef_False; PyStackRef_CLOSE(value); - /* Pushed outputs */ stack_pointer[-1] = res; break; } @@ -455,7 +451,7 @@ } (void)value ; STAT_INC(TO_BOOL, hit); - res = PyStackRef_False;/* Pushed outputs */ + res = PyStackRef_False; stack_pointer[-1] = res; break; } @@ -481,7 +477,7 @@ assert(Py_SIZE(value_o)); PyStackRef_CLOSE(value); res = PyStackRef_True; - }/* Pushed outputs */ + } stack_pointer[-1] = res; break; } @@ -491,7 +487,7 @@ _PyStackRef res; value = stack_pointer[-1]; PyStackRef_CLOSE(value); - res = PyStackRef_True;/* Pushed outputs */ + res = PyStackRef_True; stack_pointer[-1] = res; break; } @@ -507,7 +503,7 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -529,7 +525,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -541,7 +536,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -553,7 +547,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -572,7 +565,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -594,7 +587,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -616,7 +609,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -638,7 +631,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -650,7 +642,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -662,7 +653,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -680,7 +670,7 @@ ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -701,7 +691,7 @@ ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -722,7 +712,7 @@ ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -744,7 +734,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -763,7 +752,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -815,7 +804,7 @@ // and during trace projection in tier two: assert(next_instr->op.code == STORE_FAST); SKIP_OVER(1); - #endif/* Pushed outputs */ + #endif break; } @@ -835,7 +824,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -873,7 +862,7 @@ stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -911,7 +900,6 @@ stack_pointer += -4; assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); - /* Pushed outputs */ break; } @@ -947,7 +935,7 @@ Py_INCREF(res_o); _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; PyStackRef_CLOSE(list_st); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -989,7 +977,7 @@ PyObject *res_o = (PyObject*)&_Py_SINGLETON(strings).ascii[c]; _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; PyStackRef_CLOSE(str_st); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1028,7 +1016,7 @@ Py_INCREF(res_o); _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; PyStackRef_CLOSE(tuple_st); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1063,7 +1051,7 @@ assert(WITHIN_STACK_BOUNDS()); if (rc <= 0) JUMP_TO_ERROR(); // not found or error - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); break; } @@ -1094,7 +1082,7 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(BINARY_SUBSCR, hit); - Py_INCREF(getitem);/* Pushed outputs */ + Py_INCREF(getitem); break; } @@ -1110,7 +1098,7 @@ new_frame = _PyFrame_PushUnchecked(tstate, (PyFunctionObject *)getitem, 2, frame); new_frame->localsplus[0] = container; new_frame->localsplus[1] = sub; - frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_BINARY_SUBSCR);/* Pushed outputs */ + frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_BINARY_SUBSCR); stack_pointer[-2].bits = (uintptr_t)new_frame; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1128,7 +1116,6 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); if (err < 0) JUMP_TO_ERROR(); - /* Pushed outputs */ break; } @@ -1146,7 +1133,6 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); - /* Pushed outputs */ break; } @@ -1167,7 +1153,6 @@ stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); - /* Pushed outputs */ break; } @@ -1205,7 +1190,7 @@ assert(old_value != NULL); Py_DECREF(old_value); _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; - PyStackRef_CLOSE(list_st);/* Pushed outputs */ + PyStackRef_CLOSE(list_st); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); break; @@ -1233,7 +1218,6 @@ stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); - /* Pushed outputs */ break; } @@ -1252,7 +1236,6 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); - /* Pushed outputs */ break; } @@ -1267,7 +1250,7 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1290,7 +1273,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1317,7 +1300,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(frame->return_offset); res = temp; - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1363,7 +1346,7 @@ Py_DECREF(iter_o); if (true) JUMP_TO_ERROR(); } - iter = PyStackRef_FromPyObjectSteal(iter_o);/* Pushed outputs */ + iter = PyStackRef_FromPyObjectSteal(iter_o); break; } @@ -1377,7 +1360,7 @@ if (awaitable_o == NULL) { JUMP_TO_ERROR(); } - awaitable = PyStackRef_FromPyObjectSteal(awaitable_o);/* Pushed outputs */ + awaitable = PyStackRef_FromPyObjectSteal(awaitable_o); stack_pointer[0] = awaitable; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1396,7 +1379,7 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); if (iter_o == NULL) JUMP_TO_ERROR(); - iter = PyStackRef_FromPyObjectSteal(iter_o);/* Pushed outputs */ + iter = PyStackRef_FromPyObjectSteal(iter_o); stack_pointer[0] = iter; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1429,7 +1412,7 @@ tstate->exc_info = &gen->gi_exc_state; assert(1 + INLINE_CACHE_ENTRIES_SEND + oparg <= UINT16_MAX); frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_SEND + oparg); - gen_frame->previous = frame;/* Pushed outputs */ + gen_frame->previous = frame; stack_pointer[-1].bits = (uintptr_t)gen_frame; break; } @@ -1475,7 +1458,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND); value = temp; - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1491,7 +1474,6 @@ PyStackRef_Is(exc_value, PyStackRef_None) ? NULL : PyStackRef_AsPyObjectSteal(exc_value)); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -1512,7 +1494,7 @@ default: Py_FatalError("bad LOAD_COMMON_CONSTANT oparg"); } - value = PyStackRef_FromPyObjectImmortal(val);/* Pushed outputs */ + value = PyStackRef_FromPyObjectImmortal(val); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1533,7 +1515,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (true) JUMP_TO_ERROR(); } - bc = PyStackRef_FromPyObjectSteal(bc_o);/* Pushed outputs */ + bc = PyStackRef_FromPyObjectSteal(bc_o); stack_pointer[0] = bc; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1571,7 +1553,6 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); - /* Pushed outputs */ break; } @@ -1598,7 +1579,7 @@ name); stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); - }/* Pushed outputs */ + } break; } @@ -1606,8 +1587,8 @@ _PyStackRef seq; _PyStackRef *output; oparg = CURRENT_OPARG(); - output = &stack_pointer[0]; seq = stack_pointer[-1]; + output = &stack_pointer[-1]; _PyStackRef *top = output + oparg; _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top); @@ -1616,7 +1597,6 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); if (res == 0) JUMP_TO_ERROR(); - /* Pushed outputs */ stack_pointer += oparg; assert(WITHIN_STACK_BOUNDS()); break; @@ -1642,7 +1622,6 @@ val0 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 0)); val1 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 1)); PyStackRef_CLOSE(seq); - /* Pushed outputs */ stack_pointer[-1] = val1; stack_pointer[0] = val0; stack_pointer += 1; @@ -1654,8 +1633,8 @@ _PyStackRef seq; _PyStackRef *values; oparg = CURRENT_OPARG(); - values = &stack_pointer[0]; seq = stack_pointer[-1]; + values = &stack_pointer[-1]; PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq); if (!PyTuple_CheckExact(seq_o)) { UOP_STAT_INC(uopcode, miss); @@ -1671,7 +1650,6 @@ *values++ = PyStackRef_FromPyObjectNew(items[i]); } PyStackRef_CLOSE(seq); - /* Pushed outputs */ stack_pointer += -1 + oparg; assert(WITHIN_STACK_BOUNDS()); break; @@ -1681,8 +1659,8 @@ _PyStackRef seq; _PyStackRef *values; oparg = CURRENT_OPARG(); - values = &stack_pointer[0]; seq = stack_pointer[-1]; + values = &stack_pointer[-1]; PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq); if (!PyList_CheckExact(seq_o)) { UOP_STAT_INC(uopcode, miss); @@ -1698,7 +1676,6 @@ *values++ = PyStackRef_FromPyObjectNew(items[i]); } PyStackRef_CLOSE(seq); - /* Pushed outputs */ stack_pointer += -1 + oparg; assert(WITHIN_STACK_BOUNDS()); break; @@ -1708,8 +1685,8 @@ _PyStackRef seq; _PyStackRef *right; oparg = CURRENT_OPARG(); - right = &stack_pointer[1 + (oparg & 0xFF)]; seq = stack_pointer[-1]; + right = &stack_pointer[(oparg & 0xFF)]; _PyStackRef *top = right + (oparg >> 8); _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top); @@ -1718,7 +1695,6 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); if (res == 0) JUMP_TO_ERROR(); - /* Pushed outputs */ stack_pointer += 1 + (oparg & 0xFF) + (oparg >> 8); assert(WITHIN_STACK_BOUNDS()); break; @@ -1740,7 +1716,6 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); - /* Pushed outputs */ break; } @@ -1756,7 +1731,6 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); - /* Pushed outputs */ break; } @@ -1772,7 +1746,6 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); - /* Pushed outputs */ break; } @@ -1792,7 +1765,7 @@ NAME_ERROR_MSG, name); stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); - }/* Pushed outputs */ + } break; } @@ -1806,7 +1779,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (true) JUMP_TO_ERROR(); } - locals = PyStackRef_FromPyObjectNew(l);/* Pushed outputs */ + locals = PyStackRef_FromPyObjectNew(l); stack_pointer[0] = locals; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1823,7 +1796,7 @@ PyObject *v_o = _PyEval_LoadName(tstate, frame, name); stack_pointer = _PyFrame_GetStackPointer(frame); if (v_o == NULL) JUMP_TO_ERROR(); - v = PyStackRef_FromPyObjectSteal(v_o);/* Pushed outputs */ + v = PyStackRef_FromPyObjectSteal(v_o); stack_pointer[0] = v; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1840,7 +1813,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (res_o == NULL) JUMP_TO_ERROR(); null = PyStackRef_NULL; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; if (oparg & 1) stack_pointer[1] = null; stack_pointer += 1 + (oparg & 1); @@ -1859,7 +1832,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - assert(DK_IS_UNICODE(dict->ma_keys));/* Pushed outputs */ + assert(DK_IS_UNICODE(dict->ma_keys)); break; } @@ -1874,7 +1847,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - assert(DK_IS_UNICODE(dict->ma_keys));/* Pushed outputs */ + assert(DK_IS_UNICODE(dict->ma_keys)); break; } @@ -1893,7 +1866,7 @@ Py_INCREF(res_o); STAT_INC(LOAD_GLOBAL, hit); null = PyStackRef_NULL; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; if (oparg & 1) stack_pointer[1] = null; stack_pointer += 1 + (oparg & 1); @@ -1916,7 +1889,7 @@ Py_INCREF(res_o); STAT_INC(LOAD_GLOBAL, hit); null = PyStackRef_NULL; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; if (oparg & 1) stack_pointer[1] = null; stack_pointer += 1 + (oparg & 1); @@ -1936,7 +1909,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (1) JUMP_TO_ERROR(); } - SETLOCAL(oparg, PyStackRef_NULL);/* Pushed outputs */ + SETLOCAL(oparg, PyStackRef_NULL); break; } @@ -1949,7 +1922,7 @@ if (cell == NULL) { JUMP_TO_ERROR(); } - SETLOCAL(oparg, PyStackRef_FromPyObjectSteal(cell));/* Pushed outputs */ + SETLOCAL(oparg, PyStackRef_FromPyObjectSteal(cell)); break; } @@ -1967,7 +1940,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); } - Py_DECREF(oldobj);/* Pushed outputs */ + Py_DECREF(oldobj); break; } @@ -1999,7 +1972,7 @@ } } PyStackRef_CLOSE(class_dict_st); - value = PyStackRef_FromPyObjectSteal(value_o);/* Pushed outputs */ + value = PyStackRef_FromPyObjectSteal(value_o); break; } @@ -2014,7 +1987,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (true) JUMP_TO_ERROR(); } - value = PyStackRef_FromPyObjectSteal(value_o);/* Pushed outputs */ + value = PyStackRef_FromPyObjectSteal(value_o); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2029,7 +2002,6 @@ _PyFrame_SetStackPointer(frame, stack_pointer); PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v)); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -2046,7 +2018,7 @@ for (int i = 0; i < oparg; ++i) { PyObject *o = PyTuple_GET_ITEM(closure, i); frame->localsplus[offset + i] = PyStackRef_FromPyObjectNew(o); - }/* Pushed outputs */ + } break; } @@ -2072,7 +2044,7 @@ stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); if (str_o == NULL) JUMP_TO_ERROR(); - str = PyStackRef_FromPyObjectSteal(str_o);/* Pushed outputs */ + str = PyStackRef_FromPyObjectSteal(str_o); stack_pointer[0] = str; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2088,7 +2060,7 @@ stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); if (tup_o == NULL) JUMP_TO_ERROR(); - tup = PyStackRef_FromPyObjectSteal(tup_o);/* Pushed outputs */ + tup = PyStackRef_FromPyObjectSteal(tup_o); stack_pointer[0] = tup; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2104,7 +2076,7 @@ stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); if (list_o == NULL) JUMP_TO_ERROR(); - list = PyStackRef_FromPyObjectSteal(list_o);/* Pushed outputs */ + list = PyStackRef_FromPyObjectSteal(list_o); stack_pointer[0] = list; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2143,7 +2115,6 @@ } assert(Py_IsNone(none_val)); PyStackRef_CLOSE(iterable_st); - /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -2163,7 +2134,6 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); if (err < 0) JUMP_TO_ERROR(); - /* Pushed outputs */ break; } @@ -2172,8 +2142,6 @@ _PyStackRef set; oparg = CURRENT_OPARG(); values = &stack_pointer[-oparg]; - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *set_o = PySet_New(NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2181,6 +2149,8 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } int err = 0; @@ -2191,12 +2161,14 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(values[i]); - } + }(void)values ; if (err != 0) { Py_DECREF(set_o); + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } - set = PyStackRef_FromPyObjectSteal(set_o);/* Pushed outputs */ + set = PyStackRef_FromPyObjectSteal(set_o); break; } @@ -2214,8 +2186,6 @@ assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } - stack_pointer += -oparg*2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *map_o = _PyDict_FromItems( values_o, 2, @@ -2226,8 +2196,10 @@ for (int _i = oparg*2; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } + stack_pointer += -oparg*2; + assert(WITHIN_STACK_BOUNDS()); if (map_o == NULL) JUMP_TO_ERROR(); - map = PyStackRef_FromPyObjectSteal(map_o);/* Pushed outputs */ + map = PyStackRef_FromPyObjectSteal(map_o); stack_pointer[0] = map; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2262,7 +2234,7 @@ } else { Py_DECREF(ann_dict); - }/* Pushed outputs */ + } break; } @@ -2294,7 +2266,6 @@ if (true) JUMP_TO_ERROR(); } PyStackRef_CLOSE(update); - /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -2324,7 +2295,6 @@ if (true) JUMP_TO_ERROR(); } PyStackRef_CLOSE(update); - /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -2352,7 +2322,6 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (err != 0) JUMP_TO_ERROR(); - /* Pushed outputs */ break; } @@ -2390,7 +2359,7 @@ stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); if (attr == NULL) JUMP_TO_ERROR(); - attr_st = PyStackRef_FromPyObjectSteal(attr);/* Pushed outputs */ + attr_st = PyStackRef_FromPyObjectSteal(attr); stack_pointer[0] = attr_st; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2441,7 +2410,7 @@ PyStackRef_CLOSE(self_st); self_or_null = PyStackRef_NULL; } - attr = PyStackRef_FromPyObjectSteal(attr_o);/* Pushed outputs */ + attr = PyStackRef_FromPyObjectSteal(attr_o); stack_pointer[-3] = attr; stack_pointer[-2] = self_or_null; stack_pointer += -1; @@ -2499,7 +2468,7 @@ self_or_null = PyStackRef_NULL;stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); } - attr = PyStackRef_FromPyObjectSteal(attr_o);/* Pushed outputs */ + attr = PyStackRef_FromPyObjectSteal(attr_o); stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = self_or_null; stack_pointer += (oparg & 1); @@ -2517,7 +2486,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -2531,7 +2499,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -2554,7 +2521,6 @@ null = PyStackRef_NULL; attr = PyStackRef_FromPyObjectSteal(attr_o); PyStackRef_CLOSE(owner); - /* Pushed outputs */ stack_pointer[-1] = attr; break; } @@ -2578,7 +2544,6 @@ null = PyStackRef_NULL; attr = PyStackRef_FromPyObjectSteal(attr_o); PyStackRef_CLOSE(owner); - /* Pushed outputs */ stack_pointer[-1] = attr; stack_pointer[0] = null; stack_pointer += 1; @@ -2603,7 +2568,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -2629,7 +2593,6 @@ attr = PyStackRef_FromPyObjectSteal(attr_o); null = PyStackRef_NULL; PyStackRef_CLOSE(owner); - /* Pushed outputs */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); @@ -2647,7 +2610,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - assert(PyDict_CheckExact((PyObject *)dict));/* Pushed outputs */ + assert(PyDict_CheckExact((PyObject *)dict)); break; } @@ -2685,7 +2648,6 @@ attr = PyStackRef_FromPyObjectSteal(attr_o); null = PyStackRef_NULL; PyStackRef_CLOSE(owner); - /* Pushed outputs */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); @@ -2711,7 +2673,6 @@ null = PyStackRef_NULL; attr = PyStackRef_FromPyObjectNew(attr_o); PyStackRef_CLOSE(owner); - /* Pushed outputs */ stack_pointer[-1] = attr; break; } @@ -2734,7 +2695,6 @@ null = PyStackRef_NULL; attr = PyStackRef_FromPyObjectNew(attr_o); PyStackRef_CLOSE(owner); - /* Pushed outputs */ stack_pointer[-1] = attr; stack_pointer[0] = null; stack_pointer += 1; @@ -2758,7 +2718,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -2774,7 +2733,6 @@ attr = PyStackRef_FromPyObjectNew(descr); null = PyStackRef_NULL; PyStackRef_CLOSE(owner); - /* Pushed outputs */ stack_pointer[-1] = attr; break; } @@ -2791,7 +2749,6 @@ attr = PyStackRef_FromPyObjectNew(descr); null = PyStackRef_NULL; PyStackRef_CLOSE(owner); - /* Pushed outputs */ stack_pointer[-1] = attr; stack_pointer[0] = null; stack_pointer += 1; @@ -2830,7 +2787,7 @@ STAT_INC(LOAD_ATTR, hit); Py_INCREF(fget); new_frame = _PyFrame_PushUnchecked(tstate, f, 1, frame); - new_frame->localsplus[0] = owner;(void)owner ;/* Pushed outputs */ + new_frame->localsplus[0] = owner;(void)owner ; stack_pointer[-1].bits = (uintptr_t)new_frame; break; } @@ -2851,7 +2808,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -2875,7 +2831,7 @@ else { Py_DECREF(old_value); } - PyStackRef_CLOSE(owner);/* Pushed outputs */ + PyStackRef_CLOSE(owner); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); break; @@ -2929,7 +2885,7 @@ // when dict only holds the strong reference to value in ep->me_value. Py_XDECREF(old_value); STAT_INC(STORE_ATTR, hit); - PyStackRef_CLOSE(owner);/* Pushed outputs */ + PyStackRef_CLOSE(owner); break; } @@ -2945,7 +2901,7 @@ PyObject *old_value = *(PyObject **)addr; *(PyObject **)addr = PyStackRef_AsPyObjectSteal(value); Py_XDECREF(old_value); - PyStackRef_CLOSE(owner);/* Pushed outputs */ + PyStackRef_CLOSE(owner); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); break; @@ -2979,7 +2935,7 @@ } else { res = PyStackRef_FromPyObjectSteal(res_o); - }/* Pushed outputs */ + } stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3003,7 +2959,7 @@ _Py_DECREF_SPECIALIZED(left_o, _PyFloat_ExactDealloc);(void)left ; _Py_DECREF_SPECIALIZED(right_o, _PyFloat_ExactDealloc);(void)right ; res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; - // It's always a bool, so we don't care about oparg & 16./* Pushed outputs */ + // It's always a bool, so we don't care about oparg & 16. stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -3037,7 +2993,7 @@ _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);(void)left ; _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free);(void)right ; res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; - // It's always a bool, so we don't care about oparg & 16./* Pushed outputs */ + // It's always a bool, so we don't care about oparg & 16. stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -3062,7 +3018,7 @@ assert((oparg & 0xf) == COMPARISON_NOT_EQUALS || (oparg & 0xf) == COMPARISON_EQUALS); assert(COMPARISON_NOT_EQUALS + 1 == COMPARISON_EQUALS); res = ((COMPARISON_NOT_EQUALS + eq) & oparg) ? PyStackRef_True : PyStackRef_False; - // It's always a bool, so we don't care about oparg & 16./* Pushed outputs */ + // It's always a bool, so we don't care about oparg & 16. stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -3085,7 +3041,7 @@ #endif PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - b = res ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + b = res ? PyStackRef_True : PyStackRef_False; stack_pointer[-2] = b; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -3109,7 +3065,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res < 0) JUMP_TO_ERROR(); - b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; stack_pointer[0] = b; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3139,7 +3095,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res < 0) JUMP_TO_ERROR(); - b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; stack_pointer[0] = b; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3168,7 +3124,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res < 0) JUMP_TO_ERROR(); - b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; stack_pointer[0] = b; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3213,7 +3169,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } rest = PyStackRef_FromPyObjectSteal(rest_o); - match = PyStackRef_FromPyObjectSteal(match_o);/* Pushed outputs */ + match = PyStackRef_FromPyObjectSteal(match_o); break; } @@ -3239,7 +3195,7 @@ int res = PyErr_GivenExceptionMatches(left_o, right_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(right); - b = res ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + b = res ? PyStackRef_True : PyStackRef_False; stack_pointer[-1] = b; break; } @@ -3262,7 +3218,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3279,7 +3235,7 @@ PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name); stack_pointer = _PyFrame_GetStackPointer(frame); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3300,7 +3256,7 @@ else { b = PyStackRef_False; PyStackRef_CLOSE(value); - }/* Pushed outputs */ + } stack_pointer[-1] = b; break; } @@ -3318,7 +3274,7 @@ PyObject *len_o = PyLong_FromSsize_t(len_i); stack_pointer = _PyFrame_GetStackPointer(frame); if (len_o == NULL) JUMP_TO_ERROR(); - len = PyStackRef_FromPyObjectSteal(len_o);/* Pushed outputs */ + len = PyStackRef_FromPyObjectSteal(len_o); stack_pointer[0] = len; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3357,7 +3313,7 @@ // Error! attrs = PyStackRef_None; // Failure!stack_pointer += 3; assert(WITHIN_STACK_BOUNDS()); - }/* Pushed outputs */ + } stack_pointer[-3] = attrs; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -3369,7 +3325,7 @@ _PyStackRef res; subject = stack_pointer[-1]; int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING; - res = match ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + res = match ? PyStackRef_True : PyStackRef_False; stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3381,7 +3337,7 @@ _PyStackRef res; subject = stack_pointer[-1]; int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE; - res = match ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + res = match ? PyStackRef_True : PyStackRef_False; stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3400,7 +3356,7 @@ PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys)); stack_pointer = _PyFrame_GetStackPointer(frame); if (values_or_none_o == NULL) JUMP_TO_ERROR(); - values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o);/* Pushed outputs */ + values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o); stack_pointer[0] = values_or_none; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3418,7 +3374,6 @@ PyStackRef_CLOSE(iterable); stack_pointer[-1] = iter; if (PyStackRef_IsNull(iter)) JUMP_TO_ERROR(); - /* Pushed outputs */ break; } @@ -3455,7 +3410,7 @@ JUMP_TO_ERROR(); } PyStackRef_CLOSE(iterable); - }/* Pushed outputs */ + } stack_pointer[-1] = iter; break; } @@ -3490,7 +3445,7 @@ } } next = PyStackRef_FromPyObjectSteal(next_o); - // Common case: no jump, leave it to the code generator/* Pushed outputs */ + // Common case: no jump, leave it to the code generator stack_pointer[0] = next; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3506,7 +3461,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -3529,7 +3483,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - }/* Pushed outputs */ + } break; } @@ -3543,7 +3497,7 @@ PyListObject *seq = it->it_seq; assert(seq); assert(it->it_index < PyList_GET_SIZE(seq)); - next = PyStackRef_FromPyObjectNew(PyList_GET_ITEM(seq, it->it_index++));/* Pushed outputs */ + next = PyStackRef_FromPyObjectNew(PyList_GET_ITEM(seq, it->it_index++)); stack_pointer[0] = next; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3557,7 +3511,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -3578,7 +3531,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -3592,7 +3544,7 @@ PyTupleObject *seq = it->it_seq; assert(seq); assert(it->it_index < PyTuple_GET_SIZE(seq)); - next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq, it->it_index++));/* Pushed outputs */ + next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq, it->it_index++)); stack_pointer[0] = next; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3607,7 +3559,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -3622,7 +3573,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -3638,7 +3588,7 @@ r->len--; PyObject *res = PyLong_FromLong(value); if (res == NULL) JUMP_TO_ERROR(); - next = PyStackRef_FromPyObjectSteal(res);/* Pushed outputs */ + next = PyStackRef_FromPyObjectSteal(res); stack_pointer[0] = next; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3667,7 +3617,7 @@ tstate->exc_info = &gen->gi_exc_state; gen_frame->previous = frame; // oparg is the return offset from the next instruction. - frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_FOR_ITER + oparg);/* Pushed outputs */ + frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_FOR_ITER + oparg); stack_pointer[0].bits = (uintptr_t)gen_frame; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3707,7 +3657,7 @@ stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(attr)) JUMP_TO_ERROR(); - self_or_null = PyStackRef_FromPyObjectSteal(self_or_null_o);/* Pushed outputs */ + self_or_null = PyStackRef_FromPyObjectSteal(self_or_null_o); stack_pointer[0] = attr; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3759,7 +3709,6 @@ stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); - /* Pushed outputs */ break; } @@ -3777,7 +3726,7 @@ } assert(PyStackRef_ExceptionInstanceCheck(exc)); exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); - new_exc = exc;(void)exc ;/* Pushed outputs */ + new_exc = exc;(void)exc ; stack_pointer[-1] = prev_exc; stack_pointer[0] = new_exc; stack_pointer += 1; @@ -3794,7 +3743,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -3808,7 +3756,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -3825,7 +3772,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner;(void)owner ;/* Pushed outputs */ + self = owner;(void)owner ; stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; @@ -3846,7 +3793,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner;(void)owner ;/* Pushed outputs */ + self = owner;(void)owner ; stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; @@ -3864,7 +3811,7 @@ STAT_INC(LOAD_ATTR, hit); assert(descr != NULL); PyStackRef_CLOSE(owner); - attr = PyStackRef_FromPyObjectNew(descr);/* Pushed outputs */ + attr = PyStackRef_FromPyObjectNew(descr); stack_pointer[-1] = attr; break; } @@ -3880,7 +3827,7 @@ STAT_INC(LOAD_ATTR, hit); assert(descr != NULL); PyStackRef_CLOSE(owner); - attr = PyStackRef_FromPyObjectNew(descr);/* Pushed outputs */ + attr = PyStackRef_FromPyObjectNew(descr); stack_pointer[-1] = attr; break; } @@ -3896,7 +3843,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -3912,7 +3858,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner;(void)owner ;/* Pushed outputs */ + self = owner;(void)owner ; stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; @@ -3923,26 +3869,24 @@ case _MAYBE_EXPAND_METHOD: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; - _PyStackRef func; + _PyStackRef *callable; + _PyStackRef *func; _PyStackRef *maybe_self; oparg = CURRENT_OPARG(); - maybe_self = &stack_pointer[1]; args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + func = &stack_pointer[-2 - oparg]; + maybe_self = &stack_pointer[-1 - oparg]; + if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); PyObject *self = ((PyMethodObject *)callable_o)->im_self; maybe_self[0] = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; - func = PyStackRef_FromPyObjectNew(method); - PyStackRef_CLOSE(callable);(void)self_or_null ; + _PyStackRef temp = callable[0]; + func[0] = PyStackRef_FromPyObjectNew(method); + PyStackRef_CLOSE(temp); } - else { - func = callable;(void)callable ;(void)self_or_null ; - }/* Pushed outputs */ - stack_pointer[-2 - oparg] = func; break; } @@ -3953,13 +3897,13 @@ case _PY_FRAME_GENERAL: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyInterpreterFrame *new_frame; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); // oparg counts all of the args, but *not* self: int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -3969,29 +3913,28 @@ 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)); - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - new_frame = _PyEvalFramePushAndInit( - tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, + _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( + tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable[0]), locals, args, total_args, NULL, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); - // The frame has stolen all the arguments from the stack, - // so there is no need to clean them up. - stack_pointer[-1].bits = (uintptr_t)new_frame; - if (new_frame == NULL) { + // The frame has stolen all the arguments from the stack. + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + if (temp == NULL) { JUMP_TO_ERROR(); - }/* Pushed outputs */ + } + new_frame = temp; break; } case _CHECK_FUNCTION_VERSION: { - _PyStackRef callable; + _PyStackRef *callable; oparg = CURRENT_OPARG(); - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; uint32_t func_version = (uint32_t)CURRENT_OPERAND(); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); if (!PyFunction_Check(callable_o)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -4001,18 +3944,17 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } case _CHECK_METHOD_VERSION: { _PyStackRef *null; - _PyStackRef callable; + _PyStackRef *callable; oparg = CURRENT_OPARG(); null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; uint32_t func_version = (uint32_t)CURRENT_OPERAND(); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); if (Py_TYPE(callable_o) != &PyMethod_Type) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -4030,35 +3972,35 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } case _EXPAND_METHOD: { _PyStackRef *null; - _PyStackRef callable; - _PyStackRef method; + _PyStackRef *callable; + _PyStackRef *method; _PyStackRef *self; oparg = CURRENT_OPARG(); - self = &stack_pointer[1]; null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + method = &stack_pointer[-2 - oparg]; + self = &stack_pointer[-1 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); assert(PyStackRef_IsNull(null[0]));(void)null ; assert(Py_TYPE(callable_o) == &PyMethod_Type); self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - assert(PyStackRef_FunctionCheck(method)); - PyStackRef_CLOSE(callable);/* Pushed outputs */ - stack_pointer[-2 - oparg] = method; + _PyStackRef temp = callable[0]; + method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + assert(PyStackRef_FunctionCheck(method[0])); + PyStackRef_CLOSE(temp); break; } case _CHECK_IS_NOT_PY_CALLABLE: { - _PyStackRef callable; + _PyStackRef *callable; oparg = CURRENT_OPARG(); - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); if (PyFunction_Check(callable_o)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -4067,23 +4009,22 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } case _CALL_NON_PY_GENERAL: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; #if TIER_ONE assert(opcode != INSTRUMENTED_CALL); #endif - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -4092,7 +4033,7 @@ /* Callable is not a normal Python function */ STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(self_or_null[0]); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); @@ -4101,8 +4042,6 @@ assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -4111,51 +4050,51 @@ stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - } - stack_pointer += -1; + }(void)self_or_null ; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); break; } case _CHECK_CALL_BOUND_METHOD_EXACT_ARGS: { _PyStackRef *null; - _PyStackRef callable; + _PyStackRef *callable; oparg = CURRENT_OPARG(); null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; if (!PyStackRef_IsNull(null[0])) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - if (Py_TYPE(PyStackRef_AsPyObjectBorrow(callable)) != &PyMethod_Type) { + if (Py_TYPE(PyStackRef_AsPyObjectBorrow(callable[0])) != &PyMethod_Type) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } case _INIT_CALL_BOUND_METHOD_EXACT_ARGS: { _PyStackRef *null; - _PyStackRef callable; - _PyStackRef func; + _PyStackRef *callable; + _PyStackRef *func; _PyStackRef *self; oparg = CURRENT_OPARG(); - self = &stack_pointer[1]; null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; + func = &stack_pointer[-2 - oparg]; + self = &stack_pointer[-1 - oparg]; (void)null ; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); STAT_INC(CALL, hit); self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - func = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - PyStackRef_CLOSE(callable);/* Pushed outputs */ - stack_pointer[-2 - oparg] = func; + _PyStackRef temp = callable[0]; + func[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + PyStackRef_CLOSE(temp); break; } @@ -4164,17 +4103,16 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } case _CHECK_FUNCTION_EXACT_ARGS: { _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; oparg = CURRENT_OPARG(); self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); assert(PyFunction_Check(callable_o)); PyFunctionObject *func = (PyFunctionObject *)callable_o; PyCodeObject *code = (PyCodeObject *)func->func_code; @@ -4182,15 +4120,14 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } case _CHECK_STACK_SPACE: { - _PyStackRef callable; + _PyStackRef *callable; oparg = CURRENT_OPARG(); - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); PyFunctionObject *func = (PyFunctionObject *)callable_o; PyCodeObject *code = (PyCodeObject *)func->func_code; if (!_PyThreadState_HasStackSpace(tstate, code->co_framesize)) { @@ -4201,21 +4138,20 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } case _INIT_CALL_PY_EXACT_ARGS_0: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyInterpreterFrame *new_frame; oparg = 0; assert(oparg == CURRENT_OPARG()); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int has_self = !PyStackRef_IsNull(self_or_null[0]); STAT_INC(CALL, hit); PyFunctionObject *func = (PyFunctionObject *)callable_o; @@ -4224,7 +4160,7 @@ new_frame->localsplus[0] = self_or_null[0]; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; - }/* Pushed outputs */ + } stack_pointer[-2 - oparg].bits = (uintptr_t)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -4234,14 +4170,14 @@ case _INIT_CALL_PY_EXACT_ARGS_1: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyInterpreterFrame *new_frame; oparg = 1; assert(oparg == CURRENT_OPARG()); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int has_self = !PyStackRef_IsNull(self_or_null[0]); STAT_INC(CALL, hit); PyFunctionObject *func = (PyFunctionObject *)callable_o; @@ -4250,7 +4186,7 @@ new_frame->localsplus[0] = self_or_null[0]; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; - }/* Pushed outputs */ + } stack_pointer[-2 - oparg].bits = (uintptr_t)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -4260,14 +4196,14 @@ case _INIT_CALL_PY_EXACT_ARGS_2: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyInterpreterFrame *new_frame; oparg = 2; assert(oparg == CURRENT_OPARG()); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int has_self = !PyStackRef_IsNull(self_or_null[0]); STAT_INC(CALL, hit); PyFunctionObject *func = (PyFunctionObject *)callable_o; @@ -4276,7 +4212,7 @@ new_frame->localsplus[0] = self_or_null[0]; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; - }/* Pushed outputs */ + } stack_pointer[-2 - oparg].bits = (uintptr_t)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -4286,14 +4222,14 @@ case _INIT_CALL_PY_EXACT_ARGS_3: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyInterpreterFrame *new_frame; oparg = 3; assert(oparg == CURRENT_OPARG()); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int has_self = !PyStackRef_IsNull(self_or_null[0]); STAT_INC(CALL, hit); PyFunctionObject *func = (PyFunctionObject *)callable_o; @@ -4302,7 +4238,7 @@ new_frame->localsplus[0] = self_or_null[0]; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; - }/* Pushed outputs */ + } stack_pointer[-2 - oparg].bits = (uintptr_t)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -4312,14 +4248,14 @@ case _INIT_CALL_PY_EXACT_ARGS_4: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyInterpreterFrame *new_frame; oparg = 4; assert(oparg == CURRENT_OPARG()); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int has_self = !PyStackRef_IsNull(self_or_null[0]); STAT_INC(CALL, hit); PyFunctionObject *func = (PyFunctionObject *)callable_o; @@ -4328,7 +4264,7 @@ new_frame->localsplus[0] = self_or_null[0]; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; - }/* Pushed outputs */ + } stack_pointer[-2 - oparg].bits = (uintptr_t)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -4338,13 +4274,13 @@ case _INIT_CALL_PY_EXACT_ARGS: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyInterpreterFrame *new_frame; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int has_self = !PyStackRef_IsNull(self_or_null[0]); STAT_INC(CALL, hit); PyFunctionObject *func = (PyFunctionObject *)callable_o; @@ -4353,7 +4289,7 @@ new_frame->localsplus[0] = self_or_null[0]; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; - }/* Pushed outputs */ + } stack_pointer[-2 - oparg].bits = (uintptr_t)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -4376,7 +4312,7 @@ tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); break; } @@ -4404,7 +4340,7 @@ (void)callable ; STAT_INC(CALL, hit); res = PyStackRef_FromPyObjectSteal(Py_NewRef(Py_TYPE(arg_o))); - PyStackRef_CLOSE(arg);/* Pushed outputs */ + PyStackRef_CLOSE(arg); stack_pointer[-3] = res; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -4441,7 +4377,6 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); - /* Pushed outputs */ break; } @@ -4475,27 +4410,27 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); - /* Pushed outputs */ break; } case _CHECK_AND_ALLOCATE_OBJECT: { _PyStackRef *args; - _PyStackRef null; - _PyStackRef callable; - _PyStackRef self; - _PyStackRef init; + _PyStackRef *null; + _PyStackRef *callable; + _PyStackRef *init; + _PyStackRef *self; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; - null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + null = &stack_pointer[-1 - oparg]; + callable = &stack_pointer[-2 - oparg]; + init = &stack_pointer[-2 - oparg]; + self = &stack_pointer[-1 - oparg]; uint32_t type_version = (uint32_t)CURRENT_OPERAND(); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - if (!PyStackRef_IsNull(null)) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + if (!PyStackRef_IsNull(null[0])) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - (void)null ; if (!PyType_Check(callable_o)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -4514,51 +4449,42 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(CALL, hit); - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - self = PyStackRef_FromPyObjectSteal(_PyType_NewManagedObject(tp)); + PyObject *self_o = _PyType_NewManagedObject(tp); stack_pointer = _PyFrame_GetStackPointer(frame); - if (PyStackRef_IsNull(self)) { + if (self_o == NULL) { JUMP_TO_ERROR(); } - PyStackRef_CLOSE(callable); - init = PyStackRef_FromPyObjectNew(init_func);/* Pushed outputs */ - stack_pointer[-1] = self; - stack_pointer[0] = init; - stack_pointer += 1 + oparg; - assert(WITHIN_STACK_BOUNDS()); + self[0] = PyStackRef_FromPyObjectSteal(self_o); + _PyStackRef temp = callable[0]; + init[0] = PyStackRef_FromPyObjectNew(init_func); + PyStackRef_CLOSE(temp); break; } case _CREATE_INIT_FRAME: { _PyStackRef *args; - _PyStackRef init; - _PyStackRef self; + _PyStackRef *self; + _PyStackRef *init; _PyInterpreterFrame *init_frame; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; - init = stack_pointer[-1 - oparg]; - self = stack_pointer[-2 - oparg]; - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); + self = &stack_pointer[-1 - oparg]; + init = &stack_pointer[-2 - oparg]; _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame); assert(_PyCode_CODE((PyCodeObject *)shim->f_executable)[0].op.code == EXIT_INIT_CHECK); stack_pointer = _PyFrame_GetStackPointer(frame); /* Push self onto stack of shim */ - shim->localsplus[0] = PyStackRef_DUP(self); - PyFunctionObject *init_func = (PyFunctionObject *)PyStackRef_AsPyObjectSteal(init); - args[-1] = self;(void)self ; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + shim->localsplus[0] = PyStackRef_DUP(self[0]); + PyFunctionObject *init_func = (PyFunctionObject *)PyStackRef_AsPyObjectSteal(init[0]);(void)init ;(void)self ; _PyFrame_SetStackPointer(frame, stack_pointer); init_frame = _PyEvalFramePushAndInit( tstate, init_func, NULL, args-1, oparg+1, NULL, shim); stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer[0].bits = (uintptr_t)init_frame; - stack_pointer += 1; + stack_pointer[-2 - oparg].bits = (uintptr_t)init_frame; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); if (init_frame == NULL) { _PyEval_FrameClearAndPop(tstate, shim); @@ -4568,7 +4494,7 @@ /* Account for pushing the extra frame. * We don't check recursion depth here, * as it will be checked after start_frame */ - tstate->py_recursion_remaining--;/* Pushed outputs */ + tstate->py_recursion_remaining--; break; } @@ -4583,7 +4509,7 @@ Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); - }(void)should_be_none ;/* Pushed outputs */ + }(void)should_be_none ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -4592,13 +4518,13 @@ case _CALL_BUILTIN_CLASS: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -4616,7 +4542,7 @@ STAT_INC(CALL, hit); STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(self_or_null[0]); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); @@ -4631,25 +4557,25 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); break; } case _CALL_BUILTIN_O: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; /* Builtin METH_O functions */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -4676,33 +4602,31 @@ PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o); _PyStackRef arg = args[0]; _Py_EnterRecursiveCallTstateUnchecked(tstate); - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg)); stack_pointer = _PyFrame_GetStackPointer(frame); _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(arg); - PyStackRef_CLOSE(callable); - stack_pointer += -1; + PyStackRef_CLOSE(arg);(void)args ;(void)self_or_null ; + PyStackRef_CLOSE(callable[0]); + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); break; } case _CALL_BUILTIN_FAST: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; /* Builtin METH_FASTCALL functions, without keywords */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -4721,7 +4645,7 @@ /* res = func(self, args, nargs) */ STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(self_or_null[0]); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); @@ -4740,25 +4664,25 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); break; } case _CALL_BUILTIN_FAST_WITH_KEYWORDS: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; /* Builtin METH_FASTCALL | METH_KEYWORDS functions */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -4779,7 +4703,7 @@ PyCFunction_GET_FUNCTION(callable_o); STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(self_or_null[0]); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); @@ -4794,26 +4718,26 @@ /* Free the arguments. */ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - } - PyStackRef_CLOSE(callable); + }(void)self_or_null ; + PyStackRef_CLOSE(callable[0]); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); break; } case _CALL_LEN: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; /* len(o) */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -4831,8 +4755,6 @@ STAT_INC(CALL, hit); _PyStackRef arg_stackref = args[0]; PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref); - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(arg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4846,23 +4768,23 @@ if (res_o == NULL) { GOTO_ERROR(error); } - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(arg_stackref); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); break; } case _CALL_ISINSTANCE: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; /* isinstance(o, o2) */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -4880,8 +4802,6 @@ STAT_INC(CALL, hit); _PyStackRef cls_stackref = args[1]; _PyStackRef inst_stackref = args[0]; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4892,7 +4812,7 @@ assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(inst_stackref); PyStackRef_CLOSE(cls_stackref); - PyStackRef_CLOSE(callable);/* Pushed outputs */ + PyStackRef_CLOSE(callable[0]); break; } @@ -4929,20 +4849,20 @@ // during trace projection in tier two: assert(next_instr->op.code == POP_TOP); SKIP_OVER(1); - #endif/* Pushed outputs */ + #endif break; } case _CALL_METHOD_DESCRIPTOR_O: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -4977,8 +4897,6 @@ STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; _Py_EnterRecursiveCallTstateUnchecked(tstate); - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyStackRef_AsPyObjectBorrow(self_stackref), @@ -4987,25 +4905,25 @@ _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); - PyStackRef_CLOSE(arg_stackref); - PyStackRef_CLOSE(callable); - stack_pointer += -1; + PyStackRef_CLOSE(arg_stackref);(void)args ;(void)self_or_null ; + PyStackRef_CLOSE(callable[0]); + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); break; } case _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -5033,7 +4951,7 @@ (PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth; STACKREFS_TO_PYOBJECTS(args, nargs, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(self_or_null[0]); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); @@ -5048,26 +4966,26 @@ /* Free the arguments. */ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - } - PyStackRef_CLOSE(callable); + }(void)self_or_null ; + PyStackRef_CLOSE(callable[0]); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); break; } case _CALL_METHOD_DESCRIPTOR_NOARGS: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; assert(oparg == 0 || oparg == 1); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -5101,32 +5019,30 @@ STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; _Py_EnterRecursiveCallTstateUnchecked(tstate); - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(self_stackref); - PyStackRef_CLOSE(callable); - stack_pointer += -1; + PyStackRef_CLOSE(self_stackref);(void)args ;(void)self_or_null ; + PyStackRef_CLOSE(callable[0]); + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); break; } case _CALL_METHOD_DESCRIPTOR_FAST: { _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef res; oparg = CURRENT_OPARG(); args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -5154,7 +5070,7 @@ int nargs = total_args - 1; STACKREFS_TO_PYOBJECTS(args, nargs, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(self_or_null[0]); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); @@ -5169,12 +5085,12 @@ /* Clear the stack of the arguments. */ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - } - PyStackRef_CLOSE(callable); + }(void)self_or_null ; + PyStackRef_CLOSE(callable[0]); stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); break; } @@ -5184,30 +5100,27 @@ _PyStackRef kwnames_in; _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; - _PyStackRef func; + _PyStackRef *callable; + _PyStackRef *func; _PyStackRef *maybe_self; _PyStackRef kwnames_out; oparg = CURRENT_OPARG(); - maybe_self = &stack_pointer[1]; kwnames_in = stack_pointer[-1]; args = &stack_pointer[-1 - oparg]; self_or_null = &stack_pointer[-2 - oparg]; - callable = stack_pointer[-3 - oparg]; - if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-3 - oparg]; + func = &stack_pointer[-3 - oparg]; + maybe_self = &stack_pointer[-2 - oparg]; + if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); PyObject *self = ((PyMethodObject *)callable_o)->im_self; maybe_self[0] = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; - func = PyStackRef_FromPyObjectNew(method); - PyStackRef_CLOSE(callable); + _PyStackRef temp = callable[0]; + func[0] = PyStackRef_FromPyObjectNew(method); + PyStackRef_CLOSE(temp); } - else { - func = callable;(void)callable ; - } - kwnames_out = kwnames_in;(void)kwnames_in ;/* Pushed outputs */ - stack_pointer[-3 - oparg] = func; - stack_pointer[-1] = kwnames_out; + kwnames_out = kwnames_in;(void)kwnames_in ; break; } @@ -5217,14 +5130,14 @@ _PyStackRef kwnames; _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyInterpreterFrame *new_frame; oparg = CURRENT_OPARG(); kwnames = stack_pointer[-1]; args = &stack_pointer[-1 - oparg]; self_or_null = &stack_pointer[-2 - oparg]; - callable = stack_pointer[-3 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-3 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); // oparg counts all of the args, but *not* self: int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -5238,7 +5151,7 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( - tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, + tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable[0]), locals, args, positional_args, kwnames_o, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5250,16 +5163,16 @@ assert(WITHIN_STACK_BOUNDS()); if (new_frame == NULL) { JUMP_TO_ERROR(); - }/* Pushed outputs */ + } break; } case _CHECK_FUNCTION_VERSION_KW: { - _PyStackRef callable; + _PyStackRef *callable; oparg = CURRENT_OPARG(); - callable = stack_pointer[-3 - oparg]; + callable = &stack_pointer[-3 - oparg]; uint32_t func_version = (uint32_t)CURRENT_OPERAND(); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); if (!PyFunction_Check(callable_o)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -5269,18 +5182,17 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } case _CHECK_METHOD_VERSION_KW: { _PyStackRef *null; - _PyStackRef callable; + _PyStackRef *callable; oparg = CURRENT_OPARG(); null = &stack_pointer[-2 - oparg]; - callable = stack_pointer[-3 - oparg]; + callable = &stack_pointer[-3 - oparg]; uint32_t func_version = (uint32_t)CURRENT_OPERAND(); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); if (Py_TYPE(callable_o) != &PyMethod_Type) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -5298,35 +5210,35 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } case _EXPAND_METHOD_KW: { _PyStackRef *null; - _PyStackRef callable; - _PyStackRef method; + _PyStackRef *callable; + _PyStackRef *method; _PyStackRef *self; oparg = CURRENT_OPARG(); - self = &stack_pointer[1]; null = &stack_pointer[-2 - oparg]; - callable = stack_pointer[-3 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-3 - oparg]; + method = &stack_pointer[-3 - oparg]; + self = &stack_pointer[-2 - oparg]; + _PyStackRef callable_s = callable[0]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable_s); assert(PyStackRef_IsNull(null[0])); assert(Py_TYPE(callable_o) == &PyMethod_Type); self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - assert(PyStackRef_FunctionCheck(method)); - PyStackRef_CLOSE(callable);/* Pushed outputs */ - stack_pointer[-3 - oparg] = method; + method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + assert(PyStackRef_FunctionCheck(method[0])); + PyStackRef_CLOSE(callable_s); break; } case _CHECK_IS_NOT_PY_CALLABLE_KW: { - _PyStackRef callable; + _PyStackRef *callable; oparg = CURRENT_OPARG(); - callable = stack_pointer[-3 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-3 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); if (PyFunction_Check(callable_o)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -5335,7 +5247,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -5343,17 +5254,17 @@ _PyStackRef kwnames; _PyStackRef *args; _PyStackRef *self_or_null; - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef res; oparg = CURRENT_OPARG(); kwnames = stack_pointer[-1]; args = &stack_pointer[-1 - oparg]; self_or_null = &stack_pointer[-2 - oparg]; - callable = stack_pointer[-3 - oparg]; + callable = &stack_pointer[-3 - oparg]; #if TIER_ONE assert(opcode != INSTRUMENTED_CALL); #endif - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -5362,7 +5273,7 @@ /* Callable is not a normal Python function */ STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(self_or_null[0]); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); @@ -5383,20 +5294,54 @@ PyStackRef_CLOSE(kwnames); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - } + }(void)self_or_null ; + PyStackRef_CLOSE(callable[0]); stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); break; } /* _INSTRUMENTED_CALL_FUNCTION_EX is not a viable micro-op for tier 2 because it is instrumented */ - /* __DO_CALL_FUNCTION_EX is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ + case _MAKE_CALLARGS_A_TUPLE: { + _PyStackRef kwargs_in = PyStackRef_NULL; + _PyStackRef callargs; + _PyStackRef func; + _PyStackRef tuple; + _PyStackRef kwargs_out = PyStackRef_NULL; + oparg = CURRENT_OPARG(); + if (oparg & 1) { kwargs_in = stack_pointer[-(oparg & 1)]; } + callargs = stack_pointer[-1 - (oparg & 1)]; + func = stack_pointer[-3 - (oparg & 1)]; + PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs); + if (PyTuple_CheckExact(callargs_o)) { + tuple = callargs;(void)callargs ; + } + else { + int err = check_args_iterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); + if (err < 0) { + JUMP_TO_ERROR(); + } + _PyFrame_SetStackPointer(frame, stack_pointer); + PyObject *tuple_o = PySequence_Tuple(callargs_o); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (tuple_o == NULL) { + JUMP_TO_ERROR(); + } + PyStackRef_CLOSE(callargs); + tuple = PyStackRef_FromPyObjectSteal(tuple_o); + } + kwargs_out = kwargs_in;(void)kwargs_in ; + stack_pointer[-1 - (oparg & 1)] = tuple; + if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_out; + break; + } + + /* _DO_CALL_FUNCTION_EX is not a viable micro-op for tier 2 because it uses the 'this_instr' variable */ case _MAKE_FUNCTION: { _PyStackRef codeobj_st; @@ -5415,7 +5360,7 @@ _PyFunction_SetVersion( func_obj, ((PyCodeObject *)codeobj)->co_version); stack_pointer = _PyFrame_GetStackPointer(frame); - func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj);/* Pushed outputs */ + func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj); stack_pointer[0] = func; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5437,7 +5382,7 @@ assert(offset != 0); PyObject **ptr = (PyObject **)(((char *)func) + offset); assert(*ptr == NULL); - *ptr = attr;/* Pushed outputs */ + *ptr = attr; stack_pointer[-2] = func_out; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -5467,7 +5412,7 @@ LOAD_IP(frame->return_offset); stack_pointer = _PyFrame_GetStackPointer(frame); res = PyStackRef_FromPyObjectSteal((PyObject *)gen); - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5493,7 +5438,7 @@ stack_pointer += -2 - ((oparg == 3) ? 1 : 0); assert(WITHIN_STACK_BOUNDS()); if (slice_o == NULL) JUMP_TO_ERROR(); - slice = PyStackRef_FromPyObjectSteal(slice_o);/* Pushed outputs */ + slice = PyStackRef_FromPyObjectSteal(slice_o); stack_pointer[0] = slice; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5513,7 +5458,7 @@ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); if (result_o == NULL) JUMP_TO_ERROR(); - result = PyStackRef_FromPyObjectSteal(result_o);/* Pushed outputs */ + result = PyStackRef_FromPyObjectSteal(result_o); stack_pointer[0] = result; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5537,7 +5482,7 @@ } else { res = value;(void)value ; - }/* Pushed outputs */ + } stack_pointer[-1] = res; break; } @@ -5556,7 +5501,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5569,7 +5514,7 @@ oparg = CURRENT_OPARG(); bottom = stack_pointer[-1 - (oparg-1)]; assert(oparg > 0); - top = PyStackRef_DUP(bottom);/* Pushed outputs */ + top = PyStackRef_DUP(bottom); stack_pointer[0] = top; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5592,7 +5537,7 @@ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5609,7 +5554,7 @@ bottom_in = stack_pointer[-2 - (oparg-2)]; bottom_out = bottom_in;(void)bottom_in ; top_out = top_in;(void)top_in ; - assert(oparg >= 2);/* Pushed outputs */ + assert(oparg >= 2); stack_pointer[-2 - (oparg-2)] = top_out; stack_pointer[-1] = bottom_out; break; @@ -5639,7 +5584,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -5653,7 +5597,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -5669,7 +5612,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - }(void)val ;/* Pushed outputs */ + }(void)val ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -5683,20 +5626,20 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - PyStackRef_CLOSE(val);/* Pushed outputs */ + PyStackRef_CLOSE(val); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } case _JUMP_TO_TOP: { - JUMP_TO_JUMP_TARGET();/* Pushed outputs */ + JUMP_TO_JUMP_TARGET(); break; } case _SET_IP: { PyObject *instr_ptr = (PyObject *)CURRENT_OPERAND(); - frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr;/* Pushed outputs */ + frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr; break; } @@ -5711,7 +5654,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -5722,7 +5664,7 @@ #endif #if TIER_TWO frame->return_offset = oparg; - #endif/* Pushed outputs */ + #endif break; } @@ -5782,7 +5724,7 @@ } Py_INCREF(exit->executor); tstate->previous_executor = (PyObject *)current_executor; - GOTO_TIER_TWO(exit->executor);/* Pushed outputs */ + GOTO_TIER_TWO(exit->executor); break; } @@ -5791,14 +5733,13 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } case _LOAD_CONST_INLINE: { _PyStackRef value; PyObject *ptr = (PyObject *)CURRENT_OPERAND(); - value = PyStackRef_FromPyObjectNew(ptr);/* Pushed outputs */ + value = PyStackRef_FromPyObjectNew(ptr); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5808,7 +5749,7 @@ case _LOAD_CONST_INLINE_BORROW: { _PyStackRef value; PyObject *ptr = (PyObject *)CURRENT_OPERAND(); - value = PyStackRef_FromPyObjectImmortal(ptr);/* Pushed outputs */ + value = PyStackRef_FromPyObjectImmortal(ptr); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5821,7 +5762,7 @@ pop = stack_pointer[-1]; PyObject *ptr = (PyObject *)CURRENT_OPERAND(); PyStackRef_CLOSE(pop); - value = PyStackRef_FromPyObjectImmortal(ptr);/* Pushed outputs */ + value = PyStackRef_FromPyObjectImmortal(ptr); stack_pointer[-1] = value; break; } @@ -5831,7 +5772,7 @@ _PyStackRef null; PyObject *ptr = (PyObject *)CURRENT_OPERAND(); value = PyStackRef_FromPyObjectNew(ptr); - null = PyStackRef_NULL;/* Pushed outputs */ + null = PyStackRef_NULL; stack_pointer[0] = value; stack_pointer[1] = null; stack_pointer += 2; @@ -5844,7 +5785,7 @@ _PyStackRef null; PyObject *ptr = (PyObject *)CURRENT_OPERAND(); value = PyStackRef_FromPyObjectImmortal(ptr); - null = PyStackRef_NULL;/* Pushed outputs */ + null = PyStackRef_NULL; stack_pointer[0] = value; stack_pointer[1] = null; stack_pointer += 2; @@ -5859,7 +5800,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - /* Pushed outputs */ break; } @@ -5867,7 +5807,7 @@ _PyStackRef opt; opt = stack_pointer[-1]; _PyCounterOptimizerObject *exe = (_PyCounterOptimizerObject *)PyStackRef_AsPyObjectBorrow(opt); - exe->count++;(void)opt ;/* Pushed outputs */ + exe->count++;(void)opt ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -5916,7 +5856,7 @@ exit->temperature = initial_temperature_backoff_counter(); } } - GOTO_TIER_TWO(executor);/* Pushed outputs */ + GOTO_TIER_TWO(executor); break; } @@ -5927,13 +5867,13 @@ #ifndef _Py_JIT current_executor = (_PyExecutorObject*)executor; #endif - assert(((_PyExecutorObject *)executor)->vm_data.valid);/* Pushed outputs */ + assert(((_PyExecutorObject *)executor)->vm_data.valid); break; } case _FATAL_ERROR: { assert(0); - Py_FatalError("Fatal error uop executed.");/* Pushed outputs */ + Py_FatalError("Fatal error uop executed."); break; } @@ -5943,12 +5883,12 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr;/* Pushed outputs */ + frame->instr_ptr = (_Py_CODEUNIT *)instr_ptr; break; } case _DEOPT: { - EXIT_TO_TIER1();/* Pushed outputs */ + EXIT_TO_TIER1(); break; } @@ -5956,16 +5896,9 @@ oparg = CURRENT_OPARG(); uint32_t target = (uint32_t)CURRENT_OPERAND(); frame->instr_ptr = ((_Py_CODEUNIT *)_PyFrame_GetCode(frame)->co_code_adaptive) + target; - { - stack_pointer -= oparg; - if (!WITHIN_STACK_BOUNDS()) { - printf("Stacke level: %d, oparg: %d\n", STACK_LEVEL(), oparg); - } - stack_pointer += oparg; - } stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); - GOTO_UNWIND();/* Pushed outputs */ + GOTO_UNWIND(); break; } @@ -5982,7 +5915,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - assert(tstate->tracing || eval_breaker == FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version));/* Pushed outputs */ + assert(tstate->tracing || eval_breaker == FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version)); break; } diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index d6b2b195273c7c..586c270d507b34 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -37,7 +37,7 @@ ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); #endif /* ENABLE_SPECIALIZATION */ assert(NB_ADD <= oparg); - assert(oparg <= NB_INPLACE_XOR);/* Pushed outputs */ + assert(oparg <= NB_INPLACE_XOR); } // _BINARY_OP { @@ -47,8 +47,8 @@ PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o); PyStackRef_CLOSE(lhs); PyStackRef_CLOSE(rhs); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + if (res_o == NULL) goto pop_2_error; + res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; stack_pointer += -1; @@ -72,7 +72,6 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyFloat_CheckExact(left_o), BINARY_OP); DEOPT_IF(!PyFloat_CheckExact(right_o), BINARY_OP); - /* Pushed outputs */ } /* Skip 1 cache entry */ // _BINARY_OP_ADD_FLOAT @@ -85,7 +84,7 @@ ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; stack_pointer += -1; @@ -109,7 +108,6 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyLong_CheckExact(left_o), BINARY_OP); DEOPT_IF(!PyLong_CheckExact(right_o), BINARY_OP); - /* Pushed outputs */ } /* Skip 1 cache entry */ // _BINARY_OP_ADD_INT @@ -120,8 +118,8 @@ PyObject *res_o = _PyLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + if (res_o == NULL) goto pop_2_error; + res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; stack_pointer += -1; @@ -145,7 +143,6 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyUnicode_CheckExact(left_o), BINARY_OP); DEOPT_IF(!PyUnicode_CheckExact(right_o), BINARY_OP); - /* Pushed outputs */ } /* Skip 1 cache entry */ // _BINARY_OP_ADD_UNICODE @@ -156,8 +153,8 @@ PyObject *res_o = PyUnicode_Concat(left_o, right_o); _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc); _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + if (res_o == NULL) goto pop_2_error; + res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; stack_pointer += -1; @@ -180,7 +177,6 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyUnicode_CheckExact(left_o), BINARY_OP); DEOPT_IF(!PyUnicode_CheckExact(right_o), BINARY_OP); - /* Pushed outputs */ } /* Skip 1 cache entry */ // _BINARY_OP_INPLACE_ADD_UNICODE @@ -214,13 +210,13 @@ PyUnicode_Append(&temp, right_o); *target_local = PyStackRef_FromPyObjectSteal(temp); _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);(void)right ; - if (PyStackRef_IsNull(*target_local)) goto error; + if (PyStackRef_IsNull(*target_local)) goto pop_2_error; #if TIER_ONE // The STORE_FAST is already done. This is done here in tier one, // and during trace projection in tier two: assert(next_instr->op.code == STORE_FAST); SKIP_OVER(1); - #endif/* Pushed outputs */ + #endif } stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -243,7 +239,6 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyFloat_CheckExact(left_o), BINARY_OP); DEOPT_IF(!PyFloat_CheckExact(right_o), BINARY_OP); - /* Pushed outputs */ } /* Skip 1 cache entry */ // _BINARY_OP_MULTIPLY_FLOAT @@ -256,7 +251,7 @@ ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; stack_pointer += -1; @@ -280,7 +275,6 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyLong_CheckExact(left_o), BINARY_OP); DEOPT_IF(!PyLong_CheckExact(right_o), BINARY_OP); - /* Pushed outputs */ } /* Skip 1 cache entry */ // _BINARY_OP_MULTIPLY_INT @@ -291,8 +285,8 @@ PyObject *res_o = _PyLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + if (res_o == NULL) goto pop_2_error; + res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; stack_pointer += -1; @@ -316,7 +310,6 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyFloat_CheckExact(left_o), BINARY_OP); DEOPT_IF(!PyFloat_CheckExact(right_o), BINARY_OP); - /* Pushed outputs */ } /* Skip 1 cache entry */ // _BINARY_OP_SUBTRACT_FLOAT @@ -329,7 +322,7 @@ ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; stack_pointer += -1; @@ -353,7 +346,6 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyLong_CheckExact(left_o), BINARY_OP); DEOPT_IF(!PyLong_CheckExact(right_o), BINARY_OP); - /* Pushed outputs */ } /* Skip 1 cache entry */ // _BINARY_OP_SUBTRACT_INT @@ -364,8 +356,8 @@ PyObject *res_o = _PyLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + if (res_o == NULL) goto pop_2_error; + res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; stack_pointer += -1; @@ -386,7 +378,7 @@ // Placeholder until we implement BINARY_SLICE specialization #if ENABLE_SPECIALIZATION OPCODE_DEFERRED_INC(BINARY_SLICE); - #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ + #endif /* ENABLE_SPECIALIZATION */ } // _BINARY_SLICE { @@ -413,8 +405,8 @@ assert(WITHIN_STACK_BOUNDS()); } PyStackRef_CLOSE(container); - if (res_o == NULL) goto pop_2_error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + if (res_o == NULL) goto pop_3_error; + res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-3] = res; stack_pointer += -2; @@ -449,7 +441,7 @@ } OPCODE_DEFERRED_INC(BINARY_SUBSCR); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ + #endif /* ENABLE_SPECIALIZATION */ } // _BINARY_SUBSCR { @@ -460,8 +452,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + if (res_o == NULL) goto pop_2_error; + res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-2] = res; stack_pointer += -1; @@ -495,9 +487,9 @@ } PyStackRef_CLOSE(dict_st); PyStackRef_CLOSE(sub_st); - if (rc <= 0) goto error; + if (rc <= 0) goto pop_2_error; // not found or error - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -516,7 +508,6 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, BINARY_SUBSCR); - /* Pushed outputs */ } // _BINARY_SUBSCR_CHECK_FUNC { @@ -533,7 +524,7 @@ assert(code->co_argcount == 2); DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), BINARY_SUBSCR); STAT_INC(BINARY_SUBSCR, hit); - Py_INCREF(getitem);/* Pushed outputs */ + Py_INCREF(getitem); } // _BINARY_SUBSCR_INIT_CALL { @@ -544,7 +535,7 @@ new_frame = _PyFrame_PushUnchecked(tstate, (PyFunctionObject *)getitem, 2, frame); new_frame->localsplus[0] = container; new_frame->localsplus[1] = sub; - frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_BINARY_SUBSCR);/* Pushed outputs */ + frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_BINARY_SUBSCR); } // _PUSH_FRAME { @@ -561,7 +552,7 @@ tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); } DISPATCH(); } @@ -591,7 +582,7 @@ Py_INCREF(res_o); _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; PyStackRef_CLOSE(list_st); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -623,7 +614,7 @@ PyObject *res_o = (PyObject*)&_Py_SINGLETON(strings).ascii[c]; _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; PyStackRef_CLOSE(str_st); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -655,7 +646,7 @@ Py_INCREF(res_o); _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; PyStackRef_CLOSE(tuple_st); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -670,8 +661,12 @@ _PyStackRef list; values = &stack_pointer[-oparg]; PyObject *list_o = _PyList_FromStackRefSteal(values, oparg); - if (list_o == NULL) goto error; - list = PyStackRef_FromPyObjectSteal(list_o);/* Pushed outputs */ + if (list_o == NULL) { + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } + list = PyStackRef_FromPyObjectSteal(list_o); stack_pointer[-oparg] = list; stack_pointer += 1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -690,10 +685,12 @@ for (int _i = oparg*2; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } - if (true) goto error; + if (true) { + stack_pointer += -oparg*2; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } - stack_pointer += -oparg*2; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *map_o = _PyDict_FromItems( values_o, 2, @@ -704,10 +701,14 @@ for (int _i = oparg*2; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } - if (map_o == NULL) goto error; - map = PyStackRef_FromPyObjectSteal(map_o);/* Pushed outputs */ - stack_pointer[0] = map; - stack_pointer += 1; + if (map_o == NULL) { + stack_pointer += -oparg*2; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } + map = PyStackRef_FromPyObjectSteal(map_o); + stack_pointer[-oparg*2] = map; + stack_pointer += 1 - oparg*2; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -719,8 +720,6 @@ _PyStackRef *values; _PyStackRef set; values = &stack_pointer[-oparg]; - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *set_o = PySet_New(NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -728,7 +727,11 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } - if (true) goto error; + if (true) { + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } int err = 0; for (int i = 0; i < oparg; i++) { @@ -738,14 +741,18 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(values[i]); - } + }(void)values ; if (err != 0) { Py_DECREF(set_o); - if (true) goto error; + if (true) { + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } - set = PyStackRef_FromPyObjectSteal(set_o);/* Pushed outputs */ - stack_pointer[0] = set; - stack_pointer += 1; + set = PyStackRef_FromPyObjectSteal(set_o); + stack_pointer[-oparg] = set; + stack_pointer += 1 - oparg; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -768,8 +775,12 @@ PyStackRef_CLOSE(start); PyStackRef_CLOSE(stop); PyStackRef_XCLOSE(step); - if (slice_o == NULL) goto error; - slice = PyStackRef_FromPyObjectSteal(slice_o);/* Pushed outputs */ + if (slice_o == NULL) { + stack_pointer += -2 - ((oparg == 3) ? 1 : 0); + assert(WITHIN_STACK_BOUNDS()); + goto error; + } + slice = PyStackRef_FromPyObjectSteal(slice_o); stack_pointer[-2 - ((oparg == 3) ? 1 : 0)] = slice; stack_pointer += -1 - ((oparg == 3) ? 1 : 0); assert(WITHIN_STACK_BOUNDS()); @@ -788,15 +799,23 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(pieces[_i]); } - if (true) goto error; + if (true) { + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } PyObject *str_o = _PyUnicode_JoinArray(&_Py_STR(empty), pieces_o, oparg); STACKREFS_TO_PYOBJECTS_CLEANUP(pieces_o); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(pieces[_i]); } - if (str_o == NULL) goto error; - str = PyStackRef_FromPyObjectSteal(str_o);/* Pushed outputs */ + if (str_o == NULL) { + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } + str = PyStackRef_FromPyObjectSteal(str_o); stack_pointer[-oparg] = str; stack_pointer += 1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -811,8 +830,12 @@ _PyStackRef tup; values = &stack_pointer[-oparg]; PyObject *tup_o = _PyTuple_FromStackRefSteal(values, oparg); - if (tup_o == NULL) goto error; - tup = PyStackRef_FromPyObjectSteal(tup_o);/* Pushed outputs */ + if (tup_o == NULL) { + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } + tup = PyStackRef_FromPyObjectSteal(tup_o); stack_pointer[-oparg] = tup; stack_pointer += 1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -824,7 +847,7 @@ next_instr += 1; INSTRUCTION_STATS(CACHE); assert(0 && "Executing a cache."); - Py_FatalError("Executing a cache.");/* Pushed outputs */ + Py_FatalError("Executing a cache."); DISPATCH(); } @@ -835,53 +858,52 @@ PREDICTED(CALL); _Py_CODEUNIT *this_instr = next_instr - 4; (void)this_instr; - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef *args; - _PyStackRef func; + _PyStackRef *func; _PyStackRef *maybe_self; _PyStackRef res; // _SPECIALIZE_CALL { self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); - _Py_Specialize_Call(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); + _Py_Specialize_Call(callable[0], next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(CALL); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ + #endif /* ENABLE_SPECIALIZATION */ } /* Skip 2 cache entries */ // _MAYBE_EXPAND_METHOD { - maybe_self = &stack_pointer[1]; args = &stack_pointer[-oparg]; - if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + func = &stack_pointer[-2 - oparg]; + maybe_self = &stack_pointer[-1 - oparg]; + if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); PyObject *self = ((PyMethodObject *)callable_o)->im_self; maybe_self[0] = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; - func = PyStackRef_FromPyObjectNew(method); - PyStackRef_CLOSE(callable);(void)self_or_null ; + _PyStackRef temp = callable[0]; + func[0] = PyStackRef_FromPyObjectNew(method); + PyStackRef_CLOSE(temp); } - else { - func = callable;(void)callable ;(void)self_or_null ; - }/* Pushed outputs */ } // _DO_CALL { args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = func; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); // oparg counts all of the args, but *not* self: int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -895,17 +917,14 @@ { 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)); - stack_pointer[-2 - oparg] = callable; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( - tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, + tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable[0]), locals, args, total_args, NULL, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); // Manipulate stack directly since we leave using DISPATCH_INLINED(). - stack_pointer += -1; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. @@ -918,15 +937,16 @@ /* Callable is not a normal Python function */ STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); + }(void)self_or_null ; + if (true) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; } - if (true) goto error; } - stack_pointer[-2 - oparg] = callable; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -958,26 +978,36 @@ } } assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); + }(void)self_or_null ; + if (res_o == NULL) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; } - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[-1] = res; + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - }/* Pushed outputs */ + stack_pointer += 1 + oparg; + assert(WITHIN_STACK_BOUNDS()); + } } - stack_pointer[-1] = res; + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -986,28 +1016,28 @@ next_instr += 4; INSTRUCTION_STATS(CALL_ALLOC_AND_ENTER_INIT); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef callable; - _PyStackRef null; + _PyStackRef *callable; + _PyStackRef *null; _PyStackRef *args; - _PyStackRef self; - _PyStackRef init; + _PyStackRef *init; + _PyStackRef *self; _PyInterpreterFrame *init_frame; _PyInterpreterFrame *new_frame; /* Skip 1 cache entry */ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, CALL); - /* Pushed outputs */ } // _CHECK_AND_ALLOCATE_OBJECT { args = &stack_pointer[-oparg]; - null = stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + null = &stack_pointer[-1 - oparg]; + callable = &stack_pointer[-2 - oparg]; + init = &stack_pointer[-2 - oparg]; + self = &stack_pointer[-1 - oparg]; uint32_t type_version = read_u32(&this_instr[2].cache); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); - DEOPT_IF(!PyStackRef_IsNull(null), CALL); - (void)null ; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); + DEOPT_IF(!PyStackRef_IsNull(null[0]), CALL); DEOPT_IF(!PyType_Check(callable_o), CALL); PyTypeObject *tp = (PyTypeObject *)callable_o; DEOPT_IF(tp->tp_version_tag != type_version, CALL); @@ -1017,41 +1047,36 @@ PyCodeObject *code = (PyCodeObject *)init_func->func_code; DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize + _Py_InitCleanup.co_framesize), CALL); STAT_INC(CALL, hit); - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - self = PyStackRef_FromPyObjectSteal(_PyType_NewManagedObject(tp)); + PyObject *self_o = _PyType_NewManagedObject(tp); stack_pointer = _PyFrame_GetStackPointer(frame); - if (PyStackRef_IsNull(self)) { + if (self_o == NULL) { goto error; } - PyStackRef_CLOSE(callable); - init = PyStackRef_FromPyObjectNew(init_func);/* Pushed outputs */ + self[0] = PyStackRef_FromPyObjectSteal(self_o); + _PyStackRef temp = callable[0]; + init[0] = PyStackRef_FromPyObjectNew(init_func); + PyStackRef_CLOSE(temp); } // _CREATE_INIT_FRAME { - args = &stack_pointer[1]; - stack_pointer[-1] = self; - stack_pointer[0] = init; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + args = &stack_pointer[-oparg]; + self = &stack_pointer[-1 - oparg]; + init = &stack_pointer[-2 - oparg]; _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame); assert(_PyCode_CODE((PyCodeObject *)shim->f_executable)[0].op.code == EXIT_INIT_CHECK); stack_pointer = _PyFrame_GetStackPointer(frame); /* Push self onto stack of shim */ - shim->localsplus[0] = PyStackRef_DUP(self); - PyFunctionObject *init_func = (PyFunctionObject *)PyStackRef_AsPyObjectSteal(init); - args[-1] = self;(void)self ; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + shim->localsplus[0] = PyStackRef_DUP(self[0]); + PyFunctionObject *init_func = (PyFunctionObject *)PyStackRef_AsPyObjectSteal(init[0]);(void)init ;(void)self ; _PyFrame_SetStackPointer(frame, stack_pointer); init_frame = _PyEvalFramePushAndInit( tstate, init_func, NULL, args-1, oparg+1, NULL, shim); stack_pointer = _PyFrame_GetStackPointer(frame); - stack_pointer[0].bits = (uintptr_t)init_frame; - stack_pointer += 1; + stack_pointer[-2 - oparg].bits = (uintptr_t)init_frame; + stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); if (init_frame == NULL) { _PyEval_FrameClearAndPop(tstate, shim); @@ -1061,7 +1086,7 @@ /* Account for pushing the extra frame. * We don't check recursion depth here, * as it will be checked after start_frame */ - tstate->py_recursion_remaining--;/* Pushed outputs */ + tstate->py_recursion_remaining--; } // _PUSH_FRAME { @@ -1079,7 +1104,7 @@ tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); } DISPATCH(); } @@ -1089,9 +1114,9 @@ next_instr += 4; INSTRUCTION_STATS(CALL_BOUND_METHOD_EXACT_ARGS); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *null; - _PyStackRef func; + _PyStackRef *func; _PyStackRef *self; _PyStackRef *self_or_null; _PyStackRef *args; @@ -1100,61 +1125,57 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, CALL); - /* Pushed outputs */ } // _CHECK_CALL_BOUND_METHOD_EXACT_ARGS { null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; DEOPT_IF(!PyStackRef_IsNull(null[0]), CALL); - DEOPT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(callable)) != &PyMethod_Type, CALL); - /* Pushed outputs */ + DEOPT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(callable[0])) != &PyMethod_Type, CALL); } // _INIT_CALL_BOUND_METHOD_EXACT_ARGS { - self = &stack_pointer[1]; + func = &stack_pointer[-2 - oparg]; + self = &stack_pointer[-1 - oparg]; (void)null ; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); STAT_INC(CALL, hit); self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - func = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - PyStackRef_CLOSE(callable);/* Pushed outputs */ + _PyStackRef temp = callable[0]; + func[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + PyStackRef_CLOSE(temp); } // flush - stack_pointer[-2 - oparg] = func; // _CHECK_FUNCTION_VERSION { - callable = func; + callable = &stack_pointer[-2 - oparg]; uint32_t func_version = read_u32(&this_instr[2].cache); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); DEOPT_IF(!PyFunction_Check(callable_o), CALL); PyFunctionObject *func = (PyFunctionObject *)callable_o; DEOPT_IF(func->func_version != func_version, CALL); - /* Pushed outputs */ } // _CHECK_FUNCTION_EXACT_ARGS { self_or_null = &stack_pointer[-1 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); assert(PyFunction_Check(callable_o)); PyFunctionObject *func = (PyFunctionObject *)callable_o; PyCodeObject *code = (PyCodeObject *)func->func_code; DEOPT_IF(code->co_argcount != oparg + (!PyStackRef_IsNull(self_or_null[0])), CALL); - /* Pushed outputs */ } // _CHECK_STACK_SPACE { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); PyFunctionObject *func = (PyFunctionObject *)callable_o; PyCodeObject *code = (PyCodeObject *)func->func_code; DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), CALL); DEOPT_IF(tstate->py_recursion_remaining <= 1, CALL); - /* Pushed outputs */ } // _INIT_CALL_PY_EXACT_ARGS { args = &stack_pointer[-oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int has_self = !PyStackRef_IsNull(self_or_null[0]); STAT_INC(CALL, hit); PyFunctionObject *func = (PyFunctionObject *)callable_o; @@ -1163,7 +1184,7 @@ new_frame->localsplus[0] = self_or_null[0]; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; - }/* Pushed outputs */ + } } // _SAVE_RETURN_OFFSET { @@ -1172,7 +1193,7 @@ #endif #if TIER_TWO frame->return_offset = oparg; - #endif/* Pushed outputs */ + #endif } // _PUSH_FRAME { @@ -1189,7 +1210,7 @@ tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); } DISPATCH(); } @@ -1199,9 +1220,9 @@ next_instr += 4; INSTRUCTION_STATS(CALL_BOUND_METHOD_GENERAL); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *null; - _PyStackRef method; + _PyStackRef *method; _PyStackRef *self; _PyStackRef *self_or_null; _PyStackRef *args; @@ -1210,40 +1231,39 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, CALL); - /* Pushed outputs */ } // _CHECK_METHOD_VERSION { null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; uint32_t func_version = read_u32(&this_instr[2].cache); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); DEOPT_IF(Py_TYPE(callable_o) != &PyMethod_Type, CALL); PyObject *func = ((PyMethodObject *)callable_o)->im_func; DEOPT_IF(!PyFunction_Check(func), CALL); DEOPT_IF(((PyFunctionObject *)func)->func_version != func_version, CALL); DEOPT_IF(!PyStackRef_IsNull(null[0]), CALL); - /* Pushed outputs */ } // _EXPAND_METHOD { - self = &stack_pointer[1]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + method = &stack_pointer[-2 - oparg]; + self = &stack_pointer[-1 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); assert(PyStackRef_IsNull(null[0]));(void)null ; assert(Py_TYPE(callable_o) == &PyMethod_Type); self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - assert(PyStackRef_FunctionCheck(method)); - PyStackRef_CLOSE(callable);/* Pushed outputs */ + _PyStackRef temp = callable[0]; + method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + assert(PyStackRef_FunctionCheck(method[0])); + PyStackRef_CLOSE(temp); } // flush - stack_pointer[-2 - oparg] = method; // _PY_FRAME_GENERAL { args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = method; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); // oparg counts all of the args, but *not* self: int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -1253,20 +1273,19 @@ 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)); - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - new_frame = _PyEvalFramePushAndInit( - tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, + _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( + tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable[0]), locals, args, total_args, NULL, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); - // The frame has stolen all the arguments from the stack, - // so there is no need to clean them up. - stack_pointer[-1].bits = (uintptr_t)new_frame; - if (new_frame == NULL) { + // The frame has stolen all the arguments from the stack. + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + if (temp == NULL) { goto error; - }/* Pushed outputs */ + } + new_frame = temp; } // _SAVE_RETURN_OFFSET { @@ -1275,7 +1294,7 @@ #endif #if TIER_TWO frame->return_offset = oparg; - #endif/* Pushed outputs */ + #endif } // _PUSH_FRAME { @@ -1283,8 +1302,6 @@ // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); _PyInterpreterFrame *temp = new_frame;(void)new_frame ; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); @@ -1292,7 +1309,7 @@ tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); } DISPATCH(); } @@ -1302,7 +1319,7 @@ next_instr += 4; INSTRUCTION_STATS(CALL_BUILTIN_CLASS); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef *args; _PyStackRef res; @@ -1312,8 +1329,8 @@ { args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -1325,12 +1342,16 @@ STAT_INC(CALL, hit); STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(self_or_null[0]); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) goto error; + if (true) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } PyObject *res_o = tp->tp_vectorcall((PyObject *)tp, args_o, total_args, NULL); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); @@ -1338,9 +1359,13 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + PyStackRef_CLOSE(callable[0]); + if (res_o == NULL) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } + res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC { @@ -1356,7 +1381,7 @@ if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); - }/* Pushed outputs */ + } } stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; @@ -1369,7 +1394,7 @@ next_instr += 4; INSTRUCTION_STATS(CALL_BUILTIN_FAST); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef *args; _PyStackRef res; @@ -1379,9 +1404,9 @@ { args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; /* Builtin METH_FASTCALL functions, without keywords */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -1394,12 +1419,16 @@ /* res = func(self, args, nargs) */ STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(self_or_null[0]); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) goto error; + if (true) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } PyObject *res_o = ((PyCFunctionFast)(void(*)(void))cfunc)( PyCFunction_GET_SELF(callable_o), @@ -1411,9 +1440,13 @@ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - PyStackRef_CLOSE(callable); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + PyStackRef_CLOSE(callable[0]); + if (res_o == NULL) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } + res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC { @@ -1429,7 +1462,7 @@ if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); - }/* Pushed outputs */ + } } stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; @@ -1442,7 +1475,7 @@ next_instr += 4; INSTRUCTION_STATS(CALL_BUILTIN_FAST_WITH_KEYWORDS); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef *args; _PyStackRef res; @@ -1452,9 +1485,9 @@ { args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; /* Builtin METH_FASTCALL | METH_KEYWORDS functions */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -1469,12 +1502,16 @@ PyCFunction_GET_FUNCTION(callable_o); STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(self_or_null[0]); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) goto error; + if (true) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } PyObject *res_o = cfunc(PyCFunction_GET_SELF(callable_o), args_o, total_args, NULL); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); @@ -1482,10 +1519,14 @@ /* Free the arguments. */ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); + }(void)self_or_null ; + PyStackRef_CLOSE(callable[0]); + if (res_o == NULL) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; } - PyStackRef_CLOSE(callable); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC { @@ -1501,7 +1542,7 @@ if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); - }/* Pushed outputs */ + } } stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; @@ -1514,7 +1555,7 @@ next_instr += 4; INSTRUCTION_STATS(CALL_BUILTIN_O); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef *args; _PyStackRef res; @@ -1524,9 +1565,9 @@ { args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; /* Builtin METH_O functions */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -1541,31 +1582,39 @@ PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o); _PyStackRef arg = args[0]; _Py_EnterRecursiveCallTstateUnchecked(tstate); - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg)); stack_pointer = _PyFrame_GetStackPointer(frame); _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(arg); - PyStackRef_CLOSE(callable); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + PyStackRef_CLOSE(arg);(void)args ;(void)self_or_null ; + PyStackRef_CLOSE(callable[0]); + if (res_o == NULL) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } + res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[-1] = res; + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - }/* Pushed outputs */ + stack_pointer += 1 + oparg; + assert(WITHIN_STACK_BOUNDS()); + } } - stack_pointer[-1] = res; + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -1576,49 +1625,60 @@ PREDICTED(CALL_FUNCTION_EX); _Py_CODEUNIT *this_instr = next_instr - 1; (void)this_instr; + _PyStackRef func; + _PyStackRef callargs; + _PyStackRef kwargs_in = PyStackRef_NULL; + _PyStackRef tuple; + _PyStackRef kwargs_out = PyStackRef_NULL; _PyStackRef func_st; _PyStackRef callargs_st; _PyStackRef kwargs_st = PyStackRef_NULL; _PyStackRef result; - // __DO_CALL_FUNCTION_EX - { - if (oparg & 1) { kwargs_st = stack_pointer[-(oparg & 1)]; } - callargs_st = stack_pointer[-1 - (oparg & 1)]; - func_st = stack_pointer[-3 - (oparg & 1)]; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); - PyObject *callargs = PyStackRef_AsPyObjectBorrow(callargs_st); - PyObject *kwargs = PyStackRef_AsPyObjectSteal(kwargs_st); - // DICT_MERGE is called before this opcode if there are kwargs. - // It converts all dict subtypes in kwargs into regular dicts. - assert(kwargs == NULL || PyDict_CheckExact(kwargs)); - if (!PyTuple_CheckExact(callargs)) { - int err = check_args_iterable(tstate, func, callargs); + // _MAKE_CALLARGS_A_TUPLE + { + if (oparg & 1) { kwargs_in = stack_pointer[-(oparg & 1)]; } + callargs = stack_pointer[-1 - (oparg & 1)]; + func = stack_pointer[-3 - (oparg & 1)]; + PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs); + if (PyTuple_CheckExact(callargs_o)) { + tuple = callargs;(void)callargs ; + } + else { + int err = check_args_iterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); if (err < 0) { goto error; } - stack_pointer += -(oparg & 1); - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *tuple = PySequence_Tuple(callargs); + PyObject *tuple_o = PySequence_Tuple(callargs_o); stack_pointer = _PyFrame_GetStackPointer(frame); - if (tuple == NULL) { + if (tuple_o == NULL) { goto error; } - PyStackRef_CLOSE(callargs_st); - callargs = tuple; - } - else { - callargs = PyStackRef_AsPyObjectSteal(callargs_st);stack_pointer += -(oparg & 1); - assert(WITHIN_STACK_BOUNDS()); + PyStackRef_CLOSE(callargs); + tuple = PyStackRef_FromPyObjectSteal(tuple_o); } + kwargs_out = kwargs_in;(void)kwargs_in ; + } + // _DO_CALL_FUNCTION_EX + { + kwargs_st = kwargs_out; + callargs_st = tuple; + func_st = func; + PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); + PyObject *callargs = PyStackRef_AsPyObjectBorrow(callargs_st); + PyObject *kwargs = PyStackRef_AsPyObjectBorrow(kwargs_st); + // DICT_MERGE is called before this opcode if there are kwargs. + // It converts all dict subtypes in kwargs into regular dicts. + assert(kwargs == NULL || PyDict_CheckExact(kwargs)); assert(PyTuple_CheckExact(callargs)); EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_FUNCTION_EX, func); PyObject *result_o; + assert(!_PyErr_Occurred(tstate)); if (opcode == INSTRUMENTED_CALL_FUNCTION_EX) { PyObject *arg = PyTuple_GET_SIZE(callargs) > 0 ? PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1 - (oparg & 1)] = callargs_st; + if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_st; _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, @@ -1631,7 +1691,7 @@ result_o = PyObject_Call(func, callargs, kwargs); stack_pointer = _PyFrame_GetStackPointer(frame); if (!PyFunction_Check(func) && !PyMethod_Check(func)) { - if (PyStackRef_IsNull(result)) { + if (result_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, @@ -1660,15 +1720,15 @@ Py_ssize_t nargs = PyTuple_GET_SIZE(callargs); int code_flags = ((PyCodeObject *)PyFunction_GET_CODE(func))->co_flags; PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func)); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1 - (oparg & 1)] = callargs_st; + if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_st; _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(func_st), locals, nargs, callargs, kwargs, frame); stack_pointer = _PyFrame_GetStackPointer(frame); // Need to sync the stack since we exit with DISPATCH_INLINED. - stack_pointer += -1; + stack_pointer += -3 - (oparg & 1); assert(WITHIN_STACK_BOUNDS()); if (new_frame == NULL) { goto error; @@ -1677,35 +1737,44 @@ frame->return_offset = 1; DISPATCH_INLINED(new_frame); } - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1 - (oparg & 1)] = callargs_st; + if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_st; _PyFrame_SetStackPointer(frame, stack_pointer); result_o = PyObject_Call(func, callargs, kwargs); stack_pointer = _PyFrame_GetStackPointer(frame); } - Py_DECREF(callargs); + _PyFrame_SetStackPointer(frame, stack_pointer); + PyStackRef_XCLOSE(kwargs_st); + stack_pointer = _PyFrame_GetStackPointer(frame); + (void)kwargs_st ; + PyStackRef_CLOSE(callargs_st); PyStackRef_CLOSE(func_st); - Py_XDECREF(kwargs); - result = PyStackRef_FromPyObjectSteal(result_o); - if (PyStackRef_IsNull(result)) { - stack_pointer[-1] = result; + if (result_o == NULL) { + stack_pointer += -3 - (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); goto error; } - /* Pushed outputs */ + result = PyStackRef_FromPyObjectSteal(result_o); } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[-1] = result; + stack_pointer[-3 - (oparg & 1)] = result; + stack_pointer += -2 - (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - }/* Pushed outputs */ + stack_pointer += 2 + (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); + } } - stack_pointer[-1] = result; + stack_pointer[-3 - (oparg & 1)] = result; + stack_pointer += -2 - (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -1719,8 +1788,8 @@ assert(oparg <= MAX_INTRINSIC_1); PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value)); PyStackRef_CLOSE(value); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + if (res_o == NULL) goto pop_1_error; + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-1] = res; DISPATCH(); } @@ -1740,8 +1809,8 @@ PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1); PyStackRef_CLOSE(value2_st); PyStackRef_CLOSE(value1_st); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + if (res_o == NULL) goto pop_2_error; + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1753,7 +1822,7 @@ next_instr += 4; INSTRUCTION_STATS(CALL_ISINSTANCE); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef *args; _PyStackRef res; @@ -1761,9 +1830,9 @@ /* Skip 2 cache entries */ args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; /* isinstance(o, o2) */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -1775,8 +1844,6 @@ STAT_INC(CALL, hit); _PyStackRef cls_stackref = args[1]; _PyStackRef inst_stackref = args[0]; - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1787,8 +1854,10 @@ assert((!PyStackRef_IsNull(res)) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(inst_stackref); PyStackRef_CLOSE(cls_stackref); - PyStackRef_CLOSE(callable);/* Pushed outputs */ - stack_pointer[-1] = res; + PyStackRef_CLOSE(callable[0]); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -1799,59 +1868,58 @@ PREDICTED(CALL_KW); _Py_CODEUNIT *this_instr = next_instr - 4; (void)this_instr; - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef *args; _PyStackRef kwnames; _PyStackRef kwnames_in; - _PyStackRef func; + _PyStackRef *func; _PyStackRef *maybe_self; _PyStackRef kwnames_out; _PyStackRef res; // _SPECIALIZE_CALL_KW { self_or_null = &stack_pointer[-2 - oparg]; - callable = stack_pointer[-3 - oparg]; + callable = &stack_pointer[-3 - oparg]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); - _Py_Specialize_CallKw(callable, next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); + _Py_Specialize_CallKw(callable[0], next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH_SAME_OPARG(); } OPCODE_DEFERRED_INC(CALL_KW); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ + #endif /* ENABLE_SPECIALIZATION */ } /* Skip 2 cache entries */ // _MAYBE_EXPAND_METHOD_KW { - maybe_self = &stack_pointer[1]; kwnames_in = stack_pointer[-1]; args = &stack_pointer[-1 - oparg]; - if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + func = &stack_pointer[-3 - oparg]; + maybe_self = &stack_pointer[-2 - oparg]; + if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); PyObject *self = ((PyMethodObject *)callable_o)->im_self; maybe_self[0] = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; - func = PyStackRef_FromPyObjectNew(method); - PyStackRef_CLOSE(callable); - } - else { - func = callable;(void)callable ; + _PyStackRef temp = callable[0]; + func[0] = PyStackRef_FromPyObjectNew(method); + PyStackRef_CLOSE(temp); } - kwnames_out = kwnames_in;(void)kwnames_in ;/* Pushed outputs */ + kwnames_out = kwnames_in;(void)kwnames_in ; } // _DO_CALL_KW { kwnames = kwnames_out; args = &stack_pointer[-1 - oparg]; self_or_null = &stack_pointer[-2 - oparg]; - callable = func; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-3 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); // oparg counts all of the args, but *not* self: int total_args = oparg; @@ -1867,11 +1935,10 @@ { 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)); - stack_pointer[-3 - oparg] = callable; stack_pointer[-1] = kwnames; _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( - tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, + tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable[0]), locals, args, positional_args, kwnames_o, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1891,15 +1958,18 @@ /* Callable is not a normal Python function */ STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(self_or_null[0]); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } PyStackRef_CLOSE(kwnames); - if (true) goto error; + if (true) { + stack_pointer += -3 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } - stack_pointer[-3 - oparg] = callable; stack_pointer[-1] = kwnames; _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( @@ -1933,12 +2003,16 @@ } PyStackRef_CLOSE(kwnames); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); + }(void)self_or_null ; + if (res_o == NULL) { + stack_pointer += -3 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; } - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[-3 - oparg] = res; stack_pointer += -2 - oparg; @@ -1951,10 +2025,10 @@ next_instr += 4; INSTRUCTION_STATS(CALL_KW_BOUND_METHOD); static_assert(INLINE_CACHE_ENTRIES_CALL_KW == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *null; _PyStackRef kwnames; - _PyStackRef method; + _PyStackRef *method; _PyStackRef *self; _PyStackRef *self_or_null; _PyStackRef *args; @@ -1963,41 +2037,40 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, CALL_KW); - /* Pushed outputs */ } // _CHECK_METHOD_VERSION_KW { null = &stack_pointer[-2 - oparg]; - callable = stack_pointer[-3 - oparg]; + callable = &stack_pointer[-3 - oparg]; uint32_t func_version = read_u32(&this_instr[2].cache); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); DEOPT_IF(Py_TYPE(callable_o) != &PyMethod_Type, CALL_KW); PyObject *func = ((PyMethodObject *)callable_o)->im_func; DEOPT_IF(!PyFunction_Check(func), CALL_KW); DEOPT_IF(((PyFunctionObject *)func)->func_version != func_version, CALL_KW); DEOPT_IF(!PyStackRef_IsNull(null[0]), CALL_KW); - /* Pushed outputs */ } // _EXPAND_METHOD_KW { - self = &stack_pointer[1]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + method = &stack_pointer[-3 - oparg]; + self = &stack_pointer[-2 - oparg]; + _PyStackRef callable_s = callable[0]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable_s); assert(PyStackRef_IsNull(null[0])); assert(Py_TYPE(callable_o) == &PyMethod_Type); self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); - method = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); - assert(PyStackRef_FunctionCheck(method)); - PyStackRef_CLOSE(callable);/* Pushed outputs */ + method[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_func); + assert(PyStackRef_FunctionCheck(method[0])); + PyStackRef_CLOSE(callable_s); } // flush - stack_pointer[-3 - oparg] = method; // _PY_FRAME_KW { kwnames = stack_pointer[-1]; args = &stack_pointer[-1 - oparg]; self_or_null = &stack_pointer[-2 - oparg]; - callable = method; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-3 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); // oparg counts all of the args, but *not* self: int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -2011,7 +2084,7 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( - tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, + tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable[0]), locals, args, positional_args, kwnames_o, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2023,7 +2096,7 @@ assert(WITHIN_STACK_BOUNDS()); if (new_frame == NULL) { goto error; - }/* Pushed outputs */ + } } // _SAVE_RETURN_OFFSET { @@ -2032,7 +2105,7 @@ #endif #if TIER_TWO frame->return_offset = oparg; - #endif/* Pushed outputs */ + #endif } // _PUSH_FRAME { @@ -2049,7 +2122,7 @@ tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); } DISPATCH(); } @@ -2059,7 +2132,7 @@ next_instr += 4; INSTRUCTION_STATS(CALL_KW_NON_PY); static_assert(INLINE_CACHE_ENTRIES_CALL_KW == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef kwnames; _PyStackRef *self_or_null; _PyStackRef *args; @@ -2068,11 +2141,10 @@ /* Skip 2 cache entries */ // _CHECK_IS_NOT_PY_CALLABLE_KW { - callable = stack_pointer[-3 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-3 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); DEOPT_IF(PyFunction_Check(callable_o), CALL_KW); DEOPT_IF(Py_TYPE(callable_o) == &PyMethod_Type, CALL_KW); - /* Pushed outputs */ } // _CALL_KW_NON_PY { @@ -2082,7 +2154,7 @@ #if TIER_ONE assert(opcode != INSTRUMENTED_CALL); #endif - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -2091,13 +2163,17 @@ /* Callable is not a normal Python function */ STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(self_or_null[0]); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } PyStackRef_CLOSE(kwnames); - if (true) goto error; + if (true) { + stack_pointer += -3 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); @@ -2110,12 +2186,16 @@ PyStackRef_CLOSE(kwnames); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(callable); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); + }(void)self_or_null ; + PyStackRef_CLOSE(callable[0]); + if (res_o == NULL) { + stack_pointer += -3 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; } - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC { @@ -2131,7 +2211,7 @@ if (err != 0) goto error; stack_pointer += 2 + oparg; assert(WITHIN_STACK_BOUNDS()); - }/* Pushed outputs */ + } } stack_pointer[-3 - oparg] = res; stack_pointer += -2 - oparg; @@ -2144,7 +2224,7 @@ next_instr += 4; INSTRUCTION_STATS(CALL_KW_PY); static_assert(INLINE_CACHE_ENTRIES_CALL_KW == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef kwnames; _PyStackRef *args; @@ -2153,24 +2233,22 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, CALL_KW); - /* Pushed outputs */ } // _CHECK_FUNCTION_VERSION_KW { - callable = stack_pointer[-3 - oparg]; + callable = &stack_pointer[-3 - oparg]; uint32_t func_version = read_u32(&this_instr[2].cache); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); DEOPT_IF(!PyFunction_Check(callable_o), CALL_KW); PyFunctionObject *func = (PyFunctionObject *)callable_o; DEOPT_IF(func->func_version != func_version, CALL_KW); - /* Pushed outputs */ } // _PY_FRAME_KW { kwnames = stack_pointer[-1]; args = &stack_pointer[-1 - oparg]; self_or_null = &stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); // oparg counts all of the args, but *not* self: int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -2184,7 +2262,7 @@ PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( - tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, + tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable[0]), locals, args, positional_args, kwnames_o, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2196,7 +2274,7 @@ assert(WITHIN_STACK_BOUNDS()); if (new_frame == NULL) { goto error; - }/* Pushed outputs */ + } } // _SAVE_RETURN_OFFSET { @@ -2205,7 +2283,7 @@ #endif #if TIER_TWO frame->return_offset = oparg; - #endif/* Pushed outputs */ + #endif } // _PUSH_FRAME { @@ -2222,7 +2300,7 @@ tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); } DISPATCH(); } @@ -2232,7 +2310,7 @@ next_instr += 4; INSTRUCTION_STATS(CALL_LEN); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef *args; _PyStackRef res; @@ -2240,9 +2318,9 @@ /* Skip 2 cache entries */ args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; /* len(o) */ - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -2254,8 +2332,6 @@ STAT_INC(CALL, hit); _PyStackRef arg_stackref = args[0]; PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref); - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(arg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2269,10 +2345,12 @@ if (res_o == NULL) { GOTO_ERROR(error); } - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(arg_stackref); - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ - stack_pointer[-1] = res; + res = PyStackRef_FromPyObjectSteal(res_o); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -2300,13 +2378,13 @@ int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg)); PyStackRef_CLOSE(self); PyStackRef_CLOSE(callable); - if (err) goto error; + if (err) goto pop_3_error; #if TIER_ONE // Skip the following POP_TOP. This is done here in tier one, and // during trace projection in tier two: assert(next_instr->op.code == POP_TOP); SKIP_OVER(1); - #endif/* Pushed outputs */ + #endif stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -2317,7 +2395,7 @@ next_instr += 4; INSTRUCTION_STATS(CALL_METHOD_DESCRIPTOR_FAST); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef *args; _PyStackRef res; @@ -2327,8 +2405,8 @@ { args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -2347,12 +2425,16 @@ int nargs = total_args - 1; STACKREFS_TO_PYOBJECTS(args, nargs, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(self_or_null[0]); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) goto error; + if (true) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } PyObject *res_o = cfunc(self, (args_o + 1), nargs); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); @@ -2360,10 +2442,14 @@ /* Clear the stack of the arguments. */ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); + }(void)self_or_null ; + PyStackRef_CLOSE(callable[0]); + if (res_o == NULL) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; } - PyStackRef_CLOSE(callable); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC { @@ -2379,7 +2465,7 @@ if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); - }/* Pushed outputs */ + } } stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; @@ -2392,7 +2478,7 @@ next_instr += 4; INSTRUCTION_STATS(CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef *args; _PyStackRef res; @@ -2402,8 +2488,8 @@ { args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -2422,12 +2508,16 @@ (PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth; STACKREFS_TO_PYOBJECTS(args, nargs, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(self_or_null[0]); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) goto error; + if (true) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } PyObject *res_o = cfunc(self, (args_o + 1), nargs, NULL); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); @@ -2435,10 +2525,14 @@ /* Free the arguments. */ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); + }(void)self_or_null ; + PyStackRef_CLOSE(callable[0]); + if (res_o == NULL) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; } - PyStackRef_CLOSE(callable); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC { @@ -2454,7 +2548,7 @@ if (err != 0) goto error; stack_pointer += 1 + oparg; assert(WITHIN_STACK_BOUNDS()); - }/* Pushed outputs */ + } } stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; @@ -2467,7 +2561,7 @@ next_instr += 4; INSTRUCTION_STATS(CALL_METHOD_DESCRIPTOR_NOARGS); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef *args; _PyStackRef res; @@ -2477,9 +2571,9 @@ { args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; assert(oparg == 0 || oparg == 1); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -2498,31 +2592,39 @@ STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; _Py_EnterRecursiveCallTstateUnchecked(tstate); - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(self_stackref); - PyStackRef_CLOSE(callable); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + PyStackRef_CLOSE(self_stackref);(void)args ;(void)self_or_null ; + PyStackRef_CLOSE(callable[0]); + if (res_o == NULL) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } + res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[-1] = res; + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - }/* Pushed outputs */ + stack_pointer += 1 + oparg; + assert(WITHIN_STACK_BOUNDS()); + } } - stack_pointer[-1] = res; + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -2531,7 +2633,7 @@ next_instr += 4; INSTRUCTION_STATS(CALL_METHOD_DESCRIPTOR_O); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef *args; _PyStackRef res; @@ -2541,8 +2643,8 @@ { args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -2562,8 +2664,6 @@ STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; _Py_EnterRecursiveCallTstateUnchecked(tstate); - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyStackRef_AsPyObjectBorrow(self_stackref), @@ -2572,24 +2672,34 @@ _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); - PyStackRef_CLOSE(arg_stackref); - PyStackRef_CLOSE(callable); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + PyStackRef_CLOSE(arg_stackref);(void)args ;(void)self_or_null ; + PyStackRef_CLOSE(callable[0]); + if (res_o == NULL) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } + res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[-1] = res; + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - }/* Pushed outputs */ + stack_pointer += 1 + oparg; + assert(WITHIN_STACK_BOUNDS()); + } } - stack_pointer[-1] = res; + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -2598,7 +2708,7 @@ next_instr += 4; INSTRUCTION_STATS(CALL_NON_PY_GENERAL); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef *args; _PyStackRef res; @@ -2606,11 +2716,10 @@ /* Skip 2 cache entries */ // _CHECK_IS_NOT_PY_CALLABLE { - callable = stack_pointer[-2 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); DEOPT_IF(PyFunction_Check(callable_o), CALL); DEOPT_IF(Py_TYPE(callable_o) == &PyMethod_Type, CALL); - /* Pushed outputs */ } // _CALL_NON_PY_GENERAL { @@ -2619,7 +2728,7 @@ #if TIER_ONE assert(opcode != INSTRUMENTED_CALL); #endif - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { args--; @@ -2628,15 +2737,17 @@ /* Callable is not a normal Python function */ STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(self_or_null[0]); for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - if (true) goto error; + if (true) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } } - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -2645,26 +2756,36 @@ stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); + }(void)self_or_null ; + if (res_o == NULL) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; } - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[-1] = res; + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - }/* Pushed outputs */ + stack_pointer += 1 + oparg; + assert(WITHIN_STACK_BOUNDS()); + } } - stack_pointer[-1] = res; + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -2673,7 +2794,7 @@ next_instr += 4; INSTRUCTION_STATS(CALL_PY_EXACT_ARGS); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef *args; _PyInterpreterFrame *new_frame; @@ -2681,41 +2802,37 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, CALL); - /* Pushed outputs */ } // _CHECK_FUNCTION_VERSION { - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; uint32_t func_version = read_u32(&this_instr[2].cache); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); DEOPT_IF(!PyFunction_Check(callable_o), CALL); PyFunctionObject *func = (PyFunctionObject *)callable_o; DEOPT_IF(func->func_version != func_version, CALL); - /* Pushed outputs */ } // _CHECK_FUNCTION_EXACT_ARGS { self_or_null = &stack_pointer[-1 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); assert(PyFunction_Check(callable_o)); PyFunctionObject *func = (PyFunctionObject *)callable_o; PyCodeObject *code = (PyCodeObject *)func->func_code; DEOPT_IF(code->co_argcount != oparg + (!PyStackRef_IsNull(self_or_null[0])), CALL); - /* Pushed outputs */ } // _CHECK_STACK_SPACE { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); PyFunctionObject *func = (PyFunctionObject *)callable_o; PyCodeObject *code = (PyCodeObject *)func->func_code; DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize), CALL); DEOPT_IF(tstate->py_recursion_remaining <= 1, CALL); - /* Pushed outputs */ } // _INIT_CALL_PY_EXACT_ARGS { args = &stack_pointer[-oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); int has_self = !PyStackRef_IsNull(self_or_null[0]); STAT_INC(CALL, hit); PyFunctionObject *func = (PyFunctionObject *)callable_o; @@ -2724,7 +2841,7 @@ new_frame->localsplus[0] = self_or_null[0]; for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; - }/* Pushed outputs */ + } } // _SAVE_RETURN_OFFSET { @@ -2733,7 +2850,7 @@ #endif #if TIER_TWO frame->return_offset = oparg; - #endif/* Pushed outputs */ + #endif } // _PUSH_FRAME { @@ -2750,7 +2867,7 @@ tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); } DISPATCH(); } @@ -2760,7 +2877,7 @@ next_instr += 4; INSTRUCTION_STATS(CALL_PY_GENERAL); static_assert(INLINE_CACHE_ENTRIES_CALL == 3, "incorrect cache size"); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef *args; _PyInterpreterFrame *new_frame; @@ -2768,23 +2885,21 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, CALL); - /* Pushed outputs */ } // _CHECK_FUNCTION_VERSION { - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; uint32_t func_version = read_u32(&this_instr[2].cache); - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); DEOPT_IF(!PyFunction_Check(callable_o), CALL); PyFunctionObject *func = (PyFunctionObject *)callable_o; DEOPT_IF(func->func_version != func_version, CALL); - /* Pushed outputs */ } // _PY_FRAME_GENERAL { args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); // oparg counts all of the args, but *not* self: int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -2794,20 +2909,19 @@ 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)); - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - new_frame = _PyEvalFramePushAndInit( - tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, + _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( + tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable[0]), locals, args, total_args, NULL, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); - // The frame has stolen all the arguments from the stack, - // so there is no need to clean them up. - stack_pointer[-1].bits = (uintptr_t)new_frame; - if (new_frame == NULL) { + // The frame has stolen all the arguments from the stack. + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + if (temp == NULL) { goto error; - }/* Pushed outputs */ + } + new_frame = temp; } // _SAVE_RETURN_OFFSET { @@ -2816,7 +2930,7 @@ #endif #if TIER_TWO frame->return_offset = oparg; - #endif/* Pushed outputs */ + #endif } // _PUSH_FRAME { @@ -2824,8 +2938,6 @@ // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); _PyInterpreterFrame *temp = new_frame;(void)new_frame ; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); @@ -2833,7 +2945,7 @@ tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); } DISPATCH(); } @@ -2865,13 +2977,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); (void)null ;(void)callable ; PyStackRef_CLOSE(arg); - if (PyStackRef_IsNull(res)) { - stack_pointer[-3] = res; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - /* Pushed outputs */ + if (PyStackRef_IsNull(res)) goto pop_3_error; } // _CHECK_PERIODIC { @@ -2887,7 +2993,7 @@ if (err != 0) goto error; stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); - }/* Pushed outputs */ + } } stack_pointer[-3] = res; stack_pointer += -2; @@ -2922,13 +3028,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); (void)null ;(void)callable ; PyStackRef_CLOSE(arg); - if (PyStackRef_IsNull(res)) { - stack_pointer[-3] = res; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - /* Pushed outputs */ + if (PyStackRef_IsNull(res)) goto pop_3_error; } // _CHECK_PERIODIC { @@ -2944,7 +3044,7 @@ if (err != 0) goto error; stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); - }/* Pushed outputs */ + } } stack_pointer[-3] = res; stack_pointer += -2; @@ -2975,7 +3075,7 @@ (void)callable ; STAT_INC(CALL, hit); res = PyStackRef_FromPyObjectSteal(Py_NewRef(Py_TYPE(arg_o))); - PyStackRef_CLOSE(arg);/* Pushed outputs */ + PyStackRef_CLOSE(arg); stack_pointer[-3] = res; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -3000,7 +3100,7 @@ if (err < 0) { PyStackRef_CLOSE(exc_value_st); PyStackRef_CLOSE(match_type_st); - if (true) goto error; + if (true) goto pop_2_error; } PyObject *match_o = NULL; PyObject *rest_o = NULL; @@ -3010,9 +3110,9 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(exc_value_st); PyStackRef_CLOSE(match_type_st); - if (res < 0) goto error; + if (res < 0) goto pop_2_error; assert((match_o == NULL) == (rest_o == NULL)); - if (match_o == NULL) goto error; + if (match_o == NULL) goto pop_2_error; if (!Py_IsNone(match_o)) { stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -3023,7 +3123,7 @@ assert(WITHIN_STACK_BOUNDS()); } rest = PyStackRef_FromPyObjectSteal(rest_o); - match = PyStackRef_FromPyObjectSteal(match_o);/* Pushed outputs */ + match = PyStackRef_FromPyObjectSteal(match_o); stack_pointer[-2] = rest; stack_pointer[-1] = match; DISPATCH(); @@ -3046,13 +3146,13 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { PyStackRef_CLOSE(right); - if (true) goto error; + if (true) goto pop_1_error; } _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyErr_GivenExceptionMatches(left_o, right_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(right); - b = res ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + b = res ? PyStackRef_True : PyStackRef_False; stack_pointer[-1] = b; DISPATCH(); } @@ -3089,7 +3189,7 @@ monitor_reraise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; - }/* Pushed outputs */ + } stack_pointer[-3] = none; stack_pointer[-2] = value; stack_pointer += -1; @@ -3123,7 +3223,7 @@ } OPCODE_DEFERRED_INC(COMPARE_OP); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ + #endif /* ENABLE_SPECIALIZATION */ } // _COMPARE_OP { @@ -3135,7 +3235,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - if (res_o == NULL) goto error; + if (res_o == NULL) goto pop_2_error; if (oparg & 16) { stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -3149,7 +3249,7 @@ else { res = PyStackRef_FromPyObjectSteal(res_o);stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); - }/* Pushed outputs */ + } } stack_pointer[0] = res; stack_pointer += 1; @@ -3173,7 +3273,6 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyFloat_CheckExact(left_o), COMPARE_OP); DEOPT_IF(!PyFloat_CheckExact(right_o), COMPARE_OP); - /* Pushed outputs */ } /* Skip 1 cache entry */ // _COMPARE_OP_FLOAT @@ -3188,7 +3287,7 @@ _Py_DECREF_SPECIALIZED(left_o, _PyFloat_ExactDealloc);(void)left ; _Py_DECREF_SPECIALIZED(right_o, _PyFloat_ExactDealloc);(void)right ; res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; - // It's always a bool, so we don't care about oparg & 16./* Pushed outputs */ + // It's always a bool, so we don't care about oparg & 16. } stack_pointer[-2] = res; stack_pointer += -1; @@ -3212,7 +3311,6 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyLong_CheckExact(left_o), COMPARE_OP); DEOPT_IF(!PyLong_CheckExact(right_o), COMPARE_OP); - /* Pushed outputs */ } /* Skip 1 cache entry */ // _COMPARE_OP_INT @@ -3231,7 +3329,7 @@ _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);(void)left ; _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free);(void)right ; res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; - // It's always a bool, so we don't care about oparg & 16./* Pushed outputs */ + // It's always a bool, so we don't care about oparg & 16. } stack_pointer[-2] = res; stack_pointer += -1; @@ -3255,7 +3353,6 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyUnicode_CheckExact(left_o), COMPARE_OP); DEOPT_IF(!PyUnicode_CheckExact(right_o), COMPARE_OP); - /* Pushed outputs */ } /* Skip 1 cache entry */ // _COMPARE_OP_STR @@ -3271,7 +3368,7 @@ assert((oparg & 0xf) == COMPARISON_NOT_EQUALS || (oparg & 0xf) == COMPARISON_EQUALS); assert(COMPARISON_NOT_EQUALS + 1 == COMPARISON_EQUALS); res = ((COMPARISON_NOT_EQUALS + eq) & oparg) ? PyStackRef_True : PyStackRef_False; - // It's always a bool, so we don't care about oparg & 16./* Pushed outputs */ + // It's always a bool, so we don't care about oparg & 16. } stack_pointer[-2] = res; stack_pointer += -1; @@ -3304,7 +3401,7 @@ } OPCODE_DEFERRED_INC(CONTAINS_OP); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ + #endif /* ENABLE_SPECIALIZATION */ } // _CONTAINS_OP { @@ -3316,8 +3413,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - if (res < 0) goto error; - b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + if (res < 0) goto pop_2_error; + b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; } stack_pointer[-2] = b; stack_pointer += -1; @@ -3345,8 +3442,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - if (res < 0) goto error; - b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + if (res < 0) goto pop_2_error; + b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; stack_pointer[-2] = b; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -3374,8 +3471,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - if (res < 0) goto error; - b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + if (res < 0) goto pop_2_error; + b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; stack_pointer[-2] = b; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -3394,8 +3491,8 @@ conv_fn = _PyEval_ConversionFuncs[oparg]; PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value)); PyStackRef_CLOSE(value); - if (result_o == NULL) goto error; - result = PyStackRef_FromPyObjectSteal(result_o);/* Pushed outputs */ + if (result_o == NULL) goto pop_1_error; + result = PyStackRef_FromPyObjectSteal(result_o); stack_pointer[-1] = result; DISPATCH(); } @@ -3408,7 +3505,7 @@ _PyStackRef top; bottom = stack_pointer[-1 - (oparg-1)]; assert(oparg > 0); - top = PyStackRef_DUP(bottom);/* Pushed outputs */ + top = PyStackRef_DUP(bottom); stack_pointer[0] = top; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3428,7 +3525,7 @@ for (int i = 0; i < oparg; ++i) { PyObject *o = PyTuple_GET_ITEM(closure, i); frame->localsplus[offset + i] = PyStackRef_FromPyObjectNew(o); - }/* Pushed outputs */ + } DISPATCH(); } @@ -3443,8 +3540,7 @@ int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(owner); - if (err) goto error; - /* Pushed outputs */ + if (err) goto pop_1_error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -3466,7 +3562,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); goto error; } - Py_DECREF(oldobj);/* Pushed outputs */ + Py_DECREF(oldobj); DISPATCH(); } @@ -3484,7 +3580,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (1) goto error; } - SETLOCAL(oparg, PyStackRef_NULL);/* Pushed outputs */ + SETLOCAL(oparg, PyStackRef_NULL); DISPATCH(); } @@ -3506,7 +3602,7 @@ NAME_ERROR_MSG, name); stack_pointer = _PyFrame_GetStackPointer(frame); goto error; - }/* Pushed outputs */ + } DISPATCH(); } @@ -3535,7 +3631,7 @@ name); stack_pointer = _PyFrame_GetStackPointer(frame); goto error; - }/* Pushed outputs */ + } DISPATCH(); } @@ -3554,8 +3650,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); - if (err) goto error; - /* Pushed outputs */ + if (err) goto pop_2_error; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -3582,10 +3677,9 @@ _PyEval_FormatKwargsError(tstate, callable_o, update_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(update); - if (true) goto error; + if (true) goto pop_1_error; } PyStackRef_CLOSE(update); - /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -3616,10 +3710,9 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(update); - if (true) goto error; + if (true) goto pop_1_error; } PyStackRef_CLOSE(update); - /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -3650,7 +3743,7 @@ monitor_reraise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; - }/* Pushed outputs */ + } stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -3663,7 +3756,6 @@ _PyStackRef value; value = stack_pointer[-1]; PyStackRef_CLOSE(value); - /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -3680,7 +3772,7 @@ receiver = stack_pointer[-2]; (void)receiver; val = value;(void)value ; - PyStackRef_CLOSE(receiver);/* Pushed outputs */ + PyStackRef_CLOSE(receiver); stack_pointer[-2] = val; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -3716,7 +3808,7 @@ GOTO_TIER_TWO(executor); #else Py_FatalError("ENTER_EXECUTOR is not supported in this build"); - #endif /* _Py_TIER2 *//* Pushed outputs */ + #endif /* _Py_TIER2 */ DISPATCH(); } @@ -3734,7 +3826,7 @@ Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); goto error; - }(void)should_be_none ;/* Pushed outputs */ + }(void)should_be_none ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -3748,7 +3840,7 @@ opcode = next_instr->op.code; oparg = oparg << 8 | next_instr->op.arg; PRE_DISPATCH_GOTO(); - DISPATCH_GOTO();/* Pushed outputs */ + DISPATCH_GOTO(); } TARGET(FORMAT_SIMPLE) { @@ -3766,14 +3858,11 @@ res = PyStackRef_FromPyObjectSteal(PyObject_Format(value_o, NULL)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - if (PyStackRef_IsNull(res)) { - stack_pointer[-1] = res; - goto error; - } + if (PyStackRef_IsNull(res)) goto pop_1_error; } else { res = value;(void)value ; - }/* Pushed outputs */ + } stack_pointer[-1] = res; DISPATCH(); } @@ -3792,8 +3881,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); PyStackRef_CLOSE(fmt_spec); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + if (res_o == NULL) goto pop_2_error; + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -3824,7 +3913,7 @@ } OPCODE_DEFERRED_INC(FOR_ITER); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ + #endif /* ENABLE_SPECIALIZATION */ } // _FOR_ITER { @@ -3854,7 +3943,7 @@ DISPATCH(); } next = PyStackRef_FromPyObjectSteal(next_o); - // Common case: no jump, leave it to the code generator/* Pushed outputs */ + // Common case: no jump, leave it to the code generator } stack_pointer[0] = next; stack_pointer += 1; @@ -3874,7 +3963,6 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, FOR_ITER); - /* Pushed outputs */ } // _FOR_ITER_GEN_FRAME { @@ -3890,7 +3978,7 @@ tstate->exc_info = &gen->gi_exc_state; gen_frame->previous = frame; // oparg is the return offset from the next instruction. - frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_FOR_ITER + oparg);/* Pushed outputs */ + frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_FOR_ITER + oparg); } // _PUSH_FRAME { @@ -3906,7 +3994,7 @@ tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); } DISPATCH(); } @@ -3923,7 +4011,6 @@ { iter = stack_pointer[-1]; DEOPT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(iter)) != &PyListIter_Type, FOR_ITER); - /* Pushed outputs */ } // _ITER_JUMP_LIST { @@ -3945,7 +4032,7 @@ /* Jump forward oparg, then skip following END_FOR and POP_TOP instructions */ JUMPBY(oparg + 2); DISPATCH(); - }/* Pushed outputs */ + } } // _ITER_NEXT_LIST { @@ -3955,7 +4042,7 @@ PyListObject *seq = it->it_seq; assert(seq); assert(it->it_index < PyList_GET_SIZE(seq)); - next = PyStackRef_FromPyObjectNew(PyList_GET_ITEM(seq, it->it_index++));/* Pushed outputs */ + next = PyStackRef_FromPyObjectNew(PyList_GET_ITEM(seq, it->it_index++)); } stack_pointer[0] = next; stack_pointer += 1; @@ -3976,7 +4063,6 @@ iter = stack_pointer[-1]; _PyRangeIterObject *r = (_PyRangeIterObject *)PyStackRef_AsPyObjectBorrow(iter); DEOPT_IF(Py_TYPE(r) != &PyRangeIter_Type, FOR_ITER); - /* Pushed outputs */ } // _ITER_JUMP_RANGE { @@ -3989,7 +4075,7 @@ // Jump over END_FOR and POP_TOP instructions. JUMPBY(oparg + 2); DISPATCH(); - }/* Pushed outputs */ + } } // _ITER_NEXT_RANGE { @@ -4001,7 +4087,7 @@ r->len--; PyObject *res = PyLong_FromLong(value); if (res == NULL) goto error; - next = PyStackRef_FromPyObjectSteal(res);/* Pushed outputs */ + next = PyStackRef_FromPyObjectSteal(res); } stack_pointer[0] = next; stack_pointer += 1; @@ -4021,7 +4107,6 @@ { iter = stack_pointer[-1]; DEOPT_IF(Py_TYPE(PyStackRef_AsPyObjectBorrow(iter)) != &PyTupleIter_Type, FOR_ITER); - /* Pushed outputs */ } // _ITER_JUMP_TUPLE { @@ -4040,7 +4125,7 @@ /* Jump forward oparg, then skip following END_FOR and POP_TOP instructions */ JUMPBY(oparg + 2); DISPATCH(); - }/* Pushed outputs */ + } } // _ITER_NEXT_TUPLE { @@ -4050,7 +4135,7 @@ PyTupleObject *seq = it->it_seq; assert(seq); assert(it->it_index < PyTuple_GET_SIZE(seq)); - next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq, it->it_index++));/* Pushed outputs */ + next = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq, it->it_index++)); } stack_pointer[0] = next; stack_pointer += 1; @@ -4080,11 +4165,11 @@ type->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(obj); - if (true) goto error; + if (true) goto pop_1_error; } iter_o = (*getter)(obj_o); PyStackRef_CLOSE(obj); - if (iter_o == NULL) goto error; + if (iter_o == NULL) goto pop_1_error; if (Py_TYPE(iter_o)->tp_as_async == NULL || Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) { stack_pointer += -1; @@ -4098,7 +4183,7 @@ Py_DECREF(iter_o); if (true) goto error; } - iter = PyStackRef_FromPyObjectSteal(iter_o);/* Pushed outputs */ + iter = PyStackRef_FromPyObjectSteal(iter_o); stack_pointer[-1] = iter; DISPATCH(); } @@ -4116,7 +4201,7 @@ if (awaitable_o == NULL) { goto error; } - awaitable = PyStackRef_FromPyObjectSteal(awaitable_o);/* Pushed outputs */ + awaitable = PyStackRef_FromPyObjectSteal(awaitable_o); stack_pointer[0] = awaitable; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -4134,8 +4219,8 @@ PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); - if (iter_o == NULL) goto error; - iter = PyStackRef_FromPyObjectSteal(iter_o);/* Pushed outputs */ + if (iter_o == NULL) goto pop_1_error; + iter = PyStackRef_FromPyObjectSteal(iter_o); stack_pointer[-1] = iter; DISPATCH(); } @@ -4152,11 +4237,7 @@ iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable))); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); - if (PyStackRef_IsNull(iter)) { - stack_pointer[-1] = iter; - goto error; - } - /* Pushed outputs */ + if (PyStackRef_IsNull(iter)) goto pop_1_error; stack_pointer[-1] = iter; DISPATCH(); } @@ -4177,7 +4258,7 @@ PyObject *len_o = PyLong_FromSsize_t(len_i); stack_pointer = _PyFrame_GetStackPointer(frame); if (len_o == NULL) goto error; - len = PyStackRef_FromPyObjectSteal(len_o);/* Pushed outputs */ + len = PyStackRef_FromPyObjectSteal(len_o); stack_pointer[0] = len; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -4220,7 +4301,7 @@ goto error; } PyStackRef_CLOSE(iterable); - }/* Pushed outputs */ + } stack_pointer[-1] = iter; DISPATCH(); } @@ -4237,7 +4318,7 @@ PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name); stack_pointer = _PyFrame_GetStackPointer(frame); if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -4261,8 +4342,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(level); PyStackRef_CLOSE(fromlist); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + if (res_o == NULL) goto pop_2_error; + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -4274,37 +4355,37 @@ (void)this_instr; next_instr += 4; INSTRUCTION_STATS(INSTRUMENTED_CALL); - _PyStackRef callable; + _PyStackRef *callable; _PyStackRef *self_or_null; _PyStackRef *args; - _PyStackRef func; + _PyStackRef *func; _PyStackRef *maybe_self; _PyStackRef res; /* Skip 3 cache entries */ // _MAYBE_EXPAND_METHOD { - maybe_self = &stack_pointer[1]; args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - if (PyStackRef_TYPE(callable) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + callable = &stack_pointer[-2 - oparg]; + func = &stack_pointer[-2 - oparg]; + maybe_self = &stack_pointer[-1 - oparg]; + if (PyStackRef_TYPE(callable[0]) == &PyMethod_Type && PyStackRef_IsNull(self_or_null[0])) { + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); PyObject *self = ((PyMethodObject *)callable_o)->im_self; maybe_self[0] = PyStackRef_FromPyObjectNew(self); PyObject *method = ((PyMethodObject *)callable_o)->im_func; - func = PyStackRef_FromPyObjectNew(method); - PyStackRef_CLOSE(callable);(void)self_or_null ; + _PyStackRef temp = callable[0]; + func[0] = PyStackRef_FromPyObjectNew(method); + PyStackRef_CLOSE(temp); } - else { - func = callable;(void)callable ;(void)self_or_null ; - }/* Pushed outputs */ } // _MONITOR_CALL { args = &stack_pointer[-oparg]; maybe_self = &stack_pointer[-1 - oparg]; + func = &stack_pointer[-2 - oparg]; int is_meth = !PyStackRef_IsNull(maybe_self[0]); - PyObject *function = PyStackRef_AsPyObjectBorrow(func); + PyObject *function = PyStackRef_AsPyObjectBorrow(func[0]); PyObject *arg0; if (is_meth) { arg0 = PyStackRef_AsPyObjectBorrow(maybe_self[0]); @@ -4315,7 +4396,6 @@ else { arg0 = &_PyInstrumentation_MISSING; } - stack_pointer[-2 - oparg] = func; _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, @@ -4323,13 +4403,12 @@ ); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) goto error; - /* Pushed outputs */ } // _DO_CALL { self_or_null = maybe_self; callable = func; - PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); + PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); // oparg counts all of the args, but *not* self: int total_args = oparg; if (!PyStackRef_IsNull(self_or_null[0])) { @@ -4343,16 +4422,14 @@ { 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)); - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( - tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable), locals, + tstate, (PyFunctionObject *)PyStackRef_AsPyObjectSteal(callable[0]), locals, args, total_args, NULL, frame ); stack_pointer = _PyFrame_GetStackPointer(frame); // Manipulate stack directly since we leave using DISPATCH_INLINED(). - stack_pointer += -1; + stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); // The frame has stolen all the arguments from the stack, // so there is no need to clean them up. @@ -4365,14 +4442,16 @@ /* Callable is not a normal Python function */ STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); + }(void)self_or_null ; + if (true) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; } - if (true) goto error; } - stack_pointer += -1 - oparg; - assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -4404,26 +4483,36 @@ } } assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(callable); + PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); + }(void)self_or_null ; + if (res_o == NULL) { + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; } - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); } // _CHECK_PERIODIC { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { - stack_pointer[-1] = res; + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - }/* Pushed outputs */ + stack_pointer += 1 + oparg; + assert(WITHIN_STACK_BOUNDS()); + } } - stack_pointer[-1] = res; + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } @@ -4431,7 +4520,7 @@ frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(INSTRUMENTED_CALL_FUNCTION_EX); - GO_TO_INSTRUCTION(CALL_FUNCTION_EX);/* Pushed outputs */ + GO_TO_INSTRUCTION(CALL_FUNCTION_EX); } TARGET(INSTRUMENTED_CALL_KW) { @@ -4455,7 +4544,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (err) goto error; PAUSE_ADAPTIVE_COUNTER(this_instr[1].counter); - GO_TO_INSTRUCTION(CALL_KW);/* Pushed outputs */ + GO_TO_INSTRUCTION(CALL_KW); } TARGET(INSTRUMENTED_END_FOR) { @@ -4473,10 +4562,11 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) goto error; + if (err) { + goto error; + } } PyStackRef_CLOSE(value); - /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -4497,10 +4587,12 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) goto error; + if (err) { + goto error; + } } val = value;(void)value ; - PyStackRef_CLOSE(receiver);/* Pushed outputs */ + PyStackRef_CLOSE(receiver); stack_pointer[-2] = val; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -4542,7 +4634,7 @@ /* Skip END_FOR and POP_TOP */ target = next_instr + oparg + 2; } - INSTRUMENTED_JUMP(this_instr, target, PY_MONITORING_EVENT_BRANCH);/* Pushed outputs */ + INSTRUMENTED_JUMP(this_instr, target, PY_MONITORING_EVENT_BRANCH); DISPATCH(); } @@ -4562,7 +4654,7 @@ } assert(next_opcode > 0 && next_opcode < 256); opcode = next_opcode; - DISPATCH_GOTO();/* Pushed outputs */ + DISPATCH_GOTO(); } TARGET(INSTRUMENTED_JUMP_BACKWARD) { @@ -4580,11 +4672,11 @@ int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - }/* Pushed outputs */ + } } // _MONITOR_JUMP_BACKWARD { - INSTRUMENTED_JUMP(this_instr, next_instr - oparg, PY_MONITORING_EVENT_JUMP);/* Pushed outputs */ + INSTRUMENTED_JUMP(this_instr, next_instr - oparg, PY_MONITORING_EVENT_JUMP); } DISPATCH(); } @@ -4594,7 +4686,7 @@ (void)this_instr; next_instr += 1; INSTRUCTION_STATS(INSTRUMENTED_JUMP_FORWARD); - INSTRUMENTED_JUMP(this_instr, next_instr + oparg, PY_MONITORING_EVENT_JUMP);/* Pushed outputs */ + INSTRUMENTED_JUMP(this_instr, next_instr + oparg, PY_MONITORING_EVENT_JUMP); DISPATCH(); } @@ -4632,7 +4724,7 @@ PAUSE_ADAPTIVE_COUNTER(cache->counter); } opcode = original_opcode; - DISPATCH_GOTO();/* Pushed outputs */ + DISPATCH_GOTO(); } TARGET(INSTRUMENTED_LOAD_SUPER_ATTR) { @@ -4644,7 +4736,7 @@ // cancel out the decrement that will happen in LOAD_SUPER_ATTR; we // don't want to specialize instrumented instructions PAUSE_ADAPTIVE_COUNTER(this_instr[1].counter); - GO_TO_INSTRUCTION(LOAD_SUPER_ATTR);/* Pushed outputs */ + GO_TO_INSTRUCTION(LOAD_SUPER_ATTR); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -4662,7 +4754,7 @@ #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif - INSTRUMENTED_JUMP(this_instr, next_instr + offset, PY_MONITORING_EVENT_BRANCH);/* Pushed outputs */ + INSTRUMENTED_JUMP(this_instr, next_instr + offset, PY_MONITORING_EVENT_BRANCH); DISPATCH(); } @@ -4685,7 +4777,7 @@ #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif - INSTRUMENTED_JUMP(this_instr, next_instr + offset, PY_MONITORING_EVENT_BRANCH);/* Pushed outputs */ + INSTRUMENTED_JUMP(this_instr, next_instr + offset, PY_MONITORING_EVENT_BRANCH); DISPATCH(); } @@ -4708,7 +4800,7 @@ #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | !nflag; #endif - INSTRUMENTED_JUMP(this_instr, next_instr + offset, PY_MONITORING_EVENT_BRANCH);/* Pushed outputs */ + INSTRUMENTED_JUMP(this_instr, next_instr + offset, PY_MONITORING_EVENT_BRANCH); DISPATCH(); } @@ -4725,7 +4817,7 @@ #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif - INSTRUMENTED_JUMP(this_instr, next_instr + offset, PY_MONITORING_EVENT_BRANCH);/* Pushed outputs */ + INSTRUMENTED_JUMP(this_instr, next_instr + offset, PY_MONITORING_EVENT_BRANCH); DISPATCH(); } @@ -4749,7 +4841,7 @@ next_instr = this_instr; DISPATCH(); } - }/* Pushed outputs */ + } } // _CHECK_PERIODIC_IF_NOT_YIELD_FROM { @@ -4762,7 +4854,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; } - }/* Pushed outputs */ + } } // _MONITOR_RESUME { @@ -4774,7 +4866,7 @@ if (frame->instr_ptr != this_instr) { /* Instrumentation has jumped */ next_instr = frame->instr_ptr; - }/* Pushed outputs */ + } } DISPATCH(); } @@ -4790,7 +4882,7 @@ _PyStackRef res; // _LOAD_CONST { - value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg));/* Pushed outputs */ + value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg)); } // _RETURN_VALUE_EVENT { @@ -4804,7 +4896,6 @@ frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) goto error; - /* Pushed outputs */ } // _RETURN_VALUE { @@ -4825,7 +4916,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(frame->return_offset); res = temp; - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); } stack_pointer[0] = res; stack_pointer += 1; @@ -4850,7 +4941,6 @@ frame, this_instr, PyStackRef_AsPyObjectBorrow(val)); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) goto error; - /* Pushed outputs */ } // _RETURN_VALUE { @@ -4871,7 +4961,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(frame->return_offset); res = temp; - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); } stack_pointer[0] = res; stack_pointer += 1; @@ -4901,7 +4991,7 @@ if (frame->instr_ptr != this_instr) { next_instr = frame->instr_ptr; DISPATCH(); - }/* Pushed outputs */ + } } // _YIELD_VALUE { @@ -4942,7 +5032,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND); value = temp; - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); } stack_pointer[0] = value; stack_pointer += 1; @@ -4964,7 +5054,7 @@ tstate->current_frame = frame->previous; assert(!_PyErr_Occurred(tstate)); tstate->c_recursion_remaining += PY_EVAL_C_STACK_UNITS; - return PyStackRef_AsPyObjectSteal(retval);/* Pushed outputs */ + return PyStackRef_AsPyObjectSteal(retval); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -4987,7 +5077,7 @@ #endif PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - b = res ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + b = res ? PyStackRef_True : PyStackRef_False; stack_pointer[-2] = b; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -5008,7 +5098,7 @@ int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; - }/* Pushed outputs */ + } } // _JUMP_BACKWARD { @@ -5044,7 +5134,7 @@ ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); } #endif /* ENABLE_SPECIALIZATION */ - #endif /* _Py_TIER2 *//* Pushed outputs */ + #endif /* _Py_TIER2 */ } DISPATCH(); } @@ -5058,7 +5148,7 @@ * generator or coroutine, so we deliberately do not check it here. * (see bpo-30039). */ - JUMPBY(-oparg);/* Pushed outputs */ + JUMPBY(-oparg); DISPATCH(); } @@ -5066,7 +5156,7 @@ frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(JUMP_FORWARD); - JUMPBY(oparg);/* Pushed outputs */ + JUMPBY(oparg); DISPATCH(); } @@ -5080,8 +5170,7 @@ list = stack_pointer[-2 - (oparg-1)]; int err = _PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list), PyStackRef_AsPyObjectSteal(v)); - if (err < 0) goto error; - /* Pushed outputs */ + if (err < 0) goto pop_1_error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -5115,11 +5204,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(iterable_st); - if (true) goto error; + if (true) goto pop_1_error; } assert(Py_IsNone(none_val)); PyStackRef_CLOSE(iterable_st); - /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -5151,7 +5239,7 @@ } OPCODE_DEFERRED_INC(LOAD_ATTR); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ + #endif /* ENABLE_SPECIALIZATION */ } /* Skip 8 cache entries */ // _LOAD_ATTR @@ -5180,7 +5268,7 @@ meth | NULL | arg1 | ... | argN */ PyStackRef_CLOSE(owner); - if (attr_o == NULL) goto error; + if (attr_o == NULL) goto pop_1_error; self_or_null = PyStackRef_NULL; } } @@ -5190,11 +5278,11 @@ attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(owner); - if (attr_o == NULL) goto error; + if (attr_o == NULL) goto pop_1_error; /* We need to define self_or_null on all paths */ self_or_null = PyStackRef_NULL; } - attr = PyStackRef_FromPyObjectSteal(attr_o);/* Pushed outputs */ + attr = PyStackRef_FromPyObjectSteal(attr_o); } stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = self_or_null; @@ -5220,7 +5308,6 @@ DEOPT_IF(!PyType_Check(owner_o), LOAD_ATTR); assert(type_version != 0); DEOPT_IF(((PyTypeObject *)owner_o)->tp_version_tag != type_version, LOAD_ATTR); - /* Pushed outputs */ } /* Skip 2 cache entries */ // _LOAD_ATTR_CLASS @@ -5231,7 +5318,6 @@ attr = PyStackRef_FromPyObjectNew(descr); null = PyStackRef_NULL; PyStackRef_CLOSE(owner); - /* Pushed outputs */ } stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; @@ -5257,7 +5343,6 @@ DEOPT_IF(!PyType_Check(owner_o), LOAD_ATTR); assert(type_version != 0); DEOPT_IF(((PyTypeObject *)owner_o)->tp_version_tag != type_version, LOAD_ATTR); - /* Pushed outputs */ } // _GUARD_TYPE_VERSION { @@ -5265,7 +5350,6 @@ PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); - /* Pushed outputs */ } // _LOAD_ATTR_CLASS { @@ -5275,7 +5359,6 @@ attr = PyStackRef_FromPyObjectNew(descr); null = PyStackRef_NULL; PyStackRef_CLOSE(owner); - /* Pushed outputs */ } stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; @@ -5317,7 +5400,7 @@ new_frame->localsplus[0] = owner;(void)owner ; new_frame->localsplus[1] = PyStackRef_FromPyObjectNew(name); frame->return_offset = (uint16_t)(next_instr - this_instr); - DISPATCH_INLINED(new_frame);/* Pushed outputs */ + DISPATCH_INLINED(new_frame); } TARGET(LOAD_ATTR_INSTANCE_VALUE) { @@ -5336,7 +5419,6 @@ PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); - /* Pushed outputs */ } // _CHECK_MANAGED_OBJECT_HAS_VALUES { @@ -5344,7 +5426,6 @@ assert(Py_TYPE(owner_o)->tp_dictoffset < 0); assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); DEOPT_IF(!_PyObject_InlineValues(owner_o)->valid, LOAD_ATTR); - /* Pushed outputs */ } // _LOAD_ATTR_INSTANCE_VALUE { @@ -5358,7 +5439,6 @@ null = PyStackRef_NULL; attr = PyStackRef_FromPyObjectSteal(attr_o); PyStackRef_CLOSE(owner); - /* Pushed outputs */ } /* Skip 5 cache entries */ stack_pointer[-1] = attr; @@ -5384,7 +5464,6 @@ PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); - /* Pushed outputs */ } // _CHECK_ATTR_METHOD_LAZY_DICT { @@ -5393,7 +5472,6 @@ PyObject *dict = *(PyObject **)ptr; /* This object has a __dict__, just not yet created */ DEOPT_IF(dict != NULL, LOAD_ATTR); - /* Pushed outputs */ } /* Skip 1 cache entry */ // _LOAD_ATTR_METHOD_LAZY_DICT @@ -5404,7 +5482,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner;(void)owner ;/* Pushed outputs */ + self = owner;(void)owner ; } stack_pointer[-1] = attr; stack_pointer[0] = self; @@ -5429,7 +5507,6 @@ PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); - /* Pushed outputs */ } /* Skip 2 cache entries */ // _LOAD_ATTR_METHOD_NO_DICT @@ -5441,7 +5518,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner;(void)owner ;/* Pushed outputs */ + self = owner;(void)owner ; } stack_pointer[-1] = attr; stack_pointer[0] = self; @@ -5466,14 +5543,12 @@ PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); - /* Pushed outputs */ } // _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT { PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); DEOPT_IF(!_PyObject_InlineValues(owner_o)->valid, LOAD_ATTR); - /* Pushed outputs */ } // _GUARD_KEYS_VERSION { @@ -5481,7 +5556,6 @@ PyTypeObject *owner_cls = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); PyHeapTypeObject *owner_heap_type = (PyHeapTypeObject *)owner_cls; DEOPT_IF(owner_heap_type->ht_cached_keys->dk_version != keys_version, LOAD_ATTR); - /* Pushed outputs */ } // _LOAD_ATTR_METHOD_WITH_VALUES { @@ -5492,7 +5566,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner;(void)owner ;/* Pushed outputs */ + self = owner;(void)owner ; } stack_pointer[-1] = attr; stack_pointer[0] = self; @@ -5519,7 +5593,6 @@ PyDictObject *dict = (PyDictObject *)((PyModuleObject *)owner_o)->md_dict; assert(dict != NULL); DEOPT_IF(dict->ma_keys->dk_version != dict_version, LOAD_ATTR); - /* Pushed outputs */ } // _LOAD_ATTR_MODULE { @@ -5536,7 +5609,6 @@ attr = PyStackRef_FromPyObjectSteal(attr_o); null = PyStackRef_NULL; PyStackRef_CLOSE(owner); - /* Pushed outputs */ } /* Skip 5 cache entries */ stack_pointer[-1] = attr; @@ -5561,7 +5633,6 @@ PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); - /* Pushed outputs */ } /* Skip 2 cache entries */ // _LOAD_ATTR_NONDESCRIPTOR_NO_DICT @@ -5572,7 +5643,7 @@ STAT_INC(LOAD_ATTR, hit); assert(descr != NULL); PyStackRef_CLOSE(owner); - attr = PyStackRef_FromPyObjectNew(descr);/* Pushed outputs */ + attr = PyStackRef_FromPyObjectNew(descr); } stack_pointer[-1] = attr; DISPATCH(); @@ -5593,14 +5664,12 @@ PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); - /* Pushed outputs */ } // _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT { PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner); assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); DEOPT_IF(!_PyObject_InlineValues(owner_o)->valid, LOAD_ATTR); - /* Pushed outputs */ } // _GUARD_KEYS_VERSION { @@ -5608,7 +5677,6 @@ PyTypeObject *owner_cls = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); PyHeapTypeObject *owner_heap_type = (PyHeapTypeObject *)owner_cls; DEOPT_IF(owner_heap_type->ht_cached_keys->dk_version != keys_version, LOAD_ATTR); - /* Pushed outputs */ } // _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES { @@ -5617,7 +5685,7 @@ STAT_INC(LOAD_ATTR, hit); assert(descr != NULL); PyStackRef_CLOSE(owner); - attr = PyStackRef_FromPyObjectNew(descr);/* Pushed outputs */ + attr = PyStackRef_FromPyObjectNew(descr); } stack_pointer[-1] = attr; DISPATCH(); @@ -5634,7 +5702,6 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, LOAD_ATTR); - /* Pushed outputs */ } // _GUARD_TYPE_VERSION { @@ -5643,7 +5710,6 @@ PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); - /* Pushed outputs */ } /* Skip 2 cache entries */ // _LOAD_ATTR_PROPERTY_FRAME @@ -5660,7 +5726,7 @@ STAT_INC(LOAD_ATTR, hit); Py_INCREF(fget); new_frame = _PyFrame_PushUnchecked(tstate, f, 1, frame); - new_frame->localsplus[0] = owner;(void)owner ;/* Pushed outputs */ + new_frame->localsplus[0] = owner;(void)owner ; } // _SAVE_RETURN_OFFSET { @@ -5669,7 +5735,7 @@ #endif #if TIER_TWO frame->return_offset = oparg; - #endif/* Pushed outputs */ + #endif } // _PUSH_FRAME { @@ -5686,7 +5752,7 @@ tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); } DISPATCH(); } @@ -5707,7 +5773,6 @@ PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); - /* Pushed outputs */ } // _LOAD_ATTR_SLOT { @@ -5720,7 +5785,6 @@ null = PyStackRef_NULL; attr = PyStackRef_FromPyObjectNew(attr_o); PyStackRef_CLOSE(owner); - /* Pushed outputs */ } /* Skip 5 cache entries */ stack_pointer[-1] = attr; @@ -5746,7 +5810,6 @@ PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, LOAD_ATTR); - /* Pushed outputs */ } // _CHECK_ATTR_WITH_HINT { @@ -5754,7 +5817,7 @@ assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_MANAGED_DICT); PyDictObject *dict = _PyObject_GetManagedDict(owner_o); DEOPT_IF(dict == NULL, LOAD_ATTR); - assert(PyDict_CheckExact((PyObject *)dict));/* Pushed outputs */ + assert(PyDict_CheckExact((PyObject *)dict)); } // _LOAD_ATTR_WITH_HINT { @@ -5774,7 +5837,6 @@ attr = PyStackRef_FromPyObjectSteal(attr_o); null = PyStackRef_NULL; PyStackRef_CLOSE(owner); - /* Pushed outputs */ } /* Skip 5 cache entries */ stack_pointer[-1] = attr; @@ -5801,7 +5863,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (true) goto error; } - bc = PyStackRef_FromPyObjectSteal(bc_o);/* Pushed outputs */ + bc = PyStackRef_FromPyObjectSteal(bc_o); stack_pointer[0] = bc; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5825,7 +5887,7 @@ default: Py_FatalError("bad LOAD_COMMON_CONSTANT oparg"); } - value = PyStackRef_FromPyObjectImmortal(val);/* Pushed outputs */ + value = PyStackRef_FromPyObjectImmortal(val); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5837,7 +5899,7 @@ next_instr += 1; INSTRUCTION_STATS(LOAD_CONST); _PyStackRef value; - value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg));/* Pushed outputs */ + value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg)); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5857,7 +5919,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (true) goto error; } - value = PyStackRef_FromPyObjectSteal(value_o);/* Pushed outputs */ + value = PyStackRef_FromPyObjectSteal(value_o); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5870,7 +5932,7 @@ INSTRUCTION_STATS(LOAD_FAST); _PyStackRef value; assert(!PyStackRef_IsNull(GETLOCAL(oparg))); - value = PyStackRef_DUP(GETLOCAL(oparg));/* Pushed outputs */ + value = PyStackRef_DUP(GETLOCAL(oparg)); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5884,7 +5946,7 @@ _PyStackRef value; value = GETLOCAL(oparg); // do not use SETLOCAL here, it decrefs the old value - GETLOCAL(oparg) = PyStackRef_NULL;/* Pushed outputs */ + GETLOCAL(oparg) = PyStackRef_NULL; stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5906,7 +5968,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (1) goto error; } - value = PyStackRef_DUP(value_s);/* Pushed outputs */ + value = PyStackRef_DUP(value_s); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -5922,7 +5984,7 @@ uint32_t oparg1 = oparg >> 4; uint32_t oparg2 = oparg & 15; value1 = PyStackRef_DUP(GETLOCAL(oparg1)); - value2 = PyStackRef_DUP(GETLOCAL(oparg2));/* Pushed outputs */ + value2 = PyStackRef_DUP(GETLOCAL(oparg2)); stack_pointer[0] = value1; stack_pointer[1] = value2; stack_pointer += 2; @@ -5960,7 +6022,7 @@ } } PyStackRef_CLOSE(class_dict_st); - value = PyStackRef_FromPyObjectSteal(value_o);/* Pushed outputs */ + value = PyStackRef_FromPyObjectSteal(value_o); stack_pointer[-1] = value; DISPATCH(); } @@ -5977,13 +6039,14 @@ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &v_o); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { - goto error; - } + PyStackRef_CLOSE(mod_or_class_dict); + if (err < 0) goto pop_1_error; if (v_o == NULL) { if (PyDict_CheckExact(GLOBALS()) && PyDict_CheckExact(BUILTINS())) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); v_o = _PyDict_LoadGlobal((PyDictObject *)GLOBALS(), (PyDictObject *)BUILTINS(), @@ -6004,6 +6067,8 @@ else { /* Slow-path if globals or builtins is not a dict */ /* namespace 1: globals */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(GLOBALS(), name, &v_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6023,10 +6088,10 @@ if (true) goto error; } } - } + }stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); } - PyStackRef_CLOSE(mod_or_class_dict); - v = PyStackRef_FromPyObjectSteal(v_o);/* Pushed outputs */ + v = PyStackRef_FromPyObjectSteal(v_o); stack_pointer[-1] = v; DISPATCH(); } @@ -6055,7 +6120,7 @@ } OPCODE_DEFERRED_INC(LOAD_GLOBAL); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ + #endif /* ENABLE_SPECIALIZATION */ } /* Skip 1 cache entry */ /* Skip 1 cache entry */ @@ -6068,7 +6133,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (res_o == NULL) goto error; null = PyStackRef_NULL; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[0] = res; if (oparg & 1) stack_pointer[1] = null; @@ -6091,7 +6156,7 @@ PyDictObject *dict = (PyDictObject *)GLOBALS(); DEOPT_IF(!PyDict_CheckExact(dict), LOAD_GLOBAL); DEOPT_IF(dict->ma_keys->dk_version != version, LOAD_GLOBAL); - assert(DK_IS_UNICODE(dict->ma_keys));/* Pushed outputs */ + assert(DK_IS_UNICODE(dict->ma_keys)); } // _GUARD_BUILTINS_VERSION { @@ -6099,7 +6164,7 @@ PyDictObject *dict = (PyDictObject *)BUILTINS(); DEOPT_IF(!PyDict_CheckExact(dict), LOAD_GLOBAL); DEOPT_IF(dict->ma_keys->dk_version != version, LOAD_GLOBAL); - assert(DK_IS_UNICODE(dict->ma_keys));/* Pushed outputs */ + assert(DK_IS_UNICODE(dict->ma_keys)); } // _LOAD_GLOBAL_BUILTINS { @@ -6111,7 +6176,7 @@ Py_INCREF(res_o); STAT_INC(LOAD_GLOBAL, hit); null = PyStackRef_NULL; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[0] = res; if (oparg & 1) stack_pointer[1] = null; @@ -6134,7 +6199,7 @@ PyDictObject *dict = (PyDictObject *)GLOBALS(); DEOPT_IF(!PyDict_CheckExact(dict), LOAD_GLOBAL); DEOPT_IF(dict->ma_keys->dk_version != version, LOAD_GLOBAL); - assert(DK_IS_UNICODE(dict->ma_keys));/* Pushed outputs */ + assert(DK_IS_UNICODE(dict->ma_keys)); } /* Skip 1 cache entry */ // _LOAD_GLOBAL_MODULE @@ -6147,7 +6212,7 @@ Py_INCREF(res_o); STAT_INC(LOAD_GLOBAL, hit); null = PyStackRef_NULL; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + res = PyStackRef_FromPyObjectSteal(res_o); } stack_pointer[0] = res; if (oparg & 1) stack_pointer[1] = null; @@ -6169,7 +6234,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (true) goto error; } - locals = PyStackRef_FromPyObjectNew(l);/* Pushed outputs */ + locals = PyStackRef_FromPyObjectNew(l); stack_pointer[0] = locals; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6186,7 +6251,7 @@ PyObject *v_o = _PyEval_LoadName(tstate, frame, name); stack_pointer = _PyFrame_GetStackPointer(frame); if (v_o == NULL) goto error; - v = PyStackRef_FromPyObjectSteal(v_o);/* Pushed outputs */ + v = PyStackRef_FromPyObjectSteal(v_o); stack_pointer[0] = v; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6230,7 +6295,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - self_or_null = PyStackRef_FromPyObjectSteal(self_or_null_o);/* Pushed outputs */ + self_or_null = PyStackRef_FromPyObjectSteal(self_or_null_o); stack_pointer[0] = attr; stack_pointer[1] = self_or_null; stack_pointer += 2; @@ -6267,7 +6332,7 @@ } OPCODE_DEFERRED_INC(LOAD_SUPER_ATTR); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ + #endif /* ENABLE_SPECIALIZATION */ } // _LOAD_SUPER_ATTR { @@ -6282,7 +6347,12 @@ tstate, PY_MONITORING_EVENT_CALL, frame, this_instr, global_super, arg); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) goto error; + if (err) { + PyStackRef_CLOSE(global_super_st); + PyStackRef_CLOSE(class_st); + PyStackRef_CLOSE(self_st); + if (true) goto pop_3_error; + } } // we make no attempt to optimize here; specializations should // handle any case whose performance we care about @@ -6315,7 +6385,7 @@ PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); PyStackRef_CLOSE(self_st); - if (super == NULL) goto error; + if (super == NULL) goto pop_3_error; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); @@ -6323,13 +6393,8 @@ attr = PyStackRef_FromPyObjectSteal(PyObject_GetAttr(super, name)); stack_pointer = _PyFrame_GetStackPointer(frame); Py_DECREF(super); - if (PyStackRef_IsNull(attr)) { - stack_pointer[0] = attr; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - null = PyStackRef_NULL;/* Pushed outputs */ + if (PyStackRef_IsNull(attr)) goto error; + null = PyStackRef_NULL; } stack_pointer[0] = attr; if (oparg & 1) stack_pointer[1] = null; @@ -6365,8 +6430,8 @@ PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); PyStackRef_CLOSE(self_st); - if (attr == NULL) goto error; - attr_st = PyStackRef_FromPyObjectSteal(attr);/* Pushed outputs */ + if (attr == NULL) goto pop_3_error; + attr_st = PyStackRef_FromPyObjectSteal(attr); stack_pointer[-3] = attr_st; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -6405,7 +6470,7 @@ PyStackRef_CLOSE(class_st); if (attr_o == NULL) { PyStackRef_CLOSE(self_st); - if (true) goto error; + if (true) goto pop_3_error; } if (method_found) { self_or_null = self_st; // transfer ownership(void)self_st ; @@ -6413,7 +6478,7 @@ PyStackRef_CLOSE(self_st); self_or_null = PyStackRef_NULL; } - attr = PyStackRef_FromPyObjectSteal(attr_o);/* Pushed outputs */ + attr = PyStackRef_FromPyObjectSteal(attr_o); stack_pointer[-3] = attr; stack_pointer[-2] = self_or_null; stack_pointer += -1; @@ -6432,7 +6497,7 @@ if (cell == NULL) { goto error; } - SETLOCAL(oparg, PyStackRef_FromPyObjectSteal(cell));/* Pushed outputs */ + SETLOCAL(oparg, PyStackRef_FromPyObjectSteal(cell)); DISPATCH(); } @@ -6449,14 +6514,14 @@ PyFunction_New(codeobj, GLOBALS()); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(codeobj_st); - if (func_obj == NULL) goto error; + if (func_obj == NULL) goto pop_1_error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyFunction_SetVersion( func_obj, ((PyCodeObject *)codeobj)->co_version); stack_pointer = _PyFrame_GetStackPointer(frame); - func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj);/* Pushed outputs */ + func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj); stack_pointer[0] = func; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6484,8 +6549,7 @@ PyStackRef_AsPyObjectSteal(value) ); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err != 0) goto error; - /* Pushed outputs */ + if (err != 0) goto pop_2_error; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -6519,10 +6583,10 @@ attrs = PyStackRef_FromPyObjectSteal(attrs_o); } else { - if (_PyErr_Occurred(tstate)) goto error; + if (_PyErr_Occurred(tstate)) goto pop_3_error; // Error! attrs = PyStackRef_None; // Failure! - }/* Pushed outputs */ + } stack_pointer[-3] = attrs; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -6544,7 +6608,7 @@ PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys)); stack_pointer = _PyFrame_GetStackPointer(frame); if (values_or_none_o == NULL) goto error; - values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o);/* Pushed outputs */ + values_or_none = PyStackRef_FromPyObjectSteal(values_or_none_o); stack_pointer[0] = values_or_none; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6559,7 +6623,7 @@ _PyStackRef res; subject = stack_pointer[-1]; int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING; - res = match ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + res = match ? PyStackRef_True : PyStackRef_False; stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6574,7 +6638,7 @@ _PyStackRef res; subject = stack_pointer[-1]; int match = PyStackRef_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE; - res = match ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + res = match ? PyStackRef_True : PyStackRef_False; stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6585,7 +6649,6 @@ frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(NOP); - /* Pushed outputs */ DISPATCH(); } @@ -6601,7 +6664,6 @@ PyStackRef_Is(exc_value, PyStackRef_None) ? NULL : PyStackRef_AsPyObjectSteal(exc_value)); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -6620,7 +6682,7 @@ #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif - JUMPBY(oparg * flag);/* Pushed outputs */ + JUMPBY(oparg * flag); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -6644,7 +6706,7 @@ else { b = PyStackRef_False; PyStackRef_CLOSE(value); - }/* Pushed outputs */ + } } // _POP_JUMP_IF_TRUE { @@ -6654,7 +6716,7 @@ #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif - JUMPBY(oparg * flag);/* Pushed outputs */ + JUMPBY(oparg * flag); } stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -6679,7 +6741,7 @@ else { b = PyStackRef_False; PyStackRef_CLOSE(value); - }/* Pushed outputs */ + } } // _POP_JUMP_IF_FALSE { @@ -6689,7 +6751,7 @@ #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif - JUMPBY(oparg * flag);/* Pushed outputs */ + JUMPBY(oparg * flag); } stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -6709,7 +6771,7 @@ #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif - JUMPBY(oparg * flag);/* Pushed outputs */ + JUMPBY(oparg * flag); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -6722,7 +6784,6 @@ _PyStackRef value; value = stack_pointer[-1]; PyStackRef_CLOSE(value); - /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -6745,7 +6806,7 @@ } assert(PyStackRef_ExceptionInstanceCheck(exc)); exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); - new_exc = exc;(void)exc ;/* Pushed outputs */ + new_exc = exc;(void)exc ; stack_pointer[-1] = prev_exc; stack_pointer[0] = new_exc; stack_pointer += 1; @@ -6758,7 +6819,7 @@ next_instr += 1; INSTRUCTION_STATS(PUSH_NULL); _PyStackRef res; - res = PyStackRef_NULL;/* Pushed outputs */ + res = PyStackRef_NULL; stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6784,8 +6845,11 @@ stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; } - if (true) goto error; - /* Pushed outputs */ + if (true) { + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); + goto error; + } stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); } @@ -6829,7 +6893,7 @@ _PyErr_SetRaisedException(tstate, exc); monitor_reraise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); - goto exception_unwind;/* Pushed outputs */ + goto exception_unwind; } TARGET(RESERVED) { @@ -6837,7 +6901,7 @@ next_instr += 1; INSTRUCTION_STATS(RESERVED); assert(0 && "Executing RESERVED instruction."); - Py_FatalError("Executing RESERVED instruction.");/* Pushed outputs */ + Py_FatalError("Executing RESERVED instruction."); DISPATCH(); } @@ -6863,7 +6927,7 @@ next_instr = this_instr; DISPATCH(); } - }/* Pushed outputs */ + } } // _QUICKEN_RESUME { @@ -6871,7 +6935,7 @@ if (tstate->tracing == 0 && this_instr->op.code == RESUME) { FT_ATOMIC_STORE_UINT8_RELAXED(this_instr->op.code, RESUME_CHECK); } - #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ + #endif /* ENABLE_SPECIALIZATION */ } // _CHECK_PERIODIC_IF_NOT_YIELD_FROM { @@ -6884,7 +6948,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (err != 0) goto error; } - }/* Pushed outputs */ + } } DISPATCH(); } @@ -6902,7 +6966,6 @@ uintptr_t version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version); assert((version & _PY_EVAL_EVENTS_MASK) == 0); DEOPT_IF(eval_breaker != version, RESUME); - /* Pushed outputs */ DISPATCH(); } @@ -6915,7 +6978,7 @@ _PyStackRef res; // _LOAD_CONST { - value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg));/* Pushed outputs */ + value = PyStackRef_FromPyObjectNew(GETITEM(FRAME_CO_CONSTS, oparg)); } // _RETURN_VALUE { @@ -6934,7 +6997,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(frame->return_offset); res = temp; - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); } stack_pointer[0] = res; stack_pointer += 1; @@ -6968,7 +7031,7 @@ LOAD_IP(frame->return_offset); stack_pointer = _PyFrame_GetStackPointer(frame); res = PyStackRef_FromPyObjectSteal((PyObject *)gen); - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6998,7 +7061,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(frame->return_offset); res = temp; - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -7030,7 +7093,7 @@ } OPCODE_DEFERRED_INC(SEND); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ + #endif /* ENABLE_SPECIALIZATION */ } // _SEND { @@ -7083,11 +7146,11 @@ } else { PyStackRef_CLOSE(v); - if (true) goto error; + if (true) goto pop_1_error; } } PyStackRef_CLOSE(v); - retval = PyStackRef_FromPyObjectSteal(retval_o);/* Pushed outputs */ + retval = PyStackRef_FromPyObjectSteal(retval_o); } stack_pointer[-1] = retval; DISPATCH(); @@ -7106,7 +7169,6 @@ // _CHECK_PEP_523 { DEOPT_IF(tstate->interp->eval_frame, SEND); - /* Pushed outputs */ } // _SEND_GEN_FRAME { @@ -7123,7 +7185,7 @@ tstate->exc_info = &gen->gi_exc_state; assert(1 + INLINE_CACHE_ENTRIES_SEND + oparg <= UINT16_MAX); frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_SEND + oparg); - gen_frame->previous = frame;/* Pushed outputs */ + gen_frame->previous = frame; } // _PUSH_FRAME { @@ -7141,7 +7203,7 @@ tstate->py_recursion_remaining--; LOAD_SP(); LOAD_IP(0); - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); } DISPATCH(); } @@ -7177,7 +7239,7 @@ } else { Py_DECREF(ann_dict); - }/* Pushed outputs */ + } DISPATCH(); } @@ -7194,8 +7256,7 @@ PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); - if (err) goto error; - /* Pushed outputs */ + if (err) goto pop_1_error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -7218,7 +7279,7 @@ assert(offset != 0); PyObject **ptr = (PyObject **)(((char *)func) + offset); assert(*ptr == NULL); - *ptr = attr;/* Pushed outputs */ + *ptr = attr; stack_pointer[-2] = func_out; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -7238,8 +7299,7 @@ PyStackRef_AsPyObjectBorrow(iterable)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); - if (err < 0) goto error; - /* Pushed outputs */ + if (err < 0) goto pop_1_error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -7270,7 +7330,7 @@ } OPCODE_DEFERRED_INC(STORE_ATTR); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ + #endif /* ENABLE_SPECIALIZATION */ } /* Skip 3 cache entries */ // _STORE_ATTR @@ -7283,8 +7343,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); PyStackRef_CLOSE(owner); - if (err) goto error; - /* Pushed outputs */ + if (err) goto pop_2_error; } stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -7306,7 +7365,6 @@ PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR); - /* Pushed outputs */ } // _GUARD_DORV_NO_DICT { @@ -7315,7 +7373,6 @@ assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES); DEOPT_IF(_PyObject_GetManagedDict(owner_o), STORE_ATTR); DEOPT_IF(_PyObject_InlineValues(owner_o)->valid == 0, STORE_ATTR); - /* Pushed outputs */ } // _STORE_ATTR_INSTANCE_VALUE { @@ -7335,7 +7392,7 @@ else { Py_DECREF(old_value); } - PyStackRef_CLOSE(owner);/* Pushed outputs */ + PyStackRef_CLOSE(owner); } stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -7357,7 +7414,6 @@ PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR); - /* Pushed outputs */ } // _STORE_ATTR_SLOT { @@ -7369,7 +7425,7 @@ PyObject *old_value = *(PyObject **)addr; *(PyObject **)addr = PyStackRef_AsPyObjectSteal(value); Py_XDECREF(old_value); - PyStackRef_CLOSE(owner);/* Pushed outputs */ + PyStackRef_CLOSE(owner); } stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -7391,7 +7447,6 @@ PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, STORE_ATTR); - /* Pushed outputs */ } // _STORE_ATTR_WITH_HINT { @@ -7426,7 +7481,7 @@ // when dict only holds the strong reference to value in ep->me_value. Py_XDECREF(old_value); STAT_INC(STORE_ATTR, hit); - PyStackRef_CLOSE(owner);/* Pushed outputs */ + PyStackRef_CLOSE(owner); } stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -7443,7 +7498,6 @@ _PyFrame_SetStackPointer(frame, stack_pointer); PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v)); stack_pointer = _PyFrame_GetStackPointer(frame); - /* Pushed outputs */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -7455,7 +7509,7 @@ INSTRUCTION_STATS(STORE_FAST); _PyStackRef value; value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ;/* Pushed outputs */ + SETLOCAL(oparg, value);(void)value ; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -7471,7 +7525,7 @@ uint32_t oparg1 = oparg >> 4; uint32_t oparg2 = oparg & 15; SETLOCAL(oparg1, value1);(void)value1 ; - value2 = PyStackRef_DUP(GETLOCAL(oparg2));/* Pushed outputs */ + value2 = PyStackRef_DUP(GETLOCAL(oparg2)); stack_pointer[-1] = value2; DISPATCH(); } @@ -7487,7 +7541,7 @@ uint32_t oparg1 = oparg >> 4; uint32_t oparg2 = oparg & 15; SETLOCAL(oparg1, value1);(void)value1 ; - SETLOCAL(oparg2, value2);(void)value2 ;/* Pushed outputs */ + SETLOCAL(oparg2, value2);(void)value2 ; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -7504,8 +7558,7 @@ int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); - if (err) goto error; - /* Pushed outputs */ + if (err) goto pop_1_error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -7526,7 +7579,7 @@ "no locals found when storing %R", name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); - if (true) goto error; + if (true) goto pop_1_error; } if (PyDict_CheckExact(ns)) { _PyFrame_SetStackPointer(frame, stack_pointer); @@ -7539,8 +7592,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(v); - if (err) goto error; - /* Pushed outputs */ + if (err) goto pop_1_error; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -7559,7 +7611,7 @@ // Placeholder until we implement STORE_SLICE specialization #if ENABLE_SPECIALIZATION OPCODE_DEFERRED_INC(STORE_SLICE); - #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ + #endif /* ENABLE_SPECIALIZATION */ } // _STORE_SLICE { @@ -7586,8 +7638,7 @@ } PyStackRef_CLOSE(v); PyStackRef_CLOSE(container); - if (err) goto pop_2_error; - /* Pushed outputs */ + if (err) goto pop_4_error; } stack_pointer += -4; assert(WITHIN_STACK_BOUNDS()); @@ -7620,7 +7671,7 @@ } OPCODE_DEFERRED_INC(STORE_SUBSCR); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ + #endif /* ENABLE_SPECIALIZATION */ } // _STORE_SUBSCR { @@ -7632,8 +7683,7 @@ PyStackRef_CLOSE(v); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); - if (err) goto error; - /* Pushed outputs */ + if (err) goto pop_3_error; } stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); @@ -7661,8 +7711,7 @@ PyStackRef_AsPyObjectSteal(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(dict_st); - if (err) goto error; - /* Pushed outputs */ + if (err) goto pop_3_error; stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -7695,7 +7744,7 @@ assert(old_value != NULL); Py_DECREF(old_value); _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; - PyStackRef_CLOSE(list_st);/* Pushed outputs */ + PyStackRef_CLOSE(list_st); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -7713,7 +7762,7 @@ bottom_in = stack_pointer[-2 - (oparg-2)]; bottom_out = bottom_in;(void)bottom_in ; top_out = top_in;(void)top_in ; - assert(oparg >= 2);/* Pushed outputs */ + assert(oparg >= 2); stack_pointer[-2 - (oparg-2)] = top_out; stack_pointer[-1] = bottom_out; DISPATCH(); @@ -7743,7 +7792,7 @@ } OPCODE_DEFERRED_INC(TO_BOOL); ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); - #endif /* ENABLE_SPECIALIZATION *//* Pushed outputs */ + #endif /* ENABLE_SPECIALIZATION */ } /* Skip 2 cache entries */ // _TO_BOOL @@ -7752,8 +7801,8 @@ int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - if (err < 0) goto error; - res = err ? PyStackRef_True : PyStackRef_False;/* Pushed outputs */ + if (err < 0) goto pop_1_error; + res = err ? PyStackRef_True : PyStackRef_False; } stack_pointer[-1] = res; DISPATCH(); @@ -7775,13 +7824,12 @@ PyTypeObject *tp = Py_TYPE(PyStackRef_AsPyObjectBorrow(owner)); assert(type_version != 0); DEOPT_IF(tp->tp_version_tag != type_version, TO_BOOL); - /* Pushed outputs */ } // _REPLACE_WITH_TRUE { value = owner; PyStackRef_CLOSE(value); - res = PyStackRef_True;/* Pushed outputs */ + res = PyStackRef_True; } stack_pointer[-1] = res; DISPATCH(); @@ -7797,7 +7845,7 @@ /* Skip 2 cache entries */ value = stack_pointer[-1]; DEOPT_IF(!PyStackRef_BoolCheck(value), TO_BOOL); - STAT_INC(TO_BOOL, hit);/* Pushed outputs */ + STAT_INC(TO_BOOL, hit); DISPATCH(); } @@ -7824,7 +7872,7 @@ else { PyStackRef_CLOSE(value); res = PyStackRef_True; - }/* Pushed outputs */ + } stack_pointer[-1] = res; DISPATCH(); } @@ -7844,7 +7892,6 @@ STAT_INC(TO_BOOL, hit); res = Py_SIZE(value_o) ? PyStackRef_True : PyStackRef_False; PyStackRef_CLOSE(value); - /* Pushed outputs */ stack_pointer[-1] = res; DISPATCH(); } @@ -7863,7 +7910,7 @@ DEOPT_IF(!PyStackRef_Is(value, PyStackRef_None), TO_BOOL); (void)value ; STAT_INC(TO_BOOL, hit); - res = PyStackRef_False;/* Pushed outputs */ + res = PyStackRef_False; stack_pointer[-1] = res; DISPATCH(); } @@ -7892,7 +7939,7 @@ assert(Py_SIZE(value_o)); PyStackRef_CLOSE(value); res = PyStackRef_True; - }/* Pushed outputs */ + } stack_pointer[-1] = res; DISPATCH(); } @@ -7908,8 +7955,8 @@ PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + if (res_o == NULL) goto pop_1_error; + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-1] = res; DISPATCH(); } @@ -7925,8 +7972,8 @@ PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - if (res_o == NULL) goto error; - res = PyStackRef_FromPyObjectSteal(res_o);/* Pushed outputs */ + if (res_o == NULL) goto pop_1_error; + res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-1] = res; DISPATCH(); } @@ -7940,7 +7987,7 @@ value = stack_pointer[-1]; assert(PyStackRef_BoolCheck(value)); res = PyStackRef_Is(value, PyStackRef_False) - ? PyStackRef_True : PyStackRef_False;(void)value ;/* Pushed outputs */ + ? PyStackRef_True : PyStackRef_False;(void)value ; stack_pointer[-1] = res; DISPATCH(); } @@ -7951,15 +7998,14 @@ INSTRUCTION_STATS(UNPACK_EX); _PyStackRef seq; _PyStackRef *right; - right = &stack_pointer[1 + (oparg & 0xFF)]; seq = stack_pointer[-1]; + right = &stack_pointer[(oparg & 0xFF)]; _PyStackRef *top = right + (oparg >> 8); _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(seq); - if (res == 0) goto error; - /* Pushed outputs */ + if (res == 0) goto pop_1_error; stack_pointer += (oparg & 0xFF) + (oparg >> 8); assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -7991,18 +8037,17 @@ ADVANCE_ADAPTIVE_COUNTER(this_instr[1].counter); #endif /* ENABLE_SPECIALIZATION */ (void)seq; - (void)counter;/* Pushed outputs */ + (void)counter; } // _UNPACK_SEQUENCE { - output = &stack_pointer[0]; + output = &stack_pointer[-1]; _PyStackRef *top = output + oparg; _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(seq); - if (res == 0) goto error; - /* Pushed outputs */ + if (res == 0) goto pop_1_error; } stack_pointer += -1 + oparg; assert(WITHIN_STACK_BOUNDS()); @@ -8017,8 +8062,8 @@ _PyStackRef seq; _PyStackRef *values; /* Skip 1 cache entry */ - values = &stack_pointer[0]; seq = stack_pointer[-1]; + values = &stack_pointer[-1]; PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq); DEOPT_IF(!PyList_CheckExact(seq_o), UNPACK_SEQUENCE); DEOPT_IF(PyList_GET_SIZE(seq_o) != oparg, UNPACK_SEQUENCE); @@ -8028,7 +8073,6 @@ *values++ = PyStackRef_FromPyObjectNew(items[i]); } PyStackRef_CLOSE(seq); - /* Pushed outputs */ stack_pointer += -1 + oparg; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -8042,8 +8086,8 @@ _PyStackRef seq; _PyStackRef *values; /* Skip 1 cache entry */ - values = &stack_pointer[0]; seq = stack_pointer[-1]; + values = &stack_pointer[-1]; PyObject *seq_o = PyStackRef_AsPyObjectBorrow(seq); DEOPT_IF(!PyTuple_CheckExact(seq_o), UNPACK_SEQUENCE); DEOPT_IF(PyTuple_GET_SIZE(seq_o) != oparg, UNPACK_SEQUENCE); @@ -8053,7 +8097,6 @@ *values++ = PyStackRef_FromPyObjectNew(items[i]); } PyStackRef_CLOSE(seq); - /* Pushed outputs */ stack_pointer += -1 + oparg; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -8077,7 +8120,6 @@ val0 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 0)); val1 = PyStackRef_FromPyObjectNew(PyTuple_GET_ITEM(seq_o, 1)); PyStackRef_CLOSE(seq); - /* Pushed outputs */ stack_pointer[-1] = val1; stack_pointer[0] = val0; stack_pointer += 1; @@ -8129,13 +8171,7 @@ res = PyStackRef_FromPyObjectSteal(PyObject_Vectorcall(exit_func_o, stack + 2 - has_self, (3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL)); stack_pointer = _PyFrame_GetStackPointer(frame); - if (PyStackRef_IsNull(res)) { - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - /* Pushed outputs */ + if (PyStackRef_IsNull(res)) goto error; stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -8185,133 +8221,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND); value = temp; - LLTRACE_RESUME_FRAME();/* Pushed outputs */ + LLTRACE_RESUME_FRAME(); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } - - TARGET(_DO_CALL_FUNCTION_EX) { - _Py_CODEUNIT *this_instr = frame->instr_ptr = next_instr; - (void)this_instr; - next_instr += 1; - INSTRUCTION_STATS(_DO_CALL_FUNCTION_EX); - _PyStackRef func_st; - _PyStackRef callargs_st; - _PyStackRef kwargs_st = PyStackRef_NULL; - _PyStackRef result; - if (oparg & 1) { kwargs_st = stack_pointer[-(oparg & 1)]; } - callargs_st = stack_pointer[-1 - (oparg & 1)]; - func_st = stack_pointer[-3 - (oparg & 1)]; - PyObject *func = PyStackRef_AsPyObjectBorrow(func_st); - PyObject *callargs = PyStackRef_AsPyObjectBorrow(callargs_st); - PyObject *kwargs = PyStackRef_AsPyObjectSteal(kwargs_st); - // DICT_MERGE is called before this opcode if there are kwargs. - // It converts all dict subtypes in kwargs into regular dicts. - assert(kwargs == NULL || PyDict_CheckExact(kwargs)); - if (!PyTuple_CheckExact(callargs)) { - int err = check_args_iterable(tstate, func, callargs); - if (err < 0) { - goto error; - } - stack_pointer += -(oparg & 1); - assert(WITHIN_STACK_BOUNDS()); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyObject *tuple = PySequence_Tuple(callargs); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (tuple == NULL) { - goto error; - } - PyStackRef_CLOSE(callargs_st); - callargs = tuple; - } - else { - callargs = PyStackRef_AsPyObjectSteal(callargs_st);stack_pointer += -(oparg & 1); - assert(WITHIN_STACK_BOUNDS()); - } - assert(PyTuple_CheckExact(callargs)); - EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_FUNCTION_EX, func); - PyObject *result_o; - if (opcode == INSTRUMENTED_CALL_FUNCTION_EX) { - PyObject *arg = PyTuple_GET_SIZE(callargs) > 0 ? - PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = _Py_call_instrumentation_2args( - tstate, PY_MONITORING_EVENT_CALL, - frame, this_instr, func, arg); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err) { - goto error; - } - _PyFrame_SetStackPointer(frame, stack_pointer); - result_o = PyObject_Call(func, callargs, kwargs); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (!PyFunction_Check(func) && !PyMethod_Check(func)) { - if (PyStackRef_IsNull(result)) { - _PyFrame_SetStackPointer(frame, stack_pointer); - _Py_call_instrumentation_exc2( - tstate, PY_MONITORING_EVENT_C_RAISE, - frame, this_instr, func, arg); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - else { - _PyFrame_SetStackPointer(frame, stack_pointer); - int err = _Py_call_instrumentation_2args( - tstate, PY_MONITORING_EVENT_C_RETURN, - frame, this_instr, func, arg); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { - _PyFrame_SetStackPointer(frame, stack_pointer); - Py_CLEAR(result_o); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - } - } - } - else { - if (Py_TYPE(func) == &PyFunction_Type && - tstate->interp->eval_frame == NULL && - ((PyFunctionObject *)func)->vectorcall == _PyFunction_Vectorcall) { - assert(PyTuple_CheckExact(callargs)); - Py_ssize_t nargs = PyTuple_GET_SIZE(callargs); - int code_flags = ((PyCodeObject *)PyFunction_GET_CODE(func))->co_flags; - PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func)); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); - _PyFrame_SetStackPointer(frame, stack_pointer); - _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit_Ex(tstate, - (PyFunctionObject *)PyStackRef_AsPyObjectSteal(func_st), locals, - nargs, callargs, kwargs, frame); - stack_pointer = _PyFrame_GetStackPointer(frame); - // Need to sync the stack since we exit with DISPATCH_INLINED. - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - if (new_frame == NULL) { - goto error; - } - assert(next_instr - this_instr == 1); - frame->return_offset = 1; - DISPATCH_INLINED(new_frame); - } - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); - _PyFrame_SetStackPointer(frame, stack_pointer); - result_o = PyObject_Call(func, callargs, kwargs); - stack_pointer = _PyFrame_GetStackPointer(frame); - } - Py_DECREF(callargs); - PyStackRef_CLOSE(func_st); - Py_XDECREF(kwargs); - result = PyStackRef_FromPyObjectSteal(result_o); - if (PyStackRef_IsNull(result)) { - stack_pointer[-1] = result; - goto error; - } - /* Pushed outputs */ - stack_pointer[-1] = result; - DISPATCH(); - } #undef TIER_ONE diff --git a/Python/opcode_targets.h b/Python/opcode_targets.h index 49f01ca2932ee2..3fc9d3118d59ad 100644 --- a/Python/opcode_targets.h +++ b/Python/opcode_targets.h @@ -115,7 +115,7 @@ static void *opcode_targets[256] = { &&TARGET_UNPACK_EX, &&TARGET_UNPACK_SEQUENCE, &&TARGET_YIELD_VALUE, - &&TARGET__DO_CALL_FUNCTION_EX, + &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, &&_unknown_opcode, diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 3eac66da236b62..d086975396e0a3 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -29,13 +29,13 @@ // We guarantee this will error - just bail and don't optimize it. if (sym_is_null(value)) { ctx->done = true; - }/* Pushed outputs */ + } break; } case _LOAD_FAST: { _Py_UopsSymbol *value; - value = GETLOCAL(oparg);/* Pushed outputs */ + value = GETLOCAL(oparg); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -46,7 +46,7 @@ _Py_UopsSymbol *value; value = GETLOCAL(oparg); _Py_UopsSymbol *temp = sym_new_null(ctx); - GETLOCAL(oparg) = temp;/* Pushed outputs */ + GETLOCAL(oparg) = temp; stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -58,7 +58,7 @@ PyObject *val = PyTuple_GET_ITEM(co->co_consts, this_instr->oparg); int opcode = _Py_IsImmortal(val) ? _LOAD_CONST_INLINE_BORROW : _LOAD_CONST_INLINE; REPLACE_OP(this_instr, opcode, 0, (uintptr_t)val); - value = sym_new_const(ctx, val);/* Pushed outputs */ + value = sym_new_const(ctx, val); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -68,7 +68,7 @@ case _STORE_FAST: { _Py_UopsSymbol *value; value = stack_pointer[-1]; - GETLOCAL(oparg) = value;/* Pushed outputs */ + GETLOCAL(oparg) = value; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -81,7 +81,7 @@ case _PUSH_NULL: { _Py_UopsSymbol *res; - res = sym_new_null(ctx);/* Pushed outputs */ + res = sym_new_null(ctx); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -117,7 +117,7 @@ int opt = optimize_to_bool(this_instr, ctx, value, &res); if (!opt) { res = sym_new_type(ctx, &PyBool_Type); - }/* Pushed outputs */ + } break; } @@ -129,7 +129,7 @@ if (!opt) { sym_set_type(value, &PyBool_Type); res = value; - }/* Pushed outputs */ + } break; } @@ -141,7 +141,7 @@ if (!opt) { sym_set_type(value, &PyLong_Type); res = sym_new_type(ctx, &PyBool_Type); - }/* Pushed outputs */ + } break; } @@ -153,7 +153,7 @@ if (!opt) { sym_set_type(value, &PyList_Type); res = sym_new_type(ctx, &PyBool_Type); - }/* Pushed outputs */ + } break; } @@ -165,7 +165,7 @@ if (!opt) { sym_set_const(value, Py_None); res = sym_new_const(ctx, Py_False); - }/* Pushed outputs */ + } break; } @@ -177,7 +177,7 @@ if (!opt) { res = sym_new_type(ctx, &PyBool_Type); sym_set_type(value, &PyUnicode_Type); - }/* Pushed outputs */ + } break; } @@ -214,7 +214,7 @@ } } sym_set_type(left, &PyLong_Type); - sym_set_type(right, &PyLong_Type);/* Pushed outputs */ + sym_set_type(right, &PyLong_Type); break; } @@ -251,7 +251,7 @@ } else { res = sym_new_type(ctx, &PyLong_Type); - }/* Pushed outputs */ + } stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -281,7 +281,7 @@ } else { res = sym_new_type(ctx, &PyLong_Type); - }/* Pushed outputs */ + } stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -311,7 +311,7 @@ } else { res = sym_new_type(ctx, &PyLong_Type); - }/* Pushed outputs */ + } stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -337,7 +337,7 @@ } } sym_set_type(left, &PyFloat_Type); - sym_set_type(right, &PyFloat_Type);/* Pushed outputs */ + sym_set_type(right, &PyFloat_Type); break; } @@ -375,7 +375,7 @@ } else { res = sym_new_type(ctx, &PyFloat_Type); - }/* Pushed outputs */ + } stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -406,7 +406,7 @@ } else { res = sym_new_type(ctx, &PyFloat_Type); - }/* Pushed outputs */ + } stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -437,7 +437,7 @@ } else { res = sym_new_type(ctx, &PyFloat_Type); - }/* Pushed outputs */ + } stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -454,7 +454,7 @@ REPLACE_OP(this_instr, _NOP, 0 ,0); } sym_set_type(left, &PyUnicode_Type); - sym_set_type(left, &PyUnicode_Type);/* Pushed outputs */ + sym_set_type(left, &PyUnicode_Type); break; } @@ -475,7 +475,7 @@ } else { res = sym_new_type(ctx, &PyUnicode_Type); - }/* Pushed outputs */ + } stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -559,7 +559,7 @@ (void)container; (void)sub; new_frame = NULL; - ctx->done = true;/* Pushed outputs */ + ctx->done = true; stack_pointer[-2] = (_Py_UopsSymbol *)new_frame; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -641,7 +641,7 @@ if (co == NULL) { // might be impossible, but bailing is still safe ctx->done = true; - }/* Pushed outputs */ + } break; } @@ -670,13 +670,13 @@ case _SEND_GEN_FRAME: { // We are about to hit the end of the trace: - ctx->done = true;/* Pushed outputs */ + ctx->done = true; break; } case _YIELD_VALUE: { _Py_UopsSymbol *res; - res = sym_new_unknown(ctx);/* Pushed outputs */ + res = sym_new_unknown(ctx); stack_pointer[-1] = res; break; } @@ -710,13 +710,13 @@ case _UNPACK_SEQUENCE: { _Py_UopsSymbol *seq; _Py_UopsSymbol **values; - values = &stack_pointer[0]; seq = stack_pointer[-1]; + values = &stack_pointer[-1]; /* This has to be done manually */ (void)seq; for (int i = 0; i < oparg; i++) { values[i] = sym_new_unknown(ctx); - }/* Pushed outputs */ + } stack_pointer += -1 + oparg; assert(WITHIN_STACK_BOUNDS()); break; @@ -733,8 +733,8 @@ case _UNPACK_SEQUENCE_TUPLE: { _Py_UopsSymbol **values; - values = &stack_pointer[0]; seq = stack_pointer[-1]; + values = &stack_pointer[-1]; for (int _i = oparg; --_i >= 0;) { values[_i] = sym_new_not_null(ctx); } @@ -743,8 +743,8 @@ case _UNPACK_SEQUENCE_LIST: { _Py_UopsSymbol **values; - values = &stack_pointer[0]; seq = stack_pointer[-1]; + values = &stack_pointer[-1]; for (int _i = oparg; --_i >= 0;) { values[_i] = sym_new_not_null(ctx); } @@ -754,14 +754,14 @@ case _UNPACK_EX: { _Py_UopsSymbol *seq; _Py_UopsSymbol **values; - values = &stack_pointer[0]; seq = stack_pointer[-1]; + values = &stack_pointer[-1]; /* This has to be done manually */ (void)seq; int totalargs = (oparg & 0xFF) + (oparg >> 8) + 1; for (int i = 0; i < totalargs; i++) { values[i] = sym_new_unknown(ctx); - }/* Pushed outputs */ + } stack_pointer += (oparg & 0xFF) + (oparg >> 8); assert(WITHIN_STACK_BOUNDS()); break; @@ -972,7 +972,7 @@ } else { self_or_null = NULL; - }/* Pushed outputs */ + } stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = self_or_null; stack_pointer += (oparg & 1); @@ -1002,7 +1002,7 @@ _Py_BloomFilter_Add(dependencies, type); } } - }/* Pushed outputs */ + } break; } @@ -1020,7 +1020,7 @@ attr = sym_new_not_null(ctx); null = sym_new_null(ctx); (void)offset; - (void)owner;/* Pushed outputs */ + (void)owner; stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); @@ -1045,7 +1045,7 @@ this_instr->opcode = _NOP; } } - }/* Pushed outputs */ + } break; } @@ -1073,7 +1073,7 @@ if (attr == NULL) { /* No conversion made. We don't know what `attr` is. */ attr = sym_new_not_null(ctx); - }/* Pushed outputs */ + } break; } @@ -1091,7 +1091,7 @@ attr = sym_new_not_null(ctx); null = sym_new_null(ctx); (void)hint; - (void)owner;/* Pushed outputs */ + (void)owner; stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); @@ -1108,7 +1108,7 @@ attr = sym_new_not_null(ctx); null = sym_new_null(ctx); (void)index; - (void)owner;/* Pushed outputs */ + (void)owner; stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); @@ -1130,7 +1130,7 @@ attr = sym_new_not_null(ctx); null = sym_new_null(ctx); (void)descr; - (void)owner;/* Pushed outputs */ + (void)owner; stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); @@ -1146,7 +1146,7 @@ (void)fget; (void)owner; new_frame = NULL; - ctx->done = true;/* Pushed outputs */ + ctx->done = true; stack_pointer[-1] = (_Py_UopsSymbol *)new_frame; break; } @@ -1189,7 +1189,7 @@ } else { res = _Py_uop_sym_new_not_null(ctx); - }/* Pushed outputs */ + } stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1204,7 +1204,7 @@ left = stack_pointer[-2]; (void)left; (void)right; - res = sym_new_type(ctx, &PyBool_Type);/* Pushed outputs */ + res = sym_new_type(ctx, &PyBool_Type); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1219,7 +1219,7 @@ left = stack_pointer[-2]; (void)left; (void)right; - res = sym_new_type(ctx, &PyBool_Type);/* Pushed outputs */ + res = sym_new_type(ctx, &PyBool_Type); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1234,7 +1234,7 @@ left = stack_pointer[-2]; (void)left; (void)right; - res = sym_new_type(ctx, &PyBool_Type);/* Pushed outputs */ + res = sym_new_type(ctx, &PyBool_Type); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1249,7 +1249,7 @@ left = stack_pointer[-2]; (void)left; (void)right; - res = sym_new_type(ctx, &PyBool_Type);/* Pushed outputs */ + res = sym_new_type(ctx, &PyBool_Type); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1264,7 +1264,7 @@ left = stack_pointer[-2]; (void)left; (void)right; - res = sym_new_type(ctx, &PyBool_Type);/* Pushed outputs */ + res = sym_new_type(ctx, &PyBool_Type); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -1449,7 +1449,7 @@ _Py_UopsSymbol *next; iter = stack_pointer[-1]; next = sym_new_type(ctx, &PyLong_Type); - (void)iter;/* Pushed outputs */ + (void)iter; stack_pointer[0] = next; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -1458,7 +1458,7 @@ case _FOR_ITER_GEN_FRAME: { /* We are about to hit the end of the trace */ - ctx->done = true;/* Pushed outputs */ + ctx->done = true; break; } @@ -1469,7 +1469,7 @@ owner = stack_pointer[-1]; (void)owner; attr = sym_new_not_null(ctx); - self_or_null = sym_new_unknown(ctx);/* Pushed outputs */ + self_or_null = sym_new_unknown(ctx); stack_pointer[-1] = attr; stack_pointer[0] = self_or_null; stack_pointer += 1; @@ -1514,7 +1514,7 @@ PyObject *descr = (PyObject *)this_instr->operand; (void)descr; attr = sym_new_not_null(ctx); - self = owner;/* Pushed outputs */ + self = owner; stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; @@ -1530,7 +1530,7 @@ PyObject *descr = (PyObject *)this_instr->operand; (void)descr; attr = sym_new_not_null(ctx); - self = owner;/* Pushed outputs */ + self = owner; stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; @@ -1565,7 +1565,7 @@ PyObject *descr = (PyObject *)this_instr->operand; (void)descr; attr = sym_new_not_null(ctx); - self = owner;/* Pushed outputs */ + self = owner; stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; @@ -1579,15 +1579,15 @@ _Py_UopsSymbol *callable; _Py_UopsSymbol *func; _Py_UopsSymbol *maybe_self; - args = &stack_pointer[2]; args = &stack_pointer[-oparg]; self_or_null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; + args = &stack_pointer[-oparg]; (void)callable; (void)self_or_null; (void)args; func = sym_new_not_null(ctx); - maybe_self = sym_new_not_null(ctx);/* Pushed outputs */ + maybe_self = sym_new_not_null(ctx); stack_pointer[-2 - oparg] = func; stack_pointer[-1 - oparg] = maybe_self; break; @@ -1610,7 +1610,7 @@ (void)self_or_null; (void)args; new_frame = NULL; - ctx->done = true;/* Pushed outputs */ + ctx->done = true; stack_pointer[-2 - oparg] = (_Py_UopsSymbol *)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1618,23 +1618,26 @@ } case _CHECK_FUNCTION_VERSION: { - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; break; } case _CHECK_METHOD_VERSION: { null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; break; } case _EXPAND_METHOD: { - _Py_UopsSymbol *method; + _Py_UopsSymbol **method; _Py_UopsSymbol **self; - self = &stack_pointer[1]; null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; - method = sym_new_not_null(ctx); + callable = &stack_pointer[-2 - oparg]; + method = &stack_pointer[-2 - oparg]; + self = &stack_pointer[-1 - oparg]; + for (int _i = 1; --_i >= 0;) { + method[_i] = sym_new_not_null(ctx); + } for (int _i = 1; --_i >= 0;) { self[_i] = sym_new_not_null(ctx); } @@ -1642,7 +1645,7 @@ } case _CHECK_IS_NOT_PY_CALLABLE: { - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; break; } @@ -1650,7 +1653,7 @@ _Py_UopsSymbol *res; args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); break; } @@ -1661,7 +1664,7 @@ null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; sym_set_null(null); - sym_set_type(callable, &PyMethod_Type);/* Pushed outputs */ + sym_set_type(callable, &PyMethod_Type); break; } @@ -1672,7 +1675,7 @@ callable = stack_pointer[-2 - oparg]; (void)callable; func = sym_new_not_null(ctx); - self = sym_new_not_null(ctx);/* Pushed outputs */ + self = sym_new_not_null(ctx); stack_pointer[-2 - oparg] = func; stack_pointer[-1 - oparg] = self; break; @@ -1683,7 +1686,7 @@ * all executors, so no need to check dynamically */ if (_PyInterpreterState_GET()->eval_frame == NULL) { REPLACE_OP(this_instr, _NOP, 0 ,0); - }/* Pushed outputs */ + } break; } @@ -1693,13 +1696,13 @@ self_or_null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; sym_set_type(callable, &PyFunction_Type); - (void)self_or_null;/* Pushed outputs */ + (void)self_or_null; break; } case _CHECK_STACK_SPACE: { assert(corresponding_check_stack == NULL); - corresponding_check_stack = this_instr;/* Pushed outputs */ + corresponding_check_stack = this_instr; break; } @@ -1743,7 +1746,7 @@ new_frame = frame_new(ctx, co, 0, args, argcount); } else { new_frame = frame_new(ctx, co, 0, NULL, 0); - }/* Pushed outputs */ + } break; } @@ -1779,7 +1782,7 @@ // delete all but the first valid _CHECK_STACK_SPACE corresponding_check_stack->opcode = _NOP; } - corresponding_check_stack = NULL;/* Pushed outputs */ + corresponding_check_stack = NULL; break; } @@ -1816,17 +1819,17 @@ _Py_UopsSymbol *callable; _Py_UopsSymbol *self; _Py_UopsSymbol *init; - args = &stack_pointer[2]; args = &stack_pointer[-oparg]; null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; + args = &stack_pointer[-oparg]; uint32_t type_version = (uint32_t)this_instr->operand; (void)type_version; (void)callable; (void)null; (void)args; self = sym_new_not_null(ctx); - init = sym_new_not_null(ctx);/* Pushed outputs */ + init = sym_new_not_null(ctx); stack_pointer[-2 - oparg] = self; stack_pointer[-1 - oparg] = init; break; @@ -1844,7 +1847,7 @@ (void)init; (void)args; init_frame = NULL; - ctx->done = true;/* Pushed outputs */ + ctx->done = true; stack_pointer[-2 - oparg] = (_Py_UopsSymbol *)init_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1860,7 +1863,7 @@ _Py_UopsSymbol *res; args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); break; } @@ -1869,7 +1872,7 @@ _Py_UopsSymbol *res; args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); break; } @@ -1878,7 +1881,7 @@ _Py_UopsSymbol *res; args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); break; } @@ -1887,7 +1890,7 @@ _Py_UopsSymbol *res; args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); break; } @@ -1896,7 +1899,7 @@ _Py_UopsSymbol *res; args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); break; } @@ -1905,7 +1908,7 @@ _Py_UopsSymbol *res; args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); break; } @@ -1921,7 +1924,7 @@ _Py_UopsSymbol *res; args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); break; } @@ -1930,7 +1933,7 @@ _Py_UopsSymbol *res; args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); break; } @@ -1939,7 +1942,7 @@ _Py_UopsSymbol *res; args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); break; } @@ -1948,7 +1951,7 @@ _Py_UopsSymbol *res; args = &stack_pointer[-oparg]; self_or_null = &stack_pointer[-1 - oparg]; - callable = stack_pointer[-2 - oparg]; + callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); break; } @@ -1956,16 +1959,19 @@ /* _INSTRUMENTED_CALL_KW is not a viable micro-op for tier 2 */ case _MAYBE_EXPAND_METHOD_KW: { - _Py_UopsSymbol *func; + _Py_UopsSymbol **func; _Py_UopsSymbol **maybe_self; _Py_UopsSymbol **args; _Py_UopsSymbol *kwnames_out; - maybe_self = &stack_pointer[1]; kwnames_in = stack_pointer[-1]; args = &stack_pointer[-1 - oparg]; self_or_null = &stack_pointer[-2 - oparg]; - callable = stack_pointer[-3 - oparg]; - func = sym_new_not_null(ctx); + callable = &stack_pointer[-3 - oparg]; + func = &stack_pointer[-3 - oparg]; + maybe_self = &stack_pointer[-2 - oparg]; + for (int _i = 1; --_i >= 0;) { + func[_i] = sym_new_not_null(ctx); + } for (int _i = 1; --_i >= 0;) { maybe_self[_i] = sym_new_not_null(ctx); } @@ -1993,7 +1999,7 @@ (void)args; (void)kwnames; new_frame = NULL; - ctx->done = true;/* Pushed outputs */ + ctx->done = true; stack_pointer[-3 - oparg] = (_Py_UopsSymbol *)new_frame; stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2001,23 +2007,26 @@ } case _CHECK_FUNCTION_VERSION_KW: { - callable = stack_pointer[-3 - oparg]; + callable = &stack_pointer[-3 - oparg]; break; } case _CHECK_METHOD_VERSION_KW: { null = &stack_pointer[-2 - oparg]; - callable = stack_pointer[-3 - oparg]; + callable = &stack_pointer[-3 - oparg]; break; } case _EXPAND_METHOD_KW: { - _Py_UopsSymbol *method; + _Py_UopsSymbol **method; _Py_UopsSymbol **self; - self = &stack_pointer[1]; null = &stack_pointer[-2 - oparg]; - callable = stack_pointer[-3 - oparg]; - method = sym_new_not_null(ctx); + callable = &stack_pointer[-3 - oparg]; + method = &stack_pointer[-3 - oparg]; + self = &stack_pointer[-2 - oparg]; + for (int _i = 1; --_i >= 0;) { + method[_i] = sym_new_not_null(ctx); + } for (int _i = 1; --_i >= 0;) { self[_i] = sym_new_not_null(ctx); } @@ -2025,7 +2034,7 @@ } case _CHECK_IS_NOT_PY_CALLABLE_KW: { - callable = stack_pointer[-3 - oparg]; + callable = &stack_pointer[-3 - oparg]; break; } @@ -2034,14 +2043,25 @@ kwnames = stack_pointer[-1]; args = &stack_pointer[-1 - oparg]; self_or_null = &stack_pointer[-2 - oparg]; - callable = stack_pointer[-3 - oparg]; + callable = &stack_pointer[-3 - oparg]; res = sym_new_not_null(ctx); break; } /* _INSTRUMENTED_CALL_FUNCTION_EX is not a viable micro-op for tier 2 */ - /* __DO_CALL_FUNCTION_EX is not a viable micro-op for tier 2 */ + case _MAKE_CALLARGS_A_TUPLE: { + _Py_UopsSymbol *tuple; + _Py_UopsSymbol *kwargs_out = NULL; + if (oparg & 1) { kwargs_in = stack_pointer[-(oparg & 1)]; } + callargs = stack_pointer[-1 - (oparg & 1)]; + func = stack_pointer[-3 - (oparg & 1)]; + tuple = sym_new_not_null(ctx); + kwargs_out = sym_new_not_null(ctx); + break; + } + + /* _DO_CALL_FUNCTION_EX is not a viable micro-op for tier 2 */ case _MAKE_FUNCTION: { _Py_UopsSymbol *func; @@ -2075,7 +2095,7 @@ if (co == NULL) { // might be impossible, but bailing is still safe ctx->done = true; - }/* Pushed outputs */ + } break; } @@ -2115,7 +2135,7 @@ _Py_UopsSymbol *top; bottom = stack_pointer[-1 - (oparg-1)]; assert(oparg > 0); - top = bottom;/* Pushed outputs */ + top = bottom; stack_pointer[0] = top; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2145,7 +2165,7 @@ } else { res = sym_new_unknown(ctx); - }/* Pushed outputs */ + } stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -2160,7 +2180,7 @@ top_in = stack_pointer[-1]; bottom_in = stack_pointer[-2 - (oparg-2)]; bottom_out = bottom_in; - top_out = top_in;/* Pushed outputs */ + top_out = top_in; stack_pointer[-2 - (oparg-2)] = top_out; stack_pointer[-1] = bottom_out; break; @@ -2189,7 +2209,7 @@ PyObject *value = sym_get_const(flag); assert(value != NULL); eliminate_pop_guard(this_instr, value != Py_True); - }/* Pushed outputs */ + } break; } @@ -2200,7 +2220,7 @@ PyObject *value = sym_get_const(flag); assert(value != NULL); eliminate_pop_guard(this_instr, value != Py_False); - }/* Pushed outputs */ + } break; } @@ -2215,7 +2235,7 @@ else if (sym_has_type(flag)) { assert(!sym_matches_type(flag, &_PyNone_Type)); eliminate_pop_guard(this_instr, true); - }/* Pushed outputs */ + } break; } @@ -2230,12 +2250,12 @@ else if (sym_has_type(flag)) { assert(!sym_matches_type(flag, &_PyNone_Type)); eliminate_pop_guard(this_instr, false); - }/* Pushed outputs */ + } break; } case _JUMP_TO_TOP: { - ctx->done = true;/* Pushed outputs */ + ctx->done = true; break; } @@ -2248,7 +2268,7 @@ (void)framesize; /* We should never see _CHECK_STACK_SPACE_OPERANDs. * They are only created at the end of this pass. */ - Py_UNREACHABLE();/* Pushed outputs */ + Py_UNREACHABLE(); break; } @@ -2259,7 +2279,7 @@ case _EXIT_TRACE: { PyObject *exit_p = (PyObject *)this_instr->operand; (void)exit_p; - ctx->done = true;/* Pushed outputs */ + ctx->done = true; break; } @@ -2270,7 +2290,7 @@ case _LOAD_CONST_INLINE: { _Py_UopsSymbol *value; PyObject *ptr = (PyObject *)this_instr->operand; - value = sym_new_const(ctx, ptr);/* Pushed outputs */ + value = sym_new_const(ctx, ptr); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2280,7 +2300,7 @@ case _LOAD_CONST_INLINE_BORROW: { _Py_UopsSymbol *value; PyObject *ptr = (PyObject *)this_instr->operand; - value = sym_new_const(ctx, ptr);/* Pushed outputs */ + value = sym_new_const(ctx, ptr); stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2299,7 +2319,7 @@ _Py_UopsSymbol *null; PyObject *ptr = (PyObject *)this_instr->operand; value = sym_new_const(ctx, ptr); - null = sym_new_null(ctx);/* Pushed outputs */ + null = sym_new_null(ctx); stack_pointer[0] = value; stack_pointer[1] = null; stack_pointer += 2; @@ -2312,7 +2332,7 @@ _Py_UopsSymbol *null; PyObject *ptr = (PyObject *)this_instr->operand; value = sym_new_const(ctx, ptr); - null = sym_new_null(ctx);/* Pushed outputs */ + null = sym_new_null(ctx); stack_pointer[0] = value; stack_pointer[1] = null; stack_pointer += 2; diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 66f24ae1f6ceab..215e834db09cde 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -176,14 +176,12 @@ def error_if( next(tkn_iter) # RPAREN next(tkn_iter) # Semi colon self.out.emit(") ") - if storage.locals_cached(): + storage.clear_inputs("at ERROR_IF") + c_offset = storage.stack.peek_offset() + try: + offset = -int(c_offset) + except ValueError: offset = -1 - else: - c_offset = storage.stack.peek_offset() - try: - offset = -int(c_offset) - except ValueError: - offset = -1 if offset > 0: self.out.emit(f"goto pop_{offset}_") self.out.emit(label) @@ -299,16 +297,12 @@ def stackref_close( self.out.emit(tkn) name = next(tkn_iter) self.out.emit(name) - rparen = next(tkn_iter) - self.out.emit(rparen) - if rparen.kind == "RPAREN": - if name.kind == "IDENTIFIER": - for var in storage.inputs: - if var.name == name.text: - var.defined = False - else: - rparen = emit_to(self.out, tkn_iter, "RPAREN") - self.emit(rparen) + if name.kind == "IDENTIFIER": + for var in storage.inputs: + if var.name == name.text: + var.defined = False + rparen = emit_to(self.out, tkn_iter, "RPAREN") + self.emit(rparen) return True stackref_steal = stackref_close @@ -512,7 +506,6 @@ def emit_tokens( _, rbrace, storage = self._emit_block(tkn_iter, uop, storage, inst, False) try: storage.push_outputs() - self.emit("/* Pushed outputs */") self._print_storage(storage) except StackError as ex: raise analysis_error(ex.args[0], rbrace) diff --git a/Tools/cases_generator/optimizer_generator.py b/Tools/cases_generator/optimizer_generator.py index 16fdb9ad162221..000a35f4253996 100644 --- a/Tools/cases_generator/optimizer_generator.py +++ b/Tools/cases_generator/optimizer_generator.py @@ -113,7 +113,6 @@ def write_uop( prototype = override if override else uop try: out.start_line() - out.emit(stack.define_output_arrays(prototype.stack.outputs)) code_list, storage = Storage.for_uop(stack, prototype) for code in code_list: out.emit(code) diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index 0e1752eae65983..32575091d8e5da 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -49,6 +49,12 @@ class Local: def __repr__(self): return f"Local('{self.item.name}', mem={self.in_memory}, defined={self.defined}, array={self.is_array()})" + def compact_str(self) -> str: + mtag = "M" if self.in_memory else "" + dtag = "D" if self.defined else "" + atag = "A" if self.is_array() else "" + return f"'{self.item.name}'{mtag}{dtag}{atag}" + @staticmethod def unused(defn: StackItem) -> "Local": return Local(defn, False, defn.is_array(), False) @@ -285,18 +291,6 @@ def push(self, var: Local) -> None: if var.item.used: self.defined.add(var.name) - def define_output_arrays(self, outputs: list[StackItem]) -> str: - res = [] - top_offset = self.top_offset.copy() - for var in outputs: - if var.is_array() and var.used and not var.peek: - c_offset = top_offset.to_c() - top_offset.push(var) - res.append(f"{var.name} = &stack_pointer[{c_offset}];\n") - else: - top_offset.push(var) - return "\n".join(res) - @staticmethod def _do_emit( out: CWriter, @@ -344,10 +338,9 @@ def peek_offset(self) -> str: return self.top_offset.to_c() def as_comment(self) -> str: - variables = ", ".join([str(v) for v in self.variables]) + variables = ", ".join([v.compact_str() for v in self.variables]) return ( - f"/* Variables: {variables}. " - f"Base offset: {self.base_offset.to_c()}. Top offset: {self.top_offset.to_c()} */" + f"/* Variables: {variables}. base: {self.base_offset.to_c()}. top: {self.top_offset.to_c()} */" ) def copy(self) -> "Stack": @@ -438,14 +431,19 @@ def needs_defining(var: Local): def is_live(var: Local): return ( var.defined and - not var.is_array() and var.name != "unused" ) + def first_input_not_cleared(self) -> str: + for input in self.inputs: + if input.defined: + return input.name + return "" + def clear_inputs(self, reason:str) -> None: while self.inputs: tos = self.inputs.pop() - if self.is_live(tos): + if self.is_live(tos) and not tos.is_array(): raise StackError( f"Input '{tos.name}' is still live {reason}" ) @@ -532,6 +530,14 @@ def for_uop(stack: Stack, uop: Uop) -> tuple[list[str], "Storage"]: peeks.reverse() for var in peeks: stack.push(var) + top_offset = stack.top_offset.copy() + for var in uop.stack.outputs: + if var.is_array() and var.used and not var.peek: + c_offset = top_offset.to_c() + top_offset.push(var) + code_list.append(f"{var.name} = &stack_pointer[{c_offset}];\n") + else: + top_offset.push(var) for var in inputs: stack.push(var) outputs = [ Local.undefined(var) for var in uop.stack.outputs if not var.peek ] @@ -611,7 +617,7 @@ def push_outputs(self): def as_comment(self) -> str: stack_comment = self.stack.as_comment() next_line = "\n " - inputs = ", ".join([str(var) for var in self.inputs]) - outputs = ", ".join([str(var) for var in self.outputs]) + inputs = ", ".join([var.compact_str() for var in self.inputs]) + outputs = ", ".join([var.compact_str() for var in self.outputs]) peeks = ", ".join([var.name for var in self.peeks]) return f"{stack_comment[:-2]}{next_line}inputs: {inputs}{next_line}outputs: {outputs}{next_line}peeks: {peeks} */" diff --git a/Tools/cases_generator/tier1_generator.py b/Tools/cases_generator/tier1_generator.py index 738b89935115fb..279d80efeb2626 100644 --- a/Tools/cases_generator/tier1_generator.py +++ b/Tools/cases_generator/tier1_generator.py @@ -89,7 +89,6 @@ def write_uop( emitter.emit("{\n") code_list, storage = Storage.for_uop(stack, uop) emitter._print_storage(storage) - emitter.emit(stack.define_output_arrays(uop.stack.outputs)) for code in code_list: emitter.emit(code) diff --git a/Tools/cases_generator/tier2_generator.py b/Tools/cases_generator/tier2_generator.py index 30504e4270ae63..e9d3503b160e05 100644 --- a/Tools/cases_generator/tier2_generator.py +++ b/Tools/cases_generator/tier2_generator.py @@ -178,7 +178,6 @@ def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> None: elif uop.properties.const_oparg >= 0: emitter.emit(f"oparg = {uop.properties.const_oparg};\n") emitter.emit(f"assert(oparg == CURRENT_OPARG());\n") - emitter.emit(stack.define_output_arrays(uop.stack.outputs)) code_list, storage = Storage.for_uop(stack, uop) for code in code_list: emitter.emit(code) From c95d36709cea907b5d5f1e1ca6fe280cb7ca6608 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Mon, 16 Sep 2024 17:37:37 +0100 Subject: [PATCH 30/53] Fix tests --- Lib/test/test_generated_cases.py | 105 +++++++++++++++------ Lib/test/test_monitoring.py | 3 - Tools/cases_generator/generators_common.py | 3 +- Tools/cases_generator/stack.py | 2 + 4 files changed, 80 insertions(+), 33 deletions(-) diff --git a/Lib/test/test_generated_cases.py b/Lib/test/test_generated_cases.py index 8d18786701a6b9..f089c3c929359b 100644 --- a/Lib/test/test_generated_cases.py +++ b/Lib/test/test_generated_cases.py @@ -140,6 +140,7 @@ def test_inst_one_pop(self): input = """ inst(OP, (value --)) { spam(value); + KILL(value); } """ output = """ @@ -182,6 +183,7 @@ def test_inst_one_push_one_pop(self): input = """ inst(OP, (value -- res)) { res = spam(value); + KILL(value); } """ output = """ @@ -203,6 +205,8 @@ def test_binary_op(self): input = """ inst(OP, (left, right -- res)) { res = spam(left, right); + KILL_INPUTS(); + } """ output = """ @@ -228,6 +232,7 @@ def test_overlap(self): input = """ inst(OP, (left, right -- left, result)) { result = spam(left, right); + KILL_INPUTS(); } """ output = """ @@ -319,12 +324,8 @@ def test_sync_sp(self): INSTRUCTION_STATS(B); _PyStackRef res; res = Py_None; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; escaping_call(); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); DISPATCH(); } """ @@ -384,6 +385,7 @@ def test_error_if_pop(self): input = """ inst(OP, (left, right -- res)) { spam(left, right); + KILL_INPUTS(); ERROR_IF(cond, label); res = 0; } @@ -413,6 +415,7 @@ def test_error_if_pop_with_result(self): input = """ inst(OP, (left, right -- res)) { res = spam(left, right); + KILL_INPUTS(); ERROR_IF(cond, label); } """ @@ -427,12 +430,7 @@ def test_error_if_pop_with_result(self): right = stack_pointer[-1]; left = stack_pointer[-2]; res = spam(left, right); - if (cond) { - stack_pointer[-2] = res; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - goto label; - } + if (cond) goto pop_2_label; stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -486,10 +484,12 @@ def test_macro_instruction(self): } op(OP2, (extra/2, arg2, left, right -- res)) { res = op2(arg2, left, right); + KILL_INPUTS(); } macro(OP) = OP1 + cache/2 + OP2; inst(OP3, (unused/5, arg2, left, right -- res)) { res = op3(arg2, left, right); + KILL_INPUTS(); } family(OP, INLINE_CACHE_ENTRIES_OP) = { OP3 }; """ @@ -506,17 +506,17 @@ def test_macro_instruction(self): _PyStackRef arg2; _PyStackRef res; // _OP1 - right = stack_pointer[-1]; - left = stack_pointer[-2]; { + right = stack_pointer[-1]; + left = stack_pointer[-2]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; op1(left, right); } /* Skip 2 cache entries */ // OP2 - arg2 = stack_pointer[-3]; { + arg2 = stack_pointer[-3]; uint32_t extra = read_u32(&this_instr[4].cache); (void)extra; res = op2(arg2, left, right); @@ -723,6 +723,7 @@ def test_cond_effect(self): input = """ inst(OP, (aa, input if ((oparg & 1) == 1), cc -- xx, output if (oparg & 2), zz)) { output = spam(oparg, aa, cc, input); + KILL_INPUTS(); xx = 0; zz = 0; } @@ -758,11 +759,13 @@ def test_macro_cond_effect(self): input = """ op(A, (left, middle, right --)) { use(left, middle, right); + KILL_INPUTS(); } op(B, (-- deep, extra if (oparg), res)) { deep = -1; res = 0; extra = 1; + KILL_INPUTS(); } macro(M) = A + B; """ @@ -778,10 +781,10 @@ def test_macro_cond_effect(self): _PyStackRef extra = PyStackRef_NULL; _PyStackRef res; // A - right = stack_pointer[-1]; - middle = stack_pointer[-2]; - left = stack_pointer[-3]; { + right = stack_pointer[-1]; + middle = stack_pointer[-2]; + left = stack_pointer[-3]; use(left, middle, right); } // B @@ -954,6 +957,7 @@ def test_pointer_to_stackref(self): input = """ inst(OP, (arg: _PyStackRef * -- out)) { out = *arg; + KILL(arg); } """ output = """ @@ -1094,6 +1098,7 @@ def test_flush(self): op(SECOND, (a, b -- )) { use(a, b); + KILL_INPUTS(); } macro(TEST) = FIRST + flush + SECOND; @@ -1140,7 +1145,7 @@ def test_pop_on_error_peeks(self): } op(THIRD, (j, k --)) { - j,k; // Mark j and k as used + KILL_INPUTS(); // Mark j and k as used ERROR_IF(cond, error); } @@ -1155,12 +1160,10 @@ def test_pop_on_error_peeks(self): _PyStackRef y; _PyStackRef a; _PyStackRef b; - _PyStackRef j; - _PyStackRef k; // FIRST - y = stack_pointer[-1]; - x = stack_pointer[-2]; { + y = stack_pointer[-1]; + x = stack_pointer[-2]; a = x; b = y; } @@ -1168,10 +1171,8 @@ def test_pop_on_error_peeks(self): { } // THIRD - k = b; - j = a; { - j,k; // Mark j and k as used + // Mark j and k as used if (cond) goto pop_2_error; } stack_pointer += -2; @@ -1265,7 +1266,7 @@ def test_array_size_inconsistency(self): with self.assertRaises(SyntaxError): self.run_cases_test(input, output) - def test_save_reload(self): + def test_stack_save_reload(self): input = """ inst(BALANCED, ( -- )) { @@ -1275,9 +1276,59 @@ def test_save_reload(self): """ output = """ + TARGET(BALANCED) { + frame->instr_ptr = next_instr; + next_instr += 1; + INSTRUCTION_STATS(BALANCED); + _PyFrame_SetStackPointer(frame, stack_pointer); + stack_pointer = _PyFrame_GetStackPointer(frame); + DISPATCH(); + } """ self.run_cases_test(input, output) + def test_stack_reload_only(self): + + input = """ + inst(BALANCED, ( -- )) { + RELOAD_STACK(); + } + """ + + output = """ + TARGET(BALANCED) { + frame->instr_ptr = next_instr; + next_instr += 1; + INSTRUCTION_STATS(BALANCED); + _PyFrame_SetStackPointer(frame, stack_pointer); + stack_pointer = _PyFrame_GetStackPointer(frame); + DISPATCH(); + } + """ + with self.assertRaises(SyntaxError): + self.run_cases_test(input, output) + + def test_stack_save_only(self): + + input = """ + inst(BALANCED, ( -- )) { + SAVE_STACK(); + } + """ + + output = """ + TARGET(BALANCED) { + frame->instr_ptr = next_instr; + next_instr += 1; + INSTRUCTION_STATS(BALANCED); + _PyFrame_SetStackPointer(frame, stack_pointer); + stack_pointer = _PyFrame_GetStackPointer(frame); + DISPATCH(); + } + """ + with self.assertRaises(SyntaxError): + self.run_cases_test(input, output) + class TestGeneratedAbstractCases(unittest.TestCase): def setUp(self) -> None: @@ -1374,7 +1425,6 @@ def test_overridden_abstract_args(self): case OP2: { _Py_UopsSymbol *out; out = sym_new_not_null(ctx); - stack_pointer[-1] = out; break; } """ @@ -1399,7 +1449,6 @@ def test_no_overridden_case(self): case OP: { _Py_UopsSymbol *out; out = sym_new_not_null(ctx); - stack_pointer[-1] = out; break; } diff --git a/Lib/test/test_monitoring.py b/Lib/test/test_monitoring.py index e84a65126f8fae..28813080857af4 100644 --- a/Lib/test/test_monitoring.py +++ b/Lib/test/test_monitoring.py @@ -744,8 +744,6 @@ def get_events(self, func, tool, recorders): def check_events(self, func, expected, tool=TEST_TOOL, recorders=(ExceptionRecorder,)): events = self.get_events(func, tool, recorders) - if events != expected: - print(events, file = sys.stderr) self.assertEqual(events, expected) def check_balanced(self, func, recorders): @@ -2088,7 +2086,6 @@ def test_fire_event_failing_callback(self): args_ = (self.codelike, offset) + tuple(args) exc = OSError(42) with self.assertRaises(type(exc)): - print(event) self.check_event_count(event, function, args_, expected, callback_raises=exc) diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 215e834db09cde..d9f5a523a71697 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -273,8 +273,7 @@ def kill( name_tkn = next(tkn_iter) name = name_tkn.text next(tkn_iter) - self.out.emit("(void)") - self.out.emit(name_tkn) + next(tkn_iter) for var in storage.inputs: if var.name == name: var.defined = False diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index 32575091d8e5da..df4e9a227dfbc2 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -506,6 +506,8 @@ def save(self, out: CWriter) -> None: self.spilled += 1 def reload(self, out: CWriter) -> None: + if self.spilled == 0: + raise StackError("Cannot reload stack as it hasn't been saved") assert self.spilled > 0 self.spilled -= 1 if self.spilled == 0: From dd0e9f62d3b4c7e42099e4b00c25a12b2b37ecaa Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Tue, 17 Sep 2024 13:50:21 +0100 Subject: [PATCH 31/53] Fix up tier 2 and optimizer generators --- Lib/test/test_generated_cases.py | 14 +- Python/bytecodes.c | 6 +- Python/ceval.c | 4 +- Python/executor_cases.c.h | 500 +++----- Python/generated_cases.c.h | 168 ++- Python/optimizer.c | 2 +- Python/optimizer_bytecodes.c | 8 +- Python/optimizer_cases.c.h | 1172 ++++++++++++++---- Tools/cases_generator/generators_common.py | 5 +- Tools/cases_generator/optimizer_generator.py | 44 +- Tools/cases_generator/stack.py | 18 +- Tools/cases_generator/tier1_generator.py | 4 +- Tools/cases_generator/tier2_generator.py | 11 +- 13 files changed, 1285 insertions(+), 671 deletions(-) diff --git a/Lib/test/test_generated_cases.py b/Lib/test/test_generated_cases.py index f089c3c929359b..c80bb4252d5f90 100644 --- a/Lib/test/test_generated_cases.py +++ b/Lib/test/test_generated_cases.py @@ -1402,22 +1402,23 @@ def test_overridden_abstract(self): def test_overridden_abstract_args(self): input = """ pure op(OP, (arg1 -- out)) { - spam(); + out = spam(arg1); } op(OP2, (arg1 -- out)) { - eggs(); + out = eggs(arg1); } """ input2 = """ op(OP, (arg1 -- out)) { - out = eggs(); + out = eggs(arg1); } """ output = """ case OP: { _Py_UopsSymbol *arg1; _Py_UopsSymbol *out; - out = eggs(); + arg1 = stack_pointer[-1]; + out = eggs(arg1); stack_pointer[-1] = out; break; } @@ -1425,6 +1426,7 @@ def test_overridden_abstract_args(self): case OP2: { _Py_UopsSymbol *out; out = sym_new_not_null(ctx); + stack_pointer[-1] = out; break; } """ @@ -1433,7 +1435,7 @@ def test_overridden_abstract_args(self): def test_no_overridden_case(self): input = """ pure op(OP, (arg1 -- out)) { - spam(); + out = spam(arg1); } pure op(OP2, (arg1 -- out)) { @@ -1449,11 +1451,11 @@ def test_no_overridden_case(self): case OP: { _Py_UopsSymbol *out; out = sym_new_not_null(ctx); + stack_pointer[-1] = out; break; } case OP2: { - _Py_UopsSymbol *arg1; _Py_UopsSymbol *out; out = NULL; stack_pointer[-1] = out; diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 7cbc3a36e33619..2aa16f6dfae297 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -4730,12 +4730,14 @@ dummy_func( op (_GUARD_IS_TRUE_POP, (flag -- )) { int is_true = PyStackRef_Is(flag, PyStackRef_True); KILL(flag); + SYNC_SP(); EXIT_IF(!is_true); } op (_GUARD_IS_FALSE_POP, (flag -- )) { int is_false = PyStackRef_Is(flag, PyStackRef_False); KILL(flag); + SYNC_SP(); EXIT_IF(!is_false); } @@ -4743,6 +4745,7 @@ dummy_func( int is_none = PyStackRef_Is(val, PyStackRef_None); if (!is_none) { PyStackRef_CLOSE(val); + SYNC_SP(); EXIT_IF(1); } KILL(val); @@ -4750,8 +4753,9 @@ dummy_func( op (_GUARD_IS_NOT_NONE_POP, (val -- )) { int is_none = PyStackRef_Is(val, PyStackRef_None); - EXIT_IF(is_none); PyStackRef_CLOSE(val); + SYNC_SP(); + EXIT_IF(is_none); } op(_JUMP_TO_TOP, (--)) { diff --git a/Python/ceval.c b/Python/ceval.c index d9ede2816fc02f..26dcd54a474a6d 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -1040,6 +1040,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int uopcode = next_uop->opcode; #ifdef Py_DEBUG if (lltrace >= 3) { + dump_stack(frame, stack_pointer); if (next_uop->opcode == _START_EXECUTOR) { printf("%4d uop: ", 0); } @@ -1047,8 +1048,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int printf("%4d uop: ", (int)(next_uop - current_executor->trace)); } _PyUOpPrint(next_uop); - printf(" stack_level=%d\n", - (int)(stack_pointer - _PyFrame_Stackbase(frame))); + printf("\n"); } #endif next_uop++; diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index c92aea6f5f0c53..41f2ef27cf692e 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -215,7 +215,7 @@ oparg = 0; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ; + SETLOCAL(oparg, value); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -226,7 +226,7 @@ oparg = 1; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ; + SETLOCAL(oparg, value); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -237,7 +237,7 @@ oparg = 2; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ; + SETLOCAL(oparg, value); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -248,7 +248,7 @@ oparg = 3; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ; + SETLOCAL(oparg, value); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -259,7 +259,7 @@ oparg = 4; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ; + SETLOCAL(oparg, value); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -270,7 +270,7 @@ oparg = 5; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ; + SETLOCAL(oparg, value); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -281,7 +281,7 @@ oparg = 6; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ; + SETLOCAL(oparg, value); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -292,7 +292,7 @@ oparg = 7; assert(oparg == CURRENT_OPARG()); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ; + SETLOCAL(oparg, value); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -302,7 +302,7 @@ _PyStackRef value; oparg = CURRENT_OPARG(); value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ; + SETLOCAL(oparg, value); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -333,7 +333,7 @@ value = stack_pointer[-1]; receiver = stack_pointer[-2]; (void)receiver; - val = value;(void)value ; + val = value; PyStackRef_CLOSE(receiver); stack_pointer[-2] = val; stack_pointer += -1; @@ -349,13 +349,9 @@ PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; break; } @@ -365,7 +361,7 @@ value = stack_pointer[-1]; assert(PyStackRef_BoolCheck(value)); res = PyStackRef_Is(value, PyStackRef_False) - ? PyStackRef_True : PyStackRef_False;(void)value ; + ? PyStackRef_True : PyStackRef_False; stack_pointer[-1] = res; break; } @@ -378,13 +374,9 @@ int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (err < 0) JUMP_TO_ERROR(); res = err ? PyStackRef_True : PyStackRef_False; - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; break; } @@ -413,7 +405,6 @@ _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); stack_pointer = _PyFrame_GetStackPointer(frame); - (void)value ; res = PyStackRef_False; } else { @@ -449,7 +440,6 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - (void)value ; STAT_INC(TO_BOOL, hit); res = PyStackRef_False; stack_pointer[-1] = res; @@ -470,7 +460,6 @@ _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); stack_pointer = _PyFrame_GetStackPointer(frame); - (void)value ; res = PyStackRef_False; } else { @@ -500,13 +489,9 @@ PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; break; } @@ -562,12 +547,10 @@ PyObject *res_o = _PyLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -584,12 +567,10 @@ PyObject *res_o = _PyLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -606,12 +587,10 @@ PyObject *res_o = _PyLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -749,12 +728,10 @@ PyObject *res_o = PyUnicode_Concat(left_o, right_o); _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc); _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -791,13 +768,11 @@ * that the string is safe to mutate. */ assert(Py_REFCNT(left_o) >= 2); - _Py_DECREF_NO_DEALLOC(left_o);(void)left ; + _Py_DECREF_NO_DEALLOC(left_o); PyObject *temp = PyStackRef_AsPyObjectBorrow(*target_local); PyUnicode_Append(&temp, right_o); *target_local = PyStackRef_FromPyObjectSteal(temp); - _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);(void)right ; - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); + _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); if (PyStackRef_IsNull(*target_local)) JUMP_TO_ERROR(); #if TIER_ONE // The STORE_FAST is already done. This is done here in tier one, @@ -805,6 +780,8 @@ assert(next_instr->op.code == STORE_FAST); SKIP_OVER(1); #endif + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -821,12 +798,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -859,12 +834,10 @@ assert(WITHIN_STACK_BOUNDS()); } PyStackRef_CLOSE(container); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-3] = res; + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); break; } @@ -897,9 +870,9 @@ } PyStackRef_CLOSE(v); PyStackRef_CLOSE(container); + if (err) JUMP_TO_ERROR(); stack_pointer += -4; assert(WITHIN_STACK_BOUNDS()); - if (err) JUMP_TO_ERROR(); break; } @@ -933,7 +906,7 @@ PyObject *res_o = PyList_GET_ITEM(list, index); assert(res_o != NULL); Py_INCREF(res_o); - _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; + _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); PyStackRef_CLOSE(list_st); res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; @@ -975,7 +948,7 @@ } STAT_INC(BINARY_SUBSCR, hit); PyObject *res_o = (PyObject*)&_Py_SINGLETON(strings).ascii[c]; - _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; + _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); PyStackRef_CLOSE(str_st); res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; @@ -1014,7 +987,7 @@ PyObject *res_o = PyTuple_GET_ITEM(tuple, index); assert(res_o != NULL); Py_INCREF(res_o); - _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; + _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); PyStackRef_CLOSE(tuple_st); res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; @@ -1047,11 +1020,12 @@ } PyStackRef_CLOSE(dict_st); PyStackRef_CLOSE(sub_st); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (rc <= 0) JUMP_TO_ERROR(); // not found or error res = PyStackRef_FromPyObjectSteal(res_o); + stack_pointer[-2] = res; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1113,9 +1087,9 @@ list = stack_pointer[-2 - (oparg-1)]; int err = _PyList_AppendTakeRef((PyListObject *)PyStackRef_AsPyObjectBorrow(list), PyStackRef_AsPyObjectSteal(v)); + if (err < 0) JUMP_TO_ERROR(); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - if (err < 0) JUMP_TO_ERROR(); break; } @@ -1130,9 +1104,9 @@ PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); + if (err) JUMP_TO_ERROR(); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - if (err) JUMP_TO_ERROR(); break; } @@ -1150,9 +1124,9 @@ PyStackRef_CLOSE(v); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); + if (err) JUMP_TO_ERROR(); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); - if (err) JUMP_TO_ERROR(); break; } @@ -1189,7 +1163,7 @@ PyList_SET_ITEM(list, index, PyStackRef_AsPyObjectSteal(value)); assert(old_value != NULL); Py_DECREF(old_value); - _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; + _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); PyStackRef_CLOSE(list_st); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); @@ -1215,9 +1189,9 @@ PyStackRef_AsPyObjectSteal(value)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(dict_st); + if (err) JUMP_TO_ERROR(); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); - if (err) JUMP_TO_ERROR(); break; } @@ -1233,9 +1207,9 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(container); PyStackRef_CLOSE(sub); + if (err) JUMP_TO_ERROR(); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); - if (err) JUMP_TO_ERROR(); break; } @@ -1247,13 +1221,9 @@ assert(oparg <= MAX_INTRINSIC_1); PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value)); PyStackRef_CLOSE(value); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = res; break; } @@ -1270,12 +1240,10 @@ PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1); PyStackRef_CLOSE(value2_st); PyStackRef_CLOSE(value1_st); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1287,7 +1255,7 @@ #if TIER_ONE assert(frame != &entry_frame); #endif - _PyStackRef temp = retval;(void)retval ; + _PyStackRef temp = retval; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -1326,17 +1294,15 @@ type->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(obj); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } iter_o = (*getter)(obj_o); PyStackRef_CLOSE(obj); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (iter_o == NULL) JUMP_TO_ERROR(); if (Py_TYPE(iter_o)->tp_as_async == NULL || Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) { + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'async for' received an object from __aiter__ " @@ -1347,6 +1313,7 @@ if (true) JUMP_TO_ERROR(); } iter = PyStackRef_FromPyObjectSteal(iter_o); + stack_pointer[-1] = iter; break; } @@ -1376,13 +1343,9 @@ PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (iter_o == NULL) JUMP_TO_ERROR(); iter = PyStackRef_FromPyObjectSteal(iter_o); - stack_pointer[0] = iter; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = iter; break; } @@ -1406,7 +1369,7 @@ } STAT_INC(SEND, hit); gen_frame = &gen->gi_iframe; - _PyFrame_StackPush(gen_frame, v);(void)v ; + _PyFrame_StackPush(gen_frame, v); gen->gi_frame_state = FRAME_EXECUTING; gen->gi_exc_state.previous_item = tstate->exc_info; tstate->exc_info = &gen->gi_exc_state; @@ -1435,7 +1398,7 @@ assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; - _PyStackRef temp = retval;(void)retval ; + _PyStackRef temp = retval; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -1535,8 +1498,6 @@ "no locals found when storing %R", name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } if (PyDict_CheckExact(ns)) { @@ -1550,9 +1511,9 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(v); + if (err) JUMP_TO_ERROR(); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - if (err) JUMP_TO_ERROR(); break; } @@ -1594,10 +1555,8 @@ int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(seq); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (res == 0) JUMP_TO_ERROR(); - stack_pointer += oparg; + stack_pointer += -1 + oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1692,10 +1651,8 @@ int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(seq); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (res == 0) JUMP_TO_ERROR(); - stack_pointer += 1 + (oparg & 0xFF) + (oparg >> 8); + stack_pointer += (oparg & 0xFF) + (oparg >> 8); assert(WITHIN_STACK_BOUNDS()); break; } @@ -1713,9 +1670,9 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); PyStackRef_CLOSE(owner); + if (err) JUMP_TO_ERROR(); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); - if (err) JUMP_TO_ERROR(); break; } @@ -1728,9 +1685,9 @@ int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(owner); + if (err) JUMP_TO_ERROR(); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - if (err) JUMP_TO_ERROR(); break; } @@ -1743,9 +1700,9 @@ int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(v); + if (err) JUMP_TO_ERROR(); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - if (err) JUMP_TO_ERROR(); break; } @@ -1973,6 +1930,7 @@ } PyStackRef_CLOSE(class_dict_st); value = PyStackRef_FromPyObjectSteal(value_o); + stack_pointer[-1] = value; break; } @@ -2032,8 +1990,6 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(pieces[_i]); } - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyObject *str_o = _PyUnicode_JoinArray(&_Py_STR(empty), pieces_o, oparg); @@ -2041,12 +1997,10 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(pieces[_i]); } - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); if (str_o == NULL) JUMP_TO_ERROR(); str = PyStackRef_FromPyObjectSteal(str_o); - stack_pointer[0] = str; - stack_pointer += 1; + stack_pointer[-oparg] = str; + stack_pointer += 1 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -2057,12 +2011,10 @@ oparg = CURRENT_OPARG(); values = &stack_pointer[-oparg]; PyObject *tup_o = _PyTuple_FromStackRefSteal(values, oparg); - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); if (tup_o == NULL) JUMP_TO_ERROR(); tup = PyStackRef_FromPyObjectSteal(tup_o); - stack_pointer[0] = tup; - stack_pointer += 1; + stack_pointer[-oparg] = tup; + stack_pointer += 1 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -2073,12 +2025,10 @@ oparg = CURRENT_OPARG(); values = &stack_pointer[-oparg]; PyObject *list_o = _PyList_FromStackRefSteal(values, oparg); - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); if (list_o == NULL) JUMP_TO_ERROR(); list = PyStackRef_FromPyObjectSteal(list_o); - stack_pointer[0] = list; - stack_pointer += 1; + stack_pointer[-oparg] = list; + stack_pointer += 1 - oparg; assert(WITHIN_STACK_BOUNDS()); break; } @@ -2109,8 +2059,6 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(iterable_st); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } assert(Py_IsNone(none_val)); @@ -2131,9 +2079,9 @@ PyStackRef_AsPyObjectBorrow(iterable)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); + if (err < 0) JUMP_TO_ERROR(); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - if (err < 0) JUMP_TO_ERROR(); break; } @@ -2149,8 +2097,6 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } int err = 0; @@ -2161,14 +2107,15 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(values[i]); - }(void)values ; + } if (err != 0) { Py_DECREF(set_o); - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } set = PyStackRef_FromPyObjectSteal(set_o); + stack_pointer[-oparg] = set; + stack_pointer += 1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -2182,8 +2129,6 @@ for (int _i = oparg*2; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } - stack_pointer += -oparg*2; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } _PyFrame_SetStackPointer(frame, stack_pointer); @@ -2196,12 +2141,10 @@ for (int _i = oparg*2; --_i >= 0;) { PyStackRef_CLOSE(values[_i]); } - stack_pointer += -oparg*2; - assert(WITHIN_STACK_BOUNDS()); if (map_o == NULL) JUMP_TO_ERROR(); map = PyStackRef_FromPyObjectSteal(map_o); - stack_pointer[0] = map; - stack_pointer += 1; + stack_pointer[-oparg*2] = map; + stack_pointer += 1 - oparg*2; assert(WITHIN_STACK_BOUNDS()); break; } @@ -2261,8 +2204,6 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(update); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyStackRef_CLOSE(update); @@ -2290,8 +2231,6 @@ _PyEval_FormatKwargsError(tstate, callable_o, update_o); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(update); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyStackRef_CLOSE(update); @@ -2319,9 +2258,9 @@ PyStackRef_AsPyObjectSteal(value) ); stack_pointer = _PyFrame_GetStackPointer(frame); + if (err != 0) JUMP_TO_ERROR(); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); - if (err != 0) JUMP_TO_ERROR(); break; } @@ -2356,12 +2295,10 @@ PyStackRef_CLOSE(global_super_st); PyStackRef_CLOSE(class_st); PyStackRef_CLOSE(self_st); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); if (attr == NULL) JUMP_TO_ERROR(); attr_st = PyStackRef_FromPyObjectSteal(attr); - stack_pointer[0] = attr_st; - stack_pointer += 1; + stack_pointer[-3] = attr_st; + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); break; } @@ -2400,12 +2337,10 @@ PyStackRef_CLOSE(class_st); if (attr_o == NULL) { PyStackRef_CLOSE(self_st); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } if (method_found) { - self_or_null = self_st; // transfer ownership(void)self_st ; + self_or_null = self_st; // transfer ownership } else { PyStackRef_CLOSE(self_st); self_or_null = PyStackRef_NULL; @@ -2438,7 +2373,7 @@ meth | self | arg1 | ... | argN */ assert(attr_o != NULL); // No errors on this branch - self_or_null = owner; // Transfer ownership(void)owner ; + self_or_null = owner; // Transfer ownership } else { /* meth is not an unbound method (but a regular attr, or @@ -2448,11 +2383,8 @@ meth | NULL | arg1 | ... | argN */ PyStackRef_CLOSE(owner); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (attr_o == NULL) JUMP_TO_ERROR(); - self_or_null = PyStackRef_NULL;stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + self_or_null = PyStackRef_NULL; } } else { @@ -2461,12 +2393,9 @@ attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(owner); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (attr_o == NULL) JUMP_TO_ERROR(); /* We need to define self_or_null on all paths */ - self_or_null = PyStackRef_NULL;stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + self_or_null = PyStackRef_NULL; } attr = PyStackRef_FromPyObjectSteal(attr_o); stack_pointer[-1] = attr; @@ -2787,7 +2716,7 @@ STAT_INC(LOAD_ATTR, hit); Py_INCREF(fget); new_frame = _PyFrame_PushUnchecked(tstate, f, 1, frame); - new_frame->localsplus[0] = owner;(void)owner ; + new_frame->localsplus[0] = owner; stack_pointer[-1].bits = (uintptr_t)new_frame; break; } @@ -2886,6 +2815,8 @@ Py_XDECREF(old_value); STAT_INC(STORE_ATTR, hit); PyStackRef_CLOSE(owner); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -2922,10 +2853,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); if (oparg & 16) { + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int res_bool = PyObject_IsTrue(res_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2934,7 +2865,8 @@ res = res_bool ? PyStackRef_True : PyStackRef_False; } else { - res = PyStackRef_FromPyObjectSteal(res_o); + res = PyStackRef_FromPyObjectSteal(res_o);stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); } stack_pointer[0] = res; stack_pointer += 1; @@ -2956,8 +2888,8 @@ double dright = PyFloat_AS_DOUBLE(right_o); // 1 if NaN, 2 if <, 4 if >, 8 if ==; this matches low four bits of the oparg int sign_ish = COMPARISON_BIT(dleft, dright); - _Py_DECREF_SPECIALIZED(left_o, _PyFloat_ExactDealloc);(void)left ; - _Py_DECREF_SPECIALIZED(right_o, _PyFloat_ExactDealloc);(void)right ; + _Py_DECREF_SPECIALIZED(left_o, _PyFloat_ExactDealloc); + _Py_DECREF_SPECIALIZED(right_o, _PyFloat_ExactDealloc); res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; // It's always a bool, so we don't care about oparg & 16. stack_pointer[-2] = res; @@ -2990,8 +2922,8 @@ Py_ssize_t iright = _PyLong_CompactValue((PyLongObject *)right_o); // 2 if <, 4 if >, 8 if ==; this matches the low 4 bits of the oparg int sign_ish = COMPARISON_BIT(ileft, iright); - _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);(void)left ; - _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free);(void)right ; + _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); + _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; // It's always a bool, so we don't care about oparg & 16. stack_pointer[-2] = res; @@ -3012,8 +2944,8 @@ STAT_INC(COMPARE_OP, hit); int eq = _PyUnicode_Equal(left_o, right_o); assert((oparg >> 5) == Py_EQ || (oparg >> 5) == Py_NE); - _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc);(void)left ; - _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);(void)right ; + _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc); + _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); assert(eq == 0 || eq == 1); assert((oparg & 0xf) == COMPARISON_NOT_EQUALS || (oparg & 0xf) == COMPARISON_EQUALS); assert(COMPARISON_NOT_EQUALS + 1 == COMPARISON_EQUALS); @@ -3062,12 +2994,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (res < 0) JUMP_TO_ERROR(); b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; - stack_pointer[0] = b; - stack_pointer += 1; + stack_pointer[-2] = b; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -3092,12 +3022,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (res < 0) JUMP_TO_ERROR(); b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; - stack_pointer[0] = b; - stack_pointer += 1; + stack_pointer[-2] = b; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -3121,12 +3049,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (res < 0) JUMP_TO_ERROR(); b = (res ^ oparg) ? PyStackRef_True : PyStackRef_False; - stack_pointer[0] = b; - stack_pointer += 1; + stack_pointer[-2] = b; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -3146,8 +3072,6 @@ if (err < 0) { PyStackRef_CLOSE(exc_value_st); PyStackRef_CLOSE(match_type_st); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyObject *match_o = NULL; @@ -3158,18 +3082,22 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(exc_value_st); PyStackRef_CLOSE(match_type_st); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (res < 0) JUMP_TO_ERROR(); assert((match_o == NULL) == (rest_o == NULL)); if (match_o == NULL) JUMP_TO_ERROR(); if (!Py_IsNone(match_o)) { + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); PyErr_SetHandledException(match_o); stack_pointer = _PyFrame_GetStackPointer(frame); + stack_pointer += 2; + assert(WITHIN_STACK_BOUNDS()); } rest = PyStackRef_FromPyObjectSteal(rest_o); match = PyStackRef_FromPyObjectSteal(match_o); + stack_pointer[-2] = rest; + stack_pointer[-1] = match; break; } @@ -3187,8 +3115,6 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { PyStackRef_CLOSE(right); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } _PyFrame_SetStackPointer(frame, stack_pointer); @@ -3215,12 +3141,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(level); PyStackRef_CLOSE(fromlist); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -3251,7 +3175,7 @@ _PyStackRef b; value = stack_pointer[-1]; if (PyStackRef_Is(value, PyStackRef_None)) { - b = PyStackRef_True;(void)value ; + b = PyStackRef_True; } else { b = PyStackRef_False; @@ -3307,12 +3231,9 @@ attrs = PyStackRef_FromPyObjectSteal(attrs_o); } else { - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); if (_PyErr_Occurred(tstate)) JUMP_TO_ERROR(); // Error! - attrs = PyStackRef_None; // Failure!stack_pointer += 3; - assert(WITHIN_STACK_BOUNDS()); + attrs = PyStackRef_None; // Failure! } stack_pointer[-3] = attrs; stack_pointer += -2; @@ -3372,8 +3293,8 @@ iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable))); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(iterable); - stack_pointer[-1] = iter; if (PyStackRef_IsNull(iter)) JUMP_TO_ERROR(); + stack_pointer[-1] = iter; break; } @@ -3395,17 +3316,16 @@ stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); } - iter = iterable;(void)iterable ; + iter = iterable; } else if (PyGen_CheckExact(iterable_o)) { - iter = iterable;(void)iterable ; + iter = iterable; } else { /* `iterable` is not a generator. */ _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); stack_pointer = _PyFrame_GetStackPointer(frame); - (void)iterable ; if (PyStackRef_IsNull(iter)) { JUMP_TO_ERROR(); } @@ -3653,13 +3573,11 @@ assert(WITHIN_STACK_BOUNDS()); } } - stack_pointer[0] = attr; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); if (PyStackRef_IsNull(attr)) JUMP_TO_ERROR(); self_or_null = PyStackRef_FromPyObjectSteal(self_or_null_o); stack_pointer[0] = attr; - stack_pointer += 1; + stack_pointer[1] = self_or_null; + stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); break; } @@ -3705,10 +3623,10 @@ res = PyStackRef_FromPyObjectSteal(PyObject_Vectorcall(exit_func_o, stack + 2 - has_self, (3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL)); stack_pointer = _PyFrame_GetStackPointer(frame); + if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); break; } @@ -3726,7 +3644,7 @@ } assert(PyStackRef_ExceptionInstanceCheck(exc)); exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); - new_exc = exc;(void)exc ; + new_exc = exc; stack_pointer[-1] = prev_exc; stack_pointer[0] = new_exc; stack_pointer += 1; @@ -3772,7 +3690,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner;(void)owner ; + self = owner; stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; @@ -3793,7 +3711,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner;(void)owner ; + self = owner; stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; @@ -3858,7 +3776,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner;(void)owner ; + self = owner; stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; @@ -3926,6 +3844,9 @@ JUMP_TO_ERROR(); } new_frame = temp; + stack_pointer[0].bits = (uintptr_t)new_frame; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -3986,7 +3907,7 @@ method = &stack_pointer[-2 - oparg]; self = &stack_pointer[-1 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); - assert(PyStackRef_IsNull(null[0]));(void)null ; + assert(PyStackRef_IsNull(null[0])); assert(Py_TYPE(callable_o) == &PyMethod_Type); self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); _PyStackRef temp = callable[0]; @@ -4038,8 +3959,6 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } _PyFrame_SetStackPointer(frame, stack_pointer); @@ -4053,11 +3972,12 @@ PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }(void)self_or_null ; - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); + } if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -4088,7 +4008,6 @@ callable = &stack_pointer[-2 - oparg]; func = &stack_pointer[-2 - oparg]; self = &stack_pointer[-1 - oparg]; - (void)null ; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); STAT_INC(CALL, hit); self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); @@ -4302,7 +4221,7 @@ // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); - _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + _PyInterpreterFrame *temp = new_frame; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -4332,12 +4251,10 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - (void)null ; if (callable_o != (PyObject *)&PyType_Type) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - (void)callable ; STAT_INC(CALL, hit); res = PyStackRef_FromPyObjectSteal(Py_NewRef(Py_TYPE(arg_o))); PyStackRef_CLOSE(arg); @@ -4371,12 +4288,11 @@ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); - (void)null ;(void)callable ; PyStackRef_CLOSE(arg); + if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); stack_pointer[-3] = res; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); - if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); break; } @@ -4404,12 +4320,11 @@ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); - (void)null ;(void)callable ; PyStackRef_CLOSE(arg); + if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); stack_pointer[-3] = res; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); - if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); break; } @@ -4478,7 +4393,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); /* Push self onto stack of shim */ shim->localsplus[0] = PyStackRef_DUP(self[0]); - PyFunctionObject *init_func = (PyFunctionObject *)PyStackRef_AsPyObjectSteal(init[0]);(void)init ;(void)self ; + PyFunctionObject *init_func = (PyFunctionObject *)PyStackRef_AsPyObjectSteal(init[0]); _PyFrame_SetStackPointer(frame, stack_pointer); init_frame = _PyEvalFramePushAndInit( tstate, init_func, NULL, args-1, oparg+1, NULL, shim); @@ -4509,7 +4424,7 @@ Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); - }(void)should_be_none ; + } stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -4529,7 +4444,7 @@ if (!PyStackRef_IsNull(self_or_null[0])) { args--; total_args++; - }(void)self_or_null ; + } if (!PyType_Check(callable_o)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -4547,8 +4462,6 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyObject *res_o = tp->tp_vectorcall((PyObject *)tp, args_o, total_args, NULL); @@ -4558,10 +4471,11 @@ PyStackRef_CLOSE(args[i]); } PyStackRef_CLOSE(callable[0]); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -4607,12 +4521,13 @@ stack_pointer = _PyFrame_GetStackPointer(frame); _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(arg);(void)args ;(void)self_or_null ; + PyStackRef_CLOSE(arg); PyStackRef_CLOSE(callable[0]); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -4631,7 +4546,7 @@ if (!PyStackRef_IsNull(self_or_null[0])) { args--; total_args++; - }(void)self_or_null ; + } if (!PyCFunction_CheckExact(callable_o)) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); @@ -4650,8 +4565,6 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyObject *res_o = ((PyCFunctionFast)(void(*)(void))cfunc)( @@ -4665,10 +4578,11 @@ PyStackRef_CLOSE(args[i]); } PyStackRef_CLOSE(callable[0]); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -4708,8 +4622,6 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyObject *res_o = cfunc(PyCFunction_GET_SELF(callable_o), args_o, total_args, NULL); @@ -4718,12 +4630,13 @@ /* Free the arguments. */ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }(void)self_or_null ; + } PyStackRef_CLOSE(callable[0]); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -4771,6 +4684,9 @@ PyStackRef_CLOSE(callable[0]); PyStackRef_CLOSE(arg_stackref); res = PyStackRef_FromPyObjectSteal(res_o); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -4813,6 +4729,9 @@ PyStackRef_CLOSE(inst_stackref); PyStackRef_CLOSE(cls_stackref); PyStackRef_CLOSE(callable[0]); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -4841,8 +4760,6 @@ int err = _PyList_AppendTakeRef((PyListObject *)self_o, PyStackRef_AsPyObjectSteal(arg)); PyStackRef_CLOSE(self); PyStackRef_CLOSE(callable); - stack_pointer += -3; - assert(WITHIN_STACK_BOUNDS()); if (err) JUMP_TO_ERROR(); #if TIER_ONE // Skip the following POP_TOP. This is done here in tier one, and @@ -4850,6 +4767,8 @@ assert(next_instr->op.code == POP_TOP); SKIP_OVER(1); #endif + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -4905,12 +4824,13 @@ _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); - PyStackRef_CLOSE(arg_stackref);(void)args ;(void)self_or_null ; + PyStackRef_CLOSE(arg_stackref); PyStackRef_CLOSE(callable[0]); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -4956,8 +4876,6 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyObject *res_o = cfunc(self, (args_o + 1), nargs, NULL); @@ -4966,12 +4884,13 @@ /* Free the arguments. */ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }(void)self_or_null ; + } PyStackRef_CLOSE(callable[0]); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -5024,12 +4943,13 @@ stack_pointer = _PyFrame_GetStackPointer(frame); _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(self_stackref);(void)args ;(void)self_or_null ; + PyStackRef_CLOSE(self_stackref); PyStackRef_CLOSE(callable[0]); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -5075,8 +4995,6 @@ for (int _i = oparg; --_i >= 0;) { PyStackRef_CLOSE(args[_i]); } - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyObject *res_o = cfunc(self, (args_o + 1), nargs); @@ -5085,12 +5003,13 @@ /* Clear the stack of the arguments. */ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }(void)self_or_null ; + } PyStackRef_CLOSE(callable[0]); - stack_pointer += -2 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -5120,7 +5039,8 @@ func[0] = PyStackRef_FromPyObjectNew(method); PyStackRef_CLOSE(temp); } - kwnames_out = kwnames_in;(void)kwnames_in ; + kwnames_out = kwnames_in; + stack_pointer[-1] = kwnames_out; break; } @@ -5279,8 +5199,6 @@ PyStackRef_CLOSE(args[_i]); } PyStackRef_CLOSE(kwnames); - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (true) JUMP_TO_ERROR(); } PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); @@ -5296,12 +5214,13 @@ assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }(void)self_or_null ; + } PyStackRef_CLOSE(callable[0]); - stack_pointer += -3 - oparg; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); + stack_pointer[-3 - oparg] = res; + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -5319,7 +5238,7 @@ func = stack_pointer[-3 - (oparg & 1)]; PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs); if (PyTuple_CheckExact(callargs_o)) { - tuple = callargs;(void)callargs ; + tuple = callargs; } else { int err = check_args_iterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); @@ -5335,7 +5254,7 @@ PyStackRef_CLOSE(callargs); tuple = PyStackRef_FromPyObjectSteal(tuple_o); } - kwargs_out = kwargs_in;(void)kwargs_in ; + kwargs_out = kwargs_in; stack_pointer[-1 - (oparg & 1)] = tuple; if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_out; break; @@ -5353,9 +5272,9 @@ PyFunction_New(codeobj, GLOBALS()); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(codeobj_st); + if (func_obj == NULL) JUMP_TO_ERROR(); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - if (func_obj == NULL) JUMP_TO_ERROR(); _PyFrame_SetStackPointer(frame, stack_pointer); _PyFunction_SetVersion( func_obj, ((PyCodeObject *)codeobj)->co_version); @@ -5376,7 +5295,7 @@ attr_st = stack_pointer[-2]; PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st); - func_out = func_in;(void)func_in ; + func_out = func_in; assert(PyFunction_Check(func)); size_t offset = _Py_FunctionAttributeOffsets[oparg]; assert(offset != 0); @@ -5435,12 +5354,10 @@ PyStackRef_CLOSE(start); PyStackRef_CLOSE(stop); PyStackRef_XCLOSE(step); - stack_pointer += -2 - ((oparg == 3) ? 1 : 0); - assert(WITHIN_STACK_BOUNDS()); if (slice_o == NULL) JUMP_TO_ERROR(); slice = PyStackRef_FromPyObjectSteal(slice_o); - stack_pointer[0] = slice; - stack_pointer += 1; + stack_pointer[-2 - ((oparg == 3) ? 1 : 0)] = slice; + stack_pointer += -1 - ((oparg == 3) ? 1 : 0); assert(WITHIN_STACK_BOUNDS()); break; } @@ -5455,13 +5372,9 @@ conv_fn = _PyEval_ConversionFuncs[oparg]; PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value)); PyStackRef_CLOSE(value); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); if (result_o == NULL) JUMP_TO_ERROR(); result = PyStackRef_FromPyObjectSteal(result_o); - stack_pointer[0] = result; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = result; break; } @@ -5477,11 +5390,10 @@ res = PyStackRef_FromPyObjectSteal(PyObject_Format(value_o, NULL)); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); - stack_pointer[-1] = res; if (PyStackRef_IsNull(res)) JUMP_TO_ERROR(); } else { - res = value;(void)value ; + res = value; } stack_pointer[-1] = res; break; @@ -5498,12 +5410,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); PyStackRef_CLOSE(fmt_spec); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -5534,12 +5444,10 @@ PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o); PyStackRef_CLOSE(lhs); PyStackRef_CLOSE(rhs); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -5552,8 +5460,8 @@ oparg = CURRENT_OPARG(); top_in = stack_pointer[-1]; bottom_in = stack_pointer[-2 - (oparg-2)]; - bottom_out = bottom_in;(void)bottom_in ; - top_out = top_in;(void)top_in ; + bottom_out = bottom_in; + top_out = top_in; assert(oparg >= 2); stack_pointer[-2 - (oparg-2)] = top_out; stack_pointer[-1] = bottom_out; @@ -5579,26 +5487,26 @@ case _GUARD_IS_TRUE_POP: { _PyStackRef flag; flag = stack_pointer[-1]; - int is_true = PyStackRef_Is(flag, PyStackRef_True);(void)flag ; + int is_true = PyStackRef_Is(flag, PyStackRef_True); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (!is_true) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } case _GUARD_IS_FALSE_POP: { _PyStackRef flag; flag = stack_pointer[-1]; - int is_false = PyStackRef_Is(flag, PyStackRef_False);(void)flag ; + int is_false = PyStackRef_Is(flag, PyStackRef_False); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (!is_false) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -5608,11 +5516,13 @@ int is_none = PyStackRef_Is(val, PyStackRef_None); if (!is_none) { PyStackRef_CLOSE(val); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (1) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - }(void)val ; + } stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; @@ -5622,13 +5532,13 @@ _PyStackRef val; val = stack_pointer[-1]; int is_none = PyStackRef_Is(val, PyStackRef_None); + PyStackRef_CLOSE(val); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); if (is_none) { UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - PyStackRef_CLOSE(val); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -5807,7 +5717,7 @@ _PyStackRef opt; opt = stack_pointer[-1]; _PyCounterOptimizerObject *exe = (_PyCounterOptimizerObject *)PyStackRef_AsPyObjectBorrow(opt); - exe->count++;(void)opt ; + exe->count++; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 586c270d507b34..3ec19203d1bfff 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -205,11 +205,11 @@ * that the string is safe to mutate. */ assert(Py_REFCNT(left_o) >= 2); - _Py_DECREF_NO_DEALLOC(left_o);(void)left ; + _Py_DECREF_NO_DEALLOC(left_o); PyObject *temp = PyStackRef_AsPyObjectBorrow(*target_local); PyUnicode_Append(&temp, right_o); *target_local = PyStackRef_FromPyObjectSteal(temp); - _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);(void)right ; + _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); if (PyStackRef_IsNull(*target_local)) goto pop_2_error; #if TIER_ONE // The STORE_FAST is already done. This is done here in tier one, @@ -542,7 +542,7 @@ // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); - _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + _PyInterpreterFrame *temp = new_frame; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -580,7 +580,7 @@ PyObject *res_o = PyList_GET_ITEM(list, index); assert(res_o != NULL); Py_INCREF(res_o); - _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; + _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); PyStackRef_CLOSE(list_st); res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; @@ -612,7 +612,7 @@ DEOPT_IF(Py_ARRAY_LENGTH(_Py_SINGLETON(strings).ascii) <= c, BINARY_SUBSCR); STAT_INC(BINARY_SUBSCR, hit); PyObject *res_o = (PyObject*)&_Py_SINGLETON(strings).ascii[c]; - _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; + _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); PyStackRef_CLOSE(str_st); res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; @@ -644,7 +644,7 @@ PyObject *res_o = PyTuple_GET_ITEM(tuple, index); assert(res_o != NULL); Py_INCREF(res_o); - _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; + _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); PyStackRef_CLOSE(tuple_st); res = PyStackRef_FromPyObjectSteal(res_o); stack_pointer[-2] = res; @@ -741,7 +741,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); } PyStackRef_CLOSE(values[i]); - }(void)values ; + } if (err != 0) { Py_DECREF(set_o); if (true) { @@ -940,7 +940,7 @@ PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }(void)self_or_null ; + } if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -981,7 +981,7 @@ PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }(void)self_or_null ; + } if (res_o == NULL) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1070,7 +1070,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); /* Push self onto stack of shim */ shim->localsplus[0] = PyStackRef_DUP(self[0]); - PyFunctionObject *init_func = (PyFunctionObject *)PyStackRef_AsPyObjectSteal(init[0]);(void)init ;(void)self ; + PyFunctionObject *init_func = (PyFunctionObject *)PyStackRef_AsPyObjectSteal(init[0]); _PyFrame_SetStackPointer(frame, stack_pointer); init_frame = _PyEvalFramePushAndInit( tstate, init_func, NULL, args-1, oparg+1, NULL, shim); @@ -1094,7 +1094,7 @@ // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); - _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + _PyInterpreterFrame *temp = new_frame; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -1137,7 +1137,6 @@ { func = &stack_pointer[-2 - oparg]; self = &stack_pointer[-1 - oparg]; - (void)null ; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); STAT_INC(CALL, hit); self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); @@ -1200,7 +1199,7 @@ // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); - _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + _PyInterpreterFrame *temp = new_frame; stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -1249,7 +1248,7 @@ method = &stack_pointer[-2 - oparg]; self = &stack_pointer[-1 - oparg]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); - assert(PyStackRef_IsNull(null[0]));(void)null ; + assert(PyStackRef_IsNull(null[0])); assert(Py_TYPE(callable_o) == &PyMethod_Type); self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); _PyStackRef temp = callable[0]; @@ -1301,7 +1300,7 @@ // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); - _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + _PyInterpreterFrame *temp = new_frame; _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); @@ -1335,7 +1334,7 @@ if (!PyStackRef_IsNull(self_or_null[0])) { args--; total_args++; - }(void)self_or_null ; + } DEOPT_IF(!PyType_Check(callable_o), CALL); PyTypeObject *tp = (PyTypeObject *)callable_o; DEOPT_IF(tp->tp_vectorcall == NULL, CALL); @@ -1411,7 +1410,7 @@ if (!PyStackRef_IsNull(self_or_null[0])) { args--; total_args++; - }(void)self_or_null ; + } DEOPT_IF(!PyCFunction_CheckExact(callable_o), CALL); DEOPT_IF(PyCFunction_GET_FLAGS(callable_o) != METH_FASTCALL, CALL); STAT_INC(CALL, hit); @@ -1519,7 +1518,7 @@ /* Free the arguments. */ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }(void)self_or_null ; + } PyStackRef_CLOSE(callable[0]); if (res_o == NULL) { stack_pointer += -2 - oparg; @@ -1587,7 +1586,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(arg);(void)args ;(void)self_or_null ; + PyStackRef_CLOSE(arg); PyStackRef_CLOSE(callable[0]); if (res_o == NULL) { stack_pointer += -2 - oparg; @@ -1641,7 +1640,7 @@ func = stack_pointer[-3 - (oparg & 1)]; PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs); if (PyTuple_CheckExact(callargs_o)) { - tuple = callargs;(void)callargs ; + tuple = callargs; } else { int err = check_args_iterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); @@ -1657,7 +1656,7 @@ PyStackRef_CLOSE(callargs); tuple = PyStackRef_FromPyObjectSteal(tuple_o); } - kwargs_out = kwargs_in;(void)kwargs_in ; + kwargs_out = kwargs_in; } // _DO_CALL_FUNCTION_EX { @@ -1746,7 +1745,6 @@ _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_XCLOSE(kwargs_st); stack_pointer = _PyFrame_GetStackPointer(frame); - (void)kwargs_st ; PyStackRef_CLOSE(callargs_st); PyStackRef_CLOSE(func_st); if (result_o == NULL) { @@ -1911,7 +1909,7 @@ func[0] = PyStackRef_FromPyObjectNew(method); PyStackRef_CLOSE(temp); } - kwnames_out = kwnames_in;(void)kwnames_in ; + kwnames_out = kwnames_in; } // _DO_CALL_KW { @@ -2006,7 +2004,7 @@ PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }(void)self_or_null ; + } if (res_o == NULL) { stack_pointer += -3 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2112,7 +2110,7 @@ // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); - _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + _PyInterpreterFrame *temp = new_frame; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -2188,7 +2186,7 @@ assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }(void)self_or_null ; + } PyStackRef_CLOSE(callable[0]); if (res_o == NULL) { stack_pointer += -3 - oparg; @@ -2290,7 +2288,7 @@ // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); - _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + _PyInterpreterFrame *temp = new_frame; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -2442,7 +2440,7 @@ /* Clear the stack of the arguments. */ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }(void)self_or_null ; + } PyStackRef_CLOSE(callable[0]); if (res_o == NULL) { stack_pointer += -2 - oparg; @@ -2525,7 +2523,7 @@ /* Free the arguments. */ for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }(void)self_or_null ; + } PyStackRef_CLOSE(callable[0]); if (res_o == NULL) { stack_pointer += -2 - oparg; @@ -2597,7 +2595,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); - PyStackRef_CLOSE(self_stackref);(void)args ;(void)self_or_null ; + PyStackRef_CLOSE(self_stackref); PyStackRef_CLOSE(callable[0]); if (res_o == NULL) { stack_pointer += -2 - oparg; @@ -2672,7 +2670,7 @@ _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); - PyStackRef_CLOSE(arg_stackref);(void)args ;(void)self_or_null ; + PyStackRef_CLOSE(arg_stackref); PyStackRef_CLOSE(callable[0]); if (res_o == NULL) { stack_pointer += -2 - oparg; @@ -2759,7 +2757,7 @@ PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }(void)self_or_null ; + } if (res_o == NULL) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2857,7 +2855,7 @@ // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); - _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + _PyInterpreterFrame *temp = new_frame; stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -2937,7 +2935,7 @@ // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); - _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + _PyInterpreterFrame *temp = new_frame; _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); @@ -2975,7 +2973,6 @@ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); - (void)null ;(void)callable ; PyStackRef_CLOSE(arg); if (PyStackRef_IsNull(res)) goto pop_3_error; } @@ -3026,7 +3023,6 @@ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); - (void)null ;(void)callable ; PyStackRef_CLOSE(arg); if (PyStackRef_IsNull(res)) goto pop_3_error; } @@ -3070,9 +3066,7 @@ PyObject *arg_o = PyStackRef_AsPyObjectBorrow(arg); assert(oparg == 1); DEOPT_IF(!PyStackRef_IsNull(null), CALL); - (void)null ; DEOPT_IF(callable_o != (PyObject *)&PyType_Type, CALL); - (void)callable ; STAT_INC(CALL, hit); res = PyStackRef_FromPyObjectSteal(Py_NewRef(Py_TYPE(arg_o))); PyStackRef_CLOSE(arg); @@ -3284,8 +3278,8 @@ double dright = PyFloat_AS_DOUBLE(right_o); // 1 if NaN, 2 if <, 4 if >, 8 if ==; this matches low four bits of the oparg int sign_ish = COMPARISON_BIT(dleft, dright); - _Py_DECREF_SPECIALIZED(left_o, _PyFloat_ExactDealloc);(void)left ; - _Py_DECREF_SPECIALIZED(right_o, _PyFloat_ExactDealloc);(void)right ; + _Py_DECREF_SPECIALIZED(left_o, _PyFloat_ExactDealloc); + _Py_DECREF_SPECIALIZED(right_o, _PyFloat_ExactDealloc); res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; // It's always a bool, so we don't care about oparg & 16. } @@ -3326,8 +3320,8 @@ Py_ssize_t iright = _PyLong_CompactValue((PyLongObject *)right_o); // 2 if <, 4 if >, 8 if ==; this matches the low 4 bits of the oparg int sign_ish = COMPARISON_BIT(ileft, iright); - _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free);(void)left ; - _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free);(void)right ; + _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); + _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; // It's always a bool, so we don't care about oparg & 16. } @@ -3362,8 +3356,8 @@ STAT_INC(COMPARE_OP, hit); int eq = _PyUnicode_Equal(left_o, right_o); assert((oparg >> 5) == Py_EQ || (oparg >> 5) == Py_NE); - _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc);(void)left ; - _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc);(void)right ; + _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc); + _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); assert(eq == 0 || eq == 1); assert((oparg & 0xf) == COMPARISON_NOT_EQUALS || (oparg & 0xf) == COMPARISON_EQUALS); assert(COMPARISON_NOT_EQUALS + 1 == COMPARISON_EQUALS); @@ -3771,7 +3765,7 @@ value = stack_pointer[-1]; receiver = stack_pointer[-2]; (void)receiver; - val = value;(void)value ; + val = value; PyStackRef_CLOSE(receiver); stack_pointer[-2] = val; stack_pointer += -1; @@ -3826,7 +3820,7 @@ Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); goto error; - }(void)should_be_none ; + } stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -3861,7 +3855,7 @@ if (PyStackRef_IsNull(res)) goto pop_1_error; } else { - res = value;(void)value ; + res = value; } stack_pointer[-1] = res; DISPATCH(); @@ -3986,7 +3980,7 @@ // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); - _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + _PyInterpreterFrame *temp = new_frame; _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); CALL_STAT_INC(inlined_py_calls); @@ -4286,17 +4280,16 @@ stack_pointer = _PyFrame_GetStackPointer(frame); goto error; } - iter = iterable;(void)iterable ; + iter = iterable; } else if (PyGen_CheckExact(iterable_o)) { - iter = iterable;(void)iterable ; + iter = iterable; } else { /* `iterable` is not a generator. */ _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); stack_pointer = _PyFrame_GetStackPointer(frame); - (void)iterable ; if (PyStackRef_IsNull(iter)) { goto error; } @@ -4445,7 +4438,7 @@ PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }(void)self_or_null ; + } if (true) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -4486,7 +4479,7 @@ PyStackRef_CLOSE(callable[0]); for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); - }(void)self_or_null ; + } if (res_o == NULL) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -4591,7 +4584,7 @@ goto error; } } - val = value;(void)value ; + val = value; PyStackRef_CLOSE(receiver); stack_pointer[-2] = val; stack_pointer += -1; @@ -4903,7 +4896,7 @@ #if TIER_ONE assert(frame != &entry_frame); #endif - _PyStackRef temp = retval;(void)retval ; + _PyStackRef temp = retval; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -4948,7 +4941,7 @@ #if TIER_ONE assert(frame != &entry_frame); #endif - _PyStackRef temp = retval;(void)retval ; + _PyStackRef temp = retval; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -5009,7 +5002,7 @@ assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; - _PyStackRef temp = retval;(void)retval ; + _PyStackRef temp = retval; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -5258,7 +5251,7 @@ meth | self | arg1 | ... | argN */ assert(attr_o != NULL); // No errors on this branch - self_or_null = owner; // Transfer ownership(void)owner ; + self_or_null = owner; // Transfer ownership } else { /* meth is not an unbound method (but a regular attr, or @@ -5397,7 +5390,7 @@ _PyInterpreterFrame *new_frame = _PyFrame_PushUnchecked(tstate, f, 2, frame); // Manipulate stack directly because we exit with DISPATCH_INLINED(). STACK_SHRINK(1); - new_frame->localsplus[0] = owner;(void)owner ; + new_frame->localsplus[0] = owner; new_frame->localsplus[1] = PyStackRef_FromPyObjectNew(name); frame->return_offset = (uint16_t)(next_instr - this_instr); DISPATCH_INLINED(new_frame); @@ -5482,7 +5475,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner;(void)owner ; + self = owner; } stack_pointer[-1] = attr; stack_pointer[0] = self; @@ -5518,7 +5511,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner;(void)owner ; + self = owner; } stack_pointer[-1] = attr; stack_pointer[0] = self; @@ -5566,7 +5559,7 @@ assert(descr != NULL); assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); - self = owner;(void)owner ; + self = owner; } stack_pointer[-1] = attr; stack_pointer[0] = self; @@ -5726,7 +5719,7 @@ STAT_INC(LOAD_ATTR, hit); Py_INCREF(fget); new_frame = _PyFrame_PushUnchecked(tstate, f, 1, frame); - new_frame->localsplus[0] = owner;(void)owner ; + new_frame->localsplus[0] = owner; } // _SAVE_RETURN_OFFSET { @@ -5742,7 +5735,7 @@ // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); - _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + _PyInterpreterFrame *temp = new_frame; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -6473,7 +6466,7 @@ if (true) goto pop_3_error; } if (method_found) { - self_or_null = self_st; // transfer ownership(void)self_st ; + self_or_null = self_st; // transfer ownership } else { PyStackRef_CLOSE(self_st); self_or_null = PyStackRef_NULL; @@ -6678,7 +6671,7 @@ /* Skip 1 cache entry */ cond = stack_pointer[-1]; assert(PyStackRef_BoolCheck(cond)); - int flag = PyStackRef_Is(cond, PyStackRef_False);(void)cond ; + int flag = PyStackRef_Is(cond, PyStackRef_False); #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif @@ -6701,7 +6694,7 @@ { value = stack_pointer[-1]; if (PyStackRef_Is(value, PyStackRef_None)) { - b = PyStackRef_True;(void)value ; + b = PyStackRef_True; } else { b = PyStackRef_False; @@ -6712,7 +6705,7 @@ { cond = b; assert(PyStackRef_BoolCheck(cond)); - int flag = PyStackRef_Is(cond, PyStackRef_True);(void)cond ; + int flag = PyStackRef_Is(cond, PyStackRef_True); #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif @@ -6736,7 +6729,7 @@ { value = stack_pointer[-1]; if (PyStackRef_Is(value, PyStackRef_None)) { - b = PyStackRef_True;(void)value ; + b = PyStackRef_True; } else { b = PyStackRef_False; @@ -6747,7 +6740,7 @@ { cond = b; assert(PyStackRef_BoolCheck(cond)); - int flag = PyStackRef_Is(cond, PyStackRef_False);(void)cond ; + int flag = PyStackRef_Is(cond, PyStackRef_False); #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif @@ -6767,7 +6760,7 @@ /* Skip 1 cache entry */ cond = stack_pointer[-1]; assert(PyStackRef_BoolCheck(cond)); - int flag = PyStackRef_Is(cond, PyStackRef_True);(void)cond ; + int flag = PyStackRef_Is(cond, PyStackRef_True); #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif @@ -6806,7 +6799,7 @@ } assert(PyStackRef_ExceptionInstanceCheck(exc)); exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); - new_exc = exc;(void)exc ; + new_exc = exc; stack_pointer[-1] = prev_exc; stack_pointer[0] = new_exc; stack_pointer += 1; @@ -6986,7 +6979,7 @@ #if TIER_ONE assert(frame != &entry_frame); #endif - _PyStackRef temp = retval;(void)retval ; + _PyStackRef temp = retval; _PyFrame_SetStackPointer(frame, stack_pointer); assert(EMPTY()); _Py_LeaveRecursiveCallPy(tstate); @@ -7048,7 +7041,7 @@ #if TIER_ONE assert(frame != &entry_frame); #endif - _PyStackRef temp = retval;(void)retval ; + _PyStackRef temp = retval; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -7179,7 +7172,7 @@ DEOPT_IF(gen->gi_frame_state >= FRAME_EXECUTING, SEND); STAT_INC(SEND, hit); gen_frame = &gen->gi_iframe; - _PyFrame_StackPush(gen_frame, v);(void)v ; + _PyFrame_StackPush(gen_frame, v); gen->gi_frame_state = FRAME_EXECUTING; gen->gi_exc_state.previous_item = tstate->exc_info; tstate->exc_info = &gen->gi_exc_state; @@ -7193,7 +7186,7 @@ // Write it out explicitly because it's subtly different. // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); - _PyInterpreterFrame *temp = new_frame;(void)new_frame ; + _PyInterpreterFrame *temp = new_frame; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -7273,7 +7266,7 @@ attr_st = stack_pointer[-2]; PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st); - func_out = func_in;(void)func_in ; + func_out = func_in; assert(PyFunction_Check(func)); size_t offset = _Py_FunctionAttributeOffsets[oparg]; assert(offset != 0); @@ -7509,7 +7502,7 @@ INSTRUCTION_STATS(STORE_FAST); _PyStackRef value; value = stack_pointer[-1]; - SETLOCAL(oparg, value);(void)value ; + SETLOCAL(oparg, value); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -7524,7 +7517,7 @@ value1 = stack_pointer[-1]; uint32_t oparg1 = oparg >> 4; uint32_t oparg2 = oparg & 15; - SETLOCAL(oparg1, value1);(void)value1 ; + SETLOCAL(oparg1, value1); value2 = PyStackRef_DUP(GETLOCAL(oparg2)); stack_pointer[-1] = value2; DISPATCH(); @@ -7540,8 +7533,8 @@ value2 = stack_pointer[-2]; uint32_t oparg1 = oparg >> 4; uint32_t oparg2 = oparg & 15; - SETLOCAL(oparg1, value1);(void)value1 ; - SETLOCAL(oparg2, value2);(void)value2 ; + SETLOCAL(oparg1, value1); + SETLOCAL(oparg2, value2); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -7743,7 +7736,7 @@ PyList_SET_ITEM(list, index, PyStackRef_AsPyObjectSteal(value)); assert(old_value != NULL); Py_DECREF(old_value); - _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free);(void)sub_st ; + _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); PyStackRef_CLOSE(list_st); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); @@ -7760,8 +7753,8 @@ _PyStackRef bottom_out; top_in = stack_pointer[-1]; bottom_in = stack_pointer[-2 - (oparg-2)]; - bottom_out = bottom_in;(void)bottom_in ; - top_out = top_in;(void)top_in ; + bottom_out = bottom_in; + top_out = top_in; assert(oparg >= 2); stack_pointer[-2 - (oparg-2)] = top_out; stack_pointer[-1] = bottom_out; @@ -7866,7 +7859,6 @@ _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); stack_pointer = _PyFrame_GetStackPointer(frame); - (void)value ; res = PyStackRef_False; } else { @@ -7908,7 +7900,6 @@ value = stack_pointer[-1]; // This one is a bit weird, because we expect *some* failures: DEOPT_IF(!PyStackRef_Is(value, PyStackRef_None), TO_BOOL); - (void)value ; STAT_INC(TO_BOOL, hit); res = PyStackRef_False; stack_pointer[-1] = res; @@ -7932,7 +7923,6 @@ _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); stack_pointer = _PyFrame_GetStackPointer(frame); - (void)value ; res = PyStackRef_False; } else { @@ -7987,7 +7977,7 @@ value = stack_pointer[-1]; assert(PyStackRef_BoolCheck(value)); res = PyStackRef_Is(value, PyStackRef_False) - ? PyStackRef_True : PyStackRef_False;(void)value ; + ? PyStackRef_True : PyStackRef_False; stack_pointer[-1] = res; DISPATCH(); } @@ -8198,7 +8188,7 @@ assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; - _PyStackRef temp = retval;(void)retval ; + _PyStackRef temp = retval; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); diff --git a/Python/optimizer.c b/Python/optimizer.c index 6a4510ad929767..9198e410627dd4 100644 --- a/Python/optimizer.c +++ b/Python/optimizer.c @@ -1033,7 +1033,7 @@ prepare_for_execution(_PyUOpInstruction *buffer, int length) current_error = next_spare; current_error_target = target; make_exit(&buffer[next_spare], _ERROR_POP_N, 0); - buffer[next_spare].oparg = 0; + buffer[next_spare].oparg = popped; buffer[next_spare].operand = target; next_spare++; } diff --git a/Python/optimizer_bytecodes.c b/Python/optimizer_bytecodes.c index b51027b3ea95b5..3538cd2c666bb8 100644 --- a/Python/optimizer_bytecodes.c +++ b/Python/optimizer_bytecodes.c @@ -583,8 +583,7 @@ dummy_func(void) { op(_INIT_CALL_PY_EXACT_ARGS, (callable, self_or_null, args[oparg] -- new_frame: _Py_UOpsAbstractFrame *)) { int argcount = oparg; - - KILL(callable); + (void)callable; PyCodeObject *co = NULL; assert((this_instr + 2)->opcode == _PUSH_FRAME); @@ -667,11 +666,10 @@ dummy_func(void) { } op(_RETURN_VALUE, (retval -- res)) { - SYNC_SP(); + SAVE_STACK(); ctx->frame->stack_pointer = stack_pointer; frame_pop(ctx); stack_pointer = ctx->frame->stack_pointer; - res = retval; /* Stack space handling */ assert(corresponding_check_stack == NULL); @@ -686,6 +684,8 @@ dummy_func(void) { // might be impossible, but bailing is still safe ctx->done = true; } + RELOAD_STACK(); + res = retval; } op(_RETURN_GENERATOR, ( -- res)) { diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index d086975396e0a3..a0c292df339fbd 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -30,15 +30,34 @@ if (sym_is_null(value)) { ctx->done = true; } + /* Variables: 'value'D. base: 0. top: 1 + inputs: + outputs: + peeks: */ + stack_pointer[0] = value; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'value'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } case _LOAD_FAST: { _Py_UopsSymbol *value; value = GETLOCAL(oparg); + /* Variables: 'value'D. base: 0. top: 1 + inputs: + outputs: + peeks: */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'value'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -47,9 +66,17 @@ value = GETLOCAL(oparg); _Py_UopsSymbol *temp = sym_new_null(ctx); GETLOCAL(oparg) = temp; + /* Variables: 'value'D. base: 0. top: 1 + inputs: + outputs: + peeks: */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'value'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -59,9 +86,17 @@ int opcode = _Py_IsImmortal(val) ? _LOAD_CONST_INLINE_BORROW : _LOAD_CONST_INLINE; REPLACE_OP(this_instr, opcode, 0, (uintptr_t)val); value = sym_new_const(ctx, val); + /* Variables: 'value'D. base: 0. top: 1 + inputs: + outputs: + peeks: */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'value'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -69,44 +104,62 @@ _Py_UopsSymbol *value; value = stack_pointer[-1]; GETLOCAL(oparg) = value; + /* Variables: . base: -1. top: -1 + inputs: + outputs: + peeks: */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ break; } case _POP_TOP: { - value = stack_pointer[-1]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _PUSH_NULL: { _Py_UopsSymbol *res; res = sym_new_null(ctx); + /* Variables: 'res'D. base: 0. top: 1 + inputs: + outputs: + peeks: */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } case _END_SEND: { _Py_UopsSymbol *val; - value = stack_pointer[-1]; - receiver = stack_pointer[-2]; val = sym_new_not_null(ctx); + stack_pointer[-2] = val; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _UNARY_NEGATIVE: { _Py_UopsSymbol *res; - value = stack_pointer[-1]; res = sym_new_not_null(ctx); + stack_pointer[-1] = res; break; } case _UNARY_NOT: { _Py_UopsSymbol *res; - value = stack_pointer[-1]; res = sym_new_not_null(ctx); + stack_pointer[-1] = res; break; } @@ -118,6 +171,15 @@ if (!opt) { res = sym_new_type(ctx, &PyBool_Type); } + /* Variables: 'res'D. base: -1. top: 0 + inputs: + outputs: + peeks: */ + stack_pointer[-1] = res; + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -130,6 +192,15 @@ sym_set_type(value, &PyBool_Type); res = value; } + /* Variables: 'res'D. base: -1. top: 0 + inputs: + outputs: + peeks: */ + stack_pointer[-1] = res; + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -142,6 +213,15 @@ sym_set_type(value, &PyLong_Type); res = sym_new_type(ctx, &PyBool_Type); } + /* Variables: 'res'D. base: -1. top: 0 + inputs: + outputs: + peeks: */ + stack_pointer[-1] = res; + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -154,6 +234,15 @@ sym_set_type(value, &PyList_Type); res = sym_new_type(ctx, &PyBool_Type); } + /* Variables: 'res'D. base: -1. top: 0 + inputs: + outputs: + peeks: */ + stack_pointer[-1] = res; + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -166,6 +255,15 @@ sym_set_const(value, Py_None); res = sym_new_const(ctx, Py_False); } + /* Variables: 'res'D. base: -1. top: 0 + inputs: + outputs: + peeks: */ + stack_pointer[-1] = res; + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -178,20 +276,29 @@ res = sym_new_type(ctx, &PyBool_Type); sym_set_type(value, &PyUnicode_Type); } + /* Variables: 'res'D. base: -1. top: 0 + inputs: + outputs: + peeks: */ + stack_pointer[-1] = res; + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } case _REPLACE_WITH_TRUE: { _Py_UopsSymbol *res; - value = stack_pointer[-1]; res = sym_new_not_null(ctx); + stack_pointer[-1] = res; break; } case _UNARY_INVERT: { _Py_UopsSymbol *res; - value = stack_pointer[-1]; res = sym_new_not_null(ctx); + stack_pointer[-1] = res; break; } @@ -215,16 +322,22 @@ } sym_set_type(left, &PyLong_Type); sym_set_type(right, &PyLong_Type); + /* Variables: 'left'MD, 'right'MD. base: -2. top: 0 + inputs: + outputs: + peeks: left, right */ + /* Variables: 'left'MD, 'right'MD. base: -2. top: 0 + inputs: + outputs: + peeks: left, right */ break; } case _GUARD_NOS_INT: { - left = stack_pointer[-2]; break; } case _GUARD_TOS_INT: { - value = stack_pointer[-1]; break; } @@ -252,9 +365,17 @@ else { res = sym_new_type(ctx, &PyLong_Type); } + /* Variables: 'res'D. base: -2. top: -1 + inputs: + outputs: + peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -282,9 +403,17 @@ else { res = sym_new_type(ctx, &PyLong_Type); } + /* Variables: 'res'D. base: -2. top: -1 + inputs: + outputs: + peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -312,9 +441,17 @@ else { res = sym_new_type(ctx, &PyLong_Type); } + /* Variables: 'res'D. base: -2. top: -1 + inputs: + outputs: + peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -338,16 +475,22 @@ } sym_set_type(left, &PyFloat_Type); sym_set_type(right, &PyFloat_Type); + /* Variables: 'left'MD, 'right'MD. base: -2. top: 0 + inputs: + outputs: + peeks: left, right */ + /* Variables: 'left'MD, 'right'MD. base: -2. top: 0 + inputs: + outputs: + peeks: left, right */ break; } case _GUARD_NOS_FLOAT: { - left = stack_pointer[-2]; break; } case _GUARD_TOS_FLOAT: { - value = stack_pointer[-1]; break; } @@ -362,6 +505,8 @@ { assert(PyFloat_CheckExact(sym_get_const(left))); assert(PyFloat_CheckExact(sym_get_const(right))); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( PyFloat_AS_DOUBLE(sym_get_const(left)) * PyFloat_AS_DOUBLE(sym_get_const(right))); @@ -374,11 +519,20 @@ // replace opcode with constant propagated one and update tests! } else { - res = sym_new_type(ctx, &PyFloat_Type); + res = sym_new_type(ctx, &PyFloat_Type);stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); } - stack_pointer[-2] = res; - stack_pointer += -1; + /* Variables: 'res'D. base: 0. top: 1 + inputs: + outputs: + peeks: */ + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -393,6 +547,8 @@ { assert(PyFloat_CheckExact(sym_get_const(left))); assert(PyFloat_CheckExact(sym_get_const(right))); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( PyFloat_AS_DOUBLE(sym_get_const(left)) + PyFloat_AS_DOUBLE(sym_get_const(right))); @@ -405,11 +561,20 @@ // replace opcode with constant propagated one and update tests! } else { - res = sym_new_type(ctx, &PyFloat_Type); + res = sym_new_type(ctx, &PyFloat_Type);stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); } - stack_pointer[-2] = res; - stack_pointer += -1; + /* Variables: 'res'D. base: 0. top: 1 + inputs: + outputs: + peeks: */ + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -424,6 +589,8 @@ { assert(PyFloat_CheckExact(sym_get_const(left))); assert(PyFloat_CheckExact(sym_get_const(right))); + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( PyFloat_AS_DOUBLE(sym_get_const(left)) - PyFloat_AS_DOUBLE(sym_get_const(right))); @@ -436,11 +603,20 @@ // replace opcode with constant propagated one and update tests! } else { - res = sym_new_type(ctx, &PyFloat_Type); + res = sym_new_type(ctx, &PyFloat_Type);stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); } - stack_pointer[-2] = res; - stack_pointer += -1; + /* Variables: 'res'D. base: 0. top: 1 + inputs: + outputs: + peeks: */ + stack_pointer[0] = res; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -455,6 +631,14 @@ } sym_set_type(left, &PyUnicode_Type); sym_set_type(left, &PyUnicode_Type); + /* Variables: 'left'MD, 'right'MD. base: -2. top: 0 + inputs: + outputs: + peeks: left, right */ + /* Variables: 'left'MD, 'right'MD. base: -2. top: 0 + inputs: + outputs: + peeks: left, right */ break; } @@ -476,77 +660,87 @@ else { res = sym_new_type(ctx, &PyUnicode_Type); } + /* Variables: 'res'D. base: -2. top: -1 + inputs: + outputs: + peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } case _BINARY_OP_INPLACE_ADD_UNICODE: { - right = stack_pointer[-1]; - left = stack_pointer[-2]; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } case _BINARY_SUBSCR: { _Py_UopsSymbol *res; - sub = stack_pointer[-1]; - container = stack_pointer[-2]; res = sym_new_not_null(ctx); + stack_pointer[-2] = res; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _BINARY_SLICE: { _Py_UopsSymbol *res; - stop = stack_pointer[-1]; - start = stack_pointer[-2]; - container = stack_pointer[-3]; res = sym_new_not_null(ctx); + stack_pointer[-3] = res; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } case _STORE_SLICE: { - stop = stack_pointer[-1]; - start = stack_pointer[-2]; - container = stack_pointer[-3]; - v = stack_pointer[-4]; + stack_pointer += -4; + assert(WITHIN_STACK_BOUNDS()); break; } case _BINARY_SUBSCR_LIST_INT: { _Py_UopsSymbol *res; - sub_st = stack_pointer[-1]; - list_st = stack_pointer[-2]; res = sym_new_not_null(ctx); + stack_pointer[-2] = res; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _BINARY_SUBSCR_STR_INT: { _Py_UopsSymbol *res; - sub_st = stack_pointer[-1]; - str_st = stack_pointer[-2]; res = sym_new_not_null(ctx); + stack_pointer[-2] = res; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _BINARY_SUBSCR_TUPLE_INT: { _Py_UopsSymbol *res; - sub_st = stack_pointer[-1]; - tuple_st = stack_pointer[-2]; res = sym_new_not_null(ctx); + stack_pointer[-2] = res; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _BINARY_SUBSCR_DICT: { _Py_UopsSymbol *res; - sub_st = stack_pointer[-1]; - dict_st = stack_pointer[-2]; res = sym_new_not_null(ctx); + stack_pointer[-2] = res; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _BINARY_SUBSCR_CHECK_FUNC: { - container = stack_pointer[-2]; break; } @@ -560,63 +754,69 @@ (void)sub; new_frame = NULL; ctx->done = true; + /* Variables: 'new_frame'D. base: -2. top: -1 + inputs: + outputs: + peeks: */ stack_pointer[-2] = (_Py_UopsSymbol *)new_frame; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'new_frame'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } case _LIST_APPEND: { - v = stack_pointer[-1]; - list = stack_pointer[-2 - (oparg-1)]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _SET_ADD: { - v = stack_pointer[-1]; - set = stack_pointer[-2 - (oparg-1)]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _STORE_SUBSCR: { - sub = stack_pointer[-1]; - container = stack_pointer[-2]; - v = stack_pointer[-3]; + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); break; } case _STORE_SUBSCR_LIST_INT: { - sub_st = stack_pointer[-1]; - list_st = stack_pointer[-2]; - value = stack_pointer[-3]; + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); break; } case _STORE_SUBSCR_DICT: { - sub = stack_pointer[-1]; - dict_st = stack_pointer[-2]; - value = stack_pointer[-3]; + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); break; } case _DELETE_SUBSCR: { - sub = stack_pointer[-1]; - container = stack_pointer[-2]; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_INTRINSIC_1: { _Py_UopsSymbol *res; - value = stack_pointer[-1]; res = sym_new_not_null(ctx); + stack_pointer[-1] = res; break; } case _CALL_INTRINSIC_2: { _Py_UopsSymbol *res; - value1_st = stack_pointer[-1]; - value2_st = stack_pointer[-2]; res = sym_new_not_null(ctx); + stack_pointer[-2] = res; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -629,7 +829,6 @@ ctx->frame->stack_pointer = stack_pointer; frame_pop(ctx); stack_pointer = ctx->frame->stack_pointer; - res = retval; /* Stack space handling */ assert(corresponding_check_stack == NULL); assert(co != NULL); @@ -642,27 +841,41 @@ // might be impossible, but bailing is still safe ctx->done = true; } + res = retval; + /* Variables: 'res'D. base: 0. top: 1 + inputs: + outputs: + peeks: */ + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } case _GET_AITER: { _Py_UopsSymbol *iter; - obj = stack_pointer[-1]; iter = sym_new_not_null(ctx); + stack_pointer[-1] = iter; break; } case _GET_ANEXT: { _Py_UopsSymbol *awaitable; - aiter = stack_pointer[-1]; awaitable = sym_new_not_null(ctx); + stack_pointer[0] = awaitable; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _GET_AWAITABLE: { _Py_UopsSymbol *iter; - iterable = stack_pointer[-1]; iter = sym_new_not_null(ctx); + stack_pointer[-1] = iter; break; } @@ -671,35 +884,59 @@ case _SEND_GEN_FRAME: { // We are about to hit the end of the trace: ctx->done = true; + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ break; } case _YIELD_VALUE: { _Py_UopsSymbol *res; res = sym_new_unknown(ctx); + /* Variables: 'res'D. base: -1. top: 0 + inputs: + outputs: + peeks: */ stack_pointer[-1] = res; + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } case _POP_EXCEPT: { - exc_value = stack_pointer[-1]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _LOAD_COMMON_CONSTANT: { _Py_UopsSymbol *value; value = sym_new_not_null(ctx); + stack_pointer[0] = value; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _LOAD_BUILD_CLASS: { _Py_UopsSymbol *bc; bc = sym_new_not_null(ctx); + stack_pointer[0] = bc; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _STORE_NAME: { - v = stack_pointer[-1]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -717,37 +954,50 @@ for (int i = 0; i < oparg; i++) { values[i] = sym_new_unknown(ctx); } + /* Variables: 'values'MA. base: -1. top: -1 + oparg + inputs: + outputs: + peeks: */ stack_pointer += -1 + oparg; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'values'MA. base: -oparg. top: 0 + inputs: + outputs: + peeks: */ break; } case _UNPACK_SEQUENCE_TWO_TUPLE: { _Py_UopsSymbol *val1; _Py_UopsSymbol *val0; - seq = stack_pointer[-1]; val1 = sym_new_not_null(ctx); val0 = sym_new_not_null(ctx); + stack_pointer[-1] = val1; + stack_pointer[0] = val0; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _UNPACK_SEQUENCE_TUPLE: { _Py_UopsSymbol **values; - seq = stack_pointer[-1]; - values = &stack_pointer[-1]; + values = &stack_pointer[0]; for (int _i = oparg; --_i >= 0;) { values[_i] = sym_new_not_null(ctx); } + stack_pointer += -1 + oparg; + assert(WITHIN_STACK_BOUNDS()); break; } case _UNPACK_SEQUENCE_LIST: { _Py_UopsSymbol **values; - seq = stack_pointer[-1]; - values = &stack_pointer[-1]; + values = &stack_pointer[0]; for (int _i = oparg; --_i >= 0;) { values[_i] = sym_new_not_null(ctx); } + stack_pointer += -1 + oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -762,24 +1012,34 @@ for (int i = 0; i < totalargs; i++) { values[i] = sym_new_unknown(ctx); } + /* Variables: 'values'MA, 'unused', 'unused'MA. base: -1. top: (oparg & 0xFF) + (oparg >> 8) + inputs: + outputs: + peeks: */ stack_pointer += (oparg & 0xFF) + (oparg >> 8); assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'values'MA, 'unused', 'unused'MA. base: -1 - (oparg & 0xFF) - (oparg >> 8). top: 0 + inputs: + outputs: + peeks: */ break; } case _STORE_ATTR: { - owner = stack_pointer[-1]; - v = stack_pointer[-2]; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } case _DELETE_ATTR: { - owner = stack_pointer[-1]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _STORE_GLOBAL: { - v = stack_pointer[-1]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -790,6 +1050,9 @@ case _LOAD_LOCALS: { _Py_UopsSymbol *locals; locals = sym_new_not_null(ctx); + stack_pointer[0] = locals; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -798,6 +1061,9 @@ case _LOAD_NAME: { _Py_UopsSymbol *v; v = sym_new_not_null(ctx); + stack_pointer[0] = v; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -806,6 +1072,10 @@ _Py_UopsSymbol *null = NULL; res = sym_new_not_null(ctx); null = sym_new_null(ctx); + stack_pointer[0] = res; + if (oparg & 1) stack_pointer[1] = null; + stack_pointer += 1 + (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); break; } @@ -822,6 +1092,10 @@ _Py_UopsSymbol *null = NULL; res = sym_new_not_null(ctx); null = sym_new_null(ctx); + stack_pointer[0] = res; + if (oparg & 1) stack_pointer[1] = null; + stack_pointer += 1 + (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); break; } @@ -830,6 +1104,10 @@ _Py_UopsSymbol *null = NULL; res = sym_new_not_null(ctx); null = sym_new_null(ctx); + stack_pointer[0] = res; + if (oparg & 1) stack_pointer[1] = null; + stack_pointer += 1 + (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); break; } @@ -847,19 +1125,23 @@ case _LOAD_FROM_DICT_OR_DEREF: { _Py_UopsSymbol *value; - class_dict_st = stack_pointer[-1]; value = sym_new_not_null(ctx); + stack_pointer[-1] = value; break; } case _LOAD_DEREF: { _Py_UopsSymbol *value; value = sym_new_not_null(ctx); + stack_pointer[0] = value; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _STORE_DEREF: { - v = stack_pointer[-1]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -869,48 +1151,58 @@ case _BUILD_STRING: { _Py_UopsSymbol *str; - pieces = &stack_pointer[-oparg]; str = sym_new_not_null(ctx); + stack_pointer[-oparg] = str; + stack_pointer += 1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } case _BUILD_TUPLE: { _Py_UopsSymbol *tup; - values = &stack_pointer[-oparg]; tup = sym_new_not_null(ctx); + stack_pointer[-oparg] = tup; + stack_pointer += 1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } case _BUILD_LIST: { _Py_UopsSymbol *list; - values = &stack_pointer[-oparg]; list = sym_new_not_null(ctx); + stack_pointer[-oparg] = list; + stack_pointer += 1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } case _LIST_EXTEND: { - iterable_st = stack_pointer[-1]; - list_st = stack_pointer[-2 - (oparg-1)]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _SET_UPDATE: { - iterable = stack_pointer[-1]; - set = stack_pointer[-2 - (oparg-1)]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _BUILD_SET: { _Py_UopsSymbol *set; - values = &stack_pointer[-oparg]; set = sym_new_not_null(ctx); + stack_pointer[-oparg] = set; + stack_pointer += 1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } case _BUILD_MAP: { _Py_UopsSymbol *map; - values = &stack_pointer[-oparg*2]; map = sym_new_not_null(ctx); + stack_pointer[-oparg*2] = map; + stack_pointer += 1 - oparg*2; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -919,22 +1211,20 @@ } case _DICT_UPDATE: { - update = stack_pointer[-1]; - dict = stack_pointer[-2 - (oparg - 1)]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _DICT_MERGE: { - update = stack_pointer[-1]; - dict = stack_pointer[-2 - (oparg - 1)]; - callable = stack_pointer[-5 - (oparg - 1)]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _MAP_ADD: { - value = stack_pointer[-1]; - key = stack_pointer[-2]; - dict_st = stack_pointer[-3 - (oparg - 1)]; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -942,21 +1232,22 @@ case _LOAD_SUPER_ATTR_ATTR: { _Py_UopsSymbol *attr_st; - self_st = stack_pointer[-1]; - class_st = stack_pointer[-2]; - global_super_st = stack_pointer[-3]; attr_st = sym_new_not_null(ctx); + stack_pointer[-3] = attr_st; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } case _LOAD_SUPER_ATTR_METHOD: { _Py_UopsSymbol *attr; _Py_UopsSymbol *self_or_null; - self_st = stack_pointer[-1]; - class_st = stack_pointer[-2]; - global_super_st = stack_pointer[-3]; attr = sym_new_not_null(ctx); self_or_null = sym_new_not_null(ctx); + stack_pointer[-3] = attr; + stack_pointer[-2] = self_or_null; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -973,10 +1264,18 @@ else { self_or_null = NULL; } + /* Variables: 'attr'D, 'self_or_null'D. base: -1. top: (oparg & 1) + inputs: + outputs: + peeks: */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = self_or_null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'attr'MD, 'self_or_null'MD. base: -1 - (oparg & 1). top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1003,11 +1302,18 @@ } } } + /* Variables: 'owner'MD. base: -1. top: 0 + inputs: + outputs: + peeks: owner */ + /* Variables: 'owner'MD. base: -1. top: 0 + inputs: + outputs: + peeks: owner */ break; } case _CHECK_MANAGED_OBJECT_HAS_VALUES: { - owner = stack_pointer[-1]; break; } @@ -1021,10 +1327,18 @@ null = sym_new_null(ctx); (void)offset; (void)owner; + /* Variables: 'attr'D, 'null'D. base: -1. top: (oparg & 1) + inputs: + outputs: + peeks: */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'attr'MD, 'null'MD. base: -1 - (oparg & 1). top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1046,6 +1360,14 @@ } } } + /* Variables: 'owner'MD. base: -1. top: 0 + inputs: + outputs: + peeks: owner */ + /* Variables: 'owner'MD. base: -1. top: 0 + inputs: + outputs: + peeks: owner */ break; } @@ -1074,11 +1396,22 @@ /* No conversion made. We don't know what `attr` is. */ attr = sym_new_not_null(ctx); } + /* Variables: 'attr'D, 'null'D. base: -1. top: (oparg & 1) + inputs: + outputs: + peeks: */ + stack_pointer[-1] = attr; + if (oparg & 1) stack_pointer[0] = null; + stack_pointer += (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'attr'MD, 'null'MD. base: -1 - (oparg & 1). top: 0 + inputs: + outputs: + peeks: */ break; } case _CHECK_ATTR_WITH_HINT: { - owner = stack_pointer[-1]; break; } @@ -1092,10 +1425,18 @@ null = sym_new_null(ctx); (void)hint; (void)owner; + /* Variables: 'attr'D, 'null'D. base: -1. top: (oparg & 1) + inputs: + outputs: + peeks: */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'attr'MD, 'null'MD. base: -1 - (oparg & 1). top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1109,15 +1450,22 @@ null = sym_new_null(ctx); (void)index; (void)owner; + /* Variables: 'attr'D, 'null'D. base: -1. top: (oparg & 1) + inputs: + outputs: + peeks: */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'attr'MD, 'null'MD. base: -1 - (oparg & 1). top: 0 + inputs: + outputs: + peeks: */ break; } case _CHECK_ATTR_CLASS: { - owner = stack_pointer[-1]; break; } @@ -1131,10 +1479,18 @@ null = sym_new_null(ctx); (void)descr; (void)owner; + /* Variables: 'attr'D, 'null'D. base: -1. top: (oparg & 1) + inputs: + outputs: + peeks: */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'attr'MD, 'null'MD. base: -1 - (oparg & 1). top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1147,32 +1503,39 @@ (void)owner; new_frame = NULL; ctx->done = true; + /* Variables: 'new_frame'D. base: -1. top: 0 + inputs: + outputs: + peeks: */ stack_pointer[-1] = (_Py_UopsSymbol *)new_frame; + /* Variables: 'new_frame'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } /* _LOAD_ATTR_GETATTRIBUTE_OVERRIDDEN is not a viable micro-op for tier 2 */ case _GUARD_DORV_NO_DICT: { - owner = stack_pointer[-1]; break; } case _STORE_ATTR_INSTANCE_VALUE: { - owner = stack_pointer[-1]; - value = stack_pointer[-2]; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } case _STORE_ATTR_WITH_HINT: { - owner = stack_pointer[-1]; - value = stack_pointer[-2]; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } case _STORE_ATTR_SLOT: { - owner = stack_pointer[-1]; - value = stack_pointer[-2]; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1188,11 +1551,22 @@ res = sym_new_type(ctx, &PyBool_Type); } else { - res = _Py_uop_sym_new_not_null(ctx); - } + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); + res = _Py_uop_sym_new_not_null(ctx);stack_pointer += 2; + assert(WITHIN_STACK_BOUNDS()); + } + /* Variables: 'res'D. base: -2. top: -1 + inputs: + outputs: + peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1205,9 +1579,17 @@ (void)left; (void)right; res = sym_new_type(ctx, &PyBool_Type); + /* Variables: 'res'D. base: -2. top: -1 + inputs: + outputs: + peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1220,9 +1602,17 @@ (void)left; (void)right; res = sym_new_type(ctx, &PyBool_Type); + /* Variables: 'res'D. base: -2. top: -1 + inputs: + outputs: + peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1235,9 +1625,17 @@ (void)left; (void)right; res = sym_new_type(ctx, &PyBool_Type); + /* Variables: 'res'D. base: -2. top: -1 + inputs: + outputs: + peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1250,9 +1648,17 @@ (void)left; (void)right; res = sym_new_type(ctx, &PyBool_Type); + /* Variables: 'res'D. base: -2. top: -1 + inputs: + outputs: + peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1265,58 +1671,70 @@ (void)left; (void)right; res = sym_new_type(ctx, &PyBool_Type); + /* Variables: 'res'D. base: -2. top: -1 + inputs: + outputs: + peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } case _CONTAINS_OP_SET: { _Py_UopsSymbol *b; - right = stack_pointer[-1]; - left = stack_pointer[-2]; b = sym_new_not_null(ctx); + stack_pointer[-2] = b; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _CONTAINS_OP_DICT: { _Py_UopsSymbol *b; - right = stack_pointer[-1]; - left = stack_pointer[-2]; b = sym_new_not_null(ctx); + stack_pointer[-2] = b; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _CHECK_EG_MATCH: { _Py_UopsSymbol *rest; _Py_UopsSymbol *match; - match_type_st = stack_pointer[-1]; - exc_value_st = stack_pointer[-2]; rest = sym_new_not_null(ctx); match = sym_new_not_null(ctx); + stack_pointer[-2] = rest; + stack_pointer[-1] = match; break; } case _CHECK_EXC_MATCH: { _Py_UopsSymbol *b; - right = stack_pointer[-1]; - left = stack_pointer[-2]; b = sym_new_not_null(ctx); + stack_pointer[-1] = b; break; } case _IMPORT_NAME: { _Py_UopsSymbol *res; - fromlist = stack_pointer[-1]; - level = stack_pointer[-2]; res = sym_new_not_null(ctx); + stack_pointer[-2] = res; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _IMPORT_FROM: { _Py_UopsSymbol *res; - from = stack_pointer[-1]; res = sym_new_not_null(ctx); + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1326,60 +1744,67 @@ case _IS_NONE: { _Py_UopsSymbol *b; - value = stack_pointer[-1]; b = sym_new_not_null(ctx); + stack_pointer[-1] = b; break; } case _GET_LEN: { _Py_UopsSymbol *len; - obj = stack_pointer[-1]; len = sym_new_not_null(ctx); + stack_pointer[0] = len; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _MATCH_CLASS: { _Py_UopsSymbol *attrs; - names = stack_pointer[-1]; - type = stack_pointer[-2]; - subject = stack_pointer[-3]; attrs = sym_new_not_null(ctx); + stack_pointer[-3] = attrs; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } case _MATCH_MAPPING: { _Py_UopsSymbol *res; - subject = stack_pointer[-1]; res = sym_new_not_null(ctx); + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _MATCH_SEQUENCE: { _Py_UopsSymbol *res; - subject = stack_pointer[-1]; res = sym_new_not_null(ctx); + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _MATCH_KEYS: { _Py_UopsSymbol *values_or_none; - keys = stack_pointer[-1]; - subject = stack_pointer[-2]; values_or_none = sym_new_not_null(ctx); + stack_pointer[0] = values_or_none; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _GET_ITER: { _Py_UopsSymbol *iter; - iterable = stack_pointer[-1]; iter = sym_new_not_null(ctx); + stack_pointer[-1] = iter; break; } case _GET_YIELD_FROM_ITER: { _Py_UopsSymbol *iter; - iterable = stack_pointer[-1]; iter = sym_new_not_null(ctx); + stack_pointer[-1] = iter; break; } @@ -1387,60 +1812,60 @@ case _FOR_ITER_TIER_TWO: { _Py_UopsSymbol *next; - iter = stack_pointer[-1]; next = sym_new_not_null(ctx); + stack_pointer[0] = next; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } /* _INSTRUMENTED_FOR_ITER is not a viable micro-op for tier 2 */ case _ITER_CHECK_LIST: { - iter = stack_pointer[-1]; break; } /* _ITER_JUMP_LIST is not a viable micro-op for tier 2 */ case _GUARD_NOT_EXHAUSTED_LIST: { - iter = stack_pointer[-1]; break; } case _ITER_NEXT_LIST: { _Py_UopsSymbol *next; - iter = stack_pointer[-1]; next = sym_new_not_null(ctx); + stack_pointer[0] = next; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _ITER_CHECK_TUPLE: { - iter = stack_pointer[-1]; break; } /* _ITER_JUMP_TUPLE is not a viable micro-op for tier 2 */ case _GUARD_NOT_EXHAUSTED_TUPLE: { - iter = stack_pointer[-1]; break; } case _ITER_NEXT_TUPLE: { _Py_UopsSymbol *next; - iter = stack_pointer[-1]; next = sym_new_not_null(ctx); + stack_pointer[0] = next; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _ITER_CHECK_RANGE: { - iter = stack_pointer[-1]; break; } /* _ITER_JUMP_RANGE is not a viable micro-op for tier 2 */ case _GUARD_NOT_EXHAUSTED_RANGE: { - iter = stack_pointer[-1]; break; } @@ -1450,15 +1875,31 @@ iter = stack_pointer[-1]; next = sym_new_type(ctx, &PyLong_Type); (void)iter; + /* Variables: 'iter'MD, 'next'D. base: -1. top: 1 + inputs: + outputs: + peeks: iter */ stack_pointer[0] = next; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'iter'MD, 'next'MD. base: -2. top: 0 + inputs: + outputs: + peeks: iter */ break; } case _FOR_ITER_GEN_FRAME: { /* We are about to hit the end of the trace */ ctx->done = true; + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1470,39 +1911,47 @@ (void)owner; attr = sym_new_not_null(ctx); self_or_null = sym_new_unknown(ctx); + /* Variables: 'attr'D, 'self_or_null'D. base: -1. top: 1 + inputs: + outputs: + peeks: */ stack_pointer[-1] = attr; stack_pointer[0] = self_or_null; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'attr'MD, 'self_or_null'MD. base: -2. top: 0 + inputs: + outputs: + peeks: */ break; } case _WITH_EXCEPT_START: { _Py_UopsSymbol *res; - val = stack_pointer[-1]; - lasti = stack_pointer[-3]; - exit_self = stack_pointer[-4]; - exit_func = stack_pointer[-5]; res = sym_new_not_null(ctx); + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _PUSH_EXC_INFO: { _Py_UopsSymbol *prev_exc; _Py_UopsSymbol *new_exc; - exc = stack_pointer[-1]; prev_exc = sym_new_not_null(ctx); new_exc = sym_new_not_null(ctx); + stack_pointer[-1] = prev_exc; + stack_pointer[0] = new_exc; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); break; } case _GUARD_DORV_VALUES_INST_ATTR_FROM_DICT: { - owner = stack_pointer[-1]; break; } case _GUARD_KEYS_VERSION: { - owner = stack_pointer[-1]; break; } @@ -1515,10 +1964,18 @@ (void)descr; attr = sym_new_not_null(ctx); self = owner; + /* Variables: 'attr'D, 'self'D. base: -1. top: 1 + inputs: + outputs: + peeks: */ stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'attr'MD, 'self'MD. base: -2. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1531,29 +1988,36 @@ (void)descr; attr = sym_new_not_null(ctx); self = owner; + /* Variables: 'attr'D, 'self'D. base: -1. top: 1 + inputs: + outputs: + peeks: */ stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'attr'MD, 'self'MD. base: -2. top: 0 + inputs: + outputs: + peeks: */ break; } case _LOAD_ATTR_NONDESCRIPTOR_WITH_VALUES: { _Py_UopsSymbol *attr; - owner = stack_pointer[-1]; attr = sym_new_not_null(ctx); + stack_pointer[-1] = attr; break; } case _LOAD_ATTR_NONDESCRIPTOR_NO_DICT: { _Py_UopsSymbol *attr; - owner = stack_pointer[-1]; attr = sym_new_not_null(ctx); + stack_pointer[-1] = attr; break; } case _CHECK_ATTR_METHOD_LAZY_DICT: { - owner = stack_pointer[-1]; break; } @@ -1566,10 +2030,18 @@ (void)descr; attr = sym_new_not_null(ctx); self = owner; + /* Variables: 'attr'D, 'self'D. base: -1. top: 1 + inputs: + outputs: + peeks: */ stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'attr'MD, 'self'MD. base: -2. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1588,8 +2060,16 @@ (void)args; func = sym_new_not_null(ctx); maybe_self = sym_new_not_null(ctx); + /* Variables: 'func'D, 'maybe_self'D, 'args'MA. base: -2 - oparg. top: 0 + inputs: + outputs: + peeks: */ stack_pointer[-2 - oparg] = func; stack_pointer[-1 - oparg] = maybe_self; + /* Variables: 'func'MD, 'maybe_self'MD, 'args'MA. base: -2 - oparg. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1611,30 +2091,33 @@ (void)args; new_frame = NULL; ctx->done = true; + /* Variables: 'new_frame'D. base: -2 - oparg. top: -1 - oparg + inputs: + outputs: + peeks: */ stack_pointer[-2 - oparg] = (_Py_UopsSymbol *)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'new_frame'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } case _CHECK_FUNCTION_VERSION: { - callable = &stack_pointer[-2 - oparg]; break; } case _CHECK_METHOD_VERSION: { - null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; break; } case _EXPAND_METHOD: { _Py_UopsSymbol **method; _Py_UopsSymbol **self; - null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; - method = &stack_pointer[-2 - oparg]; - self = &stack_pointer[-1 - oparg]; + method = &stack_pointer[0]; + self = &stack_pointer[1]; for (int _i = 1; --_i >= 0;) { method[_i] = sym_new_not_null(ctx); } @@ -1645,16 +2128,15 @@ } case _CHECK_IS_NOT_PY_CALLABLE: { - callable = &stack_pointer[-2 - oparg]; break; } case _CALL_NON_PY_GENERAL: { _Py_UopsSymbol *res; - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1665,6 +2147,14 @@ callable = stack_pointer[-2 - oparg]; sym_set_null(null); sym_set_type(callable, &PyMethod_Type); + /* Variables: 'callable'MD, 'null'MD, 'unused'MA. base: -2 - oparg. top: 0 + inputs: + outputs: + peeks: callable, null, unused */ + /* Variables: 'callable'MD, 'null'MD, 'unused'MA. base: -2 - oparg. top: 0 + inputs: + outputs: + peeks: callable, null, unused */ break; } @@ -1676,8 +2166,16 @@ (void)callable; func = sym_new_not_null(ctx); self = sym_new_not_null(ctx); + /* Variables: 'func'D, 'self'D, 'unused'MA. base: -2 - oparg. top: 0 + inputs: + outputs: + peeks: */ stack_pointer[-2 - oparg] = func; stack_pointer[-1 - oparg] = self; + /* Variables: 'func'MD, 'self'MD, 'unused'MA. base: -2 - oparg. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1687,6 +2185,14 @@ if (_PyInterpreterState_GET()->eval_frame == NULL) { REPLACE_OP(this_instr, _NOP, 0 ,0); } + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1697,12 +2203,28 @@ callable = stack_pointer[-2 - oparg]; sym_set_type(callable, &PyFunction_Type); (void)self_or_null; + /* Variables: 'callable'MD, 'self_or_null'MD, 'unused'MA. base: -2 - oparg. top: 0 + inputs: + outputs: + peeks: callable, self_or_null, unused */ + /* Variables: 'callable'MD, 'self_or_null'MD, 'unused'MA. base: -2 - oparg. top: 0 + inputs: + outputs: + peeks: callable, self_or_null, unused */ break; } case _CHECK_STACK_SPACE: { assert(corresponding_check_stack == NULL); corresponding_check_stack = this_instr; + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1714,7 +2236,8 @@ args = &stack_pointer[-oparg]; self_or_null = stack_pointer[-1 - oparg]; callable = stack_pointer[-2 - oparg]; - int argcount = oparg;(void)callable ; + int argcount = oparg; + (void)callable; PyCodeObject *co = NULL; assert((this_instr + 2)->opcode == _PUSH_FRAME); uint64_t push_operand = (this_instr + 2)->operand; @@ -1747,12 +2270,23 @@ } else { new_frame = frame_new(ctx, co, 0, NULL, 0); } + /* Variables: 'new_frame'D. base: -2 - oparg. top: -1 - oparg + inputs: + outputs: + peeks: */ + stack_pointer[-2 - oparg] = (_Py_UopsSymbol *)new_frame; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'new_frame'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } case _PUSH_FRAME: { _Py_UOpsAbstractFrame *new_frame; - new_frame = (_Py_UOpsAbstractFrame *)stack_pointer[-1].bits; + new_frame = (_Py_UOpsAbstractFrame *)stack_pointer[-1]; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); ctx->frame->stack_pointer = stack_pointer; @@ -1783,33 +2317,41 @@ corresponding_check_stack->opcode = _NOP; } corresponding_check_stack = NULL; + /* Variables: 'unused'. base: 0. top: 0 + inputs: + outputs: + peeks: */ + /* Variables: 'unused'. base: 0. top: 0 + inputs: + outputs: + peeks: */ break; } case _CALL_TYPE_1: { _Py_UopsSymbol *res; - arg = stack_pointer[-1]; - null = stack_pointer[-2]; - callable = stack_pointer[-3]; res = sym_new_not_null(ctx); + stack_pointer[-3] = res; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_STR_1: { _Py_UopsSymbol *res; - arg = stack_pointer[-1]; - null = stack_pointer[-2]; - callable = stack_pointer[-3]; res = sym_new_not_null(ctx); + stack_pointer[-3] = res; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_TUPLE_1: { _Py_UopsSymbol *res; - arg = stack_pointer[-1]; - null = stack_pointer[-2]; - callable = stack_pointer[-3]; res = sym_new_not_null(ctx); + stack_pointer[-3] = res; + stack_pointer += -2; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1830,8 +2372,16 @@ (void)args; self = sym_new_not_null(ctx); init = sym_new_not_null(ctx); + /* Variables: 'self'D, 'init'D, 'args'MA. base: -2 - oparg. top: 0 + inputs: + outputs: + peeks: */ stack_pointer[-2 - oparg] = self; stack_pointer[-1 - oparg] = init; + /* Variables: 'self'MD, 'init'MD, 'args'MA. base: -2 - oparg. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -1848,111 +2398,119 @@ (void)args; init_frame = NULL; ctx->done = true; + /* Variables: 'init_frame'D. base: -2 - oparg. top: -1 - oparg + inputs: + outputs: + peeks: */ stack_pointer[-2 - oparg] = (_Py_UopsSymbol *)init_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'init_frame'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } case _EXIT_INIT_CHECK: { - should_be_none = stack_pointer[-1]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_BUILTIN_CLASS: { _Py_UopsSymbol *res; - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_BUILTIN_O: { _Py_UopsSymbol *res; - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_BUILTIN_FAST: { _Py_UopsSymbol *res; - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_BUILTIN_FAST_WITH_KEYWORDS: { _Py_UopsSymbol *res; - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_LEN: { _Py_UopsSymbol *res; - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_ISINSTANCE: { _Py_UopsSymbol *res; - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_LIST_APPEND: { - arg = stack_pointer[-1]; - self = stack_pointer[-2]; - callable = stack_pointer[-3]; + stack_pointer += -3; + assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_METHOD_DESCRIPTOR_O: { _Py_UopsSymbol *res; - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS: { _Py_UopsSymbol *res; - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_METHOD_DESCRIPTOR_NOARGS: { _Py_UopsSymbol *res; - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } case _CALL_METHOD_DESCRIPTOR_FAST: { _Py_UopsSymbol *res; - args = &stack_pointer[-oparg]; - self_or_null = &stack_pointer[-1 - oparg]; - callable = &stack_pointer[-2 - oparg]; res = sym_new_not_null(ctx); + stack_pointer[-2 - oparg] = res; + stack_pointer += -1 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -1963,12 +2521,9 @@ _Py_UopsSymbol **maybe_self; _Py_UopsSymbol **args; _Py_UopsSymbol *kwnames_out; - kwnames_in = stack_pointer[-1]; - args = &stack_pointer[-1 - oparg]; - self_or_null = &stack_pointer[-2 - oparg]; - callable = &stack_pointer[-3 - oparg]; - func = &stack_pointer[-3 - oparg]; - maybe_self = &stack_pointer[-2 - oparg]; + func = &stack_pointer[0]; + maybe_self = &stack_pointer[1]; + args = &stack_pointer[2]; for (int _i = 1; --_i >= 0;) { func[_i] = sym_new_not_null(ctx); } @@ -1979,6 +2534,7 @@ args[_i] = sym_new_not_null(ctx); } kwnames_out = sym_new_not_null(ctx); + stack_pointer[-1] = kwnames_out; break; } @@ -2000,30 +2556,33 @@ (void)kwnames; new_frame = NULL; ctx->done = true; + /* Variables: 'new_frame'D. base: -3 - oparg. top: -2 - oparg + inputs: + outputs: + peeks: */ stack_pointer[-3 - oparg] = (_Py_UopsSymbol *)new_frame; stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'new_frame'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } case _CHECK_FUNCTION_VERSION_KW: { - callable = &stack_pointer[-3 - oparg]; break; } case _CHECK_METHOD_VERSION_KW: { - null = &stack_pointer[-2 - oparg]; - callable = &stack_pointer[-3 - oparg]; break; } case _EXPAND_METHOD_KW: { _Py_UopsSymbol **method; _Py_UopsSymbol **self; - null = &stack_pointer[-2 - oparg]; - callable = &stack_pointer[-3 - oparg]; - method = &stack_pointer[-3 - oparg]; - self = &stack_pointer[-2 - oparg]; + method = &stack_pointer[0]; + self = &stack_pointer[1]; for (int _i = 1; --_i >= 0;) { method[_i] = sym_new_not_null(ctx); } @@ -2034,17 +2593,15 @@ } case _CHECK_IS_NOT_PY_CALLABLE_KW: { - callable = &stack_pointer[-3 - oparg]; break; } case _CALL_KW_NON_PY: { _Py_UopsSymbol *res; - kwnames = stack_pointer[-1]; - args = &stack_pointer[-1 - oparg]; - self_or_null = &stack_pointer[-2 - oparg]; - callable = &stack_pointer[-3 - oparg]; res = sym_new_not_null(ctx); + stack_pointer[-3 - oparg] = res; + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -2053,11 +2610,10 @@ case _MAKE_CALLARGS_A_TUPLE: { _Py_UopsSymbol *tuple; _Py_UopsSymbol *kwargs_out = NULL; - if (oparg & 1) { kwargs_in = stack_pointer[-(oparg & 1)]; } - callargs = stack_pointer[-1 - (oparg & 1)]; - func = stack_pointer[-3 - (oparg & 1)]; tuple = sym_new_not_null(ctx); kwargs_out = sym_new_not_null(ctx); + stack_pointer[-1 - (oparg & 1)] = tuple; + if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_out; break; } @@ -2065,16 +2621,17 @@ case _MAKE_FUNCTION: { _Py_UopsSymbol *func; - codeobj_st = stack_pointer[-1]; func = sym_new_not_null(ctx); + stack_pointer[-1] = func; break; } case _SET_FUNCTION_ATTRIBUTE: { _Py_UopsSymbol *func_out; - func_in = stack_pointer[-1]; - attr_st = stack_pointer[-2]; func_out = sym_new_not_null(ctx); + stack_pointer[-2] = func_out; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -2096,37 +2653,49 @@ // might be impossible, but bailing is still safe ctx->done = true; } + /* Variables: 'res'D. base: 0. top: 1 + inputs: + outputs: + peeks: */ + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } case _BUILD_SLICE: { _Py_UopsSymbol *slice; - if (oparg == 3) { step = stack_pointer[-((oparg == 3) ? 1 : 0)]; } - stop = stack_pointer[-1 - ((oparg == 3) ? 1 : 0)]; - start = stack_pointer[-2 - ((oparg == 3) ? 1 : 0)]; slice = sym_new_not_null(ctx); + stack_pointer[-2 - ((oparg == 3) ? 1 : 0)] = slice; + stack_pointer += -1 - ((oparg == 3) ? 1 : 0); + assert(WITHIN_STACK_BOUNDS()); break; } case _CONVERT_VALUE: { _Py_UopsSymbol *result; - value = stack_pointer[-1]; result = sym_new_not_null(ctx); + stack_pointer[-1] = result; break; } case _FORMAT_SIMPLE: { _Py_UopsSymbol *res; - value = stack_pointer[-1]; res = sym_new_not_null(ctx); + stack_pointer[-1] = res; break; } case _FORMAT_WITH_SPEC: { _Py_UopsSymbol *res; - fmt_spec = stack_pointer[-1]; - value = stack_pointer[-2]; res = sym_new_not_null(ctx); + stack_pointer[-2] = res; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -2136,9 +2705,17 @@ bottom = stack_pointer[-1 - (oparg-1)]; assert(oparg > 0); top = bottom; + /* Variables: 'bottom'MD, 'unused'MA, 'top'D. base: -1 - (oparg-1). top: 1 + inputs: + outputs: + peeks: bottom, unused */ stack_pointer[0] = top; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'bottom'MD, 'unused'MA, 'top'MD. base: -2 - (oparg-1). top: 0 + inputs: + outputs: + peeks: bottom, unused */ break; } @@ -2166,9 +2743,17 @@ else { res = sym_new_unknown(ctx); } + /* Variables: 'res'D. base: -2. top: -1 + inputs: + outputs: + peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'res'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -2181,8 +2766,16 @@ bottom_in = stack_pointer[-2 - (oparg-2)]; bottom_out = bottom_in; top_out = top_in; + /* Variables: 'top_out'D, 'unused'MA, 'bottom_out'D. base: -2 - (oparg-2). top: 0 + inputs: + outputs: + peeks: */ stack_pointer[-2 - (oparg-2)] = top_out; stack_pointer[-1] = bottom_out; + /* Variables: 'top_out'MD, 'unused'MA, 'bottom_out'MD. base: -2 - (oparg-2). top: 0 + inputs: + outputs: + peeks: */ break; } @@ -2210,6 +2803,16 @@ assert(value != NULL); eliminate_pop_guard(this_instr, value != Py_True); } + /* Variables: . base: -1. top: -1 + inputs: + outputs: + peeks: */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -2221,6 +2824,16 @@ assert(value != NULL); eliminate_pop_guard(this_instr, value != Py_False); } + /* Variables: . base: -1. top: -1 + inputs: + outputs: + peeks: */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -2236,6 +2849,16 @@ assert(!sym_matches_type(flag, &_PyNone_Type)); eliminate_pop_guard(this_instr, true); } + /* Variables: . base: -1. top: -1 + inputs: + outputs: + peeks: */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -2251,11 +2874,29 @@ assert(!sym_matches_type(flag, &_PyNone_Type)); eliminate_pop_guard(this_instr, false); } + /* Variables: . base: -1. top: -1 + inputs: + outputs: + peeks: */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ break; } case _JUMP_TO_TOP: { ctx->done = true; + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -2269,6 +2910,14 @@ /* We should never see _CHECK_STACK_SPACE_OPERANDs. * They are only created at the end of this pass. */ Py_UNREACHABLE(); + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -2280,6 +2929,14 @@ PyObject *exit_p = (PyObject *)this_instr->operand; (void)exit_p; ctx->done = true; + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ + /* Variables: . base: 0. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -2291,9 +2948,17 @@ _Py_UopsSymbol *value; PyObject *ptr = (PyObject *)this_instr->operand; value = sym_new_const(ctx, ptr); + /* Variables: 'value'D. base: 0. top: 1 + inputs: + outputs: + peeks: */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'value'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -2301,16 +2966,24 @@ _Py_UopsSymbol *value; PyObject *ptr = (PyObject *)this_instr->operand; value = sym_new_const(ctx, ptr); + /* Variables: 'value'D. base: 0. top: 1 + inputs: + outputs: + peeks: */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'value'MD. base: -1. top: 0 + inputs: + outputs: + peeks: */ break; } case _POP_TOP_LOAD_CONST_INLINE_BORROW: { _Py_UopsSymbol *value; - pop = stack_pointer[-1]; value = sym_new_not_null(ctx); + stack_pointer[-1] = value; break; } @@ -2320,10 +2993,18 @@ PyObject *ptr = (PyObject *)this_instr->operand; value = sym_new_const(ctx, ptr); null = sym_new_null(ctx); + /* Variables: 'value'D, 'null'D. base: 0. top: 2 + inputs: + outputs: + peeks: */ stack_pointer[0] = value; stack_pointer[1] = null; stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'value'MD, 'null'MD. base: -2. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -2333,10 +3014,18 @@ PyObject *ptr = (PyObject *)this_instr->operand; value = sym_new_const(ctx, ptr); null = sym_new_null(ctx); + /* Variables: 'value'D, 'null'D. base: 0. top: 2 + inputs: + outputs: + peeks: */ stack_pointer[0] = value; stack_pointer[1] = null; stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); + /* Variables: 'value'MD, 'null'MD. base: -2. top: 0 + inputs: + outputs: + peeks: */ break; } @@ -2345,7 +3034,8 @@ } case _INTERNAL_INCREMENT_OPT_COUNTER: { - opt = stack_pointer[-1]; + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); break; } @@ -2370,6 +3060,8 @@ } case _ERROR_POP_N: { + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); break; } diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index d9f5a523a71697..f8c8ff514b3c03 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -499,16 +499,17 @@ def emit_tokens( uop: Uop, storage: Storage, inst: Instruction | None, - ) -> None: + ) -> Storage: tkn_iter = TokenIterator(uop.body) self.out.start_line() _, rbrace, storage = self._emit_block(tkn_iter, uop, storage, inst, False) try: + self._print_storage(storage) storage.push_outputs() self._print_storage(storage) except StackError as ex: raise analysis_error(ex.args[0], rbrace) - return storage.stack + return storage def emit(self, txt: str | Token) -> None: self.out.emit(txt) diff --git a/Tools/cases_generator/optimizer_generator.py b/Tools/cases_generator/optimizer_generator.py index 000a35f4253996..9fd131b42d56bc 100644 --- a/Tools/cases_generator/optimizer_generator.py +++ b/Tools/cases_generator/optimizer_generator.py @@ -46,7 +46,7 @@ def declare_variables(uop: Uop, out: CWriter, skip_inputs: bool) -> None: variables = {"unused"} if not skip_inputs: for var in reversed(uop.stack.inputs): - if var.name not in variables: + if var.name not in variables and var.used: variables.add(var.name) if var.condition: out.emit(f"{type_name(var)}{var.name} = NULL;\n") @@ -77,25 +77,36 @@ def decref_inputs( out.emit_at("", tkn) -def emit_default(out: CWriter, uop: Uop, storage: Storage) -> None: - for var in storage.outputs: - if var.name != "unused" and not var.item.peek: +def emit_default(out: CWriter, uop: Uop, stack: Stack) -> None: + top_offset = stack.top_offset.copy() + for var in uop.stack.inputs: + stack.pop(var) + for var in uop.stack.outputs: + if var.is_array() and not var.peek and not var.name == "unused": + c_offset = top_offset.to_c() + top_offset.push(var) + out.emit(f"{var.name} = &stack_pointer[{c_offset}];\n") + else: + top_offset.push(var) + for var in uop.stack.outputs: + local = Local.undefined(var) + stack.push(local) + if var.name != "unused" and not var.peek: + local.defined = True if var.is_array(): out.emit(f"for (int _i = {var.size}; --_i >= 0;) {{\n") out.emit(f"{var.name}[_i] = sym_new_not_null(ctx);\n") out.emit("}\n") elif var.name == "null": out.emit(f"{var.name} = sym_new_null(ctx);\n") - var.defined = True else: out.emit(f"{var.name} = sym_new_not_null(ctx);\n") - var.defined = True class OptimizerEmitter(Emitter): def emit_save(self, storage: Storage): - pass + storage.flush(self.out) def emit_reload(self, storage: Storage): pass @@ -113,9 +124,10 @@ def write_uop( prototype = override if override else uop try: out.start_line() - code_list, storage = Storage.for_uop(stack, prototype) - for code in code_list: - out.emit(code) + if override: + code_list, storage = Storage.for_uop(stack, prototype, extract_bits=False) + for code in code_list: + out.emit(code) if debug: args = [] for var in prototype.stack.inputs: @@ -133,14 +145,16 @@ def write_uop( out.emit(f"{type}{cache.name} = ({cast})this_instr->operand;\n") if override: emitter = OptimizerEmitter(out) - # No reference management needed. + # No reference management of inputs needed. for var in storage.inputs: var.defined = False - emitter.emit_tokens(override, storage, None) + storage = emitter.emit_tokens(override, storage, None) + out.start_line() + storage.flush(out, cast_type="_Py_UopsSymbol *", extract_bits=False) else: - emit_default(out, uop, storage) - out.start_line() - stack.flush(out, cast_type="_Py_UopsSymbol *", extract_bits=True) + emit_default(out, uop, stack) + out.start_line() + stack.flush(out, cast_type="_Py_UopsSymbol *", extract_bits=False) except StackError as ex: raise analysis_error(ex.args[0], prototype.body[0]) # from None diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index df4e9a227dfbc2..3affbe051db236 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -229,7 +229,7 @@ def __init__(self) -> None: self.variables: list[Local] = [] self.defined: set[str] = set() - def pop(self, var: StackItem, extract_bits: bool = False) -> tuple[str, Local]: + def pop(self, var: StackItem, extract_bits: bool = True) -> tuple[str, Local]: self.top_offset.pop(var) indirect = "&" if var.is_array() else "" if self.variables: @@ -271,7 +271,7 @@ def pop(self, var: StackItem, extract_bits: bool = False) -> tuple[str, Local]: return "", Local.unused(var) self.defined.add(var.name) cast = f"({var.type})" if (not indirect and var.type) else "" - bits = ".bits" if cast and not extract_bits else "" + bits = ".bits" if cast and extract_bits else "" assign = f"{var.name} = {cast}{indirect}stack_pointer[{self.base_offset.to_c()}]{bits};" if var.condition: if var.condition == "1": @@ -297,10 +297,10 @@ def _do_emit( var: StackItem, base_offset: StackOffset, cast_type: str = "uintptr_t", - extract_bits: bool = False, + extract_bits: bool = True, ) -> None: cast = f"({cast_type})" if var.type else "" - bits = ".bits" if cast and not extract_bits else "" + bits = ".bits" if cast and extract_bits else "" if var.condition == "0": return if var.condition and var.condition != "1": @@ -313,7 +313,7 @@ def _adjust_stack_pointer(self, out: CWriter, number: str): out.emit("assert(WITHIN_STACK_BOUNDS());\n") def flush( - self, out: CWriter, cast_type: str = "uintptr_t", extract_bits: bool = False + self, out: CWriter, cast_type: str = "uintptr_t", extract_bits: bool = True ) -> None: out.start_line() var_offset = self.base_offset.copy() @@ -490,10 +490,10 @@ def locals_cached(self) -> bool: return True return False - def flush(self, out: CWriter) -> None: + def flush(self, out: CWriter, cast_type: str = "uintptr_t", extract_bits: bool = True) -> None: self.clear_dead_inputs() self._push_defined_outputs() - self.stack.flush(out) + self.stack.flush(out, cast_type, extract_bits) def save(self, out: CWriter) -> None: assert self.spilled >= 0 @@ -517,12 +517,12 @@ def reload(self, out: CWriter) -> None: out.emit(f"/* Virtual reload {self.spilled} */\n") @staticmethod - def for_uop(stack: Stack, uop: Uop) -> tuple[list[str], "Storage"]: + def for_uop(stack: Stack, uop: Uop, extract_bits: bool = True) -> tuple[list[str], "Storage"]: code_list: list[str] = [] inputs: list[Local] = [] peeks: list[Local] = [] for var in reversed(uop.stack.inputs): - code, local = stack.pop(var) + code, local = stack.pop(var, extract_bits) code_list.append(code) if var.peek: peeks.append(local) diff --git a/Tools/cases_generator/tier1_generator.py b/Tools/cases_generator/tier1_generator.py index 279d80efeb2626..1b116a578c5a86 100644 --- a/Tools/cases_generator/tier1_generator.py +++ b/Tools/cases_generator/tier1_generator.py @@ -107,12 +107,12 @@ def write_uop( emitter.emit(f"(void){cache.name};\n") offset += cache.size - stack = emitter.emit_tokens(uop, storage, inst) + storage = emitter.emit_tokens(uop, storage, inst) if braces: emitter.out.start_line() emitter.emit("}\n") # emitter.emit(stack.as_comment() + "\n") - return offset, stack + return offset, storage.stack except StackError as ex: raise analysis_error(ex.args[0], uop.body[0]) diff --git a/Tools/cases_generator/tier2_generator.py b/Tools/cases_generator/tier2_generator.py index e9d3503b160e05..e5e698de765e73 100644 --- a/Tools/cases_generator/tier2_generator.py +++ b/Tools/cases_generator/tier2_generator.py @@ -36,6 +36,8 @@ def declare_variable( ) -> None: if var.name not in required: return + if not var.used: + return required.remove(var.name) type, null = type_and_null(var) space = " " if type[-1].isalnum() else "" @@ -76,7 +78,6 @@ def error_if( storage: Storage, inst: Instruction | None, ) -> bool: - storage.flush(self.out) self.out.emit_at("if ", tkn) lparen = next(tkn_iter) self.emit(lparen) @@ -168,7 +169,7 @@ def oparg( return True -def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> None: +def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> Stack: locals: dict[str, Local] = {} try: emitter.out.start_line() @@ -189,10 +190,10 @@ def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> None: type = f"uint{cache.size*16}_t " cast = f"uint{cache.size*16}_t" emitter.emit(f"{type}{cache.name} = ({cast})CURRENT_OPERAND();\n") - emitter.emit_tokens(uop, storage, None) + storage = emitter.emit_tokens(uop, storage, None) except StackError as ex: raise analysis_error(ex.args[0], uop.body[0]) from None - + return storage.stack SKIPS = ("_EXTENDED_ARG",) @@ -229,7 +230,7 @@ def generate_tier2( out.emit(f"case {uop.name}: {{\n") declare_variables(uop, out) stack = Stack() - write_uop(uop, emitter, stack) + stack = write_uop(uop, emitter, stack) out.start_line() if not uop.properties.always_exits: stack.flush(out) From e5d0e6709279a898c13b58c4d87153472c7bf41e Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Tue, 17 Sep 2024 15:38:54 +0100 Subject: [PATCH 32/53] Publish symbol for the JIT --- Include/internal/pycore_ceval.h | 2 + Python/bytecodes.c | 2 +- Python/ceval.c | 4 +- Python/executor_cases.c.h | 4 +- Python/generated_cases.c.h | 4 +- Python/optimizer_cases.c.h | 608 -------------------------------- 6 files changed, 11 insertions(+), 613 deletions(-) diff --git a/Include/internal/pycore_ceval.h b/Include/internal/pycore_ceval.h index ffc9a8875f7816..0f963c64c57108 100644 --- a/Include/internal/pycore_ceval.h +++ b/Include/internal/pycore_ceval.h @@ -275,6 +275,8 @@ PyAPI_FUNC(PyObject *) _PyEval_GetANext(PyObject *aiter); PyAPI_FUNC(PyObject *) _PyEval_LoadGlobal(PyObject *globals, PyObject *builtins, PyObject *name); PyAPI_FUNC(PyObject *) _PyEval_GetAwaitable(PyObject *iterable, int oparg); PyAPI_FUNC(PyObject *) _PyEval_LoadName(PyThreadState *tstate, _PyInterpreterFrame *frame, PyObject *name); +PyAPI_FUNC(int) +_Py_Check_ArgsIterable(PyThreadState *tstate, PyObject *func, PyObject *args); /* Bits that can be set in PyThreadState.eval_breaker */ #define _PY_GIL_DROP_REQUEST_BIT (1U << 0) diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 2aa16f6dfae297..e702d008671739 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -4370,7 +4370,7 @@ dummy_func( KILL(callargs); } else { - int err = check_args_iterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); + int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); if (err < 0) { ERROR_NO_POP(); } diff --git a/Python/ceval.c b/Python/ceval.c index 26dcd54a474a6d..ee12e5eea95302 100644 --- a/Python/ceval.c +++ b/Python/ceval.c @@ -2923,8 +2923,8 @@ _PyEval_CheckExceptStarTypeValid(PyThreadState *tstate, PyObject* right) return 0; } -static int -check_args_iterable(PyThreadState *tstate, PyObject *func, PyObject *args) +int +_Py_Check_ArgsIterable(PyThreadState *tstate, PyObject *func, PyObject *args) { if (Py_TYPE(args)->tp_iter == NULL && !PySequence_Check(args)) { /* check_args_iterable() may be called with a live exception: diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 41f2ef27cf692e..a4e11adfe20a32 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -5241,7 +5241,9 @@ tuple = callargs; } else { - int err = check_args_iterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { JUMP_TO_ERROR(); } diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 3ec19203d1bfff..3f45c1f93eff57 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -1643,7 +1643,9 @@ tuple = callargs; } else { - int err = check_args_iterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { goto error; } diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index a0c292df339fbd..9e01963038201c 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -30,34 +30,18 @@ if (sym_is_null(value)) { ctx->done = true; } - /* Variables: 'value'D. base: 0. top: 1 - inputs: - outputs: - peeks: */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'value'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } case _LOAD_FAST: { _Py_UopsSymbol *value; value = GETLOCAL(oparg); - /* Variables: 'value'D. base: 0. top: 1 - inputs: - outputs: - peeks: */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'value'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -66,17 +50,9 @@ value = GETLOCAL(oparg); _Py_UopsSymbol *temp = sym_new_null(ctx); GETLOCAL(oparg) = temp; - /* Variables: 'value'D. base: 0. top: 1 - inputs: - outputs: - peeks: */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'value'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -86,17 +62,9 @@ int opcode = _Py_IsImmortal(val) ? _LOAD_CONST_INLINE_BORROW : _LOAD_CONST_INLINE; REPLACE_OP(this_instr, opcode, 0, (uintptr_t)val); value = sym_new_const(ctx, val); - /* Variables: 'value'D. base: 0. top: 1 - inputs: - outputs: - peeks: */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'value'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -104,16 +72,8 @@ _Py_UopsSymbol *value; value = stack_pointer[-1]; GETLOCAL(oparg) = value; - /* Variables: . base: -1. top: -1 - inputs: - outputs: - peeks: */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -126,17 +86,9 @@ case _PUSH_NULL: { _Py_UopsSymbol *res; res = sym_new_null(ctx); - /* Variables: 'res'D. base: 0. top: 1 - inputs: - outputs: - peeks: */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -171,15 +123,7 @@ if (!opt) { res = sym_new_type(ctx, &PyBool_Type); } - /* Variables: 'res'D. base: -1. top: 0 - inputs: - outputs: - peeks: */ stack_pointer[-1] = res; - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -192,15 +136,7 @@ sym_set_type(value, &PyBool_Type); res = value; } - /* Variables: 'res'D. base: -1. top: 0 - inputs: - outputs: - peeks: */ stack_pointer[-1] = res; - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -213,15 +149,7 @@ sym_set_type(value, &PyLong_Type); res = sym_new_type(ctx, &PyBool_Type); } - /* Variables: 'res'D. base: -1. top: 0 - inputs: - outputs: - peeks: */ stack_pointer[-1] = res; - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -234,15 +162,7 @@ sym_set_type(value, &PyList_Type); res = sym_new_type(ctx, &PyBool_Type); } - /* Variables: 'res'D. base: -1. top: 0 - inputs: - outputs: - peeks: */ stack_pointer[-1] = res; - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -255,15 +175,7 @@ sym_set_const(value, Py_None); res = sym_new_const(ctx, Py_False); } - /* Variables: 'res'D. base: -1. top: 0 - inputs: - outputs: - peeks: */ stack_pointer[-1] = res; - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -276,15 +188,7 @@ res = sym_new_type(ctx, &PyBool_Type); sym_set_type(value, &PyUnicode_Type); } - /* Variables: 'res'D. base: -1. top: 0 - inputs: - outputs: - peeks: */ stack_pointer[-1] = res; - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -322,14 +226,6 @@ } sym_set_type(left, &PyLong_Type); sym_set_type(right, &PyLong_Type); - /* Variables: 'left'MD, 'right'MD. base: -2. top: 0 - inputs: - outputs: - peeks: left, right */ - /* Variables: 'left'MD, 'right'MD. base: -2. top: 0 - inputs: - outputs: - peeks: left, right */ break; } @@ -365,17 +261,9 @@ else { res = sym_new_type(ctx, &PyLong_Type); } - /* Variables: 'res'D. base: -2. top: -1 - inputs: - outputs: - peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -403,17 +291,9 @@ else { res = sym_new_type(ctx, &PyLong_Type); } - /* Variables: 'res'D. base: -2. top: -1 - inputs: - outputs: - peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -441,17 +321,9 @@ else { res = sym_new_type(ctx, &PyLong_Type); } - /* Variables: 'res'D. base: -2. top: -1 - inputs: - outputs: - peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -475,14 +347,6 @@ } sym_set_type(left, &PyFloat_Type); sym_set_type(right, &PyFloat_Type); - /* Variables: 'left'MD, 'right'MD. base: -2. top: 0 - inputs: - outputs: - peeks: left, right */ - /* Variables: 'left'MD, 'right'MD. base: -2. top: 0 - inputs: - outputs: - peeks: left, right */ break; } @@ -522,17 +386,9 @@ res = sym_new_type(ctx, &PyFloat_Type);stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); } - /* Variables: 'res'D. base: 0. top: 1 - inputs: - outputs: - peeks: */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -564,17 +420,9 @@ res = sym_new_type(ctx, &PyFloat_Type);stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); } - /* Variables: 'res'D. base: 0. top: 1 - inputs: - outputs: - peeks: */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -606,17 +454,9 @@ res = sym_new_type(ctx, &PyFloat_Type);stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); } - /* Variables: 'res'D. base: 0. top: 1 - inputs: - outputs: - peeks: */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -631,14 +471,6 @@ } sym_set_type(left, &PyUnicode_Type); sym_set_type(left, &PyUnicode_Type); - /* Variables: 'left'MD, 'right'MD. base: -2. top: 0 - inputs: - outputs: - peeks: left, right */ - /* Variables: 'left'MD, 'right'MD. base: -2. top: 0 - inputs: - outputs: - peeks: left, right */ break; } @@ -660,17 +492,9 @@ else { res = sym_new_type(ctx, &PyUnicode_Type); } - /* Variables: 'res'D. base: -2. top: -1 - inputs: - outputs: - peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -754,17 +578,9 @@ (void)sub; new_frame = NULL; ctx->done = true; - /* Variables: 'new_frame'D. base: -2. top: -1 - inputs: - outputs: - peeks: */ stack_pointer[-2] = (_Py_UopsSymbol *)new_frame; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'new_frame'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -842,17 +658,9 @@ ctx->done = true; } res = retval; - /* Variables: 'res'D. base: 0. top: 1 - inputs: - outputs: - peeks: */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -884,29 +692,13 @@ case _SEND_GEN_FRAME: { // We are about to hit the end of the trace: ctx->done = true; - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ break; } case _YIELD_VALUE: { _Py_UopsSymbol *res; res = sym_new_unknown(ctx); - /* Variables: 'res'D. base: -1. top: 0 - inputs: - outputs: - peeks: */ stack_pointer[-1] = res; - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -954,16 +746,8 @@ for (int i = 0; i < oparg; i++) { values[i] = sym_new_unknown(ctx); } - /* Variables: 'values'MA. base: -1. top: -1 + oparg - inputs: - outputs: - peeks: */ stack_pointer += -1 + oparg; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'values'MA. base: -oparg. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1012,16 +796,8 @@ for (int i = 0; i < totalargs; i++) { values[i] = sym_new_unknown(ctx); } - /* Variables: 'values'MA, 'unused', 'unused'MA. base: -1. top: (oparg & 0xFF) + (oparg >> 8) - inputs: - outputs: - peeks: */ stack_pointer += (oparg & 0xFF) + (oparg >> 8); assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'values'MA, 'unused', 'unused'MA. base: -1 - (oparg & 0xFF) - (oparg >> 8). top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1264,18 +1040,10 @@ else { self_or_null = NULL; } - /* Variables: 'attr'D, 'self_or_null'D. base: -1. top: (oparg & 1) - inputs: - outputs: - peeks: */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = self_or_null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'attr'MD, 'self_or_null'MD. base: -1 - (oparg & 1). top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1302,14 +1070,6 @@ } } } - /* Variables: 'owner'MD. base: -1. top: 0 - inputs: - outputs: - peeks: owner */ - /* Variables: 'owner'MD. base: -1. top: 0 - inputs: - outputs: - peeks: owner */ break; } @@ -1327,18 +1087,10 @@ null = sym_new_null(ctx); (void)offset; (void)owner; - /* Variables: 'attr'D, 'null'D. base: -1. top: (oparg & 1) - inputs: - outputs: - peeks: */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'attr'MD, 'null'MD. base: -1 - (oparg & 1). top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1360,14 +1112,6 @@ } } } - /* Variables: 'owner'MD. base: -1. top: 0 - inputs: - outputs: - peeks: owner */ - /* Variables: 'owner'MD. base: -1. top: 0 - inputs: - outputs: - peeks: owner */ break; } @@ -1396,18 +1140,10 @@ /* No conversion made. We don't know what `attr` is. */ attr = sym_new_not_null(ctx); } - /* Variables: 'attr'D, 'null'D. base: -1. top: (oparg & 1) - inputs: - outputs: - peeks: */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'attr'MD, 'null'MD. base: -1 - (oparg & 1). top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1425,18 +1161,10 @@ null = sym_new_null(ctx); (void)hint; (void)owner; - /* Variables: 'attr'D, 'null'D. base: -1. top: (oparg & 1) - inputs: - outputs: - peeks: */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'attr'MD, 'null'MD. base: -1 - (oparg & 1). top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1450,18 +1178,10 @@ null = sym_new_null(ctx); (void)index; (void)owner; - /* Variables: 'attr'D, 'null'D. base: -1. top: (oparg & 1) - inputs: - outputs: - peeks: */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'attr'MD, 'null'MD. base: -1 - (oparg & 1). top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1479,18 +1199,10 @@ null = sym_new_null(ctx); (void)descr; (void)owner; - /* Variables: 'attr'D, 'null'D. base: -1. top: (oparg & 1) - inputs: - outputs: - peeks: */ stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'attr'MD, 'null'MD. base: -1 - (oparg & 1). top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1503,15 +1215,7 @@ (void)owner; new_frame = NULL; ctx->done = true; - /* Variables: 'new_frame'D. base: -1. top: 0 - inputs: - outputs: - peeks: */ stack_pointer[-1] = (_Py_UopsSymbol *)new_frame; - /* Variables: 'new_frame'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1556,17 +1260,9 @@ res = _Py_uop_sym_new_not_null(ctx);stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); } - /* Variables: 'res'D. base: -2. top: -1 - inputs: - outputs: - peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1579,17 +1275,9 @@ (void)left; (void)right; res = sym_new_type(ctx, &PyBool_Type); - /* Variables: 'res'D. base: -2. top: -1 - inputs: - outputs: - peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1602,17 +1290,9 @@ (void)left; (void)right; res = sym_new_type(ctx, &PyBool_Type); - /* Variables: 'res'D. base: -2. top: -1 - inputs: - outputs: - peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1625,17 +1305,9 @@ (void)left; (void)right; res = sym_new_type(ctx, &PyBool_Type); - /* Variables: 'res'D. base: -2. top: -1 - inputs: - outputs: - peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1648,17 +1320,9 @@ (void)left; (void)right; res = sym_new_type(ctx, &PyBool_Type); - /* Variables: 'res'D. base: -2. top: -1 - inputs: - outputs: - peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1671,17 +1335,9 @@ (void)left; (void)right; res = sym_new_type(ctx, &PyBool_Type); - /* Variables: 'res'D. base: -2. top: -1 - inputs: - outputs: - peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1875,31 +1531,15 @@ iter = stack_pointer[-1]; next = sym_new_type(ctx, &PyLong_Type); (void)iter; - /* Variables: 'iter'MD, 'next'D. base: -1. top: 1 - inputs: - outputs: - peeks: iter */ stack_pointer[0] = next; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'iter'MD, 'next'MD. base: -2. top: 0 - inputs: - outputs: - peeks: iter */ break; } case _FOR_ITER_GEN_FRAME: { /* We are about to hit the end of the trace */ ctx->done = true; - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1911,18 +1551,10 @@ (void)owner; attr = sym_new_not_null(ctx); self_or_null = sym_new_unknown(ctx); - /* Variables: 'attr'D, 'self_or_null'D. base: -1. top: 1 - inputs: - outputs: - peeks: */ stack_pointer[-1] = attr; stack_pointer[0] = self_or_null; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'attr'MD, 'self_or_null'MD. base: -2. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1964,18 +1596,10 @@ (void)descr; attr = sym_new_not_null(ctx); self = owner; - /* Variables: 'attr'D, 'self'D. base: -1. top: 1 - inputs: - outputs: - peeks: */ stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'attr'MD, 'self'MD. base: -2. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -1988,18 +1612,10 @@ (void)descr; attr = sym_new_not_null(ctx); self = owner; - /* Variables: 'attr'D, 'self'D. base: -1. top: 1 - inputs: - outputs: - peeks: */ stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'attr'MD, 'self'MD. base: -2. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2030,18 +1646,10 @@ (void)descr; attr = sym_new_not_null(ctx); self = owner; - /* Variables: 'attr'D, 'self'D. base: -1. top: 1 - inputs: - outputs: - peeks: */ stack_pointer[-1] = attr; stack_pointer[0] = self; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'attr'MD, 'self'MD. base: -2. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2060,16 +1668,8 @@ (void)args; func = sym_new_not_null(ctx); maybe_self = sym_new_not_null(ctx); - /* Variables: 'func'D, 'maybe_self'D, 'args'MA. base: -2 - oparg. top: 0 - inputs: - outputs: - peeks: */ stack_pointer[-2 - oparg] = func; stack_pointer[-1 - oparg] = maybe_self; - /* Variables: 'func'MD, 'maybe_self'MD, 'args'MA. base: -2 - oparg. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2091,17 +1691,9 @@ (void)args; new_frame = NULL; ctx->done = true; - /* Variables: 'new_frame'D. base: -2 - oparg. top: -1 - oparg - inputs: - outputs: - peeks: */ stack_pointer[-2 - oparg] = (_Py_UopsSymbol *)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'new_frame'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2147,14 +1739,6 @@ callable = stack_pointer[-2 - oparg]; sym_set_null(null); sym_set_type(callable, &PyMethod_Type); - /* Variables: 'callable'MD, 'null'MD, 'unused'MA. base: -2 - oparg. top: 0 - inputs: - outputs: - peeks: callable, null, unused */ - /* Variables: 'callable'MD, 'null'MD, 'unused'MA. base: -2 - oparg. top: 0 - inputs: - outputs: - peeks: callable, null, unused */ break; } @@ -2166,16 +1750,8 @@ (void)callable; func = sym_new_not_null(ctx); self = sym_new_not_null(ctx); - /* Variables: 'func'D, 'self'D, 'unused'MA. base: -2 - oparg. top: 0 - inputs: - outputs: - peeks: */ stack_pointer[-2 - oparg] = func; stack_pointer[-1 - oparg] = self; - /* Variables: 'func'MD, 'self'MD, 'unused'MA. base: -2 - oparg. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2185,14 +1761,6 @@ if (_PyInterpreterState_GET()->eval_frame == NULL) { REPLACE_OP(this_instr, _NOP, 0 ,0); } - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2203,28 +1771,12 @@ callable = stack_pointer[-2 - oparg]; sym_set_type(callable, &PyFunction_Type); (void)self_or_null; - /* Variables: 'callable'MD, 'self_or_null'MD, 'unused'MA. base: -2 - oparg. top: 0 - inputs: - outputs: - peeks: callable, self_or_null, unused */ - /* Variables: 'callable'MD, 'self_or_null'MD, 'unused'MA. base: -2 - oparg. top: 0 - inputs: - outputs: - peeks: callable, self_or_null, unused */ break; } case _CHECK_STACK_SPACE: { assert(corresponding_check_stack == NULL); corresponding_check_stack = this_instr; - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2270,17 +1822,9 @@ } else { new_frame = frame_new(ctx, co, 0, NULL, 0); } - /* Variables: 'new_frame'D. base: -2 - oparg. top: -1 - oparg - inputs: - outputs: - peeks: */ stack_pointer[-2 - oparg] = (_Py_UopsSymbol *)new_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'new_frame'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2317,14 +1861,6 @@ corresponding_check_stack->opcode = _NOP; } corresponding_check_stack = NULL; - /* Variables: 'unused'. base: 0. top: 0 - inputs: - outputs: - peeks: */ - /* Variables: 'unused'. base: 0. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2372,16 +1908,8 @@ (void)args; self = sym_new_not_null(ctx); init = sym_new_not_null(ctx); - /* Variables: 'self'D, 'init'D, 'args'MA. base: -2 - oparg. top: 0 - inputs: - outputs: - peeks: */ stack_pointer[-2 - oparg] = self; stack_pointer[-1 - oparg] = init; - /* Variables: 'self'MD, 'init'MD, 'args'MA. base: -2 - oparg. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2398,17 +1926,9 @@ (void)args; init_frame = NULL; ctx->done = true; - /* Variables: 'init_frame'D. base: -2 - oparg. top: -1 - oparg - inputs: - outputs: - peeks: */ stack_pointer[-2 - oparg] = (_Py_UopsSymbol *)init_frame; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'init_frame'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2556,17 +2076,9 @@ (void)kwnames; new_frame = NULL; ctx->done = true; - /* Variables: 'new_frame'D. base: -3 - oparg. top: -2 - oparg - inputs: - outputs: - peeks: */ stack_pointer[-3 - oparg] = (_Py_UopsSymbol *)new_frame; stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'new_frame'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2653,17 +2165,9 @@ // might be impossible, but bailing is still safe ctx->done = true; } - /* Variables: 'res'D. base: 0. top: 1 - inputs: - outputs: - peeks: */ stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2705,17 +2209,9 @@ bottom = stack_pointer[-1 - (oparg-1)]; assert(oparg > 0); top = bottom; - /* Variables: 'bottom'MD, 'unused'MA, 'top'D. base: -1 - (oparg-1). top: 1 - inputs: - outputs: - peeks: bottom, unused */ stack_pointer[0] = top; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'bottom'MD, 'unused'MA, 'top'MD. base: -2 - (oparg-1). top: 0 - inputs: - outputs: - peeks: bottom, unused */ break; } @@ -2743,17 +2239,9 @@ else { res = sym_new_unknown(ctx); } - /* Variables: 'res'D. base: -2. top: -1 - inputs: - outputs: - peeks: */ stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'res'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2766,16 +2254,8 @@ bottom_in = stack_pointer[-2 - (oparg-2)]; bottom_out = bottom_in; top_out = top_in; - /* Variables: 'top_out'D, 'unused'MA, 'bottom_out'D. base: -2 - (oparg-2). top: 0 - inputs: - outputs: - peeks: */ stack_pointer[-2 - (oparg-2)] = top_out; stack_pointer[-1] = bottom_out; - /* Variables: 'top_out'MD, 'unused'MA, 'bottom_out'MD. base: -2 - (oparg-2). top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2803,16 +2283,8 @@ assert(value != NULL); eliminate_pop_guard(this_instr, value != Py_True); } - /* Variables: . base: -1. top: -1 - inputs: - outputs: - peeks: */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2824,16 +2296,8 @@ assert(value != NULL); eliminate_pop_guard(this_instr, value != Py_False); } - /* Variables: . base: -1. top: -1 - inputs: - outputs: - peeks: */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2849,16 +2313,8 @@ assert(!sym_matches_type(flag, &_PyNone_Type)); eliminate_pop_guard(this_instr, true); } - /* Variables: . base: -1. top: -1 - inputs: - outputs: - peeks: */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2874,29 +2330,13 @@ assert(!sym_matches_type(flag, &_PyNone_Type)); eliminate_pop_guard(this_instr, false); } - /* Variables: . base: -1. top: -1 - inputs: - outputs: - peeks: */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ break; } case _JUMP_TO_TOP: { ctx->done = true; - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2910,14 +2350,6 @@ /* We should never see _CHECK_STACK_SPACE_OPERANDs. * They are only created at the end of this pass. */ Py_UNREACHABLE(); - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2929,14 +2361,6 @@ PyObject *exit_p = (PyObject *)this_instr->operand; (void)exit_p; ctx->done = true; - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ - /* Variables: . base: 0. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2948,17 +2372,9 @@ _Py_UopsSymbol *value; PyObject *ptr = (PyObject *)this_instr->operand; value = sym_new_const(ctx, ptr); - /* Variables: 'value'D. base: 0. top: 1 - inputs: - outputs: - peeks: */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'value'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2966,17 +2382,9 @@ _Py_UopsSymbol *value; PyObject *ptr = (PyObject *)this_instr->operand; value = sym_new_const(ctx, ptr); - /* Variables: 'value'D. base: 0. top: 1 - inputs: - outputs: - peeks: */ stack_pointer[0] = value; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'value'MD. base: -1. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -2993,18 +2401,10 @@ PyObject *ptr = (PyObject *)this_instr->operand; value = sym_new_const(ctx, ptr); null = sym_new_null(ctx); - /* Variables: 'value'D, 'null'D. base: 0. top: 2 - inputs: - outputs: - peeks: */ stack_pointer[0] = value; stack_pointer[1] = null; stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'value'MD, 'null'MD. base: -2. top: 0 - inputs: - outputs: - peeks: */ break; } @@ -3014,18 +2414,10 @@ PyObject *ptr = (PyObject *)this_instr->operand; value = sym_new_const(ctx, ptr); null = sym_new_null(ctx); - /* Variables: 'value'D, 'null'D. base: 0. top: 2 - inputs: - outputs: - peeks: */ stack_pointer[0] = value; stack_pointer[1] = null; stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); - /* Variables: 'value'MD, 'null'MD. base: -2. top: 0 - inputs: - outputs: - peeks: */ break; } From 2492e6dc7b69f4ffbd37a78d017081a2a87e4c02 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Mon, 23 Sep 2024 15:35:59 -0700 Subject: [PATCH 33/53] Rename to KILL to the less aggressive DEAD --- Lib/test/test_generated_cases.py | 32 ++-- Python/bytecodes.c | 186 ++++++++++----------- Tools/cases_generator/generators_common.py | 4 +- 3 files changed, 111 insertions(+), 111 deletions(-) diff --git a/Lib/test/test_generated_cases.py b/Lib/test/test_generated_cases.py index c80bb4252d5f90..9af6e4c8b176f8 100644 --- a/Lib/test/test_generated_cases.py +++ b/Lib/test/test_generated_cases.py @@ -140,7 +140,7 @@ def test_inst_one_pop(self): input = """ inst(OP, (value --)) { spam(value); - KILL(value); + DEAD(value); } """ output = """ @@ -183,7 +183,7 @@ def test_inst_one_push_one_pop(self): input = """ inst(OP, (value -- res)) { res = spam(value); - KILL(value); + DEAD(value); } """ output = """ @@ -205,7 +205,7 @@ def test_binary_op(self): input = """ inst(OP, (left, right -- res)) { res = spam(left, right); - KILL_INPUTS(); + INPUTS_DEAD(); } """ @@ -232,7 +232,7 @@ def test_overlap(self): input = """ inst(OP, (left, right -- left, result)) { result = spam(left, right); - KILL_INPUTS(); + INPUTS_DEAD(); } """ output = """ @@ -385,7 +385,7 @@ def test_error_if_pop(self): input = """ inst(OP, (left, right -- res)) { spam(left, right); - KILL_INPUTS(); + INPUTS_DEAD(); ERROR_IF(cond, label); res = 0; } @@ -415,7 +415,7 @@ def test_error_if_pop_with_result(self): input = """ inst(OP, (left, right -- res)) { res = spam(left, right); - KILL_INPUTS(); + INPUTS_DEAD(); ERROR_IF(cond, label); } """ @@ -484,12 +484,12 @@ def test_macro_instruction(self): } op(OP2, (extra/2, arg2, left, right -- res)) { res = op2(arg2, left, right); - KILL_INPUTS(); + INPUTS_DEAD(); } macro(OP) = OP1 + cache/2 + OP2; inst(OP3, (unused/5, arg2, left, right -- res)) { res = op3(arg2, left, right); - KILL_INPUTS(); + INPUTS_DEAD(); } family(OP, INLINE_CACHE_ENTRIES_OP) = { OP3 }; """ @@ -723,7 +723,7 @@ def test_cond_effect(self): input = """ inst(OP, (aa, input if ((oparg & 1) == 1), cc -- xx, output if (oparg & 2), zz)) { output = spam(oparg, aa, cc, input); - KILL_INPUTS(); + INPUTS_DEAD(); xx = 0; zz = 0; } @@ -759,13 +759,13 @@ def test_macro_cond_effect(self): input = """ op(A, (left, middle, right --)) { use(left, middle, right); - KILL_INPUTS(); + INPUTS_DEAD(); } op(B, (-- deep, extra if (oparg), res)) { deep = -1; res = 0; extra = 1; - KILL_INPUTS(); + INPUTS_DEAD(); } macro(M) = A + B; """ @@ -957,7 +957,7 @@ def test_pointer_to_stackref(self): input = """ inst(OP, (arg: _PyStackRef * -- out)) { out = *arg; - KILL(arg); + DEAD(arg); } """ output = """ @@ -1098,7 +1098,7 @@ def test_flush(self): op(SECOND, (a, b -- )) { use(a, b); - KILL_INPUTS(); + INPUTS_DEAD(); } macro(TEST) = FIRST + flush + SECOND; @@ -1136,16 +1136,16 @@ def test_pop_on_error_peeks(self): input = """ op(FIRST, (x, y -- a, b)) { a = x; - KILL(x); + DEAD(x); b = y; - KILL(y); + DEAD(y); } op(SECOND, (a, b -- a, b)) { } op(THIRD, (j, k --)) { - KILL_INPUTS(); // Mark j and k as used + INPUTS_DEAD(); // Mark j and k as used ERROR_IF(cond, error); } diff --git a/Python/bytecodes.c b/Python/bytecodes.c index a9d69205781c43..08bc80c125a57b 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -261,7 +261,7 @@ dummy_func( replicate(8) inst(STORE_FAST, (value --)) { SETLOCAL(oparg, value); - KILL(value); + DEAD(value); } pseudo(STORE_FAST_MAYBE_NULL, (unused --)) = { @@ -272,7 +272,7 @@ dummy_func( uint32_t oparg1 = oparg >> 4; uint32_t oparg2 = oparg & 15; SETLOCAL(oparg1, value1); - KILL(value1); + DEAD(value1); value2 = PyStackRef_DUP(GETLOCAL(oparg2)); } @@ -280,9 +280,9 @@ dummy_func( uint32_t oparg1 = oparg >> 4; uint32_t oparg2 = oparg & 15; SETLOCAL(oparg1, value1); - KILL(value1); + DEAD(value1); SETLOCAL(oparg2, value2); - KILL(value2); + DEAD(value2); } pure inst(POP_TOP, (value --)) { @@ -310,7 +310,7 @@ dummy_func( pure inst(END_SEND, (receiver, value -- val)) { (void)receiver; val = value; - KILL(value); + DEAD(value); PyStackRef_CLOSE(receiver); } @@ -323,7 +323,7 @@ dummy_func( } } val = value; - KILL(value); + DEAD(value); PyStackRef_CLOSE(receiver); } @@ -338,7 +338,7 @@ dummy_func( assert(PyStackRef_BoolCheck(value)); res = PyStackRef_Is(value, PyStackRef_False) ? PyStackRef_True : PyStackRef_False; - KILL(value); + DEAD(value); } family(TO_BOOL, INLINE_CACHE_ENTRIES_TO_BOOL) = { @@ -382,7 +382,7 @@ dummy_func( STAT_INC(TO_BOOL, hit); if (_PyLong_IsZero((PyLongObject *)value_o)) { assert(_Py_IsImmortalLoose(value_o)); - KILL(value); + DEAD(value); res = PyStackRef_False; } else { @@ -402,7 +402,7 @@ dummy_func( inst(TO_BOOL_NONE, (unused/1, unused/2, value -- res)) { // This one is a bit weird, because we expect *some* failures: EXIT_IF(!PyStackRef_Is(value, PyStackRef_None)); - KILL(value); + DEAD(value); STAT_INC(TO_BOOL, hit); res = PyStackRef_False; } @@ -413,7 +413,7 @@ dummy_func( STAT_INC(TO_BOOL, hit); if (value_o == &_Py_STR(empty)) { assert(_Py_IsImmortalLoose(value_o)); - KILL(value); + DEAD(value); res = PyStackRef_False; } else { @@ -476,7 +476,7 @@ dummy_func( PyObject *res_o = _PyLong_Multiply((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); - KILL_INPUTS(); + INPUTS_DEAD(); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -489,7 +489,7 @@ dummy_func( PyObject *res_o = _PyLong_Add((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); - KILL_INPUTS(); + INPUTS_DEAD(); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -502,7 +502,7 @@ dummy_func( PyObject *res_o = _PyLong_Subtract((PyLongObject *)left_o, (PyLongObject *)right_o); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); - KILL_INPUTS(); + INPUTS_DEAD(); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -541,7 +541,7 @@ dummy_func( ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); - KILL_INPUTS(); + INPUTS_DEAD(); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -555,7 +555,7 @@ dummy_func( ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); - KILL_INPUTS(); + INPUTS_DEAD(); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -569,7 +569,7 @@ dummy_func( ((PyFloatObject *)right_o)->ob_fval; PyObject *res_o; DECREF_INPUTS_AND_REUSE_FLOAT(left_o, right_o, dres, res_o); - KILL_INPUTS(); + INPUTS_DEAD(); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -596,7 +596,7 @@ dummy_func( PyObject *res_o = PyUnicode_Concat(left_o, right_o); _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc); _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); - KILL_INPUTS(); + INPUTS_DEAD(); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -637,12 +637,12 @@ dummy_func( */ assert(Py_REFCNT(left_o) >= 2); _Py_DECREF_NO_DEALLOC(left_o); - KILL(left); + DEAD(left); PyObject *temp = PyStackRef_AsPyObjectBorrow(*target_local); PyUnicode_Append(&temp, right_o); *target_local = PyStackRef_FromPyObjectSteal(temp); _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); - KILL(right); + DEAD(right); ERROR_IF(PyStackRef_IsNull(*target_local), error); #if TIER_ONE // The STORE_FAST is already done. This is done here in tier one, @@ -756,7 +756,7 @@ dummy_func( assert(res_o != NULL); Py_INCREF(res_o); _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); - KILL(sub_st); + DEAD(sub_st); PyStackRef_CLOSE(list_st); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -776,7 +776,7 @@ dummy_func( STAT_INC(BINARY_SUBSCR, hit); PyObject *res_o = (PyObject*)&_Py_SINGLETON(strings).ascii[c]; _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); - KILL(sub_st); + DEAD(sub_st); PyStackRef_CLOSE(str_st); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -797,7 +797,7 @@ dummy_func( assert(res_o != NULL); Py_INCREF(res_o); _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); - KILL(sub_st); + DEAD(sub_st); PyStackRef_CLOSE(tuple_st); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -841,7 +841,7 @@ dummy_func( new_frame = _PyFrame_PushUnchecked(tstate, (PyFunctionObject *)getitem, 2, frame); new_frame->localsplus[0] = container; new_frame->localsplus[1] = sub; - KILL_INPUTS(); + INPUTS_DEAD(); frame->return_offset = (uint16_t)(1 + INLINE_CACHE_ENTRIES_BINARY_SUBSCR); } @@ -910,7 +910,7 @@ dummy_func( assert(old_value != NULL); Py_DECREF(old_value); _Py_DECREF_SPECIALIZED(sub, (destructor)PyObject_Free); - KILL(sub_st); + DEAD(sub_st); PyStackRef_CLOSE(list_st); } @@ -984,7 +984,7 @@ dummy_func( assert(frame != &entry_frame); #endif _PyStackRef temp = retval; - KILL(retval); + DEAD(retval); SAVE_STACK(); assert(EMPTY()); _Py_LeaveRecursiveCallPy(tstate); @@ -1143,7 +1143,7 @@ dummy_func( STAT_INC(SEND, hit); gen_frame = &gen->gi_iframe; _PyFrame_StackPush(gen_frame, v); - KILL(v); + DEAD(v); gen->gi_frame_state = FRAME_EXECUTING; gen->gi_exc_state.previous_item = tstate->exc_info; tstate->exc_info = &gen->gi_exc_state; @@ -1171,7 +1171,7 @@ dummy_func( assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; _PyStackRef temp = retval; - KILL(retval); + DEAD(retval); SAVE_STACK(); tstate->exc_info = gen->gi_exc_state.previous_item; gen->gi_exc_state.previous_item = NULL; @@ -1714,14 +1714,14 @@ dummy_func( inst(BUILD_TUPLE, (values[oparg] -- tup)) { PyObject *tup_o = _PyTuple_FromStackRefSteal(values, oparg); - KILL_INPUTS(); + INPUTS_DEAD(); ERROR_IF(tup_o == NULL, error); tup = PyStackRef_FromPyObjectSteal(tup_o); } inst(BUILD_LIST, (values[oparg] -- list)) { PyObject *list_o = _PyList_FromStackRefSteal(values, oparg); - KILL_INPUTS(); + INPUTS_DEAD(); ERROR_IF(list_o == NULL, error); list = PyStackRef_FromPyObjectSteal(list_o); } @@ -1768,7 +1768,7 @@ dummy_func( } PyStackRef_CLOSE(values[i]); } - KILL(values); + DEAD(values); if (err != 0) { Py_DECREF(set_o); ERROR_IF(true, error); @@ -1969,7 +1969,7 @@ dummy_func( } if (method_found) { self_or_null = self_st; // transfer ownership - KILL(self_st); + DEAD(self_st); } else { PyStackRef_CLOSE(self_st); self_or_null = PyStackRef_NULL; @@ -2021,7 +2021,7 @@ dummy_func( */ assert(attr_o != NULL); // No errors on this branch self_or_null = owner; // Transfer ownership - KILL(owner); + DEAD(owner); } else { /* meth is not an unbound method (but a regular attr, or @@ -2206,7 +2206,7 @@ dummy_func( Py_INCREF(fget); new_frame = _PyFrame_PushUnchecked(tstate, f, 1, frame); new_frame->localsplus[0] = owner; - KILL(owner); + DEAD(owner); } macro(LOAD_ATTR_PROPERTY) = @@ -2241,7 +2241,7 @@ dummy_func( // Manipulate stack directly because we exit with DISPATCH_INLINED(). STACK_SHRINK(1); new_frame->localsplus[0] = owner; - KILL(owner); + DEAD(owner); new_frame->localsplus[1] = PyStackRef_FromPyObjectNew(name); frame->return_offset = (uint16_t)(next_instr - this_instr); DISPATCH_INLINED(new_frame); @@ -2389,9 +2389,9 @@ dummy_func( // 1 if NaN, 2 if <, 4 if >, 8 if ==; this matches low four bits of the oparg int sign_ish = COMPARISON_BIT(dleft, dright); _Py_DECREF_SPECIALIZED(left_o, _PyFloat_ExactDealloc); - KILL(left); + DEAD(left); _Py_DECREF_SPECIALIZED(right_o, _PyFloat_ExactDealloc); - KILL(right); + DEAD(right); res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; // It's always a bool, so we don't care about oparg & 16. } @@ -2411,9 +2411,9 @@ dummy_func( // 2 if <, 4 if >, 8 if ==; this matches the low 4 bits of the oparg int sign_ish = COMPARISON_BIT(ileft, iright); _Py_DECREF_SPECIALIZED(left_o, (destructor)PyObject_Free); - KILL(left); + DEAD(left); _Py_DECREF_SPECIALIZED(right_o, (destructor)PyObject_Free); - KILL(right); + DEAD(right); res = (sign_ish & oparg) ? PyStackRef_True : PyStackRef_False; // It's always a bool, so we don't care about oparg & 16. } @@ -2427,9 +2427,9 @@ dummy_func( int eq = _PyUnicode_Equal(left_o, right_o); assert((oparg >> 5) == Py_EQ || (oparg >> 5) == Py_NE); _Py_DECREF_SPECIALIZED(left_o, _PyUnicode_ExactDealloc); - KILL(left); + DEAD(left); _Py_DECREF_SPECIALIZED(right_o, _PyUnicode_ExactDealloc); - KILL(right); + DEAD(right); assert(eq == 0 || eq == 1); assert((oparg & 0xf) == COMPARISON_NOT_EQUALS || (oparg & 0xf) == COMPARISON_EQUALS); assert(COMPARISON_NOT_EQUALS + 1 == COMPARISON_EQUALS); @@ -2643,7 +2643,7 @@ dummy_func( replaced op(_POP_JUMP_IF_FALSE, (cond -- )) { assert(PyStackRef_BoolCheck(cond)); int flag = PyStackRef_Is(cond, PyStackRef_False); - KILL(cond); + DEAD(cond); #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif @@ -2653,7 +2653,7 @@ dummy_func( replaced op(_POP_JUMP_IF_TRUE, (cond -- )) { assert(PyStackRef_BoolCheck(cond)); int flag = PyStackRef_Is(cond, PyStackRef_True); - KILL(cond); + DEAD(cond); #if ENABLE_SPECIALIZATION this_instr[1].cache = (this_instr[1].cache << 1) | flag; #endif @@ -2663,7 +2663,7 @@ dummy_func( op(_IS_NONE, (value -- b)) { if (PyStackRef_Is(value, PyStackRef_None)) { b = PyStackRef_True; - KILL(value); + DEAD(value); } else { b = PyStackRef_False; @@ -2755,16 +2755,16 @@ dummy_func( ERROR_NO_POP(); } iter = iterable; - KILL(iterable); + DEAD(iterable); } else if (PyGen_CheckExact(iterable_o)) { iter = iterable; - KILL(iterable); + DEAD(iterable); } else { /* `iterable` is not a generator. */ iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); - KILL(iterable); + DEAD(iterable); if (PyStackRef_IsNull(iter)) { ERROR_NO_POP(); } @@ -3129,7 +3129,7 @@ dummy_func( assert(PyStackRef_ExceptionInstanceCheck(exc)); exc_info->exc_value = PyStackRef_AsPyObjectNew(exc); new_exc = exc; - KILL(exc); + DEAD(exc); } op(_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, (owner -- owner)) { @@ -3152,7 +3152,7 @@ dummy_func( assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); self = owner; - KILL(owner); + DEAD(owner); } macro(LOAD_ATTR_METHOD_WITH_VALUES) = @@ -3170,7 +3170,7 @@ dummy_func( assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); self = owner; - KILL(owner); + DEAD(owner); } macro(LOAD_ATTR_METHOD_NO_DICT) = @@ -3223,7 +3223,7 @@ dummy_func( assert(_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)); attr = PyStackRef_FromPyObjectNew(descr); self = owner; - KILL(owner); + DEAD(owner); } macro(LOAD_ATTR_METHOD_LAZY_DICT) = @@ -3320,7 +3320,7 @@ dummy_func( for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - KILL(self_or_null); + DEAD(self_or_null); ERROR_IF(true, error); } PyObject *res_o = PyObject_Vectorcall( @@ -3350,7 +3350,7 @@ dummy_func( for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - KILL(self_or_null); + DEAD(self_or_null); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -3396,7 +3396,7 @@ dummy_func( args, total_args, NULL, frame ); // The frame has stolen all the arguments from the stack. - KILL_INPUTS(); + INPUTS_DEAD(); SYNC_SP(); if (temp == NULL) { ERROR_NO_POP(); @@ -3432,7 +3432,7 @@ dummy_func( op(_EXPAND_METHOD, (callable[1], null[1], unused[oparg] -- method[1], self[1], unused[oparg])) { PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); assert(PyStackRef_IsNull(null[0])); - KILL(null); + DEAD(null); assert(Py_TYPE(callable_o) == &PyMethod_Type); self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); _PyStackRef temp = callable[0]; @@ -3484,7 +3484,7 @@ dummy_func( for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - KILL(self_or_null); + DEAD(self_or_null); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -3502,7 +3502,7 @@ dummy_func( } op(_INIT_CALL_BOUND_METHOD_EXACT_ARGS, (callable[1], null[1], unused[oparg] -- func[1], self[1], unused[oparg])) { - KILL(null); + DEAD(null); PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable[0]); STAT_INC(CALL, hit); self[0] = PyStackRef_FromPyObjectNew(((PyMethodObject *)callable_o)->im_self); @@ -3542,7 +3542,7 @@ dummy_func( for (int i = 0; i < oparg; i++) { first_non_self_local[i] = args[i]; } - KILL_INPUTS(); + INPUTS_DEAD(); } op(_PUSH_FRAME, (new_frame: _PyInterpreterFrame* -- )) { @@ -3550,7 +3550,7 @@ dummy_func( // Eventually this should be the only occurrence of this code. assert(tstate->interp->eval_frame == NULL); _PyInterpreterFrame *temp = new_frame; - KILL(new_frame); + DEAD(new_frame); SYNC_SP(); _PyFrame_SetStackPointer(frame, stack_pointer); assert(new_frame->previous == frame || new_frame->previous->previous == frame); @@ -3591,9 +3591,9 @@ dummy_func( assert(oparg == 1); DEOPT_IF(!PyStackRef_IsNull(null)); - KILL(null); + DEAD(null); DEOPT_IF(callable_o != (PyObject *)&PyType_Type); - KILL(callable); + DEAD(callable); STAT_INC(CALL, hit); res = PyStackRef_FromPyObjectSteal(Py_NewRef(Py_TYPE(arg_o))); PyStackRef_CLOSE(arg); @@ -3608,8 +3608,8 @@ dummy_func( DEOPT_IF(callable_o != (PyObject *)&PyUnicode_Type); STAT_INC(CALL, hit); res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o)); - KILL(null); - KILL(callable); + DEAD(null); + DEAD(callable); PyStackRef_CLOSE(arg); ERROR_IF(PyStackRef_IsNull(res), error); } @@ -3629,8 +3629,8 @@ dummy_func( DEOPT_IF(callable_o != (PyObject *)&PyTuple_Type); STAT_INC(CALL, hit); res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o)); - KILL(null); - KILL(callable); + DEAD(null); + DEAD(callable); PyStackRef_CLOSE(arg); ERROR_IF(PyStackRef_IsNull(res), error); } @@ -3670,8 +3670,8 @@ dummy_func( /* Push self onto stack of shim */ shim->localsplus[0] = PyStackRef_DUP(self[0]); PyFunctionObject *init_func = (PyFunctionObject *)PyStackRef_AsPyObjectSteal(init[0]); - KILL(init); - KILL(self); + DEAD(init); + DEAD(self); init_frame = _PyEvalFramePushAndInit( tstate, init_func, NULL, args-1, oparg+1, NULL, shim); SYNC_SP(); @@ -3701,7 +3701,7 @@ dummy_func( Py_TYPE(PyStackRef_AsPyObjectBorrow(should_be_none))->tp_name); ERROR_NO_POP(); } - KILL(should_be_none); + DEAD(should_be_none); } op(_CALL_BUILTIN_CLASS, (callable[1], self_or_null[1], args[oparg] -- res)) { @@ -3712,7 +3712,7 @@ dummy_func( args--; total_args++; } - KILL(self_or_null); + DEAD(self_or_null); DEOPT_IF(!PyType_Check(callable_o)); PyTypeObject *tp = (PyTypeObject *)callable_o; DEOPT_IF(tp->tp_vectorcall == NULL); @@ -3762,8 +3762,8 @@ dummy_func( assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(arg); - KILL(args); - KILL(self_or_null); + DEAD(args); + DEAD(self_or_null); PyStackRef_CLOSE(callable[0]); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); @@ -3784,7 +3784,7 @@ dummy_func( args--; total_args++; } - KILL(self_or_null); + DEAD(self_or_null); DEOPT_IF(!PyCFunction_CheckExact(callable_o)); DEOPT_IF(PyCFunction_GET_FLAGS(callable_o) != METH_FASTCALL); STAT_INC(CALL, hit); @@ -3848,7 +3848,7 @@ dummy_func( for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - KILL(self_or_null); + DEAD(self_or_null); PyStackRef_CLOSE(callable[0]); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); @@ -3968,8 +3968,8 @@ dummy_func( assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); PyStackRef_CLOSE(arg_stackref); - KILL(args); - KILL(self_or_null); + DEAD(args); + DEAD(self_or_null); PyStackRef_CLOSE(callable[0]); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); @@ -4014,7 +4014,7 @@ dummy_func( for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - KILL(self_or_null); + DEAD(self_or_null); PyStackRef_CLOSE(callable[0]); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); @@ -4052,8 +4052,8 @@ dummy_func( _Py_LeaveRecursiveCallTstate(tstate); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); PyStackRef_CLOSE(self_stackref); - KILL(args); - KILL(self_or_null); + DEAD(args); + DEAD(self_or_null); PyStackRef_CLOSE(callable[0]); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); @@ -4098,7 +4098,7 @@ dummy_func( for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - KILL(self_or_null); + DEAD(self_or_null); PyStackRef_CLOSE(callable[0]); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); @@ -4142,7 +4142,7 @@ dummy_func( PyStackRef_CLOSE(temp); } kwnames_out = kwnames_in; - KILL(kwnames_in); + DEAD(kwnames_in); } op(_DO_CALL_KW, (callable[1], self_or_null[1], args[oparg], kwnames -- res)) { @@ -4213,7 +4213,7 @@ dummy_func( for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - KILL(self_or_null); + DEAD(self_or_null); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); } @@ -4346,7 +4346,7 @@ dummy_func( for (int i = 0; i < total_args; i++) { PyStackRef_CLOSE(args[i]); } - KILL(self_or_null); + DEAD(self_or_null); PyStackRef_CLOSE(callable[0]); ERROR_IF(res_o == NULL, error); res = PyStackRef_FromPyObjectSteal(res_o); @@ -4367,7 +4367,7 @@ dummy_func( PyObject *callargs_o = PyStackRef_AsPyObjectBorrow(callargs); if (PyTuple_CheckExact(callargs_o)) { tuple = callargs; - KILL(callargs); + DEAD(callargs); } else { int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); @@ -4382,7 +4382,7 @@ dummy_func( tuple = PyStackRef_FromPyObjectSteal(tuple_o); } kwargs_out = kwargs_in; - KILL(kwargs_in); + DEAD(kwargs_in); } op(_DO_CALL_FUNCTION_EX, (func_st, unused, callargs_st, kwargs_st if (oparg & 1) -- result)) { @@ -4437,7 +4437,7 @@ dummy_func( (PyFunctionObject *)PyStackRef_AsPyObjectSteal(func_st), locals, nargs, callargs, kwargs, frame); // Need to sync the stack since we exit with DISPATCH_INLINED. - KILL_INPUTS(); + INPUTS_DEAD(); SYNC_SP(); if (new_frame == NULL) { ERROR_NO_POP(); @@ -4449,7 +4449,7 @@ dummy_func( result_o = PyObject_Call(func, callargs, kwargs); } PyStackRef_XCLOSE(kwargs_st); - KILL(kwargs_st); + DEAD(kwargs_st); PyStackRef_CLOSE(callargs_st); PyStackRef_CLOSE(func_st); ERROR_IF(result_o == NULL, error); @@ -4480,7 +4480,7 @@ dummy_func( PyObject *func = PyStackRef_AsPyObjectBorrow(func_in); PyObject *attr = PyStackRef_AsPyObjectSteal(attr_st); func_out = func_in; - KILL(func_in); + DEAD(func_in); assert(PyFunction_Check(func)); size_t offset = _Py_FunctionAttributeOffsets[oparg]; assert(offset != 0); @@ -4544,7 +4544,7 @@ dummy_func( } else { res = value; - KILL(value); + DEAD(value); } } @@ -4591,9 +4591,9 @@ dummy_func( pure inst(SWAP, (bottom_in, unused[oparg-2], top_in -- top_out, unused[oparg-2], bottom_out)) { bottom_out = bottom_in; - KILL(bottom_in); + DEAD(bottom_in); top_out = top_in; - KILL(top_in); + DEAD(top_in); assert(oparg >= 2); } @@ -4729,14 +4729,14 @@ dummy_func( op (_GUARD_IS_TRUE_POP, (flag -- )) { int is_true = PyStackRef_Is(flag, PyStackRef_True); - KILL(flag); + DEAD(flag); SYNC_SP(); EXIT_IF(!is_true); } op (_GUARD_IS_FALSE_POP, (flag -- )) { int is_false = PyStackRef_Is(flag, PyStackRef_False); - KILL(flag); + DEAD(flag); SYNC_SP(); EXIT_IF(!is_false); } @@ -4748,7 +4748,7 @@ dummy_func( SYNC_SP(); EXIT_IF(1); } - KILL(val); + DEAD(val); } op (_GUARD_IS_NOT_NONE_POP, (val -- )) { @@ -4867,7 +4867,7 @@ dummy_func( op(_INTERNAL_INCREMENT_OPT_COUNTER, (opt --)) { _PyCounterOptimizerObject *exe = (_PyCounterOptimizerObject *)PyStackRef_AsPyObjectBorrow(opt); exe->count++; - KILL(opt); + DEAD(opt); } tier2 op(_DYNAMIC_EXIT, (exit_p/4 --)) { diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index f8c8ff514b3c03..e9c267b73cffd7 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -111,8 +111,8 @@ def __init__(self, out: CWriter): "ERROR_IF": self.error_if, "ERROR_NO_POP": self.error_no_pop, "DECREF_INPUTS": self.decref_inputs, - "KILL": self.kill, - "KILL_INPUTS": self.kill_inputs, + "DEAD": self.kill, + "INPUTS_DEAD": self.kill_inputs, "SYNC_SP": self.sync_sp, "SAVE_STACK": self.save_stack, "RELOAD_STACK": self.reload_stack, From 4c813d191d7b5f7a7acc21c1511088e4d0a066fe Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Mon, 23 Sep 2024 16:12:51 -0700 Subject: [PATCH 34/53] Add type annotations and workaround mypy's lack of flow sensitivity --- Tools/cases_generator/analyzer.py | 8 ++-- Tools/cases_generator/generators_common.py | 10 ++--- Tools/cases_generator/optimizer_generator.py | 10 ++--- Tools/cases_generator/stack.py | 40 ++++++++++---------- 4 files changed, 34 insertions(+), 34 deletions(-) diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index a44aae1d196dc5..3a320d3cd8cbe0 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -67,7 +67,7 @@ def escapes(self) -> bool: return bool(self.escaping_calls) SKIP_PROPERTIES = Properties( - escaping_calls=[], + escaping_calls={}, error_with_pop=False, error_without_pop=False, deopts=False, @@ -627,7 +627,7 @@ def find_stmt_end(node: parser.InstDef, idx: int) -> lexer.Token: if tkn.kind == "SEMI": return node.block.tokens[idx+1] -def check_escaping_calls(instr: parser.InstDef, escapes: dict[lexer.Token, lexer.Token]) -> None: +def check_escaping_calls(instr: parser.InstDef, escapes: dict[lexer.Token, tuple[lexer.Token, lexer.Token]]) -> None: calls = {escapes[t][0] for t in escapes} in_if = 0 tkn_iter = iter(instr.block.tokens) @@ -646,8 +646,8 @@ def check_escaping_calls(instr: parser.InstDef, escapes: dict[lexer.Token, lexer elif tkn in calls and in_if: raise analysis_error(f"Escaping call '{tkn.text} in condition", tkn) -def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, lexer.Token]: - result: dict[lexer.Token, lexer.Token] = {} +def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, tuple[lexer.Token, lexer.Token]]: + result: dict[lexer.Token, tuple[lexer.Token, lexer.Token]] = {} tokens = instr.block.tokens for idx, tkn in enumerate(tokens): if tkn.kind != lexer.IDENTIFIER: diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index e9c267b73cffd7..2dcba362417de5 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -242,8 +242,8 @@ def decref_inputs( self.out.emit(f"PyStackRef_XCLOSE({var.name});\n") else: self.out.emit(f"PyStackRef_CLOSE({var.name});\n") - for var in storage.inputs: - var.defined = False + for input in storage.inputs: + input.defined = False return True def kill_inputs( @@ -322,7 +322,7 @@ def sync_sp( self._print_storage(storage) return True - def emit_save(self, storage: Storage): + def emit_save(self, storage: Storage) -> None: storage.save(self.out) self._print_storage(storage) @@ -340,7 +340,7 @@ def save_stack( self.emit_save(storage) return True - def emit_reload(self, storage: Storage): + def emit_reload(self, storage: Storage) -> None: storage.reload(self.out) self._print_storage(storage) @@ -358,7 +358,7 @@ def reload_stack( self.emit_reload(storage) return True - def _print_storage(self, storage: Storage): + def _print_storage(self, storage: Storage) -> None: if PRINT_STACKS: self.out.start_line() self.emit(storage.as_comment()) diff --git a/Tools/cases_generator/optimizer_generator.py b/Tools/cases_generator/optimizer_generator.py index 9fd131b42d56bc..66773432044979 100644 --- a/Tools/cases_generator/optimizer_generator.py +++ b/Tools/cases_generator/optimizer_generator.py @@ -105,10 +105,10 @@ def emit_default(out: CWriter, uop: Uop, stack: Stack) -> None: class OptimizerEmitter(Emitter): - def emit_save(self, storage: Storage): + def emit_save(self, storage: Storage) -> None: storage.flush(self.out) - def emit_reload(self, storage: Storage): + def emit_reload(self, storage: Storage) -> None: pass @@ -130,9 +130,9 @@ def write_uop( out.emit(code) if debug: args = [] - for var in prototype.stack.inputs: - if not var.peek or override: - args.append(var.name) + for input in prototype.stack.inputs: + if not input.peek or override: + args.append(input.name) out.emit(f'DEBUG_PRINTF({", ".join(args)});\n') if override: for cache in uop.caches: diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index 3affbe051db236..25d3d492a97f4c 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -46,7 +46,7 @@ class Local: in_memory: bool defined: bool - def __repr__(self): + def __repr__(self) -> str: return f"Local('{self.item.name}', mem={self.in_memory}, defined={self.defined}, array={self.is_array()})" def compact_str(self) -> str: @@ -206,7 +206,7 @@ def clear(self) -> None: self.popped = [] self.pushed = [] - def __bool__(self): + def __bool__(self) -> bool: self.simplify() return bool(self.popped) or bool(self.pushed) @@ -307,7 +307,7 @@ def _do_emit( out.emit(f"if ({var.condition}) ") out.emit(f"stack_pointer[{base_offset.to_c()}]{bits} = {cast}{var.name};\n") - def _adjust_stack_pointer(self, out: CWriter, number: str): + def _adjust_stack_pointer(self, out: CWriter, number: str) -> None: if number != "0": out.emit(f"stack_pointer += {number};\n") out.emit("assert(WITHIN_STACK_BOUNDS());\n") @@ -331,7 +331,7 @@ def flush( self.top_offset.clear() out.start_line() - def is_flushed(self): + def is_flushed(self) -> bool: return not self.variables and not self.base_offset and not self.top_offset def peek_offset(self) -> str: @@ -420,7 +420,7 @@ class Storage: spilled: int = 0 @staticmethod - def needs_defining(var: Local): + def needs_defining(var: Local) -> bool: return ( not var.defined and not var.is_array() and @@ -428,7 +428,7 @@ def needs_defining(var: Local): ) @staticmethod - def is_live(var: Local): + def is_live(var: Local) -> bool: return ( var.defined and var.name != "unused" @@ -521,25 +521,25 @@ def for_uop(stack: Stack, uop: Uop, extract_bits: bool = True) -> tuple[list[str code_list: list[str] = [] inputs: list[Local] = [] peeks: list[Local] = [] - for var in reversed(uop.stack.inputs): - code, local = stack.pop(var, extract_bits) + for input in reversed(uop.stack.inputs): + code, local = stack.pop(input, extract_bits) code_list.append(code) - if var.peek: + if input.peek: peeks.append(local) else: inputs.append(local) inputs.reverse() peeks.reverse() - for var in peeks: - stack.push(var) + for peek in peeks: + stack.push(peek) top_offset = stack.top_offset.copy() - for var in uop.stack.outputs: - if var.is_array() and var.used and not var.peek: + for ouput in uop.stack.outputs: + if ouput.is_array() and ouput.used and not ouput.peek: c_offset = top_offset.to_c() - top_offset.push(var) - code_list.append(f"{var.name} = &stack_pointer[{c_offset}];\n") + top_offset.push(ouput) + code_list.append(f"{ouput.name} = &stack_pointer[{c_offset}];\n") else: - top_offset.push(var) + top_offset.push(ouput) for var in inputs: stack.push(var) outputs = [ Local.undefined(var) for var in uop.stack.outputs if not var.peek ] @@ -560,7 +560,7 @@ def copy(self) -> "Storage": ) def sanity_check(self) -> None: - names = set() + names: set[str] = set() for var in self.inputs: if var.name in names: raise StackError(f"Duplicate name {var.name}") @@ -570,13 +570,13 @@ def sanity_check(self) -> None: if var.name in names: raise StackError(f"Duplicate name {var.name}") names.add(var.name) - names: set[str] = set() + names = set() for var in self.stack.variables: if var.name in names: raise StackError(f"Duplicate name {var.name}") names.add(var.name) - def is_flushed(self) -> None: + def is_flushed(self) -> bool: for var in self.outputs: if var.defined and not var.in_memory: return False @@ -602,7 +602,7 @@ def merge(self, other: "Storage", out: CWriter) -> None: self.stack.merge(other.stack, out) self.sanity_check() - def push_outputs(self): + def push_outputs(self) -> None: if self.spilled: raise StackError(f"Unbalanced stack spills") self.clear_inputs("at the end of the micro-op") From 8c949741c153cac270b2cace8f627e0290f0eb2b Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Mon, 23 Sep 2024 16:30:16 -0700 Subject: [PATCH 35/53] Add type ignore --- Tools/cases_generator/optimizer_generator.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Tools/cases_generator/optimizer_generator.py b/Tools/cases_generator/optimizer_generator.py index 66773432044979..83329241108c7d 100644 --- a/Tools/cases_generator/optimizer_generator.py +++ b/Tools/cases_generator/optimizer_generator.py @@ -146,7 +146,7 @@ def write_uop( if override: emitter = OptimizerEmitter(out) # No reference management of inputs needed. - for var in storage.inputs: + for var in storage.inputs: # type: ignore[possibly-undefined] var.defined = False storage = emitter.emit_tokens(override, storage, None) out.start_line() From 16d6345db153c9a96122a54b3956a9854d0c1670 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Mon, 30 Sep 2024 03:08:30 -0700 Subject: [PATCH 36/53] Address some review comments --- Tools/cases_generator/analyzer.py | 25 ++++++++------------ Tools/cases_generator/generators_common.py | 21 ++++++++-------- Tools/cases_generator/optimizer_generator.py | 2 +- Tools/cases_generator/tier2_generator.py | 4 +--- 4 files changed, 22 insertions(+), 30 deletions(-) diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 1a645131b34021..cc77ef5537c1ca 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -378,7 +378,7 @@ def find_assignment_target(node: parser.InstDef, idx: int) -> list[lexer.Token]: """Find the tokens that make up the left-hand side of an assignment""" offset = 0 for tkn in reversed(node.block.tokens[: idx]): - if tkn.kind == "SEMI" or tkn.kind == "LBRACE" or tkn.kind == "RBRACE": + if tkn.kind in {"SEMI", "LBRACE", "RBRACE"}: return node.block.tokens[idx - offset : idx] offset += 1 return [] @@ -386,8 +386,8 @@ def find_assignment_target(node: parser.InstDef, idx: int) -> list[lexer.Token]: def find_stores_outputs(node: parser.InstDef) -> list[lexer.Token]: res: list[lexer.Token] = [] - outnames = [ out.name for out in node.outputs ] - innames = [ out.name for out in node.inputs ] + outnames = { out.name for out in node.outputs } + innames = { out.name for out in node.inputs } for idx, tkn in enumerate(node.block.tokens): if tkn.kind == "AND": name = node.block.tokens[idx+1] @@ -413,7 +413,7 @@ def analyze_deferred_refs(node: parser.InstDef) -> dict[lexer.Token, str | None] def in_frame_push(idx: int) -> bool: for tkn in reversed(node.block.tokens[: idx - 1]): - if tkn.kind == "SEMI" or tkn.kind == "LBRACE" or tkn.kind == "RBRACE": + if tkn.kind in {"SEMI", "LBRACE", "RBRACE"}: return False if tkn.kind == "IDENTIFIER" and tkn.text == "_PyFrame_PushUnchecked": return True @@ -451,15 +451,10 @@ def in_frame_push(idx: int) -> bool: ) name = lhs[0].text - match = False - for var in node.inputs: - if var.name == name: - match = True - break - for var in node.outputs: - if var.name == name: - match = True - break + match = ( + any(var.name == name for var in node.inputs) + or any(var.name == name for var in node.outputs) + ) if not match: raise analysis_error( f"PyStackRef_FromPyObjectNew() must be assigned to an input or output, not '{name}'", @@ -622,7 +617,7 @@ def find_stmt_start(node: parser.InstDef, idx: int) -> lexer.Token: assert idx < len(node.block.tokens) while True: tkn = node.block.tokens[idx-1] - if tkn.kind == "SEMI" or tkn.kind == "LBRACE" or tkn.kind == "RBRACE": + if tkn.kind in {"SEMI", "LBRACE", "RBRACE"}: break idx -= 1 assert idx > 0 @@ -670,7 +665,7 @@ def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, tuple[le break if next_tkn.kind != lexer.LPAREN: continue - if not tkn.text.startswith("Py") and not tkn.text.startswith("_Py") and not tkn.text.startswith("monitor"): + if not tkn.text.startswith(("Py", "_Py", "monitor")): continue if tkn.text.endswith("Check"): continue diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index f031fca653cc0c..6c8ea54cc54d01 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -38,10 +38,9 @@ def __next__(self) -> Token: def peek(self) -> Token | None: if self.look_ahead is None: - try: - self.look_ahead = next(self.iterator) - except StopIteration: - pass + for tkn in self.iterator: + self.look_ahead = tkn + break return self.look_ahead ROOT = Path(__file__).parent.parent.parent @@ -97,7 +96,7 @@ def emit_to(out: CWriter, tkn_iter: TokenIterator, end: str) -> Token: def always_true(tkn: Token | None) -> bool: if tkn is None: return False - return tkn.text == "true" or tkn.text == "1" + return tkn.text in {"true", "1"} class Emitter: @@ -278,7 +277,7 @@ def kill( var.defined = False break else: - raise analysis_error(f"'{name} is not a live input-only variable", name_tkn) + raise analysis_error(f"'{name}' is not a live input-only variable", name_tkn) return True def stackref_close( @@ -291,7 +290,7 @@ def stackref_close( ) -> bool: self.out.emit(tkn) tkn = next(tkn_iter) - assert (tkn.kind == "LPAREN") + assert tkn.kind == "LPAREN" self.out.emit(tkn) name = next(tkn_iter) self.out.emit(name) @@ -316,7 +315,7 @@ def sync_sp( next(tkn_iter) next(tkn_iter) next(tkn_iter) - storage.clear_inputs(" when syncing stack") + storage.clear_inputs("when syncing stack") storage.flush(self.out) self._print_storage(storage) return True @@ -370,9 +369,9 @@ def _emit_if( storage: Storage, inst: Instruction | None, ) -> tuple[bool, Token, Storage]: - """ Returns (reachable?, closing '}', stack).""" + """Returns (reachable?, closing '}', stack).""" tkn = next(tkn_iter) - assert (tkn.kind == "LPAREN") + assert tkn.kind == "LPAREN" self.out.emit(tkn) rparen = emit_to(self.out, tkn_iter, "RPAREN") self.emit(rparen) @@ -436,7 +435,7 @@ def _emit_block( reachable = True line : int = -1 if tkn.kind != "LBRACE": - raise analysis_error(f"PEP 7: expected '{{' found {tkn.text}", tkn) + raise analysis_error(f"PEP 7: expected '{{', found: {tkn.text}", tkn) escaping_calls = uop.properties.escaping_calls if emit_first_brace: self.emit(tkn) diff --git a/Tools/cases_generator/optimizer_generator.py b/Tools/cases_generator/optimizer_generator.py index 83329241108c7d..0f128844540268 100644 --- a/Tools/cases_generator/optimizer_generator.py +++ b/Tools/cases_generator/optimizer_generator.py @@ -46,7 +46,7 @@ def declare_variables(uop: Uop, out: CWriter, skip_inputs: bool) -> None: variables = {"unused"} if not skip_inputs: for var in reversed(uop.stack.inputs): - if var.name not in variables and var.used: + if var.used and var.name not in variables: variables.add(var.name) if var.condition: out.emit(f"{type_name(var)}{var.name} = NULL;\n") diff --git a/Tools/cases_generator/tier2_generator.py b/Tools/cases_generator/tier2_generator.py index e5e698de765e73..634848c10309d5 100644 --- a/Tools/cases_generator/tier2_generator.py +++ b/Tools/cases_generator/tier2_generator.py @@ -34,9 +34,7 @@ def declare_variable( var: StackItem, uop: Uop, required: set[str], out: CWriter ) -> None: - if var.name not in required: - return - if not var.used: + if not var.used or var.name not in required: return required.remove(var.name) type, null = type_and_null(var) From b9c645ee05ded0688706fc5aa9805a8909d43089 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Mon, 30 Sep 2024 04:07:55 -0700 Subject: [PATCH 37/53] Address more review comments --- Python/executor_cases.c.h | 9 ++- Python/generated_cases.c.h | 15 +++-- Python/optimizer_bytecodes.c | 7 +-- Python/optimizer_cases.c.h | 65 ++++++++------------ Tools/cases_generator/optimizer_generator.py | 17 ++--- Tools/cases_generator/stack.py | 1 + 6 files changed, 52 insertions(+), 62 deletions(-) diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 3d807d76cb428c..e9df699924e93c 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -830,7 +830,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); res_o = PyObject_GetItem(PyStackRef_AsPyObjectBorrow(container), slice); stack_pointer = _PyFrame_GetStackPointer(frame); - Py_DECREF(slice);stack_pointer += 2; + Py_DECREF(slice); + stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); } PyStackRef_CLOSE(container); @@ -865,7 +866,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), slice, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); - Py_DECREF(slice);stack_pointer += 2; + Py_DECREF(slice); + stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); } PyStackRef_CLOSE(v); @@ -2863,7 +2865,8 @@ res = res_bool ? PyStackRef_True : PyStackRef_False; } else { - res = PyStackRef_FromPyObjectSteal(res_o);stack_pointer += -2; + res = PyStackRef_FromPyObjectSteal(res_o); + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); } stack_pointer[0] = res; diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 3d283e4e17d526..61f926cce3c799 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -401,7 +401,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); res_o = PyObject_GetItem(PyStackRef_AsPyObjectBorrow(container), slice); stack_pointer = _PyFrame_GetStackPointer(frame); - Py_DECREF(slice);stack_pointer += 2; + Py_DECREF(slice); + stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); } PyStackRef_CLOSE(container); @@ -3237,7 +3238,8 @@ res = res_bool ? PyStackRef_True : PyStackRef_False; } else { - res = PyStackRef_FromPyObjectSteal(res_o);stack_pointer += -2; + res = PyStackRef_FromPyObjectSteal(res_o); + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); } } @@ -6077,7 +6079,8 @@ if (true) goto error; } } - }stack_pointer += 1; + } + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); } v = PyStackRef_FromPyObjectSteal(v_o); @@ -6871,7 +6874,8 @@ stack_pointer = _PyFrame_GetStackPointer(frame); Py_DECREF(exc); goto error; - }stack_pointer += 1; + } + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); } assert(exc && PyExceptionInstance_Check(exc)); @@ -7621,7 +7625,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), slice, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); - Py_DECREF(slice);stack_pointer += 2; + Py_DECREF(slice); + stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); } PyStackRef_CLOSE(v); diff --git a/Python/optimizer_bytecodes.c b/Python/optimizer_bytecodes.c index 3538cd2c666bb8..d6cdfbfa3f0c79 100644 --- a/Python/optimizer_bytecodes.c +++ b/Python/optimizer_bytecodes.c @@ -489,12 +489,7 @@ dummy_func(void) { op(_LOAD_ATTR, (owner -- attr, self_or_null if (oparg & 1))) { (void)owner; attr = sym_new_not_null(ctx); - if (oparg & 1) { - self_or_null = sym_new_unknown(ctx); - } - else { - self_or_null = NULL; - } + self_or_null = sym_new_unknown(ctx); } op(_LOAD_ATTR_MODULE, (index/1, owner -- attr, null if (oparg & 1))) { diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 7ee1463b73fb42..cd42ef0d0adb1a 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -383,7 +383,8 @@ // replace opcode with constant propagated one and update tests! } else { - res = sym_new_type(ctx, &PyFloat_Type);stack_pointer += -2; + res = sym_new_type(ctx, &PyFloat_Type); + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); } stack_pointer[0] = res; @@ -417,7 +418,8 @@ // replace opcode with constant propagated one and update tests! } else { - res = sym_new_type(ctx, &PyFloat_Type);stack_pointer += -2; + res = sym_new_type(ctx, &PyFloat_Type); + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); } stack_pointer[0] = res; @@ -451,7 +453,8 @@ // replace opcode with constant propagated one and update tests! } else { - res = sym_new_type(ctx, &PyFloat_Type);stack_pointer += -2; + res = sym_new_type(ctx, &PyFloat_Type); + stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); } stack_pointer[0] = res; @@ -765,7 +768,7 @@ case _UNPACK_SEQUENCE_TUPLE: { _Py_UopsSymbol **values; - values = &stack_pointer[0]; + values = &stack_pointer[-1]; for (int _i = oparg; --_i >= 0;) { values[_i] = sym_new_not_null(ctx); } @@ -776,7 +779,7 @@ case _UNPACK_SEQUENCE_LIST: { _Py_UopsSymbol **values; - values = &stack_pointer[0]; + values = &stack_pointer[-1]; for (int _i = oparg; --_i >= 0;) { values[_i] = sym_new_not_null(ctx); } @@ -847,9 +850,7 @@ _Py_UopsSymbol **res; _Py_UopsSymbol *null = NULL; res = &stack_pointer[0]; - for (int _i = 1; --_i >= 0;) { - res[_i] = sym_new_not_null(ctx); - } + res[0] = sym_new_not_null(ctx); null = sym_new_null(ctx); if (oparg & 1) stack_pointer[1] = null; stack_pointer += 1 + (oparg & 1); @@ -1036,12 +1037,7 @@ owner = stack_pointer[-1]; (void)owner; attr = sym_new_not_null(ctx); - if (oparg & 1) { - self_or_null = sym_new_unknown(ctx); - } - else { - self_or_null = NULL; - } + self_or_null = sym_new_unknown(ctx); stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = self_or_null; stack_pointer += (oparg & 1); @@ -1259,7 +1255,8 @@ else { stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); - res = _Py_uop_sym_new_not_null(ctx);stack_pointer += 2; + res = _Py_uop_sym_new_not_null(ctx); + stack_pointer += 2; assert(WITHIN_STACK_BOUNDS()); } stack_pointer[-2] = res; @@ -1710,14 +1707,10 @@ case _EXPAND_METHOD: { _Py_UopsSymbol **method; _Py_UopsSymbol **self; - method = &stack_pointer[0]; - self = &stack_pointer[1]; - for (int _i = 1; --_i >= 0;) { - method[_i] = sym_new_not_null(ctx); - } - for (int _i = 1; --_i >= 0;) { - self[_i] = sym_new_not_null(ctx); - } + method = &stack_pointer[-2 - oparg]; + self = &stack_pointer[-1 - oparg]; + method[0] = sym_new_not_null(ctx); + self[0] = sym_new_not_null(ctx); break; } @@ -2043,15 +2036,11 @@ _Py_UopsSymbol **maybe_self; _Py_UopsSymbol **args; _Py_UopsSymbol *kwnames_out; - func = &stack_pointer[0]; - maybe_self = &stack_pointer[1]; - args = &stack_pointer[2]; - for (int _i = 1; --_i >= 0;) { - func[_i] = sym_new_not_null(ctx); - } - for (int _i = 1; --_i >= 0;) { - maybe_self[_i] = sym_new_not_null(ctx); - } + func = &stack_pointer[-3 - oparg]; + maybe_self = &stack_pointer[-2 - oparg]; + args = &stack_pointer[-1 - oparg]; + func[0] = sym_new_not_null(ctx); + maybe_self[0] = sym_new_not_null(ctx); for (int _i = oparg; --_i >= 0;) { args[_i] = sym_new_not_null(ctx); } @@ -2095,14 +2084,10 @@ case _EXPAND_METHOD_KW: { _Py_UopsSymbol **method; _Py_UopsSymbol **self; - method = &stack_pointer[0]; - self = &stack_pointer[1]; - for (int _i = 1; --_i >= 0;) { - method[_i] = sym_new_not_null(ctx); - } - for (int _i = 1; --_i >= 0;) { - self[_i] = sym_new_not_null(ctx); - } + method = &stack_pointer[-3 - oparg]; + self = &stack_pointer[-2 - oparg]; + method[0] = sym_new_not_null(ctx); + self[0] = sym_new_not_null(ctx); break; } diff --git a/Tools/cases_generator/optimizer_generator.py b/Tools/cases_generator/optimizer_generator.py index 0f128844540268..7a1dfe1b85bf1a 100644 --- a/Tools/cases_generator/optimizer_generator.py +++ b/Tools/cases_generator/optimizer_generator.py @@ -78,25 +78,26 @@ def decref_inputs( def emit_default(out: CWriter, uop: Uop, stack: Stack) -> None: - top_offset = stack.top_offset.copy() - for var in uop.stack.inputs: + for var in reversed(uop.stack.inputs): stack.pop(var) + top_offset = stack.top_offset.copy() for var in uop.stack.outputs: if var.is_array() and not var.peek and not var.name == "unused": c_offset = top_offset.to_c() - top_offset.push(var) out.emit(f"{var.name} = &stack_pointer[{c_offset}];\n") - else: - top_offset.push(var) + top_offset.push(var) for var in uop.stack.outputs: local = Local.undefined(var) stack.push(local) if var.name != "unused" and not var.peek: local.defined = True if var.is_array(): - out.emit(f"for (int _i = {var.size}; --_i >= 0;) {{\n") - out.emit(f"{var.name}[_i] = sym_new_not_null(ctx);\n") - out.emit("}\n") + if var.size == "1": + out.emit(f"{var.name}[0] = sym_new_not_null(ctx);\n") + else: + out.emit(f"for (int _i = {var.size}; --_i >= 0;) {{\n") + out.emit(f"{var.name}[_i] = sym_new_not_null(ctx);\n") + out.emit("}\n") elif var.name == "null": out.emit(f"{var.name} = sym_new_null(ctx);\n") else: diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index 25d3d492a97f4c..a5404e78439b4e 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -309,6 +309,7 @@ def _do_emit( def _adjust_stack_pointer(self, out: CWriter, number: str) -> None: if number != "0": + out.start_line() out.emit(f"stack_pointer += {number};\n") out.emit("assert(WITHIN_STACK_BOUNDS());\n") From d8228664e8c0a800e759bd31667c2d36089fea94 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Mon, 30 Sep 2024 04:20:32 -0700 Subject: [PATCH 38/53] Revert TO_BOOL changes in optimizer_bytecodes.c --- Python/optimizer_bytecodes.c | 18 ++++++------------ Python/optimizer_cases.c.h | 18 ++++++------------ 2 files changed, 12 insertions(+), 24 deletions(-) diff --git a/Python/optimizer_bytecodes.c b/Python/optimizer_bytecodes.c index d6cdfbfa3f0c79..e476bc754341a8 100644 --- a/Python/optimizer_bytecodes.c +++ b/Python/optimizer_bytecodes.c @@ -339,47 +339,41 @@ dummy_func(void) { } op(_TO_BOOL, (value -- res)) { - int opt = optimize_to_bool(this_instr, ctx, value, &res); - if (!opt) { + if (!optimize_to_bool(this_instr, ctx, value, &res)) { res = sym_new_type(ctx, &PyBool_Type); } } op(_TO_BOOL_BOOL, (value -- res)) { - int opt = optimize_to_bool(this_instr, ctx, value, &res); - if (!opt) { + if (!optimize_to_bool(this_instr, ctx, value, &res)) { sym_set_type(value, &PyBool_Type); res = value; } } op(_TO_BOOL_INT, (value -- res)) { - int opt = optimize_to_bool(this_instr, ctx, value, &res); - if (!opt) { + if (!optimize_to_bool(this_instr, ctx, value, &res)) { sym_set_type(value, &PyLong_Type); res = sym_new_type(ctx, &PyBool_Type); } } op(_TO_BOOL_LIST, (value -- res)) { - int opt = optimize_to_bool(this_instr, ctx, value, &res); - if (!opt) { + if (!optimize_to_bool(this_instr, ctx, value, &res)) { sym_set_type(value, &PyList_Type); res = sym_new_type(ctx, &PyBool_Type); } } op(_TO_BOOL_NONE, (value -- res)) { - int opt = optimize_to_bool(this_instr, ctx, value, &res); - if (!opt) { + if (!optimize_to_bool(this_instr, ctx, value, &res)) { sym_set_const(value, Py_None); res = sym_new_const(ctx, Py_False); } } op(_TO_BOOL_STR, (value -- res)) { - int opt = optimize_to_bool(this_instr, ctx, value, &res); - if (!opt) { + if (!optimize_to_bool(this_instr, ctx, value, &res)) { res = sym_new_type(ctx, &PyBool_Type); sym_set_type(value, &PyUnicode_Type); } diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index cd42ef0d0adb1a..954a5007d4e55e 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -119,8 +119,7 @@ _Py_UopsSymbol *value; _Py_UopsSymbol *res; value = stack_pointer[-1]; - int opt = optimize_to_bool(this_instr, ctx, value, &res); - if (!opt) { + if (!optimize_to_bool(this_instr, ctx, value, &res)) { res = sym_new_type(ctx, &PyBool_Type); } stack_pointer[-1] = res; @@ -131,8 +130,7 @@ _Py_UopsSymbol *value; _Py_UopsSymbol *res; value = stack_pointer[-1]; - int opt = optimize_to_bool(this_instr, ctx, value, &res); - if (!opt) { + if (!optimize_to_bool(this_instr, ctx, value, &res)) { sym_set_type(value, &PyBool_Type); res = value; } @@ -144,8 +142,7 @@ _Py_UopsSymbol *value; _Py_UopsSymbol *res; value = stack_pointer[-1]; - int opt = optimize_to_bool(this_instr, ctx, value, &res); - if (!opt) { + if (!optimize_to_bool(this_instr, ctx, value, &res)) { sym_set_type(value, &PyLong_Type); res = sym_new_type(ctx, &PyBool_Type); } @@ -157,8 +154,7 @@ _Py_UopsSymbol *value; _Py_UopsSymbol *res; value = stack_pointer[-1]; - int opt = optimize_to_bool(this_instr, ctx, value, &res); - if (!opt) { + if (!optimize_to_bool(this_instr, ctx, value, &res)) { sym_set_type(value, &PyList_Type); res = sym_new_type(ctx, &PyBool_Type); } @@ -170,8 +166,7 @@ _Py_UopsSymbol *value; _Py_UopsSymbol *res; value = stack_pointer[-1]; - int opt = optimize_to_bool(this_instr, ctx, value, &res); - if (!opt) { + if (!optimize_to_bool(this_instr, ctx, value, &res)) { sym_set_const(value, Py_None); res = sym_new_const(ctx, Py_False); } @@ -183,8 +178,7 @@ _Py_UopsSymbol *value; _Py_UopsSymbol *res; value = stack_pointer[-1]; - int opt = optimize_to_bool(this_instr, ctx, value, &res); - if (!opt) { + if (!optimize_to_bool(this_instr, ctx, value, &res)) { res = sym_new_type(ctx, &PyBool_Type); sym_set_type(value, &PyUnicode_Type); } From c61905a8fc8cc96ecad2ab2d1a89272027067701 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Mon, 30 Sep 2024 04:30:26 -0700 Subject: [PATCH 39/53] Remove dead code --- Tools/cases_generator/analyzer.py | 1 - 1 file changed, 1 deletion(-) diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index cc77ef5537c1ca..dc9236f1774adc 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -329,7 +329,6 @@ def analyze_stack( # Mark variables with matching names at the base of the stack as "peek" modified = False input_names: dict[str, lexer.Token] = { i.name : i.first_token for i in op.inputs if i.name != "unused" } - input_names for input, output in itertools.zip_longest(inputs, outputs): if output is None: pass From bded3085b0c1f016cd438d0e8cced6608da6f505 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Mon, 30 Sep 2024 06:20:32 -0700 Subject: [PATCH 40/53] Better analysis of escaping calls --- Include/internal/pycore_opcode_metadata.h | 6 +- Include/internal/pycore_uop_metadata.h | 14 +- Lib/test/test_generated_cases.py | 132 +++--- Python/bytecodes.c | 3 +- Python/executor_cases.c.h | 323 +++++++------- Python/generated_cases.c.h | 502 ++++++++++++---------- Python/optimizer_cases.c.h | 98 +++-- Tools/cases_generator/analyzer.py | 17 +- Tools/cases_generator/lexer.py | 2 +- 9 files changed, 598 insertions(+), 499 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index 2c38b163699dcb..67128c81056db3 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -1036,8 +1036,8 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [CALL_BUILTIN_FAST_WITH_KEYWORDS] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_BUILTIN_O] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_FUNCTION_EX] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, - [CALL_INTRINSIC_1] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, - [CALL_INTRINSIC_2] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, + [CALL_INTRINSIC_1] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, + [CALL_INTRINSIC_2] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CALL_ISINSTANCE] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [CALL_KW] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, [CALL_KW_BOUND_METHOD] = { true, INSTR_FMT_IBC00, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, @@ -1065,7 +1065,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[264] = { [CONTAINS_OP] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CONTAINS_OP_DICT] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [CONTAINS_OP_SET] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, - [CONVERT_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG }, + [CONVERT_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [COPY] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_PURE_FLAG }, [COPY_FREE_VARS] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, [DELETE_ATTR] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_NAME_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index 6d035230fcfcd9..eb00f4f173df24 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -90,8 +90,8 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_STORE_SUBSCR_LIST_INT] = HAS_DEOPT_FLAG, [_STORE_SUBSCR_DICT] = HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_DELETE_SUBSCR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_INTRINSIC_1] = HAS_ARG_FLAG | HAS_ERROR_FLAG, - [_CALL_INTRINSIC_2] = HAS_ARG_FLAG | HAS_ERROR_FLAG, + [_CALL_INTRINSIC_1] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, + [_CALL_INTRINSIC_2] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_RETURN_VALUE] = 0, [_GET_AITER] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GET_ANEXT] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, @@ -228,17 +228,17 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CHECK_AND_ALLOCATE_OBJECT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CREATE_INIT_FRAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_EXIT_INIT_CHECK] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, - [_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, + [_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_BUILTIN_O] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_BUILTIN_FAST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, - [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, + [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_LEN] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CALL_ISINSTANCE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CALL_LIST_APPEND] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, [_CALL_METHOD_DESCRIPTOR_O] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG, + [_CALL_METHOD_DESCRIPTOR_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_METHOD_DESCRIPTOR_NOARGS] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG, + [_CALL_METHOD_DESCRIPTOR_FAST] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_MAYBE_EXPAND_METHOD_KW] = HAS_ARG_FLAG, [_PY_FRAME_KW] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CHECK_FUNCTION_VERSION_KW] = HAS_ARG_FLAG | HAS_EXIT_FLAG, @@ -251,7 +251,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_SET_FUNCTION_ATTRIBUTE] = HAS_ARG_FLAG, [_RETURN_GENERATOR] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_BUILD_SLICE] = HAS_ARG_FLAG | HAS_ERROR_FLAG, - [_CONVERT_VALUE] = HAS_ARG_FLAG | HAS_ERROR_FLAG, + [_CONVERT_VALUE] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_FORMAT_SIMPLE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_FORMAT_WITH_SPEC] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_COPY] = HAS_ARG_FLAG | HAS_PURE_FLAG, diff --git a/Lib/test/test_generated_cases.py b/Lib/test/test_generated_cases.py index 9af6e4c8b176f8..95e9a6edd069f0 100644 --- a/Lib/test/test_generated_cases.py +++ b/Lib/test/test_generated_cases.py @@ -122,7 +122,7 @@ def run_cases_test(self, input: str, expected: str): def test_inst_no_args(self): input = """ inst(OP, (--)) { - spam(); + SPAM(); } """ output = """ @@ -130,7 +130,7 @@ def test_inst_no_args(self): frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(OP); - spam(); + SPAM(); DISPATCH(); } """ @@ -139,7 +139,7 @@ def test_inst_no_args(self): def test_inst_one_pop(self): input = """ inst(OP, (value --)) { - spam(value); + SPAM(value); DEAD(value); } """ @@ -150,7 +150,7 @@ def test_inst_one_pop(self): INSTRUCTION_STATS(OP); _PyStackRef value; value = stack_pointer[-1]; - spam(value); + SPAM(value); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -161,7 +161,7 @@ def test_inst_one_pop(self): def test_inst_one_push(self): input = """ inst(OP, (-- res)) { - res = spam(); + res = SPAM(); } """ output = """ @@ -170,7 +170,7 @@ def test_inst_one_push(self): next_instr += 1; INSTRUCTION_STATS(OP); _PyStackRef res; - res = spam(); + res = SPAM(); stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -182,7 +182,7 @@ def test_inst_one_push(self): def test_inst_one_push_one_pop(self): input = """ inst(OP, (value -- res)) { - res = spam(value); + res = SPAM(value); DEAD(value); } """ @@ -194,7 +194,7 @@ def test_inst_one_push_one_pop(self): _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; - res = spam(value); + res = SPAM(value); stack_pointer[-1] = res; DISPATCH(); } @@ -204,7 +204,7 @@ def test_inst_one_push_one_pop(self): def test_binary_op(self): input = """ inst(OP, (left, right -- res)) { - res = spam(left, right); + res = SPAM(left, right); INPUTS_DEAD(); } @@ -219,7 +219,7 @@ def test_binary_op(self): _PyStackRef res; right = stack_pointer[-1]; left = stack_pointer[-2]; - res = spam(left, right); + res = SPAM(left, right); stack_pointer[-2] = res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -231,7 +231,7 @@ def test_binary_op(self): def test_overlap(self): input = """ inst(OP, (left, right -- left, result)) { - result = spam(left, right); + result = SPAM(left, right); INPUTS_DEAD(); } """ @@ -245,7 +245,7 @@ def test_overlap(self): _PyStackRef result; right = stack_pointer[-1]; left = stack_pointer[-2]; - result = spam(left, right); + result = SPAM(left, right); stack_pointer[-1] = result; DISPATCH(); } @@ -310,7 +310,9 @@ def test_sync_sp(self): _PyStackRef res; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); escaping_call(); + stack_pointer = _PyFrame_GetStackPointer(frame); res = Py_None; stack_pointer[0] = res; stack_pointer += 1; @@ -325,7 +327,9 @@ def test_sync_sp(self): _PyStackRef res; res = Py_None; stack_pointer[-1] = res; + _PyFrame_SetStackPointer(frame, stack_pointer); escaping_call(); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH(); } """ @@ -384,7 +388,7 @@ def test_error_if_plain_with_comment(self): def test_error_if_pop(self): input = """ inst(OP, (left, right -- res)) { - spam(left, right); + SPAM(left, right); INPUTS_DEAD(); ERROR_IF(cond, label); res = 0; @@ -400,7 +404,7 @@ def test_error_if_pop(self): _PyStackRef res; right = stack_pointer[-1]; left = stack_pointer[-2]; - spam(left, right); + SPAM(left, right); if (cond) goto pop_2_label; res = 0; stack_pointer[-2] = res; @@ -414,7 +418,7 @@ def test_error_if_pop(self): def test_error_if_pop_with_result(self): input = """ inst(OP, (left, right -- res)) { - res = spam(left, right); + res = SPAM(left, right); INPUTS_DEAD(); ERROR_IF(cond, label); } @@ -429,7 +433,7 @@ def test_error_if_pop_with_result(self): _PyStackRef res; right = stack_pointer[-1]; left = stack_pointer[-2]; - res = spam(left, right); + res = SPAM(left, right); if (cond) goto pop_2_label; stack_pointer[-2] = res; stack_pointer += -1; @@ -511,7 +515,9 @@ def test_macro_instruction(self): left = stack_pointer[-2]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; + _PyFrame_SetStackPointer(frame, stack_pointer); op1(left, right); + stack_pointer = _PyFrame_GetStackPointer(frame); } /* Skip 2 cache entries */ // OP2 @@ -519,7 +525,9 @@ def test_macro_instruction(self): arg2 = stack_pointer[-3]; uint32_t extra = read_u32(&this_instr[4].cache); (void)extra; + _PyFrame_SetStackPointer(frame, stack_pointer); res = op2(arg2, left, right); + stack_pointer = _PyFrame_GetStackPointer(frame); } stack_pointer[-3] = res; stack_pointer += -2; @@ -538,7 +546,9 @@ def test_macro_instruction(self): left = stack_pointer[-2]; uint16_t counter = read_u16(&this_instr[1].cache); (void)counter; + _PyFrame_SetStackPointer(frame, stack_pointer); op1(left, right); + stack_pointer = _PyFrame_GetStackPointer(frame); DISPATCH(); } @@ -555,7 +565,9 @@ def test_macro_instruction(self): right = stack_pointer[-1]; left = stack_pointer[-2]; arg2 = stack_pointer[-3]; + _PyFrame_SetStackPointer(frame, stack_pointer); res = op3(arg2, left, right); + stack_pointer = _PyFrame_GetStackPointer(frame); stack_pointer[-3] = res; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -567,7 +579,7 @@ def test_macro_instruction(self): def test_unused_caches(self): input = """ inst(OP, (unused/1, unused/2 --)) { - body(); + body; } """ output = """ @@ -577,7 +589,7 @@ def test_unused_caches(self): INSTRUCTION_STATS(OP); /* Skip 1 cache entry */ /* Skip 2 cache entries */ - body(); + body; DISPATCH(); } """ @@ -624,7 +636,7 @@ def test_pseudo_instruction_with_flags(self): def test_array_input(self): input = """ inst(OP, (below, values[oparg*2], above --)) { - spam(values, oparg); + SPAM(values, oparg); } """ output = """ @@ -634,7 +646,7 @@ def test_array_input(self): INSTRUCTION_STATS(OP); _PyStackRef *values; values = &stack_pointer[-1 - oparg*2]; - spam(values, oparg); + SPAM(values, oparg); stack_pointer += -2 - oparg*2; assert(WITHIN_STACK_BOUNDS()); DISPATCH(); @@ -645,7 +657,7 @@ def test_array_input(self): def test_array_output(self): input = """ inst(OP, (unused, unused -- below, values[oparg*3], above)) { - spam(values, oparg); + SPAM(values, oparg); below = 0; above = 0; } @@ -659,7 +671,7 @@ def test_array_output(self): _PyStackRef *values; _PyStackRef above; values = &stack_pointer[-1]; - spam(values, oparg); + SPAM(values, oparg); below = 0; above = 0; stack_pointer[-2] = below; @@ -674,7 +686,7 @@ def test_array_output(self): def test_array_input_output(self): input = """ inst(OP, (values[oparg] -- values[oparg], above)) { - spam(values, oparg); + SPAM(values, oparg); above = 0; } """ @@ -686,7 +698,7 @@ def test_array_input_output(self): _PyStackRef *values; _PyStackRef above; values = &stack_pointer[-oparg]; - spam(values, oparg); + SPAM(values, oparg); above = 0; stack_pointer[0] = above; stack_pointer += 1; @@ -722,7 +734,7 @@ def test_array_error_if(self): def test_cond_effect(self): input = """ inst(OP, (aa, input if ((oparg & 1) == 1), cc -- xx, output if (oparg & 2), zz)) { - output = spam(oparg, aa, cc, input); + output = SPAM(oparg, aa, cc, input); INPUTS_DEAD(); xx = 0; zz = 0; @@ -742,7 +754,7 @@ def test_cond_effect(self): cc = stack_pointer[-1]; if ((oparg & 1) == 1) { input = stack_pointer[-1 - (((oparg & 1) == 1) ? 1 : 0)]; } aa = stack_pointer[-2 - (((oparg & 1) == 1) ? 1 : 0)]; - output = spam(oparg, aa, cc, input); + output = SPAM(oparg, aa, cc, input); xx = 0; zz = 0; stack_pointer[-2 - (((oparg & 1) == 1) ? 1 : 0)] = xx; @@ -758,7 +770,7 @@ def test_cond_effect(self): def test_macro_cond_effect(self): input = """ op(A, (left, middle, right --)) { - use(left, middle, right); + USE(left, middle, right); INPUTS_DEAD(); } op(B, (-- deep, extra if (oparg), res)) { @@ -785,7 +797,7 @@ def test_macro_cond_effect(self): right = stack_pointer[-1]; middle = stack_pointer[-2]; left = stack_pointer[-3]; - use(left, middle, right); + USE(left, middle, right); } // B { @@ -806,10 +818,10 @@ def test_macro_cond_effect(self): def test_macro_push_push(self): input = """ op(A, (-- val1)) { - val1 = spam(); + val1 = SPAM(); } op(B, (-- val2)) { - val2 = spam(); + val2 = SPAM(); } macro(M) = A + B; """ @@ -822,11 +834,11 @@ def test_macro_push_push(self): _PyStackRef val2; // A { - val1 = spam(); + val1 = SPAM(); } // B { - val2 = spam(); + val2 = SPAM(); } stack_pointer[0] = val1; stack_pointer[1] = val2; @@ -840,10 +852,10 @@ def test_macro_push_push(self): def test_override_inst(self): input = """ inst(OP, (--)) { - spam(); + spam; } override inst(OP, (--)) { - ham(); + ham; } """ output = """ @@ -851,7 +863,7 @@ def test_override_inst(self): frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(OP); - ham(); + ham; DISPATCH(); } """ @@ -860,11 +872,11 @@ def test_override_inst(self): def test_override_op(self): input = """ op(OP, (--)) { - spam(); + spam; } macro(M) = OP; override op(OP, (--)) { - ham(); + ham; } """ output = """ @@ -872,7 +884,7 @@ def test_override_op(self): frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(M); - ham(); + ham; DISPATCH(); } """ @@ -881,7 +893,7 @@ def test_override_op(self): def test_annotated_inst(self): input = """ pure inst(OP, (--)) { - ham(); + ham; } """ output = """ @@ -889,7 +901,7 @@ def test_annotated_inst(self): frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(OP); - ham(); + ham; DISPATCH(); } """ @@ -898,7 +910,7 @@ def test_annotated_inst(self): def test_annotated_op(self): input = """ pure op(OP, (--)) { - spam(); + SPAM(); } macro(M) = OP; """ @@ -907,7 +919,7 @@ def test_annotated_op(self): frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(M); - spam(); + SPAM(); DISPATCH(); } """ @@ -915,7 +927,7 @@ def test_annotated_op(self): input = """ pure register specializing op(OP, (--)) { - spam(); + SPAM(); } macro(M) = OP; """ @@ -1012,14 +1024,14 @@ def test_unused_named_values(self): def test_used_unused_used(self): input = """ op(FIRST, (w -- w)) { - use(w); + USE(w); } op(SECOND, (x -- x)) { } op(THIRD, (y -- y)) { - use(y); + USE(y); } macro(TEST) = FIRST + SECOND + THIRD; @@ -1034,7 +1046,7 @@ def test_used_unused_used(self): // FIRST { w = stack_pointer[-1]; - use(w); + USE(w); } // SECOND { @@ -1042,7 +1054,7 @@ def test_used_unused_used(self): // THIRD { y = w; - use(y); + USE(y); } DISPATCH(); } @@ -1055,11 +1067,11 @@ def test_unused_used_used(self): } op(SECOND, (x -- x)) { - use(x); + USE(x); } op(THIRD, (y -- y)) { - use(y); + USE(y); } macro(TEST) = FIRST + SECOND + THIRD; @@ -1077,12 +1089,12 @@ def test_unused_used_used(self): // SECOND { x = stack_pointer[-1]; - use(x); + USE(x); } // THIRD { y = x; - use(y); + USE(y); } DISPATCH(); } @@ -1097,7 +1109,7 @@ def test_flush(self): } op(SECOND, (a, b -- )) { - use(a, b); + USE(a, b); INPUTS_DEAD(); } @@ -1122,7 +1134,7 @@ def test_flush(self): assert(WITHIN_STACK_BOUNDS()); // SECOND { - use(a, b); + USE(a, b); } stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -1383,7 +1395,7 @@ def run_cases_test(self, input: str, input2: str, expected: str): def test_overridden_abstract(self): input = """ pure op(OP, (--)) { - spam(); + SPAM(); } """ input2 = """ @@ -1402,15 +1414,15 @@ def test_overridden_abstract(self): def test_overridden_abstract_args(self): input = """ pure op(OP, (arg1 -- out)) { - out = spam(arg1); + out = SPAM(arg1); } op(OP2, (arg1 -- out)) { - out = eggs(arg1); + out = EGGS(arg1); } """ input2 = """ op(OP, (arg1 -- out)) { - out = eggs(arg1); + out = EGGS(arg1); } """ output = """ @@ -1418,7 +1430,7 @@ def test_overridden_abstract_args(self): _Py_UopsSymbol *arg1; _Py_UopsSymbol *out; arg1 = stack_pointer[-1]; - out = eggs(arg1); + out = EGGS(arg1); stack_pointer[-1] = out; break; } @@ -1435,7 +1447,7 @@ def test_overridden_abstract_args(self): def test_no_overridden_case(self): input = """ pure op(OP, (arg1 -- out)) { - out = spam(arg1); + out = SPAM(arg1); } pure op(OP2, (arg1 -- out)) { @@ -1467,7 +1479,7 @@ def test_no_overridden_case(self): def test_missing_override_failure(self): input = """ pure op(OP, (arg1 -- out)) { - spam(); + SPAM(); } """ input2 = """ diff --git a/Python/bytecodes.c b/Python/bytecodes.c index c4911344e6423b..048fc5da026b87 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -956,7 +956,8 @@ dummy_func( assert(oparg < 3); PyObject *cause = oparg == 2 ? PyStackRef_AsPyObjectSteal(args[1]) : NULL; PyObject *exc = oparg > 0 ? PyStackRef_AsPyObjectSteal(args[0]) : NULL; - if (do_raise(tstate, exc, cause)) { + int err = do_raise(tstate, exc, cause); + if (err) { assert(oparg == 0); monitor_reraise(tstate, frame, this_instr); goto exception_unwind; diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index e9df699924e93c..cb7a858dc2f90f 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -15,7 +15,7 @@ case _CHECK_PERIODIC: { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -29,7 +29,7 @@ if ((oparg & RESUME_OPARG_LOCATION_MASK) < RESUME_AFTER_YIELD_FROM) { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -65,7 +65,7 @@ _PyStackRef value; oparg = CURRENT_OPARG(); _PyStackRef value_s = GETLOCAL(oparg); - if (PyStackRef_IsNull(value_s)) { + if (PyStackRef_IsNull(value_s)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError, UNBOUNDLOCAL_ERROR_MSG, @@ -345,6 +345,7 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -370,6 +371,7 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -401,7 +403,7 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(TO_BOOL, hit); - if (_PyLong_IsZero((PyLongObject *)value_o)) { + if (_PyLong_IsZero((PyLongObject *)value_o)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -456,7 +458,7 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(TO_BOOL, hit); - if (value_o == &_Py_STR(empty)) { + if (value_o == &_Py_STR(empty)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -485,6 +487,7 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -792,7 +795,7 @@ sub = stack_pointer[-1]; container = stack_pointer[-2]; PyObject *container_o = PyStackRef_AsPyObjectBorrow(container); - PyObject *sub_o = PyStackRef_AsPyObjectBorrow(sub); + PyObject *sub_o = PyStackRef_AsPyObjectBorrow(sub);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_GetItem(container_o, sub_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -814,6 +817,7 @@ stop = stack_pointer[-1]; start = stack_pointer[-2]; container = stack_pointer[-3]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); @@ -824,7 +828,7 @@ if (slice == NULL) { res_o = NULL; } - else { + else {/* Escaping */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -852,6 +856,7 @@ start = stack_pointer[-2]; container = stack_pointer[-3]; v = stack_pointer[-4]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); @@ -860,7 +865,7 @@ if (slice == NULL) { err = 1; } - else { + else {/* Escaping */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -1011,11 +1016,11 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(BINARY_SUBSCR, hit); - PyObject *res_o; + PyObject *res_o;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int rc = PyDict_GetItemRef(dict, sub, &res_o); stack_pointer = _PyFrame_GetStackPointer(frame); - if (rc == 0) { + if (rc == 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetKeyError(sub); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1100,6 +1105,7 @@ oparg = CURRENT_OPARG(); v = stack_pointer[-1]; set = stack_pointer[-2 - (oparg-1)]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PySet_Add(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(v)); @@ -1118,7 +1124,7 @@ sub = stack_pointer[-1]; container = stack_pointer[-2]; v = stack_pointer[-3]; - /* container[sub] = v */ + /* container[sub] = v *//* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1183,7 +1189,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - STAT_INC(STORE_SUBSCR, hit); + STAT_INC(STORE_SUBSCR, hit);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_SetItem_Take2((PyDictObject *)dict, PyStackRef_AsPyObjectSteal(sub), @@ -1201,7 +1207,7 @@ _PyStackRef container; sub = stack_pointer[-1]; container = stack_pointer[-2]; - /* del container[sub] */ + /* del container[sub] *//* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub)); @@ -1219,8 +1225,10 @@ _PyStackRef res; oparg = CURRENT_OPARG(); value = stack_pointer[-1]; - assert(oparg <= MAX_INTRINSIC_1); + assert(oparg <= MAX_INTRINSIC_1);/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); if (res_o == NULL) JUMP_TO_ERROR(); res = PyStackRef_FromPyObjectSteal(res_o); @@ -1237,8 +1245,10 @@ value2_st = stack_pointer[-2]; assert(oparg <= MAX_INTRINSIC_2); PyObject *value1 = PyStackRef_AsPyObjectBorrow(value1_st); - PyObject *value2 = PyStackRef_AsPyObjectBorrow(value2_st); + PyObject *value2 = PyStackRef_AsPyObjectBorrow(value2_st);/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value2_st); PyStackRef_CLOSE(value1_st); if (res_o == NULL) JUMP_TO_ERROR(); @@ -1287,7 +1297,7 @@ if (type->tp_as_async != NULL) { getter = type->tp_as_async->am_aiter; } - if (getter == NULL) { + if (getter == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'async for' requires an object with " @@ -1301,7 +1311,7 @@ PyStackRef_CLOSE(obj); if (iter_o == NULL) JUMP_TO_ERROR(); if (Py_TYPE(iter_o)->tp_as_async == NULL || - Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) { + Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) {/* Escaping */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -1322,6 +1332,7 @@ _PyStackRef aiter; _PyStackRef awaitable; aiter = stack_pointer[-1]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *awaitable_o = _PyEval_GetANext(PyStackRef_AsPyObjectBorrow(aiter)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1340,6 +1351,7 @@ _PyStackRef iter; oparg = CURRENT_OPARG(); iterable = stack_pointer[-1]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1392,7 +1404,7 @@ #if TIER_ONE assert(frame != &entry_frame); #endif - frame->instr_ptr++; + frame->instr_ptr++;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1432,7 +1444,7 @@ case _POP_EXCEPT: { _PyStackRef exc_value; exc_value = stack_pointer[-1]; - _PyErr_StackItem *exc_info = tstate->exc_info; + _PyErr_StackItem *exc_info = tstate->exc_info;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); Py_XSETREF(exc_info->exc_value, PyStackRef_Is(exc_value, PyStackRef_None) @@ -1467,12 +1479,12 @@ case _LOAD_BUILD_CLASS: { _PyStackRef bc; - PyObject *bc_o; + PyObject *bc_o;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) JUMP_TO_ERROR(); - if (bc_o == NULL) { + if (bc_o == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_NameError, "__build_class__ not found"); @@ -1493,7 +1505,7 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); PyObject *ns = LOCALS(); int err; - if (ns == NULL) { + if (ns == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when storing %R", name); @@ -1501,12 +1513,12 @@ PyStackRef_CLOSE(v); if (true) JUMP_TO_ERROR(); } - if (PyDict_CheckExact(ns)) { + if (PyDict_CheckExact(ns)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); } - else { + else {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1523,18 +1535,18 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); PyObject *ns = LOCALS(); int err; - if (ns == NULL) { + if (ns == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals when deleting %R", name); stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_DelItem(ns, name); stack_pointer = _PyFrame_GetStackPointer(frame); // Can't use ERROR_IF here. - if (err != 0) { + if (err != 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, @@ -1551,7 +1563,7 @@ oparg = CURRENT_OPARG(); seq = stack_pointer[-1]; output = &stack_pointer[-1]; - _PyStackRef *top = output + oparg; + _PyStackRef *top = output + oparg;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1647,7 +1659,7 @@ oparg = CURRENT_OPARG(); seq = stack_pointer[-1]; right = &stack_pointer[(oparg & 0xFF)]; - _PyStackRef *top = right + (oparg >> 8); + _PyStackRef *top = right + (oparg >> 8);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1664,7 +1676,7 @@ oparg = CURRENT_OPARG(); owner = stack_pointer[-1]; v = stack_pointer[-2]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner), name, PyStackRef_AsPyObjectBorrow(v)); @@ -1681,7 +1693,7 @@ _PyStackRef owner; oparg = CURRENT_OPARG(); owner = stack_pointer[-1]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1696,7 +1708,7 @@ _PyStackRef v; oparg = CURRENT_OPARG(); v = stack_pointer[-1]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1709,7 +1721,7 @@ case _DELETE_GLOBAL: { oparg = CURRENT_OPARG(); - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_Pop(GLOBALS(), name, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1717,7 +1729,7 @@ if (err < 0) { JUMP_TO_ERROR(); } - if (err == 0) { + if (err == 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, name); @@ -1730,7 +1742,7 @@ case _LOAD_LOCALS: { _PyStackRef locals; PyObject *l = LOCALS(); - if (l == NULL) { + if (l == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_SystemError, "no locals found"); @@ -1749,7 +1761,7 @@ case _LOAD_NAME: { _PyStackRef v; oparg = CURRENT_OPARG(); - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *v_o = _PyEval_LoadName(tstate, frame, name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1766,7 +1778,7 @@ _PyStackRef null = PyStackRef_NULL; oparg = CURRENT_OPARG(); res = &stack_pointer[0]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_LoadGlobalStackRef(GLOBALS(), BUILTINS(), name, res); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1857,7 +1869,7 @@ case _DELETE_FAST: { oparg = CURRENT_OPARG(); _PyStackRef v = GETLOCAL(oparg); - if (PyStackRef_IsNull(v)) { + if (PyStackRef_IsNull(v)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError, UNBOUNDLOCAL_ERROR_MSG, @@ -1887,11 +1899,11 @@ oparg = CURRENT_OPARG(); PyObject *cell = PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); // Can't use ERROR_IF here. - // Fortunately we don't need its superpower. + // Fortunately we don't need its superpower./* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *oldobj = PyCell_SwapTakeRef((PyCellObject *)cell, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); - if (oldobj == NULL) { + if (oldobj == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1911,7 +1923,7 @@ PyObject *class_dict = PyStackRef_AsPyObjectBorrow(class_dict_st); assert(class_dict); assert(oparg >= 0 && oparg < _PyFrame_GetCode(frame)->co_nlocalsplus); - name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg); + name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(class_dict, name, &value_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1921,7 +1933,7 @@ if (!value_o) { PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); value_o = PyCell_GetRef(cell); - if (value_o == NULL) { + if (value_o == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1939,7 +1951,7 @@ oparg = CURRENT_OPARG(); PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); PyObject *value_o = PyCell_GetRef(cell); - if (value_o == NULL) { + if (value_o == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1956,7 +1968,7 @@ _PyStackRef v; oparg = CURRENT_OPARG(); v = stack_pointer[-1]; - PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); + PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2041,20 +2053,19 @@ iterable_st = stack_pointer[-1]; list_st = stack_pointer[-2 - (oparg-1)]; PyObject *list = PyStackRef_AsPyObjectBorrow(list_st); - PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st); + PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable); stack_pointer = _PyFrame_GetStackPointer(frame); - if (none_val == NULL) { + if (none_val == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_TypeError); stack_pointer = _PyFrame_GetStackPointer(frame); if (matches && (Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable))) - { + {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_Clear(tstate); - _PyErr_Format(tstate, PyExc_TypeError, + _PyErr_Clear(tstate);/* Escaping */_PyErr_Format(tstate, PyExc_TypeError, "Value after * must be an iterable, not %.200s", Py_TYPE(iterable)->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2075,6 +2086,7 @@ oparg = CURRENT_OPARG(); iterable = stack_pointer[-1]; set = stack_pointer[-2 - (oparg-1)]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(iterable)); @@ -2091,6 +2103,7 @@ _PyStackRef set; oparg = CURRENT_OPARG(); values = &stack_pointer[-oparg]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *set_o = PySet_New(NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2102,7 +2115,7 @@ } int err = 0; for (int i = 0; i < oparg; i++) { - if (err == 0) { + if (err == 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); err = PySet_Add(set_o, PyStackRef_AsPyObjectBorrow(values[i])); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2131,7 +2144,7 @@ PyStackRef_CLOSE(values[_i]); } if (true) JUMP_TO_ERROR(); - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *map_o = _PyDict_FromItems( values_o, 2, @@ -2152,23 +2165,24 @@ case _SETUP_ANNOTATIONS: { PyObject *ann_dict; - if (LOCALS() == NULL) { + if (LOCALS() == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when setting up annotations"); stack_pointer = _PyFrame_GetStackPointer(frame); if (true) JUMP_TO_ERROR(); } - /* check if __annotations__ in locals()... */ + /* check if __annotations__ in locals()... *//* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) JUMP_TO_ERROR(); - if (ann_dict == NULL) { + if (ann_dict == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); ann_dict = PyDict_New(); stack_pointer = _PyFrame_GetStackPointer(frame); if (ann_dict == NULL) JUMP_TO_ERROR(); + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__), ann_dict); @@ -2189,15 +2203,15 @@ update = stack_pointer[-1]; dict = stack_pointer[-2 - (oparg - 1)]; PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); - PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); + PyObject *update_o = PyStackRef_AsPyObjectBorrow(update);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_Update(dict_o, update_o); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { + if (err < 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_AttributeError); stack_pointer = _PyFrame_GetStackPointer(frame); - if (matches) { + if (matches) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'%.200s' object is not a mapping", @@ -2223,11 +2237,11 @@ callable = stack_pointer[-5 - (oparg - 1)]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); - PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); + PyObject *update_o = PyStackRef_AsPyObjectBorrow(update);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_MergeEx(dict_o, update_o, 2); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { + if (err < 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatKwargsError(tstate, callable_o, update_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2251,7 +2265,7 @@ PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st); assert(PyDict_CheckExact(dict)); /* dict[key] = value */ - // Do not DECREF INPUTS because the function steals the references + // Do not DECREF INPUTS because the function steals the references/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_SetItem_Take2( (PyDictObject *)dict, @@ -2289,7 +2303,7 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(LOAD_SUPER_ATTR, hit); - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2329,7 +2343,7 @@ STAT_INC(LOAD_SUPER_ATTR, hit); PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); PyTypeObject *cls = (PyTypeObject *)class; - int method_found = 0; + int method_found = 0;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attr_o = _PySuper_Lookup(cls, self, name, Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? &method_found : NULL); @@ -2364,7 +2378,7 @@ PyObject *attr_o; if (oparg & 1) { /* Designed to work in tandem with CALL, pushes two values. */ - attr_o = NULL; + attr_o = NULL;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int is_meth = _PyObject_GetMethod(PyStackRef_AsPyObjectBorrow(owner), name, &attr_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2389,7 +2403,7 @@ } } else { - /* Classic, pushes one value. */ + /* Classic, pushes one value. *//* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2798,13 +2812,13 @@ JUMP_TO_JUMP_TARGET(); } /* Ensure dict is GC tracked if it needs to be */ - if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(PyStackRef_AsPyObjectBorrow(value))) { + if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(PyStackRef_AsPyObjectBorrow(value))) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyObject_GC_TRACK(dict); stack_pointer = _PyFrame_GetStackPointer(frame); } old_value = ep->me_value; - PyDict_WatchEvent event = old_value == NULL ? PyDict_EVENT_ADDED : PyDict_EVENT_MODIFIED; + PyDict_WatchEvent event = old_value == NULL ? PyDict_EVENT_ADDED : PyDict_EVENT_MODIFIED;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); new_version = _PyDict_NotifyEvent(tstate->interp, event, dict, name, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2847,14 +2861,14 @@ left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert((oparg >> 5) <= Py_GE); + assert((oparg >> 5) <= Py_GE);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res_o == NULL) JUMP_TO_ERROR(); - if (oparg & 16) { + if (oparg & 16) {/* Escaping */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -2989,7 +3003,7 @@ right = stack_pointer[-1]; left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int res = PySequence_Contains(right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3017,7 +3031,7 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(CONTAINS_OP, hit); - // Note: both set and frozenset use the same seq_contains method! + // Note: both set and frozenset use the same seq_contains method!/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PySet_Contains((PySetObject *)right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3044,7 +3058,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - STAT_INC(CONTAINS_OP, hit); + STAT_INC(CONTAINS_OP, hit);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyDict_Contains(right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3066,7 +3080,7 @@ match_type_st = stack_pointer[-1]; exc_value_st = stack_pointer[-2]; PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st); - PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st); + PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3076,7 +3090,7 @@ if (true) JUMP_TO_ERROR(); } PyObject *match_o = NULL; - PyObject *rest_o = NULL; + PyObject *rest_o = NULL;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_ExceptionGroupMatch(exc_value, match_type, &match_o, &rest_o); @@ -3086,7 +3100,7 @@ if (res < 0) JUMP_TO_ERROR(); assert((match_o == NULL) == (rest_o == NULL)); if (match_o == NULL) JUMP_TO_ERROR(); - if (!Py_IsNone(match_o)) { + if (!Py_IsNone(match_o)) {/* Escaping */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -3110,14 +3124,14 @@ left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyExceptionInstance_Check(left_o)); + assert(PyExceptionInstance_Check(left_o));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyEval_CheckExceptTypeValid(tstate, right_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { PyStackRef_CLOSE(right); if (true) JUMP_TO_ERROR(); - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyErr_GivenExceptionMatches(left_o, right_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3134,7 +3148,7 @@ oparg = CURRENT_OPARG(); fromlist = stack_pointer[-1]; level = stack_pointer[-2]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_ImportName(tstate, frame, name, PyStackRef_AsPyObjectBorrow(fromlist), @@ -3155,7 +3169,7 @@ _PyStackRef res; oparg = CURRENT_OPARG(); from = stack_pointer[-1]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3190,11 +3204,12 @@ _PyStackRef obj; _PyStackRef len; obj = stack_pointer[-1]; - // PUSH(len(TOS)) + // PUSH(len(TOS))/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj)); stack_pointer = _PyFrame_GetStackPointer(frame); if (len_i < 0) JUMP_TO_ERROR(); + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *len_o = PyLong_FromSsize_t(len_i); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3217,7 +3232,7 @@ subject = stack_pointer[-3]; // Pop TOS and TOS1. Set TOS to a tuple of attributes on success, or // None on failure. - assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names))); + assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names)));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attrs_o = _PyEval_MatchClass(tstate, PyStackRef_AsPyObjectBorrow(subject), @@ -3272,7 +3287,7 @@ _PyStackRef values_or_none; keys = stack_pointer[-1]; subject = stack_pointer[-2]; - // On successful match, PUSH(values). Otherwise, PUSH(None). + // On successful match, PUSH(values). Otherwise, PUSH(None)./* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *values_or_none_o = _PyEval_MatchKeys(tstate, PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys)); @@ -3289,7 +3304,7 @@ _PyStackRef iterable; _PyStackRef iter; iterable = stack_pointer[-1]; - /* before: [obj]; after [getiter(obj)] */ + /* before: [obj]; after [getiter(obj)] *//* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable))); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3309,7 +3324,7 @@ /* `iterable` is a coroutine */ if (!(_PyFrame_GetCode(frame)->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) { /* and it is used in a 'yield from' expression of a - regular generator. */ + regular generator. *//* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_TypeError, "cannot 'yield from' a coroutine object " @@ -3323,7 +3338,7 @@ iter = iterable; } else { - /* `iterable` is not a generator. */ + /* `iterable` is not a generator. *//* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3346,16 +3361,15 @@ PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); PyObject *next_o = (*Py_TYPE(iter_o)->tp_iternext)(iter_o); if (next_o == NULL) { - if (_PyErr_Occurred(tstate)) { + if (_PyErr_Occurred(tstate)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); stack_pointer = _PyFrame_GetStackPointer(frame); if (!matches) { JUMP_TO_ERROR(); - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); - _PyEval_MonitorRaise(tstate, frame, frame->instr_ptr); - _PyErr_Clear(tstate); + _PyEval_MonitorRaise(tstate, frame, frame->instr_ptr);/* Escaping */_PyErr_Clear(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); } /* iterator ended normally */ @@ -3554,14 +3568,14 @@ assert(oparg <= SPECIAL_MAX); PyObject *owner_o = PyStackRef_AsPyObjectSteal(owner); PyObject *name = _Py_SpecialMethods[oparg].name; - PyObject *self_or_null_o; + PyObject *self_or_null_o;/* Escaping */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); attr = PyStackRef_FromPyObjectSteal(_PyObject_LookupSpecialMethod(owner_o, name, &self_or_null_o)); stack_pointer = _PyFrame_GetStackPointer(frame); if (PyStackRef_IsNull(attr)) { - if (!_PyErr_Occurred(tstate)) { + if (!_PyErr_Occurred(tstate)) {/* Escaping */ stack_pointer[0] = attr; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3605,10 +3619,9 @@ PyObject *exc, *tb; PyObject *val_o = PyStackRef_AsPyObjectBorrow(val); PyObject *exit_func_o = PyStackRef_AsPyObjectBorrow(exit_func); - assert(val_o && PyExceptionInstance_Check(val_o)); + assert(val_o && PyExceptionInstance_Check(val_o));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); - exc = PyExceptionInstance_Class(val_o); - tb = PyException_GetTraceback(val_o); + exc = PyExceptionInstance_Class(val_o);/* Escaping */tb = PyException_GetTraceback(val_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (tb == NULL) { tb = Py_None; @@ -3619,7 +3632,7 @@ assert(PyStackRef_LongCheck(lasti)); (void)lasti; // Shut up compiler warning if asserts are off PyObject *stack[5] = {NULL, PyStackRef_AsPyObjectBorrow(exit_self), exc, val_o, tb}; - int has_self = !PyStackRef_IsNull(exit_self); + int has_self = !PyStackRef_IsNull(exit_self);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Vectorcall(exit_func_o, stack + 2 - has_self, (3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL)); @@ -3831,7 +3844,7 @@ } 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)); + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( tstate, callable[0], locals, @@ -3961,7 +3974,7 @@ PyStackRef_CLOSE(args[_i]); } if (true) JUMP_TO_ERROR(); - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -4273,7 +4286,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - STAT_INC(CALL, hit); + STAT_INC(CALL, hit);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4305,7 +4318,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - STAT_INC(CALL, hit); + STAT_INC(CALL, hit);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4352,7 +4365,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - STAT_INC(CALL, hit); + STAT_INC(CALL, hit);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *self_o = _PyType_NewManagedObject(tp); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4375,13 +4388,13 @@ args = &stack_pointer[-oparg]; self = &stack_pointer[-1 - oparg]; init = &stack_pointer[-2 - oparg]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( - tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame); - assert(_PyCode_CODE(_PyFrame_GetCode(shim))[0].op.code == EXIT_INIT_CHECK); + tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame);/* Escaping */assert(_PyCode_CODE(_PyFrame_GetCode(shim))[0].op.code == EXIT_INIT_CHECK); stack_pointer = _PyFrame_GetStackPointer(frame); /* Push self onto stack of shim */ - shim->localsplus[0] = PyStackRef_DUP(self[0]); + shim->localsplus[0] = PyStackRef_DUP(self[0]);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); init_frame = _PyEvalFramePushAndInit( tstate, init[0], NULL, args-1, oparg+1, NULL, shim); @@ -4405,7 +4418,7 @@ _PyStackRef should_be_none; should_be_none = stack_pointer[-1]; assert(STACK_LEVEL() == 2); - if (!PyStackRef_Is(should_be_none, PyStackRef_None)) { + if (!PyStackRef_Is(should_be_none, PyStackRef_None)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyErr_Format(PyExc_TypeError, "__init__() should return None, not '%.200s'", @@ -4451,8 +4464,10 @@ PyStackRef_CLOSE(args[_i]); } if (true) JUMP_TO_ERROR(); - } + }/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = tp->tp_vectorcall((PyObject *)tp, args_o, total_args, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); /* Free the arguments. */ for (int i = 0; i < total_args; i++) { @@ -4503,7 +4518,7 @@ STAT_INC(CALL, hit); PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o); _PyStackRef arg = args[0]; - _Py_EnterRecursiveCallTstateUnchecked(tstate); + _Py_EnterRecursiveCallTstateUnchecked(tstate);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4611,8 +4626,10 @@ PyStackRef_CLOSE(args[_i]); } if (true) JUMP_TO_ERROR(); - } + }/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = cfunc(PyCFunction_GET_SELF(callable_o), args_o, total_args, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); /* Free the arguments. */ @@ -4655,13 +4672,13 @@ } STAT_INC(CALL, hit); _PyStackRef arg_stackref = args[0]; - PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref); + PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (len_i < 0) { JUMP_TO_ERROR(); - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyLong_FromSsize_t(len_i); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4705,7 +4722,7 @@ } STAT_INC(CALL, hit); _PyStackRef cls_stackref = args[1]; - _PyStackRef inst_stackref = args[0]; + _PyStackRef inst_stackref = args[0];/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4803,7 +4820,7 @@ } STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; - _Py_EnterRecursiveCallTstateUnchecked(tstate); + _Py_EnterRecursiveCallTstateUnchecked(tstate);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyStackRef_AsPyObjectBorrow(self_stackref), @@ -4865,8 +4882,10 @@ PyStackRef_CLOSE(args[_i]); } if (true) JUMP_TO_ERROR(); - } + }/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = cfunc(self, (args_o + 1), nargs, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); /* Free the arguments. */ @@ -4925,7 +4944,7 @@ } STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; - _Py_EnterRecursiveCallTstateUnchecked(tstate); + _Py_EnterRecursiveCallTstateUnchecked(tstate);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4984,8 +5003,10 @@ PyStackRef_CLOSE(args[_i]); } if (true) JUMP_TO_ERROR(); - } + }/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = cfunc(self, (args_o + 1), nargs); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); /* Clear the stack of the arguments. */ @@ -5056,7 +5077,7 @@ int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); 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)); + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( tstate, callable[0], locals, @@ -5190,7 +5211,7 @@ if (true) JUMP_TO_ERROR(); } PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); - int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); + int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -5228,13 +5249,13 @@ if (PyTuple_CheckExact(callargs_o)) { tuple = callargs; } - else { + else {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { JUMP_TO_ERROR(); - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *tuple_o = PySequence_Tuple(callargs_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5256,13 +5277,14 @@ _PyStackRef codeobj_st; _PyStackRef func; codeobj_st = stack_pointer[-1]; - PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st); + PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyFunctionObject *func_obj = (PyFunctionObject *) PyFunction_New(codeobj, GLOBALS()); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(codeobj_st); if (func_obj == NULL) JUMP_TO_ERROR(); + /* Escaping */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -5301,7 +5323,7 @@ case _RETURN_GENERATOR: { _PyStackRef res; assert(PyStackRef_FunctionCheck(frame->f_funcobj)); - PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj); + PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5309,13 +5331,13 @@ assert(EMPTY()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *gen_frame = &gen->gi_iframe; - frame->instr_ptr++;/* Virtual flush 1 */ + frame->instr_ptr++;/* Escaping *//* Virtual flush 1 */ _PyFrame_Copy(frame, gen_frame);/* Virtual reload 1 */ assert(frame->frame_obj == NULL); gen->gi_frame_state = FRAME_CREATED; gen_frame->owner = FRAME_OWNED_BY_GENERATOR; _Py_LeaveRecursiveCallPy(tstate); - _PyInterpreterFrame *prev = frame->previous;/* Virtual flush 1 */ + _PyInterpreterFrame *prev = frame->previous;/* Escaping *//* Virtual flush 1 */ _PyThreadState_PopFrame(tstate, frame);/* Virtual reload 1 */ frame = tstate->current_frame = prev; LOAD_IP(frame->return_offset); @@ -5359,8 +5381,10 @@ value = stack_pointer[-1]; conversion_func conv_fn; assert(oparg >= FVC_STR && oparg <= FVC_ASCII); - conv_fn = _PyEval_ConversionFuncs[oparg]; + conv_fn = _PyEval_ConversionFuncs[oparg];/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); if (result_o == NULL) JUMP_TO_ERROR(); result = PyStackRef_FromPyObjectSteal(result_o); @@ -5375,7 +5399,7 @@ PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); /* If value is a unicode object, then we know the result * of format(value) is value itself. */ - if (!PyUnicode_CheckExact(value_o)) { + if (!PyUnicode_CheckExact(value_o)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Format(value_o, NULL)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5395,6 +5419,7 @@ _PyStackRef res; fmt_spec = stack_pointer[-1]; value = stack_pointer[-2]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5571,33 +5596,31 @@ case _EXIT_TRACE: { PyObject *exit_p = (PyObject *)CURRENT_OPERAND(); _PyExitData *exit = (_PyExitData *)exit_p; - PyCodeObject *code = _PyFrame_GetCode(frame); + PyCodeObject *code = _PyFrame_GetCode(frame);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); - _Py_CODEUNIT *target = _PyCode_CODE(code) + exit->target; - stack_pointer = _PyFrame_GetStackPointer(frame); - #if defined(Py_DEBUG) && !defined(_Py_JIT) + _Py_CODEUNIT *target = _PyCode_CODE(code) + exit->target;/* Escaping */#if defined(Py_DEBUG) && !defined(_Py_JIT) OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); - if (lltrace >= 2) { - printf("SIDE EXIT: [UOp "); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (lltrace >= 2) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); - _PyUOpPrint(&next_uop[-1]); - printf(", exit %u, temp %d, target %d -> %s]\n", + printf("SIDE EXIT: [UOp ");/* Escaping */_PyUOpPrint(&next_uop[-1]);/* Escaping */printf(", exit %u, temp %d, target %d -> %s]\n", exit - current_executor->exits, exit->temperature.as_counter, (int)(target - _PyCode_CODE(code)), _PyOpcode_OpName[target->op.code]); stack_pointer = _PyFrame_GetStackPointer(frame); } #endif - if (exit->executor && !exit->executor->vm_data.valid) { - exit->temperature = initial_temperature_backoff_counter(); + if (exit->executor && !exit->executor->vm_data.valid) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); - Py_CLEAR(exit->executor); + exit->temperature = initial_temperature_backoff_counter();/* Escaping */Py_CLEAR(exit->executor); stack_pointer = _PyFrame_GetStackPointer(frame); } if (exit->executor == NULL) { _Py_BackoffCounter temperature = exit->temperature; - if (!backoff_counter_triggers(temperature)) { + if (!backoff_counter_triggers(temperature)) {/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); exit->temperature = advance_backoff_counter(temperature); + stack_pointer = _PyFrame_GetStackPointer(frame); tstate->previous_executor = (PyObject *)current_executor; GOTO_TIER_ONE(target); } @@ -5607,12 +5630,14 @@ Py_INCREF(executor); } else { - int chain_depth = current_executor->vm_data.chain_depth + 1; + int chain_depth = current_executor->vm_data.chain_depth + 1;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int optimized = _PyOptimizer_Optimize(frame, target, stack_pointer, &executor, chain_depth); stack_pointer = _PyFrame_GetStackPointer(frame); - if (optimized <= 0) { + if (optimized <= 0) {/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); exit->temperature = restart_backoff_counter(temperature); + stack_pointer = _PyFrame_GetStackPointer(frame); if (optimized < 0) { GOTO_UNWIND(); } @@ -5718,14 +5743,14 @@ PyObject *exit_p = (PyObject *)CURRENT_OPERAND(); tstate->previous_executor = (PyObject *)current_executor; _PyExitData *exit = (_PyExitData *)exit_p; - _Py_CODEUNIT *target = frame->instr_ptr; + _Py_CODEUNIT *target = frame->instr_ptr;/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); #if defined(Py_DEBUG) && !defined(_Py_JIT) OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); - if (lltrace >= 2) { - printf("DYNAMIC EXIT: [UOp "); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (lltrace >= 2) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); - _PyUOpPrint(&next_uop[-1]); - printf(", exit %u, temp %d, target %d -> %s]\n", + printf("DYNAMIC EXIT: [UOp ");/* Escaping */_PyUOpPrint(&next_uop[-1]);/* Escaping */printf(", exit %u, temp %d, target %d -> %s]\n", exit - current_executor->exits, exit->temperature.as_counter, (int)(target - _PyCode_CODE(_PyFrame_GetCode(frame))), _PyOpcode_OpName[target->op.code]); @@ -5739,22 +5764,28 @@ Py_INCREF(executor); } else { - if (!backoff_counter_triggers(exit->temperature)) { + if (!backoff_counter_triggers(exit->temperature)) {/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); exit->temperature = advance_backoff_counter(exit->temperature); + stack_pointer = _PyFrame_GetStackPointer(frame); GOTO_TIER_ONE(target); - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int optimized = _PyOptimizer_Optimize(frame, target, stack_pointer, &executor, 0); stack_pointer = _PyFrame_GetStackPointer(frame); - if (optimized <= 0) { + if (optimized <= 0) {/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); exit->temperature = restart_backoff_counter(exit->temperature); + stack_pointer = _PyFrame_GetStackPointer(frame); if (optimized < 0) { GOTO_UNWIND(); } GOTO_TIER_ONE(target); } - else { + else {/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); exit->temperature = initial_temperature_backoff_counter(); + stack_pointer = _PyFrame_GetStackPointer(frame); } } GOTO_TIER_TWO(executor); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 61f926cce3c799..85fe8c8ac40f8b 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -27,7 +27,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr; + next_instr = this_instr;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_BinaryOp(lhs, rhs, next_instr, oparg, LOCALS_ARRAY); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -385,6 +385,7 @@ stop = stack_pointer[-1]; start = stack_pointer[-2]; container = stack_pointer[-3]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); @@ -395,7 +396,7 @@ if (slice == NULL) { res_o = NULL; } - else { + else {/* Escaping */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -434,7 +435,7 @@ assert(frame->stackpointer == NULL); #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr; + next_instr = this_instr;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_BinarySubscr(container, sub, next_instr); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -447,7 +448,7 @@ // _BINARY_SUBSCR { PyObject *container_o = PyStackRef_AsPyObjectBorrow(container); - PyObject *sub_o = PyStackRef_AsPyObjectBorrow(sub); + PyObject *sub_o = PyStackRef_AsPyObjectBorrow(sub);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_GetItem(container_o, sub_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -477,11 +478,11 @@ PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st); DEOPT_IF(!PyDict_CheckExact(dict), BINARY_SUBSCR); STAT_INC(BINARY_SUBSCR, hit); - PyObject *res_o; + PyObject *res_o;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int rc = PyDict_GetItemRef(dict, sub, &res_o); stack_pointer = _PyFrame_GetStackPointer(frame); - if (rc == 0) { + if (rc == 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetKeyError(sub); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -690,7 +691,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *map_o = _PyDict_FromItems( values_o, 2, @@ -720,6 +721,7 @@ _PyStackRef *values; _PyStackRef set; values = &stack_pointer[-oparg]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *set_o = PySet_New(NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -735,7 +737,7 @@ } int err = 0; for (int i = 0; i < oparg; i++) { - if (err == 0) { + if (err == 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); err = PySet_Add(set_o, PyStackRef_AsPyObjectBorrow(values[i])); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -872,7 +874,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr; + next_instr = this_instr;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_Call(callable[0], next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -916,7 +918,7 @@ ((PyFunctionObject *)callable_o)->vectorcall == _PyFunction_Vectorcall) { 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)); + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( tstate, callable[0], locals, @@ -946,7 +948,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -957,20 +959,20 @@ if (opcode == INSTRUMENTED_CALL) { PyObject *arg = total_args == 0 ? &_PyInstrumentation_MISSING : PyStackRef_AsPyObjectBorrow(args[0]); - if (res_o == NULL) { + if (res_o == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, callable_o, arg); stack_pointer = _PyFrame_GetStackPointer(frame); } - else { + else {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, callable_o, arg); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { + if (err < 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(res_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -993,7 +995,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1046,7 +1048,7 @@ PyFunctionObject *init_func = (PyFunctionObject *)cls->_spec_cache.init; PyCodeObject *code = (PyCodeObject *)init_func->func_code; DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize + _Py_InitCleanup.co_framesize), CALL); - STAT_INC(CALL, hit); + STAT_INC(CALL, hit);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *self_o = _PyType_NewManagedObject(tp); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1063,13 +1065,13 @@ args = &stack_pointer[-oparg]; self = &stack_pointer[-1 - oparg]; init = &stack_pointer[-2 - oparg]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( - tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame); - assert(_PyCode_CODE(_PyFrame_GetCode(shim))[0].op.code == EXIT_INIT_CHECK); + tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame);/* Escaping */assert(_PyCode_CODE(_PyFrame_GetCode(shim))[0].op.code == EXIT_INIT_CHECK); stack_pointer = _PyFrame_GetStackPointer(frame); /* Push self onto stack of shim */ - shim->localsplus[0] = PyStackRef_DUP(self[0]); + shim->localsplus[0] = PyStackRef_DUP(self[0]);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); init_frame = _PyEvalFramePushAndInit( tstate, init[0], NULL, args-1, oparg+1, NULL, shim); @@ -1268,7 +1270,7 @@ } 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)); + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( tstate, callable[0], locals, @@ -1348,8 +1350,10 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - } + }/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = tp->tp_vectorcall((PyObject *)tp, args_o, total_args, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); /* Free the arguments. */ for (int i = 0; i < total_args; i++) { @@ -1367,7 +1371,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1448,7 +1452,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1508,8 +1512,10 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - } + }/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = cfunc(PyCFunction_GET_SELF(callable_o), args_o, total_args, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); /* Free the arguments. */ @@ -1528,7 +1534,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1577,7 +1583,7 @@ STAT_INC(CALL, hit); PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o); _PyStackRef arg = args[0]; - _Py_EnterRecursiveCallTstateUnchecked(tstate); + _Py_EnterRecursiveCallTstateUnchecked(tstate);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1596,7 +1602,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1639,13 +1645,13 @@ if (PyTuple_CheckExact(callargs_o)) { tuple = callargs; } - else { + else {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { goto error; - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *tuple_o = PySequence_Tuple(callargs_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1674,7 +1680,7 @@ assert(!_PyErr_Occurred(tstate)); if (opcode == INSTRUMENTED_CALL_FUNCTION_EX) { PyObject *arg = PyTuple_GET_SIZE(callargs) > 0 ? - PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING; + PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING;/* Escaping */ stack_pointer[-1 - (oparg & 1)] = callargs_st; if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_st; _PyFrame_SetStackPointer(frame, stack_pointer); @@ -1684,25 +1690,25 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { goto error; - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); result_o = PyObject_Call(func, callargs, kwargs); stack_pointer = _PyFrame_GetStackPointer(frame); if (!PyFunction_Check(func) && !PyMethod_Check(func)) { - if (result_o == NULL) { + if (result_o == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, func, arg); stack_pointer = _PyFrame_GetStackPointer(frame); } - else { + else {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, func, arg); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { + if (err < 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(result_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1717,7 +1723,7 @@ assert(PyTuple_CheckExact(callargs)); Py_ssize_t nargs = PyTuple_GET_SIZE(callargs); int code_flags = ((PyCodeObject *)PyFunction_GET_CODE(func))->co_flags; - PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func)); + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func));/* Escaping */ stack_pointer[-1 - (oparg & 1)] = callargs_st; if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_st; _PyFrame_SetStackPointer(frame, stack_pointer); @@ -1734,13 +1740,13 @@ assert(next_instr - this_instr == 1); frame->return_offset = 1; DISPATCH_INLINED(new_frame); - } + }/* Escaping */ stack_pointer[-1 - (oparg & 1)] = callargs_st; if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_st; _PyFrame_SetStackPointer(frame, stack_pointer); result_o = PyObject_Call(func, callargs, kwargs); stack_pointer = _PyFrame_GetStackPointer(frame); - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_XCLOSE(kwargs_st); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1757,7 +1763,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ stack_pointer[-3 - (oparg & 1)] = result; stack_pointer += -2 - (oparg & 1); assert(WITHIN_STACK_BOUNDS()); @@ -1782,8 +1788,10 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; - assert(oparg <= MAX_INTRINSIC_1); + assert(oparg <= MAX_INTRINSIC_1);/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); if (res_o == NULL) goto pop_1_error; res = PyStackRef_FromPyObjectSteal(res_o); @@ -1802,8 +1810,10 @@ value2_st = stack_pointer[-2]; assert(oparg <= MAX_INTRINSIC_2); PyObject *value1 = PyStackRef_AsPyObjectBorrow(value1_st); - PyObject *value2 = PyStackRef_AsPyObjectBorrow(value2_st); + PyObject *value2 = PyStackRef_AsPyObjectBorrow(value2_st);/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value2_st); PyStackRef_CLOSE(value1_st); if (res_o == NULL) goto pop_2_error; @@ -1840,7 +1850,7 @@ DEOPT_IF(callable_o != interp->callable_cache.isinstance, CALL); STAT_INC(CALL, hit); _PyStackRef cls_stackref = args[1]; - _PyStackRef inst_stackref = args[0]; + _PyStackRef inst_stackref = args[0];/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1882,7 +1892,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr; + next_instr = this_instr;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_CallKw(callable[0], next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1931,7 +1941,7 @@ ((PyFunctionObject *)callable_o)->vectorcall == _PyFunction_Vectorcall) { 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)); + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));/* Escaping */ stack_pointer[-1] = kwnames; _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( @@ -1966,7 +1976,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - } + }/* Escaping */ stack_pointer[-1] = kwnames; _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( @@ -1978,20 +1988,20 @@ if (opcode == INSTRUMENTED_CALL_KW) { PyObject *arg = total_args == 0 ? &_PyInstrumentation_MISSING : PyStackRef_AsPyObjectBorrow(args[0]); - if (res_o == NULL) { + if (res_o == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, callable_o, arg); stack_pointer = _PyFrame_GetStackPointer(frame); } - else { + else {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, callable_o, arg); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { + if (err < 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(res_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2078,7 +2088,7 @@ int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); 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)); + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( tstate, callable[0], locals, @@ -2173,7 +2183,7 @@ } } PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); - int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); + int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -2198,7 +2208,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ stack_pointer[-3 - oparg] = res; stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2256,7 +2266,7 @@ int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); 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)); + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( tstate, callable[0], locals, @@ -2328,13 +2338,13 @@ DEOPT_IF(callable_o != interp->callable_cache.len, CALL); STAT_INC(CALL, hit); _PyStackRef arg_stackref = args[0]; - PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref); + PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (len_i < 0) { goto error; - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyLong_FromSsize_t(len_i); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2432,8 +2442,10 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - } + }/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = cfunc(self, (args_o + 1), nargs); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); /* Clear the stack of the arguments. */ @@ -2452,7 +2464,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2515,8 +2527,10 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - } + }/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = cfunc(self, (args_o + 1), nargs, NULL); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); /* Free the arguments. */ @@ -2535,7 +2549,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2588,7 +2602,7 @@ DEOPT_IF(tstate->c_recursion_remaining <= 0, CALL); STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; - _Py_EnterRecursiveCallTstateUnchecked(tstate); + _Py_EnterRecursiveCallTstateUnchecked(tstate);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2607,7 +2621,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2660,7 +2674,7 @@ method->d_common.d_type), CALL); STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; - _Py_EnterRecursiveCallTstateUnchecked(tstate); + _Py_EnterRecursiveCallTstateUnchecked(tstate);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyStackRef_AsPyObjectBorrow(self_stackref), @@ -2682,7 +2696,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2744,7 +2758,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -2768,7 +2782,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2903,7 +2917,7 @@ } 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)); + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( tstate, callable[0], locals, @@ -2966,7 +2980,7 @@ assert(oparg == 1); DEOPT_IF(!PyStackRef_IsNull(null), CALL); DEOPT_IF(callable_o != (PyObject *)&PyUnicode_Type, CALL); - STAT_INC(CALL, hit); + STAT_INC(CALL, hit);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2977,7 +2991,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ stack_pointer[-3] = res; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -3016,7 +3030,7 @@ assert(oparg == 1); DEOPT_IF(!PyStackRef_IsNull(null), CALL); DEOPT_IF(callable_o != (PyObject *)&PyTuple_Type, CALL); - STAT_INC(CALL, hit); + STAT_INC(CALL, hit);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3027,7 +3041,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ stack_pointer[-3] = res; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -3084,7 +3098,7 @@ match_type_st = stack_pointer[-1]; exc_value_st = stack_pointer[-2]; PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st); - PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st); + PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3094,7 +3108,7 @@ if (true) goto pop_2_error; } PyObject *match_o = NULL; - PyObject *rest_o = NULL; + PyObject *rest_o = NULL;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_ExceptionGroupMatch(exc_value, match_type, &match_o, &rest_o); @@ -3104,7 +3118,7 @@ if (res < 0) goto pop_2_error; assert((match_o == NULL) == (rest_o == NULL)); if (match_o == NULL) goto pop_2_error; - if (!Py_IsNone(match_o)) { + if (!Py_IsNone(match_o)) {/* Escaping */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -3131,14 +3145,14 @@ left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyExceptionInstance_Check(left_o)); + assert(PyExceptionInstance_Check(left_o));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyEval_CheckExceptTypeValid(tstate, right_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { PyStackRef_CLOSE(right); if (true) goto pop_1_error; - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyErr_GivenExceptionMatches(left_o, right_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3163,7 +3177,7 @@ sub_iter_st = stack_pointer[-3]; PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st); assert(throwflag); - assert(exc_value && PyExceptionInstance_Check(exc_value)); + assert(exc_value && PyExceptionInstance_Check(exc_value));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int matches = PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3174,10 +3188,9 @@ PyStackRef_CLOSE(last_sent_val_st); PyStackRef_CLOSE(exc_value_st); } - else { + else {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_SetRaisedException(tstate, Py_NewRef(exc_value)); - monitor_reraise(tstate, frame, this_instr); + _PyErr_SetRaisedException(tstate, Py_NewRef(exc_value));/* Escaping */monitor_reraise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; } @@ -3206,7 +3219,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr; + next_instr = this_instr;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_CompareOp(left, right, next_instr, oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3220,14 +3233,14 @@ { PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert((oparg >> 5) <= Py_GE); + assert((oparg >> 5) <= Py_GE);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res_o == NULL) goto pop_2_error; - if (oparg & 16) { + if (oparg & 16) {/* Escaping */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -3385,7 +3398,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr; + next_instr = this_instr;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_ContainsOp(right, next_instr); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3399,7 +3412,7 @@ { left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int res = PySequence_Contains(right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3428,7 +3441,7 @@ PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyDict_CheckExact(right_o), CONTAINS_OP); - STAT_INC(CONTAINS_OP, hit); + STAT_INC(CONTAINS_OP, hit);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyDict_Contains(right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3457,7 +3470,7 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!(PySet_CheckExact(right_o) || PyFrozenSet_CheckExact(right_o)), CONTAINS_OP); STAT_INC(CONTAINS_OP, hit); - // Note: both set and frozenset use the same seq_contains method! + // Note: both set and frozenset use the same seq_contains method!/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PySet_Contains((PySetObject *)right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3480,8 +3493,10 @@ value = stack_pointer[-1]; conversion_func conv_fn; assert(oparg >= FVC_STR && oparg <= FVC_ASCII); - conv_fn = _PyEval_ConversionFuncs[oparg]; + conv_fn = _PyEval_ConversionFuncs[oparg];/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value)); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(value); if (result_o == NULL) goto pop_1_error; result = PyStackRef_FromPyObjectSteal(result_o); @@ -3528,7 +3543,7 @@ INSTRUCTION_STATS(DELETE_ATTR); _PyStackRef owner; owner = stack_pointer[-1]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3545,11 +3560,11 @@ INSTRUCTION_STATS(DELETE_DEREF); PyObject *cell = PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); // Can't use ERROR_IF here. - // Fortunately we don't need its superpower. + // Fortunately we don't need its superpower./* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *oldobj = PyCell_SwapTakeRef((PyCellObject *)cell, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); - if (oldobj == NULL) { + if (oldobj == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3564,7 +3579,7 @@ next_instr += 1; INSTRUCTION_STATS(DELETE_FAST); _PyStackRef v = GETLOCAL(oparg); - if (PyStackRef_IsNull(v)) { + if (PyStackRef_IsNull(v)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError, UNBOUNDLOCAL_ERROR_MSG, @@ -3581,7 +3596,7 @@ frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(DELETE_GLOBAL); - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_Pop(GLOBALS(), name, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3589,7 +3604,7 @@ if (err < 0) { goto error; } - if (err == 0) { + if (err == 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, name); @@ -3606,18 +3621,18 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); PyObject *ns = LOCALS(); int err; - if (ns == NULL) { + if (ns == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals when deleting %R", name); stack_pointer = _PyFrame_GetStackPointer(frame); goto error; - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_DelItem(ns, name); stack_pointer = _PyFrame_GetStackPointer(frame); // Can't use ERROR_IF here. - if (err != 0) { + if (err != 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, @@ -3636,7 +3651,7 @@ _PyStackRef sub; sub = stack_pointer[-1]; container = stack_pointer[-2]; - /* del container[sub] */ + /* del container[sub] *//* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub)); @@ -3661,11 +3676,11 @@ callable = stack_pointer[-5 - (oparg - 1)]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); - PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); + PyObject *update_o = PyStackRef_AsPyObjectBorrow(update);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_MergeEx(dict_o, update_o, 2); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { + if (err < 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatKwargsError(tstate, callable_o, update_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3687,15 +3702,15 @@ update = stack_pointer[-1]; dict = stack_pointer[-2 - (oparg - 1)]; PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); - PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); + PyObject *update_o = PyStackRef_AsPyObjectBorrow(update);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_Update(dict_o, update_o); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { + if (err < 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_AttributeError); stack_pointer = _PyFrame_GetStackPointer(frame); - if (matches) { + if (matches) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'%.200s' object is not a mapping", @@ -3721,7 +3736,7 @@ exc_st = stack_pointer[-1]; awaitable_st = stack_pointer[-2]; PyObject *exc = PyStackRef_AsPyObjectBorrow(exc_st); - assert(exc && PyExceptionInstance_Check(exc)); + assert(exc && PyExceptionInstance_Check(exc));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int matches = PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3730,10 +3745,9 @@ PyStackRef_CLOSE(exc_st); } else { - Py_INCREF(exc); + Py_INCREF(exc);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_SetRaisedException(tstate, exc); - monitor_reraise(tstate, frame, this_instr); + _PyErr_SetRaisedException(tstate, exc);/* Escaping */monitor_reraise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; } @@ -3812,7 +3826,7 @@ _PyStackRef should_be_none; should_be_none = stack_pointer[-1]; assert(STACK_LEVEL() == 2); - if (!PyStackRef_Is(should_be_none, PyStackRef_None)) { + if (!PyStackRef_Is(should_be_none, PyStackRef_None)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyErr_Format(PyExc_TypeError, "__init__() should return None, not '%.200s'", @@ -3846,7 +3860,7 @@ PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); /* If value is a unicode object, then we know the result * of format(value) is value itself. */ - if (!PyUnicode_CheckExact(value_o)) { + if (!PyUnicode_CheckExact(value_o)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Format(value_o, NULL)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3869,6 +3883,7 @@ _PyStackRef res; fmt_spec = stack_pointer[-1]; value = stack_pointer[-2]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3898,7 +3913,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr; + next_instr = this_instr;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_ForIter(iter, next_instr, oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3914,16 +3929,15 @@ PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); PyObject *next_o = (*Py_TYPE(iter_o)->tp_iternext)(iter_o); if (next_o == NULL) { - if (_PyErr_Occurred(tstate)) { + if (_PyErr_Occurred(tstate)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); stack_pointer = _PyFrame_GetStackPointer(frame); if (!matches) { goto error; - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); - _PyEval_MonitorRaise(tstate, frame, this_instr); - _PyErr_Clear(tstate); + _PyEval_MonitorRaise(tstate, frame, this_instr);/* Escaping */_PyErr_Clear(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); } /* iterator ended normally */ @@ -4150,7 +4164,7 @@ if (type->tp_as_async != NULL) { getter = type->tp_as_async->am_aiter; } - if (getter == NULL) { + if (getter == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'async for' requires an object with " @@ -4164,7 +4178,7 @@ PyStackRef_CLOSE(obj); if (iter_o == NULL) goto pop_1_error; if (Py_TYPE(iter_o)->tp_as_async == NULL || - Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) { + Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) {/* Escaping */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -4188,6 +4202,7 @@ _PyStackRef aiter; _PyStackRef awaitable; aiter = stack_pointer[-1]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *awaitable_o = _PyEval_GetANext(PyStackRef_AsPyObjectBorrow(aiter)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4208,6 +4223,7 @@ _PyStackRef iterable; _PyStackRef iter; iterable = stack_pointer[-1]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4225,7 +4241,7 @@ _PyStackRef iterable; _PyStackRef iter; iterable = stack_pointer[-1]; - /* before: [obj]; after [getiter(obj)] */ + /* before: [obj]; after [getiter(obj)] *//* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable))); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4242,11 +4258,12 @@ _PyStackRef obj; _PyStackRef len; obj = stack_pointer[-1]; - // PUSH(len(TOS)) + // PUSH(len(TOS))/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj)); stack_pointer = _PyFrame_GetStackPointer(frame); if (len_i < 0) goto error; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *len_o = PyLong_FromSsize_t(len_i); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4271,7 +4288,7 @@ /* `iterable` is a coroutine */ if (!(_PyFrame_GetCode(frame)->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) { /* and it is used in a 'yield from' expression of a - regular generator. */ + regular generator. *//* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_TypeError, "cannot 'yield from' a coroutine object " @@ -4285,7 +4302,7 @@ iter = iterable; } else { - /* `iterable` is not a generator. */ + /* `iterable` is not a generator. *//* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4305,7 +4322,7 @@ _PyStackRef from; _PyStackRef res; from = stack_pointer[-1]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4326,7 +4343,7 @@ _PyStackRef res; fromlist = stack_pointer[-1]; level = stack_pointer[-2]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_ImportName(tstate, frame, name, PyStackRef_AsPyObjectBorrow(fromlist), @@ -4388,6 +4405,7 @@ else { arg0 = &_PyInstrumentation_MISSING; } + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, @@ -4413,7 +4431,7 @@ ((PyFunctionObject *)callable_o)->vectorcall == _PyFunction_Vectorcall) { 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)); + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( tstate, callable[0], locals, @@ -4443,7 +4461,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -4454,20 +4472,20 @@ if (opcode == INSTRUMENTED_CALL) { PyObject *arg = total_args == 0 ? &_PyInstrumentation_MISSING : PyStackRef_AsPyObjectBorrow(args[0]); - if (res_o == NULL) { + if (res_o == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, callable_o, arg); stack_pointer = _PyFrame_GetStackPointer(frame); } - else { + else {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, callable_o, arg); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { + if (err < 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(res_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4490,7 +4508,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -4528,7 +4546,7 @@ int total_args = oparg + is_meth; PyObject *function = PyStackRef_AsPyObjectBorrow(PEEK(oparg + 3)); PyObject *arg = total_args == 0 ? &_PyInstrumentation_MISSING - : PyStackRef_AsPyObjectBorrow(PEEK(total_args + 1)); + : PyStackRef_AsPyObjectBorrow(PEEK(total_args + 1));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, @@ -4550,7 +4568,7 @@ receiver = stack_pointer[-2]; /* Need to create a fake StopIteration error here, * to conform to PEP 380 */ - if (PyStackRef_GenCheck(receiver)) { + if (PyStackRef_GenCheck(receiver)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4575,7 +4593,7 @@ value = stack_pointer[-1]; receiver = stack_pointer[-2]; PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver); - if (PyGen_Check(receiver_o) || PyCoro_CheckExact(receiver_o)) { + if (PyGen_Check(receiver_o) || PyCoro_CheckExact(receiver_o)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4606,16 +4624,15 @@ target = next_instr; } else { - if (_PyErr_Occurred(tstate)) { + if (_PyErr_Occurred(tstate)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); stack_pointer = _PyFrame_GetStackPointer(frame); if (!matches) { goto error; - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); - _PyEval_MonitorRaise(tstate, frame, this_instr); - _PyErr_Clear(tstate); + _PyEval_MonitorRaise(tstate, frame, this_instr);/* Escaping */_PyErr_Clear(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); } /* iterator ended normally */ @@ -4635,6 +4652,7 @@ (void)this_instr; next_instr += 1; INSTRUCTION_STATS(INSTRUMENTED_INSTRUCTION); + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int next_opcode = _Py_call_instrumentation_instruction( tstate, frame, this_instr); @@ -4659,7 +4677,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4690,12 +4708,12 @@ INSTRUCTION_STATS(INSTRUMENTED_LINE); int original_opcode = 0; if (tstate->tracing) { - PyCodeObject *code = _PyFrame_GetCode(frame); + PyCodeObject *code = _PyFrame_GetCode(frame);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); original_opcode = code->_co_monitoring->lines[(int)(this_instr - _PyCode_CODE(code))].original_opcode; stack_pointer = _PyFrame_GetStackPointer(frame); next_instr = this_instr; - } else { + } else {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); original_opcode = _Py_call_instrumentation_line( tstate, frame, this_instr, prev_instr); @@ -4823,7 +4841,7 @@ if (tstate->tracing == 0) { uintptr_t global_version = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & ~_PY_EVAL_EVENTS_MASK; uintptr_t code_version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version); - if (code_version != global_version) { + if (code_version != global_version) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_Instrument(_PyFrame_GetCode(frame), tstate->interp); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4840,7 +4858,7 @@ if ((oparg & RESUME_OPARG_LOCATION_MASK) < RESUME_AFTER_YIELD_FROM) { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4850,6 +4868,7 @@ } // _MONITOR_RESUME { + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation( tstate, oparg > 0, frame, this_instr); @@ -4879,6 +4898,7 @@ // _RETURN_VALUE_EVENT { val = value; + /* Escaping */ stack_pointer[0] = val; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -4927,6 +4947,7 @@ // _RETURN_VALUE_EVENT { val = stack_pointer[-1]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_arg( tstate, PY_MONITORING_EVENT_PY_RETURN, @@ -4972,6 +4993,7 @@ // _YIELD_VALUE_EVENT { val = stack_pointer[-1]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_arg( tstate, PY_MONITORING_EVENT_PY_YIELD, @@ -4994,7 +5016,7 @@ #if TIER_ONE assert(frame != &entry_frame); #endif - frame->instr_ptr++; + frame->instr_ptr++;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5038,7 +5060,7 @@ INSTRUCTION_STATS(INTERPRETER_EXIT); _PyStackRef retval; retval = stack_pointer[-1]; - assert(frame == &entry_frame); + assert(frame == &entry_frame);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); assert(_PyFrame_IsIncomplete(frame)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5085,7 +5107,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5108,7 +5130,7 @@ oparg >>= 8; start--; } - _PyExecutorObject *executor; + _PyExecutorObject *executor;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int optimized = _PyOptimizer_Optimize(frame, start, stack_pointer, &executor, 0); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5118,8 +5140,10 @@ tstate->previous_executor = Py_None; GOTO_TIER_TWO(executor); } - else { + else {/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); this_instr[1].counter = restart_backoff_counter(counter); + stack_pointer = _PyFrame_GetStackPointer(frame); } } else { @@ -5177,20 +5201,19 @@ iterable_st = stack_pointer[-1]; list_st = stack_pointer[-2 - (oparg-1)]; PyObject *list = PyStackRef_AsPyObjectBorrow(list_st); - PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st); + PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable); stack_pointer = _PyFrame_GetStackPointer(frame); - if (none_val == NULL) { + if (none_val == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_TypeError); stack_pointer = _PyFrame_GetStackPointer(frame); if (matches && (Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable))) - { + {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_Clear(tstate); - _PyErr_Format(tstate, PyExc_TypeError, + _PyErr_Clear(tstate);/* Escaping */_PyErr_Format(tstate, PyExc_TypeError, "Value after * must be an iterable, not %.200s", Py_TYPE(iterable)->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5223,7 +5246,7 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); - next_instr = this_instr; + next_instr = this_instr;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_LoadAttr(owner, next_instr, name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5240,7 +5263,7 @@ PyObject *attr_o; if (oparg & 1) { /* Designed to work in tandem with CALL, pushes two values. */ - attr_o = NULL; + attr_o = NULL;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int is_meth = _PyObject_GetMethod(PyStackRef_AsPyObjectBorrow(owner), name, &attr_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5265,7 +5288,7 @@ } } else { - /* Classic, pushes one value. */ + /* Classic, pushes one value. *//* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5842,12 +5865,12 @@ next_instr += 1; INSTRUCTION_STATS(LOAD_BUILD_CLASS); _PyStackRef bc; - PyObject *bc_o; + PyObject *bc_o;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) goto error; - if (bc_o == NULL) { + if (bc_o == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_NameError, "__build_class__ not found"); @@ -5904,7 +5927,7 @@ _PyStackRef value; PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); PyObject *value_o = PyCell_GetRef(cell); - if (value_o == NULL) { + if (value_o == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5950,7 +5973,7 @@ INSTRUCTION_STATS(LOAD_FAST_CHECK); _PyStackRef value; _PyStackRef value_s = GETLOCAL(oparg); - if (PyStackRef_IsNull(value_s)) { + if (PyStackRef_IsNull(value_s)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError, UNBOUNDLOCAL_ERROR_MSG, @@ -5995,7 +6018,7 @@ PyObject *class_dict = PyStackRef_AsPyObjectBorrow(class_dict_st); assert(class_dict); assert(oparg >= 0 && oparg < _PyFrame_GetCode(frame)->co_nlocalsplus); - name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg); + name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(class_dict, name, &value_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6005,7 +6028,7 @@ if (!value_o) { PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); value_o = PyCell_GetRef(cell); - if (value_o == NULL) { + if (value_o == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6026,7 +6049,7 @@ _PyStackRef v; mod_or_class_dict = stack_pointer[-1]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - PyObject *v_o; + PyObject *v_o;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &v_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6035,7 +6058,7 @@ if (v_o == NULL) { if (PyDict_CheckExact(GLOBALS()) && PyDict_CheckExact(BUILTINS())) - { + {/* Escaping */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -6046,7 +6069,7 @@ if (v_o == NULL) { if (!_PyErr_Occurred(tstate)) { /* _PyDict_LoadGlobal() returns NULL without raising - * an exception if the key doesn't exist */ + * an exception if the key doesn't exist *//* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, name); @@ -6057,7 +6080,7 @@ } else { /* Slow-path if globals or builtins is not a dict */ - /* namespace 1: globals */ + /* namespace 1: globals *//* Escaping */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -6065,12 +6088,12 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) goto error; if (v_o == NULL) { - /* namespace 2: builtins */ + /* namespace 2: builtins *//* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(BUILTINS(), name, &v_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) goto error; - if (v_o == NULL) { + if (v_o == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg( tstate, PyExc_NameError, @@ -6104,7 +6127,7 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); - next_instr = this_instr; + next_instr = this_instr;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_LoadGlobal(GLOBALS(), BUILTINS(), next_instr, name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6120,7 +6143,7 @@ // _LOAD_GLOBAL { res = &stack_pointer[0]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_LoadGlobalStackRef(GLOBALS(), BUILTINS(), name, res); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6218,7 +6241,7 @@ INSTRUCTION_STATS(LOAD_LOCALS); _PyStackRef locals; PyObject *l = LOCALS(); - if (l == NULL) { + if (l == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_SystemError, "no locals found"); @@ -6237,7 +6260,7 @@ next_instr += 1; INSTRUCTION_STATS(LOAD_NAME); _PyStackRef v; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *v_o = _PyEval_LoadName(tstate, frame, name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6260,14 +6283,14 @@ assert(oparg <= SPECIAL_MAX); PyObject *owner_o = PyStackRef_AsPyObjectSteal(owner); PyObject *name = _Py_SpecialMethods[oparg].name; - PyObject *self_or_null_o; + PyObject *self_or_null_o;/* Escaping */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); attr = PyStackRef_FromPyObjectSteal(_PyObject_LookupSpecialMethod(owner_o, name, &self_or_null_o)); stack_pointer = _PyFrame_GetStackPointer(frame); if (PyStackRef_IsNull(attr)) { - if (!_PyErr_Occurred(tstate)) { + if (!_PyErr_Occurred(tstate)) {/* Escaping */ stack_pointer[0] = attr; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6315,7 +6338,7 @@ #if ENABLE_SPECIALIZATION int load_method = oparg & 1; if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr; + next_instr = this_instr;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_LoadSuperAttr(global_super_st, class_st, next_instr, load_method); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6332,7 +6355,7 @@ PyObject *class = PyStackRef_AsPyObjectBorrow(class_st); PyObject *self = PyStackRef_AsPyObjectBorrow(self_st); if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) { - PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING; + PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, @@ -6347,26 +6370,26 @@ } // we make no attempt to optimize here; specializations should // handle any case whose performance we care about - PyObject *stack[] = {class, self}; + PyObject *stack[] = {class, self};/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *super = PyObject_Vectorcall(global_super, stack, oparg & 2, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) { PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING; - if (super == NULL) { + if (super == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, global_super, arg); stack_pointer = _PyFrame_GetStackPointer(frame); } - else { + else {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, global_super, arg); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) { + if (err < 0) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(super); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6377,7 +6400,7 @@ PyStackRef_CLOSE(class_st); PyStackRef_CLOSE(self_st); if (super == NULL) goto pop_3_error; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);/* Escaping */ stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -6414,7 +6437,7 @@ DEOPT_IF(global_super != (PyObject *)&PySuper_Type, LOAD_SUPER_ATTR); DEOPT_IF(!PyType_Check(class), LOAD_SUPER_ATTR); STAT_INC(LOAD_SUPER_ATTR, hit); - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6452,7 +6475,7 @@ STAT_INC(LOAD_SUPER_ATTR, hit); PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); PyTypeObject *cls = (PyTypeObject *)class; - int method_found = 0; + int method_found = 0;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attr_o = _PySuper_Lookup(cls, self, name, Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? &method_found : NULL); @@ -6499,13 +6522,14 @@ _PyStackRef codeobj_st; _PyStackRef func; codeobj_st = stack_pointer[-1]; - PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st); + PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyFunctionObject *func_obj = (PyFunctionObject *) PyFunction_New(codeobj, GLOBALS()); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(codeobj_st); if (func_obj == NULL) goto pop_1_error; + /* Escaping */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -6532,7 +6556,7 @@ PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st); assert(PyDict_CheckExact(dict)); /* dict[key] = value */ - // Do not DECREF INPUTS because the function steals the references + // Do not DECREF INPUTS because the function steals the references/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_SetItem_Take2( (PyDictObject *)dict, @@ -6559,7 +6583,7 @@ subject = stack_pointer[-3]; // Pop TOS and TOS1. Set TOS to a tuple of attributes on success, or // None on failure. - assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names))); + assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names)));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attrs_o = _PyEval_MatchClass(tstate, PyStackRef_AsPyObjectBorrow(subject), @@ -6593,7 +6617,7 @@ _PyStackRef values_or_none; keys = stack_pointer[-1]; subject = stack_pointer[-2]; - // On successful match, PUSH(values). Otherwise, PUSH(None). + // On successful match, PUSH(values). Otherwise, PUSH(None)./* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *values_or_none_o = _PyEval_MatchKeys(tstate, PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys)); @@ -6649,7 +6673,7 @@ INSTRUCTION_STATS(POP_EXCEPT); _PyStackRef exc_value; exc_value = stack_pointer[-1]; - _PyErr_StackItem *exc_info = tstate->exc_info; + _PyErr_StackItem *exc_info = tstate->exc_info;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); Py_XSETREF(exc_info->exc_value, PyStackRef_Is(exc_value, PyStackRef_None) @@ -6826,23 +6850,20 @@ args = &stack_pointer[-oparg]; assert(oparg < 3); PyObject *cause = oparg == 2 ? PyStackRef_AsPyObjectSteal(args[1]) : NULL; - PyObject *exc = oparg > 0 ? PyStackRef_AsPyObjectSteal(args[0]) : NULL; - if (do_raise(tstate, exc, cause)) { - assert(oparg == 0); - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); + PyObject *exc = oparg > 0 ? PyStackRef_AsPyObjectSteal(args[0]) : NULL;/* Escaping */ + stack_pointer += -oparg; + assert(WITHIN_STACK_BOUNDS()); + _PyFrame_SetStackPointer(frame, stack_pointer); + int err = do_raise(tstate, exc, cause); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (err) { + assert(oparg == 0);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); monitor_reraise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; } - if (true) { - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); - goto error; - } - stack_pointer += -oparg; - assert(WITHIN_STACK_BOUNDS()); + if (true) goto error; } TARGET(RERAISE) { @@ -6858,7 +6879,7 @@ assert(oparg >= 0 && oparg <= 2); if (oparg) { PyObject *lasti = PyStackRef_AsPyObjectBorrow(values[0]); - if (PyLong_Check(lasti)) { + if (PyLong_Check(lasti)) {/* Escaping */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -6866,7 +6887,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); assert(!_PyErr_Occurred(tstate)); } - else { + else {/* Escaping */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -6878,12 +6899,11 @@ stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); } - assert(exc && PyExceptionInstance_Check(exc)); + assert(exc && PyExceptionInstance_Check(exc));/* Escaping */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_SetRaisedException(tstate, exc); - monitor_reraise(tstate, frame, this_instr); + _PyErr_SetRaisedException(tstate, exc);/* Escaping */monitor_reraise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; } @@ -6909,7 +6929,7 @@ if (tstate->tracing == 0) { uintptr_t global_version = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & ~_PY_EVAL_EVENTS_MASK; uintptr_t code_version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version); - if (code_version != global_version) { + if (code_version != global_version) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_Instrument(_PyFrame_GetCode(frame), tstate->interp); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6934,7 +6954,7 @@ if ((oparg & RESUME_OPARG_LOCATION_MASK) < RESUME_AFTER_YIELD_FROM) { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7003,7 +7023,7 @@ INSTRUCTION_STATS(RETURN_GENERATOR); _PyStackRef res; assert(PyStackRef_FunctionCheck(frame->f_funcobj)); - PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj); + PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7011,13 +7031,13 @@ assert(EMPTY()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *gen_frame = &gen->gi_iframe; - frame->instr_ptr++;/* Virtual flush 1 */ + frame->instr_ptr++;/* Escaping *//* Virtual flush 1 */ _PyFrame_Copy(frame, gen_frame);/* Virtual reload 1 */ assert(frame->frame_obj == NULL); gen->gi_frame_state = FRAME_CREATED; gen_frame->owner = FRAME_OWNED_BY_GENERATOR; _Py_LeaveRecursiveCallPy(tstate); - _PyInterpreterFrame *prev = frame->previous;/* Virtual flush 1 */ + _PyInterpreterFrame *prev = frame->previous;/* Escaping *//* Virtual flush 1 */ _PyThreadState_PopFrame(tstate, frame);/* Virtual reload 1 */ frame = tstate->current_frame = prev; LOAD_IP(frame->return_offset); @@ -7077,7 +7097,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr; + next_instr = this_instr;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_Send(receiver, next_instr); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7110,25 +7130,27 @@ gen_frame->previous = frame; DISPATCH_INLINED(gen_frame); } - if (PyStackRef_Is(v, PyStackRef_None) && PyIter_Check(receiver_o)) { + if (PyStackRef_Is(v, PyStackRef_None) && PyIter_Check(receiver_o)) {/* Escaping */ + _PyFrame_SetStackPointer(frame, stack_pointer); retval_o = Py_TYPE(receiver_o)->tp_iternext(receiver_o); + stack_pointer = _PyFrame_GetStackPointer(frame); } - else { + else {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); retval_o = PyObject_CallMethodOneArg(receiver_o, &_Py_ID(send), PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); } - if (retval_o == NULL) { + if (retval_o == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); stack_pointer = _PyFrame_GetStackPointer(frame); - if (matches) { + if (matches) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_MonitorRaise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); - } + }/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyGen_FetchStopIterationValue(&retval_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7205,23 +7227,24 @@ next_instr += 1; INSTRUCTION_STATS(SETUP_ANNOTATIONS); PyObject *ann_dict; - if (LOCALS() == NULL) { + if (LOCALS() == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when setting up annotations"); stack_pointer = _PyFrame_GetStackPointer(frame); if (true) goto error; } - /* check if __annotations__ in locals()... */ + /* check if __annotations__ in locals()... *//* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) goto error; - if (ann_dict == NULL) { + if (ann_dict == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); ann_dict = PyDict_New(); stack_pointer = _PyFrame_GetStackPointer(frame); if (ann_dict == NULL) goto error; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__), ann_dict); @@ -7243,6 +7266,7 @@ _PyStackRef v; v = stack_pointer[-1]; set = stack_pointer[-2 - (oparg-1)]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PySet_Add(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(v)); @@ -7286,6 +7310,7 @@ _PyStackRef iterable; iterable = stack_pointer[-1]; set = stack_pointer[-2 - (oparg-1)]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(iterable)); @@ -7314,7 +7339,7 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - next_instr = this_instr; + next_instr = this_instr;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_StoreAttr(owner, next_instr, name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7328,7 +7353,7 @@ // _STORE_ATTR { v = stack_pointer[-2]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner), name, PyStackRef_AsPyObjectBorrow(v)); @@ -7457,13 +7482,13 @@ PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dict->ma_keys) + hint; DEOPT_IF(ep->me_key != name, STORE_ATTR); /* Ensure dict is GC tracked if it needs to be */ - if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(PyStackRef_AsPyObjectBorrow(value))) { + if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(PyStackRef_AsPyObjectBorrow(value))) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyObject_GC_TRACK(dict); stack_pointer = _PyFrame_GetStackPointer(frame); } old_value = ep->me_value; - PyDict_WatchEvent event = old_value == NULL ? PyDict_EVENT_ADDED : PyDict_EVENT_MODIFIED; + PyDict_WatchEvent event = old_value == NULL ? PyDict_EVENT_ADDED : PyDict_EVENT_MODIFIED;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); new_version = _PyDict_NotifyEvent(tstate->interp, event, dict, name, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7486,7 +7511,7 @@ INSTRUCTION_STATS(STORE_DEREF); _PyStackRef v; v = stack_pointer[-1]; - PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); + PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7545,7 +7570,7 @@ INSTRUCTION_STATS(STORE_GLOBAL); _PyStackRef v; v = stack_pointer[-1]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7565,7 +7590,7 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); PyObject *ns = LOCALS(); int err; - if (ns == NULL) { + if (ns == NULL) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when storing %R", name); @@ -7573,12 +7598,12 @@ PyStackRef_CLOSE(v); if (true) goto pop_1_error; } - if (PyDict_CheckExact(ns)) { + if (PyDict_CheckExact(ns)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); } - else { + else {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7611,6 +7636,7 @@ start = stack_pointer[-2]; container = stack_pointer[-3]; v = stack_pointer[-4]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); @@ -7619,7 +7645,7 @@ if (slice == NULL) { err = 1; } - else { + else {/* Escaping */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -7656,7 +7682,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr; + next_instr = this_instr;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_StoreSubscr(container, sub, next_instr); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7669,7 +7695,7 @@ // _STORE_SUBSCR { v = stack_pointer[-3]; - /* container[sub] = v */ + /* container[sub] = v *//* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7697,7 +7723,7 @@ value = stack_pointer[-3]; PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st); DEOPT_IF(!PyDict_CheckExact(dict), STORE_SUBSCR); - STAT_INC(STORE_SUBSCR, hit); + STAT_INC(STORE_SUBSCR, hit);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_SetItem_Take2((PyDictObject *)dict, PyStackRef_AsPyObjectSteal(sub), @@ -7777,7 +7803,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr; + next_instr = this_instr;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_ToBool(value, next_instr); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7790,6 +7816,7 @@ /* Skip 2 cache entries */ // _TO_BOOL { + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7855,7 +7882,7 @@ PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); DEOPT_IF(!PyLong_CheckExact(value_o), TO_BOOL); STAT_INC(TO_BOOL, hit); - if (_PyLong_IsZero((PyLongObject *)value_o)) { + if (_PyLong_IsZero((PyLongObject *)value_o)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7919,7 +7946,7 @@ PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); DEOPT_IF(!PyUnicode_CheckExact(value_o), TO_BOOL); STAT_INC(TO_BOOL, hit); - if (value_o == &_Py_STR(empty)) { + if (value_o == &_Py_STR(empty)) {/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7941,6 +7968,7 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7958,6 +7986,7 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; + /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7990,7 +8019,7 @@ _PyStackRef *right; seq = stack_pointer[-1]; right = &stack_pointer[(oparg & 0xFF)]; - _PyStackRef *top = right + (oparg >> 8); + _PyStackRef *top = right + (oparg >> 8);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -8017,7 +8046,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr; + next_instr = this_instr;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_UnpackSequence(seq, next_instr, oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -8032,7 +8061,7 @@ // _UNPACK_SEQUENCE { output = &stack_pointer[-1]; - _PyStackRef *top = output + oparg; + _PyStackRef *top = output + oparg;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -8142,10 +8171,9 @@ PyObject *exc, *tb; PyObject *val_o = PyStackRef_AsPyObjectBorrow(val); PyObject *exit_func_o = PyStackRef_AsPyObjectBorrow(exit_func); - assert(val_o && PyExceptionInstance_Check(val_o)); + assert(val_o && PyExceptionInstance_Check(val_o));/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); - exc = PyExceptionInstance_Class(val_o); - tb = PyException_GetTraceback(val_o); + exc = PyExceptionInstance_Class(val_o);/* Escaping */tb = PyException_GetTraceback(val_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (tb == NULL) { tb = Py_None; @@ -8156,7 +8184,7 @@ assert(PyStackRef_LongCheck(lasti)); (void)lasti; // Shut up compiler warning if asserts are off PyObject *stack[5] = {NULL, PyStackRef_AsPyObjectBorrow(exit_self), exc, val_o, tb}; - int has_self = !PyStackRef_IsNull(exit_self); + int has_self = !PyStackRef_IsNull(exit_self);/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Vectorcall(exit_func_o, stack + 2 - has_self, (3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL)); @@ -8181,7 +8209,7 @@ #if TIER_ONE assert(frame != &entry_frame); #endif - frame->instr_ptr++; + frame->instr_ptr++;/* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); stack_pointer = _PyFrame_GetStackPointer(frame); diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 954a5007d4e55e..71bfaa03aa163f 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -362,7 +362,7 @@ sym_matches_type(left, &PyFloat_Type) && sym_matches_type(right, &PyFloat_Type)) { assert(PyFloat_CheckExact(sym_get_const(left))); - assert(PyFloat_CheckExact(sym_get_const(right))); + assert(PyFloat_CheckExact(sym_get_const(right)));/* Escaping */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( @@ -397,7 +397,7 @@ sym_matches_type(left, &PyFloat_Type) && sym_matches_type(right, &PyFloat_Type)) { assert(PyFloat_CheckExact(sym_get_const(left))); - assert(PyFloat_CheckExact(sym_get_const(right))); + assert(PyFloat_CheckExact(sym_get_const(right)));/* Escaping */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( @@ -432,7 +432,7 @@ sym_matches_type(left, &PyFloat_Type) && sym_matches_type(right, &PyFloat_Type)) { assert(PyFloat_CheckExact(sym_get_const(left))); - assert(PyFloat_CheckExact(sym_get_const(right))); + assert(PyFloat_CheckExact(sym_get_const(right)));/* Escaping */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( @@ -639,7 +639,7 @@ retval = stack_pointer[-1]; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - ctx->frame->stack_pointer = stack_pointer; + ctx->frame->stack_pointer = stack_pointer;/* Escaping */ frame_pop(ctx); stack_pointer = ctx->frame->stack_pointer; /* Stack space handling */ @@ -648,7 +648,7 @@ int framesize = co->co_framesize; assert(framesize > 0); assert(framesize <= curr_space); - curr_space -= framesize; + curr_space -= framesize;/* Escaping */ co = get_code(this_instr); if (co == NULL) { // might be impossible, but bailing is still safe @@ -1047,7 +1047,7 @@ if (sym_matches_type_version(owner, type_version)) { REPLACE_OP(this_instr, _NOP, 0, 0); } else { - // add watcher so that whenever the type changes we invalidate this + // add watcher so that whenever the type changes we invalidate this/* Escaping */ PyTypeObject *type = _PyType_LookupByVersion(type_version); // if the type is null, it was not found in the cache (there was a conflict) // with the key, in which case we can't trust the version @@ -1056,9 +1056,8 @@ // if it wasn't this means that the type version was previously set to something else // and we set the owner to bottom, so we don't need to add a watcher because we must have // already added one earlier. - if (sym_set_type_version(owner, type_version)) { - PyType_Watch(TYPE_WATCHER_ID, (PyObject *)type); - _Py_BloomFilter_Add(dependencies, type); + if (sym_set_type_version(owner, type_version)) {/* Escaping */ + PyType_Watch(TYPE_WATCHER_ID, (PyObject *)type);/* Escaping */_Py_BloomFilter_Add(dependencies, type); } } } @@ -1095,11 +1094,10 @@ PyObject *cnst = sym_get_const(owner); if (PyModule_CheckExact(cnst)) { PyModuleObject *mod = (PyModuleObject *)cnst; - PyObject *dict = mod->md_dict; + PyObject *dict = mod->md_dict;/* Escaping */ uint64_t watched_mutations = get_mutations(dict); - if (watched_mutations < _Py_MAX_ALLOWED_GLOBALS_MODIFICATIONS) { - PyDict_Watch(GLOBALS_WATCHER_ID, dict); - _Py_BloomFilter_Add(dependencies, dict); + if (watched_mutations < _Py_MAX_ALLOWED_GLOBALS_MODIFICATIONS) {/* Escaping */ + PyDict_Watch(GLOBALS_WATCHER_ID, dict);/* Escaping */_Py_BloomFilter_Add(dependencies, dict); this_instr->opcode = _NOP; } } @@ -1121,12 +1119,18 @@ assert(sym_is_const(owner)); PyModuleObject *mod = (PyModuleObject *)sym_get_const(owner); assert(PyModule_CheckExact(mod)); - PyObject *dict = mod->md_dict; + PyObject *dict = mod->md_dict;/* Escaping */ + stack_pointer[-1] = attr; + if (oparg & 1) stack_pointer[0] = null; + stack_pointer += (oparg & 1); + assert(WITHIN_STACK_BOUNDS()); PyObject *res = convert_global_to_const(this_instr, dict); if (res != NULL) { this_instr[-1].opcode = _POP_TOP; attr = sym_new_const(ctx, res); } + stack_pointer += -(oparg & 1); + assert(WITHIN_STACK_BOUNDS()); } if (attr == NULL) { /* No conversion made. We don't know what `attr` is. */ @@ -1246,7 +1250,7 @@ if (oparg & 16) { res = sym_new_type(ctx, &PyBool_Type); } - else { + else {/* Escaping */ stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); res = _Py_uop_sym_new_not_null(ctx); @@ -1806,13 +1810,17 @@ args--; argcount++; } - if (sym_is_null(self_or_null) || sym_is_not_null(self_or_null)) { + if (sym_is_null(self_or_null) || sym_is_not_null(self_or_null)) {/* Escaping */ + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); new_frame = frame_new(ctx, co, 0, args, argcount); - } else { + } else {/* Escaping */ + stack_pointer += -2 - oparg; + assert(WITHIN_STACK_BOUNDS()); new_frame = frame_new(ctx, co, 0, NULL, 0); } - stack_pointer[-2 - oparg] = (_Py_UopsSymbol *)new_frame; - stack_pointer += -1 - oparg; + stack_pointer[0] = (_Py_UopsSymbol *)new_frame; + stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -1825,7 +1833,7 @@ ctx->frame->stack_pointer = stack_pointer; ctx->frame = new_frame; ctx->curr_frame_depth++; - stack_pointer = new_frame->stack_pointer; + stack_pointer = new_frame->stack_pointer;/* Escaping */ co = get_code(this_instr); if (co == NULL) { // should be about to _EXIT_TRACE anyway @@ -2130,7 +2138,7 @@ case _RETURN_GENERATOR: { _Py_UopsSymbol *res; - ctx->frame->stack_pointer = stack_pointer; + ctx->frame->stack_pointer = stack_pointer;/* Escaping */ frame_pop(ctx); stack_pointer = ctx->frame->stack_pointer; res = sym_new_unknown(ctx); @@ -2140,15 +2148,15 @@ int framesize = co->co_framesize; assert(framesize > 0); assert(framesize <= curr_space); - curr_space -= framesize; + curr_space -= framesize;/* Escaping */ + stack_pointer[0] = res; + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); co = get_code(this_instr); if (co == NULL) { // might be impossible, but bailing is still safe ctx->done = true; } - stack_pointer[0] = res; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -2261,8 +2269,12 @@ flag = stack_pointer[-1]; if (sym_is_const(flag)) { PyObject *value = sym_get_const(flag); - assert(value != NULL); + assert(value != NULL);/* Escaping */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); eliminate_pop_guard(this_instr, value != Py_True); + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); } stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -2274,8 +2286,12 @@ flag = stack_pointer[-1]; if (sym_is_const(flag)) { PyObject *value = sym_get_const(flag); - assert(value != NULL); + assert(value != NULL);/* Escaping */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); eliminate_pop_guard(this_instr, value != Py_False); + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); } stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); @@ -2287,15 +2303,21 @@ flag = stack_pointer[-1]; if (sym_is_const(flag)) { PyObject *value = sym_get_const(flag); - assert(value != NULL); + assert(value != NULL);/* Escaping */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); eliminate_pop_guard(this_instr, !Py_IsNone(value)); } else if (sym_has_type(flag)) { - assert(!sym_matches_type(flag, &_PyNone_Type)); + assert(!sym_matches_type(flag, &_PyNone_Type));/* Escaping */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); eliminate_pop_guard(this_instr, true); + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } @@ -2304,15 +2326,21 @@ flag = stack_pointer[-1]; if (sym_is_const(flag)) { PyObject *value = sym_get_const(flag); - assert(value != NULL); + assert(value != NULL);/* Escaping */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); eliminate_pop_guard(this_instr, Py_IsNone(value)); } else if (sym_has_type(flag)) { - assert(!sym_matches_type(flag, &_PyNone_Type)); + assert(!sym_matches_type(flag, &_PyNone_Type));/* Escaping */ + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); eliminate_pop_guard(this_instr, false); + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); } - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); break; } diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index dc9236f1774adc..71831ef70ab62f 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -534,7 +534,6 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "Py_XDECREF", "Py_REFCNT", "_Py_DECREF_SPECIALIZED", - "DECREF_INPUTS_AND_REUSE_FLOAT", "PyUnicode_Append", "_PyLong_IsZero", "Py_SIZE", @@ -574,8 +573,6 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "PyUnicode_Concat", "PySlice_New", "_Py_LeaveRecursiveCallPy", - "CALL_STAT_INC", - "STAT_INC", "maybe_lltrace_resume_frame", "_PyUnicode_JoinArray", "_PyEval_FrameClearAndPop", @@ -584,9 +581,6 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "PyFloat_AS_DOUBLE", "_PyFrame_PushUnchecked", "Py_FatalError", - "STACKREFS_TO_PYOBJECTS", - "STACKREFS_TO_PYOBJECTS_CLEANUP", - "CONVERSION_FAILED", "_PyList_FromStackRefSteal", "_PyTuple_FromArraySteal", "_PyTuple_FromStackRefSteal", @@ -603,13 +597,12 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "_Py_EnterRecursiveCallTstateUnchecked", "_PyObject_GC_IS_TRACKED", "_PyObject_GC_MAY_BE_TRACKED", - "ADAPTIVE_COUNTER_TRIGGERS", "_PyInterpreterState_GET", "PyType_HasFeature", "_Py_ID", "_Py_DECREF_NO_DEALLOC", - "EMPTY", "assert", + "backoff_counter_triggers", ) def find_stmt_start(node: parser.InstDef, idx: int) -> lexer.Token: @@ -664,7 +657,13 @@ def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, tuple[le break if next_tkn.kind != lexer.LPAREN: continue - if not tkn.text.startswith(("Py", "_Py", "monitor")): + if tkn.text.upper() == tkn.text: + # simple macro + continue + #if not tkn.text.startswith(("Py", "_Py", "monitor")): + # continue + if tkn.text.startswith(("sym_", "optimize_")): + # Optimize functions continue if tkn.text.endswith("Check"): continue diff --git a/Tools/cases_generator/lexer.py b/Tools/cases_generator/lexer.py index d5831593215f76..c6293a77d5ac87 100644 --- a/Tools/cases_generator/lexer.py +++ b/Tools/cases_generator/lexer.py @@ -79,7 +79,7 @@ def choice(*opts: str) -> str: opmap = {pattern.replace("\\", "") or "\\": op for op, pattern in operators.items()} # Macros -macro = r"# *(ifdef|ifndef|undef|define|error|endif|if|else|include|#)" +macro = r"# *(ifdef|ifndef|undef|define|error|endif|if +defined|if|else|include|#)" CMACRO = "CMACRO" id_re = r"[a-zA-Z_][0-9a-zA-Z_]*" From 56b0bd5b791421a2f6e2de299125ba9fa37e2d28 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Mon, 30 Sep 2024 06:27:04 -0700 Subject: [PATCH 41/53] Remove debug statement --- Python/executor_cases.c.h | 295 ++++++++++++----------- Python/generated_cases.c.h | 467 ++++++++++++++++++------------------- Python/optimizer_cases.c.h | 50 ++-- 3 files changed, 398 insertions(+), 414 deletions(-) diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index cb7a858dc2f90f..8668c04ee1bddb 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -15,7 +15,7 @@ case _CHECK_PERIODIC: { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -29,7 +29,7 @@ if ((oparg & RESUME_OPARG_LOCATION_MASK) < RESUME_AFTER_YIELD_FROM) { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -65,7 +65,7 @@ _PyStackRef value; oparg = CURRENT_OPARG(); _PyStackRef value_s = GETLOCAL(oparg); - if (PyStackRef_IsNull(value_s)) {/* Escaping */ + if (PyStackRef_IsNull(value_s)) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError, UNBOUNDLOCAL_ERROR_MSG, @@ -345,7 +345,6 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -371,7 +370,6 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -403,7 +401,7 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(TO_BOOL, hit); - if (_PyLong_IsZero((PyLongObject *)value_o)) {/* Escaping */ + if (_PyLong_IsZero((PyLongObject *)value_o)) { _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -458,7 +456,7 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(TO_BOOL, hit); - if (value_o == &_Py_STR(empty)) {/* Escaping */ + if (value_o == &_Py_STR(empty)) { _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -487,7 +485,6 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -795,7 +792,7 @@ sub = stack_pointer[-1]; container = stack_pointer[-2]; PyObject *container_o = PyStackRef_AsPyObjectBorrow(container); - PyObject *sub_o = PyStackRef_AsPyObjectBorrow(sub);/* Escaping */ + PyObject *sub_o = PyStackRef_AsPyObjectBorrow(sub); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_GetItem(container_o, sub_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -817,7 +814,6 @@ stop = stack_pointer[-1]; start = stack_pointer[-2]; container = stack_pointer[-3]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); @@ -828,7 +824,7 @@ if (slice == NULL) { res_o = NULL; } - else {/* Escaping */ + else { stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -856,7 +852,6 @@ start = stack_pointer[-2]; container = stack_pointer[-3]; v = stack_pointer[-4]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); @@ -865,7 +860,7 @@ if (slice == NULL) { err = 1; } - else {/* Escaping */ + else { stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -1016,11 +1011,11 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(BINARY_SUBSCR, hit); - PyObject *res_o;/* Escaping */ + PyObject *res_o; _PyFrame_SetStackPointer(frame, stack_pointer); int rc = PyDict_GetItemRef(dict, sub, &res_o); stack_pointer = _PyFrame_GetStackPointer(frame); - if (rc == 0) {/* Escaping */ + if (rc == 0) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetKeyError(sub); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1105,7 +1100,6 @@ oparg = CURRENT_OPARG(); v = stack_pointer[-1]; set = stack_pointer[-2 - (oparg-1)]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PySet_Add(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(v)); @@ -1124,7 +1118,7 @@ sub = stack_pointer[-1]; container = stack_pointer[-2]; v = stack_pointer[-3]; - /* container[sub] = v *//* Escaping */ + /* container[sub] = v */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1189,7 +1183,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - STAT_INC(STORE_SUBSCR, hit);/* Escaping */ + STAT_INC(STORE_SUBSCR, hit); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_SetItem_Take2((PyDictObject *)dict, PyStackRef_AsPyObjectSteal(sub), @@ -1207,7 +1201,7 @@ _PyStackRef container; sub = stack_pointer[-1]; container = stack_pointer[-2]; - /* del container[sub] *//* Escaping */ + /* del container[sub] */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub)); @@ -1225,7 +1219,7 @@ _PyStackRef res; oparg = CURRENT_OPARG(); value = stack_pointer[-1]; - assert(oparg <= MAX_INTRINSIC_1);/* Escaping */ + assert(oparg <= MAX_INTRINSIC_1); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1245,7 +1239,7 @@ value2_st = stack_pointer[-2]; assert(oparg <= MAX_INTRINSIC_2); PyObject *value1 = PyStackRef_AsPyObjectBorrow(value1_st); - PyObject *value2 = PyStackRef_AsPyObjectBorrow(value2_st);/* Escaping */ + PyObject *value2 = PyStackRef_AsPyObjectBorrow(value2_st); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1297,7 +1291,7 @@ if (type->tp_as_async != NULL) { getter = type->tp_as_async->am_aiter; } - if (getter == NULL) {/* Escaping */ + if (getter == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'async for' requires an object with " @@ -1311,7 +1305,7 @@ PyStackRef_CLOSE(obj); if (iter_o == NULL) JUMP_TO_ERROR(); if (Py_TYPE(iter_o)->tp_as_async == NULL || - Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) {/* Escaping */ + Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -1332,7 +1326,6 @@ _PyStackRef aiter; _PyStackRef awaitable; aiter = stack_pointer[-1]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *awaitable_o = _PyEval_GetANext(PyStackRef_AsPyObjectBorrow(aiter)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1351,7 +1344,6 @@ _PyStackRef iter; oparg = CURRENT_OPARG(); iterable = stack_pointer[-1]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1404,7 +1396,7 @@ #if TIER_ONE assert(frame != &entry_frame); #endif - frame->instr_ptr++;/* Escaping */ + frame->instr_ptr++; _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1444,7 +1436,7 @@ case _POP_EXCEPT: { _PyStackRef exc_value; exc_value = stack_pointer[-1]; - _PyErr_StackItem *exc_info = tstate->exc_info;/* Escaping */ + _PyErr_StackItem *exc_info = tstate->exc_info; _PyFrame_SetStackPointer(frame, stack_pointer); Py_XSETREF(exc_info->exc_value, PyStackRef_Is(exc_value, PyStackRef_None) @@ -1479,12 +1471,12 @@ case _LOAD_BUILD_CLASS: { _PyStackRef bc; - PyObject *bc_o;/* Escaping */ + PyObject *bc_o; _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) JUMP_TO_ERROR(); - if (bc_o == NULL) {/* Escaping */ + if (bc_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_NameError, "__build_class__ not found"); @@ -1505,7 +1497,7 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); PyObject *ns = LOCALS(); int err; - if (ns == NULL) {/* Escaping */ + if (ns == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when storing %R", name); @@ -1513,12 +1505,12 @@ PyStackRef_CLOSE(v); if (true) JUMP_TO_ERROR(); } - if (PyDict_CheckExact(ns)) {/* Escaping */ + if (PyDict_CheckExact(ns)) { _PyFrame_SetStackPointer(frame, stack_pointer); err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); } - else {/* Escaping */ + else { _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1535,18 +1527,18 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); PyObject *ns = LOCALS(); int err; - if (ns == NULL) {/* Escaping */ + if (ns == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals when deleting %R", name); stack_pointer = _PyFrame_GetStackPointer(frame); JUMP_TO_ERROR(); - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_DelItem(ns, name); stack_pointer = _PyFrame_GetStackPointer(frame); // Can't use ERROR_IF here. - if (err != 0) {/* Escaping */ + if (err != 0) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, @@ -1563,7 +1555,7 @@ oparg = CURRENT_OPARG(); seq = stack_pointer[-1]; output = &stack_pointer[-1]; - _PyStackRef *top = output + oparg;/* Escaping */ + _PyStackRef *top = output + oparg; _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1659,7 +1651,7 @@ oparg = CURRENT_OPARG(); seq = stack_pointer[-1]; right = &stack_pointer[(oparg & 0xFF)]; - _PyStackRef *top = right + (oparg >> 8);/* Escaping */ + _PyStackRef *top = right + (oparg >> 8); _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1676,7 +1668,7 @@ oparg = CURRENT_OPARG(); owner = stack_pointer[-1]; v = stack_pointer[-2]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner), name, PyStackRef_AsPyObjectBorrow(v)); @@ -1693,7 +1685,7 @@ _PyStackRef owner; oparg = CURRENT_OPARG(); owner = stack_pointer[-1]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1708,7 +1700,7 @@ _PyStackRef v; oparg = CURRENT_OPARG(); v = stack_pointer[-1]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1721,7 +1713,7 @@ case _DELETE_GLOBAL: { oparg = CURRENT_OPARG(); - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_Pop(GLOBALS(), name, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1729,7 +1721,7 @@ if (err < 0) { JUMP_TO_ERROR(); } - if (err == 0) {/* Escaping */ + if (err == 0) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, name); @@ -1742,7 +1734,7 @@ case _LOAD_LOCALS: { _PyStackRef locals; PyObject *l = LOCALS(); - if (l == NULL) {/* Escaping */ + if (l == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_SystemError, "no locals found"); @@ -1761,7 +1753,7 @@ case _LOAD_NAME: { _PyStackRef v; oparg = CURRENT_OPARG(); - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *v_o = _PyEval_LoadName(tstate, frame, name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1778,7 +1770,7 @@ _PyStackRef null = PyStackRef_NULL; oparg = CURRENT_OPARG(); res = &stack_pointer[0]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_LoadGlobalStackRef(GLOBALS(), BUILTINS(), name, res); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1869,7 +1861,7 @@ case _DELETE_FAST: { oparg = CURRENT_OPARG(); _PyStackRef v = GETLOCAL(oparg); - if (PyStackRef_IsNull(v)) {/* Escaping */ + if (PyStackRef_IsNull(v)) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError, UNBOUNDLOCAL_ERROR_MSG, @@ -1899,11 +1891,11 @@ oparg = CURRENT_OPARG(); PyObject *cell = PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); // Can't use ERROR_IF here. - // Fortunately we don't need its superpower./* Escaping */ + // Fortunately we don't need its superpower. _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *oldobj = PyCell_SwapTakeRef((PyCellObject *)cell, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); - if (oldobj == NULL) {/* Escaping */ + if (oldobj == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1923,7 +1915,7 @@ PyObject *class_dict = PyStackRef_AsPyObjectBorrow(class_dict_st); assert(class_dict); assert(oparg >= 0 && oparg < _PyFrame_GetCode(frame)->co_nlocalsplus); - name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg);/* Escaping */ + name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(class_dict, name, &value_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1933,7 +1925,7 @@ if (!value_o) { PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); value_o = PyCell_GetRef(cell); - if (value_o == NULL) {/* Escaping */ + if (value_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1951,7 +1943,7 @@ oparg = CURRENT_OPARG(); PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); PyObject *value_o = PyCell_GetRef(cell); - if (value_o == NULL) {/* Escaping */ + if (value_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1968,7 +1960,7 @@ _PyStackRef v; oparg = CURRENT_OPARG(); v = stack_pointer[-1]; - PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));/* Escaping */ + PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); _PyFrame_SetStackPointer(frame, stack_pointer); PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2053,19 +2045,20 @@ iterable_st = stack_pointer[-1]; list_st = stack_pointer[-2 - (oparg-1)]; PyObject *list = PyStackRef_AsPyObjectBorrow(list_st); - PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st);/* Escaping */ + PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable); stack_pointer = _PyFrame_GetStackPointer(frame); - if (none_val == NULL) {/* Escaping */ + if (none_val == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_TypeError); stack_pointer = _PyFrame_GetStackPointer(frame); if (matches && (Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable))) - {/* Escaping */ + { _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_Clear(tstate);/* Escaping */_PyErr_Format(tstate, PyExc_TypeError, + _PyErr_Clear(tstate); + _PyErr_Format(tstate, PyExc_TypeError, "Value after * must be an iterable, not %.200s", Py_TYPE(iterable)->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2086,7 +2079,6 @@ oparg = CURRENT_OPARG(); iterable = stack_pointer[-1]; set = stack_pointer[-2 - (oparg-1)]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(iterable)); @@ -2103,7 +2095,6 @@ _PyStackRef set; oparg = CURRENT_OPARG(); values = &stack_pointer[-oparg]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *set_o = PySet_New(NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2115,7 +2106,7 @@ } int err = 0; for (int i = 0; i < oparg; i++) { - if (err == 0) {/* Escaping */ + if (err == 0) { _PyFrame_SetStackPointer(frame, stack_pointer); err = PySet_Add(set_o, PyStackRef_AsPyObjectBorrow(values[i])); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2144,7 +2135,7 @@ PyStackRef_CLOSE(values[_i]); } if (true) JUMP_TO_ERROR(); - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *map_o = _PyDict_FromItems( values_o, 2, @@ -2165,24 +2156,23 @@ case _SETUP_ANNOTATIONS: { PyObject *ann_dict; - if (LOCALS() == NULL) {/* Escaping */ + if (LOCALS() == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when setting up annotations"); stack_pointer = _PyFrame_GetStackPointer(frame); if (true) JUMP_TO_ERROR(); } - /* check if __annotations__ in locals()... *//* Escaping */ + /* check if __annotations__ in locals()... */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) JUMP_TO_ERROR(); - if (ann_dict == NULL) {/* Escaping */ + if (ann_dict == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); ann_dict = PyDict_New(); stack_pointer = _PyFrame_GetStackPointer(frame); if (ann_dict == NULL) JUMP_TO_ERROR(); - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__), ann_dict); @@ -2203,15 +2193,15 @@ update = stack_pointer[-1]; dict = stack_pointer[-2 - (oparg - 1)]; PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); - PyObject *update_o = PyStackRef_AsPyObjectBorrow(update);/* Escaping */ + PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_Update(dict_o, update_o); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) {/* Escaping */ + if (err < 0) { _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_AttributeError); stack_pointer = _PyFrame_GetStackPointer(frame); - if (matches) {/* Escaping */ + if (matches) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'%.200s' object is not a mapping", @@ -2237,11 +2227,11 @@ callable = stack_pointer[-5 - (oparg - 1)]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); - PyObject *update_o = PyStackRef_AsPyObjectBorrow(update);/* Escaping */ + PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_MergeEx(dict_o, update_o, 2); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) {/* Escaping */ + if (err < 0) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatKwargsError(tstate, callable_o, update_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2265,7 +2255,7 @@ PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st); assert(PyDict_CheckExact(dict)); /* dict[key] = value */ - // Do not DECREF INPUTS because the function steals the references/* Escaping */ + // Do not DECREF INPUTS because the function steals the references _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_SetItem_Take2( (PyDictObject *)dict, @@ -2303,7 +2293,7 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(LOAD_SUPER_ATTR, hit); - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2343,7 +2333,7 @@ STAT_INC(LOAD_SUPER_ATTR, hit); PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); PyTypeObject *cls = (PyTypeObject *)class; - int method_found = 0;/* Escaping */ + int method_found = 0; _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attr_o = _PySuper_Lookup(cls, self, name, Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? &method_found : NULL); @@ -2378,7 +2368,7 @@ PyObject *attr_o; if (oparg & 1) { /* Designed to work in tandem with CALL, pushes two values. */ - attr_o = NULL;/* Escaping */ + attr_o = NULL; _PyFrame_SetStackPointer(frame, stack_pointer); int is_meth = _PyObject_GetMethod(PyStackRef_AsPyObjectBorrow(owner), name, &attr_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2403,7 +2393,7 @@ } } else { - /* Classic, pushes one value. *//* Escaping */ + /* Classic, pushes one value. */ _PyFrame_SetStackPointer(frame, stack_pointer); attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2812,13 +2802,13 @@ JUMP_TO_JUMP_TARGET(); } /* Ensure dict is GC tracked if it needs to be */ - if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(PyStackRef_AsPyObjectBorrow(value))) {/* Escaping */ + if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(PyStackRef_AsPyObjectBorrow(value))) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyObject_GC_TRACK(dict); stack_pointer = _PyFrame_GetStackPointer(frame); } old_value = ep->me_value; - PyDict_WatchEvent event = old_value == NULL ? PyDict_EVENT_ADDED : PyDict_EVENT_MODIFIED;/* Escaping */ + PyDict_WatchEvent event = old_value == NULL ? PyDict_EVENT_ADDED : PyDict_EVENT_MODIFIED; _PyFrame_SetStackPointer(frame, stack_pointer); new_version = _PyDict_NotifyEvent(tstate->interp, event, dict, name, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2861,14 +2851,14 @@ left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert((oparg >> 5) <= Py_GE);/* Escaping */ + assert((oparg >> 5) <= Py_GE); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res_o == NULL) JUMP_TO_ERROR(); - if (oparg & 16) {/* Escaping */ + if (oparg & 16) { stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -3003,7 +2993,7 @@ right = stack_pointer[-1]; left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);/* Escaping */ + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); _PyFrame_SetStackPointer(frame, stack_pointer); int res = PySequence_Contains(right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3031,7 +3021,7 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(CONTAINS_OP, hit); - // Note: both set and frozenset use the same seq_contains method!/* Escaping */ + // Note: both set and frozenset use the same seq_contains method! _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PySet_Contains((PySetObject *)right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3058,7 +3048,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - STAT_INC(CONTAINS_OP, hit);/* Escaping */ + STAT_INC(CONTAINS_OP, hit); _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyDict_Contains(right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3080,7 +3070,7 @@ match_type_st = stack_pointer[-1]; exc_value_st = stack_pointer[-2]; PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st); - PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st);/* Escaping */ + PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3090,7 +3080,7 @@ if (true) JUMP_TO_ERROR(); } PyObject *match_o = NULL; - PyObject *rest_o = NULL;/* Escaping */ + PyObject *rest_o = NULL; _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_ExceptionGroupMatch(exc_value, match_type, &match_o, &rest_o); @@ -3100,7 +3090,7 @@ if (res < 0) JUMP_TO_ERROR(); assert((match_o == NULL) == (rest_o == NULL)); if (match_o == NULL) JUMP_TO_ERROR(); - if (!Py_IsNone(match_o)) {/* Escaping */ + if (!Py_IsNone(match_o)) { stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -3124,14 +3114,14 @@ left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyExceptionInstance_Check(left_o));/* Escaping */ + assert(PyExceptionInstance_Check(left_o)); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyEval_CheckExceptTypeValid(tstate, right_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { PyStackRef_CLOSE(right); if (true) JUMP_TO_ERROR(); - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyErr_GivenExceptionMatches(left_o, right_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3148,7 +3138,7 @@ oparg = CURRENT_OPARG(); fromlist = stack_pointer[-1]; level = stack_pointer[-2]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_ImportName(tstate, frame, name, PyStackRef_AsPyObjectBorrow(fromlist), @@ -3169,7 +3159,7 @@ _PyStackRef res; oparg = CURRENT_OPARG(); from = stack_pointer[-1]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3204,12 +3194,11 @@ _PyStackRef obj; _PyStackRef len; obj = stack_pointer[-1]; - // PUSH(len(TOS))/* Escaping */ + // PUSH(len(TOS)) _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj)); stack_pointer = _PyFrame_GetStackPointer(frame); if (len_i < 0) JUMP_TO_ERROR(); - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *len_o = PyLong_FromSsize_t(len_i); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3232,7 +3221,7 @@ subject = stack_pointer[-3]; // Pop TOS and TOS1. Set TOS to a tuple of attributes on success, or // None on failure. - assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names)));/* Escaping */ + assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names))); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attrs_o = _PyEval_MatchClass(tstate, PyStackRef_AsPyObjectBorrow(subject), @@ -3287,7 +3276,7 @@ _PyStackRef values_or_none; keys = stack_pointer[-1]; subject = stack_pointer[-2]; - // On successful match, PUSH(values). Otherwise, PUSH(None)./* Escaping */ + // On successful match, PUSH(values). Otherwise, PUSH(None). _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *values_or_none_o = _PyEval_MatchKeys(tstate, PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys)); @@ -3304,7 +3293,7 @@ _PyStackRef iterable; _PyStackRef iter; iterable = stack_pointer[-1]; - /* before: [obj]; after [getiter(obj)] *//* Escaping */ + /* before: [obj]; after [getiter(obj)] */ _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable))); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3324,7 +3313,7 @@ /* `iterable` is a coroutine */ if (!(_PyFrame_GetCode(frame)->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) { /* and it is used in a 'yield from' expression of a - regular generator. *//* Escaping */ + regular generator. */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_TypeError, "cannot 'yield from' a coroutine object " @@ -3338,7 +3327,7 @@ iter = iterable; } else { - /* `iterable` is not a generator. *//* Escaping */ + /* `iterable` is not a generator. */ _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3361,15 +3350,16 @@ PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); PyObject *next_o = (*Py_TYPE(iter_o)->tp_iternext)(iter_o); if (next_o == NULL) { - if (_PyErr_Occurred(tstate)) {/* Escaping */ + if (_PyErr_Occurred(tstate)) { _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); stack_pointer = _PyFrame_GetStackPointer(frame); if (!matches) { JUMP_TO_ERROR(); - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); - _PyEval_MonitorRaise(tstate, frame, frame->instr_ptr);/* Escaping */_PyErr_Clear(tstate); + _PyEval_MonitorRaise(tstate, frame, frame->instr_ptr); + _PyErr_Clear(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); } /* iterator ended normally */ @@ -3568,14 +3558,14 @@ assert(oparg <= SPECIAL_MAX); PyObject *owner_o = PyStackRef_AsPyObjectSteal(owner); PyObject *name = _Py_SpecialMethods[oparg].name; - PyObject *self_or_null_o;/* Escaping */ + PyObject *self_or_null_o; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); attr = PyStackRef_FromPyObjectSteal(_PyObject_LookupSpecialMethod(owner_o, name, &self_or_null_o)); stack_pointer = _PyFrame_GetStackPointer(frame); if (PyStackRef_IsNull(attr)) { - if (!_PyErr_Occurred(tstate)) {/* Escaping */ + if (!_PyErr_Occurred(tstate)) { stack_pointer[0] = attr; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -3619,9 +3609,10 @@ PyObject *exc, *tb; PyObject *val_o = PyStackRef_AsPyObjectBorrow(val); PyObject *exit_func_o = PyStackRef_AsPyObjectBorrow(exit_func); - assert(val_o && PyExceptionInstance_Check(val_o));/* Escaping */ + assert(val_o && PyExceptionInstance_Check(val_o)); _PyFrame_SetStackPointer(frame, stack_pointer); - exc = PyExceptionInstance_Class(val_o);/* Escaping */tb = PyException_GetTraceback(val_o); + exc = PyExceptionInstance_Class(val_o); + tb = PyException_GetTraceback(val_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (tb == NULL) { tb = Py_None; @@ -3632,7 +3623,7 @@ assert(PyStackRef_LongCheck(lasti)); (void)lasti; // Shut up compiler warning if asserts are off PyObject *stack[5] = {NULL, PyStackRef_AsPyObjectBorrow(exit_self), exc, val_o, tb}; - int has_self = !PyStackRef_IsNull(exit_self);/* Escaping */ + int has_self = !PyStackRef_IsNull(exit_self); _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Vectorcall(exit_func_o, stack + 2 - has_self, (3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL)); @@ -3844,7 +3835,7 @@ } 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));/* Escaping */ + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( tstate, callable[0], locals, @@ -3974,7 +3965,7 @@ PyStackRef_CLOSE(args[_i]); } if (true) JUMP_TO_ERROR(); - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -4286,7 +4277,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - STAT_INC(CALL, hit);/* Escaping */ + STAT_INC(CALL, hit); _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4318,7 +4309,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - STAT_INC(CALL, hit);/* Escaping */ + STAT_INC(CALL, hit); _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4365,7 +4356,7 @@ UOP_STAT_INC(uopcode, miss); JUMP_TO_JUMP_TARGET(); } - STAT_INC(CALL, hit);/* Escaping */ + STAT_INC(CALL, hit); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *self_o = _PyType_NewManagedObject(tp); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4388,13 +4379,13 @@ args = &stack_pointer[-oparg]; self = &stack_pointer[-1 - oparg]; init = &stack_pointer[-2 - oparg]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( - tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame);/* Escaping */assert(_PyCode_CODE(_PyFrame_GetCode(shim))[0].op.code == EXIT_INIT_CHECK); + tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame); + assert(_PyCode_CODE(_PyFrame_GetCode(shim))[0].op.code == EXIT_INIT_CHECK); stack_pointer = _PyFrame_GetStackPointer(frame); /* Push self onto stack of shim */ - shim->localsplus[0] = PyStackRef_DUP(self[0]);/* Escaping */ + shim->localsplus[0] = PyStackRef_DUP(self[0]); _PyFrame_SetStackPointer(frame, stack_pointer); init_frame = _PyEvalFramePushAndInit( tstate, init[0], NULL, args-1, oparg+1, NULL, shim); @@ -4418,7 +4409,7 @@ _PyStackRef should_be_none; should_be_none = stack_pointer[-1]; assert(STACK_LEVEL() == 2); - if (!PyStackRef_Is(should_be_none, PyStackRef_None)) {/* Escaping */ + if (!PyStackRef_Is(should_be_none, PyStackRef_None)) { _PyFrame_SetStackPointer(frame, stack_pointer); PyErr_Format(PyExc_TypeError, "__init__() should return None, not '%.200s'", @@ -4464,7 +4455,7 @@ PyStackRef_CLOSE(args[_i]); } if (true) JUMP_TO_ERROR(); - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = tp->tp_vectorcall((PyObject *)tp, args_o, total_args, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4518,7 +4509,7 @@ STAT_INC(CALL, hit); PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o); _PyStackRef arg = args[0]; - _Py_EnterRecursiveCallTstateUnchecked(tstate);/* Escaping */ + _Py_EnterRecursiveCallTstateUnchecked(tstate); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4626,7 +4617,7 @@ PyStackRef_CLOSE(args[_i]); } if (true) JUMP_TO_ERROR(); - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = cfunc(PyCFunction_GET_SELF(callable_o), args_o, total_args, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4672,13 +4663,13 @@ } STAT_INC(CALL, hit); _PyStackRef arg_stackref = args[0]; - PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref);/* Escaping */ + PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref); _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (len_i < 0) { JUMP_TO_ERROR(); - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyLong_FromSsize_t(len_i); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4722,7 +4713,7 @@ } STAT_INC(CALL, hit); _PyStackRef cls_stackref = args[1]; - _PyStackRef inst_stackref = args[0];/* Escaping */ + _PyStackRef inst_stackref = args[0]; _PyFrame_SetStackPointer(frame, stack_pointer); int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4820,7 +4811,7 @@ } STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; - _Py_EnterRecursiveCallTstateUnchecked(tstate);/* Escaping */ + _Py_EnterRecursiveCallTstateUnchecked(tstate); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyStackRef_AsPyObjectBorrow(self_stackref), @@ -4882,7 +4873,7 @@ PyStackRef_CLOSE(args[_i]); } if (true) JUMP_TO_ERROR(); - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = cfunc(self, (args_o + 1), nargs, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4944,7 +4935,7 @@ } STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; - _Py_EnterRecursiveCallTstateUnchecked(tstate);/* Escaping */ + _Py_EnterRecursiveCallTstateUnchecked(tstate); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5003,7 +4994,7 @@ PyStackRef_CLOSE(args[_i]); } if (true) JUMP_TO_ERROR(); - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = cfunc(self, (args_o + 1), nargs); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5077,7 +5068,7 @@ int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); 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));/* Escaping */ + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( tstate, callable[0], locals, @@ -5211,7 +5202,7 @@ if (true) JUMP_TO_ERROR(); } PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); - int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o);/* Escaping */ + int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -5249,13 +5240,13 @@ if (PyTuple_CheckExact(callargs_o)) { tuple = callargs; } - else {/* Escaping */ + else { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { JUMP_TO_ERROR(); - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *tuple_o = PySequence_Tuple(callargs_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5277,14 +5268,13 @@ _PyStackRef codeobj_st; _PyStackRef func; codeobj_st = stack_pointer[-1]; - PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st);/* Escaping */ + PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st); _PyFrame_SetStackPointer(frame, stack_pointer); PyFunctionObject *func_obj = (PyFunctionObject *) PyFunction_New(codeobj, GLOBALS()); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(codeobj_st); if (func_obj == NULL) JUMP_TO_ERROR(); - /* Escaping */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -5323,7 +5313,7 @@ case _RETURN_GENERATOR: { _PyStackRef res; assert(PyStackRef_FunctionCheck(frame->f_funcobj)); - PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj);/* Escaping */ + PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj); _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5331,13 +5321,13 @@ assert(EMPTY()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *gen_frame = &gen->gi_iframe; - frame->instr_ptr++;/* Escaping *//* Virtual flush 1 */ + frame->instr_ptr++;/* Virtual flush 1 */ _PyFrame_Copy(frame, gen_frame);/* Virtual reload 1 */ assert(frame->frame_obj == NULL); gen->gi_frame_state = FRAME_CREATED; gen_frame->owner = FRAME_OWNED_BY_GENERATOR; _Py_LeaveRecursiveCallPy(tstate); - _PyInterpreterFrame *prev = frame->previous;/* Escaping *//* Virtual flush 1 */ + _PyInterpreterFrame *prev = frame->previous;/* Virtual flush 1 */ _PyThreadState_PopFrame(tstate, frame);/* Virtual reload 1 */ frame = tstate->current_frame = prev; LOAD_IP(frame->return_offset); @@ -5381,7 +5371,7 @@ value = stack_pointer[-1]; conversion_func conv_fn; assert(oparg >= FVC_STR && oparg <= FVC_ASCII); - conv_fn = _PyEval_ConversionFuncs[oparg];/* Escaping */ + conv_fn = _PyEval_ConversionFuncs[oparg]; _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5399,7 +5389,7 @@ PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); /* If value is a unicode object, then we know the result * of format(value) is value itself. */ - if (!PyUnicode_CheckExact(value_o)) {/* Escaping */ + if (!PyUnicode_CheckExact(value_o)) { _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Format(value_o, NULL)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5419,7 +5409,6 @@ _PyStackRef res; fmt_spec = stack_pointer[-1]; value = stack_pointer[-2]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5596,28 +5585,32 @@ case _EXIT_TRACE: { PyObject *exit_p = (PyObject *)CURRENT_OPERAND(); _PyExitData *exit = (_PyExitData *)exit_p; - PyCodeObject *code = _PyFrame_GetCode(frame);/* Escaping */ + PyCodeObject *code = _PyFrame_GetCode(frame); _PyFrame_SetStackPointer(frame, stack_pointer); - _Py_CODEUNIT *target = _PyCode_CODE(code) + exit->target;/* Escaping */#if defined(Py_DEBUG) && !defined(_Py_JIT) + _Py_CODEUNIT *target = _PyCode_CODE(code) + exit->target; + #if defined(Py_DEBUG) && !defined(_Py_JIT) OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); stack_pointer = _PyFrame_GetStackPointer(frame); - if (lltrace >= 2) {/* Escaping */ + if (lltrace >= 2) { _PyFrame_SetStackPointer(frame, stack_pointer); - printf("SIDE EXIT: [UOp ");/* Escaping */_PyUOpPrint(&next_uop[-1]);/* Escaping */printf(", exit %u, temp %d, target %d -> %s]\n", + printf("SIDE EXIT: [UOp "); + _PyUOpPrint(&next_uop[-1]); + printf(", exit %u, temp %d, target %d -> %s]\n", exit - current_executor->exits, exit->temperature.as_counter, (int)(target - _PyCode_CODE(code)), _PyOpcode_OpName[target->op.code]); stack_pointer = _PyFrame_GetStackPointer(frame); } #endif - if (exit->executor && !exit->executor->vm_data.valid) {/* Escaping */ + if (exit->executor && !exit->executor->vm_data.valid) { _PyFrame_SetStackPointer(frame, stack_pointer); - exit->temperature = initial_temperature_backoff_counter();/* Escaping */Py_CLEAR(exit->executor); + exit->temperature = initial_temperature_backoff_counter(); + Py_CLEAR(exit->executor); stack_pointer = _PyFrame_GetStackPointer(frame); } if (exit->executor == NULL) { _Py_BackoffCounter temperature = exit->temperature; - if (!backoff_counter_triggers(temperature)) {/* Escaping */ + if (!backoff_counter_triggers(temperature)) { _PyFrame_SetStackPointer(frame, stack_pointer); exit->temperature = advance_backoff_counter(temperature); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5630,11 +5623,11 @@ Py_INCREF(executor); } else { - int chain_depth = current_executor->vm_data.chain_depth + 1;/* Escaping */ + int chain_depth = current_executor->vm_data.chain_depth + 1; _PyFrame_SetStackPointer(frame, stack_pointer); int optimized = _PyOptimizer_Optimize(frame, target, stack_pointer, &executor, chain_depth); stack_pointer = _PyFrame_GetStackPointer(frame); - if (optimized <= 0) {/* Escaping */ + if (optimized <= 0) { _PyFrame_SetStackPointer(frame, stack_pointer); exit->temperature = restart_backoff_counter(temperature); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5743,14 +5736,16 @@ PyObject *exit_p = (PyObject *)CURRENT_OPERAND(); tstate->previous_executor = (PyObject *)current_executor; _PyExitData *exit = (_PyExitData *)exit_p; - _Py_CODEUNIT *target = frame->instr_ptr;/* Escaping */ + _Py_CODEUNIT *target = frame->instr_ptr; _PyFrame_SetStackPointer(frame, stack_pointer); #if defined(Py_DEBUG) && !defined(_Py_JIT) OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); stack_pointer = _PyFrame_GetStackPointer(frame); - if (lltrace >= 2) {/* Escaping */ + if (lltrace >= 2) { _PyFrame_SetStackPointer(frame, stack_pointer); - printf("DYNAMIC EXIT: [UOp ");/* Escaping */_PyUOpPrint(&next_uop[-1]);/* Escaping */printf(", exit %u, temp %d, target %d -> %s]\n", + printf("DYNAMIC EXIT: [UOp "); + _PyUOpPrint(&next_uop[-1]); + printf(", exit %u, temp %d, target %d -> %s]\n", exit - current_executor->exits, exit->temperature.as_counter, (int)(target - _PyCode_CODE(_PyFrame_GetCode(frame))), _PyOpcode_OpName[target->op.code]); @@ -5764,16 +5759,16 @@ Py_INCREF(executor); } else { - if (!backoff_counter_triggers(exit->temperature)) {/* Escaping */ + if (!backoff_counter_triggers(exit->temperature)) { _PyFrame_SetStackPointer(frame, stack_pointer); exit->temperature = advance_backoff_counter(exit->temperature); stack_pointer = _PyFrame_GetStackPointer(frame); GOTO_TIER_ONE(target); - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); int optimized = _PyOptimizer_Optimize(frame, target, stack_pointer, &executor, 0); stack_pointer = _PyFrame_GetStackPointer(frame); - if (optimized <= 0) {/* Escaping */ + if (optimized <= 0) { _PyFrame_SetStackPointer(frame, stack_pointer); exit->temperature = restart_backoff_counter(exit->temperature); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5782,7 +5777,7 @@ } GOTO_TIER_ONE(target); } - else {/* Escaping */ + else { _PyFrame_SetStackPointer(frame, stack_pointer); exit->temperature = initial_temperature_backoff_counter(); stack_pointer = _PyFrame_GetStackPointer(frame); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 85fe8c8ac40f8b..8f44af9f87089e 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -27,7 +27,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr;/* Escaping */ + next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_BinaryOp(lhs, rhs, next_instr, oparg, LOCALS_ARRAY); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -385,7 +385,6 @@ stop = stack_pointer[-1]; start = stack_pointer[-2]; container = stack_pointer[-3]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); @@ -396,7 +395,7 @@ if (slice == NULL) { res_o = NULL; } - else {/* Escaping */ + else { stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -435,7 +434,7 @@ assert(frame->stackpointer == NULL); #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr;/* Escaping */ + next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_BinarySubscr(container, sub, next_instr); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -448,7 +447,7 @@ // _BINARY_SUBSCR { PyObject *container_o = PyStackRef_AsPyObjectBorrow(container); - PyObject *sub_o = PyStackRef_AsPyObjectBorrow(sub);/* Escaping */ + PyObject *sub_o = PyStackRef_AsPyObjectBorrow(sub); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_GetItem(container_o, sub_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -478,11 +477,11 @@ PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st); DEOPT_IF(!PyDict_CheckExact(dict), BINARY_SUBSCR); STAT_INC(BINARY_SUBSCR, hit); - PyObject *res_o;/* Escaping */ + PyObject *res_o; _PyFrame_SetStackPointer(frame, stack_pointer); int rc = PyDict_GetItemRef(dict, sub, &res_o); stack_pointer = _PyFrame_GetStackPointer(frame); - if (rc == 0) {/* Escaping */ + if (rc == 0) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetKeyError(sub); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -691,7 +690,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *map_o = _PyDict_FromItems( values_o, 2, @@ -721,7 +720,6 @@ _PyStackRef *values; _PyStackRef set; values = &stack_pointer[-oparg]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *set_o = PySet_New(NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -737,7 +735,7 @@ } int err = 0; for (int i = 0; i < oparg; i++) { - if (err == 0) {/* Escaping */ + if (err == 0) { _PyFrame_SetStackPointer(frame, stack_pointer); err = PySet_Add(set_o, PyStackRef_AsPyObjectBorrow(values[i])); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -874,7 +872,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr;/* Escaping */ + next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_Call(callable[0], next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -918,7 +916,7 @@ ((PyFunctionObject *)callable_o)->vectorcall == _PyFunction_Vectorcall) { 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));/* Escaping */ + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( tstate, callable[0], locals, @@ -948,7 +946,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -959,20 +957,20 @@ if (opcode == INSTRUMENTED_CALL) { PyObject *arg = total_args == 0 ? &_PyInstrumentation_MISSING : PyStackRef_AsPyObjectBorrow(args[0]); - if (res_o == NULL) {/* Escaping */ + if (res_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, callable_o, arg); stack_pointer = _PyFrame_GetStackPointer(frame); } - else {/* Escaping */ + else { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, callable_o, arg); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) {/* Escaping */ + if (err < 0) { _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(res_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -995,7 +993,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1048,7 +1046,7 @@ PyFunctionObject *init_func = (PyFunctionObject *)cls->_spec_cache.init; PyCodeObject *code = (PyCodeObject *)init_func->func_code; DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize + _Py_InitCleanup.co_framesize), CALL); - STAT_INC(CALL, hit);/* Escaping */ + STAT_INC(CALL, hit); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *self_o = _PyType_NewManagedObject(tp); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1065,13 +1063,13 @@ args = &stack_pointer[-oparg]; self = &stack_pointer[-1 - oparg]; init = &stack_pointer[-2 - oparg]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( - tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame);/* Escaping */assert(_PyCode_CODE(_PyFrame_GetCode(shim))[0].op.code == EXIT_INIT_CHECK); + tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame); + assert(_PyCode_CODE(_PyFrame_GetCode(shim))[0].op.code == EXIT_INIT_CHECK); stack_pointer = _PyFrame_GetStackPointer(frame); /* Push self onto stack of shim */ - shim->localsplus[0] = PyStackRef_DUP(self[0]);/* Escaping */ + shim->localsplus[0] = PyStackRef_DUP(self[0]); _PyFrame_SetStackPointer(frame, stack_pointer); init_frame = _PyEvalFramePushAndInit( tstate, init[0], NULL, args-1, oparg+1, NULL, shim); @@ -1270,7 +1268,7 @@ } 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));/* Escaping */ + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( tstate, callable[0], locals, @@ -1350,7 +1348,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = tp->tp_vectorcall((PyObject *)tp, args_o, total_args, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1371,7 +1369,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1452,7 +1450,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1512,7 +1510,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = cfunc(PyCFunction_GET_SELF(callable_o), args_o, total_args, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1534,7 +1532,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1583,7 +1581,7 @@ STAT_INC(CALL, hit); PyCFunction cfunc = PyCFunction_GET_FUNCTION(callable_o); _PyStackRef arg = args[0]; - _Py_EnterRecursiveCallTstateUnchecked(tstate);/* Escaping */ + _Py_EnterRecursiveCallTstateUnchecked(tstate); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyCFunction_GET_SELF(callable_o), PyStackRef_AsPyObjectBorrow(arg)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1602,7 +1600,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -1645,13 +1643,13 @@ if (PyTuple_CheckExact(callargs_o)) { tuple = callargs; } - else {/* Escaping */ + else { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_Check_ArgsIterable(tstate, PyStackRef_AsPyObjectBorrow(func), callargs_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { goto error; - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *tuple_o = PySequence_Tuple(callargs_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1680,7 +1678,7 @@ assert(!_PyErr_Occurred(tstate)); if (opcode == INSTRUMENTED_CALL_FUNCTION_EX) { PyObject *arg = PyTuple_GET_SIZE(callargs) > 0 ? - PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING;/* Escaping */ + PyTuple_GET_ITEM(callargs, 0) : &_PyInstrumentation_MISSING; stack_pointer[-1 - (oparg & 1)] = callargs_st; if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_st; _PyFrame_SetStackPointer(frame, stack_pointer); @@ -1690,25 +1688,25 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { goto error; - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); result_o = PyObject_Call(func, callargs, kwargs); stack_pointer = _PyFrame_GetStackPointer(frame); if (!PyFunction_Check(func) && !PyMethod_Check(func)) { - if (result_o == NULL) {/* Escaping */ + if (result_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, func, arg); stack_pointer = _PyFrame_GetStackPointer(frame); } - else {/* Escaping */ + else { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, func, arg); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) {/* Escaping */ + if (err < 0) { _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(result_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1723,7 +1721,7 @@ assert(PyTuple_CheckExact(callargs)); Py_ssize_t nargs = PyTuple_GET_SIZE(callargs); int code_flags = ((PyCodeObject *)PyFunction_GET_CODE(func))->co_flags; - PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func));/* Escaping */ + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(func)); stack_pointer[-1 - (oparg & 1)] = callargs_st; if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_st; _PyFrame_SetStackPointer(frame, stack_pointer); @@ -1740,13 +1738,13 @@ assert(next_instr - this_instr == 1); frame->return_offset = 1; DISPATCH_INLINED(new_frame); - }/* Escaping */ + } stack_pointer[-1 - (oparg & 1)] = callargs_st; if (oparg & 1) stack_pointer[-(oparg & 1)] = kwargs_st; _PyFrame_SetStackPointer(frame, stack_pointer); result_o = PyObject_Call(func, callargs, kwargs); stack_pointer = _PyFrame_GetStackPointer(frame); - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyStackRef_XCLOSE(kwargs_st); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1763,7 +1761,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-3 - (oparg & 1)] = result; stack_pointer += -2 - (oparg & 1); assert(WITHIN_STACK_BOUNDS()); @@ -1788,7 +1786,7 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; - assert(oparg <= MAX_INTRINSIC_1);/* Escaping */ + assert(oparg <= MAX_INTRINSIC_1); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyIntrinsics_UnaryFunctions[oparg].func(tstate, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1810,7 +1808,7 @@ value2_st = stack_pointer[-2]; assert(oparg <= MAX_INTRINSIC_2); PyObject *value1 = PyStackRef_AsPyObjectBorrow(value1_st); - PyObject *value2 = PyStackRef_AsPyObjectBorrow(value2_st);/* Escaping */ + PyObject *value2 = PyStackRef_AsPyObjectBorrow(value2_st); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyIntrinsics_BinaryFunctions[oparg].func(tstate, value2, value1); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1850,7 +1848,7 @@ DEOPT_IF(callable_o != interp->callable_cache.isinstance, CALL); STAT_INC(CALL, hit); _PyStackRef cls_stackref = args[1]; - _PyStackRef inst_stackref = args[0];/* Escaping */ + _PyStackRef inst_stackref = args[0]; _PyFrame_SetStackPointer(frame, stack_pointer); int retval = PyObject_IsInstance(PyStackRef_AsPyObjectBorrow(inst_stackref), PyStackRef_AsPyObjectBorrow(cls_stackref)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1892,7 +1890,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr;/* Escaping */ + next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_CallKw(callable[0], next_instr, oparg + !PyStackRef_IsNull(self_or_null[0])); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -1941,7 +1939,7 @@ ((PyFunctionObject *)callable_o)->vectorcall == _PyFunction_Vectorcall) { 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));/* Escaping */ + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); stack_pointer[-1] = kwnames; _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( @@ -1976,7 +1974,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - }/* Escaping */ + } stack_pointer[-1] = kwnames; _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( @@ -1988,20 +1986,20 @@ if (opcode == INSTRUMENTED_CALL_KW) { PyObject *arg = total_args == 0 ? &_PyInstrumentation_MISSING : PyStackRef_AsPyObjectBorrow(args[0]); - if (res_o == NULL) {/* Escaping */ + if (res_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, callable_o, arg); stack_pointer = _PyFrame_GetStackPointer(frame); } - else {/* Escaping */ + else { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, callable_o, arg); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) {/* Escaping */ + if (err < 0) { _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(res_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2088,7 +2086,7 @@ int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); 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));/* Escaping */ + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( tstate, callable[0], locals, @@ -2183,7 +2181,7 @@ } } PyObject *kwnames_o = PyStackRef_AsPyObjectBorrow(kwnames); - int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o);/* Escaping */ + int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -2208,7 +2206,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-3 - oparg] = res; stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2266,7 +2264,7 @@ int positional_args = total_args - (int)PyTuple_GET_SIZE(kwnames_o); 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));/* Escaping */ + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); new_frame = _PyEvalFramePushAndInit( tstate, callable[0], locals, @@ -2338,13 +2336,13 @@ DEOPT_IF(callable_o != interp->callable_cache.len, CALL); STAT_INC(CALL, hit); _PyStackRef arg_stackref = args[0]; - PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref);/* Escaping */ + PyObject *arg = PyStackRef_AsPyObjectBorrow(arg_stackref); _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (len_i < 0) { goto error; - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyLong_FromSsize_t(len_i); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2442,7 +2440,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = cfunc(self, (args_o + 1), nargs); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2464,7 +2462,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2527,7 +2525,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = cfunc(self, (args_o + 1), nargs, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2549,7 +2547,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2602,7 +2600,7 @@ DEOPT_IF(tstate->c_recursion_remaining <= 0, CALL); STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; - _Py_EnterRecursiveCallTstateUnchecked(tstate);/* Escaping */ + _Py_EnterRecursiveCallTstateUnchecked(tstate); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, self, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2621,7 +2619,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2674,7 +2672,7 @@ method->d_common.d_type), CALL); STAT_INC(CALL, hit); PyCFunction cfunc = meth->ml_meth; - _Py_EnterRecursiveCallTstateUnchecked(tstate);/* Escaping */ + _Py_EnterRecursiveCallTstateUnchecked(tstate); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyCFunction_TrampolineCall(cfunc, PyStackRef_AsPyObjectBorrow(self_stackref), @@ -2696,7 +2694,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2758,7 +2756,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -2782,7 +2780,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -2917,7 +2915,7 @@ } 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));/* Escaping */ + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *temp = _PyEvalFramePushAndInit( tstate, callable[0], locals, @@ -2980,7 +2978,7 @@ assert(oparg == 1); DEOPT_IF(!PyStackRef_IsNull(null), CALL); DEOPT_IF(callable_o != (PyObject *)&PyUnicode_Type, CALL); - STAT_INC(CALL, hit);/* Escaping */ + STAT_INC(CALL, hit); _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Str(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -2991,7 +2989,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-3] = res; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -3030,7 +3028,7 @@ assert(oparg == 1); DEOPT_IF(!PyStackRef_IsNull(null), CALL); DEOPT_IF(callable_o != (PyObject *)&PyTuple_Type, CALL); - STAT_INC(CALL, hit);/* Escaping */ + STAT_INC(CALL, hit); _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PySequence_Tuple(arg_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3041,7 +3039,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-3] = res; stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); @@ -3098,7 +3096,7 @@ match_type_st = stack_pointer[-1]; exc_value_st = stack_pointer[-2]; PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st); - PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st);/* Escaping */ + PyObject *match_type = PyStackRef_AsPyObjectBorrow(match_type_st); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyEval_CheckExceptStarTypeValid(tstate, match_type); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3108,7 +3106,7 @@ if (true) goto pop_2_error; } PyObject *match_o = NULL; - PyObject *rest_o = NULL;/* Escaping */ + PyObject *rest_o = NULL; _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_ExceptionGroupMatch(exc_value, match_type, &match_o, &rest_o); @@ -3118,7 +3116,7 @@ if (res < 0) goto pop_2_error; assert((match_o == NULL) == (rest_o == NULL)); if (match_o == NULL) goto pop_2_error; - if (!Py_IsNone(match_o)) {/* Escaping */ + if (!Py_IsNone(match_o)) { stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -3145,14 +3143,14 @@ left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert(PyExceptionInstance_Check(left_o));/* Escaping */ + assert(PyExceptionInstance_Check(left_o)); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyEval_CheckExceptTypeValid(tstate, right_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { PyStackRef_CLOSE(right); if (true) goto pop_1_error; - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyErr_GivenExceptionMatches(left_o, right_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3177,7 +3175,7 @@ sub_iter_st = stack_pointer[-3]; PyObject *exc_value = PyStackRef_AsPyObjectBorrow(exc_value_st); assert(throwflag); - assert(exc_value && PyExceptionInstance_Check(exc_value));/* Escaping */ + assert(exc_value && PyExceptionInstance_Check(exc_value)); _PyFrame_SetStackPointer(frame, stack_pointer); int matches = PyErr_GivenExceptionMatches(exc_value, PyExc_StopIteration); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3188,9 +3186,10 @@ PyStackRef_CLOSE(last_sent_val_st); PyStackRef_CLOSE(exc_value_st); } - else {/* Escaping */ + else { _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_SetRaisedException(tstate, Py_NewRef(exc_value));/* Escaping */monitor_reraise(tstate, frame, this_instr); + _PyErr_SetRaisedException(tstate, Py_NewRef(exc_value)); + monitor_reraise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; } @@ -3219,7 +3218,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr;/* Escaping */ + next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_CompareOp(left, right, next_instr, oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3233,14 +3232,14 @@ { PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); - assert((oparg >> 5) <= Py_GE);/* Escaping */ + assert((oparg >> 5) <= Py_GE); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_RichCompare(left_o, right_o, oparg >> 5); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(left); PyStackRef_CLOSE(right); if (res_o == NULL) goto pop_2_error; - if (oparg & 16) {/* Escaping */ + if (oparg & 16) { stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -3398,7 +3397,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr;/* Escaping */ + next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_ContainsOp(right, next_instr); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3412,7 +3411,7 @@ { left = stack_pointer[-2]; PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); - PyObject *right_o = PyStackRef_AsPyObjectBorrow(right);/* Escaping */ + PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); _PyFrame_SetStackPointer(frame, stack_pointer); int res = PySequence_Contains(right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3441,7 +3440,7 @@ PyObject *left_o = PyStackRef_AsPyObjectBorrow(left); PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!PyDict_CheckExact(right_o), CONTAINS_OP); - STAT_INC(CONTAINS_OP, hit);/* Escaping */ + STAT_INC(CONTAINS_OP, hit); _PyFrame_SetStackPointer(frame, stack_pointer); int res = PyDict_Contains(right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3470,7 +3469,7 @@ PyObject *right_o = PyStackRef_AsPyObjectBorrow(right); DEOPT_IF(!(PySet_CheckExact(right_o) || PyFrozenSet_CheckExact(right_o)), CONTAINS_OP); STAT_INC(CONTAINS_OP, hit); - // Note: both set and frozenset use the same seq_contains method!/* Escaping */ + // Note: both set and frozenset use the same seq_contains method! _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PySet_Contains((PySetObject *)right_o, left_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3493,7 +3492,7 @@ value = stack_pointer[-1]; conversion_func conv_fn; assert(oparg >= FVC_STR && oparg <= FVC_ASCII); - conv_fn = _PyEval_ConversionFuncs[oparg];/* Escaping */ + conv_fn = _PyEval_ConversionFuncs[oparg]; _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *result_o = conv_fn(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3543,7 +3542,7 @@ INSTRUCTION_STATS(DELETE_ATTR); _PyStackRef owner; owner = stack_pointer[-1]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_DelAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3560,11 +3559,11 @@ INSTRUCTION_STATS(DELETE_DEREF); PyObject *cell = PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); // Can't use ERROR_IF here. - // Fortunately we don't need its superpower./* Escaping */ + // Fortunately we don't need its superpower. _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *oldobj = PyCell_SwapTakeRef((PyCellObject *)cell, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); - if (oldobj == NULL) {/* Escaping */ + if (oldobj == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3579,7 +3578,7 @@ next_instr += 1; INSTRUCTION_STATS(DELETE_FAST); _PyStackRef v = GETLOCAL(oparg); - if (PyStackRef_IsNull(v)) {/* Escaping */ + if (PyStackRef_IsNull(v)) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError, UNBOUNDLOCAL_ERROR_MSG, @@ -3596,7 +3595,7 @@ frame->instr_ptr = next_instr; next_instr += 1; INSTRUCTION_STATS(DELETE_GLOBAL); - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_Pop(GLOBALS(), name, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3604,7 +3603,7 @@ if (err < 0) { goto error; } - if (err == 0) {/* Escaping */ + if (err == 0) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, name); @@ -3621,18 +3620,18 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); PyObject *ns = LOCALS(); int err; - if (ns == NULL) {/* Escaping */ + if (ns == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals when deleting %R", name); stack_pointer = _PyFrame_GetStackPointer(frame); goto error; - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_DelItem(ns, name); stack_pointer = _PyFrame_GetStackPointer(frame); // Can't use ERROR_IF here. - if (err != 0) {/* Escaping */ + if (err != 0) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, @@ -3651,7 +3650,7 @@ _PyStackRef sub; sub = stack_pointer[-1]; container = stack_pointer[-2]; - /* del container[sub] *//* Escaping */ + /* del container[sub] */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_DelItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub)); @@ -3676,11 +3675,11 @@ callable = stack_pointer[-5 - (oparg - 1)]; PyObject *callable_o = PyStackRef_AsPyObjectBorrow(callable); PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); - PyObject *update_o = PyStackRef_AsPyObjectBorrow(update);/* Escaping */ + PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_MergeEx(dict_o, update_o, 2); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) {/* Escaping */ + if (err < 0) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatKwargsError(tstate, callable_o, update_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3702,15 +3701,15 @@ update = stack_pointer[-1]; dict = stack_pointer[-2 - (oparg - 1)]; PyObject *dict_o = PyStackRef_AsPyObjectBorrow(dict); - PyObject *update_o = PyStackRef_AsPyObjectBorrow(update);/* Escaping */ + PyObject *update_o = PyStackRef_AsPyObjectBorrow(update); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_Update(dict_o, update_o); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) {/* Escaping */ + if (err < 0) { _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_AttributeError); stack_pointer = _PyFrame_GetStackPointer(frame); - if (matches) {/* Escaping */ + if (matches) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'%.200s' object is not a mapping", @@ -3736,7 +3735,7 @@ exc_st = stack_pointer[-1]; awaitable_st = stack_pointer[-2]; PyObject *exc = PyStackRef_AsPyObjectBorrow(exc_st); - assert(exc && PyExceptionInstance_Check(exc));/* Escaping */ + assert(exc && PyExceptionInstance_Check(exc)); _PyFrame_SetStackPointer(frame, stack_pointer); int matches = PyErr_GivenExceptionMatches(exc, PyExc_StopAsyncIteration); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3745,9 +3744,10 @@ PyStackRef_CLOSE(exc_st); } else { - Py_INCREF(exc);/* Escaping */ + Py_INCREF(exc); _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_SetRaisedException(tstate, exc);/* Escaping */monitor_reraise(tstate, frame, this_instr); + _PyErr_SetRaisedException(tstate, exc); + monitor_reraise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; } @@ -3826,7 +3826,7 @@ _PyStackRef should_be_none; should_be_none = stack_pointer[-1]; assert(STACK_LEVEL() == 2); - if (!PyStackRef_Is(should_be_none, PyStackRef_None)) {/* Escaping */ + if (!PyStackRef_Is(should_be_none, PyStackRef_None)) { _PyFrame_SetStackPointer(frame, stack_pointer); PyErr_Format(PyExc_TypeError, "__init__() should return None, not '%.200s'", @@ -3860,7 +3860,7 @@ PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); /* If value is a unicode object, then we know the result * of format(value) is value itself. */ - if (!PyUnicode_CheckExact(value_o)) {/* Escaping */ + if (!PyUnicode_CheckExact(value_o)) { _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Format(value_o, NULL)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3883,7 +3883,6 @@ _PyStackRef res; fmt_spec = stack_pointer[-1]; value = stack_pointer[-2]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Format(PyStackRef_AsPyObjectBorrow(value), PyStackRef_AsPyObjectBorrow(fmt_spec)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3913,7 +3912,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr;/* Escaping */ + next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_ForIter(iter, next_instr, oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -3929,15 +3928,16 @@ PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); PyObject *next_o = (*Py_TYPE(iter_o)->tp_iternext)(iter_o); if (next_o == NULL) { - if (_PyErr_Occurred(tstate)) {/* Escaping */ + if (_PyErr_Occurred(tstate)) { _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); stack_pointer = _PyFrame_GetStackPointer(frame); if (!matches) { goto error; - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); - _PyEval_MonitorRaise(tstate, frame, this_instr);/* Escaping */_PyErr_Clear(tstate); + _PyEval_MonitorRaise(tstate, frame, this_instr); + _PyErr_Clear(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); } /* iterator ended normally */ @@ -4164,7 +4164,7 @@ if (type->tp_as_async != NULL) { getter = type->tp_as_async->am_aiter; } - if (getter == NULL) {/* Escaping */ + if (getter == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_TypeError, "'async for' requires an object with " @@ -4178,7 +4178,7 @@ PyStackRef_CLOSE(obj); if (iter_o == NULL) goto pop_1_error; if (Py_TYPE(iter_o)->tp_as_async == NULL || - Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) {/* Escaping */ + Py_TYPE(iter_o)->tp_as_async->am_anext == NULL) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -4202,7 +4202,6 @@ _PyStackRef aiter; _PyStackRef awaitable; aiter = stack_pointer[-1]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *awaitable_o = _PyEval_GetANext(PyStackRef_AsPyObjectBorrow(aiter)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4223,7 +4222,6 @@ _PyStackRef iterable; _PyStackRef iter; iterable = stack_pointer[-1]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *iter_o = _PyEval_GetAwaitable(PyStackRef_AsPyObjectBorrow(iterable), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4241,7 +4239,7 @@ _PyStackRef iterable; _PyStackRef iter; iterable = stack_pointer[-1]; - /* before: [obj]; after [getiter(obj)] *//* Escaping */ + /* before: [obj]; after [getiter(obj)] */ _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(PyStackRef_AsPyObjectBorrow(iterable))); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4258,12 +4256,11 @@ _PyStackRef obj; _PyStackRef len; obj = stack_pointer[-1]; - // PUSH(len(TOS))/* Escaping */ + // PUSH(len(TOS)) _PyFrame_SetStackPointer(frame, stack_pointer); Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj)); stack_pointer = _PyFrame_GetStackPointer(frame); if (len_i < 0) goto error; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *len_o = PyLong_FromSsize_t(len_i); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4288,7 +4285,7 @@ /* `iterable` is a coroutine */ if (!(_PyFrame_GetCode(frame)->co_flags & (CO_COROUTINE | CO_ITERABLE_COROUTINE))) { /* and it is used in a 'yield from' expression of a - regular generator. *//* Escaping */ + regular generator. */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_TypeError, "cannot 'yield from' a coroutine object " @@ -4302,7 +4299,7 @@ iter = iterable; } else { - /* `iterable` is not a generator. *//* Escaping */ + /* `iterable` is not a generator. */ _PyFrame_SetStackPointer(frame, stack_pointer); iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4322,7 +4319,7 @@ _PyStackRef from; _PyStackRef res; from = stack_pointer[-1]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_ImportFrom(tstate, PyStackRef_AsPyObjectBorrow(from), name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4343,7 +4340,7 @@ _PyStackRef res; fromlist = stack_pointer[-1]; level = stack_pointer[-2]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_ImportName(tstate, frame, name, PyStackRef_AsPyObjectBorrow(fromlist), @@ -4405,7 +4402,6 @@ else { arg0 = &_PyInstrumentation_MISSING; } - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, @@ -4431,7 +4427,7 @@ ((PyFunctionObject *)callable_o)->vectorcall == _PyFunction_Vectorcall) { 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));/* Escaping */ + PyObject *locals = code_flags & CO_OPTIMIZED ? NULL : Py_NewRef(PyFunction_GET_GLOBALS(callable_o)); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *new_frame = _PyEvalFramePushAndInit( tstate, callable[0], locals, @@ -4461,7 +4457,7 @@ assert(WITHIN_STACK_BOUNDS()); goto error; } - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyObject_Vectorcall( callable_o, args_o, @@ -4472,20 +4468,20 @@ if (opcode == INSTRUMENTED_CALL) { PyObject *arg = total_args == 0 ? &_PyInstrumentation_MISSING : PyStackRef_AsPyObjectBorrow(args[0]); - if (res_o == NULL) {/* Escaping */ + if (res_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, callable_o, arg); stack_pointer = _PyFrame_GetStackPointer(frame); } - else {/* Escaping */ + else { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, callable_o, arg); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) {/* Escaping */ + if (err < 0) { _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(res_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4508,7 +4504,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { stack_pointer[-2 - oparg] = res; stack_pointer += -1 - oparg; assert(WITHIN_STACK_BOUNDS()); @@ -4546,7 +4542,7 @@ int total_args = oparg + is_meth; PyObject *function = PyStackRef_AsPyObjectBorrow(PEEK(oparg + 3)); PyObject *arg = total_args == 0 ? &_PyInstrumentation_MISSING - : PyStackRef_AsPyObjectBorrow(PEEK(total_args + 1));/* Escaping */ + : PyStackRef_AsPyObjectBorrow(PEEK(total_args + 1)); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, @@ -4568,7 +4564,7 @@ receiver = stack_pointer[-2]; /* Need to create a fake StopIteration error here, * to conform to PEP 380 */ - if (PyStackRef_GenCheck(receiver)) {/* Escaping */ + if (PyStackRef_GenCheck(receiver)) { _PyFrame_SetStackPointer(frame, stack_pointer); int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4593,7 +4589,7 @@ value = stack_pointer[-1]; receiver = stack_pointer[-2]; PyObject *receiver_o = PyStackRef_AsPyObjectBorrow(receiver); - if (PyGen_Check(receiver_o) || PyCoro_CheckExact(receiver_o)) {/* Escaping */ + if (PyGen_Check(receiver_o) || PyCoro_CheckExact(receiver_o)) { _PyFrame_SetStackPointer(frame, stack_pointer); int err = monitor_stop_iteration(tstate, frame, this_instr, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4624,15 +4620,16 @@ target = next_instr; } else { - if (_PyErr_Occurred(tstate)) {/* Escaping */ + if (_PyErr_Occurred(tstate)) { _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); stack_pointer = _PyFrame_GetStackPointer(frame); if (!matches) { goto error; - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); - _PyEval_MonitorRaise(tstate, frame, this_instr);/* Escaping */_PyErr_Clear(tstate); + _PyEval_MonitorRaise(tstate, frame, this_instr); + _PyErr_Clear(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); } /* iterator ended normally */ @@ -4652,7 +4649,6 @@ (void)this_instr; next_instr += 1; INSTRUCTION_STATS(INSTRUMENTED_INSTRUCTION); - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int next_opcode = _Py_call_instrumentation_instruction( tstate, frame, this_instr); @@ -4677,7 +4673,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4708,12 +4704,12 @@ INSTRUCTION_STATS(INSTRUMENTED_LINE); int original_opcode = 0; if (tstate->tracing) { - PyCodeObject *code = _PyFrame_GetCode(frame);/* Escaping */ + PyCodeObject *code = _PyFrame_GetCode(frame); _PyFrame_SetStackPointer(frame, stack_pointer); original_opcode = code->_co_monitoring->lines[(int)(this_instr - _PyCode_CODE(code))].original_opcode; stack_pointer = _PyFrame_GetStackPointer(frame); next_instr = this_instr; - } else {/* Escaping */ + } else { _PyFrame_SetStackPointer(frame, stack_pointer); original_opcode = _Py_call_instrumentation_line( tstate, frame, this_instr, prev_instr); @@ -4841,7 +4837,7 @@ if (tstate->tracing == 0) { uintptr_t global_version = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & ~_PY_EVAL_EVENTS_MASK; uintptr_t code_version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version); - if (code_version != global_version) {/* Escaping */ + if (code_version != global_version) { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_Instrument(_PyFrame_GetCode(frame), tstate->interp); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4858,7 +4854,7 @@ if ((oparg & RESUME_OPARG_LOCATION_MASK) < RESUME_AFTER_YIELD_FROM) { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -4868,7 +4864,6 @@ } // _MONITOR_RESUME { - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation( tstate, oparg > 0, frame, this_instr); @@ -4898,7 +4893,6 @@ // _RETURN_VALUE_EVENT { val = value; - /* Escaping */ stack_pointer[0] = val; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -4947,7 +4941,6 @@ // _RETURN_VALUE_EVENT { val = stack_pointer[-1]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_arg( tstate, PY_MONITORING_EVENT_PY_RETURN, @@ -4993,7 +4986,6 @@ // _YIELD_VALUE_EVENT { val = stack_pointer[-1]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_arg( tstate, PY_MONITORING_EVENT_PY_YIELD, @@ -5016,7 +5008,7 @@ #if TIER_ONE assert(frame != &entry_frame); #endif - frame->instr_ptr++;/* Escaping */ + frame->instr_ptr++; _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5060,7 +5052,7 @@ INSTRUCTION_STATS(INTERPRETER_EXIT); _PyStackRef retval; retval = stack_pointer[-1]; - assert(frame == &entry_frame);/* Escaping */ + assert(frame == &entry_frame); _PyFrame_SetStackPointer(frame, stack_pointer); assert(_PyFrame_IsIncomplete(frame)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5107,7 +5099,7 @@ { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5130,7 +5122,7 @@ oparg >>= 8; start--; } - _PyExecutorObject *executor;/* Escaping */ + _PyExecutorObject *executor; _PyFrame_SetStackPointer(frame, stack_pointer); int optimized = _PyOptimizer_Optimize(frame, start, stack_pointer, &executor, 0); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5140,7 +5132,7 @@ tstate->previous_executor = Py_None; GOTO_TIER_TWO(executor); } - else {/* Escaping */ + else { _PyFrame_SetStackPointer(frame, stack_pointer); this_instr[1].counter = restart_backoff_counter(counter); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5201,19 +5193,20 @@ iterable_st = stack_pointer[-1]; list_st = stack_pointer[-2 - (oparg-1)]; PyObject *list = PyStackRef_AsPyObjectBorrow(list_st); - PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st);/* Escaping */ + PyObject *iterable = PyStackRef_AsPyObjectBorrow(iterable_st); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *none_val = _PyList_Extend((PyListObject *)list, iterable); stack_pointer = _PyFrame_GetStackPointer(frame); - if (none_val == NULL) {/* Escaping */ + if (none_val == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_TypeError); stack_pointer = _PyFrame_GetStackPointer(frame); if (matches && (Py_TYPE(iterable)->tp_iter == NULL && !PySequence_Check(iterable))) - {/* Escaping */ + { _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_Clear(tstate);/* Escaping */_PyErr_Format(tstate, PyExc_TypeError, + _PyErr_Clear(tstate); + _PyErr_Format(tstate, PyExc_TypeError, "Value after * must be an iterable, not %.200s", Py_TYPE(iterable)->tp_name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5246,7 +5239,7 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); - next_instr = this_instr;/* Escaping */ + next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_LoadAttr(owner, next_instr, name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5263,7 +5256,7 @@ PyObject *attr_o; if (oparg & 1) { /* Designed to work in tandem with CALL, pushes two values. */ - attr_o = NULL;/* Escaping */ + attr_o = NULL; _PyFrame_SetStackPointer(frame, stack_pointer); int is_meth = _PyObject_GetMethod(PyStackRef_AsPyObjectBorrow(owner), name, &attr_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5288,7 +5281,7 @@ } } else { - /* Classic, pushes one value. *//* Escaping */ + /* Classic, pushes one value. */ _PyFrame_SetStackPointer(frame, stack_pointer); attr_o = PyObject_GetAttr(PyStackRef_AsPyObjectBorrow(owner), name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5865,12 +5858,12 @@ next_instr += 1; INSTRUCTION_STATS(LOAD_BUILD_CLASS); _PyStackRef bc; - PyObject *bc_o;/* Escaping */ + PyObject *bc_o; _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(BUILTINS(), &_Py_ID(__build_class__), &bc_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) goto error; - if (bc_o == NULL) {/* Escaping */ + if (bc_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_NameError, "__build_class__ not found"); @@ -5927,7 +5920,7 @@ _PyStackRef value; PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); PyObject *value_o = PyCell_GetRef(cell); - if (value_o == NULL) {/* Escaping */ + if (value_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -5973,7 +5966,7 @@ INSTRUCTION_STATS(LOAD_FAST_CHECK); _PyStackRef value; _PyStackRef value_s = GETLOCAL(oparg); - if (PyStackRef_IsNull(value_s)) {/* Escaping */ + if (PyStackRef_IsNull(value_s)) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_UnboundLocalError, UNBOUNDLOCAL_ERROR_MSG, @@ -6018,7 +6011,7 @@ PyObject *class_dict = PyStackRef_AsPyObjectBorrow(class_dict_st); assert(class_dict); assert(oparg >= 0 && oparg < _PyFrame_GetCode(frame)->co_nlocalsplus); - name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg);/* Escaping */ + name = PyTuple_GET_ITEM(_PyFrame_GetCode(frame)->co_localsplusnames, oparg); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(class_dict, name, &value_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6028,7 +6021,7 @@ if (!value_o) { PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); value_o = PyCell_GetRef(cell); - if (value_o == NULL) {/* Escaping */ + if (value_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6049,7 +6042,7 @@ _PyStackRef v; mod_or_class_dict = stack_pointer[-1]; PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - PyObject *v_o;/* Escaping */ + PyObject *v_o; _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(PyStackRef_AsPyObjectBorrow(mod_or_class_dict), name, &v_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6058,7 +6051,7 @@ if (v_o == NULL) { if (PyDict_CheckExact(GLOBALS()) && PyDict_CheckExact(BUILTINS())) - {/* Escaping */ + { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -6069,7 +6062,7 @@ if (v_o == NULL) { if (!_PyErr_Occurred(tstate)) { /* _PyDict_LoadGlobal() returns NULL without raising - * an exception if the key doesn't exist *//* Escaping */ + * an exception if the key doesn't exist */ _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg(tstate, PyExc_NameError, NAME_ERROR_MSG, name); @@ -6080,7 +6073,7 @@ } else { /* Slow-path if globals or builtins is not a dict */ - /* namespace 1: globals *//* Escaping */ + /* namespace 1: globals */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -6088,12 +6081,12 @@ stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) goto error; if (v_o == NULL) { - /* namespace 2: builtins *//* Escaping */ + /* namespace 2: builtins */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(BUILTINS(), name, &v_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) goto error; - if (v_o == NULL) {/* Escaping */ + if (v_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcCheckArg( tstate, PyExc_NameError, @@ -6127,7 +6120,7 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); - next_instr = this_instr;/* Escaping */ + next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_LoadGlobal(GLOBALS(), BUILTINS(), next_instr, name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6143,7 +6136,7 @@ // _LOAD_GLOBAL { res = &stack_pointer[0]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg>>1); _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_LoadGlobalStackRef(GLOBALS(), BUILTINS(), name, res); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6241,7 +6234,7 @@ INSTRUCTION_STATS(LOAD_LOCALS); _PyStackRef locals; PyObject *l = LOCALS(); - if (l == NULL) {/* Escaping */ + if (l == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_SetString(tstate, PyExc_SystemError, "no locals found"); @@ -6260,7 +6253,7 @@ next_instr += 1; INSTRUCTION_STATS(LOAD_NAME); _PyStackRef v; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *v_o = _PyEval_LoadName(tstate, frame, name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6283,14 +6276,14 @@ assert(oparg <= SPECIAL_MAX); PyObject *owner_o = PyStackRef_AsPyObjectSteal(owner); PyObject *name = _Py_SpecialMethods[oparg].name; - PyObject *self_or_null_o;/* Escaping */ + PyObject *self_or_null_o; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); attr = PyStackRef_FromPyObjectSteal(_PyObject_LookupSpecialMethod(owner_o, name, &self_or_null_o)); stack_pointer = _PyFrame_GetStackPointer(frame); if (PyStackRef_IsNull(attr)) { - if (!_PyErr_Occurred(tstate)) {/* Escaping */ + if (!_PyErr_Occurred(tstate)) { stack_pointer[0] = attr; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -6338,7 +6331,7 @@ #if ENABLE_SPECIALIZATION int load_method = oparg & 1; if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr;/* Escaping */ + next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_LoadSuperAttr(global_super_st, class_st, next_instr, load_method); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6355,7 +6348,7 @@ PyObject *class = PyStackRef_AsPyObjectBorrow(class_st); PyObject *self = PyStackRef_AsPyObjectBorrow(self_st); if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) { - PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING;/* Escaping */ + PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING; _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_CALL, @@ -6370,26 +6363,26 @@ } // we make no attempt to optimize here; specializations should // handle any case whose performance we care about - PyObject *stack[] = {class, self};/* Escaping */ + PyObject *stack[] = {class, self}; _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *super = PyObject_Vectorcall(global_super, stack, oparg & 2, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); if (opcode == INSTRUMENTED_LOAD_SUPER_ATTR) { PyObject *arg = oparg & 2 ? class : &_PyInstrumentation_MISSING; - if (super == NULL) {/* Escaping */ + if (super == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _Py_call_instrumentation_exc2( tstate, PY_MONITORING_EVENT_C_RAISE, frame, this_instr, global_super, arg); stack_pointer = _PyFrame_GetStackPointer(frame); } - else {/* Escaping */ + else { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( tstate, PY_MONITORING_EVENT_C_RETURN, frame, this_instr, global_super, arg); stack_pointer = _PyFrame_GetStackPointer(frame); - if (err < 0) {/* Escaping */ + if (err < 0) { _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(super); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6400,7 +6393,7 @@ PyStackRef_CLOSE(class_st); PyStackRef_CLOSE(self_st); if (super == NULL) goto pop_3_error; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); stack_pointer += -3; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -6437,7 +6430,7 @@ DEOPT_IF(global_super != (PyObject *)&PySuper_Type, LOAD_SUPER_ATTR); DEOPT_IF(!PyType_Check(class), LOAD_SUPER_ATTR); STAT_INC(LOAD_SUPER_ATTR, hit); - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attr = _PySuper_Lookup((PyTypeObject *)class, self, name, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6475,7 +6468,7 @@ STAT_INC(LOAD_SUPER_ATTR, hit); PyObject *name = GETITEM(FRAME_CO_NAMES, oparg >> 2); PyTypeObject *cls = (PyTypeObject *)class; - int method_found = 0;/* Escaping */ + int method_found = 0; _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attr_o = _PySuper_Lookup(cls, self, name, Py_TYPE(self)->tp_getattro == PyObject_GenericGetAttr ? &method_found : NULL); @@ -6522,14 +6515,13 @@ _PyStackRef codeobj_st; _PyStackRef func; codeobj_st = stack_pointer[-1]; - PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st);/* Escaping */ + PyObject *codeobj = PyStackRef_AsPyObjectBorrow(codeobj_st); _PyFrame_SetStackPointer(frame, stack_pointer); PyFunctionObject *func_obj = (PyFunctionObject *) PyFunction_New(codeobj, GLOBALS()); stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(codeobj_st); if (func_obj == NULL) goto pop_1_error; - /* Escaping */ stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -6556,7 +6548,7 @@ PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st); assert(PyDict_CheckExact(dict)); /* dict[key] = value */ - // Do not DECREF INPUTS because the function steals the references/* Escaping */ + // Do not DECREF INPUTS because the function steals the references _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_SetItem_Take2( (PyDictObject *)dict, @@ -6583,7 +6575,7 @@ subject = stack_pointer[-3]; // Pop TOS and TOS1. Set TOS to a tuple of attributes on success, or // None on failure. - assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names)));/* Escaping */ + assert(PyTuple_CheckExact(PyStackRef_AsPyObjectBorrow(names))); _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *attrs_o = _PyEval_MatchClass(tstate, PyStackRef_AsPyObjectBorrow(subject), @@ -6617,7 +6609,7 @@ _PyStackRef values_or_none; keys = stack_pointer[-1]; subject = stack_pointer[-2]; - // On successful match, PUSH(values). Otherwise, PUSH(None)./* Escaping */ + // On successful match, PUSH(values). Otherwise, PUSH(None). _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *values_or_none_o = _PyEval_MatchKeys(tstate, PyStackRef_AsPyObjectBorrow(subject), PyStackRef_AsPyObjectBorrow(keys)); @@ -6673,7 +6665,7 @@ INSTRUCTION_STATS(POP_EXCEPT); _PyStackRef exc_value; exc_value = stack_pointer[-1]; - _PyErr_StackItem *exc_info = tstate->exc_info;/* Escaping */ + _PyErr_StackItem *exc_info = tstate->exc_info; _PyFrame_SetStackPointer(frame, stack_pointer); Py_XSETREF(exc_info->exc_value, PyStackRef_Is(exc_value, PyStackRef_None) @@ -6850,14 +6842,14 @@ args = &stack_pointer[-oparg]; assert(oparg < 3); PyObject *cause = oparg == 2 ? PyStackRef_AsPyObjectSteal(args[1]) : NULL; - PyObject *exc = oparg > 0 ? PyStackRef_AsPyObjectSteal(args[0]) : NULL;/* Escaping */ + PyObject *exc = oparg > 0 ? PyStackRef_AsPyObjectSteal(args[0]) : NULL; stack_pointer += -oparg; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); int err = do_raise(tstate, exc, cause); stack_pointer = _PyFrame_GetStackPointer(frame); if (err) { - assert(oparg == 0);/* Escaping */ + assert(oparg == 0); _PyFrame_SetStackPointer(frame, stack_pointer); monitor_reraise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6879,7 +6871,7 @@ assert(oparg >= 0 && oparg <= 2); if (oparg) { PyObject *lasti = PyStackRef_AsPyObjectBorrow(values[0]); - if (PyLong_Check(lasti)) {/* Escaping */ + if (PyLong_Check(lasti)) { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -6887,7 +6879,7 @@ stack_pointer = _PyFrame_GetStackPointer(frame); assert(!_PyErr_Occurred(tstate)); } - else {/* Escaping */ + else { stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -6899,11 +6891,12 @@ stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); } - assert(exc && PyExceptionInstance_Check(exc));/* Escaping */ + assert(exc && PyExceptionInstance_Check(exc)); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); - _PyErr_SetRaisedException(tstate, exc);/* Escaping */monitor_reraise(tstate, frame, this_instr); + _PyErr_SetRaisedException(tstate, exc); + monitor_reraise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); goto exception_unwind; } @@ -6929,7 +6922,7 @@ if (tstate->tracing == 0) { uintptr_t global_version = _Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & ~_PY_EVAL_EVENTS_MASK; uintptr_t code_version = FT_ATOMIC_LOAD_UINTPTR_ACQUIRE(_PyFrame_GetCode(frame)->_co_instrumentation_version); - if (code_version != global_version) {/* Escaping */ + if (code_version != global_version) { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_Instrument(_PyFrame_GetCode(frame), tstate->interp); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -6954,7 +6947,7 @@ if ((oparg & RESUME_OPARG_LOCATION_MASK) < RESUME_AFTER_YIELD_FROM) { _Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY(); QSBR_QUIESCENT_STATE(tstate); \ - if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) {/* Escaping */ + if (_Py_atomic_load_uintptr_relaxed(&tstate->eval_breaker) & _PY_EVAL_EVENTS_MASK) { _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_HandlePending(tstate); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7023,7 +7016,7 @@ INSTRUCTION_STATS(RETURN_GENERATOR); _PyStackRef res; assert(PyStackRef_FunctionCheck(frame->f_funcobj)); - PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj);/* Escaping */ + PyFunctionObject *func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj); _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = (PyGenObject *)_Py_MakeCoro(func); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7031,13 +7024,13 @@ assert(EMPTY()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *gen_frame = &gen->gi_iframe; - frame->instr_ptr++;/* Escaping *//* Virtual flush 1 */ + frame->instr_ptr++;/* Virtual flush 1 */ _PyFrame_Copy(frame, gen_frame);/* Virtual reload 1 */ assert(frame->frame_obj == NULL); gen->gi_frame_state = FRAME_CREATED; gen_frame->owner = FRAME_OWNED_BY_GENERATOR; _Py_LeaveRecursiveCallPy(tstate); - _PyInterpreterFrame *prev = frame->previous;/* Escaping *//* Virtual flush 1 */ + _PyInterpreterFrame *prev = frame->previous;/* Virtual flush 1 */ _PyThreadState_PopFrame(tstate, frame);/* Virtual reload 1 */ frame = tstate->current_frame = prev; LOAD_IP(frame->return_offset); @@ -7097,7 +7090,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr;/* Escaping */ + next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_Send(receiver, next_instr); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7130,27 +7123,27 @@ gen_frame->previous = frame; DISPATCH_INLINED(gen_frame); } - if (PyStackRef_Is(v, PyStackRef_None) && PyIter_Check(receiver_o)) {/* Escaping */ + if (PyStackRef_Is(v, PyStackRef_None) && PyIter_Check(receiver_o)) { _PyFrame_SetStackPointer(frame, stack_pointer); retval_o = Py_TYPE(receiver_o)->tp_iternext(receiver_o); stack_pointer = _PyFrame_GetStackPointer(frame); } - else {/* Escaping */ + else { _PyFrame_SetStackPointer(frame, stack_pointer); retval_o = PyObject_CallMethodOneArg(receiver_o, &_Py_ID(send), PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); } - if (retval_o == NULL) {/* Escaping */ + if (retval_o == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); int matches = _PyErr_ExceptionMatches(tstate, PyExc_StopIteration); stack_pointer = _PyFrame_GetStackPointer(frame); - if (matches) {/* Escaping */ + if (matches) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_MonitorRaise(tstate, frame, this_instr); stack_pointer = _PyFrame_GetStackPointer(frame); - }/* Escaping */ + } _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyGen_FetchStopIterationValue(&retval_o); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7227,24 +7220,23 @@ next_instr += 1; INSTRUCTION_STATS(SETUP_ANNOTATIONS); PyObject *ann_dict; - if (LOCALS() == NULL) {/* Escaping */ + if (LOCALS() == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when setting up annotations"); stack_pointer = _PyFrame_GetStackPointer(frame); if (true) goto error; } - /* check if __annotations__ in locals()... *//* Escaping */ + /* check if __annotations__ in locals()... */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyMapping_GetOptionalItem(LOCALS(), &_Py_ID(__annotations__), &ann_dict); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) goto error; - if (ann_dict == NULL) {/* Escaping */ + if (ann_dict == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); ann_dict = PyDict_New(); stack_pointer = _PyFrame_GetStackPointer(frame); if (ann_dict == NULL) goto error; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(LOCALS(), &_Py_ID(__annotations__), ann_dict); @@ -7266,7 +7258,6 @@ _PyStackRef v; v = stack_pointer[-1]; set = stack_pointer[-2 - (oparg-1)]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PySet_Add(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(v)); @@ -7310,7 +7301,6 @@ _PyStackRef iterable; iterable = stack_pointer[-1]; set = stack_pointer[-2 - (oparg-1)]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PySet_Update(PyStackRef_AsPyObjectBorrow(set), PyStackRef_AsPyObjectBorrow(iterable)); @@ -7339,7 +7329,7 @@ #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); - next_instr = this_instr;/* Escaping */ + next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_StoreAttr(owner, next_instr, name); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7353,7 +7343,7 @@ // _STORE_ATTR { v = stack_pointer[-2]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_SetAttr(PyStackRef_AsPyObjectBorrow(owner), name, PyStackRef_AsPyObjectBorrow(v)); @@ -7482,13 +7472,13 @@ PyDictUnicodeEntry *ep = DK_UNICODE_ENTRIES(dict->ma_keys) + hint; DEOPT_IF(ep->me_key != name, STORE_ATTR); /* Ensure dict is GC tracked if it needs to be */ - if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(PyStackRef_AsPyObjectBorrow(value))) {/* Escaping */ + if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(PyStackRef_AsPyObjectBorrow(value))) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyObject_GC_TRACK(dict); stack_pointer = _PyFrame_GetStackPointer(frame); } old_value = ep->me_value; - PyDict_WatchEvent event = old_value == NULL ? PyDict_EVENT_ADDED : PyDict_EVENT_MODIFIED;/* Escaping */ + PyDict_WatchEvent event = old_value == NULL ? PyDict_EVENT_ADDED : PyDict_EVENT_MODIFIED; _PyFrame_SetStackPointer(frame, stack_pointer); new_version = _PyDict_NotifyEvent(tstate->interp, event, dict, name, PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7511,7 +7501,7 @@ INSTRUCTION_STATS(STORE_DEREF); _PyStackRef v; v = stack_pointer[-1]; - PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg));/* Escaping */ + PyCellObject *cell = (PyCellObject *)PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); _PyFrame_SetStackPointer(frame, stack_pointer); PyCell_SetTakeRef(cell, PyStackRef_AsPyObjectSteal(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7570,7 +7560,7 @@ INSTRUCTION_STATS(STORE_GLOBAL); _PyStackRef v; v = stack_pointer[-1]; - PyObject *name = GETITEM(FRAME_CO_NAMES, oparg);/* Escaping */ + PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyDict_SetItem(GLOBALS(), name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7590,7 +7580,7 @@ PyObject *name = GETITEM(FRAME_CO_NAMES, oparg); PyObject *ns = LOCALS(); int err; - if (ns == NULL) {/* Escaping */ + if (ns == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyErr_Format(tstate, PyExc_SystemError, "no locals found when storing %R", name); @@ -7598,12 +7588,12 @@ PyStackRef_CLOSE(v); if (true) goto pop_1_error; } - if (PyDict_CheckExact(ns)) {/* Escaping */ + if (PyDict_CheckExact(ns)) { _PyFrame_SetStackPointer(frame, stack_pointer); err = PyDict_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); } - else {/* Escaping */ + else { _PyFrame_SetStackPointer(frame, stack_pointer); err = PyObject_SetItem(ns, name, PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7636,7 +7626,6 @@ start = stack_pointer[-2]; container = stack_pointer[-3]; v = stack_pointer[-4]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *slice = _PyBuildSlice_ConsumeRefs(PyStackRef_AsPyObjectSteal(start), PyStackRef_AsPyObjectSteal(stop)); @@ -7645,7 +7634,7 @@ if (slice == NULL) { err = 1; } - else {/* Escaping */ + else { stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -7682,7 +7671,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr;/* Escaping */ + next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_StoreSubscr(container, sub, next_instr); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7695,7 +7684,7 @@ // _STORE_SUBSCR { v = stack_pointer[-3]; - /* container[sub] = v *//* Escaping */ + /* container[sub] = v */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_SetItem(PyStackRef_AsPyObjectBorrow(container), PyStackRef_AsPyObjectBorrow(sub), PyStackRef_AsPyObjectBorrow(v)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7723,7 +7712,7 @@ value = stack_pointer[-3]; PyObject *dict = PyStackRef_AsPyObjectBorrow(dict_st); DEOPT_IF(!PyDict_CheckExact(dict), STORE_SUBSCR); - STAT_INC(STORE_SUBSCR, hit);/* Escaping */ + STAT_INC(STORE_SUBSCR, hit); _PyFrame_SetStackPointer(frame, stack_pointer); int err = _PyDict_SetItem_Take2((PyDictObject *)dict, PyStackRef_AsPyObjectSteal(sub), @@ -7803,7 +7792,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr;/* Escaping */ + next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_ToBool(value, next_instr); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7816,7 +7805,6 @@ /* Skip 2 cache entries */ // _TO_BOOL { - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); int err = PyObject_IsTrue(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7882,7 +7870,7 @@ PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); DEOPT_IF(!PyLong_CheckExact(value_o), TO_BOOL); STAT_INC(TO_BOOL, hit); - if (_PyLong_IsZero((PyLongObject *)value_o)) {/* Escaping */ + if (_PyLong_IsZero((PyLongObject *)value_o)) { _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7946,7 +7934,7 @@ PyObject *value_o = PyStackRef_AsPyObjectBorrow(value); DEOPT_IF(!PyUnicode_CheckExact(value_o), TO_BOOL); STAT_INC(TO_BOOL, hit); - if (value_o == &_Py_STR(empty)) {/* Escaping */ + if (value_o == &_Py_STR(empty)) { _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7968,7 +7956,6 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyNumber_Invert(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -7986,7 +7973,6 @@ _PyStackRef value; _PyStackRef res; value = stack_pointer[-1]; - /* Escaping */ _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyNumber_Negative(PyStackRef_AsPyObjectBorrow(value)); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -8019,7 +8005,7 @@ _PyStackRef *right; seq = stack_pointer[-1]; right = &stack_pointer[(oparg & 0xFF)]; - _PyStackRef *top = right + (oparg >> 8);/* Escaping */ + _PyStackRef *top = right + (oparg >> 8); _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg & 0xFF, oparg >> 8, top); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -8046,7 +8032,7 @@ (void)counter; #if ENABLE_SPECIALIZATION if (ADAPTIVE_COUNTER_TRIGGERS(counter)) { - next_instr = this_instr;/* Escaping */ + next_instr = this_instr; _PyFrame_SetStackPointer(frame, stack_pointer); _Py_Specialize_UnpackSequence(seq, next_instr, oparg); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -8061,7 +8047,7 @@ // _UNPACK_SEQUENCE { output = &stack_pointer[-1]; - _PyStackRef *top = output + oparg;/* Escaping */ + _PyStackRef *top = output + oparg; _PyFrame_SetStackPointer(frame, stack_pointer); int res = _PyEval_UnpackIterableStackRef(tstate, seq, oparg, -1, top); stack_pointer = _PyFrame_GetStackPointer(frame); @@ -8171,9 +8157,10 @@ PyObject *exc, *tb; PyObject *val_o = PyStackRef_AsPyObjectBorrow(val); PyObject *exit_func_o = PyStackRef_AsPyObjectBorrow(exit_func); - assert(val_o && PyExceptionInstance_Check(val_o));/* Escaping */ + assert(val_o && PyExceptionInstance_Check(val_o)); _PyFrame_SetStackPointer(frame, stack_pointer); - exc = PyExceptionInstance_Class(val_o);/* Escaping */tb = PyException_GetTraceback(val_o); + exc = PyExceptionInstance_Class(val_o); + tb = PyException_GetTraceback(val_o); stack_pointer = _PyFrame_GetStackPointer(frame); if (tb == NULL) { tb = Py_None; @@ -8184,7 +8171,7 @@ assert(PyStackRef_LongCheck(lasti)); (void)lasti; // Shut up compiler warning if asserts are off PyObject *stack[5] = {NULL, PyStackRef_AsPyObjectBorrow(exit_self), exc, val_o, tb}; - int has_self = !PyStackRef_IsNull(exit_self);/* Escaping */ + int has_self = !PyStackRef_IsNull(exit_self); _PyFrame_SetStackPointer(frame, stack_pointer); res = PyStackRef_FromPyObjectSteal(PyObject_Vectorcall(exit_func_o, stack + 2 - has_self, (3 + has_self) | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL)); @@ -8209,7 +8196,7 @@ #if TIER_ONE assert(frame != &entry_frame); #endif - frame->instr_ptr++;/* Escaping */ + frame->instr_ptr++; _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); stack_pointer = _PyFrame_GetStackPointer(frame); diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 71bfaa03aa163f..03348375668a26 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -362,7 +362,7 @@ sym_matches_type(left, &PyFloat_Type) && sym_matches_type(right, &PyFloat_Type)) { assert(PyFloat_CheckExact(sym_get_const(left))); - assert(PyFloat_CheckExact(sym_get_const(right)));/* Escaping */ + assert(PyFloat_CheckExact(sym_get_const(right))); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( @@ -397,7 +397,7 @@ sym_matches_type(left, &PyFloat_Type) && sym_matches_type(right, &PyFloat_Type)) { assert(PyFloat_CheckExact(sym_get_const(left))); - assert(PyFloat_CheckExact(sym_get_const(right)));/* Escaping */ + assert(PyFloat_CheckExact(sym_get_const(right))); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( @@ -432,7 +432,7 @@ sym_matches_type(left, &PyFloat_Type) && sym_matches_type(right, &PyFloat_Type)) { assert(PyFloat_CheckExact(sym_get_const(left))); - assert(PyFloat_CheckExact(sym_get_const(right)));/* Escaping */ + assert(PyFloat_CheckExact(sym_get_const(right))); stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( @@ -639,7 +639,7 @@ retval = stack_pointer[-1]; stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); - ctx->frame->stack_pointer = stack_pointer;/* Escaping */ + ctx->frame->stack_pointer = stack_pointer; frame_pop(ctx); stack_pointer = ctx->frame->stack_pointer; /* Stack space handling */ @@ -648,7 +648,7 @@ int framesize = co->co_framesize; assert(framesize > 0); assert(framesize <= curr_space); - curr_space -= framesize;/* Escaping */ + curr_space -= framesize; co = get_code(this_instr); if (co == NULL) { // might be impossible, but bailing is still safe @@ -1047,7 +1047,7 @@ if (sym_matches_type_version(owner, type_version)) { REPLACE_OP(this_instr, _NOP, 0, 0); } else { - // add watcher so that whenever the type changes we invalidate this/* Escaping */ + // add watcher so that whenever the type changes we invalidate this PyTypeObject *type = _PyType_LookupByVersion(type_version); // if the type is null, it was not found in the cache (there was a conflict) // with the key, in which case we can't trust the version @@ -1056,8 +1056,9 @@ // if it wasn't this means that the type version was previously set to something else // and we set the owner to bottom, so we don't need to add a watcher because we must have // already added one earlier. - if (sym_set_type_version(owner, type_version)) {/* Escaping */ - PyType_Watch(TYPE_WATCHER_ID, (PyObject *)type);/* Escaping */_Py_BloomFilter_Add(dependencies, type); + if (sym_set_type_version(owner, type_version)) { + PyType_Watch(TYPE_WATCHER_ID, (PyObject *)type); + _Py_BloomFilter_Add(dependencies, type); } } } @@ -1094,10 +1095,11 @@ PyObject *cnst = sym_get_const(owner); if (PyModule_CheckExact(cnst)) { PyModuleObject *mod = (PyModuleObject *)cnst; - PyObject *dict = mod->md_dict;/* Escaping */ + PyObject *dict = mod->md_dict; uint64_t watched_mutations = get_mutations(dict); - if (watched_mutations < _Py_MAX_ALLOWED_GLOBALS_MODIFICATIONS) {/* Escaping */ - PyDict_Watch(GLOBALS_WATCHER_ID, dict);/* Escaping */_Py_BloomFilter_Add(dependencies, dict); + if (watched_mutations < _Py_MAX_ALLOWED_GLOBALS_MODIFICATIONS) { + PyDict_Watch(GLOBALS_WATCHER_ID, dict); + _Py_BloomFilter_Add(dependencies, dict); this_instr->opcode = _NOP; } } @@ -1119,7 +1121,7 @@ assert(sym_is_const(owner)); PyModuleObject *mod = (PyModuleObject *)sym_get_const(owner); assert(PyModule_CheckExact(mod)); - PyObject *dict = mod->md_dict;/* Escaping */ + PyObject *dict = mod->md_dict; stack_pointer[-1] = attr; if (oparg & 1) stack_pointer[0] = null; stack_pointer += (oparg & 1); @@ -1250,7 +1252,7 @@ if (oparg & 16) { res = sym_new_type(ctx, &PyBool_Type); } - else {/* Escaping */ + else { stack_pointer += -2; assert(WITHIN_STACK_BOUNDS()); res = _Py_uop_sym_new_not_null(ctx); @@ -1810,11 +1812,11 @@ args--; argcount++; } - if (sym_is_null(self_or_null) || sym_is_not_null(self_or_null)) {/* Escaping */ + if (sym_is_null(self_or_null) || sym_is_not_null(self_or_null)) { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); new_frame = frame_new(ctx, co, 0, args, argcount); - } else {/* Escaping */ + } else { stack_pointer += -2 - oparg; assert(WITHIN_STACK_BOUNDS()); new_frame = frame_new(ctx, co, 0, NULL, 0); @@ -1833,7 +1835,7 @@ ctx->frame->stack_pointer = stack_pointer; ctx->frame = new_frame; ctx->curr_frame_depth++; - stack_pointer = new_frame->stack_pointer;/* Escaping */ + stack_pointer = new_frame->stack_pointer; co = get_code(this_instr); if (co == NULL) { // should be about to _EXIT_TRACE anyway @@ -2138,7 +2140,7 @@ case _RETURN_GENERATOR: { _Py_UopsSymbol *res; - ctx->frame->stack_pointer = stack_pointer;/* Escaping */ + ctx->frame->stack_pointer = stack_pointer; frame_pop(ctx); stack_pointer = ctx->frame->stack_pointer; res = sym_new_unknown(ctx); @@ -2148,7 +2150,7 @@ int framesize = co->co_framesize; assert(framesize > 0); assert(framesize <= curr_space); - curr_space -= framesize;/* Escaping */ + curr_space -= framesize; stack_pointer[0] = res; stack_pointer += 1; assert(WITHIN_STACK_BOUNDS()); @@ -2269,7 +2271,7 @@ flag = stack_pointer[-1]; if (sym_is_const(flag)) { PyObject *value = sym_get_const(flag); - assert(value != NULL);/* Escaping */ + assert(value != NULL); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); eliminate_pop_guard(this_instr, value != Py_True); @@ -2286,7 +2288,7 @@ flag = stack_pointer[-1]; if (sym_is_const(flag)) { PyObject *value = sym_get_const(flag); - assert(value != NULL);/* Escaping */ + assert(value != NULL); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); eliminate_pop_guard(this_instr, value != Py_False); @@ -2303,13 +2305,13 @@ flag = stack_pointer[-1]; if (sym_is_const(flag)) { PyObject *value = sym_get_const(flag); - assert(value != NULL);/* Escaping */ + assert(value != NULL); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); eliminate_pop_guard(this_instr, !Py_IsNone(value)); } else if (sym_has_type(flag)) { - assert(!sym_matches_type(flag, &_PyNone_Type));/* Escaping */ + assert(!sym_matches_type(flag, &_PyNone_Type)); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); eliminate_pop_guard(this_instr, true); @@ -2326,13 +2328,13 @@ flag = stack_pointer[-1]; if (sym_is_const(flag)) { PyObject *value = sym_get_const(flag); - assert(value != NULL);/* Escaping */ + assert(value != NULL); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); eliminate_pop_guard(this_instr, Py_IsNone(value)); } else if (sym_has_type(flag)) { - assert(!sym_matches_type(flag, &_PyNone_Type));/* Escaping */ + assert(!sym_matches_type(flag, &_PyNone_Type)); stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); eliminate_pop_guard(this_instr, false); From e2408e2123a88704934bf6d572b2410c61e973d4 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Mon, 30 Sep 2024 06:57:43 -0700 Subject: [PATCH 42/53] Find escaping calls of form (func)(args) and table[oparg](args) --- Include/internal/pycore_uop_metadata.h | 4 +-- Python/executor_cases.c.h | 14 +++++++++ Python/generated_cases.c.h | 16 +++++++++++ Tools/cases_generator/analyzer.py | 40 +++++++++++++++----------- 4 files changed, 55 insertions(+), 19 deletions(-) diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index fa22e0840e167e..e980cf662fcf60 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -230,7 +230,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_EXIT_INIT_CHECK] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_BUILTIN_O] = HAS_ARG_FLAG | HAS_EXIT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CALL_BUILTIN_FAST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG, + [_CALL_BUILTIN_FAST] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_BUILTIN_FAST_WITH_KEYWORDS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_LEN] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CALL_ISINSTANCE] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, @@ -255,7 +255,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_FORMAT_SIMPLE] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_FORMAT_WITH_SPEC] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_COPY] = HAS_ARG_FLAG | HAS_PURE_FLAG, - [_BINARY_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG, + [_BINARY_OP] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_SWAP] = HAS_ARG_FLAG | HAS_PURE_FLAG, [_GUARD_IS_TRUE_POP] = HAS_EXIT_FLAG, [_GUARD_IS_FALSE_POP] = HAS_EXIT_FLAG, diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index e5231110602256..548e7859f77c61 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -1301,7 +1301,9 @@ PyStackRef_CLOSE(obj); if (true) JUMP_TO_ERROR(); } + _PyFrame_SetStackPointer(frame, stack_pointer); iter_o = (*getter)(obj_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(obj); if (iter_o == NULL) JUMP_TO_ERROR(); if (Py_TYPE(iter_o)->tp_as_async == NULL || @@ -3348,7 +3350,9 @@ iter = stack_pointer[-1]; /* before: [iter]; after: [iter, iter()] *or* [] (and jump over END_FOR.) */ PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *next_o = (*Py_TYPE(iter_o)->tp_iternext)(iter_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (next_o == NULL) { if (_PyErr_Occurred(tstate)) { _PyFrame_SetStackPointer(frame, stack_pointer); @@ -4561,10 +4565,12 @@ } if (true) JUMP_TO_ERROR(); } + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = ((PyCFunctionFast)(void(*)(void))cfunc)( PyCFunction_GET_SELF(callable_o), args_o, total_args); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); /* Free the arguments. */ @@ -4606,9 +4612,11 @@ } STAT_INC(CALL, hit); /* res = func(self, args, nargs, kwnames) */ + _PyFrame_SetStackPointer(frame, stack_pointer); PyCFunctionFastWithKeywords cfunc = (PyCFunctionFastWithKeywords)(void(*)(void)) PyCFunction_GET_FUNCTION(callable_o); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { PyStackRef_CLOSE(callable[0]); @@ -4863,8 +4871,10 @@ } STAT_INC(CALL, hit); int nargs = total_args - 1; + _PyFrame_SetStackPointer(frame, stack_pointer); PyCFunctionFastWithKeywords cfunc = (PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth; + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { PyStackRef_CLOSE(callable[0]); @@ -4983,8 +4993,10 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(CALL, hit); + _PyFrame_SetStackPointer(frame, stack_pointer); PyCFunctionFast cfunc = (PyCFunctionFast)(void(*)(void))meth->ml_meth; + stack_pointer = _PyFrame_GetStackPointer(frame); int nargs = total_args - 1; STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { @@ -5445,7 +5457,9 @@ PyObject *lhs_o = PyStackRef_AsPyObjectBorrow(lhs); PyObject *rhs_o = PyStackRef_AsPyObjectBorrow(rhs); assert(_PyEval_BinaryOps[oparg]); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(lhs); PyStackRef_CLOSE(rhs); if (res_o == NULL) JUMP_TO_ERROR(); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 18951002f12f34..d558374aaefefc 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -44,7 +44,9 @@ PyObject *lhs_o = PyStackRef_AsPyObjectBorrow(lhs); PyObject *rhs_o = PyStackRef_AsPyObjectBorrow(rhs); assert(_PyEval_BinaryOps[oparg]); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = _PyEval_BinaryOps[oparg](lhs_o, rhs_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(lhs); PyStackRef_CLOSE(rhs); if (res_o == NULL) goto pop_2_error; @@ -1428,10 +1430,12 @@ goto error; } } + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = ((PyCFunctionFast)(void(*)(void))cfunc)( PyCFunction_GET_SELF(callable_o), args_o, total_args); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); /* Free the arguments. */ @@ -1495,9 +1499,11 @@ DEOPT_IF(PyCFunction_GET_FLAGS(callable_o) != (METH_FASTCALL | METH_KEYWORDS), CALL); STAT_INC(CALL, hit); /* res = func(self, args, nargs, kwnames) */ + _PyFrame_SetStackPointer(frame, stack_pointer); PyCFunctionFastWithKeywords cfunc = (PyCFunctionFastWithKeywords)(void(*)(void)) PyCFunction_GET_FUNCTION(callable_o); + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { PyStackRef_CLOSE(callable[0]); @@ -2425,8 +2431,10 @@ PyObject *self = PyStackRef_AsPyObjectBorrow(args[0]); DEOPT_IF(!Py_IS_TYPE(self, method->d_common.d_type), CALL); STAT_INC(CALL, hit); + _PyFrame_SetStackPointer(frame, stack_pointer); PyCFunctionFast cfunc = (PyCFunctionFast)(void(*)(void))meth->ml_meth; + stack_pointer = _PyFrame_GetStackPointer(frame); int nargs = total_args - 1; STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { @@ -2511,8 +2519,10 @@ DEOPT_IF(!Py_IS_TYPE(self, d_type), CALL); STAT_INC(CALL, hit); int nargs = total_args - 1; + _PyFrame_SetStackPointer(frame, stack_pointer); PyCFunctionFastWithKeywords cfunc = (PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth; + stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { PyStackRef_CLOSE(callable[0]); @@ -3926,7 +3936,9 @@ { /* before: [iter]; after: [iter, iter()] *or* [] (and jump over END_FOR.) */ PyObject *iter_o = PyStackRef_AsPyObjectBorrow(iter); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *next_o = (*Py_TYPE(iter_o)->tp_iternext)(iter_o); + stack_pointer = _PyFrame_GetStackPointer(frame); if (next_o == NULL) { if (_PyErr_Occurred(tstate)) { _PyFrame_SetStackPointer(frame, stack_pointer); @@ -4174,7 +4186,9 @@ PyStackRef_CLOSE(obj); if (true) goto pop_1_error; } + _PyFrame_SetStackPointer(frame, stack_pointer); iter_o = (*getter)(obj_o); + stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(obj); if (iter_o == NULL) goto pop_1_error; if (Py_TYPE(iter_o)->tp_as_async == NULL || @@ -4614,7 +4628,9 @@ _Py_CODEUNIT *target; _PyStackRef iter_stackref = TOP(); PyObject *iter = PyStackRef_AsPyObjectBorrow(iter_stackref); + _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *next = (*Py_TYPE(iter)->tp_iternext)(iter); + stack_pointer = _PyFrame_GetStackPointer(frame); if (next != NULL) { PUSH(PyStackRef_FromPyObjectSteal(next)); target = next_instr; diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index e9fcc734f7fe89..820bedd465bcc7 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -651,29 +651,35 @@ def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, tuple[le result: dict[lexer.Token, tuple[lexer.Token, lexer.Token]] = {} tokens = instr.block.tokens for idx, tkn in enumerate(tokens): - if tkn.kind != lexer.IDENTIFIER: - continue try: next_tkn = tokens[idx+1] except IndexError: break if next_tkn.kind != lexer.LPAREN: continue - if tkn.text.upper() == tkn.text: - # simple macro - continue - #if not tkn.text.startswith(("Py", "_Py", "monitor")): - # continue - if tkn.text.startswith(("sym_", "optimize_")): - # Optimize functions - continue - if tkn.text.endswith("Check"): - continue - if tkn.text.startswith("Py_Is"): - continue - if tkn.text.endswith("CheckExact"): - continue - if tkn.text in NON_ESCAPING_FUNCTIONS: + if tkn.kind == lexer.IDENTIFIER: + if tkn.text.upper() == tkn.text: + # simple macro + continue + #if not tkn.text.startswith(("Py", "_Py", "monitor")): + # continue + if tkn.text.startswith(("sym_", "optimize_")): + # Optimize functions + continue + if tkn.text.endswith("Check"): + continue + if tkn.text.startswith("Py_Is"): + continue + if tkn.text.endswith("CheckExact"): + continue + if tkn.text in NON_ESCAPING_FUNCTIONS: + continue + elif tkn.kind == "RPAREN": + prev = tokens[idx-1] + if prev.text.endswith("_t") or prev.text == "*": + #cast + continue + elif tkn.kind != "RBRACKET": continue start = find_stmt_start(instr, idx) end = find_stmt_end(instr, idx) From 7cd6f904c8af7eaff000f3c591014895b9265878 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Mon, 30 Sep 2024 10:15:07 -0700 Subject: [PATCH 43/53] Refactor optimizer_bytecodes.c a bit to help codegen understand it --- Python/optimizer_bytecodes.c | 16 ++++++++++------ Python/optimizer_cases.c.h | 32 ++++++++++++++++++-------------- 2 files changed, 28 insertions(+), 20 deletions(-) diff --git a/Python/optimizer_bytecodes.c b/Python/optimizer_bytecodes.c index e476bc754341a8..da8000864b3ae8 100644 --- a/Python/optimizer_bytecodes.c +++ b/Python/optimizer_bytecodes.c @@ -802,9 +802,11 @@ dummy_func(void) { assert(value != NULL); eliminate_pop_guard(this_instr, !Py_IsNone(value)); } - else if (sym_has_type(flag)) { - assert(!sym_matches_type(flag, &_PyNone_Type)); - eliminate_pop_guard(this_instr, true); + else { + if (sym_has_type(flag)) { + assert(!sym_matches_type(flag, &_PyNone_Type)); + eliminate_pop_guard(this_instr, true); + } } } @@ -814,9 +816,11 @@ dummy_func(void) { assert(value != NULL); eliminate_pop_guard(this_instr, Py_IsNone(value)); } - else if (sym_has_type(flag)) { - assert(!sym_matches_type(flag, &_PyNone_Type)); - eliminate_pop_guard(this_instr, false); + else { + if (sym_has_type(flag)) { + assert(!sym_matches_type(flag, &_PyNone_Type)); + eliminate_pop_guard(this_instr, false); + } } } diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 3fd2786edae1e6..5b3e272ea7d692 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -2310,13 +2310,15 @@ assert(WITHIN_STACK_BOUNDS()); eliminate_pop_guard(this_instr, !Py_IsNone(value)); } - else if (sym_has_type(flag)) { - assert(!sym_matches_type(flag, &_PyNone_Type)); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - eliminate_pop_guard(this_instr, true); - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + else { + if (sym_has_type(flag)) { + assert(!sym_matches_type(flag, &_PyNone_Type)); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + eliminate_pop_guard(this_instr, true); + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + } stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } @@ -2333,13 +2335,15 @@ assert(WITHIN_STACK_BOUNDS()); eliminate_pop_guard(this_instr, Py_IsNone(value)); } - else if (sym_has_type(flag)) { - assert(!sym_matches_type(flag, &_PyNone_Type)); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - eliminate_pop_guard(this_instr, false); - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + else { + if (sym_has_type(flag)) { + assert(!sym_matches_type(flag, &_PyNone_Type)); + stack_pointer += -1; + assert(WITHIN_STACK_BOUNDS()); + eliminate_pop_guard(this_instr, false); + stack_pointer += 1; + assert(WITHIN_STACK_BOUNDS()); + } stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); } From 7a774910a06f9c5ca227880ff541ad81fc42a9b8 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Tue, 1 Oct 2024 05:48:11 -0700 Subject: [PATCH 44/53] Fix lexer bug --- Tools/cases_generator/lexer.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Tools/cases_generator/lexer.py b/Tools/cases_generator/lexer.py index c6293a77d5ac87..e628d89b966c91 100644 --- a/Tools/cases_generator/lexer.py +++ b/Tools/cases_generator/lexer.py @@ -79,7 +79,7 @@ def choice(*opts: str) -> str: opmap = {pattern.replace("\\", "") or "\\": op for op, pattern in operators.items()} # Macros -macro = r"# *(ifdef|ifndef|undef|define|error|endif|if +defined|if|else|include|#)" +macro = r"#.*\n" CMACRO = "CMACRO" id_re = r"[a-zA-Z_][0-9a-zA-Z_]*" @@ -312,6 +312,8 @@ def tokenize(src: str, line: int = 1, filename: str = "") -> Iterator[Token]: kind = CHARACTER elif text[0] == "#": kind = CMACRO + linestart = start + line += 1 elif text[0] == "/" and text[1] in "/*": kind = COMMENT else: From 60f5054216b57b3eeef2c4d4df50510584d0e850 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Tue, 1 Oct 2024 06:30:53 -0700 Subject: [PATCH 45/53] Tweak formatting of code directly after C macros --- Python/executor_cases.c.h | 28 +++++++--------------------- Python/generated_cases.c.h | 24 +++++++++++------------- Tools/cases_generator/analyzer.py | 12 ++++++++++-- Tools/cases_generator/cwriter.py | 5 ++++- Tools/cases_generator/lexer.py | 5 +++-- 5 files changed, 35 insertions(+), 39 deletions(-) diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 548e7859f77c61..8abae31f532353 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -1419,11 +1419,11 @@ assert(INLINE_CACHE_ENTRIES_SEND == INLINE_CACHE_ENTRIES_FOR_ITER); #if TIER_ONE assert(frame->instr_ptr->op.code == INSTRUMENTED_LINE || - frame->instr_ptr->op.code == INSTRUMENTED_INSTRUCTION || - _PyOpcode_Deopt[frame->instr_ptr->op.code] == SEND || - _PyOpcode_Deopt[frame->instr_ptr->op.code] == FOR_ITER || - _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT || - _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR); + frame->instr_ptr->op.code == INSTRUMENTED_INSTRUCTION || + _PyOpcode_Deopt[frame->instr_ptr->op.code] == SEND || + _PyOpcode_Deopt[frame->instr_ptr->op.code] == FOR_ITER || + _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT || + _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR); #endif stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND); @@ -4386,8 +4386,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame); - assert(_PyCode_CODE(_PyFrame_GetCode(shim))[0].op.code == EXIT_INIT_CHECK); stack_pointer = _PyFrame_GetStackPointer(frame); + assert(_PyCode_CODE(_PyFrame_GetCode(shim))[0].op.code == EXIT_INIT_CHECK); /* Push self onto stack of shim */ shim->localsplus[0] = PyStackRef_DUP(self[0]); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -5600,11 +5600,9 @@ PyObject *exit_p = (PyObject *)CURRENT_OPERAND(); _PyExitData *exit = (_PyExitData *)exit_p; PyCodeObject *code = _PyFrame_GetCode(frame); - _PyFrame_SetStackPointer(frame, stack_pointer); _Py_CODEUNIT *target = _PyCode_CODE(code) + exit->target; #if defined(Py_DEBUG) && !defined(_Py_JIT) OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); - stack_pointer = _PyFrame_GetStackPointer(frame); if (lltrace >= 2) { _PyFrame_SetStackPointer(frame, stack_pointer); printf("SIDE EXIT: [UOp "); @@ -5617,17 +5615,15 @@ } #endif if (exit->executor && !exit->executor->vm_data.valid) { - _PyFrame_SetStackPointer(frame, stack_pointer); exit->temperature = initial_temperature_backoff_counter(); + _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(exit->executor); stack_pointer = _PyFrame_GetStackPointer(frame); } if (exit->executor == NULL) { _Py_BackoffCounter temperature = exit->temperature; if (!backoff_counter_triggers(temperature)) { - _PyFrame_SetStackPointer(frame, stack_pointer); exit->temperature = advance_backoff_counter(temperature); - stack_pointer = _PyFrame_GetStackPointer(frame); tstate->previous_executor = (PyObject *)current_executor; GOTO_TIER_ONE(target); } @@ -5642,9 +5638,7 @@ int optimized = _PyOptimizer_Optimize(frame, target, stack_pointer, &executor, chain_depth); stack_pointer = _PyFrame_GetStackPointer(frame); if (optimized <= 0) { - _PyFrame_SetStackPointer(frame, stack_pointer); exit->temperature = restart_backoff_counter(temperature); - stack_pointer = _PyFrame_GetStackPointer(frame); if (optimized < 0) { GOTO_UNWIND(); } @@ -5751,10 +5745,8 @@ tstate->previous_executor = (PyObject *)current_executor; _PyExitData *exit = (_PyExitData *)exit_p; _Py_CODEUNIT *target = frame->instr_ptr; - _PyFrame_SetStackPointer(frame, stack_pointer); #if defined(Py_DEBUG) && !defined(_Py_JIT) OPT_HIST(trace_uop_execution_counter, trace_run_length_hist); - stack_pointer = _PyFrame_GetStackPointer(frame); if (lltrace >= 2) { _PyFrame_SetStackPointer(frame, stack_pointer); printf("DYNAMIC EXIT: [UOp "); @@ -5774,27 +5766,21 @@ } else { if (!backoff_counter_triggers(exit->temperature)) { - _PyFrame_SetStackPointer(frame, stack_pointer); exit->temperature = advance_backoff_counter(exit->temperature); - stack_pointer = _PyFrame_GetStackPointer(frame); GOTO_TIER_ONE(target); } _PyFrame_SetStackPointer(frame, stack_pointer); int optimized = _PyOptimizer_Optimize(frame, target, stack_pointer, &executor, 0); stack_pointer = _PyFrame_GetStackPointer(frame); if (optimized <= 0) { - _PyFrame_SetStackPointer(frame, stack_pointer); exit->temperature = restart_backoff_counter(exit->temperature); - stack_pointer = _PyFrame_GetStackPointer(frame); if (optimized < 0) { GOTO_UNWIND(); } GOTO_TIER_ONE(target); } else { - _PyFrame_SetStackPointer(frame, stack_pointer); exit->temperature = initial_temperature_backoff_counter(); - stack_pointer = _PyFrame_GetStackPointer(frame); } } GOTO_TIER_TWO(executor); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index d558374aaefefc..b19f1ec4c74c72 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -1068,8 +1068,8 @@ _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *shim = _PyFrame_PushTrampolineUnchecked( tstate, (PyCodeObject *)&_Py_InitCleanup, 1, frame); - assert(_PyCode_CODE(_PyFrame_GetCode(shim))[0].op.code == EXIT_INIT_CHECK); stack_pointer = _PyFrame_GetStackPointer(frame); + assert(_PyCode_CODE(_PyFrame_GetCode(shim))[0].op.code == EXIT_INIT_CHECK); /* Push self onto stack of shim */ shim->localsplus[0] = PyStackRef_DUP(self[0]); _PyFrame_SetStackPointer(frame, stack_pointer); @@ -5045,11 +5045,11 @@ assert(INLINE_CACHE_ENTRIES_SEND == INLINE_CACHE_ENTRIES_FOR_ITER); #if TIER_ONE assert(frame->instr_ptr->op.code == INSTRUMENTED_LINE || - frame->instr_ptr->op.code == INSTRUMENTED_INSTRUCTION || - _PyOpcode_Deopt[frame->instr_ptr->op.code] == SEND || - _PyOpcode_Deopt[frame->instr_ptr->op.code] == FOR_ITER || - _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT || - _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR); + frame->instr_ptr->op.code == INSTRUMENTED_INSTRUCTION || + _PyOpcode_Deopt[frame->instr_ptr->op.code] == SEND || + _PyOpcode_Deopt[frame->instr_ptr->op.code] == FOR_ITER || + _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT || + _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR); #endif stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND); @@ -5149,9 +5149,7 @@ GOTO_TIER_TWO(executor); } else { - _PyFrame_SetStackPointer(frame, stack_pointer); this_instr[1].counter = restart_backoff_counter(counter); - stack_pointer = _PyFrame_GetStackPointer(frame); } } else { @@ -8233,11 +8231,11 @@ assert(INLINE_CACHE_ENTRIES_SEND == INLINE_CACHE_ENTRIES_FOR_ITER); #if TIER_ONE assert(frame->instr_ptr->op.code == INSTRUMENTED_LINE || - frame->instr_ptr->op.code == INSTRUMENTED_INSTRUCTION || - _PyOpcode_Deopt[frame->instr_ptr->op.code] == SEND || - _PyOpcode_Deopt[frame->instr_ptr->op.code] == FOR_ITER || - _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT || - _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR); + frame->instr_ptr->op.code == INSTRUMENTED_INSTRUCTION || + _PyOpcode_Deopt[frame->instr_ptr->op.code] == SEND || + _PyOpcode_Deopt[frame->instr_ptr->op.code] == FOR_ITER || + _PyOpcode_Deopt[frame->instr_ptr->op.code] == INTERPRETER_EXIT || + _PyOpcode_Deopt[frame->instr_ptr->op.code] == ENTER_EXECUTOR); #endif stack_pointer = _PyFrame_GetStackPointer(frame); LOAD_IP(1 + INLINE_CACHE_ENTRIES_SEND); diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 820bedd465bcc7..0c461ff8dd8489 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -29,8 +29,12 @@ class Properties: needs_prev: bool = False def dump(self, indent: str) -> None: - print(indent, end="") - text = ", ".join([f"{key}: {value}" for (key, value) in self.__dict__.items()]) + simple_properties = self.__dict__.copy() + del simple_properties["escaping_calls"] + text = "escaping_calls:\n" + for tkns in self.escaping_calls.values(): + text += f"{indent} {tkns}\n" + text += ", ".join([f"{key}: {value}" for (key, value) in simple_properties.items()]) print(indent, text, sep="") @staticmethod @@ -605,6 +609,10 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "_Py_DECREF_NO_DEALLOC", "assert", "backoff_counter_triggers", + "initial_temperature_backoff_counter", + "advance_backoff_counter", + "restart_backoff_counter", + "_PyCode_CODE", ) def find_stmt_start(node: parser.InstDef, idx: int) -> lexer.Token: diff --git a/Tools/cases_generator/cwriter.py b/Tools/cases_generator/cwriter.py index 069f0177a74018..8cba9127fa3071 100644 --- a/Tools/cases_generator/cwriter.py +++ b/Tools/cases_generator/cwriter.py @@ -18,8 +18,9 @@ def __init__(self, out: TextIO, indent: int, line_directives: bool): def set_position(self, tkn: Token) -> None: if self.last_token is not None: - if self.last_token.line < tkn.line: + if self.last_token.end_line < tkn.line: self.out.write("\n") + if self.last_token.line < tkn.line: if self.line_directives: self.out.write(f'#line {tkn.line} "{tkn.filename}"\n') self.out.write(" " * self.indents[-1]) @@ -91,6 +92,8 @@ def emit_token(self, tkn: Token) -> None: self.maybe_dedent(tkn.text) self.set_position(tkn) self.emit_text(tkn.text) + if tkn.kind == "CMACRO": + self.newline = True self.maybe_indent(tkn.text) def emit_str(self, txt: str) -> None: diff --git a/Tools/cases_generator/lexer.py b/Tools/cases_generator/lexer.py index e628d89b966c91..37f96398ff175f 100644 --- a/Tools/cases_generator/lexer.py +++ b/Tools/cases_generator/lexer.py @@ -312,8 +312,6 @@ def tokenize(src: str, line: int = 1, filename: str = "") -> Iterator[Token]: kind = CHARACTER elif text[0] == "#": kind = CMACRO - linestart = start - line += 1 elif text[0] == "/" and text[1] in "/*": kind = COMMENT else: @@ -335,6 +333,9 @@ def tokenize(src: str, line: int = 1, filename: str = "") -> Iterator[Token]: line += newlines else: begin = line, start - linestart + if kind == CMACRO: + linestart = end + line += 1 if kind != "\n": yield Token( filename, kind, text, begin, (line, start - linestart + len(text)) From 6771c4a1413edf3870bf372a19dfb6c4ebbfd4d0 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 3 Oct 2024 04:03:21 -0700 Subject: [PATCH 46/53] Remove debugging code --- Python/executor_cases.c.h | 8 ++++---- Python/generated_cases.c.h | 8 ++++---- Tools/cases_generator/stack.py | 4 ---- 3 files changed, 8 insertions(+), 12 deletions(-) diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 361c0f69fdb90d..7df1b00a7e17a3 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -5331,14 +5331,14 @@ assert(EMPTY()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *gen_frame = &gen->gi_iframe; - frame->instr_ptr++;/* Virtual flush 1 */ - _PyFrame_Copy(frame, gen_frame);/* Virtual reload 1 */ + frame->instr_ptr++; + _PyFrame_Copy(frame, gen_frame); assert(frame->frame_obj == NULL); gen->gi_frame_state = FRAME_CREATED; gen_frame->owner = FRAME_OWNED_BY_GENERATOR; _Py_LeaveRecursiveCallPy(tstate); - _PyInterpreterFrame *prev = frame->previous;/* Virtual flush 1 */ - _PyThreadState_PopFrame(tstate, frame);/* Virtual reload 1 */ + _PyInterpreterFrame *prev = frame->previous; + _PyThreadState_PopFrame(tstate, frame); frame = tstate->current_frame = prev; LOAD_IP(frame->return_offset); stack_pointer = _PyFrame_GetStackPointer(frame); diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 060cd3dc9ac9ef..53c6528ad0e52a 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -7038,14 +7038,14 @@ assert(EMPTY()); _PyFrame_SetStackPointer(frame, stack_pointer); _PyInterpreterFrame *gen_frame = &gen->gi_iframe; - frame->instr_ptr++;/* Virtual flush 1 */ - _PyFrame_Copy(frame, gen_frame);/* Virtual reload 1 */ + frame->instr_ptr++; + _PyFrame_Copy(frame, gen_frame); assert(frame->frame_obj == NULL); gen->gi_frame_state = FRAME_CREATED; gen_frame->owner = FRAME_OWNED_BY_GENERATOR; _Py_LeaveRecursiveCallPy(tstate); - _PyInterpreterFrame *prev = frame->previous;/* Virtual flush 1 */ - _PyThreadState_PopFrame(tstate, frame);/* Virtual reload 1 */ + _PyInterpreterFrame *prev = frame->previous; + _PyThreadState_PopFrame(tstate, frame); frame = tstate->current_frame = prev; LOAD_IP(frame->return_offset); stack_pointer = _PyFrame_GetStackPointer(frame); diff --git a/Tools/cases_generator/stack.py b/Tools/cases_generator/stack.py index a5404e78439b4e..a954bed4df073c 100644 --- a/Tools/cases_generator/stack.py +++ b/Tools/cases_generator/stack.py @@ -502,8 +502,6 @@ def save(self, out: CWriter) -> None: self.flush(out) out.start_line() out.emit("_PyFrame_SetStackPointer(frame, stack_pointer);\n") - else: - out.emit(f"/* Virtual flush {self.spilled} */\n") self.spilled += 1 def reload(self, out: CWriter) -> None: @@ -514,8 +512,6 @@ def reload(self, out: CWriter) -> None: if self.spilled == 0: out.start_line() out.emit("stack_pointer = _PyFrame_GetStackPointer(frame);\n") - else: - out.emit(f"/* Virtual reload {self.spilled} */\n") @staticmethod def for_uop(stack: Stack, uop: Uop, extract_bits: bool = True) -> tuple[list[str], "Storage"]: From 8c48eaa35fb1aec298313d7ba91fe3a68f83111a Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 3 Oct 2024 06:07:31 -0700 Subject: [PATCH 47/53] Add more non-escaping functions --- Tools/cases_generator/analyzer.py | 23 +++++++++++++++++++---- 1 file changed, 19 insertions(+), 4 deletions(-) diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index 0c461ff8dd8489..a2e25614336220 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -558,13 +558,16 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "_PyLong_IsNonNegativeCompact", "_PyLong_CompactValue", "_PyLong_DigitCount", - "_Py_NewRef", - "_Py_IsImmortal", - "PyLong_FromLong", - "_Py_STR", "_PyLong_Add", "_PyLong_Multiply", "_PyLong_Subtract", + "PyLong_AsLong", + "PyLong_FromLong", + "PyLong_FromSsize_t", + "_Py_NewRef", + "_Py_IsImmortal", + "_Py_IsImmortalLoose", + "_Py_STR", "Py_NewRef", "_PyList_ITEMS", "_PyTuple_ITEMS", @@ -598,11 +601,13 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "PyCFunction_GET_SELF", "_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY", "PyCell_GetRef", + "PyCell_SwapTakeRef", "Py_UNREACHABLE", "_Py_LeaveRecursiveCallTstate", "_Py_EnterRecursiveCallTstateUnchecked", "_PyObject_GC_IS_TRACKED", "_PyObject_GC_MAY_BE_TRACKED", + "_PyObject_GC_TRACK", "_PyInterpreterState_GET", "PyType_HasFeature", "_Py_ID", @@ -613,6 +618,16 @@ def has_error_without_pop(op: parser.InstDef) -> bool: "advance_backoff_counter", "restart_backoff_counter", "_PyCode_CODE", + "_PyFunction_SetVersion", + "PyFloat_FromDouble", + "_PyGen_GetGeneratorFromFrame", + "PyExceptionInstance_Class", + "PyException_GetTraceback", + "PyException_GetCause", + "PyException_GetContext", + "_PyType_NewManagedObject", + "Py_CLEAR", + "_PyFrame_IsIncomplete", ) def find_stmt_start(node: parser.InstDef, idx: int) -> lexer.Token: From 6288f803de0506033893ecf21aa8a551a5010e7e Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 3 Oct 2024 06:14:27 -0700 Subject: [PATCH 48/53] Move casts to avoid extra spilling. Regenerate files --- Include/internal/pycore_opcode_metadata.h | 8 ++-- Include/internal/pycore_uop_metadata.h | 8 ++-- Python/bytecodes.c | 8 ++-- Python/executor_cases.c.h | 40 ++-------------- Python/generated_cases.c.h | 58 ++--------------------- Python/optimizer_cases.c.h | 24 +++------- 6 files changed, 28 insertions(+), 118 deletions(-) diff --git a/Include/internal/pycore_opcode_metadata.h b/Include/internal/pycore_opcode_metadata.h index c5a1dc4d5d38c1..a0d3072d2cd5f6 100644 --- a/Include/internal/pycore_opcode_metadata.h +++ b/Include/internal/pycore_opcode_metadata.h @@ -1126,7 +1126,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[266] = { [INSTRUMENTED_RETURN_CONST] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_CONST_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_RETURN_VALUE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [INSTRUMENTED_YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG }, - [INTERPRETER_EXIT] = { true, INSTR_FMT_IX, HAS_ESCAPES_FLAG }, + [INTERPRETER_EXIT] = { true, INSTR_FMT_IX, 0 }, [IS_OP] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, [JUMP_BACKWARD] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [JUMP_BACKWARD_NO_INTERRUPT] = { true, INSTR_FMT_IB, HAS_ARG_FLAG | HAS_JUMP_FLAG }, @@ -1214,10 +1214,10 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[266] = { [TO_BOOL] = { true, INSTR_FMT_IXC00, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [TO_BOOL_ALWAYS_TRUE] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG }, [TO_BOOL_BOOL] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG }, - [TO_BOOL_INT] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [TO_BOOL_INT] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG }, [TO_BOOL_LIST] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG }, [TO_BOOL_NONE] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG }, - [TO_BOOL_STR] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG | HAS_ESCAPES_FLAG }, + [TO_BOOL_STR] = { true, INSTR_FMT_IXC00, HAS_EXIT_FLAG }, [UNARY_INVERT] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [UNARY_NEGATIVE] = { true, INSTR_FMT_IX, HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [UNARY_NOT] = { true, INSTR_FMT_IX, HAS_PURE_FLAG }, @@ -1227,7 +1227,7 @@ const struct opcode_metadata _PyOpcode_opcode_metadata[266] = { [UNPACK_SEQUENCE_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, [UNPACK_SEQUENCE_TWO_TUPLE] = { true, INSTR_FMT_IBC, HAS_ARG_FLAG | HAS_DEOPT_FLAG }, [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 }, + [YIELD_VALUE] = { true, INSTR_FMT_IB, HAS_ARG_FLAG }, [JUMP] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_EVAL_BREAK_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [JUMP_IF_FALSE] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, [JUMP_IF_TRUE] = { true, -1, HAS_ARG_FLAG | HAS_JUMP_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG }, diff --git a/Include/internal/pycore_uop_metadata.h b/Include/internal/pycore_uop_metadata.h index e980cf662fcf60..c68ee594947283 100644 --- a/Include/internal/pycore_uop_metadata.h +++ b/Include/internal/pycore_uop_metadata.h @@ -54,10 +54,10 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_UNARY_NOT] = HAS_PURE_FLAG, [_TO_BOOL] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_TO_BOOL_BOOL] = HAS_EXIT_FLAG, - [_TO_BOOL_INT] = HAS_EXIT_FLAG | HAS_ESCAPES_FLAG, + [_TO_BOOL_INT] = HAS_EXIT_FLAG, [_TO_BOOL_LIST] = HAS_EXIT_FLAG, [_TO_BOOL_NONE] = HAS_EXIT_FLAG, - [_TO_BOOL_STR] = HAS_EXIT_FLAG | HAS_ESCAPES_FLAG, + [_TO_BOOL_STR] = HAS_EXIT_FLAG, [_REPLACE_WITH_TRUE] = 0, [_UNARY_INVERT] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_GUARD_BOTH_INT] = HAS_EXIT_FLAG, @@ -97,7 +97,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_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_GEN_FRAME] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, - [_YIELD_VALUE] = HAS_ARG_FLAG | HAS_ESCAPES_FLAG, + [_YIELD_VALUE] = HAS_ARG_FLAG, [_POP_EXCEPT] = HAS_ESCAPES_FLAG, [_LOAD_COMMON_CONSTANT] = HAS_ARG_FLAG, [_LOAD_BUILD_CLASS] = HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, @@ -225,7 +225,7 @@ const uint16_t _PyUop_Flags[MAX_UOP_ID+1] = { [_CALL_TYPE_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG, [_CALL_STR_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, [_CALL_TUPLE_1] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, - [_CHECK_AND_ALLOCATE_OBJECT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, + [_CHECK_AND_ALLOCATE_OBJECT] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG, [_CREATE_INIT_FRAME] = HAS_ARG_FLAG | HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_EXIT_INIT_CHECK] = HAS_ERROR_FLAG | HAS_ERROR_NO_POP_FLAG | HAS_ESCAPES_FLAG, [_CALL_BUILTIN_CLASS] = HAS_ARG_FLAG | HAS_DEOPT_FLAG | HAS_ERROR_FLAG | HAS_ESCAPES_FLAG, diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 1845c1c1b5c3f9..76f544fec878bf 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -4001,14 +4001,14 @@ dummy_func( EXIT_IF(!Py_IS_TYPE(self, d_type)); STAT_INC(CALL, hit); int nargs = total_args - 1; - PyCFunctionFastWithKeywords cfunc = - (PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth; STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { DECREF_INPUTS(); ERROR_IF(true, error); } + PyCFunctionFastWithKeywords cfunc = + (PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth; PyObject *res_o = cfunc(self, (args_o + 1), nargs, NULL); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); @@ -4084,8 +4084,6 @@ dummy_func( PyObject *self = PyStackRef_AsPyObjectBorrow(args[0]); EXIT_IF(!Py_IS_TYPE(self, method->d_common.d_type)); STAT_INC(CALL, hit); - PyCFunctionFast cfunc = - (PyCFunctionFast)(void(*)(void))meth->ml_meth; int nargs = total_args - 1; STACKREFS_TO_PYOBJECTS(args, total_args, args_o); @@ -4093,6 +4091,8 @@ dummy_func( DECREF_INPUTS(); ERROR_IF(true, error); } + PyCFunctionFast cfunc = + (PyCFunctionFast)(void(*)(void))meth->ml_meth; PyObject *res_o = cfunc(self, (args_o + 1), nargs); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 7df1b00a7e17a3..b4c1739c8f5453 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -402,9 +402,7 @@ } STAT_INC(TO_BOOL, hit); if (_PyLong_IsZero((PyLongObject *)value_o)) { - _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); - stack_pointer = _PyFrame_GetStackPointer(frame); res = PyStackRef_False; } else { @@ -457,9 +455,7 @@ } STAT_INC(TO_BOOL, hit); if (value_o == &_Py_STR(empty)) { - _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); - stack_pointer = _PyFrame_GetStackPointer(frame); res = PyStackRef_False; } else { @@ -1399,9 +1395,7 @@ assert(frame != &entry_frame); #endif frame->instr_ptr++; - _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); - stack_pointer = _PyFrame_GetStackPointer(frame); assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; @@ -1894,9 +1888,7 @@ PyObject *cell = PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); // Can't use ERROR_IF here. // Fortunately we don't need its superpower. - _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *oldobj = PyCell_SwapTakeRef((PyCellObject *)cell, NULL); - stack_pointer = _PyFrame_GetStackPointer(frame); if (oldobj == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); @@ -2804,9 +2796,7 @@ } /* Ensure dict is GC tracked if it needs to be */ if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(PyStackRef_AsPyObjectBorrow(value))) { - _PyFrame_SetStackPointer(frame, stack_pointer); _PyObject_GC_TRACK(dict); - stack_pointer = _PyFrame_GetStackPointer(frame); } old_value = ep->me_value; PyDict_WatchEvent event = old_value == NULL ? PyDict_EVENT_ADDED : PyDict_EVENT_MODIFIED; @@ -3199,9 +3189,7 @@ Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj)); stack_pointer = _PyFrame_GetStackPointer(frame); if (len_i < 0) JUMP_TO_ERROR(); - _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *len_o = PyLong_FromSsize_t(len_i); - stack_pointer = _PyFrame_GetStackPointer(frame); if (len_o == NULL) JUMP_TO_ERROR(); len = PyStackRef_FromPyObjectSteal(len_o); stack_pointer[0] = len; @@ -3612,10 +3600,8 @@ PyObject *val_o = PyStackRef_AsPyObjectBorrow(val); PyObject *exit_func_o = PyStackRef_AsPyObjectBorrow(exit_func); assert(val_o && PyExceptionInstance_Check(val_o)); - _PyFrame_SetStackPointer(frame, stack_pointer); exc = PyExceptionInstance_Class(val_o); tb = PyException_GetTraceback(val_o); - stack_pointer = _PyFrame_GetStackPointer(frame); if (tb == NULL) { tb = Py_None; } @@ -4359,9 +4345,7 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(CALL, hit); - _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *self_o = _PyType_NewManagedObject(tp); - stack_pointer = _PyFrame_GetStackPointer(frame); if (self_o == NULL) { JUMP_TO_ERROR(); } @@ -4676,9 +4660,7 @@ if (len_i < 0) { JUMP_TO_ERROR(); } - _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyLong_FromSsize_t(len_i); - stack_pointer = _PyFrame_GetStackPointer(frame); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); if (res_o == NULL) { GOTO_ERROR(error); @@ -4869,10 +4851,6 @@ } STAT_INC(CALL, hit); int nargs = total_args - 1; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyCFunctionFastWithKeywords cfunc = - (PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth; - stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { PyStackRef_CLOSE(callable[0]); @@ -4883,6 +4861,8 @@ if (true) JUMP_TO_ERROR(); } _PyFrame_SetStackPointer(frame, stack_pointer); + PyCFunctionFastWithKeywords cfunc = + (PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth; PyObject *res_o = cfunc(self, (args_o + 1), nargs, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); @@ -4991,10 +4971,6 @@ JUMP_TO_JUMP_TARGET(); } STAT_INC(CALL, hit); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyCFunctionFast cfunc = - (PyCFunctionFast)(void(*)(void))meth->ml_meth; - stack_pointer = _PyFrame_GetStackPointer(frame); int nargs = total_args - 1; STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { @@ -5006,6 +4982,8 @@ if (true) JUMP_TO_ERROR(); } _PyFrame_SetStackPointer(frame, stack_pointer); + PyCFunctionFast cfunc = + (PyCFunctionFast)(void(*)(void))meth->ml_meth; PyObject *res_o = cfunc(self, (args_o + 1), nargs); stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); @@ -5285,16 +5263,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(codeobj_st); if (func_obj == NULL) JUMP_TO_ERROR(); - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - _PyFrame_SetStackPointer(frame, stack_pointer); _PyFunction_SetVersion( func_obj, ((PyCodeObject *)codeobj)->co_version); - stack_pointer = _PyFrame_GetStackPointer(frame); func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj); - stack_pointer[0] = func; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = func; break; } @@ -5614,9 +5586,7 @@ #endif if (exit->executor && !exit->executor->vm_data.valid) { exit->temperature = initial_temperature_backoff_counter(); - _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(exit->executor); - stack_pointer = _PyFrame_GetStackPointer(frame); } if (exit->executor == NULL) { _Py_BackoffCounter temperature = exit->temperature; diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 53c6528ad0e52a..7913e99b5579b0 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -973,9 +973,7 @@ frame, this_instr, callable_o, arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { - _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(res_o); - stack_pointer = _PyFrame_GetStackPointer(frame); } } } @@ -1049,9 +1047,7 @@ PyCodeObject *code = (PyCodeObject *)init_func->func_code; DEOPT_IF(!_PyThreadState_HasStackSpace(tstate, code->co_framesize + _Py_InitCleanup.co_framesize), CALL); STAT_INC(CALL, hit); - _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *self_o = _PyType_NewManagedObject(tp); - stack_pointer = _PyFrame_GetStackPointer(frame); if (self_o == NULL) { goto error; } @@ -1713,9 +1709,7 @@ frame, this_instr, func, arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { - _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(result_o); - stack_pointer = _PyFrame_GetStackPointer(frame); } } } @@ -2006,9 +2000,7 @@ frame, this_instr, callable_o, arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { - _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(res_o); - stack_pointer = _PyFrame_GetStackPointer(frame); } } } @@ -2349,9 +2341,7 @@ if (len_i < 0) { goto error; } - _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *res_o = PyLong_FromSsize_t(len_i); - stack_pointer = _PyFrame_GetStackPointer(frame); assert((res_o != NULL) ^ (_PyErr_Occurred(tstate) != NULL)); if (res_o == NULL) { GOTO_ERROR(error); @@ -2431,10 +2421,6 @@ PyObject *self = PyStackRef_AsPyObjectBorrow(args[0]); DEOPT_IF(!Py_IS_TYPE(self, method->d_common.d_type), CALL); STAT_INC(CALL, hit); - _PyFrame_SetStackPointer(frame, stack_pointer); - PyCFunctionFast cfunc = - (PyCFunctionFast)(void(*)(void))meth->ml_meth; - stack_pointer = _PyFrame_GetStackPointer(frame); int nargs = total_args - 1; STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { @@ -2450,6 +2436,8 @@ } } _PyFrame_SetStackPointer(frame, stack_pointer); + PyCFunctionFast cfunc = + (PyCFunctionFast)(void(*)(void))meth->ml_meth; PyObject *res_o = cfunc(self, (args_o + 1), nargs); stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); @@ -2519,10 +2507,6 @@ DEOPT_IF(!Py_IS_TYPE(self, d_type), CALL); STAT_INC(CALL, hit); int nargs = total_args - 1; - _PyFrame_SetStackPointer(frame, stack_pointer); - PyCFunctionFastWithKeywords cfunc = - (PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth; - stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS(args, total_args, args_o); if (CONVERSION_FAILED(args_o)) { PyStackRef_CLOSE(callable[0]); @@ -2537,6 +2521,8 @@ } } _PyFrame_SetStackPointer(frame, stack_pointer); + PyCFunctionFastWithKeywords cfunc = + (PyCFunctionFastWithKeywords)(void(*)(void))meth->ml_meth; PyObject *res_o = cfunc(self, (args_o + 1), nargs, NULL); stack_pointer = _PyFrame_GetStackPointer(frame); STACKREFS_TO_PYOBJECTS_CLEANUP(args_o); @@ -3570,9 +3556,7 @@ PyObject *cell = PyStackRef_AsPyObjectBorrow(GETLOCAL(oparg)); // Can't use ERROR_IF here. // Fortunately we don't need its superpower. - _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *oldobj = PyCell_SwapTakeRef((PyCellObject *)cell, NULL); - stack_pointer = _PyFrame_GetStackPointer(frame); if (oldobj == NULL) { _PyFrame_SetStackPointer(frame, stack_pointer); _PyEval_FormatExcUnbound(tstate, _PyFrame_GetCode(frame), oparg); @@ -4275,9 +4259,7 @@ Py_ssize_t len_i = PyObject_Length(PyStackRef_AsPyObjectBorrow(obj)); stack_pointer = _PyFrame_GetStackPointer(frame); if (len_i < 0) goto error; - _PyFrame_SetStackPointer(frame, stack_pointer); PyObject *len_o = PyLong_FromSsize_t(len_i); - stack_pointer = _PyFrame_GetStackPointer(frame); if (len_o == NULL) goto error; len = PyStackRef_FromPyObjectSteal(len_o); stack_pointer[0] = len; @@ -4496,9 +4478,7 @@ frame, this_instr, callable_o, arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { - _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(res_o); - stack_pointer = _PyFrame_GetStackPointer(frame); } } } @@ -5025,9 +5005,7 @@ assert(frame != &entry_frame); #endif frame->instr_ptr++; - _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); - stack_pointer = _PyFrame_GetStackPointer(frame); assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; @@ -5069,9 +5047,7 @@ _PyStackRef retval; retval = stack_pointer[-1]; assert(frame == &entry_frame); - _PyFrame_SetStackPointer(frame, stack_pointer); assert(_PyFrame_IsIncomplete(frame)); - stack_pointer = _PyFrame_GetStackPointer(frame); /* Restore previous frame and return. */ tstate->current_frame = frame->previous; assert(!_PyErr_Occurred(tstate)); @@ -6397,9 +6373,7 @@ frame, this_instr, global_super, arg); stack_pointer = _PyFrame_GetStackPointer(frame); if (err < 0) { - _PyFrame_SetStackPointer(frame, stack_pointer); Py_CLEAR(super); - stack_pointer = _PyFrame_GetStackPointer(frame); } } } @@ -6536,16 +6510,10 @@ stack_pointer = _PyFrame_GetStackPointer(frame); PyStackRef_CLOSE(codeobj_st); if (func_obj == NULL) goto pop_1_error; - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - _PyFrame_SetStackPointer(frame, stack_pointer); _PyFunction_SetVersion( func_obj, ((PyCodeObject *)codeobj)->co_version); - stack_pointer = _PyFrame_GetStackPointer(frame); func = PyStackRef_FromPyObjectSteal((PyObject *)func_obj); - stack_pointer[0] = func; - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); + stack_pointer[-1] = func; DISPATCH(); } @@ -6886,11 +6854,7 @@ if (oparg) { PyObject *lasti = PyStackRef_AsPyObjectBorrow(values[0]); if (PyLong_Check(lasti)) { - stack_pointer += -1; - assert(WITHIN_STACK_BOUNDS()); - _PyFrame_SetStackPointer(frame, stack_pointer); frame->instr_ptr = _PyCode_CODE(_PyFrame_GetCode(frame)) + PyLong_AsLong(lasti); - stack_pointer = _PyFrame_GetStackPointer(frame); assert(!_PyErr_Occurred(tstate)); } else { @@ -6902,8 +6866,6 @@ Py_DECREF(exc); goto error; } - stack_pointer += 1; - assert(WITHIN_STACK_BOUNDS()); } assert(exc && PyExceptionInstance_Check(exc)); stack_pointer += -1; @@ -7486,9 +7448,7 @@ DEOPT_IF(ep->me_key != name, STORE_ATTR); /* Ensure dict is GC tracked if it needs to be */ if (!_PyObject_GC_IS_TRACKED(dict) && _PyObject_GC_MAY_BE_TRACKED(PyStackRef_AsPyObjectBorrow(value))) { - _PyFrame_SetStackPointer(frame, stack_pointer); _PyObject_GC_TRACK(dict); - stack_pointer = _PyFrame_GetStackPointer(frame); } old_value = ep->me_value; PyDict_WatchEvent event = old_value == NULL ? PyDict_EVENT_ADDED : PyDict_EVENT_MODIFIED; @@ -7883,9 +7843,7 @@ DEOPT_IF(!PyLong_CheckExact(value_o), TO_BOOL); STAT_INC(TO_BOOL, hit); if (_PyLong_IsZero((PyLongObject *)value_o)) { - _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); - stack_pointer = _PyFrame_GetStackPointer(frame); res = PyStackRef_False; } else { @@ -7947,9 +7905,7 @@ DEOPT_IF(!PyUnicode_CheckExact(value_o), TO_BOOL); STAT_INC(TO_BOOL, hit); if (value_o == &_Py_STR(empty)) { - _PyFrame_SetStackPointer(frame, stack_pointer); assert(_Py_IsImmortalLoose(value_o)); - stack_pointer = _PyFrame_GetStackPointer(frame); res = PyStackRef_False; } else { @@ -8170,10 +8126,8 @@ PyObject *val_o = PyStackRef_AsPyObjectBorrow(val); PyObject *exit_func_o = PyStackRef_AsPyObjectBorrow(exit_func); assert(val_o && PyExceptionInstance_Check(val_o)); - _PyFrame_SetStackPointer(frame, stack_pointer); exc = PyExceptionInstance_Class(val_o); tb = PyException_GetTraceback(val_o); - stack_pointer = _PyFrame_GetStackPointer(frame); if (tb == NULL) { tb = Py_None; } @@ -8209,9 +8163,7 @@ assert(frame != &entry_frame); #endif frame->instr_ptr++; - _PyFrame_SetStackPointer(frame, stack_pointer); PyGenObject *gen = _PyGen_GetGeneratorFromFrame(frame); - stack_pointer = _PyFrame_GetStackPointer(frame); assert(FRAME_SUSPENDED_YIELD_FROM == FRAME_SUSPENDED + 1); assert(oparg == 0 || oparg == 1); gen->gi_frame_state = FRAME_SUSPENDED + oparg; diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 5b3e272ea7d692..66d94a6b94b24a 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -363,8 +363,6 @@ { assert(PyFloat_CheckExact(sym_get_const(left))); assert(PyFloat_CheckExact(sym_get_const(right))); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( PyFloat_AS_DOUBLE(sym_get_const(left)) * PyFloat_AS_DOUBLE(sym_get_const(right))); @@ -378,11 +376,9 @@ } else { res = sym_new_type(ctx, &PyFloat_Type); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); } - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -398,8 +394,6 @@ { assert(PyFloat_CheckExact(sym_get_const(left))); assert(PyFloat_CheckExact(sym_get_const(right))); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( PyFloat_AS_DOUBLE(sym_get_const(left)) + PyFloat_AS_DOUBLE(sym_get_const(right))); @@ -413,11 +407,9 @@ } else { res = sym_new_type(ctx, &PyFloat_Type); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); } - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } @@ -433,8 +425,6 @@ { assert(PyFloat_CheckExact(sym_get_const(left))); assert(PyFloat_CheckExact(sym_get_const(right))); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); PyObject *temp = PyFloat_FromDouble( PyFloat_AS_DOUBLE(sym_get_const(left)) - PyFloat_AS_DOUBLE(sym_get_const(right))); @@ -448,11 +438,9 @@ } else { res = sym_new_type(ctx, &PyFloat_Type); - stack_pointer += -2; - assert(WITHIN_STACK_BOUNDS()); } - stack_pointer[0] = res; - stack_pointer += 1; + stack_pointer[-2] = res; + stack_pointer += -1; assert(WITHIN_STACK_BOUNDS()); break; } From d183767c61d72f81b807078ff3fb080b80e6867d Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 3 Oct 2024 06:18:00 -0700 Subject: [PATCH 49/53] Sort non-escaping function names --- Tools/cases_generator/analyzer.py | 176 +++++++++++++++--------------- 1 file changed, 88 insertions(+), 88 deletions(-) diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index a2e25614336220..d0b9476aa380b0 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -514,120 +514,120 @@ def has_error_without_pop(op: parser.InstDef) -> bool: NON_ESCAPING_FUNCTIONS = ( - "PyStackRef_FromPyObjectSteal", + "PyCFunction_GET_FLAGS", + "PyCFunction_GET_FUNCTION", + "PyCFunction_GET_SELF", + "PyCell_GetRef", + "PyCell_New", + "PyCell_SwapTakeRef", + "PyExceptionInstance_Class", + "PyException_GetCause", + "PyException_GetContext", + "PyException_GetTraceback", + "PyFloat_AS_DOUBLE", + "PyFloat_FromDouble", + "PyFunction_GET_CODE", + "PyFunction_GET_GLOBALS", + "PyList_GET_ITEM", + "PyList_GET_SIZE", + "PyList_SET_ITEM", + "PyLong_AsLong", + "PyLong_FromLong", + "PyLong_FromSsize_t", + "PySlice_New", "PyStackRef_AsPyObjectBorrow", + "PyStackRef_AsPyObjectNew", "PyStackRef_AsPyObjectSteal", + "PyStackRef_CLEAR", "PyStackRef_CLOSE", "PyStackRef_DUP", - "PyStackRef_CLEAR", + "PyStackRef_False", + "PyStackRef_FromPyObjectImmortal", + "PyStackRef_FromPyObjectNew", + "PyStackRef_FromPyObjectSteal", + "PyStackRef_Is", "PyStackRef_IsNull", + "PyStackRef_None", "PyStackRef_TYPE", - "PyStackRef_False", "PyStackRef_True", - "PyStackRef_None", - "PyStackRef_Is", - "PyStackRef_FromPyObjectNew", - "PyStackRef_AsPyObjectNew", - "PyStackRef_FromPyObjectImmortal", - "Py_INCREF", - "_PyManagedDictPointer_IsValues", - "_PyObject_GetManagedDict", - "_PyObject_ManagedDictPointer", - "_PyObject_InlineValues", - "_PyDictValues_AddToInsertionOrder", + "PyTuple_GET_ITEM", + "PyTuple_GET_SIZE", + "PyType_HasFeature", + "PyUnicode_Append", + "PyUnicode_Concat", + "PyUnicode_GET_LENGTH", + "PyUnicode_READ_CHAR", + "Py_ARRAY_LENGTH", + "Py_CLEAR", "Py_DECREF", - "Py_XDECREF", + "Py_FatalError", + "Py_INCREF", + "Py_IS_TYPE", + "Py_NewRef", "Py_REFCNT", - "_Py_DECREF_SPECIALIZED", - "PyUnicode_Append", - "_PyLong_IsZero", "Py_SIZE", "Py_TYPE", - "Py_IS_TYPE", - "PyList_GET_ITEM", - "PyList_SET_ITEM", - "PyTuple_GET_ITEM", - "PyList_GET_SIZE", - "PyTuple_GET_SIZE", - "Py_ARRAY_LENGTH", + "Py_UNREACHABLE", "Py_Unicode_GET_LENGTH", - "PyUnicode_READ_CHAR", - "_Py_SINGLETON", - "PyUnicode_GET_LENGTH", - "_PyLong_IsCompact", - "_PyLong_IsNonNegativeCompact", + "Py_XDECREF", + "_PyCode_CODE", + "_PyDictValues_AddToInsertionOrder", + "_PyErr_Occurred", + "_PyEval_FrameClearAndPop", + "_PyFrame_GetCode", + "_PyFrame_IsIncomplete", + "_PyFrame_PushUnchecked", + "_PyFrame_SetStackPointer", + "_PyFrame_StackPush", + "_PyFunction_SetVersion", + "_PyGen_GetGeneratorFromFrame", + "_PyInterpreterState_GET", + "_PyList_AppendTakeRef", + "_PyList_FromStackRefSteal", + "_PyList_ITEMS", + "_PyLong_Add", "_PyLong_CompactValue", "_PyLong_DigitCount", - "_PyLong_Add", + "_PyLong_IsCompact", + "_PyLong_IsNonNegativeCompact", + "_PyLong_IsZero", "_PyLong_Multiply", "_PyLong_Subtract", - "PyLong_AsLong", - "PyLong_FromLong", - "PyLong_FromSsize_t", - "_Py_NewRef", - "_Py_IsImmortal", - "_Py_IsImmortalLoose", - "_Py_STR", - "Py_NewRef", - "_PyList_ITEMS", - "_PyTuple_ITEMS", - "_PyList_AppendTakeRef", - "_Py_atomic_load_uintptr_relaxed", - "_PyFrame_GetCode", + "_PyManagedDictPointer_IsValues", + "_PyObject_GC_IS_TRACKED", + "_PyObject_GC_MAY_BE_TRACKED", + "_PyObject_GC_TRACK", + "_PyObject_GetManagedDict", + "_PyObject_InlineValues", + "_PyObject_ManagedDictPointer", "_PyThreadState_HasStackSpace", - "_PyUnicode_Equal", - "_PyFrame_SetStackPointer", - "_PyType_HasFeature", - "PyUnicode_Concat", - "PySlice_New", - "_Py_LeaveRecursiveCallPy", - "maybe_lltrace_resume_frame", - "_PyUnicode_JoinArray", - "_PyEval_FrameClearAndPop", - "_PyFrame_StackPush", - "PyCell_New", - "PyFloat_AS_DOUBLE", - "_PyFrame_PushUnchecked", - "Py_FatalError", - "_PyList_FromStackRefSteal", "_PyTuple_FromArraySteal", "_PyTuple_FromStackRefSteal", - "_Py_set_eval_breaker_bit", - "PyFunction_GET_CODE", - "PyFunction_GET_GLOBALS", - "_PyErr_Occurred", - "PyCFunction_GET_FUNCTION", - "PyCFunction_GET_FLAGS", - "PyCFunction_GET_SELF", + "_PyTuple_ITEMS", + "_PyType_HasFeature", + "_PyType_NewManagedObject", + "_PyUnicode_Equal", + "_PyUnicode_JoinArray", "_Py_CHECK_EMSCRIPTEN_SIGNALS_PERIODICALLY", - "PyCell_GetRef", - "PyCell_SwapTakeRef", - "Py_UNREACHABLE", - "_Py_LeaveRecursiveCallTstate", + "_Py_DECREF_NO_DEALLOC", + "_Py_DECREF_SPECIALIZED", "_Py_EnterRecursiveCallTstateUnchecked", - "_PyObject_GC_IS_TRACKED", - "_PyObject_GC_MAY_BE_TRACKED", - "_PyObject_GC_TRACK", - "_PyInterpreterState_GET", - "PyType_HasFeature", "_Py_ID", - "_Py_DECREF_NO_DEALLOC", + "_Py_IsImmortal", + "_Py_IsImmortalLoose", + "_Py_LeaveRecursiveCallPy", + "_Py_LeaveRecursiveCallTstate", + "_Py_NewRef", + "_Py_SINGLETON", + "_Py_STR", + "_Py_atomic_load_uintptr_relaxed", + "_Py_set_eval_breaker_bit", + "advance_backoff_counter", "assert", "backoff_counter_triggers", "initial_temperature_backoff_counter", - "advance_backoff_counter", + "maybe_lltrace_resume_frame", "restart_backoff_counter", - "_PyCode_CODE", - "_PyFunction_SetVersion", - "PyFloat_FromDouble", - "_PyGen_GetGeneratorFromFrame", - "PyExceptionInstance_Class", - "PyException_GetTraceback", - "PyException_GetCause", - "PyException_GetContext", - "_PyType_NewManagedObject", - "Py_CLEAR", - "_PyFrame_IsIncomplete", ) def find_stmt_start(node: parser.InstDef, idx: int) -> lexer.Token: From 0244d779588ed6ce89146b3760604ef1df253cfb Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 3 Oct 2024 06:20:25 -0700 Subject: [PATCH 50/53] A cast to (int) is not a call --- Python/generated_cases.c.h | 2 -- Tools/cases_generator/analyzer.py | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 7913e99b5579b0..283f91cf642be9 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -4701,9 +4701,7 @@ int original_opcode = 0; if (tstate->tracing) { PyCodeObject *code = _PyFrame_GetCode(frame); - _PyFrame_SetStackPointer(frame, stack_pointer); original_opcode = code->_co_monitoring->lines[(int)(this_instr - _PyCode_CODE(code))].original_opcode; - stack_pointer = _PyFrame_GetStackPointer(frame); next_instr = this_instr; } else { _PyFrame_SetStackPointer(frame, stack_pointer); diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index d0b9476aa380b0..fd8d404667d7a3 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -699,7 +699,7 @@ def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, tuple[le continue elif tkn.kind == "RPAREN": prev = tokens[idx-1] - if prev.text.endswith("_t") or prev.text == "*": + if prev.text.endswith("_t") or prev.text == "*" or prev.text == "int": #cast continue elif tkn.kind != "RBRACKET": From efb5e7d77b7697f66674dbac4b2f55d7d6c841d0 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 3 Oct 2024 06:28:33 -0700 Subject: [PATCH 51/53] Prohibit switch statements in bytecodes.c and remove the last one. --- Python/bytecodes.c | 12 +++++------- Python/executor_cases.c.h | 12 +++++------- Python/generated_cases.c.h | 12 +++++------- Tools/cases_generator/analyzer.py | 2 ++ 4 files changed, 17 insertions(+), 21 deletions(-) diff --git a/Python/bytecodes.c b/Python/bytecodes.c index 76f544fec878bf..001831b213027c 100644 --- a/Python/bytecodes.c +++ b/Python/bytecodes.c @@ -1277,16 +1277,14 @@ dummy_func( inst(LOAD_COMMON_CONSTANT, ( -- value)) { // Keep in sync with _common_constants in opcode.py + // If we ever have more than two constants, use a lookup table PyObject *val; - switch(oparg) { - case CONSTANT_ASSERTIONERROR: + if (oparg == CONSTANT_ASSERTIONERROR) { val = PyExc_AssertionError; - break; - case CONSTANT_NOTIMPLEMENTEDERROR: + } + else { + assert(oparg == CONSTANT_NOTIMPLEMENTEDERROR); val = PyExc_NotImplementedError; - break; - default: - Py_FatalError("bad LOAD_COMMON_CONSTANT oparg"); } value = PyStackRef_FromPyObjectImmortal(val); } diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index b4c1739c8f5453..6cfecc0370d124 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -1447,16 +1447,14 @@ _PyStackRef value; oparg = CURRENT_OPARG(); // Keep in sync with _common_constants in opcode.py + // If we ever have more than two constants, use a lookup table PyObject *val; - switch(oparg) { - case CONSTANT_ASSERTIONERROR: + if (oparg == CONSTANT_ASSERTIONERROR) { val = PyExc_AssertionError; - break; - case CONSTANT_NOTIMPLEMENTEDERROR: + } + else { + assert(oparg == CONSTANT_NOTIMPLEMENTEDERROR); val = PyExc_NotImplementedError; - break; - default: - Py_FatalError("bad LOAD_COMMON_CONSTANT oparg"); } value = PyStackRef_FromPyObjectImmortal(val); stack_pointer[0] = value; diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 283f91cf642be9..37d51ea3a78151 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -5871,16 +5871,14 @@ INSTRUCTION_STATS(LOAD_COMMON_CONSTANT); _PyStackRef value; // Keep in sync with _common_constants in opcode.py + // If we ever have more than two constants, use a lookup table PyObject *val; - switch(oparg) { - case CONSTANT_ASSERTIONERROR: + if (oparg == CONSTANT_ASSERTIONERROR) { val = PyExc_AssertionError; - break; - case CONSTANT_NOTIMPLEMENTEDERROR: + } + else { + assert(oparg == CONSTANT_NOTIMPLEMENTEDERROR); val = PyExc_NotImplementedError; - break; - default: - Py_FatalError("bad LOAD_COMMON_CONSTANT oparg"); } value = PyStackRef_FromPyObjectImmortal(val); stack_pointer[0] = value; diff --git a/Tools/cases_generator/analyzer.py b/Tools/cases_generator/analyzer.py index fd8d404667d7a3..9c2981a68ac909 100644 --- a/Tools/cases_generator/analyzer.py +++ b/Tools/cases_generator/analyzer.py @@ -678,6 +678,8 @@ def find_escaping_api_calls(instr: parser.InstDef) -> dict[lexer.Token, tuple[le next_tkn = tokens[idx+1] except IndexError: break + if tkn.kind == "SWITCH": + raise analysis_error(f"switch statements are not supported due to their complex flow control. Sorry.", tkn) if next_tkn.kind != lexer.LPAREN: continue if tkn.kind == lexer.IDENTIFIER: From de3b86c98d86dfbea67962f261d18908fc473e2c Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 3 Oct 2024 07:01:53 -0700 Subject: [PATCH 52/53] Insert extra braces to handle 'else if' without an 'else' correctly. --- Python/executor_cases.c.h | 22 ++++++++------- Python/generated_cases.c.h | 32 ++++++++++++---------- Python/optimizer_bytecodes.c | 16 ++++------- Python/optimizer_cases.c.h | 8 ++++-- Tools/cases_generator/generators_common.py | 4 +++ 5 files changed, 45 insertions(+), 37 deletions(-) diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h index 6cfecc0370d124..d42772e829be59 100644 --- a/Python/executor_cases.c.h +++ b/Python/executor_cases.c.h @@ -3309,18 +3309,20 @@ } iter = iterable; } - else if (PyGen_CheckExact(iterable_o)) { - iter = iterable; - } else { - /* `iterable` is not a generator. */ - _PyFrame_SetStackPointer(frame, stack_pointer); - iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (PyStackRef_IsNull(iter)) { - JUMP_TO_ERROR(); + if (PyGen_CheckExact(iterable_o)) { + iter = iterable; + } + else { + /* `iterable` is not a generator. */ + _PyFrame_SetStackPointer(frame, stack_pointer); + iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (PyStackRef_IsNull(iter)) { + JUMP_TO_ERROR(); + } + PyStackRef_CLOSE(iterable); } - PyStackRef_CLOSE(iterable); } stack_pointer[-1] = iter; break; diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h index 37d51ea3a78151..a9c127784edc83 100644 --- a/Python/generated_cases.c.h +++ b/Python/generated_cases.c.h @@ -4291,18 +4291,20 @@ } iter = iterable; } - else if (PyGen_CheckExact(iterable_o)) { - iter = iterable; - } else { - /* `iterable` is not a generator. */ - _PyFrame_SetStackPointer(frame, stack_pointer); - iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); - stack_pointer = _PyFrame_GetStackPointer(frame); - if (PyStackRef_IsNull(iter)) { - goto error; + if (PyGen_CheckExact(iterable_o)) { + iter = iterable; + } + else { + /* `iterable` is not a generator. */ + _PyFrame_SetStackPointer(frame, stack_pointer); + iter = PyStackRef_FromPyObjectSteal(PyObject_GetIter(iterable_o)); + stack_pointer = _PyFrame_GetStackPointer(frame); + if (PyStackRef_IsNull(iter)) { + goto error; + } + PyStackRef_CLOSE(iterable); } - PyStackRef_CLOSE(iterable); } stack_pointer[-1] = iter; DISPATCH(); @@ -4392,11 +4394,13 @@ if (is_meth) { arg0 = PyStackRef_AsPyObjectBorrow(maybe_self[0]); } - else if (oparg) { - arg0 = PyStackRef_AsPyObjectBorrow(args[0]); - } else { - arg0 = &_PyInstrumentation_MISSING; + if (oparg) { + arg0 = PyStackRef_AsPyObjectBorrow(args[0]); + } + else { + arg0 = &_PyInstrumentation_MISSING; + } } _PyFrame_SetStackPointer(frame, stack_pointer); int err = _Py_call_instrumentation_2args( diff --git a/Python/optimizer_bytecodes.c b/Python/optimizer_bytecodes.c index da8000864b3ae8..e476bc754341a8 100644 --- a/Python/optimizer_bytecodes.c +++ b/Python/optimizer_bytecodes.c @@ -802,11 +802,9 @@ dummy_func(void) { assert(value != NULL); eliminate_pop_guard(this_instr, !Py_IsNone(value)); } - else { - if (sym_has_type(flag)) { - assert(!sym_matches_type(flag, &_PyNone_Type)); - eliminate_pop_guard(this_instr, true); - } + else if (sym_has_type(flag)) { + assert(!sym_matches_type(flag, &_PyNone_Type)); + eliminate_pop_guard(this_instr, true); } } @@ -816,11 +814,9 @@ dummy_func(void) { assert(value != NULL); eliminate_pop_guard(this_instr, Py_IsNone(value)); } - else { - if (sym_has_type(flag)) { - assert(!sym_matches_type(flag, &_PyNone_Type)); - eliminate_pop_guard(this_instr, false); - } + else if (sym_has_type(flag)) { + assert(!sym_matches_type(flag, &_PyNone_Type)); + eliminate_pop_guard(this_instr, false); } } diff --git a/Python/optimizer_cases.c.h b/Python/optimizer_cases.c.h index 66d94a6b94b24a..b08a7b89e5f91e 100644 --- a/Python/optimizer_cases.c.h +++ b/Python/optimizer_cases.c.h @@ -1843,9 +1843,11 @@ if (first_valid_check_stack == NULL) { first_valid_check_stack = corresponding_check_stack; } - else if (corresponding_check_stack) { - // delete all but the first valid _CHECK_STACK_SPACE - corresponding_check_stack->opcode = _NOP; + else { + if (corresponding_check_stack) { + // delete all but the first valid _CHECK_STACK_SPACE + corresponding_check_stack->opcode = _NOP; + } } corresponding_check_stack = NULL; break; diff --git a/Tools/cases_generator/generators_common.py b/Tools/cases_generator/generators_common.py index 6c8ea54cc54d01..f32a20b304c354 100644 --- a/Tools/cases_generator/generators_common.py +++ b/Tools/cases_generator/generators_common.py @@ -385,8 +385,12 @@ def _emit_if( self.emit(next(tkn_iter)) maybe_if = tkn_iter.peek() if maybe_if and maybe_if.kind == "IF": + #Emit extra braces around the if to get scoping right + self.emit(" {\n") self.emit(next(tkn_iter)) else_reachable, rbrace, else_storage = self._emit_if(tkn_iter, uop, storage, inst) + self.out.start_line() + self.emit("}\n") else: else_reachable, rbrace, else_storage = self._emit_block(tkn_iter, uop, storage, inst, True) if not reachable: From a1e55d4985bdd5e9160d4db2257bba371d91d1a1 Mon Sep 17 00:00:00 2001 From: Mark Shannon Date: Thu, 3 Oct 2024 07:37:32 -0700 Subject: [PATCH 53/53] Fix test. gc.get_referrers can now see values on generator stacks --- Lib/test/test_asyncio/test_streams.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/Lib/test/test_asyncio/test_streams.py b/Lib/test/test_asyncio/test_streams.py index 0688299447d064..dbe5646c2b7c08 100644 --- a/Lib/test/test_asyncio/test_streams.py +++ b/Lib/test/test_asyncio/test_streams.py @@ -1214,9 +1214,9 @@ async def main(): # can't use assertRaises because that clears frames exc = excs.exceptions[0] self.assertIsNotNone(exc) - self.assertListEqual(gc.get_referrers(exc), []) - - asyncio.run(main()) + self.assertListEqual(gc.get_referrers(exc), [main_coro]) + main_coro = main() + asyncio.run(main_coro) if __name__ == '__main__':