Add pretty-printer for wait(2) statuses and modernize the code handling them

[labath]

Summary

A number of places were trying to decode the result of wait(). Add a simple
utility function that does that and a struct that encapsulates the
decoded result. Then also provide a pretty-printer for that class.

[labath]

Fix typo

[krytarowski]

source/Host/common/Host.cpp

1001 ↗

(On Diff #101758)

WIFCONTINUED()?

[labath]

source/Host/common/Host.cpp

1001 ↗

(On Diff #101758)

I'm deliberately ignoring that, as we don't have a use for it yet. On linux you have to pass the a special flag to waitpid to receive those notifications, and we don't do that. Does it work the same way on netbsd? If it possible to get those during normal interaction (without WCONTINUED), then I need to add it (and probably netbsd code needs to handle it), but otherwise I propose to skip it for the time being.

[krytarowski]

source/Host/common/Host.cpp

1001 ↗

(On Diff #101758)

I see, we need WCONTINUED too. We can skip it now.

[krytarowski]

NetBSD part looks fine.

[eugene]

source/Host/common/Host.cpp

1010 ↗

(On Diff #101759)

type[WS.type] seems to be a somewhat unnecessary hack. I would use a simple switch here.

1017 ↗

(On Diff #101759)

Same as above.

[labath]

source/Host/common/Host.cpp

1010 ↗

(On Diff #101759)

I wouldn't call it a hack. :) More like data-oriented programming... :P
I wrote it like this because fully
clang-formatted
switches
tend
to
be
loooooong
.

But I don't care about it too much.

[labath]

Use a switch instead of indexing the array with an enum value

lldb/trunk/include/lldb/Host/Host.h

 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 class FileAction;
 class ProcessLaunchInfo;
 
 //----------------------------------------------------------------------
+// Exit Type for inferior processes
+//----------------------------------------------------------------------
+struct WaitStatus {
+  enum Type : uint8_t {
+    Exit,   // The status represents the return code from normal
+            // program exit (i.e. WIFEXITED() was true)
+    Signal, // The status represents the signal number that caused
+            // the program to exit (i.e. WIFSIGNALED() was true)
+    Stop,   // The status represents the signal number that caused the
+            // program to stop (i.e. WIFSTOPPED() was true)
+  };
+
+  Type type;
+  uint8_t status;
+
+  WaitStatus(Type type, uint8_t status) : type(type), status(status) {}
+
+  static WaitStatus Decode(int wstatus);
+};
+
+//----------------------------------------------------------------------
 /// @class Host Host.h "lldb/Host/Host.h"
 /// @brief A class that provides host computer information.
 ///
 /// Host is a class that answers information about the host operating
 /// system.
 //----------------------------------------------------------------------
 class Host {
 public:
public:
   static bool OpenFileInExternalEditor(const FileSpec &file_spec,
                                        uint32_t line_no);
 
   static size_t GetEnvironment(StringList &env);
 };
 
 } // namespace lldb_private
 
+namespace llvm {
+template <> struct format_provider<lldb_private::WaitStatus> {
+  /// Options = "" gives a human readable description of the status
+  /// Options = "g" gives a gdb-remote protocol status (e.g., X09)
+  static void format(const lldb_private::WaitStatus &WS, raw_ostream &OS,
+                     llvm::StringRef Options);
+};
+} // namespace llvm
+
 #endif // #if defined(__cplusplus)
 #endif // liblldb_Host_h_

lldb/trunk/include/lldb/Host/common/NativeProcessProtocol.h

 //===-- NativeProcessProtocol.h ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_NativeProcessProtocol_h_
 #define liblldb_NativeProcessProtocol_h_
 
 #include "lldb/Core/TraceOptions.h"
+#include "lldb/Host/Host.h"
 #include "lldb/Host/MainLoop.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-types.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/MemoryBuffer.h"
public:
   bool GetByteOrder(lldb::ByteOrder &byte_order) const;
 
   virtual llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
   GetAuxvData() const = 0;
 
   //----------------------------------------------------------------------
   // Exit Status
   //----------------------------------------------------------------------
-  virtual bool GetExitStatus(lldb_private::ExitType *exit_type, int *status,
-                             std::string &exit_description);
+  virtual llvm::Optional<WaitStatus> GetExitStatus();
 
-  virtual bool SetExitStatus(lldb_private::ExitType exit_type, int status,
-                             const char *exit_description,
-                             bool bNotifyStateChange);
+  virtual bool SetExitStatus(WaitStatus status, bool bNotifyStateChange);
 
   //----------------------------------------------------------------------
   // Access to threads
   //----------------------------------------------------------------------
   NativeThreadProtocolSP GetThreadAtIndex(uint32_t idx);
 
   NativeThreadProtocolSP GetThreadByID(lldb::tid_t tid);
 
protected:
 
   std::vector<NativeThreadProtocolSP> m_threads;
   lldb::tid_t m_current_thread_id;
   mutable std::recursive_mutex m_threads_mutex;
 
   lldb::StateType m_state;
   mutable std::recursive_mutex m_state_mutex;
 
-  lldb_private::ExitType m_exit_type;
-  int m_exit_status;
-  std::string m_exit_description;
+  llvm::Optional<WaitStatus> m_exit_status;
+
   std::recursive_mutex m_delegates_mutex;
   std::vector<NativeDelegate *> m_delegates;
   NativeBreakpointList m_breakpoint_list;
   NativeWatchpointList m_watchpoint_list;
   HardwareBreakpointMap m_hw_breakpoints_map;
   int m_terminal_fd;
   uint32_t m_stop_id;
 

lldb/trunk/include/lldb/lldb-private-enumerations.h

Success, // The line that was just edited if good and should be added to the
            // lines
   Status,  // There is an error with the current line and it needs to be
            // re-edited
            // before it can be accepted
   Done     // Lines are complete
 };
 
 //----------------------------------------------------------------------
-// Exit Type for inferior processes
-//----------------------------------------------------------------------
-typedef enum ExitType {
-  eExitTypeInvalid,
-  eExitTypeExit,   // The exit status represents the return code from normal
-                   // program exit (i.e. WIFEXITED() was true)
-  eExitTypeSignal, // The exit status represents the signal number that caused
-                   // the program to exit (i.e. WIFSIGNALED() was true)
-  eExitTypeStop,   // The exit status represents the stop signal that caused the
-                   // program to exit (i.e. WIFSTOPPED() was true)
-} ExitType;
-
-//----------------------------------------------------------------------
 // Boolean result of running a Type Validator
 //----------------------------------------------------------------------
 enum class TypeValidatorResult : bool { Success = true, Failure = false };
 
 //----------------------------------------------------------------------
 // Enumerations that can be used to specify scopes types when looking up
 // types.
 //----------------------------------------------------------------------

lldb/trunk/source/Host/common/Host.cpp

 #include "lldb/Target/UnixSignals.h"
 #include "lldb/Utility/CleanUp.h"
 #include "lldb/Utility/DataBufferLLVM.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private-forward.h"
 #include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/FileSystem.h"
 
 #if defined(_WIN32)
 #include "lldb/Host/windows/ProcessLauncherWindows.h"
 #else
 #include "lldb/Host/posix/ProcessLauncherPosixFork.h"
 #endif

 
 #endif
 
 const UnixSignalsSP &Host::GetUnixSignals() {
   static const auto s_unix_signals_sp =
       UnixSignals::Create(HostInfo::GetArchitecture());
   return s_unix_signals_sp;
 }
+
+#if defined(LLVM_ON_UNIX)
+WaitStatus WaitStatus::Decode(int wstatus) {
+  if (WIFEXITED(wstatus))
+    return {Exit, uint8_t(WEXITSTATUS(wstatus))};
+  else if (WIFSIGNALED(wstatus))
+    return {Signal, uint8_t(WTERMSIG(wstatus))};
+  else if (WIFSTOPPED(wstatus))
+    return {Stop, uint8_t(WSTOPSIG(wstatus))};
+  llvm_unreachable("Unknown wait status");
+}
+#endif
+
+void llvm::format_provider<WaitStatus>::format(const WaitStatus &WS,
+                                               raw_ostream &OS,
+                                               StringRef Options) {
+  if (Options == "g") {
+    char type;
+    switch (WS.type) {
+    case WaitStatus::Exit:
+      type = 'W';
+      break;
+    case WaitStatus::Signal:
+      type = 'X';
+      break;
+    case WaitStatus::Stop:
+      type = 'S';
+      break;
+    }
+    OS << formatv("{0}{1:x-2}", type, WS.status);
+    return;
+  }
+
+  assert(Options.empty());
+  const char *desc;
+  switch(WS.type) {
+  case WaitStatus::Exit:
+    desc = "Exited with status";
+    break;
+  case WaitStatus::Signal:
+    desc = "Killed by signal";
+    break;
+  case WaitStatus::Stop:
+    desc = "Stopped by signal";
+    break;
+  }
+  OS << desc << " " << int(WS.status);
+}

lldb/trunk/source/Host/common/NativeProcessProtocol.cpp

 
 // -----------------------------------------------------------------------------
 // NativeProcessProtocol Members
 // -----------------------------------------------------------------------------
 
 NativeProcessProtocol::NativeProcessProtocol(lldb::pid_t pid)
     : m_pid(pid), m_threads(), m_current_thread_id(LLDB_INVALID_THREAD_ID),
       m_threads_mutex(), m_state(lldb::eStateInvalid), m_state_mutex(),
-      m_exit_type(eExitTypeInvalid), m_exit_status(0), m_exit_description(),
       m_delegates_mutex(), m_delegates(), m_breakpoint_list(),
       m_watchpoint_list(), m_terminal_fd(-1), m_stop_id(0) {}
 
 lldb_private::Status NativeProcessProtocol::Interrupt() {
   Status error;
 #if !defined(SIGSTOP)
   error.SetErrorString("local host does not support signaling");
   return error;

 
 lldb_private::Status
 NativeProcessProtocol::GetMemoryRegionInfo(lldb::addr_t load_addr,
                                            MemoryRegionInfo &range_info) {
   // Default: not implemented.
   return Status("not implemented");
 }
 
-bool NativeProcessProtocol::GetExitStatus(ExitType *exit_type, int *status,
-                                          std::string &exit_description) {
-  if (m_state == lldb::eStateExited) {
-    *exit_type = m_exit_type;
-    *status = m_exit_status;
-    exit_description = m_exit_description;
-    return true;
-  }
+llvm::Optional<WaitStatus> NativeProcessProtocol::GetExitStatus() {
+  if (m_state == lldb::eStateExited)
+    return m_exit_status;
 
-  *status = 0;
-  return false;
+  return llvm::None;
 }
 
-bool NativeProcessProtocol::SetExitStatus(ExitType exit_type, int status,
-                                          const char *exit_description,
+bool NativeProcessProtocol::SetExitStatus(WaitStatus status,
                                           bool bNotifyStateChange) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
-  if (log)
-    log->Printf("NativeProcessProtocol::%s(%d, %d, %s, %s) called",
-                __FUNCTION__, exit_type, status,
-                exit_description ? exit_description : "nullptr",
-                bNotifyStateChange ? "true" : "false");
+  LLDB_LOG(log, "status = {0}, notify = {1}", status, bNotifyStateChange);
 
   // Exit status already set
   if (m_state == lldb::eStateExited) {
-    if (log)
-      log->Printf("NativeProcessProtocol::%s exit status already set to %d, "
-                  "ignoring new set to %d",
-                  __FUNCTION__, m_exit_status, status);
+    if (m_exit_status)
+      LLDB_LOG(log, "exit status already set to {0}", *m_exit_status);
+    else
+      LLDB_LOG(log, "state is exited, but status not set");
     return false;
   }
 
   m_state = lldb::eStateExited;
-
-  m_exit_type = exit_type;
   m_exit_status = status;
-  if (exit_description && exit_description[0])
-    m_exit_description = exit_description;
-  else
-    m_exit_description.clear();
 
   if (bNotifyStateChange)
     SynchronouslyNotifyProcessStateChanged(lldb::eStateExited);
 
   return true;
 }
 
 NativeThreadProtocolSP NativeProcessProtocol::GetThreadAtIndex(uint32_t idx) {

lldb/trunk/source/Plugins/Process/Darwin/NativeProcessDarwin.cpp

Status NativeProcessDarwin::HandleWaitpidResult() {
   size_t bytes_read = 0;
   error = m_waitpid_pipe.Read(&pid, sizeof(pid), bytes_read);
   if (error.Fail() || (bytes_read < sizeof(pid))) {
     if (log)
       log->Printf("NativeProcessDarwin::%s() - failed to read "
                   "waitpid exiting pid from the pipe.  Will notify "
                   "as if parent process died with exit status -1.",
                   __FUNCTION__);
-    SetExitStatus(eExitTypeInvalid, -1, "failed to receive waitpid result",
-                  notify_status);
+    SetExitStatus(WaitStatus(WaitStatus::Exit, -1), notify_status);
     return error;
   }
 
   // Read the status.
   int status = -1;
   error = m_waitpid_pipe.Read(&status, sizeof(status), bytes_read);
   if (error.Fail() || (bytes_read < sizeof(status))) {
     if (log)
       log->Printf("NativeProcessDarwin::%s() - failed to read "
                   "waitpid exit status from the pipe.  Will notify "
                   "as if parent process died with exit status -1.",
                   __FUNCTION__);
-    SetExitStatus(eExitTypeInvalid, -1, "failed to receive waitpid result",
-                  notify_status);
+    SetExitStatus(WaitStatus(WaitStatus::Exit, -1), notify_status);
     return error;
   }
 
   // Notify the monitor that our state has changed.
   if (log)
     log->Printf("NativeProcessDarwin::%s(): main loop received waitpid "
                 "exit status info: pid=%i (%s), status=%i",
                 __FUNCTION__, pid,
                 (pid == m_pid) ? "the inferior" : "not the inferior", status);
 
-  ExitType exit_type = eExitTypeInvalid;
-  int exit_status = -1;
-
-  if (WIFEXITED(status)) {
-    exit_type = eExitTypeExit;
-    exit_status = WEXITSTATUS(status);
-  } else if (WIFSIGNALED(status)) {
-    exit_type = eExitTypeSignal;
-    exit_status = WTERMSIG(status);
-  }
-
-  SetExitStatus(exit_type, exit_status, nullptr, notify_status);
+  SetExitStatus(WaitStatus::Decode(status), notify_status);
   return error;
 }
 
 task_t NativeProcessDarwin::TaskPortForProcessID(Status &error,
                                                  bool force) const {
   if ((m_task == TASK_NULL) || force) {
     Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
     if (m_pid == LLDB_INVALID_PROCESS_ID) {

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.h

private:
   void AttachToInferior(MainLoop &mainloop, lldb::pid_t pid, Status &error);
 
   ::pid_t Attach(lldb::pid_t pid, Status &error);
 
   static Status SetDefaultPtraceOpts(const lldb::pid_t);
 
   static void *MonitorThread(void *baton);
 
-  void MonitorCallback(lldb::pid_t pid, bool exited, int signal, int status);
+  void MonitorCallback(lldb::pid_t pid, bool exited, WaitStatus status);
 
   void WaitForNewThread(::pid_t tid);
 
   void MonitorSIGTRAP(const siginfo_t &info, NativeThreadLinux &thread);
 
   void MonitorTrace(NativeThreadLinux &thread);
 
   void MonitorBreakpoint(NativeThreadLinux &thread);

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

Status NativeProcessLinux::SetDefaultPtraceOpts(lldb::pid_t pid) {
 
   // Have the tracer notify us before execve returns
   // (needed to disable legacy SIGTRAP generation)
   ptrace_opts |= PTRACE_O_TRACEEXEC;
 
   return PtraceWrapper(PTRACE_SETOPTIONS, pid, nullptr, (void *)ptrace_opts);
 }
 
-static ExitType convert_pid_status_to_exit_type(int status) {
-  if (WIFEXITED(status))
-    return ExitType::eExitTypeExit;
-  else if (WIFSIGNALED(status))
-    return ExitType::eExitTypeSignal;
-  else if (WIFSTOPPED(status))
-    return ExitType::eExitTypeStop;
-  else {
-    // We don't know what this is.
-    return ExitType::eExitTypeInvalid;
-  }
-}
-
-static int convert_pid_status_to_return_code(int status) {
-  if (WIFEXITED(status))
-    return WEXITSTATUS(status);
-  else if (WIFSIGNALED(status))
-    return WTERMSIG(status);
-  else if (WIFSTOPPED(status))
-    return WSTOPSIG(status);
-  else {
-    // We don't know what this is.
-    return ExitType::eExitTypeInvalid;
-  }
-}
-
 // Handles all waitpid events from the inferior process.
 void NativeProcessLinux::MonitorCallback(lldb::pid_t pid, bool exited,
-                                         int signal, int status) {
+                                         WaitStatus status) {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   // Certain activities differ based on whether the pid is the tid of the main
   // thread.
   const bool is_main_thread = (pid == GetID());
 
   // Handle when the thread exits.
   if (exited) {
if (is_main_thread) {
             log,
             "tid = {0} handling main thread exit ({1}), expected exit state "
             "already set but state was {2} instead, setting exit state now",
             pid,
             thread_found ? "stopped tracking thread metadata"
                          : "thread metadata not found",
             GetState());
         // The main thread exited.  We're done monitoring.  Report to delegate.
-        SetExitStatus(convert_pid_status_to_exit_type(status),
-                      convert_pid_status_to_return_code(status), nullptr, true);
+        SetExitStatus(status, true);
 
         // Notify delegate that our process has exited.
         SetState(StateType::eStateExited, true);
       } else
         LLDB_LOG(log, "tid = {0} main thread now exited (%s)", pid,
                  thread_found ? "stopped tracking thread metadata"
                               : "thread metadata not found");
     } else {
if (info_err.GetError() == EINVAL) {
                "GetSignalInfo failed: {0}, tid = {1}, signal = {2}, "
                "status = {3}, main_thread = {4}, thread_found: {5}",
                info_err, pid, signal, status, is_main_thread, thread_found);
 
       if (is_main_thread) {
         // Notify the delegate - our process is not available but appears to
         // have been killed outside
         // our control.  Is eStateExited the right exit state in this case?
-        SetExitStatus(convert_pid_status_to_exit_type(status),
-                      convert_pid_status_to_return_code(status), nullptr, true);
+        SetExitStatus(status, true);
         SetState(StateType::eStateExited, true);
       } else {
         // This thread was pulled out from underneath us.  Anything to do here?
         // Do we want to do an all stop?
         LLDB_LOG(log,
                  "pid {0} tid {1} non-main thread exit occurred, didn't "
                  "tell delegate anything since thread disappeared out "
                  "from underneath us",
if (GetEventMessage(thread.GetID(), &data).Fail())
       data = -1;
 
     LLDB_LOG(log,
              "received PTRACE_EVENT_EXIT, data = {0:x}, WIFEXITED={1}, "
              "WIFSIGNALED={2}, pid = {3}, main_thread = {4}",
              data, WIFEXITED(data), WIFSIGNALED(data), thread.GetID(),
              is_main_thread);
 
-    if (is_main_thread) {
-      SetExitStatus(convert_pid_status_to_exit_type(data),
-                    convert_pid_status_to_return_code(data), nullptr, true);
-    }
+    if (is_main_thread)
+      SetExitStatus(WaitStatus::Decode(data), true);
 
     StateType state = thread.GetState();
     if (!StateIsRunningState(state)) {
       // Due to a kernel bug, we may sometimes get this stop after the inferior
       // gets a
       // SIGKILL. This confuses our state tracking logic in ResumeThread(),
       // since normally,
       // we should not be receiving any ptrace events while the inferior is
if (wait_pid == -1) {
       if (errno == EINTR)
         continue;
 
       Status error(errno, eErrorTypePOSIX);
       LLDB_LOG(log, "waitpid (-1, &status, _) failed: {0}", error);
       break;
     }
 
-    bool exited = false;
-    int signal = 0;
-    int exit_status = 0;
-    const char *status_cstr = nullptr;
-    if (WIFSTOPPED(status)) {
-      signal = WSTOPSIG(status);
-      status_cstr = "STOPPED";
-    } else if (WIFEXITED(status)) {
-      exit_status = WEXITSTATUS(status);
-      status_cstr = "EXITED";
-      exited = true;
-    } else if (WIFSIGNALED(status)) {
-      signal = WTERMSIG(status);
-      status_cstr = "SIGNALED";
-      if (wait_pid == static_cast<::pid_t>(GetID())) {
-        exited = true;
-        exit_status = -1;
-      }
-    } else
-      status_cstr = "(\?\?\?)";
+    WaitStatus wait_status = WaitStatus::Decode(status);
+    bool exited = wait_status.type == WaitStatus::Exit ||
+                  (wait_status.type == WaitStatus::Signal &&
+                   wait_pid == static_cast<::pid_t>(GetID()));
 
-    LLDB_LOG(log,
-             "waitpid (-1, &status, _) => pid = {0}, status = {1:x} "
-             "({2}), signal = {3}, exit_state = {4}",
-             wait_pid, status, status_cstr, signal, exit_status);
+    LLDB_LOG(
+        log,
+        "waitpid (-1, &status, _) => pid = {0}, status = {1}, exited = {2}",
+        wait_pid, wait_status, exited);
 
-    MonitorCallback(wait_pid, exited, signal, exit_status);
+    MonitorCallback(wait_pid, exited, wait_status);
   }
 }
 
 // Wrapper for ptrace to catch errors and log calls.
 // Note that ptrace sets errno on error because -1 can be a valid result (i.e.
 // for PTRACE_PEEK*)
 Status NativeProcessLinux::PtraceWrapper(int req, lldb::pid_t pid, void *addr,
                                          void *data, size_t data_size,

lldb/trunk/source/Plugins/Process/NetBSD/NativeProcessNetBSD.h

private:
   bool HasThreadNoLock(lldb::tid_t thread_id);
 
   NativeThreadNetBSDSP AddThread(lldb::tid_t thread_id);
 
   Status LaunchInferior(MainLoop &mainloop, ProcessLaunchInfo &launch_info);
   void AttachToInferior(MainLoop &mainloop, lldb::pid_t pid, Status &error);
 
   void MonitorCallback(lldb::pid_t pid, int signal);
-  void MonitorExited(lldb::pid_t pid, int signal, int status);
+  void MonitorExited(lldb::pid_t pid, WaitStatus status);
   void MonitorSIGSTOP(lldb::pid_t pid);
   void MonitorSIGTRAP(lldb::pid_t pid);
   void MonitorSignal(lldb::pid_t pid, int signal);
 
   Status GetSoftwareBreakpointPCOffset(uint32_t &actual_opcode_size);
   Status FixupBreakpointPCAsNeeded(NativeThreadNetBSD &thread);
   Status PopulateMemoryRegionCache();
   void SigchldHandler();

lldb/trunk/source/Plugins/Process/NetBSD/NativeProcessNetBSD.cpp

 #include <util.h>
 // clang-format on
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_netbsd;
 using namespace llvm;
 
-static ExitType convert_pid_status_to_exit_type(int status) {
-  if (WIFEXITED(status))
-    return ExitType::eExitTypeExit;
-  else if (WIFSIGNALED(status))
-    return ExitType::eExitTypeSignal;
-  else if (WIFSTOPPED(status))
-    return ExitType::eExitTypeStop;
-  else {
-    // We don't know what this is.
-    return ExitType::eExitTypeInvalid;
-  }
-}
-
-static int convert_pid_status_to_return_code(int status) {
-  if (WIFEXITED(status))
-    return WEXITSTATUS(status);
-  else if (WIFSIGNALED(status))
-    return WTERMSIG(status);
-  else if (WIFSTOPPED(status))
-    return WSTOPSIG(status);
-  else {
-    // We don't know what this is.
-    return ExitType::eExitTypeInvalid;
-  }
-}
-
 // Simple helper function to ensure flags are enabled on the given file
 // descriptor.
 static Status EnsureFDFlags(int fd, int flags) {
   Status error;
 
   int status = fcntl(fd, F_GETFL);
   if (status == -1) {
     error.SetErrorToErrno();
case SIGTRAP:
     return MonitorSIGTRAP(pid);
   case SIGSTOP:
     return MonitorSIGSTOP(pid);
   default:
     return MonitorSignal(pid, signal);
   }
 }
 
-void NativeProcessNetBSD::MonitorExited(lldb::pid_t pid, int signal,
-                                        int status) {
+void NativeProcessNetBSD::MonitorExited(lldb::pid_t pid, WaitStatus status) {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_PROCESS));
 
-  LLDB_LOG(log, "got exit signal({0}) , pid = {1}", signal, pid);
+  LLDB_LOG(log, "got exit signal({0}) , pid = {1}", status, pid);
 
   /* Stop Tracking All Threads attached to Process */
   m_threads.clear();
 
-  SetExitStatus(convert_pid_status_to_exit_type(status),
-                convert_pid_status_to_return_code(status), nullptr, true);
+  SetExitStatus(status, true);
 
   // Notify delegate that our process has exited.
   SetState(StateType::eStateExited, true);
 }
 
 void NativeProcessNetBSD::MonitorSIGSTOP(lldb::pid_t pid) {
   ptrace_siginfo_t info;
 
void NativeProcessNetBSD::SigchldHandler() {
   if (wait_pid == -1) {
     if (errno == EINTR)
       return;
 
     Status error(errno, eErrorTypePOSIX);
     LLDB_LOG(log, "waitpid ({0}, &status, _) failed: {1}", GetID(), error);
   }
 
-  bool exited = false;
-  int signal = 0;
-  int exit_status = 0;
-  const char *status_cstr = nullptr;
-  if (WIFSTOPPED(status)) {
-    signal = WSTOPSIG(status);
-    status_cstr = "STOPPED";
-  } else if (WIFEXITED(status)) {
-    exit_status = WEXITSTATUS(status);
-    status_cstr = "EXITED";
-    exited = true;
-  } else if (WIFSIGNALED(status)) {
-    signal = WTERMSIG(status);
-    status_cstr = "SIGNALED";
-    if (wait_pid == static_cast<::pid_t>(GetID())) {
-      exited = true;
-      exit_status = -1;
-    }
-  } else
-    status_cstr = "(\?\?\?)";
+  WaitStatus wait_status = WaitStatus::Decode(status);
+  bool exited = wait_status.type == WaitStatus::Exit ||
+                (wait_status.type == WaitStatus::Signal &&
+                 wait_pid == static_cast<::pid_t>(GetID()));
 
   LLDB_LOG(log,
-           "waitpid ({0}, &status, _) => pid = {1}, status = {2:x} "
-           "({3}), signal = {4}, exit_state = {5}",
-           GetID(), wait_pid, status, status_cstr, signal, exit_status);
+           "waitpid ({0}, &status, _) => pid = {1}, status = {2}, exited = {3}",
+           GetID(), wait_pid, status, exited);
 
   if (exited)
-    MonitorExited(wait_pid, signal, exit_status);
-  else
-    MonitorCallback(wait_pid, signal);
+    MonitorExited(wait_pid, wait_status);
+  else {
+    assert(wait_status == WaitStatus::Stop);
+    MonitorCallback(wait_pid, wait_status.status);
+  }
 }
 
 bool NativeProcessNetBSD::HasThreadNoLock(lldb::tid_t thread_id) {
   for (auto thread_sp : m_threads) {
     assert(thread_sp && "thread list should not contain NULL threads");
     if (thread_sp->GetID() == thread_id) {
       // We have this thread.
       return true;

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::SendWResponse(
     NativeProcessProtocol *process) {
   assert(process && "process cannot be NULL");
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   // send W notification
-  ExitType exit_type = ExitType::eExitTypeInvalid;
-  int return_code = 0;
-  std::string exit_description;
-
-  const bool got_exit_info =
-      process->GetExitStatus(&exit_type, &return_code, exit_description);
-  if (!got_exit_info) {
-    if (log)
-      log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
-                  ", failed to retrieve process exit status",
-                  __FUNCTION__, process->GetID());
+  auto wait_status = process->GetExitStatus();
+  if (!wait_status) {
+    LLDB_LOG(log, "pid = {0}, failed to retrieve process exit status",
+             process->GetID());
 
     StreamGDBRemote response;
     response.PutChar('E');
     response.PutHex8(GDBRemoteServerError::eErrorExitStatus);
     return SendPacketNoLock(response.GetString());
-  } else {
-    if (log)
-      log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
-                  ", returning exit type %d, return code %d [%s]",
-                  __FUNCTION__, process->GetID(), exit_type, return_code,
-                  exit_description.c_str());
-
-    StreamGDBRemote response;
-
-    char return_type_code;
-    switch (exit_type) {
-    case ExitType::eExitTypeExit:
-      return_type_code = 'W';
-      break;
-    case ExitType::eExitTypeSignal:
-      return_type_code = 'X';
-      break;
-    case ExitType::eExitTypeStop:
-      return_type_code = 'S';
-      break;
-    case ExitType::eExitTypeInvalid:
-      return_type_code = 'E';
-      break;
-    }
-    response.PutChar(return_type_code);
 
-    // POSIX exit status limited to unsigned 8 bits.
-    response.PutHex8(return_code);
+  LLDB_LOG(log, "pid = {0}, returning exit type {1}", process->GetID(),
+           *wait_status);
 
-    return SendPacketNoLock(response.GetString());
-  }
-}
+  StreamGDBRemote response;
+  response.Format("{0:g}", *wait_status);
 
 static void AppendHexValue(StreamString &response, const uint8_t *buf,
                            uint32_t buf_size, bool swap) {
   int64_t i;
   if (swap) {
     for (i = buf_size - 1; i >= 0; i--)
       response.PutHex8(buf[i]);
   } else {

lldb/trunk/unittests/Host/CMakeLists.txt

 set (FILES
   FileSpecTest.cpp
   FileSystemTest.cpp
+  HostTest.cpp
   MainLoopTest.cpp
   SocketAddressTest.cpp
   SocketTest.cpp
   SymbolsTest.cpp
 )
 
 if (CMAKE_SYSTEM_NAME MATCHES "Linux|Android")
   list(APPEND FILES

lldb/trunk/unittests/Host/HostTest.cpp

+//===-- HostTest.cpp --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Host/Host.h"
+#include "gtest/gtest.h"
+
+using namespace lldb_private;
+using namespace llvm;
+
+TEST(Host, WaitStatusFormat) {
+  EXPECT_EQ("W01", formatv("{0:g}", WaitStatus{WaitStatus::Exit, 1}).str());
+  EXPECT_EQ("X02", formatv("{0:g}", WaitStatus{WaitStatus::Signal, 2}).str());
+  EXPECT_EQ("S03", formatv("{0:g}", WaitStatus{WaitStatus::Stop, 3}).str());
+  EXPECT_EQ("Exited with status 4",
+            formatv("{0}", WaitStatus{WaitStatus::Exit, 4}).str());
+}