Make less of a special case of _PUSH_FRAME

Instead, the special case is an opcode using SAVE_FRAME_STATE().
Introducing #if TIER_ONE and #if TIER_TWO so we can implement
_PUSH_FRAME differently for both tiers.

Author: gvanrossum

Python/bytecodes.c

@@ -2981,8 +2981,22 @@ dummy_func(
         // (which will be pushed when the frame returns).
         // It is needed so CALL_PY_EXACT_ARGS matches its family.
         op(_PUSH_FRAME, (new_frame: _PyInterpreterFrame* -- unused)) {
+            // Write it out explicitly because it's subtly different.
+            // Eventually this should be the only occurrence of this code.
             frame->return_offset = 0;
-            DISPATCH_INLINED(new_frame);
+            assert(tstate->interp->eval_frame == NULL);
+            SAVE_FRAME_STATE();  // Signals to the code generator
+            new_frame->previous = frame;
+            CALL_STAT_INC(inlined_py_calls);
+            #if TIER_ONE
+            frame = cframe.current_frame = new_frame;
+            goto start_frame;
+            #endif
+            #if TIER_TWO
+            frame = tstate->cframe->current_frame = new_frame;
+            stack_pointer = _PyFrame_GetStackPointer(frame);
+            ip_offset = (_Py_CODEUNIT *)_PyFrame_GetCode(frame)->co_code_adaptive;
+            #endif
         }
 
         macro(CALL_PY_EXACT_ARGS) =

Python/ceval.c

@@ -770,6 +770,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
 #endif
         {
 
+#define TIER_ONE 1
 #include "generated_cases.c.h"
 
     /* INSTRUMENTED_LINE has to be here, rather than in bytecodes.c,

Python/ceval_macros.h

@@ -103,11 +103,16 @@
         DISPATCH_GOTO(); \
     }
 
+#define SAVE_FRAME_STATE() \
+    do { \
+        frame->prev_instr = next_instr - 1; \
+        _PyFrame_SetStackPointer(frame, stack_pointer); \
+    } while (0)
+
 #define DISPATCH_INLINED(NEW_FRAME)                     \
     do {                                                \
         assert(tstate->interp->eval_frame == NULL);     \
-        _PyFrame_SetStackPointer(frame, stack_pointer); \
-        frame->prev_instr = next_instr - 1;             \
+        SAVE_FRAME_STATE();                             \
         (NEW_FRAME)->previous = frame;                  \
         frame = cframe.current_frame = (NEW_FRAME);     \
         CALL_STAT_INC(inlined_py_calls);                \

Python/executor.c

@@ -30,17 +30,12 @@
 #undef ENABLE_SPECIALIZATION
 #define ENABLE_SPECIALIZATION 0
 
-#undef DISPATCH_INLINED
-#define DISPATCH_INLINED(NEW_FRAME)                             \
-    do {                                                        \
-        assert(tstate->interp->eval_frame == NULL);             \
-        _PyFrame_SetStackPointer(frame, stack_pointer);         \
-        frame->prev_instr -= 1;                                 \
-        (NEW_FRAME)->previous = frame;                          \
-        frame = tstate->cframe->current_frame = (NEW_FRAME);    \
-        CALL_STAT_INC(inlined_py_calls);                        \
-        stack_pointer = _PyFrame_GetStackPointer(frame);        \
-        ip_offset = (_Py_CODEUNIT *)_PyFrame_GetCode(frame)->co_code_adaptive; \
+#undef SAVE_FRAME_STATE
+#define SAVE_FRAME_STATE() \
+    do { \
+        /* Assume preceding SAVE_IP has set frame->prev_instr */ \
+        frame->prev_instr--; \
+        _PyFrame_SetStackPointer(frame, stack_pointer); \
     } while (0)
 
 
@@ -94,6 +89,7 @@ _PyUopExecute(_PyExecutorObject *executor, _PyInterpreterFrame *frame, PyObject
         OBJECT_STAT_INC(optimization_uops_executed);
         switch (opcode) {
 
+#define TIER_TWO 2
 #include "executor_cases.c.h"
 
             default:

Python/executor_cases.c.h

@@ -60,6 +60,7 @@ class Instruction:
 
     # Computed by constructor
     always_exits: str  # If the block always exits, its last line; else ""
+    save_frame_state: bool  # Whether the instruction uses SAVE_FRAME_STATE()
     has_deopt: bool
     cache_offset: int
     cache_effects: list[parsing.CacheEffect]
@@ -83,6 +84,7 @@ def __init__(self, inst: parsing.InstDef):
             self.block
         )
         self.always_exits = always_exits(self.block_text)
+        self.save_frame_state = variable_used(self.inst, "SAVE_FRAME_STATE")
         self.has_deopt = variable_used(self.inst, "DEOPT_IF")
         self.cache_effects = [
             effect for effect in inst.inputs if isinstance(effect, parsing.CacheEffect)
@@ -120,15 +122,13 @@ def __init__(self, inst: parsing.InstDef):
     def is_viable_uop(self) -> bool:
         """Whether this instruction is viable as a uop."""
         dprint: typing.Callable[..., None] = lambda *args, **kwargs: None
-        if "PY_EXACT" in self.name:
+        if "PUSH_FRAME" in self.name:
             dprint = print
 
         if self.name == "EXIT_TRACE":
             return True  # This has 'return frame' but it's okay
-        if self.name == "_PUSH_FRAME":
-            return True  # Has DISPATCH_INLINED but it's okay
         if self.always_exits:
-            dprint(f"Skipping {self.name} because it always exits")
+            dprint(f"Skipping {self.name} because it always exits: {self.always_exits}")
             return False
         if len(self.active_caches) > 1:
             # print(f"Skipping {self.name} because it has >1 cache entries")

Python/generated_cases.c.h

@@ -1,6 +1,7 @@
 import dataclasses
 import typing
 
+from flags import variable_used_unspecialized
 from formatting import (
     Formatter,
     UNUSED,
@@ -314,7 +315,7 @@ def write_macro_instr(
             write_components(parts, out, TIER_ONE, mac.cache_offset)
         except AssertionError as err:
             raise AssertionError(f"Error writing macro {mac.name}") from err
-        if not parts[-1].instr.always_exits:
+        if not parts[-1].instr.always_exits and not parts[-1].instr.save_frame_state:
             if mac.cache_offset:
                 out.emit(f"next_instr += {mac.cache_offset};")
             out.emit("DISPATCH();")
@@ -366,12 +367,7 @@ def write_components(
                     poke.as_stack_effect(lax=True),
                 )
 
-        dispatch_inlined_special_case = (
-            mgr is managers[-1]
-            and mgr.instr.always_exits.startswith("DISPATCH_INLINED")
-            and mgr.instr.name == "_PUSH_FRAME"
-        )
-        if dispatch_inlined_special_case:
+        if mgr.instr.save_frame_state:
             # Adjust stack to min_offset (input effects materialized)
             out.stack_adjust(mgr.min_offset.deep, mgr.min_offset.high)
             # Use clone() since adjust_inverse() mutates final_offset
@@ -385,7 +381,7 @@ def write_components(
             with out.block(""):
                 mgr.instr.write_body(out, -4, mgr.active_caches, tier)
 
-        if mgr is managers[-1] and not dispatch_inlined_special_case:
+        if mgr is managers[-1] and not mgr.instr.save_frame_state:
             # TODO: Explain why this adjustment is needed.
             out.stack_adjust(mgr.final_offset.deep, mgr.final_offset.high)
             # Use clone() since adjust_inverse() mutates final_offset