* [PATCH] gdb: stepping between inline functions with multiple ranges
@ 2024-10-18 10:45 Andrew Burgess
2024-11-13 14:22 ` Andrew Burgess
0 siblings, 1 reply; 2+ messages in thread
From: Andrew Burgess @ 2024-10-18 10:45 UTC (permalink / raw)
To: gdb-patches; +Cc: Bernd Edlinger, Andrew Burgess
From: Bernd Edlinger <bernd.edlinger@hotmail.de>
I (Andrew) have split this small change from a larger patch which was
posted here:
https://inbox.sourceware.org/gdb-patches/AS1PR01MB9465608EBD5D62642C51C428E4922@AS1PR01MB9465.eurprd01.prod.exchangelabs.com
And I have written the stand alone test for this issue. The original
patch included this paragraph to explain this change (I've fixed one
typo in this text replacing 'program' with 'function'):
... it may happen that the infrun machinery steps from one inline
range to another inline range of the same inline function. That can
look like jumping back and forth from the calling function to the
inline function, while really the inline function just jumps from a
hot to a cold section of the code, i.e. error handling.
The important thing that happens here is that both the outer function
and the inline function must both have multiple ranges. When the
inferior is within the inline function and moves from one range to
another it is critical that the address we stop at is the start of a
range in both the outer function and the inline function.
The diagram below represents how the functions are split and aligned:
(A) (B)
bar: |------------| |---|
foo: |------------------| |--------|
The inferior is stepping through 'bar' and eventually reaches
point (A) at which point control passes to point (B).
Currently, when the inferior stops, GDB notices that both 'foo' and
'bar' start at address (B), and so GDB uses the inline frame mechanism
to skip 'bar' and tells the user that the inferior is in 'foo'.
However, as we were in 'bar' before the step then it makes sense that
we should be in 'bar' after the step, and this is what the patch does.
There are two tests using the DWARF assembler, the first checks the
above situation and ensures that GDB reports 'bar' after the step.
The second test is similar, but after the step we enter a new range
where a different inline function starts, something like this:
(A) (B)
bar: |------------|
baz: |---|
foo: |------------------| |--------|
In this case as we step at (A) and land at (B) we leave 'bar' and
expect to stop in 'foo', GDB shouldn't automatically enter 'baz' as
that is a completely different inline function. And this is, indeed,
what we see.
Co-Authored-By: Andrew Burgess <aburgess@redhat.com>
---
gdb/infrun.c | 28 +++
...-step-between-different-inline-functions.c | 105 +++++++++
...tep-between-different-inline-functions.exp | 215 ++++++++++++++++++
.../dw2-step-between-inline-func-blocks.c | 100 ++++++++
.../dw2-step-between-inline-func-blocks.exp | 196 ++++++++++++++++
5 files changed, 644 insertions(+)
create mode 100644 gdb/testsuite/gdb.dwarf2/dw2-step-between-different-inline-functions.c
create mode 100644 gdb/testsuite/gdb.dwarf2/dw2-step-between-different-inline-functions.exp
create mode 100644 gdb/testsuite/gdb.dwarf2/dw2-step-between-inline-func-blocks.c
create mode 100644 gdb/testsuite/gdb.dwarf2/dw2-step-between-inline-func-blocks.exp
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 4ca15450afe..623c2d336a1 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -8114,6 +8114,34 @@ process_event_stop_test (struct execution_control_state *ecs)
return;
}
+ /* Handle the case when subroutines have multiple ranges. When we step
+ from one part to the next part of the same subroutine, all subroutine
+ levels are skipped again which begin here. Compensate for this by
+ removing all skipped subroutines, which were already executing from
+ the user's perspective. */
+
+ if (get_stack_frame_id (frame)
+ == ecs->event_thread->control.step_stack_frame_id
+ && inline_skipped_frames (ecs->event_thread) > 0
+ && ecs->event_thread->control.step_frame_id.artificial_depth > 0
+ && ecs->event_thread->control.step_frame_id.code_addr_p)
+ {
+ int depth = 0;
+ const struct block *prev
+ = block_for_pc (ecs->event_thread->control.step_frame_id.code_addr);
+ const struct block *curr = block_for_pc (ecs->event_thread->stop_pc ());
+ while (curr != nullptr && !curr->contains (prev))
+ {
+ if (curr->inlined_p ())
+ depth++;
+ else if (curr->function () != nullptr)
+ break;
+ curr = curr->superblock ();
+ }
+ while (inline_skipped_frames (ecs->event_thread) > depth)
+ step_into_inline_frame (ecs->event_thread);
+ }
+
/* Look for "calls" to inlined functions, part one. If the inline
frame machinery detected some skipped call sites, we have entered
a new inline function. */
diff --git a/gdb/testsuite/gdb.dwarf2/dw2-step-between-different-inline-functions.c b/gdb/testsuite/gdb.dwarf2/dw2-step-between-different-inline-functions.c
new file mode 100644
index 00000000000..5e4fe47b28e
--- /dev/null
+++ b/gdb/testsuite/gdb.dwarf2/dw2-step-between-different-inline-functions.c
@@ -0,0 +1,105 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 2024 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/>. */
+
+/* Used to insert labels within function foo. */
+#define LABEL(N) asm ("foo_label_" #N ": .globl foo_label_" #N)
+
+volatile int global_var = 0;
+
+/* The contents of this '#if 0' block exist so the generated debug can
+ point to these as the source lines. */
+#if 0
+
+void
+bar (void) /* bar decl line */
+{
+ /* bar line 1 */
+ /* bar line 2 */
+}
+
+void
+baz (void) /* baz decl line */
+{
+ /* baz line 1 */
+ /* baz line 2 */
+}
+
+void
+foo (void) /* foo decl line */
+{
+ /* foo line 1 */
+ /* foo line 2 */
+ /* foo line 3 */
+ /* foo line 4 */
+}
+
+#endif
+
+extern void *foo_label_6 (void);
+
+void
+foo (void)
+{
+ /* This label is used to find the start of 'foo' when generating the
+ debug information. */
+ asm ("foo_label: .globl foo_label");
+ ++global_var;
+
+ LABEL (1);
+ ++global_var;
+
+ LABEL (2);
+ ++global_var;
+
+ LABEL (3);
+ ++global_var;
+
+ /* This goto will always trigger, but we make it conditional so that the
+ compiler doesn't optimise out the code between the goto and the
+ destination.
+
+ Also 'goto *ADDR' is a GCC extension, but it is critical that the
+ destination address be a global label so that we can generate DWARF
+ that has ranges that start exactly at the destination address. */
+ if (global_var > 0)
+ goto *(&foo_label_6);
+
+ LABEL (4);
+ ++global_var;
+
+ LABEL (5);
+ ++global_var;
+
+ LABEL (6);
+ ++global_var;
+
+ LABEL (7);
+ ++global_var;
+
+ LABEL (8);
+ ++global_var;
+
+ LABEL (9);
+ ++global_var;
+}
+
+int
+main (void)
+{
+ asm ("main_label: .globl main_label");
+ foo ();
+}
diff --git a/gdb/testsuite/gdb.dwarf2/dw2-step-between-different-inline-functions.exp b/gdb/testsuite/gdb.dwarf2/dw2-step-between-different-inline-functions.exp
new file mode 100644
index 00000000000..7e7c4adcb5c
--- /dev/null
+++ b/gdb/testsuite/gdb.dwarf2/dw2-step-between-different-inline-functions.exp
@@ -0,0 +1,215 @@
+# Copyright 2024 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/>.
+
+# This test is a follow on from the test:
+# gdb.dwarf2/dw2-step-between-inline-func-blocks.exp
+# It is worth reading that test before looking at this one.
+#
+# This test creates a function 'foo' that contains two inline
+# functions 'bar' and 'baz'. The function 'foo' is split into two
+# ranges. 'bar' is inline in the first range and 'baz' is inline in
+# the second range, but critically, 'baz' starts at the very start of
+# the second range. The functions are laid out like this:
+#
+# (A) (B)
+# bar: |------------|
+# baz: |---|
+# foo: |------------------| |--------|
+#
+# When the inferior reaches address (A) we jump directly to point (B).
+# At that point we expect GDB to tell the user that the inferior is in
+# 'foo'. GDB should not automatically enter 'baz'.
+#
+# This tests exists because in
+# dw2-step-between-inline-func-blocks.exp, the second range is another
+# part of 'bar' and the jump from (A) to (B) is from one part of 'bar'
+# to the next, in this case GDB does automatically reenter 'bar'.
+# This test checks that GDB isn't too keen to reenter inline
+# functions.
+
+load_lib dwarf.exp
+
+require dwarf2_support
+
+# The source program use 'goto *ADDR' which is a GCC extension.
+require is_c_compiler_gcc
+
+standard_testfile
+
+# This compiles the source file and starts and stops GDB, so run it
+# before calling prepare_for_testing otherwise GDB will have exited.
+get_func_info foo
+
+# Make some DWARF for the test.
+set asm_file [standard_output_file "$::testfile-dw.S"]
+Dwarf::assemble $asm_file {
+ global srcfile
+
+ # Create local varibles like BAR_SRC_* containing the line number
+ # for the souce lines of 'foo' and 'bar' and 'baz'. These will be
+ # referenced in the generated DWARF.
+ for { set i 1 } { $i <= 2 } { incr i } {
+ set bar_src_$i [gdb_get_line_number "bar line $i"]
+ set baz_src_$i [gdb_get_line_number "baz line $i"]
+ }
+ for { set i 1 } { $i <= 4 } { incr i } {
+ set foo_src_$i [gdb_get_line_number "foo line $i"]
+ }
+
+ # More line numbers needed for the generated DWARF.
+ set foo_decl_line [gdb_get_line_number "foo decl line"]
+ set bar_decl_line [gdb_get_line_number "bar decl line"]
+ set baz_decl_line [gdb_get_line_number "baz decl line"]
+
+ # Labels used to link parts of the DWARF together.
+ declare_labels lines_table bar_label baz_label
+ declare_labels ranges_label_bar ranges_label_baz ranges_label_foo
+
+ cu { version 4 } {
+ compile_unit {
+ {producer "gcc"}
+ {language @DW_LANG_C}
+ {name ${srcfile}}
+ {comp_dir /tmp}
+ {stmt_list $lines_table DW_FORM_sec_offset}
+ {low_pc 0 addr}
+ } {
+ bar_label: subprogram {
+ {external 1 flag}
+ {name bar}
+ {decl_file 1 data1}
+ {decl_line $bar_decl_line data1}
+ {decl_column 1 data1}
+ {inline 3 data1}
+ }
+ baz_label: subprogram {
+ {external 1 flag}
+ {name baz}
+ {decl_file 1 data1}
+ {decl_line $baz_decl_line data1}
+ {decl_column 1 data1}
+ {inline 3 data1}
+ }
+ subprogram {
+ {name foo}
+ {decl_file 1 data1}
+ {decl_line $foo_decl_line data1}
+ {decl_column 1 data1}
+ {ranges ${ranges_label_foo} DW_FORM_sec_offset}
+ {external 1 flag}
+ } {
+ inlined_subroutine {
+ {abstract_origin %$bar_label}
+ {call_file 1 data1}
+ {call_line $foo_src_2 data1}
+ {ranges ${ranges_label_bar} DW_FORM_sec_offset}
+ }
+ inlined_subroutine {
+ {abstract_origin %$baz_label}
+ {call_file 1 data1}
+ {call_line $foo_src_3 data1}
+ {ranges ${ranges_label_baz} DW_FORM_sec_offset}
+ }
+ }
+ }
+ }
+
+ lines {version 2} lines_table {
+ include_dir "$::srcdir/$::subdir"
+ file_name "$srcfile" 1
+ program {
+ DW_LNE_set_address "foo_label"
+ line $foo_src_1
+ DW_LNS_copy
+ DW_LNE_set_address "foo_label_1"
+ line $foo_src_2
+ DW_LNS_copy
+ DW_LNE_set_address "foo_label_2"
+ line $bar_src_1
+ DW_LNS_copy
+ DW_LNE_set_address "foo_label_3"
+ line $bar_src_2
+ DW_LNS_copy
+ DW_LNE_set_address "foo_label_4"
+ DW_LNE_end_sequence
+
+ DW_LNE_set_address "foo_label_6"
+ line $baz_src_1
+ DW_LNS_copy
+ DW_LNE_set_address "foo_label_7"
+ line $baz_src_2
+ DW_LNS_copy
+ DW_LNS_negate_stmt
+ DW_LNE_set_address "foo_label_7"
+ line $foo_src_3
+ DW_LNS_copy
+ DW_LNS_negate_stmt
+ DW_LNE_set_address "foo_label_8"
+ line $foo_src_4
+ DW_LNS_copy
+ DW_LNE_set_address $::foo_end
+ DW_LNE_end_sequence
+ }
+ }
+
+ ranges { } {
+ ranges_label_bar: sequence {
+ range foo_label_2 foo_label_4
+ }
+ ranges_label_baz: sequence {
+ range foo_label_6 foo_label_7
+ }
+ ranges_label_foo: sequence {
+ range foo_label_1 foo_label_4
+ range foo_label_6 foo_label_9
+ }
+ }
+}
+
+if {[prepare_for_testing "failed to prepare" "${::testfile}" \
+ [list $srcfile $asm_file] {nodebug}]} {
+ return -1
+}
+
+if ![runto_main] {
+ return -1
+}
+
+gdb_breakpoint bar
+gdb_continue_to_breakpoint "continue to bar line 1" \
+ ".*bar line 1\[^\r\n\]+"
+
+gdb_test "step" ".*bar line 2\[^\r\n\]+" \
+ "step to bar line 2"
+
+# This is the interesting one. This step will take us over the goto
+# and place the inferior at the start of the second range of 'foo' and
+# at the start of 'baz'.
+#
+# As we started the step in 'bar', GDB should not reenter 'baz'.
+gdb_test "step" ".*foo line 3\[^\r\n\]+" \
+ "step to foo line 3"
+
+# The next step should allow the inferior to enter 'baz'.
+gdb_test "step" ".*baz line 1\[^\r\n\]+" \
+ "step to baz line 1"
+
+# The remaining steps take the inferior through 'baz' and back into
+# 'foo'.
+gdb_test "step" ".*baz line 2\[^\r\n\]+" \
+ "step to baz line 2"
+
+gdb_test "step" ".*foo line 4\[^\r\n\]+" \
+ "step out of bar to foo line 4"
diff --git a/gdb/testsuite/gdb.dwarf2/dw2-step-between-inline-func-blocks.c b/gdb/testsuite/gdb.dwarf2/dw2-step-between-inline-func-blocks.c
new file mode 100644
index 00000000000..7fdf1bb2c86
--- /dev/null
+++ b/gdb/testsuite/gdb.dwarf2/dw2-step-between-inline-func-blocks.c
@@ -0,0 +1,100 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+ Copyright 2024 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/>. */
+
+/* Used to insert labels within function foo. */
+#define LABEL(N) asm ("foo_label_" #N ": .globl foo_label_" #N)
+
+volatile int global_var = 0;
+
+/* The contents of this '#if 0' block exist so the generated debug can
+ point to these as the source lines. */
+#if 0
+
+void
+bar (void) /* bar decl line */
+{
+ /* bar line 1 */
+ /* bar line 2 */
+ /* bar line 3 */
+ /* bar line 4 */
+}
+
+void
+foo (void) /* foo decl line */
+{
+ /* foo line 1 */
+ /* foo line 2 */
+ /* foo line 3 */
+ /* foo line 4 */
+}
+
+#endif
+
+extern void *foo_label_6 (void);
+
+void
+foo (void)
+{
+ /* This label is used to find the start of 'foo' when generating the
+ debug information. */
+ asm ("foo_label: .globl foo_label");
+ ++global_var;
+
+ LABEL (1);
+ ++global_var;
+
+ LABEL (2);
+ ++global_var;
+
+ LABEL (3);
+ ++global_var;
+
+ /* This goto will always trigger, but we make it conditional so that the
+ compiler doesn't optimise out the code between the goto and the
+ destination.
+
+ Also 'goto *ADDR' is a GCC extension, but it is critical that the
+ destination address be a global label so that we can generate DWARF
+ that has ranges that start exactly at the destination address. */
+ if (global_var > 0)
+ goto *(&foo_label_6);
+
+ LABEL (4);
+ ++global_var;
+
+ LABEL (5);
+ ++global_var;
+
+ LABEL (6);
+ ++global_var;
+
+ LABEL (7);
+ ++global_var;
+
+ LABEL (8);
+ ++global_var;
+
+ LABEL (9);
+ ++global_var;
+}
+
+int
+main (void)
+{
+ asm ("main_label: .globl main_label");
+ foo ();
+}
diff --git a/gdb/testsuite/gdb.dwarf2/dw2-step-between-inline-func-blocks.exp b/gdb/testsuite/gdb.dwarf2/dw2-step-between-inline-func-blocks.exp
new file mode 100644
index 00000000000..9128f87c93d
--- /dev/null
+++ b/gdb/testsuite/gdb.dwarf2/dw2-step-between-inline-func-blocks.exp
@@ -0,0 +1,196 @@
+# Copyright 2024 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/>.
+
+# This test creates a function 'foo' that contains an inline function
+# 'bar'. Both 'foo' and 'bar' are split into two regions. The layout
+# in memory looks something like this:
+#
+# <part-a> <gap> <part-b>
+#
+# bar: |------------| |---|
+# foo: |------------------| |--------|
+#
+# We see things like this in "real" code where the parts after the gap
+# (part-b) are cold paths within the function that have been moved
+# aside.
+#
+# However, in this test program we use 'goto' to jump directly from
+# the first part of the function (part-a) to the second part (part-b).
+#
+# At the time we hit the goto we are inside 'bar'. After the goto we
+# expect to still be in bar. At one point GDB would get this wrong
+# and after the jump we would revert back to 'foo'.
+#
+# This bug will only trigger if both 'foo' and 'bar' are split, and
+# both 'foo' and 'bar' must start at the same address for part-b.
+
+load_lib dwarf.exp
+
+require dwarf2_support
+
+# The source program use 'goto *ADDR' which is a GCC extension.
+require is_c_compiler_gcc
+
+standard_testfile
+
+# This compiles the source file and starts and stops GDB, so run it
+# before calling prepare_for_testing otherwise GDB will have exited.
+get_func_info foo
+
+# Make some DWARF for the test.
+set asm_file [standard_output_file "$::testfile-dw.S"]
+Dwarf::assemble $asm_file {
+ global srcfile
+
+ # Create local varibles BAR_SRC_* containing the line number for
+ # the four souce lines of 'foo' and 'bar'. These will be
+ # referenced in the generated DWARF.
+ for { set i 1 } { $i <= 4 } { incr i } {
+ set bar_src_$i [gdb_get_line_number "bar line $i"]
+ set foo_src_$i [gdb_get_line_number "foo line $i"]
+ }
+
+ # More line numbers needed for the generated DWARF.
+ set foo_decl_line [gdb_get_line_number "foo decl line"]
+ set bar_decl_line [gdb_get_line_number "bar decl line"]
+
+ # Labels used to link parts of the DWARF together.
+ declare_labels lines_table bar_label ranges_label_bar ranges_label_foo
+
+ cu { version 4 } {
+ compile_unit {
+ {producer "gcc"}
+ {language @DW_LANG_C}
+ {name ${srcfile}}
+ {comp_dir /tmp}
+ {stmt_list $lines_table DW_FORM_sec_offset}
+ {low_pc 0 addr}
+ } {
+ bar_label: subprogram {
+ {external 1 flag}
+ {name bar}
+ {decl_file 1 data1}
+ {decl_line $bar_decl_line data1}
+ {decl_column 1 data1}
+ {inline 3 data1}
+ }
+ subprogram {
+ {name foo}
+ {decl_file 1 data1}
+ {decl_line $foo_decl_line data1}
+ {decl_column 1 data1}
+ {ranges ${ranges_label_foo} DW_FORM_sec_offset}
+ {external 1 flag}
+ } {
+ inlined_subroutine {
+ {abstract_origin %$bar_label}
+ {call_file 1 data1}
+ {call_line $foo_src_3 data1}
+ {ranges ${ranges_label_bar} DW_FORM_sec_offset}
+ }
+ }
+ }
+ }
+
+ lines {version 2} lines_table {
+ include_dir "$::srcdir/$::subdir"
+ file_name "$srcfile" 1
+ program {
+ DW_LNE_set_address "foo_label"
+ line $foo_src_1
+ DW_LNS_copy
+ DW_LNE_set_address "foo_label_1"
+ line $foo_src_2
+ DW_LNS_copy
+ DW_LNE_set_address "foo_label_2"
+ line $foo_src_3
+ DW_LNS_copy
+ DW_LNE_set_address "foo_label_2"
+ line $bar_src_1
+ DW_LNS_copy
+ DW_LNE_set_address "foo_label_3"
+ line $bar_src_2
+ DW_LNS_copy
+
+ DW_LNE_set_address "foo_label_4"
+ DW_LNE_end_sequence
+
+ DW_LNE_set_address "foo_label_6"
+ line $bar_src_3
+ DW_LNS_copy
+ DW_LNE_set_address "foo_label_7"
+ line $bar_src_4
+ DW_LNS_copy
+
+ DW_LNS_negate_stmt
+ DW_LNE_set_address "foo_label_7"
+ line $foo_src_3
+ DW_LNS_copy
+
+ DW_LNS_negate_stmt
+ DW_LNE_set_address "foo_label_8"
+ line $foo_src_4
+ DW_LNS_copy
+
+ DW_LNE_set_address $::foo_end
+ DW_LNE_end_sequence
+ }
+ }
+
+ ranges { } {
+ ranges_label_bar: sequence {
+ range foo_label_2 foo_label_4
+ range foo_label_6 foo_label_8
+ }
+ ranges_label_foo: sequence {
+ range foo_label_1 foo_label_4
+ range foo_label_6 foo_label_9
+ }
+ }
+}
+
+if {[prepare_for_testing "failed to prepare" "${::testfile}" \
+ [list $srcfile $asm_file] {nodebug}]} {
+ return -1
+}
+
+if ![runto_main] {
+ return -1
+}
+
+gdb_breakpoint bar
+gdb_continue_to_breakpoint "continue to bar line 1" \
+ ".*bar line 1\[^\r\n\]+"
+
+gdb_test "step" ".*bar line 2\[^\r\n\]+" \
+ "step to bar line 2"
+
+# This is the interesting one. This step will take us over the goto
+# and into the second range of both 'foo' and 'bar'. As we started
+# the step in 'bar' GDB should reselect 'bar' after the step.
+#
+# If this goes wrong the GDB will claim we are at foo_line_3, which is
+# the DW_AT_call_line for 'bar'.
+gdb_test "step" ".*bar line 3\[^\r\n\]+" \
+ "step to bar line 3"
+
+# These following steps should be straight forward, but lets just
+# check we can step out of 'bar' and back to 'foo', there shouldn't be
+# anything tricky going on here though.
+gdb_test "step" ".*bar line 4\[^\r\n\]+" \
+ "step to bar line 4"
+
+gdb_test "step" ".*foo line 4\[^\r\n\]+" \
+ "step out of bar to foo line 4"
base-commit: efa903e0bc1db2fc13386f7fe150d9ff88ebe156
--
2.25.4
^ permalink raw reply [flat|nested] 2+ messages in thread
* Re: [PATCH] gdb: stepping between inline functions with multiple ranges
2024-10-18 10:45 [PATCH] gdb: stepping between inline functions with multiple ranges Andrew Burgess
@ 2024-11-13 14:22 ` Andrew Burgess
0 siblings, 0 replies; 2+ messages in thread
From: Andrew Burgess @ 2024-11-13 14:22 UTC (permalink / raw)
To: gdb-patches; +Cc: Bernd Edlinger
Andrew Burgess <aburgess@redhat.com> writes:
> From: Bernd Edlinger <bernd.edlinger@hotmail.de>
>
> I (Andrew) have split this small change from a larger patch which was
> posted here:
>
> https://inbox.sourceware.org/gdb-patches/AS1PR01MB9465608EBD5D62642C51C428E4922@AS1PR01MB9465.eurprd01.prod.exchangelabs.com
>
> And I have written the stand alone test for this issue. The original
> patch included this paragraph to explain this change (I've fixed one
> typo in this text replacing 'program' with 'function'):
>
> ... it may happen that the infrun machinery steps from one inline
> range to another inline range of the same inline function. That can
> look like jumping back and forth from the calling function to the
> inline function, while really the inline function just jumps from a
> hot to a cold section of the code, i.e. error handling.
>
> The important thing that happens here is that both the outer function
> and the inline function must both have multiple ranges. When the
> inferior is within the inline function and moves from one range to
> another it is critical that the address we stop at is the start of a
> range in both the outer function and the inline function.
>
> The diagram below represents how the functions are split and aligned:
>
> (A) (B)
> bar: |------------| |---|
> foo: |------------------| |--------|
>
> The inferior is stepping through 'bar' and eventually reaches
> point (A) at which point control passes to point (B).
>
> Currently, when the inferior stops, GDB notices that both 'foo' and
> 'bar' start at address (B), and so GDB uses the inline frame mechanism
> to skip 'bar' and tells the user that the inferior is in 'foo'.
>
> However, as we were in 'bar' before the step then it makes sense that
> we should be in 'bar' after the step, and this is what the patch does.
>
> There are two tests using the DWARF assembler, the first checks the
> above situation and ensures that GDB reports 'bar' after the step.
>
> The second test is similar, but after the step we enter a new range
> where a different inline function starts, something like this:
>
> (A) (B)
> bar: |------------|
> baz: |---|
> foo: |------------------| |--------|
>
> In this case as we step at (A) and land at (B) we leave 'bar' and
> expect to stop in 'foo', GDB shouldn't automatically enter 'baz' as
> that is a completely different inline function. And this is, indeed,
> what we see.
>
> Co-Authored-By: Andrew Burgess <aburgess@redhat.com>
I've checked this in.
Thanks,
Andrew
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2024-11-13 14:22 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2024-10-18 10:45 [PATCH] gdb: stepping between inline functions with multiple ranges Andrew Burgess
2024-11-13 14:22 ` Andrew Burgess
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).