[NFC] Darwin llgs support from Week of Code

This code represents the Week of Code work I did on bringing up
lldb-server LLGS support for Darwin.  It does not include the
Xcode project changes needed, as we don't want to throw that switch
until more support is implemented (i.e. this change is inert, no
build systems use it yet.  I've verified on Ubuntu 16.04, macOS
Xcode and macOS cmake builds).

This change does some minimal refactoring of code that is shared
with the Linux LLGS portion, moving it from NativeProcessLinux into
NativeProcessProtocol.  That code is also used by NativeProcessDarwin.

Current state on Darwin:
* Process launching is implemented.  (Attach is not).
  Launching on devices has not yet been tested (FBS/BKS might
  need a bit of work).
* Inferior waitpid monitoring and communication of exit status
  via MainLoop callback is implemented.
* Memory read/write, breakpoints, thread register context, etc.
  are not yet implemented.  This impacts process stop/resume, as
  the initial launch suspended immediately starts the process
  up and running because it doesn't know it is supposed to remain
  stopped.
* I implemented the equivalent of MachThreadList as
  NativeThreadListDarwin, in anticipation that we might want to
  factor out common parts into NativeThreadList{Protocol} and share
  some code here.  After writing it, though, the fallout from merging
  Mach Task/Process into a single concept plus some other minor
  changes makes the whole NativeThreadListDarwin concept nothing more
  than dead weight.  I am likely going to get rid of this class and
  just manage it directly in NativeProcessDarwin, much like I did
  for NativeProcessLinux.
* There is a stub-out call for starting a STDIO thread.  That will
  go away and adopt the MainLoop pselect-based IOObject reading.

I am developing the fully-integrated changes in the following repo,
which contains the necessary Xcode bits and the glue that enables
lldb-debugserver on a macOS system:

  https://github.com/tfiala/lldb/tree/llgs-darwin

This change also breaks out a few of the lldb-server tests into
their own directory, and adds some $qHostInfo tests (not sure why
I didn't write those tests back when I initially implemented that
on the Linux side).

llvm-svn: 280604

1 files changed, 163 insertions, 0 deletions

diff --git a/lldb/source/Plugins/Process/Darwin/MachException.h b/lldb/source/Plugins/Process/Darwin/MachException.h
new file mode 100644
index 00000000000..a96090b3bd8
--- /dev/null
+++ b/lldb/source/Plugins/Process/Darwin/MachException.h
@@ -0,0 +1,163 @@
+//===-- MachException.h -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+//  Created by Greg Clayton on 6/18/07.
+//
+//===----------------------------------------------------------------------===//
+
+
+#ifndef __MachException_h__
+#define __MachException_h__
+
+#include <mach/mach.h>
+#include <vector>
+
+#include "lldb/lldb-private-forward.h"
+#include "lldb/lldb-types.h"
+#include "lldb/Host/Debug.h"
+
+namespace lldb_private
+{
+namespace process_darwin
+{
+
+typedef union MachMessageTag
+{
+    mach_msg_header_t hdr;
+    char data[1024];
+} MachMessage;
+
+
+class MachException
+{
+public:
+
+    struct PortInfo
+    {
+        exception_mask_t        mask; // the exception mask for this device which may be a subset of EXC_MASK_ALL...
+        exception_mask_t        masks[EXC_TYPES_COUNT];
+        mach_port_t             ports[EXC_TYPES_COUNT];
+        exception_behavior_t    behaviors[EXC_TYPES_COUNT];
+        thread_state_flavor_t   flavors[EXC_TYPES_COUNT];
+        mach_msg_type_number_t  count;
+
+        Error
+        Save(task_t task);
+
+        Error
+        Restore(task_t task);
+    };
+
+    struct Data
+    {
+        task_t task_port;
+        thread_t thread_port;
+        exception_type_t exc_type;
+        std::vector<mach_exception_data_type_t> exc_data;
+        Data() :
+            task_port(TASK_NULL),
+            thread_port(THREAD_NULL),
+            exc_type(0),
+            exc_data()
+            {
+            }
+
+        void
+        Clear()
+        {
+            task_port = TASK_NULL;
+            thread_port = THREAD_NULL;
+            exc_type = 0;
+            exc_data.clear();
+        }
+
+        bool
+        IsValid() const
+        {
+            return  task_port != TASK_NULL &&
+                    thread_port != THREAD_NULL &&
+                    exc_type != 0;
+        }
+        
+        // Return the SoftSignal for this MachException data, or zero if there is none
+        int
+        SoftSignal() const
+        {
+            if (exc_type == EXC_SOFTWARE && exc_data.size() == 2 && exc_data[0] == EXC_SOFT_SIGNAL)
+                return static_cast<int>(exc_data[1]);
+            return 0;
+        }
+
+        bool
+        IsBreakpoint() const
+        {
+            return (exc_type == EXC_BREAKPOINT || ((exc_type == EXC_SOFTWARE) && exc_data[0] == 1));
+        }
+
+        bool
+        GetStopInfo(ThreadStopInfo *stop_info, const UnixSignals &signals,
+                         Stream &stream) const;
+    };
+
+    struct Message
+    {
+        MachMessage exc_msg;
+        MachMessage reply_msg;
+        Data state;
+
+        Message() :
+            state()
+        {
+            memset(&exc_msg,   0, sizeof(exc_msg));
+            memset(&reply_msg, 0, sizeof(reply_msg));
+        }
+
+        bool
+        CatchExceptionRaise(task_t task);
+
+        Error
+        Reply(::pid_t inferior_pid, task_t inferior_task, int signal);
+
+        Error
+        Receive(mach_port_t receive_port,
+                mach_msg_option_t options,
+                mach_msg_timeout_t timeout,
+                mach_port_t notify_port = MACH_PORT_NULL);
+
+        void
+        Dump(Stream &stream) const;
+
+        typedef std::vector<Message>        collection;
+        typedef collection::iterator        iterator;
+        typedef collection::const_iterator    const_iterator;
+    };
+
+    enum
+    {
+        e_actionForward,    // Forward signal to inferior process
+        e_actionStop,        // Stop when this signal is received
+    };
+    struct Action
+    {
+        task_t task_port;            // Set to TASK_NULL for any TASK
+        thread_t thread_port;        // Set to THREAD_NULL for any thread
+        exception_type_t exc_mask;    // Mach exception mask to watch for
+        std::vector<mach_exception_data_type_t> exc_data_mask;    // Mask to apply to exception data, or empty to ignore exc_data value for exception
+        std::vector<mach_exception_data_type_t> exc_data_value;    // Value to compare to exception data after masking, or empty to ignore exc_data value for exception
+        uint8_t flags;                // Action flags describing what to do with the exception
+    };
+
+    static const char*
+    Name(exception_type_t exc_type);
+};
+
+} // namespace process_darwin
+} // namespace lldb_private
+
+#endif