Drop all shim related changes.

Link the JIT shim into the binary and remove
the old runtime shim-specific unwind machinery.
Rename _PyJIT to _PyJIT_Entry and the synthetic
executor frame to py::jit:executor.
Make executor unwinding materialize _PyJIT_Entry
beneath py::jit:executor.
Update the GDB tests to require both the executor
frame and _PyJIT_Entry.

Author: diegorusso

Include/internal/pycore_jit.h

@@ -23,7 +23,7 @@ typedef _Py_CODEUNIT *(*jit_func)(
     _PyStackRef _tos_cache0, _PyStackRef _tos_cache1, _PyStackRef _tos_cache2
 );
 
-_Py_CODEUNIT *_PyJIT(
+_Py_CODEUNIT *_PyJIT_Entry(
     _PyExecutorObject *executor, _PyInterpreterFrame *frame,
     _PyStackRef *stack_pointer, PyThreadState *tstate
 );

Include/internal/pycore_jit_unwind.h

@@ -8,28 +8,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-/*
- * Compiler-emitted CFI for the shim region (GDB path only).
- *
- * Captured at build time by Tools/jit from the shim's compiled .eh_frame
- * so the runtime CIE/FDE can describe whatever prologue the compiler
- * chose, without hand-rolling DWARF. Executors pass NULL and fall back
- * to the invariant-based steady-state rule that the CIE emits by hand.
- *
- * The struct is defined unconditionally so jit_record_code() in Python/jit.c
- * has a valid pointer type on every platform — callers on non-(Linux+ELF)
- * always pass NULL, matching jit_record_code()'s internal #ifdef.
- */
-typedef struct {
-    const uint8_t *cie_init_cfi;
-    size_t         cie_init_cfi_size;
-    const uint8_t *fde_cfi;
-    size_t         fde_cfi_size;
-    uint32_t       code_align;
-    int32_t        data_align;
-    uint32_t       ra_column;
-} _PyJitUnwind_ShimCfi;
-
 #if defined(PY_HAVE_PERF_TRAMPOLINE) || (defined(__linux__) && defined(__ELF__))
 
 /* DWARF exception-handling pointer encodings shared by JIT unwind users. */
@@ -58,30 +36,22 @@ enum {
 };
 
 /* Return the size of the generated .eh_frame data for the given encoding. */
-size_t _PyJitUnwind_EhFrameSize(int absolute_addr,
-                                const _PyJitUnwind_ShimCfi *shim_cfi);
+size_t _PyJitUnwind_EhFrameSize(int absolute_addr);
 
 /*
  * Build DWARF .eh_frame data for JIT code; returns size written or 0 on error.
  * absolute_addr selects the FDE address encoding:
  * - 0: PC-relative offsets (perf jitdump synthesized DSO).
  * - nonzero: absolute addresses (GDB JIT in-memory ELF).
- *
- * shim_cfi selects which JIT region the CFI describes (GDB path only):
- * - NULL: executor trace; steady-state rule in the CIE applies at every PC.
- * - non-NULL: compile_shim() output; the captured CIE/FDE CFI bytes are
- *            spliced in so unwinding is valid at every PC in the shim.
  */
 size_t _PyJitUnwind_BuildEhFrame(uint8_t *buffer, size_t buffer_size,
                                  const void *code_addr, size_t code_size,
-                                 int absolute_addr,
-                                 const _PyJitUnwind_ShimCfi *shim_cfi);
+                                 int absolute_addr);
 
 void *_PyJitUnwind_GdbRegisterCode(const void *code_addr,
                                   size_t code_size,
                                   const char *entry,
-                                  const char *filename,
-                                  const _PyJitUnwind_ShimCfi *shim_cfi);
+                                  const char *filename);
 
 void _PyJitUnwind_GdbUnregisterCode(void *handle);
 

Include/internal/pycore_uop_metadata.h

@@ -9,17 +9,13 @@
 
 JIT_SAMPLE_SCRIPT = os.path.join(os.path.dirname(__file__), "gdb_jit_sample.py")
 # In batch GDB, break in builtin_id() while it is running under JIT,
-# then repeatedly "finish" until the selected frame is the JIT entry.
-# That gives a deterministic backtrace starting with py::jit_entry:<jit>.
+# then repeatedly "finish" until the selected frame is the JIT executor.
+# That gives a deterministic backtrace starting with py::jit:executor.
 #
 # builtin_id() sits only a few helper frames above the JIT entry on this path.
 # This bound is just a generous upper limit so the test fails clearly if the
 # expected stack shape changes.
 MAX_FINISH_STEPS = 20
-# Break directly on the lazy shim entry in the binary, then single-step just
-# enough to let it install the compiled JIT entry and set a temporary
-# breakpoint on the resulting address.
-MAX_ENTRY_SETUP_STEPS = 20
 # After landing on the JIT entry frame, single-step a bounded number of
 # instructions further into the blob so the backtrace is taken from JIT code
 # itself rather than the immediate helper-return site. The exact number of
@@ -28,11 +24,13 @@
 # JIT region, instead of asserting against a misleading backtrace.
 MAX_JIT_ENTRY_STEPS = 4
 EVAL_FRAME_RE = r"(_PyEval_EvalFrameDefault|_PyEval_Vector)"
+JIT_ENTRY_RE = r"_PyJIT_Entry"
+JIT_EXECUTOR_FRAME = "py::jit:executor"
 BACKTRACE_FRAME_RE = re.compile(r"^#\d+\s+.*$", re.MULTILINE)
 
-FINISH_TO_JIT_ENTRY = (
+FINISH_TO_JIT_EXECUTOR = (
     "python exec(\"import gdb\\n"
-    "target = 'py::jit_entry:<jit>'\\n"
+    f"target = {JIT_EXECUTOR_FRAME!r}\\n"
     f"for _ in range({MAX_FINISH_STEPS}):\\n"
     "    frame = gdb.selected_frame()\\n"
     "    if frame is not None and frame.name() == target:\\n"
@@ -41,21 +39,9 @@
     "else:\\n"
     "    raise RuntimeError('did not reach %s' % target)\\n\")"
 )
-BREAK_IN_COMPILED_JIT_ENTRY = (
+STEP_INSIDE_JIT_EXECUTOR = (
     "python exec(\"import gdb\\n"
-    "lazy = int(gdb.parse_and_eval('(void*)_Py_LazyJitShim'))\\n"
-    f"for _ in range({MAX_ENTRY_SETUP_STEPS}):\\n"
-    "    entry = int(gdb.parse_and_eval('(void*)_Py_jit_entry'))\\n"
-    "    if entry != lazy:\\n"
-    "        gdb.execute('tbreak *0x%x' % entry)\\n"
-    "        break\\n"
-    "    gdb.execute('next')\\n"
-    "else:\\n"
-    "    raise RuntimeError('compiled JIT entry was not installed')\\n\")"
-)
-STEP_INSIDE_JIT_ENTRY = (
-    "python exec(\"import gdb\\n"
-    "target = 'py::jit_entry:<jit>'\\n"
+    f"target = {JIT_EXECUTOR_FRAME!r}\\n"
     f"for _ in range({MAX_JIT_ENTRY_STEPS}):\\n"
     "    frame = gdb.selected_frame()\\n"
     "    if frame is None or frame.name() != target:\\n"
@@ -103,10 +89,12 @@ def _extract_backtrace_frames(self, gdb_output):
     def _assert_jit_backtrace_shape(self, gdb_output, *, anchor_at_top):
         # Shape assertions applied to every JIT backtrace we produce:
         #   1. The synthetic JIT symbol appears exactly once. A second
-        #      py::jit_entry:<jit> frame would mean the unwinder is
+        #      py::jit:executor frame would mean the unwinder is
         #      materializing two native frames for a single logical JIT
         #      region, or failing to unwind out of the region entirely.
-        #   2. At least one _PyEval_EvalFrameDefault / _PyEval_Vector
+        #   2. The linked shim frame appears exactly once after the
+        #      synthetic JIT frame and before the eval loop.
+        #   3. At least one _PyEval_EvalFrameDefault / _PyEval_Vector
         #      frame appears after the JIT frame, proving the unwinder
         #      climbs back out of the JIT region into the eval loop.
         #      Helper frames from inside the JITted region may still
@@ -116,11 +104,18 @@ def _assert_jit_backtrace_shape(self, gdb_output, *, anchor_at_top):
         frames = self._extract_backtrace_frames(gdb_output)
         backtrace = "\n".join(frames)
 
-        jit_frames = [frame for frame in frames if "py::jit_entry:<jit>" in frame]
+        jit_frames = [frame for frame in frames if JIT_EXECUTOR_FRAME in frame]
         jit_count = len(jit_frames)
         self.assertEqual(
             jit_count, 1,
-            f"expected exactly 1 py::jit_entry:<jit> frame, got {jit_count}\n"
+            f"expected exactly 1 {JIT_EXECUTOR_FRAME} frame, got {jit_count}\n"
+            f"backtrace:\n{backtrace}",
+        )
+        jit_entry_frames = [frame for frame in frames if re.search(JIT_ENTRY_RE, frame)]
+        jit_entry_count = len(jit_entry_frames)
+        self.assertEqual(
+            jit_entry_count, 1,
+            f"expected exactly 1 _PyJIT_Entry frame, got {jit_entry_count}\n"
             f"backtrace:\n{backtrace}",
         )
         eval_frames = [frame for frame in frames if re.search(EVAL_FRAME_RE, frame)]
@@ -131,7 +126,15 @@ def _assert_jit_backtrace_shape(self, gdb_output, *, anchor_at_top):
             f"backtrace:\n{backtrace}",
         )
         jit_frame_index = next(
-            i for i, frame in enumerate(frames) if "py::jit_entry:<jit>" in frame
+            i for i, frame in enumerate(frames) if JIT_EXECUTOR_FRAME in frame
+        )
+        jit_entry_index = next(
+            i for i, frame in enumerate(frames) if re.search(JIT_ENTRY_RE, frame)
+        )
+        self.assertGreater(
+            jit_entry_index, jit_frame_index,
+            "expected _PyJIT_Entry after the synthetic JIT frame\n"
+            f"backtrace:\n{backtrace}",
         )
         eval_after_jit = any(
             re.search(EVAL_FRAME_RE, frame)
@@ -142,10 +145,23 @@ def _assert_jit_backtrace_shape(self, gdb_output, *, anchor_at_top):
             f"expected an eval frame after the JIT frame\n"
             f"backtrace:\n{backtrace}",
         )
+        eval_after_entry = any(
+            re.search(EVAL_FRAME_RE, frame)
+            for frame in frames[jit_entry_index + 1:]
+        )
+        self.assertTrue(
+            eval_after_entry,
+            "expected an eval frame after _PyJIT_Entry\n"
+            f"backtrace:\n{backtrace}",
+        )
         relevant_end = max(
             i
             for i, frame in enumerate(frames)
-            if "py::jit_entry:<jit>" in frame or re.search(EVAL_FRAME_RE, frame)
+            if (
+                JIT_EXECUTOR_FRAME in frame
+                or re.search(JIT_ENTRY_RE, frame)
+                or re.search(EVAL_FRAME_RE, frame)
+            )
         )
         truncated_frames = [
             frame for frame in frames[: relevant_end + 1]
@@ -159,46 +175,29 @@ def _assert_jit_backtrace_shape(self, gdb_output, *, anchor_at_top):
         if anchor_at_top:
             self.assertRegex(
                 frames[0],
-                re.compile(r"^#0\s+py::jit_entry:<jit>"),
+                re.compile(rf"^#0\s+{re.escape(JIT_EXECUTOR_FRAME)}"),
             )
 
-    def test_bt_shows_compiled_jit_entry(self):
-        gdb_output = self.get_stack_trace(
-            script=JIT_SAMPLE_SCRIPT,
-            breakpoint="_Py_LazyJitShim",
-            cmds_after_breakpoint=[
-                BREAK_IN_COMPILED_JIT_ENTRY,
-                "continue",
-                "bt",
-            ],
-            PYTHON_JIT="1",
-        )
-        # GDB registers the compiled JIT entry and per-trace JIT regions under
-        # the same synthetic symbol name; breaking at the entry PC pins the
-        # JIT frame at #0.
-        self._assert_jit_backtrace_shape(gdb_output, anchor_at_top=True)
-
     def test_bt_unwinds_through_jit_frames(self):
         gdb_output = self.get_stack_trace(
             script=JIT_SAMPLE_SCRIPT,
             cmds_after_breakpoint=["bt"],
             PYTHON_JIT="1",
         )
         # The executor should appear as a named JIT frame and unwind back into
-        # the eval loop. Whether GDB also materializes a separate shim frame is
-        # an implementation detail of the synthetic executor CFI.
+        # the eval loop.
         self._assert_jit_backtrace_shape(gdb_output, anchor_at_top=False)
 
-    def test_bt_unwinds_from_inside_jit_entry(self):
+    def test_bt_unwinds_from_inside_jit_executor(self):
         gdb_output = self.get_stack_trace(
             script=JIT_SAMPLE_SCRIPT,
             cmds_after_breakpoint=[
-                FINISH_TO_JIT_ENTRY,
-                STEP_INSIDE_JIT_ENTRY,
+                FINISH_TO_JIT_EXECUTOR,
+                STEP_INSIDE_JIT_EXECUTOR,
                 "bt",
             ],
             PYTHON_JIT="1",
         )
-        # Once the selected PC is inside the JIT entry, we require that GDB
+        # Once the selected PC is inside the JIT executor, we require that GDB
         # identifies the JIT frame at #0 and keeps unwinding into _PyEval_*.
         self._assert_jit_backtrace_shape(gdb_output, anchor_at_top=True)

Lib/test/test_gdb/test_jit.py

@@ -6118,6 +6118,11 @@ dummy_func(
 #ifndef _Py_JIT
             assert(current_executor == (_PyExecutorObject*)executor);
 #endif
+            // Keep the return-to-_PyJIT_Entry PC in a reserved
+            // callee-saved register so the executor-wide GDB FDE can
+            // always materialize _PyJIT_Entry as the immediate caller
+            // frame.
+            _Py_JIT_CAPTURE_CALLER_PC();
             assert(tstate->jit_exit == NULL || tstate->jit_exit->executor == current_executor);
             tstate->current_executor = (PyObject *)current_executor;
             if (!current_executor->vm_data.valid) {

Python/bytecodes.c

@@ -1305,7 +1305,7 @@ _PyEval_EvalFrameDefault(PyThreadState *tstate, _PyInterpreterFrame *frame, int
 }
 #ifdef _Py_TIER2
 #ifdef _Py_JIT
-_PyJitEntryFuncPtr _Py_jit_entry = _PyJIT;
+_PyJitEntryFuncPtr _Py_jit_entry = _PyJIT_Entry;
 #else
 _PyJitEntryFuncPtr _Py_jit_entry = _PyTier2Interpreter;
 #endif

Python/ceval.c

@@ -168,6 +168,20 @@
 #define STOP_TRACING() ((void)(0));
 #endif
 
+/*
+ * The executor runs inside the frame established by _PyJIT_Entry. On AArch64,
+ * helper-calling stencils would otherwise leave the return-to-_PyJIT_Entry PC
+ * in different places at different executor PCs. Capture the entry x30 into
+ * reserved x28 once so the executor-wide GDB FDE in Python/jit_unwind.c can
+ * always materialize _PyJIT_Entry as the immediate caller frame.
+ */
+#if defined(_Py_JIT) && defined(__aarch64__) && defined(__AARCH64EL__) && !defined(__ILP32__)
+#  define _Py_JIT_CAPTURE_CALLER_PC() \
+    __asm__ volatile("mov x28, x30")
+#else
+#  define _Py_JIT_CAPTURE_CALLER_PC() ((void)0)
+#endif
+
 
 /* PRE_DISPATCH_GOTO() does lltrace if enabled. Normally a no-op */
 #ifdef Py_DEBUG

Python/ceval_macros.h

@@ -63,8 +63,7 @@ jit_error(const char *message)
 
 static void *
 jit_record_code(const void *code_addr, size_t code_size,
-                const char *entry, const char *filename,
-                const _PyJitUnwind_ShimCfi *shim_cfi)
+                const char *entry, const char *filename)
 {
 #ifdef PY_HAVE_PERF_TRAMPOLINE
     _PyPerf_Callbacks callbacks;
@@ -78,20 +77,16 @@ jit_record_code(const void *code_addr, size_t code_size,
 
 #if defined(__linux__) && defined(__ELF__)
     return _PyJitUnwind_GdbRegisterCode(
-        code_addr, code_size, entry, filename, shim_cfi);
+        code_addr, code_size, entry, filename);
 #else
     (void)code_addr;
     (void)code_size;
     (void)entry;
     (void)filename;
-    (void)shim_cfi;
     return NULL;
 #endif
 }
 
-static size_t _Py_jit_shim_size = 0;
-static void *_Py_jit_shim_gdb_handle = NULL;
-
 static int
 address_in_executor_array(_PyExecutorObject **ptrs, size_t count, uintptr_t addr)
 {
@@ -749,9 +744,8 @@ _PyJIT_Compile(_PyExecutorObject *executor, const _PyUOpInstruction trace[], siz
     executor->jit_size = total_size;
     executor->jit_gdb_handle = jit_record_code(memory,
                     code_size + state.trampolines.size,
-                    "jit_entry",
-                    "<jit>",
-                    /*shim_cfi=*/NULL);
+                    "jit",
+                    "executor");
     return 0;
 }