* [PATCH 1/3] gdb: rename target_waitstatus_to_string to target_waitstatus::to_string
@ 2021-11-22 16:27 Simon Marchi
2021-11-22 16:27 ` [PATCH 2/3] gdb: introduce target_waitkind_str, use it in target_waitstatus::to_string Simon Marchi
` (2 more replies)
0 siblings, 3 replies; 9+ messages in thread
From: Simon Marchi @ 2021-11-22 16:27 UTC (permalink / raw)
To: gdb-patches; +Cc: Simon Marchi
Make target_waitstatus_to_string a "to_string" method of
target_waitstatus, a bit like we have ptid_t::to_string already. This
will save a bit of typing.
Change-Id: Id261b7a09fa9fa3c738abac131c191a6f9c13905
---
gdb/gnu-nat.c | 2 +-
gdb/infrun.c | 17 ++++++++---------
gdb/record-btrace.c | 4 ++--
gdb/target-debug.h | 4 +---
gdb/target/waitstatus.c | 18 +++++++++---------
gdb/target/waitstatus.h | 11 ++++++-----
gdbserver/linux-low.cc | 10 +++-------
gdbserver/server.cc | 11 +++--------
8 files changed, 33 insertions(+), 44 deletions(-)
diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c
index c6cecff0686..216d178424f 100644
--- a/gdb/gnu-nat.c
+++ b/gdb/gnu-nat.c
@@ -1619,7 +1619,7 @@ gnu_nat_target::wait (ptid_t ptid, struct target_waitstatus *status,
inf_debug (inf, "returning ptid = %s, %s",
target_pid_to_str (ptid).c_str (),
- target_waitstatus_to_string (status).c_str ());
+ status->to_string ().c_str ());
return ptid;
}
diff --git a/gdb/infrun.c b/gdb/infrun.c
index 89a98c20df4..dba4f33a327 100644
--- a/gdb/infrun.c
+++ b/gdb/infrun.c
@@ -2214,7 +2214,7 @@ resume_1 (enum gdb_signal sig)
("thread %s has pending wait "
"status %s (currently_stepping=%d).",
tp->ptid.to_string ().c_str (),
- target_waitstatus_to_string (&tp->pending_waitstatus ()).c_str (),
+ tp->pending_waitstatus ().to_string ().c_str (),
currently_stepping (tp));
tp->inf->process_target ()->threads_executing = true;
@@ -2632,7 +2632,7 @@ clear_proceed_status_thread (struct thread_info *tp)
infrun_debug_printf
("thread %s has pending wait status %s (currently_stepping=%d).",
tp->ptid.to_string ().c_str (),
- target_waitstatus_to_string (&tp->pending_waitstatus ()).c_str (),
+ tp->pending_waitstatus ().to_string ().c_str (),
currently_stepping (tp));
}
}
@@ -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", target_waitstatus_to_string (ws).c_str ());
+ infrun_debug_printf (" %s", ws->to_string ().c_str ());
}
/* Select a thread at random, out of those which are resumed and have
@@ -3584,8 +3584,7 @@ do_target_wait_1 (inferior *inf, ptid_t ptid,
if (tp != NULL)
{
infrun_debug_printf ("Using pending wait status %s for %s.",
- target_waitstatus_to_string
- (&tp->pending_waitstatus ()).c_str (),
+ tp->pending_waitstatus ().to_string ().c_str (),
tp->ptid.to_string ().c_str ());
/* Now that we've selected our final event LWP, un-adjust its PC
@@ -4678,7 +4677,7 @@ static void
save_waitstatus (struct thread_info *tp, const target_waitstatus *ws)
{
infrun_debug_printf ("saving status %s for %s",
- target_waitstatus_to_string (ws).c_str (),
+ ws->to_string ().c_str (),
tp->ptid.to_string ().c_str ());
/* Record for later. */
@@ -4769,7 +4768,7 @@ static bool
handle_one (const wait_one_event &event)
{
infrun_debug_printf
- ("%s %s", target_waitstatus_to_string (&event.ws).c_str (),
+ ("%s %s", event.ws.to_string ().c_str (),
event.ptid.to_string ().c_str ());
if (event.ws.kind () == TARGET_WAITKIND_NO_RESUMED)
@@ -4875,7 +4874,7 @@ handle_one (const wait_one_event &event)
infrun_debug_printf
("target_wait %s, saving status for %s",
- target_waitstatus_to_string (&event.ws).c_str (),
+ event.ws.to_string ().c_str (),
t->ptid.to_string ().c_str ());
/* Record for later. */
@@ -5181,7 +5180,7 @@ handle_inferior_event (struct execution_control_state *ecs)
end. */
scoped_value_mark free_values;
- infrun_debug_printf ("%s", target_waitstatus_to_string (&ecs->ws).c_str ());
+ infrun_debug_printf ("%s", ecs->ws.to_string ().c_str ());
if (ecs->ws.kind () == TARGET_WAITKIND_IGNORE)
{
diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c
index a9518d57bcb..3fcfd6a4761 100644
--- a/gdb/record-btrace.c
+++ b/gdb/record-btrace.c
@@ -2556,7 +2556,7 @@ record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status,
*status = btrace_step_no_resumed ();
DEBUG ("wait ended by %s: %s", target_pid_to_str (null_ptid).c_str (),
- target_waitstatus_to_string (status).c_str ());
+ status->to_string ().c_str ());
return null_ptid;
}
@@ -2647,7 +2647,7 @@ record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status,
DEBUG ("wait ended by thread %s (%s): %s",
print_thread_id (eventing),
target_pid_to_str (eventing->ptid).c_str (),
- target_waitstatus_to_string (status).c_str ());
+ status->to_string ().c_str ());
return eventing->ptid;
}
diff --git a/gdb/target-debug.h b/gdb/target-debug.h
index 5949441bc66..c9bc68b7826 100644
--- a/gdb/target-debug.h
+++ b/gdb/target-debug.h
@@ -180,9 +180,7 @@
static void
target_debug_print_struct_target_waitstatus_p (struct target_waitstatus *status)
{
- std::string str = target_waitstatus_to_string (status);
-
- fputs_unfiltered (str.c_str (), gdb_stdlog);
+ fputs_unfiltered (status->to_string ().c_str (), gdb_stdlog);
}
\f
diff --git a/gdb/target/waitstatus.c b/gdb/target/waitstatus.c
index dc3d75eef6e..2293d83230d 100644
--- a/gdb/target/waitstatus.c
+++ b/gdb/target/waitstatus.c
@@ -23,40 +23,40 @@
/* Return a pretty printed form of target_waitstatus. */
std::string
-target_waitstatus_to_string (const struct target_waitstatus *ws)
+target_waitstatus::to_string () const
{
const char *kind_str = "status->kind = ";
- switch (ws->kind ())
+ switch (this->kind ())
{
case TARGET_WAITKIND_EXITED:
return string_printf ("%sexited, status = %d",
- kind_str, ws->exit_status ());
+ kind_str, this->exit_status ());
case TARGET_WAITKIND_STOPPED:
return string_printf ("%sstopped, signal = %s",
kind_str,
- gdb_signal_to_symbol_string (ws->sig ()));
+ gdb_signal_to_symbol_string (this->sig ()));
case TARGET_WAITKIND_SIGNALLED:
return string_printf ("%ssignalled, signal = %s",
kind_str,
- gdb_signal_to_symbol_string (ws->sig ()));
+ gdb_signal_to_symbol_string (this->sig ()));
case TARGET_WAITKIND_LOADED:
return string_printf ("%sloaded", kind_str);
case TARGET_WAITKIND_FORKED:
return string_printf ("%sforked, child_ptid = %s", kind_str,
- ws->child_ptid ().to_string ().c_str ());
+ this->child_ptid ().to_string ().c_str ());
case TARGET_WAITKIND_VFORKED:
return string_printf ("%svforked, child_ptid = %s", kind_str,
- ws->child_ptid ().to_string ().c_str ());
+ this->child_ptid ().to_string ().c_str ());
case TARGET_WAITKIND_EXECD:
return string_printf ("%sexecd, execd_pathname = %s", kind_str,
- ws->execd_pathname ());
+ this->execd_pathname ());
case TARGET_WAITKIND_VFORK_DONE:
return string_printf ("%svfork-done", kind_str);
@@ -84,7 +84,7 @@ target_waitstatus_to_string (const struct target_waitstatus *ws)
case TARGET_WAITKIND_THREAD_EXITED:
return string_printf ("%sthread exited, status = %d",
- kind_str, ws->exit_status ());
+ kind_str, this->exit_status ());
default:
return string_printf ("%sunknown???", kind_str);
diff --git a/gdb/target/waitstatus.h b/gdb/target/waitstatus.h
index 333863e6d6e..f5b050b8b82 100644
--- a/gdb/target/waitstatus.h
+++ b/gdb/target/waitstatus.h
@@ -321,6 +321,12 @@ struct target_waitstatus
return m_value.syscall_number;
}
+ /* Return a pretty printed form of target_waitstatus.
+
+ This is only meant to be used in debug messages, not for user-visible
+ messages. */
+ std::string to_string () const;
+
private:
/* Reset the wait status to its original state. */
void reset ()
@@ -371,9 +377,4 @@ enum target_stop_reason
TARGET_STOPPED_BY_SINGLE_STEP
};
-/* Prototypes */
-
-/* Return a pretty printed form of target_waitstatus. */
-std::string target_waitstatus_to_string (const struct target_waitstatus *);
-
#endif /* TARGET_WAITSTATUS_H */
diff --git a/gdbserver/linux-low.cc b/gdbserver/linux-low.cc
index 34ede238d19..d214aff7051 100644
--- a/gdbserver/linux-low.cc
+++ b/gdbserver/linux-low.cc
@@ -3445,13 +3445,9 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
if (debug_threads)
{
if (event_child->waitstatus.kind () != TARGET_WAITKIND_IGNORE)
- {
- std::string str
- = target_waitstatus_to_string (&event_child->waitstatus);
-
- debug_printf ("LWP %ld: extended event with waitstatus %s\n",
- lwpid_of (get_lwp_thread (event_child)), str.c_str ());
- }
+ debug_printf ("LWP %ld: extended event with waitstatus %s\n",
+ lwpid_of (get_lwp_thread (event_child)),
+ event_child->waitstatus.to_string ().c_str ());
if (current_thread->last_resume_kind == resume_step)
{
if (event_child->step_range_start == event_child->step_range_end)
diff --git a/gdbserver/server.cc b/gdbserver/server.cc
index c58f7e01d8d..2807525d11c 100644
--- a/gdbserver/server.cc
+++ b/gdbserver/server.cc
@@ -3305,14 +3305,9 @@ queue_stop_reply_callback (thread_info *thread)
if (target_thread_stopped (thread))
{
if (debug_threads)
- {
- std::string status_string
- = target_waitstatus_to_string (&thread->last_status);
-
- debug_printf ("Reporting thread %s as already stopped with %s\n",
- target_pid_to_str (thread->id).c_str (),
- status_string.c_str ());
- }
+ debug_printf ("Reporting thread %s as already stopped with %s\n",
+ target_pid_to_str (thread->id).c_str (),
+ thread->last_status.to_string ().c_str ());
gdb_assert (thread->last_status.kind () != TARGET_WAITKIND_IGNORE);
--
2.33.1
^ permalink raw reply [flat|nested] 9+ messages in thread
* [PATCH 2/3] gdb: introduce target_waitkind_str, use it in target_waitstatus::to_string
2021-11-22 16:27 [PATCH 1/3] gdb: rename target_waitstatus_to_string to target_waitstatus::to_string Simon Marchi
@ 2021-11-22 16:27 ` Simon Marchi
2021-11-22 18:53 ` Andrew Burgess
2021-11-25 14:38 ` Vaseeharan Vinayagamoorthy
2021-11-22 16:27 ` [PATCH 3/3] gdb: pass more const target_waitstatus by reference Simon Marchi
2021-11-22 18:48 ` [PATCH 1/3] gdb: rename target_waitstatus_to_string to target_waitstatus::to_string Andrew Burgess
2 siblings, 2 replies; 9+ messages in thread
From: Simon Marchi @ 2021-11-22 16:27 UTC (permalink / raw)
To: gdb-patches; +Cc: Simon Marchi
I would like to print target_waitkind values in debug messages, so I
think that a target_waitkind-to-string function would be useful. While
at it, use it in target_waitstatus::to_string. This changes the output
of target_waitstatus::to_string a bit, but I think it is for the better.
The debug messages will show a string matching exactly the
target_waitkind enumerator (minus the TARGET_WAITKIND prefix).
As a convenience, make string_appendf return the same reference to
string it got as a parameter. This allows doing this:
return string_appendf (str, "foo");
... keeping the code concise.
Change-Id: I383dffc9c78614e7d0668b1516073905e798eef7
---
gdb/target/waitstatus.c | 66 +++++++++-----------------
gdb/target/waitstatus.h | 49 +++++++++++++++++++
gdb/unittests/common-utils-selftests.c | 7 ++-
gdbsupport/common-utils.cc | 8 +++-
gdbsupport/common-utils.h | 4 +-
5 files changed, 84 insertions(+), 50 deletions(-)
diff --git a/gdb/target/waitstatus.c b/gdb/target/waitstatus.c
index 2293d83230d..a7209e3f2b7 100644
--- a/gdb/target/waitstatus.c
+++ b/gdb/target/waitstatus.c
@@ -20,73 +20,51 @@
#include "gdbsupport/common-defs.h"
#include "waitstatus.h"
-/* Return a pretty printed form of target_waitstatus. */
+/* See waitstatus.h. */
std::string
target_waitstatus::to_string () const
{
- const char *kind_str = "status->kind = ";
+ std::string str = string_printf
+ ("status->kind = %s", target_waitkind_str (this->kind ()));
+/* Make sure the compiler warns if a new TARGET_WAITKIND enumerator is added
+ but not handled here. */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic error "-Wswitch"
switch (this->kind ())
{
case TARGET_WAITKIND_EXITED:
- return string_printf ("%sexited, status = %d",
- kind_str, this->exit_status ());
+ case TARGET_WAITKIND_THREAD_EXITED:
+ return string_appendf (str, ", exit_status = %d", this->exit_status ());
case TARGET_WAITKIND_STOPPED:
- return string_printf ("%sstopped, signal = %s",
- kind_str,
- gdb_signal_to_symbol_string (this->sig ()));
-
case TARGET_WAITKIND_SIGNALLED:
- return string_printf ("%ssignalled, signal = %s",
- kind_str,
- gdb_signal_to_symbol_string (this->sig ()));
-
- case TARGET_WAITKIND_LOADED:
- return string_printf ("%sloaded", kind_str);
+ return string_appendf (str, ", sig = %s",
+ gdb_signal_to_symbol_string (this->sig ()));
case TARGET_WAITKIND_FORKED:
- return string_printf ("%sforked, child_ptid = %s", kind_str,
- this->child_ptid ().to_string ().c_str ());
-
case TARGET_WAITKIND_VFORKED:
- return string_printf ("%svforked, child_ptid = %s", kind_str,
- this->child_ptid ().to_string ().c_str ());
+ return string_appendf (str, ", child_ptid = %s",
+ this->child_ptid ().to_string ().c_str ());
case TARGET_WAITKIND_EXECD:
- return string_printf ("%sexecd, execd_pathname = %s", kind_str,
- this->execd_pathname ());
+ return string_appendf (str, ", execd_pathname = %s",
+ this->execd_pathname ());
+ case TARGET_WAITKIND_LOADED:
case TARGET_WAITKIND_VFORK_DONE:
- return string_printf ("%svfork-done", kind_str);
-
+ case TARGET_WAITKIND_SPURIOUS:
case TARGET_WAITKIND_SYSCALL_ENTRY:
- return string_printf ("%sentered syscall", kind_str);
-
case TARGET_WAITKIND_SYSCALL_RETURN:
- return string_printf ("%sexited syscall", kind_str);
-
- case TARGET_WAITKIND_SPURIOUS:
- return string_printf ("%sspurious", kind_str);
-
case TARGET_WAITKIND_IGNORE:
- return string_printf ("%signore", kind_str);
-
case TARGET_WAITKIND_NO_HISTORY:
- return string_printf ("%sno-history", kind_str);
-
case TARGET_WAITKIND_NO_RESUMED:
- return string_printf ("%sno-resumed", kind_str);
-
case TARGET_WAITKIND_THREAD_CREATED:
- return string_printf ("%sthread created", kind_str);
-
- case TARGET_WAITKIND_THREAD_EXITED:
- return string_printf ("%sthread exited, status = %d",
- kind_str, this->exit_status ());
-
- default:
- return string_printf ("%sunknown???", kind_str);
+ return str;
}
+#pragma GCC diagnostic pop
+
+ gdb_assert_not_reached ("invalid target_waitkind value: %d",
+ (int) this->kind ());
}
diff --git a/gdb/target/waitstatus.h b/gdb/target/waitstatus.h
index f5b050b8b82..48405d222f4 100644
--- a/gdb/target/waitstatus.h
+++ b/gdb/target/waitstatus.h
@@ -101,6 +101,55 @@ enum target_waitkind
TARGET_WAITKIND_THREAD_EXITED,
};
+/* Return KIND as a string. */
+
+static inline const char *
+target_waitkind_str (target_waitkind kind)
+{
+/* Make sure the compiler warns if a new TARGET_WAITKIND enumerator is added
+ but not handled here. */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic error "-Wswitch"
+ switch (kind)
+ {
+ case TARGET_WAITKIND_EXITED:
+ return "EXITED";
+ case TARGET_WAITKIND_STOPPED:
+ return "STOPPED";
+ case TARGET_WAITKIND_SIGNALLED:
+ return "SIGNALLED";
+ case TARGET_WAITKIND_LOADED:
+ return "LOADED";
+ case TARGET_WAITKIND_FORKED:
+ return "FORKED";
+ case TARGET_WAITKIND_VFORKED:
+ return "VFORKED";
+ case TARGET_WAITKIND_EXECD:
+ return "EXECD";
+ case TARGET_WAITKIND_VFORK_DONE:
+ return "VFORK_DONE";
+ case TARGET_WAITKIND_SYSCALL_ENTRY:
+ return "SYSCALL_ENTRY";
+ case TARGET_WAITKIND_SYSCALL_RETURN:
+ return "SYSCALL_RETURN";
+ case TARGET_WAITKIND_SPURIOUS:
+ return "SPURIOUS";
+ case TARGET_WAITKIND_IGNORE:
+ return "IGNORE";
+ case TARGET_WAITKIND_NO_HISTORY:
+ return "NO_HISTORY";
+ case TARGET_WAITKIND_NO_RESUMED:
+ return "NO_RESUMED";
+ case TARGET_WAITKIND_THREAD_CREATED:
+ return "THREAD_CREATED";
+ case TARGET_WAITKIND_THREAD_EXITED:
+ return "THREAD_EXITED";
+ };
+#pragma GCC diagnostic pop
+
+ gdb_assert_not_reached ("invalid target_waitkind value: %d\n", (int) kind);
+}
+
struct target_waitstatus
{
/* Default constructor. */
diff --git a/gdb/unittests/common-utils-selftests.c b/gdb/unittests/common-utils-selftests.c
index 26d313fd329..aa0f45241b9 100644
--- a/gdb/unittests/common-utils-selftests.c
+++ b/gdb/unittests/common-utils-selftests.c
@@ -80,7 +80,8 @@ string_vprintf_tests ()
/* Type of both 'string_appendf' and the 'string_vappendf_wrapper'
function below. Used to run the same tests against both
string_appendf and string_vappendf. */
-typedef void (string_appendf_func) (std::string &str, const char *fmt, ...)
+typedef std::string &(string_appendf_func) (std::string &str, const char *fmt,
+ ...)
ATTRIBUTE_PRINTF (2, 3);
static void
@@ -101,7 +102,7 @@ test_appendf_func (string_appendf_func *func)
SELF_CHECK (str == "test23foo 45 bar");
}
-static void ATTRIBUTE_PRINTF (2, 3)
+static std::string & ATTRIBUTE_PRINTF (2, 3)
string_vappendf_wrapper (std::string &str, const char *fmt, ...)
{
va_list vp;
@@ -109,6 +110,8 @@ string_vappendf_wrapper (std::string &str, const char *fmt, ...)
va_start (vp, fmt);
string_vappendf (str, fmt, vp);
va_end (vp);
+
+ return str;
}
static void
diff --git a/gdbsupport/common-utils.cc b/gdbsupport/common-utils.cc
index 42bce36e535..b591537e62e 100644
--- a/gdbsupport/common-utils.cc
+++ b/gdbsupport/common-utils.cc
@@ -119,7 +119,7 @@ string_vprintf (const char* fmt, va_list args)
/* See documentation in common-utils.h. */
-void
+std::string &
string_appendf (std::string &str, const char *fmt, ...)
{
va_list vp;
@@ -127,12 +127,14 @@ string_appendf (std::string &str, const char *fmt, ...)
va_start (vp, fmt);
string_vappendf (str, fmt, vp);
va_end (vp);
+
+ return str;
}
/* See documentation in common-utils.h. */
-void
+std::string &
string_vappendf (std::string &str, const char *fmt, va_list args)
{
va_list vp;
@@ -148,6 +150,8 @@ string_vappendf (std::string &str, const char *fmt, va_list args)
/* C++11 and later guarantee std::string uses contiguous memory and
always includes the terminating '\0'. */
vsprintf (&str[curr_size], fmt, args); /* ARI: vsprintf */
+
+ return str;
}
char *
diff --git a/gdbsupport/common-utils.h b/gdbsupport/common-utils.h
index af078475780..98a9dc72f36 100644
--- a/gdbsupport/common-utils.h
+++ b/gdbsupport/common-utils.h
@@ -54,11 +54,11 @@ std::string string_vprintf (const char* fmt, va_list args)
/* Like string_printf, but appends to DEST instead of returning a new
std::string. */
-void string_appendf (std::string &dest, const char* fmt, ...)
+std::string &string_appendf (std::string &dest, const char* fmt, ...)
ATTRIBUTE_PRINTF (2, 3);
/* Like string_appendf, but takes a va_list. */
-void string_vappendf (std::string &dest, const char* fmt, va_list args)
+std::string &string_vappendf (std::string &dest, const char* fmt, va_list args)
ATTRIBUTE_PRINTF (2, 0);
/* Make a copy of the string at PTR with LEN characters
--
2.33.1
^ permalink raw reply [flat|nested] 9+ messages in thread
* [PATCH 3/3] gdb: pass more const target_waitstatus by reference
2021-11-22 16:27 [PATCH 1/3] gdb: rename target_waitstatus_to_string to target_waitstatus::to_string Simon Marchi
2021-11-22 16:27 ` [PATCH 2/3] gdb: introduce target_waitkind_str, use it in target_waitstatus::to_string Simon Marchi
@ 2021-11-22 16:27 ` Simon Marchi
2021-11-22 18:56 ` Andrew Burgess
2021-11-22 18:48 ` [PATCH 1/3] gdb: rename target_waitstatus_to_string to target_waitstatus::to_string Andrew Burgess
2 siblings, 1 reply; 9+ messages in thread
From: Simon Marchi @ 2021-11-22 16:27 UTC (permalink / raw)
To: gdb-patches; +Cc: Simon Marchi
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
---
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);
\f
/* 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
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH 1/3] gdb: rename target_waitstatus_to_string to target_waitstatus::to_string
2021-11-22 16:27 [PATCH 1/3] gdb: rename target_waitstatus_to_string to target_waitstatus::to_string Simon Marchi
2021-11-22 16:27 ` [PATCH 2/3] gdb: introduce target_waitkind_str, use it in target_waitstatus::to_string Simon Marchi
2021-11-22 16:27 ` [PATCH 3/3] gdb: pass more const target_waitstatus by reference Simon Marchi
@ 2021-11-22 18:48 ` Andrew Burgess
2 siblings, 0 replies; 9+ messages in thread
From: Andrew Burgess @ 2021-11-22 18:48 UTC (permalink / raw)
To: Simon Marchi; +Cc: gdb-patches
* Simon Marchi via Gdb-patches <gdb-patches@sourceware.org> [2021-11-22 11:27:29 -0500]:
> Make target_waitstatus_to_string a "to_string" method of
> target_waitstatus, a bit like we have ptid_t::to_string already. This
> will save a bit of typing.
LGTM.
Thanks,
Andrew
>
> Change-Id: Id261b7a09fa9fa3c738abac131c191a6f9c13905
> ---
> gdb/gnu-nat.c | 2 +-
> gdb/infrun.c | 17 ++++++++---------
> gdb/record-btrace.c | 4 ++--
> gdb/target-debug.h | 4 +---
> gdb/target/waitstatus.c | 18 +++++++++---------
> gdb/target/waitstatus.h | 11 ++++++-----
> gdbserver/linux-low.cc | 10 +++-------
> gdbserver/server.cc | 11 +++--------
> 8 files changed, 33 insertions(+), 44 deletions(-)
>
> diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c
> index c6cecff0686..216d178424f 100644
> --- a/gdb/gnu-nat.c
> +++ b/gdb/gnu-nat.c
> @@ -1619,7 +1619,7 @@ gnu_nat_target::wait (ptid_t ptid, struct target_waitstatus *status,
>
> inf_debug (inf, "returning ptid = %s, %s",
> target_pid_to_str (ptid).c_str (),
> - target_waitstatus_to_string (status).c_str ());
> + status->to_string ().c_str ());
>
> return ptid;
> }
> diff --git a/gdb/infrun.c b/gdb/infrun.c
> index 89a98c20df4..dba4f33a327 100644
> --- a/gdb/infrun.c
> +++ b/gdb/infrun.c
> @@ -2214,7 +2214,7 @@ resume_1 (enum gdb_signal sig)
> ("thread %s has pending wait "
> "status %s (currently_stepping=%d).",
> tp->ptid.to_string ().c_str (),
> - target_waitstatus_to_string (&tp->pending_waitstatus ()).c_str (),
> + tp->pending_waitstatus ().to_string ().c_str (),
> currently_stepping (tp));
>
> tp->inf->process_target ()->threads_executing = true;
> @@ -2632,7 +2632,7 @@ clear_proceed_status_thread (struct thread_info *tp)
> infrun_debug_printf
> ("thread %s has pending wait status %s (currently_stepping=%d).",
> tp->ptid.to_string ().c_str (),
> - target_waitstatus_to_string (&tp->pending_waitstatus ()).c_str (),
> + tp->pending_waitstatus ().to_string ().c_str (),
> currently_stepping (tp));
> }
> }
> @@ -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", target_waitstatus_to_string (ws).c_str ());
> + infrun_debug_printf (" %s", ws->to_string ().c_str ());
> }
>
> /* Select a thread at random, out of those which are resumed and have
> @@ -3584,8 +3584,7 @@ do_target_wait_1 (inferior *inf, ptid_t ptid,
> if (tp != NULL)
> {
> infrun_debug_printf ("Using pending wait status %s for %s.",
> - target_waitstatus_to_string
> - (&tp->pending_waitstatus ()).c_str (),
> + tp->pending_waitstatus ().to_string ().c_str (),
> tp->ptid.to_string ().c_str ());
>
> /* Now that we've selected our final event LWP, un-adjust its PC
> @@ -4678,7 +4677,7 @@ static void
> save_waitstatus (struct thread_info *tp, const target_waitstatus *ws)
> {
> infrun_debug_printf ("saving status %s for %s",
> - target_waitstatus_to_string (ws).c_str (),
> + ws->to_string ().c_str (),
> tp->ptid.to_string ().c_str ());
>
> /* Record for later. */
> @@ -4769,7 +4768,7 @@ static bool
> handle_one (const wait_one_event &event)
> {
> infrun_debug_printf
> - ("%s %s", target_waitstatus_to_string (&event.ws).c_str (),
> + ("%s %s", event.ws.to_string ().c_str (),
> event.ptid.to_string ().c_str ());
>
> if (event.ws.kind () == TARGET_WAITKIND_NO_RESUMED)
> @@ -4875,7 +4874,7 @@ handle_one (const wait_one_event &event)
>
> infrun_debug_printf
> ("target_wait %s, saving status for %s",
> - target_waitstatus_to_string (&event.ws).c_str (),
> + event.ws.to_string ().c_str (),
> t->ptid.to_string ().c_str ());
>
> /* Record for later. */
> @@ -5181,7 +5180,7 @@ handle_inferior_event (struct execution_control_state *ecs)
> end. */
> scoped_value_mark free_values;
>
> - infrun_debug_printf ("%s", target_waitstatus_to_string (&ecs->ws).c_str ());
> + infrun_debug_printf ("%s", ecs->ws.to_string ().c_str ());
>
> if (ecs->ws.kind () == TARGET_WAITKIND_IGNORE)
> {
> diff --git a/gdb/record-btrace.c b/gdb/record-btrace.c
> index a9518d57bcb..3fcfd6a4761 100644
> --- a/gdb/record-btrace.c
> +++ b/gdb/record-btrace.c
> @@ -2556,7 +2556,7 @@ record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status,
> *status = btrace_step_no_resumed ();
>
> DEBUG ("wait ended by %s: %s", target_pid_to_str (null_ptid).c_str (),
> - target_waitstatus_to_string (status).c_str ());
> + status->to_string ().c_str ());
>
> return null_ptid;
> }
> @@ -2647,7 +2647,7 @@ record_btrace_target::wait (ptid_t ptid, struct target_waitstatus *status,
> DEBUG ("wait ended by thread %s (%s): %s",
> print_thread_id (eventing),
> target_pid_to_str (eventing->ptid).c_str (),
> - target_waitstatus_to_string (status).c_str ());
> + status->to_string ().c_str ());
>
> return eventing->ptid;
> }
> diff --git a/gdb/target-debug.h b/gdb/target-debug.h
> index 5949441bc66..c9bc68b7826 100644
> --- a/gdb/target-debug.h
> +++ b/gdb/target-debug.h
> @@ -180,9 +180,7 @@
> static void
> target_debug_print_struct_target_waitstatus_p (struct target_waitstatus *status)
> {
> - std::string str = target_waitstatus_to_string (status);
> -
> - fputs_unfiltered (str.c_str (), gdb_stdlog);
> + fputs_unfiltered (status->to_string ().c_str (), gdb_stdlog);
> }
>
> \f
> diff --git a/gdb/target/waitstatus.c b/gdb/target/waitstatus.c
> index dc3d75eef6e..2293d83230d 100644
> --- a/gdb/target/waitstatus.c
> +++ b/gdb/target/waitstatus.c
> @@ -23,40 +23,40 @@
> /* Return a pretty printed form of target_waitstatus. */
>
> std::string
> -target_waitstatus_to_string (const struct target_waitstatus *ws)
> +target_waitstatus::to_string () const
> {
> const char *kind_str = "status->kind = ";
>
> - switch (ws->kind ())
> + switch (this->kind ())
> {
> case TARGET_WAITKIND_EXITED:
> return string_printf ("%sexited, status = %d",
> - kind_str, ws->exit_status ());
> + kind_str, this->exit_status ());
>
> case TARGET_WAITKIND_STOPPED:
> return string_printf ("%sstopped, signal = %s",
> kind_str,
> - gdb_signal_to_symbol_string (ws->sig ()));
> + gdb_signal_to_symbol_string (this->sig ()));
>
> case TARGET_WAITKIND_SIGNALLED:
> return string_printf ("%ssignalled, signal = %s",
> kind_str,
> - gdb_signal_to_symbol_string (ws->sig ()));
> + gdb_signal_to_symbol_string (this->sig ()));
>
> case TARGET_WAITKIND_LOADED:
> return string_printf ("%sloaded", kind_str);
>
> case TARGET_WAITKIND_FORKED:
> return string_printf ("%sforked, child_ptid = %s", kind_str,
> - ws->child_ptid ().to_string ().c_str ());
> + this->child_ptid ().to_string ().c_str ());
>
> case TARGET_WAITKIND_VFORKED:
> return string_printf ("%svforked, child_ptid = %s", kind_str,
> - ws->child_ptid ().to_string ().c_str ());
> + this->child_ptid ().to_string ().c_str ());
>
> case TARGET_WAITKIND_EXECD:
> return string_printf ("%sexecd, execd_pathname = %s", kind_str,
> - ws->execd_pathname ());
> + this->execd_pathname ());
>
> case TARGET_WAITKIND_VFORK_DONE:
> return string_printf ("%svfork-done", kind_str);
> @@ -84,7 +84,7 @@ target_waitstatus_to_string (const struct target_waitstatus *ws)
>
> case TARGET_WAITKIND_THREAD_EXITED:
> return string_printf ("%sthread exited, status = %d",
> - kind_str, ws->exit_status ());
> + kind_str, this->exit_status ());
>
> default:
> return string_printf ("%sunknown???", kind_str);
> diff --git a/gdb/target/waitstatus.h b/gdb/target/waitstatus.h
> index 333863e6d6e..f5b050b8b82 100644
> --- a/gdb/target/waitstatus.h
> +++ b/gdb/target/waitstatus.h
> @@ -321,6 +321,12 @@ struct target_waitstatus
> return m_value.syscall_number;
> }
>
> + /* Return a pretty printed form of target_waitstatus.
> +
> + This is only meant to be used in debug messages, not for user-visible
> + messages. */
> + std::string to_string () const;
> +
> private:
> /* Reset the wait status to its original state. */
> void reset ()
> @@ -371,9 +377,4 @@ enum target_stop_reason
> TARGET_STOPPED_BY_SINGLE_STEP
> };
>
> -/* Prototypes */
> -
> -/* Return a pretty printed form of target_waitstatus. */
> -std::string target_waitstatus_to_string (const struct target_waitstatus *);
> -
> #endif /* TARGET_WAITSTATUS_H */
> diff --git a/gdbserver/linux-low.cc b/gdbserver/linux-low.cc
> index 34ede238d19..d214aff7051 100644
> --- a/gdbserver/linux-low.cc
> +++ b/gdbserver/linux-low.cc
> @@ -3445,13 +3445,9 @@ linux_process_target::wait_1 (ptid_t ptid, target_waitstatus *ourstatus,
> if (debug_threads)
> {
> if (event_child->waitstatus.kind () != TARGET_WAITKIND_IGNORE)
> - {
> - std::string str
> - = target_waitstatus_to_string (&event_child->waitstatus);
> -
> - debug_printf ("LWP %ld: extended event with waitstatus %s\n",
> - lwpid_of (get_lwp_thread (event_child)), str.c_str ());
> - }
> + debug_printf ("LWP %ld: extended event with waitstatus %s\n",
> + lwpid_of (get_lwp_thread (event_child)),
> + event_child->waitstatus.to_string ().c_str ());
> if (current_thread->last_resume_kind == resume_step)
> {
> if (event_child->step_range_start == event_child->step_range_end)
> diff --git a/gdbserver/server.cc b/gdbserver/server.cc
> index c58f7e01d8d..2807525d11c 100644
> --- a/gdbserver/server.cc
> +++ b/gdbserver/server.cc
> @@ -3305,14 +3305,9 @@ queue_stop_reply_callback (thread_info *thread)
> if (target_thread_stopped (thread))
> {
> if (debug_threads)
> - {
> - std::string status_string
> - = target_waitstatus_to_string (&thread->last_status);
> -
> - debug_printf ("Reporting thread %s as already stopped with %s\n",
> - target_pid_to_str (thread->id).c_str (),
> - status_string.c_str ());
> - }
> + debug_printf ("Reporting thread %s as already stopped with %s\n",
> + target_pid_to_str (thread->id).c_str (),
> + thread->last_status.to_string ().c_str ());
>
> gdb_assert (thread->last_status.kind () != TARGET_WAITKIND_IGNORE);
>
> --
> 2.33.1
>
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH 2/3] gdb: introduce target_waitkind_str, use it in target_waitstatus::to_string
2021-11-22 16:27 ` [PATCH 2/3] gdb: introduce target_waitkind_str, use it in target_waitstatus::to_string Simon Marchi
@ 2021-11-22 18:53 ` Andrew Burgess
2021-11-25 14:38 ` Vaseeharan Vinayagamoorthy
1 sibling, 0 replies; 9+ messages in thread
From: Andrew Burgess @ 2021-11-22 18:53 UTC (permalink / raw)
To: Simon Marchi; +Cc: gdb-patches
* Simon Marchi via Gdb-patches <gdb-patches@sourceware.org> [2021-11-22 11:27:30 -0500]:
> I would like to print target_waitkind values in debug messages, so I
> think that a target_waitkind-to-string function would be useful. While
> at it, use it in target_waitstatus::to_string. This changes the output
> of target_waitstatus::to_string a bit, but I think it is for the better.
> The debug messages will show a string matching exactly the
> target_waitkind enumerator (minus the TARGET_WAITKIND prefix).
>
> As a convenience, make string_appendf return the same reference to
> string it got as a parameter. This allows doing this:
>
> return string_appendf (str, "foo");
>
> ... keeping the code concise.
LGTM.
Thanks,
Andrew
>
> Change-Id: I383dffc9c78614e7d0668b1516073905e798eef7
> ---
> gdb/target/waitstatus.c | 66 +++++++++-----------------
> gdb/target/waitstatus.h | 49 +++++++++++++++++++
> gdb/unittests/common-utils-selftests.c | 7 ++-
> gdbsupport/common-utils.cc | 8 +++-
> gdbsupport/common-utils.h | 4 +-
> 5 files changed, 84 insertions(+), 50 deletions(-)
>
> diff --git a/gdb/target/waitstatus.c b/gdb/target/waitstatus.c
> index 2293d83230d..a7209e3f2b7 100644
> --- a/gdb/target/waitstatus.c
> +++ b/gdb/target/waitstatus.c
> @@ -20,73 +20,51 @@
> #include "gdbsupport/common-defs.h"
> #include "waitstatus.h"
>
> -/* Return a pretty printed form of target_waitstatus. */
> +/* See waitstatus.h. */
>
> std::string
> target_waitstatus::to_string () const
> {
> - const char *kind_str = "status->kind = ";
> + std::string str = string_printf
> + ("status->kind = %s", target_waitkind_str (this->kind ()));
>
> +/* Make sure the compiler warns if a new TARGET_WAITKIND enumerator is added
> + but not handled here. */
> +#pragma GCC diagnostic push
> +#pragma GCC diagnostic error "-Wswitch"
> switch (this->kind ())
> {
> case TARGET_WAITKIND_EXITED:
> - return string_printf ("%sexited, status = %d",
> - kind_str, this->exit_status ());
> + case TARGET_WAITKIND_THREAD_EXITED:
> + return string_appendf (str, ", exit_status = %d", this->exit_status ());
>
> case TARGET_WAITKIND_STOPPED:
> - return string_printf ("%sstopped, signal = %s",
> - kind_str,
> - gdb_signal_to_symbol_string (this->sig ()));
> -
> case TARGET_WAITKIND_SIGNALLED:
> - return string_printf ("%ssignalled, signal = %s",
> - kind_str,
> - gdb_signal_to_symbol_string (this->sig ()));
> -
> - case TARGET_WAITKIND_LOADED:
> - return string_printf ("%sloaded", kind_str);
> + return string_appendf (str, ", sig = %s",
> + gdb_signal_to_symbol_string (this->sig ()));
>
> case TARGET_WAITKIND_FORKED:
> - return string_printf ("%sforked, child_ptid = %s", kind_str,
> - this->child_ptid ().to_string ().c_str ());
> -
> case TARGET_WAITKIND_VFORKED:
> - return string_printf ("%svforked, child_ptid = %s", kind_str,
> - this->child_ptid ().to_string ().c_str ());
> + return string_appendf (str, ", child_ptid = %s",
> + this->child_ptid ().to_string ().c_str ());
>
> case TARGET_WAITKIND_EXECD:
> - return string_printf ("%sexecd, execd_pathname = %s", kind_str,
> - this->execd_pathname ());
> + return string_appendf (str, ", execd_pathname = %s",
> + this->execd_pathname ());
>
> + case TARGET_WAITKIND_LOADED:
> case TARGET_WAITKIND_VFORK_DONE:
> - return string_printf ("%svfork-done", kind_str);
> -
> + case TARGET_WAITKIND_SPURIOUS:
> case TARGET_WAITKIND_SYSCALL_ENTRY:
> - return string_printf ("%sentered syscall", kind_str);
> -
> case TARGET_WAITKIND_SYSCALL_RETURN:
> - return string_printf ("%sexited syscall", kind_str);
> -
> - case TARGET_WAITKIND_SPURIOUS:
> - return string_printf ("%sspurious", kind_str);
> -
> case TARGET_WAITKIND_IGNORE:
> - return string_printf ("%signore", kind_str);
> -
> case TARGET_WAITKIND_NO_HISTORY:
> - return string_printf ("%sno-history", kind_str);
> -
> case TARGET_WAITKIND_NO_RESUMED:
> - return string_printf ("%sno-resumed", kind_str);
> -
> case TARGET_WAITKIND_THREAD_CREATED:
> - return string_printf ("%sthread created", kind_str);
> -
> - case TARGET_WAITKIND_THREAD_EXITED:
> - return string_printf ("%sthread exited, status = %d",
> - kind_str, this->exit_status ());
> -
> - default:
> - return string_printf ("%sunknown???", kind_str);
> + return str;
> }
> +#pragma GCC diagnostic pop
> +
> + gdb_assert_not_reached ("invalid target_waitkind value: %d",
> + (int) this->kind ());
> }
> diff --git a/gdb/target/waitstatus.h b/gdb/target/waitstatus.h
> index f5b050b8b82..48405d222f4 100644
> --- a/gdb/target/waitstatus.h
> +++ b/gdb/target/waitstatus.h
> @@ -101,6 +101,55 @@ enum target_waitkind
> TARGET_WAITKIND_THREAD_EXITED,
> };
>
> +/* Return KIND as a string. */
> +
> +static inline const char *
> +target_waitkind_str (target_waitkind kind)
> +{
> +/* Make sure the compiler warns if a new TARGET_WAITKIND enumerator is added
> + but not handled here. */
> +#pragma GCC diagnostic push
> +#pragma GCC diagnostic error "-Wswitch"
> + switch (kind)
> + {
> + case TARGET_WAITKIND_EXITED:
> + return "EXITED";
> + case TARGET_WAITKIND_STOPPED:
> + return "STOPPED";
> + case TARGET_WAITKIND_SIGNALLED:
> + return "SIGNALLED";
> + case TARGET_WAITKIND_LOADED:
> + return "LOADED";
> + case TARGET_WAITKIND_FORKED:
> + return "FORKED";
> + case TARGET_WAITKIND_VFORKED:
> + return "VFORKED";
> + case TARGET_WAITKIND_EXECD:
> + return "EXECD";
> + case TARGET_WAITKIND_VFORK_DONE:
> + return "VFORK_DONE";
> + case TARGET_WAITKIND_SYSCALL_ENTRY:
> + return "SYSCALL_ENTRY";
> + case TARGET_WAITKIND_SYSCALL_RETURN:
> + return "SYSCALL_RETURN";
> + case TARGET_WAITKIND_SPURIOUS:
> + return "SPURIOUS";
> + case TARGET_WAITKIND_IGNORE:
> + return "IGNORE";
> + case TARGET_WAITKIND_NO_HISTORY:
> + return "NO_HISTORY";
> + case TARGET_WAITKIND_NO_RESUMED:
> + return "NO_RESUMED";
> + case TARGET_WAITKIND_THREAD_CREATED:
> + return "THREAD_CREATED";
> + case TARGET_WAITKIND_THREAD_EXITED:
> + return "THREAD_EXITED";
> + };
> +#pragma GCC diagnostic pop
> +
> + gdb_assert_not_reached ("invalid target_waitkind value: %d\n", (int) kind);
> +}
> +
> struct target_waitstatus
> {
> /* Default constructor. */
> diff --git a/gdb/unittests/common-utils-selftests.c b/gdb/unittests/common-utils-selftests.c
> index 26d313fd329..aa0f45241b9 100644
> --- a/gdb/unittests/common-utils-selftests.c
> +++ b/gdb/unittests/common-utils-selftests.c
> @@ -80,7 +80,8 @@ string_vprintf_tests ()
> /* Type of both 'string_appendf' and the 'string_vappendf_wrapper'
> function below. Used to run the same tests against both
> string_appendf and string_vappendf. */
> -typedef void (string_appendf_func) (std::string &str, const char *fmt, ...)
> +typedef std::string &(string_appendf_func) (std::string &str, const char *fmt,
> + ...)
> ATTRIBUTE_PRINTF (2, 3);
>
> static void
> @@ -101,7 +102,7 @@ test_appendf_func (string_appendf_func *func)
> SELF_CHECK (str == "test23foo 45 bar");
> }
>
> -static void ATTRIBUTE_PRINTF (2, 3)
> +static std::string & ATTRIBUTE_PRINTF (2, 3)
> string_vappendf_wrapper (std::string &str, const char *fmt, ...)
> {
> va_list vp;
> @@ -109,6 +110,8 @@ string_vappendf_wrapper (std::string &str, const char *fmt, ...)
> va_start (vp, fmt);
> string_vappendf (str, fmt, vp);
> va_end (vp);
> +
> + return str;
> }
>
> static void
> diff --git a/gdbsupport/common-utils.cc b/gdbsupport/common-utils.cc
> index 42bce36e535..b591537e62e 100644
> --- a/gdbsupport/common-utils.cc
> +++ b/gdbsupport/common-utils.cc
> @@ -119,7 +119,7 @@ string_vprintf (const char* fmt, va_list args)
>
> /* See documentation in common-utils.h. */
>
> -void
> +std::string &
> string_appendf (std::string &str, const char *fmt, ...)
> {
> va_list vp;
> @@ -127,12 +127,14 @@ string_appendf (std::string &str, const char *fmt, ...)
> va_start (vp, fmt);
> string_vappendf (str, fmt, vp);
> va_end (vp);
> +
> + return str;
> }
>
>
> /* See documentation in common-utils.h. */
>
> -void
> +std::string &
> string_vappendf (std::string &str, const char *fmt, va_list args)
> {
> va_list vp;
> @@ -148,6 +150,8 @@ string_vappendf (std::string &str, const char *fmt, va_list args)
> /* C++11 and later guarantee std::string uses contiguous memory and
> always includes the terminating '\0'. */
> vsprintf (&str[curr_size], fmt, args); /* ARI: vsprintf */
> +
> + return str;
> }
>
> char *
> diff --git a/gdbsupport/common-utils.h b/gdbsupport/common-utils.h
> index af078475780..98a9dc72f36 100644
> --- a/gdbsupport/common-utils.h
> +++ b/gdbsupport/common-utils.h
> @@ -54,11 +54,11 @@ std::string string_vprintf (const char* fmt, va_list args)
>
> /* Like string_printf, but appends to DEST instead of returning a new
> std::string. */
> -void string_appendf (std::string &dest, const char* fmt, ...)
> +std::string &string_appendf (std::string &dest, const char* fmt, ...)
> ATTRIBUTE_PRINTF (2, 3);
>
> /* Like string_appendf, but takes a va_list. */
> -void string_vappendf (std::string &dest, const char* fmt, va_list args)
> +std::string &string_vappendf (std::string &dest, const char* fmt, va_list args)
> ATTRIBUTE_PRINTF (2, 0);
>
> /* Make a copy of the string at PTR with LEN characters
> --
> 2.33.1
>
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH 3/3] gdb: pass more const target_waitstatus by reference
2021-11-22 16:27 ` [PATCH 3/3] gdb: pass more const target_waitstatus by reference Simon Marchi
@ 2021-11-22 18:56 ` Andrew Burgess
2021-11-22 18:58 ` Simon Marchi
0 siblings, 1 reply; 9+ messages in thread
From: Andrew Burgess @ 2021-11-22 18:56 UTC (permalink / raw)
To: Simon Marchi; +Cc: gdb-patches
* 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);
> \f
> /* 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
>
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH 3/3] gdb: pass more const target_waitstatus by reference
2021-11-22 18:56 ` Andrew Burgess
@ 2021-11-22 18:58 ` Simon Marchi
0 siblings, 0 replies; 9+ messages in thread
From: Simon Marchi @ 2021-11-22 18:58 UTC (permalink / raw)
To: Andrew Burgess; +Cc: gdb-patches
On 2021-11-22 1:56 p.m., Andrew Burgess wrote:
> * 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
Thanks, pushed all three patches.
Simon
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH 2/3] gdb: introduce target_waitkind_str, use it in target_waitstatus::to_string
2021-11-22 16:27 ` [PATCH 2/3] gdb: introduce target_waitkind_str, use it in target_waitstatus::to_string Simon Marchi
2021-11-22 18:53 ` Andrew Burgess
@ 2021-11-25 14:38 ` Vaseeharan Vinayagamoorthy
2021-11-25 15:33 ` Simon Marchi
1 sibling, 1 reply; 9+ messages in thread
From: Vaseeharan Vinayagamoorthy @ 2021-11-25 14:38 UTC (permalink / raw)
To: gdb-patches, Simon Marchi
After this commit, I am seeing this error, when using gcc 4.8.5:
gdb/ada-tasks.c:998:10: error: enumeration value ‘ADA_TASKS_UNKNOWN’ not handled in switch [-Werror=switch]
switch (data->known_tasks_kind)
^
The build/host/target setup is:
Build: x86_64 (Linux), using gcc 4.8.5
Host: x86_64 (Linux)
Target: arm-none-eabi / aarch64-none-elf / aarch64_be-none-elf
Kind regards
Vasee
________________________________
From: Gdb-patches <gdb-patches-bounces+vvinayag=arm.com@sourceware.org> on behalf of Simon Marchi via Gdb-patches <gdb-patches@sourceware.org>
Sent: 22 November 2021 16:27
To: gdb-patches@sourceware.org <gdb-patches@sourceware.org>
Cc: Simon Marchi <simon.marchi@efficios.com>
Subject: [PATCH 2/3] gdb: introduce target_waitkind_str, use it in target_waitstatus::to_string
I would like to print target_waitkind values in debug messages, so I
think that a target_waitkind-to-string function would be useful. While
at it, use it in target_waitstatus::to_string. This changes the output
of target_waitstatus::to_string a bit, but I think it is for the better.
The debug messages will show a string matching exactly the
target_waitkind enumerator (minus the TARGET_WAITKIND prefix).
As a convenience, make string_appendf return the same reference to
string it got as a parameter. This allows doing this:
return string_appendf (str, "foo");
... keeping the code concise.
Change-Id: I383dffc9c78614e7d0668b1516073905e798eef7
---
gdb/target/waitstatus.c | 66 +++++++++-----------------
gdb/target/waitstatus.h | 49 +++++++++++++++++++
gdb/unittests/common-utils-selftests.c | 7 ++-
gdbsupport/common-utils.cc | 8 +++-
gdbsupport/common-utils.h | 4 +-
5 files changed, 84 insertions(+), 50 deletions(-)
diff --git a/gdb/target/waitstatus.c b/gdb/target/waitstatus.c
index 2293d83230d..a7209e3f2b7 100644
--- a/gdb/target/waitstatus.c
+++ b/gdb/target/waitstatus.c
@@ -20,73 +20,51 @@
#include "gdbsupport/common-defs.h"
#include "waitstatus.h"
-/* Return a pretty printed form of target_waitstatus. */
+/* See waitstatus.h. */
std::string
target_waitstatus::to_string () const
{
- const char *kind_str = "status->kind = ";
+ std::string str = string_printf
+ ("status->kind = %s", target_waitkind_str (this->kind ()));
+/* Make sure the compiler warns if a new TARGET_WAITKIND enumerator is added
+ but not handled here. */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic error "-Wswitch"
switch (this->kind ())
{
case TARGET_WAITKIND_EXITED:
- return string_printf ("%sexited, status = %d",
- kind_str, this->exit_status ());
+ case TARGET_WAITKIND_THREAD_EXITED:
+ return string_appendf (str, ", exit_status = %d", this->exit_status ());
case TARGET_WAITKIND_STOPPED:
- return string_printf ("%sstopped, signal = %s",
- kind_str,
- gdb_signal_to_symbol_string (this->sig ()));
-
case TARGET_WAITKIND_SIGNALLED:
- return string_printf ("%ssignalled, signal = %s",
- kind_str,
- gdb_signal_to_symbol_string (this->sig ()));
-
- case TARGET_WAITKIND_LOADED:
- return string_printf ("%sloaded", kind_str);
+ return string_appendf (str, ", sig = %s",
+ gdb_signal_to_symbol_string (this->sig ()));
case TARGET_WAITKIND_FORKED:
- return string_printf ("%sforked, child_ptid = %s", kind_str,
- this->child_ptid ().to_string ().c_str ());
-
case TARGET_WAITKIND_VFORKED:
- return string_printf ("%svforked, child_ptid = %s", kind_str,
- this->child_ptid ().to_string ().c_str ());
+ return string_appendf (str, ", child_ptid = %s",
+ this->child_ptid ().to_string ().c_str ());
case TARGET_WAITKIND_EXECD:
- return string_printf ("%sexecd, execd_pathname = %s", kind_str,
- this->execd_pathname ());
+ return string_appendf (str, ", execd_pathname = %s",
+ this->execd_pathname ());
+ case TARGET_WAITKIND_LOADED:
case TARGET_WAITKIND_VFORK_DONE:
- return string_printf ("%svfork-done", kind_str);
-
+ case TARGET_WAITKIND_SPURIOUS:
case TARGET_WAITKIND_SYSCALL_ENTRY:
- return string_printf ("%sentered syscall", kind_str);
-
case TARGET_WAITKIND_SYSCALL_RETURN:
- return string_printf ("%sexited syscall", kind_str);
-
- case TARGET_WAITKIND_SPURIOUS:
- return string_printf ("%sspurious", kind_str);
-
case TARGET_WAITKIND_IGNORE:
- return string_printf ("%signore", kind_str);
-
case TARGET_WAITKIND_NO_HISTORY:
- return string_printf ("%sno-history", kind_str);
-
case TARGET_WAITKIND_NO_RESUMED:
- return string_printf ("%sno-resumed", kind_str);
-
case TARGET_WAITKIND_THREAD_CREATED:
- return string_printf ("%sthread created", kind_str);
-
- case TARGET_WAITKIND_THREAD_EXITED:
- return string_printf ("%sthread exited, status = %d",
- kind_str, this->exit_status ());
-
- default:
- return string_printf ("%sunknown???", kind_str);
+ return str;
}
+#pragma GCC diagnostic pop
+
+ gdb_assert_not_reached ("invalid target_waitkind value: %d",
+ (int) this->kind ());
}
diff --git a/gdb/target/waitstatus.h b/gdb/target/waitstatus.h
index f5b050b8b82..48405d222f4 100644
--- a/gdb/target/waitstatus.h
+++ b/gdb/target/waitstatus.h
@@ -101,6 +101,55 @@ enum target_waitkind
TARGET_WAITKIND_THREAD_EXITED,
};
+/* Return KIND as a string. */
+
+static inline const char *
+target_waitkind_str (target_waitkind kind)
+{
+/* Make sure the compiler warns if a new TARGET_WAITKIND enumerator is added
+ but not handled here. */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic error "-Wswitch"
+ switch (kind)
+ {
+ case TARGET_WAITKIND_EXITED:
+ return "EXITED";
+ case TARGET_WAITKIND_STOPPED:
+ return "STOPPED";
+ case TARGET_WAITKIND_SIGNALLED:
+ return "SIGNALLED";
+ case TARGET_WAITKIND_LOADED:
+ return "LOADED";
+ case TARGET_WAITKIND_FORKED:
+ return "FORKED";
+ case TARGET_WAITKIND_VFORKED:
+ return "VFORKED";
+ case TARGET_WAITKIND_EXECD:
+ return "EXECD";
+ case TARGET_WAITKIND_VFORK_DONE:
+ return "VFORK_DONE";
+ case TARGET_WAITKIND_SYSCALL_ENTRY:
+ return "SYSCALL_ENTRY";
+ case TARGET_WAITKIND_SYSCALL_RETURN:
+ return "SYSCALL_RETURN";
+ case TARGET_WAITKIND_SPURIOUS:
+ return "SPURIOUS";
+ case TARGET_WAITKIND_IGNORE:
+ return "IGNORE";
+ case TARGET_WAITKIND_NO_HISTORY:
+ return "NO_HISTORY";
+ case TARGET_WAITKIND_NO_RESUMED:
+ return "NO_RESUMED";
+ case TARGET_WAITKIND_THREAD_CREATED:
+ return "THREAD_CREATED";
+ case TARGET_WAITKIND_THREAD_EXITED:
+ return "THREAD_EXITED";
+ };
+#pragma GCC diagnostic pop
+
+ gdb_assert_not_reached ("invalid target_waitkind value: %d\n", (int) kind);
+}
+
struct target_waitstatus
{
/* Default constructor. */
diff --git a/gdb/unittests/common-utils-selftests.c b/gdb/unittests/common-utils-selftests.c
index 26d313fd329..aa0f45241b9 100644
--- a/gdb/unittests/common-utils-selftests.c
+++ b/gdb/unittests/common-utils-selftests.c
@@ -80,7 +80,8 @@ string_vprintf_tests ()
/* Type of both 'string_appendf' and the 'string_vappendf_wrapper'
function below. Used to run the same tests against both
string_appendf and string_vappendf. */
-typedef void (string_appendf_func) (std::string &str, const char *fmt, ...)
+typedef std::string &(string_appendf_func) (std::string &str, const char *fmt,
+ ...)
ATTRIBUTE_PRINTF (2, 3);
static void
@@ -101,7 +102,7 @@ test_appendf_func (string_appendf_func *func)
SELF_CHECK (str == "test23foo 45 bar");
}
-static void ATTRIBUTE_PRINTF (2, 3)
+static std::string & ATTRIBUTE_PRINTF (2, 3)
string_vappendf_wrapper (std::string &str, const char *fmt, ...)
{
va_list vp;
@@ -109,6 +110,8 @@ string_vappendf_wrapper (std::string &str, const char *fmt, ...)
va_start (vp, fmt);
string_vappendf (str, fmt, vp);
va_end (vp);
+
+ return str;
}
static void
diff --git a/gdbsupport/common-utils.cc b/gdbsupport/common-utils.cc
index 42bce36e535..b591537e62e 100644
--- a/gdbsupport/common-utils.cc
+++ b/gdbsupport/common-utils.cc
@@ -119,7 +119,7 @@ string_vprintf (const char* fmt, va_list args)
/* See documentation in common-utils.h. */
-void
+std::string &
string_appendf (std::string &str, const char *fmt, ...)
{
va_list vp;
@@ -127,12 +127,14 @@ string_appendf (std::string &str, const char *fmt, ...)
va_start (vp, fmt);
string_vappendf (str, fmt, vp);
va_end (vp);
+
+ return str;
}
/* See documentation in common-utils.h. */
-void
+std::string &
string_vappendf (std::string &str, const char *fmt, va_list args)
{
va_list vp;
@@ -148,6 +150,8 @@ string_vappendf (std::string &str, const char *fmt, va_list args)
/* C++11 and later guarantee std::string uses contiguous memory and
always includes the terminating '\0'. */
vsprintf (&str[curr_size], fmt, args); /* ARI: vsprintf */
+
+ return str;
}
char *
diff --git a/gdbsupport/common-utils.h b/gdbsupport/common-utils.h
index af078475780..98a9dc72f36 100644
--- a/gdbsupport/common-utils.h
+++ b/gdbsupport/common-utils.h
@@ -54,11 +54,11 @@ std::string string_vprintf (const char* fmt, va_list args)
/* Like string_printf, but appends to DEST instead of returning a new
std::string. */
-void string_appendf (std::string &dest, const char* fmt, ...)
+std::string &string_appendf (std::string &dest, const char* fmt, ...)
ATTRIBUTE_PRINTF (2, 3);
/* Like string_appendf, but takes a va_list. */
-void string_vappendf (std::string &dest, const char* fmt, va_list args)
+std::string &string_vappendf (std::string &dest, const char* fmt, va_list args)
ATTRIBUTE_PRINTF (2, 0);
/* Make a copy of the string at PTR with LEN characters
--
2.33.1
^ permalink raw reply [flat|nested] 9+ messages in thread
* Re: [PATCH 2/3] gdb: introduce target_waitkind_str, use it in target_waitstatus::to_string
2021-11-25 14:38 ` Vaseeharan Vinayagamoorthy
@ 2021-11-25 15:33 ` Simon Marchi
0 siblings, 0 replies; 9+ messages in thread
From: Simon Marchi @ 2021-11-25 15:33 UTC (permalink / raw)
To: Vaseeharan Vinayagamoorthy, gdb-patches, Simon Marchi
On 2021-11-25 9:38 a.m., Vaseeharan Vinayagamoorthy via Gdb-patches wrote:
> After this commit, I am seeing this error, when using gcc 4.8.5:
> gdb/ada-tasks.c:998:10: error: enumeration value ‘ADA_TASKS_UNKNOWN’ not handled in switch [-Werror=switch]
> switch (data->known_tasks_kind)
> ^
>
> The build/host/target setup is:
> Build: x86_64 (Linux), using gcc 4.8.5
> Host: x86_64 (Linux)
> Target: arm-none-eabi / aarch64-none-elf / aarch64_be-none-elf
This would be fixed by this patch series, but it's waiting for review:
https://sourceware.org/pipermail/gdb-patches/2021-November/183732.html
Simon
^ permalink raw reply [flat|nested] 9+ messages in thread
end of thread, other threads:[~2021-11-25 15:33 UTC | newest]
Thread overview: 9+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2021-11-22 16:27 [PATCH 1/3] gdb: rename target_waitstatus_to_string to target_waitstatus::to_string Simon Marchi
2021-11-22 16:27 ` [PATCH 2/3] gdb: introduce target_waitkind_str, use it in target_waitstatus::to_string Simon Marchi
2021-11-22 18:53 ` Andrew Burgess
2021-11-25 14:38 ` Vaseeharan Vinayagamoorthy
2021-11-25 15:33 ` Simon Marchi
2021-11-22 16:27 ` [PATCH 3/3] gdb: pass more const target_waitstatus by reference Simon Marchi
2021-11-22 18:56 ` Andrew Burgess
2021-11-22 18:58 ` Simon Marchi
2021-11-22 18:48 ` [PATCH 1/3] gdb: rename target_waitstatus_to_string to target_waitstatus::to_string 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).