+2020-08-27 Pedro Alves <pedro@palves.net>
+
+ PR gdb/26524
+ * breakpoint.c (until_break_fsm) <location_breakpoint,
+ caller_breakpoint>: Delete fields.
+ <breakpoints>: New field.
+ <until_break_fsm>: Adjust to save a breakpoint vector instead of
+ two individual breakpoints.
+ (until_break_fsm::should_stop): Loop over breakpoints in the
+ breakpoint vector.
+ (until_break_fsm::clean_up): Adjust to clear the breakpoints
+ vector.
+ (until_break_command): Handle location expanding into multiple
+ sals.
+
2020-08-27 Pedro Alves <pedro@palves.net>
PR gdb/26523
/* The thread that was current when the command was executed. */
int thread;
- /* The breakpoint set at the destination location. */
- breakpoint_up location_breakpoint;
-
- /* Breakpoint set at the return address in the caller frame. May be
- NULL. */
- breakpoint_up caller_breakpoint;
+ /* The breakpoint set at the return address in the caller frame,
+ plus breakpoints at all the destination locations. */
+ std::vector<breakpoint_up> breakpoints;
until_break_fsm (struct interp *cmd_interp, int thread,
- breakpoint_up &&location_breakpoint,
- breakpoint_up &&caller_breakpoint)
+ std::vector<breakpoint_up> &&breakpoints)
: thread_fsm (cmd_interp),
thread (thread),
- location_breakpoint (std::move (location_breakpoint)),
- caller_breakpoint (std::move (caller_breakpoint))
+ breakpoints (std::move (breakpoints))
{
}
bool
until_break_fsm::should_stop (struct thread_info *tp)
{
- if (bpstat_find_breakpoint (tp->control.stop_bpstat,
- location_breakpoint.get ()) != NULL
- || (caller_breakpoint != NULL
- && bpstat_find_breakpoint (tp->control.stop_bpstat,
- caller_breakpoint.get ()) != NULL))
- set_finished ();
+ for (const breakpoint_up &bp : breakpoints)
+ if (bpstat_find_breakpoint (tp->control.stop_bpstat,
+ bp.get ()) != NULL)
+ {
+ set_finished ();
+ break;
+ }
return true;
}
until_break_fsm::clean_up (struct thread_info *)
{
/* Clean up our temporary breakpoints. */
- location_breakpoint.reset ();
- caller_breakpoint.reset ();
+ breakpoints.clear ();
delete_longjmp_breakpoint (thread);
}
: decode_line_1 (location.get (), DECODE_LINE_FUNFIRSTLINE,
NULL, NULL, 0));
- if (sals.size () != 1)
+ if (sals.empty ())
error (_("Couldn't get information on specified line."));
- symtab_and_line &sal = sals[0];
-
if (*arg)
error (_("Junk at end of arguments."));
- resolve_sal_pc (&sal);
-
tp = inferior_thread ();
thread = tp->global_num;
/* Keep within the current frame, or in frames called by the current
one. */
- breakpoint_up caller_breakpoint;
+ std::vector<breakpoint_up> breakpoints;
gdb::optional<delete_longjmp_breakpoint_cleanup> lj_deleter;
sal2 = find_pc_line (frame_unwind_caller_pc (frame), 0);
sal2.pc = frame_unwind_caller_pc (frame);
caller_gdbarch = frame_unwind_caller_arch (frame);
- caller_breakpoint = set_momentary_breakpoint (caller_gdbarch,
- sal2,
- caller_frame_id,
- bp_until);
+
+ breakpoint_up caller_breakpoint
+ = set_momentary_breakpoint (caller_gdbarch, sal2,
+ caller_frame_id, bp_until);
+ breakpoints.emplace_back (std::move (caller_breakpoint));
set_longjmp_breakpoint (tp, caller_frame_id);
lj_deleter.emplace (thread);
/* set_momentary_breakpoint could invalidate FRAME. */
frame = NULL;
- breakpoint_up location_breakpoint;
- if (anywhere)
- /* If the user told us to continue until a specified location,
- we don't specify a frame at which we need to stop. */
- location_breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
- null_frame_id, bp_until);
- else
- /* Otherwise, specify the selected frame, because we want to stop
- only at the very same frame. */
- location_breakpoint = set_momentary_breakpoint (frame_gdbarch, sal,
- stack_frame_id, bp_until);
+ /* If the user told us to continue until a specified location, we
+ don't specify a frame at which we need to stop. Otherwise,
+ specify the selected frame, because we want to stop only at the
+ very same frame. */
+ frame_id stop_frame_id = anywhere ? null_frame_id : stack_frame_id;
+
+ for (symtab_and_line &sal : sals)
+ {
+ resolve_sal_pc (&sal);
+
+ breakpoint_up location_breakpoint
+ = set_momentary_breakpoint (frame_gdbarch, sal,
+ stop_frame_id, bp_until);
+ breakpoints.emplace_back (std::move (location_breakpoint));
+ }
tp->thread_fsm = new until_break_fsm (command_interp (), tp->global_num,
- std::move (location_breakpoint),
- std::move (caller_breakpoint));
+ std::move (breakpoints));
if (lj_deleter)
lj_deleter->release ();
+2020-08-27 Pedro Alves <pedro@palves.net>
+
+ PR gdb/26523
+ PR gdb/26524
+ * gdb.base/advance-until-multiple-locations.cc: New.
+ * gdb.base/advance-until-multiple-locations.exp: New.
+
2020-08-27 Simon Marchi <simon.marchi@polymtl.ca>
* gdb.dwarf2/dw2-reg-undefined.exp: Use multi_line.
--- /dev/null
+/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 2020 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/>. */
+
+static inline int __attribute__ ((always_inline))
+inline_func (int i)
+{
+ i++; /* multiple locations here */
+ return i;
+}
+
+int global = 0;
+
+void
+ovld_func ()
+{
+ global = 1;
+}
+
+void
+ovld_func (int)
+{
+ global = 2;
+}
+
+/* This is a separate function so that we can test that "until" stops
+ at the caller. */
+
+int
+test ()
+{
+ int i = 0;
+
+ i = inline_func (i);
+ i = inline_func (i);
+ i = inline_func (i);
+
+ ovld_func ();
+ ovld_func (0);
+
+ return 0;
+}
+
+int
+main ()
+{
+ return test ();
+}
--- /dev/null
+# Copyright 2020 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/>. */
+
+# Test 'advance/until LINESPEC' where LINESPEC expands to multiple
+# locations.
+
+standard_testfile .cc
+
+if { [skip_cplus_tests] } { continue }
+
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile} \
+ {debug c++}] } {
+ return -1
+}
+
+set lineno [gdb_get_line_number "multiple locations here"]
+
+# advance/until to an inlined line number, which has been inlined
+# multiple times, when the program is stopped at the same inlined
+# function.
+proc_with_prefix until_advance_lineno_from_inlined {cmd} {
+ global lineno
+
+ if ![runto test] {
+ fail "can't run to test"
+ return
+ }
+
+ gdb_breakpoint $lineno
+ gdb_continue_to_breakpoint "break here"
+
+ set lineno2 [expr $lineno + 1]
+
+ gdb_test "$cmd $lineno2" \
+ "inline_func .* at .*:$lineno2.*return i.*" \
+ "$cmd line number"
+}
+
+# advance/until to a line number, which has been inlined multiple
+# times, when the program is stopped at a non-inlined function.
+
+proc_with_prefix until_advance_lineno_from_non_inlined {cmd} {
+ global lineno
+
+ if ![runto test] {
+ fail "can't run to test"
+ return
+ }
+
+ gdb_test "$cmd $lineno" \
+ "inline_func .* at .*:$lineno.*multiple locations here.*" \
+ "$cmd line number"
+}
+
+# Test advancing to an inlined function, which has been inlined
+# multiple times.
+
+proc_with_prefix until_advance_inline_func {cmd} {
+ global lineno
+
+ if ![runto test] {
+ fail "can't run to test"
+ return
+ }
+
+ gdb_test "$cmd inline_func" \
+ "inline_func .* at .*:$lineno.*multiple locations here.*"
+}
+
+# Test advancing to an overloaded function, which is another form of a
+# linespec expanding to multiple locations. GDB will stop at the
+# first overload called.
+
+proc_with_prefix advance_overload {} {
+ global lineno
+
+ if ![runto test] {
+ fail "can't run to test"
+ return
+ }
+
+ # Test that advance stops at the first overload called by the
+ # program.
+
+ gdb_test "advance ovld_func" \
+ "ovld_func .* at .*global = 1.*" \
+ "first advance stops at ovld_func()"
+
+ # Now test that advance also stops at the other overload called by
+ # the program.
+
+ # Need to issue the advance twice, because advance also stops upon
+ # exit from the current stack frame.
+ gdb_test "advance ovld_func" \
+ "ovld_func \\(0\\);.*" \
+ "second advance stops at caller"
+
+ gdb_test "advance ovld_func" \
+ "ovld_func .* at .*global = 2.*" \
+ "third advance stops at ovld_func(int)"
+}
+
+# Test "until" to an overloaded function, which is another form of a
+# linespec expanding to multiple locations. Unlike "advance", "until"
+# only stops if still in the same frame. Since the overloaded
+# function is a different frame, the program should stop at the caller
+# frame instead.
+
+proc_with_prefix until_overload {} {
+ global lineno
+
+ if ![runto test] {
+ fail "can't run to test"
+ return
+ }
+
+ # ovld_func is a different frame, so it shouldn't cause a stop.
+ # Instead, the program should stop at the caller frame.
+ gdb_test "until ovld_func" \
+ "main .* at .*return test \\(\\);.*"
+}
+
+foreach_with_prefix cmd {"until" "advance"} {
+ until_advance_lineno_from_inlined $cmd
+ until_advance_lineno_from_non_inlined $cmd
+ until_advance_inline_func $cmd
+}
+
+advance_overload
+until_overload
projects / binutils-gdb.git / commitdiff