mirror of
https://github.com/bminor/binutils-gdb.git
synced 2025-12-26 17:18:55 +00:00
ddfe970e6b
This patch essentially causes GDB to treat inlined frames like "normal"
frames from the user's perspective. This means, for example, that when a
user sets a breakpoint in an inlined function, GDB will now actually stop
"in" that function.
Using the test case from breakpoints/17534,
3 static inline void NVIC_EnableIRQ(int IRQn)
4 {
5 volatile int y;
6 y = IRQn;
7 }
8
9 __attribute__( ( always_inline ) ) static inline void __WFI(void)
10 {
11 __asm volatile ("nop");
12 }
13
14 int main(void) {
15
16 x= 42;
17
18 if (x)
19 NVIC_EnableIRQ(16);
20 else
21 NVIC_EnableIRQ(18);
(gdb) b NVIC_EnableIRQ
Breakpoint 1 at 0x4003e4: NVIC_EnableIRQ. (2 locations)
(gdb) r
Starting program: 17534
Breakpoint 1, main () at 17534.c:19
19 NVIC_EnableIRQ(16);
Because skip_inline_frames currently skips every inlined frame, GDB "stops"
in the caller. This patch adds a new parameter to skip_inline_frames
that allows us to pass in a bpstat stop chain. The breakpoint locations
on the stop chain can be used to determine if we've stopped inside an inline
function (due to a user breakpoint). If we have, we do not elide the frame.
With this patch, GDB now reports that the inferior has stopped inside the
inlined function:
(gdb) r
Starting program: 17534
Breakpoint 1, NVIC_EnableIRQ (IRQn=16) at 17534.c:6
6 y = IRQn;
Many thanks to Jan and Pedro for guidance on this.
gdb/ChangeLog:
* breakpoint.c (build_bpstat_chain): New function, moved from
bpstat_stop_status.
(bpstat_stop_status): Add optional parameter, `stop_chain'.
If no stop chain is passed, call build_bpstat_chain to build it.
* breakpoint.h (build_bpstat_chain): Declare.
(bpstat_stop_status): Move documentation here from breakpoint.c.
* infrun.c (handle_signal_stop): Before eliding inlined frames,
build the stop chain and pass it to skip_inline_frames.
Pass this stop chain to bpstat_stop_status.
* inline-frame.c: Include breakpoint.h.
(stopped_by_user_bp_inline_frame): New function.
(skip_inline_frames): Add parameter `stop_chain'.
Move documention to inline-frame.h.
If non-NULL, use stopped_by_user_bp_inline_frame to determine
whether the frame should be elided.
* inline-frame.h (skip_inline_frames): Add parameter `stop_chain'.
Add moved documentation and update for new parameter.
gdb/testsuite/ChangeLog:
* gdb.ada/bp_inlined_func.exp: Update inlined frame locations
in expected breakpoint stop locations.
* gdb.dwarf2/implptr.exp (implptr_test_baz): Use up/down to
move to proper scope to test variable values.
* gdb.opt/inline-break.c (inline_func1, not_inline_func1)
(inline_func2, not_inline_func2, inline_func3, not_inline_func3):
New functions.
(main): Call not_inline_func3.
* gdb.opt/inline-break.exp: Start inferior and set breakpoints at
inline_func1, inline_func2, and inline_func3. Test that when each
breakpoint is hit, GDB properly reports both the stop location
and the backtrace. Repeat tests for temporary breakpoints.
235 lines
7.5 KiB
Plaintext
235 lines
7.5 KiB
Plaintext
# Copyright 2012-2018 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/>.
|
|
|
|
# Note that the testcase gdb.dwarf2/dw2-inline-break.exp largely
|
|
# mirrors this testcase, and should be updated if this testcase is
|
|
# changed.
|
|
|
|
standard_testfile
|
|
|
|
if { [prepare_for_testing "failed to prepare" $testfile $srcfile \
|
|
{debug additional_flags=-Winline}] } {
|
|
return -1
|
|
}
|
|
|
|
# Return a string that may be used to match the output of "info break NUM".
|
|
#
|
|
# Optional arguments:
|
|
#
|
|
# source - the name of the source file
|
|
# func - the name of the function
|
|
# disp - the event disposition
|
|
# enabled - enable state
|
|
# locs - number of locations
|
|
# line - source line number (ignored without -source)
|
|
|
|
proc break_info_1 {num args} {
|
|
global decimal
|
|
|
|
# Column delimiter
|
|
set c {[\t ]+}
|
|
|
|
# Row delimiter
|
|
set end {[\r\n \t]+}
|
|
|
|
# Table header
|
|
set header "[join [list Num Type Disp Enb Address What] ${c}]"
|
|
|
|
# Get/configure any optional parameters.
|
|
parse_args [list {source ""} {func ".*"} {disp "keep"} \
|
|
{enabled "y"} {locs 1} [list line $decimal] \
|
|
{type "breakpoint"}]
|
|
|
|
if {$source != ""} {
|
|
set source "$source:$line"
|
|
}
|
|
|
|
# Result starts with the standard header.
|
|
set result "$header${end}"
|
|
|
|
# Set up for multi-location breakpoint marker.
|
|
if {$locs == 1} {
|
|
set multi ".*"
|
|
} else {
|
|
set multi "<MULTIPLE>${end}"
|
|
}
|
|
append result "[join [list $num $type $disp $enabled $multi] $c]"
|
|
|
|
# Add location info.
|
|
for {set i 1} {$i <= $locs} {incr i} {
|
|
if {$locs > 1} {
|
|
append result "[join [list $num.$i $enabled] $c].*"
|
|
}
|
|
|
|
# Add function/source file info.
|
|
append result "in $func at .*$source${end}"
|
|
}
|
|
|
|
return $result
|
|
}
|
|
|
|
#
|
|
# func1 is a static inlined function that is called once.
|
|
# The result should be a single-location breakpoint.
|
|
#
|
|
gdb_test "break func1" \
|
|
"Breakpoint.*at.* file .*$srcfile, line.*"
|
|
|
|
#
|
|
# func2 is a non-static inlined function that is called once.
|
|
# The result should be a breakpoint with two locations: the
|
|
# out-of-line function and the single inlined instance.
|
|
#
|
|
gdb_test "break func2" \
|
|
"Breakpoint.*at.*func2.*\\(2 locations\\)"
|
|
|
|
#
|
|
# func3b is a static inlined function that is called once from
|
|
# within another static inlined function. The result should be
|
|
# a single-location breakpoint.
|
|
#
|
|
gdb_test "break func3b" \
|
|
"Breakpoint.*at.* file .*$srcfile, line.*"
|
|
|
|
#
|
|
# func4b is a static inlined function that is called once from
|
|
# within a non-static inlined function. The result should be
|
|
# a breakpoint with two locations: the inlined instance within
|
|
# the inlined call to func4a in main, and the inlined instance
|
|
# within the out-of-line func4a.
|
|
#
|
|
gdb_test "break func4b" \
|
|
"Breakpoint.*at.*func4b.*\\(2 locations\\)"
|
|
|
|
#
|
|
# func5b is a non-static inlined function that is called once
|
|
# from within a static inlined function. The result should be a
|
|
# breakpoint with two locations: the out-of-line function and the
|
|
# inlined instance within the inlined call to func5a in main.
|
|
#
|
|
gdb_test "break func5b" \
|
|
"Breakpoint.*at.*func5b.*\\(2 locations\\)"
|
|
#
|
|
# func6b is a non-static inlined function that is called once from
|
|
# within another non-static inlined function. The result should be
|
|
# a breakpoint with three locations: the out-of-line function, the
|
|
# inlined instance within the out-of-line func6a, and the inlined
|
|
# instance within the inlined call to func6a in main,
|
|
#
|
|
gdb_test "break func6b" \
|
|
"Breakpoint.*at.*func6b.*\\(3 locations\\)"
|
|
|
|
#
|
|
# func7b is a static inlined function that is called twice: once from
|
|
# func7a, and once from main. The result should be a breakpoint with
|
|
# two locations: the inlined instance within the inlined instance of
|
|
# func7a, and the inlined instance within main.
|
|
#
|
|
gdb_test "break func7b" \
|
|
"Breakpoint.*at.*func7b.*\\(2 locations\\)"
|
|
|
|
#
|
|
# func8b is a non-static inlined function that is called twice: once
|
|
# func8a, and once from main. The result should be a breakpoint with
|
|
# three locations: the out-of-line function, the inlined instance
|
|
# within the inlined instance of func7a, and the inlined instance
|
|
# within main.
|
|
#
|
|
gdb_test "break func8b" \
|
|
"Breakpoint.*at.*func8b.*\\(3 locations\\)"
|
|
|
|
#
|
|
# func1 is a static inlined function. The result should be that no
|
|
# symbol is found to print.
|
|
#
|
|
gdb_test "print func1" \
|
|
"No symbol \"func1\" in current context."
|
|
|
|
#
|
|
# func2 is a non-static inlined function. The result should be that
|
|
# one symbol is found to print, and that the printed symbol is called
|
|
# "func2". Note that this does not cover the failure case that two
|
|
# symbols were found, but that gdb chose the out-of-line copy to
|
|
# print, but if this was failing the "print func1" test would likely
|
|
# fail instead.
|
|
#
|
|
gdb_test "print func2" \
|
|
"\\\$.* = {int \\(int\\)} .* <func2>"
|
|
|
|
# Test that "info break" reports the location of the breakpoints "inside"
|
|
# the inlined functions
|
|
|
|
set results(1) [break_info_1 1 -source $srcfile -func "func1"]
|
|
set results(2) [break_info_1 2 -locs 2 -source $srcfile -func "func2"]
|
|
set results(3) [break_info_1 3 -source $srcfile -func "func3b"]
|
|
set results(4) [break_info_1 4 -locs 2 -source $srcfile -func "func4b"]
|
|
set results(5) [break_info_1 5 -locs 2 -source $srcfile -func "func5b"]
|
|
set results(6) [break_info_1 6 -locs 3 -source $srcfile -func "func6b"]
|
|
set results(7) [break_info_1 7 -locs 2 -source $srcfile -func "func7b"]
|
|
set results(8) [break_info_1 8 -locs 3 -source $srcfile -func "func8b"]
|
|
|
|
for {set i 1} {$i <= [array size results]} {incr i} {
|
|
send_log "Expecting: $results($i)\n"
|
|
gdb_test "info break $i" $results($i)
|
|
}
|
|
|
|
# Test "permanent" and "temporary" breakpoints.
|
|
foreach_with_prefix cmd [list "break" "tbreak"] {
|
|
|
|
# Start with a clean state.
|
|
delete_breakpoints
|
|
if {![runto main]} {
|
|
untested "could not run to main"
|
|
return -1
|
|
}
|
|
|
|
# Assemble flags to pass to gdb_breakpoint. Lame but this is just
|
|
# a test suite!
|
|
set break_flags "message"
|
|
if {[string match $cmd "tbreak"]} {
|
|
lappend break_flags "temporary"
|
|
}
|
|
|
|
# Insert breakpoints for all inline_func? and not_inline_func? and check
|
|
# that we actually stop where we think we should.
|
|
for {set i 1} {$i < 4} {incr i} {
|
|
foreach inline {"not_inline" "inline"} {
|
|
eval gdb_breakpoint "${inline}_func$i" $break_flags
|
|
}
|
|
}
|
|
|
|
set ws {[\r\n\t ]+}
|
|
set backtrace [list "(in|at)? main"]
|
|
for {set i 3} {$i > 0} {incr i -1} {
|
|
|
|
foreach inline {"not_inline" "inline"} {
|
|
|
|
# Check that we stop at the correct location and print out
|
|
# the (possibly) inlined frames.
|
|
set num [gdb_get_line_number "/* ${inline}_func$i */"]
|
|
set pattern ".*$srcfile:$num${ws}.*$num${ws}int y = $decimal;"
|
|
append pattern "${ws}/\\\* ${inline}_func$i \\\*/"
|
|
send_log "Expecting $pattern\n"
|
|
gdb_continue_to_breakpoint "${inline}_func$i" $pattern
|
|
|
|
# Also check for the correct backtrace.
|
|
set backtrace [linsert $backtrace 0 "(in|at)?${ws}${inline}_func$i"]
|
|
gdb_test_sequence "bt" "bt stopped in ${inline}_func$i" $backtrace
|
|
}
|
|
}
|
|
}
|
|
|
|
unset -nocomplain results
|