Address Pablo's feedback

Author: diegorusso

Include/internal/pycore_ceval.h

@@ -94,7 +94,7 @@ typedef struct {
     void* (*init_state)(void);
     // Callback to register every trampoline being created
     void (*write_state)(void* state, const void *code_addr,
-                        unsigned int code_size, PyCodeObject* code);
+                        size_t code_size, PyCodeObject* code);
     // Callback to free the trampoline state
     int (*free_state)(void* state);
 } _PyPerf_Callbacks;
@@ -109,7 +109,7 @@ extern PyStatus _PyPerfTrampoline_AfterFork_Child(void);
 extern _PyPerf_Callbacks _Py_perfmap_callbacks;
 extern _PyPerf_Callbacks _Py_perfmap_jit_callbacks;
 extern void _PyPerfJit_WriteNamedCode(const void *code_addr,
-                                      unsigned int code_size,
+                                      size_t code_size,
                                       const char *entry,
                                       const char *filename);
 #endif

Include/internal/pycore_interp_structs.h

@@ -69,7 +69,7 @@ struct code_arena_st;
 struct trampoline_api_st {
     void* (*init_state)(void);
     void (*write_state)(void* state, const void *code_addr,
-                        unsigned int code_size, PyCodeObject* code);
+                        size_t code_size, PyCodeObject* code);
     int (*free_state)(void* state);
     void *state;
     Py_ssize_t code_padding;

Include/internal/pycore_jit_unwind.h

@@ -19,7 +19,7 @@ size_t _PyJitUnwind_BuildEhFrame(uint8_t *buffer, size_t buffer_size,
                                  int absolute_addr);
 
 void _PyJitUnwind_GdbRegisterCode(const void *code_addr,
-                                  unsigned int code_size,
+                                  size_t code_size,
                                   const char *entry,
                                   const char *filename);
 

Lib/test/test_gdb/gdb_jit_sample.py

@@ -1,20 +1,27 @@
 # Sample script for use by test_gdb.test_jit
 
+import _testinternalcapi
 import operator
-import sys
+
+
+WARMUP_ITERATIONS = _testinternalcapi.TIER2_THRESHOLD + 10
 
 
 def jit_bt_hot(depth, warming_up_caller=False):
-    if warming_up_caller:
-        return
     if depth == 0:
-        id(42)
+        if not warming_up_caller:
+            id(42)
         return
 
-    warming_up = True
-    while warming_up:
-        warming_up = sys._jit.is_enabled() & (not sys._jit.is_active())
-        operator.call(jit_bt_hot, depth - 1, warming_up)
+    for iteration in range(WARMUP_ITERATIONS):
+        operator.call(
+            jit_bt_hot,
+            depth - 1,
+            warming_up_caller or iteration + 1 != WARMUP_ITERATIONS,
+        )
 
 
-jit_bt_hot(10)
+# Warm the shared shim once without hitting builtin_id so the real run uses
+# the steady-state shim path when GDB breaks inside id(42).
+jit_bt_hot(1, warming_up_caller=True)
+jit_bt_hot(1)

Lib/test/test_gdb/test_jit.py

@@ -7,6 +7,30 @@
 
 
 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>.
+#
+# builtin_id() sits only a few helper frames above the executor 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
+# 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
+# immediate helper-return site.
+EXECUTOR_SINGLE_STEPS = 2
+
+FINISH_TO_JIT_EXECUTOR = (
+    "python exec(\"import gdb\\n"
+    "target = 'py::jit_executor:<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"
+    "        break\\n"
+    "    gdb.execute('finish')\\n"
+    "else:\\n"
+    "    raise RuntimeError('did not reach %s' % target)\\n\")"
+)
 
 
 def setUpModule():
@@ -24,12 +48,30 @@ def test_bt_unwinds_through_jit_frames(self):
             cmds_after_breakpoint=["bt"],
             PYTHON_JIT="1",
         )
-        self.assertIn("py::jit_executor:<jit>", gdb_output)
-        self.assertIn("py::jit_shim:<jit>", gdb_output)
         self.assertRegex(
             gdb_output,
             re.compile(
-                r"py::jit_executor:<jit>.*(_PyEval_EvalFrameDefault|_PyEval_Vector)",
+                r"py::jit_executor:<jit>.*py::jit_shim:<jit>.*"
+                r"(_PyEval_EvalFrameDefault|_PyEval_Vector)",
+                re.DOTALL,
+            ),
+        )
+
+    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_EXECUTOR,
+                *(["si"] * EXECUTOR_SINGLE_STEPS),
+                "bt",
+            ],
+            PYTHON_JIT="1",
+        )
+        self.assertRegex(
+            gdb_output,
+            re.compile(
+                r"#0\s+py::jit_executor:<jit>.*#1\s+py::jit_shim:<jit>.*"
+                r"(_PyEval_EvalFrameDefault|_PyEval_Vector)",
                 re.DOTALL,
             ),
         )

Modules/_testinternalcapi.c

@@ -1210,7 +1210,7 @@ write_perf_map_entry(PyObject *self, PyObject *args)
 {
     PyObject *code_addr_v;
     const void *code_addr;
-    unsigned int code_size;
+    size_t code_size;
     const char *entry_name;
 
     if (!PyArg_ParseTuple(args, "OIs", &code_addr_v, &code_size, &entry_name))

Python/jit.c

@@ -70,11 +70,11 @@ jit_record_code(const void *code_addr, size_t code_size,
     _PyPerfTrampoline_GetCallbacks(&callbacks);
     if (callbacks.write_state == _Py_perfmap_jit_callbacks.write_state) {
         _PyPerfJit_WriteNamedCode(
-            code_addr, (unsigned int)code_size, entry, filename);
+            code_addr, code_size, entry, filename);
         return;
     }
     _PyJitUnwind_GdbRegisterCode(
-        code_addr, (unsigned int)code_size, entry, filename);
+        code_addr, code_size, entry, filename);
 #else
     (void)code_addr;
     (void)code_size;

Python/jit_unwind.c

@@ -655,11 +655,12 @@ struct jit_descriptor {
     struct jit_code_entry *first_entry;
 };
 
-static volatile struct jit_descriptor __jit_debug_descriptor = {
+Py_EXPORTED_SYMBOL volatile struct jit_descriptor __jit_debug_descriptor = {
     1, JIT_NOACTION, NULL, NULL
 };
 
-static void __attribute__((noinline)) __jit_debug_register_code(void)
+Py_EXPORTED_SYMBOL void __attribute__((noinline))
+__jit_debug_register_code(void)
 {
     /* Keep this call visible to debuggers and not optimized away. */
     (void)__jit_debug_descriptor.action_flag;
@@ -684,7 +685,7 @@ gdb_jit_machine_id(void)
 static void
 gdb_jit_register_code(
     const void *code_addr,
-    unsigned int code_size,
+    size_t code_size,
     const char *symname,
     const uint8_t *eh_frame,
     size_t eh_frame_size
@@ -858,9 +859,9 @@ gdb_jit_register_code(
 
 void
 _PyJitUnwind_GdbRegisterCode(const void *code_addr,
-                           unsigned int code_size,
-                           const char *entry,
-                           const char *filename)
+                             size_t code_size,
+                             const char *entry,
+                             const char *filename)
 {
 #if defined(__linux__) && defined(__ELF__)
     /* GDB expects a stable symbol name and absolute addresses in .eh_frame. */

Python/perf_jit_trampoline.c

@@ -531,7 +531,7 @@ static void* perf_map_jit_init(void) {
 static void perf_map_jit_write_entry_with_name(
     void *state,
     const void *code_addr,
-    unsigned int code_size,
+    size_t code_size,
     const char *entry,
     const char *filename
 )
@@ -724,7 +724,7 @@ static void perf_map_jit_write_entry_with_name(
  * and must not be changed without coordinating with core Python development.
  */
 static void perf_map_jit_write_entry(void *state, const void *code_addr,
-                                    unsigned int code_size, PyCodeObject *co)
+                                     size_t code_size, PyCodeObject *co)
 {
     const char *entry = "";
     const char *filename = "";
@@ -741,7 +741,7 @@ static void perf_map_jit_write_entry(void *state, const void *code_addr,
 }
 
 void
-_PyPerfJit_WriteNamedCode(const void *code_addr, unsigned int code_size,
+_PyPerfJit_WriteNamedCode(const void *code_addr, size_t code_size,
                           const char *entry, const char *filename)
 {
     perf_map_jit_write_entry_with_name(

Python/perf_trampoline.c

@@ -243,7 +243,7 @@ perf_trampoline_code_watcher(PyCodeEvent event, PyCodeObject *co)
 
 static void
 perf_map_write_entry(void *state, const void *code_addr,
-                         unsigned int code_size, PyCodeObject *co)
+                         size_t code_size, PyCodeObject *co)
 {
     const char *entry = "";
     if (co->co_qualname != NULL) {