Rename jit_executor/jit_shim to just jit_entry

This because the two JIT memory regions are visible as unique frame
from the GDB point of view.

Author: diegorusso

Lib/test/test_gdb/test_jit.py

@@ -8,26 +8,26 @@
 
 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 executor.
-# That gives a deterministic backtrace starting with py::jit_executor:<jit>.
+# then repeatedly "finish" until the selected frame is the JIT entry.
+# That gives a deterministic backtrace starting with py::jit_entry:<jit>.
 #
-# builtin_id() sits only a few helper frames above the executor on this path.
+# 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 shim and set a temporary breakpoint on
-# the resulting JIT entry address.
-MAX_SHIM_SETUP_STEPS = 20
-# After landing on the executor frame, single-step a little further into the
-# blob so the backtrace is taken from executor code itself rather than the
+# 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 little further into the
+# blob so the backtrace is taken from JIT code itself rather than the
 # immediate helper-return site.
-EXECUTOR_SINGLE_STEPS = 2
+JIT_ENTRY_SINGLE_STEPS = 2
 EVAL_FRAME_RE = r"(_PyEval_EvalFrameDefault|_PyEval_Vector)"
 
-FINISH_TO_JIT_EXECUTOR = (
+FINISH_TO_JIT_ENTRY = (
     "python exec(\"import gdb\\n"
-    "target = 'py::jit_executor:<jit>'\\n"
+    "target = 'py::jit_entry:<jit>'\\n"
     f"for _ in range({MAX_FINISH_STEPS}):\\n"
     "    frame = gdb.selected_frame()\\n"
     "    if frame is not None and frame.name() == target:\\n"
@@ -36,17 +36,17 @@
     "else:\\n"
     "    raise RuntimeError('did not reach %s' % target)\\n\")"
 )
-BREAK_IN_COMPILED_SHIM = (
+BREAK_IN_COMPILED_JIT_ENTRY = (
     "python exec(\"import gdb\\n"
     "lazy = int(gdb.parse_and_eval('(void*)_Py_LazyJitShim'))\\n"
-    f"for _ in range({MAX_SHIM_SETUP_STEPS}):\\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 shim was not installed')\\n\")"
+    "    raise RuntimeError('compiled JIT entry was not installed')\\n\")"
 )
 
 
@@ -59,21 +59,23 @@ def setUpModule():
     "requires a JIT-enabled build",
 )
 class JitBacktraceTests(DebuggerTests):
-    def test_bt_shows_compiled_jit_shim(self):
+    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_SHIM,
+                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.
         self.assertRegex(
             gdb_output,
             re.compile(
-                rf"#0\s+py::jit_shim:<jit>.*{EVAL_FRAME_RE}",
+                rf"#0\s+py::jit_entry:<jit>.*{EVAL_FRAME_RE}",
                 re.DOTALL,
             ),
         )
@@ -90,27 +92,27 @@ def test_bt_unwinds_through_jit_frames(self):
         self.assertRegex(
             gdb_output,
             re.compile(
-                rf"py::jit_executor:<jit>.*{EVAL_FRAME_RE}",
+                rf"py::jit_entry:<jit>.*{EVAL_FRAME_RE}",
                 re.DOTALL,
             ),
         )
 
-    def test_bt_unwinds_from_inside_jit_executor(self):
+    def test_bt_unwinds_from_inside_jit_entry(self):
         gdb_output = self.get_stack_trace(
             script=JIT_SAMPLE_SCRIPT,
             cmds_after_breakpoint=[
-                FINISH_TO_JIT_EXECUTOR,
-                *(["si"] * EXECUTOR_SINGLE_STEPS),
+                FINISH_TO_JIT_ENTRY,
+                *(["si"] * JIT_ENTRY_SINGLE_STEPS),
                 "bt",
             ],
             PYTHON_JIT="1",
         )
-        # Once the selected PC is inside the executor, we only require that
+        # Once the selected PC is inside the JIT entry, we only require that
         # GDB can identify the JIT frame and keep unwinding into _PyEval_*.
         self.assertRegex(
             gdb_output,
             re.compile(
-                rf"#0\s+py::jit_executor:<jit>.*{EVAL_FRAME_RE}",
+                rf"#0\s+py::jit_entry:<jit>.*{EVAL_FRAME_RE}",
                 re.DOTALL,
             ),
         )

Python/jit.c

@@ -756,7 +756,7 @@ _PyJIT_Compile(_PyExecutorObject *executor, const _PyUOpInstruction trace[], siz
     executor->jit_size = total_size;
     jit_record_code(memory,
                     code_size + state.trampolines.size,
-                    "jit_executor",
+                    "jit_entry",
                     "<jit>");
     return 0;
 }
@@ -810,7 +810,7 @@ compile_shim(void)
     _Py_jit_shim_size = total_size;
     jit_record_code(memory,
                     code_size + state.trampolines.size,
-                    "jit_shim",
+                    "jit_entry",
                     "<jit>");
     return (_PyJitEntryFuncPtr)memory;
 }