Assert backtrace shape in test_gdb.test_jit

Add a shared helper that asserts exactly one py::jit_entry frame
above at least one eval frame, so regressions producing duplicate
JIT frames or JIT-below-eval can't pass the old tolerant regex.

Author: pablogsal

Lib/test/test_gdb/test_jit.py

@@ -84,6 +84,41 @@ def setUpModule():
 @unittest.skipUnless(hasattr(sys, "_jit") and sys._jit.is_enabled(),
                      "requires a JIT-enabled build with JIT execution active")
 class JitBacktraceTests(DebuggerTests):
+    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
+        #      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
+        #      frame appears (the JIT is always reached from the eval
+        #      loop in these tests).
+        #   3. The JIT frame is above (i.e. textually before, since GDB
+        #      prints innermost first) an eval frame.
+        #   4. For tests that assert a specific entry PC, the JIT frame
+        #      is also at #0.
+        jit_count = len(re.findall(r"py::jit_entry:<jit>", gdb_output))
+        self.assertEqual(
+            jit_count, 1,
+            f"expected exactly 1 py::jit_entry:<jit> frame, got {jit_count}\n"
+            f"backtrace:\n{gdb_output}",
+        )
+        eval_count = len(re.findall(EVAL_FRAME_RE, gdb_output))
+        self.assertGreaterEqual(
+            eval_count, 1,
+            f"expected at least one _PyEval_* frame, got {eval_count}\n"
+            f"backtrace:\n{gdb_output}",
+        )
+        jit_before_eval = re.compile(
+            rf"py::jit_entry:<jit>.*{EVAL_FRAME_RE}", re.DOTALL
+        )
+        self.assertRegex(gdb_output, jit_before_eval)
+        if anchor_at_top:
+            self.assertRegex(
+                gdb_output,
+                re.compile(r"#0\s+py::jit_entry:<jit>", re.DOTALL),
+            )
+
     def test_bt_shows_compiled_jit_entry(self):
         gdb_output = self.get_stack_trace(
             script=JIT_SAMPLE_SCRIPT,
@@ -96,14 +131,9 @@ def test_bt_shows_compiled_jit_entry(self):
             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_entry:<jit>.*{EVAL_FRAME_RE}",
-                re.DOTALL,
-            ),
-        )
+        # 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(
@@ -114,13 +144,7 @@ def test_bt_unwinds_through_jit_frames(self):
         # 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.
-        self.assertRegex(
-            gdb_output,
-            re.compile(
-                rf"py::jit_entry:<jit>.*{EVAL_FRAME_RE}",
-                re.DOTALL,
-            ),
-        )
+        self._assert_jit_backtrace_shape(gdb_output, anchor_at_top=False)
 
     def test_bt_unwinds_from_inside_jit_entry(self):
         gdb_output = self.get_stack_trace(
@@ -132,12 +156,6 @@ def test_bt_unwinds_from_inside_jit_entry(self):
             ],
             PYTHON_JIT="1",
         )
-        # 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_entry:<jit>.*{EVAL_FRAME_RE}",
-                re.DOTALL,
-            ),
-        )
+        # Once the selected PC is inside the JIT entry, 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)