gdb: rename target_waitstatus_to_string to target_waitstatus::to_string

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

diff --git a/gdb/gnu-nat.c b/gdb/gnu-nat.c
index c6cecff06867a312df04ef92227c0fded7f215ae..216d178424f3afa60d412ea219209253a2222ce2 100644 (file)
--- a/gdb/gnu-nat.c
+++ b/gdb/gnu-nat.c
@@ -1619,7 +1619,7 @@ rewait:
 
   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 89a98c20df435afd63b52fbbbb0578c55cc6c083..dba4f33a327fc577c19a8306247fb65e1910a7b8 100644 (file)
--- 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 a9518d57bcb106fa92d8a56cc82a6b065346a715..3fcfd6a4761c21b69c1465afa663b489db7b452c 100644 (file)
--- 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 5949441bc66c66cef67a304eca5d122369588ce0..c9bc68b78262794659a55c4a2fdb9e2ebeb0cce2 100644 (file)
--- 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 dc3d75eef6e5837f7b21cd127e554c560df5f4ce..2293d83230daaa7248370d145efc7f90856e8811 100644 (file)
--- 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 333863e6d6e5599626d74ea21ee0936642fe5764..f5b050b8b82e9f2e4fb36cb2ef231f1c28fa0047 100644 (file)
--- 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 34ede238d19fb2393e9ea39be7a4e45e4ee36f4b..d214aff7051ef7210edefd1fcb739698dab9089d 100644 (file)
--- 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 c58f7e01d8da910bbed96c6cf5e8f785e11fcb65..2807525d11cf73e073273dccc8c35dadae9a8941 100644 (file)
--- 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);