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