Update LLDB snapshot to upstream r216948 (git 50f7fe44)

This is approximately "LLDB 3.5" although with a little bit of skew,
and will go along with the Clang 3.5 import.

Sponsored by:	DARPA, AFRL

12 files changed, 4265 insertions, 368 deletions

diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
index 72600d8..1f4dd93 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp
@@ -22,14 +22,21 @@
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/FileSpec.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Host/HostInfo.h"
+#include "lldb/Host/Socket.h"
 #include "lldb/Host/TimeValue.h"
 #include "lldb/Target/Process.h"
 
 // Project includes
 #include "ProcessGDBRemoteLog.h"
 
-#define DEBUGSERVER_BASENAME    "debugserver"
+#if defined(__APPLE__)
+# define DEBUGSERVER_BASENAME    "debugserver"
+#else
+# define DEBUGSERVER_BASENAME    "lldb-gdbserver"
+#endif
 
 using namespace lldb;
 using namespace lldb_private;
@@ -321,6 +328,7 @@ GDBRemoteCommunication::WaitForPacketWithTimeoutMicroSecondsNoLock (StringExtrac
             switch (status)
             {
             case eConnectionStatusTimedOut:
+            case eConnectionStatusInterrupted:
                 timed_out = true;
                 break;
             case eConnectionStatusSuccess:
@@ -457,7 +465,8 @@ GDBRemoteCommunication::CheckForPacket (const uint8_t *src, size_t src_len, Stri
             assert (content_length <= m_bytes.size());
             assert (total_length <= m_bytes.size());
             assert (content_length <= total_length);
-            
+            const size_t content_end = content_start + content_length;
+
             bool success = true;
             std::string &packet_str = packet.GetStringRef();
             
@@ -471,7 +480,45 @@ GDBRemoteCommunication::CheckForPacket (const uint8_t *src, size_t src_len, Stri
                 if (!m_history.DidDumpToLog ())
                     m_history.Dump (log);
                 
-                log->Printf("<%4" PRIu64 "> read packet: %.*s", (uint64_t)total_length, (int)(total_length), m_bytes.c_str());
+                bool binary = false;
+                // Only detect binary for packets that start with a '$' and have a '#CC' checksum
+                if (m_bytes[0] == '$' && total_length > 4)
+                {
+                    for (size_t i=0; !binary && i<total_length; ++i)
+                    {
+                        if (isprint(m_bytes[i]) == 0)
+                            binary = true;
+                    }
+                }
+                if (binary)
+                {
+                    StreamString strm;
+                    // Packet header...
+                    strm.Printf("<%4" PRIu64 "> read packet: %c", (uint64_t)total_length, m_bytes[0]);
+                    for (size_t i=content_start; i<content_end; ++i)
+                    {
+                        // Remove binary escaped bytes when displaying the packet...
+                        const char ch = m_bytes[i];
+                        if (ch == 0x7d)
+                        {
+                            // 0x7d is the escape character.  The next character is to
+                            // be XOR'd with 0x20.
+                            const char escapee = m_bytes[++i] ^ 0x20;
+                            strm.Printf("%2.2x", escapee);
+                        }
+                        else
+                        {
+                            strm.Printf("%2.2x", (uint8_t)ch);
+                        }
+                    }
+                    // Packet footer...
+                    strm.Printf("%c%c%c", m_bytes[total_length-3], m_bytes[total_length-2], m_bytes[total_length-1]);
+                    log->PutCString(strm.GetString().c_str());
+                }
+                else
+                {
+                    log->Printf("<%4" PRIu64 "> read packet: %.*s", (uint64_t)total_length, (int)(total_length), m_bytes.c_str());
+                }
             }
 
             m_history.AddPacket (m_bytes.c_str(), total_length, History::ePacketTypeRecv, total_length);
@@ -482,7 +529,7 @@ GDBRemoteCommunication::CheckForPacket (const uint8_t *src, size_t src_len, Stri
             // run-length encoding in the process.
             // Reserve enough byte for the most common case (no RLE used)
             packet_str.reserve(m_bytes.length());
-            for (std::string::const_iterator c = m_bytes.begin() + content_start; c != m_bytes.begin() + content_start + content_length; ++c)
+            for (std::string::const_iterator c = m_bytes.begin() + content_start; c != m_bytes.begin() + content_end; ++c)
             {
                 if (*c == '*')
                 {
@@ -610,6 +657,10 @@ GDBRemoteCommunication::StartDebugserverProcess (const char *hostname,
                                                  lldb_private::ProcessLaunchInfo &launch_info,
                                                  uint16_t &out_port)
 {
+    Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
+    if (log)
+        log->Printf ("GDBRemoteCommunication::%s(hostname=%s, in_port=%" PRIu16 ", out_port=%" PRIu16, __FUNCTION__, hostname ? hostname : "<empty>", in_port, out_port);
+
     out_port = in_port;
     Error error;
     // If we locate debugserver, keep that located version around
@@ -622,24 +673,34 @@ GDBRemoteCommunication::StartDebugserverProcess (const char *hostname,
     // to the debugserver to use and use it if we do.
     const char *env_debugserver_path = getenv("LLDB_DEBUGSERVER_PATH");
     if (env_debugserver_path)
+    {
         debugserver_file_spec.SetFile (env_debugserver_path, false);
+        if (log)
+            log->Printf ("GDBRemoteCommunication::%s() gdb-remote stub exe path set from environment variable: %s", __FUNCTION__, env_debugserver_path);
+    }
     else
         debugserver_file_spec = g_debugserver_file_spec;
     bool debugserver_exists = debugserver_file_spec.Exists();
     if (!debugserver_exists)
     {
         // The debugserver binary is in the LLDB.framework/Resources
-        // directory. 
-        if (Host::GetLLDBPath (ePathTypeSupportExecutableDir, debugserver_file_spec))
+        // directory.
+        if (HostInfo::GetLLDBPath(ePathTypeSupportExecutableDir, debugserver_file_spec))
         {
-            debugserver_file_spec.GetFilename().SetCString(DEBUGSERVER_BASENAME);
+            debugserver_file_spec.AppendPathComponent (DEBUGSERVER_BASENAME);
             debugserver_exists = debugserver_file_spec.Exists();
             if (debugserver_exists)
             {
+                if (log)
+                    log->Printf ("GDBRemoteCommunication::%s() found gdb-remote stub exe '%s'", __FUNCTION__, debugserver_file_spec.GetPath ().c_str ());
+
                 g_debugserver_file_spec = debugserver_file_spec;
             }
             else
             {
+                if (log)
+                    log->Printf ("GDBRemoteCommunication::%s() could not find gdb-remote stub exe '%s'", __FUNCTION__, debugserver_file_spec.GetPath ().c_str ());
+
                 g_debugserver_file_spec.Clear();
                 debugserver_file_spec.Clear();
             }
@@ -690,9 +751,9 @@ GDBRemoteCommunication::StartDebugserverProcess (const char *hostname,
                 // Binding to port zero, we need to figure out what port it ends up
                 // using using a named pipe...
                 FileSpec tmpdir_file_spec;
-                if (Host::GetLLDBPath (ePathTypeLLDBTempSystemDir, tmpdir_file_spec))
+                if (HostInfo::GetLLDBPath(ePathTypeLLDBTempSystemDir, tmpdir_file_spec))
                 {
-                    tmpdir_file_spec.GetFilename().SetCString("debugserver-named-pipe.XXXXXX");
+                    tmpdir_file_spec.AppendPathComponent("debugserver-named-pipe.XXXXXX");
                     strncpy(named_pipe_path, tmpdir_file_spec.GetPath().c_str(), sizeof(named_pipe_path));
                 }
                 else
@@ -702,7 +763,7 @@ GDBRemoteCommunication::StartDebugserverProcess (const char *hostname,
 
                 if (::mktemp (named_pipe_path))
                 {
-#if defined(_MSC_VER)
+#if defined(_WIN32)
                     if ( false )
 #else
                     if (::mkfifo(named_pipe_path, 0600) == 0)
@@ -722,21 +783,28 @@ GDBRemoteCommunication::StartDebugserverProcess (const char *hostname,
         {
             // No host and port given, so lets listen on our end and make the debugserver
             // connect to us..
-            error = StartListenThread ("localhost", 0);
+            error = StartListenThread ("127.0.0.1", 0);
             if (error.Fail())
                 return error;
 
             ConnectionFileDescriptor *connection = (ConnectionFileDescriptor *)GetConnection ();
-            out_port = connection->GetBoundPort(3);
-            assert (out_port != 0);
-            char port_cstr[32];
-            snprintf(port_cstr, sizeof(port_cstr), "localhost:%i", out_port);
-            // Send the host and port down that debugserver and specify an option
-            // so that it connects back to the port we are listening to in this process
-            debugserver_args.AppendArgument("--reverse-connect");
-            debugserver_args.AppendArgument(port_cstr);
+            // Wait for 10 seconds to resolve the bound port
+            out_port = connection->GetListeningPort(10);
+            if (out_port > 0)
+            {
+                char port_cstr[32];
+                snprintf(port_cstr, sizeof(port_cstr), "127.0.0.1:%i", out_port);
+                // Send the host and port down that debugserver and specify an option
+                // so that it connects back to the port we are listening to in this process
+                debugserver_args.AppendArgument("--reverse-connect");
+                debugserver_args.AppendArgument(port_cstr);
+            }
+            else
+            {
+                error.SetErrorString ("failed to bind to port 0 on 127.0.0.1");
+                return error;
+            }
         }
-
         
         const char *env_debugserver_log_file = getenv("LLDB_DEBUGSERVER_LOG_FILE");
         if (env_debugserver_log_file)
@@ -751,7 +819,25 @@ GDBRemoteCommunication::StartDebugserverProcess (const char *hostname,
             ::snprintf (arg_cstr, sizeof(arg_cstr), "--log-flags=%s", env_debugserver_log_flags);
             debugserver_args.AppendArgument(arg_cstr);
         }
-        
+
+        // Add additional args, starting with LLDB_DEBUGSERVER_EXTRA_ARG_1 until an env var doesn't come back.
+        uint32_t env_var_index = 1;
+        bool has_env_var;
+        do
+        {
+            char env_var_name[64];
+            snprintf (env_var_name, sizeof (env_var_name), "LLDB_DEBUGSERVER_EXTRA_ARG_%" PRIu32, env_var_index++);
+            const char *extra_arg = getenv(env_var_name);
+            has_env_var = extra_arg != nullptr;
+
+            if (has_env_var)
+            {
+                debugserver_args.AppendArgument (extra_arg);
+                if (log)
+                    log->Printf ("GDBRemoteCommunication::%s adding env var %s contents to stub command line (%s)", __FUNCTION__, env_var_name, extra_arg);
+            }
+        } while (has_env_var);
+
         // Close STDIN, STDOUT and STDERR. We might need to redirect them
         // to "/dev/null" if we run into any problems.
         launch_info.AppendCloseFileAction (STDIN_FILENO);
@@ -760,31 +846,34 @@ GDBRemoteCommunication::StartDebugserverProcess (const char *hostname,
         
         error = Host::LaunchProcess(launch_info);
         
-        if (named_pipe_path[0])
+        if (error.Success() && launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID)
         {
-            File name_pipe_file;
-            error = name_pipe_file.Open(named_pipe_path, File::eOpenOptionRead);
-            if (error.Success())
+            if (named_pipe_path[0])
             {
-                char port_cstr[256];
-                port_cstr[0] = '\0';
-                size_t num_bytes = sizeof(port_cstr);
-                error = name_pipe_file.Read(port_cstr, num_bytes);
-                assert (error.Success());
-                assert (num_bytes > 0 && port_cstr[num_bytes-1] == '\0');
-                out_port = Args::StringToUInt32(port_cstr, 0);
-                name_pipe_file.Close();
+                File name_pipe_file;
+                error = name_pipe_file.Open(named_pipe_path, File::eOpenOptionRead);
+                if (error.Success())
+                {
+                    char port_cstr[256];
+                    port_cstr[0] = '\0';
+                    size_t num_bytes = sizeof(port_cstr);
+                    error = name_pipe_file.Read(port_cstr, num_bytes);
+                    assert (error.Success());
+                    assert (num_bytes > 0 && port_cstr[num_bytes-1] == '\0');
+                    out_port = Args::StringToUInt32(port_cstr, 0);
+                    name_pipe_file.Close();
+                }
+                FileSystem::Unlink(named_pipe_path);
+            }
+            else if (listen)
+            {
+                
+            }
+            else
+            {
+                // Make sure we actually connect with the debugserver...
+                JoinListenThread();
             }
-            Host::Unlink(named_pipe_path);
-        }
-        else if (listen)
-        {
-            
-        }
-        else
-        {
-            // Make sure we actually connect with the debugserver...
-            JoinListenThread();
         }
     }
     else
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h
index d836111..b11d385 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.h
@@ -271,7 +271,7 @@ protected:
     
 
     lldb_private::Error
-    StartListenThread (const char *hostname = "localhost",
+    StartListenThread (const char *hostname = "127.0.0.1",
                        uint16_t port = 0);
 
     bool
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
index ab3bf7f..5e4ed76 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp
@@ -17,6 +17,7 @@
 #include <sstream>
 
 // Other libraries and framework includes
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Triple.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Core/ConnectionFileDescriptor.h"
@@ -26,7 +27,9 @@
 #include "lldb/Core/StreamString.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Host/HostInfo.h"
 #include "lldb/Host/TimeValue.h"
+#include "lldb/Target/Target.h"
 
 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
@@ -37,7 +40,7 @@
 using namespace lldb;
 using namespace lldb_private;
 
-#ifdef LLDB_DISABLE_POSIX
+#if defined(LLDB_DISABLE_POSIX) && !defined(SIGSTOP)
 #define SIGSTOP 17
 #endif
 
@@ -56,7 +59,9 @@ GDBRemoteCommunicationClient::GDBRemoteCommunicationClient(bool is_platform) :
     m_supports_vCont_s (eLazyBoolCalculate),
     m_supports_vCont_S (eLazyBoolCalculate),
     m_qHostInfo_is_valid (eLazyBoolCalculate),
+    m_curr_pid_is_valid (eLazyBoolCalculate),
     m_qProcessInfo_is_valid (eLazyBoolCalculate),
+    m_qGDBServerVersion_is_valid (eLazyBoolCalculate),
     m_supports_alloc_dealloc_memory (eLazyBoolCalculate),
     m_supports_memory_region_info  (eLazyBoolCalculate),
     m_supports_watchpoint_support_info  (eLazyBoolCalculate),
@@ -65,10 +70,14 @@ GDBRemoteCommunicationClient::GDBRemoteCommunicationClient(bool is_platform) :
     m_attach_or_wait_reply(eLazyBoolCalculate),
     m_prepare_for_reg_writing_reply (eLazyBoolCalculate),
     m_supports_p (eLazyBoolCalculate),
+    m_supports_x (eLazyBoolCalculate),
+    m_avoid_g_packets (eLazyBoolCalculate),
     m_supports_QSaveRegisterState (eLazyBoolCalculate),
+    m_supports_qXfer_auxv_read (eLazyBoolCalculate),
     m_supports_qXfer_libraries_read (eLazyBoolCalculate),
     m_supports_qXfer_libraries_svr4_read (eLazyBoolCalculate),
     m_supports_augmented_libraries_svr4_read (eLazyBoolCalculate),
+    m_supports_jThreadExtendedInfo (eLazyBoolCalculate),
     m_supports_qProcessInfoPID (true),
     m_supports_qfProcessInfo (true),
     m_supports_qUserName (true),
@@ -81,6 +90,7 @@ GDBRemoteCommunicationClient::GDBRemoteCommunicationClient(bool is_platform) :
     m_supports_z4 (true),
     m_supports_QEnvironment (true),
     m_supports_QEnvironmentHexEncoded (true),
+    m_curr_pid (LLDB_INVALID_PROCESS_ID),
     m_curr_tid (LLDB_INVALID_THREAD_ID),
     m_curr_tid_run (LLDB_INVALID_THREAD_ID),
     m_num_supported_hardware_watchpoints (0),
@@ -90,6 +100,7 @@ GDBRemoteCommunicationClient::GDBRemoteCommunicationClient(bool is_platform) :
     m_async_result (PacketResult::Success),
     m_async_response (),
     m_async_signal (-1),
+    m_interrupt_sent (false),
     m_thread_id_to_used_usec_map (),
     m_host_arch(),
     m_process_arch(),
@@ -99,6 +110,8 @@ GDBRemoteCommunicationClient::GDBRemoteCommunicationClient(bool is_platform) :
     m_os_build (),
     m_os_kernel (),
     m_hostname (),
+    m_gdb_server_name(),
+    m_gdb_server_version(UINT32_MAX),
     m_default_packet_timeout (0),
     m_max_packet_size (0)
 {
@@ -187,6 +200,16 @@ GDBRemoteCommunicationClient::GetQXferLibrariesReadSupported ()
     return (m_supports_qXfer_libraries_read == eLazyBoolYes);
 }
 
+bool
+GDBRemoteCommunicationClient::GetQXferAuxvReadSupported ()
+{
+    if (m_supports_qXfer_auxv_read == eLazyBoolCalculate)
+    {
+        GetRemoteQSupported();
+    }
+    return (m_supports_qXfer_auxv_read == eLazyBoolYes);
+}
+
 uint64_t
 GDBRemoteCommunicationClient::GetRemoteMaxPacketSize()
 {
@@ -205,8 +228,18 @@ GDBRemoteCommunicationClient::QueryNoAckModeSupported ()
         m_send_acks = true;
         m_supports_not_sending_acks = eLazyBoolNo;
 
+        // This is the first real packet that we'll send in a debug session and it may take a little
+        // longer than normal to receive a reply.  Wait at least 6 seconds for a reply to this packet.
+
+        const uint32_t minimum_timeout = 6;
+        uint32_t old_timeout = GetPacketTimeoutInMicroSeconds() / lldb_private::TimeValue::MicroSecPerSec;
+        SetPacketTimeout (std::max (old_timeout, minimum_timeout));
+
         StringExtractorGDBRemote response;
-        if (SendPacketAndWaitForResponse("QStartNoAckMode", response, false) == PacketResult::Success)
+        PacketResult packet_send_result = SendPacketAndWaitForResponse("QStartNoAckMode", response, false);
+        SetPacketTimeout (old_timeout);
+
+        if (packet_send_result == PacketResult::Success)
         {
             if (response.IsOKResponse())
             {
@@ -287,13 +320,18 @@ GDBRemoteCommunicationClient::ResetDiscoverableSettings()
     m_supports_vCont_s = eLazyBoolCalculate;
     m_supports_vCont_S = eLazyBoolCalculate;
     m_supports_p = eLazyBoolCalculate;
+    m_supports_x = eLazyBoolCalculate;
     m_supports_QSaveRegisterState = eLazyBoolCalculate;
     m_qHostInfo_is_valid = eLazyBoolCalculate;
+    m_curr_pid_is_valid = eLazyBoolCalculate;
     m_qProcessInfo_is_valid = eLazyBoolCalculate;
+    m_qGDBServerVersion_is_valid = eLazyBoolCalculate;
     m_supports_alloc_dealloc_memory = eLazyBoolCalculate;
     m_supports_memory_region_info = eLazyBoolCalculate;
     m_prepare_for_reg_writing_reply = eLazyBoolCalculate;
     m_attach_or_wait_reply = eLazyBoolCalculate;
+    m_avoid_g_packets = eLazyBoolCalculate;
+    m_supports_qXfer_auxv_read = eLazyBoolCalculate;
     m_supports_qXfer_libraries_read = eLazyBoolCalculate;
     m_supports_qXfer_libraries_svr4_read = eLazyBoolCalculate;
     m_supports_augmented_libraries_svr4_read = eLazyBoolCalculate;
@@ -310,8 +348,18 @@ GDBRemoteCommunicationClient::ResetDiscoverableSettings()
     m_supports_z4 = true;
     m_supports_QEnvironment = true;
     m_supports_QEnvironmentHexEncoded = true;
+    
     m_host_arch.Clear();
     m_process_arch.Clear();
+    m_os_version_major = UINT32_MAX;
+    m_os_version_minor = UINT32_MAX;
+    m_os_version_update = UINT32_MAX;
+    m_os_build.clear();
+    m_os_kernel.clear();
+    m_hostname.clear();
+    m_gdb_server_name.clear();
+    m_gdb_server_version = UINT32_MAX;
+    m_default_packet_timeout = 0;
 
     m_max_packet_size = 0;
 }
@@ -320,8 +368,9 @@ void
 GDBRemoteCommunicationClient::GetRemoteQSupported ()
 {
     // Clear out any capabilities we expect to see in the qSupported response
-    m_supports_qXfer_libraries_svr4_read = eLazyBoolNo;
+    m_supports_qXfer_auxv_read = eLazyBoolNo;
     m_supports_qXfer_libraries_read = eLazyBoolNo;
+    m_supports_qXfer_libraries_svr4_read = eLazyBoolNo;
     m_supports_augmented_libraries_svr4_read = eLazyBoolNo;
     m_max_packet_size = UINT64_MAX;  // It's supposed to always be there, but if not, we assume no limit
 
@@ -331,6 +380,8 @@ GDBRemoteCommunicationClient::GetRemoteQSupported ()
                                      /*send_async=*/false) == PacketResult::Success)
     {
         const char *response_cstr = response.GetStringRef().c_str();
+        if (::strstr (response_cstr, "qXfer:auxv:read+"))
+            m_supports_qXfer_auxv_read = eLazyBoolYes;
         if (::strstr (response_cstr, "qXfer:libraries-svr4:read+"))
             m_supports_qXfer_libraries_svr4_read = eLazyBoolYes;
         if (::strstr (response_cstr, "augmented-libraries-svr4-read"))
@@ -457,6 +508,42 @@ GDBRemoteCommunicationClient::GetpPacketSupported (lldb::tid_t tid)
     return m_supports_p;
 }
 
+bool
+GDBRemoteCommunicationClient::GetThreadExtendedInfoSupported ()
+{
+    if (m_supports_jThreadExtendedInfo == eLazyBoolCalculate)
+    {
+        StringExtractorGDBRemote response;
+        m_supports_jThreadExtendedInfo = eLazyBoolNo;
+        if (SendPacketAndWaitForResponse("jThreadExtendedInfo:", response, false) == PacketResult::Success)
+        {
+            if (response.IsOKResponse())
+            {
+                m_supports_jThreadExtendedInfo = eLazyBoolYes;
+            }
+        }
+    }
+    return m_supports_jThreadExtendedInfo;
+}
+
+bool
+GDBRemoteCommunicationClient::GetxPacketSupported ()
+{
+    if (m_supports_x == eLazyBoolCalculate)
+    {
+        StringExtractorGDBRemote response;
+        m_supports_x = eLazyBoolNo;
+        char packet[256];
+        snprintf (packet, sizeof (packet), "x0,0");
+        if (SendPacketAndWaitForResponse(packet, response, false) == PacketResult::Success)
+        {
+            if (response.IsOKResponse())
+                m_supports_x = eLazyBoolYes;
+        }
+    }
+    return m_supports_x;
+}
+
 GDBRemoteCommunicationClient::PacketResult
 GDBRemoteCommunicationClient::SendPacketsAndConcatenateResponses
 (
@@ -502,11 +589,8 @@ GDBRemoteCommunicationClient::SendPacketsAndConcatenateResponses
         {
             return PacketResult::ErrorReplyInvalid;
         }
-        // Skip past m or l
-        const char *s = this_string.c_str() + 1;
-
-        // Concatenate the result so far
-        response_string += s;
+        // Concatenate the result so far (skipping 'm' or 'l')
+        response_string.append(this_string, 1, std::string::npos);
         if (first_char == 'l')
             // We're done
             return PacketResult::Success;
@@ -550,7 +634,6 @@ GDBRemoteCommunicationClient::SendPacketAndWaitForResponse
     PacketResult packet_result = PacketResult::ErrorSendFailed;
     Mutex::Locker locker;
     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
-    size_t response_len = 0;
     if (GetSequenceMutex (locker))
     {
         packet_result = SendPacketAndWaitForResponseNoLock (payload, payload_length, response);
@@ -588,7 +671,6 @@ GDBRemoteCommunicationClient::SendPacketAndWaitForResponse
 
                             // Swap the response buffer to avoid malloc and string copy
                             response.GetStringRef().swap (m_async_response.GetStringRef());
-                            response_len = response.GetStringRef().size();
                             packet_result = m_async_result;
                         }
                         else
@@ -772,6 +854,8 @@ GDBRemoteCommunicationClient::SendContinuePacketAndWaitForResponse
                 log->Printf ("GDBRemoteCommunicationClient::%s () sending continue packet: %s", __FUNCTION__, continue_packet.c_str());
             if (SendPacketNoLock(continue_packet.c_str(), continue_packet.size()) != PacketResult::Success)
                 state = eStateInvalid;
+            else
+                m_interrupt_sent = false;
         
             m_private_is_running.SetValue (true, eBroadcastAlways);
         }
@@ -1047,7 +1131,7 @@ GDBRemoteCommunicationClient::SendAsyncSignal (int signo)
 // then the caller that requested the interrupt will want to keep the sequence
 // locked down so that no one else can send packets while the caller has control.
 // This function usually gets called when we are running and need to stop the 
-// target. It can also be used when we are running and and we need to do something
+// target. It can also be used when we are running and we need to do something
 // else (like read/write memory), so we need to interrupt the running process
 // (gdb remote protocol requires this), and do what we need to do, then resume.
 
@@ -1128,13 +1212,40 @@ GDBRemoteCommunicationClient::SendInterrupt
 lldb::pid_t
 GDBRemoteCommunicationClient::GetCurrentProcessID ()
 {
-    StringExtractorGDBRemote response;
-    if (SendPacketAndWaitForResponse("qC", strlen("qC"), response, false) == PacketResult::Success)
+    if (m_curr_pid_is_valid == eLazyBoolYes)
+        return m_curr_pid;
+    
+    // First try to retrieve the pid via the qProcessInfo request.
+    GetCurrentProcessInfo ();
+    if (m_curr_pid_is_valid == eLazyBoolYes)
+    {
+        // We really got it.
+        return m_curr_pid;
+    }
+    else
     {
-        if (response.GetChar() == 'Q')
-            if (response.GetChar() == 'C')
-                return response.GetHexMaxU32 (false, LLDB_INVALID_PROCESS_ID);
+        // If we don't get a response for qProcessInfo, check if $qC gives us a result.
+        // $qC only returns a real process id on older debugserver and lldb-platform stubs.
+        // The gdb remote protocol documents $qC as returning the thread id, which newer
+        // debugserver and lldb-gdbserver stubs return correctly.
+        StringExtractorGDBRemote response;
+        if (SendPacketAndWaitForResponse("qC", strlen("qC"), response, false) == PacketResult::Success)
+        {
+            if (response.GetChar() == 'Q')
+            {
+                if (response.GetChar() == 'C')
+                {
+                    m_curr_pid = response.GetHexMaxU32 (false, LLDB_INVALID_PROCESS_ID);
+                    if (m_curr_pid != LLDB_INVALID_PROCESS_ID)
+                    {
+                        m_curr_pid_is_valid = eLazyBoolYes;
+                        return m_curr_pid;
+                    }
+                }
+            }
+        }
     }
+    
     return LLDB_INVALID_PROCESS_ID;
 }
 
@@ -1168,7 +1279,7 @@ int
 GDBRemoteCommunicationClient::SendArgumentsPacket (const ProcessLaunchInfo &launch_info)
 {
     // Since we don't get the send argv0 separate from the executable path, we need to
-    // make sure to use the actual exectuable path found in the launch_info...
+    // make sure to use the actual executable path found in the launch_info...
     std::vector<const char *> argv;
     FileSpec exe_file = launch_info.GetExecutableFile();
     std::string exe_path;
@@ -1304,6 +1415,41 @@ GDBRemoteCommunicationClient::SendLaunchArchPacket (char const *arch)
     return -1;
 }
 
+int
+GDBRemoteCommunicationClient::SendLaunchEventDataPacket (char const *data, bool *was_supported)
+{
+    if (data && *data != '\0')
+    {
+        StreamString packet;
+        packet.Printf("QSetProcessEvent:%s", data);
+        StringExtractorGDBRemote response;
+        if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
+        {
+            if (response.IsOKResponse())
+            {
+                if (was_supported)
+                    *was_supported = true;
+                return 0;
+            }
+            else if (response.IsUnsupportedResponse())
+            {
+                if (was_supported)
+                    *was_supported = false;
+                return -1;
+            }
+            else
+            {
+                uint8_t error = response.GetError();
+                if (was_supported)
+                    *was_supported = true;
+                if (error)
+                    return error;
+            }
+        }
+    }
+    return -1;
+}
+
 bool
 GDBRemoteCommunicationClient::GetOSVersion (uint32_t &major, 
                                             uint32_t &minor, 
@@ -1384,10 +1530,75 @@ GDBRemoteCommunicationClient::GetProcessArchitecture ()
     return m_process_arch;
 }
 
+bool
+GDBRemoteCommunicationClient::GetGDBServerVersion()
+{
+    if (m_qGDBServerVersion_is_valid == eLazyBoolCalculate)
+    {
+        m_gdb_server_name.clear();
+        m_gdb_server_version = 0;
+        m_qGDBServerVersion_is_valid = eLazyBoolNo;
+
+        StringExtractorGDBRemote response;
+        if (SendPacketAndWaitForResponse ("qGDBServerVersion", response, false) == PacketResult::Success)
+        {
+            if (response.IsNormalResponse())
+            {
+                std::string name;
+                std::string value;
+                bool success = false;
+                while (response.GetNameColonValue(name, value))
+                {
+                    if (name.compare("name") == 0)
+                    {
+                        success = true;
+                        m_gdb_server_name.swap(value);
+                    }
+                    else if (name.compare("version") == 0)
+                    {
+                        size_t dot_pos = value.find('.');
+                        if (dot_pos != std::string::npos)
+                            value[dot_pos] = '\0';
+                        const uint32_t version = Args::StringToUInt32(value.c_str(), UINT32_MAX, 0);
+                        if (version != UINT32_MAX)
+                        {
+                            success = true;
+                            m_gdb_server_version = version;
+                        }
+                    }
+                }
+                if (success)
+                    m_qGDBServerVersion_is_valid = eLazyBoolYes;
+            }
+        }
+    }
+    return m_qGDBServerVersion_is_valid == eLazyBoolYes;
+}
+
+const char *
+GDBRemoteCommunicationClient::GetGDBServerProgramName()
+{
+    if (GetGDBServerVersion())
+    {
+        if (!m_gdb_server_name.empty())
+            return m_gdb_server_name.c_str();
+    }
+    return NULL;
+}
+
+uint32_t
+GDBRemoteCommunicationClient::GetGDBServerProgramVersion()
+{
+    if (GetGDBServerVersion())
+        return m_gdb_server_version;
+    return 0;
+}
 
 bool
 GDBRemoteCommunicationClient::GetHostInfo (bool force)
 {
+    Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_PROCESS));
+
     if (force || m_qHostInfo_is_valid == eLazyBoolCalculate)
     {
         m_qHostInfo_is_valid = eLazyBoolNo;
@@ -1432,10 +1643,7 @@ GDBRemoteCommunicationClient::GetHostInfo (bool force)
                     }
                     else if (name.compare("triple") == 0)
                     {
-                        // The triple comes as ASCII hex bytes since it contains '-' chars
-                        extractor.GetStringRef().swap(value);
-                        extractor.SetFilePos(0);
-                        extractor.GetHexByteString (triple);
+                        triple.swap(value);
                         ++num_keys_decoded;
                     }
                     else if (name.compare ("distribution_id") == 0)
@@ -1548,6 +1756,7 @@ GDBRemoteCommunicationClient::GetHostInfo (bool force)
                             {
                                 switch (m_host_arch.GetMachine())
                                 {
+                                case llvm::Triple::aarch64:
                                 case llvm::Triple::arm:
                                 case llvm::Triple::thumb:
                                     os_name = "ios";
@@ -1588,6 +1797,7 @@ GDBRemoteCommunicationClient::GetHostInfo (bool force)
                         {
                             switch (m_host_arch.GetMachine())
                             {
+                                case llvm::Triple::aarch64:
                                 case llvm::Triple::arm:
                                 case llvm::Triple::thumb:
                                     host_triple.setOS(llvm::Triple::IOS);
@@ -1619,6 +1829,9 @@ GDBRemoteCommunicationClient::GetHostInfo (bool force)
                     {
                         assert (byte_order == m_host_arch.GetByteOrder());
                     }
+
+                    if (log)
+                        log->Printf ("GDBRemoteCommunicationClient::%s parsed host architecture as %s, triple as %s from triple text %s", __FUNCTION__, m_host_arch.GetArchitectureName () ? m_host_arch.GetArchitectureName () : "<null-arch-name>", m_host_arch.GetTriple ().getTriple ().c_str(), triple.c_str ());
                 }
                 if (!distribution_id.empty ())
                     m_host_arch.SetDistributionId (distribution_id.c_str ());
@@ -1682,7 +1895,9 @@ GDBRemoteCommunicationClient::AllocateMemory (size_t size, uint32_t permissions)
         StringExtractorGDBRemote response;
         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
         {
-            if (!response.IsErrorResponse())
+            if (response.IsUnsupportedResponse())
+                m_supports_alloc_dealloc_memory = eLazyBoolNo;
+            else if (!response.IsErrorResponse())
                 return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
         }
         else
@@ -1705,7 +1920,9 @@ GDBRemoteCommunicationClient::DeallocateMemory (addr_t addr)
         StringExtractorGDBRemote response;
         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
         {
-            if (response.IsOKResponse())
+            if (response.IsUnsupportedResponse())
+                m_supports_alloc_dealloc_memory = eLazyBoolNo;
+            else if (response.IsOKResponse())
                 return true;
         }
         else
@@ -1746,14 +1963,16 @@ GDBRemoteCommunicationClient::Detach (bool keep_stopped)
         }
         else
         {
-            PacketResult packet_result = SendPacket ("D1", 2);
+            StringExtractorGDBRemote response;
+            PacketResult packet_result = SendPacketAndWaitForResponse ("D1", 1, response, false);
             if (packet_result != PacketResult::Success)
                 error.SetErrorString ("Sending extended disconnect packet failed.");
         }
     }
     else
     {
-        PacketResult packet_result = SendPacket ("D", 1);
+        StringExtractorGDBRemote response;
+        PacketResult packet_result = SendPacketAndWaitForResponse ("D", 1, response, false);
         if (packet_result != PacketResult::Success)
             error.SetErrorString ("Sending disconnect packet failed.");
     }
@@ -2051,6 +2270,25 @@ GDBRemoteCommunicationClient::SetDisableASLR (bool enable)
     return -1;
 }
 
+int
+GDBRemoteCommunicationClient::SetDetachOnError (bool enable)
+{
+    char packet[32];
+    const int packet_len = ::snprintf (packet, sizeof (packet), "QSetDetachOnError:%i", enable ? 1 : 0);
+    assert (packet_len < (int)sizeof(packet));
+    StringExtractorGDBRemote response;
+    if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
+    {
+        if (response.IsOKResponse())
+            return 0;
+        uint8_t error = response.GetError();
+        if (error)
+            return error;
+    }
+    return -1;
+}
+
+
 bool
 GDBRemoteCommunicationClient::DecodeProcessInfoResponse (StringExtractorGDBRemote &response, ProcessInstanceInfo &process_info)
 {
@@ -2093,10 +2331,6 @@ GDBRemoteCommunicationClient::DecodeProcessInfoResponse (StringExtractorGDBRemot
             }
             else if (name.compare("triple") == 0)
             {
-                // The triple comes as ASCII hex bytes since it contains '-' chars
-                extractor.GetStringRef().swap(value);
-                extractor.SetFilePos(0);
-                extractor.GetHexByteString (value);
                 process_info.GetArchitecture ().SetTriple (value.c_str());
             }
             else if (name.compare("name") == 0)
@@ -2192,8 +2426,8 @@ GDBRemoteCommunicationClient::GetCurrentProcessInfo ()
             std::string triple;
             uint32_t pointer_byte_size = 0;
             StringExtractor extractor;
-            ByteOrder byte_order = eByteOrderInvalid;
             uint32_t num_keys_decoded = 0;
+            lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
             while (response.GetNameColonValue(name, value))
             {
                 if (name.compare("cputype") == 0)
@@ -2208,6 +2442,11 @@ GDBRemoteCommunicationClient::GetCurrentProcessInfo ()
                     if (sub != 0)
                         ++num_keys_decoded;
                 }
+                else if (name.compare("triple") == 0)
+                {
+                    triple = value;
+                    ++num_keys_decoded;
+                }
                 else if (name.compare("ostype") == 0)
                 {
                     os_name.swap (value);
@@ -2220,15 +2459,10 @@ GDBRemoteCommunicationClient::GetCurrentProcessInfo ()
                 }
                 else if (name.compare("endian") == 0)
                 {
-                    ++num_keys_decoded;
-                    if (value.compare("little") == 0)
-                        byte_order = eByteOrderLittle;
-                    else if (value.compare("big") == 0)
-                        byte_order = eByteOrderBig;
-                    else if (value.compare("pdp") == 0)
-                        byte_order = eByteOrderPDP;
-                    else
-                        --num_keys_decoded;
+                    if (value.compare("little") == 0 ||
+                        value.compare("big") == 0 ||
+                        value.compare("pdp") == 0)
+                        ++num_keys_decoded;
                 }
                 else if (name.compare("ptrsize") == 0)
                 {
@@ -2236,20 +2470,42 @@ GDBRemoteCommunicationClient::GetCurrentProcessInfo ()
                     if (pointer_byte_size != 0)
                         ++num_keys_decoded;
                 }
+                else if (name.compare("pid") == 0)
+                {
+                    pid = Args::StringToUInt64(value.c_str(), 0, 16);
+                    if (pid != LLDB_INVALID_PROCESS_ID)
+                        ++num_keys_decoded;
+                }
             }
             if (num_keys_decoded > 0)
                 m_qProcessInfo_is_valid = eLazyBoolYes;
-            if (cpu != LLDB_INVALID_CPUTYPE && !os_name.empty() && !vendor_name.empty())
+            if (pid != LLDB_INVALID_PROCESS_ID)
+            {
+                m_curr_pid_is_valid = eLazyBoolYes;
+                m_curr_pid = pid;
+            }
+
+            // Set the ArchSpec from the triple if we have it.
+            if (!triple.empty ())
+            {
+                m_process_arch.SetTriple (triple.c_str ());
+                if (pointer_byte_size)
+                {
+                    assert (pointer_byte_size == m_process_arch.GetAddressByteSize());
+                }
+            }
+            else if (cpu != LLDB_INVALID_CPUTYPE && !os_name.empty() && !vendor_name.empty())
             {
                 m_process_arch.SetArchitecture (eArchTypeMachO, cpu, sub);
                 if (pointer_byte_size)
                 {
                     assert (pointer_byte_size == m_process_arch.GetAddressByteSize());
                 }
+                m_process_arch.GetTriple().setOSName(llvm::StringRef (os_name));
                 m_host_arch.GetTriple().setVendorName (llvm::StringRef (vendor_name));
                 m_host_arch.GetTriple().setOSName (llvm::StringRef (os_name));
-                return true;
             }
+            return true;
         }
     }
     else
@@ -2333,7 +2589,7 @@ GDBRemoteCommunicationClient::FindProcesses (const ProcessInstanceInfoMatch &mat
                 const ArchSpec &match_arch = match_info.GetProcessInfo().GetArchitecture();
                 const llvm::Triple &triple = match_arch.GetTriple();
                 packet.PutCString("triple:");
-                packet.PutCStringAsRawHex8(triple.getTriple().c_str());
+                packet.PutCString(triple.getTriple().c_str());
                 packet.PutChar (';');
             }
         }
@@ -2429,8 +2685,8 @@ GDBRemoteCommunicationClient::TestPacketSpeed (const uint32_t num_packets)
     {
         static uint32_t g_send_sizes[] = { 0, 64, 128, 512, 1024 };
         static uint32_t g_recv_sizes[] = { 0, 64, 128, 512, 1024 }; //, 4*1024, 8*1024, 16*1024, 32*1024, 48*1024, 64*1024, 96*1024, 128*1024 };
-        const size_t k_num_send_sizes = sizeof(g_send_sizes)/sizeof(uint32_t);
-        const size_t k_num_recv_sizes = sizeof(g_recv_sizes)/sizeof(uint32_t);
+        const size_t k_num_send_sizes = llvm::array_lengthof(g_send_sizes);
+        const size_t k_num_recv_sizes = llvm::array_lengthof(g_recv_sizes);
         const uint64_t k_recv_amount = 4*1024*1024; // Receive 4MB
         for (uint32_t send_idx = 0; send_idx < k_num_send_sizes; ++send_idx)
         {
@@ -2539,7 +2795,7 @@ GDBRemoteCommunicationClient::LaunchGDBserverAndGetPort (lldb::pid_t &pid, const
         hostname = remote_accept_hostname;
     else
     {
-        if (Host::GetHostname (hostname))
+        if (HostInfo::GetHostname(hostname))
         {
             // Make the GDB server we launch only accept connections from this host
             stream.Printf("host:%s;", hostname.c_str());
@@ -2687,7 +2943,7 @@ GDBRemoteCommunicationClient::SendGDBStoppointTypePacket (GDBStoppointType type,
                                        type, 
                                        addr, 
                                        length);
-    // Check we havent overwritten the end of the packet buffer
+    // Check we haven't overwritten the end of the packet buffer
     assert (packet_len + 1 < (int)sizeof(packet));
     StringExtractorGDBRemote response;
     // Try to send the breakpoint packet, and check that it was correctly sent
@@ -2715,7 +2971,7 @@ GDBRemoteCommunicationClient::SendGDBStoppointTypePacket (GDBStoppointType type,
             }
         }
     }
-    // Signal generic faliure
+    // Signal generic failure
     return UINT8_MAX;
 }
 
@@ -2977,7 +3233,7 @@ GDBRemoteCommunicationClient::GetFilePermissions(const char *path, uint32_t &fil
         else
         {
             const uint32_t mode = response.GetS32(-1);
-            if (mode == -1)
+            if (static_cast<int32_t>(mode) == -1)
             {
                 if (response.GetChar() == ',')
                 {
@@ -3217,6 +3473,38 @@ GDBRemoteCommunicationClient::CalculateMD5 (const lldb_private::FileSpec& file_s
 }
 
 bool
+GDBRemoteCommunicationClient::AvoidGPackets (ProcessGDBRemote *process)
+{
+    // Some targets have issues with g/G packets and we need to avoid using them
+    if (m_avoid_g_packets == eLazyBoolCalculate)
+    {
+        if (process)
+        {
+            m_avoid_g_packets = eLazyBoolNo;
+            const ArchSpec &arch = process->GetTarget().GetArchitecture();
+            if (arch.IsValid()
+                && arch.GetTriple().getVendor() == llvm::Triple::Apple
+                && arch.GetTriple().getOS() == llvm::Triple::IOS
+                && arch.GetTriple().getArch() == llvm::Triple::aarch64)
+            {
+                m_avoid_g_packets = eLazyBoolYes;
+                uint32_t gdb_server_version = GetGDBServerProgramVersion();
+                if (gdb_server_version != 0)
+                {
+                    const char *gdb_server_name = GetGDBServerProgramName();
+                    if (gdb_server_name && strcmp(gdb_server_name, "debugserver") == 0)
+                    {
+                        if (gdb_server_version >= 310)
+                            m_avoid_g_packets = eLazyBoolNo;
+                    }
+                }
+            }
+        }
+    }
+    return m_avoid_g_packets == eLazyBoolYes;
+}
+
+bool
 GDBRemoteCommunicationClient::ReadRegister(lldb::tid_t tid, uint32_t reg, StringExtractorGDBRemote &response)
 {
     Mutex::Locker locker;
@@ -3309,7 +3597,7 @@ GDBRemoteCommunicationClient::SaveRegisterState (lldb::tid_t tid, uint32_t &save
 bool
 GDBRemoteCommunicationClient::RestoreRegisterState (lldb::tid_t tid, uint32_t save_id)
 {
-    // We use the "m_supports_QSaveRegisterState" variable here becuase the
+    // We use the "m_supports_QSaveRegisterState" variable here because the
     // QSaveRegisterState and QRestoreRegisterState packets must both be supported in
     // order to be useful
     if (m_supports_QSaveRegisterState == eLazyBoolNo)
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
index a1e982b..fddcd6c 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h
@@ -92,7 +92,7 @@ public:
     // indicates if the packet was send and any response was received
     // even in the response is UNIMPLEMENTED. If the packet failed to
     // get a response, then false is returned. This quickly tells us
-    // if we were able to connect and communicte with the remote GDB
+    // if we were able to connect and communicate with the remote GDB
     // server
     bool
     QueryNoAckModeSupported ();
@@ -159,6 +159,10 @@ public:
 
     int
     SendLaunchArchPacket (const char *arch);
+    
+    int
+    SendLaunchEventDataPacket (const char *data, bool *was_supported = NULL);
+    
     //------------------------------------------------------------------
     /// Sends a "vAttach:PID" where PID is in hex. 
     ///
@@ -201,13 +205,25 @@ public:
     /// be launched with the 'A' packet.
     ///
     /// @param[in] enable
-    ///     A boolean value indicating wether to disable ASLR or not.
+    ///     A boolean value indicating whether to disable ASLR or not.
     ///
     /// @return
     ///     Zero if the for success, or an error code for failure.
     //------------------------------------------------------------------
     int
     SetDisableASLR (bool enable);
+    
+    //------------------------------------------------------------------
+    /// Sets the DetachOnError flag to \a enable for the process controlled by the stub.
+    ///
+    /// @param[in] enable
+    ///     A boolean value indicating whether to detach on error or not.
+    ///
+    /// @return
+    ///     Zero if the for success, or an error code for failure.
+    //------------------------------------------------------------------
+    int
+    SetDetachOnError (bool enable);
 
     //------------------------------------------------------------------
     /// Sets the working directory to \a path for a process that will 
@@ -217,7 +233,7 @@ public:
     /// directory for the platform process.
     ///
     /// @param[in] path
-    ///     The path to a directory to use when launching our processs
+    ///     The path to a directory to use when launching our process
     ///
     /// @return
     ///     Zero if the for success, or an error code for failure.
@@ -279,6 +295,9 @@ public:
     GetpPacketSupported (lldb::tid_t tid);
 
     bool
+    GetxPacketSupported ();
+
+    bool
     GetVAttachOrWaitSupported ();
     
     bool
@@ -384,6 +403,9 @@ public:
     SetCurrentThreadForRun (uint64_t tid);
 
     bool
+    GetQXferAuxvReadSupported ();
+
+    bool
     GetQXferLibrariesReadSupported ();
 
     bool
@@ -491,7 +513,19 @@ public:
     
     bool
     RestoreRegisterState (lldb::tid_t tid, uint32_t save_id);
+
+    const char *
+    GetGDBServerProgramName();
     
+    uint32_t
+    GetGDBServerProgramVersion();
+
+    bool
+    AvoidGPackets(ProcessGDBRemote *process);
+
+    bool
+    GetThreadExtendedInfoSupported();
+
 protected:
 
     PacketResult
@@ -502,6 +536,9 @@ protected:
     bool
     GetCurrentProcessInfo ();
 
+    bool
+    GetGDBServerVersion();
+
     //------------------------------------------------------------------
     // Classes that inherit from GDBRemoteCommunicationClient can see and modify these
     //------------------------------------------------------------------
@@ -515,7 +552,9 @@ protected:
     lldb_private::LazyBool m_supports_vCont_s;
     lldb_private::LazyBool m_supports_vCont_S;
     lldb_private::LazyBool m_qHostInfo_is_valid;
+    lldb_private::LazyBool m_curr_pid_is_valid;
     lldb_private::LazyBool m_qProcessInfo_is_valid;
+    lldb_private::LazyBool m_qGDBServerVersion_is_valid;
     lldb_private::LazyBool m_supports_alloc_dealloc_memory;
     lldb_private::LazyBool m_supports_memory_region_info;
     lldb_private::LazyBool m_supports_watchpoint_support_info;
@@ -524,10 +563,14 @@ protected:
     lldb_private::LazyBool m_attach_or_wait_reply;
     lldb_private::LazyBool m_prepare_for_reg_writing_reply;
     lldb_private::LazyBool m_supports_p;
+    lldb_private::LazyBool m_supports_x;
+    lldb_private::LazyBool m_avoid_g_packets;
     lldb_private::LazyBool m_supports_QSaveRegisterState;
+    lldb_private::LazyBool m_supports_qXfer_auxv_read;
     lldb_private::LazyBool m_supports_qXfer_libraries_read;
     lldb_private::LazyBool m_supports_qXfer_libraries_svr4_read;
     lldb_private::LazyBool m_supports_augmented_libraries_svr4_read;
+    lldb_private::LazyBool m_supports_jThreadExtendedInfo;
 
     bool
         m_supports_qProcessInfoPID:1,
@@ -543,7 +586,7 @@ protected:
         m_supports_QEnvironment:1,
         m_supports_QEnvironmentHexEncoded:1;
     
-
+    lldb::pid_t m_curr_pid;
     lldb::tid_t m_curr_tid;         // Current gdb remote protocol thread index for all other operations
     lldb::tid_t m_curr_tid_run;     // Current gdb remote protocol thread index for continue, step, etc
 
@@ -570,6 +613,8 @@ protected:
     std::string m_os_build;
     std::string m_os_kernel;
     std::string m_hostname;
+    std::string m_gdb_server_name; // from reply to qGDBServerVersion, empty if qGDBServerVersion is not supported
+    uint32_t m_gdb_server_version; // from reply to qGDBServerVersion, zero if qGDBServerVersion is not supported
     uint32_t m_default_packet_timeout;
     uint64_t m_max_packet_size;  // as returned by qSupported
     
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.cpp
index df95542..ffcdd16 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.cpp
@@ -9,24 +9,38 @@
 
 #include <errno.h>
 
+#include "lldb/Host/Config.h"
+
 #include "GDBRemoteCommunicationServer.h"
 #include "lldb/Core/StreamGDBRemote.h"
 
 // C Includes
 // C++ Includes
+#include <cstring>
+#include <chrono>
+#include <thread>
+
 // Other libraries and framework includes
 #include "llvm/ADT/Triple.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Core/ConnectionFileDescriptor.h"
+#include "lldb/Core/Debugger.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamString.h"
+#include "lldb/Host/Debug.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Host/File.h"
+#include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Host/HostInfo.h"
 #include "lldb/Host/TimeValue.h"
+#include "lldb/Target/FileAction.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
+#include "lldb/Target/NativeRegisterContext.h"
+#include "Host/common/NativeProcessProtocol.h"
+#include "Host/common/NativeThreadProtocol.h"
 
 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
@@ -37,6 +51,22 @@ using namespace lldb;
 using namespace lldb_private;
 
 //----------------------------------------------------------------------
+// GDBRemote Errors
+//----------------------------------------------------------------------
+
+namespace
+{
+    enum GDBRemoteServerError
+    {
+        // Set to the first unused error number in literal form below
+        eErrorFirst = 29,
+        eErrorNoProcess = eErrorFirst,
+        eErrorResume,
+        eErrorExitStatus
+    };
+}
+
+//----------------------------------------------------------------------
 // GDBRemoteCommunicationServer constructor
 //----------------------------------------------------------------------
 GDBRemoteCommunicationServer::GDBRemoteCommunicationServer(bool is_platform) :
@@ -50,12 +80,28 @@ GDBRemoteCommunicationServer::GDBRemoteCommunicationServer(bool is_platform) :
     m_proc_infos (),
     m_proc_infos_index (0),
     m_port_map (),
-    m_port_offset(0)
+    m_port_offset(0),
+    m_current_tid (LLDB_INVALID_THREAD_ID),
+    m_continue_tid (LLDB_INVALID_THREAD_ID),
+    m_debugged_process_mutex (Mutex::eMutexTypeRecursive),
+    m_debugged_process_sp (),
+    m_debugger_sp (),
+    m_stdio_communication ("process.stdio"),
+    m_exit_now (false),
+    m_inferior_prev_state (StateType::eStateInvalid),
+    m_thread_suffix_supported (false),
+    m_list_threads_in_stop_reply (false),
+    m_active_auxv_buffer_sp (),
+    m_saved_registers_mutex (),
+    m_saved_registers_map (),
+    m_next_saved_registers_id (1)
 {
+    assert(is_platform && "must be lldb-platform if debugger is not specified");
 }
 
 GDBRemoteCommunicationServer::GDBRemoteCommunicationServer(bool is_platform,
-                                                           const lldb::PlatformSP& platform_sp) :
+                                                           const lldb::PlatformSP& platform_sp,
+                                                           lldb::DebuggerSP &debugger_sp) :
     GDBRemoteCommunication ("gdb-remote.server", "gdb-remote.server.rx_packet", is_platform),
     m_platform_sp (platform_sp),
     m_async_thread (LLDB_INVALID_HOST_THREAD),
@@ -66,9 +112,24 @@ GDBRemoteCommunicationServer::GDBRemoteCommunicationServer(bool is_platform,
     m_proc_infos (),
     m_proc_infos_index (0),
     m_port_map (),
-    m_port_offset(0)
+    m_port_offset(0),
+    m_current_tid (LLDB_INVALID_THREAD_ID),
+    m_continue_tid (LLDB_INVALID_THREAD_ID),
+    m_debugged_process_mutex (Mutex::eMutexTypeRecursive),
+    m_debugged_process_sp (),
+    m_debugger_sp (debugger_sp),
+    m_stdio_communication ("process.stdio"),
+    m_exit_now (false),
+    m_inferior_prev_state (StateType::eStateInvalid),
+    m_thread_suffix_supported (false),
+    m_list_threads_in_stop_reply (false),
+    m_active_auxv_buffer_sp (),
+    m_saved_registers_mutex (),
+    m_saved_registers_map (),
+    m_next_saved_registers_id (1)
 {
     assert(platform_sp);
+    assert((is_platform || debugger_sp) && "must specify non-NULL debugger_sp when lldb-gdbserver");
 }
 
 //----------------------------------------------------------------------
@@ -78,37 +139,14 @@ GDBRemoteCommunicationServer::~GDBRemoteCommunicationServer()
 {
 }
 
-
-//void *
-//GDBRemoteCommunicationServer::AsyncThread (void *arg)
-//{
-//    GDBRemoteCommunicationServer *server = (GDBRemoteCommunicationServer*) arg;
-//
-//    Log *log;// (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
-//    if (log)
-//        log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) thread starting...", __FUNCTION__, arg, process->GetID());
-//
-//    StringExtractorGDBRemote packet;
-//
-//    while ()
-//    {
-//        if (packet.
-//    }
-//
-//    if (log)
-//        log->Printf ("ProcessGDBRemote::%s (arg = %p, pid = %i) thread exiting...", __FUNCTION__, arg, process->GetID());
-//
-//    process->m_async_thread = LLDB_INVALID_HOST_THREAD;
-//    return NULL;
-//}
-//
-bool
+GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::GetPacketAndSendResponse (uint32_t timeout_usec,
                                                         Error &error,
                                                         bool &interrupt,
                                                         bool &quit)
 {
     StringExtractorGDBRemote packet;
+
     PacketResult packet_result = WaitForPacketWithTimeoutMicroSecondsNoLock (packet, timeout_usec);
     if (packet_result == PacketResult::Success)
     {
@@ -124,11 +162,6 @@ GDBRemoteCommunicationServer::GetPacketAndSendResponse (uint32_t timeout_usec,
             quit = true;
             break;
 
-        case StringExtractorGDBRemote::eServerPacketType_interrupt:
-            error.SetErrorString("interrupt received");
-            interrupt = true;
-            break;
-
         default:
         case StringExtractorGDBRemote::eServerPacketType_unimplemented:
             packet_result = SendUnimplementedResponse (packet.GetStringRef().c_str());
@@ -164,6 +197,7 @@ GDBRemoteCommunicationServer::GetPacketAndSendResponse (uint32_t timeout_usec,
 
         case StringExtractorGDBRemote::eServerPacketType_k:
             packet_result = Handle_k (packet);
+            quit = true;
             break;
 
         case StringExtractorGDBRemote::eServerPacketType_qLaunchSuccess:
@@ -174,6 +208,10 @@ GDBRemoteCommunicationServer::GetPacketAndSendResponse (uint32_t timeout_usec,
             packet_result = Handle_qGroupName (packet);
             break;
 
+        case StringExtractorGDBRemote::eServerPacketType_qProcessInfo:
+            packet_result = Handle_qProcessInfo (packet);
+            break;
+                
         case StringExtractorGDBRemote::eServerPacketType_qProcessInfoPID:
             packet_result = Handle_qProcessInfoPID (packet);
             break;
@@ -202,6 +240,10 @@ GDBRemoteCommunicationServer::GetPacketAndSendResponse (uint32_t timeout_usec,
             packet_result = Handle_QSetDisableASLR (packet);
             break;
 
+        case StringExtractorGDBRemote::eServerPacketType_QSetDetachOnError:
+            packet_result = Handle_QSetDetachOnError (packet);
+            break;
+
         case StringExtractorGDBRemote::eServerPacketType_QSetSTDIN:
             packet_result = Handle_QSetSTDIN (packet);
             break;
@@ -234,6 +276,26 @@ GDBRemoteCommunicationServer::GetPacketAndSendResponse (uint32_t timeout_usec,
             packet_result = Handle_qPlatform_shell (packet);
             break;
 
+        case StringExtractorGDBRemote::eServerPacketType_C:
+            packet_result = Handle_C (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_c:
+            packet_result = Handle_c (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_vCont:
+            packet_result = Handle_vCont (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_vCont_actions:
+            packet_result = Handle_vCont_actions (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_stop_reason: // ?
+            packet_result = Handle_stop_reason (packet);
+            break;
+
         case StringExtractorGDBRemote::eServerPacketType_vFile_open:
             packet_result = Handle_vFile_Open (packet);
             break;
@@ -277,6 +339,96 @@ GDBRemoteCommunicationServer::GetPacketAndSendResponse (uint32_t timeout_usec,
         case StringExtractorGDBRemote::eServerPacketType_vFile_unlink:
             packet_result = Handle_vFile_unlink (packet);
             break;
+
+        case StringExtractorGDBRemote::eServerPacketType_qRegisterInfo:
+            packet_result = Handle_qRegisterInfo (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_qfThreadInfo:
+            packet_result = Handle_qfThreadInfo (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_qsThreadInfo:
+            packet_result = Handle_qsThreadInfo (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_p:
+            packet_result = Handle_p (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_P:
+            packet_result = Handle_P (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_H:
+            packet_result = Handle_H (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_m:
+            packet_result = Handle_m (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_M:
+            packet_result = Handle_M (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfoSupported:
+            packet_result = Handle_qMemoryRegionInfoSupported (packet);
+            break;
+                
+        case StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfo:
+            packet_result = Handle_qMemoryRegionInfo (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_interrupt:
+            if (IsGdbServer ())
+                packet_result = Handle_interrupt (packet);
+            else
+            {
+                error.SetErrorString("interrupt received");
+                interrupt = true;
+            }
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_Z:
+            packet_result = Handle_Z (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_z:
+            packet_result = Handle_z (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_s:
+            packet_result = Handle_s (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_qSupported:
+            packet_result = Handle_qSupported (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_QThreadSuffixSupported:
+            packet_result = Handle_QThreadSuffixSupported (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_QListThreadsInStopReply:
+            packet_result = Handle_QListThreadsInStopReply (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_qXfer_auxv_read:
+            packet_result = Handle_qXfer_auxv_read (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_QSaveRegisterState:
+            packet_result = Handle_QSaveRegisterState (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_QRestoreRegisterState:
+            packet_result = Handle_QRestoreRegisterState (packet);
+            break;
+
+        case StringExtractorGDBRemote::eServerPacketType_vAttach:
+            packet_result = Handle_vAttach (packet);
+            break;
         }
     }
     else
@@ -291,7 +443,12 @@ GDBRemoteCommunicationServer::GetPacketAndSendResponse (uint32_t timeout_usec,
             error.SetErrorString("timeout");
         }
     }
-    return packet_result == PacketResult::Success;
+
+    // Check if anything occurred that would force us to want to exit.
+    if (m_exit_now)
+        quit = true;
+
+    return packet_result;
 }
 
 lldb_private::Error
@@ -314,6 +471,96 @@ GDBRemoteCommunicationServer::SetLaunchFlags (unsigned int launch_flags)
 lldb_private::Error
 GDBRemoteCommunicationServer::LaunchProcess ()
 {
+    // FIXME This looks an awful lot like we could override this in
+    // derived classes, one for lldb-platform, the other for lldb-gdbserver.
+    if (IsGdbServer ())
+        return LaunchDebugServerProcess ();
+    else
+        return LaunchPlatformProcess ();
+}
+
+lldb_private::Error
+GDBRemoteCommunicationServer::LaunchDebugServerProcess ()
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    if (!m_process_launch_info.GetArguments ().GetArgumentCount ())
+        return lldb_private::Error ("%s: no process command line specified to launch", __FUNCTION__);
+
+    lldb_private::Error error;
+    {
+        Mutex::Locker locker (m_debugged_process_mutex);
+        assert (!m_debugged_process_sp && "lldb-gdbserver creating debugged process but one already exists");
+        error = m_platform_sp->LaunchNativeProcess (
+            m_process_launch_info,
+            *this,
+            m_debugged_process_sp);
+    }
+
+    if (!error.Success ())
+    {
+        fprintf (stderr, "%s: failed to launch executable %s", __FUNCTION__, m_process_launch_info.GetArguments ().GetArgumentAtIndex (0));
+        return error;
+    }
+
+    // Setup stdout/stderr mapping from inferior.
+    auto terminal_fd = m_debugged_process_sp->GetTerminalFileDescriptor ();
+    if (terminal_fd >= 0)
+    {
+        if (log)
+            log->Printf ("ProcessGDBRemoteCommunicationServer::%s setting inferior STDIO fd to %d", __FUNCTION__, terminal_fd);
+        error = SetSTDIOFileDescriptor (terminal_fd);
+        if (error.Fail ())
+            return error;
+    }
+    else
+    {
+        if (log)
+            log->Printf ("ProcessGDBRemoteCommunicationServer::%s ignoring inferior STDIO since terminal fd reported as %d", __FUNCTION__, terminal_fd);
+    }
+
+    printf ("Launched '%s' as process %" PRIu64 "...\n", m_process_launch_info.GetArguments ().GetArgumentAtIndex (0), m_process_launch_info.GetProcessID ());
+
+    // Add to list of spawned processes.
+    lldb::pid_t pid;
+    if ((pid = m_process_launch_info.GetProcessID ()) != LLDB_INVALID_PROCESS_ID)
+    {
+        // add to spawned pids
+        {
+            Mutex::Locker locker (m_spawned_pids_mutex);
+            // On an lldb-gdbserver, we would expect there to be only one.
+            assert (m_spawned_pids.empty () && "lldb-gdbserver adding tracked process but one already existed");
+            m_spawned_pids.insert (pid);
+        }
+    }
+
+    if (error.Success ())
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s beginning check to wait for launched application to hit first stop", __FUNCTION__);
+
+        int iteration = 0;
+        // Wait for the process to hit its first stop state.
+        while (!StateIsStoppedState (m_debugged_process_sp->GetState (), false))
+        {
+            if (log)
+                log->Printf ("GDBRemoteCommunicationServer::%s waiting for launched process to hit first stop (%d)...", __FUNCTION__, iteration++);
+
+            // FIXME use a finer granularity.
+            std::this_thread::sleep_for(std::chrono::seconds(1));
+        }
+
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s launched application has hit first stop", __FUNCTION__);
+
+    }
+
+    return error;
+}
+
+lldb_private::Error
+GDBRemoteCommunicationServer::LaunchPlatformProcess ()
+{
     if (!m_process_launch_info.GetArguments ().GetArgumentCount ())
         return lldb_private::Error ("%s: no process command line specified to launch", __FUNCTION__);
 
@@ -337,13 +584,571 @@ GDBRemoteCommunicationServer::LaunchProcess ()
     lldb::pid_t pid;
     if ( (pid = m_process_launch_info.GetProcessID()) != LLDB_INVALID_PROCESS_ID )
     {
+        // add to spawned pids
+        {
+            Mutex::Locker locker (m_spawned_pids_mutex);
+            m_spawned_pids.insert(pid);
+        }
+    }
+
+    return error;
+}
+
+lldb_private::Error
+GDBRemoteCommunicationServer::AttachToProcess (lldb::pid_t pid)
+{
+    Error error;
+
+    if (!IsGdbServer ())
+    {
+        error.SetErrorString("cannot AttachToProcess () unless process is lldb-gdbserver");
+        return error;
+    }
+
+    Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64, __FUNCTION__, pid);
+
+    // Scope for mutex locker.
+    {
+        // Before we try to attach, make sure we aren't already monitoring something else.
+        Mutex::Locker locker (m_spawned_pids_mutex);
+        if (!m_spawned_pids.empty ())
+        {
+            error.SetErrorStringWithFormat ("cannot attach to a process %" PRIu64 " when another process with pid %" PRIu64 " is being debugged.", pid, *m_spawned_pids.begin());
+            return error;
+        }
+
+        // Try to attach.
+        error = m_platform_sp->AttachNativeProcess (pid, *this, m_debugged_process_sp);
+        if (!error.Success ())
+        {
+            fprintf (stderr, "%s: failed to attach to process %" PRIu64 ": %s", __FUNCTION__, pid, error.AsCString ());
+            return error;
+        }
+
+        // Setup stdout/stderr mapping from inferior.
+        auto terminal_fd = m_debugged_process_sp->GetTerminalFileDescriptor ();
+        if (terminal_fd >= 0)
+        {
+            if (log)
+                log->Printf ("ProcessGDBRemoteCommunicationServer::%s setting inferior STDIO fd to %d", __FUNCTION__, terminal_fd);
+            error = SetSTDIOFileDescriptor (terminal_fd);
+            if (error.Fail ())
+                return error;
+        }
+        else
+        {
+            if (log)
+                log->Printf ("ProcessGDBRemoteCommunicationServer::%s ignoring inferior STDIO since terminal fd reported as %d", __FUNCTION__, terminal_fd);
+        }
+
+        printf ("Attached to process %" PRIu64 "...\n", pid);
+
+        // Add to list of spawned processes.
+        assert (m_spawned_pids.empty () && "lldb-gdbserver adding tracked process but one already existed");
+        m_spawned_pids.insert (pid);
+
+        return error;
+    }
+}
+
+void
+GDBRemoteCommunicationServer::InitializeDelegate (lldb_private::NativeProcessProtocol *process)
+{
+    assert (process && "process cannot be NULL");
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+    if (log)
+    {
+        log->Printf ("GDBRemoteCommunicationServer::%s called with NativeProcessProtocol pid %" PRIu64 ", current state: %s",
+                __FUNCTION__,
+                process->GetID (),
+                StateAsCString (process->GetState ()));
+    }
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::SendWResponse (lldb_private::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 ("GDBRemoteCommunicationServer::%s pid %" PRIu64 ", failed to retrieve process exit status", __FUNCTION__, process->GetID ());
+
+        StreamGDBRemote response;
+        response.PutChar ('E');
+        response.PutHex8 (GDBRemoteServerError::eErrorExitStatus);
+        return SendPacketNoLock(response.GetData(), response.GetSize());
+    }
+    else
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%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:
+            default:                        return_type_code = 'E'; break;
+        }
+        response.PutChar (return_type_code);
+
+        // POSIX exit status limited to unsigned 8 bits.
+        response.PutHex8 (return_code);
+
+        return SendPacketNoLock(response.GetData(), response.GetSize());
+    }
+}
+
+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
+    {
+        for (i = 0; i < buf_size; i++)
+            response.PutHex8 (buf[i]);
+    }
+}
+
+static void
+WriteRegisterValueInHexFixedWidth (StreamString &response,
+                                   NativeRegisterContextSP &reg_ctx_sp,
+                                   const RegisterInfo &reg_info,
+                                   const RegisterValue *reg_value_p)
+{
+    RegisterValue reg_value;
+    if (!reg_value_p)
+    {
+        Error error = reg_ctx_sp->ReadRegister (&reg_info, reg_value);
+        if (error.Success ())
+            reg_value_p = &reg_value;
+        // else log.
+    }
+
+    if (reg_value_p)
+    {
+        AppendHexValue (response, (const uint8_t*) reg_value_p->GetBytes (), reg_value_p->GetByteSize (), false);
+    }
+    else
+    {
+        // Zero-out any unreadable values.
+        if (reg_info.byte_size > 0)
+        {
+            std::basic_string<uint8_t> zeros(reg_info.byte_size, '\0');
+            AppendHexValue (response, zeros.data(), zeros.size(), false);
+        }
+    }
+}
+
+// WriteGdbRegnumWithFixedWidthHexRegisterValue (response, reg_ctx_sp, *reg_info_p, reg_value);
+
+
+static void
+WriteGdbRegnumWithFixedWidthHexRegisterValue (StreamString &response,
+                                              NativeRegisterContextSP &reg_ctx_sp,
+                                              const RegisterInfo &reg_info,
+                                              const RegisterValue &reg_value)
+{
+    // Output the register number as 'NN:VVVVVVVV;' where NN is a 2 bytes HEX
+    // gdb register number, and VVVVVVVV is the correct number of hex bytes
+    // as ASCII for the register value.
+    if (reg_info.kinds[eRegisterKindGDB] == LLDB_INVALID_REGNUM)
+        return;
+
+    response.Printf ("%.02x:", reg_info.kinds[eRegisterKindGDB]);
+    WriteRegisterValueInHexFixedWidth (response, reg_ctx_sp, reg_info, &reg_value);
+    response.PutChar (';');
+}
+
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::SendStopReplyPacketForThread (lldb::tid_t tid)
+{
+    Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
+
+    // Ensure we're llgs.
+    if (!IsGdbServer ())
+    {
+        // Only supported on llgs
+        return SendUnimplementedResponse ("");
+    }
+
+    // Ensure we have a debugged process.
+    if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
+        return SendErrorResponse (50);
+
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s preparing packet for pid %" PRIu64 " tid %" PRIu64,
+                __FUNCTION__, m_debugged_process_sp->GetID (), tid);
+
+    // Ensure we can get info on the given thread.
+    NativeThreadProtocolSP thread_sp (m_debugged_process_sp->GetThreadByID (tid));
+    if (!thread_sp)
+        return SendErrorResponse (51);
+
+    // Grab the reason this thread stopped.
+    struct ThreadStopInfo tid_stop_info;
+    if (!thread_sp->GetStopReason (tid_stop_info))
+        return SendErrorResponse (52);
+
+    const bool did_exec = tid_stop_info.reason == eStopReasonExec;
+    // FIXME implement register handling for exec'd inferiors.
+    // if (did_exec)
+    // {
+    //     const bool force = true;
+    //     InitializeRegisters(force);
+    // }
+
+    StreamString response;
+    // Output the T packet with the thread
+    response.PutChar ('T');
+    int signum = tid_stop_info.details.signal.signo;
+    if (log)
+    {
+        log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " tid %" PRIu64 " got signal signo = %d, reason = %d, exc_type = %" PRIu64, 
+                __FUNCTION__,
+                m_debugged_process_sp->GetID (),
+                tid,
+                signum,
+                tid_stop_info.reason,
+                tid_stop_info.details.exception.type);
+    }
+
+    switch (tid_stop_info.reason)
+    {
+    case eStopReasonSignal:
+    case eStopReasonException:
+        signum = thread_sp->TranslateStopInfoToGdbSignal (tid_stop_info);
+        break;
+    default:
+        signum = 0;
+        if (log)
+        {
+            log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " tid %" PRIu64 " has stop reason %d, using signo = 0 in stop reply response",
+                __FUNCTION__,
+                m_debugged_process_sp->GetID (),
+                tid,
+                tid_stop_info.reason);
+        }
+        break;
+    }
+
+    // Print the signal number.
+    response.PutHex8 (signum & 0xff);
+
+    // Include the tid.
+    response.Printf ("thread:%" PRIx64 ";", tid);
+
+    // Include the thread name if there is one.
+    const char *thread_name = thread_sp->GetName ();
+    if (thread_name && thread_name[0])
+    {
+        size_t thread_name_len = strlen(thread_name);
+
+        if (::strcspn (thread_name, "$#+-;:") == thread_name_len)
+        {
+            response.PutCString ("name:");
+            response.PutCString (thread_name);
+        }
+        else
+        {
+            // The thread name contains special chars, send as hex bytes.
+            response.PutCString ("hexname:");
+            response.PutCStringAsRawHex8 (thread_name);
+        }
+        response.PutChar (';');
+    }
+
+    // FIXME look for analog
+    // thread_identifier_info_data_t thread_ident_info;
+    // if (DNBThreadGetIdentifierInfo (pid, tid, &thread_ident_info))
+    // {
+    //     if (thread_ident_info.dispatch_qaddr != 0)
+    //         ostrm << std::hex << "qaddr:" << thread_ident_info.dispatch_qaddr << ';';
+    // }
+
+    // If a 'QListThreadsInStopReply' was sent to enable this feature, we
+    // will send all thread IDs back in the "threads" key whose value is
+    // a list of hex thread IDs separated by commas:
+    //  "threads:10a,10b,10c;"
+    // This will save the debugger from having to send a pair of qfThreadInfo
+    // and qsThreadInfo packets, but it also might take a lot of room in the
+    // stop reply packet, so it must be enabled only on systems where there
+    // are no limits on packet lengths.
+    if (m_list_threads_in_stop_reply)
+    {
+        response.PutCString ("threads:");
+
+        uint32_t thread_index = 0;
+        NativeThreadProtocolSP listed_thread_sp;
+        for (listed_thread_sp = m_debugged_process_sp->GetThreadAtIndex (thread_index); listed_thread_sp; ++thread_index, listed_thread_sp = m_debugged_process_sp->GetThreadAtIndex (thread_index))
+        {
+            if (thread_index > 0)
+                response.PutChar (',');
+            response.Printf ("%" PRIx64, listed_thread_sp->GetID ());
+        }
+        response.PutChar (';');
+    }
+
+    //
+    // Expedite registers.
+    //
+
+    // Grab the register context.
+    NativeRegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext ();
+    if (reg_ctx_sp)
+    {
+        // Expedite all registers in the first register set (i.e. should be GPRs) that are not contained in other registers.
+        const RegisterSet *reg_set_p;
+        if (reg_ctx_sp->GetRegisterSetCount () > 0 && ((reg_set_p = reg_ctx_sp->GetRegisterSet (0)) != nullptr))
+        {
+            if (log)
+                log->Printf ("GDBRemoteCommunicationServer::%s expediting registers from set '%s' (registers set count: %zu)", __FUNCTION__, reg_set_p->name ? reg_set_p->name : "<unnamed-set>", reg_set_p->num_registers);
+
+            for (const uint32_t *reg_num_p = reg_set_p->registers; *reg_num_p != LLDB_INVALID_REGNUM; ++reg_num_p)
+            {
+                const RegisterInfo *const reg_info_p = reg_ctx_sp->GetRegisterInfoAtIndex (*reg_num_p);
+                if (reg_info_p == nullptr)
+                {
+                    if (log)
+                        log->Printf ("GDBRemoteCommunicationServer::%s failed to get register info for register set '%s', register index %" PRIu32, __FUNCTION__, reg_set_p->name ? reg_set_p->name : "<unnamed-set>", *reg_num_p);
+                }
+                else if (reg_info_p->value_regs == nullptr)
+                {
+                    // Only expediate registers that are not contained in other registers.
+                    RegisterValue reg_value;
+                    Error error = reg_ctx_sp->ReadRegister (reg_info_p, reg_value);
+                    if (error.Success ())
+                        WriteGdbRegnumWithFixedWidthHexRegisterValue (response, reg_ctx_sp, *reg_info_p, reg_value);
+                    else
+                    {
+                        if (log)
+                            log->Printf ("GDBRemoteCommunicationServer::%s failed to read register '%s' index %" PRIu32 ": %s", __FUNCTION__, reg_info_p->name ? reg_info_p->name : "<unnamed-register>", *reg_num_p, error.AsCString ());
+
+                    }
+                }
+            }
+        }
+    }
+
+    if (did_exec)
+    {
+        response.PutCString ("reason:exec;");
+    }
+    else if ((tid_stop_info.reason == eStopReasonException) && tid_stop_info.details.exception.type)
+    {
+        response.PutCString ("metype:");
+        response.PutHex64 (tid_stop_info.details.exception.type);
+        response.PutCString (";mecount:");
+        response.PutHex32 (tid_stop_info.details.exception.data_count);
+        response.PutChar (';');
+
+        for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; ++i)
+        {
+            response.PutCString ("medata:");
+            response.PutHex64 (tid_stop_info.details.exception.data[i]);
+            response.PutChar (';');
+        }
+    }
+
+    return SendPacketNoLock (response.GetData(), response.GetSize());
+}
+
+void
+GDBRemoteCommunicationServer::HandleInferiorState_Exited (lldb_private::NativeProcessProtocol *process)
+{
+    assert (process && "process cannot be NULL");
+
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s called", __FUNCTION__);
+
+    // Send the exit result, and don't flush output.
+    // Note: flushing output here would join the inferior stdio reflection thread, which
+    // would gunk up the waitpid monitor thread that is calling this.
+    PacketResult result = SendStopReasonForState (StateType::eStateExited, false);
+    if (result != PacketResult::Success)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed to send stop notification for PID %" PRIu64 ", state: eStateExited", __FUNCTION__, process->GetID ());
+    }
+
+    // Remove the process from the list of spawned pids.
+    {
         Mutex::Locker locker (m_spawned_pids_mutex);
-        m_spawned_pids.insert(pid);
+        if (m_spawned_pids.erase (process->GetID ()) < 1)
+        {
+            if (log)
+                log->Printf ("GDBRemoteCommunicationServer::%s failed to remove PID %" PRIu64 " from the spawned pids list", __FUNCTION__, process->GetID ());
+
+        }
     }
 
+    // FIXME can't do this yet - since process state propagation is currently
+    // synchronous, it is running off the NativeProcessProtocol's innards and
+    // will tear down the NPP while it still has code to execute.
+#if 0
+    // Clear the NativeProcessProtocol pointer.
+    {
+        Mutex::Locker locker (m_debugged_process_mutex);
+        m_debugged_process_sp.reset();
+    }
+#endif
+
+    // Close the pipe to the inferior terminal i/o if we launched it
+    // and set one up.  Otherwise, 'k' and its flush of stdio could
+    // end up waiting on a thread join that will never end.  Consider
+    // adding a timeout to the connection thread join call so we
+    // can avoid that scenario altogether.
+    MaybeCloseInferiorTerminalConnection ();
+
+    // We are ready to exit the debug monitor.
+    m_exit_now = true;
+}
+
+void
+GDBRemoteCommunicationServer::HandleInferiorState_Stopped (lldb_private::NativeProcessProtocol *process)
+{
+    assert (process && "process cannot be NULL");
+
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s called", __FUNCTION__);
+
+    // Send the stop reason unless this is the stop after the
+    // launch or attach.
+    switch (m_inferior_prev_state)
+    {
+        case eStateLaunching:
+        case eStateAttaching:
+            // Don't send anything per debugserver behavior.
+            break;
+        default:
+            // In all other cases, send the stop reason.
+            PacketResult result = SendStopReasonForState (StateType::eStateStopped, false);
+            if (result != PacketResult::Success)
+            {
+                if (log)
+                    log->Printf ("GDBRemoteCommunicationServer::%s failed to send stop notification for PID %" PRIu64 ", state: eStateExited", __FUNCTION__, process->GetID ());
+            }
+            break;
+    }
+}
+
+void
+GDBRemoteCommunicationServer::ProcessStateChanged (lldb_private::NativeProcessProtocol *process, lldb::StateType state)
+{
+    assert (process && "process cannot be NULL");
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+    if (log)
+    {
+        log->Printf ("GDBRemoteCommunicationServer::%s called with NativeProcessProtocol pid %" PRIu64 ", state: %s",
+                __FUNCTION__,
+                process->GetID (),
+                StateAsCString (state));
+    }
+
+    switch (state)
+    {
+    case StateType::eStateExited:
+        HandleInferiorState_Exited (process);
+        break;
+
+    case StateType::eStateStopped:
+        HandleInferiorState_Stopped (process);
+        break;
+
+    default:
+        if (log)
+        {
+            log->Printf ("GDBRemoteCommunicationServer::%s didn't handle state change for pid %" PRIu64 ", new state: %s",
+                    __FUNCTION__,
+                    process->GetID (),
+                    StateAsCString (state));
+        }
+        break;
+    }
+
+    // Remember the previous state reported to us.
+    m_inferior_prev_state = state;
+}
+
+void
+GDBRemoteCommunicationServer::DidExec (NativeProcessProtocol *process)
+{
+    ClearProcessSpecificData ();
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::SendONotification (const char *buffer, uint32_t len)
+{
+    if ((buffer == nullptr) || (len == 0))
+    {
+        // Nothing to send.
+        return PacketResult::Success;
+    }
+
+    StreamString response;
+    response.PutChar ('O');
+    response.PutBytesAsRawHex8 (buffer, len);
+
+    return SendPacketNoLock (response.GetData (), response.GetSize ());
+}
+
+lldb_private::Error
+GDBRemoteCommunicationServer::SetSTDIOFileDescriptor (int fd)
+{
+    Error error;
+
+    // Set up the Read Thread for reading/handling process I/O
+    std::unique_ptr<ConnectionFileDescriptor> conn_up (new ConnectionFileDescriptor (fd, true));
+    if (!conn_up)
+    {
+        error.SetErrorString ("failed to create ConnectionFileDescriptor");
+        return error;
+    }
+
+    m_stdio_communication.SetConnection (conn_up.release());
+    if (!m_stdio_communication.IsConnected ())
+    {
+        error.SetErrorString ("failed to set connection for inferior I/O communication");
+        return error;
+    }
+
+    m_stdio_communication.SetReadThreadBytesReceivedCallback (STDIOReadThreadBytesReceived, this);
+    m_stdio_communication.StartReadThread();
+
     return error;
 }
 
+void
+GDBRemoteCommunicationServer::STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len)
+{
+    GDBRemoteCommunicationServer *server = reinterpret_cast<GDBRemoteCommunicationServer*> (baton);
+    static_cast<void> (server->SendONotification (static_cast<const char *>(src), src_len));
+}
+
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::SendUnimplementedResponse (const char *)
 {
@@ -351,6 +1156,7 @@ GDBRemoteCommunicationServer::SendUnimplementedResponse (const char *)
     return SendPacketNoLock ("", 0);
 }
 
+
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::SendErrorResponse (uint8_t err)
 {
@@ -360,6 +1166,14 @@ GDBRemoteCommunicationServer::SendErrorResponse (uint8_t err)
     return SendPacketNoLock (packet, packet_len);
 }
 
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::SendIllFormedResponse (const StringExtractorGDBRemote &failed_packet, const char *message)
+{
+    Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PACKETS));
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s: ILLFORMED: '%s' (%s)", __FUNCTION__, failed_packet.GetStringRef ().c_str (), message ? message : "");
+    return SendErrorResponse (0x03);
+}
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::SendOKResponse ()
@@ -380,10 +1194,10 @@ GDBRemoteCommunicationServer::Handle_qHostInfo (StringExtractorGDBRemote &packet
 
     // $cputype:16777223;cpusubtype:3;ostype:Darwin;vendor:apple;endian:little;ptrsize:8;#00
 
-    ArchSpec host_arch (Host::GetArchitecture ());
+    ArchSpec host_arch(HostInfo::GetArchitecture());
     const llvm::Triple &host_triple = host_arch.GetTriple();
     response.PutCString("triple:");
-    response.PutCStringAsRawHex8(host_triple.getTriple().c_str());
+    response.PutCString(host_triple.getTriple().c_str());
     response.Printf (";ptrsize:%u;",host_arch.GetAddressByteSize());
 
     const char* distribution_id = host_arch.GetDistributionId ().AsCString ();
@@ -394,6 +1208,8 @@ GDBRemoteCommunicationServer::Handle_qHostInfo (StringExtractorGDBRemote &packet
         response.PutCString(";");
     }
 
+    // Only send out MachO info when lldb-platform/llgs is running on a MachO host.
+#if defined(__APPLE__)
     uint32_t cpu = host_arch.GetMachOCPUType();
     uint32_t sub = host_arch.GetMachOCPUSubType();
     if (cpu != LLDB_INVALID_CPUTYPE)
@@ -405,6 +1221,9 @@ GDBRemoteCommunicationServer::Handle_qHostInfo (StringExtractorGDBRemote &packet
         response.Printf("watchpoint_exceptions_received:before;");   // On armv7 we use "synchronous" watchpoints which means the exception is delivered before the instruction executes.
     else
         response.Printf("watchpoint_exceptions_received:after;");
+#else
+    response.Printf("watchpoint_exceptions_received:after;");
+#endif
 
     switch (lldb::endian::InlHostByteOrder())
     {
@@ -417,7 +1236,7 @@ GDBRemoteCommunicationServer::Handle_qHostInfo (StringExtractorGDBRemote &packet
     uint32_t major = UINT32_MAX;
     uint32_t minor = UINT32_MAX;
     uint32_t update = UINT32_MAX;
-    if (Host::GetOSVersion (major, minor, update))
+    if (HostInfo::GetOSVersion(major, minor, update))
     {
         if (major != UINT32_MAX)
         {
@@ -433,39 +1252,41 @@ GDBRemoteCommunicationServer::Handle_qHostInfo (StringExtractorGDBRemote &packet
     }
 
     std::string s;
-    if (Host::GetOSBuildString (s))
+#if !defined(__linux__)
+    if (HostInfo::GetOSBuildString(s))
     {
         response.PutCString ("os_build:");
         response.PutCStringAsRawHex8(s.c_str());
         response.PutChar(';');
     }
-    if (Host::GetOSKernelDescription (s))
+    if (HostInfo::GetOSKernelDescription(s))
     {
         response.PutCString ("os_kernel:");
         response.PutCStringAsRawHex8(s.c_str());
         response.PutChar(';');
     }
+#endif
+
 #if defined(__APPLE__)
 
-#if defined(__arm__)
+#if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
     // For iOS devices, we are connected through a USB Mux so we never pretend
     // to actually have a hostname as far as the remote lldb that is connecting
     // to this lldb-platform is concerned
     response.PutCString ("hostname:");
-    response.PutCStringAsRawHex8("localhost");
+    response.PutCStringAsRawHex8("127.0.0.1");
     response.PutChar(';');
-#else   // #if defined(__arm__)
-    if (Host::GetHostname (s))
+#else   // #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
+    if (HostInfo::GetHostname(s))
     {
         response.PutCString ("hostname:");
         response.PutCStringAsRawHex8(s.c_str());
         response.PutChar(';');
     }
-
-#endif  // #if defined(__arm__)
+#endif  // #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
 
 #else   // #if defined(__APPLE__)
-    if (Host::GetHostname (s))
+    if (HostInfo::GetHostname(s))
     {
         response.PutCString ("hostname:");
         response.PutCStringAsRawHex8(s.c_str());
@@ -494,11 +1315,105 @@ CreateProcessInfoResponse (const ProcessInstanceInfo &proc_info, StreamString &r
     {
         const llvm::Triple &proc_triple = proc_arch.GetTriple();
         response.PutCString("triple:");
-        response.PutCStringAsRawHex8(proc_triple.getTriple().c_str());
+        response.PutCString(proc_triple.getTriple().c_str());
         response.PutChar(';');
     }
 }
 
+static void
+CreateProcessInfoResponse_DebugServerStyle (const ProcessInstanceInfo &proc_info, StreamString &response)
+{
+    response.Printf ("pid:%" PRIx64 ";parent-pid:%" PRIx64 ";real-uid:%x;real-gid:%x;effective-uid:%x;effective-gid:%x;",
+                     proc_info.GetProcessID(),
+                     proc_info.GetParentProcessID(),
+                     proc_info.GetUserID(),
+                     proc_info.GetGroupID(),
+                     proc_info.GetEffectiveUserID(),
+                     proc_info.GetEffectiveGroupID());
+
+    const ArchSpec &proc_arch = proc_info.GetArchitecture();
+    if (proc_arch.IsValid())
+    {
+        const llvm::Triple &proc_triple = proc_arch.GetTriple();
+#if defined(__APPLE__)
+        // We'll send cputype/cpusubtype.
+        const uint32_t cpu_type = proc_arch.GetMachOCPUType();
+        if (cpu_type != 0)
+            response.Printf ("cputype:%" PRIx32 ";", cpu_type);
+        
+        const uint32_t cpu_subtype = proc_arch.GetMachOCPUSubType();
+        if (cpu_subtype != 0)
+            response.Printf ("cpusubtype:%" PRIx32 ";", cpu_subtype);
+
+        
+        const std::string vendor = proc_triple.getVendorName ();
+        if (!vendor.empty ())
+            response.Printf ("vendor:%s;", vendor.c_str ());
+#else
+        // We'll send the triple.
+        response.Printf ("triple:%s;", proc_triple.getTriple().c_str ());
+#endif
+        std::string ostype = proc_triple.getOSName ();
+        // Adjust so ostype reports ios for Apple/ARM and Apple/ARM64.
+        if (proc_triple.getVendor () == llvm::Triple::Apple)
+        {
+            switch (proc_triple.getArch ())
+            {
+                case llvm::Triple::arm:
+                case llvm::Triple::aarch64:
+                    ostype = "ios";
+                    break;
+                default:
+                    // No change.
+                    break;
+            }
+        }
+        response.Printf ("ostype:%s;", ostype.c_str ());
+
+
+        switch (proc_arch.GetByteOrder ())
+        {
+            case lldb::eByteOrderLittle: response.PutCString ("endian:little;"); break;
+            case lldb::eByteOrderBig:    response.PutCString ("endian:big;");    break;
+            case lldb::eByteOrderPDP:    response.PutCString ("endian:pdp;");    break;
+            default:
+                // Nothing.
+                break;
+        }
+
+        if (proc_triple.isArch64Bit ())
+            response.PutCString ("ptrsize:8;");
+        else if (proc_triple.isArch32Bit ())
+            response.PutCString ("ptrsize:4;");
+        else if (proc_triple.isArch16Bit ())
+            response.PutCString ("ptrsize:2;");
+    }
+
+}
+
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::Handle_qProcessInfo (StringExtractorGDBRemote &packet)
+{
+    // Only the gdb server handles this.
+    if (!IsGdbServer ())
+        return SendUnimplementedResponse (packet.GetStringRef ().c_str ());
+    
+    // Fail if we don't have a current process.
+    if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
+        return SendErrorResponse (68);
+    
+    ProcessInstanceInfo proc_info;
+    if (Host::GetProcessInfo (m_debugged_process_sp->GetID (), proc_info))
+    {
+        StreamString response;
+        CreateProcessInfoResponse_DebugServerStyle(proc_info, response);
+        return SendPacketNoLock (response.GetData (), response.GetSize ());
+    }
+    
+    return SendErrorResponse (1);
+}
+
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_qProcessInfoPID (StringExtractorGDBRemote &packet)
 {
@@ -635,19 +1550,21 @@ GDBRemoteCommunicationServer::Handle_qsProcessInfo (StringExtractorGDBRemote &pa
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_qUserName (StringExtractorGDBRemote &packet)
 {
+#if !defined(LLDB_DISABLE_POSIX)
     // Packet format: "qUserName:%i" where %i is the uid
     packet.SetFilePos(::strlen ("qUserName:"));
     uint32_t uid = packet.GetU32 (UINT32_MAX);
     if (uid != UINT32_MAX)
     {
         std::string name;
-        if (Host::GetUserName (uid, name))
+        if (HostInfo::LookupUserName(uid, name))
         {
             StreamString response;
             response.PutCStringAsRawHex8 (name.c_str());
             return SendPacketNoLock (response.GetData(), response.GetSize());
         }
     }
+#endif
     return SendErrorResponse (5);
 
 }
@@ -655,19 +1572,21 @@ GDBRemoteCommunicationServer::Handle_qUserName (StringExtractorGDBRemote &packet
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_qGroupName (StringExtractorGDBRemote &packet)
 {
+#if !defined(LLDB_DISABLE_POSIX)
     // Packet format: "qGroupName:%i" where %i is the gid
     packet.SetFilePos(::strlen ("qGroupName:"));
     uint32_t gid = packet.GetU32 (UINT32_MAX);
     if (gid != UINT32_MAX)
     {
         std::string name;
-        if (Host::GetGroupName (gid, name))
+        if (HostInfo::LookupGroupName(gid, name))
         {
             StreamString response;
             response.PutCStringAsRawHex8 (name.c_str());
             return SendPacketNoLock (response.GetData(), response.GetSize());
         }
     }
+#endif
     return SendErrorResponse (6);
 }
 
@@ -708,27 +1627,6 @@ GDBRemoteCommunicationServer::Handle_qSpeedTest (StringExtractorGDBRemote &packe
     return SendErrorResponse (7);
 }
 
-
-static void *
-AcceptPortFromInferior (void *arg)
-{
-    const char *connect_url = (const char *)arg;
-    ConnectionFileDescriptor file_conn;
-    Error error;
-    if (file_conn.Connect (connect_url, &error) == eConnectionStatusSuccess)
-    {
-        char pid_str[256];
-        ::memset (pid_str, 0, sizeof(pid_str));
-        ConnectionStatus status;
-        const size_t pid_str_len = file_conn.Read (pid_str, sizeof(pid_str), 0, status, NULL);
-        if (pid_str_len > 0)
-        {
-            int pid = atoi (pid_str);
-            return (void *)(intptr_t)pid;
-        }
-    }
-    return NULL;
-}
 //
 //static bool
 //WaitForProcessToSIGSTOP (const lldb::pid_t pid, const int timeout_in_seconds)
@@ -772,6 +1670,9 @@ GDBRemoteCommunicationServer::Handle_A (StringExtractorGDBRemote &packet)
     // separated hex encoded argument value list, but we will stay true to the
     // documented version of the 'A' packet here...
 
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+    int actual_arg_index = 0;
+
     packet.SetFilePos(1); // Skip the 'A'
     bool success = true;
     while (success && packet.GetBytesLeft() > 0)
@@ -788,7 +1689,7 @@ GDBRemoteCommunicationServer::Handle_A (StringExtractorGDBRemote &packet)
                 success = false;
             else
             {
-                // Decode the argument index. We ignore this really becuase
+                // Decode the argument index. We ignore this really because
                 // who would really send down the arguments in a random order???
                 const uint32_t arg_idx = packet.GetU32(UINT32_MAX);
                 if (arg_idx == UINT32_MAX)
@@ -804,11 +1705,11 @@ GDBRemoteCommunicationServer::Handle_A (StringExtractorGDBRemote &packet)
                         // back into a UTF8 string and make sure the length
                         // matches the one supplied in the packet
                         std::string arg;
-                        if (packet.GetHexByteString(arg) != (arg_len / 2))
+                        if (packet.GetHexByteStringFixedLength(arg, arg_len) != (arg_len / 2))
                             success = false;
                         else
                         {
-                            // If there are any bytes lft
+                            // If there are any bytes left
                             if (packet.GetBytesLeft())
                             {
                                 if (packet.GetChar() != ',')
@@ -820,6 +1721,9 @@ GDBRemoteCommunicationServer::Handle_A (StringExtractorGDBRemote &packet)
                                 if (arg_idx == 0)
                                     m_process_launch_info.GetExecutableFile().SetFile(arg.c_str(), false);
                                 m_process_launch_info.GetArguments().AppendArgument(arg.c_str());
+                                if (log)
+                                    log->Printf ("GDBRemoteCommunicationServer::%s added arg %d: \"%s\"", __FUNCTION__, actual_arg_index, arg.c_str ());
+                                ++actual_arg_index;
                             }
                         }
                     }
@@ -830,15 +1734,20 @@ GDBRemoteCommunicationServer::Handle_A (StringExtractorGDBRemote &packet)
 
     if (success)
     {
-        // FIXME: remove linux restriction once eLaunchFlagDebug is supported
-#if !defined (__linux__)
-        m_process_launch_info.GetFlags().Set (eLaunchFlagDebug);
-#endif
         m_process_launch_error = LaunchProcess ();
         if (m_process_launch_info.GetProcessID() != LLDB_INVALID_PROCESS_ID)
         {
             return SendOKResponse ();
         }
+        else
+        {
+            Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+            if (log)
+                log->Printf("GDBRemoteCommunicationServer::%s failed to launch exe: %s",
+                        __FUNCTION__,
+                        m_process_launch_error.AsCString());
+
+        }
     }
     return SendErrorResponse (8);
 }
@@ -846,22 +1755,51 @@ GDBRemoteCommunicationServer::Handle_A (StringExtractorGDBRemote &packet)
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_qC (StringExtractorGDBRemote &packet)
 {
-    lldb::pid_t pid = m_process_launch_info.GetProcessID();
     StreamString response;
-    response.Printf("QC%" PRIx64, pid);
-    if (m_is_platform)
+
+    if (IsGdbServer ())
+    {
+        // Fail if we don't have a current process.
+        if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
+            return SendErrorResponse (68);
+
+        // Make sure we set the current thread so g and p packets return
+        // the data the gdb will expect.
+        lldb::tid_t tid = m_debugged_process_sp->GetCurrentThreadID ();
+        SetCurrentThreadID (tid);
+
+        NativeThreadProtocolSP thread_sp = m_debugged_process_sp->GetCurrentThread ();
+        if (!thread_sp)
+            return SendErrorResponse (69);
+
+        response.Printf ("QC%" PRIx64, thread_sp->GetID ());
+    }
+    else
     {
-        // If we launch a process and this GDB server is acting as a platform,
-        // then we need to clear the process launch state so we can start
-        // launching another process. In order to launch a process a bunch or
-        // packets need to be sent: environment packets, working directory,
-        // disable ASLR, and many more settings. When we launch a process we
-        // then need to know when to clear this information. Currently we are
-        // selecting the 'qC' packet as that packet which seems to make the most
-        // sense.
-        if (pid != LLDB_INVALID_PROCESS_ID)
+        // NOTE: lldb should now be using qProcessInfo for process IDs.  This path here
+        // should not be used.  It is reporting process id instead of thread id.  The
+        // correct answer doesn't seem to make much sense for lldb-platform.
+        // CONSIDER: flip to "unsupported".
+        lldb::pid_t pid = m_process_launch_info.GetProcessID();
+        response.Printf("QC%" PRIx64, pid);
+
+        // this should always be platform here
+        assert (m_is_platform && "this code path should only be traversed for lldb-platform");
+
+        if (m_is_platform)
         {
-            m_process_launch_info.Clear();
+            // If we launch a process and this GDB server is acting as a platform,
+            // then we need to clear the process launch state so we can start
+            // launching another process. In order to launch a process a bunch or
+            // packets need to be sent: environment packets, working directory,
+            // disable ASLR, and many more settings. When we launch a process we
+            // then need to know when to clear this information. Currently we are
+            // selecting the 'qC' packet as that packet which seems to make the most
+            // sense.
+            if (pid != LLDB_INVALID_PROCESS_ID)
+            {
+                m_process_launch_info.Clear();
+            }
         }
     }
     return SendPacketNoLock (response.GetData(), response.GetSize());
@@ -912,17 +1850,21 @@ GDBRemoteCommunicationServer::Handle_qLaunchGDBServer (StringExtractorGDBRemote
 #ifdef _WIN32
     return SendErrorResponse(9);
 #else
+    Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
+
     // Spawn a local debugserver as a platform so we can then attach or launch
     // a process...
 
     if (m_is_platform)
     {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s() called", __FUNCTION__);
+
         // Sleep and wait a bit for debugserver to start to listen...
         ConnectionFileDescriptor file_conn;
-        Error error;
         std::string hostname;
         // TODO: /tmp/ should not be hardcoded. User might want to override /tmp
-        // with the TMPDIR environnement variable
+        // with the TMPDIR environment variable
         packet.SetFilePos(::strlen ("qLaunchGDBServer;"));
         std::string name;
         std::string value;
@@ -940,53 +1882,57 @@ GDBRemoteCommunicationServer::Handle_qLaunchGDBServer (StringExtractorGDBRemote
         // Spawn a new thread to accept the port that gets bound after
         // binding to port 0 (zero).
 
-        if (error.Success())
-        {
-            // Spawn a debugserver and try to get the port it listens to.
-            ProcessLaunchInfo debugserver_launch_info;
-            if (hostname.empty())
-                hostname = "localhost";
-            Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PLATFORM));
-            if (log)
-                log->Printf("Launching debugserver with: %s:%u...\n", hostname.c_str(), port);
+        // Spawn a debugserver and try to get the port it listens to.
+        ProcessLaunchInfo debugserver_launch_info;
+        if (hostname.empty())
+            hostname = "127.0.0.1";
+        if (log)
+            log->Printf("Launching debugserver with: %s:%u...\n", hostname.c_str(), port);
 
-            debugserver_launch_info.SetMonitorProcessCallback(ReapDebugserverProcess, this, false);
-            
-            error = StartDebugserverProcess (hostname.empty() ? NULL : hostname.c_str(),
-                                             port,
-                                             debugserver_launch_info,
-                                             port);
+        debugserver_launch_info.SetMonitorProcessCallback(ReapDebugserverProcess, this, false);
 
-            lldb::pid_t debugserver_pid = debugserver_launch_info.GetProcessID();
+        Error error = StartDebugserverProcess (hostname.empty() ? NULL : hostname.c_str(),
+                                         port,
+                                         debugserver_launch_info,
+                                         port);
 
+        lldb::pid_t debugserver_pid = debugserver_launch_info.GetProcessID();
 
-            if (debugserver_pid != LLDB_INVALID_PROCESS_ID)
-            {
-                Mutex::Locker locker (m_spawned_pids_mutex);
-                m_spawned_pids.insert(debugserver_pid);
-                if (port > 0)
-                    AssociatePortWithProcess(port, debugserver_pid);
-            }
-            else
-            {
-                if (port > 0)
-                    FreePort (port);
-            }
 
-            if (error.Success())
-            {
-                char response[256];
-                const int response_len = ::snprintf (response, sizeof(response), "pid:%" PRIu64 ";port:%u;", debugserver_pid, port + m_port_offset);
-                assert (response_len < sizeof(response));
-                PacketResult packet_result = SendPacketNoLock (response, response_len);
+        if (debugserver_pid != LLDB_INVALID_PROCESS_ID)
+        {
+            Mutex::Locker locker (m_spawned_pids_mutex);
+            m_spawned_pids.insert(debugserver_pid);
+            if (port > 0)
+                AssociatePortWithProcess(port, debugserver_pid);
+        }
+        else
+        {
+            if (port > 0)
+                FreePort (port);
+        }
 
-                if (packet_result != PacketResult::Success)
-                {
-                    if (debugserver_pid != LLDB_INVALID_PROCESS_ID)
-                        ::kill (debugserver_pid, SIGINT);
-                }
-                return packet_result;
+        if (error.Success())
+        {
+            if (log)
+                log->Printf ("GDBRemoteCommunicationServer::%s() debugserver launched successfully as pid %" PRIu64, __FUNCTION__, debugserver_pid);
+
+            char response[256];
+            const int response_len = ::snprintf (response, sizeof(response), "pid:%" PRIu64 ";port:%u;", debugserver_pid, port + m_port_offset);
+            assert (response_len < (int)sizeof(response));
+            PacketResult packet_result = SendPacketNoLock (response, response_len);
+
+            if (packet_result != PacketResult::Success)
+            {
+                if (debugserver_pid != LLDB_INVALID_PROCESS_ID)
+                    ::kill (debugserver_pid, SIGINT);
             }
+            return packet_result;
+        }
+        else
+        {
+            if (log)
+                log->Printf ("GDBRemoteCommunicationServer::%s() debugserver launch failed: %s", __FUNCTION__, error.AsCString ());
         }
     }
     return SendErrorResponse (9);
@@ -1027,7 +1973,7 @@ GDBRemoteCommunicationServer::KillSpawnedProcess (lldb::pid_t pid)
             return true;
     }
 
-    // the launched process still lives.  Now try killling it again,
+    // the launched process still lives.  Now try killing it again,
     // this time with an unblockable signal.
     Host::Kill (pid, SIGKILL);
 
@@ -1107,8 +2053,11 @@ GDBRemoteCommunicationServer::Handle_k (StringExtractorGDBRemote &packet)
         }
     }
 
-    // TODO figure out how to shut down gracefully at this point
-    return SendOKResponse ();
+    FlushInferiorOutput ();
+
+    // No OK response for kill packet.
+    // return SendOKResponse ();
+    return PacketResult::Success;
 }
 
 GDBRemoteCommunication::PacketResult
@@ -1223,7 +2172,7 @@ GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_QSetSTDIN (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen ("QSetSTDIN:"));
-    ProcessLaunchInfo::FileAction file_action;
+    FileAction file_action;
     std::string path;
     packet.GetHexByteString(path);
     const bool read = false;
@@ -1240,7 +2189,7 @@ GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_QSetSTDOUT (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen ("QSetSTDOUT:"));
-    ProcessLaunchInfo::FileAction file_action;
+    FileAction file_action;
     std::string path;
     packet.GetHexByteString(path);
     const bool read = true;
@@ -1257,7 +2206,7 @@ GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_QSetSTDERR (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen ("QSetSTDERR:"));
-    ProcessLaunchInfo::FileAction file_action;
+    FileAction file_action;
     std::string path;
     packet.GetHexByteString(path);
     const bool read = true;
@@ -1271,6 +2220,288 @@ GDBRemoteCommunicationServer::Handle_QSetSTDERR (StringExtractorGDBRemote &packe
 }
 
 GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::Handle_C (StringExtractorGDBRemote &packet)
+{
+    if (!IsGdbServer ())
+        return SendUnimplementedResponse (packet.GetStringRef().c_str());
+
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_THREAD));
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s called", __FUNCTION__);
+
+    // Ensure we have a native process.
+    if (!m_debugged_process_sp)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s no debugged process shared pointer", __FUNCTION__);
+        return SendErrorResponse (0x36);
+    }
+
+    // Pull out the signal number.
+    packet.SetFilePos (::strlen ("C"));
+    if (packet.GetBytesLeft () < 1)
+    {
+        // Shouldn't be using a C without a signal.
+        return SendIllFormedResponse (packet, "C packet specified without signal.");
+    }
+    const uint32_t signo = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ());
+    if (signo == std::numeric_limits<uint32_t>::max ())
+        return SendIllFormedResponse (packet, "failed to parse signal number");
+
+    // Handle optional continue address.
+    if (packet.GetBytesLeft () > 0)
+    {
+        // FIXME add continue at address support for $C{signo}[;{continue-address}].
+        if (*packet.Peek () == ';')
+            return SendUnimplementedResponse (packet.GetStringRef().c_str());
+        else
+            return SendIllFormedResponse (packet, "unexpected content after $C{signal-number}");
+    }
+
+    lldb_private::ResumeActionList resume_actions (StateType::eStateRunning, 0);
+    Error error;
+
+    // We have two branches: what to do if a continue thread is specified (in which case we target
+    // sending the signal to that thread), or when we don't have a continue thread set (in which
+    // case we send a signal to the process).
+
+    // TODO discuss with Greg Clayton, make sure this makes sense.
+
+    lldb::tid_t signal_tid = GetContinueThreadID ();
+    if (signal_tid != LLDB_INVALID_THREAD_ID)
+    {
+        // The resume action for the continue thread (or all threads if a continue thread is not set).
+        lldb_private::ResumeAction action = { GetContinueThreadID (), StateType::eStateRunning, static_cast<int> (signo) };
+
+        // Add the action for the continue thread (or all threads when the continue thread isn't present).
+        resume_actions.Append (action);
+    }
+    else
+    {
+        // Send the signal to the process since we weren't targeting a specific continue thread with the signal.
+        error = m_debugged_process_sp->Signal (signo);
+        if (error.Fail ())
+        {
+            if (log)
+                log->Printf ("GDBRemoteCommunicationServer::%s failed to send signal for process %" PRIu64 ": %s",
+                             __FUNCTION__,
+                             m_debugged_process_sp->GetID (),
+                             error.AsCString ());
+
+            return SendErrorResponse (0x52);
+        }
+    }
+
+    // Resume the threads.
+    error = m_debugged_process_sp->Resume (resume_actions);
+    if (error.Fail ())
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed to resume threads for process %" PRIu64 ": %s",
+                         __FUNCTION__,
+                         m_debugged_process_sp->GetID (),
+                         error.AsCString ());
+
+        return SendErrorResponse (0x38);
+    }
+
+    // Don't send an "OK" packet; response is the stopped/exited message.
+    return PacketResult::Success;
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::Handle_c (StringExtractorGDBRemote &packet, bool skip_file_pos_adjustment)
+{
+    if (!IsGdbServer ())
+        return SendUnimplementedResponse (packet.GetStringRef().c_str());
+
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_THREAD));
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s called", __FUNCTION__);
+
+    // We reuse this method in vCont - don't double adjust the file position.
+    if (!skip_file_pos_adjustment)
+        packet.SetFilePos (::strlen ("c"));
+
+    // For now just support all continue.
+    const bool has_continue_address = (packet.GetBytesLeft () > 0);
+    if (has_continue_address)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s not implemented for c{address} variant [%s remains]", __FUNCTION__, packet.Peek ());
+        return SendUnimplementedResponse (packet.GetStringRef().c_str());
+    }
+
+    // Ensure we have a native process.
+    if (!m_debugged_process_sp)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s no debugged process shared pointer", __FUNCTION__);
+        return SendErrorResponse (0x36);
+    }
+
+    // Build the ResumeActionList
+    lldb_private::ResumeActionList actions (StateType::eStateRunning, 0);
+
+    Error error = m_debugged_process_sp->Resume (actions);
+    if (error.Fail ())
+    {
+        if (log)
+        {
+            log->Printf ("GDBRemoteCommunicationServer::%s c failed for process %" PRIu64 ": %s",
+                         __FUNCTION__,
+                         m_debugged_process_sp->GetID (),
+                         error.AsCString ());
+        }
+        return SendErrorResponse (GDBRemoteServerError::eErrorResume);
+    }
+
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s continued process %" PRIu64, __FUNCTION__, m_debugged_process_sp->GetID ());
+
+    // No response required from continue.
+    return PacketResult::Success;
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::Handle_vCont_actions (StringExtractorGDBRemote &packet)
+{
+    if (!IsGdbServer ())
+    {
+        // only llgs supports $vCont.
+        return SendUnimplementedResponse (packet.GetStringRef().c_str());
+    }
+
+    // We handle $vCont messages for c.
+    // TODO add C, s and S.
+    StreamString response;
+    response.Printf("vCont;c;C;s;S");
+
+    return SendPacketNoLock(response.GetData(), response.GetSize());
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::Handle_vCont (StringExtractorGDBRemote &packet)
+{
+    if (!IsGdbServer ())
+    {
+        // only llgs supports $vCont
+        return SendUnimplementedResponse (packet.GetStringRef().c_str());
+    }
+
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s handling vCont packet", __FUNCTION__);
+
+    packet.SetFilePos (::strlen ("vCont"));
+
+    // Check if this is all continue (no options or ";c").
+    if (!packet.GetBytesLeft () || (::strcmp (packet.Peek (), ";c") == 0))
+    {
+        // Move the packet past the ";c".
+        if (packet.GetBytesLeft ())
+            packet.SetFilePos (packet.GetFilePos () + ::strlen (";c"));
+
+        const bool skip_file_pos_adjustment = true;
+        return Handle_c (packet, skip_file_pos_adjustment);
+    }
+    else if (::strcmp (packet.Peek (), ";s") == 0)
+    {
+        // Move past the ';', then do a simple 's'.
+        packet.SetFilePos (packet.GetFilePos () + 1);
+        return Handle_s (packet);
+    }
+
+    // Ensure we have a native process.
+    if (!m_debugged_process_sp)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s no debugged process shared pointer", __FUNCTION__);
+        return SendErrorResponse (0x36);
+    }
+
+    ResumeActionList thread_actions;
+
+    while (packet.GetBytesLeft () && *packet.Peek () == ';')
+    {
+        // Skip the semi-colon.
+        packet.GetChar ();
+
+        // Build up the thread action.
+        ResumeAction thread_action;
+        thread_action.tid = LLDB_INVALID_THREAD_ID;
+        thread_action.state = eStateInvalid;
+        thread_action.signal = 0;
+
+        const char action = packet.GetChar ();
+        switch (action)
+        {
+            case 'C':
+                thread_action.signal = packet.GetHexMaxU32 (false, 0);
+                if (thread_action.signal == 0)
+                    return SendIllFormedResponse (packet, "Could not parse signal in vCont packet C action");
+                // Fall through to next case...
+
+            case 'c':
+                // Continue
+                thread_action.state = eStateRunning;
+                break;
+
+            case 'S':
+                thread_action.signal = packet.GetHexMaxU32 (false, 0);
+                if (thread_action.signal == 0)
+                    return SendIllFormedResponse (packet, "Could not parse signal in vCont packet S action");
+                // Fall through to next case...
+
+            case 's':
+                // Step
+                thread_action.state = eStateStepping;
+                break;
+
+            default:
+                return SendIllFormedResponse (packet, "Unsupported vCont action");
+                break;
+        }
+
+        // Parse out optional :{thread-id} value.
+        if (packet.GetBytesLeft () && (*packet.Peek () == ':'))
+        {
+            // Consume the separator.
+            packet.GetChar ();
+
+            thread_action.tid = packet.GetHexMaxU32 (false, LLDB_INVALID_THREAD_ID);
+            if (thread_action.tid == LLDB_INVALID_THREAD_ID)
+                return SendIllFormedResponse (packet, "Could not parse thread number in vCont packet");
+        }
+
+        thread_actions.Append (thread_action);
+    }
+
+    // If a default action for all other threads wasn't mentioned
+    // then we should stop the threads.
+    thread_actions.SetDefaultThreadActionIfNeeded (eStateStopped, 0);
+
+    Error error = m_debugged_process_sp->Resume (thread_actions);
+    if (error.Fail ())
+    {
+        if (log)
+        {
+            log->Printf ("GDBRemoteCommunicationServer::%s vCont failed for process %" PRIu64 ": %s",
+                         __FUNCTION__,
+                         m_debugged_process_sp->GetID (),
+                         error.AsCString ());
+        }
+        return SendErrorResponse (GDBRemoteServerError::eErrorResume);
+    }
+
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s continued process %" PRIu64, __FUNCTION__, m_debugged_process_sp->GetID ());
+
+    // No response required from vCont.
+    return PacketResult::Success;
+}
+
+GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_QStartNoAckMode (StringExtractorGDBRemote &packet)
 {
     // Send response first before changing m_send_acks to we ack this packet
@@ -1288,7 +2519,7 @@ GDBRemoteCommunicationServer::Handle_qPlatform_mkdir (StringExtractorGDBRemote &
     {
         std::string path;
         packet.GetHexByteString(path);
-        Error error = Host::MakeDirectory(path.c_str(),mode);
+        Error error = FileSystem::MakeDirectory(path.c_str(), mode);
         if (error.Success())
             return SendPacketNoLock ("OK", 2);
         else
@@ -1307,7 +2538,7 @@ GDBRemoteCommunicationServer::Handle_qPlatform_chmod (StringExtractorGDBRemote &
     {
         std::string path;
         packet.GetHexByteString(path);
-        Error error = Host::SetFilePermissions (path.c_str(), mode);
+        Error error = FileSystem::SetFilePermissions(path.c_str(), mode);
         if (error.Success())
             return SendPacketNoLock ("OK", 2);
         else
@@ -1457,7 +2688,7 @@ GDBRemoteCommunicationServer::Handle_vFile_Size (StringExtractorGDBRemote &packe
     packet.GetHexByteString(path);
     if (!path.empty())
     {
-        lldb::user_id_t retcode = Host::GetFileSize(FileSpec(path.c_str(), false));
+        lldb::user_id_t retcode = FileSystem::GetFileSize(FileSpec(path.c_str(), false));
         StreamString response;
         response.PutChar('F');
         response.PutHex64(retcode);
@@ -1498,7 +2729,7 @@ GDBRemoteCommunicationServer::Handle_vFile_Exists (StringExtractorGDBRemote &pac
     packet.GetHexByteString(path);
     if (!path.empty())
     {
-        bool retcode = Host::GetFileExists(FileSpec(path.c_str(), false));
+        bool retcode = FileSystem::GetFileExists(FileSpec(path.c_str(), false));
         StreamString response;
         response.PutChar('F');
         response.PutChar(',');
@@ -1519,7 +2750,7 @@ GDBRemoteCommunicationServer::Handle_vFile_symlink (StringExtractorGDBRemote &pa
     packet.GetHexByteStringTerminatedBy(dst, ',');
     packet.GetChar(); // Skip ',' char
     packet.GetHexByteString(src);
-    Error error = Host::Symlink(src.c_str(), dst.c_str());
+    Error error = FileSystem::Symlink(src.c_str(), dst.c_str());
     StreamString response;
     response.Printf("F%u,%u", error.GetError(), error.GetError());
     return SendPacketNoLock(response.GetData(), response.GetSize());
@@ -1531,7 +2762,7 @@ GDBRemoteCommunicationServer::Handle_vFile_unlink (StringExtractorGDBRemote &pac
     packet.SetFilePos(::strlen("vFile:unlink:"));
     std::string path;
     packet.GetHexByteString(path);
-    Error error = Host::Unlink(path.c_str());
+    Error error = FileSystem::Unlink(path.c_str());
     StreamString response;
     response.Printf("F%u,%u", error.GetError(), error.GetError());
     return SendPacketNoLock(response.GetData(), response.GetSize());
@@ -1579,6 +2810,94 @@ GDBRemoteCommunicationServer::Handle_qPlatform_shell (StringExtractorGDBRemote &
     return SendErrorResponse(24);
 }
 
+void
+GDBRemoteCommunicationServer::SetCurrentThreadID (lldb::tid_t tid)
+{
+    assert (IsGdbServer () && "SetCurrentThreadID() called when not GdbServer code");
+
+    Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_THREAD));
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s setting current thread id to %" PRIu64, __FUNCTION__, tid);
+
+    m_current_tid = tid;
+    if (m_debugged_process_sp)
+        m_debugged_process_sp->SetCurrentThreadID (m_current_tid);
+}
+
+void
+GDBRemoteCommunicationServer::SetContinueThreadID (lldb::tid_t tid)
+{
+    assert (IsGdbServer () && "SetContinueThreadID() called when not GdbServer code");
+
+    Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_THREAD));
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s setting continue thread id to %" PRIu64, __FUNCTION__, tid);
+
+    m_continue_tid = tid;
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::Handle_stop_reason (StringExtractorGDBRemote &packet)
+{
+    // Handle the $? gdbremote command.
+    if (!IsGdbServer ())
+        return SendUnimplementedResponse("GDBRemoteCommunicationServer::Handle_stop_reason() unimplemented");
+
+    // If no process, indicate error
+    if (!m_debugged_process_sp)
+        return SendErrorResponse (02);
+
+    return SendStopReasonForState (m_debugged_process_sp->GetState (), true);
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::SendStopReasonForState (lldb::StateType process_state, bool flush_on_exit)
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    switch (process_state)
+    {
+        case eStateAttaching:
+        case eStateLaunching:
+        case eStateRunning:
+        case eStateStepping:
+        case eStateDetached:
+            // NOTE: gdb protocol doc looks like it should return $OK
+            // when everything is running (i.e. no stopped result).
+            return PacketResult::Success;  // Ignore
+
+        case eStateSuspended:
+        case eStateStopped:
+        case eStateCrashed:
+        {
+            lldb::tid_t tid = m_debugged_process_sp->GetCurrentThreadID ();
+            // Make sure we set the current thread so g and p packets return
+            // the data the gdb will expect.
+            SetCurrentThreadID (tid);
+            return SendStopReplyPacketForThread (tid);
+        }
+
+        case eStateInvalid:
+        case eStateUnloaded:
+        case eStateExited:
+            if (flush_on_exit)
+                FlushInferiorOutput ();
+            return SendWResponse(m_debugged_process_sp.get());
+
+        default:
+            if (log)
+            {
+                log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 ", current state reporting not handled: %s",
+                             __FUNCTION__,
+                             m_debugged_process_sp->GetID (),
+                             StateAsCString (process_state));
+            }
+            break;
+    }
+    
+    return SendErrorResponse (0);
+}
+
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::Handle_vFile_Stat (StringExtractorGDBRemote &packet)
 {
@@ -1595,7 +2914,7 @@ GDBRemoteCommunicationServer::Handle_vFile_MD5 (StringExtractorGDBRemote &packet
     {
         uint64_t a,b;
         StreamGDBRemote response;
-        if (Host::CalculateMD5(FileSpec(path.c_str(),false),a,b) == false)
+        if (FileSystem::CalculateMD5(FileSpec(path.c_str(), false), a, b) == false)
         {
             response.PutCString("F,");
             response.PutCString("x");
@@ -1611,3 +2930,1385 @@ GDBRemoteCommunicationServer::Handle_vFile_MD5 (StringExtractorGDBRemote &packet
     return SendErrorResponse(25);
 }
 
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::Handle_qRegisterInfo (StringExtractorGDBRemote &packet)
+{
+    // Ensure we're llgs.
+    if (!IsGdbServer())
+        return SendUnimplementedResponse("GDBRemoteCommunicationServer::Handle_qRegisterInfo() unimplemented");
+
+    // Fail if we don't have a current process.
+    if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
+        return SendErrorResponse (68);
+
+    // Ensure we have a thread.
+    NativeThreadProtocolSP thread_sp (m_debugged_process_sp->GetThreadAtIndex (0));
+    if (!thread_sp)
+        return SendErrorResponse (69);
+
+    // Get the register context for the first thread.
+    NativeRegisterContextSP reg_context_sp (thread_sp->GetRegisterContext ());
+    if (!reg_context_sp)
+        return SendErrorResponse (69);
+
+    // Parse out the register number from the request.
+    packet.SetFilePos (strlen("qRegisterInfo"));
+    const uint32_t reg_index = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ());
+    if (reg_index == std::numeric_limits<uint32_t>::max ())
+        return SendErrorResponse (69);
+
+    // Return the end of registers response if we've iterated one past the end of the register set.
+    if (reg_index >= reg_context_sp->GetRegisterCount ())
+        return SendErrorResponse (69);
+
+    const RegisterInfo *reg_info = reg_context_sp->GetRegisterInfoAtIndex(reg_index);
+    if (!reg_info)
+        return SendErrorResponse (69);
+
+    // Build the reginfos response.
+    StreamGDBRemote response;
+
+    response.PutCString ("name:");
+    response.PutCString (reg_info->name);
+    response.PutChar (';');
+
+    if (reg_info->alt_name && reg_info->alt_name[0])
+    {
+        response.PutCString ("alt-name:");
+        response.PutCString (reg_info->alt_name);
+        response.PutChar (';');
+    }
+
+    response.Printf ("bitsize:%" PRIu32 ";offset:%" PRIu32 ";", reg_info->byte_size * 8, reg_info->byte_offset);
+
+    switch (reg_info->encoding)
+    {
+        case eEncodingUint:    response.PutCString ("encoding:uint;"); break;
+        case eEncodingSint:    response.PutCString ("encoding:sint;"); break;
+        case eEncodingIEEE754: response.PutCString ("encoding:ieee754;"); break;
+        case eEncodingVector:  response.PutCString ("encoding:vector;"); break;
+        default: break;
+    }
+
+    switch (reg_info->format)
+    {
+        case eFormatBinary:          response.PutCString ("format:binary;"); break;
+        case eFormatDecimal:         response.PutCString ("format:decimal;"); break;
+        case eFormatHex:             response.PutCString ("format:hex;"); break;
+        case eFormatFloat:           response.PutCString ("format:float;"); break;
+        case eFormatVectorOfSInt8:   response.PutCString ("format:vector-sint8;"); break;
+        case eFormatVectorOfUInt8:   response.PutCString ("format:vector-uint8;"); break;
+        case eFormatVectorOfSInt16:  response.PutCString ("format:vector-sint16;"); break;
+        case eFormatVectorOfUInt16:  response.PutCString ("format:vector-uint16;"); break;
+        case eFormatVectorOfSInt32:  response.PutCString ("format:vector-sint32;"); break;
+        case eFormatVectorOfUInt32:  response.PutCString ("format:vector-uint32;"); break;
+        case eFormatVectorOfFloat32: response.PutCString ("format:vector-float32;"); break;
+        case eFormatVectorOfUInt128: response.PutCString ("format:vector-uint128;"); break;
+        default: break;
+    };
+
+    const char *const register_set_name = reg_context_sp->GetRegisterSetNameForRegisterAtIndex(reg_index);
+    if (register_set_name)
+    {
+        response.PutCString ("set:");
+        response.PutCString (register_set_name);
+        response.PutChar (';');
+    }
+
+    if (reg_info->kinds[RegisterKind::eRegisterKindGCC] != LLDB_INVALID_REGNUM)
+        response.Printf ("gcc:%" PRIu32 ";", reg_info->kinds[RegisterKind::eRegisterKindGCC]);
+
+    if (reg_info->kinds[RegisterKind::eRegisterKindDWARF] != LLDB_INVALID_REGNUM)
+        response.Printf ("dwarf:%" PRIu32 ";", reg_info->kinds[RegisterKind::eRegisterKindDWARF]);
+
+    switch (reg_info->kinds[RegisterKind::eRegisterKindGeneric])
+    {
+        case LLDB_REGNUM_GENERIC_PC:     response.PutCString("generic:pc;"); break;
+        case LLDB_REGNUM_GENERIC_SP:     response.PutCString("generic:sp;"); break;
+        case LLDB_REGNUM_GENERIC_FP:     response.PutCString("generic:fp;"); break;
+        case LLDB_REGNUM_GENERIC_RA:     response.PutCString("generic:ra;"); break;
+        case LLDB_REGNUM_GENERIC_FLAGS:  response.PutCString("generic:flags;"); break;
+        case LLDB_REGNUM_GENERIC_ARG1:   response.PutCString("generic:arg1;"); break;
+        case LLDB_REGNUM_GENERIC_ARG2:   response.PutCString("generic:arg2;"); break;
+        case LLDB_REGNUM_GENERIC_ARG3:   response.PutCString("generic:arg3;"); break;
+        case LLDB_REGNUM_GENERIC_ARG4:   response.PutCString("generic:arg4;"); break;
+        case LLDB_REGNUM_GENERIC_ARG5:   response.PutCString("generic:arg5;"); break;
+        case LLDB_REGNUM_GENERIC_ARG6:   response.PutCString("generic:arg6;"); break;
+        case LLDB_REGNUM_GENERIC_ARG7:   response.PutCString("generic:arg7;"); break;
+        case LLDB_REGNUM_GENERIC_ARG8:   response.PutCString("generic:arg8;"); break;
+        default: break;
+    }
+
+    if (reg_info->value_regs && reg_info->value_regs[0] != LLDB_INVALID_REGNUM)
+    {
+        response.PutCString ("container-regs:");
+        int i = 0;
+        for (const uint32_t *reg_num = reg_info->value_regs; *reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i)
+        {
+            if (i > 0)
+                response.PutChar (',');
+            response.Printf ("%" PRIx32, *reg_num);
+        }
+        response.PutChar (';');
+    }
+
+    if (reg_info->invalidate_regs && reg_info->invalidate_regs[0])
+    {
+        response.PutCString ("invalidate-regs:");
+        int i = 0;
+        for (const uint32_t *reg_num = reg_info->invalidate_regs; *reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i)
+        {
+            if (i > 0)
+                response.PutChar (',');
+            response.Printf ("%" PRIx32, *reg_num);
+        }
+        response.PutChar (';');
+    }
+
+    return SendPacketNoLock(response.GetData(), response.GetSize());
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::Handle_qfThreadInfo (StringExtractorGDBRemote &packet)
+{
+    // Ensure we're llgs.
+    if (!IsGdbServer())
+        return SendUnimplementedResponse("GDBRemoteCommunicationServer::Handle_qfThreadInfo() unimplemented");
+
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
+
+    // Fail if we don't have a current process.
+    if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s() no process (%s), returning OK", __FUNCTION__, m_debugged_process_sp ? "invalid process id" : "null m_debugged_process_sp");
+        return SendOKResponse ();
+    }
+
+    StreamGDBRemote response;
+    response.PutChar ('m');
+
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s() starting thread iteration", __FUNCTION__);
+
+    NativeThreadProtocolSP thread_sp;
+    uint32_t thread_index;
+    for (thread_index = 0, thread_sp = m_debugged_process_sp->GetThreadAtIndex (thread_index);
+         thread_sp;
+         ++thread_index, thread_sp = m_debugged_process_sp->GetThreadAtIndex (thread_index))
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s() iterated thread %" PRIu32 "(%s, tid=0x%" PRIx64 ")", __FUNCTION__, thread_index, thread_sp ? "is not null" : "null", thread_sp ? thread_sp->GetID () : LLDB_INVALID_THREAD_ID);
+        if (thread_index > 0)
+            response.PutChar(',');
+        response.Printf ("%" PRIx64, thread_sp->GetID ());
+    }
+
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s() finished thread iteration", __FUNCTION__);
+
+    return SendPacketNoLock(response.GetData(), response.GetSize());
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::Handle_qsThreadInfo (StringExtractorGDBRemote &packet)
+{
+    // Ensure we're llgs.
+    if (!IsGdbServer())
+        return SendUnimplementedResponse ("GDBRemoteCommunicationServer::Handle_qsThreadInfo() unimplemented");
+
+    // FIXME for now we return the full thread list in the initial packet and always do nothing here.
+    return SendPacketNoLock ("l", 1);
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::Handle_p (StringExtractorGDBRemote &packet)
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
+
+    // Ensure we're llgs.
+    if (!IsGdbServer())
+        return SendUnimplementedResponse ("GDBRemoteCommunicationServer::Handle_p() unimplemented");
+
+    // Parse out the register number from the request.
+    packet.SetFilePos (strlen("p"));
+    const uint32_t reg_index = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ());
+    if (reg_index == std::numeric_limits<uint32_t>::max ())
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, could not parse register number from request \"%s\"", __FUNCTION__, packet.GetStringRef ().c_str ());
+        return SendErrorResponse (0x15);
+    }
+
+    // Get the thread to use.
+    NativeThreadProtocolSP thread_sp = GetThreadFromSuffix (packet);
+    if (!thread_sp)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, no thread available", __FUNCTION__);
+        return SendErrorResponse (0x15);
+    }
+
+    // Get the thread's register context.
+    NativeRegisterContextSP reg_context_sp (thread_sp->GetRegisterContext ());
+    if (!reg_context_sp)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " tid %" PRIu64 " failed, no register context available for the thread", __FUNCTION__, m_debugged_process_sp->GetID (), thread_sp->GetID ());
+        return SendErrorResponse (0x15);
+    }
+
+    // Return the end of registers response if we've iterated one past the end of the register set.
+    if (reg_index >= reg_context_sp->GetRegisterCount ())
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, requested register %" PRIu32 " beyond register count %" PRIu32, __FUNCTION__, reg_index, reg_context_sp->GetRegisterCount ());
+        return SendErrorResponse (0x15);
+    }
+
+    const RegisterInfo *reg_info = reg_context_sp->GetRegisterInfoAtIndex(reg_index);
+    if (!reg_info)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, requested register %" PRIu32 " returned NULL", __FUNCTION__, reg_index);
+        return SendErrorResponse (0x15);
+    }
+
+    // Build the reginfos response.
+    StreamGDBRemote response;
+
+    // Retrieve the value
+    RegisterValue reg_value;
+    Error error = reg_context_sp->ReadRegister (reg_info, reg_value);
+    if (error.Fail ())
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, read of requested register %" PRIu32 " (%s) failed: %s", __FUNCTION__, reg_index, reg_info->name, error.AsCString ());
+        return SendErrorResponse (0x15);
+    }
+
+    const uint8_t *const data = reinterpret_cast<const uint8_t*> (reg_value.GetBytes ());
+    if (!data)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed to get data bytes from requested register %" PRIu32, __FUNCTION__, reg_index);
+        return SendErrorResponse (0x15);
+    }
+
+    // FIXME flip as needed to get data in big/little endian format for this host.
+    for (uint32_t i = 0; i < reg_value.GetByteSize (); ++i)
+        response.PutHex8 (data[i]);
+
+    return SendPacketNoLock (response.GetData (), response.GetSize ());
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::Handle_P (StringExtractorGDBRemote &packet)
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
+
+    // Ensure we're llgs.
+    if (!IsGdbServer())
+        return SendUnimplementedResponse ("GDBRemoteCommunicationServer::Handle_P() unimplemented");
+
+    // Ensure there is more content.
+    if (packet.GetBytesLeft () < 1)
+        return SendIllFormedResponse (packet, "Empty P packet");
+
+    // Parse out the register number from the request.
+    packet.SetFilePos (strlen("P"));
+    const uint32_t reg_index = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ());
+    if (reg_index == std::numeric_limits<uint32_t>::max ())
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, could not parse register number from request \"%s\"", __FUNCTION__, packet.GetStringRef ().c_str ());
+        return SendErrorResponse (0x29);
+    }
+
+    // Note debugserver would send an E30 here.
+    if ((packet.GetBytesLeft () < 1) || (packet.GetChar () != '='))
+        return SendIllFormedResponse (packet, "P packet missing '=' char after register number");
+
+    // Get process architecture.
+    ArchSpec process_arch;
+    if (!m_debugged_process_sp || !m_debugged_process_sp->GetArchitecture (process_arch))
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed to retrieve inferior architecture", __FUNCTION__);
+        return SendErrorResponse (0x49);
+    }
+
+    // Parse out the value.
+    const uint64_t raw_value = packet.GetHexMaxU64 (process_arch.GetByteOrder () == lldb::eByteOrderLittle, std::numeric_limits<uint64_t>::max ());
+
+    // Get the thread to use.
+    NativeThreadProtocolSP thread_sp = GetThreadFromSuffix (packet);
+    if (!thread_sp)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, no thread available (thread index 0)", __FUNCTION__);
+        return SendErrorResponse (0x28);
+    }
+
+    // Get the thread's register context.
+    NativeRegisterContextSP reg_context_sp (thread_sp->GetRegisterContext ());
+    if (!reg_context_sp)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " tid %" PRIu64 " failed, no register context available for the thread", __FUNCTION__, m_debugged_process_sp->GetID (), thread_sp->GetID ());
+        return SendErrorResponse (0x15);
+    }
+
+    const RegisterInfo *reg_info = reg_context_sp->GetRegisterInfoAtIndex(reg_index);
+    if (!reg_info)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, requested register %" PRIu32 " returned NULL", __FUNCTION__, reg_index);
+        return SendErrorResponse (0x48);
+    }
+
+    // Return the end of registers response if we've iterated one past the end of the register set.
+    if (reg_index >= reg_context_sp->GetRegisterCount ())
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, requested register %" PRIu32 " beyond register count %" PRIu32, __FUNCTION__, reg_index, reg_context_sp->GetRegisterCount ());
+        return SendErrorResponse (0x47);
+    }
+
+
+    // Build the reginfos response.
+    StreamGDBRemote response;
+
+    // FIXME Could be suffixed with a thread: parameter.
+    // That thread then needs to be fed back into the reg context retrieval above.
+    Error error = reg_context_sp->WriteRegisterFromUnsigned (reg_info, raw_value);
+    if (error.Fail ())
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, write of requested register %" PRIu32 " (%s) failed: %s", __FUNCTION__, reg_index, reg_info->name, error.AsCString ());
+        return SendErrorResponse (0x32);
+    }
+
+    return SendOKResponse();
+}
+
+GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_H (StringExtractorGDBRemote &packet)
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
+
+    // Ensure we're llgs.
+    if (!IsGdbServer())
+        return SendUnimplementedResponse("GDBRemoteCommunicationServer::Handle_H() unimplemented");
+
+    // Fail if we don't have a current process.
+    if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, no process available", __FUNCTION__);
+        return SendErrorResponse (0x15);
+    }
+
+    // Parse out which variant of $H is requested.
+    packet.SetFilePos (strlen("H"));
+    if (packet.GetBytesLeft () < 1)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, H command missing {g,c} variant", __FUNCTION__);
+        return SendIllFormedResponse (packet, "H command missing {g,c} variant");
+    }
+
+    const char h_variant = packet.GetChar ();
+    switch (h_variant)
+    {
+        case 'g':
+            break;
+
+        case 'c':
+            break;
+
+        default:
+            if (log)
+                log->Printf ("GDBRemoteCommunicationServer::%s failed, invalid $H variant %c", __FUNCTION__, h_variant);
+            return SendIllFormedResponse (packet, "H variant unsupported, should be c or g");
+    }
+
+    // Parse out the thread number.
+    // FIXME return a parse success/fail value.  All values are valid here.
+    const lldb::tid_t tid = packet.GetHexMaxU64 (false, std::numeric_limits<lldb::tid_t>::max ());
+
+    // Ensure we have the given thread when not specifying -1 (all threads) or 0 (any thread).
+    if (tid != LLDB_INVALID_THREAD_ID && tid != 0)
+    {
+        NativeThreadProtocolSP thread_sp (m_debugged_process_sp->GetThreadByID (tid));
+        if (!thread_sp)
+        {
+            if (log)
+                log->Printf ("GDBRemoteCommunicationServer::%s failed, tid %" PRIu64 " not found", __FUNCTION__, tid);
+            return SendErrorResponse (0x15);
+        }
+    }
+
+    // Now switch the given thread type.
+    switch (h_variant)
+    {
+        case 'g':
+            SetCurrentThreadID (tid);
+            break;
+
+        case 'c':
+            SetContinueThreadID (tid);
+            break;
+
+        default:
+            assert (false && "unsupported $H variant - shouldn't get here");
+            return SendIllFormedResponse (packet, "H variant unsupported, should be c or g");
+    }
+
+    return SendOKResponse();
+}
+
+GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_interrupt (StringExtractorGDBRemote &packet)
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
+
+    // Ensure we're llgs.
+    if (!IsGdbServer())
+    {
+        // Only supported on llgs
+        return SendUnimplementedResponse ("");
+    }
+
+    // Fail if we don't have a current process.
+    if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, no process available", __FUNCTION__);
+        return SendErrorResponse (0x15);
+    }
+
+    // Build the ResumeActionList - stop everything.
+    lldb_private::ResumeActionList actions (StateType::eStateStopped, 0);
+
+    Error error = m_debugged_process_sp->Resume (actions);
+    if (error.Fail ())
+    {
+        if (log)
+        {
+            log->Printf ("GDBRemoteCommunicationServer::%s failed for process %" PRIu64 ": %s",
+                         __FUNCTION__,
+                         m_debugged_process_sp->GetID (),
+                         error.AsCString ());
+        }
+        return SendErrorResponse (GDBRemoteServerError::eErrorResume);
+    }
+
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s stopped process %" PRIu64, __FUNCTION__, m_debugged_process_sp->GetID ());
+
+    // No response required from stop all.
+    return PacketResult::Success;
+}
+
+GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_m (StringExtractorGDBRemote &packet)
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    // Ensure we're llgs.
+    if (!IsGdbServer())
+    {
+        // Only supported on llgs
+        return SendUnimplementedResponse ("");
+    }
+
+    if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, no process available", __FUNCTION__);
+        return SendErrorResponse (0x15);
+    }
+
+    // Parse out the memory address.
+    packet.SetFilePos (strlen("m"));
+    if (packet.GetBytesLeft() < 1)
+        return SendIllFormedResponse(packet, "Too short m packet");
+
+    // Read the address.  Punting on validation.
+    // FIXME replace with Hex U64 read with no default value that fails on failed read.
+    const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0);
+
+    // Validate comma.
+    if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ','))
+        return SendIllFormedResponse(packet, "Comma sep missing in m packet");
+
+    // Get # bytes to read.
+    if (packet.GetBytesLeft() < 1)
+        return SendIllFormedResponse(packet, "Length missing in m packet");
+
+    const uint64_t byte_count = packet.GetHexMaxU64(false, 0);
+    if (byte_count == 0)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s nothing to read: zero-length packet", __FUNCTION__);
+        return PacketResult::Success;
+    }
+
+    // Allocate the response buffer.
+    std::string buf(byte_count, '\0');
+    if (buf.empty())
+        return SendErrorResponse (0x78);
+
+
+    // Retrieve the process memory.
+    lldb::addr_t bytes_read = 0;
+    lldb_private::Error error = m_debugged_process_sp->ReadMemory (read_addr, &buf[0], byte_count, bytes_read);
+    if (error.Fail ())
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " mem 0x%" PRIx64 ": failed to read. Error: %s", __FUNCTION__, m_debugged_process_sp->GetID (), read_addr, error.AsCString ());
+        return SendErrorResponse (0x08);
+    }
+
+    if (bytes_read == 0)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " mem 0x%" PRIx64 ": read %" PRIu64 " of %" PRIu64 " requested bytes", __FUNCTION__, m_debugged_process_sp->GetID (), read_addr, bytes_read, byte_count);
+        return SendErrorResponse (0x08);
+    }
+
+    StreamGDBRemote response;
+    for (lldb::addr_t i = 0; i < bytes_read; ++i)
+        response.PutHex8(buf[i]);
+
+    return SendPacketNoLock(response.GetData(), response.GetSize());
+}
+
+GDBRemoteCommunication::PacketResult
+GDBRemoteCommunicationServer::Handle_QSetDetachOnError (StringExtractorGDBRemote &packet)
+{
+    packet.SetFilePos(::strlen ("QSetDetachOnError:"));
+    if (packet.GetU32(0))
+        m_process_launch_info.GetFlags().Set (eLaunchFlagDetachOnError);
+    else
+        m_process_launch_info.GetFlags().Clear (eLaunchFlagDetachOnError);
+    return SendOKResponse ();
+}
+
+GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_M (StringExtractorGDBRemote &packet)
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    // Ensure we're llgs.
+    if (!IsGdbServer())
+    {
+        // Only supported on llgs
+        return SendUnimplementedResponse ("");
+    }
+
+    if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, no process available", __FUNCTION__);
+        return SendErrorResponse (0x15);
+    }
+
+    // Parse out the memory address.
+    packet.SetFilePos (strlen("M"));
+    if (packet.GetBytesLeft() < 1)
+        return SendIllFormedResponse(packet, "Too short M packet");
+
+    // Read the address.  Punting on validation.
+    // FIXME replace with Hex U64 read with no default value that fails on failed read.
+    const lldb::addr_t write_addr = packet.GetHexMaxU64(false, 0);
+
+    // Validate comma.
+    if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ','))
+        return SendIllFormedResponse(packet, "Comma sep missing in M packet");
+
+    // Get # bytes to read.
+    if (packet.GetBytesLeft() < 1)
+        return SendIllFormedResponse(packet, "Length missing in M packet");
+
+    const uint64_t byte_count = packet.GetHexMaxU64(false, 0);
+    if (byte_count == 0)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s nothing to write: zero-length packet", __FUNCTION__);
+        return PacketResult::Success;
+    }
+
+    // Validate colon.
+    if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ':'))
+        return SendIllFormedResponse(packet, "Comma sep missing in M packet after byte length");
+
+    // Allocate the conversion buffer.
+    std::vector<uint8_t> buf(byte_count, 0);
+    if (buf.empty())
+        return SendErrorResponse (0x78);
+
+    // Convert the hex memory write contents to bytes.
+    StreamGDBRemote response;
+    const uint64_t convert_count = static_cast<uint64_t> (packet.GetHexBytes (&buf[0], byte_count, 0));
+    if (convert_count != byte_count)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " mem 0x%" PRIx64 ": asked to write %" PRIu64 " bytes, but only found %" PRIu64 " to convert.", __FUNCTION__, m_debugged_process_sp->GetID (), write_addr, byte_count, convert_count);
+        return SendIllFormedResponse (packet, "M content byte length specified did not match hex-encoded content length");
+    }
+
+    // Write the process memory.
+    lldb::addr_t bytes_written = 0;
+    lldb_private::Error error = m_debugged_process_sp->WriteMemory (write_addr, &buf[0], byte_count, bytes_written);
+    if (error.Fail ())
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " mem 0x%" PRIx64 ": failed to write. Error: %s", __FUNCTION__, m_debugged_process_sp->GetID (), write_addr, error.AsCString ());
+        return SendErrorResponse (0x09);
+    }
+
+    if (bytes_written == 0)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " mem 0x%" PRIx64 ": wrote %" PRIu64 " of %" PRIu64 " requested bytes", __FUNCTION__, m_debugged_process_sp->GetID (), write_addr, bytes_written, byte_count);
+        return SendErrorResponse (0x09);
+    }
+
+    return SendOKResponse ();
+}
+
+GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_qMemoryRegionInfoSupported (StringExtractorGDBRemote &packet)
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    // We don't support if we're not llgs.
+    if (!IsGdbServer())
+        return SendUnimplementedResponse ("");
+
+    // Currently only the NativeProcessProtocol knows if it can handle a qMemoryRegionInfoSupported
+    // request, but we're not guaranteed to be attached to a process.  For now we'll assume the
+    // client only asks this when a process is being debugged.
+
+    // Ensure we have a process running; otherwise, we can't figure this out
+    // since we won't have a NativeProcessProtocol.
+    if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, no process available", __FUNCTION__);
+        return SendErrorResponse (0x15);
+    }
+
+    // Test if we can get any region back when asking for the region around NULL.
+    MemoryRegionInfo region_info;
+    const Error error = m_debugged_process_sp->GetMemoryRegionInfo (0, region_info);
+    if (error.Fail ())
+    {
+        // We don't support memory region info collection for this NativeProcessProtocol.
+        return SendUnimplementedResponse ("");
+    }
+
+    return SendOKResponse();
+}
+
+GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_qMemoryRegionInfo (StringExtractorGDBRemote &packet)
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    // We don't support if we're not llgs.
+    if (!IsGdbServer())
+        return SendUnimplementedResponse ("");
+
+    // Ensure we have a process.
+    if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, no process available", __FUNCTION__);
+        return SendErrorResponse (0x15);
+    }
+
+    // Parse out the memory address.
+    packet.SetFilePos (strlen("qMemoryRegionInfo:"));
+    if (packet.GetBytesLeft() < 1)
+        return SendIllFormedResponse(packet, "Too short qMemoryRegionInfo: packet");
+
+    // Read the address.  Punting on validation.
+    const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0);
+
+    StreamGDBRemote response;
+
+    // Get the memory region info for the target address.
+    MemoryRegionInfo region_info;
+    const Error error = m_debugged_process_sp->GetMemoryRegionInfo (read_addr, region_info);
+    if (error.Fail ())
+    {
+        // Return the error message.
+
+        response.PutCString ("error:");
+        response.PutCStringAsRawHex8 (error.AsCString ());
+        response.PutChar (';');
+    }
+    else
+    {
+        // Range start and size.
+        response.Printf ("start:%" PRIx64 ";size:%" PRIx64 ";", region_info.GetRange ().GetRangeBase (), region_info.GetRange ().GetByteSize ());
+
+        // Permissions.
+        if (region_info.GetReadable () ||
+            region_info.GetWritable () ||
+            region_info.GetExecutable ())
+        {
+            // Write permissions info.
+            response.PutCString ("permissions:");
+
+            if (region_info.GetReadable ())
+                response.PutChar ('r');
+            if (region_info.GetWritable ())
+                response.PutChar('w');
+            if (region_info.GetExecutable())
+                response.PutChar ('x');
+
+            response.PutChar (';');
+        }
+    }
+
+    return SendPacketNoLock(response.GetData(), response.GetSize());
+}
+
+GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_Z (StringExtractorGDBRemote &packet)
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
+
+    // We don't support if we're not llgs.
+    if (!IsGdbServer())
+        return SendUnimplementedResponse ("");
+
+    // Ensure we have a process.
+    if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, no process available", __FUNCTION__);
+        return SendErrorResponse (0x15);
+    }
+
+    // Parse out software or hardware breakpoint requested.
+    packet.SetFilePos (strlen("Z"));
+    if (packet.GetBytesLeft() < 1)
+        return SendIllFormedResponse(packet, "Too short Z packet, missing software/hardware specifier");
+
+    bool want_breakpoint = true;
+    bool want_hardware = false;
+
+    const char breakpoint_type_char = packet.GetChar ();
+    switch (breakpoint_type_char)
+    {
+        case '0': want_hardware = false; want_breakpoint = true;  break;
+        case '1': want_hardware = true;  want_breakpoint = true;  break;
+        case '2': want_breakpoint = false; break;
+        case '3': want_breakpoint = false; break;
+        default:
+            return SendIllFormedResponse(packet, "Z packet had invalid software/hardware specifier");
+
+    }
+
+    if ((packet.GetBytesLeft() < 1) || packet.GetChar () != ',')
+        return SendIllFormedResponse(packet, "Malformed Z packet, expecting comma after breakpoint type");
+
+    // FIXME implement watchpoint support.
+    if (!want_breakpoint)
+        return SendUnimplementedResponse ("watchpoint support not yet implemented");
+
+    // Parse out the breakpoint address.
+    if (packet.GetBytesLeft() < 1)
+        return SendIllFormedResponse(packet, "Too short Z packet, missing address");
+    const lldb::addr_t breakpoint_addr = packet.GetHexMaxU64(false, 0);
+
+    if ((packet.GetBytesLeft() < 1) || packet.GetChar () != ',')
+        return SendIllFormedResponse(packet, "Malformed Z packet, expecting comma after address");
+
+    // Parse out the breakpoint kind (i.e. size hint for opcode size).
+    const uint32_t kind = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ());
+    if (kind == std::numeric_limits<uint32_t>::max ())
+        return SendIllFormedResponse(packet, "Malformed Z packet, failed to parse kind argument");
+
+    if (want_breakpoint)
+    {
+        // Try to set the breakpoint.
+        const Error error = m_debugged_process_sp->SetBreakpoint (breakpoint_addr, kind, want_hardware);
+        if (error.Success ())
+            return SendOKResponse ();
+        else
+        {
+            if (log)
+                log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " failed to set breakpoint: %s", __FUNCTION__, m_debugged_process_sp->GetID (), error.AsCString ());
+            return SendErrorResponse (0x09);
+        }
+    }
+
+    // FIXME fix up after watchpoints are handled.
+    return SendUnimplementedResponse ("");
+}
+
+GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_z (StringExtractorGDBRemote &packet)
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
+
+    // We don't support if we're not llgs.
+    if (!IsGdbServer())
+        return SendUnimplementedResponse ("");
+
+    // Ensure we have a process.
+    if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, no process available", __FUNCTION__);
+        return SendErrorResponse (0x15);
+    }
+
+    // Parse out software or hardware breakpoint requested.
+    packet.SetFilePos (strlen("Z"));
+    if (packet.GetBytesLeft() < 1)
+        return SendIllFormedResponse(packet, "Too short z packet, missing software/hardware specifier");
+
+    bool want_breakpoint = true;
+
+    const char breakpoint_type_char = packet.GetChar ();
+    switch (breakpoint_type_char)
+    {
+        case '0': want_breakpoint = true;  break;
+        case '1': want_breakpoint = true;  break;
+        case '2': want_breakpoint = false; break;
+        case '3': want_breakpoint = false; break;
+        default:
+            return SendIllFormedResponse(packet, "z packet had invalid software/hardware specifier");
+
+    }
+
+    if ((packet.GetBytesLeft() < 1) || packet.GetChar () != ',')
+        return SendIllFormedResponse(packet, "Malformed z packet, expecting comma after breakpoint type");
+
+    // FIXME implement watchpoint support.
+    if (!want_breakpoint)
+        return SendUnimplementedResponse ("watchpoint support not yet implemented");
+
+    // Parse out the breakpoint address.
+    if (packet.GetBytesLeft() < 1)
+        return SendIllFormedResponse(packet, "Too short z packet, missing address");
+    const lldb::addr_t breakpoint_addr = packet.GetHexMaxU64(false, 0);
+
+    if ((packet.GetBytesLeft() < 1) || packet.GetChar () != ',')
+        return SendIllFormedResponse(packet, "Malformed z packet, expecting comma after address");
+
+    // Parse out the breakpoint kind (i.e. size hint for opcode size).
+    const uint32_t kind = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ());
+    if (kind == std::numeric_limits<uint32_t>::max ())
+        return SendIllFormedResponse(packet, "Malformed z packet, failed to parse kind argument");
+
+    if (want_breakpoint)
+    {
+        // Try to set the breakpoint.
+        const Error error = m_debugged_process_sp->RemoveBreakpoint (breakpoint_addr);
+        if (error.Success ())
+            return SendOKResponse ();
+        else
+        {
+            if (log)
+                log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " failed to remove breakpoint: %s", __FUNCTION__, m_debugged_process_sp->GetID (), error.AsCString ());
+            return SendErrorResponse (0x09);
+        }
+    }
+
+    // FIXME fix up after watchpoints are handled.
+    return SendUnimplementedResponse ("");
+}
+
+GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_s (StringExtractorGDBRemote &packet)
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_THREAD));
+
+    // We don't support if we're not llgs.
+    if (!IsGdbServer())
+        return SendUnimplementedResponse ("");
+
+    // Ensure we have a process.
+    if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed, no process available", __FUNCTION__);
+        return SendErrorResponse (0x32);
+    }
+
+    // We first try to use a continue thread id.  If any one or any all set, use the current thread.
+    // Bail out if we don't have a thread id.
+    lldb::tid_t tid = GetContinueThreadID ();
+    if (tid == 0 || tid == LLDB_INVALID_THREAD_ID)
+        tid = GetCurrentThreadID ();
+    if (tid == LLDB_INVALID_THREAD_ID)
+        return SendErrorResponse (0x33);
+
+    // Double check that we have such a thread.
+    // TODO investigate: on MacOSX we might need to do an UpdateThreads () here.
+    NativeThreadProtocolSP thread_sp = m_debugged_process_sp->GetThreadByID (tid);
+    if (!thread_sp || thread_sp->GetID () != tid)
+        return SendErrorResponse (0x33);
+
+    // Create the step action for the given thread.
+    lldb_private::ResumeAction action = { tid, eStateStepping, 0 };
+
+    // Setup the actions list.
+    lldb_private::ResumeActionList actions;
+    actions.Append (action);
+
+    // All other threads stop while we're single stepping a thread.
+    actions.SetDefaultThreadActionIfNeeded(eStateStopped, 0);
+    Error error = m_debugged_process_sp->Resume (actions);
+    if (error.Fail ())
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " tid %" PRIu64 " Resume() failed with error: %s", __FUNCTION__, m_debugged_process_sp->GetID (), tid, error.AsCString ());
+        return SendErrorResponse(0x49);
+    }
+
+    // No response here - the stop or exit will come from the resulting action.
+    return PacketResult::Success;
+}
+
+GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_qSupported (StringExtractorGDBRemote &packet)
+{
+    StreamGDBRemote response;
+
+    // Features common to lldb-platform and llgs.
+    uint32_t max_packet_size = 128 * 1024;  // 128KBytes is a reasonable max packet size--debugger can always use less
+    response.Printf ("PacketSize=%x", max_packet_size);
+
+    response.PutCString (";QStartNoAckMode+");
+    response.PutCString (";QThreadSuffixSupported+");
+    response.PutCString (";QListThreadsInStopReply+");
+#if defined(__linux__)
+    response.PutCString (";qXfer:auxv:read+");
+#endif
+
+    return SendPacketNoLock(response.GetData(), response.GetSize());
+}
+
+GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_QThreadSuffixSupported (StringExtractorGDBRemote &packet)
+{
+    m_thread_suffix_supported = true;
+    return SendOKResponse();
+}
+
+GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_QListThreadsInStopReply (StringExtractorGDBRemote &packet)
+{
+    m_list_threads_in_stop_reply = true;
+    return SendOKResponse();
+}
+
+GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_qXfer_auxv_read (StringExtractorGDBRemote &packet)
+{
+    // We don't support if we're not llgs.
+    if (!IsGdbServer())
+        return SendUnimplementedResponse ("only supported for lldb-gdbserver");
+
+    // *BSD impls should be able to do this too.
+#if defined(__linux__)
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    // Parse out the offset.
+    packet.SetFilePos (strlen("qXfer:auxv:read::"));
+    if (packet.GetBytesLeft () < 1)
+        return SendIllFormedResponse (packet, "qXfer:auxv:read:: packet missing offset");
+
+    const uint64_t auxv_offset = packet.GetHexMaxU64 (false, std::numeric_limits<uint64_t>::max ());
+    if (auxv_offset == std::numeric_limits<uint64_t>::max ())
+        return SendIllFormedResponse (packet, "qXfer:auxv:read:: packet missing offset");
+
+    // Parse out comma.
+    if (packet.GetBytesLeft () < 1 || packet.GetChar () != ',')
+        return SendIllFormedResponse (packet, "qXfer:auxv:read:: packet missing comma after offset");
+
+    // Parse out the length.
+    const uint64_t auxv_length = packet.GetHexMaxU64 (false, std::numeric_limits<uint64_t>::max ());
+    if (auxv_length == std::numeric_limits<uint64_t>::max ())
+        return SendIllFormedResponse (packet, "qXfer:auxv:read:: packet missing length");
+
+    // Grab the auxv data if we need it.
+    if (!m_active_auxv_buffer_sp)
+    {
+        // Make sure we have a valid process.
+        if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
+        {
+            if (log)
+                log->Printf ("GDBRemoteCommunicationServer::%s failed, no process available", __FUNCTION__);
+            return SendErrorResponse (0x10);
+        }
+
+        // Grab the auxv data.
+        m_active_auxv_buffer_sp = Host::GetAuxvData (m_debugged_process_sp->GetID ());
+        if (!m_active_auxv_buffer_sp || m_active_auxv_buffer_sp->GetByteSize () ==  0)
+        {
+            // Hmm, no auxv data, call that an error.
+            if (log)
+                log->Printf ("GDBRemoteCommunicationServer::%s failed, no auxv data retrieved", __FUNCTION__);
+            m_active_auxv_buffer_sp.reset ();
+            return SendErrorResponse (0x11);
+        }
+    }
+
+    // FIXME find out if/how I lock the stream here.
+
+    StreamGDBRemote response;
+    bool done_with_buffer = false;
+
+    if (auxv_offset >= m_active_auxv_buffer_sp->GetByteSize ())
+    {
+        // We have nothing left to send.  Mark the buffer as complete.
+        response.PutChar ('l');
+        done_with_buffer = true;
+    }
+    else
+    {
+        // Figure out how many bytes are available starting at the given offset.
+        const uint64_t bytes_remaining = m_active_auxv_buffer_sp->GetByteSize () - auxv_offset;
+
+        // Figure out how many bytes we're going to read.
+        const uint64_t bytes_to_read = (auxv_length > bytes_remaining) ? bytes_remaining : auxv_length;
+
+        // Mark the response type according to whether we're reading the remainder of the auxv data.
+        if (bytes_to_read >= bytes_remaining)
+        {
+            // There will be nothing left to read after this
+            response.PutChar ('l');
+            done_with_buffer = true;
+        }
+        else
+        {
+            // There will still be bytes to read after this request.
+            response.PutChar ('m');
+        }
+
+        // Now write the data in encoded binary form.
+        response.PutEscapedBytes (m_active_auxv_buffer_sp->GetBytes () + auxv_offset, bytes_to_read);
+    }
+
+    if (done_with_buffer)
+        m_active_auxv_buffer_sp.reset ();
+
+    return SendPacketNoLock(response.GetData(), response.GetSize());
+#else
+    return SendUnimplementedResponse ("not implemented on this platform");
+#endif
+}
+
+GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_QSaveRegisterState (StringExtractorGDBRemote &packet)
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
+
+    // We don't support if we're not llgs.
+    if (!IsGdbServer())
+        return SendUnimplementedResponse ("only supported for lldb-gdbserver");
+
+    // Move past packet name.
+    packet.SetFilePos (strlen ("QSaveRegisterState"));
+
+    // Get the thread to use.
+    NativeThreadProtocolSP thread_sp = GetThreadFromSuffix (packet);
+    if (!thread_sp)
+    {
+        if (m_thread_suffix_supported)
+            return SendIllFormedResponse (packet, "No thread specified in QSaveRegisterState packet");
+        else
+            return SendIllFormedResponse (packet, "No thread was is set with the Hg packet");
+    }
+
+    // Grab the register context for the thread.
+    NativeRegisterContextSP reg_context_sp (thread_sp->GetRegisterContext ());
+    if (!reg_context_sp)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " tid %" PRIu64 " failed, no register context available for the thread", __FUNCTION__, m_debugged_process_sp->GetID (), thread_sp->GetID ());
+        return SendErrorResponse (0x15);
+    }
+
+    // Save registers to a buffer.
+    DataBufferSP register_data_sp;
+    Error error = reg_context_sp->ReadAllRegisterValues (register_data_sp);
+    if (error.Fail ())
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " failed to save all register values: %s", __FUNCTION__, m_debugged_process_sp->GetID (), error.AsCString ());
+        return SendErrorResponse (0x75);
+    }
+
+    // Allocate a new save id.
+    const uint32_t save_id = GetNextSavedRegistersID ();
+    assert ((m_saved_registers_map.find (save_id) == m_saved_registers_map.end ()) && "GetNextRegisterSaveID() returned an existing register save id");
+
+    // Save the register data buffer under the save id.
+    {
+        Mutex::Locker locker (m_saved_registers_mutex);
+        m_saved_registers_map[save_id] = register_data_sp;
+    }
+
+    // Write the response.
+    StreamGDBRemote response;
+    response.Printf ("%" PRIu32, save_id);
+    return SendPacketNoLock(response.GetData(), response.GetSize());
+}
+
+GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_QRestoreRegisterState (StringExtractorGDBRemote &packet)
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
+
+    // We don't support if we're not llgs.
+    if (!IsGdbServer())
+        return SendUnimplementedResponse ("only supported for lldb-gdbserver");
+
+    // Parse out save id.
+    packet.SetFilePos (strlen ("QRestoreRegisterState:"));
+    if (packet.GetBytesLeft () < 1)
+        return SendIllFormedResponse (packet, "QRestoreRegisterState packet missing register save id");
+
+    const uint32_t save_id = packet.GetU32 (0);
+    if (save_id == 0)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s QRestoreRegisterState packet has malformed save id, expecting decimal uint32_t", __FUNCTION__);
+        return SendErrorResponse (0x76);
+    }
+
+    // Get the thread to use.
+    NativeThreadProtocolSP thread_sp = GetThreadFromSuffix (packet);
+    if (!thread_sp)
+    {
+        if (m_thread_suffix_supported)
+            return SendIllFormedResponse (packet, "No thread specified in QRestoreRegisterState packet");
+        else
+            return SendIllFormedResponse (packet, "No thread was is set with the Hg packet");
+    }
+
+    // Grab the register context for the thread.
+    NativeRegisterContextSP reg_context_sp (thread_sp->GetRegisterContext ());
+    if (!reg_context_sp)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " tid %" PRIu64 " failed, no register context available for the thread", __FUNCTION__, m_debugged_process_sp->GetID (), thread_sp->GetID ());
+        return SendErrorResponse (0x15);
+    }
+
+    // Retrieve register state buffer, then remove from the list.
+    DataBufferSP register_data_sp;
+    {
+        Mutex::Locker locker (m_saved_registers_mutex);
+
+        // Find the register set buffer for the given save id.
+        auto it = m_saved_registers_map.find (save_id);
+        if (it == m_saved_registers_map.end ())
+        {
+            if (log)
+                log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " does not have a register set save buffer for id %" PRIu32, __FUNCTION__, m_debugged_process_sp->GetID (), save_id);
+            return SendErrorResponse (0x77);
+        }
+        register_data_sp = it->second;
+
+        // Remove it from the map.
+        m_saved_registers_map.erase (it);
+    }
+
+    Error error = reg_context_sp->WriteAllRegisterValues (register_data_sp);
+    if (error.Fail ())
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s pid %" PRIu64 " failed to restore all register values: %s", __FUNCTION__, m_debugged_process_sp->GetID (), error.AsCString ());
+        return SendErrorResponse (0x77);
+    }
+
+    return SendOKResponse();
+}
+
+GDBRemoteCommunicationServer::PacketResult
+GDBRemoteCommunicationServer::Handle_vAttach (StringExtractorGDBRemote &packet)
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    // We don't support if we're not llgs.
+    if (!IsGdbServer())
+        return SendUnimplementedResponse ("only supported for lldb-gdbserver");
+
+    // Consume the ';' after vAttach.
+    packet.SetFilePos (strlen ("vAttach"));
+    if (!packet.GetBytesLeft () || packet.GetChar () != ';')
+        return SendIllFormedResponse (packet, "vAttach missing expected ';'");
+
+    // Grab the PID to which we will attach (assume hex encoding).
+    lldb::pid_t pid = packet.GetU32 (LLDB_INVALID_PROCESS_ID, 16);
+    if (pid == LLDB_INVALID_PROCESS_ID)
+        return SendIllFormedResponse (packet, "vAttach failed to parse the process id");
+
+    // Attempt to attach.
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s attempting to attach to pid %" PRIu64, __FUNCTION__, pid);
+
+    Error error = AttachToProcess (pid);
+
+    if (error.Fail ())
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s failed to attach to pid %" PRIu64 ": %s\n", __FUNCTION__, pid, error.AsCString());
+        return SendErrorResponse (0x01);
+    }
+
+    // Notify we attached by sending a stop packet.
+    return SendStopReasonForState (m_debugged_process_sp->GetState (), true);
+
+    return PacketResult::Success;
+}
+
+void
+GDBRemoteCommunicationServer::FlushInferiorOutput ()
+{
+    // If we're not monitoring an inferior's terminal, ignore this.
+    if (!m_stdio_communication.IsConnected())
+        return;
+
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s() called", __FUNCTION__);
+
+    // FIXME implement a timeout on the join.
+    m_stdio_communication.JoinReadThread();
+}
+
+void
+GDBRemoteCommunicationServer::MaybeCloseInferiorTerminalConnection ()
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+    // Tell the stdio connection to shut down.
+    if (m_stdio_communication.IsConnected())
+    {
+        auto connection = m_stdio_communication.GetConnection();
+        if (connection)
+        {
+            Error error;
+            connection->Disconnect (&error);
+
+            if (error.Success ())
+            {
+                if (log)
+                    log->Printf ("GDBRemoteCommunicationServer::%s disconnect process terminal stdio - SUCCESS", __FUNCTION__);
+            }
+            else
+            {
+                if (log)
+                    log->Printf ("GDBRemoteCommunicationServer::%s disconnect process terminal stdio - FAIL: %s", __FUNCTION__, error.AsCString ());
+            }
+        }
+    }
+}
+
+
+lldb_private::NativeThreadProtocolSP
+GDBRemoteCommunicationServer::GetThreadFromSuffix (StringExtractorGDBRemote &packet)
+{
+    NativeThreadProtocolSP thread_sp;
+
+    // We have no thread if we don't have a process.
+    if (!m_debugged_process_sp || m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)
+        return thread_sp;
+
+    // If the client hasn't asked for thread suffix support, there will not be a thread suffix.
+    // Use the current thread in that case.
+    if (!m_thread_suffix_supported)
+    {
+        const lldb::tid_t current_tid = GetCurrentThreadID ();
+        if (current_tid == LLDB_INVALID_THREAD_ID)
+            return thread_sp;
+        else if (current_tid == 0)
+        {
+            // Pick a thread.
+            return m_debugged_process_sp->GetThreadAtIndex (0);
+        }
+        else
+            return m_debugged_process_sp->GetThreadByID (current_tid);
+    }
+
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
+
+    // Parse out the ';'.
+    if (packet.GetBytesLeft () < 1 || packet.GetChar () != ';')
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s gdb-remote parse error: expected ';' prior to start of thread suffix: packet contents = '%s'", __FUNCTION__, packet.GetStringRef ().c_str ());
+        return thread_sp;
+    }
+
+    if (!packet.GetBytesLeft ())
+        return thread_sp;
+
+    // Parse out thread: portion.
+    if (strncmp (packet.Peek (), "thread:", strlen("thread:")) != 0)
+    {
+        if (log)
+            log->Printf ("GDBRemoteCommunicationServer::%s gdb-remote parse error: expected 'thread:' but not found, packet contents = '%s'", __FUNCTION__, packet.GetStringRef ().c_str ());
+        return thread_sp;
+    }
+    packet.SetFilePos (packet.GetFilePos () + strlen("thread:"));
+    const lldb::tid_t tid = packet.GetHexMaxU64(false, 0);
+    if (tid != 0)
+        return m_debugged_process_sp->GetThreadByID (tid);
+
+    return thread_sp;
+}
+
+lldb::tid_t
+GDBRemoteCommunicationServer::GetCurrentThreadID () const
+{
+    if (m_current_tid == 0 || m_current_tid == LLDB_INVALID_THREAD_ID)
+    {
+        // Use whatever the debug process says is the current thread id
+        // since the protocol either didn't specify or specified we want
+        // any/all threads marked as the current thread.
+        if (!m_debugged_process_sp)
+            return LLDB_INVALID_THREAD_ID;
+        return m_debugged_process_sp->GetCurrentThreadID ();
+    }
+    // Use the specific current thread id set by the gdb remote protocol.
+    return m_current_tid;
+}
+
+uint32_t
+GDBRemoteCommunicationServer::GetNextSavedRegistersID ()
+{
+    Mutex::Locker locker (m_saved_registers_mutex);
+    return m_next_saved_registers_id++;
+}
+
+void
+GDBRemoteCommunicationServer::ClearProcessSpecificData ()
+{
+    Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS|GDBR_LOG_PROCESS));
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s()", __FUNCTION__);
+
+    // Clear any auxv cached data.
+    // *BSD impls should be able to do this too.
+#if defined(__linux__)
+    if (log)
+        log->Printf ("GDBRemoteCommunicationServer::%s clearing auxv buffer (previously %s)",
+                     __FUNCTION__,
+                     m_active_auxv_buffer_sp ? "was set" : "was not set");
+    m_active_auxv_buffer_sp.reset ();
+#endif
+}
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.h b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.h
index 913c6b6..13c037c 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.h
@@ -14,16 +14,23 @@
 // C++ Includes
 #include <vector>
 #include <set>
+#include <unordered_map>
 // Other libraries and framework includes
 // Project includes
+#include "lldb/lldb-private-forward.h"
+#include "lldb/Core/Communication.h"
 #include "lldb/Host/Mutex.h"
 #include "lldb/Target/Process.h"
 #include "GDBRemoteCommunication.h"
 
+#include "../../../Host/common/NativeProcessProtocol.h"
+
 class ProcessGDBRemote;
 class StringExtractorGDBRemote;
 
-class GDBRemoteCommunicationServer : public GDBRemoteCommunication
+class GDBRemoteCommunicationServer :
+    public GDBRemoteCommunication,
+    public lldb_private::NativeProcessProtocol::NativeDelegate
 {
 public:
     typedef std::map<uint16_t, lldb::pid_t> PortMap;
@@ -38,12 +45,13 @@ public:
     GDBRemoteCommunicationServer(bool is_platform);
 
     GDBRemoteCommunicationServer(bool is_platform,
-                                 const lldb::PlatformSP& platform_sp); 
+                                 const lldb::PlatformSP& platform_sp,
+                                 lldb::DebuggerSP& debugger_sp);
 
     virtual
     ~GDBRemoteCommunicationServer();
 
-    bool
+    PacketResult
     GetPacketAndSendResponse (uint32_t timeout_usec,
                               lldb_private::Error &error,
                               bool &interrupt, 
@@ -188,6 +196,31 @@ public:
     lldb_private::Error
     LaunchProcess ();
 
+    //------------------------------------------------------------------
+    /// Attach to a process.
+    ///
+    /// This method supports attaching llgs to a process accessible via the
+    /// configured Platform.
+    ///
+    /// @return
+    ///     An Error object indicating the success or failure of the
+    ///     attach operation.
+    //------------------------------------------------------------------
+    lldb_private::Error
+    AttachToProcess (lldb::pid_t pid);
+
+    //------------------------------------------------------------------
+    // NativeProcessProtocol::NativeDelegate overrides
+    //------------------------------------------------------------------
+    void
+    InitializeDelegate (lldb_private::NativeProcessProtocol *process) override;
+
+    void
+    ProcessStateChanged (lldb_private::NativeProcessProtocol *process, lldb::StateType state) override;
+
+    void
+    DidExec (lldb_private::NativeProcessProtocol *process) override;
+
 protected:
     lldb::PlatformSP m_platform_sp;
     lldb::thread_t m_async_thread;
@@ -199,7 +232,20 @@ protected:
     uint32_t m_proc_infos_index;
     PortMap m_port_map;
     uint16_t m_port_offset;
-
+    lldb::tid_t m_current_tid;
+    lldb::tid_t m_continue_tid;
+    lldb_private::Mutex m_debugged_process_mutex;
+    lldb_private::NativeProcessProtocolSP m_debugged_process_sp;
+    lldb::DebuggerSP m_debugger_sp;
+    Communication m_stdio_communication;
+    bool m_exit_now; // use in asynchronous handling to indicate process should exit.
+    lldb::StateType m_inferior_prev_state;
+    bool m_thread_suffix_supported;
+    bool m_list_threads_in_stop_reply;
+    lldb::DataBufferSP m_active_auxv_buffer_sp;
+    lldb_private::Mutex m_saved_registers_mutex;
+    std::unordered_map<uint32_t, lldb::DataBufferSP> m_saved_registers_map;
+    uint32_t m_next_saved_registers_id;
 
     PacketResult
     SendUnimplementedResponse (const char *packet);
@@ -208,9 +254,24 @@ protected:
     SendErrorResponse (uint8_t error);
 
     PacketResult
+    SendIllFormedResponse (const StringExtractorGDBRemote &packet, const char *error_message);
+
+    PacketResult
     SendOKResponse ();
 
     PacketResult
+    SendONotification (const char *buffer, uint32_t len);
+
+    PacketResult
+    SendWResponse (lldb_private::NativeProcessProtocol *process);
+
+    PacketResult
+    SendStopReplyPacketForThread (lldb::tid_t tid);
+
+    PacketResult
+    SendStopReasonForState (lldb::StateType process_state, bool flush_on_exit);
+
+    PacketResult
     Handle_A (StringExtractorGDBRemote &packet);
     
     PacketResult
@@ -233,7 +294,10 @@ protected:
     
     PacketResult
     Handle_qPlatform_chmod (StringExtractorGDBRemote &packet);
-    
+
+    PacketResult
+    Handle_qProcessInfo (StringExtractorGDBRemote &packet);
+
     PacketResult
     Handle_qProcessInfoPID (StringExtractorGDBRemote &packet);
     
@@ -265,6 +329,9 @@ protected:
     Handle_QSetDisableASLR (StringExtractorGDBRemote &packet);
 
     PacketResult
+    Handle_QSetDetachOnError (StringExtractorGDBRemote &packet);
+
+    PacketResult
     Handle_QSetWorkingDir (StringExtractorGDBRemote &packet);
     
     PacketResult
@@ -281,7 +348,22 @@ protected:
 
     PacketResult
     Handle_QSetSTDERR (StringExtractorGDBRemote &packet);
-    
+
+    PacketResult
+    Handle_C (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_c (StringExtractorGDBRemote &packet, bool skip_file_pos_adjustment = false);
+
+    PacketResult
+    Handle_vCont (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_vCont_actions (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_stop_reason (StringExtractorGDBRemote &packet);
+
     PacketResult
     Handle_vFile_Open (StringExtractorGDBRemote &packet);
 
@@ -318,6 +400,87 @@ protected:
     PacketResult
     Handle_qPlatform_shell (StringExtractorGDBRemote &packet);
 
+    PacketResult
+    Handle_qRegisterInfo (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_qfThreadInfo (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_qsThreadInfo (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_p (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_P (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_H (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_interrupt (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_m (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_M (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_qMemoryRegionInfoSupported (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_qMemoryRegionInfo (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_Z (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_z (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_s (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_qSupported (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_QThreadSuffixSupported (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_QListThreadsInStopReply (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_qXfer_auxv_read (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_QSaveRegisterState (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_QRestoreRegisterState (StringExtractorGDBRemote &packet);
+
+    PacketResult
+    Handle_vAttach (StringExtractorGDBRemote &packet);
+
+    void
+    SetCurrentThreadID (lldb::tid_t tid);
+
+    lldb::tid_t
+    GetCurrentThreadID () const;
+
+    void
+    SetContinueThreadID (lldb::tid_t tid);
+
+    lldb::tid_t
+    GetContinueThreadID () const { return m_continue_tid; }
+
+    lldb_private::Error
+    SetSTDIOFileDescriptor (int fd);
+
+    static void
+    STDIOReadThreadBytesReceived (void *baton, const void *src, size_t src_len);
+
 private:
     bool
     DebugserverProcessReaped (lldb::pid_t pid);
@@ -342,6 +505,41 @@ private:
     bool
     KillSpawnedProcess (lldb::pid_t pid);
 
+    bool
+    IsGdbServer ()
+    {
+        return !m_is_platform;
+    }
+
+    /// Launch a process from lldb-gdbserver
+    lldb_private::Error
+    LaunchDebugServerProcess ();
+
+    /// Launch a process from lldb-platform
+    lldb_private::Error
+    LaunchPlatformProcess ();
+
+    void
+    HandleInferiorState_Exited (lldb_private::NativeProcessProtocol *process);
+
+    void
+    HandleInferiorState_Stopped (lldb_private::NativeProcessProtocol *process);
+
+    void
+    FlushInferiorOutput ();
+
+    lldb_private::NativeThreadProtocolSP
+    GetThreadFromSuffix (StringExtractorGDBRemote &packet);
+
+    uint32_t
+    GetNextSavedRegistersID ();
+
+    void
+    MaybeCloseInferiorTerminalConnection ();
+
+    void
+    ClearProcessSpecificData ();
+
     //------------------------------------------------------------------
     // For GDBRemoteCommunicationServer only
     //------------------------------------------------------------------
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
index 73b9b3e..6d7eca1 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.cpp
@@ -21,6 +21,7 @@
 #include "lldb/Interpreter/PythonDataObjects.h"
 #endif
 #include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Target.h"
 #include "lldb/Utility/Utils.h"
 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
@@ -199,7 +200,7 @@ GDBRemoteRegisterContext::ReadRegisterBytes (const RegisterInfo *reg_info, DataE
                 const uint32_t prim_reg = reg_info->value_regs[idx];
                 if (prim_reg == LLDB_INVALID_REGNUM)
                     break;
-                // We have a valid primordial regsiter as our constituent.
+                // We have a valid primordial register as our constituent.
                 // Grab the corresponding register info.
                 const RegisterInfo *prim_reg_info = GetRegisterInfoAtIndex(prim_reg);
                 if (prim_reg_info == NULL)
@@ -232,11 +233,20 @@ GDBRemoteRegisterContext::ReadRegisterBytes (const RegisterInfo *reg_info, DataE
 
     if (&data != &m_reg_data)
     {
+#if defined (LLDB_CONFIGURATION_DEBUG)
+        assert (m_reg_data.GetByteSize() >= reg_info->byte_offset + reg_info->byte_size);
+#endif  
+        // If our register context and our register info disagree, which should never happen, don't
+        // read past the end of the buffer.
+        if (m_reg_data.GetByteSize() < reg_info->byte_offset + reg_info->byte_size)
+            return false;
+
         // If we aren't extracting into our own buffer (which
         // only happens when this function is called from
         // ReadRegisterValue(uint32_t, Scalar&)) then
         // we transfer bytes from our buffer into the data
         // buffer that was passed in
+
         data.SetByteOrder (m_reg_data.GetByteOrder());
         data.SetData (m_reg_data, reg_info->byte_offset, reg_info->byte_size);
     }
@@ -322,6 +332,16 @@ GDBRemoteRegisterContext::WriteRegisterBytes (const lldb_private::RegisterInfo *
 //    if (gdb_comm.IsRunning())
 //        return false;
 
+
+#if defined (LLDB_CONFIGURATION_DEBUG)
+    assert (m_reg_data.GetByteSize() >= reg_info->byte_offset + reg_info->byte_size);
+#endif
+
+    // If our register context and our register info disagree, which should never happen, don't
+    // overwrite past the end of the buffer.
+    if (m_reg_data.GetByteSize() < reg_info->byte_offset + reg_info->byte_size)
+        return false;
+
     // Grab a pointer to where we are going to put this register
     uint8_t *dst = const_cast<uint8_t*>(m_reg_data.PeekData(reg_info->byte_offset, reg_info->byte_size));
 
@@ -389,7 +409,7 @@ GDBRemoteRegisterContext::WriteRegisterBytes (const lldb_private::RegisterInfo *
                             const uint32_t reg = reg_info->value_regs[idx];
                             if (reg == LLDB_INVALID_REGNUM)
                                 break;
-                            // We have a valid primordial regsiter as our constituent.
+                            // We have a valid primordial register as our constituent.
                             // Grab the corresponding register info.
                             const RegisterInfo *value_reg_info = GetRegisterInfoAtIndex(reg);
                             if (value_reg_info == NULL)
@@ -502,6 +522,8 @@ GDBRemoteRegisterContext::ReadAllRegisterValues (lldb::DataBufferSP &data_sp)
 
     StringExtractorGDBRemote response;
 
+    const bool use_g_packet = gdb_comm.AvoidGPackets ((ProcessGDBRemote *)process) == false;
+
     Mutex::Locker locker;
     if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex for read all registers."))
     {
@@ -519,29 +541,62 @@ GDBRemoteRegisterContext::ReadAllRegisterValues (lldb::DataBufferSP &data_sp)
                 packet_len = ::snprintf (packet, sizeof(packet), "g");
             assert (packet_len < ((int)sizeof(packet) - 1));
 
-            if (gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, false) == GDBRemoteCommunication::PacketResult::Success)
+            if (use_g_packet && gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, false) == GDBRemoteCommunication::PacketResult::Success)
             {
-                if (response.IsErrorResponse())
-                    return false;
-
-                std::string &response_str = response.GetStringRef();
-                if (isxdigit(response_str[0]))
+                int packet_len = 0;
+                if (thread_suffix_supported)
+                    packet_len = ::snprintf (packet, sizeof(packet), "g;thread:%4.4" PRIx64, m_thread.GetProtocolID());
+                else
+                    packet_len = ::snprintf (packet, sizeof(packet), "g");
+                assert (packet_len < ((int)sizeof(packet) - 1));
+    
+                if (gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, false) == GDBRemoteCommunication::PacketResult::Success)
                 {
-                    response_str.insert(0, 1, 'G');
-                    if (thread_suffix_supported)
+                    if (response.IsErrorResponse())
+                        return false;
+    
+                    std::string &response_str = response.GetStringRef();
+                    if (isxdigit(response_str[0]))
                     {
-                        char thread_id_cstr[64];
-                        ::snprintf (thread_id_cstr, sizeof(thread_id_cstr), ";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
-                        response_str.append (thread_id_cstr);
+                        response_str.insert(0, 1, 'G');
+                        if (thread_suffix_supported)
+                        {
+                            char thread_id_cstr[64];
+                            ::snprintf (thread_id_cstr, sizeof(thread_id_cstr), ";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
+                            response_str.append (thread_id_cstr);
+                        }
+                        data_sp.reset (new DataBufferHeap (response_str.c_str(), response_str.size()));
+                        return true;
                     }
-                    data_sp.reset (new DataBufferHeap (response_str.c_str(), response_str.size()));
-                    return true;
                 }
             }
+            else
+            {
+                // For the use_g_packet == false case, we're going to read each register 
+                // individually and store them as binary data in a buffer instead of as ascii
+                // characters.
+                const RegisterInfo *reg_info;
+
+                // data_sp will take ownership of this DataBufferHeap pointer soon.
+                DataBufferSP reg_ctx(new DataBufferHeap(m_reg_info.GetRegisterDataByteSize(), 0));
+
+                for (uint32_t i = 0; (reg_info = GetRegisterInfoAtIndex (i)) != NULL; i++)
+                {
+                    if (reg_info->value_regs) // skip registers that are slices of real registers
+                        continue;
+                    ReadRegisterBytes (reg_info, m_reg_data);
+                    // ReadRegisterBytes saves the contents of the register in to the m_reg_data buffer
+                }
+                memcpy (reg_ctx->GetBytes(), m_reg_data.GetDataStart(), m_reg_info.GetRegisterDataByteSize());
+
+                data_sp = reg_ctx;
+                return true;
+            }
         }
     }
     else
     {
+
         Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_THREAD | GDBR_LOG_PACKETS));
         if (log)
         {
@@ -575,6 +630,8 @@ GDBRemoteRegisterContext::WriteAllRegisterValues (const lldb::DataBufferSP &data
 
     GDBRemoteCommunicationClient &gdb_comm (((ProcessGDBRemote *)process)->GetGDBRemote());
 
+    const bool use_g_packet = gdb_comm.AvoidGPackets ((ProcessGDBRemote *)process) == false;
+
     StringExtractorGDBRemote response;
     Mutex::Locker locker;
     if (gdb_comm.GetSequenceMutex (locker, "Didn't get sequence mutex for write all registers."))
@@ -588,63 +645,126 @@ GDBRemoteRegisterContext::WriteAllRegisterValues (const lldb::DataBufferSP &data
             // as well.
             const char *G_packet = (const char *)data_sp->GetBytes();
             size_t G_packet_len = data_sp->GetByteSize();
-            if (gdb_comm.SendPacketAndWaitForResponse (G_packet,
-                                                       G_packet_len,
-                                                       response,
-                                                       false) == GDBRemoteCommunication::PacketResult::Success)
+            if (use_g_packet
+                && gdb_comm.SendPacketAndWaitForResponse (G_packet,
+                                                          G_packet_len,
+                                                          response,
+                                                          false) == GDBRemoteCommunication::PacketResult::Success)
             {
-                if (response.IsOKResponse())
-                    return true;
-                else if (response.IsErrorResponse())
+                // The data_sp contains the entire G response packet including the
+                // G, and if the thread suffix is supported, it has the thread suffix
+                // as well.
+                const char *G_packet = (const char *)data_sp->GetBytes();
+                size_t G_packet_len = data_sp->GetByteSize();
+                if (gdb_comm.SendPacketAndWaitForResponse (G_packet,
+                                                           G_packet_len,
+                                                           response,
+                                                           false) == GDBRemoteCommunication::PacketResult::Success)
                 {
-                    uint32_t num_restored = 0;
-                    // We need to manually go through all of the registers and
-                    // restore them manually
-
-                    response.GetStringRef().assign (G_packet, G_packet_len);
-                    response.SetFilePos(1); // Skip the leading 'G'
-                    DataBufferHeap buffer (m_reg_data.GetByteSize(), 0);
-                    DataExtractor restore_data (buffer.GetBytes(),
-                                                buffer.GetByteSize(),
-                                                m_reg_data.GetByteOrder(),
-                                                m_reg_data.GetAddressByteSize());
-
-                    const uint32_t bytes_extracted = response.GetHexBytes ((void *)restore_data.GetDataStart(),
-                                                                           restore_data.GetByteSize(),
-                                                                           '\xcc');
-
-                    if (bytes_extracted < restore_data.GetByteSize())
-                        restore_data.SetData(restore_data.GetDataStart(), bytes_extracted, m_reg_data.GetByteOrder());
-
-                    //ReadRegisterBytes (const RegisterInfo *reg_info, RegisterValue &value, DataExtractor &data)
-                    const RegisterInfo *reg_info;
-                    // We have to march the offset of each register along in the
-                    // buffer to make sure we get the right offset.
-                    uint32_t reg_byte_offset = 0;
-                    for (uint32_t reg_idx=0; (reg_info = GetRegisterInfoAtIndex (reg_idx)) != NULL; ++reg_idx, reg_byte_offset += reg_info->byte_size)
+                    if (response.IsOKResponse())
+                        return true;
+                    else if (response.IsErrorResponse())
                     {
-                        const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
-
-                        // Skip composite registers.
-                        if (reg_info->value_regs)
-                            continue;
+                        uint32_t num_restored = 0;
+                        // We need to manually go through all of the registers and
+                        // restore them manually
+    
+                        response.GetStringRef().assign (G_packet, G_packet_len);
+                        response.SetFilePos(1); // Skip the leading 'G'
+
+                        // G_packet_len is hex-ascii characters plus prefix 'G' plus suffix thread specifier.
+                        // This means buffer will be a little more than 2x larger than necessary but we resize
+                        // it down once we've extracted all hex ascii chars from the packet.
+                        DataBufferHeap buffer (G_packet_len, 0);
+                        DataExtractor restore_data (buffer.GetBytes(),
+                                                    buffer.GetByteSize(),
+                                                    m_reg_data.GetByteOrder(),
+                                                    m_reg_data.GetAddressByteSize());
+    
+                        const uint32_t bytes_extracted = response.GetHexBytes ((void *)restore_data.GetDataStart(),
+                                                                               restore_data.GetByteSize(),
+                                                                               '\xcc');
+    
+                        if (bytes_extracted < restore_data.GetByteSize())
+                            restore_data.SetData(restore_data.GetDataStart(), bytes_extracted, m_reg_data.GetByteOrder());
+    
+                        const RegisterInfo *reg_info;
+
+                        // The g packet contents may either include the slice registers (registers defined in
+                        // terms of other registers, e.g. eax is a subset of rax) or not.  The slice registers 
+                        // should NOT be in the g packet, but some implementations may incorrectly include them.
+                        // 
+                        // If the slice registers are included in the packet, we must step over the slice registers 
+                        // when parsing the packet -- relying on the RegisterInfo byte_offset field would be incorrect.
+                        // If the slice registers are not included, then using the byte_offset values into the
+                        // data buffer is the best way to find individual register values.
+
+                        uint64_t size_including_slice_registers = 0;
+                        uint64_t size_not_including_slice_registers = 0;
+                        uint64_t size_by_highest_offset = 0;
+
+                        for (uint32_t reg_idx=0; (reg_info = GetRegisterInfoAtIndex (reg_idx)) != NULL; ++reg_idx)
+                        {
+                            size_including_slice_registers += reg_info->byte_size;
+                            if (reg_info->value_regs == NULL)
+                                size_not_including_slice_registers += reg_info->byte_size;
+                            if (reg_info->byte_offset >= size_by_highest_offset)
+                                size_by_highest_offset = reg_info->byte_offset + reg_info->byte_size;
+                        }
 
-                        // Only write down the registers that need to be written
-                        // if we are going to be doing registers individually.
-                        bool write_reg = true;
-                        const uint32_t reg_byte_size = reg_info->byte_size;
+                        bool use_byte_offset_into_buffer;
+                        if (size_by_highest_offset == restore_data.GetByteSize())
+                        {
+                            // The size of the packet agrees with the highest offset: + size in the register file
+                            use_byte_offset_into_buffer = true;
+                        }
+                        else if (size_not_including_slice_registers == restore_data.GetByteSize())
+                        {
+                            // The size of the packet is the same as concatenating all of the registers sequentially,
+                            // skipping the slice registers
+                            use_byte_offset_into_buffer = true;
+                        }
+                        else if (size_including_slice_registers == restore_data.GetByteSize())
+                        {
+                            // The slice registers are present in the packet (when they shouldn't be).
+                            // Don't try to use the RegisterInfo byte_offset into the restore_data, it will
+                            // point to the wrong place.
+                            use_byte_offset_into_buffer = false;
+                        }
+                        else {
+                            // None of our expected sizes match the actual g packet data we're looking at.
+                            // The most conservative approach here is to use the running total byte offset.
+                            use_byte_offset_into_buffer = false;
+                        }
 
-                        const char *restore_src = (const char *)restore_data.PeekData(reg_byte_offset, reg_byte_size);
-                        if (restore_src)
+                        // In case our register definitions don't include the correct offsets,
+                        // keep track of the size of each reg & compute offset based on that.
+                        uint32_t running_byte_offset = 0;
+                        for (uint32_t reg_idx=0; (reg_info = GetRegisterInfoAtIndex (reg_idx)) != NULL; ++reg_idx, running_byte_offset += reg_info->byte_size)
                         {
-                            if (GetRegisterIsValid(reg))
+                            // Skip composite aka slice registers (e.g. eax is a slice of rax).
+                            if (reg_info->value_regs)
+                                continue;
+
+                            const uint32_t reg = reg_info->kinds[eRegisterKindLLDB];
+
+                            uint32_t register_offset;
+                            if (use_byte_offset_into_buffer)
                             {
-                                const char *current_src = (const char *)m_reg_data.PeekData(reg_byte_offset, reg_byte_size);
-                                if (current_src)
-                                    write_reg = memcmp (current_src, restore_src, reg_byte_size) != 0;
+                                register_offset = reg_info->byte_offset;
+                            }
+                            else
+                            {
+                                register_offset = running_byte_offset;
                             }
 
-                            if (write_reg)
+                            // Only write down the registers that need to be written
+                            // if we are going to be doing registers individually.
+                            bool write_reg = true;
+                            const uint32_t reg_byte_size = reg_info->byte_size;
+    
+                            const char *restore_src = (const char *)restore_data.PeekData(register_offset, reg_byte_size);
+                            if (restore_src)
                             {
                                 StreamString packet;
                                 packet.Printf ("P%x=", reg);
@@ -662,14 +782,88 @@ GDBRemoteRegisterContext::WriteAllRegisterValues (const lldb::DataBufferSP &data
                                                                           response,
                                                                           false) == GDBRemoteCommunication::PacketResult::Success)
                                 {
-                                    if (response.IsOKResponse())
-                                        ++num_restored;
+                                    const char *current_src = (const char *)m_reg_data.PeekData(register_offset, reg_byte_size);
+                                    if (current_src)
+                                        write_reg = memcmp (current_src, restore_src, reg_byte_size) != 0;
+                                }
+    
+                                if (write_reg)
+                                {
+                                    StreamString packet;
+                                    packet.Printf ("P%x=", reg);
+                                    packet.PutBytesAsRawHex8 (restore_src,
+                                                              reg_byte_size,
+                                                              lldb::endian::InlHostByteOrder(),
+                                                              lldb::endian::InlHostByteOrder());
+    
+                                    if (thread_suffix_supported)
+                                        packet.Printf (";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
+    
+                                    SetRegisterIsValid(reg, false);
+                                    if (gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(),
+                                                                              packet.GetString().size(),
+                                                                              response,
+                                                                              false) == GDBRemoteCommunication::PacketResult::Success)
+                                    {
+                                        if (response.IsOKResponse())
+                                            ++num_restored;
+                                    }
                                 }
                             }
                         }
+                        return num_restored > 0;
+                    }
+                }
+            }
+            else
+            {
+                // For the use_g_packet == false case, we're going to write each register 
+                // individually.  The data buffer is binary data in this case, instead of 
+                // ascii characters.
+
+                bool arm64_debugserver = false;
+                if (m_thread.GetProcess().get())
+                {
+                    const ArchSpec &arch = m_thread.GetProcess()->GetTarget().GetArchitecture();
+                    if (arch.IsValid()
+                        && arch.GetMachine() == llvm::Triple::aarch64
+                        && arch.GetTriple().getVendor() == llvm::Triple::Apple
+                        && arch.GetTriple().getOS() == llvm::Triple::IOS)
+                    {
+                        arm64_debugserver = true;
+                    }
+                }
+                uint32_t num_restored = 0;
+                const RegisterInfo *reg_info;
+                for (uint32_t i = 0; (reg_info = GetRegisterInfoAtIndex (i)) != NULL; i++)
+                {
+                    if (reg_info->value_regs) // skip registers that are slices of real registers
+                        continue;
+                    // Skip the fpsr and fpcr floating point status/control register writing to
+                    // work around a bug in an older version of debugserver that would lead to
+                    // register context corruption when writing fpsr/fpcr.
+                    if (arm64_debugserver &&
+                        (strcmp (reg_info->name, "fpsr") == 0 || strcmp (reg_info->name, "fpcr") == 0))
+                    {
+                        continue;
+                    }
+                    StreamString packet;
+                    packet.Printf ("P%x=", reg_info->kinds[eRegisterKindLLDB]);
+                    packet.PutBytesAsRawHex8 (data_sp->GetBytes() + reg_info->byte_offset, reg_info->byte_size, lldb::endian::InlHostByteOrder(), lldb::endian::InlHostByteOrder());
+                    if (thread_suffix_supported)
+                        packet.Printf (";thread:%4.4" PRIx64 ";", m_thread.GetProtocolID());
+
+                    SetRegisterIsValid(reg_info, false);
+                    if (gdb_comm.SendPacketAndWaitForResponse(packet.GetString().c_str(),
+                                                              packet.GetString().size(),
+                                                              response,
+                                                              false) == GDBRemoteCommunication::PacketResult::Success)
+                    {
+                        if (response.IsOKResponse())
+                            ++num_restored;
                     }
-                    return num_restored > 0;
                 }
+                return num_restored > 0;
             }
         }
     }
@@ -693,7 +887,7 @@ GDBRemoteRegisterContext::WriteAllRegisterValues (const lldb::DataBufferSP &data
 
 
 uint32_t
-GDBRemoteRegisterContext::ConvertRegisterKindToRegisterNumber (uint32_t kind, uint32_t num)
+GDBRemoteRegisterContext::ConvertRegisterKindToRegisterNumber (lldb::RegisterKind kind, uint32_t num)
 {
     return m_reg_info.ConvertRegisterKindToRegisterNumber (kind, num);
 }
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h
index 38f29bb..b773814 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteRegisterContext.h
@@ -98,7 +98,7 @@ public:
     WriteAllRegisterValues (const lldb_private::RegisterCheckpoint &reg_checkpoint);
 
     virtual uint32_t
-    ConvertRegisterKindToRegisterNumber (uint32_t kind, uint32_t num);
+    ConvertRegisterKindToRegisterNumber (lldb::RegisterKind kind, uint32_t num);
 
 protected:
     friend class ThreadGDBRemote;
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
index 326efd4..46d0540 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
@@ -56,11 +56,14 @@
 #include "lldb/Target/Target.h"
 #include "lldb/Target/TargetList.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
+#include "lldb/Target/SystemRuntime.h"
 #include "lldb/Utility/PseudoTerminal.h"
 
 // Project includes
 #include "lldb/Host/Host.h"
+#include "Plugins/Process/Utility/FreeBSDSignals.h"
 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
+#include "Plugins/Process/Utility/LinuxSignals.h"
 #include "Plugins/Process/Utility/StopInfoMachException.h"
 #include "Utility/StringExtractorGDBRemote.h"
 #include "GDBRemoteRegisterContext.h"
@@ -165,8 +168,6 @@ namespace {
     
 } // anonymous namespace end
 
-static bool rand_initialized = false;
-
 // TODO Randomly assigning a port is unsafe.  We should get an unused
 // ephemeral port from the kernel and make sure we reserve it before passing
 // it to debugserver.
@@ -179,19 +180,22 @@ static bool rand_initialized = false;
 #define HIGH_PORT   (49151u)
 #endif
 
+#if defined(__APPLE__) && (defined(__arm__) || defined(__arm64__) || defined(__aarch64__))
+static bool rand_initialized = false;
+
 static inline uint16_t
 get_random_port ()
 {
     if (!rand_initialized)
     {
         time_t seed = time(NULL);
-        
+
         rand_initialized = true;
         srand(seed);
     }
     return (rand() % (HIGH_PORT - LOW_PORT)) + LOW_PORT;
 }
-
+#endif
 
 lldb_private::ConstString
 ProcessGDBRemote::GetPluginNameStatic()
@@ -242,6 +246,7 @@ ProcessGDBRemote::CanDebug (Target &target, bool plugin_specified_by_name)
             case ObjectFile::eTypeObjectFile:
             case ObjectFile::eTypeSharedLibrary:
             case ObjectFile::eTypeStubLibrary:
+            case ObjectFile::eTypeJIT:
                 return false;
             case ObjectFile::eTypeExecutable:
             case ObjectFile::eTypeDynamicLinker:
@@ -274,7 +279,8 @@ ProcessGDBRemote::ProcessGDBRemote(Target& target, Listener &listener) :
     m_continue_C_tids (),
     m_continue_s_tids (),
     m_continue_S_tids (),
-    m_max_memory_size (512),
+    m_max_memory_size (0),
+    m_remote_stub_max_memory_size (0),
     m_addr_to_mmap_size (),
     m_thread_create_bp_sp (),
     m_waiting_for_attach (false),
@@ -623,6 +629,7 @@ ProcessGDBRemote::WillAttachToProcessWithName (const char *process_name, bool wa
 Error
 ProcessGDBRemote::DoConnectRemote (Stream *strm, const char *remote_url)
 {
+    Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
     Error error (WillLaunchOrAttach ());
     
     if (error.Fail())
@@ -673,7 +680,11 @@ ProcessGDBRemote::DoConnectRemote (Stream *strm, const char *remote_url)
             error.SetErrorStringWithFormat ("Process %" PRIu64 " was reported after connecting to '%s', but no stop reply packet was received", pid, remote_url);
     }
 
-    if (error.Success() 
+    if (log)
+        log->Printf ("ProcessGDBRemote::%s pid %" PRIu64 ": normalizing target architecture initial triple: %s (GetTarget().GetArchitecture().IsValid() %s, m_gdb_comm.GetHostArchitecture().IsValid(): %s)", __FUNCTION__, GetID (), GetTarget ().GetArchitecture ().GetTriple ().getTriple ().c_str (), GetTarget ().GetArchitecture ().IsValid () ? "true" : "false", m_gdb_comm.GetHostArchitecture ().IsValid () ? "true" : "false");
+
+
+    if (error.Success()
         && !GetTarget().GetArchitecture().IsValid()
         && m_gdb_comm.GetHostArchitecture().IsValid())
     {
@@ -684,6 +695,42 @@ ProcessGDBRemote::DoConnectRemote (Stream *strm, const char *remote_url)
             GetTarget().SetArchitecture(m_gdb_comm.GetHostArchitecture());
     }
 
+    if (log)
+        log->Printf ("ProcessGDBRemote::%s pid %" PRIu64 ": normalized target architecture triple: %s", __FUNCTION__, GetID (), GetTarget ().GetArchitecture ().GetTriple ().getTriple ().c_str ());
+
+    // Set the Unix signals properly for the target.
+    // FIXME Add a gdb-remote packet to discover dynamically.
+    if (error.Success ())
+    {
+        const ArchSpec arch_spec = GetTarget ().GetArchitecture ();
+        if (arch_spec.IsValid ())
+        {
+            if (log)
+                log->Printf ("ProcessGDBRemote::%s pid %" PRIu64 ": determining unix signals type based on architecture %s, triple %s", __FUNCTION__, GetID (), arch_spec.GetArchitectureName () ? arch_spec.GetArchitectureName () : "<null>", arch_spec.GetTriple ().getTriple ().c_str ());
+
+            switch (arch_spec.GetTriple ().getOS ())
+            {
+            case llvm::Triple::Linux:
+                SetUnixSignals (UnixSignalsSP (new process_linux::LinuxSignals ()));
+                if (log)
+                    log->Printf ("ProcessGDBRemote::%s using Linux unix signals type for pid %" PRIu64, __FUNCTION__, GetID ());
+                break;
+            case llvm::Triple::OpenBSD:
+            case llvm::Triple::FreeBSD:
+            case llvm::Triple::NetBSD:
+                SetUnixSignals (UnixSignalsSP (new FreeBSDSignals ()));
+                if (log)
+                    log->Printf ("ProcessGDBRemote::%s using *BSD unix signals type for pid %" PRIu64, __FUNCTION__, GetID ());
+                break;
+            default:
+                SetUnixSignals (UnixSignalsSP (new UnixSignals ()));
+                if (log)
+                    log->Printf ("ProcessGDBRemote::%s using generic unix signals type for pid %" PRIu64, __FUNCTION__, GetID ());
+                break;
+            }
+        }
+    }
+
     return error;
 }
 
@@ -709,23 +756,23 @@ ProcessGDBRemote::DoLaunch (Module *exe_module, ProcessLaunchInfo &launch_info)
     const char *stderr_path = NULL;
     const char *working_dir = launch_info.GetWorkingDirectory();
 
-    const ProcessLaunchInfo::FileAction *file_action;
+    const FileAction *file_action;
     file_action = launch_info.GetFileActionForFD (STDIN_FILENO);
     if (file_action)
     {
-        if (file_action->GetAction () == ProcessLaunchInfo::FileAction::eFileActionOpen)
+        if (file_action->GetAction() == FileAction::eFileActionOpen)
             stdin_path = file_action->GetPath();
     }
     file_action = launch_info.GetFileActionForFD (STDOUT_FILENO);
     if (file_action)
     {
-        if (file_action->GetAction () == ProcessLaunchInfo::FileAction::eFileActionOpen)
+        if (file_action->GetAction() == FileAction::eFileActionOpen)
             stdout_path = file_action->GetPath();
     }
     file_action = launch_info.GetFileActionForFD (STDERR_FILENO);
     if (file_action)
     {
-        if (file_action->GetAction () == ProcessLaunchInfo::FileAction::eFileActionOpen)
+        if (file_action->GetAction() == FileAction::eFileActionOpen)
             stderr_path = file_action->GetPath();
     }
 
@@ -794,9 +841,14 @@ ProcessGDBRemote::DoLaunch (Module *exe_module, ProcessLaunchInfo &launch_info)
                 m_gdb_comm.SetSTDERR (stderr_path);
 
             m_gdb_comm.SetDisableASLR (launch_flags & eLaunchFlagDisableASLR);
+            m_gdb_comm.SetDetachOnError (launch_flags & eLaunchFlagDetachOnError);
 
             m_gdb_comm.SendLaunchArchPacket (m_target.GetArchitecture().GetArchitectureName());
             
+            const char * launch_event_data = launch_info.GetLaunchEventData();
+            if (launch_event_data != NULL && *launch_event_data != '\0')
+                m_gdb_comm.SendLaunchEventDataPacket (launch_event_data);
+            
             if (working_dir && working_dir[0])
             {
                 m_gdb_comm.SetWorkingDir (working_dir);
@@ -957,7 +1009,7 @@ ProcessGDBRemote::ConnectToDebugserver (const char *connect_url)
 }
 
 void
-ProcessGDBRemote::DidLaunchOrAttach ()
+ProcessGDBRemote::DidLaunchOrAttach (ArchSpec& process_arch)
 {
     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
     if (log)
@@ -968,16 +1020,17 @@ ProcessGDBRemote::DidLaunchOrAttach ()
 
         // See if the GDB server supports the qHostInfo information
 
-        ArchSpec gdb_remote_arch = m_gdb_comm.GetHostArchitecture();
 
         // See if the GDB server supports the qProcessInfo packet, if so
         // prefer that over the Host information as it will be more specific
         // to our process.
 
         if (m_gdb_comm.GetProcessArchitecture().IsValid())
-            gdb_remote_arch = m_gdb_comm.GetProcessArchitecture();
+            process_arch = m_gdb_comm.GetProcessArchitecture();
+        else
+            process_arch = m_gdb_comm.GetHostArchitecture();
 
-        if (gdb_remote_arch.IsValid())
+        if (process_arch.IsValid())
         {
             ArchSpec &target_arch = GetTarget().GetArchitecture();
 
@@ -990,15 +1043,15 @@ ProcessGDBRemote::DidLaunchOrAttach ()
                 // it has, so we really need to take the remote host architecture as our
                 // defacto architecture in this case.
 
-                if (gdb_remote_arch.GetMachine() == llvm::Triple::arm &&
-                    gdb_remote_arch.GetTriple().getVendor() == llvm::Triple::Apple)
+                if (process_arch.GetMachine() == llvm::Triple::arm &&
+                    process_arch.GetTriple().getVendor() == llvm::Triple::Apple)
                 {
-                    target_arch = gdb_remote_arch;
+                    GetTarget().SetArchitecture (process_arch);
                 }
                 else
                 {
                     // Fill in what is missing in the triple
-                    const llvm::Triple &remote_triple = gdb_remote_arch.GetTriple();
+                    const llvm::Triple &remote_triple = process_arch.GetTriple();
                     llvm::Triple &target_triple = target_arch.GetTriple();
                     if (target_triple.getVendorName().size() == 0)
                     {
@@ -1018,7 +1071,7 @@ ProcessGDBRemote::DidLaunchOrAttach ()
             {
                 // The target doesn't have a valid architecture yet, set it from
                 // the architecture we got from the remote GDB server
-                target_arch = gdb_remote_arch;
+                GetTarget().SetArchitecture (process_arch);
             }
         }
     }
@@ -1027,7 +1080,8 @@ ProcessGDBRemote::DidLaunchOrAttach ()
 void
 ProcessGDBRemote::DidLaunch ()
 {
-    DidLaunchOrAttach ();
+    ArchSpec process_arch;
+    DidLaunchOrAttach (process_arch);
 }
 
 Error
@@ -1062,6 +1116,8 @@ ProcessGDBRemote::DoAttachToProcessWithID (lldb::pid_t attach_pid, const Process
     
         if (error.Success())
         {
+            m_gdb_comm.SetDetachOnError(attach_info.GetDetachOnError());
+            
             char packet[64];
             const int packet_len = ::snprintf (packet, sizeof(packet), "vAttach;%" PRIx64, attach_pid);
             SetID (attach_pid);            
@@ -1099,6 +1155,8 @@ ProcessGDBRemote::DoAttachToProcessWithName (const char *process_name, const Pro
         {
             StreamString packet;
             
+            m_gdb_comm.SetDetachOnError(attach_info.GetDetachOnError());
+            
             if (attach_info.GetWaitForLaunch())
             {
                 if (!m_gdb_comm.GetVAttachOrWaitSupported())
@@ -1134,9 +1192,11 @@ ProcessGDBRemote::SetExitStatus (int exit_status, const char *cstr)
 }
 
 void
-ProcessGDBRemote::DidAttach ()
+ProcessGDBRemote::DidAttach (ArchSpec &process_arch)
 {
-    DidLaunchOrAttach ();
+    // If you can figure out what the architecture is, fill it in here.
+    process_arch.Clear();
+    DidLaunchOrAttach (process_arch);
 }
 
 
@@ -1451,8 +1511,7 @@ ProcessGDBRemote::UpdateThreadList (ThreadList &old_thread_list, ThreadList &new
                 if (log && log->GetMask().Test(GDBR_LOG_VERBOSE))
                     log->Printf(
                             "ProcessGDBRemote::%s Making new thread: %p for thread ID: 0x%" PRIx64 ".\n",
-                            __FUNCTION__,
-                            thread_sp.get(),
+                            __FUNCTION__, static_cast<void*>(thread_sp.get()),
                             thread_sp->GetID());
             }
             else
@@ -1460,8 +1519,7 @@ ProcessGDBRemote::UpdateThreadList (ThreadList &old_thread_list, ThreadList &new
                 if (log && log->GetMask().Test(GDBR_LOG_VERBOSE))
                     log->Printf(
                            "ProcessGDBRemote::%s Found old thread: %p for thread ID: 0x%" PRIx64 ".\n",
-                           __FUNCTION__,
-                           thread_sp.get(),
+                           __FUNCTION__, static_cast<void*>(thread_sp.get()),
                            thread_sp->GetID());
             }
             new_thread_list.AddThread(thread_sp);
@@ -1556,9 +1614,9 @@ ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet)
                         if (log && log->GetMask().Test(GDBR_LOG_VERBOSE))
                             log->Printf ("ProcessGDBRemote::%s Adding new thread: %p for thread ID: 0x%" PRIx64 ".\n",
                                          __FUNCTION__,
-                                         thread_sp.get(),
+                                         static_cast<void*>(thread_sp.get()),
                                          thread_sp->GetID());
-                                         
+
                         m_thread_list_real.AddThread(thread_sp);
                     }
                     gdb_thread = static_cast<ThreadGDBRemote *> (thread_sp.get());
@@ -1581,7 +1639,6 @@ ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet)
                         if (tid != LLDB_INVALID_THREAD_ID)
                             m_thread_ids.push_back (tid);
                         value.erase(0, comma_pos + 1);
-                            
                     }
                     tid = Args::StringToUInt64 (value.c_str(), LLDB_INVALID_THREAD_ID, 16);
                     if (tid != LLDB_INVALID_THREAD_ID)
@@ -1708,7 +1765,6 @@ ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet)
                                     thread_sp->SetStopInfo (invalid_stop_info_sp);
                                 }
                             }
-                            
                         }
                         else if (reason.compare("trap") == 0)
                         {
@@ -1733,7 +1789,7 @@ ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet)
                             handled = true;
                         }
                     }
-                    
+
                     if (!handled && signo && did_exec == false)
                     {
                         if (signo == SIGTRAP)
@@ -1743,7 +1799,7 @@ ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet)
                             handled = true;
                             addr_t pc = thread_sp->GetRegisterContext()->GetPC() + m_breakpoint_pc_offset;
                             lldb::BreakpointSiteSP bp_site_sp = thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(pc);
-                            
+
                             if (bp_site_sp)
                             {
                                 // If the breakpoint is for this thread, then we'll report the hit, but if it is for another thread,
@@ -1775,7 +1831,7 @@ ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet)
                         if (!handled)
                             thread_sp->SetStopInfo (StopInfo::CreateStopReasonWithSignal (*thread_sp, signo));
                     }
-                    
+
                     if (!description.empty())
                     {
                         lldb::StopInfoSP stop_info_sp (thread_sp->GetStopInfo ());
@@ -1795,6 +1851,7 @@ ProcessGDBRemote::SetThreadStopInfo (StringExtractor& stop_packet)
         break;
 
     case 'W':
+    case 'X':
         // process exited
         return eStateExited;
 
@@ -1863,10 +1920,6 @@ ProcessGDBRemote::DoDetach(bool keep_stopped)
     if (log)
         log->Printf ("ProcessGDBRemote::DoDetach(keep_stopped: %i)", keep_stopped);
  
-    DisableAllBreakpointSites ();
-
-    m_thread_list.DiscardThreadPlans();
-
     error = m_gdb_comm.Detach (keep_stopped);
     if (log)
     {
@@ -1928,7 +1981,7 @@ ProcessGDBRemote::DoDestroy ()
             if (m_destroy_tried_resuming)
             {
                 if (log)
-                    log->PutCString ("ProcessGDBRemote::DoDestroy()Tried resuming to destroy once already, not doing it again.");
+                    log->PutCString ("ProcessGDBRemote::DoDestroy() - Tried resuming to destroy once already, not doing it again.");
             }
             else
             {            
@@ -2065,7 +2118,7 @@ ProcessGDBRemote::DoDestroy ()
         else
         {
             if (log)
-                log->Printf ("ProcessGDBRemote::DoDestroy - failed to send k packet");
+                log->Printf ("ProcessGDBRemote::DoDestroy - killed or interrupted while attaching");
             exit_string.assign ("killed or interrupted while attaching.");
         }
     }
@@ -2125,6 +2178,7 @@ ProcessGDBRemote::GetImageInfoAddress()
 size_t
 ProcessGDBRemote::DoReadMemory (addr_t addr, void *buf, size_t size, Error &error)
 {
+    GetMaxMemorySize ();
     if (size > m_max_memory_size)
     {
         // Keep memory read sizes down to a sane limit. This function will be
@@ -2134,7 +2188,16 @@ ProcessGDBRemote::DoReadMemory (addr_t addr, void *buf, size_t size, Error &erro
     }
 
     char packet[64];
-    const int packet_len = ::snprintf (packet, sizeof(packet), "m%" PRIx64 ",%" PRIx64, (uint64_t)addr, (uint64_t)size);
+    int packet_len;
+    bool binary_memory_read = m_gdb_comm.GetxPacketSupported();
+    if (binary_memory_read)
+    {
+        packet_len = ::snprintf (packet, sizeof(packet), "x0x%" PRIx64 ",0x%" PRIx64, (uint64_t)addr, (uint64_t)size);
+    }
+    else
+    {
+        packet_len = ::snprintf (packet, sizeof(packet), "m%" PRIx64 ",%" PRIx64, (uint64_t)addr, (uint64_t)size);
+    }
     assert (packet_len + 1 < (int)sizeof(packet));
     StringExtractorGDBRemote response;
     if (m_gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, true) == GDBRemoteCommunication::PacketResult::Success)
@@ -2142,7 +2205,25 @@ ProcessGDBRemote::DoReadMemory (addr_t addr, void *buf, size_t size, Error &erro
         if (response.IsNormalResponse())
         {
             error.Clear();
-            return response.GetHexBytes(buf, size, '\xdd');
+            if (binary_memory_read)
+            {
+                // The lower level GDBRemoteCommunication packet receive layer has already de-quoted any
+                // 0x7d character escaping that was present in the packet
+
+                size_t data_received_size = response.GetBytesLeft();
+                if (data_received_size > size)
+                {
+                    // Don't write past the end of BUF if the remote debug server gave us too
+                    // much data for some reason.
+                    data_received_size = size;
+                }
+                memcpy (buf, response.GetStringRef().data(), data_received_size);
+                return data_received_size;
+            }
+            else
+            {
+                return response.GetHexBytes(buf, size, '\xdd');
+            }
         }
         else if (response.IsErrorResponse())
             error.SetErrorStringWithFormat("memory read failed for 0x%" PRIx64, addr);
@@ -2161,6 +2242,7 @@ ProcessGDBRemote::DoReadMemory (addr_t addr, void *buf, size_t size, Error &erro
 size_t
 ProcessGDBRemote::DoWriteMemory (addr_t addr, const void *buf, size_t size, Error &error)
 {
+    GetMaxMemorySize ();
     if (size > m_max_memory_size)
     {
         // Keep memory read sizes down to a sane limit. This function will be
@@ -2197,6 +2279,7 @@ ProcessGDBRemote::DoWriteMemory (addr_t addr, const void *buf, size_t size, Erro
 lldb::addr_t
 ProcessGDBRemote::DoAllocateMemory (size_t size, uint32_t permissions, Error &error)
 {
+    lldb_private::Log *log (lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_EXPRESSIONS));
     addr_t allocated_addr = LLDB_INVALID_ADDRESS;
     
     LazyBool supported = m_gdb_comm.SupportsAllocDeallocMemory();
@@ -2222,7 +2305,11 @@ ProcessGDBRemote::DoAllocateMemory (size_t size, uint32_t permissions, Error &er
                                  eMmapFlagsAnon | eMmapFlagsPrivate, -1, 0))
                 m_addr_to_mmap_size[allocated_addr] = size;
             else
+            {
                 allocated_addr = LLDB_INVALID_ADDRESS;
+                if (log)
+                    log->Printf ("ProcessGDBRemote::%s no direct stub support for memory allocation, and InferiorCallMmap also failed - is stub missing register context save/restore capability?", __FUNCTION__);
+            }
             break;
     }
     
@@ -2394,7 +2481,7 @@ ProcessGDBRemote::EnableBreakpointSite (BreakpointSite *bp_site)
             return error;
         }
 
-        // We will reach here when the stub gives an unsported response to a hardware breakpoint
+        // We will reach here when the stub gives an unsupported response to a hardware breakpoint
         if (log)
             log->Printf("Hardware breakpoints are unsupported");
 
@@ -2441,8 +2528,16 @@ ProcessGDBRemote::DisableBreakpointSite (BreakpointSite *bp_site)
             break;
 
         case BreakpointSite::eExternal:
-            if (m_gdb_comm.SendGDBStoppointTypePacket(eBreakpointSoftware, false, addr, bp_op_size))
+            {
+                GDBStoppointType stoppoint_type;
+                if (bp_site->IsHardware())
+                    stoppoint_type = eBreakpointHardware;
+                else
+                    stoppoint_type = eBreakpointSoftware;
+                
+                if (m_gdb_comm.SendGDBStoppointTypePacket(stoppoint_type, false, addr, bp_op_size))
                 error.SetErrorToGenericError();
+            }
             break;
         }
         if (error.Success())
@@ -2603,9 +2698,9 @@ ProcessGDBRemote::LaunchAndConnectToDebugserver (const ProcessInfo &process_info
         debugserver_launch_info.SetMonitorProcessCallback (MonitorDebugserverProcess, this, false);
         debugserver_launch_info.SetUserID(process_info.GetUserID());
 
-#if defined (__APPLE__) && defined (__arm__)
+#if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__) || defined (__aarch64__))
         // On iOS, still do a local connection using a random port
-        const char *hostname = "localhost";
+        const char *hostname = "127.0.0.1";
         uint16_t port = get_random_port ();
 #else
         // Set hostname being NULL to do the reverse connect where debugserver
@@ -2919,13 +3014,33 @@ ProcessGDBRemote::AsyncThread (void *arg)
                                         break;
 
                                     case eStateExited:
+                                    {
                                         process->SetLastStopPacket (response);
                                         process->ClearThreadIDList();
                                         response.SetFilePos(1);
-                                        process->SetExitStatus(response.GetHexU8(), NULL);
+                                        
+                                        int exit_status = response.GetHexU8();
+                                        const char *desc_cstr = NULL;
+                                        StringExtractor extractor;
+                                        std::string desc_string;
+                                        if (response.GetBytesLeft() > 0 && response.GetChar('-') == ';')
+                                        {
+                                            std::string desc_token;
+                                            while (response.GetNameColonValue (desc_token, desc_string))
+                                            {
+                                                if (desc_token == "description")
+                                                {
+                                                    extractor.GetStringRef().swap(desc_string);
+                                                    extractor.SetFilePos(0);
+                                                    extractor.GetHexByteString (desc_string);
+                                                    desc_cstr = desc_string.c_str();
+                                                }
+                                            }
+                                        }
+                                        process->SetExitStatus(exit_status, desc_cstr);
                                         done = true;
                                         break;
-
+                                    }
                                     case eStateInvalid:
                                         process->SetExitStatus(-1, "lost connection");
                                         break;
@@ -3061,6 +3176,146 @@ ProcessGDBRemote::GetDynamicLoader ()
     return m_dyld_ap.get();
 }
 
+Error
+ProcessGDBRemote::SendEventData(const char *data)
+{
+    int return_value;
+    bool was_supported;
+    
+    Error error;
+    
+    return_value = m_gdb_comm.SendLaunchEventDataPacket (data, &was_supported);
+    if (return_value != 0)
+    {
+        if (!was_supported)
+            error.SetErrorString("Sending events is not supported for this process.");
+        else
+            error.SetErrorStringWithFormat("Error sending event data: %d.", return_value);
+    }
+    return error;
+}
+
+const DataBufferSP
+ProcessGDBRemote::GetAuxvData()
+{
+    DataBufferSP buf;
+    if (m_gdb_comm.GetQXferAuxvReadSupported())
+    {
+        std::string response_string;
+        if (m_gdb_comm.SendPacketsAndConcatenateResponses("qXfer:auxv:read::", response_string) == GDBRemoteCommunication::PacketResult::Success)
+            buf.reset(new DataBufferHeap(response_string.c_str(), response_string.length()));
+    }
+    return buf;
+}
+
+StructuredData::ObjectSP
+ProcessGDBRemote::GetExtendedInfoForThread (lldb::tid_t tid)
+{
+    StructuredData::ObjectSP object_sp;
+
+    if (m_gdb_comm.GetThreadExtendedInfoSupported())
+    {
+        StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());
+        SystemRuntime *runtime = GetSystemRuntime();
+        if (runtime)
+        {
+            runtime->AddThreadExtendedInfoPacketHints (args_dict);
+        }
+        args_dict->GetAsDictionary()->AddIntegerItem ("thread", tid);
+
+        StreamString packet;
+        packet << "jThreadExtendedInfo:";
+        args_dict->Dump (packet);
+
+        // FIXME the final character of a JSON dictionary, '}', is the escape
+        // character in gdb-remote binary mode.  lldb currently doesn't escape
+        // these characters in its packet output -- so we add the quoted version
+        // of the } character here manually in case we talk to a debugserver which
+        // un-escapes the characters at packet read time.
+        packet << (char) (0x7d ^ 0x20);
+
+        StringExtractorGDBRemote response;
+        if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetData(), packet.GetSize(), response, false) == GDBRemoteCommunication::PacketResult::Success)
+        {
+            StringExtractorGDBRemote::ResponseType response_type = response.GetResponseType();
+            if (response_type == StringExtractorGDBRemote::eResponse)
+            {
+                if (!response.Empty())
+                {
+                    // The packet has already had the 0x7d xor quoting stripped out at the
+                    // GDBRemoteCommunication packet receive level.
+                    object_sp = StructuredData::ParseJSON (response.GetStringRef());
+                }
+            }
+        }
+    }
+    return object_sp;
+}
+
+// Establish the largest memory read/write payloads we should use.
+// If the remote stub has a max packet size, stay under that size.
+// 
+// If the remote stub's max packet size is crazy large, use a 
+// reasonable largeish default.
+//
+// If the remote stub doesn't advertise a max packet size, use a
+// conservative default.
+
+void
+ProcessGDBRemote::GetMaxMemorySize()
+{
+    const uint64_t reasonable_largeish_default = 128 * 1024;
+    const uint64_t conservative_default = 512;
+
+    if (m_max_memory_size == 0)
+    {
+        uint64_t stub_max_size = m_gdb_comm.GetRemoteMaxPacketSize();
+        if (stub_max_size != UINT64_MAX && stub_max_size != 0)
+        {
+            // Save the stub's claimed maximum packet size
+            m_remote_stub_max_memory_size = stub_max_size;
+
+            // Even if the stub says it can support ginormous packets,
+            // don't exceed our reasonable largeish default packet size.
+            if (stub_max_size > reasonable_largeish_default)
+            {
+                stub_max_size = reasonable_largeish_default;
+            }
+
+            m_max_memory_size = stub_max_size;
+        }
+        else
+        {
+            m_max_memory_size = conservative_default;
+        }
+    }
+}
+
+void
+ProcessGDBRemote::SetUserSpecifiedMaxMemoryTransferSize (uint64_t user_specified_max)
+{
+    if (user_specified_max != 0)
+    {
+        GetMaxMemorySize ();
+
+        if (m_remote_stub_max_memory_size != 0)
+        {
+            if (m_remote_stub_max_memory_size < user_specified_max)
+            {
+                m_max_memory_size = m_remote_stub_max_memory_size;   // user specified a packet size too big, go as big
+                                                                     // as the remote stub says we can go.
+            }
+            else
+            {
+                m_max_memory_size = user_specified_max;             // user's packet size is good
+            }
+        }
+        else
+        {
+            m_max_memory_size = user_specified_max;                 // user's packet size is probably fine
+        }
+    }
+}
 
 class CommandObjectProcessGDBRemotePacketHistory : public CommandObjectParsed
 {
@@ -3102,6 +3357,53 @@ public:
     }
 };
 
+class CommandObjectProcessGDBRemotePacketXferSize : public CommandObjectParsed
+{
+private:
+    
+public:
+    CommandObjectProcessGDBRemotePacketXferSize(CommandInterpreter &interpreter) :
+    CommandObjectParsed (interpreter,
+                         "process plugin packet xfer-size",
+                         "Maximum size that lldb will try to read/write one one chunk.",
+                         NULL)
+    {
+    }
+    
+    ~CommandObjectProcessGDBRemotePacketXferSize ()
+    {
+    }
+    
+    bool
+    DoExecute (Args& command, CommandReturnObject &result)
+    {
+        const size_t argc = command.GetArgumentCount();
+        if (argc == 0)
+        {
+            result.AppendErrorWithFormat ("'%s' takes an argument to specify the max amount to be transferred when reading/writing", m_cmd_name.c_str());
+            result.SetStatus (eReturnStatusFailed);
+            return false;
+        }
+
+        ProcessGDBRemote *process = (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr();
+        if (process)
+        {
+            const char *packet_size = command.GetArgumentAtIndex(0);
+            errno = 0;
+            uint64_t user_specified_max = strtoul (packet_size, NULL, 10);
+            if (errno == 0 && user_specified_max != 0)
+            {
+                process->SetUserSpecifiedMaxMemoryTransferSize (user_specified_max);
+                result.SetStatus (eReturnStatusSuccessFinishResult);
+                return true;
+            }
+        }
+        result.SetStatus (eReturnStatusFailed);
+        return false;
+    }
+};
+
+
 class CommandObjectProcessGDBRemotePacketSend : public CommandObjectParsed
 {
 private:
@@ -3227,6 +3529,7 @@ public:
         LoadSubCommand ("history", CommandObjectSP (new CommandObjectProcessGDBRemotePacketHistory (interpreter)));
         LoadSubCommand ("send", CommandObjectSP (new CommandObjectProcessGDBRemotePacketSend (interpreter)));
         LoadSubCommand ("monitor", CommandObjectSP (new CommandObjectProcessGDBRemotePacketMonitor (interpreter)));
+        LoadSubCommand ("xfer-size", CommandObjectSP (new CommandObjectProcessGDBRemotePacketXferSize (interpreter)));
     }
     
     ~CommandObjectProcessGDBRemotePacket ()
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h
index 9331775..942b31c 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h
@@ -23,7 +23,9 @@
 #include "lldb/Core/Error.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/StringList.h"
+#include "lldb/Core/StructuredData.h"
 #include "lldb/Core/ThreadSafeValue.h"
+#include "lldb/lldb-private-forward.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 
@@ -113,7 +115,7 @@ public:
                                const lldb_private::ProcessAttachInfo &attach_info);
 
     virtual void
-    DidAttach ();
+    DidAttach (lldb_private::ArchSpec &process_arch);
 
     //------------------------------------------------------------------
     // PluginInterface protocol
@@ -221,12 +223,17 @@ public:
         return m_gdb_comm;
     }
     
+    virtual lldb_private::Error
+    SendEventData(const char *data);
+
     //----------------------------------------------------------------------
     // Override SetExitStatus so we can disconnect from the remote GDB server
     //----------------------------------------------------------------------
     virtual bool
     SetExitStatus (int exit_status, const char *cstr);
 
+    void
+    SetUserSpecifiedMaxMemoryTransferSize (uint64_t user_specified_max);
 
 protected:
     friend class ThreadGDBRemote;
@@ -299,6 +306,15 @@ protected:
     bool
     ParseRegisters(lldb_private::ScriptInterpreterObject *registers_array);
 
+    const lldb::DataBufferSP
+    GetAuxvData() override;
+
+    lldb_private::StructuredData::ObjectSP
+    GetExtendedInfoForThread (lldb::tid_t tid);
+
+    void
+    GetMaxMemorySize();
+
     //------------------------------------------------------------------
     /// Broadcaster event bits definitions.
     //------------------------------------------------------------------
@@ -334,14 +350,15 @@ protected:
     tid_sig_collection m_continue_C_tids; // 'C' for continue with signal
     tid_collection m_continue_s_tids;                  // 's' for step
     tid_sig_collection m_continue_S_tids; // 'S' for step with signal
-    size_t m_max_memory_size;       // The maximum number of bytes to read/write when reading and writing memory
+    uint64_t m_max_memory_size;       // The maximum number of bytes to read/write when reading and writing memory
+    uint64_t m_remote_stub_max_memory_size;    // The maximum memory size the remote gdb stub can handle
     MMapMap m_addr_to_mmap_size;
     lldb::BreakpointSP m_thread_create_bp_sp;
     bool m_waiting_for_attach;
     bool m_destroy_tried_resuming;
     lldb::CommandObjectSP m_command_sp;
     int64_t m_breakpoint_pc_offset;
-    
+
     bool
     StartAsyncThread ();
 
@@ -368,7 +385,7 @@ protected:
     UpdateThreadIDList ();
 
     void
-    DidLaunchOrAttach ();
+    DidLaunchOrAttach (lldb_private::ArchSpec& process_arch);
 
     lldb_private::Error
     ConnectToDebugserver (const char *host_port);
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
index fb524de..5c70cb5 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.cpp
@@ -107,6 +107,58 @@ ThreadGDBRemote::GetQueueID ()
     return LLDB_INVALID_QUEUE_ID;
 }
 
+QueueSP
+ThreadGDBRemote::GetQueue ()
+{
+    queue_id_t queue_id = GetQueueID();
+    QueueSP queue;
+    if (queue_id != LLDB_INVALID_QUEUE_ID)
+    {
+        ProcessSP process_sp (GetProcess());
+        if (process_sp)
+        {
+            queue = process_sp->GetQueueList().FindQueueByID (queue_id);
+        }
+    }
+    return queue;
+}
+
+addr_t
+ThreadGDBRemote::GetQueueLibdispatchQueueAddress ()
+{
+    addr_t dispatch_queue_t_addr = LLDB_INVALID_ADDRESS;
+    if (m_thread_dispatch_qaddr != 0 || m_thread_dispatch_qaddr != LLDB_INVALID_ADDRESS)
+    {
+        ProcessSP process_sp (GetProcess());
+        if (process_sp)
+        {
+            SystemRuntime *runtime = process_sp->GetSystemRuntime ();
+            if (runtime)
+            {
+                dispatch_queue_t_addr = runtime->GetLibdispatchQueueAddressFromThreadQAddress (m_thread_dispatch_qaddr);
+            }
+        }
+    }
+    return dispatch_queue_t_addr;
+}
+
+StructuredData::ObjectSP
+ThreadGDBRemote::FetchThreadExtendedInfo ()
+{
+    StructuredData::ObjectSP object_sp;
+    const lldb::user_id_t tid = GetProtocolID();
+    Log *log(lldb_private::GetLogIfAnyCategoriesSet (GDBR_LOG_THREAD));
+    if (log)
+        log->Printf ("Fetching extended information for thread %4.4" PRIx64, tid);
+    ProcessSP process_sp (GetProcess());
+    if (process_sp)
+    {
+        ProcessGDBRemote *gdb_process = static_cast<ProcessGDBRemote *>(process_sp.get());
+        object_sp = gdb_process->GetExtendedInfoForThread (tid);
+    }
+    return object_sp;
+}
+
 void
 ThreadGDBRemote::WillResume (StateType resume_state)
 {
diff --git a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h
index dd4cc03..a204a91 100644
--- a/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h
+++ b/contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/ThreadGDBRemote.h
@@ -12,6 +12,7 @@
 
 #include <string>
 
+#include "lldb/Core/StructuredData.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Thread.h"
 
@@ -41,6 +42,12 @@ public:
     virtual lldb::queue_id_t
     GetQueueID ();
 
+    virtual lldb::QueueSP
+    GetQueue ();
+
+    lldb::addr_t
+    GetQueueLibdispatchQueueAddress ();
+
     virtual lldb::RegisterContextSP
     GetRegisterContext ();
 
@@ -80,6 +87,9 @@ public:
         m_thread_dispatch_qaddr = thread_dispatch_qaddr;
     }
 
+    lldb_private::StructuredData::ObjectSP
+    FetchThreadExtendedInfo ();
+
 protected:
     
     friend class ProcessGDBRemote;