gdb/python: don't allow FinishBreakpoints for inline frames

Creating a Python gdb.FinishBreakpoint for an inline frame doesn't
work.

If we look at the 'finish' command, in the finish_command
function (infcmd.c) then we see that GDB handles inline frames very
different to non-inline frames.

For non-inline frames GDB creates a temporary breakpoint and then
resumes the inferior until the breakpoint is hit.

But for inline frames, GDB steps forward until we have left the inline
frame.

When it comes to gdb.FinishBreakpoint we only have the "create a
temporary breakpoint" mechanism; that is, after all, what the
FinishBreakpoint is, it's a temporary breakpoint placed at the
return address in the caller.

Currently, when a FinishBreakpoint is created within an inline frame,
GDB ends up creating the breakpoint at the current $pc.  As a result
the breakpoint will not be hit before the current function
exits (unless there's a loop going on, but that's not the point).

We could imagine what a solution to this problem would look like, GDB
would need to figure out the set of addresses for all possible exit
points from the inline function, and place a breakpoint at each of
these locations.  I don't propose doing that in this commit.

Instead, I plan to update the docs to note that creating a
FinishBreakpoint within an inline frame is not allowed, and I will
catch this case within bpfinishpy_init (python/py-finishbreakpoint.c)
and throw an error.

Though the error is new, all I'm doing is raising an error for a case
that never worked.

There's a new test to cover this case.

Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=18339

Reviewed-By: Eli Zaretskii <eliz@gnu.org>
Approved-By: Tom Tromey <tom@tromey.com>

diff --git a/gdb/doc/python.texi b/gdb/doc/python.texi
index 009ac7a3f9fd52fa0228ad5c43ec6b3b22e7767b..2df3b7c042363fff83d7555846dbcb101d642c71 100644 (file)
--- a/gdb/doc/python.texi
+++ b/gdb/doc/python.texi
@@ -7282,6 +7282,9 @@ and deleted when the execution will run out of the breakpoint scope (i.e.@:
 Finish breakpoints are thread specific and must be create with the right
 thread selected.
 
+It is not possible to create a @code{gdb.FinishBreakpoint} for an
+inline frame (@pxref{Inline Functions}).
+
 @defun FinishBreakpoint.__init__ (@r{[}frame@r{]} @r{[}, internal@r{]})
 Create a finish breakpoint at the return address of the @code{gdb.Frame}
 object @var{frame}.  If @var{frame} is not provided, this defaults to the

diff --git a/gdb/python/py-finishbreakpoint.c b/gdb/python/py-finishbreakpoint.c
index 4af8ec6c75f251a584b379cb1296f4c755cb4a3f..834f85037c0da2af7962c47e344b347081de3678 100644 (file)
--- a/gdb/python/py-finishbreakpoint.c
+++ b/gdb/python/py-finishbreakpoint.c
@@ -192,10 +192,16 @@ bpfinishpy_init (PyObject *self, PyObject *args, PyObject *kwargs)
          PyErr_SetString (PyExc_ValueError,
                           _("Invalid ID for the `frame' object."));
        }
+      else if (get_frame_type (frame) == INLINE_FRAME)
+       {
+         PyErr_SetString
+           (PyExc_ValueError,
+            _("Unable to create FinishBreakpoint for inline frame."));
+       }
       else
        {
          prev_frame = get_prev_frame (frame);
-         if (prev_frame == 0)
+         if (prev_frame == nullptr)
            {
              PyErr_SetString (PyExc_ValueError,
                               _("\"FinishBreakpoint\" not "

diff --git a/gdb/testsuite/gdb.python/py-finish-breakpoint-inline.c b/gdb/testsuite/gdb.python/py-finish-breakpoint-inline.c
new file mode 100644 (file)
index 0000000..c955917
--- /dev/null
+++ b/gdb/testsuite/gdb.python/py-finish-breakpoint-inline.c
@@ -0,0 +1,58 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 2026 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see  <http://www.gnu.org/licenses/>.  */
+
+/* Global used to create filler code within functions.  */
+volatile int global_var = 1;
+
+static int  __attribute__ ((noinline, noclone))
+baz (int arg)
+{
+  arg += global_var;
+  return arg;
+}
+
+static inline int __attribute__ ((__always_inline__))
+bar (int arg)
+{
+  arg += global_var;
+  arg = baz (arg);             /* Finish location.  */
+  arg -= global_var;
+  return arg;
+}
+
+static inline int __attribute__ ((__always_inline__))
+foo (int arg)
+{
+  arg += global_var;
+  arg = bar (arg);
+  arg -= global_var;
+  return arg;
+}
+
+int
+main (void)
+{
+  int ans;
+
+  ++global_var;
+  ++global_var;
+  ans = foo (42);
+  ++global_var;
+  ++global_var;
+  ans += global_var;
+  return ans;          /* Final breakpoint.  */
+}

diff --git a/gdb/testsuite/gdb.python/py-finish-breakpoint-inline.exp b/gdb/testsuite/gdb.python/py-finish-breakpoint-inline.exp
new file mode 100644 (file)
index 0000000..d1c3f3d
--- /dev/null
+++ b/gdb/testsuite/gdb.python/py-finish-breakpoint-inline.exp
@@ -0,0 +1,147 @@
+# Copyright (C) 2026 Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Check that attempting to create a FinishBreakpoint within an inline
+# function will fail.
+#
+# For inline functions the 'finish' command steps forward until we are
+# outside the inline function.
+#
+# For FinishBreakpoints though we need to pick an address an place a
+# breakpoint there.  Currently GDB doesn't know where to place such a
+# breakpoint for an inline function, so our solution is to prevent
+# creation of FinishBreakpoints for inline frames.
+
+load_lib gdb-python.exp
+
+require allow_python_tests
+
+standard_testfile
+
+if {[prepare_for_testing "failed to prepare" $testfile $srcfile]} {
+    return
+}
+
+if {![runto_main]} {
+    return
+}
+
+# Source the Python script.
+set pyfile [gdb_remote_download host ${srcdir}/${subdir}/${testfile}.py]
+gdb_test "source $pyfile" "Python script imported" "import python scripts"
+
+# Breakpoint locations needed for this test.
+gdb_breakpoint foo
+gdb_breakpoint bar
+gdb_breakpoint baz
+set final_lineno [gdb_get_line_number "Final breakpoint."]
+gdb_breakpoint $final_lineno
+
+# Depending on how the code is compiled, and exactly where the finish
+# breakpoint is placed, the breakpoint could potentially be reported
+# on either of these lines.
+set lineno_1 [gdb_get_line_number "Finish location."]
+set lineno_2 [expr {$lineno_1 + 1}]
+set lineno_re "(?:$lineno_1|$lineno_2)"
+
+# Run to 'foo', which is an inline function called from a normal
+# function, and try to create a MyFinishBreakpoint.  This should fail.
+gdb_continue_to_breakpoint "breakpoint in foo"
+gdb_test "python MyFinishBreakpoint(gdb.selected_frame())" \
+    "Error occurred in Python: Unable to create FinishBreakpoint for inline frame\\." \
+    "try to create FinishBreakpoint for inline frame, caller is a normal frame"
+
+# Continue to 'bar', which is an inline function called from another
+# inline function, and try to create a MyFinishBreakpoint.  This
+# should fail.
+gdb_continue_to_breakpoint "breakpoint in bar"
+gdb_test "python MyFinishBreakpoint(gdb.selected_frame())" \
+    "Error occurred in Python: Unable to create FinishBreakpoint for inline frame\\." \
+    "try to create FinishBreakpoint for inline frame, caller is an inline frame"
+
+# Continue to 'baz', which is a normal function called from an inline
+# function, and create a MyFinishBreakpoint, which we expect to succeed.
+gdb_continue_to_breakpoint "breakpoint in baz"
+gdb_test "python MyFinishBreakpoint(gdb.selected_frame())" \
+    "Temporary breakpoint $decimal at $hex: file \[^\r\n\]+/$srcfile, line $lineno_re\\." \
+    "create FinishBreakpoint normal function, caller is an inline frame"
+
+# Continue and make sure we hit the MyFinishBreakpoint.
+set saw_finish_breakpoint false
+set saw_return_value false
+set saw_breakpoint_location false
+set saw_source_line false
+gdb_test_multiple "continue" "continue to finish breakpoint" {
+    -re "^Stopped at MyFinishBreakpoint\r\n" {
+       set saw_finish_breakpoint true
+       exp_continue
+    }
+    -re "^Return value is 51\r\n" {
+       set saw_return_value true
+       exp_continue
+    }
+    -re "^Breakpoint $decimal, ($hex in )?bar \\(arg=$decimal\\) at \[^\r\n\]+/$srcfile:$lineno_re\r\n" {
+       set saw_breakpoint_location true
+       exp_continue
+    }
+    -re "^$lineno_re\\s+\[^\r\n\]+\r\n" {
+       set saw_source_line true
+       exp_continue
+    }
+    -re "^$gdb_prompt $" {
+       gdb_assert {$saw_finish_breakpoint \
+                       && $saw_return_value \
+                       && $saw_breakpoint_location \
+                       && $saw_source_line } $gdb_test_name
+    }
+    -re "^\[^\r\n\]*\r\n" {
+       exp_continue
+    }
+}
+
+# Continue to the final breakpoint location.  We don't expect to see
+# any of the MyFinishBreakpoint output here.  If we do then we've hit
+# an unexpected FinishBreakpoint.
+set saw_finish_breakpoint false
+set saw_return_value false
+set saw_breakpoint_location false
+set saw_source_line false
+gdb_test_multiple "continue" "continue to final breakpoint" {
+    -re "^Stopped at MyFinishBreakpoint\r\n" {
+       set saw_finish_breakpoint true
+       exp_continue
+    }
+    -re "^Return value is 51\r\n" {
+       set saw_return_value true
+       exp_continue
+    }
+    -re "^Breakpoint $decimal, main \\(\\) at \[^\r\n\]+/$srcfile:$final_lineno\r\n" {
+       set saw_breakpoint_location true
+       exp_continue
+    }
+    -re "^$final_lineno\\s+\[^\r\n\]+\r\n" {
+       set saw_source_line true
+       exp_continue
+    }
+    -re "^$gdb_prompt $" {
+       gdb_assert {!$saw_finish_breakpoint \
+                       && !$saw_return_value \
+                       && $saw_breakpoint_location \
+                       && $saw_source_line } $gdb_test_name
+    }
+    -re "^\[^\r\n\]*\r\n" {
+       exp_continue
+    }
+}

diff --git a/gdb/testsuite/gdb.python/py-finish-breakpoint-inline.py b/gdb/testsuite/gdb.python/py-finish-breakpoint-inline.py
new file mode 100644 (file)
index 0000000..e493dfa
--- /dev/null
+++ b/gdb/testsuite/gdb.python/py-finish-breakpoint-inline.py
@@ -0,0 +1,27 @@
+# Copyright (C) 2026 Free Software Foundation, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+import gdb
+
+
+class MyFinishBreakpoint(gdb.FinishBreakpoint):
+    def stop(self):
+        print("Stopped at MyFinishBreakpoint")
+        print("Return value is {}".format(self.return_value))
+        return True
+
+
+print("Python script imported")