/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/include/lldb/Utility/TraceOptions.h

Bug Summary

File:	tools/lldb/include/lldb/Utility/TraceOptions.h
Warning:	line 27, column 37 Undefined or garbage value returned to caller

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name GDBRemoteCommunicationServerLLGS.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -momit-leaf-frame-pointer -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-8/lib/clang/8.0.0 -D HAVE_ROUND -D LLDB_CONFIGURATION_RELEASE -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/source/Plugins/Process/gdb-remote -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/include -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/include -I /build/llvm-toolchain-snapshot-8~svn345461/include -I /usr/include/python2.7 -I /build/llvm-toolchain-snapshot-8~svn345461/tools/clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/../clang/include -I /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/. -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/include/clang/8.0.0/include/ -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-8/lib/clang/8.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -Wno-deprecated-declarations -Wno-unknown-pragmas -Wno-strict-aliasing -Wno-deprecated-register -Wno-vla-extension -std=c++11 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-8~svn345461/build-llvm/tools/lldb/source/Plugins/Process/gdb-remote -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -o /tmp/scan-build-2018-10-27-211344-32123-1 -x c++ /build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp -faddrsig

/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

→

1//===-- GDBRemoteCommunicationServerLLGS.cpp --------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//

10#include <errno(*__errno_location ()).h>

12#include "lldb/Host/Config.h"

14#include "GDBRemoteCommunicationServerLLGS.h"
15#include "lldb/Utility/StreamGDBRemote.h"

17// C Includes
18// C++ Includes
19#include <chrono>
20#include <cstring>
21#include <thread>

23// Other libraries and framework includes
24#include "lldb/Host/ConnectionFileDescriptor.h"
25#include "lldb/Host/Debug.h"
26#include "lldb/Host/File.h"
27#include "lldb/Host/FileSystem.h"
28#include "lldb/Host/Host.h"
29#include "lldb/Host/HostInfo.h"
30#include "lldb/Host/PosixApi.h"
31#include "lldb/Host/common/NativeProcessProtocol.h"
32#include "lldb/Host/common/NativeRegisterContext.h"
33#include "lldb/Host/common/NativeThreadProtocol.h"
34#include "lldb/Target/FileAction.h"
35#include "lldb/Target/MemoryRegionInfo.h"
36#include "lldb/Utility/Args.h"
37#include "lldb/Utility/DataBuffer.h"
38#include "lldb/Utility/Endian.h"
39#include "lldb/Utility/JSON.h"
40#include "lldb/Utility/LLDBAssert.h"
41#include "lldb/Utility/Log.h"
42#include "lldb/Utility/RegisterValue.h"
43#include "lldb/Utility/State.h"
44#include "lldb/Utility/StreamString.h"
45#include "lldb/Utility/UriParser.h"
46#include "llvm/ADT/Triple.h"
47#include "llvm/Support/ScopedPrinter.h"

49// Project includes
50#include "ProcessGDBRemote.h"
51#include "ProcessGDBRemoteLog.h"
52#include "lldb/Utility/StringExtractorGDBRemote.h"

54using namespace lldb;
55using namespace lldb_private;
56using namespace lldb_private::process_gdb_remote;
57using namespace llvm;

59//----------------------------------------------------------------------
60// GDBRemote Errors
61//----------------------------------------------------------------------

63namespace {
64enum GDBRemoteServerError {
// Set to the first unused error number in literal form below
eErrorFirst = 29,
eErrorNoProcess = eErrorFirst,
eErrorResume,
eErrorExitStatus
70};
71}

73//----------------------------------------------------------------------
74// GDBRemoteCommunicationServerLLGS constructor
75//----------------------------------------------------------------------
76GDBRemoteCommunicationServerLLGS::GDBRemoteCommunicationServerLLGS(
  MainLoop &mainloop, const NativeProcessProtocol::Factory &process_factory)
  : GDBRemoteCommunicationServerCommon("gdb-remote.server",
                                       "gdb-remote.server.rx_packet"),
    m_mainloop(mainloop), m_process_factory(process_factory),
    m_stdio_communication("process.stdio") {
RegisterPacketHandlers();
83}

85void GDBRemoteCommunicationServerLLGS::RegisterPacketHandlers() {
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_C,
                              &GDBRemoteCommunicationServerLLGS::Handle_C);
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_c,
                              &GDBRemoteCommunicationServerLLGS::Handle_c);
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_D,
                              &GDBRemoteCommunicationServerLLGS::Handle_D);
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_H,
                              &GDBRemoteCommunicationServerLLGS::Handle_H);
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_I,
                              &GDBRemoteCommunicationServerLLGS::Handle_I);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_interrupt,
    &GDBRemoteCommunicationServerLLGS::Handle_interrupt);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_m,
    &GDBRemoteCommunicationServerLLGS::Handle_memory_read);
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_M,
                              &GDBRemoteCommunicationServerLLGS::Handle_M);
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_p,
                              &GDBRemoteCommunicationServerLLGS::Handle_p);
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_P,
                              &GDBRemoteCommunicationServerLLGS::Handle_P);
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_qC,
                              &GDBRemoteCommunicationServerLLGS::Handle_qC);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_qfThreadInfo,
    &GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_qFileLoadAddress,
    &GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_qGetWorkingDir,
    &GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfo,
    &GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_qMemoryRegionInfoSupported,
    &GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_qProcessInfo,
    &GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_qRegisterInfo,
    &GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_QRestoreRegisterState,
    &GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_QSaveRegisterState,
    &GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_QSetDisableASLR,
    &GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_QSetWorkingDir,
    &GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_qsThreadInfo,
    &GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_qThreadStopInfo,
    &GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_jThreadsInfo,
    &GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_qWatchpointSupportInfo,
    &GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_qXfer_auxv_read,
    &GDBRemoteCommunicationServerLLGS::Handle_qXfer_auxv_read);
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_s,
                              &GDBRemoteCommunicationServerLLGS::Handle_s);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_stop_reason,
    &GDBRemoteCommunicationServerLLGS::Handle_stop_reason); // ?
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_vAttach,
    &GDBRemoteCommunicationServerLLGS::Handle_vAttach);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_vCont,
    &GDBRemoteCommunicationServerLLGS::Handle_vCont);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_vCont_actions,
    &GDBRemoteCommunicationServerLLGS::Handle_vCont_actions);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_x,
    &GDBRemoteCommunicationServerLLGS::Handle_memory_read);
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_Z,
                              &GDBRemoteCommunicationServerLLGS::Handle_Z);
RegisterMemberFunctionHandler(StringExtractorGDBRemote::eServerPacketType_z,
                              &GDBRemoteCommunicationServerLLGS::Handle_z);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_QPassSignals,
    &GDBRemoteCommunicationServerLLGS::Handle_QPassSignals);

RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_jTraceStart,
    &GDBRemoteCommunicationServerLLGS::Handle_jTraceStart);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_jTraceBufferRead,
    &GDBRemoteCommunicationServerLLGS::Handle_jTraceRead);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_jTraceMetaRead,
    &GDBRemoteCommunicationServerLLGS::Handle_jTraceRead);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_jTraceStop,
    &GDBRemoteCommunicationServerLLGS::Handle_jTraceStop);
RegisterMemberFunctionHandler(
    StringExtractorGDBRemote::eServerPacketType_jTraceConfigRead,
    &GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead);

RegisterPacketHandler(StringExtractorGDBRemote::eServerPacketType_k,
                      [this](StringExtractorGDBRemote packet, Status &error,
                             bool &interrupt, bool &quit) {
                        quit = true;
                        return this->Handle_k(packet);
                      });
205}

207void GDBRemoteCommunicationServerLLGS::SetLaunchInfo(const ProcessLaunchInfo &info) {
m_process_launch_info = info;
209}

211Status GDBRemoteCommunicationServerLLGS::LaunchProcess() {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));

if (!m_process_launch_info.GetArguments().GetArgumentCount())
  return Status("%s: no process command line specified to launch",
                __FUNCTION__);

const bool should_forward_stdio =
    m_process_launch_info.GetFileActionForFD(STDIN_FILENO0) == nullptr ||
    m_process_launch_info.GetFileActionForFD(STDOUT_FILENO1) == nullptr ||
    m_process_launch_info.GetFileActionForFD(STDERR_FILENO2) == nullptr;
m_process_launch_info.SetLaunchInSeparateProcessGroup(true);
m_process_launch_info.GetFlags().Set(eLaunchFlagDebug);

const bool default_to_use_pty = true;
m_process_launch_info.FinalizeFileActions(nullptr, default_to_use_pty);

{
  std::lock_guard<std::recursive_mutex> guard(m_debugged_process_mutex);
  assert(!m_debugged_process_up && "lldb-server creating debugged "((!m_debugged_process_up && "lldb-server creating debugged "
 "process but one already exists") ? static_cast<void> (
0) : __assert_fail ("!m_debugged_process_up && \"lldb-server creating debugged \" \"process but one already exists\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, 231, __PRETTY_FUNCTION__))
                                   "process but one already exists")((!m_debugged_process_up && "lldb-server creating debugged "
 "process but one already exists") ? static_cast<void> (
0) : __assert_fail ("!m_debugged_process_up && \"lldb-server creating debugged \" \"process but one already exists\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, 231, __PRETTY_FUNCTION__));
  auto process_or =
      m_process_factory.Launch(m_process_launch_info, *this, m_mainloop);
  if (!process_or)
    return Status(process_or.takeError());
  m_debugged_process_up = std::move(*process_or);
}

// Handle mirroring of inferior stdout/stderr over the gdb-remote protocol as
// needed. llgs local-process debugging may specify PTY paths, which will
// make these file actions non-null process launch -i/e/o will also make
// these file actions non-null nullptr means that the traffic is expected to
// flow over gdb-remote protocol
if (should_forward_stdio) {
  // nullptr means it's not redirected to file or pty (in case of LLGS local)
  // at least one of stdio will be transferred pty<->gdb-remote we need to
  // give the pty master handle to this object to read and/or write
  LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid = {0}: setting up stdout/stderr redirection via $O "
 "gdb-remote commands", m_debugged_process_up->GetID()); }
 while (0)
           "pid = {0}: setting up stdout/stderr redirection via $O "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid = {0}: setting up stdout/stderr redirection via $O "
 "gdb-remote commands", m_debugged_process_up->GetID()); }
 while (0)
           "gdb-remote commands",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid = {0}: setting up stdout/stderr redirection via $O "
 "gdb-remote commands", m_debugged_process_up->GetID()); }
 while (0)
           m_debugged_process_up->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid = {0}: setting up stdout/stderr redirection via $O "
 "gdb-remote commands", m_debugged_process_up->GetID()); }
 while (0);

  // Setup stdout/stderr mapping from inferior to $O
  auto terminal_fd = m_debugged_process_up->GetTerminalFileDescriptor();
  if (terminal_fd >= 0) {
    if (log)
      log->Printf("ProcessGDBRemoteCommunicationServerLLGS::%s setting "
                  "inferior STDIO fd to %d",
                  __FUNCTION__, terminal_fd);
    Status status = SetSTDIOFileDescriptor(terminal_fd);
    if (status.Fail())
      return status;
  } else {
    if (log)
      log->Printf("ProcessGDBRemoteCommunicationServerLLGS::%s ignoring "
                  "inferior STDIO since terminal fd reported as %d",
                  __FUNCTION__, terminal_fd);
  }
} else {
  LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid = {0} skipping stdout/stderr redirection via $O: inferior "
 "will communicate over client-provided file descriptors", m_debugged_process_up
->GetID()); } while (0)
           "pid = {0} skipping stdout/stderr redirection via $O: inferior "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid = {0} skipping stdout/stderr redirection via $O: inferior "
 "will communicate over client-provided file descriptors", m_debugged_process_up
->GetID()); } while (0)
           "will communicate over client-provided file descriptors",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid = {0} skipping stdout/stderr redirection via $O: inferior "
 "will communicate over client-provided file descriptors", m_debugged_process_up
->GetID()); } while (0)
           m_debugged_process_up->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid = {0} skipping stdout/stderr redirection via $O: inferior "
 "will communicate over client-provided file descriptors", m_debugged_process_up
->GetID()); } while (0);
}

printf("Launched '%s' as process %" PRIu64"l" "u" "...\n",
       m_process_launch_info.GetArguments().GetArgumentAtIndex(0),
       m_debugged_process_up->GetID());

return Status();
281}

283Status GDBRemoteCommunicationServerLLGS::AttachToProcess(lldb::pid_t pid) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));
if (log)
  log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64"l" "u",
              __FUNCTION__, pid);

// Before we try to attach, make sure we aren't already monitoring something
// else.
if (m_debugged_process_up &&
    m_debugged_process_up->GetID() != LLDB_INVALID_PROCESS_ID0)
  return Status("cannot attach to process %" PRIu64"l" "u"
                " when another process with pid %" PRIu64"l" "u"
                " is being debugged.",
                pid, m_debugged_process_up->GetID());

// Try to attach.
auto process_or = m_process_factory.Attach(pid, *this, m_mainloop);
if (!process_or) {
  Status status(process_or.takeError());
  llvm::errs() << llvm::formatv("failed to attach to process {0}: {1}", pid,
                                status);
  return status;
}
m_debugged_process_up = std::move(*process_or);

// Setup stdout/stderr mapping from inferior.
auto terminal_fd = m_debugged_process_up->GetTerminalFileDescriptor();
if (terminal_fd >= 0) {
  if (log)
    log->Printf("ProcessGDBRemoteCommunicationServerLLGS::%s setting "
                "inferior STDIO fd to %d",
                __FUNCTION__, terminal_fd);
  Status status = SetSTDIOFileDescriptor(terminal_fd);
  if (status.Fail())
    return status;
} else {
  if (log)
    log->Printf("ProcessGDBRemoteCommunicationServerLLGS::%s ignoring "
                "inferior STDIO since terminal fd reported as %d",
                __FUNCTION__, terminal_fd);
}

printf("Attached to process %" PRIu64"l" "u" "...\n", pid);
return Status();
327}

329void GDBRemoteCommunicationServerLLGS::InitializeDelegate(
  NativeProcessProtocol *process) {
assert(process && "process cannot be NULL")((process && "process cannot be NULL") ? static_cast<
void> (0) : __assert_fail ("process && \"process cannot be NULL\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, 331, __PRETTY_FUNCTION__));
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));
if (log) {
  log->Printf("GDBRemoteCommunicationServerLLGS::%s called with "
              "NativeProcessProtocol pid %" PRIu64"l" "u" ", current state: %s",
              __FUNCTION__, process->GetID(),
              StateAsCString(process->GetState()));
}
339}

341GDBRemoteCommunication::PacketResult
342GDBRemoteCommunicationServerLLGS::SendWResponse(
  NativeProcessProtocol *process) {
assert(process && "process cannot be NULL")((process && "process cannot be NULL") ? static_cast<
void> (0) : __assert_fail ("process && \"process cannot be NULL\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, 344, __PRETTY_FUNCTION__));
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));

// send W notification
auto wait_status = process->GetExitStatus();
if (!wait_status) {
  LLDB_LOG(log, "pid = {0}, failed to retrieve process exit status",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid = {0}, failed to retrieve process exit status"
, process->GetID()); } while (0)
           process->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid = {0}, failed to retrieve process exit status"
, process->GetID()); } while (0);

  StreamGDBRemote response;
  response.PutChar('E');
  response.PutHex8(GDBRemoteServerError::eErrorExitStatus);
  return SendPacketNoLock(response.GetString());
}

LLDB_LOG(log, "pid = {0}, returning exit type {1}", process->GetID(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid = {0}, returning exit type {1}", process->
GetID(), *wait_status); } while (0)
         *wait_status)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid = {0}, returning exit type {1}", process->
GetID(), *wait_status); } while (0);

StreamGDBRemote response;
response.Format("{0:g}", *wait_status);
return SendPacketNoLock(response.GetString());
365}

367static void AppendHexValue(StreamString &response, const uint8_t *buf,
                         uint32_t buf_size, bool swap) {
int64_t i;
if (swap) {
  for (i = buf_size - 1; i >= 0; i--)
    response.PutHex8(buf[i]);
} else {
  for (i = 0; i < buf_size; i++)
    response.PutHex8(buf[i]);
}
377}

379static void WriteRegisterValueInHexFixedWidth(
  StreamString &response, NativeRegisterContext &reg_ctx,
  const RegisterInfo &reg_info, const RegisterValue *reg_value_p,
  lldb::ByteOrder byte_order) {
RegisterValue reg_value;
if (!reg_value_p) {
  Status error = reg_ctx.ReadRegister(&reg_info, reg_value);
  if (error.Success())
    reg_value_p = &reg_value;
  // else log.
}

if (reg_value_p) {
  AppendHexValue(response, (const uint8_t *)reg_value_p->GetBytes(),
                 reg_value_p->GetByteSize(),
                 byte_order == lldb::eByteOrderLittle);
} else {
  // Zero-out any unreadable values.
  if (reg_info.byte_size > 0) {
    std::basic_string<uint8_t> zeros(reg_info.byte_size, '\0');
    AppendHexValue(response, zeros.data(), zeros.size(), false);
  }
}
402}

404static JSONObject::SP GetRegistersAsJSON(NativeThreadProtocol &thread) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD(1u << 2)));

NativeRegisterContext& reg_ctx = thread.GetRegisterContext();

JSONObject::SP register_object_sp = std::make_shared<JSONObject>();

411#ifdef LLDB_JTHREADSINFO_FULL_REGISTER_SET
// Expedite all registers in the first register set (i.e. should be GPRs)
// that are not contained in other registers.
const RegisterSet *reg_set_p = reg_ctx_sp->GetRegisterSet(0);
if (!reg_set_p)
  return nullptr;
for (const uint32_t *reg_num_p = reg_set_p->registers;
     *reg_num_p != LLDB_INVALID_REGNUM(4294967295U); ++reg_num_p) {
  uint32_t reg_num = *reg_num_p;
420#else
// Expedite only a couple of registers until we figure out why sending
// registers is expensive.
static const uint32_t k_expedited_registers[] = {
    LLDB_REGNUM_GENERIC_PC0, LLDB_REGNUM_GENERIC_SP1, LLDB_REGNUM_GENERIC_FP2,
    LLDB_REGNUM_GENERIC_RA3, LLDB_INVALID_REGNUM(4294967295U)};

for (const uint32_t *generic_reg_p = k_expedited_registers;
     *generic_reg_p != LLDB_INVALID_REGNUM(4294967295U); ++generic_reg_p) {
  uint32_t reg_num = reg_ctx.ConvertRegisterKindToRegisterNumber(
      eRegisterKindGeneric, *generic_reg_p);
  if (reg_num == LLDB_INVALID_REGNUM(4294967295U))
    continue; // Target does not support the given register.
433#endif

  const RegisterInfo *const reg_info_p =
      reg_ctx.GetRegisterInfoAtIndex(reg_num);
  if (reg_info_p == nullptr) {
    if (log)
      log->Printf(
          "%s failed to get register info for register index %" PRIu32"u",
          __FUNCTION__, reg_num);
    continue;
  }

  if (reg_info_p->value_regs != nullptr)
    continue; // Only expedite registers that are not contained in other
              // registers.

  RegisterValue reg_value;
  Status error = reg_ctx.ReadRegister(reg_info_p, reg_value);
  if (error.Fail()) {
    if (log)
      log->Printf("%s failed to read register '%s' index %" PRIu32"u" ": %s",
                  __FUNCTION__,
                  reg_info_p->name ? reg_info_p->name : "<unnamed-register>",
                  reg_num, error.AsCString());
    continue;
  }

  StreamString stream;
  WriteRegisterValueInHexFixedWidth(stream, reg_ctx, *reg_info_p,
                                    &reg_value, lldb::eByteOrderBig);

  register_object_sp->SetObject(
      llvm::to_string(reg_num),
      std::make_shared<JSONString>(stream.GetString()));
}

return register_object_sp;
470}

472static const char *GetStopReasonString(StopReason stop_reason) {
switch (stop_reason) {
case eStopReasonTrace:
  return "trace";
case eStopReasonBreakpoint:
  return "breakpoint";
case eStopReasonWatchpoint:
  return "watchpoint";
case eStopReasonSignal:
  return "signal";
case eStopReasonException:
  return "exception";
case eStopReasonExec:
  return "exec";
case eStopReasonInstrumentation:
case eStopReasonInvalid:
case eStopReasonPlanComplete:
case eStopReasonThreadExiting:
case eStopReasonNone:
  break; // ignored
}
return nullptr;
494}

496static JSONArray::SP GetJSONThreadsInfo(NativeProcessProtocol &process,
                                      bool abridged) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1) | LIBLLDB_LOG_THREAD(1u << 2)));

JSONArray::SP threads_array_sp = std::make_shared<JSONArray>();

// Ensure we can get info on the given thread.
uint32_t thread_idx = 0;
for (NativeThreadProtocol *thread;
     (thread = process.GetThreadAtIndex(thread_idx)) != nullptr;
     ++thread_idx) {

  lldb::tid_t tid = thread->GetID();

  // Grab the reason this thread stopped.
  struct ThreadStopInfo tid_stop_info;
  std::string description;
  if (!thread->GetStopReason(tid_stop_info, description))
    return nullptr;

  const int signum = tid_stop_info.details.signal.signo;
  if (log) {
    log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64"l" "u"
                " tid %" PRIu64"l" "u"
                " got signal signo = %d, reason = %d, exc_type = %" PRIu64"l" "u",
                __FUNCTION__, process.GetID(), tid, signum,
                tid_stop_info.reason, tid_stop_info.details.exception.type);
  }

  JSONObject::SP thread_obj_sp = std::make_shared<JSONObject>();
  threads_array_sp->AppendObject(thread_obj_sp);

  if (!abridged) {
    if (JSONObject::SP registers_sp = GetRegistersAsJSON(*thread))
      thread_obj_sp->SetObject("registers", registers_sp);
  }

  thread_obj_sp->SetObject("tid", std::make_shared<JSONNumber>(tid));
  if (signum != 0)
    thread_obj_sp->SetObject("signal", std::make_shared<JSONNumber>(signum));

  const std::string thread_name = thread->GetName();
  if (!thread_name.empty())
    thread_obj_sp->SetObject("name",
                             std::make_shared<JSONString>(thread_name));

  if (const char *stop_reason_str = GetStopReasonString(tid_stop_info.reason))
    thread_obj_sp->SetObject("reason",
                             std::make_shared<JSONString>(stop_reason_str));

  if (!description.empty())
    thread_obj_sp->SetObject("description",
                             std::make_shared<JSONString>(description));

  if ((tid_stop_info.reason == eStopReasonException) &&
      tid_stop_info.details.exception.type) {
    thread_obj_sp->SetObject(
        "metype",
        std::make_shared<JSONNumber>(tid_stop_info.details.exception.type));

    JSONArray::SP medata_array_sp = std::make_shared<JSONArray>();
    for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count;
         ++i) {
      medata_array_sp->AppendObject(std::make_shared<JSONNumber>(
          tid_stop_info.details.exception.data[i]));
    }
    thread_obj_sp->SetObject("medata", medata_array_sp);
  }

  // TODO: Expedite interesting regions of inferior memory
}

return threads_array_sp;
569}

571GDBRemoteCommunication::PacketResult
572GDBRemoteCommunicationServerLLGS::SendStopReplyPacketForThread(
  lldb::tid_t tid) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1) | LIBLLDB_LOG_THREAD(1u << 2)));

// Ensure we have a debugged process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0))
  return SendErrorResponse(50);

LLDB_LOG(log, "preparing packet for pid {0} tid {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "preparing packet for pid {0} tid {1}", m_debugged_process_up
->GetID(), tid); } while (0)
         m_debugged_process_up->GetID(), tid)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "preparing packet for pid {0} tid {1}", m_debugged_process_up
->GetID(), tid); } while (0);

// Ensure we can get info on the given thread.
NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid);
if (!thread)
  return SendErrorResponse(51);

// Grab the reason this thread stopped.
struct ThreadStopInfo tid_stop_info;
std::string description;
if (!thread->GetStopReason(tid_stop_info, description))
  return SendErrorResponse(52);

// FIXME implement register handling for exec'd inferiors.
// if (tid_stop_info.reason == eStopReasonExec) {
//     const bool force = true;
//     InitializeRegisters(force);
// }

StreamString response;
// Output the T packet with the thread
response.PutChar('T');
int signum = tid_stop_info.details.signal.signo;
LLDB_LOG(do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0}, tid {1}, got signal signo = {2}, reason = {3}, exc_type = {4}"
, m_debugged_process_up->GetID(), tid, signum, int(tid_stop_info
.reason), tid_stop_info.details.exception.type); } while (0)
    log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0}, tid {1}, got signal signo = {2}, reason = {3}, exc_type = {4}"
, m_debugged_process_up->GetID(), tid, signum, int(tid_stop_info
.reason), tid_stop_info.details.exception.type); } while (0)
    "pid {0}, tid {1}, got signal signo = {2}, reason = {3}, exc_type = {4}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0}, tid {1}, got signal signo = {2}, reason = {3}, exc_type = {4}"
, m_debugged_process_up->GetID(), tid, signum, int(tid_stop_info
.reason), tid_stop_info.details.exception.type); } while (0)
    m_debugged_process_up->GetID(), tid, signum, int(tid_stop_info.reason),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0}, tid {1}, got signal signo = {2}, reason = {3}, exc_type = {4}"
, m_debugged_process_up->GetID(), tid, signum, int(tid_stop_info
.reason), tid_stop_info.details.exception.type); } while (0)
    tid_stop_info.details.exception.type)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0}, tid {1}, got signal signo = {2}, reason = {3}, exc_type = {4}"
, m_debugged_process_up->GetID(), tid, signum, int(tid_stop_info
.reason), tid_stop_info.details.exception.type); } while (0);

// Print the signal number.
response.PutHex8(signum & 0xff);

// Include the tid.
response.Printf("thread:%" PRIx64"l" "x" ";", tid);

// Include the thread name if there is one.
const std::string thread_name = thread->GetName();
if (!thread_name.empty()) {
  size_t thread_name_len = thread_name.length();

  if (::strcspn(thread_name.c_str(), "$#+-;:") == thread_name_len) {
    response.PutCString("name:");
    response.PutCString(thread_name);
  } else {
    // The thread name contains special chars, send as hex bytes.
    response.PutCString("hexname:");
    response.PutCStringAsRawHex8(thread_name.c_str());
  }
  response.PutChar(';');
}

// If a 'QListThreadsInStopReply' was sent to enable this feature, we will
// send all thread IDs back in the "threads" key whose value is a list of hex
// thread IDs separated by commas:
//  "threads:10a,10b,10c;"
// This will save the debugger from having to send a pair of qfThreadInfo and
// qsThreadInfo packets, but it also might take a lot of room in the stop
// reply packet, so it must be enabled only on systems where there are no
// limits on packet lengths.
if (m_list_threads_in_stop_reply) {
  response.PutCString("threads:");

  uint32_t thread_index = 0;
  NativeThreadProtocol *listed_thread;
  for (listed_thread = m_debugged_process_up->GetThreadAtIndex(thread_index);
       listed_thread; ++thread_index,
      listed_thread = m_debugged_process_up->GetThreadAtIndex(thread_index)) {
    if (thread_index > 0)
      response.PutChar(',');
    response.Printf("%" PRIx64"l" "x", listed_thread->GetID());
  }
  response.PutChar(';');

  // Include JSON info that describes the stop reason for any threads that
  // actually have stop reasons. We use the new "jstopinfo" key whose values
  // is hex ascii JSON that contains the thread IDs thread stop info only for
  // threads that have stop reasons. Only send this if we have more than one
  // thread otherwise this packet has all the info it needs.
  if (thread_index > 0) {
    const bool threads_with_valid_stop_info_only = true;
    JSONArray::SP threads_info_sp = GetJSONThreadsInfo(
        *m_debugged_process_up, threads_with_valid_stop_info_only);
    if (threads_info_sp) {
      response.PutCString("jstopinfo:");
      StreamString unescaped_response;
      threads_info_sp->Write(unescaped_response);
      response.PutCStringAsRawHex8(unescaped_response.GetData());
      response.PutChar(';');
    } else
      LLDB_LOG(log, "failed to prepare a jstopinfo field for pid {0}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "failed to prepare a jstopinfo field for pid {0}"
, m_debugged_process_up->GetID()); } while (0)
               m_debugged_process_up->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "failed to prepare a jstopinfo field for pid {0}"
, m_debugged_process_up->GetID()); } while (0);
  }

  uint32_t i = 0;
  response.PutCString("thread-pcs");
  char delimiter = ':';
  for (NativeThreadProtocol *thread;
       (thread = m_debugged_process_up->GetThreadAtIndex(i)) != nullptr;
       ++i) {
    NativeRegisterContext& reg_ctx = thread->GetRegisterContext();

    uint32_t reg_to_read = reg_ctx.ConvertRegisterKindToRegisterNumber(
        eRegisterKindGeneric, LLDB_REGNUM_GENERIC_PC0);
    const RegisterInfo *const reg_info_p =
        reg_ctx.GetRegisterInfoAtIndex(reg_to_read);

    RegisterValue reg_value;
    Status error = reg_ctx.ReadRegister(reg_info_p, reg_value);
    if (error.Fail()) {
      if (log)
        log->Printf("%s failed to read register '%s' index %" PRIu32"u" ": %s",
                    __FUNCTION__,
                    reg_info_p->name ? reg_info_p->name
                                     : "<unnamed-register>",
                    reg_to_read, error.AsCString());
      continue;
    }

    response.PutChar(delimiter);
    delimiter = ',';
    WriteRegisterValueInHexFixedWidth(response, reg_ctx, *reg_info_p,
                                      &reg_value, endian::InlHostByteOrder());
  }

  response.PutChar(';');
}

//
// Expedite registers.
//

// Grab the register context.
NativeRegisterContext& reg_ctx = thread->GetRegisterContext();
// Expedite all registers in the first register set (i.e. should be GPRs)
// that are not contained in other registers.
const RegisterSet *reg_set_p;
if (reg_ctx.GetRegisterSetCount() > 0 &&
    ((reg_set_p = reg_ctx.GetRegisterSet(0)) != nullptr)) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s expediting registers "
                "from set '%s' (registers set count: %zu)",
                __FUNCTION__,
                reg_set_p->name ? reg_set_p->name : "<unnamed-set>",
                reg_set_p->num_registers);

  for (const uint32_t *reg_num_p = reg_set_p->registers;
       *reg_num_p != LLDB_INVALID_REGNUM(4294967295U); ++reg_num_p) {
    const RegisterInfo *const reg_info_p =
        reg_ctx.GetRegisterInfoAtIndex(*reg_num_p);
    if (reg_info_p == nullptr) {
      if (log)
        log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to get "
                    "register info for register set '%s', register index "
                    "%" PRIu32"u",
                    __FUNCTION__,
                    reg_set_p->name ? reg_set_p->name : "<unnamed-set>",
                    *reg_num_p);
    } else if (reg_info_p->value_regs == nullptr) {
      // Only expediate registers that are not contained in other registers.
      RegisterValue reg_value;
      Status error = reg_ctx.ReadRegister(reg_info_p, reg_value);
      if (error.Success()) {
        response.Printf("%.02x:", *reg_num_p);
        WriteRegisterValueInHexFixedWidth(response, reg_ctx, *reg_info_p,
                                          &reg_value, lldb::eByteOrderBig);
        response.PutChar(';');
      } else {
        if (log)
          log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to read "
                      "register '%s' index %" PRIu32"u" ": %s",
                      __FUNCTION__,
                      reg_info_p->name ? reg_info_p->name
                                       : "<unnamed-register>",
                      *reg_num_p, error.AsCString());
      }
    }
  }
}

const char *reason_str = GetStopReasonString(tid_stop_info.reason);
if (reason_str != nullptr) {
  response.Printf("reason:%s;", reason_str);
}

if (!description.empty()) {
  // Description may contains special chars, send as hex bytes.
  response.PutCString("description:");
  response.PutCStringAsRawHex8(description.c_str());
  response.PutChar(';');
} else if ((tid_stop_info.reason == eStopReasonException) &&
           tid_stop_info.details.exception.type) {
  response.PutCString("metype:");
  response.PutHex64(tid_stop_info.details.exception.type);
  response.PutCString(";mecount:");
  response.PutHex32(tid_stop_info.details.exception.data_count);
  response.PutChar(';');

  for (uint32_t i = 0; i < tid_stop_info.details.exception.data_count; ++i) {
    response.PutCString("medata:");
    response.PutHex64(tid_stop_info.details.exception.data[i]);
    response.PutChar(';');
  }
}

return SendPacketNoLock(response.GetString());
787}

789void GDBRemoteCommunicationServerLLGS::HandleInferiorState_Exited(
  NativeProcessProtocol *process) {
assert(process && "process cannot be NULL")((process && "process cannot be NULL") ? static_cast<
void> (0) : __assert_fail ("process && \"process cannot be NULL\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, 791, __PRETTY_FUNCTION__));

Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));
if (log)
  log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);

PacketResult result = SendStopReasonForState(StateType::eStateExited);
if (result != PacketResult::Success) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to send stop "
                "notification for PID %" PRIu64"l" "u" ", state: eStateExited",
                __FUNCTION__, process->GetID());
}

// Close the pipe to the inferior terminal i/o if we launched it and set one
// up.
MaybeCloseInferiorTerminalConnection();

// We are ready to exit the debug monitor.
m_exit_now = true;
m_mainloop.RequestTermination();
812}

814void GDBRemoteCommunicationServerLLGS::HandleInferiorState_Stopped(
  NativeProcessProtocol *process) {
assert(process && "process cannot be NULL")((process && "process cannot be NULL") ? static_cast<
void> (0) : __assert_fail ("process && \"process cannot be NULL\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, 816, __PRETTY_FUNCTION__));

Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));
if (log)
  log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);

// Send the stop reason unless this is the stop after the launch or attach.
switch (m_inferior_prev_state) {
case eStateLaunching:
case eStateAttaching:
  // Don't send anything per debugserver behavior.
  break;
default:
  // In all other cases, send the stop reason.
  PacketResult result = SendStopReasonForState(StateType::eStateStopped);
  if (result != PacketResult::Success) {
    if (log)
      log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to send stop "
                  "notification for PID %" PRIu64"l" "u" ", state: eStateExited",
                  __FUNCTION__, process->GetID());
  }
  break;
}
839}

841void GDBRemoteCommunicationServerLLGS::ProcessStateChanged(
  NativeProcessProtocol *process, lldb::StateType state) {
assert(process && "process cannot be NULL")((process && "process cannot be NULL") ? static_cast<
void> (0) : __assert_fail ("process && \"process cannot be NULL\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, 843, __PRETTY_FUNCTION__));
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));
if (log) {
  log->Printf("GDBRemoteCommunicationServerLLGS::%s called with "
              "NativeProcessProtocol pid %" PRIu64"l" "u" ", state: %s",
              __FUNCTION__, process->GetID(), StateAsCString(state));
}

switch (state) {
case StateType::eStateRunning:
  StartSTDIOForwarding();
  break;

case StateType::eStateStopped:
  // Make sure we get all of the pending stdout/stderr from the inferior and
  // send it to the lldb host before we send the state change notification
  SendProcessOutput();
  // Then stop the forwarding, so that any late output (see llvm.org/pr25652)
  // does not interfere with our protocol.
  StopSTDIOForwarding();
  HandleInferiorState_Stopped(process);
  break;

case StateType::eStateExited:
  // Same as above
  SendProcessOutput();
  StopSTDIOForwarding();
  HandleInferiorState_Exited(process);
  break;

default:
  if (log) {
    log->Printf("GDBRemoteCommunicationServerLLGS::%s didn't handle state "
                "change for pid %" PRIu64"l" "u" ", new state: %s",
                __FUNCTION__, process->GetID(), StateAsCString(state));
  }
  break;
}

// Remember the previous state reported to us.
m_inferior_prev_state = state;
884}

886void GDBRemoteCommunicationServerLLGS::DidExec(NativeProcessProtocol *process) {
ClearProcessSpecificData();
888}

890void GDBRemoteCommunicationServerLLGS::DataAvailableCallback() {
Log *log(GetLogIfAnyCategoriesSet(GDBR_LOG_COMM(1u << 10)));

if (!m_handshake_completed) {
  if (!HandshakeWithClient()) {
    if (log)
      log->Printf("GDBRemoteCommunicationServerLLGS::%s handshake with "
                  "client failed, exiting",
                  __FUNCTION__);
    m_mainloop.RequestTermination();
    return;
  }
  m_handshake_completed = true;
}

bool interrupt = false;
bool done = false;
Status error;
while (true) {
  const PacketResult result = GetPacketAndSendResponse(
      std::chrono::microseconds(0), error, interrupt, done);
  if (result == PacketResult::ErrorReplyTimeout)
    break; // No more packets in the queue

  if ((result != PacketResult::Success)) {
    if (log)
      log->Printf("GDBRemoteCommunicationServerLLGS::%s processing a packet "
                  "failed: %s",
                  __FUNCTION__, error.AsCString());
    m_mainloop.RequestTermination();
    break;
  }
}
923}

925Status GDBRemoteCommunicationServerLLGS::InitializeConnection(
  std::unique_ptr<Connection> &&connection) {
IOObjectSP read_object_sp = connection->GetReadObject();
GDBRemoteCommunicationServer::SetConnection(connection.release());

Status error;
m_network_handle_up = m_mainloop.RegisterReadObject(
    read_object_sp, [this](MainLoopBase &) { DataAvailableCallback(); },
    error);
return error;
935}

937GDBRemoteCommunication::PacketResult
938GDBRemoteCommunicationServerLLGS::SendONotification(const char *buffer,
                                                  uint32_t len) {
if ((buffer == nullptr) || (len == 0)) {
  // Nothing to send.
  return PacketResult::Success;
}

StreamString response;
response.PutChar('O');
response.PutBytesAsRawHex8(buffer, len);

return SendPacketNoLock(response.GetString());
950}

952Status GDBRemoteCommunicationServerLLGS::SetSTDIOFileDescriptor(int fd) {
Status error;

// Set up the reading/handling of process I/O
std::unique_ptr<ConnectionFileDescriptor> conn_up(
    new ConnectionFileDescriptor(fd, true));
if (!conn_up) {
  error.SetErrorString("failed to create ConnectionFileDescriptor");
  return error;
}

m_stdio_communication.SetCloseOnEOF(false);
m_stdio_communication.SetConnection(conn_up.release());
if (!m_stdio_communication.IsConnected()) {
  error.SetErrorString(
      "failed to set connection for inferior I/O communication");
  return error;
}

return Status();
972}

974void GDBRemoteCommunicationServerLLGS::StartSTDIOForwarding() {
// Don't forward if not connected (e.g. when attaching).
if (!m_stdio_communication.IsConnected())
  return;

Status error;
lldbassert(!m_stdio_handle_up)lldb_private::lldb_assert(static_cast<bool>(!m_stdio_handle_up
), "!m_stdio_handle_up", __FUNCTION__, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, 980);
m_stdio_handle_up = m_mainloop.RegisterReadObject(
    m_stdio_communication.GetConnection()->GetReadObject(),
    [this](MainLoopBase &) { SendProcessOutput(); }, error);

if (!m_stdio_handle_up) {
  // Not much we can do about the failure. Log it and continue without
  // forwarding.
  if (Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)))
    log->Printf("GDBRemoteCommunicationServerLLGS::%s Failed to set up stdio "
                "forwarding: %s",
                __FUNCTION__, error.AsCString());
}
993}

995void GDBRemoteCommunicationServerLLGS::StopSTDIOForwarding() {
m_stdio_handle_up.reset();
997}

999void GDBRemoteCommunicationServerLLGS::SendProcessOutput() {
char buffer[1024];
ConnectionStatus status;
Status error;
while (true) {
  size_t bytes_read = m_stdio_communication.Read(
      buffer, sizeof buffer, std::chrono::microseconds(0), status, &error);
  switch (status) {
  case eConnectionStatusSuccess:
    SendONotification(buffer, bytes_read);
    break;
  case eConnectionStatusLostConnection:
  case eConnectionStatusEndOfFile:
  case eConnectionStatusError:
  case eConnectionStatusNoConnection:
    if (Log *log = GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)))
      log->Printf("GDBRemoteCommunicationServerLLGS::%s Stopping stdio "
                  "forwarding as communication returned status %d (error: "
                  "%s)",
                  __FUNCTION__, status, error.AsCString());
    m_stdio_handle_up.reset();
    return;

  case eConnectionStatusInterrupted:
  case eConnectionStatusTimedOut:
    return;
  }
}
1027}

1029GDBRemoteCommunication::PacketResult
1030GDBRemoteCommunicationServerLLGS::Handle_jTraceStart(
  StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));
// Fail if we don't have a current process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0))
  return SendErrorResponse(68);

if (!packet.ConsumeFront("jTraceStart:"))
  return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet ");

TraceOptions options;
uint64_t type = std::numeric_limits<uint64_t>::max();
uint64_t buffersize = std::numeric_limits<uint64_t>::max();
lldb::tid_t tid = LLDB_INVALID_THREAD_ID0;
uint64_t metabuffersize = std::numeric_limits<uint64_t>::max();

auto json_object = StructuredData::ParseJSON(packet.Peek());

if (!json_object ||
    json_object->GetType() != lldb::eStructuredDataTypeDictionary)
  return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet ");

auto json_dict = json_object->GetAsDictionary();

json_dict->GetValueForKeyAsInteger("metabuffersize", metabuffersize);
options.setMetaDataBufferSize(metabuffersize);

json_dict->GetValueForKeyAsInteger("buffersize", buffersize);
options.setTraceBufferSize(buffersize);

json_dict->GetValueForKeyAsInteger("type", type);
options.setType(static_cast<lldb::TraceType>(type));

json_dict->GetValueForKeyAsInteger("threadid", tid);
options.setThreadID(tid);

StructuredData::ObjectSP custom_params_sp =
    json_dict->GetValueForKey("params");
if (custom_params_sp &&
    custom_params_sp->GetType() != lldb::eStructuredDataTypeDictionary)
  return SendIllFormedResponse(packet, "jTraceStart: Ill formed packet ");

options.setTraceParams(
    static_pointer_cast<StructuredData::Dictionary>(custom_params_sp));

if (buffersize == std::numeric_limits<uint64_t>::max() ||
    type != lldb::TraceType::eTraceTypeProcessorTrace) {
  LLDB_LOG(log, "Ill formed packet buffersize = {0} type = {1}", buffersize,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "Ill formed packet buffersize = {0} type = {1}", buffersize
, type); } while (0)
           type)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "Ill formed packet buffersize = {0} type = {1}", buffersize
, type); } while (0);
  return SendIllFormedResponse(packet, "JTrace:start: Ill formed packet ");
}

Status error;
lldb::user_id_t uid = LLDB_INVALID_UID(18446744073709551615UL);
uid = m_debugged_process_up->StartTrace(options, error);
LLDB_LOG(log, "uid is {0} , error is {1}", uid, error.GetError())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "uid is {0} , error is {1}", uid, error.GetError(
)); } while (0);
if (error.Fail())
  return SendErrorResponse(error);

StreamGDBRemote response;
response.Printf("%" PRIx64"l" "x", uid);
return SendPacketNoLock(response.GetString());
1093}

1095GDBRemoteCommunication::PacketResult
1096GDBRemoteCommunicationServerLLGS::Handle_jTraceStop(
  StringExtractorGDBRemote &packet) {
// Fail if we don't have a current process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0))
  return SendErrorResponse(68);

if (!packet.ConsumeFront("jTraceStop:"))
  return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet ");

lldb::user_id_t uid = LLDB_INVALID_UID(18446744073709551615UL);
lldb::tid_t tid = LLDB_INVALID_THREAD_ID0;

auto json_object = StructuredData::ParseJSON(packet.Peek());

if (!json_object ||
    json_object->GetType() != lldb::eStructuredDataTypeDictionary)
  return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet ");

auto json_dict = json_object->GetAsDictionary();

if (!json_dict->GetValueForKeyAsInteger("traceid", uid))
  return SendIllFormedResponse(packet, "jTraceStop: Ill formed packet ");

json_dict->GetValueForKeyAsInteger("threadid", tid);

Status error = m_debugged_process_up->StopTrace(uid, tid);

if (error.Fail())
  return SendErrorResponse(error);

return SendOKResponse();
1128}

1130GDBRemoteCommunication::PacketResult
1131GDBRemoteCommunicationServerLLGS::Handle_jTraceConfigRead(
  StringExtractorGDBRemote &packet) {

// Fail if we don't have a current process.
if (!m_debugged_process_up ||
2
←
Taking false branch→
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0))
1
Assuming the condition is false→
  return SendErrorResponse(68);

if (!packet.ConsumeFront("jTraceConfigRead:"))
3
←
Assuming the condition is false→
4
←
Taking false branch→
  return SendIllFormedResponse(packet,
                               "jTraceConfigRead: Ill formed packet ");

lldb::user_id_t uid = LLDB_INVALID_UID(18446744073709551615UL);
lldb::tid_t threadid = LLDB_INVALID_THREAD_ID0;

auto json_object = StructuredData::ParseJSON(packet.Peek());

if (!json_object ||
6
←
Taking false branch→
    json_object->GetType() != lldb::eStructuredDataTypeDictionary)
5
←
Assuming the condition is false→
  return SendIllFormedResponse(packet,
                               "jTraceConfigRead: Ill formed packet ");

auto json_dict = json_object->GetAsDictionary();

if (!json_dict->GetValueForKeyAsInteger("traceid", uid))
7
←
Taking false branch→
  return SendIllFormedResponse(packet,
                               "jTraceConfigRead: Ill formed packet ");

json_dict->GetValueForKeyAsInteger("threadid", threadid);

TraceOptions options;
8
←
Calling default constructor for 'TraceOptions'→
10
←
Returning from default constructor for 'TraceOptions'→
StreamGDBRemote response;

options.setThreadID(threadid);
Status error = m_debugged_process_up->GetTraceConfig(uid, options);
11
←
Calling 'NativeProcessProtocol::GetTraceConfig'→
13
←
Returning from 'NativeProcessProtocol::GetTraceConfig'→

if (error.Fail())
14
←
Assuming the condition is false→
15
←
Taking false branch→
  return SendErrorResponse(error);

StreamGDBRemote escaped_response;
StructuredData::Dictionary json_packet;

json_packet.AddIntegerItem("type", options.getType());
16
←
Calling 'TraceOptions::getType'→
json_packet.AddIntegerItem("buffersize", options.getTraceBufferSize());
json_packet.AddIntegerItem("metabuffersize", options.getMetaDataBufferSize());

StructuredData::DictionarySP custom_params = options.getTraceParams();
if (custom_params)
  json_packet.AddItem("params", custom_params);

StreamString json_string;
json_packet.Dump(json_string, false);
escaped_response.PutEscapedBytes(json_string.GetData(),
                                 json_string.GetSize());
return SendPacketNoLock(escaped_response.GetString());
1186}

1188GDBRemoteCommunication::PacketResult
1189GDBRemoteCommunicationServerLLGS::Handle_jTraceRead(
  StringExtractorGDBRemote &packet) {

// Fail if we don't have a current process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0))
  return SendErrorResponse(68);

enum PacketType { MetaData, BufferData };
PacketType tracetype = MetaData;

if (packet.ConsumeFront("jTraceBufferRead:"))
  tracetype = BufferData;
else if (packet.ConsumeFront("jTraceMetaRead:"))
  tracetype = MetaData;
else {
  return SendIllFormedResponse(packet, "jTrace: Ill formed packet ");
}

lldb::user_id_t uid = LLDB_INVALID_UID(18446744073709551615UL);

uint64_t byte_count = std::numeric_limits<uint64_t>::max();
lldb::tid_t tid = LLDB_INVALID_THREAD_ID0;
uint64_t offset = std::numeric_limits<uint64_t>::max();

auto json_object = StructuredData::ParseJSON(packet.Peek());

if (!json_object ||
    json_object->GetType() != lldb::eStructuredDataTypeDictionary)
  return SendIllFormedResponse(packet, "jTrace: Ill formed packet ");

auto json_dict = json_object->GetAsDictionary();

if (!json_dict->GetValueForKeyAsInteger("traceid", uid) ||
    !json_dict->GetValueForKeyAsInteger("offset", offset) ||
    !json_dict->GetValueForKeyAsInteger("buffersize", byte_count))
  return SendIllFormedResponse(packet, "jTrace: Ill formed packet ");

json_dict->GetValueForKeyAsInteger("threadid", tid);

// Allocate the response buffer.
std::unique_ptr<uint8_t[]> buffer (new (std::nothrow) uint8_t[byte_count]);
if (!buffer)
  return SendErrorResponse(0x78);

StreamGDBRemote response;
Status error;
llvm::MutableArrayRef<uint8_t> buf(buffer.get(), byte_count);

if (tracetype == BufferData)
  error = m_debugged_process_up->GetData(uid, tid, buf, offset);
else if (tracetype == MetaData)
  error = m_debugged_process_up->GetMetaData(uid, tid, buf, offset);

if (error.Fail())
  return SendErrorResponse(error);

for (auto i : buf)
  response.PutHex8(i);

StreamGDBRemote escaped_response;
escaped_response.PutEscapedBytes(response.GetData(), response.GetSize());
return SendPacketNoLock(escaped_response.GetString());
1252}

1254GDBRemoteCommunication::PacketResult
1255GDBRemoteCommunicationServerLLGS::Handle_qProcessInfo(
  StringExtractorGDBRemote &packet) {
// Fail if we don't have a current process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0))
  return SendErrorResponse(68);

lldb::pid_t pid = m_debugged_process_up->GetID();

if (pid == LLDB_INVALID_PROCESS_ID0)
  return SendErrorResponse(1);

ProcessInstanceInfo proc_info;
if (!Host::GetProcessInfo(pid, proc_info))
  return SendErrorResponse(1);

StreamString response;
CreateProcessInfoResponse_DebugServerStyle(proc_info, response);
return SendPacketNoLock(response.GetString());
1274}

1276GDBRemoteCommunication::PacketResult
1277GDBRemoteCommunicationServerLLGS::Handle_qC(StringExtractorGDBRemote &packet) {
// Fail if we don't have a current process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0))
  return SendErrorResponse(68);

// Make sure we set the current thread so g and p packets return the data the
// gdb will expect.
lldb::tid_t tid = m_debugged_process_up->GetCurrentThreadID();
SetCurrentThreadID(tid);

NativeThreadProtocol *thread = m_debugged_process_up->GetCurrentThread();
if (!thread)
  return SendErrorResponse(69);

StreamString response;
response.Printf("QC%" PRIx64"l" "x", thread->GetID());

return SendPacketNoLock(response.GetString());
1296}

1298GDBRemoteCommunication::PacketResult
1299GDBRemoteCommunicationServerLLGS::Handle_k(StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));

StopSTDIOForwarding();

if (!m_debugged_process_up) {
  LLDB_LOG(log, "No debugged process found.")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "No debugged process found."); } while (0);
  return PacketResult::Success;
}

Status error = m_debugged_process_up->Kill();
if (error.Fail())
  LLDB_LOG(log, "Failed to kill debugged process {0}: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "Failed to kill debugged process {0}: {1}", m_debugged_process_up
->GetID(), error); } while (0)
           m_debugged_process_up->GetID(), error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "Failed to kill debugged process {0}: {1}", m_debugged_process_up
->GetID(), error); } while (0);

// No OK response for kill packet.
// return SendOKResponse ();
return PacketResult::Success;
1317}

1319GDBRemoteCommunication::PacketResult
1320GDBRemoteCommunicationServerLLGS::Handle_QSetDisableASLR(
  StringExtractorGDBRemote &packet) {
packet.SetFilePos(::strlen("QSetDisableASLR:"));
if (packet.GetU32(0))
  m_process_launch_info.GetFlags().Set(eLaunchFlagDisableASLR);
else
  m_process_launch_info.GetFlags().Clear(eLaunchFlagDisableASLR);
return SendOKResponse();
1328}

1330GDBRemoteCommunication::PacketResult
1331GDBRemoteCommunicationServerLLGS::Handle_QSetWorkingDir(
  StringExtractorGDBRemote &packet) {
packet.SetFilePos(::strlen("QSetWorkingDir:"));
std::string path;
packet.GetHexByteString(path);
m_process_launch_info.SetWorkingDirectory(FileSpec{path, true});
return SendOKResponse();
1338}

1340GDBRemoteCommunication::PacketResult
1341GDBRemoteCommunicationServerLLGS::Handle_qGetWorkingDir(
  StringExtractorGDBRemote &packet) {
FileSpec working_dir{m_process_launch_info.GetWorkingDirectory()};
if (working_dir) {
  StreamString response;
  response.PutCStringAsRawHex8(working_dir.GetCString());
  return SendPacketNoLock(response.GetString());
}

return SendErrorResponse(14);
1351}

1353GDBRemoteCommunication::PacketResult
1354GDBRemoteCommunicationServerLLGS::Handle_C(StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1) | LIBLLDB_LOG_THREAD(1u << 2)));
if (log)
  log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);

// Ensure we have a native process.
if (!m_debugged_process_up) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s no debugged process "
                "shared pointer",
                __FUNCTION__);
  return SendErrorResponse(0x36);
}

// Pull out the signal number.
packet.SetFilePos(::strlen("C"));
if (packet.GetBytesLeft() < 1) {
  // Shouldn't be using a C without a signal.
  return SendIllFormedResponse(packet, "C packet specified without signal.");
}
const uint32_t signo =
    packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
if (signo == std::numeric_limits<uint32_t>::max())
  return SendIllFormedResponse(packet, "failed to parse signal number");

// Handle optional continue address.
if (packet.GetBytesLeft() > 0) {
  // FIXME add continue at address support for $C{signo}[;{continue-address}].
  if (*packet.Peek() == ';')
    return SendUnimplementedResponse(packet.GetStringRef().c_str());
  else
    return SendIllFormedResponse(
        packet, "unexpected content after $C{signal-number}");
}

ResumeActionList resume_actions(StateType::eStateRunning, 0);
Status error;

// We have two branches: what to do if a continue thread is specified (in
// which case we target sending the signal to that thread), or when we don't
// have a continue thread set (in which case we send a signal to the
// process).

// TODO discuss with Greg Clayton, make sure this makes sense.

lldb::tid_t signal_tid = GetContinueThreadID();
if (signal_tid != LLDB_INVALID_THREAD_ID0) {
  // The resume action for the continue thread (or all threads if a continue
  // thread is not set).
  ResumeAction action = {GetContinueThreadID(), StateType::eStateRunning,
                         static_cast<int>(signo)};

  // Add the action for the continue thread (or all threads when the continue
  // thread isn't present).
  resume_actions.Append(action);
} else {
  // Send the signal to the process since we weren't targeting a specific
  // continue thread with the signal.
  error = m_debugged_process_up->Signal(signo);
  if (error.Fail()) {
    LLDB_LOG(log, "failed to send signal for process {0}: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "failed to send signal for process {0}: {1}", m_debugged_process_up
->GetID(), error); } while (0)
             m_debugged_process_up->GetID(), error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "failed to send signal for process {0}: {1}", m_debugged_process_up
->GetID(), error); } while (0);

    return SendErrorResponse(0x52);
  }
}

// Resume the threads.
error = m_debugged_process_up->Resume(resume_actions);
if (error.Fail()) {
  LLDB_LOG(log, "failed to resume threads for process {0}: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "failed to resume threads for process {0}: {1}", m_debugged_process_up
->GetID(), error); } while (0)
           m_debugged_process_up->GetID(), error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "failed to resume threads for process {0}: {1}", m_debugged_process_up
->GetID(), error); } while (0);

  return SendErrorResponse(0x38);
}

// Don't send an "OK" packet; response is the stopped/exited message.
return PacketResult::Success;
1432}

1434GDBRemoteCommunication::PacketResult
1435GDBRemoteCommunicationServerLLGS::Handle_c(StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1) | LIBLLDB_LOG_THREAD(1u << 2)));
if (log)
  log->Printf("GDBRemoteCommunicationServerLLGS::%s called", __FUNCTION__);

packet.SetFilePos(packet.GetFilePos() + ::strlen("c"));

// For now just support all continue.
const bool has_continue_address = (packet.GetBytesLeft() > 0);
if (has_continue_address) {
  LLDB_LOG(log, "not implemented for c[address] variant [{0} remains]",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "not implemented for c[address] variant [{0} remains]"
, packet.Peek()); } while (0)
           packet.Peek())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "not implemented for c[address] variant [{0} remains]"
, packet.Peek()); } while (0);
  return SendUnimplementedResponse(packet.GetStringRef().c_str());
}

// Ensure we have a native process.
if (!m_debugged_process_up) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s no debugged process "
                "shared pointer",
                __FUNCTION__);
  return SendErrorResponse(0x36);
}

// Build the ResumeActionList
ResumeActionList actions(StateType::eStateRunning, 0);

Status error = m_debugged_process_up->Resume(actions);
if (error.Fail()) {
  LLDB_LOG(log, "c failed for process {0}: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "c failed for process {0}: {1}", m_debugged_process_up
->GetID(), error); } while (0)
           m_debugged_process_up->GetID(), error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "c failed for process {0}: {1}", m_debugged_process_up
->GetID(), error); } while (0);
  return SendErrorResponse(GDBRemoteServerError::eErrorResume);
}

LLDB_LOG(log, "continued process {0}", m_debugged_process_up->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "continued process {0}", m_debugged_process_up->
GetID()); } while (0);
// No response required from continue.
return PacketResult::Success;
1472}

1474GDBRemoteCommunication::PacketResult
1475GDBRemoteCommunicationServerLLGS::Handle_vCont_actions(
  StringExtractorGDBRemote &packet) {
StreamString response;
response.Printf("vCont;c;C;s;S");

return SendPacketNoLock(response.GetString());
1481}

1483GDBRemoteCommunication::PacketResult
1484GDBRemoteCommunicationServerLLGS::Handle_vCont(
  StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));
if (log)
  log->Printf("GDBRemoteCommunicationServerLLGS::%s handling vCont packet",
              __FUNCTION__);

packet.SetFilePos(::strlen("vCont"));

if (packet.GetBytesLeft() == 0) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s missing action from "
                "vCont package",
                __FUNCTION__);
  return SendIllFormedResponse(packet, "Missing action from vCont package");
}

// Check if this is all continue (no options or ";c").
if (::strcmp(packet.Peek(), ";c") == 0) {
  // Move past the ';', then do a simple 'c'.
  packet.SetFilePos(packet.GetFilePos() + 1);
  return Handle_c(packet);
} else if (::strcmp(packet.Peek(), ";s") == 0) {
  // Move past the ';', then do a simple 's'.
  packet.SetFilePos(packet.GetFilePos() + 1);
  return Handle_s(packet);
}

// Ensure we have a native process.
if (!m_debugged_process_up) {
  LLDB_LOG(log, "no debugged process")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "no debugged process"); } while (0);
  return SendErrorResponse(0x36);
}

ResumeActionList thread_actions;

while (packet.GetBytesLeft() && *packet.Peek() == ';') {
  // Skip the semi-colon.
  packet.GetChar();

  // Build up the thread action.
  ResumeAction thread_action;
  thread_action.tid = LLDB_INVALID_THREAD_ID0;
  thread_action.state = eStateInvalid;
  thread_action.signal = 0;

  const char action = packet.GetChar();
  switch (action) {
  case 'C':
    thread_action.signal = packet.GetHexMaxU32(false, 0);
    if (thread_action.signal == 0)
      return SendIllFormedResponse(
          packet, "Could not parse signal in vCont packet C action");
    LLVM_FALLTHROUGH[[clang::fallthrough]];

  case 'c':
    // Continue
    thread_action.state = eStateRunning;
    break;

  case 'S':
    thread_action.signal = packet.GetHexMaxU32(false, 0);
    if (thread_action.signal == 0)
      return SendIllFormedResponse(
          packet, "Could not parse signal in vCont packet S action");
    LLVM_FALLTHROUGH[[clang::fallthrough]];

  case 's':
    // Step
    thread_action.state = eStateStepping;
    break;

  default:
    return SendIllFormedResponse(packet, "Unsupported vCont action");
    break;
  }

  // Parse out optional :{thread-id} value.
  if (packet.GetBytesLeft() && (*packet.Peek() == ':')) {
    // Consume the separator.
    packet.GetChar();

    thread_action.tid = packet.GetHexMaxU32(false, LLDB_INVALID_THREAD_ID0);
    if (thread_action.tid == LLDB_INVALID_THREAD_ID0)
      return SendIllFormedResponse(
          packet, "Could not parse thread number in vCont packet");
  }

  thread_actions.Append(thread_action);
}

Status error = m_debugged_process_up->Resume(thread_actions);
if (error.Fail()) {
  LLDB_LOG(log, "vCont failed for process {0}: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "vCont failed for process {0}: {1}", m_debugged_process_up
->GetID(), error); } while (0)
           m_debugged_process_up->GetID(), error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "vCont failed for process {0}: {1}", m_debugged_process_up
->GetID(), error); } while (0);
  return SendErrorResponse(GDBRemoteServerError::eErrorResume);
}

LLDB_LOG(log, "continued process {0}", m_debugged_process_up->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "continued process {0}", m_debugged_process_up->
GetID()); } while (0);
// No response required from vCont.
return PacketResult::Success;
1585}

1587void GDBRemoteCommunicationServerLLGS::SetCurrentThreadID(lldb::tid_t tid) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD(1u << 2)));
LLDB_LOG(log, "setting current thread id to {0}", tid)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "setting current thread id to {0}", tid); } while
 (0);

m_current_tid = tid;
if (m_debugged_process_up)
  m_debugged_process_up->SetCurrentThreadID(m_current_tid);
1594}

1596void GDBRemoteCommunicationServerLLGS::SetContinueThreadID(lldb::tid_t tid) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD(1u << 2)));
LLDB_LOG(log, "setting continue thread id to {0}", tid)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "setting continue thread id to {0}", tid); } while
 (0);

m_continue_tid = tid;
1601}

1603GDBRemoteCommunication::PacketResult
1604GDBRemoteCommunicationServerLLGS::Handle_stop_reason(
  StringExtractorGDBRemote &packet) {
// Handle the $? gdbremote command.

// If no process, indicate error
if (!m_debugged_process_up)
  return SendErrorResponse(02);

return SendStopReasonForState(m_debugged_process_up->GetState());
1613}

1615GDBRemoteCommunication::PacketResult
1616GDBRemoteCommunicationServerLLGS::SendStopReasonForState(
  lldb::StateType process_state) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));

switch (process_state) {
case eStateAttaching:
case eStateLaunching:
case eStateRunning:
case eStateStepping:
case eStateDetached:
  // NOTE: gdb protocol doc looks like it should return $OK
  // when everything is running (i.e. no stopped result).
  return PacketResult::Success; // Ignore

case eStateSuspended:
case eStateStopped:
case eStateCrashed: {
  lldb::tid_t tid = m_debugged_process_up->GetCurrentThreadID();
  // Make sure we set the current thread so g and p packets return the data
  // the gdb will expect.
  SetCurrentThreadID(tid);
  return SendStopReplyPacketForThread(tid);
}

case eStateInvalid:
case eStateUnloaded:
case eStateExited:
  return SendWResponse(m_debugged_process_up.get());

default:
  LLDB_LOG(log, "pid {0}, current state reporting not handled: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0}, current state reporting not handled: {1}"
, m_debugged_process_up->GetID(), process_state); } while (
0)
           m_debugged_process_up->GetID(), process_state)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0}, current state reporting not handled: {1}"
, m_debugged_process_up->GetID(), process_state); } while (
0);
  break;
}

return SendErrorResponse(0);
1652}

1654GDBRemoteCommunication::PacketResult
1655GDBRemoteCommunicationServerLLGS::Handle_qRegisterInfo(
  StringExtractorGDBRemote &packet) {
// Fail if we don't have a current process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0))
  return SendErrorResponse(68);

// Ensure we have a thread.
NativeThreadProtocol *thread = m_debugged_process_up->GetThreadAtIndex(0);
if (!thread)
  return SendErrorResponse(69);

// Get the register context for the first thread.
NativeRegisterContext &reg_context = thread->GetRegisterContext();

// Parse out the register number from the request.
packet.SetFilePos(strlen("qRegisterInfo"));
const uint32_t reg_index =
    packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
if (reg_index == std::numeric_limits<uint32_t>::max())
  return SendErrorResponse(69);

// Return the end of registers response if we've iterated one past the end of
// the register set.
if (reg_index >= reg_context.GetUserRegisterCount())
  return SendErrorResponse(69);

const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index);
if (!reg_info)
  return SendErrorResponse(69);

// Build the reginfos response.
StreamGDBRemote response;

response.PutCString("name:");
response.PutCString(reg_info->name);
response.PutChar(';');

if (reg_info->alt_name && reg_info->alt_name[0]) {
  response.PutCString("alt-name:");
  response.PutCString(reg_info->alt_name);
  response.PutChar(';');
}

response.Printf("bitsize:%" PRIu32"u" ";offset:%" PRIu32"u" ";",
                reg_info->byte_size * 8, reg_info->byte_offset);

switch (reg_info->encoding) {
case eEncodingUint:
  response.PutCString("encoding:uint;");
  break;
case eEncodingSint:
  response.PutCString("encoding:sint;");
  break;
case eEncodingIEEE754:
  response.PutCString("encoding:ieee754;");
  break;
case eEncodingVector:
  response.PutCString("encoding:vector;");
  break;
default:
  break;
}

switch (reg_info->format) {
case eFormatBinary:
  response.PutCString("format:binary;");
  break;
case eFormatDecimal:
  response.PutCString("format:decimal;");
  break;
case eFormatHex:
  response.PutCString("format:hex;");
  break;
case eFormatFloat:
  response.PutCString("format:float;");
  break;
case eFormatVectorOfSInt8:
  response.PutCString("format:vector-sint8;");
  break;
case eFormatVectorOfUInt8:
  response.PutCString("format:vector-uint8;");
  break;
case eFormatVectorOfSInt16:
  response.PutCString("format:vector-sint16;");
  break;
case eFormatVectorOfUInt16:
  response.PutCString("format:vector-uint16;");
  break;
case eFormatVectorOfSInt32:
  response.PutCString("format:vector-sint32;");
  break;
case eFormatVectorOfUInt32:
  response.PutCString("format:vector-uint32;");
  break;
case eFormatVectorOfFloat32:
  response.PutCString("format:vector-float32;");
  break;
case eFormatVectorOfUInt64:
  response.PutCString("format:vector-uint64;");
  break;
case eFormatVectorOfUInt128:
  response.PutCString("format:vector-uint128;");
  break;
default:
  break;
};

const char *const register_set_name =
    reg_context.GetRegisterSetNameForRegisterAtIndex(reg_index);
if (register_set_name) {
  response.PutCString("set:");
  response.PutCString(register_set_name);
  response.PutChar(';');
}

if (reg_info->kinds[RegisterKind::eRegisterKindEHFrame] !=
    LLDB_INVALID_REGNUM(4294967295U))
  response.Printf("ehframe:%" PRIu32"u" ";",
                  reg_info->kinds[RegisterKind::eRegisterKindEHFrame]);

if (reg_info->kinds[RegisterKind::eRegisterKindDWARF] != LLDB_INVALID_REGNUM(4294967295U))
  response.Printf("dwarf:%" PRIu32"u" ";",
                  reg_info->kinds[RegisterKind::eRegisterKindDWARF]);

switch (reg_info->kinds[RegisterKind::eRegisterKindGeneric]) {
case LLDB_REGNUM_GENERIC_PC0:
  response.PutCString("generic:pc;");
  break;
case LLDB_REGNUM_GENERIC_SP1:
  response.PutCString("generic:sp;");
  break;
case LLDB_REGNUM_GENERIC_FP2:
  response.PutCString("generic:fp;");
  break;
case LLDB_REGNUM_GENERIC_RA3:
  response.PutCString("generic:ra;");
  break;
case LLDB_REGNUM_GENERIC_FLAGS4:
  response.PutCString("generic:flags;");
  break;
case LLDB_REGNUM_GENERIC_ARG15:
  response.PutCString("generic:arg1;");
  break;
case LLDB_REGNUM_GENERIC_ARG26:
  response.PutCString("generic:arg2;");
  break;
case LLDB_REGNUM_GENERIC_ARG37:
  response.PutCString("generic:arg3;");
  break;
case LLDB_REGNUM_GENERIC_ARG48:
  response.PutCString("generic:arg4;");
  break;
case LLDB_REGNUM_GENERIC_ARG59:
  response.PutCString("generic:arg5;");
  break;
case LLDB_REGNUM_GENERIC_ARG610:
  response.PutCString("generic:arg6;");
  break;
case LLDB_REGNUM_GENERIC_ARG711:
  response.PutCString("generic:arg7;");
  break;
case LLDB_REGNUM_GENERIC_ARG812:
  response.PutCString("generic:arg8;");
  break;
default:
  break;
}

if (reg_info->value_regs && reg_info->value_regs[0] != LLDB_INVALID_REGNUM(4294967295U)) {
  response.PutCString("container-regs:");
  int i = 0;
  for (const uint32_t *reg_num = reg_info->value_regs;
       *reg_num != LLDB_INVALID_REGNUM(4294967295U); ++reg_num, ++i) {
    if (i > 0)
      response.PutChar(',');
    response.Printf("%" PRIx32"x", *reg_num);
  }
  response.PutChar(';');
}

if (reg_info->invalidate_regs && reg_info->invalidate_regs[0]) {
  response.PutCString("invalidate-regs:");
  int i = 0;
  for (const uint32_t *reg_num = reg_info->invalidate_regs;
       *reg_num != LLDB_INVALID_REGNUM(4294967295U); ++reg_num, ++i) {
    if (i > 0)
      response.PutChar(',');
    response.Printf("%" PRIx32"x", *reg_num);
  }
  response.PutChar(';');
}

if (reg_info->dynamic_size_dwarf_expr_bytes) {
  const size_t dwarf_opcode_len = reg_info->dynamic_size_dwarf_len;
  response.PutCString("dynamic_size_dwarf_expr_bytes:");
  for (uint32_t i = 0; i < dwarf_opcode_len; ++i)
    response.PutHex8(reg_info->dynamic_size_dwarf_expr_bytes[i]);
  response.PutChar(';');
}
return SendPacketNoLock(response.GetString());
1856}

1858GDBRemoteCommunication::PacketResult
1859GDBRemoteCommunicationServerLLGS::Handle_qfThreadInfo(
  StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD(1u << 2)));

// Fail if we don't have a current process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0)) {
  LLDB_LOG(log, "no process ({0}), returning OK",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "no process ({0}), returning OK", m_debugged_process_up
 ? "invalid process id" : "null m_debugged_process_up"); } while
 (0)
           m_debugged_process_up ? "invalid process id"do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "no process ({0}), returning OK", m_debugged_process_up
 ? "invalid process id" : "null m_debugged_process_up"); } while
 (0)
                                 : "null m_debugged_process_up")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "no process ({0}), returning OK", m_debugged_process_up
 ? "invalid process id" : "null m_debugged_process_up"); } while
 (0);
  return SendOKResponse();
}

StreamGDBRemote response;
response.PutChar('m');

LLDB_LOG(log, "starting thread iteration")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "starting thread iteration"); } while (0);
NativeThreadProtocol *thread;
uint32_t thread_index;
for (thread_index = 0,
    thread = m_debugged_process_up->GetThreadAtIndex(thread_index);
     thread; ++thread_index,
    thread = m_debugged_process_up->GetThreadAtIndex(thread_index)) {
  LLDB_LOG(log, "iterated thread {0}(tid={2})", thread_index,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "iterated thread {0}(tid={2})", thread_index, thread
->GetID()); } while (0)
           thread->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "iterated thread {0}(tid={2})", thread_index, thread
->GetID()); } while (0);
  if (thread_index > 0)
    response.PutChar(',');
  response.Printf("%" PRIx64"l" "x", thread->GetID());
}

LLDB_LOG(log, "finished thread iteration")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "finished thread iteration"); } while (0);
return SendPacketNoLock(response.GetString());
1891}

1893GDBRemoteCommunication::PacketResult
1894GDBRemoteCommunicationServerLLGS::Handle_qsThreadInfo(
  StringExtractorGDBRemote &packet) {
// FIXME for now we return the full thread list in the initial packet and
// always do nothing here.
return SendPacketNoLock("l");
1899}

1901GDBRemoteCommunication::PacketResult
1902GDBRemoteCommunicationServerLLGS::Handle_p(StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD(1u << 2)));

// Parse out the register number from the request.
packet.SetFilePos(strlen("p"));
const uint32_t reg_index =
    packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
if (reg_index == std::numeric_limits<uint32_t>::max()) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not "
                "parse register number from request \"%s\"",
                __FUNCTION__, packet.GetStringRef().c_str());
  return SendErrorResponse(0x15);
}

// Get the thread to use.
NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
if (!thread) {
  LLDB_LOG(log, "failed, no thread available")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "failed, no thread available"); } while (0);
  return SendErrorResponse(0x15);
}

// Get the thread's register context.
NativeRegisterContext &reg_context = thread->GetRegisterContext();

// Return the end of registers response if we've iterated one past the end of
// the register set.
if (reg_index >= reg_context.GetUserRegisterCount()) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
                "register %" PRIu32"u" " beyond register count %" PRIu32"u",
                __FUNCTION__, reg_index,
                reg_context.GetUserRegisterCount());
  return SendErrorResponse(0x15);
}

const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index);
if (!reg_info) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
                "register %" PRIu32"u" " returned NULL",
                __FUNCTION__, reg_index);
  return SendErrorResponse(0x15);
}

// Build the reginfos response.
StreamGDBRemote response;

// Retrieve the value
RegisterValue reg_value;
Status error = reg_context.ReadRegister(reg_info, reg_value);
if (error.Fail()) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, read of "
                "requested register %" PRIu32"u" " (%s) failed: %s",
                __FUNCTION__, reg_index, reg_info->name, error.AsCString());
  return SendErrorResponse(0x15);
}

const uint8_t *const data =
    reinterpret_cast<const uint8_t *>(reg_value.GetBytes());
if (!data) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to get data "
                "bytes from requested register %" PRIu32"u",
                __FUNCTION__, reg_index);
  return SendErrorResponse(0x15);
}

// FIXME flip as needed to get data in big/little endian format for this host.
for (uint32_t i = 0; i < reg_value.GetByteSize(); ++i)
  response.PutHex8(data[i]);

return SendPacketNoLock(response.GetString());
1976}

1978GDBRemoteCommunication::PacketResult
1979GDBRemoteCommunicationServerLLGS::Handle_P(StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD(1u << 2)));

// Ensure there is more content.
if (packet.GetBytesLeft() < 1)
  return SendIllFormedResponse(packet, "Empty P packet");

// Parse out the register number from the request.
packet.SetFilePos(strlen("P"));
const uint32_t reg_index =
    packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
if (reg_index == std::numeric_limits<uint32_t>::max()) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not "
                "parse register number from request \"%s\"",
                __FUNCTION__, packet.GetStringRef().c_str());
  return SendErrorResponse(0x29);
}

// Note debugserver would send an E30 here.
if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != '='))
  return SendIllFormedResponse(
      packet, "P packet missing '=' char after register number");

// Parse out the value.
uint8_t reg_bytes[32]; // big enough to support up to 256 bit ymmN register
size_t reg_size = packet.GetHexBytesAvail(reg_bytes);

// Get the thread to use.
NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
if (!thread) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, no thread "
                "available (thread index 0)",
                __FUNCTION__);
  return SendErrorResponse(0x28);
}

// Get the thread's register context.
NativeRegisterContext &reg_context = thread->GetRegisterContext();
const RegisterInfo *reg_info = reg_context.GetRegisterInfoAtIndex(reg_index);
if (!reg_info) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
                "register %" PRIu32"u" " returned NULL",
                __FUNCTION__, reg_index);
  return SendErrorResponse(0x48);
}

// Return the end of registers response if we've iterated one past the end of
// the register set.
if (reg_index >= reg_context.GetUserRegisterCount()) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, requested "
                "register %" PRIu32"u" " beyond register count %" PRIu32"u",
                __FUNCTION__, reg_index, reg_context.GetUserRegisterCount());
  return SendErrorResponse(0x47);
}

// The dwarf expression are evaluate on host site which may cause register
// size to change Hence the reg_size may not be same as reg_info->bytes_size
if ((reg_size != reg_info->byte_size) &&
    !(reg_info->dynamic_size_dwarf_expr_bytes)) {
  return SendIllFormedResponse(packet, "P packet register size is incorrect");
}

// Build the reginfos response.
StreamGDBRemote response;

RegisterValue reg_value(
    reg_bytes, reg_size,
    m_debugged_process_up->GetArchitecture().GetByteOrder());
Status error = reg_context.WriteRegister(reg_info, reg_value);
if (error.Fail()) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, write of "
                "requested register %" PRIu32"u" " (%s) failed: %s",
                __FUNCTION__, reg_index, reg_info->name, error.AsCString());
  return SendErrorResponse(0x32);
}

return SendOKResponse();
2061}

2063GDBRemoteCommunication::PacketResult
2064GDBRemoteCommunicationServerLLGS::Handle_H(StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD(1u << 2)));

// Fail if we don't have a current process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0)) {
  if (log)
    log->Printf(
        "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
        __FUNCTION__);
  return SendErrorResponse(0x15);
}

// Parse out which variant of $H is requested.
packet.SetFilePos(strlen("H"));
if (packet.GetBytesLeft() < 1) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, H command "
                "missing {g,c} variant",
                __FUNCTION__);
  return SendIllFormedResponse(packet, "H command missing {g,c} variant");
}

const char h_variant = packet.GetChar();
switch (h_variant) {
case 'g':
  break;

case 'c':
  break;

default:
  if (log)
    log->Printf(
        "GDBRemoteCommunicationServerLLGS::%s failed, invalid $H variant %c",
        __FUNCTION__, h_variant);
  return SendIllFormedResponse(packet,
                               "H variant unsupported, should be c or g");
}

// Parse out the thread number.
// FIXME return a parse success/fail value.  All values are valid here.
const lldb::tid_t tid =
    packet.GetHexMaxU64(false, std::numeric_limits<lldb::tid_t>::max());

// Ensure we have the given thread when not specifying -1 (all threads) or 0
// (any thread).
if (tid != LLDB_INVALID_THREAD_ID0 && tid != 0) {
  NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid);
  if (!thread) {
    if (log)
      log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, tid %" PRIu64"l" "u"
                  " not found",
                  __FUNCTION__, tid);
    return SendErrorResponse(0x15);
  }
}

// Now switch the given thread type.
switch (h_variant) {
case 'g':
  SetCurrentThreadID(tid);
  break;

case 'c':
  SetContinueThreadID(tid);
  break;

default:
  assert(false && "unsupported $H variant - shouldn't get here")((false && "unsupported $H variant - shouldn't get here"
) ? static_cast<void> (0) : __assert_fail ("false && \"unsupported $H variant - shouldn't get here\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, 2133, __PRETTY_FUNCTION__));
  return SendIllFormedResponse(packet,
                               "H variant unsupported, should be c or g");
}

return SendOKResponse();
2139}

2141GDBRemoteCommunication::PacketResult
2142GDBRemoteCommunicationServerLLGS::Handle_I(StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD(1u << 2)));

// Fail if we don't have a current process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0)) {
  if (log)
    log->Printf(
        "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
        __FUNCTION__);
  return SendErrorResponse(0x15);
}

packet.SetFilePos(::strlen("I"));
uint8_t tmp[4096];
for (;;) {
  size_t read = packet.GetHexBytesAvail(tmp);
  if (read == 0) {
    break;
  }
  // write directly to stdin *this might block if stdin buffer is full*
  // TODO: enqueue this block in circular buffer and send window size to
  // remote host
  ConnectionStatus status;
  Status error;
  m_stdio_communication.Write(tmp, read, status, &error);
  if (error.Fail()) {
    return SendErrorResponse(0x15);
  }
}

return SendOKResponse();
2174}

2176GDBRemoteCommunication::PacketResult
2177GDBRemoteCommunicationServerLLGS::Handle_interrupt(
  StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1) | LIBLLDB_LOG_THREAD(1u << 2)));

// Fail if we don't have a current process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0)) {
  LLDB_LOG(log, "failed, no process available")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "failed, no process available"); } while (0);
  return SendErrorResponse(0x15);
}

// Interrupt the process.
Status error = m_debugged_process_up->Interrupt();
if (error.Fail()) {
  LLDB_LOG(log, "failed for process {0}: {1}", m_debugged_process_up->GetID(),do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "failed for process {0}: {1}", m_debugged_process_up
->GetID(), error); } while (0)
           error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "failed for process {0}: {1}", m_debugged_process_up
->GetID(), error); } while (0);
  return SendErrorResponse(GDBRemoteServerError::eErrorResume);
}

LLDB_LOG(log, "stopped process {0}", m_debugged_process_up->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "stopped process {0}", m_debugged_process_up->
GetID()); } while (0);

// No response required from stop all.
return PacketResult::Success;
2200}

2202GDBRemoteCommunication::PacketResult
2203GDBRemoteCommunicationServerLLGS::Handle_memory_read(
  StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));

if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0)) {
  if (log)
    log->Printf(
        "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
        __FUNCTION__);
  return SendErrorResponse(0x15);
}

// Parse out the memory address.
packet.SetFilePos(strlen("m"));
if (packet.GetBytesLeft() < 1)
  return SendIllFormedResponse(packet, "Too short m packet");

// Read the address.  Punting on validation.
// FIXME replace with Hex U64 read with no default value that fails on failed
// read.
const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0);

// Validate comma.
if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ','))
  return SendIllFormedResponse(packet, "Comma sep missing in m packet");

// Get # bytes to read.
if (packet.GetBytesLeft() < 1)
  return SendIllFormedResponse(packet, "Length missing in m packet");

const uint64_t byte_count = packet.GetHexMaxU64(false, 0);
if (byte_count == 0) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s nothing to read: "
                "zero-length packet",
                __FUNCTION__);
  return SendOKResponse();
}

// Allocate the response buffer.
std::string buf(byte_count, '\0');
if (buf.empty())
  return SendErrorResponse(0x78);

// Retrieve the process memory.
size_t bytes_read = 0;
Status error = m_debugged_process_up->ReadMemoryWithoutTrap(
    read_addr, &buf[0], byte_count, bytes_read);
if (error.Fail()) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64"l" "u"
                " mem 0x%" PRIx64"l" "x" ": failed to read. Error: %s",
                __FUNCTION__, m_debugged_process_up->GetID(), read_addr,
                error.AsCString());
  return SendErrorResponse(0x08);
}

if (bytes_read == 0) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64"l" "u"
                " mem 0x%" PRIx64"l" "x" ": read 0 of %" PRIu64"l" "u" " requested bytes",
                __FUNCTION__, m_debugged_process_up->GetID(), read_addr,
                byte_count);
  return SendErrorResponse(0x08);
}

StreamGDBRemote response;
packet.SetFilePos(0);
char kind = packet.GetChar('?');
if (kind == 'x')
  response.PutEscapedBytes(buf.data(), byte_count);
else {
  assert(kind == 'm')((kind == 'm') ? static_cast<void> (0) : __assert_fail (
"kind == 'm'", "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, 2276, __PRETTY_FUNCTION__));
  for (size_t i = 0; i < bytes_read; ++i)
    response.PutHex8(buf[i]);
}

return SendPacketNoLock(response.GetString());
2282}

2284GDBRemoteCommunication::PacketResult
2285GDBRemoteCommunicationServerLLGS::Handle_M(StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));

if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0)) {
  if (log)
    log->Printf(
        "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
        __FUNCTION__);
  return SendErrorResponse(0x15);
}

// Parse out the memory address.
packet.SetFilePos(strlen("M"));
if (packet.GetBytesLeft() < 1)
  return SendIllFormedResponse(packet, "Too short M packet");

// Read the address.  Punting on validation.
// FIXME replace with Hex U64 read with no default value that fails on failed
// read.
const lldb::addr_t write_addr = packet.GetHexMaxU64(false, 0);

// Validate comma.
if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ','))
  return SendIllFormedResponse(packet, "Comma sep missing in M packet");

// Get # bytes to read.
if (packet.GetBytesLeft() < 1)
  return SendIllFormedResponse(packet, "Length missing in M packet");

const uint64_t byte_count = packet.GetHexMaxU64(false, 0);
if (byte_count == 0) {
  LLDB_LOG(log, "nothing to write: zero-length packet")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "nothing to write: zero-length packet"); } while (
0);
  return PacketResult::Success;
}

// Validate colon.
if ((packet.GetBytesLeft() < 1) || (packet.GetChar() != ':'))
  return SendIllFormedResponse(
      packet, "Comma sep missing in M packet after byte length");

// Allocate the conversion buffer.
std::vector<uint8_t> buf(byte_count, 0);
if (buf.empty())
  return SendErrorResponse(0x78);

// Convert the hex memory write contents to bytes.
StreamGDBRemote response;
const uint64_t convert_count = packet.GetHexBytes(buf, 0);
if (convert_count != byte_count) {
  LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} mem {1:x}: asked to write {2} bytes, but only found {3} "
 "to convert.", m_debugged_process_up->GetID(), write_addr
, byte_count, convert_count); } while (0)
           "pid {0} mem {1:x}: asked to write {2} bytes, but only found {3} "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} mem {1:x}: asked to write {2} bytes, but only found {3} "
 "to convert.", m_debugged_process_up->GetID(), write_addr
, byte_count, convert_count); } while (0)
           "to convert.",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} mem {1:x}: asked to write {2} bytes, but only found {3} "
 "to convert.", m_debugged_process_up->GetID(), write_addr
, byte_count, convert_count); } while (0)
           m_debugged_process_up->GetID(), write_addr, byte_count,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} mem {1:x}: asked to write {2} bytes, but only found {3} "
 "to convert.", m_debugged_process_up->GetID(), write_addr
, byte_count, convert_count); } while (0)
           convert_count)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} mem {1:x}: asked to write {2} bytes, but only found {3} "
 "to convert.", m_debugged_process_up->GetID(), write_addr
, byte_count, convert_count); } while (0);
  return SendIllFormedResponse(packet, "M content byte length specified did "
                                       "not match hex-encoded content "
                                       "length");
}

// Write the process memory.
size_t bytes_written = 0;
Status error = m_debugged_process_up->WriteMemory(write_addr, &buf[0],
                                                  byte_count, bytes_written);
if (error.Fail()) {
  LLDB_LOG(log, "pid {0} mem {1:x}: failed to write. Error: {2}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} mem {1:x}: failed to write. Error: {2}",
 m_debugged_process_up->GetID(), write_addr, error); } while
 (0)
           m_debugged_process_up->GetID(), write_addr, error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} mem {1:x}: failed to write. Error: {2}",
 m_debugged_process_up->GetID(), write_addr, error); } while
 (0);
  return SendErrorResponse(0x09);
}

if (bytes_written == 0) {
  LLDB_LOG(log, "pid {0} mem {1:x}: wrote 0 of {2} requested bytes",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} mem {1:x}: wrote 0 of {2} requested bytes"
, m_debugged_process_up->GetID(), write_addr, byte_count);
 } while (0)
           m_debugged_process_up->GetID(), write_addr, byte_count)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} mem {1:x}: wrote 0 of {2} requested bytes"
, m_debugged_process_up->GetID(), write_addr, byte_count);
 } while (0);
  return SendErrorResponse(0x09);
}

return SendOKResponse();
2362}

2364GDBRemoteCommunication::PacketResult
2365GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfoSupported(
  StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));

// Currently only the NativeProcessProtocol knows if it can handle a
// qMemoryRegionInfoSupported request, but we're not guaranteed to be
// attached to a process.  For now we'll assume the client only asks this
// when a process is being debugged.

// Ensure we have a process running; otherwise, we can't figure this out
// since we won't have a NativeProcessProtocol.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0)) {
  if (log)
    log->Printf(
        "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
        __FUNCTION__);
  return SendErrorResponse(0x15);
}

// Test if we can get any region back when asking for the region around NULL.
MemoryRegionInfo region_info;
const Status error =
    m_debugged_process_up->GetMemoryRegionInfo(0, region_info);
if (error.Fail()) {
  // We don't support memory region info collection for this
  // NativeProcessProtocol.
  return SendUnimplementedResponse("");
}

return SendOKResponse();
2396}

2398GDBRemoteCommunication::PacketResult
2399GDBRemoteCommunicationServerLLGS::Handle_qMemoryRegionInfo(
  StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));

// Ensure we have a process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0)) {
  if (log)
    log->Printf(
        "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
        __FUNCTION__);
  return SendErrorResponse(0x15);
}

// Parse out the memory address.
packet.SetFilePos(strlen("qMemoryRegionInfo:"));
if (packet.GetBytesLeft() < 1)
  return SendIllFormedResponse(packet, "Too short qMemoryRegionInfo: packet");

// Read the address.  Punting on validation.
const lldb::addr_t read_addr = packet.GetHexMaxU64(false, 0);

StreamGDBRemote response;

// Get the memory region info for the target address.
MemoryRegionInfo region_info;
const Status error =
    m_debugged_process_up->GetMemoryRegionInfo(read_addr, region_info);
if (error.Fail()) {
  // Return the error message.

  response.PutCString("error:");
  response.PutCStringAsRawHex8(error.AsCString());
  response.PutChar(';');
} else {
  // Range start and size.
  response.Printf("start:%" PRIx64"l" "x" ";size:%" PRIx64"l" "x" ";",
                  region_info.GetRange().GetRangeBase(),
                  region_info.GetRange().GetByteSize());

  // Permissions.
  if (region_info.GetReadable() || region_info.GetWritable() ||
      region_info.GetExecutable()) {
    // Write permissions info.
    response.PutCString("permissions:");

    if (region_info.GetReadable())
      response.PutChar('r');
    if (region_info.GetWritable())
      response.PutChar('w');
    if (region_info.GetExecutable())
      response.PutChar('x');

    response.PutChar(';');
  }

  // Name
  ConstString name = region_info.GetName();
  if (name) {
    response.PutCString("name:");
    response.PutCStringAsRawHex8(name.AsCString());
    response.PutChar(';');
  }
}

return SendPacketNoLock(response.GetString());
2465}

2467GDBRemoteCommunication::PacketResult
2468GDBRemoteCommunicationServerLLGS::Handle_Z(StringExtractorGDBRemote &packet) {
// Ensure we have a process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0)) {
  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));
  LLDB_LOG(log, "failed, no process available")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "failed, no process available"); } while (0);
  return SendErrorResponse(0x15);
}

// Parse out software or hardware breakpoint or watchpoint requested.
packet.SetFilePos(strlen("Z"));
if (packet.GetBytesLeft() < 1)
  return SendIllFormedResponse(
      packet, "Too short Z packet, missing software/hardware specifier");

bool want_breakpoint = true;
bool want_hardware = false;
uint32_t watch_flags = 0;

const GDBStoppointType stoppoint_type =
    GDBStoppointType(packet.GetS32(eStoppointInvalid));
switch (stoppoint_type) {
case eBreakpointSoftware:
  want_hardware = false;
  want_breakpoint = true;
  break;
case eBreakpointHardware:
  want_hardware = true;
  want_breakpoint = true;
  break;
case eWatchpointWrite:
  watch_flags = 1;
  want_hardware = true;
  want_breakpoint = false;
  break;
case eWatchpointRead:
  watch_flags = 2;
  want_hardware = true;
  want_breakpoint = false;
  break;
case eWatchpointReadWrite:
  watch_flags = 3;
  want_hardware = true;
  want_breakpoint = false;
  break;
case eStoppointInvalid:
  return SendIllFormedResponse(
      packet, "Z packet had invalid software/hardware specifier");
}

if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',')
  return SendIllFormedResponse(
      packet, "Malformed Z packet, expecting comma after stoppoint type");

// Parse out the stoppoint address.
if (packet.GetBytesLeft() < 1)
  return SendIllFormedResponse(packet, "Too short Z packet, missing address");
const lldb::addr_t addr = packet.GetHexMaxU64(false, 0);

if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',')
  return SendIllFormedResponse(
      packet, "Malformed Z packet, expecting comma after address");

// Parse out the stoppoint size (i.e. size hint for opcode size).
const uint32_t size =
    packet.GetHexMaxU32(false, std::numeric_limits<uint32_t>::max());
if (size == std::numeric_limits<uint32_t>::max())
  return SendIllFormedResponse(
      packet, "Malformed Z packet, failed to parse size argument");

if (want_breakpoint) {
  // Try to set the breakpoint.
  const Status error =
      m_debugged_process_up->SetBreakpoint(addr, size, want_hardware);
  if (error.Success())
    return SendOKResponse();
  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS(1u << 5)));
  LLDB_LOG(log, "pid {0} failed to set breakpoint: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} failed to set breakpoint: {1}", m_debugged_process_up
->GetID(), error); } while (0)
           m_debugged_process_up->GetID(), error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} failed to set breakpoint: {1}", m_debugged_process_up
->GetID(), error); } while (0);
  return SendErrorResponse(0x09);
} else {
  // Try to set the watchpoint.
  const Status error = m_debugged_process_up->SetWatchpoint(
      addr, size, watch_flags, want_hardware);
  if (error.Success())
    return SendOKResponse();
  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS(1u << 6)));
  LLDB_LOG(log, "pid {0} failed to set watchpoint: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} failed to set watchpoint: {1}", m_debugged_process_up
->GetID(), error); } while (0)
           m_debugged_process_up->GetID(), error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} failed to set watchpoint: {1}", m_debugged_process_up
->GetID(), error); } while (0);
  return SendErrorResponse(0x09);
}
2559}

2561GDBRemoteCommunication::PacketResult
2562GDBRemoteCommunicationServerLLGS::Handle_z(StringExtractorGDBRemote &packet) {
// Ensure we have a process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0)) {
  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));
  LLDB_LOG(log, "failed, no process available")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "failed, no process available"); } while (0);
  return SendErrorResponse(0x15);
}

// Parse out software or hardware breakpoint or watchpoint requested.
packet.SetFilePos(strlen("z"));
if (packet.GetBytesLeft() < 1)
  return SendIllFormedResponse(
      packet, "Too short z packet, missing software/hardware specifier");

bool want_breakpoint = true;
bool want_hardware = false;

const GDBStoppointType stoppoint_type =
    GDBStoppointType(packet.GetS32(eStoppointInvalid));
switch (stoppoint_type) {
case eBreakpointHardware:
  want_breakpoint = true;
  want_hardware = true;
  break;
case eBreakpointSoftware:
  want_breakpoint = true;
  break;
case eWatchpointWrite:
  want_breakpoint = false;
  break;
case eWatchpointRead:
  want_breakpoint = false;
  break;
case eWatchpointReadWrite:
  want_breakpoint = false;
  break;
default:
  return SendIllFormedResponse(
      packet, "z packet had invalid software/hardware specifier");
}

if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',')
  return SendIllFormedResponse(
      packet, "Malformed z packet, expecting comma after stoppoint type");

// Parse out the stoppoint address.
if (packet.GetBytesLeft() < 1)
  return SendIllFormedResponse(packet, "Too short z packet, missing address");
const lldb::addr_t addr = packet.GetHexMaxU64(false, 0);

if ((packet.GetBytesLeft() < 1) || packet.GetChar() != ',')
  return SendIllFormedResponse(
      packet, "Malformed z packet, expecting comma after address");

/*
// Parse out the stoppoint size (i.e. size hint for opcode size).
const uint32_t size = packet.GetHexMaxU32 (false,
std::numeric_limits<uint32_t>::max ());
if (size == std::numeric_limits<uint32_t>::max ())
    return SendIllFormedResponse(packet, "Malformed z packet, failed to parse
size argument");
*/

if (want_breakpoint) {
  // Try to clear the breakpoint.
  const Status error =
      m_debugged_process_up->RemoveBreakpoint(addr, want_hardware);
  if (error.Success())
    return SendOKResponse();
  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS(1u << 5)));
  LLDB_LOG(log, "pid {0} failed to remove breakpoint: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} failed to remove breakpoint: {1}", m_debugged_process_up
->GetID(), error); } while (0)
           m_debugged_process_up->GetID(), error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} failed to remove breakpoint: {1}", m_debugged_process_up
->GetID(), error); } while (0);
  return SendErrorResponse(0x09);
} else {
  // Try to clear the watchpoint.
  const Status error = m_debugged_process_up->RemoveWatchpoint(addr);
  if (error.Success())
    return SendOKResponse();
  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS(1u << 6)));
  LLDB_LOG(log, "pid {0} failed to remove watchpoint: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} failed to remove watchpoint: {1}", m_debugged_process_up
->GetID(), error); } while (0)
           m_debugged_process_up->GetID(), error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} failed to remove watchpoint: {1}", m_debugged_process_up
->GetID(), error); } while (0);
  return SendErrorResponse(0x09);
}
2646}

2648GDBRemoteCommunication::PacketResult
2649GDBRemoteCommunicationServerLLGS::Handle_s(StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1) | LIBLLDB_LOG_THREAD(1u << 2)));

// Ensure we have a process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0)) {
  if (log)
    log->Printf(
        "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
        __FUNCTION__);
  return SendErrorResponse(0x32);
}

// We first try to use a continue thread id.  If any one or any all set, use
// the current thread. Bail out if we don't have a thread id.
lldb::tid_t tid = GetContinueThreadID();
if (tid == 0 || tid == LLDB_INVALID_THREAD_ID0)
  tid = GetCurrentThreadID();
if (tid == LLDB_INVALID_THREAD_ID0)
  return SendErrorResponse(0x33);

// Double check that we have such a thread.
// TODO investigate: on MacOSX we might need to do an UpdateThreads () here.
NativeThreadProtocol *thread = m_debugged_process_up->GetThreadByID(tid);
if (!thread)
  return SendErrorResponse(0x33);

// Create the step action for the given thread.
ResumeAction action = {tid, eStateStepping, 0};

// Setup the actions list.
ResumeActionList actions;
actions.Append(action);

// All other threads stop while we're single stepping a thread.
actions.SetDefaultThreadActionIfNeeded(eStateStopped, 0);
Status error = m_debugged_process_up->Resume(actions);
if (error.Fail()) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64"l" "u"
                " tid %" PRIu64"l" "u" " Resume() failed with error: %s",
                __FUNCTION__, m_debugged_process_up->GetID(), tid,
                error.AsCString());
  return SendErrorResponse(0x49);
}

// No response here - the stop or exit will come from the resulting action.
return PacketResult::Success;
2697}

2699GDBRemoteCommunication::PacketResult
2700GDBRemoteCommunicationServerLLGS::Handle_qXfer_auxv_read(
  StringExtractorGDBRemote &packet) {
2702// *BSD impls should be able to do this too.
2703#if defined(__linux__1) || defined(__NetBSD__)
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));

// Parse out the offset.
packet.SetFilePos(strlen("qXfer:auxv:read::"));
if (packet.GetBytesLeft() < 1)
  return SendIllFormedResponse(packet,
                               "qXfer:auxv:read:: packet missing offset");

const uint64_t auxv_offset =
    packet.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max());
if (auxv_offset == std::numeric_limits<uint64_t>::max())
  return SendIllFormedResponse(packet,
                               "qXfer:auxv:read:: packet missing offset");

// Parse out comma.
if (packet.GetBytesLeft() < 1 || packet.GetChar() != ',')
  return SendIllFormedResponse(
      packet, "qXfer:auxv:read:: packet missing comma after offset");

// Parse out the length.
const uint64_t auxv_length =
    packet.GetHexMaxU64(false, std::numeric_limits<uint64_t>::max());
if (auxv_length == std::numeric_limits<uint64_t>::max())
  return SendIllFormedResponse(packet,
                               "qXfer:auxv:read:: packet missing length");

// Grab the auxv data if we need it.
if (!m_active_auxv_buffer_up) {
  // Make sure we have a valid process.
  if (!m_debugged_process_up ||
      (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0)) {
    if (log)
      log->Printf(
          "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
          __FUNCTION__);
    return SendErrorResponse(0x10);
  }

  // Grab the auxv data.
  auto buffer_or_error = m_debugged_process_up->GetAuxvData();
  if (!buffer_or_error) {
    std::error_code ec = buffer_or_error.getError();
    LLDB_LOG(log, "no auxv data retrieved: {0}", ec.message())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "no auxv data retrieved: {0}", ec.message()); } while
 (0);
    return SendErrorResponse(ec.value());
  }
  m_active_auxv_buffer_up = std::move(*buffer_or_error);
}

StreamGDBRemote response;
bool done_with_buffer = false;

llvm::StringRef buffer = m_active_auxv_buffer_up->getBuffer();
if (auxv_offset >= buffer.size()) {
  // We have nothing left to send.  Mark the buffer as complete.
  response.PutChar('l');
  done_with_buffer = true;
} else {
  // Figure out how many bytes are available starting at the given offset.
  buffer = buffer.drop_front(auxv_offset);

  // Mark the response type according to whether we're reading the remainder
  // of the auxv data.
  if (auxv_length >= buffer.size()) {
    // There will be nothing left to read after this
    response.PutChar('l');
    done_with_buffer = true;
  } else {
    // There will still be bytes to read after this request.
    response.PutChar('m');
    buffer = buffer.take_front(auxv_length);
  }

  // Now write the data in encoded binary form.
  response.PutEscapedBytes(buffer.data(), buffer.size());
}

if (done_with_buffer)
  m_active_auxv_buffer_up.reset();

return SendPacketNoLock(response.GetString());
2784#else
return SendUnimplementedResponse("not implemented on this platform");
2786#endif
2787}

2789GDBRemoteCommunication::PacketResult
2790GDBRemoteCommunicationServerLLGS::Handle_QSaveRegisterState(
  StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD(1u << 2)));

// Move past packet name.
packet.SetFilePos(strlen("QSaveRegisterState"));

// Get the thread to use.
NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
if (!thread) {
  if (m_thread_suffix_supported)
    return SendIllFormedResponse(
        packet, "No thread specified in QSaveRegisterState packet");
  else
    return SendIllFormedResponse(packet,
                                 "No thread was is set with the Hg packet");
}

// Grab the register context for the thread.
NativeRegisterContext& reg_context = thread->GetRegisterContext();

// Save registers to a buffer.
DataBufferSP register_data_sp;
Status error = reg_context.ReadAllRegisterValues(register_data_sp);
if (error.Fail()) {
  LLDB_LOG(log, "pid {0} failed to save all register values: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} failed to save all register values: {1}"
, m_debugged_process_up->GetID(), error); } while (0)
           m_debugged_process_up->GetID(), error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} failed to save all register values: {1}"
, m_debugged_process_up->GetID(), error); } while (0);
  return SendErrorResponse(0x75);
}

// Allocate a new save id.
const uint32_t save_id = GetNextSavedRegistersID();
assert((m_saved_registers_map.find(save_id) == m_saved_registers_map.end()) &&(((m_saved_registers_map.find(save_id) == m_saved_registers_map
.end()) && "GetNextRegisterSaveID() returned an existing register save id"
) ? static_cast<void> (0) : __assert_fail ("(m_saved_registers_map.find(save_id) == m_saved_registers_map.end()) && \"GetNextRegisterSaveID() returned an existing register save id\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, 2823, __PRETTY_FUNCTION__))
       "GetNextRegisterSaveID() returned an existing register save id")(((m_saved_registers_map.find(save_id) == m_saved_registers_map
.end()) && "GetNextRegisterSaveID() returned an existing register save id"
) ? static_cast<void> (0) : __assert_fail ("(m_saved_registers_map.find(save_id) == m_saved_registers_map.end()) && \"GetNextRegisterSaveID() returned an existing register save id\""
, "/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, 2823, __PRETTY_FUNCTION__));

// Save the register data buffer under the save id.
{
  std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
  m_saved_registers_map[save_id] = register_data_sp;
}

// Write the response.
StreamGDBRemote response;
response.Printf("%" PRIu32"u", save_id);
return SendPacketNoLock(response.GetString());
2835}

2837GDBRemoteCommunication::PacketResult
2838GDBRemoteCommunicationServerLLGS::Handle_QRestoreRegisterState(
  StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD(1u << 2)));

// Parse out save id.
packet.SetFilePos(strlen("QRestoreRegisterState:"));
if (packet.GetBytesLeft() < 1)
  return SendIllFormedResponse(
      packet, "QRestoreRegisterState packet missing register save id");

const uint32_t save_id = packet.GetU32(0);
if (save_id == 0) {
  LLDB_LOG(log, "QRestoreRegisterState packet has malformed save id, "do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "QRestoreRegisterState packet has malformed save id, "
 "expecting decimal uint32_t"); } while (0)
                "expecting decimal uint32_t")do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "QRestoreRegisterState packet has malformed save id, "
 "expecting decimal uint32_t"); } while (0);
  return SendErrorResponse(0x76);
}

// Get the thread to use.
NativeThreadProtocol *thread = GetThreadFromSuffix(packet);
if (!thread) {
  if (m_thread_suffix_supported)
    return SendIllFormedResponse(
        packet, "No thread specified in QRestoreRegisterState packet");
  else
    return SendIllFormedResponse(packet,
                                 "No thread was is set with the Hg packet");
}

// Grab the register context for the thread.
NativeRegisterContext &reg_context = thread->GetRegisterContext();

// Retrieve register state buffer, then remove from the list.
DataBufferSP register_data_sp;
{
  std::lock_guard<std::mutex> guard(m_saved_registers_mutex);

  // Find the register set buffer for the given save id.
  auto it = m_saved_registers_map.find(save_id);
  if (it == m_saved_registers_map.end()) {
    LLDB_LOG(log,do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} does not have a register set save buffer for id {1}"
, m_debugged_process_up->GetID(), save_id); } while (0)
             "pid {0} does not have a register set save buffer for id {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} does not have a register set save buffer for id {1}"
, m_debugged_process_up->GetID(), save_id); } while (0)
             m_debugged_process_up->GetID(), save_id)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} does not have a register set save buffer for id {1}"
, m_debugged_process_up->GetID(), save_id); } while (0);
    return SendErrorResponse(0x77);
  }
  register_data_sp = it->second;

  // Remove it from the map.
  m_saved_registers_map.erase(it);
}

Status error = reg_context.WriteAllRegisterValues(register_data_sp);
if (error.Fail()) {
  LLDB_LOG(log, "pid {0} failed to restore all register values: {1}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} failed to restore all register values: {1}"
, m_debugged_process_up->GetID(), error); } while (0)
           m_debugged_process_up->GetID(), error)do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "pid {0} failed to restore all register values: {1}"
, m_debugged_process_up->GetID(), error); } while (0);
  return SendErrorResponse(0x77);
}

return SendOKResponse();
2896}

2898GDBRemoteCommunication::PacketResult
2899GDBRemoteCommunicationServerLLGS::Handle_vAttach(
  StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));

// Consume the ';' after vAttach.
packet.SetFilePos(strlen("vAttach"));
if (!packet.GetBytesLeft() || packet.GetChar() != ';')
  return SendIllFormedResponse(packet, "vAttach missing expected ';'");

// Grab the PID to which we will attach (assume hex encoding).
lldb::pid_t pid = packet.GetU32(LLDB_INVALID_PROCESS_ID0, 16);
if (pid == LLDB_INVALID_PROCESS_ID0)
  return SendIllFormedResponse(packet,
                               "vAttach failed to parse the process id");

// Attempt to attach.
if (log)
  log->Printf("GDBRemoteCommunicationServerLLGS::%s attempting to attach to "
              "pid %" PRIu64"l" "u",
              __FUNCTION__, pid);

Status error = AttachToProcess(pid);

if (error.Fail()) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to attach to "
                "pid %" PRIu64"l" "u" ": %s\n",
                __FUNCTION__, pid, error.AsCString());
  return SendErrorResponse(error);
}

// Notify we attached by sending a stop packet.
return SendStopReasonForState(m_debugged_process_up->GetState());
2932}

2934GDBRemoteCommunication::PacketResult
2935GDBRemoteCommunicationServerLLGS::Handle_D(StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));

StopSTDIOForwarding();

// Fail if we don't have a current process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0)) {
  if (log)
    log->Printf(
        "GDBRemoteCommunicationServerLLGS::%s failed, no process available",
        __FUNCTION__);
  return SendErrorResponse(0x15);
}

lldb::pid_t pid = LLDB_INVALID_PROCESS_ID0;

// Consume the ';' after D.
packet.SetFilePos(1);
if (packet.GetBytesLeft()) {
  if (packet.GetChar() != ';')
    return SendIllFormedResponse(packet, "D missing expected ';'");

  // Grab the PID from which we will detach (assume hex encoding).
  pid = packet.GetU32(LLDB_INVALID_PROCESS_ID0, 16);
  if (pid == LLDB_INVALID_PROCESS_ID0)
    return SendIllFormedResponse(packet, "D failed to parse the process id");
}

if (pid != LLDB_INVALID_PROCESS_ID0 && m_debugged_process_up->GetID() != pid) {
  return SendIllFormedResponse(packet, "Invalid pid");
}

const Status error = m_debugged_process_up->Detach();
if (error.Fail()) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s failed to detach from "
                "pid %" PRIu64"l" "u" ": %s\n",
                __FUNCTION__, m_debugged_process_up->GetID(),
                error.AsCString());
  return SendErrorResponse(0x01);
}

return SendOKResponse();
2979}

2981GDBRemoteCommunication::PacketResult
2982GDBRemoteCommunicationServerLLGS::Handle_qThreadStopInfo(
  StringExtractorGDBRemote &packet) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD(1u << 2)));

packet.SetFilePos(strlen("qThreadStopInfo"));
const lldb::tid_t tid = packet.GetHexMaxU32(false, LLDB_INVALID_THREAD_ID0);
if (tid == LLDB_INVALID_THREAD_ID0) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not "
                "parse thread id from request \"%s\"",
                __FUNCTION__, packet.GetStringRef().c_str());
  return SendErrorResponse(0x15);
}
return SendStopReplyPacketForThread(tid);
2996}

2998GDBRemoteCommunication::PacketResult
2999GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo(
  StringExtractorGDBRemote &) {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1) | LIBLLDB_LOG_THREAD(1u << 2)));

// Ensure we have a debugged process.
if (!m_debugged_process_up ||
    (m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0))
  return SendErrorResponse(50);
LLDB_LOG(log, "preparing packet for pid {0}", m_debugged_process_up->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "preparing packet for pid {0}", m_debugged_process_up
->GetID()); } while (0);

StreamString response;
const bool threads_with_valid_stop_info_only = false;
JSONArray::SP threads_array_sp = GetJSONThreadsInfo(
    *m_debugged_process_up, threads_with_valid_stop_info_only);
if (!threads_array_sp) {
  LLDB_LOG(log, "failed to prepare a packet for pid {0}",do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "failed to prepare a packet for pid {0}", m_debugged_process_up
->GetID()); } while (0)
           m_debugged_process_up->GetID())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "failed to prepare a packet for pid {0}", m_debugged_process_up
->GetID()); } while (0);
  return SendErrorResponse(52);
}

threads_array_sp->Write(response);
StreamGDBRemote escaped_response;
escaped_response.PutEscapedBytes(response.GetData(), response.GetSize());
return SendPacketNoLock(escaped_response.GetString());
3023}

3025GDBRemoteCommunication::PacketResult
3026GDBRemoteCommunicationServerLLGS::Handle_qWatchpointSupportInfo(
  StringExtractorGDBRemote &packet) {
// Fail if we don't have a current process.
if (!m_debugged_process_up ||
    m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0)
  return SendErrorResponse(68);

packet.SetFilePos(strlen("qWatchpointSupportInfo"));
if (packet.GetBytesLeft() == 0)
  return SendOKResponse();
if (packet.GetChar() != ':')
  return SendErrorResponse(67);

auto hw_debug_cap = m_debugged_process_up->GetHardwareDebugSupportInfo();

StreamGDBRemote response;
if (hw_debug_cap == llvm::None)
  response.Printf("num:0;");
else
  response.Printf("num:%d;", hw_debug_cap->second);

return SendPacketNoLock(response.GetString());
3048}

3050GDBRemoteCommunication::PacketResult
3051GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress(
  StringExtractorGDBRemote &packet) {
// Fail if we don't have a current process.
if (!m_debugged_process_up ||
    m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0)
  return SendErrorResponse(67);

packet.SetFilePos(strlen("qFileLoadAddress:"));
if (packet.GetBytesLeft() == 0)
  return SendErrorResponse(68);

std::string file_name;
packet.GetHexByteString(file_name);

lldb::addr_t file_load_address = LLDB_INVALID_ADDRESS(18446744073709551615UL);
Status error =
    m_debugged_process_up->GetFileLoadAddress(file_name, file_load_address);
if (error.Fail())
  return SendErrorResponse(69);

if (file_load_address == LLDB_INVALID_ADDRESS(18446744073709551615UL))
  return SendErrorResponse(1); // File not loaded

StreamGDBRemote response;
response.PutHex64(file_load_address);
return SendPacketNoLock(response.GetString());
3077}

3079GDBRemoteCommunication::PacketResult
3080GDBRemoteCommunicationServerLLGS::Handle_QPassSignals(
  StringExtractorGDBRemote &packet) {
std::vector<int> signals;
packet.SetFilePos(strlen("QPassSignals:"));

// Read sequence of hex signal numbers divided by a semicolon and optionally
// spaces.
while (packet.GetBytesLeft() > 0) {
  int signal = packet.GetS32(-1, 16);
  if (signal < 0)
    return SendIllFormedResponse(packet, "Failed to parse signal number.");
  signals.push_back(signal);

  packet.SkipSpaces();
  char separator = packet.GetChar();
  if (separator == '\0')
    break; // End of string
  if (separator != ';')
    return SendIllFormedResponse(packet, "Invalid separator,"
                                          " expected semicolon.");
}

// Fail if we don't have a current process.
if (!m_debugged_process_up)
  return SendErrorResponse(68);

Status error = m_debugged_process_up->IgnoreSignals(signals);
if (error.Fail())
  return SendErrorResponse(69);

return SendOKResponse();
3111}

3113void GDBRemoteCommunicationServerLLGS::MaybeCloseInferiorTerminalConnection() {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));

// Tell the stdio connection to shut down.
if (m_stdio_communication.IsConnected()) {
  auto connection = m_stdio_communication.GetConnection();
  if (connection) {
    Status error;
    connection->Disconnect(&error);

    if (error.Success()) {
      if (log)
        log->Printf("GDBRemoteCommunicationServerLLGS::%s disconnect process "
                    "terminal stdio - SUCCESS",
                    __FUNCTION__);
    } else {
      if (log)
        log->Printf("GDBRemoteCommunicationServerLLGS::%s disconnect process "
                    "terminal stdio - FAIL: %s",
                    __FUNCTION__, error.AsCString());
    }
  }
}
3136}

3138NativeThreadProtocol *GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix(
  StringExtractorGDBRemote &packet) {
// We have no thread if we don't have a process.
if (!m_debugged_process_up ||
    m_debugged_process_up->GetID() == LLDB_INVALID_PROCESS_ID0)
  return nullptr;

// If the client hasn't asked for thread suffix support, there will not be a
// thread suffix. Use the current thread in that case.
if (!m_thread_suffix_supported) {
  const lldb::tid_t current_tid = GetCurrentThreadID();
  if (current_tid == LLDB_INVALID_THREAD_ID0)
    return nullptr;
  else if (current_tid == 0) {
    // Pick a thread.
    return m_debugged_process_up->GetThreadAtIndex(0);
  } else
    return m_debugged_process_up->GetThreadByID(current_tid);
}

Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD(1u << 2)));

// Parse out the ';'.
if (packet.GetBytesLeft() < 1 || packet.GetChar() != ';') {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse "
                "error: expected ';' prior to start of thread suffix: packet "
                "contents = '%s'",
                __FUNCTION__, packet.GetStringRef().c_str());
  return nullptr;
}

if (!packet.GetBytesLeft())
  return nullptr;

// Parse out thread: portion.
if (strncmp(packet.Peek(), "thread:", strlen("thread:")) != 0) {
  if (log)
    log->Printf("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse "
                "error: expected 'thread:' but not found, packet contents = "
                "'%s'",
                __FUNCTION__, packet.GetStringRef().c_str());
  return nullptr;
}
packet.SetFilePos(packet.GetFilePos() + strlen("thread:"));
const lldb::tid_t tid = packet.GetHexMaxU64(false, 0);
if (tid != 0)
  return m_debugged_process_up->GetThreadByID(tid);

return nullptr;
3188}

3190lldb::tid_t GDBRemoteCommunicationServerLLGS::GetCurrentThreadID() const {
if (m_current_tid == 0 || m_current_tid == LLDB_INVALID_THREAD_ID0) {
  // Use whatever the debug process says is the current thread id since the
  // protocol either didn't specify or specified we want any/all threads
  // marked as the current thread.
  if (!m_debugged_process_up)
    return LLDB_INVALID_THREAD_ID0;
  return m_debugged_process_up->GetCurrentThreadID();
}
// Use the specific current thread id set by the gdb remote protocol.
return m_current_tid;
3201}

3203uint32_t GDBRemoteCommunicationServerLLGS::GetNextSavedRegistersID() {
std::lock_guard<std::mutex> guard(m_saved_registers_mutex);
return m_next_saved_registers_id++;
3206}

3208void GDBRemoteCommunicationServerLLGS::ClearProcessSpecificData() {
Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_PROCESS(1u << 1)));

LLDB_LOG(log, "clearing auxv buffer: {0}", m_active_auxv_buffer_up.get())do { ::lldb_private::Log *log_private = (log); if (log_private
) log_private->Format("/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp"
, __func__, "clearing auxv buffer: {0}", m_active_auxv_buffer_up
.get()); } while (0);
m_active_auxv_buffer_up.reset();
3213}

3215FileSpec
3216GDBRemoteCommunicationServerLLGS::FindModuleFile(const std::string &module_path,
                                               const ArchSpec &arch) {
if (m_debugged_process_up) {
  FileSpec file_spec;
  if (m_debugged_process_up
          ->GetLoadedModuleFileSpec(module_path.c_str(), file_spec)
          .Success()) {
    if (file_spec.Exists())
      return file_spec;
  }
}

return GDBRemoteCommunicationServerCommon::FindModuleFile(module_path, arch);
3229}

←

/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/include/lldb/Utility/TraceOptions.h

→

1//===-- TraceOptions.h ------------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9 
10#ifndef liblldb_TraceOptions_h_
11#define liblldb_TraceOptions_h_
12 
13#include "lldb/lldb-defines.h"
14#include "lldb/lldb-enumerations.h"
15 
16#include "lldb/Utility/StructuredData.h"
17 
18namespace lldb_private {
19class TraceOptions {
20public:
21  TraceOptions() : m_trace_params(new StructuredData::Dictionary()) {}
9
←
Returning without writing to 'this->m_type'→
22 
23  const StructuredData::DictionarySP &getTraceParams() const {
24    return m_trace_params;
25  }
26 
27  lldb::TraceType getType() const { return m_type; }
17
←
Undefined or garbage value returned to caller
28 
29  uint64_t getTraceBufferSize() const { return m_trace_buffer_size; }
30 
31  uint64_t getMetaDataBufferSize() const { return m_meta_data_buffer_size; }
32 
33  void setTraceParams(const StructuredData::DictionarySP &dict_obj) {
34    m_trace_params = dict_obj;
35  }
36 
37  void setType(lldb::TraceType type) { m_type = type; }
38 
39  void setTraceBufferSize(uint64_t size) { m_trace_buffer_size = size; }
40 
41  void setMetaDataBufferSize(uint64_t size) { m_meta_data_buffer_size = size; }
42 
43  void setThreadID(lldb::tid_t thread_id) { m_thread_id = thread_id; }
44 
45  lldb::tid_t getThreadID() const { return m_thread_id; }
46 
47private:
48  lldb::TraceType m_type;
49  uint64_t m_trace_buffer_size;
50  uint64_t m_meta_data_buffer_size;
51  lldb::tid_t m_thread_id;
52 
53  /// m_trace_params is meant to hold any custom parameters
54  /// apart from meta buffer size and trace size.
55  /// The interpretation of such parameters is left to
56  /// the lldb-server.
57  StructuredData::DictionarySP m_trace_params;
58};
59}
60 
61#endif // liblldb_TraceOptions_h_

←

/build/llvm-toolchain-snapshot-8~svn345461/tools/lldb/include/lldb/Host/common/NativeProcessProtocol.h

1//===-- NativeProcessProtocol.h ---------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//

10#ifndef liblldb_NativeProcessProtocol_h_
11#define liblldb_NativeProcessProtocol_h_

13#include "NativeBreakpointList.h"
14#include "NativeThreadProtocol.h"
15#include "NativeWatchpointList.h"
16#include "lldb/Host/Host.h"
17#include "lldb/Host/MainLoop.h"
18#include "lldb/Utility/ArchSpec.h"
19#include "lldb/Utility/Status.h"
20#include "lldb/Utility/TraceOptions.h"
21#include "lldb/lldb-private-forward.h"
22#include "lldb/lldb-types.h"
23#include "llvm/ADT/ArrayRef.h"
24#include "llvm/ADT/DenseSet.h"
25#include "llvm/ADT/StringRef.h"
26#include "llvm/Support/Error.h"
27#include "llvm/Support/MemoryBuffer.h"
28#include <vector>

30namespace lldb_private {
31class MemoryRegionInfo;
32class ResumeActionList;

34//------------------------------------------------------------------
35// NativeProcessProtocol
36//------------------------------------------------------------------
37class NativeProcessProtocol {
friend class SoftwareBreakpoint;

40public:
virtual ~NativeProcessProtocol() {}

virtual Status Resume(const ResumeActionList &resume_actions) = 0;

virtual Status Halt() = 0;

virtual Status Detach() = 0;

//------------------------------------------------------------------
/// Sends a process a UNIX signal \a signal.
///
/// @return
///     Returns an error object.
//------------------------------------------------------------------
virtual Status Signal(int signo) = 0;

//------------------------------------------------------------------
/// Tells a process to interrupt all operations as if by a Ctrl-C.
///
/// The default implementation will send a local host's equivalent of
/// a SIGSTOP to the process via the NativeProcessProtocol::Signal()
/// operation.
///
/// @return
///     Returns an error object.
//------------------------------------------------------------------
virtual Status Interrupt();

virtual Status Kill() = 0;

//------------------------------------------------------------------
// Tells a process not to stop the inferior on given signals and just
// reinject them back.
//------------------------------------------------------------------
virtual Status IgnoreSignals(llvm::ArrayRef<int> signals);

//----------------------------------------------------------------------
// Memory and memory region functions
//----------------------------------------------------------------------

virtual Status GetMemoryRegionInfo(lldb::addr_t load_addr,
                                   MemoryRegionInfo &range_info);

virtual Status ReadMemory(lldb::addr_t addr, void *buf, size_t size,
                          size_t &bytes_read) = 0;

Status ReadMemoryWithoutTrap(lldb::addr_t addr, void *buf, size_t size,
                             size_t &bytes_read);

virtual Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size,
                           size_t &bytes_written) = 0;

virtual Status AllocateMemory(size_t size, uint32_t permissions,
                              lldb::addr_t &addr) = 0;

virtual Status DeallocateMemory(lldb::addr_t addr) = 0;

virtual lldb::addr_t GetSharedLibraryInfoAddress() = 0;

virtual bool IsAlive() const;

virtual size_t UpdateThreads() = 0;

virtual const ArchSpec &GetArchitecture() const = 0;

//----------------------------------------------------------------------
// Breakpoint functions
//----------------------------------------------------------------------
virtual Status SetBreakpoint(lldb::addr_t addr, uint32_t size,
                             bool hardware) = 0;

virtual Status RemoveBreakpoint(lldb::addr_t addr, bool hardware = false);

virtual Status EnableBreakpoint(lldb::addr_t addr);

virtual Status DisableBreakpoint(lldb::addr_t addr);

//----------------------------------------------------------------------
// Hardware Breakpoint functions
//----------------------------------------------------------------------
virtual const HardwareBreakpointMap &GetHardwareBreakpointMap() const;

virtual Status SetHardwareBreakpoint(lldb::addr_t addr, size_t size);

virtual Status RemoveHardwareBreakpoint(lldb::addr_t addr);

//----------------------------------------------------------------------
// Watchpoint functions
//----------------------------------------------------------------------
virtual const NativeWatchpointList::WatchpointMap &GetWatchpointMap() const;

virtual llvm::Optional<std::pair<uint32_t, uint32_t>>
GetHardwareDebugSupportInfo() const;

virtual Status SetWatchpoint(lldb::addr_t addr, size_t size,
                             uint32_t watch_flags, bool hardware);

virtual Status RemoveWatchpoint(lldb::addr_t addr);

//----------------------------------------------------------------------
// Accessors
//----------------------------------------------------------------------
lldb::pid_t GetID() const { return m_pid; }

lldb::StateType GetState() const;

bool IsRunning() const {
  return m_state == lldb::eStateRunning || IsStepping();
}

bool IsStepping() const { return m_state == lldb::eStateStepping; }

bool CanResume() const { return m_state == lldb::eStateStopped; }

lldb::ByteOrder GetByteOrder() const {
  return GetArchitecture().GetByteOrder();
}

virtual llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
GetAuxvData() const = 0;

//----------------------------------------------------------------------
// Exit Status
//----------------------------------------------------------------------
virtual llvm::Optional<WaitStatus> GetExitStatus();

virtual bool SetExitStatus(WaitStatus status, bool bNotifyStateChange);

//----------------------------------------------------------------------
// Access to threads
//----------------------------------------------------------------------
NativeThreadProtocol *GetThreadAtIndex(uint32_t idx);

NativeThreadProtocol *GetThreadByID(lldb::tid_t tid);

void SetCurrentThreadID(lldb::tid_t tid) { m_current_thread_id = tid; }

lldb::tid_t GetCurrentThreadID() { return m_current_thread_id; }

NativeThreadProtocol *GetCurrentThread() {
  return GetThreadByID(m_current_thread_id);
}

//----------------------------------------------------------------------
// Access to inferior stdio
//----------------------------------------------------------------------
virtual int GetTerminalFileDescriptor() { return m_terminal_fd; }

//----------------------------------------------------------------------
// Stop id interface
//----------------------------------------------------------------------

uint32_t GetStopID() const;

// ---------------------------------------------------------------------
// Callbacks for low-level process state changes
// ---------------------------------------------------------------------
class NativeDelegate {
public:
  virtual ~NativeDelegate() {}

  virtual void InitializeDelegate(NativeProcessProtocol *process) = 0;

  virtual void ProcessStateChanged(NativeProcessProtocol *process,
                                   lldb::StateType state) = 0;

  virtual void DidExec(NativeProcessProtocol *process) = 0;
};

//------------------------------------------------------------------
/// Register a native delegate.
///
/// Clients can register nofication callbacks by passing in a
/// NativeDelegate impl and passing it into this function.
///
/// Note: it is required that the lifetime of the
/// native_delegate outlive the NativeProcessProtocol.
///
/// @param[in] native_delegate
///     A NativeDelegate impl to be called when certain events
///     happen within the NativeProcessProtocol or related threads.
///
/// @return
///     true if the delegate was registered successfully;
///     false if the delegate was already registered.
///
/// @see NativeProcessProtocol::NativeDelegate.
//------------------------------------------------------------------
bool RegisterNativeDelegate(NativeDelegate &native_delegate);

//------------------------------------------------------------------
/// Unregister a native delegate previously registered.
///
/// @param[in] native_delegate
///     A NativeDelegate impl previously registered with this process.
///
/// @return Returns \b true if the NativeDelegate was
/// successfully removed from the process, \b false otherwise.
///
/// @see NativeProcessProtocol::NativeDelegate
//------------------------------------------------------------------
bool UnregisterNativeDelegate(NativeDelegate &native_delegate);

virtual Status GetLoadedModuleFileSpec(const char *module_path,
                                       FileSpec &file_spec) = 0;

virtual Status GetFileLoadAddress(const llvm::StringRef &file_name,
                                  lldb::addr_t &load_addr) = 0;

class Factory {
public:
  virtual ~Factory();
  //------------------------------------------------------------------
  /// Launch a process for debugging.
  ///
  /// @param[in] launch_info
  ///     Information required to launch the process.
  ///
  /// @param[in] native_delegate
  ///     The delegate that will receive messages regarding the
  ///     inferior.  Must outlive the NativeProcessProtocol
  ///     instance.
  ///
  /// @param[in] mainloop
  ///     The mainloop instance with which the process can register
  ///     callbacks. Must outlive the NativeProcessProtocol
  ///     instance.
  ///
  /// @return
  ///     A NativeProcessProtocol shared pointer if the operation succeeded or
  ///     an error object if it failed.
  //------------------------------------------------------------------
  virtual llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
  Launch(ProcessLaunchInfo &launch_info, NativeDelegate &native_delegate,
         MainLoop &mainloop) const = 0;

  //------------------------------------------------------------------
  /// Attach to an existing process.
  ///
  /// @param[in] pid
  ///     pid of the process locatable
  ///
  /// @param[in] native_delegate
  ///     The delegate that will receive messages regarding the
  ///     inferior.  Must outlive the NativeProcessProtocol
  ///     instance.
  ///
  /// @param[in] mainloop
  ///     The mainloop instance with which the process can register
  ///     callbacks. Must outlive the NativeProcessProtocol
  ///     instance.
  ///
  /// @return
  ///     A NativeProcessProtocol shared pointer if the operation succeeded or
  ///     an error object if it failed.
  //------------------------------------------------------------------
  virtual llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
  Attach(lldb::pid_t pid, NativeDelegate &native_delegate,
         MainLoop &mainloop) const = 0;
};

//------------------------------------------------------------------
/// StartTracing API for starting a tracing instance with the
/// TraceOptions on a specific thread or process.
///
/// @param[in] config
///     The configuration to use when starting tracing.
///
/// @param[out] error
///     Status indicates what went wrong.
///
/// @return
///     The API returns a user_id which can be used to get trace
///     data, trace configuration or stopping the trace instance.
///     The user_id is a key to identify and operate with a tracing
///     instance. It may refer to the complete process or a single
///     thread.
//------------------------------------------------------------------
virtual lldb::user_id_t StartTrace(const TraceOptions &config,
                                   Status &error) {
  error.SetErrorString("Not implemented");
  return LLDB_INVALID_UID(18446744073709551615UL);
}

//------------------------------------------------------------------
/// StopTracing API as the name suggests stops a tracing instance.
///
/// @param[in] traceid
///     The user id of the trace intended to be stopped. Now a
///     user_id may map to multiple threads in which case this API
///     could be used to stop the tracing for a specific thread by
///     supplying its thread id.
///
/// @param[in] thread
///     Thread is needed when the complete process is being traced
///     and the user wishes to stop tracing on a particular thread.
///
/// @return
///     Status indicating what went wrong.
//------------------------------------------------------------------
virtual Status StopTrace(lldb::user_id_t traceid,
                         lldb::tid_t thread = LLDB_INVALID_THREAD_ID0) {
  return Status("Not implemented");
}

//------------------------------------------------------------------
/// This API provides the trace data collected in the form of raw
/// data.
///
/// @param[in] traceid thread
///     The traceid and thread provide the context for the trace
///     instance.
///
/// @param[in] buffer
///     The buffer provides the destination buffer where the trace
///     data would be read to. The buffer should be truncated to the
///     filled length by this function.
///
/// @param[in] offset
///     There is possibility to read partially the trace data from
///     a specified offset where in such cases the buffer provided
///     may be smaller than the internal trace collection container.
///
/// @return
///     The size of the data actually read.
//------------------------------------------------------------------
virtual Status GetData(lldb::user_id_t traceid, lldb::tid_t thread,
                       llvm::MutableArrayRef<uint8_t> &buffer,
                       size_t offset = 0) {
  return Status("Not implemented");
}

//------------------------------------------------------------------
/// Similar API as above except it aims to provide any extra data
/// useful for decoding the actual trace data.
//------------------------------------------------------------------
virtual Status GetMetaData(lldb::user_id_t traceid, lldb::tid_t thread,
                           llvm::MutableArrayRef<uint8_t> &buffer,
                           size_t offset = 0) {
  return Status("Not implemented");
}

//------------------------------------------------------------------
/// API to query the TraceOptions for a given user id
///
/// @param[in] traceid
///     The user id of the tracing instance.
///
/// @param[in] config
///     The thread id of the tracing instance, in case configuration
///     for a specific thread is needed should be specified in the
///     config.
///
/// @param[out] error
///     Status indicates what went wrong.
///
/// @param[out] config
///     The actual configuration being used for tracing.
//------------------------------------------------------------------
virtual Status GetTraceConfig(lldb::user_id_t traceid, TraceOptions &config) {
  return Status("Not implemented");
12
←
Returning without writing to 'config.m_type'→
}

404protected:
lldb::pid_t m_pid;

std::vector<std::unique_ptr<NativeThreadProtocol>> m_threads;
lldb::tid_t m_current_thread_id = LLDB_INVALID_THREAD_ID0;
mutable std::recursive_mutex m_threads_mutex;

lldb::StateType m_state = lldb::eStateInvalid;
mutable std::recursive_mutex m_state_mutex;

llvm::Optional<WaitStatus> m_exit_status;

std::recursive_mutex m_delegates_mutex;
std::vector<NativeDelegate *> m_delegates;
NativeBreakpointList m_breakpoint_list;
NativeWatchpointList m_watchpoint_list;
HardwareBreakpointMap m_hw_breakpoints_map;
int m_terminal_fd;
uint32_t m_stop_id = 0;

// Set of signal numbers that LLDB directly injects back to inferior without
// stopping it.
llvm::DenseSet<int> m_signals_to_ignore;

// lldb_private::Host calls should be used to launch a process for debugging,
// and then the process should be attached to. When attaching to a process
// lldb_private::Host calls should be used to locate the process to attach
// to, and then this function should be called.
NativeProcessProtocol(lldb::pid_t pid, int terminal_fd,
                      NativeDelegate &delegate);

// ----------------------------------------------------------- Internal
// interface for state handling
// -----------------------------------------------------------
void SetState(lldb::StateType state, bool notify_delegates = true);

// Derived classes need not implement this.  It can be used as a hook to
// clear internal caches that should be invalidated when stop ids change.
//
// Note this function is called with the state mutex obtained by the caller.
virtual void DoStopIDBumped(uint32_t newBumpId);

// ----------------------------------------------------------- Internal
// interface for software breakpoints
// -----------------------------------------------------------
Status SetSoftwareBreakpoint(lldb::addr_t addr, uint32_t size_hint);

virtual llvm::Expected<llvm::ArrayRef<uint8_t>>
GetSoftwareBreakpointTrapOpcode(size_t size_hint);

/// Return the offset of the PC relative to the software breakpoint that was hit. If an
/// architecture (e.g. arm) reports breakpoint hits before incrementing the PC, this offset
/// will be 0. If an architecture (e.g. intel) reports breakpoints hits after incrementing the
/// PC, this offset will be the size of the breakpoint opcode.
virtual size_t GetSoftwareBreakpointPCOffset();

// Adjust the thread's PC after hitting a software breakpoint. On
// architectures where the PC points after the breakpoint instruction, this
// resets it to point to the breakpoint itself.
void FixupBreakpointPCAsNeeded(NativeThreadProtocol &thread);

// -----------------------------------------------------------
/// Notify the delegate that an exec occurred.
///
/// Provide a mechanism for a delegate to clear out any exec-
/// sensitive data.
// -----------------------------------------------------------
void NotifyDidExec();

NativeThreadProtocol *GetThreadByIDUnlocked(lldb::tid_t tid);

475private:
void SynchronouslyNotifyProcessStateChanged(lldb::StateType state);
477};
478} // namespace lldb_private

480#endif // #ifndef liblldb_NativeProcessProtocol_h_