[PATCH 3/3] gdb: pass more const target_waitstatus by reference
Andrew Burgess
aburgess@redhat.com
Mon Nov 22 18:56:36 GMT 2021
* Simon Marchi via Gdb-patches <gdb-patches@sourceware.org> [2021-11-22 11:27:31 -0500]:
> While working on target_waitstatus changes, I noticed a few places where
> const target_waitstatus objects could be passed by reference instead of
> by pointers. And in some cases, places where a target_waitstatus could
> be passed as const, but was not. Convert them as much as possible.
LGTM.
Thanks,
Andrew
>
> Change-Id: Ied552d464be5d5b87489913b95f9720a5ad50c5a
> ---
> gdb/break-catch-sig.c | 6 ++--
> gdb/break-catch-syscall.c | 8 ++---
> gdb/breakpoint.c | 52 ++++++++++++++++----------------
> gdb/breakpoint.h | 10 +++----
> gdb/infrun.c | 62 +++++++++++++++++++--------------------
> gdb/infrun.h | 2 +-
> gdb/remote.c | 36 +++++++++++------------
> gdbserver/remote-utils.cc | 45 ++++++++++++++--------------
> gdbserver/remote-utils.h | 2 +-
> gdbserver/server.cc | 26 ++++++++--------
> 10 files changed, 124 insertions(+), 125 deletions(-)
>
> diff --git a/gdb/break-catch-sig.c b/gdb/break-catch-sig.c
> index 0998aa95c4f..7fe35dcdb0c 100644
> --- a/gdb/break-catch-sig.c
> +++ b/gdb/break-catch-sig.c
> @@ -149,16 +149,16 @@ static int
> signal_catchpoint_breakpoint_hit (const struct bp_location *bl,
> const address_space *aspace,
> CORE_ADDR bp_addr,
> - const struct target_waitstatus *ws)
> + const target_waitstatus &ws)
> {
> const struct signal_catchpoint *c
> = (const struct signal_catchpoint *) bl->owner;
> gdb_signal signal_number;
>
> - if (ws->kind () != TARGET_WAITKIND_STOPPED)
> + if (ws.kind () != TARGET_WAITKIND_STOPPED)
> return 0;
>
> - signal_number = ws->sig ();
> + signal_number = ws.sig ();
>
> /* If we are catching specific signals in this breakpoint, then we
> must guarantee that the called signal is the same signal we are
> diff --git a/gdb/break-catch-syscall.c b/gdb/break-catch-syscall.c
> index cb2d77643ca..02123736ff4 100644
> --- a/gdb/break-catch-syscall.c
> +++ b/gdb/break-catch-syscall.c
> @@ -143,7 +143,7 @@ remove_catch_syscall (struct bp_location *bl, enum remove_bp_reason reason)
> static int
> breakpoint_hit_catch_syscall (const struct bp_location *bl,
> const address_space *aspace, CORE_ADDR bp_addr,
> - const struct target_waitstatus *ws)
> + const target_waitstatus &ws)
> {
> /* We must check if we are catching specific syscalls in this
> breakpoint. If we are, then we must guarantee that the called
> @@ -152,11 +152,11 @@ breakpoint_hit_catch_syscall (const struct bp_location *bl,
> const struct syscall_catchpoint *c
> = (const struct syscall_catchpoint *) bl->owner;
>
> - if (ws->kind () != TARGET_WAITKIND_SYSCALL_ENTRY
> - && ws->kind () != TARGET_WAITKIND_SYSCALL_RETURN)
> + if (ws.kind () != TARGET_WAITKIND_SYSCALL_ENTRY
> + && ws.kind () != TARGET_WAITKIND_SYSCALL_RETURN)
> return 0;
>
> - syscall_number = ws->syscall_number ();
> + syscall_number = ws.syscall_number ();
>
> /* Now, checking if the syscall is the same. */
> if (!c->syscalls_to_be_caught.empty ())
> diff --git a/gdb/breakpoint.c b/gdb/breakpoint.c
> index d98c3a7cf0f..b1eae3af634 100644
> --- a/gdb/breakpoint.c
> +++ b/gdb/breakpoint.c
> @@ -4771,7 +4771,7 @@ bpstat::bpstat ()
> watchpoints have triggered, according to the target. */
>
> int
> -watchpoints_triggered (struct target_waitstatus *ws)
> +watchpoints_triggered (const target_waitstatus &ws)
> {
> bool stopped_by_watchpoint = target_stopped_by_watchpoint ();
> CORE_ADDR addr;
> @@ -5014,7 +5014,7 @@ watchpoint_check (bpstat *bs)
> static int
> bpstat_check_location (const struct bp_location *bl,
> const address_space *aspace, CORE_ADDR bp_addr,
> - const struct target_waitstatus *ws)
> + const target_waitstatus &ws)
> {
> struct breakpoint *b = bl->owner;
>
> @@ -5349,7 +5349,7 @@ need_moribund_for_location_type (struct bp_location *loc)
>
> bpstat *
> build_bpstat_chain (const address_space *aspace, CORE_ADDR bp_addr,
> - const struct target_waitstatus *ws)
> + const target_waitstatus &ws)
> {
> bpstat *bs_head = nullptr, **bs_link = &bs_head;
>
> @@ -5425,7 +5425,7 @@ build_bpstat_chain (const address_space *aspace, CORE_ADDR bp_addr,
> bpstat *
> bpstat_stop_status (const address_space *aspace,
> CORE_ADDR bp_addr, thread_info *thread,
> - const struct target_waitstatus *ws,
> + const target_waitstatus &ws,
> bpstat *stop_chain)
> {
> struct breakpoint *b = NULL;
> @@ -7760,14 +7760,14 @@ remove_catch_fork (struct bp_location *bl, enum remove_bp_reason reason)
> static int
> breakpoint_hit_catch_fork (const struct bp_location *bl,
> const address_space *aspace, CORE_ADDR bp_addr,
> - const struct target_waitstatus *ws)
> + const target_waitstatus &ws)
> {
> struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
>
> - if (ws->kind () != TARGET_WAITKIND_FORKED)
> + if (ws.kind () != TARGET_WAITKIND_FORKED)
> return 0;
>
> - c->forked_inferior_pid = ws->child_ptid ();
> + c->forked_inferior_pid = ws.child_ptid ();
> return 1;
> }
>
> @@ -7876,14 +7876,14 @@ remove_catch_vfork (struct bp_location *bl, enum remove_bp_reason reason)
> static int
> breakpoint_hit_catch_vfork (const struct bp_location *bl,
> const address_space *aspace, CORE_ADDR bp_addr,
> - const struct target_waitstatus *ws)
> + const target_waitstatus &ws)
> {
> struct fork_catchpoint *c = (struct fork_catchpoint *) bl->owner;
>
> - if (ws->kind () != TARGET_WAITKIND_VFORKED)
> + if (ws.kind () != TARGET_WAITKIND_VFORKED)
> return 0;
>
> - c->forked_inferior_pid = ws->child_ptid ();
> + c->forked_inferior_pid = ws.child_ptid ();
> return 1;
> }
>
> @@ -7998,11 +7998,11 @@ static int
> breakpoint_hit_catch_solib (const struct bp_location *bl,
> const address_space *aspace,
> CORE_ADDR bp_addr,
> - const struct target_waitstatus *ws)
> + const target_waitstatus &ws)
> {
> struct solib_catchpoint *self = (struct solib_catchpoint *) bl->owner;
>
> - if (ws->kind () == TARGET_WAITKIND_LOADED)
> + if (ws.kind () == TARGET_WAITKIND_LOADED)
> return 1;
>
> for (breakpoint *other : all_breakpoints ())
> @@ -8274,14 +8274,14 @@ remove_catch_exec (struct bp_location *bl, enum remove_bp_reason reason)
> static int
> breakpoint_hit_catch_exec (const struct bp_location *bl,
> const address_space *aspace, CORE_ADDR bp_addr,
> - const struct target_waitstatus *ws)
> + const target_waitstatus &ws)
> {
> struct exec_catchpoint *c = (struct exec_catchpoint *) bl->owner;
>
> - if (ws->kind () != TARGET_WAITKIND_EXECD)
> + if (ws.kind () != TARGET_WAITKIND_EXECD)
> return 0;
>
> - c->exec_pathname = make_unique_xstrdup (ws->execd_pathname ());
> + c->exec_pathname = make_unique_xstrdup (ws.execd_pathname ());
> return 1;
> }
>
> @@ -9781,10 +9781,10 @@ static int
> breakpoint_hit_ranged_breakpoint (const struct bp_location *bl,
> const address_space *aspace,
> CORE_ADDR bp_addr,
> - const struct target_waitstatus *ws)
> + const target_waitstatus &ws)
> {
> - if (ws->kind () != TARGET_WAITKIND_STOPPED
> - || ws->sig () != GDB_SIGNAL_TRAP)
> + if (ws.kind () != TARGET_WAITKIND_STOPPED
> + || ws.sig () != GDB_SIGNAL_TRAP)
> return 0;
>
> return breakpoint_address_match_range (bl->pspace->aspace, bl->address,
> @@ -10125,7 +10125,7 @@ remove_watchpoint (struct bp_location *bl, enum remove_bp_reason reason)
> static int
> breakpoint_hit_watchpoint (const struct bp_location *bl,
> const address_space *aspace, CORE_ADDR bp_addr,
> - const struct target_waitstatus *ws)
> + const target_waitstatus &ws)
> {
> struct breakpoint *b = bl->owner;
> struct watchpoint *w = (struct watchpoint *) b;
> @@ -12280,7 +12280,7 @@ static int
> base_breakpoint_breakpoint_hit (const struct bp_location *bl,
> const address_space *aspace,
> CORE_ADDR bp_addr,
> - const struct target_waitstatus *ws)
> + const target_waitstatus &ws)
> {
> internal_error_pure_virtual_called ();
> }
> @@ -12447,10 +12447,10 @@ bkpt_remove_location (struct bp_location *bl, enum remove_bp_reason reason)
> static int
> bkpt_breakpoint_hit (const struct bp_location *bl,
> const address_space *aspace, CORE_ADDR bp_addr,
> - const struct target_waitstatus *ws)
> + const target_waitstatus &ws)
> {
> - if (ws->kind () != TARGET_WAITKIND_STOPPED
> - || ws->sig () != GDB_SIGNAL_TRAP)
> + if (ws.kind () != TARGET_WAITKIND_STOPPED
> + || ws.sig () != GDB_SIGNAL_TRAP)
> return 0;
>
> if (!breakpoint_address_match (bl->pspace->aspace, bl->address,
> @@ -12468,7 +12468,7 @@ bkpt_breakpoint_hit (const struct bp_location *bl,
> static int
> dprintf_breakpoint_hit (const struct bp_location *bl,
> const address_space *aspace, CORE_ADDR bp_addr,
> - const struct target_waitstatus *ws)
> + const target_waitstatus &ws)
> {
> if (dprintf_style == dprintf_style_agent
> && target_can_run_breakpoint_commands ())
> @@ -12822,7 +12822,7 @@ tracepoint_re_set (struct breakpoint *b)
> static int
> tracepoint_breakpoint_hit (const struct bp_location *bl,
> const address_space *aspace, CORE_ADDR bp_addr,
> - const struct target_waitstatus *ws)
> + const target_waitstatus &ws)
> {
> /* By definition, the inferior does not report stops at
> tracepoints. */
> @@ -15194,7 +15194,7 @@ is_non_inline_function (struct breakpoint *b)
>
> int
> pc_at_non_inline_function (const address_space *aspace, CORE_ADDR pc,
> - const struct target_waitstatus *ws)
> + const target_waitstatus &ws)
> {
> for (breakpoint *b : all_breakpoints ())
> {
> diff --git a/gdb/breakpoint.h b/gdb/breakpoint.h
> index c9048d33816..1704d6a3fd7 100644
> --- a/gdb/breakpoint.h
> +++ b/gdb/breakpoint.h
> @@ -587,7 +587,7 @@ struct breakpoint_ops
> int (*breakpoint_hit) (const struct bp_location *bl,
> const address_space *aspace,
> CORE_ADDR bp_addr,
> - const struct target_waitstatus *ws);
> + const target_waitstatus &ws);
>
> /* Check internal conditions of the breakpoint referred to by BS.
> If we should not stop for this breakpoint, set BS->stop to 0. */
> @@ -948,7 +948,7 @@ extern bpstat *bpstat_copy (bpstat *);
>
> extern bpstat *build_bpstat_chain (const address_space *aspace,
> CORE_ADDR bp_addr,
> - const struct target_waitstatus *ws);
> + const target_waitstatus &ws);
>
> /* Get a bpstat associated with having just stopped at address
> BP_ADDR in thread PTID. STOP_CHAIN may be supplied as a previously
> @@ -972,7 +972,7 @@ extern bpstat *build_bpstat_chain (const address_space *aspace,
>
> extern bpstat *bpstat_stop_status (const address_space *aspace,
> CORE_ADDR pc, thread_info *thread,
> - const struct target_waitstatus *ws,
> + const target_waitstatus &ws,
> bpstat *stop_chain = nullptr);
>
> /* This bpstat_what stuff tells wait_for_inferior what to do with a
> @@ -1609,7 +1609,7 @@ extern int insert_single_step_breakpoints (struct gdbarch *);
>
> /* Check if any hardware watchpoints have triggered, according to the
> target. */
> -int watchpoints_triggered (struct target_waitstatus *);
> +int watchpoints_triggered (const target_waitstatus &);
>
> /* Helper for transparent breakpoint hiding for memory read and write
> routines.
> @@ -1745,7 +1745,7 @@ const std::vector<bp_location *> &all_bp_locations ();
>
> extern int pc_at_non_inline_function (const address_space *aspace,
> CORE_ADDR pc,
> - const struct target_waitstatus *ws);
> + const target_waitstatus &ws);
>
> extern int user_breakpoint_p (struct breakpoint *);
>
> diff --git a/gdb/infrun.c b/gdb/infrun.c
> index dba4f33a327..e4739ed14f6 100644
> --- a/gdb/infrun.c
> +++ b/gdb/infrun.c
> @@ -3470,7 +3470,7 @@ delete_just_stopped_threads_single_step_breakpoints (void)
>
> void
> print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
> - const struct target_waitstatus *ws)
> + const struct target_waitstatus &ws)
> {
> infrun_debug_printf ("target_wait (%s [%s], status) =",
> waiton_ptid.to_string ().c_str (),
> @@ -3478,7 +3478,7 @@ print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
> infrun_debug_printf (" %s [%s],",
> result_ptid.to_string ().c_str (),
> target_pid_to_str (result_ptid).c_str ());
> - infrun_debug_printf (" %s", ws->to_string ().c_str ());
> + infrun_debug_printf (" %s", ws.to_string ().c_str ());
> }
>
> /* Select a thread at random, out of those which are resumed and have
> @@ -3833,7 +3833,7 @@ prepare_for_detach (void)
> event.ptid = do_target_wait_1 (inf, pid_ptid, &event.ws, 0);
>
> if (debug_infrun)
> - print_target_wait_results (pid_ptid, event.ptid, &event.ws);
> + print_target_wait_results (pid_ptid, event.ptid, event.ws);
>
> handle_one (event);
> }
> @@ -3880,7 +3880,7 @@ wait_for_inferior (inferior *inf)
> ecs->target = inf->process_target ();
>
> if (debug_infrun)
> - print_target_wait_results (minus_one_ptid, ecs->ptid, &ecs->ws);
> + print_target_wait_results (minus_one_ptid, ecs->ptid, ecs->ws);
>
> /* Now figure out what to do with the result of the result. */
> handle_inferior_event (ecs);
> @@ -4070,7 +4070,7 @@ fetch_inferior_event ()
> switch_to_target_no_thread (ecs->target);
>
> if (debug_infrun)
> - print_target_wait_results (minus_one_ptid, ecs->ptid, &ecs->ws);
> + print_target_wait_results (minus_one_ptid, ecs->ptid, ecs->ws);
>
> /* If an error happens while handling the event, propagate GDB's
> knowledge of the executing state to the frontend/user running
> @@ -4257,7 +4257,7 @@ context_switch (execution_control_state *ecs)
>
> static void
> adjust_pc_after_break (struct thread_info *thread,
> - const target_waitstatus *ws)
> + const target_waitstatus &ws)
> {
> struct regcache *regcache;
> struct gdbarch *gdbarch;
> @@ -4284,10 +4284,10 @@ adjust_pc_after_break (struct thread_info *thread,
> target with both of these set in GDB history, and it seems unlikely to be
> correct, so gdbarch_have_nonsteppable_watchpoint is not checked here. */
>
> - if (ws->kind () != TARGET_WAITKIND_STOPPED)
> + if (ws.kind () != TARGET_WAITKIND_STOPPED)
> return;
>
> - if (ws->sig () != GDB_SIGNAL_TRAP)
> + if (ws.sig () != GDB_SIGNAL_TRAP)
> return;
>
> /* In reverse execution, when a breakpoint is hit, the instruction
> @@ -4494,7 +4494,7 @@ handle_syscall_event (struct execution_control_state *ecs)
> ecs->event_thread->control.stop_bpstat
> = bpstat_stop_status (regcache->aspace (),
> ecs->event_thread->stop_pc (),
> - ecs->event_thread, &ecs->ws);
> + ecs->event_thread, ecs->ws);
>
> if (handle_stop_requested (ecs))
> return false;
> @@ -4593,7 +4593,7 @@ poll_one_curr_target (struct target_waitstatus *ws)
> event_ptid = target_wait (minus_one_ptid, ws, TARGET_WNOHANG);
>
> if (debug_infrun)
> - print_target_wait_results (minus_one_ptid, event_ptid, ws);
> + print_target_wait_results (minus_one_ptid, event_ptid, *ws);
>
> return event_ptid;
> }
> @@ -4674,23 +4674,23 @@ wait_one ()
> /* Save the thread's event and stop reason to process it later. */
>
> static void
> -save_waitstatus (struct thread_info *tp, const target_waitstatus *ws)
> +save_waitstatus (struct thread_info *tp, const target_waitstatus &ws)
> {
> infrun_debug_printf ("saving status %s for %s",
> - ws->to_string ().c_str (),
> + ws.to_string ().c_str (),
> tp->ptid.to_string ().c_str ());
>
> /* Record for later. */
> - tp->set_pending_waitstatus (*ws);
> + tp->set_pending_waitstatus (ws);
>
> - if (ws->kind () == TARGET_WAITKIND_STOPPED
> - && ws->sig () == GDB_SIGNAL_TRAP)
> + if (ws.kind () == TARGET_WAITKIND_STOPPED
> + && ws.sig () == GDB_SIGNAL_TRAP)
> {
> struct regcache *regcache = get_thread_regcache (tp);
> const address_space *aspace = regcache->aspace ();
> CORE_ADDR pc = regcache_read_pc (regcache);
>
> - adjust_pc_after_break (tp, &tp->pending_waitstatus ());
> + adjust_pc_after_break (tp, tp->pending_waitstatus ());
>
> scoped_restore_current_thread restore_thread;
> switch_to_thread (tp);
> @@ -4824,7 +4824,7 @@ handle_one (const wait_one_event &event)
> switch_to_thread_no_regs (t);
> mark_non_executing_threads (event.target, event.ptid,
> event.ws);
> - save_waitstatus (t, &event.ws);
> + save_waitstatus (t, event.ws);
> t->stop_requested = false;
> }
> }
> @@ -4878,7 +4878,7 @@ handle_one (const wait_one_event &event)
> t->ptid.to_string ().c_str ());
>
> /* Record for later. */
> - save_waitstatus (t, &event.ws);
> + save_waitstatus (t, event.ws);
>
> sig = (event.ws.kind () == TARGET_WAITKIND_STOPPED
> ? event.ws.sig () : GDB_SIGNAL_0);
> @@ -5236,7 +5236,7 @@ handle_inferior_event (struct execution_control_state *ecs)
> }
>
> /* Dependent on valid ECS->EVENT_THREAD. */
> - adjust_pc_after_break (ecs->event_thread, &ecs->ws);
> + adjust_pc_after_break (ecs->event_thread, ecs->ws);
>
> /* Dependent on the current PC value modified by adjust_pc_after_break. */
> reinit_frame_cache ();
> @@ -5295,7 +5295,7 @@ handle_inferior_event (struct execution_control_state *ecs)
> ecs->event_thread->control.stop_bpstat
> = bpstat_stop_status (regcache->aspace (),
> ecs->event_thread->stop_pc (),
> - ecs->event_thread, &ecs->ws);
> + ecs->event_thread, ecs->ws);
>
> if (handle_stop_requested (ecs))
> return;
> @@ -5538,7 +5538,7 @@ handle_inferior_event (struct execution_control_state *ecs)
> ecs->event_thread->control.stop_bpstat
> = bpstat_stop_status (get_current_regcache ()->aspace (),
> ecs->event_thread->stop_pc (),
> - ecs->event_thread, &ecs->ws);
> + ecs->event_thread, ecs->ws);
>
> if (handle_stop_requested (ecs))
> return;
> @@ -5649,7 +5649,7 @@ handle_inferior_event (struct execution_control_state *ecs)
> ecs->event_thread->control.stop_bpstat
> = bpstat_stop_status (get_current_regcache ()->aspace (),
> ecs->event_thread->stop_pc (),
> - ecs->event_thread, &ecs->ws);
> + ecs->event_thread, ecs->ws);
>
> if (handle_stop_requested (ecs))
> return;
> @@ -5886,7 +5886,7 @@ finish_step_over (struct execution_control_state *ecs)
> gdb_assert (pending != tp);
>
> /* Record the event thread's event for later. */
> - save_waitstatus (tp, &ecs->ws);
> + save_waitstatus (tp, ecs->ws);
> /* This was cleared early, by handle_inferior_event. Set it
> so this pending event is considered by
> do_target_wait. */
> @@ -6061,7 +6061,7 @@ handle_signal_stop (struct execution_control_state *ecs)
> && ecs->event_thread->stepping_over_watchpoint)
> stopped_by_watchpoint = 0;
> else
> - stopped_by_watchpoint = watchpoints_triggered (&ecs->ws);
> + stopped_by_watchpoint = watchpoints_triggered (ecs->ws);
>
> /* If necessary, step over this watchpoint. We'll be back to display
> it in a moment. */
> @@ -6134,16 +6134,16 @@ handle_signal_stop (struct execution_control_state *ecs)
> that's an extremely unlikely scenario. */
> if (!pc_at_non_inline_function (aspace,
> ecs->event_thread->stop_pc (),
> - &ecs->ws)
> + ecs->ws)
> && !(ecs->event_thread->stop_signal () == GDB_SIGNAL_TRAP
> && ecs->event_thread->control.trap_expected
> && pc_at_non_inline_function (aspace,
> ecs->event_thread->prev_pc,
> - &ecs->ws)))
> + ecs->ws)))
> {
> stop_chain = build_bpstat_chain (aspace,
> ecs->event_thread->stop_pc (),
> - &ecs->ws);
> + ecs->ws);
> skip_inline_frames (ecs->event_thread, stop_chain);
>
> /* Re-fetch current thread's frame in case that invalidated
> @@ -6195,7 +6195,7 @@ handle_signal_stop (struct execution_control_state *ecs)
> ecs->event_thread->control.stop_bpstat
> = bpstat_stop_status (get_current_regcache ()->aspace (),
> ecs->event_thread->stop_pc (),
> - ecs->event_thread, &ecs->ws, stop_chain);
> + ecs->event_thread, ecs->ws, stop_chain);
>
> /* Following in case break condition called a
> function. */
> @@ -8258,14 +8258,14 @@ print_no_history_reason (struct ui_out *uiout)
> based on the event(s) that just occurred. */
>
> static void
> -print_stop_location (struct target_waitstatus *ws)
> +print_stop_location (const target_waitstatus &ws)
> {
> int bpstat_ret;
> enum print_what source_flag;
> int do_frame_printing = 1;
> struct thread_info *tp = inferior_thread ();
>
> - bpstat_ret = bpstat_print (tp->control.stop_bpstat, ws->kind ());
> + bpstat_ret = bpstat_print (tp->control.stop_bpstat, ws.kind ());
> switch (bpstat_ret)
> {
> case PRINT_UNKNOWN:
> @@ -8325,7 +8325,7 @@ print_stop_event (struct ui_out *uiout, bool displays)
> {
> scoped_restore save_uiout = make_scoped_restore (¤t_uiout, uiout);
>
> - print_stop_location (&last);
> + print_stop_location (last);
>
> /* Display the auto-display expressions. */
> if (displays)
> diff --git a/gdb/infrun.h b/gdb/infrun.h
> index c5f98d9d305..644e57f0bca 100644
> --- a/gdb/infrun.h
> +++ b/gdb/infrun.h
> @@ -209,7 +209,7 @@ extern void print_stop_event (struct ui_out *uiout, bool displays = true);
> /* Pretty print the results of target_wait, for debugging purposes. */
>
> extern void print_target_wait_results (ptid_t waiton_ptid, ptid_t result_ptid,
> - const struct target_waitstatus *ws);
> + const struct target_waitstatus &ws);
>
> extern int signal_stop_state (int);
>
> diff --git a/gdb/remote.c b/gdb/remote.c
> index 61bde5aaa94..724386e0916 100644
> --- a/gdb/remote.c
> +++ b/gdb/remote.c
> @@ -762,7 +762,7 @@ class remote_target : public process_stratum_target
> target_waitstatus *status);
>
> ptid_t select_thread_for_ambiguous_stop_reply
> - (const struct target_waitstatus *status);
> + (const struct target_waitstatus &status);
>
> void remote_notice_new_inferior (ptid_t currthread, bool executing);
>
> @@ -4542,7 +4542,7 @@ remote_target::process_initial_stop_replies (int from_tty)
>
> event_ptid = target_wait (waiton_ptid, &ws, TARGET_WNOHANG);
> if (remote_debug)
> - print_target_wait_results (waiton_ptid, event_ptid, &ws);
> + print_target_wait_results (waiton_ptid, event_ptid, ws);
>
> switch (ws.kind ())
> {
> @@ -7224,11 +7224,11 @@ struct notif_client notif_client_stop =
> -1 if we want to check all threads. */
>
> static int
> -is_pending_fork_parent (const target_waitstatus *ws, int event_pid,
> +is_pending_fork_parent (const target_waitstatus &ws, int event_pid,
> ptid_t thread_ptid)
> {
> - if (ws->kind () == TARGET_WAITKIND_FORKED
> - || ws->kind () == TARGET_WAITKIND_VFORKED)
> + if (ws.kind () == TARGET_WAITKIND_FORKED
> + || ws.kind () == TARGET_WAITKIND_VFORKED)
> {
> if (event_pid == -1 || event_pid == thread_ptid.pid ())
> return 1;
> @@ -7240,13 +7240,13 @@ is_pending_fork_parent (const target_waitstatus *ws, int event_pid,
> /* Return the thread's pending status used to determine whether the
> thread is a fork parent stopped at a fork event. */
>
> -static const target_waitstatus *
> +static const target_waitstatus &
> thread_pending_fork_status (struct thread_info *thread)
> {
> if (thread->has_pending_waitstatus ())
> - return &thread->pending_waitstatus ();
> + return thread->pending_waitstatus ();
> else
> - return &thread->pending_follow;
> + return thread->pending_follow;
> }
>
> /* Determine if THREAD is a pending fork parent thread. */
> @@ -7254,7 +7254,7 @@ thread_pending_fork_status (struct thread_info *thread)
> static int
> is_pending_fork_parent_thread (struct thread_info *thread)
> {
> - const target_waitstatus *ws = thread_pending_fork_status (thread);
> + const target_waitstatus &ws = thread_pending_fork_status (thread);
> int pid = -1;
>
> return is_pending_fork_parent (ws, pid, thread->ptid);
> @@ -7276,10 +7276,10 @@ remote_target::remove_new_fork_children (threads_listing_context *context)
> fork child threads from the CONTEXT list. */
> for (thread_info *thread : all_non_exited_threads (this))
> {
> - const target_waitstatus *ws = thread_pending_fork_status (thread);
> + const target_waitstatus &ws = thread_pending_fork_status (thread);
>
> if (is_pending_fork_parent (ws, pid, thread->ptid))
> - context->remove_thread (ws->child_ptid ());
> + context->remove_thread (ws.child_ptid ());
> }
>
> /* Check for any pending fork events (not reported or processed yet)
> @@ -7940,15 +7940,15 @@ remote_notif_get_pending_events (remote_target *remote, notif_client *nc)
>
> ptid_t
> remote_target::select_thread_for_ambiguous_stop_reply
> - (const struct target_waitstatus *status)
> + (const target_waitstatus &status)
> {
> REMOTE_SCOPED_DEBUG_ENTER_EXIT;
>
> /* Some stop events apply to all threads in an inferior, while others
> only apply to a single thread. */
> bool process_wide_stop
> - = (status->kind () == TARGET_WAITKIND_EXITED
> - || status->kind () == TARGET_WAITKIND_SIGNALLED);
> + = (status.kind () == TARGET_WAITKIND_EXITED
> + || status.kind () == TARGET_WAITKIND_SIGNALLED);
>
> remote_debug_printf ("process_wide_stop = %d", process_wide_stop);
>
> @@ -8030,7 +8030,7 @@ remote_target::process_stop_reply (struct stop_reply *stop_reply,
> /* If no thread/process was reported by the stub then select a suitable
> thread/process. */
> if (ptid == null_ptid)
> - ptid = select_thread_for_ambiguous_stop_reply (status);
> + ptid = select_thread_for_ambiguous_stop_reply (*status);
> gdb_assert (ptid != null_ptid);
>
> if (status->kind () != TARGET_WAITKIND_EXITED
> @@ -10056,11 +10056,11 @@ remote_target::kill_new_fork_children (int pid)
> that are stopped at a fork event. */
> for (thread_info *thread : all_non_exited_threads (this))
> {
> - struct target_waitstatus *ws = &thread->pending_follow;
> + const target_waitstatus &ws = thread->pending_follow;
>
> if (is_pending_fork_parent (ws, pid, thread->ptid))
> {
> - int child_pid = ws->child_ptid ().pid ();
> + int child_pid = ws.child_ptid ().pid ();
> int res;
>
> res = remote_vkill (child_pid);
> @@ -10073,7 +10073,7 @@ remote_target::kill_new_fork_children (int pid)
> in process PID and kill those fork child threads as well. */
> remote_notif_get_pending_events (notif);
> for (auto &event : rs->stop_reply_queue)
> - if (is_pending_fork_parent (&event->ws, pid, event->ptid))
> + if (is_pending_fork_parent (event->ws, pid, event->ptid))
> {
> int child_pid = event->ws.child_ptid ().pid ();
> int res;
> diff --git a/gdbserver/remote-utils.cc b/gdbserver/remote-utils.cc
> index 5bc261a9c7b..8202365350a 100644
> --- a/gdbserver/remote-utils.cc
> +++ b/gdbserver/remote-utils.cc
> @@ -1081,15 +1081,14 @@ outreg (struct regcache *regcache, int regno, char *buf)
> }
>
> void
> -prepare_resume_reply (char *buf, ptid_t ptid,
> - struct target_waitstatus *status)
> +prepare_resume_reply (char *buf, ptid_t ptid, const target_waitstatus &status)
> {
> client_state &cs = get_client_state ();
> if (debug_threads)
> debug_printf ("Writing resume reply for %s:%d\n",
> - target_pid_to_str (ptid).c_str (), status->kind ());
> + target_pid_to_str (ptid).c_str (), status.kind ());
>
> - switch (status->kind ())
> + switch (status.kind ())
> {
> case TARGET_WAITKIND_STOPPED:
> case TARGET_WAITKIND_FORKED:
> @@ -1104,27 +1103,27 @@ prepare_resume_reply (char *buf, ptid_t ptid,
> const char **regp;
> struct regcache *regcache;
>
> - if ((status->kind () == TARGET_WAITKIND_FORKED && cs.report_fork_events)
> - || (status->kind () == TARGET_WAITKIND_VFORKED
> + if ((status.kind () == TARGET_WAITKIND_FORKED && cs.report_fork_events)
> + || (status.kind () == TARGET_WAITKIND_VFORKED
> && cs.report_vfork_events))
> {
> enum gdb_signal signal = GDB_SIGNAL_TRAP;
> - const char *event = (status->kind () == TARGET_WAITKIND_FORKED
> + const char *event = (status.kind () == TARGET_WAITKIND_FORKED
> ? "fork" : "vfork");
>
> sprintf (buf, "T%02x%s:", signal, event);
> buf += strlen (buf);
> - buf = write_ptid (buf, status->child_ptid ());
> + buf = write_ptid (buf, status.child_ptid ());
> strcat (buf, ";");
> }
> - else if (status->kind () == TARGET_WAITKIND_VFORK_DONE
> + else if (status.kind () == TARGET_WAITKIND_VFORK_DONE
> && cs.report_vfork_events)
> {
> enum gdb_signal signal = GDB_SIGNAL_TRAP;
>
> sprintf (buf, "T%02xvforkdone:;", signal);
> }
> - else if (status->kind () == TARGET_WAITKIND_EXECD && cs.report_exec_events)
> + else if (status.kind () == TARGET_WAITKIND_EXECD && cs.report_exec_events)
> {
> enum gdb_signal signal = GDB_SIGNAL_TRAP;
> const char *event = "exec";
> @@ -1134,32 +1133,32 @@ prepare_resume_reply (char *buf, ptid_t ptid,
> buf += strlen (buf);
>
> /* Encode pathname to hexified format. */
> - bin2hex ((const gdb_byte *) status->execd_pathname (),
> + bin2hex ((const gdb_byte *) status.execd_pathname (),
> hexified_pathname,
> - strlen (status->execd_pathname ()));
> + strlen (status.execd_pathname ()));
>
> sprintf (buf, "%s;", hexified_pathname);
> buf += strlen (buf);
> }
> - else if (status->kind () == TARGET_WAITKIND_THREAD_CREATED
> + else if (status.kind () == TARGET_WAITKIND_THREAD_CREATED
> && cs.report_thread_events)
> {
> enum gdb_signal signal = GDB_SIGNAL_TRAP;
>
> sprintf (buf, "T%02xcreate:;", signal);
> }
> - else if (status->kind () == TARGET_WAITKIND_SYSCALL_ENTRY
> - || status->kind () == TARGET_WAITKIND_SYSCALL_RETURN)
> + else if (status.kind () == TARGET_WAITKIND_SYSCALL_ENTRY
> + || status.kind () == TARGET_WAITKIND_SYSCALL_RETURN)
> {
> enum gdb_signal signal = GDB_SIGNAL_TRAP;
> - const char *event = (status->kind () == TARGET_WAITKIND_SYSCALL_ENTRY
> + const char *event = (status.kind () == TARGET_WAITKIND_SYSCALL_ENTRY
> ? "syscall_entry" : "syscall_return");
>
> sprintf (buf, "T%02x%s:%x;", signal, event,
> - status->syscall_number ());
> + status.syscall_number ());
> }
> else
> - sprintf (buf, "T%02x", status->sig ());
> + sprintf (buf, "T%02x", status.sig ());
>
> if (disable_packet_T)
> {
> @@ -1281,19 +1280,19 @@ prepare_resume_reply (char *buf, ptid_t ptid,
> case TARGET_WAITKIND_EXITED:
> if (cs.multi_process)
> sprintf (buf, "W%x;process:%x",
> - status->exit_status (), ptid.pid ());
> + status.exit_status (), ptid.pid ());
> else
> - sprintf (buf, "W%02x", status->exit_status ());
> + sprintf (buf, "W%02x", status.exit_status ());
> break;
> case TARGET_WAITKIND_SIGNALLED:
> if (cs.multi_process)
> sprintf (buf, "X%x;process:%x",
> - status->sig (), ptid.pid ());
> + status.sig (), ptid.pid ());
> else
> - sprintf (buf, "X%02x", status->sig ());
> + sprintf (buf, "X%02x", status.sig ());
> break;
> case TARGET_WAITKIND_THREAD_EXITED:
> - sprintf (buf, "w%x;", status->exit_status ());
> + sprintf (buf, "w%x;", status.exit_status ());
> buf += strlen (buf);
> buf = write_ptid (buf, ptid);
> break;
> diff --git a/gdbserver/remote-utils.h b/gdbserver/remote-utils.h
> index 25074bcc2b9..b856862d367 100644
> --- a/gdbserver/remote-utils.h
> +++ b/gdbserver/remote-utils.h
> @@ -41,7 +41,7 @@ void enable_async_io (void);
> void disable_async_io (void);
> void check_remote_input_interrupt_request (void);
> void prepare_resume_reply (char *buf, ptid_t ptid,
> - struct target_waitstatus *status);
> + const target_waitstatus &status);
>
> const char *decode_address_to_semicolon (CORE_ADDR *addrp, const char *start);
> void decode_address (CORE_ADDR *addrp, const char *start, int len);
> diff --git a/gdbserver/server.cc b/gdbserver/server.cc
> index 2807525d11c..b1d4c92b3d9 100644
> --- a/gdbserver/server.cc
> +++ b/gdbserver/server.cc
> @@ -173,12 +173,12 @@ get_client_state ()
> /* Put a stop reply to the stop reply queue. */
>
> static void
> -queue_stop_reply (ptid_t ptid, struct target_waitstatus *status)
> +queue_stop_reply (ptid_t ptid, const target_waitstatus &status)
> {
> struct vstop_notif *new_notif = new struct vstop_notif;
>
> new_notif->ptid = ptid;
> - new_notif->status = *status;
> + new_notif->status = status;
>
> notif_event_enque (¬if_stop, new_notif);
> }
> @@ -225,7 +225,7 @@ vstop_notif_reply (struct notif_event *event, char *own_buf)
> {
> struct vstop_notif *vstop = (struct vstop_notif *) event;
>
> - prepare_resume_reply (own_buf, vstop->ptid, &vstop->status);
> + prepare_resume_reply (own_buf, vstop->ptid, vstop->status);
> }
>
> /* Helper for in_queued_stop_replies. */
> @@ -2795,7 +2795,7 @@ handle_pending_status (const struct thread_resume *resumption,
>
> cs.last_status = thread->last_status;
> cs.last_ptid = thread->id;
> - prepare_resume_reply (cs.own_buf, cs.last_ptid, &cs.last_status);
> + prepare_resume_reply (cs.own_buf, cs.last_ptid, cs.last_status);
> return 1;
> }
> return 0;
> @@ -2963,7 +2963,7 @@ resume (struct thread_resume *actions, size_t num_actions)
> so by now). Tag all threads as "want-stopped", so we don't
> resume them implicitly without the client telling us to. */
> gdb_wants_all_threads_stopped ();
> - prepare_resume_reply (cs.own_buf, cs.last_ptid, &cs.last_status);
> + prepare_resume_reply (cs.own_buf, cs.last_ptid, cs.last_status);
> disable_async_io ();
>
> if (cs.last_status.kind () == TARGET_WAITKIND_EXITED
> @@ -2996,7 +2996,7 @@ handle_v_attach (char *own_buf)
> write_ok (own_buf);
> }
> else
> - prepare_resume_reply (own_buf, cs.last_ptid, &cs.last_status);
> + prepare_resume_reply (own_buf, cs.last_ptid, cs.last_status);
> }
> else
> write_enn (own_buf);
> @@ -3114,7 +3114,7 @@ handle_v_run (char *own_buf)
>
> if (cs.last_status.kind () == TARGET_WAITKIND_STOPPED)
> {
> - prepare_resume_reply (own_buf, cs.last_ptid, &cs.last_status);
> + prepare_resume_reply (own_buf, cs.last_ptid, cs.last_status);
>
> /* In non-stop, sending a resume reply doesn't set the general
> thread, but GDB assumes a vRun sets it (this is so GDB can
> @@ -3313,7 +3313,7 @@ queue_stop_reply_callback (thread_info *thread)
>
> /* Pass the last stop reply back to GDB, but don't notify
> yet. */
> - queue_stop_reply (thread->id, &thread->last_status);
> + queue_stop_reply (thread->id, thread->last_status);
> }
> }
> }
> @@ -3436,7 +3436,7 @@ handle_status (char *own_buf)
> set_desired_thread ();
>
> gdb_assert (tp->last_status.kind () != TARGET_WAITKIND_IGNORE);
> - prepare_resume_reply (own_buf, tp->id, &tp->last_status);
> + prepare_resume_reply (own_buf, tp->id, tp->last_status);
> }
> else
> strcpy (own_buf, "W00");
> @@ -4562,11 +4562,11 @@ handle_serial_event (int err, gdb_client_data client_data)
> /* Push a stop notification on the notification queue. */
>
> static void
> -push_stop_notification (ptid_t ptid, struct target_waitstatus *status)
> +push_stop_notification (ptid_t ptid, const target_waitstatus &status)
> {
> struct vstop_notif *vstop_notif = new struct vstop_notif;
>
> - vstop_notif->status = *status;
> + vstop_notif->status = status;
> vstop_notif->ptid = ptid;
> /* Push Stop notification. */
> notif_push (¬if_stop, vstop_notif);
> @@ -4587,7 +4587,7 @@ handle_target_event (int err, gdb_client_data client_data)
> if (cs.last_status.kind () == TARGET_WAITKIND_NO_RESUMED)
> {
> if (gdb_connected () && report_no_resumed)
> - push_stop_notification (null_ptid, &cs.last_status);
> + push_stop_notification (null_ptid, cs.last_status);
> }
> else if (cs.last_status.kind () != TARGET_WAITKIND_IGNORE)
> {
> @@ -4645,7 +4645,7 @@ handle_target_event (int err, gdb_client_data client_data)
> }
> }
> else
> - push_stop_notification (cs.last_ptid, &cs.last_status);
> + push_stop_notification (cs.last_ptid, cs.last_status);
> }
>
> /* Be sure to not change the selected thread behind GDB's back.
> --
> 2.33.1
>
More information about the Gdb-patches
mailing list