contrib/llvm/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

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