mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-27 04:52:05 +08:00
cd2bb70994
While experimenting with the previous patch, I noticed this inconsistency
in GDB's output:
(gdb) b 32
Breakpoint 1 at 0x40062f: file inline-break.c, line 32. (1)
(gdb) r
....
Breakpoint 1, func1 (x=1) at inline-break.c:32 (2)
32 return x * 23; /* break here */
(gdb) info breakpoints
Num Type Disp Enb Address What
1 breakpoint keep y 0x40062f in main at inline-break.c:32 (3)
breakpoint already hit 1 time
(gdb)
Notice that when the breakpoint as set, GDB showed "inline-break.c,
line 32" (1), the same line number that was specified in the command.
When we run to the breakpoint, we present the stop at the same line
number, and correctly show "func1" as the function name (2).
But in "info break" output (3), notice that we say "in main", not "in
func1".
The same thing happens if you set a breakpoint by address. I.e.:
(gdb) b *0x40062f
Breakpoint 2 at 0x40062f: file inline-break.c, line 32.
(gdb) info breakpoints
Num Type Disp Enb Address What
2 breakpoint keep y 0x000000000040062f in main at inline-break.c:32
(gdb) r
....
Breakpoint 2, func1 (x=1) at inline-break.c:32
32 return x * 23; /* break here */
The problem is that the breakpoints were set at an inline function,
but when we set such a breakpoint by line number or address, we don't
record the functions symbol in the sal, and as consequence the
breakpoint location does not have an associated symbol either.
Then, in print_breakpoint_location, if the location does not have a
symbol, we call find_pc_sect_function to find one, and this is what
finds "main", because find_pc_sect_function uses
block_linkage_function:
/* Return the symbol for the function which contains a specified
lexical block, described by a struct block BL. The return value
will not be an inlined function; the containing function will be
returned instead. */
struct symbol *
block_linkage_function (const struct block *bl)
To fix this, this commit adds an alternative to find_pc_sect_function
that uses block_containing_function instead:
/* Return the symbol for the function which contains a specified
block, described by a struct block BL. The return value will be
the closest enclosing function, which might be an inline
function. */
struct symbol *
block_containing_function (const struct block *bl)
(It seems odd to me that block_linkage_function says "the CONTAINING
function will be returned", and then block_containing_function says it
returns "the closest enclosing function". Something seems reversed
here. Still, I've kept the same nomenclature and copied the comments,
so that at least there's consistency. Maybe we should fix that up
somehow.)
Then I wondered, why make print_breakpoint_location look up the symbol
every time it is called, instead of just always storing the symbol
when the location is created, since the location already stores the
symbol in some cases. So to find which cases might be missing setting
the symbol in the sal which is used to create the breakpoint location,
I added an assertion to print_breakpoint_location, and ran the
testsuite. That caught a few places, unsurprisingly:
- setting a breakpoint by line number
- setting a breapoint by address
- ifunc resolving
Those are all fixed by this commit. I decided not to add the
assertion to block_linkage_function and leave the existing "if (sym)"
check in place, because it's plausible that we have symtabs with line
info but no symbols. I.e., that would not be a GDB bug, but
a peculiarity of debug info input.
gdb/ChangeLog:
2018-06-29 Pedro Alves <palves@redhat.com>
* blockframe.c (find_pc_sect_containing_function): New function.
* breakpoint.c (print_breakpoint_location): Don't call
find_pc_sect_function.
* linespec.c (create_sals_line_offset): Record the location's
symbol in the sal.
* linespec.c (convert_address_location_to_sals): Fill in sal's
symbol with find_pc_sect_containing_function.
* symtab.c (find_function_start_sal): Rename to ...
(find_function_start_sal_1): ... this.
(find_function_start_sal): Reimplement as wrapper around
find_function_start_sal_1, and use
find_pc_sect_containing_function to fill in the sal's symbol.
(find_function_start_sal(symbol*, bool)): Adjust.
* symtab.h (find_pc_function, find_pc_sect_function): Adjust
comments.
(find_pc_sect_containing_function): Declare.
gdb/testsuite/ChangeLog:
2018-06-29 Pedro Alves <palves@redhat.com>
* gdb.opt/inline-break.exp (line number, address): Add "info
break" tests.
308 lines
9.7 KiB
Plaintext
308 lines
9.7 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
|
|
}
|
|
}
|
|
}
|
|
|
|
# func_extern_caller calls func_inline_caller which calls
|
|
# func_inline_callee. The latter two are both inline functions. Test
|
|
# that setting a breakpoint on each of the functions reports a stop at
|
|
# that function. This exercises the inline frame skipping logic. If
|
|
# we set a breakpoint at function A, we want to present the stop at A,
|
|
# even if A's entry code is an inlined call to another inline function
|
|
# B.
|
|
|
|
foreach_with_prefix func {
|
|
"func_extern_caller"
|
|
"func_inline_caller"
|
|
"func_inline_callee"
|
|
} {
|
|
clean_restart $binfile
|
|
|
|
if {![runto main]} {
|
|
untested "could not run to main"
|
|
continue
|
|
}
|
|
|
|
gdb_breakpoint $func
|
|
gdb_test "continue" "Breakpoint .* $func .*at .*$srcfile.*" \
|
|
"breakpoint hit presents stop at breakpointed function"
|
|
}
|
|
|
|
# Test setting a breakpoint in an inline function by line number and
|
|
# by address, and that GDB presents the stop there.
|
|
|
|
set line [gdb_get_line_number "break here"]
|
|
|
|
with_test_prefix "line number" {
|
|
clean_restart $binfile
|
|
|
|
if {![runto main]} {
|
|
untested "could not run to main"
|
|
continue
|
|
}
|
|
|
|
# Set the breakpoint by line number, and check that GDB reports
|
|
# the breakpoint location being the inline function.
|
|
gdb_test "break $srcfile:$line" ".*Breakpoint .* at .*: file .*$srcfile, line $line."
|
|
|
|
gdb_test "info break \$bpnum" "in func1 at .*$srcfile:$line"
|
|
|
|
gdb_test "continue" "Breakpoint .*, func1 \\(x=1\\) at .*$srcfile:$line.*break here.*" \
|
|
"breakpoint hit presents stop at inlined function"
|
|
|
|
# Save the PC for the following by-address test.
|
|
set address [get_hexadecimal_valueof "\$pc" "0"]
|
|
}
|
|
|
|
# Test setting a breakpoint in an inline function by address, and that
|
|
# GDB presents the stop there.
|
|
|
|
with_test_prefix "address" {
|
|
|
|
clean_restart $binfile
|
|
|
|
if {![runto main]} {
|
|
untested "could not run to main"
|
|
continue
|
|
}
|
|
|
|
# Set the breakpoint by address, and check that GDB reports the
|
|
# breakpoint location being the inline function.
|
|
gdb_test "break *$address" ".*Breakpoint .* at $address: file .*$srcfile, line $line."
|
|
|
|
gdb_test "info break \$bpnum" "in func1 at .*$srcfile:$line"
|
|
|
|
gdb_test "continue" "Breakpoint .*, func1 \\(x=1\\) at .*$srcfile:$line.*break here.*" \
|
|
"breakpoint hit presents stop at inlined function"
|
|
}
|
|
|
|
unset -nocomplain results
|