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

   1 //===-- GDBRemoteCommunicationServerLLGS.cpp --------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include <errno.h>
  11
  12 #include "lldb/Host/Config.h"
  13
  14 #include "GDBRemoteCommunicationServerLLGS.h"
  15 #include "lldb/Core/StreamGDBRemote.h"
  16
  17 // C Includes
  18 // C++ Includes
  19 #include <cstring>
  20 #include <chrono>
  21 #include <thread>
  22
  23 // Other libraries and framework includes
  24 #include "llvm/ADT/Triple.h"
  25 #include "lldb/Interpreter/Args.h"
  26 #include "lldb/Core/DataBuffer.h"
  27 #include "lldb/Core/Log.h"
  28 #include "lldb/Core/RegisterValue.h"
  29 #include "lldb/Core/State.h"
  30 #include "lldb/Core/StreamString.h"
  31 #include "lldb/Host/ConnectionFileDescriptor.h"
  32 #include "lldb/Host/Debug.h"
  33 #include "lldb/Host/Endian.h"
  34 #include "lldb/Host/File.h"
  35 #include "lldb/Host/FileSystem.h"
  36 #include "lldb/Host/Host.h"
  37 #include "lldb/Host/HostInfo.h"
  38 #include "lldb/Host/StringConvert.h"
  39 #include "lldb/Host/TimeValue.h"
  40 #include "lldb/Target/FileAction.h"
  41 #include "lldb/Target/MemoryRegionInfo.h"
  42 #include "lldb/Host/common/NativeRegisterContext.h"
  43 #include "lldb/Host/common/NativeProcessProtocol.h"
  44 #include "lldb/Host/common/NativeThreadProtocol.h"
  45 #include "lldb/Utility/JSON.h"
  46 #include "lldb/Utility/LLDBAssert.h"
  47
  48 // Project includes
  49 #include "Utility/StringExtractorGDBRemote.h"
  50 #include "Utility/UriParser.h"
  51 #include "ProcessGDBRemote.h"
  52 #include "ProcessGDBRemoteLog.h"
  53
  54 using namespace lldb;
  55 using namespace lldb_private;
  56 using namespace lldb_private::process_gdb_remote;
  57 using namespace llvm;
  58
  59 //----------------------------------------------------------------------
  60 // GDBRemote Errors
  61 //----------------------------------------------------------------------
  62
  63 namespace
  64 {
  65     enum GDBRemoteServerError
  66     {
  67         // Set to the first unused error number in literal form below
  68         eErrorFirst = 29,
  69         eErrorNoProcess = eErrorFirst,
  70         eErrorResume,
  71         eErrorExitStatus
  72     };
  73 }
  74
  75 //----------------------------------------------------------------------
  76 // GDBRemoteCommunicationServerLLGS constructor
  77 //----------------------------------------------------------------------
  78 GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS(MainLoop &mainloop)
  79     : GDBRemoteCommunicationServerCommon("gdb-remote.server", "gdb-remote.server.rx_packet"),
  80       m_mainloop(mainloop),
  81       m_current_tid(LLDB_INVALID_THREAD_ID),
  82       m_continue_tid(LLDB_INVALID_THREAD_ID),
  83       m_debugged_process_mutex(),
  84       m_debugged_process_sp(),
  85       m_stdio_communication("process.stdio"),
  86       m_inferior_prev_state(StateType::eStateInvalid),
  87       m_active_auxv_buffer_sp(),
  88       m_saved_registers_mutex(),
  89       m_saved_registers_map(),
  90       m_next_saved_registers_id(1),
  91       m_handshake_completed(false)
  92 {
  93     RegisterPacketHandlers();
  94 }
  95
  96 void
  97 GDBRemoteCommunicationServerLLGS::RegisterPacketHandlers()
  98 {
  99     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_C,
 100                                   &GDBRemoteCommunicationServerLLGS::Handle_C);
 101     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_c,
 102                                   &GDBRemoteCommunicationServerLLGS::Handle_c);
 103     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_D,
 104                                   &GDBRemoteCommunicationServerLLGS::Handle_D);
 105     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_H,
 106                                   &GDBRemoteCommunicationServerLLGS::Handle_H);
 107     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_I,
 108                                   &GDBRemoteCommunicationServerLLGS::Handle_I);
 109     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_interrupt,
 110                                   &GDBRemoteCommunicationServerLLGS::Handle_interrupt);
 111     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_m,
 112                                   &GDBRemoteCommunicationServerLLGS::Handle_memory_read);
 113     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_M,
 114                                   &GDBRemoteCommunicationServerLLGS::Handle_M);
 115     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_p,
 116                                   &GDBRemoteCommunicationServerLLGS::Handle_p);
 117     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_P,
 118                                   &GDBRemoteCommunicationServerLLGS::Handle_P);
 119     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qC,
 120                                   &GDBRemoteCommunicationServerLLGS::Handle_qC);
 121     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qfThreadInfo,
 122                                   &GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo);
 123     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qFileLoadAddress,
 124                                   &GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress);
 125     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qGetWorkingDir,
 126                                   &GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir);
 127     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfo,
 128                                   &GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo);
 129     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfoSupported,
 130                                   &GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported);
 131     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qProcessInfo,
 132                                   &GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo);
 133     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qRegisterInfo,
 134                                   &GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo);
 135     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QRestoreRegisterState,
 136                                   &GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState);
 137     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QSaveRegisterState,
 138                                   &GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState);
 139     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QSetDisableASLR,
 140                                   &GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR);
 141     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_QSetWorkingDir,
 142                                   &GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir);
 143     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qsThreadInfo,
 144                                   &GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo);
 145     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qThreadStopInfo,
 146                                   &GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo);
 147     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_jThreadsInfo,
 148                                   &GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo);
 149     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qWatchpointSupportInfo,
 150                                   &GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo);
 151     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qXfer_auxv_read,
 152                                   &GDBRemoteCommunicationServerLLGS::Handle_qXfer_auxv_read);
 153     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_s,
 154                                   &GDBRemoteCommunicationServerLLGS::Handle_s);
 155     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_stop_reason,
 156                                   &GDBRemoteCommunicationServerLLGS::Handle_stop_reason); // ?
 157     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_vAttach,
 158                                   &GDBRemoteCommunicationServerLLGS::Handle_vAttach);
 159     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_vCont,
 160                                   &GDBRemoteCommunicationServerLLGS::Handle_vCont);
 161     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_vCont_actions,
 162                                   &GDBRemoteCommunicationServerLLGS::Handle_vCont_actions);
 163     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_x,
 164                                   &GDBRemoteCommunicationServerLLGS::Handle_memory_read);
 165     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_Z,
 166                                   &GDBRemoteCommunicationServerLLGS::Handle_Z);
 167     RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_z,
 168                                   &GDBRemoteCommunicationServerLLGS::Handle_z);
 169
 170     RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_k,
 171                           [this](StringExtractorGDBRemote packet,
 172                                  Error &error,
 173                                  bool &interrupt,
 174                                  bool &quit)
 175                           {
 176                               quit = true;
 177                               return this->Handle_k (packet);
 178                           });
 179 }
 180
 181 Error
 182 GDBRemoteCommunicationServerLLGS::SetLaunchArguments (const char *const args[], int argc)
 183 {
 184     if ((argc < 1) || !args || !args[0] || !args[0][0])
 185         return Error ("%s: no process command line specified to launch", __FUNCTION__);
 186
 187     m_process_launch_info.SetArguments (const_cast<const char**> (args), true);
 188     return Error ();
 189 }
 190
 191 Error
 192 GDBRemoteCommunicationServerLLGS::SetLaunchFlags (unsigned int launch_flags)
 193 {
 194     m_process_launch_info.GetFlags ().Set (launch_flags);
 195     return Error ();
 196 }
 197
 198 Error
 199 GDBRemoteCommunicationServerLLGS::LaunchProcess ()
 200 {
 201     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 202
 203     if (!m_process_launch_info.GetArguments ().GetArgumentCount ())
 204         return Error ("%s: no process command line specified to launch", __FUNCTION__);
 205
 206     Error error;
 207     {
 208         std::lock_guard<std::recursive_mutex> guard(m_debugged_process_mutex);
 209         assert (!m_debugged_process_sp && "lldb-gdbserver creating debugged process but one already exists");
 210         error = NativeProcessProtocol::Launch(
 211             m_process_launch_info,
 212             *this,
 213             m_mainloop,
 214             m_debugged_process_sp);
 215     }
 216
 217     if (!error.Success ())
 218     {
 219         fprintf (stderr, "%s: failed to launch executable %s", __FUNCTION__, m_process_launch_info.GetArguments ().GetArgumentAtIndex (0));
 220         return error;
 221     }
 222
 223     // Handle mirroring of inferior stdout/stderr over the gdb-remote protocol
 224     // as needed.
 225     // llgs local-process debugging may specify PTY paths, which will make these
 226     // file actions non-null
 227     // process launch -i/e/o will also make these file actions non-null
 228     // nullptr means that the traffic is expected to flow over gdb-remote protocol
 229     if (
 230         m_process_launch_info.GetFileActionForFD(STDIN_FILENO) == nullptr  ||
 231         m_process_launch_info.GetFileActionForFD(STDOUT_FILENO) == nullptr  ||
 232         m_process_launch_info.GetFileActionForFD(STDERR_FILENO) == nullptr
 233         )
 234     {
 235         // nullptr means it's not redirected to file or pty (in case of LLGS local)
 236         // at least one of stdio will be transferred pty<->gdb-remote
 237         // we need to give the pty master handle to this object to read and/or write
 238         if (log)
 239             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " setting up stdout/stderr redirection via $O gdb-remote commands", __FUNCTION__, m_debugged_process_sp->GetID ());
 240
 241         // Setup stdout/stderr mapping from inferior to $O
 242         auto terminal_fd = m_debugged_process_sp->GetTerminalFileDescriptor ();
 243         if (terminal_fd >= 0)
 244         {
 245             if (log)
 246                 log->Printf ("ProcessGDBRemoteCommunicationServerLLGS::%s setting inferior STDIO fd to %d", __FUNCTION__, terminal_fd);
 247             error = SetSTDIOFileDescriptor (terminal_fd);
 248             if (error.Fail ())
 249                 return error;
 250         }
 251         else
 252         {
 253             if (log)
 254                 log->Printf ("ProcessGDBRemoteCommunicationServerLLGS::%s ignoring inferior STDIO since terminal fd reported as %d", __FUNCTION__, terminal_fd);
 255         }
 256     }
 257     else
 258     {
 259         if (log)
 260             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " skipping stdout/stderr redirection via $O: inferior will communicate over client-provided file descriptors", __FUNCTION__, m_debugged_process_sp->GetID ());
 261     }
 262
 263     printf ("Launched '%s' as process %" PRIu64 "...\n", m_process_launch_info.GetArguments ().GetArgumentAtIndex (0), m_process_launch_info.GetProcessID ());
 264
 265     return error;
 266 }
 267
 268 Error
 269 GDBRemoteCommunicationServerLLGS::AttachToProcess (lldb::pid_t pid)
 270 {
 271     Error error;
 272
 273     Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
 274     if (log)
 275         log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64, __FUNCTION__, pid);
 276
 277     // Before we try to attach, make sure we aren't already monitoring something else.
 278     if (m_debugged_process_sp  && m_debugged_process_sp->GetID() != LLDB_INVALID_PROCESS_ID)
 279         return Error("cannot attach to a process %" PRIu64 " when another process with pid %" PRIu64 " is being debugged.", pid, m_debugged_process_sp->GetID());
 280
 281     // Try to attach.
 282     error = NativeProcessProtocol::Attach(pid, *this, m_mainloop, m_debugged_process_sp);
 283     if (!error.Success ())
 284     {
 285         fprintf (stderr, "%s: failed to attach to process %" PRIu64 ": %s", __FUNCTION__, pid, error.AsCString ());
 286         return error;
 287     }
 288
 289     // Setup stdout/stderr mapping from inferior.
 290     auto terminal_fd = m_debugged_process_sp->GetTerminalFileDescriptor ();
 291     if (terminal_fd >= 0)
 292     {
 293         if (log)
 294             log->Printf ("ProcessGDBRemoteCommunicationServerLLGS::%s setting inferior STDIO fd to %d", __FUNCTION__, terminal_fd);
 295         error = SetSTDIOFileDescriptor (terminal_fd);
 296         if (error.Fail ())
 297             return error;
 298     }
 299     else
 300     {
 301         if (log)
 302             log->Printf ("ProcessGDBRemoteCommunicationServerLLGS::%s ignoring inferior STDIO since terminal fd reported as %d", __FUNCTION__, terminal_fd);
 303     }
 304
 305     printf ("Attached to process %" PRIu64 "...\n", pid);
 306
 307     return error;
 308 }
 309
 310 void
 311 GDBRemoteCommunicationServerLLGS::InitializeDelegate (NativeProcessProtocol *process)
 312 {
 313     assert (process && "process cannot be NULL");
 314     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 315     if (log)
 316     {
 317         log->Printf ("GDBRemoteCommunicationServerLLGS::%s called with NativeProcessProtocol pid %" PRIu64 ", current state: %s",
 318                 __FUNCTION__,
 319                 process->GetID (),
 320                 StateAsCString (process->GetState ()));
 321     }
 322 }
 323
 324 GDBRemoteCommunication::PacketResult
 325 GDBRemoteCommunicationServerLLGS::SendWResponse (NativeProcessProtocol *process)
 326 {
 327     assert (process && "process cannot be NULL");
 328     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 329
 330     // send W notification
 331     ExitType exit_type = ExitType::eExitTypeInvalid;
 332     int return_code = 0;
 333     std::string exit_description;
 334
 335     const bool got_exit_info = process->GetExitStatus (&exit_type, &return_code, exit_description);
 336     if (!got_exit_info)
 337     {
 338         if (log)
 339             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 ", failed to retrieve process exit status", __FUNCTION__, process->GetID ());
 340
 341         StreamGDBRemote response;
 342         response.PutChar ('E');
 343         response.PutHex8 (GDBRemoteServerError::eErrorExitStatus);
 344         return SendPacketNoLock(response.GetData(), response.GetSize());
 345     }
 346     else
 347     {
 348         if (log)
 349             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 ", returning exit type %d, return code %d [%s]", __FUNCTION__, process->GetID (), exit_type, return_code, exit_description.c_str ());
 350
 351         StreamGDBRemote response;
 352
 353         char return_type_code;
 354         switch (exit_type)
 355         {
 356             case ExitType::eExitTypeExit:
 357                 return_type_code = 'W';
 358                 break;
 359             case ExitType::eExitTypeSignal:
 360                 return_type_code = 'X';
 361                 break;
 362             case ExitType::eExitTypeStop:
 363                 return_type_code = 'S';
 364                 break;
 365             case ExitType::eExitTypeInvalid:
 366                 return_type_code = 'E';
 367                 break;
 368         }
 369         response.PutChar (return_type_code);
 370
 371         // POSIX exit status limited to unsigned 8 bits.
 372         response.PutHex8 (return_code);
 373
 374         return SendPacketNoLock(response.GetData(), response.GetSize());
 375     }
 376 }
 377
 378 static void
 379 AppendHexValue (StreamString &response, const uint8_t* buf, uint32_t buf_size, bool swap)
 380 {
 381     int64_t i;
 382     if (swap)
 383     {
 384         for (i = buf_size-1; i >= 0; i--)
 385             response.PutHex8 (buf[i]);
 386     }
 387     else
 388     {
 389         for (i = 0; i < buf_size; i++)
 390             response.PutHex8 (buf[i]);
 391     }
 392 }
 393
 394 static void
 395 WriteRegisterValueInHexFixedWidth (StreamString &response,
 396                                    NativeRegisterContextSP &reg_ctx_sp,
 397                                    const RegisterInfo &reg_info,
 398                                    const RegisterValue *reg_value_p)
 399 {
 400     RegisterValue reg_value;
 401     if (!reg_value_p)
 402     {
 403         Error error = reg_ctx_sp->ReadRegister (&reg_info, reg_value);
 404         if (error.Success ())
 405             reg_value_p = &reg_value;
 406         // else log.
 407     }
 408
 409     if (reg_value_p)
 410     {
 411         AppendHexValue (response, (const uint8_t*) reg_value_p->GetBytes (), reg_value_p->GetByteSize (), false);
 412     }
 413     else
 414     {
 415         // Zero-out any unreadable values.
 416         if (reg_info.byte_size > 0)
 417         {
 418             std::basic_string<uint8_t> zeros(reg_info.byte_size, '\0');
 419             AppendHexValue (response, zeros.data(), zeros.size(), false);
 420         }
 421     }
 422 }
 423
 424 static JSONObject::SP
 425 GetRegistersAsJSON(NativeThreadProtocol &thread, bool abridged)
 426 {
 427     Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_THREAD));
 428
 429     NativeRegisterContextSP reg_ctx_sp = thread.GetRegisterContext ();
 430     if (! reg_ctx_sp)
 431         return nullptr;
 432
 433     JSONObject::SP register_object_sp = std::make_shared<JSONObject>();
 434
 435 #ifdef LLDB_JTHREADSINFO_FULL_REGISTER_SET
 436     // Expedite all registers in the first register set (i.e. should be GPRs) that are not contained in other registers.
 437     const RegisterSet *reg_set_p = reg_ctx_sp->GetRegisterSet(0);
 438     if (! reg_set_p)
 439         return nullptr;
 440     for (const uint32_t *reg_num_p = reg_set_p->registers; *reg_num_p != LLDB_INVALID_REGNUM; ++reg_num_p)
 441     {
 442         uint32_t reg_num = *reg_num_p;
 443 #else
 444     // Expedite only a couple of registers until we figure out why sending registers is
 445     // expensive.
 446     static const uint32_t k_expedited_registers[] = {
 447         LLDB_REGNUM_GENERIC_PC, LLDB_REGNUM_GENERIC_SP, LLDB_REGNUM_GENERIC_FP, LLDB_REGNUM_GENERIC_RA, LLDB_INVALID_REGNUM
 448     };
 449     static const uint32_t k_abridged_expedited_registers[] = {
 450         LLDB_REGNUM_GENERIC_PC, LLDB_INVALID_REGNUM
 451     };
 452
 453     for (const uint32_t *generic_reg_p = abridged ? k_abridged_expedited_registers : k_expedited_registers;
 454          *generic_reg_p != LLDB_INVALID_REGNUM;
 455          ++generic_reg_p)
 456     {
 457         uint32_t reg_num = reg_ctx_sp->ConvertRegisterKindToRegisterNumber(eRegisterKindGeneric, *generic_reg_p);
 458         if (reg_num == LLDB_INVALID_REGNUM)
 459             continue; // Target does not support the given register.
 460 #endif
 461
 462         const RegisterInfo *const reg_info_p = reg_ctx_sp->GetRegisterInfoAtIndex(reg_num);
 463         if (reg_info_p == nullptr)
 464         {
 465             if (log)
 466                 log->Printf("%s failed to get register info for register index %" PRIu32,
 467                         __FUNCTION__, reg_num);
 468             continue;
 469         }
 470
 471         if (reg_info_p->value_regs != nullptr)
 472             continue; // Only expedite registers that are not contained in other registers.
 473
 474         RegisterValue reg_value;
 475         Error error = reg_ctx_sp->ReadRegister(reg_info_p, reg_value);
 476         if (error.Fail())
 477         {
 478             if (log)
 479                 log->Printf("%s failed to read register '%s' index %" PRIu32 ": %s", __FUNCTION__,
 480                         reg_info_p->name ? reg_info_p->name : "<unnamed-register>", reg_num,
 481                         error.AsCString ());
 482             continue;
 483         }
 484
 485         StreamString stream;
 486         WriteRegisterValueInHexFixedWidth(stream, reg_ctx_sp, *reg_info_p, &reg_value);
 487
 488         register_object_sp->SetObject(std::to_string(reg_num),
 489                 std::make_shared<JSONString>(stream.GetString()));
 490     }
 491
 492     return register_object_sp;
 493 }
 494
 495 static const char *
 496 GetStopReasonString(StopReason stop_reason)
 497 {
 498     switch (stop_reason)
 499     {
 500     case eStopReasonTrace:
 501         return "trace";
 502     case eStopReasonBreakpoint:
 503         return "breakpoint";
 504     case eStopReasonWatchpoint:
 505         return "watchpoint";
 506     case eStopReasonSignal:
 507         return "signal";
 508     case eStopReasonException:
 509         return "exception";
 510     case eStopReasonExec:
 511         return "exec";
 512     case eStopReasonInstrumentation:
 513     case eStopReasonInvalid:
 514     case eStopReasonPlanComplete:
 515     case eStopReasonThreadExiting:
 516     case eStopReasonNone:
 517         break; // ignored
 518     }
 519     return nullptr;
 520 }
 521
 522 static JSONArray::SP
 523 GetJSONThreadsInfo(NativeProcessProtocol &process, bool abridged)
 524 {
 525     Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
 526
 527     JSONArray::SP threads_array_sp = std::make_shared<JSONArray>();
 528
 529     // Ensure we can get info on the given thread.
 530     uint32_t thread_idx = 0;
 531     for ( NativeThreadProtocolSP thread_sp;
 532           (thread_sp = process.GetThreadAtIndex(thread_idx)) != nullptr;
 533           ++thread_idx)
 534     {
 535
 536         lldb::tid_t tid = thread_sp->GetID();
 537
 538         // Grab the reason this thread stopped.
 539         struct ThreadStopInfo tid_stop_info;
 540         std::string description;
 541         if (!thread_sp->GetStopReason (tid_stop_info, description))
 542             return nullptr;
 543
 544         const int signum = tid_stop_info.details.signal.signo;
 545         if (log)
 546         {
 547             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 " got signal signo = %d, reason = %d, exc_type = %" PRIu64,
 548                     __FUNCTION__,
 549                     process.GetID (),
 550                     tid,
 551                     signum,
 552                     tid_stop_info.reason,
 553                     tid_stop_info.details.exception.type);
 554         }
 555
 556         JSONObject::SP thread_obj_sp = std::make_shared<JSONObject>();
 557         threads_array_sp->AppendObject(thread_obj_sp);
 558
 559         if (JSONObject::SP registers_sp = GetRegistersAsJSON(*thread_sp, abridged))
 560             thread_obj_sp->SetObject("registers", registers_sp);
 561
 562         thread_obj_sp->SetObject("tid", std::make_shared<JSONNumber>(tid));
 563         if (signum != 0)
 564             thread_obj_sp->SetObject("signal", std::make_shared<JSONNumber>(signum));
 565
 566         const std::string thread_name = thread_sp->GetName ();
 567         if (! thread_name.empty())
 568             thread_obj_sp->SetObject("name", std::make_shared<JSONString>(thread_name));
 569
 570         if (const char *stop_reason_str = GetStopReasonString(tid_stop_info.reason))
 571             thread_obj_sp->SetObject("reason", std::make_shared<JSONString>(stop_reason_str));
 572
 573         if (! description.empty())
 574             thread_obj_sp->SetObject("description", std::make_shared<JSONString>(description));
 575
 576         if ((tid_stop_info.reason == eStopReasonException) && tid_stop_info.details.exception.type)
 577         {
 578             thread_obj_sp->SetObject("metype",
 579                     std::make_shared<JSONNumber>(tid_stop_info.details.exception.type));
 580
 581             JSONArray::SP medata_array_sp = std::make_shared<JSONArray>();
 582             for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; ++i)
 583             {
 584                 medata_array_sp->AppendObject(std::make_shared<JSONNumber>(
 585                             tid_stop_info.details.exception.data[i]));
 586             }
 587             thread_obj_sp->SetObject("medata", medata_array_sp);
 588         }
 589
 590         // TODO: Expedite interesting regions of inferior memory
 591     }
 592
 593     return threads_array_sp;
 594 }
 595
 596 GDBRemoteCommunication::PacketResult
 597 GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread (lldb::tid_t tid)
 598 {
 599     Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
 600
 601     // Ensure we have a debugged process.
 602     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
 603         return SendErrorResponse (50);
 604
 605     if (log)
 606         log->Printf ("GDBRemoteCommunicationServerLLGS::%s preparing packet for pid %" PRIu64 " tid %" PRIu64,
 607                 __FUNCTION__, m_debugged_process_sp->GetID (), tid);
 608
 609     // Ensure we can get info on the given thread.
 610     NativeThreadProtocolSP thread_sp (m_debugged_process_sp->GetThreadByID (tid));
 611     if (!thread_sp)
 612         return SendErrorResponse (51);
 613
 614     // Grab the reason this thread stopped.
 615     struct ThreadStopInfo tid_stop_info;
 616     std::string description;
 617     if (!thread_sp->GetStopReason (tid_stop_info, description))
 618         return SendErrorResponse (52);
 619
 620     // FIXME implement register handling for exec'd inferiors.
 621     // if (tid_stop_info.reason == eStopReasonExec)
 622     // {
 623     //     const bool force = true;
 624     //     InitializeRegisters(force);
 625     // }
 626
 627     StreamString response;
 628     // Output the T packet with the thread
 629     response.PutChar ('T');
 630     int signum = tid_stop_info.details.signal.signo;
 631     if (log)
 632     {
 633         log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 " got signal signo = %d, reason = %d, exc_type = %" PRIu64,
 634                 __FUNCTION__,
 635                 m_debugged_process_sp->GetID (),
 636                 tid,
 637                 signum,
 638                 tid_stop_info.reason,
 639                 tid_stop_info.details.exception.type);
 640     }
 641
 642     // Print the signal number.
 643     response.PutHex8 (signum & 0xff);
 644
 645     // Include the tid.
 646     response.Printf ("thread:%" PRIx64 ";", tid);
 647
 648     // Include the thread name if there is one.
 649     const std::string thread_name = thread_sp->GetName ();
 650     if (!thread_name.empty ())
 651     {
 652         size_t thread_name_len = thread_name.length ();
 653
 654         if (::strcspn (thread_name.c_str (), "$#+-;:") == thread_name_len)
 655         {
 656             response.PutCString ("name:");
 657             response.PutCString (thread_name.c_str ());
 658         }
 659         else
 660         {
 661             // The thread name contains special chars, send as hex bytes.
 662             response.PutCString ("hexname:");
 663             response.PutCStringAsRawHex8 (thread_name.c_str ());
 664         }
 665         response.PutChar (';');
 666     }
 667
 668     // If a 'QListThreadsInStopReply' was sent to enable this feature, we
 669     // will send all thread IDs back in the "threads" key whose value is
 670     // a list of hex thread IDs separated by commas:
 671     //  "threads:10a,10b,10c;"
 672     // This will save the debugger from having to send a pair of qfThreadInfo
 673     // and qsThreadInfo packets, but it also might take a lot of room in the
 674     // stop reply packet, so it must be enabled only on systems where there
 675     // are no limits on packet lengths.
 676     if (m_list_threads_in_stop_reply)
 677     {
 678         response.PutCString ("threads:");
 679
 680         uint32_t thread_index = 0;
 681         NativeThreadProtocolSP listed_thread_sp;
 682         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))
 683         {
 684             if (thread_index > 0)
 685                 response.PutChar (',');
 686             response.Printf ("%" PRIx64, listed_thread_sp->GetID ());
 687         }
 688         response.PutChar (';');
 689
 690         // Include JSON info that describes the stop reason for any threads
 691         // that actually have stop reasons. We use the new "jstopinfo" key
 692         // whose values is hex ascii JSON that contains the thread IDs
 693         // thread stop info only for threads that have stop reasons. Only send
 694         // this if we have more than one thread otherwise this packet has all
 695         // the info it needs.
 696         if (thread_index > 0)
 697         {
 698             const bool threads_with_valid_stop_info_only = true;
 699             JSONArray::SP threads_info_sp = GetJSONThreadsInfo(*m_debugged_process_sp,
 700                                                                threads_with_valid_stop_info_only);
 701             if (threads_info_sp)
 702             {
 703                 response.PutCString("jstopinfo:");
 704                 StreamString unescaped_response;
 705                 threads_info_sp->Write(unescaped_response);
 706                 response.PutCStringAsRawHex8(unescaped_response.GetData());
 707                 response.PutChar(';');
 708             }
 709             else if (log)
 710                 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to prepare a jstopinfo field for pid %" PRIu64,
 711                         __FUNCTION__, m_debugged_process_sp->GetID());
 712
 713         }
 714     }
 715
 716     //
 717     // Expedite registers.
 718     //
 719
 720     // Grab the register context.
 721     NativeRegisterContextSP reg_ctx_sp = thread_sp->GetRegisterContext ();
 722     if (reg_ctx_sp)
 723     {
 724         // Expedite all registers in the first register set (i.e. should be GPRs) that are not contained in other registers.
 725         const RegisterSet *reg_set_p;
 726         if (reg_ctx_sp->GetRegisterSetCount () > 0 && ((reg_set_p = reg_ctx_sp->GetRegisterSet (0)) != nullptr))
 727         {
 728             if (log)
 729                 log->Printf ("GDBRemoteCommunicationServerLLGS::%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);
 730
 731             for (const uint32_t *reg_num_p = reg_set_p->registers; *reg_num_p != LLDB_INVALID_REGNUM; ++reg_num_p)
 732             {
 733                 const RegisterInfo *const reg_info_p = reg_ctx_sp->GetRegisterInfoAtIndex (*reg_num_p);
 734                 if (reg_info_p == nullptr)
 735                 {
 736                     if (log)
 737                         log->Printf ("GDBRemoteCommunicationServerLLGS::%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);
 738                 }
 739                 else if (reg_info_p->value_regs == nullptr)
 740                 {
 741                     // Only expediate registers that are not contained in other registers.
 742                     RegisterValue reg_value;
 743                     Error error = reg_ctx_sp->ReadRegister (reg_info_p, reg_value);
 744                     if (error.Success ())
 745                     {
 746                         response.Printf ("%.02x:", *reg_num_p);
 747                         WriteRegisterValueInHexFixedWidth(response, reg_ctx_sp, *reg_info_p, &reg_value);
 748                         response.PutChar (';');
 749                     }
 750                     else
 751                     {
 752                         if (log)
 753                             log->Printf ("GDBRemoteCommunicationServerLLGS::%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 ());
 754
 755                     }
 756                 }
 757             }
 758         }
 759     }
 760
 761     const char* reason_str = GetStopReasonString(tid_stop_info.reason);
 762     if (reason_str != nullptr)
 763     {
 764         response.Printf ("reason:%s;", reason_str);
 765     }
 766
 767     if (!description.empty())
 768     {
 769         // Description may contains special chars, send as hex bytes.
 770         response.PutCString ("description:");
 771         response.PutCStringAsRawHex8 (description.c_str ());
 772         response.PutChar (';');
 773     }
 774     else if ((tid_stop_info.reason == eStopReasonException) && tid_stop_info.details.exception.type)
 775     {
 776         response.PutCString ("metype:");
 777         response.PutHex64 (tid_stop_info.details.exception.type);
 778         response.PutCString (";mecount:");
 779         response.PutHex32 (tid_stop_info.details.exception.data_count);
 780         response.PutChar (';');
 781
 782         for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; ++i)
 783         {
 784             response.PutCString ("medata:");
 785             response.PutHex64 (tid_stop_info.details.exception.data[i]);
 786             response.PutChar (';');
 787         }
 788     }
 789
 790     return SendPacketNoLock (response.GetData(), response.GetSize());
 791 }
 792
 793 void
 794 GDBRemoteCommunicationServerLLGS::HandleInferiorState_Exited (NativeProcessProtocol *process)
 795 {
 796     assert (process && "process cannot be NULL");
 797
 798     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 799     if (log)
 800         log->Printf ("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
 801
 802     PacketResult result = SendStopReasonForState(StateType::eStateExited);
 803     if (result != PacketResult::Success)
 804     {
 805         if (log)
 806             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to send stop notification for PID %" PRIu64 ", state: eStateExited", __FUNCTION__, process->GetID ());
 807     }
 808
 809     // Close the pipe to the inferior terminal i/o if we launched it
 810     // and set one up.
 811     MaybeCloseInferiorTerminalConnection ();
 812
 813     // We are ready to exit the debug monitor.
 814     m_exit_now = true;
 815 }
 816
 817 void
 818 GDBRemoteCommunicationServerLLGS::HandleInferiorState_Stopped (NativeProcessProtocol *process)
 819 {
 820     assert (process && "process cannot be NULL");
 821
 822     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 823     if (log)
 824         log->Printf ("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
 825
 826     // Send the stop reason unless this is the stop after the
 827     // launch or attach.
 828     switch (m_inferior_prev_state)
 829     {
 830         case eStateLaunching:
 831         case eStateAttaching:
 832             // Don't send anything per debugserver behavior.
 833             break;
 834         default:
 835             // In all other cases, send the stop reason.
 836             PacketResult result = SendStopReasonForState(StateType::eStateStopped);
 837             if (result != PacketResult::Success)
 838             {
 839                 if (log)
 840                     log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to send stop notification for PID %" PRIu64 ", state: eStateExited", __FUNCTION__, process->GetID ());
 841             }
 842             break;
 843     }
 844 }
 845
 846 void
 847 GDBRemoteCommunicationServerLLGS::ProcessStateChanged (NativeProcessProtocol *process, lldb::StateType state)
 848 {
 849     assert (process && "process cannot be NULL");
 850     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
 851     if (log)
 852     {
 853         log->Printf ("GDBRemoteCommunicationServerLLGS::%s called with NativeProcessProtocol pid %" PRIu64 ", state: %s",
 854                 __FUNCTION__,
 855                 process->GetID (),
 856                 StateAsCString (state));
 857     }
 858
 859     switch (state)
 860     {
 861     case StateType::eStateRunning:
 862         StartSTDIOForwarding();
 863         break;
 864
 865     case StateType::eStateStopped:
 866         // Make sure we get all of the pending stdout/stderr from the inferior
 867         // and send it to the lldb host before we send the state change
 868         // notification
 869         SendProcessOutput();
 870         // Then stop the forwarding, so that any late output (see llvm.org/pr25652) does not
 871         // interfere with our protocol.
 872         StopSTDIOForwarding();
 873         HandleInferiorState_Stopped (process);
 874         break;
 875
 876     case StateType::eStateExited:
 877         // Same as above
 878         SendProcessOutput();
 879         StopSTDIOForwarding();
 880         HandleInferiorState_Exited (process);
 881         break;
 882
 883     default:
 884         if (log)
 885         {
 886             log->Printf ("GDBRemoteCommunicationServerLLGS::%s didn't handle state change for pid %" PRIu64 ", new state: %s",
 887                     __FUNCTION__,
 888                     process->GetID (),
 889                     StateAsCString (state));
 890         }
 891         break;
 892     }
 893
 894     // Remember the previous state reported to us.
 895     m_inferior_prev_state = state;
 896 }
 897
 898 void
 899 GDBRemoteCommunicationServerLLGS::DidExec (NativeProcessProtocol *process)
 900 {
 901     ClearProcessSpecificData ();
 902 }
 903
 904 void
 905 GDBRemoteCommunicationServerLLGS::DataAvailableCallback ()
 906 {
 907     Log *log (GetLogIfAnyCategoriesSet(GDBR_LOG_COMM));
 908
 909     if (! m_handshake_completed)
 910     {
 911         if (! HandshakeWithClient())
 912         {
 913             if(log)
 914                 log->Printf("GDBRemoteCommunicationServerLLGS::%s handshake with client failed, exiting",
 915                         __FUNCTION__);
 916             m_mainloop.RequestTermination();
 917             return;
 918         }
 919         m_handshake_completed = true;
 920     }
 921
 922     bool interrupt = false;
 923     bool done = false;
 924     Error error;
 925     while (true)
 926     {
 927         const PacketResult result = GetPacketAndSendResponse (0, error, interrupt, done);
 928         if (result == PacketResult::ErrorReplyTimeout)
 929             break; // No more packets in the queue
 930
 931         if ((result != PacketResult::Success))
 932         {
 933             if(log)
 934                 log->Printf("GDBRemoteCommunicationServerLLGS::%s processing a packet failed: %s",
 935                         __FUNCTION__, error.AsCString());
 936             m_mainloop.RequestTermination();
 937             break;
 938         }
 939     }
 940 }
 941
 942 Error
 943 GDBRemoteCommunicationServerLLGS::InitializeConnection (std::unique_ptr<Connection> &&connection)
 944 {
 945     IOObjectSP read_object_sp = connection->GetReadObject();
 946     GDBRemoteCommunicationServer::SetConnection(connection.release());
 947
 948     Error error;
 949     m_network_handle_up = m_mainloop.RegisterReadObject(read_object_sp,
 950             [this] (MainLoopBase &) { DataAvailableCallback(); }, error);
 951     return error;
 952 }
 953
 954 GDBRemoteCommunication::PacketResult
 955 GDBRemoteCommunicationServerLLGS::SendONotification (const char *buffer, uint32_t len)
 956 {
 957     if ((buffer == nullptr) || (len == 0))
 958     {
 959         // Nothing to send.
 960         return PacketResult::Success;
 961     }
 962
 963     StreamString response;
 964     response.PutChar ('O');
 965     response.PutBytesAsRawHex8 (buffer, len);
 966
 967     return SendPacketNoLock (response.GetData (), response.GetSize ());
 968 }
 969
 970 Error
 971 GDBRemoteCommunicationServerLLGS::SetSTDIOFileDescriptor (int fd)
 972 {
 973     Error error;
 974
 975     // Set up the reading/handling of process I/O
 976     std::unique_ptr<ConnectionFileDescriptor> conn_up (new ConnectionFileDescriptor (fd, true));
 977     if (!conn_up)
 978     {
 979         error.SetErrorString ("failed to create ConnectionFileDescriptor");
 980         return error;
 981     }
 982
 983     m_stdio_communication.SetCloseOnEOF (false);
 984     m_stdio_communication.SetConnection (conn_up.release());
 985     if (!m_stdio_communication.IsConnected ())
 986     {
 987         error.SetErrorString ("failed to set connection for inferior I/O communication");
 988         return error;
 989     }
 990
 991     return Error();
 992 }
 993
 994 void
 995 GDBRemoteCommunicationServerLLGS::StartSTDIOForwarding()
 996 {
 997     // Don't forward if not connected (e.g. when attaching).
 998     if (! m_stdio_communication.IsConnected())
 999         return;
1000
1001     // llgs local-process debugging may specify PTY paths, which will make these
1002     // file actions non-null
1003     // process launch -e/o will also make these file actions non-null
1004     // nullptr means that the traffic is expected to flow over gdb-remote protocol
1005     if ( m_process_launch_info.GetFileActionForFD(STDOUT_FILENO) &&
1006          m_process_launch_info.GetFileActionForFD(STDERR_FILENO))
1007         return;
1008
1009     Error error;
1010     lldbassert(! m_stdio_handle_up);
1011     m_stdio_handle_up = m_mainloop.RegisterReadObject(
1012             m_stdio_communication.GetConnection()->GetReadObject(),
1013             [this] (MainLoopBase &) { SendProcessOutput(); }, error);
1014
1015     if (! m_stdio_handle_up)
1016     {
1017         // Not much we can do about the failure. Log it and continue without forwarding.
1018         if (Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS))
1019             log->Printf("GDBRemoteCommunicationServerLLGS::%s Failed to set up stdio forwarding: %s",
1020                         __FUNCTION__, error.AsCString());
1021     }
1022 }
1023
1024 void
1025 GDBRemoteCommunicationServerLLGS::StopSTDIOForwarding()
1026 {
1027     m_stdio_handle_up.reset();
1028 }
1029
1030 void
1031 GDBRemoteCommunicationServerLLGS::SendProcessOutput()
1032 {
1033     char buffer[1024];
1034     ConnectionStatus status;
1035     Error error;
1036     while (true)
1037     {
1038         size_t bytes_read = m_stdio_communication.Read(buffer, sizeof buffer, 0, status, &error);
1039         switch (status)
1040         {
1041         case eConnectionStatusSuccess:
1042             SendONotification(buffer, bytes_read);
1043             break;
1044         case eConnectionStatusLostConnection:
1045         case eConnectionStatusEndOfFile:
1046         case eConnectionStatusError:
1047         case eConnectionStatusNoConnection:
1048             if (Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS))
1049                 log->Printf("GDBRemoteCommunicationServerLLGS::%s Stopping stdio forwarding as communication returned status %d (error: %s)", __FUNCTION__, status, error.AsCString());
1050             m_stdio_handle_up.reset();
1051             return;
1052
1053         case eConnectionStatusInterrupted:
1054         case eConnectionStatusTimedOut:
1055             return;
1056         }
1057     }
1058 }
1059
1060 GDBRemoteCommunication::PacketResult
1061 GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo (StringExtractorGDBRemote &packet)
1062 {
1063     // Fail if we don't have a current process.
1064     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
1065         return SendErrorResponse (68);
1066
1067     lldb::pid_t pid = m_debugged_process_sp->GetID ();
1068
1069     if (pid == LLDB_INVALID_PROCESS_ID)
1070         return SendErrorResponse (1);
1071
1072     ProcessInstanceInfo proc_info;
1073     if (!Host::GetProcessInfo (pid, proc_info))
1074         return SendErrorResponse (1);
1075
1076     StreamString response;
1077     CreateProcessInfoResponse_DebugServerStyle(proc_info, response);
1078     return SendPacketNoLock (response.GetData (), response.GetSize ());
1079 }
1080
1081 GDBRemoteCommunication::PacketResult
1082 GDBRemoteCommunicationServerLLGS::Handle_qC (StringExtractorGDBRemote &packet)
1083 {
1084     // Fail if we don't have a current process.
1085     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
1086         return SendErrorResponse (68);
1087
1088     // Make sure we set the current thread so g and p packets return
1089     // the data the gdb will expect.
1090     lldb::tid_t tid = m_debugged_process_sp->GetCurrentThreadID ();
1091     SetCurrentThreadID (tid);
1092
1093     NativeThreadProtocolSP thread_sp = m_debugged_process_sp->GetCurrentThread ();
1094     if (!thread_sp)
1095         return SendErrorResponse (69);
1096
1097     StreamString response;
1098     response.Printf ("QC%" PRIx64, thread_sp->GetID ());
1099
1100     return SendPacketNoLock (response.GetData(), response.GetSize());
1101 }
1102
1103 GDBRemoteCommunication::PacketResult
1104 GDBRemoteCommunicationServerLLGS::Handle_k (StringExtractorGDBRemote &packet)
1105 {
1106     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
1107
1108     StopSTDIOForwarding();
1109
1110     if (! m_debugged_process_sp)
1111     {
1112         if (log)
1113             log->Printf("GDBRemoteCommunicationServerLLGS::%s No debugged process found.", __FUNCTION__);
1114         return PacketResult::Success;
1115     }
1116
1117     Error error = m_debugged_process_sp->Kill();
1118     if (error.Fail() && log)
1119         log->Printf("GDBRemoteCommunicationServerLLGS::%s Failed to kill debugged process %" PRIu64 ": %s",
1120                 __FUNCTION__, m_debugged_process_sp->GetID(), error.AsCString());
1121
1122     // No OK response for kill packet.
1123     // return SendOKResponse ();
1124     return PacketResult::Success;
1125 }
1126
1127 GDBRemoteCommunication::PacketResult
1128 GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR (StringExtractorGDBRemote &packet)
1129 {
1130     packet.SetFilePos(::strlen ("QSetDisableASLR:"));
1131     if (packet.GetU32(0))
1132         m_process_launch_info.GetFlags().Set (eLaunchFlagDisableASLR);
1133     else
1134         m_process_launch_info.GetFlags().Clear (eLaunchFlagDisableASLR);
1135     return SendOKResponse ();
1136 }
1137
1138 GDBRemoteCommunication::PacketResult
1139 GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir (StringExtractorGDBRemote &packet)
1140 {
1141     packet.SetFilePos (::strlen ("QSetWorkingDir:"));
1142     std::string path;
1143     packet.GetHexByteString (path);
1144     m_process_launch_info.SetWorkingDirectory(FileSpec{path, true});
1145     return SendOKResponse ();
1146 }
1147
1148 GDBRemoteCommunication::PacketResult
1149 GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir (StringExtractorGDBRemote &packet)
1150 {
1151     FileSpec working_dir{m_process_launch_info.GetWorkingDirectory()};
1152     if (working_dir)
1153     {
1154         StreamString response;
1155         response.PutCStringAsRawHex8(working_dir.GetCString());
1156         return SendPacketNoLock(response.GetData(), response.GetSize());
1157     }
1158
1159     return SendErrorResponse(14);
1160 }
1161
1162 GDBRemoteCommunication::PacketResult
1163 GDBRemoteCommunicationServerLLGS::Handle_C (StringExtractorGDBRemote &packet)
1164 {
1165     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_THREAD));
1166     if (log)
1167         log->Printf ("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
1168
1169     // Ensure we have a native process.
1170     if (!m_debugged_process_sp)
1171     {
1172         if (log)
1173             log->Printf ("GDBRemoteCommunicationServerLLGS::%s no debugged process shared pointer", __FUNCTION__);
1174         return SendErrorResponse (0x36);
1175     }
1176
1177     // Pull out the signal number.
1178     packet.SetFilePos (::strlen ("C"));
1179     if (packet.GetBytesLeft () < 1)
1180     {
1181         // Shouldn't be using a C without a signal.
1182         return SendIllFormedResponse (packet, "C packet specified without signal.");
1183     }
1184     const uint32_t signo = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ());
1185     if (signo == std::numeric_limits<uint32_t>::max ())
1186         return SendIllFormedResponse (packet, "failed to parse signal number");
1187
1188     // Handle optional continue address.
1189     if (packet.GetBytesLeft () > 0)
1190     {
1191         // FIXME add continue at address support for $C{signo}[;{continue-address}].
1192         if (*packet.Peek () == ';')
1193             return SendUnimplementedResponse (packet.GetStringRef().c_str());
1194         else
1195             return SendIllFormedResponse (packet, "unexpected content after $C{signal-number}");
1196     }
1197
1198     ResumeActionList resume_actions (StateType::eStateRunning, 0);
1199     Error error;
1200
1201     // We have two branches: what to do if a continue thread is specified (in which case we target
1202     // sending the signal to that thread), or when we don't have a continue thread set (in which
1203     // case we send a signal to the process).
1204
1205     // TODO discuss with Greg Clayton, make sure this makes sense.
1206
1207     lldb::tid_t signal_tid = GetContinueThreadID ();
1208     if (signal_tid != LLDB_INVALID_THREAD_ID)
1209     {
1210         // The resume action for the continue thread (or all threads if a continue thread is not set).
1211         ResumeAction action = { GetContinueThreadID (), StateType::eStateRunning, static_cast<int> (signo) };
1212
1213         // Add the action for the continue thread (or all threads when the continue thread isn't present).
1214         resume_actions.Append (action);
1215     }
1216     else
1217     {
1218         // Send the signal to the process since we weren't targeting a specific continue thread with the signal.
1219         error = m_debugged_process_sp->Signal (signo);
1220         if (error.Fail ())
1221         {
1222             if (log)
1223                 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to send signal for process %" PRIu64 ": %s",
1224                              __FUNCTION__,
1225                              m_debugged_process_sp->GetID (),
1226                              error.AsCString ());
1227
1228             return SendErrorResponse (0x52);
1229         }
1230     }
1231
1232     // Resume the threads.
1233     error = m_debugged_process_sp->Resume (resume_actions);
1234     if (error.Fail ())
1235     {
1236         if (log)
1237             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to resume threads for process %" PRIu64 ": %s",
1238                          __FUNCTION__,
1239                          m_debugged_process_sp->GetID (),
1240                          error.AsCString ());
1241
1242         return SendErrorResponse (0x38);
1243     }
1244
1245     // Don't send an "OK" packet; response is the stopped/exited message.
1246     return PacketResult::Success;
1247 }
1248
1249 GDBRemoteCommunication::PacketResult
1250 GDBRemoteCommunicationServerLLGS::Handle_c (StringExtractorGDBRemote &packet)
1251 {
1252     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_THREAD));
1253     if (log)
1254         log->Printf ("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);
1255
1256     packet.SetFilePos (packet.GetFilePos() + ::strlen ("c"));
1257
1258     // For now just support all continue.
1259     const bool has_continue_address = (packet.GetBytesLeft () > 0);
1260     if (has_continue_address)
1261     {
1262         if (log)
1263             log->Printf ("GDBRemoteCommunicationServerLLGS::%s not implemented for c{address} variant [%s remains]", __FUNCTION__, packet.Peek ());
1264         return SendUnimplementedResponse (packet.GetStringRef().c_str());
1265     }
1266
1267     // Ensure we have a native process.
1268     if (!m_debugged_process_sp)
1269     {
1270         if (log)
1271             log->Printf ("GDBRemoteCommunicationServerLLGS::%s no debugged process shared pointer", __FUNCTION__);
1272         return SendErrorResponse (0x36);
1273     }
1274
1275     // Build the ResumeActionList
1276     ResumeActionList actions (StateType::eStateRunning, 0);
1277
1278     Error error = m_debugged_process_sp->Resume (actions);
1279     if (error.Fail ())
1280     {
1281         if (log)
1282         {
1283             log->Printf ("GDBRemoteCommunicationServerLLGS::%s c failed for process %" PRIu64 ": %s",
1284                          __FUNCTION__,
1285                          m_debugged_process_sp->GetID (),
1286                          error.AsCString ());
1287         }
1288         return SendErrorResponse (GDBRemoteServerError::eErrorResume);
1289     }
1290
1291     if (log)
1292         log->Printf ("GDBRemoteCommunicationServerLLGS::%s continued process %" PRIu64, __FUNCTION__, m_debugged_process_sp->GetID ());
1293
1294     // No response required from continue.
1295     return PacketResult::Success;
1296 }
1297
1298 GDBRemoteCommunication::PacketResult
1299 GDBRemoteCommunicationServerLLGS::Handle_vCont_actions (StringExtractorGDBRemote &packet)
1300 {
1301     StreamString response;
1302     response.Printf("vCont;c;C;s;S");
1303
1304     return SendPacketNoLock(response.GetData(), response.GetSize());
1305 }
1306
1307 GDBRemoteCommunication::PacketResult
1308 GDBRemoteCommunicationServerLLGS::Handle_vCont (StringExtractorGDBRemote &packet)
1309 {
1310     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
1311     if (log)
1312         log->Printf ("GDBRemoteCommunicationServerLLGS::%s handling vCont packet", __FUNCTION__);
1313
1314     packet.SetFilePos (::strlen ("vCont"));
1315
1316     if (packet.GetBytesLeft() == 0)
1317     {
1318         if (log)
1319             log->Printf ("GDBRemoteCommunicationServerLLGS::%s missing action from vCont package", __FUNCTION__);
1320         return SendIllFormedResponse (packet, "Missing action from vCont package");
1321     }
1322
1323     // Check if this is all continue (no options or ";c").
1324     if (::strcmp (packet.Peek (), ";c") == 0)
1325     {
1326         // Move past the ';', then do a simple 'c'.
1327         packet.SetFilePos (packet.GetFilePos () + 1);
1328         return Handle_c (packet);
1329     }
1330     else if (::strcmp (packet.Peek (), ";s") == 0)
1331     {
1332         // Move past the ';', then do a simple 's'.
1333         packet.SetFilePos (packet.GetFilePos () + 1);
1334         return Handle_s (packet);
1335     }
1336
1337     // Ensure we have a native process.
1338     if (!m_debugged_process_sp)
1339     {
1340         if (log)
1341             log->Printf ("GDBRemoteCommunicationServerLLGS::%s no debugged process shared pointer", __FUNCTION__);
1342         return SendErrorResponse (0x36);
1343     }
1344
1345     ResumeActionList thread_actions;
1346
1347     while (packet.GetBytesLeft () && *packet.Peek () == ';')
1348     {
1349         // Skip the semi-colon.
1350         packet.GetChar ();
1351
1352         // Build up the thread action.
1353         ResumeAction thread_action;
1354         thread_action.tid = LLDB_INVALID_THREAD_ID;
1355         thread_action.state = eStateInvalid;
1356         thread_action.signal = 0;
1357
1358         const char action = packet.GetChar ();
1359         switch (action)
1360         {
1361             case 'C':
1362                 thread_action.signal = packet.GetHexMaxU32 (false, 0);
1363                 if (thread_action.signal == 0)
1364                     return SendIllFormedResponse (packet, "Could not parse signal in vCont packet C action");
1365                 LLVM_FALLTHROUGH;
1366
1367             case 'c':
1368                 // Continue
1369                 thread_action.state = eStateRunning;
1370                 break;
1371
1372             case 'S':
1373                 thread_action.signal = packet.GetHexMaxU32 (false, 0);
1374                 if (thread_action.signal == 0)
1375                     return SendIllFormedResponse (packet, "Could not parse signal in vCont packet S action");
1376                 LLVM_FALLTHROUGH;
1377
1378             case 's':
1379                 // Step
1380                 thread_action.state = eStateStepping;
1381                 break;
1382
1383             default:
1384                 return SendIllFormedResponse (packet, "Unsupported vCont action");
1385                 break;
1386         }
1387
1388         // Parse out optional :{thread-id} value.
1389         if (packet.GetBytesLeft () && (*packet.Peek () == ':'))
1390         {
1391             // Consume the separator.
1392             packet.GetChar ();
1393
1394             thread_action.tid = packet.GetHexMaxU32 (false, LLDB_INVALID_THREAD_ID);
1395             if (thread_action.tid == LLDB_INVALID_THREAD_ID)
1396                 return SendIllFormedResponse (packet, "Could not parse thread number in vCont packet");
1397         }
1398
1399         thread_actions.Append (thread_action);
1400     }
1401
1402     Error error = m_debugged_process_sp->Resume (thread_actions);
1403     if (error.Fail ())
1404     {
1405         if (log)
1406         {
1407             log->Printf ("GDBRemoteCommunicationServerLLGS::%s vCont failed for process %" PRIu64 ": %s",
1408                          __FUNCTION__,
1409                          m_debugged_process_sp->GetID (),
1410                          error.AsCString ());
1411         }
1412         return SendErrorResponse (GDBRemoteServerError::eErrorResume);
1413     }
1414
1415     if (log)
1416         log->Printf ("GDBRemoteCommunicationServerLLGS::%s continued process %" PRIu64, __FUNCTION__, m_debugged_process_sp->GetID ());
1417
1418     // No response required from vCont.
1419     return PacketResult::Success;
1420 }
1421
1422 void
1423 GDBRemoteCommunicationServerLLGS::SetCurrentThreadID (lldb::tid_t tid)
1424 {
1425     Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_THREAD));
1426     if (log)
1427         log->Printf ("GDBRemoteCommunicationServerLLGS::%s setting current thread id to %" PRIu64, __FUNCTION__, tid);
1428
1429     m_current_tid = tid;
1430     if (m_debugged_process_sp)
1431         m_debugged_process_sp->SetCurrentThreadID (m_current_tid);
1432 }
1433
1434 void
1435 GDBRemoteCommunicationServerLLGS::SetContinueThreadID (lldb::tid_t tid)
1436 {
1437     Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_THREAD));
1438     if (log)
1439         log->Printf ("GDBRemoteCommunicationServerLLGS::%s setting continue thread id to %" PRIu64, __FUNCTION__, tid);
1440
1441     m_continue_tid = tid;
1442 }
1443
1444 GDBRemoteCommunication::PacketResult
1445 GDBRemoteCommunicationServerLLGS::Handle_stop_reason (StringExtractorGDBRemote &packet)
1446 {
1447     // Handle the $? gdbremote command.
1448
1449     // If no process, indicate error
1450     if (!m_debugged_process_sp)
1451         return SendErrorResponse (02);
1452
1453     return SendStopReasonForState (m_debugged_process_sp->GetState());
1454 }
1455
1456 GDBRemoteCommunication::PacketResult
1457 GDBRemoteCommunicationServerLLGS::SendStopReasonForState (lldb::StateType process_state)
1458 {
1459     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
1460
1461     switch (process_state)
1462     {
1463         case eStateAttaching:
1464         case eStateLaunching:
1465         case eStateRunning:
1466         case eStateStepping:
1467         case eStateDetached:
1468             // NOTE: gdb protocol doc looks like it should return $OK
1469             // when everything is running (i.e. no stopped result).
1470             return PacketResult::Success;  // Ignore
1471
1472         case eStateSuspended:
1473         case eStateStopped:
1474         case eStateCrashed:
1475         {
1476             lldb::tid_t tid = m_debugged_process_sp->GetCurrentThreadID ();
1477             // Make sure we set the current thread so g and p packets return
1478             // the data the gdb will expect.
1479             SetCurrentThreadID (tid);
1480             return SendStopReplyPacketForThread (tid);
1481         }
1482
1483         case eStateInvalid:
1484         case eStateUnloaded:
1485         case eStateExited:
1486             return SendWResponse(m_debugged_process_sp.get());
1487
1488         default:
1489             if (log)
1490             {
1491                 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 ", current state reporting not handled: %s",
1492                              __FUNCTION__,
1493                              m_debugged_process_sp->GetID (),
1494                              StateAsCString (process_state));
1495             }
1496             break;
1497     }
1498
1499     return SendErrorResponse (0);
1500 }
1501
1502 GDBRemoteCommunication::PacketResult
1503 GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo (StringExtractorGDBRemote &packet)
1504 {
1505     // Fail if we don't have a current process.
1506     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
1507         return SendErrorResponse (68);
1508
1509     // Ensure we have a thread.
1510     NativeThreadProtocolSP thread_sp (m_debugged_process_sp->GetThreadAtIndex (0));
1511     if (!thread_sp)
1512         return SendErrorResponse (69);
1513
1514     // Get the register context for the first thread.
1515     NativeRegisterContextSP reg_context_sp (thread_sp->GetRegisterContext ());
1516     if (!reg_context_sp)
1517         return SendErrorResponse (69);
1518
1519     // Parse out the register number from the request.
1520     packet.SetFilePos (strlen("qRegisterInfo"));
1521     const uint32_t reg_index = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ());
1522     if (reg_index == std::numeric_limits<uint32_t>::max ())
1523         return SendErrorResponse (69);
1524
1525     // Return the end of registers response if we've iterated one past the end of the register set.
1526     if (reg_index >= reg_context_sp->GetUserRegisterCount ())
1527         return SendErrorResponse (69);
1528
1529     const RegisterInfo *reg_info = reg_context_sp->GetRegisterInfoAtIndex(reg_index);
1530     if (!reg_info)
1531         return SendErrorResponse (69);
1532
1533     // Build the reginfos response.
1534     StreamGDBRemote response;
1535
1536     response.PutCString ("name:");
1537     response.PutCString (reg_info->name);
1538     response.PutChar (';');
1539
1540     if (reg_info->alt_name && reg_info->alt_name[0])
1541     {
1542         response.PutCString ("alt-name:");
1543         response.PutCString (reg_info->alt_name);
1544         response.PutChar (';');
1545     }
1546
1547     response.Printf ("bitsize:%" PRIu32 ";offset:%" PRIu32 ";", reg_info->byte_size * 8, reg_info->byte_offset);
1548
1549     switch (reg_info->encoding)
1550     {
1551         case eEncodingUint:    response.PutCString ("encoding:uint;"); break;
1552         case eEncodingSint:    response.PutCString ("encoding:sint;"); break;
1553         case eEncodingIEEE754: response.PutCString ("encoding:ieee754;"); break;
1554         case eEncodingVector:  response.PutCString ("encoding:vector;"); break;
1555         default: break;
1556     }
1557
1558     switch (reg_info->format)
1559     {
1560         case eFormatBinary:          response.PutCString ("format:binary;"); break;
1561         case eFormatDecimal:         response.PutCString ("format:decimal;"); break;
1562         case eFormatHex:             response.PutCString ("format:hex;"); break;
1563         case eFormatFloat:           response.PutCString ("format:float;"); break;
1564         case eFormatVectorOfSInt8:   response.PutCString ("format:vector-sint8;"); break;
1565         case eFormatVectorOfUInt8:   response.PutCString ("format:vector-uint8;"); break;
1566         case eFormatVectorOfSInt16:  response.PutCString ("format:vector-sint16;"); break;
1567         case eFormatVectorOfUInt16:  response.PutCString ("format:vector-uint16;"); break;
1568         case eFormatVectorOfSInt32:  response.PutCString ("format:vector-sint32;"); break;
1569         case eFormatVectorOfUInt32:  response.PutCString ("format:vector-uint32;"); break;
1570         case eFormatVectorOfFloat32: response.PutCString ("format:vector-float32;"); break;
1571         case eFormatVectorOfUInt128: response.PutCString ("format:vector-uint128;"); break;
1572         default: break;
1573     };
1574
1575     const char *const register_set_name = reg_context_sp->GetRegisterSetNameForRegisterAtIndex(reg_index);
1576     if (register_set_name)
1577     {
1578         response.PutCString ("set:");
1579         response.PutCString (register_set_name);
1580         response.PutChar (';');
1581     }
1582
1583     if (reg_info->kinds[RegisterKind::eRegisterKindEHFrame] != LLDB_INVALID_REGNUM)
1584         response.Printf ("ehframe:%" PRIu32 ";", reg_info->kinds[RegisterKind::eRegisterKindEHFrame]);
1585
1586     if (reg_info->kinds[RegisterKind::eRegisterKindDWARF] != LLDB_INVALID_REGNUM)
1587         response.Printf ("dwarf:%" PRIu32 ";", reg_info->kinds[RegisterKind::eRegisterKindDWARF]);
1588
1589     switch (reg_info->kinds[RegisterKind::eRegisterKindGeneric])
1590     {
1591         case LLDB_REGNUM_GENERIC_PC:     response.PutCString("generic:pc;"); break;
1592         case LLDB_REGNUM_GENERIC_SP:     response.PutCString("generic:sp;"); break;
1593         case LLDB_REGNUM_GENERIC_FP:     response.PutCString("generic:fp;"); break;
1594         case LLDB_REGNUM_GENERIC_RA:     response.PutCString("generic:ra;"); break;
1595         case LLDB_REGNUM_GENERIC_FLAGS:  response.PutCString("generic:flags;"); break;
1596         case LLDB_REGNUM_GENERIC_ARG1:   response.PutCString("generic:arg1;"); break;
1597         case LLDB_REGNUM_GENERIC_ARG2:   response.PutCString("generic:arg2;"); break;
1598         case LLDB_REGNUM_GENERIC_ARG3:   response.PutCString("generic:arg3;"); break;
1599         case LLDB_REGNUM_GENERIC_ARG4:   response.PutCString("generic:arg4;"); break;
1600         case LLDB_REGNUM_GENERIC_ARG5:   response.PutCString("generic:arg5;"); break;
1601         case LLDB_REGNUM_GENERIC_ARG6:   response.PutCString("generic:arg6;"); break;
1602         case LLDB_REGNUM_GENERIC_ARG7:   response.PutCString("generic:arg7;"); break;
1603         case LLDB_REGNUM_GENERIC_ARG8:   response.PutCString("generic:arg8;"); break;
1604         default: break;
1605     }
1606
1607     if (reg_info->value_regs && reg_info->value_regs[0] != LLDB_INVALID_REGNUM)
1608     {
1609         response.PutCString ("container-regs:");
1610         int i = 0;
1611         for (const uint32_t *reg_num = reg_info->value_regs; *reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i)
1612         {
1613             if (i > 0)
1614                 response.PutChar (',');
1615             response.Printf ("%" PRIx32, *reg_num);
1616         }
1617         response.PutChar (';');
1618     }
1619
1620     if (reg_info->invalidate_regs && reg_info->invalidate_regs[0])
1621     {
1622         response.PutCString ("invalidate-regs:");
1623         int i = 0;
1624         for (const uint32_t *reg_num = reg_info->invalidate_regs; *reg_num != LLDB_INVALID_REGNUM; ++reg_num, ++i)
1625         {
1626             if (i > 0)
1627                 response.PutChar (',');
1628             response.Printf ("%" PRIx32, *reg_num);
1629         }
1630         response.PutChar (';');
1631     }
1632
1633     return SendPacketNoLock(response.GetData(), response.GetSize());
1634 }
1635
1636 GDBRemoteCommunication::PacketResult
1637 GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo (StringExtractorGDBRemote &packet)
1638 {
1639     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
1640
1641     // Fail if we don't have a current process.
1642     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
1643     {
1644         if (log)
1645             log->Printf ("GDBRemoteCommunicationServerLLGS::%s() no process (%s), returning OK", __FUNCTION__, m_debugged_process_sp ? "invalid process id" : "null m_debugged_process_sp");
1646         return SendOKResponse ();
1647     }
1648
1649     StreamGDBRemote response;
1650     response.PutChar ('m');
1651
1652     if (log)
1653         log->Printf ("GDBRemoteCommunicationServerLLGS::%s() starting thread iteration", __FUNCTION__);
1654
1655     NativeThreadProtocolSP thread_sp;
1656     uint32_t thread_index;
1657     for (thread_index = 0, thread_sp = m_debugged_process_sp->GetThreadAtIndex (thread_index);
1658          thread_sp;
1659          ++thread_index, thread_sp = m_debugged_process_sp->GetThreadAtIndex (thread_index))
1660     {
1661         if (log)
1662             log->Printf ("GDBRemoteCommunicationServerLLGS::%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);
1663         if (thread_index > 0)
1664             response.PutChar(',');
1665         response.Printf ("%" PRIx64, thread_sp->GetID ());
1666     }
1667
1668     if (log)
1669         log->Printf ("GDBRemoteCommunicationServerLLGS::%s() finished thread iteration", __FUNCTION__);
1670
1671     return SendPacketNoLock(response.GetData(), response.GetSize());
1672 }
1673
1674 GDBRemoteCommunication::PacketResult
1675 GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo (StringExtractorGDBRemote &packet)
1676 {
1677     // FIXME for now we return the full thread list in the initial packet and always do nothing here.
1678     return SendPacketNoLock ("l", 1);
1679 }
1680
1681 GDBRemoteCommunication::PacketResult
1682 GDBRemoteCommunicationServerLLGS::Handle_p (StringExtractorGDBRemote &packet)
1683 {
1684     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
1685
1686     // Parse out the register number from the request.
1687     packet.SetFilePos (strlen("p"));
1688     const uint32_t reg_index = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ());
1689     if (reg_index == std::numeric_limits<uint32_t>::max ())
1690     {
1691         if (log)
1692             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, could not parse register number from request \"%s\"", __FUNCTION__, packet.GetStringRef ().c_str ());
1693         return SendErrorResponse (0x15);
1694     }
1695
1696     // Get the thread to use.
1697     NativeThreadProtocolSP thread_sp = GetThreadFromSuffix (packet);
1698     if (!thread_sp)
1699     {
1700         if (log)
1701             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no thread available", __FUNCTION__);
1702         return SendErrorResponse (0x15);
1703     }
1704
1705     // Get the thread's register context.
1706     NativeRegisterContextSP reg_context_sp (thread_sp->GetRegisterContext ());
1707     if (!reg_context_sp)
1708     {
1709         if (log)
1710             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 " failed, no register context available for the thread", __FUNCTION__, m_debugged_process_sp->GetID (), thread_sp->GetID ());
1711         return SendErrorResponse (0x15);
1712     }
1713
1714     // Return the end of registers response if we've iterated one past the end of the register set.
1715     if (reg_index >= reg_context_sp->GetUserRegisterCount ())
1716     {
1717         if (log)
1718             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, requested register %" PRIu32 " beyond register count %" PRIu32, __FUNCTION__, reg_index, reg_context_sp->GetUserRegisterCount ());
1719         return SendErrorResponse (0x15);
1720     }
1721
1722     const RegisterInfo *reg_info = reg_context_sp->GetRegisterInfoAtIndex(reg_index);
1723     if (!reg_info)
1724     {
1725         if (log)
1726             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, requested register %" PRIu32 " returned NULL", __FUNCTION__, reg_index);
1727         return SendErrorResponse (0x15);
1728     }
1729
1730     // Build the reginfos response.
1731     StreamGDBRemote response;
1732
1733     // Retrieve the value
1734     RegisterValue reg_value;
1735     Error error = reg_context_sp->ReadRegister (reg_info, reg_value);
1736     if (error.Fail ())
1737     {
1738         if (log)
1739             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, read of requested register %" PRIu32 " (%s) failed: %s", __FUNCTION__, reg_index, reg_info->name, error.AsCString ());
1740         return SendErrorResponse (0x15);
1741     }
1742
1743     const uint8_t *const data = reinterpret_cast<const uint8_t*> (reg_value.GetBytes ());
1744     if (!data)
1745     {
1746         if (log)
1747             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to get data bytes from requested register %" PRIu32, __FUNCTION__, reg_index);
1748         return SendErrorResponse (0x15);
1749     }
1750
1751     // FIXME flip as needed to get data in big/little endian format for this host.
1752     for (uint32_t i = 0; i < reg_value.GetByteSize (); ++i)
1753         response.PutHex8 (data[i]);
1754
1755     return SendPacketNoLock (response.GetData (), response.GetSize ());
1756 }
1757
1758 GDBRemoteCommunication::PacketResult
1759 GDBRemoteCommunicationServerLLGS::Handle_P (StringExtractorGDBRemote &packet)
1760 {
1761     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
1762
1763     // Ensure there is more content.
1764     if (packet.GetBytesLeft () < 1)
1765         return SendIllFormedResponse (packet, "Empty P packet");
1766
1767     // Parse out the register number from the request.
1768     packet.SetFilePos (strlen("P"));
1769     const uint32_t reg_index = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ());
1770     if (reg_index == std::numeric_limits<uint32_t>::max ())
1771     {
1772         if (log)
1773             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, could not parse register number from request \"%s\"", __FUNCTION__, packet.GetStringRef ().c_str ());
1774         return SendErrorResponse (0x29);
1775     }
1776
1777     // Note debugserver would send an E30 here.
1778     if ((packet.GetBytesLeft () < 1) || (packet.GetChar () != '='))
1779         return SendIllFormedResponse (packet, "P packet missing '=' char after register number");
1780
1781     // Get process architecture.
1782     ArchSpec process_arch;
1783     if (!m_debugged_process_sp || !m_debugged_process_sp->GetArchitecture (process_arch))
1784     {
1785         if (log)
1786             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to retrieve inferior architecture", __FUNCTION__);
1787         return SendErrorResponse (0x49);
1788     }
1789
1790     // Parse out the value.
1791     uint8_t reg_bytes[32]; // big enough to support up to 256 bit ymmN register
1792     size_t reg_size = packet.GetHexBytesAvail (reg_bytes, sizeof(reg_bytes));
1793
1794     // Get the thread to use.
1795     NativeThreadProtocolSP thread_sp = GetThreadFromSuffix (packet);
1796     if (!thread_sp)
1797     {
1798         if (log)
1799             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no thread available (thread index 0)", __FUNCTION__);
1800         return SendErrorResponse (0x28);
1801     }
1802
1803     // Get the thread's register context.
1804     NativeRegisterContextSP reg_context_sp (thread_sp->GetRegisterContext ());
1805     if (!reg_context_sp)
1806     {
1807         if (log)
1808             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 " failed, no register context available for the thread", __FUNCTION__, m_debugged_process_sp->GetID (), thread_sp->GetID ());
1809         return SendErrorResponse (0x15);
1810     }
1811
1812     const RegisterInfo *reg_info = reg_context_sp->GetRegisterInfoAtIndex (reg_index);
1813     if (!reg_info)
1814     {
1815         if (log)
1816             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, requested register %" PRIu32 " returned NULL", __FUNCTION__, reg_index);
1817         return SendErrorResponse (0x48);
1818     }
1819
1820     // Return the end of registers response if we've iterated one past the end of the register set.
1821     if (reg_index >= reg_context_sp->GetUserRegisterCount ())
1822     {
1823         if (log)
1824             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, requested register %" PRIu32 " beyond register count %" PRIu32, __FUNCTION__, reg_index, reg_context_sp->GetUserRegisterCount ());
1825         return SendErrorResponse (0x47);
1826     }
1827
1828     if (reg_size != reg_info->byte_size)
1829     {
1830         return SendIllFormedResponse (packet, "P packet register size is incorrect");
1831     }
1832
1833     // Build the reginfos response.
1834     StreamGDBRemote response;
1835
1836     RegisterValue reg_value (reg_bytes, reg_size, process_arch.GetByteOrder ());
1837     Error error = reg_context_sp->WriteRegister (reg_info, reg_value);
1838     if (error.Fail ())
1839     {
1840         if (log)
1841             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, write of requested register %" PRIu32 " (%s) failed: %s", __FUNCTION__, reg_index, reg_info->name, error.AsCString ());
1842         return SendErrorResponse (0x32);
1843     }
1844
1845     return SendOKResponse();
1846 }
1847
1848 GDBRemoteCommunication::PacketResult
1849 GDBRemoteCommunicationServerLLGS::Handle_H (StringExtractorGDBRemote &packet)
1850 {
1851     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
1852
1853     // Fail if we don't have a current process.
1854     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
1855     {
1856         if (log)
1857             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__);
1858         return SendErrorResponse (0x15);
1859     }
1860
1861     // Parse out which variant of $H is requested.
1862     packet.SetFilePos (strlen("H"));
1863     if (packet.GetBytesLeft () < 1)
1864     {
1865         if (log)
1866             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, H command missing {g,c} variant", __FUNCTION__);
1867         return SendIllFormedResponse (packet, "H command missing {g,c} variant");
1868     }
1869
1870     const char h_variant = packet.GetChar ();
1871     switch (h_variant)
1872     {
1873         case 'g':
1874             break;
1875
1876         case 'c':
1877             break;
1878
1879         default:
1880             if (log)
1881                 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, invalid $H variant %c", __FUNCTION__, h_variant);
1882             return SendIllFormedResponse (packet, "H variant unsupported, should be c or g");
1883     }
1884
1885     // Parse out the thread number.
1886     // FIXME return a parse success/fail value.  All values are valid here.
1887     const lldb::tid_t tid = packet.GetHexMaxU64 (false, std::numeric_limits<lldb::tid_t>::max ());
1888
1889     // Ensure we have the given thread when not specifying -1 (all threads) or 0 (any thread).
1890     if (tid != LLDB_INVALID_THREAD_ID && tid != 0)
1891     {
1892         NativeThreadProtocolSP thread_sp (m_debugged_process_sp->GetThreadByID (tid));
1893         if (!thread_sp)
1894         {
1895             if (log)
1896                 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, tid %" PRIu64 " not found", __FUNCTION__, tid);
1897             return SendErrorResponse (0x15);
1898         }
1899     }
1900
1901     // Now switch the given thread type.
1902     switch (h_variant)
1903     {
1904         case 'g':
1905             SetCurrentThreadID (tid);
1906             break;
1907
1908         case 'c':
1909             SetContinueThreadID (tid);
1910             break;
1911
1912         default:
1913             assert (false && "unsupported $H variant - shouldn't get here");
1914             return SendIllFormedResponse (packet, "H variant unsupported, should be c or g");
1915     }
1916
1917     return SendOKResponse();
1918 }
1919
1920 GDBRemoteCommunication::PacketResult
1921 GDBRemoteCommunicationServerLLGS::Handle_I (StringExtractorGDBRemote &packet)
1922 {
1923     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
1924
1925     // Fail if we don't have a current process.
1926     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
1927     {
1928         if (log)
1929             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__);
1930         return SendErrorResponse (0x15);
1931     }
1932
1933     packet.SetFilePos (::strlen("I"));
1934     char tmp[4096];
1935     for (;;)
1936     {
1937         size_t read = packet.GetHexBytesAvail(tmp, sizeof(tmp));
1938         if (read == 0)
1939         {
1940             break;
1941         }
1942         // write directly to stdin *this might block if stdin buffer is full*
1943         // TODO: enqueue this block in circular buffer and send window size to remote host
1944         ConnectionStatus status;
1945         Error error;
1946         m_stdio_communication.Write(tmp, read, status, &error);
1947         if (error.Fail())
1948         {
1949             return SendErrorResponse (0x15);
1950         }
1951     }
1952
1953     return SendOKResponse();
1954 }
1955
1956 GDBRemoteCommunication::PacketResult
1957 GDBRemoteCommunicationServerLLGS::Handle_interrupt (StringExtractorGDBRemote &packet)
1958 {
1959     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
1960
1961     // Fail if we don't have a current process.
1962     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
1963     {
1964         if (log)
1965             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__);
1966         return SendErrorResponse (0x15);
1967     }
1968
1969     // Interrupt the process.
1970     Error error = m_debugged_process_sp->Interrupt ();
1971     if (error.Fail ())
1972     {
1973         if (log)
1974         {
1975             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed for process %" PRIu64 ": %s",
1976                          __FUNCTION__,
1977                          m_debugged_process_sp->GetID (),
1978                          error.AsCString ());
1979         }
1980         return SendErrorResponse (GDBRemoteServerError::eErrorResume);
1981     }
1982
1983     if (log)
1984         log->Printf ("GDBRemoteCommunicationServerLLGS::%s stopped process %" PRIu64, __FUNCTION__, m_debugged_process_sp->GetID ());
1985
1986     // No response required from stop all.
1987     return PacketResult::Success;
1988 }
1989
1990 GDBRemoteCommunication::PacketResult
1991 GDBRemoteCommunicationServerLLGS::Handle_memory_read(StringExtractorGDBRemote &packet)
1992 {
1993     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
1994
1995     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
1996     {
1997         if (log)
1998             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__);
1999         return SendErrorResponse (0x15);
2000     }
2001
2002     // Parse out the memory address.
2003     packet.SetFilePos (strlen("m"));
2004     if (packet.GetBytesLeft() < 1)
2005         return SendIllFormedResponse(packet, "Too short m packet");
2006
2007     // Read the address.  Punting on validation.
2008     // FIXME replace with Hex U64 read with no default value that fails on failed read.
2009     const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0);
2010
2011     // Validate comma.
2012     if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ','))
2013         return SendIllFormedResponse(packet, "Comma sep missing in m packet");
2014
2015     // Get # bytes to read.
2016     if (packet.GetBytesLeft() < 1)
2017         return SendIllFormedResponse(packet, "Length missing in m packet");
2018
2019     const uint64_t byte_count = packet.GetHexMaxU64(false, 0);
2020     if (byte_count == 0)
2021     {
2022         if (log)
2023             log->Printf ("GDBRemoteCommunicationServerLLGS::%s nothing to read: zero-length packet", __FUNCTION__);
2024         return SendOKResponse();
2025     }
2026
2027     // Allocate the response buffer.
2028     std::string buf(byte_count, '\0');
2029     if (buf.empty())
2030         return SendErrorResponse (0x78);
2031
2032
2033     // Retrieve the process memory.
2034     size_t bytes_read = 0;
2035     Error error = m_debugged_process_sp->ReadMemoryWithoutTrap(read_addr, &buf[0], byte_count, bytes_read);
2036     if (error.Fail ())
2037     {
2038         if (log)
2039             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " mem 0x%" PRIx64 ": failed to read. Error: %s", __FUNCTION__, m_debugged_process_sp->GetID (), read_addr, error.AsCString ());
2040         return SendErrorResponse (0x08);
2041     }
2042
2043     if (bytes_read == 0)
2044     {
2045         if (log)
2046             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " mem 0x%" PRIx64 ": read 0 of %" PRIu64 " requested bytes", __FUNCTION__, m_debugged_process_sp->GetID (), read_addr, byte_count);
2047         return SendErrorResponse (0x08);
2048     }
2049
2050     StreamGDBRemote response;
2051     packet.SetFilePos(0);
2052     char kind = packet.GetChar('?');
2053     if (kind == 'x')
2054         response.PutEscapedBytes(buf.data(), byte_count);
2055     else
2056     {
2057         assert(kind == 'm');
2058         for (size_t i = 0; i < bytes_read; ++i)
2059             response.PutHex8(buf[i]);
2060     }
2061
2062     return SendPacketNoLock(response.GetData(), response.GetSize());
2063 }
2064
2065 GDBRemoteCommunication::PacketResult
2066 GDBRemoteCommunicationServerLLGS::Handle_M (StringExtractorGDBRemote &packet)
2067 {
2068     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
2069
2070     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
2071     {
2072         if (log)
2073             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__);
2074         return SendErrorResponse (0x15);
2075     }
2076
2077     // Parse out the memory address.
2078     packet.SetFilePos (strlen("M"));
2079     if (packet.GetBytesLeft() < 1)
2080         return SendIllFormedResponse(packet, "Too short M packet");
2081
2082     // Read the address.  Punting on validation.
2083     // FIXME replace with Hex U64 read with no default value that fails on failed read.
2084     const lldb::addr_t write_addr = packet.GetHexMaxU64(false, 0);
2085
2086     // Validate comma.
2087     if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ','))
2088         return SendIllFormedResponse(packet, "Comma sep missing in M packet");
2089
2090     // Get # bytes to read.
2091     if (packet.GetBytesLeft() < 1)
2092         return SendIllFormedResponse(packet, "Length missing in M packet");
2093
2094     const uint64_t byte_count = packet.GetHexMaxU64(false, 0);
2095     if (byte_count == 0)
2096     {
2097         if (log)
2098             log->Printf ("GDBRemoteCommunicationServerLLGS::%s nothing to write: zero-length packet", __FUNCTION__);
2099         return PacketResult::Success;
2100     }
2101
2102     // Validate colon.
2103     if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ':'))
2104         return SendIllFormedResponse(packet, "Comma sep missing in M packet after byte length");
2105
2106     // Allocate the conversion buffer.
2107     std::vector<uint8_t> buf(byte_count, 0);
2108     if (buf.empty())
2109         return SendErrorResponse (0x78);
2110
2111     // Convert the hex memory write contents to bytes.
2112     StreamGDBRemote response;
2113     const uint64_t convert_count = packet.GetHexBytes(&buf[0], byte_count, 0);
2114     if (convert_count != byte_count)
2115     {
2116         if (log)
2117             log->Printf ("GDBRemoteCommunicationServerLLGS::%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);
2118         return SendIllFormedResponse (packet, "M content byte length specified did not match hex-encoded content length");
2119     }
2120
2121     // Write the process memory.
2122     size_t bytes_written = 0;
2123     Error error = m_debugged_process_sp->WriteMemory (write_addr, &buf[0], byte_count, bytes_written);
2124     if (error.Fail ())
2125     {
2126         if (log)
2127             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " mem 0x%" PRIx64 ": failed to write. Error: %s", __FUNCTION__, m_debugged_process_sp->GetID (), write_addr, error.AsCString ());
2128         return SendErrorResponse (0x09);
2129     }
2130
2131     if (bytes_written == 0)
2132     {
2133         if (log)
2134             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " mem 0x%" PRIx64 ": wrote 0 of %" PRIu64 " requested bytes", __FUNCTION__, m_debugged_process_sp->GetID (), write_addr, byte_count);
2135         return SendErrorResponse (0x09);
2136     }
2137
2138     return SendOKResponse ();
2139 }
2140
2141 GDBRemoteCommunication::PacketResult
2142 GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported (StringExtractorGDBRemote &packet)
2143 {
2144     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
2145
2146     // Currently only the NativeProcessProtocol knows if it can handle a qMemoryRegionInfoSupported
2147     // request, but we're not guaranteed to be attached to a process.  For now we'll assume the
2148     // client only asks this when a process is being debugged.
2149
2150     // Ensure we have a process running; otherwise, we can't figure this out
2151     // since we won't have a NativeProcessProtocol.
2152     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
2153     {
2154         if (log)
2155             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__);
2156         return SendErrorResponse (0x15);
2157     }
2158
2159     // Test if we can get any region back when asking for the region around NULL.
2160     MemoryRegionInfo region_info;
2161     const Error error = m_debugged_process_sp->GetMemoryRegionInfo (0, region_info);
2162     if (error.Fail ())
2163     {
2164         // We don't support memory region info collection for this NativeProcessProtocol.
2165         return SendUnimplementedResponse ("");
2166     }
2167
2168     return SendOKResponse();
2169 }
2170
2171 GDBRemoteCommunication::PacketResult
2172 GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo (StringExtractorGDBRemote &packet)
2173 {
2174     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
2175
2176     // Ensure we have a process.
2177     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
2178     {
2179         if (log)
2180             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__);
2181         return SendErrorResponse (0x15);
2182     }
2183
2184     // Parse out the memory address.
2185     packet.SetFilePos (strlen("qMemoryRegionInfo:"));
2186     if (packet.GetBytesLeft() < 1)
2187         return SendIllFormedResponse(packet, "Too short qMemoryRegionInfo: packet");
2188
2189     // Read the address.  Punting on validation.
2190     const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0);
2191
2192     StreamGDBRemote response;
2193
2194     // Get the memory region info for the target address.
2195     MemoryRegionInfo region_info;
2196     const Error error = m_debugged_process_sp->GetMemoryRegionInfo (read_addr, region_info);
2197     if (error.Fail ())
2198     {
2199         // Return the error message.
2200
2201         response.PutCString ("error:");
2202         response.PutCStringAsRawHex8 (error.AsCString ());
2203         response.PutChar (';');
2204     }
2205     else
2206     {
2207         // Range start and size.
2208         response.Printf ("start:%" PRIx64 ";size:%" PRIx64 ";", region_info.GetRange ().GetRangeBase (), region_info.GetRange ().GetByteSize ());
2209
2210         // Permissions.
2211         if (region_info.GetReadable () ||
2212             region_info.GetWritable () ||
2213             region_info.GetExecutable ())
2214         {
2215             // Write permissions info.
2216             response.PutCString ("permissions:");
2217
2218             if (region_info.GetReadable ())
2219                 response.PutChar ('r');
2220             if (region_info.GetWritable ())
2221                 response.PutChar('w');
2222             if (region_info.GetExecutable())
2223                 response.PutChar ('x');
2224
2225             response.PutChar (';');
2226         }
2227     }
2228
2229     return SendPacketNoLock(response.GetData(), response.GetSize());
2230 }
2231
2232 GDBRemoteCommunication::PacketResult
2233 GDBRemoteCommunicationServerLLGS::Handle_Z (StringExtractorGDBRemote &packet)
2234 {
2235     // Ensure we have a process.
2236     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
2237     {
2238         Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
2239         if (log)
2240             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__);
2241         return SendErrorResponse (0x15);
2242     }
2243
2244     // Parse out software or hardware breakpoint or watchpoint requested.
2245     packet.SetFilePos (strlen("Z"));
2246     if (packet.GetBytesLeft() < 1)
2247         return SendIllFormedResponse(packet, "Too short Z packet, missing software/hardware specifier");
2248
2249     bool want_breakpoint = true;
2250     bool want_hardware = false;
2251     uint32_t watch_flags = 0;
2252
2253     const GDBStoppointType stoppoint_type =
2254         GDBStoppointType(packet.GetS32 (eStoppointInvalid));
2255     switch (stoppoint_type)
2256     {
2257         case eBreakpointSoftware:
2258             want_hardware = false; want_breakpoint = true;  break;
2259         case eBreakpointHardware:
2260             want_hardware = true;  want_breakpoint = true;  break;
2261         case eWatchpointWrite:
2262             watch_flags = 1;
2263             want_hardware = true;  want_breakpoint = false; break;
2264         case eWatchpointRead:
2265             watch_flags = 2;
2266             want_hardware = true;  want_breakpoint = false; break;
2267         case eWatchpointReadWrite:
2268             watch_flags = 3;
2269             want_hardware = true;  want_breakpoint = false; break;
2270         case eStoppointInvalid:
2271             return SendIllFormedResponse(packet, "Z packet had invalid software/hardware specifier");
2272
2273     }
2274
2275     if ((packet.GetBytesLeft() < 1) || packet.GetChar () != ',')
2276         return SendIllFormedResponse(packet, "Malformed Z packet, expecting comma after stoppoint type");
2277
2278     // Parse out the stoppoint address.
2279     if (packet.GetBytesLeft() < 1)
2280         return SendIllFormedResponse(packet, "Too short Z packet, missing address");
2281     const lldb::addr_t addr = packet.GetHexMaxU64(false, 0);
2282
2283     if ((packet.GetBytesLeft() < 1) || packet.GetChar () != ',')
2284         return SendIllFormedResponse(packet, "Malformed Z packet, expecting comma after address");
2285
2286     // Parse out the stoppoint size (i.e. size hint for opcode size).
2287     const uint32_t size = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ());
2288     if (size == std::numeric_limits<uint32_t>::max ())
2289         return SendIllFormedResponse(packet, "Malformed Z packet, failed to parse size argument");
2290
2291     if (want_breakpoint)
2292     {
2293         // Try to set the breakpoint.
2294         const Error error = m_debugged_process_sp->SetBreakpoint (addr, size, want_hardware);
2295         if (error.Success ())
2296             return SendOKResponse ();
2297         Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
2298         if (log)
2299             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
2300                     " failed to set breakpoint: %s",
2301                     __FUNCTION__,
2302                     m_debugged_process_sp->GetID (),
2303                     error.AsCString ());
2304         return SendErrorResponse (0x09);
2305     }
2306     else
2307     {
2308         // Try to set the watchpoint.
2309         const Error error = m_debugged_process_sp->SetWatchpoint (
2310                 addr, size, watch_flags, want_hardware);
2311         if (error.Success ())
2312             return SendOKResponse ();
2313         Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
2314         if (log)
2315             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
2316                     " failed to set watchpoint: %s",
2317                     __FUNCTION__,
2318                     m_debugged_process_sp->GetID (),
2319                     error.AsCString ());
2320         return SendErrorResponse (0x09);
2321     }
2322 }
2323
2324 GDBRemoteCommunication::PacketResult
2325 GDBRemoteCommunicationServerLLGS::Handle_z (StringExtractorGDBRemote &packet)
2326 {
2327     // Ensure we have a process.
2328     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
2329     {
2330         Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
2331         if (log)
2332             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__);
2333         return SendErrorResponse (0x15);
2334     }
2335
2336     // Parse out software or hardware breakpoint or watchpoint requested.
2337     packet.SetFilePos (strlen("z"));
2338     if (packet.GetBytesLeft() < 1)
2339         return SendIllFormedResponse(packet, "Too short z packet, missing software/hardware specifier");
2340
2341     bool want_breakpoint = true;
2342
2343     const GDBStoppointType stoppoint_type =
2344         GDBStoppointType(packet.GetS32 (eStoppointInvalid));
2345     switch (stoppoint_type)
2346     {
2347         case eBreakpointHardware:  want_breakpoint = true;  break;
2348         case eBreakpointSoftware:  want_breakpoint = true;  break;
2349         case eWatchpointWrite:     want_breakpoint = false; break;
2350         case eWatchpointRead:      want_breakpoint = false; break;
2351         case eWatchpointReadWrite: want_breakpoint = false; break;
2352         default:
2353             return SendIllFormedResponse(packet, "z packet had invalid software/hardware specifier");
2354
2355     }
2356
2357     if ((packet.GetBytesLeft() < 1) || packet.GetChar () != ',')
2358         return SendIllFormedResponse(packet, "Malformed z packet, expecting comma after stoppoint type");
2359
2360     // Parse out the stoppoint address.
2361     if (packet.GetBytesLeft() < 1)
2362         return SendIllFormedResponse(packet, "Too short z packet, missing address");
2363     const lldb::addr_t addr = packet.GetHexMaxU64(false, 0);
2364
2365     if ((packet.GetBytesLeft() < 1) || packet.GetChar () != ',')
2366         return SendIllFormedResponse(packet, "Malformed z packet, expecting comma after address");
2367
2368     /*
2369     // Parse out the stoppoint size (i.e. size hint for opcode size).
2370     const uint32_t size = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ());
2371     if (size == std::numeric_limits<uint32_t>::max ())
2372         return SendIllFormedResponse(packet, "Malformed z packet, failed to parse size argument");
2373     */
2374
2375     if (want_breakpoint)
2376     {
2377         // Try to clear the breakpoint.
2378         const Error error = m_debugged_process_sp->RemoveBreakpoint (addr);
2379         if (error.Success ())
2380             return SendOKResponse ();
2381         Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
2382         if (log)
2383             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
2384                     " failed to remove breakpoint: %s",
2385                     __FUNCTION__,
2386                     m_debugged_process_sp->GetID (),
2387                     error.AsCString ());
2388         return SendErrorResponse (0x09);
2389     }
2390     else
2391     {
2392         // Try to clear the watchpoint.
2393         const Error error = m_debugged_process_sp->RemoveWatchpoint (addr);
2394         if (error.Success ())
2395             return SendOKResponse ();
2396         Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
2397         if (log)
2398             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
2399                     " failed to remove watchpoint: %s",
2400                     __FUNCTION__,
2401                     m_debugged_process_sp->GetID (),
2402                     error.AsCString ());
2403         return SendErrorResponse (0x09);
2404     }
2405 }
2406
2407 GDBRemoteCommunication::PacketResult
2408 GDBRemoteCommunicationServerLLGS::Handle_s (StringExtractorGDBRemote &packet)
2409 {
2410     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS|LIBLLDB_LOG_THREAD));
2411
2412     // Ensure we have a process.
2413     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
2414     {
2415         if (log)
2416             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__);
2417         return SendErrorResponse (0x32);
2418     }
2419
2420     // We first try to use a continue thread id.  If any one or any all set, use the current thread.
2421     // Bail out if we don't have a thread id.
2422     lldb::tid_t tid = GetContinueThreadID ();
2423     if (tid == 0 || tid == LLDB_INVALID_THREAD_ID)
2424         tid = GetCurrentThreadID ();
2425     if (tid == LLDB_INVALID_THREAD_ID)
2426         return SendErrorResponse (0x33);
2427
2428     // Double check that we have such a thread.
2429     // TODO investigate: on MacOSX we might need to do an UpdateThreads () here.
2430     NativeThreadProtocolSP thread_sp = m_debugged_process_sp->GetThreadByID (tid);
2431     if (!thread_sp || thread_sp->GetID () != tid)
2432         return SendErrorResponse (0x33);
2433
2434     // Create the step action for the given thread.
2435     ResumeAction action = { tid, eStateStepping, 0 };
2436
2437     // Setup the actions list.
2438     ResumeActionList actions;
2439     actions.Append (action);
2440
2441     // All other threads stop while we're single stepping a thread.
2442     actions.SetDefaultThreadActionIfNeeded(eStateStopped, 0);
2443     Error error = m_debugged_process_sp->Resume (actions);
2444     if (error.Fail ())
2445     {
2446         if (log)
2447             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 " Resume() failed with error: %s", __FUNCTION__, m_debugged_process_sp->GetID (), tid, error.AsCString ());
2448         return SendErrorResponse(0x49);
2449     }
2450
2451     // No response here - the stop or exit will come from the resulting action.
2452     return PacketResult::Success;
2453 }
2454
2455 GDBRemoteCommunication::PacketResult
2456 GDBRemoteCommunicationServerLLGS::Handle_qXfer_auxv_read (StringExtractorGDBRemote &packet)
2457 {
2458     // *BSD impls should be able to do this too.
2459 #if defined(__linux__)
2460     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
2461
2462     // Parse out the offset.
2463     packet.SetFilePos (strlen("qXfer:auxv:read::"));
2464     if (packet.GetBytesLeft () < 1)
2465         return SendIllFormedResponse (packet, "qXfer:auxv:read:: packet missing offset");
2466
2467     const uint64_t auxv_offset = packet.GetHexMaxU64 (false, std::numeric_limits<uint64_t>::max ());
2468     if (auxv_offset == std::numeric_limits<uint64_t>::max ())
2469         return SendIllFormedResponse (packet, "qXfer:auxv:read:: packet missing offset");
2470
2471     // Parse out comma.
2472     if (packet.GetBytesLeft () < 1 || packet.GetChar () != ',')
2473         return SendIllFormedResponse (packet, "qXfer:auxv:read:: packet missing comma after offset");
2474
2475     // Parse out the length.
2476     const uint64_t auxv_length = packet.GetHexMaxU64 (false, std::numeric_limits<uint64_t>::max ());
2477     if (auxv_length == std::numeric_limits<uint64_t>::max ())
2478         return SendIllFormedResponse (packet, "qXfer:auxv:read:: packet missing length");
2479
2480     // Grab the auxv data if we need it.
2481     if (!m_active_auxv_buffer_sp)
2482     {
2483         // Make sure we have a valid process.
2484         if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
2485         {
2486             if (log)
2487                 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__);
2488             return SendErrorResponse (0x10);
2489         }
2490
2491         // Grab the auxv data.
2492         m_active_auxv_buffer_sp = Host::GetAuxvData (m_debugged_process_sp->GetID ());
2493         if (!m_active_auxv_buffer_sp || m_active_auxv_buffer_sp->GetByteSize () ==  0)
2494         {
2495             // Hmm, no auxv data, call that an error.
2496             if (log)
2497                 log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no auxv data retrieved", __FUNCTION__);
2498             m_active_auxv_buffer_sp.reset ();
2499             return SendErrorResponse (0x11);
2500         }
2501     }
2502
2503     // FIXME find out if/how I lock the stream here.
2504
2505     StreamGDBRemote response;
2506     bool done_with_buffer = false;
2507
2508     if (auxv_offset >= m_active_auxv_buffer_sp->GetByteSize ())
2509     {
2510         // We have nothing left to send.  Mark the buffer as complete.
2511         response.PutChar ('l');
2512         done_with_buffer = true;
2513     }
2514     else
2515     {
2516         // Figure out how many bytes are available starting at the given offset.
2517         const uint64_t bytes_remaining = m_active_auxv_buffer_sp->GetByteSize () - auxv_offset;
2518
2519         // Figure out how many bytes we're going to read.
2520         const uint64_t bytes_to_read = (auxv_length > bytes_remaining) ? bytes_remaining : auxv_length;
2521
2522         // Mark the response type according to whether we're reading the remainder of the auxv data.
2523         if (bytes_to_read >= bytes_remaining)
2524         {
2525             // There will be nothing left to read after this
2526             response.PutChar ('l');
2527             done_with_buffer = true;
2528         }
2529         else
2530         {
2531             // There will still be bytes to read after this request.
2532             response.PutChar ('m');
2533         }
2534
2535         // Now write the data in encoded binary form.
2536         response.PutEscapedBytes (m_active_auxv_buffer_sp->GetBytes () + auxv_offset, bytes_to_read);
2537     }
2538
2539     if (done_with_buffer)
2540         m_active_auxv_buffer_sp.reset ();
2541
2542     return SendPacketNoLock(response.GetData(), response.GetSize());
2543 #else
2544     return SendUnimplementedResponse ("not implemented on this platform");
2545 #endif
2546 }
2547
2548 GDBRemoteCommunication::PacketResult
2549 GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState (StringExtractorGDBRemote &packet)
2550 {
2551     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
2552
2553     // Move past packet name.
2554     packet.SetFilePos (strlen ("QSaveRegisterState"));
2555
2556     // Get the thread to use.
2557     NativeThreadProtocolSP thread_sp = GetThreadFromSuffix (packet);
2558     if (!thread_sp)
2559     {
2560         if (m_thread_suffix_supported)
2561             return SendIllFormedResponse (packet, "No thread specified in QSaveRegisterState packet");
2562         else
2563             return SendIllFormedResponse (packet, "No thread was is set with the Hg packet");
2564     }
2565
2566     // Grab the register context for the thread.
2567     NativeRegisterContextSP reg_context_sp (thread_sp->GetRegisterContext ());
2568     if (!reg_context_sp)
2569     {
2570         if (log)
2571             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 " failed, no register context available for the thread", __FUNCTION__, m_debugged_process_sp->GetID (), thread_sp->GetID ());
2572         return SendErrorResponse (0x15);
2573     }
2574
2575     // Save registers to a buffer.
2576     DataBufferSP register_data_sp;
2577     Error error = reg_context_sp->ReadAllRegisterValues (register_data_sp);
2578     if (error.Fail ())
2579     {
2580         if (log)
2581             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " failed to save all register values: %s", __FUNCTION__, m_debugged_process_sp->GetID (), error.AsCString ());
2582         return SendErrorResponse (0x75);
2583     }
2584
2585     // Allocate a new save id.
2586     const uint32_t save_id = GetNextSavedRegistersID ();
2587     assert ((m_saved_registers_map.find (save_id) == m_saved_registers_map.end ()) && "GetNextRegisterSaveID() returned an existing register save id");
2588
2589     // Save the register data buffer under the save id.
2590     {
2591         std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
2592         m_saved_registers_map[save_id] = register_data_sp;
2593     }
2594
2595     // Write the response.
2596     StreamGDBRemote response;
2597     response.Printf ("%" PRIu32, save_id);
2598     return SendPacketNoLock(response.GetData(), response.GetSize());
2599 }
2600
2601 GDBRemoteCommunication::PacketResult
2602 GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState (StringExtractorGDBRemote &packet)
2603 {
2604     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
2605
2606     // Parse out save id.
2607     packet.SetFilePos (strlen ("QRestoreRegisterState:"));
2608     if (packet.GetBytesLeft () < 1)
2609         return SendIllFormedResponse (packet, "QRestoreRegisterState packet missing register save id");
2610
2611     const uint32_t save_id = packet.GetU32 (0);
2612     if (save_id == 0)
2613     {
2614         if (log)
2615             log->Printf ("GDBRemoteCommunicationServerLLGS::%s QRestoreRegisterState packet has malformed save id, expecting decimal uint32_t", __FUNCTION__);
2616         return SendErrorResponse (0x76);
2617     }
2618
2619     // Get the thread to use.
2620     NativeThreadProtocolSP thread_sp = GetThreadFromSuffix (packet);
2621     if (!thread_sp)
2622     {
2623         if (m_thread_suffix_supported)
2624             return SendIllFormedResponse (packet, "No thread specified in QRestoreRegisterState packet");
2625         else
2626             return SendIllFormedResponse (packet, "No thread was is set with the Hg packet");
2627     }
2628
2629     // Grab the register context for the thread.
2630     NativeRegisterContextSP reg_context_sp (thread_sp->GetRegisterContext ());
2631     if (!reg_context_sp)
2632     {
2633         if (log)
2634             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " tid %" PRIu64 " failed, no register context available for the thread", __FUNCTION__, m_debugged_process_sp->GetID (), thread_sp->GetID ());
2635         return SendErrorResponse (0x15);
2636     }
2637
2638     // Retrieve register state buffer, then remove from the list.
2639     DataBufferSP register_data_sp;
2640     {
2641         std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
2642
2643         // Find the register set buffer for the given save id.
2644         auto it = m_saved_registers_map.find (save_id);
2645         if (it == m_saved_registers_map.end ())
2646         {
2647             if (log)
2648                 log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " does not have a register set save buffer for id %" PRIu32, __FUNCTION__, m_debugged_process_sp->GetID (), save_id);
2649             return SendErrorResponse (0x77);
2650         }
2651         register_data_sp = it->second;
2652
2653         // Remove it from the map.
2654         m_saved_registers_map.erase (it);
2655     }
2656
2657     Error error = reg_context_sp->WriteAllRegisterValues (register_data_sp);
2658     if (error.Fail ())
2659     {
2660         if (log)
2661             log->Printf ("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64 " failed to restore all register values: %s", __FUNCTION__, m_debugged_process_sp->GetID (), error.AsCString ());
2662         return SendErrorResponse (0x77);
2663     }
2664
2665     return SendOKResponse();
2666 }
2667
2668 GDBRemoteCommunication::PacketResult
2669 GDBRemoteCommunicationServerLLGS::Handle_vAttach (StringExtractorGDBRemote &packet)
2670 {
2671     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
2672
2673     // Consume the ';' after vAttach.
2674     packet.SetFilePos (strlen ("vAttach"));
2675     if (!packet.GetBytesLeft () || packet.GetChar () != ';')
2676         return SendIllFormedResponse (packet, "vAttach missing expected ';'");
2677
2678     // Grab the PID to which we will attach (assume hex encoding).
2679     lldb::pid_t pid = packet.GetU32 (LLDB_INVALID_PROCESS_ID, 16);
2680     if (pid == LLDB_INVALID_PROCESS_ID)
2681         return SendIllFormedResponse (packet, "vAttach failed to parse the process id");
2682
2683     // Attempt to attach.
2684     if (log)
2685         log->Printf ("GDBRemoteCommunicationServerLLGS::%s attempting to attach to pid %" PRIu64, __FUNCTION__, pid);
2686
2687     Error error = AttachToProcess (pid);
2688
2689     if (error.Fail ())
2690     {
2691         if (log)
2692             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to attach to pid %" PRIu64 ": %s\n", __FUNCTION__, pid, error.AsCString());
2693         return SendErrorResponse (0x01);
2694     }
2695
2696     // Notify we attached by sending a stop packet.
2697     return SendStopReasonForState (m_debugged_process_sp->GetState ());
2698 }
2699
2700 GDBRemoteCommunication::PacketResult
2701 GDBRemoteCommunicationServerLLGS::Handle_D (StringExtractorGDBRemote &packet)
2702 {
2703     Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS));
2704
2705     StopSTDIOForwarding();
2706
2707     // Fail if we don't have a current process.
2708     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
2709     {
2710         if (log)
2711             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, no process available", __FUNCTION__);
2712         return SendErrorResponse (0x15);
2713     }
2714
2715     lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
2716
2717     // Consume the ';' after D.
2718     packet.SetFilePos (1);
2719     if (packet.GetBytesLeft ())
2720     {
2721         if (packet.GetChar () != ';')
2722             return SendIllFormedResponse (packet, "D missing expected ';'");
2723
2724         // Grab the PID from which we will detach (assume hex encoding).
2725         pid = packet.GetU32 (LLDB_INVALID_PROCESS_ID, 16);
2726         if (pid == LLDB_INVALID_PROCESS_ID)
2727             return SendIllFormedResponse (packet, "D failed to parse the process id");
2728     }
2729
2730     if (pid != LLDB_INVALID_PROCESS_ID &&
2731         m_debugged_process_sp->GetID () != pid)
2732     {
2733         return SendIllFormedResponse (packet, "Invalid pid");
2734     }
2735
2736     const Error error = m_debugged_process_sp->Detach ();
2737     if (error.Fail ())
2738     {
2739         if (log)
2740             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to detach from pid %" PRIu64 ": %s\n",
2741                          __FUNCTION__, m_debugged_process_sp->GetID (), error.AsCString ());
2742         return SendErrorResponse (0x01);
2743     }
2744
2745     return SendOKResponse ();
2746 }
2747
2748 GDBRemoteCommunication::PacketResult
2749 GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo (StringExtractorGDBRemote &packet)
2750 {
2751     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
2752
2753     packet.SetFilePos (strlen("qThreadStopInfo"));
2754     const lldb::tid_t tid = packet.GetHexMaxU32 (false, LLDB_INVALID_THREAD_ID);
2755     if (tid == LLDB_INVALID_THREAD_ID)
2756     {
2757         if (log)
2758             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, could not parse thread id from request \"%s\"", __FUNCTION__, packet.GetStringRef ().c_str ());
2759         return SendErrorResponse (0x15);
2760     }
2761     return SendStopReplyPacketForThread (tid);
2762 }
2763
2764 GDBRemoteCommunication::PacketResult
2765 GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo (StringExtractorGDBRemote &)
2766 {
2767     Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_PROCESS | LIBLLDB_LOG_THREAD));
2768
2769     // Ensure we have a debugged process.
2770     if (!m_debugged_process_sp || (m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID))
2771         return SendErrorResponse (50);
2772
2773     if (log)
2774         log->Printf ("GDBRemoteCommunicationServerLLGS::%s preparing packet for pid %" PRIu64,
2775                 __FUNCTION__, m_debugged_process_sp->GetID());
2776
2777
2778     StreamString response;
2779     const bool threads_with_valid_stop_info_only = false;
2780     JSONArray::SP threads_array_sp = GetJSONThreadsInfo(*m_debugged_process_sp,
2781                                                         threads_with_valid_stop_info_only);
2782     if (! threads_array_sp)
2783     {
2784         if (log)
2785             log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed to prepare a packet for pid %" PRIu64,
2786                     __FUNCTION__, m_debugged_process_sp->GetID());
2787         return SendErrorResponse(52);
2788     }
2789
2790     threads_array_sp->Write(response);
2791     StreamGDBRemote escaped_response;
2792     escaped_response.PutEscapedBytes(response.GetData(), response.GetSize());
2793     return SendPacketNoLock (escaped_response.GetData(), escaped_response.GetSize());
2794 }
2795
2796 GDBRemoteCommunication::PacketResult
2797 GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo (StringExtractorGDBRemote &packet)
2798 {
2799     // Fail if we don't have a current process.
2800     if (!m_debugged_process_sp ||
2801             m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)
2802         return SendErrorResponse (68);
2803
2804     packet.SetFilePos(strlen("qWatchpointSupportInfo"));
2805     if (packet.GetBytesLeft() == 0)
2806         return SendOKResponse();
2807     if (packet.GetChar() != ':')
2808         return SendErrorResponse(67);
2809
2810     uint32_t num = m_debugged_process_sp->GetMaxWatchpoints();
2811     StreamGDBRemote response;
2812     response.Printf ("num:%d;", num);
2813     return SendPacketNoLock(response.GetData(), response.GetSize());
2814 }
2815
2816 GDBRemoteCommunication::PacketResult
2817 GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress (StringExtractorGDBRemote &packet)
2818 {
2819     // Fail if we don't have a current process.
2820     if (!m_debugged_process_sp ||
2821             m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)
2822         return SendErrorResponse(67);
2823
2824     packet.SetFilePos(strlen("qFileLoadAddress:"));
2825     if (packet.GetBytesLeft() == 0)
2826         return SendErrorResponse(68);
2827
2828     std::string file_name;
2829     packet.GetHexByteString(file_name);
2830
2831     lldb::addr_t file_load_address = LLDB_INVALID_ADDRESS;
2832     Error error = m_debugged_process_sp->GetFileLoadAddress(file_name, file_load_address);
2833     if (error.Fail())
2834         return SendErrorResponse(69);
2835
2836     if (file_load_address == LLDB_INVALID_ADDRESS)
2837         return SendErrorResponse(1); // File not loaded
2838
2839     StreamGDBRemote response;
2840     response.PutHex64(file_load_address);
2841     return SendPacketNoLock(response.GetData(), response.GetSize());
2842 }
2843
2844 void
2845 GDBRemoteCommunicationServerLLGS::MaybeCloseInferiorTerminalConnection ()
2846 {
2847     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS));
2848
2849     // Tell the stdio connection to shut down.
2850     if (m_stdio_communication.IsConnected())
2851     {
2852         auto connection = m_stdio_communication.GetConnection();
2853         if (connection)
2854         {
2855             Error error;
2856             connection->Disconnect (&error);
2857
2858             if (error.Success ())
2859             {
2860                 if (log)
2861                     log->Printf ("GDBRemoteCommunicationServerLLGS::%s disconnect process terminal stdio - SUCCESS", __FUNCTION__);
2862             }
2863             else
2864             {
2865                 if (log)
2866                     log->Printf ("GDBRemoteCommunicationServerLLGS::%s disconnect process terminal stdio - FAIL: %s", __FUNCTION__, error.AsCString ());
2867             }
2868         }
2869     }
2870 }
2871
2872
2873 NativeThreadProtocolSP
2874 GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix (StringExtractorGDBRemote &packet)
2875 {
2876     NativeThreadProtocolSP thread_sp;
2877
2878     // We have no thread if we don't have a process.
2879     if (!m_debugged_process_sp || m_debugged_process_sp->GetID () == LLDB_INVALID_PROCESS_ID)
2880         return thread_sp;
2881
2882     // If the client hasn't asked for thread suffix support, there will not be a thread suffix.
2883     // Use the current thread in that case.
2884     if (!m_thread_suffix_supported)
2885     {
2886         const lldb::tid_t current_tid = GetCurrentThreadID ();
2887         if (current_tid == LLDB_INVALID_THREAD_ID)
2888             return thread_sp;
2889         else if (current_tid == 0)
2890         {
2891             // Pick a thread.
2892             return m_debugged_process_sp->GetThreadAtIndex (0);
2893         }
2894         else
2895             return m_debugged_process_sp->GetThreadByID (current_tid);
2896     }
2897
2898     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
2899
2900     // Parse out the ';'.
2901     if (packet.GetBytesLeft () < 1 || packet.GetChar () != ';')
2902     {
2903         if (log)
2904             log->Printf ("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse error: expected ';' prior to start of thread suffix: packet contents = '%s'", __FUNCTION__, packet.GetStringRef ().c_str ());
2905         return thread_sp;
2906     }
2907
2908     if (!packet.GetBytesLeft ())
2909         return thread_sp;
2910
2911     // Parse out thread: portion.
2912     if (strncmp (packet.Peek (), "thread:", strlen("thread:")) != 0)
2913     {
2914         if (log)
2915             log->Printf ("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse error: expected 'thread:' but not found, packet contents = '%s'", __FUNCTION__, packet.GetStringRef ().c_str ());
2916         return thread_sp;
2917     }
2918     packet.SetFilePos (packet.GetFilePos () + strlen("thread:"));
2919     const lldb::tid_t tid = packet.GetHexMaxU64(false, 0);
2920     if (tid != 0)
2921         return m_debugged_process_sp->GetThreadByID (tid);
2922
2923     return thread_sp;
2924 }
2925
2926 lldb::tid_t
2927 GDBRemoteCommunicationServerLLGS::GetCurrentThreadID () const
2928 {
2929     if (m_current_tid == 0 || m_current_tid == LLDB_INVALID_THREAD_ID)
2930     {
2931         // Use whatever the debug process says is the current thread id
2932         // since the protocol either didn't specify or specified we want
2933         // any/all threads marked as the current thread.
2934         if (!m_debugged_process_sp)
2935             return LLDB_INVALID_THREAD_ID;
2936         return m_debugged_process_sp->GetCurrentThreadID ();
2937     }
2938     // Use the specific current thread id set by the gdb remote protocol.
2939     return m_current_tid;
2940 }
2941
2942 uint32_t
2943 GDBRemoteCommunicationServerLLGS::GetNextSavedRegistersID ()
2944 {
2945     std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
2946     return m_next_saved_registers_id++;
2947 }
2948
2949 void
2950 GDBRemoteCommunicationServerLLGS::ClearProcessSpecificData ()
2951 {
2952     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS|GDBR_LOG_PROCESS));
2953     if (log)
2954         log->Printf ("GDBRemoteCommunicationServerLLGS::%s()", __FUNCTION__);
2955
2956     // Clear any auxv cached data.
2957     // *BSD impls should be able to do this too.
2958 #if defined(__linux__)
2959     if (log)
2960         log->Printf ("GDBRemoteCommunicationServerLLGS::%s clearing auxv buffer (previously %s)",
2961                      __FUNCTION__,
2962                      m_active_auxv_buffer_sp ? "was set" : "was not set");
2963     m_active_auxv_buffer_sp.reset ();
2964 #endif
2965 }
2966
2967 FileSpec
2968 GDBRemoteCommunicationServerLLGS::FindModuleFile(const std::string& module_path,
2969                                                  const ArchSpec& arch)
2970 {
2971     if (m_debugged_process_sp)
2972     {
2973         FileSpec file_spec;
2974         if (m_debugged_process_sp->GetLoadedModuleFileSpec(module_path.c_str(), file_spec).Success())
2975         {
2976             if (file_spec.Exists())
2977                 return file_spec;
2978         }
2979     }
2980
2981     return GDBRemoteCommunicationServerCommon::FindModuleFile(module_path, arch);
2982 }