yggdrasil/binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

gdb: pass more const target_waitstatus by reference

Browse Source 
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.

Change-Id: Ied552d464be5d5b87489913b95f9720a5ad50c5a
This commit is contained in:
Simon Marchi 2021-11-22 11:27:31 -05:00 committed by Simon Marchi
parent 06de25b7af
commit c272a98cbf
10 changed files with 124 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
gdb/break-catch-sig.c
View File

@ -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

8
gdb/break-catch-syscall.c
View File

@ -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 ())

52
gdb/breakpoint.c
View File

@ -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 ())
{

10
gdb/breakpoint.h
View File

@ -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 *);

62
gdb/infrun.c
View File

@ -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 (&current_uiout, uiout);
print_stop_location (&last);
print_stop_location (last);
/* Display the auto-display expressions. */
if (displays)

2
gdb/infrun.h
View File

@ -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);

36
gdb/remote.c
View File

@ -762,7 +762,7 @@ public: /* Remote specific methods. */
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;

45
gdbserver/remote-utils.cc
View File

@ -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;

2
gdbserver/remote-utils.h
View File

@ -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);

26
gdbserver/server.cc
View File

@ -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 (&notif_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 (&notif_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.