From 29734269a7d1f2909814ff9c518c295c9640d6f5 Mon Sep 17 00:00:00 2001 From: Simon Marchi Date: Fri, 6 Mar 2020 18:04:52 -0500 Subject: Pass thread_info pointer to various inferior control functions [ Migrating this from Gerrit: https://gnutoolchain-gerrit.osci.io/r/c/binutils-gdb/+/321 ] I noticed that some functions in infcmd and infrun call each other and all call inferior_thread, while they could just get the thread_info pointer from their caller. That means less calls to inferior_thread, so less reliance on global state, since inferior_thread reads inferior_ptid. The paths I am unsure about are: - fetch_inferior_event calls... - step_command_fsm::should_stop calls... - prepare_one_step and - process_event_stop_test calls... - set_step_info Before this patch, prepare_one_step gets the thread pointer using inferior_thread. After this patch, it gets it from the execution_control_state structure in fetch_inferior_event. Are we sure that the thread from the execution_control_state structure is the same as the one inferior_thread would return? This code path is used when a thread completes a step, but the user had specified a step count (e.g. "step 5") so we decide to do one more step. It would be strange (and even a bug I suppose) if the thread in the ecs structure in fetch_inferior_event was not the same thread that is prepared to stepped by prepare_one_step. So I believe passing the ecs thread is fine. The same logic applies to process_event_stop_test calling set_step_info. gdb/ChangeLog: * infrun.h: Forward-declare thread_info. (set_step_info): Add thread_info parameter, add doc. * infrun.c (set_step_info): Add thread_info parameter, move doc to header. * infrun.c (process_event_stop_test): Pass thread to set_step_info call. * infcmd.c (set_step_frame): Add thread_info pointer, pass it to set_step_info. (prepare_one_step): Add thread_info parameter, pass it to set_step_frame and prepare_one_step (recursive) call. (step_1): Pass thread to prepare_one_step call. (step_command_fsm::should_stop): Pass thread to prepare_one_step. (until_next_fsm): Pass thread to set_step_frame call. (finish_command): Pass thread to set_step_info call. --- gdb/ChangeLog | 18 ++++++++++++++++++ gdb/infcmd.c | 37 +++++++++++++++++++------------------ gdb/infrun.c | 12 ++++++++---- gdb/infrun.h | 5 ++++- 4 files changed, 49 insertions(+), 23 deletions(-) diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 9c2e68d..0de3794 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,21 @@ +2020-03-06 Simon Marchi + + * infrun.h: Forward-declare thread_info. + (set_step_info): Add thread_info parameter, add doc. + * infrun.c (set_step_info): Add thread_info parameter, move doc + to header. + * infrun.c (process_event_stop_test): Pass thread to + set_step_info call. + * infcmd.c (set_step_frame): Add thread_info pointer, pass it to + set_step_info. + (prepare_one_step): Add thread_info parameter, pass it to + set_step_frame and prepare_one_step (recursive) call. + (step_1): Pass thread to prepare_one_step call. + (step_command_fsm::should_stop): Pass thread to + prepare_one_step. + (until_next_fsm): Pass thread to set_step_frame call. + (finish_command): Pass thread to set_step_info call. + 2020-03-06 Hannes Domani * windows-tdep.c (windows_solib_create_inferior_hook): diff --git a/gdb/infcmd.c b/gdb/infcmd.c index 62890bd..b4b128b 100644 --- a/gdb/infcmd.c +++ b/gdb/infcmd.c @@ -914,18 +914,21 @@ continue_command (const char *args, int from_tty) continue_1 (all_threads_p); } -/* Record the starting point of a "step" or "next" command. */ +/* Record in TP the starting point of a "step" or "next" command. */ static void -set_step_frame (void) +set_step_frame (thread_info *tp) { + /* This can be removed once this function no longer implicitly relies on the + inferior_ptid value. */ + gdb_assert (inferior_ptid == tp->ptid); + frame_info *frame = get_current_frame (); symtab_and_line sal = find_frame_sal (frame); - set_step_info (frame, sal); + set_step_info (tp, frame, sal); CORE_ADDR pc = get_frame_pc (frame); - thread_info *tp = inferior_thread (); tp->control.step_start_function = find_pc_function (pc); } @@ -1002,7 +1005,7 @@ step_command_fsm_prepare (struct step_command_fsm *sm, thread->control.stepping_command = 1; } -static int prepare_one_step (struct step_command_fsm *sm); +static int prepare_one_step (thread_info *, struct step_command_fsm *sm); static void step_1 (int skip_subroutines, int single_inst, const char *count_string) @@ -1040,7 +1043,7 @@ step_1 (int skip_subroutines, int single_inst, const char *count_string) loop. Let the continuation figure out how many other steps we need to do, and handle them one at the time, through step_once. */ - if (!prepare_one_step (step_sm)) + if (!prepare_one_step (thr, step_sm)) proceed ((CORE_ADDR) -1, GDB_SIGNAL_DEFAULT); else { @@ -1070,7 +1073,7 @@ step_command_fsm::should_stop (struct thread_info *tp) /* There are more steps to make, and we did stop due to ending a stepping range. Do another step. */ if (--count > 0) - return prepare_one_step (this); + return prepare_one_step (tp, this); set_finished (); } @@ -1102,19 +1105,17 @@ step_command_fsm::do_async_reply_reason () resumed. */ static int -prepare_one_step (struct step_command_fsm *sm) +prepare_one_step (thread_info *tp, struct step_command_fsm *sm) { + /* This can be removed once this function no longer implicitly relies on the + inferior_ptid value. */ + gdb_assert (inferior_ptid == tp->ptid); + if (sm->count > 0) { struct frame_info *frame = get_current_frame (); - /* Don't assume THREAD is a valid thread id. It is set to -1 if - the longjmp breakpoint was not required. Use the - INFERIOR_PTID thread instead, which is the same thread when - THREAD is set. */ - struct thread_info *tp = inferior_thread (); - - set_step_frame (); + set_step_frame (tp); if (!sm->single_inst) { @@ -1146,7 +1147,7 @@ prepare_one_step (struct step_command_fsm *sm) || !function_name_is_marked_for_skip (fn, sal)) { sm->count--; - return prepare_one_step (sm); + return prepare_one_step (tp, sm); } } @@ -1488,7 +1489,7 @@ until_next_command (int from_tty) struct until_next_fsm *sm; clear_proceed_status (0); - set_step_frame (); + set_step_frame (tp); frame = get_current_frame (); @@ -1945,7 +1946,7 @@ finish_command (const char *arg, int from_tty) called by that frame. We don't use the magic "1" value for step_range_end, because then infrun will think this is nexti, and not step over the rest of this inlined function call. */ - set_step_info (frame, {}); + set_step_info (tp, frame, {}); tp->control.step_range_start = get_frame_pc (frame); tp->control.step_range_end = tp->control.step_range_start; tp->control.step_over_calls = STEP_OVER_ALL; diff --git a/gdb/infrun.c b/gdb/infrun.c index b8c1bbc..2a31929 100644 --- a/gdb/infrun.c +++ b/gdb/infrun.c @@ -4102,11 +4102,15 @@ fetch_inferior_event (void *client_data) printf_unfiltered (_("completed.\n")); } -/* Record the frame and location we're currently stepping through. */ +/* See infrun.h. */ + void -set_step_info (struct frame_info *frame, struct symtab_and_line sal) +set_step_info (thread_info *tp, struct frame_info *frame, + struct symtab_and_line sal) { - struct thread_info *tp = inferior_thread (); + /* This can be removed once this function no longer implicitly relies on the + inferior_ptid value. */ + gdb_assert (inferior_ptid == tp->ptid); tp->control.step_frame_id = get_frame_id (frame); tp->control.step_stack_frame_id = get_stack_frame_id (frame); @@ -7200,7 +7204,7 @@ process_event_stop_test (struct execution_control_state *ecs) ecs->event_thread->control.step_range_start = stop_pc_sal.pc; ecs->event_thread->control.step_range_end = stop_pc_sal.end; ecs->event_thread->control.may_range_step = 1; - set_step_info (frame, stop_pc_sal); + set_step_info (ecs->event_thread, frame, stop_pc_sal); if (debug_infrun) fprintf_unfiltered (gdb_stdlog, "infrun: keep going\n"); diff --git a/gdb/infrun.h b/gdb/infrun.h index 625c53a..9808541 100644 --- a/gdb/infrun.h +++ b/gdb/infrun.h @@ -26,6 +26,7 @@ struct frame_info; struct address_space; struct return_value_info; struct process_stratum_target; +struct thread_info; /* True if we are debugging run control. */ extern unsigned int debug_infrun; @@ -150,7 +151,9 @@ extern int thread_is_stepping_over_breakpoint (int thread); triggers a non-steppable watchpoint. */ extern int stepping_past_nonsteppable_watchpoint (void); -extern void set_step_info (struct frame_info *frame, +/* Record in TP the frame and location we're currently stepping through. */ +extern void set_step_info (thread_info *tp, + struct frame_info *frame, struct symtab_and_line sal); /* Several print_*_reason helper functions to print why the inferior -- cgit v1.1