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

   1 //===-- GDBRemoteCommunicationClient.cpp ------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "GDBRemoteCommunicationClient.h"
  10
  11 #include <math.h>
  12 #include <sys/stat.h>
  13
  14 #include <numeric>
  15 #include <sstream>
  16
  17 #include "lldb/Core/ModuleSpec.h"
  18 #include "lldb/Host/HostInfo.h"
  19 #include "lldb/Host/XML.h"
  20 #include "lldb/Symbol/Symbol.h"
  21 #include "lldb/Target/MemoryRegionInfo.h"
  22 #include "lldb/Target/Target.h"
  23 #include "lldb/Target/UnixSignals.h"
  24 #include "lldb/Utility/Args.h"
  25 #include "lldb/Utility/DataBufferHeap.h"
  26 #include "lldb/Utility/JSON.h"
  27 #include "lldb/Utility/LLDBAssert.h"
  28 #include "lldb/Utility/Log.h"
  29 #include "lldb/Utility/State.h"
  30 #include "lldb/Utility/StreamString.h"
  31
  32 #include "ProcessGDBRemote.h"
  33 #include "ProcessGDBRemoteLog.h"
  34 #include "lldb/Host/Config.h"
  35 #include "lldb/Utility/StringExtractorGDBRemote.h"
  36
  37 #include "llvm/ADT/StringSwitch.h"
  38
  39 #if defined(__APPLE__)
  40 #ifndef HAVE_LIBCOMPRESSION
  41 #define HAVE_LIBCOMPRESSION
  42 #endif
  43 #include <compression.h>
  44 #endif
  45
  46 using namespace lldb;
  47 using namespace lldb_private;
  48 using namespace lldb_private::process_gdb_remote;
  49 using namespace std::chrono;
  50
  51 // GDBRemoteCommunicationClient constructor
  52 GDBRemoteCommunicationClient::GDBRemoteCommunicationClient()
  53     : GDBRemoteClientBase("gdb-remote.client", "gdb-remote.client.rx_packet"),
  54       m_supports_not_sending_acks(eLazyBoolCalculate),
  55       m_supports_thread_suffix(eLazyBoolCalculate),
  56       m_supports_threads_in_stop_reply(eLazyBoolCalculate),
  57       m_supports_vCont_all(eLazyBoolCalculate),
  58       m_supports_vCont_any(eLazyBoolCalculate),
  59       m_supports_vCont_c(eLazyBoolCalculate),
  60       m_supports_vCont_C(eLazyBoolCalculate),
  61       m_supports_vCont_s(eLazyBoolCalculate),
  62       m_supports_vCont_S(eLazyBoolCalculate),
  63       m_qHostInfo_is_valid(eLazyBoolCalculate),
  64       m_curr_pid_is_valid(eLazyBoolCalculate),
  65       m_qProcessInfo_is_valid(eLazyBoolCalculate),
  66       m_qGDBServerVersion_is_valid(eLazyBoolCalculate),
  67       m_supports_alloc_dealloc_memory(eLazyBoolCalculate),
  68       m_supports_memory_region_info(eLazyBoolCalculate),
  69       m_supports_watchpoint_support_info(eLazyBoolCalculate),
  70       m_supports_detach_stay_stopped(eLazyBoolCalculate),
  71       m_watchpoints_trigger_after_instruction(eLazyBoolCalculate),
  72       m_attach_or_wait_reply(eLazyBoolCalculate),
  73       m_prepare_for_reg_writing_reply(eLazyBoolCalculate),
  74       m_supports_p(eLazyBoolCalculate), m_supports_x(eLazyBoolCalculate),
  75       m_avoid_g_packets(eLazyBoolCalculate),
  76       m_supports_QSaveRegisterState(eLazyBoolCalculate),
  77       m_supports_qXfer_auxv_read(eLazyBoolCalculate),
  78       m_supports_qXfer_libraries_read(eLazyBoolCalculate),
  79       m_supports_qXfer_libraries_svr4_read(eLazyBoolCalculate),
  80       m_supports_qXfer_features_read(eLazyBoolCalculate),
  81       m_supports_qXfer_memory_map_read(eLazyBoolCalculate),
  82       m_supports_augmented_libraries_svr4_read(eLazyBoolCalculate),
  83       m_supports_jThreadExtendedInfo(eLazyBoolCalculate),
  84       m_supports_jLoadedDynamicLibrariesInfos(eLazyBoolCalculate),
  85       m_supports_jGetSharedCacheInfo(eLazyBoolCalculate),
  86       m_supports_QPassSignals(eLazyBoolCalculate),
  87       m_supports_error_string_reply(eLazyBoolCalculate),
  88       m_supports_qProcessInfoPID(true), m_supports_qfProcessInfo(true),
  89       m_supports_qUserName(true), m_supports_qGroupName(true),
  90       m_supports_qThreadStopInfo(true), m_supports_z0(true),
  91       m_supports_z1(true), m_supports_z2(true), m_supports_z3(true),
  92       m_supports_z4(true), m_supports_QEnvironment(true),
  93       m_supports_QEnvironmentHexEncoded(true), m_supports_qSymbol(true),
  94       m_qSymbol_requests_done(false), m_supports_qModuleInfo(true),
  95       m_supports_jThreadsInfo(true), m_supports_jModulesInfo(true),
  96       m_curr_pid(LLDB_INVALID_PROCESS_ID), m_curr_tid(LLDB_INVALID_THREAD_ID),
  97       m_curr_tid_run(LLDB_INVALID_THREAD_ID),
  98       m_num_supported_hardware_watchpoints(0), m_host_arch(), m_process_arch(),
  99       m_os_build(), m_os_kernel(), m_hostname(), m_gdb_server_name(),
 100       m_gdb_server_version(UINT32_MAX), m_default_packet_timeout(0),
 101       m_max_packet_size(0), m_qSupported_response(),
 102       m_supported_async_json_packets_is_valid(false),
 103       m_supported_async_json_packets_sp(), m_qXfer_memory_map(),
 104       m_qXfer_memory_map_loaded(false) {}
 105
 106 // Destructor
 107 GDBRemoteCommunicationClient::~GDBRemoteCommunicationClient() {
 108   if (IsConnected())
 109     Disconnect();
 110 }
 111
 112 bool GDBRemoteCommunicationClient::HandshakeWithServer(Status *error_ptr) {
 113   ResetDiscoverableSettings(false);
 114
 115   // Start the read thread after we send the handshake ack since if we fail to
 116   // send the handshake ack, there is no reason to continue...
 117   if (SendAck()) {
 118     // Wait for any responses that might have been queued up in the remote
 119     // GDB server and flush them all
 120     StringExtractorGDBRemote response;
 121     PacketResult packet_result = PacketResult::Success;
 122     while (packet_result == PacketResult::Success)
 123       packet_result = ReadPacket(response, milliseconds(10), false);
 124
 125     // The return value from QueryNoAckModeSupported() is true if the packet
 126     // was sent and _any_ response (including UNIMPLEMENTED) was received), or
 127     // false if no response was received. This quickly tells us if we have a
 128     // live connection to a remote GDB server...
 129     if (QueryNoAckModeSupported()) {
 130       return true;
 131     } else {
 132       if (error_ptr)
 133         error_ptr->SetErrorString("failed to get reply to handshake packet");
 134     }
 135   } else {
 136     if (error_ptr)
 137       error_ptr->SetErrorString("failed to send the handshake ack");
 138   }
 139   return false;
 140 }
 141
 142 bool GDBRemoteCommunicationClient::GetEchoSupported() {
 143   if (m_supports_qEcho == eLazyBoolCalculate) {
 144     GetRemoteQSupported();
 145   }
 146   return m_supports_qEcho == eLazyBoolYes;
 147 }
 148
 149 bool GDBRemoteCommunicationClient::GetQPassSignalsSupported() {
 150   if (m_supports_QPassSignals == eLazyBoolCalculate) {
 151     GetRemoteQSupported();
 152   }
 153   return m_supports_QPassSignals == eLazyBoolYes;
 154 }
 155
 156 bool GDBRemoteCommunicationClient::GetAugmentedLibrariesSVR4ReadSupported() {
 157   if (m_supports_augmented_libraries_svr4_read == eLazyBoolCalculate) {
 158     GetRemoteQSupported();
 159   }
 160   return m_supports_augmented_libraries_svr4_read == eLazyBoolYes;
 161 }
 162
 163 bool GDBRemoteCommunicationClient::GetQXferLibrariesSVR4ReadSupported() {
 164   if (m_supports_qXfer_libraries_svr4_read == eLazyBoolCalculate) {
 165     GetRemoteQSupported();
 166   }
 167   return m_supports_qXfer_libraries_svr4_read == eLazyBoolYes;
 168 }
 169
 170 bool GDBRemoteCommunicationClient::GetQXferLibrariesReadSupported() {
 171   if (m_supports_qXfer_libraries_read == eLazyBoolCalculate) {
 172     GetRemoteQSupported();
 173   }
 174   return m_supports_qXfer_libraries_read == eLazyBoolYes;
 175 }
 176
 177 bool GDBRemoteCommunicationClient::GetQXferAuxvReadSupported() {
 178   if (m_supports_qXfer_auxv_read == eLazyBoolCalculate) {
 179     GetRemoteQSupported();
 180   }
 181   return m_supports_qXfer_auxv_read == eLazyBoolYes;
 182 }
 183
 184 bool GDBRemoteCommunicationClient::GetQXferFeaturesReadSupported() {
 185   if (m_supports_qXfer_features_read == eLazyBoolCalculate) {
 186     GetRemoteQSupported();
 187   }
 188   return m_supports_qXfer_features_read == eLazyBoolYes;
 189 }
 190
 191 bool GDBRemoteCommunicationClient::GetQXferMemoryMapReadSupported() {
 192   if (m_supports_qXfer_memory_map_read == eLazyBoolCalculate) {
 193     GetRemoteQSupported();
 194   }
 195   return m_supports_qXfer_memory_map_read == eLazyBoolYes;
 196 }
 197
 198 uint64_t GDBRemoteCommunicationClient::GetRemoteMaxPacketSize() {
 199   if (m_max_packet_size == 0) {
 200     GetRemoteQSupported();
 201   }
 202   return m_max_packet_size;
 203 }
 204
 205 bool GDBRemoteCommunicationClient::QueryNoAckModeSupported() {
 206   if (m_supports_not_sending_acks == eLazyBoolCalculate) {
 207     m_send_acks = true;
 208     m_supports_not_sending_acks = eLazyBoolNo;
 209
 210     // This is the first real packet that we'll send in a debug session and it
 211     // may take a little longer than normal to receive a reply.  Wait at least
 212     // 6 seconds for a reply to this packet.
 213
 214     ScopedTimeout timeout(*this, std::max(GetPacketTimeout(), seconds(6)));
 215
 216     StringExtractorGDBRemote response;
 217     if (SendPacketAndWaitForResponse("QStartNoAckMode", response, false) ==
 218         PacketResult::Success) {
 219       if (response.IsOKResponse()) {
 220         m_send_acks = false;
 221         m_supports_not_sending_acks = eLazyBoolYes;
 222       }
 223       return true;
 224     }
 225   }
 226   return false;
 227 }
 228
 229 void GDBRemoteCommunicationClient::GetListThreadsInStopReplySupported() {
 230   if (m_supports_threads_in_stop_reply == eLazyBoolCalculate) {
 231     m_supports_threads_in_stop_reply = eLazyBoolNo;
 232
 233     StringExtractorGDBRemote response;
 234     if (SendPacketAndWaitForResponse("QListThreadsInStopReply", response,
 235                                      false) == PacketResult::Success) {
 236       if (response.IsOKResponse())
 237         m_supports_threads_in_stop_reply = eLazyBoolYes;
 238     }
 239   }
 240 }
 241
 242 bool GDBRemoteCommunicationClient::GetVAttachOrWaitSupported() {
 243   if (m_attach_or_wait_reply == eLazyBoolCalculate) {
 244     m_attach_or_wait_reply = eLazyBoolNo;
 245
 246     StringExtractorGDBRemote response;
 247     if (SendPacketAndWaitForResponse("qVAttachOrWaitSupported", response,
 248                                      false) == PacketResult::Success) {
 249       if (response.IsOKResponse())
 250         m_attach_or_wait_reply = eLazyBoolYes;
 251     }
 252   }
 253   return m_attach_or_wait_reply == eLazyBoolYes;
 254 }
 255
 256 bool GDBRemoteCommunicationClient::GetSyncThreadStateSupported() {
 257   if (m_prepare_for_reg_writing_reply == eLazyBoolCalculate) {
 258     m_prepare_for_reg_writing_reply = eLazyBoolNo;
 259
 260     StringExtractorGDBRemote response;
 261     if (SendPacketAndWaitForResponse("qSyncThreadStateSupported", response,
 262                                      false) == PacketResult::Success) {
 263       if (response.IsOKResponse())
 264         m_prepare_for_reg_writing_reply = eLazyBoolYes;
 265     }
 266   }
 267   return m_prepare_for_reg_writing_reply == eLazyBoolYes;
 268 }
 269
 270 void GDBRemoteCommunicationClient::ResetDiscoverableSettings(bool did_exec) {
 271   if (!did_exec) {
 272     // Hard reset everything, this is when we first connect to a GDB server
 273     m_supports_not_sending_acks = eLazyBoolCalculate;
 274     m_supports_thread_suffix = eLazyBoolCalculate;
 275     m_supports_threads_in_stop_reply = eLazyBoolCalculate;
 276     m_supports_vCont_c = eLazyBoolCalculate;
 277     m_supports_vCont_C = eLazyBoolCalculate;
 278     m_supports_vCont_s = eLazyBoolCalculate;
 279     m_supports_vCont_S = eLazyBoolCalculate;
 280     m_supports_p = eLazyBoolCalculate;
 281     m_supports_x = eLazyBoolCalculate;
 282     m_supports_QSaveRegisterState = eLazyBoolCalculate;
 283     m_qHostInfo_is_valid = eLazyBoolCalculate;
 284     m_curr_pid_is_valid = eLazyBoolCalculate;
 285     m_qGDBServerVersion_is_valid = eLazyBoolCalculate;
 286     m_supports_alloc_dealloc_memory = eLazyBoolCalculate;
 287     m_supports_memory_region_info = eLazyBoolCalculate;
 288     m_prepare_for_reg_writing_reply = eLazyBoolCalculate;
 289     m_attach_or_wait_reply = eLazyBoolCalculate;
 290     m_avoid_g_packets = eLazyBoolCalculate;
 291     m_supports_qXfer_auxv_read = eLazyBoolCalculate;
 292     m_supports_qXfer_libraries_read = eLazyBoolCalculate;
 293     m_supports_qXfer_libraries_svr4_read = eLazyBoolCalculate;
 294     m_supports_qXfer_features_read = eLazyBoolCalculate;
 295     m_supports_qXfer_memory_map_read = eLazyBoolCalculate;
 296     m_supports_augmented_libraries_svr4_read = eLazyBoolCalculate;
 297     m_supports_qProcessInfoPID = true;
 298     m_supports_qfProcessInfo = true;
 299     m_supports_qUserName = true;
 300     m_supports_qGroupName = true;
 301     m_supports_qThreadStopInfo = true;
 302     m_supports_z0 = true;
 303     m_supports_z1 = true;
 304     m_supports_z2 = true;
 305     m_supports_z3 = true;
 306     m_supports_z4 = true;
 307     m_supports_QEnvironment = true;
 308     m_supports_QEnvironmentHexEncoded = true;
 309     m_supports_qSymbol = true;
 310     m_qSymbol_requests_done = false;
 311     m_supports_qModuleInfo = true;
 312     m_host_arch.Clear();
 313     m_os_version = llvm::VersionTuple();
 314     m_os_build.clear();
 315     m_os_kernel.clear();
 316     m_hostname.clear();
 317     m_gdb_server_name.clear();
 318     m_gdb_server_version = UINT32_MAX;
 319     m_default_packet_timeout = seconds(0);
 320     m_max_packet_size = 0;
 321     m_qSupported_response.clear();
 322     m_supported_async_json_packets_is_valid = false;
 323     m_supported_async_json_packets_sp.reset();
 324     m_supports_jModulesInfo = true;
 325   }
 326
 327   // These flags should be reset when we first connect to a GDB server and when
 328   // our inferior process execs
 329   m_qProcessInfo_is_valid = eLazyBoolCalculate;
 330   m_process_arch.Clear();
 331 }
 332
 333 void GDBRemoteCommunicationClient::GetRemoteQSupported() {
 334   // Clear out any capabilities we expect to see in the qSupported response
 335   m_supports_qXfer_auxv_read = eLazyBoolNo;
 336   m_supports_qXfer_libraries_read = eLazyBoolNo;
 337   m_supports_qXfer_libraries_svr4_read = eLazyBoolNo;
 338   m_supports_augmented_libraries_svr4_read = eLazyBoolNo;
 339   m_supports_qXfer_features_read = eLazyBoolNo;
 340   m_supports_qXfer_memory_map_read = eLazyBoolNo;
 341   m_max_packet_size = UINT64_MAX; // It's supposed to always be there, but if
 342                                   // not, we assume no limit
 343
 344   // build the qSupported packet
 345   std::vector<std::string> features = {"xmlRegisters=i386,arm,mips"};
 346   StreamString packet;
 347   packet.PutCString("qSupported");
 348   for (uint32_t i = 0; i < features.size(); ++i) {
 349     packet.PutCString(i == 0 ? ":" : ";");
 350     packet.PutCString(features[i]);
 351   }
 352
 353   StringExtractorGDBRemote response;
 354   if (SendPacketAndWaitForResponse(packet.GetString(), response,
 355                                    /*send_async=*/false) ==
 356       PacketResult::Success) {
 357     const char *response_cstr = response.GetStringRef().c_str();
 358
 359     // Hang on to the qSupported packet, so that platforms can do custom
 360     // configuration of the transport before attaching/launching the process.
 361     m_qSupported_response = response_cstr;
 362
 363     if (::strstr(response_cstr, "qXfer:auxv:read+"))
 364       m_supports_qXfer_auxv_read = eLazyBoolYes;
 365     if (::strstr(response_cstr, "qXfer:libraries-svr4:read+"))
 366       m_supports_qXfer_libraries_svr4_read = eLazyBoolYes;
 367     if (::strstr(response_cstr, "augmented-libraries-svr4-read")) {
 368       m_supports_qXfer_libraries_svr4_read = eLazyBoolYes; // implied
 369       m_supports_augmented_libraries_svr4_read = eLazyBoolYes;
 370     }
 371     if (::strstr(response_cstr, "qXfer:libraries:read+"))
 372       m_supports_qXfer_libraries_read = eLazyBoolYes;
 373     if (::strstr(response_cstr, "qXfer:features:read+"))
 374       m_supports_qXfer_features_read = eLazyBoolYes;
 375     if (::strstr(response_cstr, "qXfer:memory-map:read+"))
 376       m_supports_qXfer_memory_map_read = eLazyBoolYes;
 377
 378     // Look for a list of compressions in the features list e.g.
 379     // qXfer:features:read+;PacketSize=20000;qEcho+;SupportedCompressions=zlib-
 380     // deflate,lzma
 381     const char *features_list = ::strstr(response_cstr, "qXfer:features:");
 382     if (features_list) {
 383       const char *compressions =
 384           ::strstr(features_list, "SupportedCompressions=");
 385       if (compressions) {
 386         std::vector<std::string> supported_compressions;
 387         compressions += sizeof("SupportedCompressions=") - 1;
 388         const char *end_of_compressions = strchr(compressions, ';');
 389         if (end_of_compressions == nullptr) {
 390           end_of_compressions = strchr(compressions, '\0');
 391         }
 392         const char *current_compression = compressions;
 393         while (current_compression < end_of_compressions) {
 394           const char *next_compression_name = strchr(current_compression, ',');
 395           const char *end_of_this_word = next_compression_name;
 396           if (next_compression_name == nullptr ||
 397               end_of_compressions < next_compression_name) {
 398             end_of_this_word = end_of_compressions;
 399           }
 400
 401           if (end_of_this_word) {
 402             if (end_of_this_word == current_compression) {
 403               current_compression++;
 404             } else {
 405               std::string this_compression(
 406                   current_compression, end_of_this_word - current_compression);
 407               supported_compressions.push_back(this_compression);
 408               current_compression = end_of_this_word + 1;
 409             }
 410           } else {
 411             supported_compressions.push_back(current_compression);
 412             current_compression = end_of_compressions;
 413           }
 414         }
 415
 416         if (supported_compressions.size() > 0) {
 417           MaybeEnableCompression(supported_compressions);
 418         }
 419       }
 420     }
 421
 422     if (::strstr(response_cstr, "qEcho"))
 423       m_supports_qEcho = eLazyBoolYes;
 424     else
 425       m_supports_qEcho = eLazyBoolNo;
 426
 427     if (::strstr(response_cstr, "QPassSignals+"))
 428       m_supports_QPassSignals = eLazyBoolYes;
 429     else
 430       m_supports_QPassSignals = eLazyBoolNo;
 431
 432     const char *packet_size_str = ::strstr(response_cstr, "PacketSize=");
 433     if (packet_size_str) {
 434       StringExtractorGDBRemote packet_response(packet_size_str +
 435                                                strlen("PacketSize="));
 436       m_max_packet_size =
 437           packet_response.GetHexMaxU64(/*little_endian=*/false, UINT64_MAX);
 438       if (m_max_packet_size == 0) {
 439         m_max_packet_size = UINT64_MAX; // Must have been a garbled response
 440         Log *log(
 441             ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
 442         if (log)
 443           log->Printf("Garbled PacketSize spec in qSupported response");
 444       }
 445     }
 446   }
 447 }
 448
 449 bool GDBRemoteCommunicationClient::GetThreadSuffixSupported() {
 450   if (m_supports_thread_suffix == eLazyBoolCalculate) {
 451     StringExtractorGDBRemote response;
 452     m_supports_thread_suffix = eLazyBoolNo;
 453     if (SendPacketAndWaitForResponse("QThreadSuffixSupported", response,
 454                                      false) == PacketResult::Success) {
 455       if (response.IsOKResponse())
 456         m_supports_thread_suffix = eLazyBoolYes;
 457     }
 458   }
 459   return m_supports_thread_suffix;
 460 }
 461 bool GDBRemoteCommunicationClient::GetVContSupported(char flavor) {
 462   if (m_supports_vCont_c == eLazyBoolCalculate) {
 463     StringExtractorGDBRemote response;
 464     m_supports_vCont_any = eLazyBoolNo;
 465     m_supports_vCont_all = eLazyBoolNo;
 466     m_supports_vCont_c = eLazyBoolNo;
 467     m_supports_vCont_C = eLazyBoolNo;
 468     m_supports_vCont_s = eLazyBoolNo;
 469     m_supports_vCont_S = eLazyBoolNo;
 470     if (SendPacketAndWaitForResponse("vCont?", response, false) ==
 471         PacketResult::Success) {
 472       const char *response_cstr = response.GetStringRef().c_str();
 473       if (::strstr(response_cstr, ";c"))
 474         m_supports_vCont_c = eLazyBoolYes;
 475
 476       if (::strstr(response_cstr, ";C"))
 477         m_supports_vCont_C = eLazyBoolYes;
 478
 479       if (::strstr(response_cstr, ";s"))
 480         m_supports_vCont_s = eLazyBoolYes;
 481
 482       if (::strstr(response_cstr, ";S"))
 483         m_supports_vCont_S = eLazyBoolYes;
 484
 485       if (m_supports_vCont_c == eLazyBoolYes &&
 486           m_supports_vCont_C == eLazyBoolYes &&
 487           m_supports_vCont_s == eLazyBoolYes &&
 488           m_supports_vCont_S == eLazyBoolYes) {
 489         m_supports_vCont_all = eLazyBoolYes;
 490       }
 491
 492       if (m_supports_vCont_c == eLazyBoolYes ||
 493           m_supports_vCont_C == eLazyBoolYes ||
 494           m_supports_vCont_s == eLazyBoolYes ||
 495           m_supports_vCont_S == eLazyBoolYes) {
 496         m_supports_vCont_any = eLazyBoolYes;
 497       }
 498     }
 499   }
 500
 501   switch (flavor) {
 502   case 'a':
 503     return m_supports_vCont_any;
 504   case 'A':
 505     return m_supports_vCont_all;
 506   case 'c':
 507     return m_supports_vCont_c;
 508   case 'C':
 509     return m_supports_vCont_C;
 510   case 's':
 511     return m_supports_vCont_s;
 512   case 'S':
 513     return m_supports_vCont_S;
 514   default:
 515     break;
 516   }
 517   return false;
 518 }
 519
 520 GDBRemoteCommunication::PacketResult
 521 GDBRemoteCommunicationClient::SendThreadSpecificPacketAndWaitForResponse(
 522     lldb::tid_t tid, StreamString &&payload, StringExtractorGDBRemote &response,
 523     bool send_async) {
 524   Lock lock(*this, send_async);
 525   if (!lock) {
 526     if (Log *log = ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(
 527             GDBR_LOG_PROCESS | GDBR_LOG_PACKETS))
 528       log->Printf("GDBRemoteCommunicationClient::%s: Didn't get sequence mutex "
 529                   "for %s packet.",
 530                   __FUNCTION__, payload.GetData());
 531     return PacketResult::ErrorNoSequenceLock;
 532   }
 533
 534   if (GetThreadSuffixSupported())
 535     payload.Printf(";thread:%4.4" PRIx64 ";", tid);
 536   else {
 537     if (!SetCurrentThread(tid))
 538       return PacketResult::ErrorSendFailed;
 539   }
 540
 541   return SendPacketAndWaitForResponseNoLock(payload.GetString(), response);
 542 }
 543
 544 // Check if the target supports 'p' packet. It sends out a 'p' packet and
 545 // checks the response. A normal packet will tell us that support is available.
 546 //
 547 // Takes a valid thread ID because p needs to apply to a thread.
 548 bool GDBRemoteCommunicationClient::GetpPacketSupported(lldb::tid_t tid) {
 549   if (m_supports_p == eLazyBoolCalculate) {
 550     m_supports_p = eLazyBoolNo;
 551     StreamString payload;
 552     payload.PutCString("p0");
 553     StringExtractorGDBRemote response;
 554     if (SendThreadSpecificPacketAndWaitForResponse(tid, std::move(payload),
 555                                                    response, false) ==
 556             PacketResult::Success &&
 557         response.IsNormalResponse()) {
 558       m_supports_p = eLazyBoolYes;
 559     }
 560   }
 561   return m_supports_p;
 562 }
 563
 564 StructuredData::ObjectSP GDBRemoteCommunicationClient::GetThreadsInfo() {
 565   // Get information on all threads at one using the "jThreadsInfo" packet
 566   StructuredData::ObjectSP object_sp;
 567
 568   if (m_supports_jThreadsInfo) {
 569     StringExtractorGDBRemote response;
 570     response.SetResponseValidatorToJSON();
 571     if (SendPacketAndWaitForResponse("jThreadsInfo", response, false) ==
 572         PacketResult::Success) {
 573       if (response.IsUnsupportedResponse()) {
 574         m_supports_jThreadsInfo = false;
 575       } else if (!response.Empty()) {
 576         object_sp = StructuredData::ParseJSON(response.GetStringRef());
 577       }
 578     }
 579   }
 580   return object_sp;
 581 }
 582
 583 bool GDBRemoteCommunicationClient::GetThreadExtendedInfoSupported() {
 584   if (m_supports_jThreadExtendedInfo == eLazyBoolCalculate) {
 585     StringExtractorGDBRemote response;
 586     m_supports_jThreadExtendedInfo = eLazyBoolNo;
 587     if (SendPacketAndWaitForResponse("jThreadExtendedInfo:", response, false) ==
 588         PacketResult::Success) {
 589       if (response.IsOKResponse()) {
 590         m_supports_jThreadExtendedInfo = eLazyBoolYes;
 591       }
 592     }
 593   }
 594   return m_supports_jThreadExtendedInfo;
 595 }
 596
 597 void GDBRemoteCommunicationClient::EnableErrorStringInPacket() {
 598   if (m_supports_error_string_reply == eLazyBoolCalculate) {
 599     StringExtractorGDBRemote response;
 600     // We try to enable error strings in remote packets but if we fail, we just
 601     // work in the older way.
 602     m_supports_error_string_reply = eLazyBoolNo;
 603     if (SendPacketAndWaitForResponse("QEnableErrorStrings", response, false) ==
 604         PacketResult::Success) {
 605       if (response.IsOKResponse()) {
 606         m_supports_error_string_reply = eLazyBoolYes;
 607       }
 608     }
 609   }
 610 }
 611
 612 bool GDBRemoteCommunicationClient::GetLoadedDynamicLibrariesInfosSupported() {
 613   if (m_supports_jLoadedDynamicLibrariesInfos == eLazyBoolCalculate) {
 614     StringExtractorGDBRemote response;
 615     m_supports_jLoadedDynamicLibrariesInfos = eLazyBoolNo;
 616     if (SendPacketAndWaitForResponse("jGetLoadedDynamicLibrariesInfos:",
 617                                      response,
 618                                      false) == PacketResult::Success) {
 619       if (response.IsOKResponse()) {
 620         m_supports_jLoadedDynamicLibrariesInfos = eLazyBoolYes;
 621       }
 622     }
 623   }
 624   return m_supports_jLoadedDynamicLibrariesInfos;
 625 }
 626
 627 bool GDBRemoteCommunicationClient::GetSharedCacheInfoSupported() {
 628   if (m_supports_jGetSharedCacheInfo == eLazyBoolCalculate) {
 629     StringExtractorGDBRemote response;
 630     m_supports_jGetSharedCacheInfo = eLazyBoolNo;
 631     if (SendPacketAndWaitForResponse("jGetSharedCacheInfo:", response, false) ==
 632         PacketResult::Success) {
 633       if (response.IsOKResponse()) {
 634         m_supports_jGetSharedCacheInfo = eLazyBoolYes;
 635       }
 636     }
 637   }
 638   return m_supports_jGetSharedCacheInfo;
 639 }
 640
 641 bool GDBRemoteCommunicationClient::GetxPacketSupported() {
 642   if (m_supports_x == eLazyBoolCalculate) {
 643     StringExtractorGDBRemote response;
 644     m_supports_x = eLazyBoolNo;
 645     char packet[256];
 646     snprintf(packet, sizeof(packet), "x0,0");
 647     if (SendPacketAndWaitForResponse(packet, response, false) ==
 648         PacketResult::Success) {
 649       if (response.IsOKResponse())
 650         m_supports_x = eLazyBoolYes;
 651     }
 652   }
 653   return m_supports_x;
 654 }
 655
 656 GDBRemoteCommunicationClient::PacketResult
 657 GDBRemoteCommunicationClient::SendPacketsAndConcatenateResponses(
 658     const char *payload_prefix, std::string &response_string) {
 659   Lock lock(*this, false);
 660   if (!lock) {
 661     Log *log(ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(GDBR_LOG_PROCESS |
 662                                                            GDBR_LOG_PACKETS));
 663     if (log)
 664       log->Printf("error: failed to get packet sequence mutex, not sending "
 665                   "packets with prefix '%s'",
 666                   payload_prefix);
 667     return PacketResult::ErrorNoSequenceLock;
 668   }
 669
 670   response_string = "";
 671   std::string payload_prefix_str(payload_prefix);
 672   unsigned int response_size = 0x1000;
 673   if (response_size > GetRemoteMaxPacketSize()) { // May send qSupported packet
 674     response_size = GetRemoteMaxPacketSize();
 675   }
 676
 677   for (unsigned int offset = 0; true; offset += response_size) {
 678     StringExtractorGDBRemote this_response;
 679     // Construct payload
 680     char sizeDescriptor[128];
 681     snprintf(sizeDescriptor, sizeof(sizeDescriptor), "%x,%x", offset,
 682              response_size);
 683     PacketResult result = SendPacketAndWaitForResponseNoLock(
 684         payload_prefix_str + sizeDescriptor, this_response);
 685     if (result != PacketResult::Success)
 686       return result;
 687
 688     const std::string &this_string = this_response.GetStringRef();
 689
 690     // Check for m or l as first character; l seems to mean this is the last
 691     // chunk
 692     char first_char = *this_string.c_str();
 693     if (first_char != 'm' && first_char != 'l') {
 694       return PacketResult::ErrorReplyInvalid;
 695     }
 696     // Concatenate the result so far (skipping 'm' or 'l')
 697     response_string.append(this_string, 1, std::string::npos);
 698     if (first_char == 'l')
 699       // We're done
 700       return PacketResult::Success;
 701   }
 702 }
 703
 704 lldb::pid_t GDBRemoteCommunicationClient::GetCurrentProcessID(bool allow_lazy) {
 705   if (allow_lazy && m_curr_pid_is_valid == eLazyBoolYes)
 706     return m_curr_pid;
 707
 708   // First try to retrieve the pid via the qProcessInfo request.
 709   GetCurrentProcessInfo(allow_lazy);
 710   if (m_curr_pid_is_valid == eLazyBoolYes) {
 711     // We really got it.
 712     return m_curr_pid;
 713   } else {
 714     // If we don't get a response for qProcessInfo, check if $qC gives us a
 715     // result. $qC only returns a real process id on older debugserver and
 716     // lldb-platform stubs. The gdb remote protocol documents $qC as returning
 717     // the thread id, which newer debugserver and lldb-gdbserver stubs return
 718     // correctly.
 719     StringExtractorGDBRemote response;
 720     if (SendPacketAndWaitForResponse("qC", response, false) ==
 721         PacketResult::Success) {
 722       if (response.GetChar() == 'Q') {
 723         if (response.GetChar() == 'C') {
 724           m_curr_pid = response.GetHexMaxU32(false, LLDB_INVALID_PROCESS_ID);
 725           if (m_curr_pid != LLDB_INVALID_PROCESS_ID) {
 726             m_curr_pid_is_valid = eLazyBoolYes;
 727             return m_curr_pid;
 728           }
 729         }
 730       }
 731     }
 732
 733     // If we don't get a response for $qC, check if $qfThreadID gives us a
 734     // result.
 735     if (m_curr_pid == LLDB_INVALID_PROCESS_ID) {
 736       std::vector<lldb::tid_t> thread_ids;
 737       bool sequence_mutex_unavailable;
 738       size_t size;
 739       size = GetCurrentThreadIDs(thread_ids, sequence_mutex_unavailable);
 740       if (size && !sequence_mutex_unavailable) {
 741         m_curr_pid = thread_ids.front();
 742         m_curr_pid_is_valid = eLazyBoolYes;
 743         return m_curr_pid;
 744       }
 745     }
 746   }
 747
 748   return LLDB_INVALID_PROCESS_ID;
 749 }
 750
 751 bool GDBRemoteCommunicationClient::GetLaunchSuccess(std::string &error_str) {
 752   error_str.clear();
 753   StringExtractorGDBRemote response;
 754   if (SendPacketAndWaitForResponse("qLaunchSuccess", response, false) ==
 755       PacketResult::Success) {
 756     if (response.IsOKResponse())
 757       return true;
 758     if (response.GetChar() == 'E') {
 759       // A string the describes what failed when launching...
 760       error_str = response.GetStringRef().substr(1);
 761     } else {
 762       error_str.assign("unknown error occurred launching process");
 763     }
 764   } else {
 765     error_str.assign("timed out waiting for app to launch");
 766   }
 767   return false;
 768 }
 769
 770 int GDBRemoteCommunicationClient::SendArgumentsPacket(
 771     const ProcessLaunchInfo &launch_info) {
 772   // Since we don't get the send argv0 separate from the executable path, we
 773   // need to make sure to use the actual executable path found in the
 774   // launch_info...
 775   std::vector<const char *> argv;
 776   FileSpec exe_file = launch_info.GetExecutableFile();
 777   std::string exe_path;
 778   const char *arg = nullptr;
 779   const Args &launch_args = launch_info.GetArguments();
 780   if (exe_file)
 781     exe_path = exe_file.GetPath(false);
 782   else {
 783     arg = launch_args.GetArgumentAtIndex(0);
 784     if (arg)
 785       exe_path = arg;
 786   }
 787   if (!exe_path.empty()) {
 788     argv.push_back(exe_path.c_str());
 789     for (uint32_t i = 1; (arg = launch_args.GetArgumentAtIndex(i)) != nullptr;
 790          ++i) {
 791       if (arg)
 792         argv.push_back(arg);
 793     }
 794   }
 795   if (!argv.empty()) {
 796     StreamString packet;
 797     packet.PutChar('A');
 798     for (size_t i = 0, n = argv.size(); i < n; ++i) {
 799       arg = argv[i];
 800       const int arg_len = strlen(arg);
 801       if (i > 0)
 802         packet.PutChar(',');
 803       packet.Printf("%i,%i,", arg_len * 2, (int)i);
 804       packet.PutBytesAsRawHex8(arg, arg_len);
 805     }
 806
 807     StringExtractorGDBRemote response;
 808     if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
 809         PacketResult::Success) {
 810       if (response.IsOKResponse())
 811         return 0;
 812       uint8_t error = response.GetError();
 813       if (error)
 814         return error;
 815     }
 816   }
 817   return -1;
 818 }
 819
 820 int GDBRemoteCommunicationClient::SendEnvironment(const Environment &env) {
 821   for (const auto &KV : env) {
 822     int r = SendEnvironmentPacket(Environment::compose(KV).c_str());
 823     if (r != 0)
 824       return r;
 825   }
 826   return 0;
 827 }
 828
 829 int GDBRemoteCommunicationClient::SendEnvironmentPacket(
 830     char const *name_equal_value) {
 831   if (name_equal_value && name_equal_value[0]) {
 832     StreamString packet;
 833     bool send_hex_encoding = false;
 834     for (const char *p = name_equal_value; *p != '\0' && !send_hex_encoding;
 835          ++p) {
 836       if (isprint(*p)) {
 837         switch (*p) {
 838         case '$':
 839         case '#':
 840         case '*':
 841         case '}':
 842           send_hex_encoding = true;
 843           break;
 844         default:
 845           break;
 846         }
 847       } else {
 848         // We have non printable characters, lets hex encode this...
 849         send_hex_encoding = true;
 850       }
 851     }
 852
 853     StringExtractorGDBRemote response;
 854     if (send_hex_encoding) {
 855       if (m_supports_QEnvironmentHexEncoded) {
 856         packet.PutCString("QEnvironmentHexEncoded:");
 857         packet.PutBytesAsRawHex8(name_equal_value, strlen(name_equal_value));
 858         if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
 859             PacketResult::Success) {
 860           if (response.IsOKResponse())
 861             return 0;
 862           uint8_t error = response.GetError();
 863           if (error)
 864             return error;
 865           if (response.IsUnsupportedResponse())
 866             m_supports_QEnvironmentHexEncoded = false;
 867         }
 868       }
 869
 870     } else if (m_supports_QEnvironment) {
 871       packet.Printf("QEnvironment:%s", name_equal_value);
 872       if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
 873           PacketResult::Success) {
 874         if (response.IsOKResponse())
 875           return 0;
 876         uint8_t error = response.GetError();
 877         if (error)
 878           return error;
 879         if (response.IsUnsupportedResponse())
 880           m_supports_QEnvironment = false;
 881       }
 882     }
 883   }
 884   return -1;
 885 }
 886
 887 int GDBRemoteCommunicationClient::SendLaunchArchPacket(char const *arch) {
 888   if (arch && arch[0]) {
 889     StreamString packet;
 890     packet.Printf("QLaunchArch:%s", arch);
 891     StringExtractorGDBRemote response;
 892     if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
 893         PacketResult::Success) {
 894       if (response.IsOKResponse())
 895         return 0;
 896       uint8_t error = response.GetError();
 897       if (error)
 898         return error;
 899     }
 900   }
 901   return -1;
 902 }
 903
 904 int GDBRemoteCommunicationClient::SendLaunchEventDataPacket(
 905     char const *data, bool *was_supported) {
 906   if (data && *data != '\0') {
 907     StreamString packet;
 908     packet.Printf("QSetProcessEvent:%s", data);
 909     StringExtractorGDBRemote response;
 910     if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
 911         PacketResult::Success) {
 912       if (response.IsOKResponse()) {
 913         if (was_supported)
 914           *was_supported = true;
 915         return 0;
 916       } else if (response.IsUnsupportedResponse()) {
 917         if (was_supported)
 918           *was_supported = false;
 919         return -1;
 920       } else {
 921         uint8_t error = response.GetError();
 922         if (was_supported)
 923           *was_supported = true;
 924         if (error)
 925           return error;
 926       }
 927     }
 928   }
 929   return -1;
 930 }
 931
 932 llvm::VersionTuple GDBRemoteCommunicationClient::GetOSVersion() {
 933   GetHostInfo();
 934   return m_os_version;
 935 }
 936
 937 bool GDBRemoteCommunicationClient::GetOSBuildString(std::string &s) {
 938   if (GetHostInfo()) {
 939     if (!m_os_build.empty()) {
 940       s = m_os_build;
 941       return true;
 942     }
 943   }
 944   s.clear();
 945   return false;
 946 }
 947
 948 bool GDBRemoteCommunicationClient::GetOSKernelDescription(std::string &s) {
 949   if (GetHostInfo()) {
 950     if (!m_os_kernel.empty()) {
 951       s = m_os_kernel;
 952       return true;
 953     }
 954   }
 955   s.clear();
 956   return false;
 957 }
 958
 959 bool GDBRemoteCommunicationClient::GetHostname(std::string &s) {
 960   if (GetHostInfo()) {
 961     if (!m_hostname.empty()) {
 962       s = m_hostname;
 963       return true;
 964     }
 965   }
 966   s.clear();
 967   return false;
 968 }
 969
 970 ArchSpec GDBRemoteCommunicationClient::GetSystemArchitecture() {
 971   if (GetHostInfo())
 972     return m_host_arch;
 973   return ArchSpec();
 974 }
 975
 976 const lldb_private::ArchSpec &
 977 GDBRemoteCommunicationClient::GetProcessArchitecture() {
 978   if (m_qProcessInfo_is_valid == eLazyBoolCalculate)
 979     GetCurrentProcessInfo();
 980   return m_process_arch;
 981 }
 982
 983 bool GDBRemoteCommunicationClient::GetGDBServerVersion() {
 984   if (m_qGDBServerVersion_is_valid == eLazyBoolCalculate) {
 985     m_gdb_server_name.clear();
 986     m_gdb_server_version = 0;
 987     m_qGDBServerVersion_is_valid = eLazyBoolNo;
 988
 989     StringExtractorGDBRemote response;
 990     if (SendPacketAndWaitForResponse("qGDBServerVersion", response, false) ==
 991         PacketResult::Success) {
 992       if (response.IsNormalResponse()) {
 993         llvm::StringRef name, value;
 994         bool success = false;
 995         while (response.GetNameColonValue(name, value)) {
 996           if (name.equals("name")) {
 997             success = true;
 998             m_gdb_server_name = value;
 999           } else if (name.equals("version")) {
1000             llvm::StringRef major, minor;
1001             std::tie(major, minor) = value.split('.');
1002             if (!major.getAsInteger(0, m_gdb_server_version))
1003               success = true;
1004           }
1005         }
1006         if (success)
1007           m_qGDBServerVersion_is_valid = eLazyBoolYes;
1008       }
1009     }
1010   }
1011   return m_qGDBServerVersion_is_valid == eLazyBoolYes;
1012 }
1013
1014 void GDBRemoteCommunicationClient::MaybeEnableCompression(
1015     std::vector<std::string> supported_compressions) {
1016   CompressionType avail_type = CompressionType::None;
1017   std::string avail_name;
1018
1019 #if defined(HAVE_LIBCOMPRESSION)
1020   if (avail_type == CompressionType::None) {
1021     for (auto compression : supported_compressions) {
1022       if (compression == "lzfse") {
1023         avail_type = CompressionType::LZFSE;
1024         avail_name = compression;
1025         break;
1026       }
1027     }
1028   }
1029 #endif
1030
1031 #if defined(HAVE_LIBCOMPRESSION)
1032   if (avail_type == CompressionType::None) {
1033     for (auto compression : supported_compressions) {
1034       if (compression == "zlib-deflate") {
1035         avail_type = CompressionType::ZlibDeflate;
1036         avail_name = compression;
1037         break;
1038       }
1039     }
1040   }
1041 #endif
1042
1043 #if defined(HAVE_LIBZ)
1044   if (avail_type == CompressionType::None) {
1045     for (auto compression : supported_compressions) {
1046       if (compression == "zlib-deflate") {
1047         avail_type = CompressionType::ZlibDeflate;
1048         avail_name = compression;
1049         break;
1050       }
1051     }
1052   }
1053 #endif
1054
1055 #if defined(HAVE_LIBCOMPRESSION)
1056   if (avail_type == CompressionType::None) {
1057     for (auto compression : supported_compressions) {
1058       if (compression == "lz4") {
1059         avail_type = CompressionType::LZ4;
1060         avail_name = compression;
1061         break;
1062       }
1063     }
1064   }
1065 #endif
1066
1067 #if defined(HAVE_LIBCOMPRESSION)
1068   if (avail_type == CompressionType::None) {
1069     for (auto compression : supported_compressions) {
1070       if (compression == "lzma") {
1071         avail_type = CompressionType::LZMA;
1072         avail_name = compression;
1073         break;
1074       }
1075     }
1076   }
1077 #endif
1078
1079   if (avail_type != CompressionType::None) {
1080     StringExtractorGDBRemote response;
1081     std::string packet = "QEnableCompression:type:" + avail_name + ";";
1082     if (SendPacketAndWaitForResponse(packet, response, false) !=
1083         PacketResult::Success)
1084       return;
1085
1086     if (response.IsOKResponse()) {
1087       m_compression_type = avail_type;
1088     }
1089   }
1090 }
1091
1092 const char *GDBRemoteCommunicationClient::GetGDBServerProgramName() {
1093   if (GetGDBServerVersion()) {
1094     if (!m_gdb_server_name.empty())
1095       return m_gdb_server_name.c_str();
1096   }
1097   return nullptr;
1098 }
1099
1100 uint32_t GDBRemoteCommunicationClient::GetGDBServerProgramVersion() {
1101   if (GetGDBServerVersion())
1102     return m_gdb_server_version;
1103   return 0;
1104 }
1105
1106 bool GDBRemoteCommunicationClient::GetDefaultThreadId(lldb::tid_t &tid) {
1107   StringExtractorGDBRemote response;
1108   if (SendPacketAndWaitForResponse("qC", response, false) !=
1109       PacketResult::Success)
1110     return false;
1111
1112   if (!response.IsNormalResponse())
1113     return false;
1114
1115   if (response.GetChar() == 'Q' && response.GetChar() == 'C')
1116     tid = response.GetHexMaxU32(true, -1);
1117
1118   return true;
1119 }
1120
1121 bool GDBRemoteCommunicationClient::GetHostInfo(bool force) {
1122   Log *log(ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(GDBR_LOG_PROCESS));
1123
1124   if (force || m_qHostInfo_is_valid == eLazyBoolCalculate) {
1125     // host info computation can require DNS traffic and shelling out to external processes.
1126     // Increase the timeout to account for that.
1127     ScopedTimeout timeout(*this, seconds(10));
1128     m_qHostInfo_is_valid = eLazyBoolNo;
1129     StringExtractorGDBRemote response;
1130     if (SendPacketAndWaitForResponse("qHostInfo", response, false) ==
1131         PacketResult::Success) {
1132       if (response.IsNormalResponse()) {
1133         llvm::StringRef name;
1134         llvm::StringRef value;
1135         uint32_t cpu = LLDB_INVALID_CPUTYPE;
1136         uint32_t sub = 0;
1137         std::string arch_name;
1138         std::string os_name;
1139         std::string vendor_name;
1140         std::string triple;
1141         std::string distribution_id;
1142         uint32_t pointer_byte_size = 0;
1143         ByteOrder byte_order = eByteOrderInvalid;
1144         uint32_t num_keys_decoded = 0;
1145         while (response.GetNameColonValue(name, value)) {
1146           if (name.equals("cputype")) {
1147             // exception type in big endian hex
1148             if (!value.getAsInteger(0, cpu))
1149               ++num_keys_decoded;
1150           } else if (name.equals("cpusubtype")) {
1151             // exception count in big endian hex
1152             if (!value.getAsInteger(0, sub))
1153               ++num_keys_decoded;
1154           } else if (name.equals("arch")) {
1155             arch_name = value;
1156             ++num_keys_decoded;
1157           } else if (name.equals("triple")) {
1158             StringExtractor extractor(value);
1159             extractor.GetHexByteString(triple);
1160             ++num_keys_decoded;
1161           } else if (name.equals("distribution_id")) {
1162             StringExtractor extractor(value);
1163             extractor.GetHexByteString(distribution_id);
1164             ++num_keys_decoded;
1165           } else if (name.equals("os_build")) {
1166             StringExtractor extractor(value);
1167             extractor.GetHexByteString(m_os_build);
1168             ++num_keys_decoded;
1169           } else if (name.equals("hostname")) {
1170             StringExtractor extractor(value);
1171             extractor.GetHexByteString(m_hostname);
1172             ++num_keys_decoded;
1173           } else if (name.equals("os_kernel")) {
1174             StringExtractor extractor(value);
1175             extractor.GetHexByteString(m_os_kernel);
1176             ++num_keys_decoded;
1177           } else if (name.equals("ostype")) {
1178             os_name = value;
1179             ++num_keys_decoded;
1180           } else if (name.equals("vendor")) {
1181             vendor_name = value;
1182             ++num_keys_decoded;
1183           } else if (name.equals("endian")) {
1184             byte_order = llvm::StringSwitch<lldb::ByteOrder>(value)
1185                              .Case("little", eByteOrderLittle)
1186                              .Case("big", eByteOrderBig)
1187                              .Case("pdp", eByteOrderPDP)
1188                              .Default(eByteOrderInvalid);
1189             if (byte_order != eByteOrderInvalid)
1190               ++num_keys_decoded;
1191           } else if (name.equals("ptrsize")) {
1192             if (!value.getAsInteger(0, pointer_byte_size))
1193               ++num_keys_decoded;
1194           } else if (name.equals("os_version") ||
1195                      name.equals(
1196                          "version")) // Older debugserver binaries used the
1197                                      // "version" key instead of
1198                                      // "os_version"...
1199           {
1200             if (!m_os_version.tryParse(value))
1201               ++num_keys_decoded;
1202           } else if (name.equals("watchpoint_exceptions_received")) {
1203             m_watchpoints_trigger_after_instruction =
1204                 llvm::StringSwitch<LazyBool>(value)
1205                     .Case("before", eLazyBoolNo)
1206                     .Case("after", eLazyBoolYes)
1207                     .Default(eLazyBoolCalculate);
1208             if (m_watchpoints_trigger_after_instruction != eLazyBoolCalculate)
1209               ++num_keys_decoded;
1210           } else if (name.equals("default_packet_timeout")) {
1211             uint32_t timeout_seconds;
1212             if (!value.getAsInteger(0, timeout_seconds)) {
1213               m_default_packet_timeout = seconds(timeout_seconds);
1214               SetPacketTimeout(m_default_packet_timeout);
1215               ++num_keys_decoded;
1216             }
1217           }
1218         }
1219
1220         if (num_keys_decoded > 0)
1221           m_qHostInfo_is_valid = eLazyBoolYes;
1222
1223         if (triple.empty()) {
1224           if (arch_name.empty()) {
1225             if (cpu != LLDB_INVALID_CPUTYPE) {
1226               m_host_arch.SetArchitecture(eArchTypeMachO, cpu, sub);
1227               if (pointer_byte_size) {
1228                 assert(pointer_byte_size == m_host_arch.GetAddressByteSize());
1229               }
1230               if (byte_order != eByteOrderInvalid) {
1231                 assert(byte_order == m_host_arch.GetByteOrder());
1232               }
1233
1234               if (!vendor_name.empty())
1235                 m_host_arch.GetTriple().setVendorName(
1236                     llvm::StringRef(vendor_name));
1237               if (!os_name.empty())
1238                 m_host_arch.GetTriple().setOSName(llvm::StringRef(os_name));
1239             }
1240           } else {
1241             std::string triple;
1242             triple += arch_name;
1243             if (!vendor_name.empty() || !os_name.empty()) {
1244               triple += '-';
1245               if (vendor_name.empty())
1246                 triple += "unknown";
1247               else
1248                 triple += vendor_name;
1249               triple += '-';
1250               if (os_name.empty())
1251                 triple += "unknown";
1252               else
1253                 triple += os_name;
1254             }
1255             m_host_arch.SetTriple(triple.c_str());
1256
1257             llvm::Triple &host_triple = m_host_arch.GetTriple();
1258             if (host_triple.getVendor() == llvm::Triple::Apple &&
1259                 host_triple.getOS() == llvm::Triple::Darwin) {
1260               switch (m_host_arch.GetMachine()) {
1261               case llvm::Triple::aarch64:
1262               case llvm::Triple::arm:
1263               case llvm::Triple::thumb:
1264                 host_triple.setOS(llvm::Triple::IOS);
1265                 break;
1266               default:
1267                 host_triple.setOS(llvm::Triple::MacOSX);
1268                 break;
1269               }
1270             }
1271             if (pointer_byte_size) {
1272               assert(pointer_byte_size == m_host_arch.GetAddressByteSize());
1273             }
1274             if (byte_order != eByteOrderInvalid) {
1275               assert(byte_order == m_host_arch.GetByteOrder());
1276             }
1277           }
1278         } else {
1279           m_host_arch.SetTriple(triple.c_str());
1280           if (pointer_byte_size) {
1281             assert(pointer_byte_size == m_host_arch.GetAddressByteSize());
1282           }
1283           if (byte_order != eByteOrderInvalid) {
1284             assert(byte_order == m_host_arch.GetByteOrder());
1285           }
1286
1287           if (log)
1288             log->Printf("GDBRemoteCommunicationClient::%s parsed host "
1289                         "architecture as %s, triple as %s from triple text %s",
1290                         __FUNCTION__, m_host_arch.GetArchitectureName()
1291                                           ? m_host_arch.GetArchitectureName()
1292                                           : "<null-arch-name>",
1293                         m_host_arch.GetTriple().getTriple().c_str(),
1294                         triple.c_str());
1295         }
1296         if (!distribution_id.empty())
1297           m_host_arch.SetDistributionId(distribution_id.c_str());
1298       }
1299     }
1300   }
1301   return m_qHostInfo_is_valid == eLazyBoolYes;
1302 }
1303
1304 int GDBRemoteCommunicationClient::SendAttach(
1305     lldb::pid_t pid, StringExtractorGDBRemote &response) {
1306   if (pid != LLDB_INVALID_PROCESS_ID) {
1307     char packet[64];
1308     const int packet_len =
1309         ::snprintf(packet, sizeof(packet), "vAttach;%" PRIx64, pid);
1310     UNUSED_IF_ASSERT_DISABLED(packet_len);
1311     assert(packet_len < (int)sizeof(packet));
1312     if (SendPacketAndWaitForResponse(packet, response, false) ==
1313         PacketResult::Success) {
1314       if (response.IsErrorResponse())
1315         return response.GetError();
1316       return 0;
1317     }
1318   }
1319   return -1;
1320 }
1321
1322 int GDBRemoteCommunicationClient::SendStdinNotification(const char *data,
1323                                                         size_t data_len) {
1324   StreamString packet;
1325   packet.PutCString("I");
1326   packet.PutBytesAsRawHex8(data, data_len);
1327   StringExtractorGDBRemote response;
1328   if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
1329       PacketResult::Success) {
1330     return 0;
1331   }
1332   return response.GetError();
1333 }
1334
1335 const lldb_private::ArchSpec &
1336 GDBRemoteCommunicationClient::GetHostArchitecture() {
1337   if (m_qHostInfo_is_valid == eLazyBoolCalculate)
1338     GetHostInfo();
1339   return m_host_arch;
1340 }
1341
1342 seconds GDBRemoteCommunicationClient::GetHostDefaultPacketTimeout() {
1343   if (m_qHostInfo_is_valid == eLazyBoolCalculate)
1344     GetHostInfo();
1345   return m_default_packet_timeout;
1346 }
1347
1348 addr_t GDBRemoteCommunicationClient::AllocateMemory(size_t size,
1349                                                     uint32_t permissions) {
1350   if (m_supports_alloc_dealloc_memory != eLazyBoolNo) {
1351     m_supports_alloc_dealloc_memory = eLazyBoolYes;
1352     char packet[64];
1353     const int packet_len = ::snprintf(
1354         packet, sizeof(packet), "_M%" PRIx64 ",%s%s%s", (uint64_t)size,
1355         permissions & lldb::ePermissionsReadable ? "r" : "",
1356         permissions & lldb::ePermissionsWritable ? "w" : "",
1357         permissions & lldb::ePermissionsExecutable ? "x" : "");
1358     assert(packet_len < (int)sizeof(packet));
1359     UNUSED_IF_ASSERT_DISABLED(packet_len);
1360     StringExtractorGDBRemote response;
1361     if (SendPacketAndWaitForResponse(packet, response, false) ==
1362         PacketResult::Success) {
1363       if (response.IsUnsupportedResponse())
1364         m_supports_alloc_dealloc_memory = eLazyBoolNo;
1365       else if (!response.IsErrorResponse())
1366         return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
1367     } else {
1368       m_supports_alloc_dealloc_memory = eLazyBoolNo;
1369     }
1370   }
1371   return LLDB_INVALID_ADDRESS;
1372 }
1373
1374 bool GDBRemoteCommunicationClient::DeallocateMemory(addr_t addr) {
1375   if (m_supports_alloc_dealloc_memory != eLazyBoolNo) {
1376     m_supports_alloc_dealloc_memory = eLazyBoolYes;
1377     char packet[64];
1378     const int packet_len =
1379         ::snprintf(packet, sizeof(packet), "_m%" PRIx64, (uint64_t)addr);
1380     assert(packet_len < (int)sizeof(packet));
1381     UNUSED_IF_ASSERT_DISABLED(packet_len);
1382     StringExtractorGDBRemote response;
1383     if (SendPacketAndWaitForResponse(packet, response, false) ==
1384         PacketResult::Success) {
1385       if (response.IsUnsupportedResponse())
1386         m_supports_alloc_dealloc_memory = eLazyBoolNo;
1387       else if (response.IsOKResponse())
1388         return true;
1389     } else {
1390       m_supports_alloc_dealloc_memory = eLazyBoolNo;
1391     }
1392   }
1393   return false;
1394 }
1395
1396 Status GDBRemoteCommunicationClient::Detach(bool keep_stopped) {
1397   Status error;
1398
1399   if (keep_stopped) {
1400     if (m_supports_detach_stay_stopped == eLazyBoolCalculate) {
1401       char packet[64];
1402       const int packet_len =
1403           ::snprintf(packet, sizeof(packet), "qSupportsDetachAndStayStopped:");
1404       assert(packet_len < (int)sizeof(packet));
1405       UNUSED_IF_ASSERT_DISABLED(packet_len);
1406       StringExtractorGDBRemote response;
1407       if (SendPacketAndWaitForResponse(packet, response, false) ==
1408               PacketResult::Success &&
1409           response.IsOKResponse()) {
1410         m_supports_detach_stay_stopped = eLazyBoolYes;
1411       } else {
1412         m_supports_detach_stay_stopped = eLazyBoolNo;
1413       }
1414     }
1415
1416     if (m_supports_detach_stay_stopped == eLazyBoolNo) {
1417       error.SetErrorString("Stays stopped not supported by this target.");
1418       return error;
1419     } else {
1420       StringExtractorGDBRemote response;
1421       PacketResult packet_result =
1422           SendPacketAndWaitForResponse("D1", response, false);
1423       if (packet_result != PacketResult::Success)
1424         error.SetErrorString("Sending extended disconnect packet failed.");
1425     }
1426   } else {
1427     StringExtractorGDBRemote response;
1428     PacketResult packet_result =
1429         SendPacketAndWaitForResponse("D", response, false);
1430     if (packet_result != PacketResult::Success)
1431       error.SetErrorString("Sending disconnect packet failed.");
1432   }
1433   return error;
1434 }
1435
1436 Status GDBRemoteCommunicationClient::GetMemoryRegionInfo(
1437     lldb::addr_t addr, lldb_private::MemoryRegionInfo &region_info) {
1438   Status error;
1439   region_info.Clear();
1440
1441   if (m_supports_memory_region_info != eLazyBoolNo) {
1442     m_supports_memory_region_info = eLazyBoolYes;
1443     char packet[64];
1444     const int packet_len = ::snprintf(
1445         packet, sizeof(packet), "qMemoryRegionInfo:%" PRIx64, (uint64_t)addr);
1446     assert(packet_len < (int)sizeof(packet));
1447     UNUSED_IF_ASSERT_DISABLED(packet_len);
1448     StringExtractorGDBRemote response;
1449     if (SendPacketAndWaitForResponse(packet, response, false) ==
1450             PacketResult::Success &&
1451         response.GetResponseType() == StringExtractorGDBRemote::eResponse) {
1452       llvm::StringRef name;
1453       llvm::StringRef value;
1454       addr_t addr_value = LLDB_INVALID_ADDRESS;
1455       bool success = true;
1456       bool saw_permissions = false;
1457       while (success && response.GetNameColonValue(name, value)) {
1458         if (name.equals("start")) {
1459           if (!value.getAsInteger(16, addr_value))
1460             region_info.GetRange().SetRangeBase(addr_value);
1461         } else if (name.equals("size")) {
1462           if (!value.getAsInteger(16, addr_value))
1463             region_info.GetRange().SetByteSize(addr_value);
1464         } else if (name.equals("permissions") &&
1465                    region_info.GetRange().IsValid()) {
1466           saw_permissions = true;
1467           if (region_info.GetRange().Contains(addr)) {
1468             if (value.find('r') != llvm::StringRef::npos)
1469               region_info.SetReadable(MemoryRegionInfo::eYes);
1470             else
1471               region_info.SetReadable(MemoryRegionInfo::eNo);
1472
1473             if (value.find('w') != llvm::StringRef::npos)
1474               region_info.SetWritable(MemoryRegionInfo::eYes);
1475             else
1476               region_info.SetWritable(MemoryRegionInfo::eNo);
1477
1478             if (value.find('x') != llvm::StringRef::npos)
1479               region_info.SetExecutable(MemoryRegionInfo::eYes);
1480             else
1481               region_info.SetExecutable(MemoryRegionInfo::eNo);
1482
1483             region_info.SetMapped(MemoryRegionInfo::eYes);
1484           } else {
1485             // The reported region does not contain this address -- we're
1486             // looking at an unmapped page
1487             region_info.SetReadable(MemoryRegionInfo::eNo);
1488             region_info.SetWritable(MemoryRegionInfo::eNo);
1489             region_info.SetExecutable(MemoryRegionInfo::eNo);
1490             region_info.SetMapped(MemoryRegionInfo::eNo);
1491           }
1492         } else if (name.equals("name")) {
1493           StringExtractorGDBRemote name_extractor(value);
1494           std::string name;
1495           name_extractor.GetHexByteString(name);
1496           region_info.SetName(name.c_str());
1497         } else if (name.equals("error")) {
1498           StringExtractorGDBRemote error_extractor(value);
1499           std::string error_string;
1500           // Now convert the HEX bytes into a string value
1501           error_extractor.GetHexByteString(error_string);
1502           error.SetErrorString(error_string.c_str());
1503         }
1504       }
1505
1506       if (region_info.GetRange().IsValid()) {
1507         // We got a valid address range back but no permissions -- which means
1508         // this is an unmapped page
1509         if (!saw_permissions) {
1510           region_info.SetReadable(MemoryRegionInfo::eNo);
1511           region_info.SetWritable(MemoryRegionInfo::eNo);
1512           region_info.SetExecutable(MemoryRegionInfo::eNo);
1513           region_info.SetMapped(MemoryRegionInfo::eNo);
1514         }
1515       } else {
1516         // We got an invalid address range back
1517         error.SetErrorString("Server returned invalid range");
1518       }
1519     } else {
1520       m_supports_memory_region_info = eLazyBoolNo;
1521     }
1522   }
1523
1524   if (m_supports_memory_region_info == eLazyBoolNo) {
1525     error.SetErrorString("qMemoryRegionInfo is not supported");
1526   }
1527
1528   // Try qXfer:memory-map:read to get region information not included in
1529   // qMemoryRegionInfo
1530   MemoryRegionInfo qXfer_region_info;
1531   Status qXfer_error = GetQXferMemoryMapRegionInfo(addr, qXfer_region_info);
1532
1533   if (error.Fail()) {
1534     // If qMemoryRegionInfo failed, but qXfer:memory-map:read succeeded, use
1535     // the qXfer result as a fallback
1536     if (qXfer_error.Success()) {
1537       region_info = qXfer_region_info;
1538       error.Clear();
1539     } else {
1540       region_info.Clear();
1541     }
1542   } else if (qXfer_error.Success()) {
1543     // If both qMemoryRegionInfo and qXfer:memory-map:read succeeded, and if
1544     // both regions are the same range, update the result to include the flash-
1545     // memory information that is specific to the qXfer result.
1546     if (region_info.GetRange() == qXfer_region_info.GetRange()) {
1547       region_info.SetFlash(qXfer_region_info.GetFlash());
1548       region_info.SetBlocksize(qXfer_region_info.GetBlocksize());
1549     }
1550   }
1551   return error;
1552 }
1553
1554 Status GDBRemoteCommunicationClient::GetQXferMemoryMapRegionInfo(
1555     lldb::addr_t addr, MemoryRegionInfo &region) {
1556   Status error = LoadQXferMemoryMap();
1557   if (!error.Success())
1558     return error;
1559   for (const auto &map_region : m_qXfer_memory_map) {
1560     if (map_region.GetRange().Contains(addr)) {
1561       region = map_region;
1562       return error;
1563     }
1564   }
1565   error.SetErrorString("Region not found");
1566   return error;
1567 }
1568
1569 Status GDBRemoteCommunicationClient::LoadQXferMemoryMap() {
1570
1571   Status error;
1572
1573   if (m_qXfer_memory_map_loaded)
1574     // Already loaded, return success
1575     return error;
1576
1577   if (!XMLDocument::XMLEnabled()) {
1578     error.SetErrorString("XML is not supported");
1579     return error;
1580   }
1581
1582   if (!GetQXferMemoryMapReadSupported()) {
1583     error.SetErrorString("Memory map is not supported");
1584     return error;
1585   }
1586
1587   std::string xml;
1588   lldb_private::Status lldberr;
1589   if (!ReadExtFeature(ConstString("memory-map"), ConstString(""), xml,
1590                       lldberr)) {
1591     error.SetErrorString("Failed to read memory map");
1592     return error;
1593   }
1594
1595   XMLDocument xml_document;
1596
1597   if (!xml_document.ParseMemory(xml.c_str(), xml.size())) {
1598     error.SetErrorString("Failed to parse memory map xml");
1599     return error;
1600   }
1601
1602   XMLNode map_node = xml_document.GetRootElement("memory-map");
1603   if (!map_node) {
1604     error.SetErrorString("Invalid root node in memory map xml");
1605     return error;
1606   }
1607
1608   m_qXfer_memory_map.clear();
1609
1610   map_node.ForEachChildElement([this](const XMLNode &memory_node) -> bool {
1611     if (!memory_node.IsElement())
1612       return true;
1613     if (memory_node.GetName() != "memory")
1614       return true;
1615     auto type = memory_node.GetAttributeValue("type", "");
1616     uint64_t start;
1617     uint64_t length;
1618     if (!memory_node.GetAttributeValueAsUnsigned("start", start))
1619       return true;
1620     if (!memory_node.GetAttributeValueAsUnsigned("length", length))
1621       return true;
1622     MemoryRegionInfo region;
1623     region.GetRange().SetRangeBase(start);
1624     region.GetRange().SetByteSize(length);
1625     if (type == "rom") {
1626       region.SetReadable(MemoryRegionInfo::eYes);
1627       this->m_qXfer_memory_map.push_back(region);
1628     } else if (type == "ram") {
1629       region.SetReadable(MemoryRegionInfo::eYes);
1630       region.SetWritable(MemoryRegionInfo::eYes);
1631       this->m_qXfer_memory_map.push_back(region);
1632     } else if (type == "flash") {
1633       region.SetFlash(MemoryRegionInfo::eYes);
1634       memory_node.ForEachChildElement(
1635           [&region](const XMLNode &prop_node) -> bool {
1636             if (!prop_node.IsElement())
1637               return true;
1638             if (prop_node.GetName() != "property")
1639               return true;
1640             auto propname = prop_node.GetAttributeValue("name", "");
1641             if (propname == "blocksize") {
1642               uint64_t blocksize;
1643               if (prop_node.GetElementTextAsUnsigned(blocksize))
1644                 region.SetBlocksize(blocksize);
1645             }
1646             return true;
1647           });
1648       this->m_qXfer_memory_map.push_back(region);
1649     }
1650     return true;
1651   });
1652
1653   m_qXfer_memory_map_loaded = true;
1654
1655   return error;
1656 }
1657
1658 Status GDBRemoteCommunicationClient::GetWatchpointSupportInfo(uint32_t &num) {
1659   Status error;
1660
1661   if (m_supports_watchpoint_support_info == eLazyBoolYes) {
1662     num = m_num_supported_hardware_watchpoints;
1663     return error;
1664   }
1665
1666   // Set num to 0 first.
1667   num = 0;
1668   if (m_supports_watchpoint_support_info != eLazyBoolNo) {
1669     char packet[64];
1670     const int packet_len =
1671         ::snprintf(packet, sizeof(packet), "qWatchpointSupportInfo:");
1672     assert(packet_len < (int)sizeof(packet));
1673     UNUSED_IF_ASSERT_DISABLED(packet_len);
1674     StringExtractorGDBRemote response;
1675     if (SendPacketAndWaitForResponse(packet, response, false) ==
1676         PacketResult::Success) {
1677       m_supports_watchpoint_support_info = eLazyBoolYes;
1678       llvm::StringRef name;
1679       llvm::StringRef value;
1680       bool found_num_field = false;
1681       while (response.GetNameColonValue(name, value)) {
1682         if (name.equals("num")) {
1683           value.getAsInteger(0, m_num_supported_hardware_watchpoints);
1684           num = m_num_supported_hardware_watchpoints;
1685           found_num_field = true;
1686         }
1687       }
1688       if (!found_num_field) {
1689         m_supports_watchpoint_support_info = eLazyBoolNo;
1690       }
1691     } else {
1692       m_supports_watchpoint_support_info = eLazyBoolNo;
1693     }
1694   }
1695
1696   if (m_supports_watchpoint_support_info == eLazyBoolNo) {
1697     error.SetErrorString("qWatchpointSupportInfo is not supported");
1698   }
1699   return error;
1700 }
1701
1702 lldb_private::Status GDBRemoteCommunicationClient::GetWatchpointSupportInfo(
1703     uint32_t &num, bool &after, const ArchSpec &arch) {
1704   Status error(GetWatchpointSupportInfo(num));
1705   if (error.Success())
1706     error = GetWatchpointsTriggerAfterInstruction(after, arch);
1707   return error;
1708 }
1709
1710 lldb_private::Status
1711 GDBRemoteCommunicationClient::GetWatchpointsTriggerAfterInstruction(
1712     bool &after, const ArchSpec &arch) {
1713   Status error;
1714   llvm::Triple triple = arch.GetTriple();
1715
1716   // we assume watchpoints will happen after running the relevant opcode and we
1717   // only want to override this behavior if we have explicitly received a
1718   // qHostInfo telling us otherwise
1719   if (m_qHostInfo_is_valid != eLazyBoolYes) {
1720     // On targets like MIPS and ppc64, watchpoint exceptions are always
1721     // generated before the instruction is executed. The connected target may
1722     // not support qHostInfo or qWatchpointSupportInfo packets.
1723     after = !(triple.isMIPS() || triple.isPPC64());
1724   } else {
1725     // For MIPS and ppc64, set m_watchpoints_trigger_after_instruction to
1726     // eLazyBoolNo if it is not calculated before.
1727     if (m_watchpoints_trigger_after_instruction == eLazyBoolCalculate &&
1728         (triple.isMIPS() || triple.isPPC64()))
1729       m_watchpoints_trigger_after_instruction = eLazyBoolNo;
1730
1731     after = (m_watchpoints_trigger_after_instruction != eLazyBoolNo);
1732   }
1733   return error;
1734 }
1735
1736 int GDBRemoteCommunicationClient::SetSTDIN(const FileSpec &file_spec) {
1737   if (file_spec) {
1738     std::string path{file_spec.GetPath(false)};
1739     StreamString packet;
1740     packet.PutCString("QSetSTDIN:");
1741     packet.PutStringAsRawHex8(path);
1742
1743     StringExtractorGDBRemote response;
1744     if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
1745         PacketResult::Success) {
1746       if (response.IsOKResponse())
1747         return 0;
1748       uint8_t error = response.GetError();
1749       if (error)
1750         return error;
1751     }
1752   }
1753   return -1;
1754 }
1755
1756 int GDBRemoteCommunicationClient::SetSTDOUT(const FileSpec &file_spec) {
1757   if (file_spec) {
1758     std::string path{file_spec.GetPath(false)};
1759     StreamString packet;
1760     packet.PutCString("QSetSTDOUT:");
1761     packet.PutStringAsRawHex8(path);
1762
1763     StringExtractorGDBRemote response;
1764     if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
1765         PacketResult::Success) {
1766       if (response.IsOKResponse())
1767         return 0;
1768       uint8_t error = response.GetError();
1769       if (error)
1770         return error;
1771     }
1772   }
1773   return -1;
1774 }
1775
1776 int GDBRemoteCommunicationClient::SetSTDERR(const FileSpec &file_spec) {
1777   if (file_spec) {
1778     std::string path{file_spec.GetPath(false)};
1779     StreamString packet;
1780     packet.PutCString("QSetSTDERR:");
1781     packet.PutStringAsRawHex8(path);
1782
1783     StringExtractorGDBRemote response;
1784     if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
1785         PacketResult::Success) {
1786       if (response.IsOKResponse())
1787         return 0;
1788       uint8_t error = response.GetError();
1789       if (error)
1790         return error;
1791     }
1792   }
1793   return -1;
1794 }
1795
1796 bool GDBRemoteCommunicationClient::GetWorkingDir(FileSpec &working_dir) {
1797   StringExtractorGDBRemote response;
1798   if (SendPacketAndWaitForResponse("qGetWorkingDir", response, false) ==
1799       PacketResult::Success) {
1800     if (response.IsUnsupportedResponse())
1801       return false;
1802     if (response.IsErrorResponse())
1803       return false;
1804     std::string cwd;
1805     response.GetHexByteString(cwd);
1806     working_dir.SetFile(cwd, GetHostArchitecture().GetTriple());
1807     return !cwd.empty();
1808   }
1809   return false;
1810 }
1811
1812 int GDBRemoteCommunicationClient::SetWorkingDir(const FileSpec &working_dir) {
1813   if (working_dir) {
1814     std::string path{working_dir.GetPath(false)};
1815     StreamString packet;
1816     packet.PutCString("QSetWorkingDir:");
1817     packet.PutStringAsRawHex8(path);
1818
1819     StringExtractorGDBRemote response;
1820     if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
1821         PacketResult::Success) {
1822       if (response.IsOKResponse())
1823         return 0;
1824       uint8_t error = response.GetError();
1825       if (error)
1826         return error;
1827     }
1828   }
1829   return -1;
1830 }
1831
1832 int GDBRemoteCommunicationClient::SetDisableASLR(bool enable) {
1833   char packet[32];
1834   const int packet_len =
1835       ::snprintf(packet, sizeof(packet), "QSetDisableASLR:%i", enable ? 1 : 0);
1836   assert(packet_len < (int)sizeof(packet));
1837   UNUSED_IF_ASSERT_DISABLED(packet_len);
1838   StringExtractorGDBRemote response;
1839   if (SendPacketAndWaitForResponse(packet, response, false) ==
1840       PacketResult::Success) {
1841     if (response.IsOKResponse())
1842       return 0;
1843     uint8_t error = response.GetError();
1844     if (error)
1845       return error;
1846   }
1847   return -1;
1848 }
1849
1850 int GDBRemoteCommunicationClient::SetDetachOnError(bool enable) {
1851   char packet[32];
1852   const int packet_len = ::snprintf(packet, sizeof(packet),
1853                                     "QSetDetachOnError:%i", enable ? 1 : 0);
1854   assert(packet_len < (int)sizeof(packet));
1855   UNUSED_IF_ASSERT_DISABLED(packet_len);
1856   StringExtractorGDBRemote response;
1857   if (SendPacketAndWaitForResponse(packet, response, false) ==
1858       PacketResult::Success) {
1859     if (response.IsOKResponse())
1860       return 0;
1861     uint8_t error = response.GetError();
1862     if (error)
1863       return error;
1864   }
1865   return -1;
1866 }
1867
1868 bool GDBRemoteCommunicationClient::DecodeProcessInfoResponse(
1869     StringExtractorGDBRemote &response, ProcessInstanceInfo &process_info) {
1870   if (response.IsNormalResponse()) {
1871     llvm::StringRef name;
1872     llvm::StringRef value;
1873     StringExtractor extractor;
1874
1875     uint32_t cpu = LLDB_INVALID_CPUTYPE;
1876     uint32_t sub = 0;
1877     std::string vendor;
1878     std::string os_type;
1879
1880     while (response.GetNameColonValue(name, value)) {
1881       if (name.equals("pid")) {
1882         lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
1883         value.getAsInteger(0, pid);
1884         process_info.SetProcessID(pid);
1885       } else if (name.equals("ppid")) {
1886         lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
1887         value.getAsInteger(0, pid);
1888         process_info.SetParentProcessID(pid);
1889       } else if (name.equals("uid")) {
1890         uint32_t uid = UINT32_MAX;
1891         value.getAsInteger(0, uid);
1892         process_info.SetUserID(uid);
1893       } else if (name.equals("euid")) {
1894         uint32_t uid = UINT32_MAX;
1895         value.getAsInteger(0, uid);
1896         process_info.SetEffectiveGroupID(uid);
1897       } else if (name.equals("gid")) {
1898         uint32_t gid = UINT32_MAX;
1899         value.getAsInteger(0, gid);
1900         process_info.SetGroupID(gid);
1901       } else if (name.equals("egid")) {
1902         uint32_t gid = UINT32_MAX;
1903         value.getAsInteger(0, gid);
1904         process_info.SetEffectiveGroupID(gid);
1905       } else if (name.equals("triple")) {
1906         StringExtractor extractor(value);
1907         std::string triple;
1908         extractor.GetHexByteString(triple);
1909         process_info.GetArchitecture().SetTriple(triple.c_str());
1910       } else if (name.equals("name")) {
1911         StringExtractor extractor(value);
1912         // The process name from ASCII hex bytes since we can't control the
1913         // characters in a process name
1914         std::string name;
1915         extractor.GetHexByteString(name);
1916         process_info.GetExecutableFile().SetFile(name, FileSpec::Style::native);
1917       } else if (name.equals("cputype")) {
1918         value.getAsInteger(0, cpu);
1919       } else if (name.equals("cpusubtype")) {
1920         value.getAsInteger(0, sub);
1921       } else if (name.equals("vendor")) {
1922         vendor = value;
1923       } else if (name.equals("ostype")) {
1924         os_type = value;
1925       }
1926     }
1927
1928     if (cpu != LLDB_INVALID_CPUTYPE && !vendor.empty() && !os_type.empty()) {
1929       if (vendor == "apple") {
1930         process_info.GetArchitecture().SetArchitecture(eArchTypeMachO, cpu,
1931                                                        sub);
1932         process_info.GetArchitecture().GetTriple().setVendorName(
1933             llvm::StringRef(vendor));
1934         process_info.GetArchitecture().GetTriple().setOSName(
1935             llvm::StringRef(os_type));
1936       }
1937     }
1938
1939     if (process_info.GetProcessID() != LLDB_INVALID_PROCESS_ID)
1940       return true;
1941   }
1942   return false;
1943 }
1944
1945 bool GDBRemoteCommunicationClient::GetProcessInfo(
1946     lldb::pid_t pid, ProcessInstanceInfo &process_info) {
1947   process_info.Clear();
1948
1949   if (m_supports_qProcessInfoPID) {
1950     char packet[32];
1951     const int packet_len =
1952         ::snprintf(packet, sizeof(packet), "qProcessInfoPID:%" PRIu64, pid);
1953     assert(packet_len < (int)sizeof(packet));
1954     UNUSED_IF_ASSERT_DISABLED(packet_len);
1955     StringExtractorGDBRemote response;
1956     if (SendPacketAndWaitForResponse(packet, response, false) ==
1957         PacketResult::Success) {
1958       return DecodeProcessInfoResponse(response, process_info);
1959     } else {
1960       m_supports_qProcessInfoPID = false;
1961       return false;
1962     }
1963   }
1964   return false;
1965 }
1966
1967 bool GDBRemoteCommunicationClient::GetCurrentProcessInfo(bool allow_lazy) {
1968   Log *log(ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(GDBR_LOG_PROCESS |
1969                                                          GDBR_LOG_PACKETS));
1970
1971   if (allow_lazy) {
1972     if (m_qProcessInfo_is_valid == eLazyBoolYes)
1973       return true;
1974     if (m_qProcessInfo_is_valid == eLazyBoolNo)
1975       return false;
1976   }
1977
1978   GetHostInfo();
1979
1980   StringExtractorGDBRemote response;
1981   if (SendPacketAndWaitForResponse("qProcessInfo", response, false) ==
1982       PacketResult::Success) {
1983     if (response.IsNormalResponse()) {
1984       llvm::StringRef name;
1985       llvm::StringRef value;
1986       uint32_t cpu = LLDB_INVALID_CPUTYPE;
1987       uint32_t sub = 0;
1988       std::string arch_name;
1989       std::string os_name;
1990       std::string vendor_name;
1991       std::string triple;
1992       std::string elf_abi;
1993       uint32_t pointer_byte_size = 0;
1994       StringExtractor extractor;
1995       ByteOrder byte_order = eByteOrderInvalid;
1996       uint32_t num_keys_decoded = 0;
1997       lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
1998       while (response.GetNameColonValue(name, value)) {
1999         if (name.equals("cputype")) {
2000           if (!value.getAsInteger(16, cpu))
2001             ++num_keys_decoded;
2002         } else if (name.equals("cpusubtype")) {
2003           if (!value.getAsInteger(16, sub))
2004             ++num_keys_decoded;
2005         } else if (name.equals("triple")) {
2006           StringExtractor extractor(value);
2007           extractor.GetHexByteString(triple);
2008           ++num_keys_decoded;
2009         } else if (name.equals("ostype")) {
2010           os_name = value;
2011           ++num_keys_decoded;
2012         } else if (name.equals("vendor")) {
2013           vendor_name = value;
2014           ++num_keys_decoded;
2015         } else if (name.equals("endian")) {
2016           byte_order = llvm::StringSwitch<lldb::ByteOrder>(value)
2017                            .Case("little", eByteOrderLittle)
2018                            .Case("big", eByteOrderBig)
2019                            .Case("pdp", eByteOrderPDP)
2020                            .Default(eByteOrderInvalid);
2021           if (byte_order != eByteOrderInvalid)
2022             ++num_keys_decoded;
2023         } else if (name.equals("ptrsize")) {
2024           if (!value.getAsInteger(16, pointer_byte_size))
2025             ++num_keys_decoded;
2026         } else if (name.equals("pid")) {
2027           if (!value.getAsInteger(16, pid))
2028             ++num_keys_decoded;
2029         } else if (name.equals("elf_abi")) {
2030           elf_abi = value;
2031           ++num_keys_decoded;
2032         }
2033       }
2034       if (num_keys_decoded > 0)
2035         m_qProcessInfo_is_valid = eLazyBoolYes;
2036       if (pid != LLDB_INVALID_PROCESS_ID) {
2037         m_curr_pid_is_valid = eLazyBoolYes;
2038         m_curr_pid = pid;
2039       }
2040
2041       // Set the ArchSpec from the triple if we have it.
2042       if (!triple.empty()) {
2043         m_process_arch.SetTriple(triple.c_str());
2044         m_process_arch.SetFlags(elf_abi);
2045         if (pointer_byte_size) {
2046           assert(pointer_byte_size == m_process_arch.GetAddressByteSize());
2047         }
2048       } else if (cpu != LLDB_INVALID_CPUTYPE && !os_name.empty() &&
2049                  !vendor_name.empty()) {
2050         llvm::Triple triple(llvm::Twine("-") + vendor_name + "-" + os_name);
2051
2052         assert(triple.getObjectFormat() != llvm::Triple::UnknownObjectFormat);
2053         assert(triple.getObjectFormat() != llvm::Triple::Wasm);
2054         assert(triple.getObjectFormat() != llvm::Triple::XCOFF);
2055         switch (triple.getObjectFormat()) {
2056         case llvm::Triple::MachO:
2057           m_process_arch.SetArchitecture(eArchTypeMachO, cpu, sub);
2058           break;
2059         case llvm::Triple::ELF:
2060           m_process_arch.SetArchitecture(eArchTypeELF, cpu, sub);
2061           break;
2062         case llvm::Triple::COFF:
2063           m_process_arch.SetArchitecture(eArchTypeCOFF, cpu, sub);
2064           break;
2065         case llvm::Triple::Wasm:
2066         case llvm::Triple::XCOFF:
2067           if (log)
2068             log->Printf("error: not supported target architecture");
2069           return false;
2070         case llvm::Triple::UnknownObjectFormat:
2071           if (log)
2072             log->Printf("error: failed to determine target architecture");
2073           return false;
2074         }
2075
2076         if (pointer_byte_size) {
2077           assert(pointer_byte_size == m_process_arch.GetAddressByteSize());
2078         }
2079         if (byte_order != eByteOrderInvalid) {
2080           assert(byte_order == m_process_arch.GetByteOrder());
2081         }
2082         m_process_arch.GetTriple().setVendorName(llvm::StringRef(vendor_name));
2083         m_process_arch.GetTriple().setOSName(llvm::StringRef(os_name));
2084         m_host_arch.GetTriple().setVendorName(llvm::StringRef(vendor_name));
2085         m_host_arch.GetTriple().setOSName(llvm::StringRef(os_name));
2086       }
2087       return true;
2088     }
2089   } else {
2090     m_qProcessInfo_is_valid = eLazyBoolNo;
2091   }
2092
2093   return false;
2094 }
2095
2096 uint32_t GDBRemoteCommunicationClient::FindProcesses(
2097     const ProcessInstanceInfoMatch &match_info,
2098     ProcessInstanceInfoList &process_infos) {
2099   process_infos.Clear();
2100
2101   if (m_supports_qfProcessInfo) {
2102     StreamString packet;
2103     packet.PutCString("qfProcessInfo");
2104     if (!match_info.MatchAllProcesses()) {
2105       packet.PutChar(':');
2106       const char *name = match_info.GetProcessInfo().GetName();
2107       bool has_name_match = false;
2108       if (name && name[0]) {
2109         has_name_match = true;
2110         NameMatch name_match_type = match_info.GetNameMatchType();
2111         switch (name_match_type) {
2112         case NameMatch::Ignore:
2113           has_name_match = false;
2114           break;
2115
2116         case NameMatch::Equals:
2117           packet.PutCString("name_match:equals;");
2118           break;
2119
2120         case NameMatch::Contains:
2121           packet.PutCString("name_match:contains;");
2122           break;
2123
2124         case NameMatch::StartsWith:
2125           packet.PutCString("name_match:starts_with;");
2126           break;
2127
2128         case NameMatch::EndsWith:
2129           packet.PutCString("name_match:ends_with;");
2130           break;
2131
2132         case NameMatch::RegularExpression:
2133           packet.PutCString("name_match:regex;");
2134           break;
2135         }
2136         if (has_name_match) {
2137           packet.PutCString("name:");
2138           packet.PutBytesAsRawHex8(name, ::strlen(name));
2139           packet.PutChar(';');
2140         }
2141       }
2142
2143       if (match_info.GetProcessInfo().ProcessIDIsValid())
2144         packet.Printf("pid:%" PRIu64 ";",
2145                       match_info.GetProcessInfo().GetProcessID());
2146       if (match_info.GetProcessInfo().ParentProcessIDIsValid())
2147         packet.Printf("parent_pid:%" PRIu64 ";",
2148                       match_info.GetProcessInfo().GetParentProcessID());
2149       if (match_info.GetProcessInfo().UserIDIsValid())
2150         packet.Printf("uid:%u;", match_info.GetProcessInfo().GetUserID());
2151       if (match_info.GetProcessInfo().GroupIDIsValid())
2152         packet.Printf("gid:%u;", match_info.GetProcessInfo().GetGroupID());
2153       if (match_info.GetProcessInfo().EffectiveUserIDIsValid())
2154         packet.Printf("euid:%u;",
2155                       match_info.GetProcessInfo().GetEffectiveUserID());
2156       if (match_info.GetProcessInfo().EffectiveGroupIDIsValid())
2157         packet.Printf("egid:%u;",
2158                       match_info.GetProcessInfo().GetEffectiveGroupID());
2159       if (match_info.GetProcessInfo().EffectiveGroupIDIsValid())
2160         packet.Printf("all_users:%u;", match_info.GetMatchAllUsers() ? 1 : 0);
2161       if (match_info.GetProcessInfo().GetArchitecture().IsValid()) {
2162         const ArchSpec &match_arch =
2163             match_info.GetProcessInfo().GetArchitecture();
2164         const llvm::Triple &triple = match_arch.GetTriple();
2165         packet.PutCString("triple:");
2166         packet.PutCString(triple.getTriple());
2167         packet.PutChar(';');
2168       }
2169     }
2170     StringExtractorGDBRemote response;
2171     // Increase timeout as the first qfProcessInfo packet takes a long time on
2172     // Android. The value of 1min was arrived at empirically.
2173     ScopedTimeout timeout(*this, minutes(1));
2174     if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
2175         PacketResult::Success) {
2176       do {
2177         ProcessInstanceInfo process_info;
2178         if (!DecodeProcessInfoResponse(response, process_info))
2179           break;
2180         process_infos.Append(process_info);
2181         response.GetStringRef().clear();
2182         response.SetFilePos(0);
2183       } while (SendPacketAndWaitForResponse("qsProcessInfo", response, false) ==
2184                PacketResult::Success);
2185     } else {
2186       m_supports_qfProcessInfo = false;
2187       return 0;
2188     }
2189   }
2190   return process_infos.GetSize();
2191 }
2192
2193 bool GDBRemoteCommunicationClient::GetUserName(uint32_t uid,
2194                                                std::string &name) {
2195   if (m_supports_qUserName) {
2196     char packet[32];
2197     const int packet_len =
2198         ::snprintf(packet, sizeof(packet), "qUserName:%i", uid);
2199     assert(packet_len < (int)sizeof(packet));
2200     UNUSED_IF_ASSERT_DISABLED(packet_len);
2201     StringExtractorGDBRemote response;
2202     if (SendPacketAndWaitForResponse(packet, response, false) ==
2203         PacketResult::Success) {
2204       if (response.IsNormalResponse()) {
2205         // Make sure we parsed the right number of characters. The response is
2206         // the hex encoded user name and should make up the entire packet. If
2207         // there are any non-hex ASCII bytes, the length won't match below..
2208         if (response.GetHexByteString(name) * 2 ==
2209             response.GetStringRef().size())
2210           return true;
2211       }
2212     } else {
2213       m_supports_qUserName = false;
2214       return false;
2215     }
2216   }
2217   return false;
2218 }
2219
2220 bool GDBRemoteCommunicationClient::GetGroupName(uint32_t gid,
2221                                                 std::string &name) {
2222   if (m_supports_qGroupName) {
2223     char packet[32];
2224     const int packet_len =
2225         ::snprintf(packet, sizeof(packet), "qGroupName:%i", gid);
2226     assert(packet_len < (int)sizeof(packet));
2227     UNUSED_IF_ASSERT_DISABLED(packet_len);
2228     StringExtractorGDBRemote response;
2229     if (SendPacketAndWaitForResponse(packet, response, false) ==
2230         PacketResult::Success) {
2231       if (response.IsNormalResponse()) {
2232         // Make sure we parsed the right number of characters. The response is
2233         // the hex encoded group name and should make up the entire packet. If
2234         // there are any non-hex ASCII bytes, the length won't match below..
2235         if (response.GetHexByteString(name) * 2 ==
2236             response.GetStringRef().size())
2237           return true;
2238       }
2239     } else {
2240       m_supports_qGroupName = false;
2241       return false;
2242     }
2243   }
2244   return false;
2245 }
2246
2247 bool GDBRemoteCommunicationClient::SetNonStopMode(const bool enable) {
2248   // Form non-stop packet request
2249   char packet[32];
2250   const int packet_len =
2251       ::snprintf(packet, sizeof(packet), "QNonStop:%1d", (int)enable);
2252   assert(packet_len < (int)sizeof(packet));
2253   UNUSED_IF_ASSERT_DISABLED(packet_len);
2254
2255   StringExtractorGDBRemote response;
2256   // Send to target
2257   if (SendPacketAndWaitForResponse(packet, response, false) ==
2258       PacketResult::Success)
2259     if (response.IsOKResponse())
2260       return true;
2261
2262   // Failed or not supported
2263   return false;
2264 }
2265
2266 static void MakeSpeedTestPacket(StreamString &packet, uint32_t send_size,
2267                                 uint32_t recv_size) {
2268   packet.Clear();
2269   packet.Printf("qSpeedTest:response_size:%i;data:", recv_size);
2270   uint32_t bytes_left = send_size;
2271   while (bytes_left > 0) {
2272     if (bytes_left >= 26) {
2273       packet.PutCString("abcdefghijklmnopqrstuvwxyz");
2274       bytes_left -= 26;
2275     } else {
2276       packet.Printf("%*.*s;", bytes_left, bytes_left,
2277                     "abcdefghijklmnopqrstuvwxyz");
2278       bytes_left = 0;
2279     }
2280   }
2281 }
2282
2283 duration<float>
2284 calculate_standard_deviation(const std::vector<duration<float>> &v) {
2285   using Dur = duration<float>;
2286   Dur sum = std::accumulate(std::begin(v), std::end(v), Dur());
2287   Dur mean = sum / v.size();
2288   float accum = 0;
2289   for (auto d : v) {
2290     float delta = (d - mean).count();
2291     accum += delta * delta;
2292   };
2293
2294   return Dur(sqrtf(accum / (v.size() - 1)));
2295 }
2296
2297 void GDBRemoteCommunicationClient::TestPacketSpeed(const uint32_t num_packets,
2298                                                    uint32_t max_send,
2299                                                    uint32_t max_recv,
2300                                                    uint64_t recv_amount,
2301                                                    bool json, Stream &strm) {
2302   uint32_t i;
2303   if (SendSpeedTestPacket(0, 0)) {
2304     StreamString packet;
2305     if (json)
2306       strm.Printf("{ \"packet_speeds\" : {\n    \"num_packets\" : %u,\n    "
2307                   "\"results\" : [",
2308                   num_packets);
2309     else
2310       strm.Printf("Testing sending %u packets of various sizes:\n",
2311                   num_packets);
2312     strm.Flush();
2313
2314     uint32_t result_idx = 0;
2315     uint32_t send_size;
2316     std::vector<duration<float>> packet_times;
2317
2318     for (send_size = 0; send_size <= max_send;
2319          send_size ? send_size *= 2 : send_size = 4) {
2320       for (uint32_t recv_size = 0; recv_size <= max_recv;
2321            recv_size ? recv_size *= 2 : recv_size = 4) {
2322         MakeSpeedTestPacket(packet, send_size, recv_size);
2323
2324         packet_times.clear();
2325         // Test how long it takes to send 'num_packets' packets
2326         const auto start_time = steady_clock::now();
2327         for (i = 0; i < num_packets; ++i) {
2328           const auto packet_start_time = steady_clock::now();
2329           StringExtractorGDBRemote response;
2330           SendPacketAndWaitForResponse(packet.GetString(), response, false);
2331           const auto packet_end_time = steady_clock::now();
2332           packet_times.push_back(packet_end_time - packet_start_time);
2333         }
2334         const auto end_time = steady_clock::now();
2335         const auto total_time = end_time - start_time;
2336
2337         float packets_per_second =
2338             ((float)num_packets) / duration<float>(total_time).count();
2339         auto average_per_packet = total_time / num_packets;
2340         const duration<float> standard_deviation =
2341             calculate_standard_deviation(packet_times);
2342         if (json) {
2343           strm.Format("{0}\n     {{\"send_size\" : {1,6}, \"recv_size\" : "
2344                       "{2,6}, \"total_time_nsec\" : {3,12:ns-}, "
2345                       "\"standard_deviation_nsec\" : {4,9:ns-f0}}",
2346                       result_idx > 0 ? "," : "", send_size, recv_size,
2347                       total_time, standard_deviation);
2348           ++result_idx;
2349         } else {
2350           strm.Format("qSpeedTest(send={0,7}, recv={1,7}) in {2:s+f9} for "
2351                       "{3,9:f2} packets/s ({4,10:ms+f6} per packet) with "
2352                       "standard deviation of {5,10:ms+f6}\n",
2353                       send_size, recv_size, duration<float>(total_time),
2354                       packets_per_second, duration<float>(average_per_packet),
2355                       standard_deviation);
2356         }
2357         strm.Flush();
2358       }
2359     }
2360
2361     const float k_recv_amount_mb = (float)recv_amount / (1024.0f * 1024.0f);
2362     if (json)
2363       strm.Printf("\n    ]\n  },\n  \"download_speed\" : {\n    \"byte_size\" "
2364                   ": %" PRIu64 ",\n    \"results\" : [",
2365                   recv_amount);
2366     else
2367       strm.Printf("Testing receiving %2.1fMB of data using varying receive "
2368                   "packet sizes:\n",
2369                   k_recv_amount_mb);
2370     strm.Flush();
2371     send_size = 0;
2372     result_idx = 0;
2373     for (uint32_t recv_size = 32; recv_size <= max_recv; recv_size *= 2) {
2374       MakeSpeedTestPacket(packet, send_size, recv_size);
2375
2376       // If we have a receive size, test how long it takes to receive 4MB of
2377       // data
2378       if (recv_size > 0) {
2379         const auto start_time = steady_clock::now();
2380         uint32_t bytes_read = 0;
2381         uint32_t packet_count = 0;
2382         while (bytes_read < recv_amount) {
2383           StringExtractorGDBRemote response;
2384           SendPacketAndWaitForResponse(packet.GetString(), response, false);
2385           bytes_read += recv_size;
2386           ++packet_count;
2387         }
2388         const auto end_time = steady_clock::now();
2389         const auto total_time = end_time - start_time;
2390         float mb_second = ((float)recv_amount) /
2391                           duration<float>(total_time).count() /
2392                           (1024.0 * 1024.0);
2393         float packets_per_second =
2394             ((float)packet_count) / duration<float>(total_time).count();
2395         const auto average_per_packet = total_time / packet_count;
2396
2397         if (json) {
2398           strm.Format("{0}\n     {{\"send_size\" : {1,6}, \"recv_size\" : "
2399                       "{2,6}, \"total_time_nsec\" : {3,12:ns-}}",
2400                       result_idx > 0 ? "," : "", send_size, recv_size,
2401                       total_time);
2402           ++result_idx;
2403         } else {
2404           strm.Format("qSpeedTest(send={0,7}, recv={1,7}) {2,6} packets needed "
2405                       "to receive {3:f1}MB in {4:s+f9} for {5} MB/sec for "
2406                       "{6,9:f2} packets/sec ({7,10:ms+f6} per packet)\n",
2407                       send_size, recv_size, packet_count, k_recv_amount_mb,
2408                       duration<float>(total_time), mb_second,
2409                       packets_per_second, duration<float>(average_per_packet));
2410         }
2411         strm.Flush();
2412       }
2413     }
2414     if (json)
2415       strm.Printf("\n    ]\n  }\n}\n");
2416     else
2417       strm.EOL();
2418   }
2419 }
2420
2421 bool GDBRemoteCommunicationClient::SendSpeedTestPacket(uint32_t send_size,
2422                                                        uint32_t recv_size) {
2423   StreamString packet;
2424   packet.Printf("qSpeedTest:response_size:%i;data:", recv_size);
2425   uint32_t bytes_left = send_size;
2426   while (bytes_left > 0) {
2427     if (bytes_left >= 26) {
2428       packet.PutCString("abcdefghijklmnopqrstuvwxyz");
2429       bytes_left -= 26;
2430     } else {
2431       packet.Printf("%*.*s;", bytes_left, bytes_left,
2432                     "abcdefghijklmnopqrstuvwxyz");
2433       bytes_left = 0;
2434     }
2435   }
2436
2437   StringExtractorGDBRemote response;
2438   return SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
2439          PacketResult::Success;
2440 }
2441
2442 bool GDBRemoteCommunicationClient::LaunchGDBServer(
2443     const char *remote_accept_hostname, lldb::pid_t &pid, uint16_t &port,
2444     std::string &socket_name) {
2445   pid = LLDB_INVALID_PROCESS_ID;
2446   port = 0;
2447   socket_name.clear();
2448
2449   StringExtractorGDBRemote response;
2450   StreamString stream;
2451   stream.PutCString("qLaunchGDBServer;");
2452   std::string hostname;
2453   if (remote_accept_hostname && remote_accept_hostname[0])
2454     hostname = remote_accept_hostname;
2455   else {
2456     if (HostInfo::GetHostname(hostname)) {
2457       // Make the GDB server we launch only accept connections from this host
2458       stream.Printf("host:%s;", hostname.c_str());
2459     } else {
2460       // Make the GDB server we launch accept connections from any host since
2461       // we can't figure out the hostname
2462       stream.Printf("host:*;");
2463     }
2464   }
2465   // give the process a few seconds to startup
2466   ScopedTimeout timeout(*this, seconds(10));
2467
2468   if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
2469       PacketResult::Success) {
2470     llvm::StringRef name;
2471     llvm::StringRef value;
2472     while (response.GetNameColonValue(name, value)) {
2473       if (name.equals("port"))
2474         value.getAsInteger(0, port);
2475       else if (name.equals("pid"))
2476         value.getAsInteger(0, pid);
2477       else if (name.compare("socket_name") == 0) {
2478         StringExtractor extractor(value);
2479         extractor.GetHexByteString(socket_name);
2480       }
2481     }
2482     return true;
2483   }
2484   return false;
2485 }
2486
2487 size_t GDBRemoteCommunicationClient::QueryGDBServer(
2488     std::vector<std::pair<uint16_t, std::string>> &connection_urls) {
2489   connection_urls.clear();
2490
2491   StringExtractorGDBRemote response;
2492   if (SendPacketAndWaitForResponse("qQueryGDBServer", response, false) !=
2493       PacketResult::Success)
2494     return 0;
2495
2496   StructuredData::ObjectSP data =
2497       StructuredData::ParseJSON(response.GetStringRef());
2498   if (!data)
2499     return 0;
2500
2501   StructuredData::Array *array = data->GetAsArray();
2502   if (!array)
2503     return 0;
2504
2505   for (size_t i = 0, count = array->GetSize(); i < count; ++i) {
2506     StructuredData::Dictionary *element = nullptr;
2507     if (!array->GetItemAtIndexAsDictionary(i, element))
2508       continue;
2509
2510     uint16_t port = 0;
2511     if (StructuredData::ObjectSP port_osp =
2512             element->GetValueForKey(llvm::StringRef("port")))
2513       port = port_osp->GetIntegerValue(0);
2514
2515     std::string socket_name;
2516     if (StructuredData::ObjectSP socket_name_osp =
2517             element->GetValueForKey(llvm::StringRef("socket_name")))
2518       socket_name = socket_name_osp->GetStringValue();
2519
2520     if (port != 0 || !socket_name.empty())
2521       connection_urls.emplace_back(port, socket_name);
2522   }
2523   return connection_urls.size();
2524 }
2525
2526 bool GDBRemoteCommunicationClient::KillSpawnedProcess(lldb::pid_t pid) {
2527   StreamString stream;
2528   stream.Printf("qKillSpawnedProcess:%" PRId64, pid);
2529
2530   StringExtractorGDBRemote response;
2531   if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
2532       PacketResult::Success) {
2533     if (response.IsOKResponse())
2534       return true;
2535   }
2536   return false;
2537 }
2538
2539 bool GDBRemoteCommunicationClient::SetCurrentThread(uint64_t tid) {
2540   if (m_curr_tid == tid)
2541     return true;
2542
2543   char packet[32];
2544   int packet_len;
2545   if (tid == UINT64_MAX)
2546     packet_len = ::snprintf(packet, sizeof(packet), "Hg-1");
2547   else
2548     packet_len = ::snprintf(packet, sizeof(packet), "Hg%" PRIx64, tid);
2549   assert(packet_len + 1 < (int)sizeof(packet));
2550   UNUSED_IF_ASSERT_DISABLED(packet_len);
2551   StringExtractorGDBRemote response;
2552   if (SendPacketAndWaitForResponse(packet, response, false) ==
2553       PacketResult::Success) {
2554     if (response.IsOKResponse()) {
2555       m_curr_tid = tid;
2556       return true;
2557     }
2558
2559     /*
2560      * Connected bare-iron target (like YAMON gdb-stub) may not have support for
2561      * Hg packet.
2562      * The reply from '?' packet could be as simple as 'S05'. There is no packet
2563      * which can
2564      * give us pid and/or tid. Assume pid=tid=1 in such cases.
2565     */
2566     if (response.IsUnsupportedResponse() && IsConnected()) {
2567       m_curr_tid = 1;
2568       return true;
2569     }
2570   }
2571   return false;
2572 }
2573
2574 bool GDBRemoteCommunicationClient::SetCurrentThreadForRun(uint64_t tid) {
2575   if (m_curr_tid_run == tid)
2576     return true;
2577
2578   char packet[32];
2579   int packet_len;
2580   if (tid == UINT64_MAX)
2581     packet_len = ::snprintf(packet, sizeof(packet), "Hc-1");
2582   else
2583     packet_len = ::snprintf(packet, sizeof(packet), "Hc%" PRIx64, tid);
2584
2585   assert(packet_len + 1 < (int)sizeof(packet));
2586   UNUSED_IF_ASSERT_DISABLED(packet_len);
2587   StringExtractorGDBRemote response;
2588   if (SendPacketAndWaitForResponse(packet, response, false) ==
2589       PacketResult::Success) {
2590     if (response.IsOKResponse()) {
2591       m_curr_tid_run = tid;
2592       return true;
2593     }
2594
2595     /*
2596      * Connected bare-iron target (like YAMON gdb-stub) may not have support for
2597      * Hc packet.
2598      * The reply from '?' packet could be as simple as 'S05'. There is no packet
2599      * which can
2600      * give us pid and/or tid. Assume pid=tid=1 in such cases.
2601     */
2602     if (response.IsUnsupportedResponse() && IsConnected()) {
2603       m_curr_tid_run = 1;
2604       return true;
2605     }
2606   }
2607   return false;
2608 }
2609
2610 bool GDBRemoteCommunicationClient::GetStopReply(
2611     StringExtractorGDBRemote &response) {
2612   if (SendPacketAndWaitForResponse("?", response, false) ==
2613       PacketResult::Success)
2614     return response.IsNormalResponse();
2615   return false;
2616 }
2617
2618 bool GDBRemoteCommunicationClient::GetThreadStopInfo(
2619     lldb::tid_t tid, StringExtractorGDBRemote &response) {
2620   if (m_supports_qThreadStopInfo) {
2621     char packet[256];
2622     int packet_len =
2623         ::snprintf(packet, sizeof(packet), "qThreadStopInfo%" PRIx64, tid);
2624     assert(packet_len < (int)sizeof(packet));
2625     UNUSED_IF_ASSERT_DISABLED(packet_len);
2626     if (SendPacketAndWaitForResponse(packet, response, false) ==
2627         PacketResult::Success) {
2628       if (response.IsUnsupportedResponse())
2629         m_supports_qThreadStopInfo = false;
2630       else if (response.IsNormalResponse())
2631         return true;
2632       else
2633         return false;
2634     } else {
2635       m_supports_qThreadStopInfo = false;
2636     }
2637   }
2638   return false;
2639 }
2640
2641 uint8_t GDBRemoteCommunicationClient::SendGDBStoppointTypePacket(
2642     GDBStoppointType type, bool insert, addr_t addr, uint32_t length) {
2643   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
2644   if (log)
2645     log->Printf("GDBRemoteCommunicationClient::%s() %s at addr = 0x%" PRIx64,
2646                 __FUNCTION__, insert ? "add" : "remove", addr);
2647
2648   // Check if the stub is known not to support this breakpoint type
2649   if (!SupportsGDBStoppointPacket(type))
2650     return UINT8_MAX;
2651   // Construct the breakpoint packet
2652   char packet[64];
2653   const int packet_len =
2654       ::snprintf(packet, sizeof(packet), "%c%i,%" PRIx64 ",%x",
2655                  insert ? 'Z' : 'z', type, addr, length);
2656   // Check we haven't overwritten the end of the packet buffer
2657   assert(packet_len + 1 < (int)sizeof(packet));
2658   UNUSED_IF_ASSERT_DISABLED(packet_len);
2659   StringExtractorGDBRemote response;
2660   // Make sure the response is either "OK", "EXX" where XX are two hex digits,
2661   // or "" (unsupported)
2662   response.SetResponseValidatorToOKErrorNotSupported();
2663   // Try to send the breakpoint packet, and check that it was correctly sent
2664   if (SendPacketAndWaitForResponse(packet, response, true) ==
2665       PacketResult::Success) {
2666     // Receive and OK packet when the breakpoint successfully placed
2667     if (response.IsOKResponse())
2668       return 0;
2669
2670     // Status while setting breakpoint, send back specific error
2671     if (response.IsErrorResponse())
2672       return response.GetError();
2673
2674     // Empty packet informs us that breakpoint is not supported
2675     if (response.IsUnsupportedResponse()) {
2676       // Disable this breakpoint type since it is unsupported
2677       switch (type) {
2678       case eBreakpointSoftware:
2679         m_supports_z0 = false;
2680         break;
2681       case eBreakpointHardware:
2682         m_supports_z1 = false;
2683         break;
2684       case eWatchpointWrite:
2685         m_supports_z2 = false;
2686         break;
2687       case eWatchpointRead:
2688         m_supports_z3 = false;
2689         break;
2690       case eWatchpointReadWrite:
2691         m_supports_z4 = false;
2692         break;
2693       case eStoppointInvalid:
2694         return UINT8_MAX;
2695       }
2696     }
2697   }
2698   // Signal generic failure
2699   return UINT8_MAX;
2700 }
2701
2702 size_t GDBRemoteCommunicationClient::GetCurrentThreadIDs(
2703     std::vector<lldb::tid_t> &thread_ids, bool &sequence_mutex_unavailable) {
2704   thread_ids.clear();
2705
2706   Lock lock(*this, false);
2707   if (lock) {
2708     sequence_mutex_unavailable = false;
2709     StringExtractorGDBRemote response;
2710
2711     PacketResult packet_result;
2712     for (packet_result =
2713              SendPacketAndWaitForResponseNoLock("qfThreadInfo", response);
2714          packet_result == PacketResult::Success && response.IsNormalResponse();
2715          packet_result =
2716              SendPacketAndWaitForResponseNoLock("qsThreadInfo", response)) {
2717       char ch = response.GetChar();
2718       if (ch == 'l')
2719         break;
2720       if (ch == 'm') {
2721         do {
2722           tid_t tid = response.GetHexMaxU64(false, LLDB_INVALID_THREAD_ID);
2723
2724           if (tid != LLDB_INVALID_THREAD_ID) {
2725             thread_ids.push_back(tid);
2726           }
2727           ch = response.GetChar(); // Skip the command separator
2728         } while (ch == ',');       // Make sure we got a comma separator
2729       }
2730     }
2731
2732     /*
2733      * Connected bare-iron target (like YAMON gdb-stub) may not have support for
2734      * qProcessInfo, qC and qfThreadInfo packets. The reply from '?' packet
2735      * could
2736      * be as simple as 'S05'. There is no packet which can give us pid and/or
2737      * tid.
2738      * Assume pid=tid=1 in such cases.
2739     */
2740     if ((response.IsUnsupportedResponse() || response.IsNormalResponse()) &&
2741         thread_ids.size() == 0 && IsConnected()) {
2742       thread_ids.push_back(1);
2743     }
2744   } else {
2745 #if !defined(LLDB_CONFIGURATION_DEBUG)
2746     Log *log(ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(GDBR_LOG_PROCESS |
2747                                                            GDBR_LOG_PACKETS));
2748     if (log)
2749       log->Printf("error: failed to get packet sequence mutex, not sending "
2750                   "packet 'qfThreadInfo'");
2751 #endif
2752     sequence_mutex_unavailable = true;
2753   }
2754   return thread_ids.size();
2755 }
2756
2757 lldb::addr_t GDBRemoteCommunicationClient::GetShlibInfoAddr() {
2758   StringExtractorGDBRemote response;
2759   if (SendPacketAndWaitForResponse("qShlibInfoAddr", response, false) !=
2760           PacketResult::Success ||
2761       !response.IsNormalResponse())
2762     return LLDB_INVALID_ADDRESS;
2763   return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
2764 }
2765
2766 lldb_private::Status GDBRemoteCommunicationClient::RunShellCommand(
2767     const char *command, // Shouldn't be NULL
2768     const FileSpec &
2769         working_dir, // Pass empty FileSpec to use the current working directory
2770     int *status_ptr, // Pass NULL if you don't want the process exit status
2771     int *signo_ptr,  // Pass NULL if you don't want the signal that caused the
2772                      // process to exit
2773     std::string
2774         *command_output, // Pass NULL if you don't want the command output
2775     const Timeout<std::micro> &timeout) {
2776   lldb_private::StreamString stream;
2777   stream.PutCString("qPlatform_shell:");
2778   stream.PutBytesAsRawHex8(command, strlen(command));
2779   stream.PutChar(',');
2780   uint32_t timeout_sec = UINT32_MAX;
2781   if (timeout) {
2782     // TODO: Use chrono version of std::ceil once c++17 is available.
2783     timeout_sec = std::ceil(std::chrono::duration<double>(*timeout).count());
2784   }
2785   stream.PutHex32(timeout_sec);
2786   if (working_dir) {
2787     std::string path{working_dir.GetPath(false)};
2788     stream.PutChar(',');
2789     stream.PutStringAsRawHex8(path);
2790   }
2791   StringExtractorGDBRemote response;
2792   if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
2793       PacketResult::Success) {
2794     if (response.GetChar() != 'F')
2795       return Status("malformed reply");
2796     if (response.GetChar() != ',')
2797       return Status("malformed reply");
2798     uint32_t exitcode = response.GetHexMaxU32(false, UINT32_MAX);
2799     if (exitcode == UINT32_MAX)
2800       return Status("unable to run remote process");
2801     else if (status_ptr)
2802       *status_ptr = exitcode;
2803     if (response.GetChar() != ',')
2804       return Status("malformed reply");
2805     uint32_t signo = response.GetHexMaxU32(false, UINT32_MAX);
2806     if (signo_ptr)
2807       *signo_ptr = signo;
2808     if (response.GetChar() != ',')
2809       return Status("malformed reply");
2810     std::string output;
2811     response.GetEscapedBinaryData(output);
2812     if (command_output)
2813       command_output->assign(output);
2814     return Status();
2815   }
2816   return Status("unable to send packet");
2817 }
2818
2819 Status GDBRemoteCommunicationClient::MakeDirectory(const FileSpec &file_spec,
2820                                                    uint32_t file_permissions) {
2821   std::string path{file_spec.GetPath(false)};
2822   lldb_private::StreamString stream;
2823   stream.PutCString("qPlatform_mkdir:");
2824   stream.PutHex32(file_permissions);
2825   stream.PutChar(',');
2826   stream.PutStringAsRawHex8(path);
2827   llvm::StringRef packet = stream.GetString();
2828   StringExtractorGDBRemote response;
2829
2830   if (SendPacketAndWaitForResponse(packet, response, false) !=
2831       PacketResult::Success)
2832     return Status("failed to send '%s' packet", packet.str().c_str());
2833
2834   if (response.GetChar() != 'F')
2835     return Status("invalid response to '%s' packet", packet.str().c_str());
2836
2837   return Status(response.GetU32(UINT32_MAX), eErrorTypePOSIX);
2838 }
2839
2840 Status
2841 GDBRemoteCommunicationClient::SetFilePermissions(const FileSpec &file_spec,
2842                                                  uint32_t file_permissions) {
2843   std::string path{file_spec.GetPath(false)};
2844   lldb_private::StreamString stream;
2845   stream.PutCString("qPlatform_chmod:");
2846   stream.PutHex32(file_permissions);
2847   stream.PutChar(',');
2848   stream.PutStringAsRawHex8(path);
2849   llvm::StringRef packet = stream.GetString();
2850   StringExtractorGDBRemote response;
2851
2852   if (SendPacketAndWaitForResponse(packet, response, false) !=
2853       PacketResult::Success)
2854     return Status("failed to send '%s' packet", stream.GetData());
2855
2856   if (response.GetChar() != 'F')
2857     return Status("invalid response to '%s' packet", stream.GetData());
2858
2859   return Status(response.GetU32(UINT32_MAX), eErrorTypePOSIX);
2860 }
2861
2862 static uint64_t ParseHostIOPacketResponse(StringExtractorGDBRemote &response,
2863                                           uint64_t fail_result, Status &error) {
2864   response.SetFilePos(0);
2865   if (response.GetChar() != 'F')
2866     return fail_result;
2867   int32_t result = response.GetS32(-2);
2868   if (result == -2)
2869     return fail_result;
2870   if (response.GetChar() == ',') {
2871     int result_errno = response.GetS32(-2);
2872     if (result_errno != -2)
2873       error.SetError(result_errno, eErrorTypePOSIX);
2874     else
2875       error.SetError(-1, eErrorTypeGeneric);
2876   } else
2877     error.Clear();
2878   return result;
2879 }
2880 lldb::user_id_t
2881 GDBRemoteCommunicationClient::OpenFile(const lldb_private::FileSpec &file_spec,
2882                                        uint32_t flags, mode_t mode,
2883                                        Status &error) {
2884   std::string path(file_spec.GetPath(false));
2885   lldb_private::StreamString stream;
2886   stream.PutCString("vFile:open:");
2887   if (path.empty())
2888     return UINT64_MAX;
2889   stream.PutStringAsRawHex8(path);
2890   stream.PutChar(',');
2891   stream.PutHex32(flags);
2892   stream.PutChar(',');
2893   stream.PutHex32(mode);
2894   StringExtractorGDBRemote response;
2895   if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
2896       PacketResult::Success) {
2897     return ParseHostIOPacketResponse(response, UINT64_MAX, error);
2898   }
2899   return UINT64_MAX;
2900 }
2901
2902 bool GDBRemoteCommunicationClient::CloseFile(lldb::user_id_t fd,
2903                                              Status &error) {
2904   lldb_private::StreamString stream;
2905   stream.Printf("vFile:close:%i", (int)fd);
2906   StringExtractorGDBRemote response;
2907   if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
2908       PacketResult::Success) {
2909     return ParseHostIOPacketResponse(response, -1, error) == 0;
2910   }
2911   return false;
2912 }
2913
2914 // Extension of host I/O packets to get the file size.
2915 lldb::user_id_t GDBRemoteCommunicationClient::GetFileSize(
2916     const lldb_private::FileSpec &file_spec) {
2917   std::string path(file_spec.GetPath(false));
2918   lldb_private::StreamString stream;
2919   stream.PutCString("vFile:size:");
2920   stream.PutStringAsRawHex8(path);
2921   StringExtractorGDBRemote response;
2922   if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
2923       PacketResult::Success) {
2924     if (response.GetChar() != 'F')
2925       return UINT64_MAX;
2926     uint32_t retcode = response.GetHexMaxU64(false, UINT64_MAX);
2927     return retcode;
2928   }
2929   return UINT64_MAX;
2930 }
2931
2932 Status
2933 GDBRemoteCommunicationClient::GetFilePermissions(const FileSpec &file_spec,
2934                                                  uint32_t &file_permissions) {
2935   std::string path{file_spec.GetPath(false)};
2936   Status error;
2937   lldb_private::StreamString stream;
2938   stream.PutCString("vFile:mode:");
2939   stream.PutStringAsRawHex8(path);
2940   StringExtractorGDBRemote response;
2941   if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
2942       PacketResult::Success) {
2943     if (response.GetChar() != 'F') {
2944       error.SetErrorStringWithFormat("invalid response to '%s' packet",
2945                                      stream.GetData());
2946     } else {
2947       const uint32_t mode = response.GetS32(-1);
2948       if (static_cast<int32_t>(mode) == -1) {
2949         if (response.GetChar() == ',') {
2950           int response_errno = response.GetS32(-1);
2951           if (response_errno > 0)
2952             error.SetError(response_errno, lldb::eErrorTypePOSIX);
2953           else
2954             error.SetErrorToGenericError();
2955         } else
2956           error.SetErrorToGenericError();
2957       } else {
2958         file_permissions = mode & (S_IRWXU | S_IRWXG | S_IRWXO);
2959       }
2960     }
2961   } else {
2962     error.SetErrorStringWithFormat("failed to send '%s' packet",
2963                                    stream.GetData());
2964   }
2965   return error;
2966 }
2967
2968 uint64_t GDBRemoteCommunicationClient::ReadFile(lldb::user_id_t fd,
2969                                                 uint64_t offset, void *dst,
2970                                                 uint64_t dst_len,
2971                                                 Status &error) {
2972   lldb_private::StreamString stream;
2973   stream.Printf("vFile:pread:%i,%" PRId64 ",%" PRId64, (int)fd, dst_len,
2974                 offset);
2975   StringExtractorGDBRemote response;
2976   if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
2977       PacketResult::Success) {
2978     if (response.GetChar() != 'F')
2979       return 0;
2980     uint32_t retcode = response.GetHexMaxU32(false, UINT32_MAX);
2981     if (retcode == UINT32_MAX)
2982       return retcode;
2983     const char next = (response.Peek() ? *response.Peek() : 0);
2984     if (next == ',')
2985       return 0;
2986     if (next == ';') {
2987       response.GetChar(); // skip the semicolon
2988       std::string buffer;
2989       if (response.GetEscapedBinaryData(buffer)) {
2990         const uint64_t data_to_write =
2991             std::min<uint64_t>(dst_len, buffer.size());
2992         if (data_to_write > 0)
2993           memcpy(dst, &buffer[0], data_to_write);
2994         return data_to_write;
2995       }
2996     }
2997   }
2998   return 0;
2999 }
3000
3001 uint64_t GDBRemoteCommunicationClient::WriteFile(lldb::user_id_t fd,
3002                                                  uint64_t offset,
3003                                                  const void *src,
3004                                                  uint64_t src_len,
3005                                                  Status &error) {
3006   lldb_private::StreamGDBRemote stream;
3007   stream.Printf("vFile:pwrite:%i,%" PRId64 ",", (int)fd, offset);
3008   stream.PutEscapedBytes(src, src_len);
3009   StringExtractorGDBRemote response;
3010   if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
3011       PacketResult::Success) {
3012     if (response.GetChar() != 'F') {
3013       error.SetErrorStringWithFormat("write file failed");
3014       return 0;
3015     }
3016     uint64_t bytes_written = response.GetU64(UINT64_MAX);
3017     if (bytes_written == UINT64_MAX) {
3018       error.SetErrorToGenericError();
3019       if (response.GetChar() == ',') {
3020         int response_errno = response.GetS32(-1);
3021         if (response_errno > 0)
3022           error.SetError(response_errno, lldb::eErrorTypePOSIX);
3023       }
3024       return 0;
3025     }
3026     return bytes_written;
3027   } else {
3028     error.SetErrorString("failed to send vFile:pwrite packet");
3029   }
3030   return 0;
3031 }
3032
3033 Status GDBRemoteCommunicationClient::CreateSymlink(const FileSpec &src,
3034                                                    const FileSpec &dst) {
3035   std::string src_path{src.GetPath(false)}, dst_path{dst.GetPath(false)};
3036   Status error;
3037   lldb_private::StreamGDBRemote stream;
3038   stream.PutCString("vFile:symlink:");
3039   // the unix symlink() command reverses its parameters where the dst if first,
3040   // so we follow suit here
3041   stream.PutStringAsRawHex8(dst_path);
3042   stream.PutChar(',');
3043   stream.PutStringAsRawHex8(src_path);
3044   StringExtractorGDBRemote response;
3045   if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
3046       PacketResult::Success) {
3047     if (response.GetChar() == 'F') {
3048       uint32_t result = response.GetU32(UINT32_MAX);
3049       if (result != 0) {
3050         error.SetErrorToGenericError();
3051         if (response.GetChar() == ',') {
3052           int response_errno = response.GetS32(-1);
3053           if (response_errno > 0)
3054             error.SetError(response_errno, lldb::eErrorTypePOSIX);
3055         }
3056       }
3057     } else {
3058       // Should have returned with 'F<result>[,<errno>]'
3059       error.SetErrorStringWithFormat("symlink failed");
3060     }
3061   } else {
3062     error.SetErrorString("failed to send vFile:symlink packet");
3063   }
3064   return error;
3065 }
3066
3067 Status GDBRemoteCommunicationClient::Unlink(const FileSpec &file_spec) {
3068   std::string path{file_spec.GetPath(false)};
3069   Status error;
3070   lldb_private::StreamGDBRemote stream;
3071   stream.PutCString("vFile:unlink:");
3072   // the unix symlink() command reverses its parameters where the dst if first,
3073   // so we follow suit here
3074   stream.PutStringAsRawHex8(path);
3075   StringExtractorGDBRemote response;
3076   if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
3077       PacketResult::Success) {
3078     if (response.GetChar() == 'F') {
3079       uint32_t result = response.GetU32(UINT32_MAX);
3080       if (result != 0) {
3081         error.SetErrorToGenericError();
3082         if (response.GetChar() == ',') {
3083           int response_errno = response.GetS32(-1);
3084           if (response_errno > 0)
3085             error.SetError(response_errno, lldb::eErrorTypePOSIX);
3086         }
3087       }
3088     } else {
3089       // Should have returned with 'F<result>[,<errno>]'
3090       error.SetErrorStringWithFormat("unlink failed");
3091     }
3092   } else {
3093     error.SetErrorString("failed to send vFile:unlink packet");
3094   }
3095   return error;
3096 }
3097
3098 // Extension of host I/O packets to get whether a file exists.
3099 bool GDBRemoteCommunicationClient::GetFileExists(
3100     const lldb_private::FileSpec &file_spec) {
3101   std::string path(file_spec.GetPath(false));
3102   lldb_private::StreamString stream;
3103   stream.PutCString("vFile:exists:");
3104   stream.PutStringAsRawHex8(path);
3105   StringExtractorGDBRemote response;
3106   if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
3107       PacketResult::Success) {
3108     if (response.GetChar() != 'F')
3109       return false;
3110     if (response.GetChar() != ',')
3111       return false;
3112     bool retcode = (response.GetChar() != '0');
3113     return retcode;
3114   }
3115   return false;
3116 }
3117
3118 bool GDBRemoteCommunicationClient::CalculateMD5(
3119     const lldb_private::FileSpec &file_spec, uint64_t &high, uint64_t &low) {
3120   std::string path(file_spec.GetPath(false));
3121   lldb_private::StreamString stream;
3122   stream.PutCString("vFile:MD5:");
3123   stream.PutStringAsRawHex8(path);
3124   StringExtractorGDBRemote response;
3125   if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
3126       PacketResult::Success) {
3127     if (response.GetChar() != 'F')
3128       return false;
3129     if (response.GetChar() != ',')
3130       return false;
3131     if (response.Peek() && *response.Peek() == 'x')
3132       return false;
3133     low = response.GetHexMaxU64(false, UINT64_MAX);
3134     high = response.GetHexMaxU64(false, UINT64_MAX);
3135     return true;
3136   }
3137   return false;
3138 }
3139
3140 bool GDBRemoteCommunicationClient::AvoidGPackets(ProcessGDBRemote *process) {
3141   // Some targets have issues with g/G packets and we need to avoid using them
3142   if (m_avoid_g_packets == eLazyBoolCalculate) {
3143     if (process) {
3144       m_avoid_g_packets = eLazyBoolNo;
3145       const ArchSpec &arch = process->GetTarget().GetArchitecture();
3146       if (arch.IsValid() &&
3147           arch.GetTriple().getVendor() == llvm::Triple::Apple &&
3148           arch.GetTriple().getOS() == llvm::Triple::IOS &&
3149           arch.GetTriple().getArch() == llvm::Triple::aarch64) {
3150         m_avoid_g_packets = eLazyBoolYes;
3151         uint32_t gdb_server_version = GetGDBServerProgramVersion();
3152         if (gdb_server_version != 0) {
3153           const char *gdb_server_name = GetGDBServerProgramName();
3154           if (gdb_server_name && strcmp(gdb_server_name, "debugserver") == 0) {
3155             if (gdb_server_version >= 310)
3156               m_avoid_g_packets = eLazyBoolNo;
3157           }
3158         }
3159       }
3160     }
3161   }
3162   return m_avoid_g_packets == eLazyBoolYes;
3163 }
3164
3165 DataBufferSP GDBRemoteCommunicationClient::ReadRegister(lldb::tid_t tid,
3166                                                         uint32_t reg) {
3167   StreamString payload;
3168   payload.Printf("p%x", reg);
3169   StringExtractorGDBRemote response;
3170   if (SendThreadSpecificPacketAndWaitForResponse(
3171           tid, std::move(payload), response, false) != PacketResult::Success ||
3172       !response.IsNormalResponse())
3173     return nullptr;
3174
3175   DataBufferSP buffer_sp(
3176       new DataBufferHeap(response.GetStringRef().size() / 2, 0));
3177   response.GetHexBytes(buffer_sp->GetData(), '\xcc');
3178   return buffer_sp;
3179 }
3180
3181 DataBufferSP GDBRemoteCommunicationClient::ReadAllRegisters(lldb::tid_t tid) {
3182   StreamString payload;
3183   payload.PutChar('g');
3184   StringExtractorGDBRemote response;
3185   if (SendThreadSpecificPacketAndWaitForResponse(
3186           tid, std::move(payload), response, false) != PacketResult::Success ||
3187       !response.IsNormalResponse())
3188     return nullptr;
3189
3190   DataBufferSP buffer_sp(
3191       new DataBufferHeap(response.GetStringRef().size() / 2, 0));
3192   response.GetHexBytes(buffer_sp->GetData(), '\xcc');
3193   return buffer_sp;
3194 }
3195
3196 bool GDBRemoteCommunicationClient::WriteRegister(lldb::tid_t tid,
3197                                                  uint32_t reg_num,
3198                                                  llvm::ArrayRef<uint8_t> data) {
3199   StreamString payload;
3200   payload.Printf("P%x=", reg_num);
3201   payload.PutBytesAsRawHex8(data.data(), data.size(),
3202                             endian::InlHostByteOrder(),
3203                             endian::InlHostByteOrder());
3204   StringExtractorGDBRemote response;
3205   return SendThreadSpecificPacketAndWaitForResponse(tid, std::move(payload),
3206                                                     response, false) ==
3207              PacketResult::Success &&
3208          response.IsOKResponse();
3209 }
3210
3211 bool GDBRemoteCommunicationClient::WriteAllRegisters(
3212     lldb::tid_t tid, llvm::ArrayRef<uint8_t> data) {
3213   StreamString payload;
3214   payload.PutChar('G');
3215   payload.PutBytesAsRawHex8(data.data(), data.size(),
3216                             endian::InlHostByteOrder(),
3217                             endian::InlHostByteOrder());
3218   StringExtractorGDBRemote response;
3219   return SendThreadSpecificPacketAndWaitForResponse(tid, std::move(payload),
3220                                                     response, false) ==
3221              PacketResult::Success &&
3222          response.IsOKResponse();
3223 }
3224
3225 bool GDBRemoteCommunicationClient::SaveRegisterState(lldb::tid_t tid,
3226                                                      uint32_t &save_id) {
3227   save_id = 0; // Set to invalid save ID
3228   if (m_supports_QSaveRegisterState == eLazyBoolNo)
3229     return false;
3230
3231   m_supports_QSaveRegisterState = eLazyBoolYes;
3232   StreamString payload;
3233   payload.PutCString("QSaveRegisterState");
3234   StringExtractorGDBRemote response;
3235   if (SendThreadSpecificPacketAndWaitForResponse(
3236           tid, std::move(payload), response, false) != PacketResult::Success)
3237     return false;
3238
3239   if (response.IsUnsupportedResponse())
3240     m_supports_QSaveRegisterState = eLazyBoolNo;
3241
3242   const uint32_t response_save_id = response.GetU32(0);
3243   if (response_save_id == 0)
3244     return false;
3245
3246   save_id = response_save_id;
3247   return true;
3248 }
3249
3250 bool GDBRemoteCommunicationClient::RestoreRegisterState(lldb::tid_t tid,
3251                                                         uint32_t save_id) {
3252   // We use the "m_supports_QSaveRegisterState" variable here because the
3253   // QSaveRegisterState and QRestoreRegisterState packets must both be
3254   // supported in order to be useful
3255   if (m_supports_QSaveRegisterState == eLazyBoolNo)
3256     return false;
3257
3258   StreamString payload;
3259   payload.Printf("QRestoreRegisterState:%u", save_id);
3260   StringExtractorGDBRemote response;
3261   if (SendThreadSpecificPacketAndWaitForResponse(
3262           tid, std::move(payload), response, false) != PacketResult::Success)
3263     return false;
3264
3265   if (response.IsOKResponse())
3266     return true;
3267
3268   if (response.IsUnsupportedResponse())
3269     m_supports_QSaveRegisterState = eLazyBoolNo;
3270   return false;
3271 }
3272
3273 bool GDBRemoteCommunicationClient::SyncThreadState(lldb::tid_t tid) {
3274   if (!GetSyncThreadStateSupported())
3275     return false;
3276
3277   StreamString packet;
3278   StringExtractorGDBRemote response;
3279   packet.Printf("QSyncThreadState:%4.4" PRIx64 ";", tid);
3280   return SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
3281              GDBRemoteCommunication::PacketResult::Success &&
3282          response.IsOKResponse();
3283 }
3284
3285 lldb::user_id_t
3286 GDBRemoteCommunicationClient::SendStartTracePacket(const TraceOptions &options,
3287                                                    Status &error) {
3288   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
3289   lldb::user_id_t ret_uid = LLDB_INVALID_UID;
3290
3291   StreamGDBRemote escaped_packet;
3292   escaped_packet.PutCString("jTraceStart:");
3293
3294   StructuredData::Dictionary json_packet;
3295   json_packet.AddIntegerItem("type", options.getType());
3296   json_packet.AddIntegerItem("buffersize", options.getTraceBufferSize());
3297   json_packet.AddIntegerItem("metabuffersize", options.getMetaDataBufferSize());
3298
3299   if (options.getThreadID() != LLDB_INVALID_THREAD_ID)
3300     json_packet.AddIntegerItem("threadid", options.getThreadID());
3301
3302   StructuredData::DictionarySP custom_params = options.getTraceParams();
3303   if (custom_params)
3304     json_packet.AddItem("params", custom_params);
3305
3306   StreamString json_string;
3307   json_packet.Dump(json_string, false);
3308   escaped_packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
3309
3310   StringExtractorGDBRemote response;
3311   if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
3312                                    true) ==
3313       GDBRemoteCommunication::PacketResult::Success) {
3314     if (!response.IsNormalResponse()) {
3315       error = response.GetStatus();
3316       LLDB_LOG(log, "Target does not support Tracing , error {0}", error);
3317     } else {
3318       ret_uid = response.GetHexMaxU64(false, LLDB_INVALID_UID);
3319     }
3320   } else {
3321     LLDB_LOG(log, "failed to send packet");
3322     error.SetErrorStringWithFormat("failed to send packet: '%s'",
3323                                    escaped_packet.GetData());
3324   }
3325   return ret_uid;
3326 }
3327
3328 Status
3329 GDBRemoteCommunicationClient::SendStopTracePacket(lldb::user_id_t uid,
3330                                                   lldb::tid_t thread_id) {
3331   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
3332   StringExtractorGDBRemote response;
3333   Status error;
3334
3335   StructuredData::Dictionary json_packet;
3336   StreamGDBRemote escaped_packet;
3337   StreamString json_string;
3338   escaped_packet.PutCString("jTraceStop:");
3339
3340   json_packet.AddIntegerItem("traceid", uid);
3341
3342   if (thread_id != LLDB_INVALID_THREAD_ID)
3343     json_packet.AddIntegerItem("threadid", thread_id);
3344
3345   json_packet.Dump(json_string, false);
3346
3347   escaped_packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
3348
3349   if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
3350                                    true) ==
3351       GDBRemoteCommunication::PacketResult::Success) {
3352     if (!response.IsOKResponse()) {
3353       error = response.GetStatus();
3354       LLDB_LOG(log, "stop tracing failed");
3355     }
3356   } else {
3357     LLDB_LOG(log, "failed to send packet");
3358     error.SetErrorStringWithFormat(
3359         "failed to send packet: '%s' with error '%d'", escaped_packet.GetData(),
3360         response.GetError());
3361   }
3362   return error;
3363 }
3364
3365 Status GDBRemoteCommunicationClient::SendGetDataPacket(
3366     lldb::user_id_t uid, lldb::tid_t thread_id,
3367     llvm::MutableArrayRef<uint8_t> &buffer, size_t offset) {
3368
3369   StreamGDBRemote escaped_packet;
3370   escaped_packet.PutCString("jTraceBufferRead:");
3371   return SendGetTraceDataPacket(escaped_packet, uid, thread_id, buffer, offset);
3372 }
3373
3374 Status GDBRemoteCommunicationClient::SendGetMetaDataPacket(
3375     lldb::user_id_t uid, lldb::tid_t thread_id,
3376     llvm::MutableArrayRef<uint8_t> &buffer, size_t offset) {
3377
3378   StreamGDBRemote escaped_packet;
3379   escaped_packet.PutCString("jTraceMetaRead:");
3380   return SendGetTraceDataPacket(escaped_packet, uid, thread_id, buffer, offset);
3381 }
3382
3383 Status
3384 GDBRemoteCommunicationClient::SendGetTraceConfigPacket(lldb::user_id_t uid,
3385                                                        TraceOptions &options) {
3386   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
3387   StringExtractorGDBRemote response;
3388   Status error;
3389
3390   StreamString json_string;
3391   StreamGDBRemote escaped_packet;
3392   escaped_packet.PutCString("jTraceConfigRead:");
3393
3394   StructuredData::Dictionary json_packet;
3395   json_packet.AddIntegerItem("traceid", uid);
3396
3397   if (options.getThreadID() != LLDB_INVALID_THREAD_ID)
3398     json_packet.AddIntegerItem("threadid", options.getThreadID());
3399
3400   json_packet.Dump(json_string, false);
3401   escaped_packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
3402
3403   if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
3404                                    true) ==
3405       GDBRemoteCommunication::PacketResult::Success) {
3406     if (response.IsNormalResponse()) {
3407       uint64_t type = std::numeric_limits<uint64_t>::max();
3408       uint64_t buffersize = std::numeric_limits<uint64_t>::max();
3409       uint64_t metabuffersize = std::numeric_limits<uint64_t>::max();
3410
3411       auto json_object = StructuredData::ParseJSON(response.Peek());
3412
3413       if (!json_object ||
3414           json_object->GetType() != lldb::eStructuredDataTypeDictionary) {
3415         error.SetErrorString("Invalid Configuration obtained");
3416         return error;
3417       }
3418
3419       auto json_dict = json_object->GetAsDictionary();
3420
3421       json_dict->GetValueForKeyAsInteger<uint64_t>("metabuffersize",
3422                                                    metabuffersize);
3423       options.setMetaDataBufferSize(metabuffersize);
3424
3425       json_dict->GetValueForKeyAsInteger<uint64_t>("buffersize", buffersize);
3426       options.setTraceBufferSize(buffersize);
3427
3428       json_dict->GetValueForKeyAsInteger<uint64_t>("type", type);
3429       options.setType(static_cast<lldb::TraceType>(type));
3430
3431       StructuredData::ObjectSP custom_params_sp =
3432           json_dict->GetValueForKey("params");
3433       if (custom_params_sp) {
3434         if (custom_params_sp->GetType() !=
3435             lldb::eStructuredDataTypeDictionary) {
3436           error.SetErrorString("Invalid Configuration obtained");
3437           return error;
3438         } else
3439           options.setTraceParams(
3440               static_pointer_cast<StructuredData::Dictionary>(
3441                   custom_params_sp));
3442       }
3443     } else {
3444       error = response.GetStatus();
3445     }
3446   } else {
3447     LLDB_LOG(log, "failed to send packet");
3448     error.SetErrorStringWithFormat("failed to send packet: '%s'",
3449                                    escaped_packet.GetData());
3450   }
3451   return error;
3452 }
3453
3454 Status GDBRemoteCommunicationClient::SendGetTraceDataPacket(
3455     StreamGDBRemote &packet, lldb::user_id_t uid, lldb::tid_t thread_id,
3456     llvm::MutableArrayRef<uint8_t> &buffer, size_t offset) {
3457   Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
3458   Status error;
3459
3460   StructuredData::Dictionary json_packet;
3461
3462   json_packet.AddIntegerItem("traceid", uid);
3463   json_packet.AddIntegerItem("offset", offset);
3464   json_packet.AddIntegerItem("buffersize", buffer.size());
3465
3466   if (thread_id != LLDB_INVALID_THREAD_ID)
3467     json_packet.AddIntegerItem("threadid", thread_id);
3468
3469   StreamString json_string;
3470   json_packet.Dump(json_string, false);
3471
3472   packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
3473   StringExtractorGDBRemote response;
3474   if (SendPacketAndWaitForResponse(packet.GetString(), response, true) ==
3475       GDBRemoteCommunication::PacketResult::Success) {
3476     if (response.IsNormalResponse()) {
3477       size_t filled_size = response.GetHexBytesAvail(buffer);
3478       buffer = llvm::MutableArrayRef<uint8_t>(buffer.data(), filled_size);
3479     } else {
3480       error = response.GetStatus();
3481       buffer = buffer.slice(buffer.size());
3482     }
3483   } else {
3484     LLDB_LOG(log, "failed to send packet");
3485     error.SetErrorStringWithFormat("failed to send packet: '%s'",
3486                                    packet.GetData());
3487     buffer = buffer.slice(buffer.size());
3488   }
3489   return error;
3490 }
3491
3492 bool GDBRemoteCommunicationClient::GetModuleInfo(
3493     const FileSpec &module_file_spec, const lldb_private::ArchSpec &arch_spec,
3494     ModuleSpec &module_spec) {
3495   if (!m_supports_qModuleInfo)
3496     return false;
3497
3498   std::string module_path = module_file_spec.GetPath(false);
3499   if (module_path.empty())
3500     return false;
3501
3502   StreamString packet;
3503   packet.PutCString("qModuleInfo:");
3504   packet.PutStringAsRawHex8(module_path);
3505   packet.PutCString(";");
3506   const auto &triple = arch_spec.GetTriple().getTriple();
3507   packet.PutStringAsRawHex8(triple);
3508
3509   StringExtractorGDBRemote response;
3510   if (SendPacketAndWaitForResponse(packet.GetString(), response, false) !=
3511       PacketResult::Success)
3512     return false;
3513
3514   if (response.IsErrorResponse())
3515     return false;
3516
3517   if (response.IsUnsupportedResponse()) {
3518     m_supports_qModuleInfo = false;
3519     return false;
3520   }
3521
3522   llvm::StringRef name;
3523   llvm::StringRef value;
3524
3525   module_spec.Clear();
3526   module_spec.GetFileSpec() = module_file_spec;
3527
3528   while (response.GetNameColonValue(name, value)) {
3529     if (name == "uuid" || name == "md5") {
3530       StringExtractor extractor(value);
3531       std::string uuid;
3532       extractor.GetHexByteString(uuid);
3533       module_spec.GetUUID().SetFromStringRef(uuid, uuid.size() / 2);
3534     } else if (name == "triple") {
3535       StringExtractor extractor(value);
3536       std::string triple;
3537       extractor.GetHexByteString(triple);
3538       module_spec.GetArchitecture().SetTriple(triple.c_str());
3539     } else if (name == "file_offset") {
3540       uint64_t ival = 0;
3541       if (!value.getAsInteger(16, ival))
3542         module_spec.SetObjectOffset(ival);
3543     } else if (name == "file_size") {
3544       uint64_t ival = 0;
3545       if (!value.getAsInteger(16, ival))
3546         module_spec.SetObjectSize(ival);
3547     } else if (name == "file_path") {
3548       StringExtractor extractor(value);
3549       std::string path;
3550       extractor.GetHexByteString(path);
3551       module_spec.GetFileSpec() = FileSpec(path, arch_spec.GetTriple());
3552     }
3553   }
3554
3555   return true;
3556 }
3557
3558 static llvm::Optional<ModuleSpec>
3559 ParseModuleSpec(StructuredData::Dictionary *dict) {
3560   ModuleSpec result;
3561   if (!dict)
3562     return llvm::None;
3563
3564   llvm::StringRef string;
3565   uint64_t integer;
3566
3567   if (!dict->GetValueForKeyAsString("uuid", string))
3568     return llvm::None;
3569   if (result.GetUUID().SetFromStringRef(string, string.size() / 2) !=
3570       string.size())
3571     return llvm::None;
3572
3573   if (!dict->GetValueForKeyAsInteger("file_offset", integer))
3574     return llvm::None;
3575   result.SetObjectOffset(integer);
3576
3577   if (!dict->GetValueForKeyAsInteger("file_size", integer))
3578     return llvm::None;
3579   result.SetObjectSize(integer);
3580
3581   if (!dict->GetValueForKeyAsString("triple", string))
3582     return llvm::None;
3583   result.GetArchitecture().SetTriple(string);
3584
3585   if (!dict->GetValueForKeyAsString("file_path", string))
3586     return llvm::None;
3587   result.GetFileSpec() = FileSpec(string, result.GetArchitecture().GetTriple());
3588
3589   return result;
3590 }
3591
3592 llvm::Optional<std::vector<ModuleSpec>>
3593 GDBRemoteCommunicationClient::GetModulesInfo(
3594     llvm::ArrayRef<FileSpec> module_file_specs, const llvm::Triple &triple) {
3595   if (!m_supports_jModulesInfo)
3596     return llvm::None;
3597
3598   JSONArray::SP module_array_sp = std::make_shared<JSONArray>();
3599   for (const FileSpec &module_file_spec : module_file_specs) {
3600     JSONObject::SP module_sp = std::make_shared<JSONObject>();
3601     module_array_sp->AppendObject(module_sp);
3602     module_sp->SetObject(
3603         "file", std::make_shared<JSONString>(module_file_spec.GetPath(false)));
3604     module_sp->SetObject("triple",
3605                          std::make_shared<JSONString>(triple.getTriple()));
3606   }
3607   StreamString unescaped_payload;
3608   unescaped_payload.PutCString("jModulesInfo:");
3609   module_array_sp->Write(unescaped_payload);
3610   StreamGDBRemote payload;
3611   payload.PutEscapedBytes(unescaped_payload.GetString().data(),
3612                           unescaped_payload.GetSize());
3613
3614   // Increase the timeout for jModulesInfo since this packet can take longer.
3615   ScopedTimeout timeout(*this, std::chrono::seconds(10));
3616
3617   StringExtractorGDBRemote response;
3618   if (SendPacketAndWaitForResponse(payload.GetString(), response, false) !=
3619           PacketResult::Success ||
3620       response.IsErrorResponse())
3621     return llvm::None;
3622
3623   if (response.IsUnsupportedResponse()) {
3624     m_supports_jModulesInfo = false;
3625     return llvm::None;
3626   }
3627
3628   StructuredData::ObjectSP response_object_sp =
3629       StructuredData::ParseJSON(response.GetStringRef());
3630   if (!response_object_sp)
3631     return llvm::None;
3632
3633   StructuredData::Array *response_array = response_object_sp->GetAsArray();
3634   if (!response_array)
3635     return llvm::None;
3636
3637   std::vector<ModuleSpec> result;
3638   for (size_t i = 0; i < response_array->GetSize(); ++i) {
3639     if (llvm::Optional<ModuleSpec> module_spec = ParseModuleSpec(
3640             response_array->GetItemAtIndex(i)->GetAsDictionary()))
3641       result.push_back(*module_spec);
3642   }
3643
3644   return result;
3645 }
3646
3647 // query the target remote for extended information using the qXfer packet
3648 //
3649 // example: object='features', annex='target.xml', out=<xml output> return:
3650 // 'true'  on success
3651 //          'false' on failure (err set)
3652 bool GDBRemoteCommunicationClient::ReadExtFeature(
3653     const lldb_private::ConstString object,
3654     const lldb_private::ConstString annex, std::string &out,
3655     lldb_private::Status &err) {
3656
3657   std::stringstream output;
3658   StringExtractorGDBRemote chunk;
3659
3660   uint64_t size = GetRemoteMaxPacketSize();
3661   if (size == 0)
3662     size = 0x1000;
3663   size = size - 1; // Leave space for the 'm' or 'l' character in the response
3664   int offset = 0;
3665   bool active = true;
3666
3667   // loop until all data has been read
3668   while (active) {
3669
3670     // send query extended feature packet
3671     std::stringstream packet;
3672     packet << "qXfer:" << object.AsCString("")
3673            << ":read:" << annex.AsCString("") << ":" << std::hex << offset
3674            << "," << std::hex << size;
3675
3676     GDBRemoteCommunication::PacketResult res =
3677         SendPacketAndWaitForResponse(packet.str(), chunk, false);
3678
3679     if (res != GDBRemoteCommunication::PacketResult::Success) {
3680       err.SetErrorString("Error sending $qXfer packet");
3681       return false;
3682     }
3683
3684     const std::string &str = chunk.GetStringRef();
3685     if (str.length() == 0) {
3686       // should have some data in chunk
3687       err.SetErrorString("Empty response from $qXfer packet");
3688       return false;
3689     }
3690
3691     // check packet code
3692     switch (str[0]) {
3693     // last chunk
3694     case ('l'):
3695       active = false;
3696       LLVM_FALLTHROUGH;
3697
3698     // more chunks
3699     case ('m'):
3700       if (str.length() > 1)
3701         output << &str[1];
3702       offset += size;
3703       break;
3704
3705     // unknown chunk
3706     default:
3707       err.SetErrorString("Invalid continuation code from $qXfer packet");
3708       return false;
3709     }
3710   }
3711
3712   out = output.str();
3713   err.Success();
3714   return true;
3715 }
3716
3717 // Notify the target that gdb is prepared to serve symbol lookup requests.
3718 //  packet: "qSymbol::"
3719 //  reply:
3720 //  OK                  The target does not need to look up any (more) symbols.
3721 //  qSymbol:<sym_name>  The target requests the value of symbol sym_name (hex
3722 //  encoded).
3723 //                      LLDB may provide the value by sending another qSymbol
3724 //                      packet
3725 //                      in the form of"qSymbol:<sym_value>:<sym_name>".
3726 //
3727 //  Three examples:
3728 //
3729 //  lldb sends:    qSymbol::
3730 //  lldb receives: OK
3731 //     Remote gdb stub does not need to know the addresses of any symbols, lldb
3732 //     does not
3733 //     need to ask again in this session.
3734 //
3735 //  lldb sends:    qSymbol::
3736 //  lldb receives: qSymbol:64697370617463685f71756575655f6f666673657473
3737 //  lldb sends:    qSymbol::64697370617463685f71756575655f6f666673657473
3738 //  lldb receives: OK
3739 //     Remote gdb stub asks for address of 'dispatch_queue_offsets'.  lldb does
3740 //     not know
3741 //     the address at this time.  lldb needs to send qSymbol:: again when it has
3742 //     more
3743 //     solibs loaded.
3744 //
3745 //  lldb sends:    qSymbol::
3746 //  lldb receives: qSymbol:64697370617463685f71756575655f6f666673657473
3747 //  lldb sends:    qSymbol:2bc97554:64697370617463685f71756575655f6f666673657473
3748 //  lldb receives: OK
3749 //     Remote gdb stub asks for address of 'dispatch_queue_offsets'.  lldb says
3750 //     that it
3751 //     is at address 0x2bc97554.  Remote gdb stub sends 'OK' indicating that it
3752 //     does not
3753 //     need any more symbols.  lldb does not need to ask again in this session.
3754
3755 void GDBRemoteCommunicationClient::ServeSymbolLookups(
3756     lldb_private::Process *process) {
3757   // Set to true once we've resolved a symbol to an address for the remote
3758   // stub. If we get an 'OK' response after this, the remote stub doesn't need
3759   // any more symbols and we can stop asking.
3760   bool symbol_response_provided = false;
3761
3762   // Is this the initial qSymbol:: packet?
3763   bool first_qsymbol_query = true;
3764
3765   if (m_supports_qSymbol && !m_qSymbol_requests_done) {
3766     Lock lock(*this, false);
3767     if (lock) {
3768       StreamString packet;
3769       packet.PutCString("qSymbol::");
3770       StringExtractorGDBRemote response;
3771       while (SendPacketAndWaitForResponseNoLock(packet.GetString(), response) ==
3772              PacketResult::Success) {
3773         if (response.IsOKResponse()) {
3774           if (symbol_response_provided || first_qsymbol_query) {
3775             m_qSymbol_requests_done = true;
3776           }
3777
3778           // We are done serving symbols requests
3779           return;
3780         }
3781         first_qsymbol_query = false;
3782
3783         if (response.IsUnsupportedResponse()) {
3784           // qSymbol is not supported by the current GDB server we are
3785           // connected to
3786           m_supports_qSymbol = false;
3787           return;
3788         } else {
3789           llvm::StringRef response_str(response.GetStringRef());
3790           if (response_str.startswith("qSymbol:")) {
3791             response.SetFilePos(strlen("qSymbol:"));
3792             std::string symbol_name;
3793             if (response.GetHexByteString(symbol_name)) {
3794               if (symbol_name.empty())
3795                 return;
3796
3797               addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
3798               lldb_private::SymbolContextList sc_list;
3799               if (process->GetTarget().GetImages().FindSymbolsWithNameAndType(
3800                       ConstString(symbol_name), eSymbolTypeAny, sc_list)) {
3801                 const size_t num_scs = sc_list.GetSize();
3802                 for (size_t sc_idx = 0;
3803                      sc_idx < num_scs &&
3804                      symbol_load_addr == LLDB_INVALID_ADDRESS;
3805                      ++sc_idx) {
3806                   SymbolContext sc;
3807                   if (sc_list.GetContextAtIndex(sc_idx, sc)) {
3808                     if (sc.symbol) {
3809                       switch (sc.symbol->GetType()) {
3810                       case eSymbolTypeInvalid:
3811                       case eSymbolTypeAbsolute:
3812                       case eSymbolTypeUndefined:
3813                       case eSymbolTypeSourceFile:
3814                       case eSymbolTypeHeaderFile:
3815                       case eSymbolTypeObjectFile:
3816                       case eSymbolTypeCommonBlock:
3817                       case eSymbolTypeBlock:
3818                       case eSymbolTypeLocal:
3819                       case eSymbolTypeParam:
3820                       case eSymbolTypeVariable:
3821                       case eSymbolTypeVariableType:
3822                       case eSymbolTypeLineEntry:
3823                       case eSymbolTypeLineHeader:
3824                       case eSymbolTypeScopeBegin:
3825                       case eSymbolTypeScopeEnd:
3826                       case eSymbolTypeAdditional:
3827                       case eSymbolTypeCompiler:
3828                       case eSymbolTypeInstrumentation:
3829                       case eSymbolTypeTrampoline:
3830                         break;
3831
3832                       case eSymbolTypeCode:
3833                       case eSymbolTypeResolver:
3834                       case eSymbolTypeData:
3835                       case eSymbolTypeRuntime:
3836                       case eSymbolTypeException:
3837                       case eSymbolTypeObjCClass:
3838                       case eSymbolTypeObjCMetaClass:
3839                       case eSymbolTypeObjCIVar:
3840                       case eSymbolTypeReExported:
3841                         symbol_load_addr =
3842                             sc.symbol->GetLoadAddress(&process->GetTarget());
3843                         break;
3844                       }
3845                     }
3846                   }
3847                 }
3848               }
3849               // This is the normal path where our symbol lookup was successful
3850               // and we want to send a packet with the new symbol value and see
3851               // if another lookup needs to be done.
3852
3853               // Change "packet" to contain the requested symbol value and name
3854               packet.Clear();
3855               packet.PutCString("qSymbol:");
3856               if (symbol_load_addr != LLDB_INVALID_ADDRESS) {
3857                 packet.Printf("%" PRIx64, symbol_load_addr);
3858                 symbol_response_provided = true;
3859               } else {
3860                 symbol_response_provided = false;
3861               }
3862               packet.PutCString(":");
3863               packet.PutBytesAsRawHex8(symbol_name.data(), symbol_name.size());
3864               continue; // go back to the while loop and send "packet" and wait
3865                         // for another response
3866             }
3867           }
3868         }
3869       }
3870       // If we make it here, the symbol request packet response wasn't valid or
3871       // our symbol lookup failed so we must abort
3872       return;
3873
3874     } else if (Log *log = ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet(
3875                    GDBR_LOG_PROCESS | GDBR_LOG_PACKETS)) {
3876       log->Printf(
3877           "GDBRemoteCommunicationClient::%s: Didn't get sequence mutex.",
3878           __FUNCTION__);
3879     }
3880   }
3881 }
3882
3883 StructuredData::Array *
3884 GDBRemoteCommunicationClient::GetSupportedStructuredDataPlugins() {
3885   if (!m_supported_async_json_packets_is_valid) {
3886     // Query the server for the array of supported asynchronous JSON packets.
3887     m_supported_async_json_packets_is_valid = true;
3888
3889     Log *log(ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
3890
3891     // Poll it now.
3892     StringExtractorGDBRemote response;
3893     const bool send_async = false;
3894     if (SendPacketAndWaitForResponse("qStructuredDataPlugins", response,
3895                                      send_async) == PacketResult::Success) {
3896       m_supported_async_json_packets_sp =
3897           StructuredData::ParseJSON(response.GetStringRef());
3898       if (m_supported_async_json_packets_sp &&
3899           !m_supported_async_json_packets_sp->GetAsArray()) {
3900         // We were returned something other than a JSON array.  This is
3901         // invalid.  Clear it out.
3902         if (log)
3903           log->Printf("GDBRemoteCommunicationClient::%s(): "
3904                       "QSupportedAsyncJSONPackets returned invalid "
3905                       "result: %s",
3906                       __FUNCTION__, response.GetStringRef().c_str());
3907         m_supported_async_json_packets_sp.reset();
3908       }
3909     } else {
3910       if (log)
3911         log->Printf("GDBRemoteCommunicationClient::%s(): "
3912                     "QSupportedAsyncJSONPackets unsupported",
3913                     __FUNCTION__);
3914     }
3915
3916     if (log && m_supported_async_json_packets_sp) {
3917       StreamString stream;
3918       m_supported_async_json_packets_sp->Dump(stream);
3919       log->Printf("GDBRemoteCommunicationClient::%s(): supported async "
3920                   "JSON packets: %s",
3921                   __FUNCTION__, stream.GetData());
3922     }
3923   }
3924
3925   return m_supported_async_json_packets_sp
3926              ? m_supported_async_json_packets_sp->GetAsArray()
3927              : nullptr;
3928 }
3929
3930 Status GDBRemoteCommunicationClient::SendSignalsToIgnore(
3931     llvm::ArrayRef<int32_t> signals) {
3932   // Format packet:
3933   // QPassSignals:<hex_sig1>;<hex_sig2>...;<hex_sigN>
3934   auto range = llvm::make_range(signals.begin(), signals.end());
3935   std::string packet = formatv("QPassSignals:{0:$[;]@(x-2)}", range).str();
3936
3937   StringExtractorGDBRemote response;
3938   auto send_status = SendPacketAndWaitForResponse(packet, response, false);
3939
3940   if (send_status != GDBRemoteCommunication::PacketResult::Success)
3941     return Status("Sending QPassSignals packet failed");
3942
3943   if (response.IsOKResponse()) {
3944     return Status();
3945   } else {
3946     return Status("Unknown error happened during sending QPassSignals packet.");
3947   }
3948 }
3949
3950 Status GDBRemoteCommunicationClient::ConfigureRemoteStructuredData(
3951     ConstString type_name, const StructuredData::ObjectSP &config_sp) {
3952   Status error;
3953
3954   if (type_name.GetLength() == 0) {
3955     error.SetErrorString("invalid type_name argument");
3956     return error;
3957   }
3958
3959   // Build command: Configure{type_name}: serialized config data.
3960   StreamGDBRemote stream;
3961   stream.PutCString("QConfigure");
3962   stream.PutCString(type_name.AsCString());
3963   stream.PutChar(':');
3964   if (config_sp) {
3965     // Gather the plain-text version of the configuration data.
3966     StreamString unescaped_stream;
3967     config_sp->Dump(unescaped_stream);
3968     unescaped_stream.Flush();
3969
3970     // Add it to the stream in escaped fashion.
3971     stream.PutEscapedBytes(unescaped_stream.GetString().data(),
3972                            unescaped_stream.GetSize());
3973   }
3974   stream.Flush();
3975
3976   // Send the packet.
3977   const bool send_async = false;
3978   StringExtractorGDBRemote response;
3979   auto result =
3980       SendPacketAndWaitForResponse(stream.GetString(), response, send_async);
3981   if (result == PacketResult::Success) {
3982     // We failed if the config result comes back other than OK.
3983     if (strcmp(response.GetStringRef().c_str(), "OK") == 0) {
3984       // Okay!
3985       error.Clear();
3986     } else {
3987       error.SetErrorStringWithFormat("configuring StructuredData feature "
3988                                      "%s failed with error %s",
3989                                      type_name.AsCString(),
3990                                      response.GetStringRef().c_str());
3991     }
3992   } else {
3993     // Can we get more data here on the failure?
3994     error.SetErrorStringWithFormat("configuring StructuredData feature %s "
3995                                    "failed when sending packet: "
3996                                    "PacketResult=%d",
3997                                    type_name.AsCString(), (int)result);
3998   }
3999   return error;
4000 }
4001
4002 void GDBRemoteCommunicationClient::OnRunPacketSent(bool first) {
4003   GDBRemoteClientBase::OnRunPacketSent(first);
4004   m_curr_tid = LLDB_INVALID_THREAD_ID;
4005 }