From bf4cb9bee210298c813f87aae005432d2e934449 Mon Sep 17 00:00:00 2001 From: Tom de Vries Date: Fri, 8 May 2020 17:26:32 +0200 Subject: [PATCH] [gdb] Fix stepping over fork with follow-fork-mode child and gcc-8 When running test-case gdb.threads/fork-child-threads.exp with gcc-8 instead of gcc-7, we have: ... (gdb) next^M [Attaching after Thread 0x7ffff7fae740 (LWP 27574) fork to child process \ 27578]^M [New inferior 2 (process 27578)]^M [Detaching after fork from parent process 27574]^M [Inferior 1 (process 27574) detached]^M [Thread debugging using libthread_db enabled]^M Using host libthread_db library "/lib64/libthread_db.so.1".^M [Switching to Thread 0x7ffff7fae740 (LWP 27578)]^M -main () at src/gdb/testsuite/gdb.threads/fork-child-threads.c:41^M +main () at src/gdb/testsuite/gdb.threads/fork-child-threads.c:34^M -41 i = pthread_create (&thread, NULL, start, NULL);^M +34 switch (fork ())^M -(gdb) PASS: gdb.threads/fork-child-threads.exp: next over fork +(gdb) FAIL: gdb.threads/fork-child-threads.exp: next over fork ... This is due to the fact that gcc-8 generates more precise line info, making the instruction after the call to fork a "recommended breakpoint location". However, it is a bug because next is supposed to move to the next source line. The problem is that in process_event_stop_test we hit this code: ... if ((ecs->event_thread->suspend.stop_pc == stop_pc_sal.pc) && (ecs->event_thread->current_line != stop_pc_sal.line || ecs->event_thread->current_symtab != stop_pc_sal.symtab)) { if (stop_pc_sal.is_stmt) { /* We are at the start of a different line. So stop. Note that we don't stop if we step into the middle of a different line. That is said to make things like for (;;) statements work better. */ if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: stepped to a different line\n"); end_stepping_range (ecs); return; } ... because current_line and current_symtab have initial values: ... (gdb) p ecs->event_thread->current_line $8 = 0 (gdb) p ecs->event_thread->current_symtab $9 = (symtab *) 0x0 ... Fix this in follow_fork by copying current_line and current_symtab from parent thread to child thread. Tested on x86_64-linux, with gcc 7.5.0 and gcc 10.0.1. gdb/ChangeLog: 2020-05-08 Tom de Vries * infrun.c (follow_fork): Copy current_line and current_symtab to child thread. --- gdb/ChangeLog | 5 +++++ gdb/infrun.c | 6 ++++++ 2 files changed, 11 insertions(+) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index d287d3aa5e..5edf06faa5 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,8 @@ +2020-05-08 Tom de Vries + + * infrun.c (follow_fork): Copy current_line and current_symtab to + child thread. + 2020-05-07 Simon Marchi * async-event.c (struct async_signal_handler, struct diff --git a/gdb/infrun.c b/gdb/infrun.c index 0e1ba6986b..3c6b201a9f 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -681,6 +681,8 @@ follow_fork () struct breakpoint *exception_resume_breakpoint = NULL; CORE_ADDR step_range_start = 0; CORE_ADDR step_range_end = 0; + int current_line = 0; + symtab *current_symtab = NULL; struct frame_id step_frame_id = { 0 }; struct thread_fsm *thread_fsm = NULL; @@ -734,6 +736,8 @@ follow_fork () (tp->control.step_resume_breakpoint); step_range_start = tp->control.step_range_start; step_range_end = tp->control.step_range_end; + current_line = tp->current_line; + current_symtab = tp->current_symtab; step_frame_id = tp->control.step_frame_id; exception_resume_breakpoint = clone_momentary_breakpoint (tp->control.exception_resume_breakpoint); @@ -794,6 +798,8 @@ follow_fork () = step_resume_breakpoint; tp->control.step_range_start = step_range_start; tp->control.step_range_end = step_range_end; + tp->current_line = current_line; + tp->current_symtab = current_symtab; tp->control.step_frame_id = step_frame_id; tp->control.exception_resume_breakpoint = exception_resume_breakpoint; -- 2.34.1