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