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

   1 //===-- GDBRemoteCommunicationClient.cpp ------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10
  11 #include "GDBRemoteCommunicationClient.h"
  12
  13 // C Includes
  14 #include <sys/stat.h>
  15
  16 // C++ Includes
  17 #include <sstream>
  18
  19 // Other libraries and framework includes
  20 #include "llvm/ADT/STLExtras.h"
  21 #include "llvm/ADT/Triple.h"
  22 #include "lldb/Interpreter/Args.h"
  23 #include "lldb/Core/Log.h"
  24 #include "lldb/Core/State.h"
  25 #include "lldb/Core/StreamGDBRemote.h"
  26 #include "lldb/Core/StreamString.h"
  27 #include "lldb/Host/ConnectionFileDescriptor.h"
  28 #include "lldb/Host/Endian.h"
  29 #include "lldb/Host/Host.h"
  30 #include "lldb/Host/HostInfo.h"
  31 #include "lldb/Host/TimeValue.h"
  32 #include "lldb/Target/Target.h"
  33
  34 // Project includes
  35 #include "Utility/StringExtractorGDBRemote.h"
  36 #include "ProcessGDBRemote.h"
  37 #include "ProcessGDBRemoteLog.h"
  38 #include "lldb/Host/Config.h"
  39
  40 using namespace lldb;
  41 using namespace lldb_private;
  42
  43 #if defined(LLDB_DISABLE_POSIX) && !defined(SIGSTOP)
  44 #define SIGSTOP 17
  45 #endif
  46
  47 //----------------------------------------------------------------------
  48 // GDBRemoteCommunicationClient constructor
  49 //----------------------------------------------------------------------
  50 GDBRemoteCommunicationClient::GDBRemoteCommunicationClient(bool is_platform) :
  51     GDBRemoteCommunication("gdb-remote.client", "gdb-remote.client.rx_packet", is_platform),
  52     m_supports_not_sending_acks (eLazyBoolCalculate),
  53     m_supports_thread_suffix (eLazyBoolCalculate),
  54     m_supports_threads_in_stop_reply (eLazyBoolCalculate),
  55     m_supports_vCont_all (eLazyBoolCalculate),
  56     m_supports_vCont_any (eLazyBoolCalculate),
  57     m_supports_vCont_c (eLazyBoolCalculate),
  58     m_supports_vCont_C (eLazyBoolCalculate),
  59     m_supports_vCont_s (eLazyBoolCalculate),
  60     m_supports_vCont_S (eLazyBoolCalculate),
  61     m_qHostInfo_is_valid (eLazyBoolCalculate),
  62     m_curr_pid_is_valid (eLazyBoolCalculate),
  63     m_qProcessInfo_is_valid (eLazyBoolCalculate),
  64     m_qGDBServerVersion_is_valid (eLazyBoolCalculate),
  65     m_supports_alloc_dealloc_memory (eLazyBoolCalculate),
  66     m_supports_memory_region_info  (eLazyBoolCalculate),
  67     m_supports_watchpoint_support_info  (eLazyBoolCalculate),
  68     m_supports_detach_stay_stopped (eLazyBoolCalculate),
  69     m_watchpoints_trigger_after_instruction(eLazyBoolCalculate),
  70     m_attach_or_wait_reply(eLazyBoolCalculate),
  71     m_prepare_for_reg_writing_reply (eLazyBoolCalculate),
  72     m_supports_p (eLazyBoolCalculate),
  73     m_supports_x (eLazyBoolCalculate),
  74     m_avoid_g_packets (eLazyBoolCalculate),
  75     m_supports_QSaveRegisterState (eLazyBoolCalculate),
  76     m_supports_qXfer_auxv_read (eLazyBoolCalculate),
  77     m_supports_qXfer_libraries_read (eLazyBoolCalculate),
  78     m_supports_qXfer_libraries_svr4_read (eLazyBoolCalculate),
  79     m_supports_augmented_libraries_svr4_read (eLazyBoolCalculate),
  80     m_supports_jThreadExtendedInfo (eLazyBoolCalculate),
  81     m_supports_qProcessInfoPID (true),
  82     m_supports_qfProcessInfo (true),
  83     m_supports_qUserName (true),
  84     m_supports_qGroupName (true),
  85     m_supports_qThreadStopInfo (true),
  86     m_supports_z0 (true),
  87     m_supports_z1 (true),
  88     m_supports_z2 (true),
  89     m_supports_z3 (true),
  90     m_supports_z4 (true),
  91     m_supports_QEnvironment (true),
  92     m_supports_QEnvironmentHexEncoded (true),
  93     m_curr_pid (LLDB_INVALID_PROCESS_ID),
  94     m_curr_tid (LLDB_INVALID_THREAD_ID),
  95     m_curr_tid_run (LLDB_INVALID_THREAD_ID),
  96     m_num_supported_hardware_watchpoints (0),
  97     m_async_mutex (Mutex::eMutexTypeRecursive),
  98     m_async_packet_predicate (false),
  99     m_async_packet (),
 100     m_async_result (PacketResult::Success),
 101     m_async_response (),
 102     m_async_signal (-1),
 103     m_interrupt_sent (false),
 104     m_thread_id_to_used_usec_map (),
 105     m_host_arch(),
 106     m_process_arch(),
 107     m_os_version_major (UINT32_MAX),
 108     m_os_version_minor (UINT32_MAX),
 109     m_os_version_update (UINT32_MAX),
 110     m_os_build (),
 111     m_os_kernel (),
 112     m_hostname (),
 113     m_gdb_server_name(),
 114     m_gdb_server_version(UINT32_MAX),
 115     m_default_packet_timeout (0),
 116     m_max_packet_size (0)
 117 {
 118 }
 119
 120 //----------------------------------------------------------------------
 121 // Destructor
 122 //----------------------------------------------------------------------
 123 GDBRemoteCommunicationClient::~GDBRemoteCommunicationClient()
 124 {
 125     if (IsConnected())
 126         Disconnect();
 127 }
 128
 129 bool
 130 GDBRemoteCommunicationClient::HandshakeWithServer (Error *error_ptr)
 131 {
 132     ResetDiscoverableSettings();
 133
 134     // Start the read thread after we send the handshake ack since if we
 135     // fail to send the handshake ack, there is no reason to continue...
 136     if (SendAck())
 137     {
 138         // Wait for any responses that might have been queued up in the remote
 139         // GDB server and flush them all
 140         StringExtractorGDBRemote response;
 141         PacketResult packet_result = PacketResult::Success;
 142         const uint32_t timeout_usec = 10 * 1000; // Wait for 10 ms for a response
 143         while (packet_result == PacketResult::Success)
 144             packet_result = WaitForPacketWithTimeoutMicroSecondsNoLock (response, timeout_usec);
 145
 146         // The return value from QueryNoAckModeSupported() is true if the packet
 147         // was sent and _any_ response (including UNIMPLEMENTED) was received),
 148         // or false if no response was received. This quickly tells us if we have
 149         // a live connection to a remote GDB server...
 150         if (QueryNoAckModeSupported())
 151         {
 152 #if 0
 153             // Set above line to "#if 1" to test packet speed if remote GDB server
 154             // supports the qSpeedTest packet...
 155             TestPacketSpeed(10000);
 156 #endif
 157             return true;
 158         }
 159         else
 160         {
 161             if (error_ptr)
 162                 error_ptr->SetErrorString("failed to get reply to handshake packet");
 163         }
 164     }
 165     else
 166     {
 167         if (error_ptr)
 168             error_ptr->SetErrorString("failed to send the handshake ack");
 169     }
 170     return false;
 171 }
 172
 173 bool
 174 GDBRemoteCommunicationClient::GetAugmentedLibrariesSVR4ReadSupported ()
 175 {
 176     if (m_supports_augmented_libraries_svr4_read == eLazyBoolCalculate)
 177     {
 178         GetRemoteQSupported();
 179     }
 180     return (m_supports_augmented_libraries_svr4_read == eLazyBoolYes);
 181 }
 182
 183 bool
 184 GDBRemoteCommunicationClient::GetQXferLibrariesSVR4ReadSupported ()
 185 {
 186     if (m_supports_qXfer_libraries_svr4_read == eLazyBoolCalculate)
 187     {
 188         GetRemoteQSupported();
 189     }
 190     return (m_supports_qXfer_libraries_svr4_read == eLazyBoolYes);
 191 }
 192
 193 bool
 194 GDBRemoteCommunicationClient::GetQXferLibrariesReadSupported ()
 195 {
 196     if (m_supports_qXfer_libraries_read == eLazyBoolCalculate)
 197     {
 198         GetRemoteQSupported();
 199     }
 200     return (m_supports_qXfer_libraries_read == eLazyBoolYes);
 201 }
 202
 203 bool
 204 GDBRemoteCommunicationClient::GetQXferAuxvReadSupported ()
 205 {
 206     if (m_supports_qXfer_auxv_read == eLazyBoolCalculate)
 207     {
 208         GetRemoteQSupported();
 209     }
 210     return (m_supports_qXfer_auxv_read == eLazyBoolYes);
 211 }
 212
 213 uint64_t
 214 GDBRemoteCommunicationClient::GetRemoteMaxPacketSize()
 215 {
 216     if (m_max_packet_size == 0)
 217     {
 218         GetRemoteQSupported();
 219     }
 220     return m_max_packet_size;
 221 }
 222
 223 bool
 224 GDBRemoteCommunicationClient::QueryNoAckModeSupported ()
 225 {
 226     if (m_supports_not_sending_acks == eLazyBoolCalculate)
 227     {
 228         m_send_acks = true;
 229         m_supports_not_sending_acks = eLazyBoolNo;
 230
 231         // This is the first real packet that we'll send in a debug session and it may take a little
 232         // longer than normal to receive a reply.  Wait at least 6 seconds for a reply to this packet.
 233
 234         const uint32_t minimum_timeout = 6;
 235         uint32_t old_timeout = GetPacketTimeoutInMicroSeconds() / lldb_private::TimeValue::MicroSecPerSec;
 236         SetPacketTimeout (std::max (old_timeout, minimum_timeout));
 237
 238         StringExtractorGDBRemote response;
 239         PacketResult packet_send_result = SendPacketAndWaitForResponse("QStartNoAckMode", response, false);
 240         SetPacketTimeout (old_timeout);
 241
 242         if (packet_send_result == PacketResult::Success)
 243         {
 244             if (response.IsOKResponse())
 245             {
 246                 m_send_acks = false;
 247                 m_supports_not_sending_acks = eLazyBoolYes;
 248             }
 249             return true;
 250         }
 251     }
 252     return false;
 253 }
 254
 255 void
 256 GDBRemoteCommunicationClient::GetListThreadsInStopReplySupported ()
 257 {
 258     if (m_supports_threads_in_stop_reply == eLazyBoolCalculate)
 259     {
 260         m_supports_threads_in_stop_reply = eLazyBoolNo;
 261
 262         StringExtractorGDBRemote response;
 263         if (SendPacketAndWaitForResponse("QListThreadsInStopReply", response, false) == PacketResult::Success)
 264         {
 265             if (response.IsOKResponse())
 266                 m_supports_threads_in_stop_reply = eLazyBoolYes;
 267         }
 268     }
 269 }
 270
 271 bool
 272 GDBRemoteCommunicationClient::GetVAttachOrWaitSupported ()
 273 {
 274     if (m_attach_or_wait_reply == eLazyBoolCalculate)
 275     {
 276         m_attach_or_wait_reply = eLazyBoolNo;
 277
 278         StringExtractorGDBRemote response;
 279         if (SendPacketAndWaitForResponse("qVAttachOrWaitSupported", response, false) == PacketResult::Success)
 280         {
 281             if (response.IsOKResponse())
 282                 m_attach_or_wait_reply = eLazyBoolYes;
 283         }
 284     }
 285     if (m_attach_or_wait_reply == eLazyBoolYes)
 286         return true;
 287     else
 288         return false;
 289 }
 290
 291 bool
 292 GDBRemoteCommunicationClient::GetSyncThreadStateSupported ()
 293 {
 294     if (m_prepare_for_reg_writing_reply == eLazyBoolCalculate)
 295     {
 296         m_prepare_for_reg_writing_reply = eLazyBoolNo;
 297
 298         StringExtractorGDBRemote response;
 299         if (SendPacketAndWaitForResponse("qSyncThreadStateSupported", response, false) == PacketResult::Success)
 300         {
 301             if (response.IsOKResponse())
 302                 m_prepare_for_reg_writing_reply = eLazyBoolYes;
 303         }
 304     }
 305     if (m_prepare_for_reg_writing_reply == eLazyBoolYes)
 306         return true;
 307     else
 308         return false;
 309 }
 310
 311
 312 void
 313 GDBRemoteCommunicationClient::ResetDiscoverableSettings()
 314 {
 315     m_supports_not_sending_acks = eLazyBoolCalculate;
 316     m_supports_thread_suffix = eLazyBoolCalculate;
 317     m_supports_threads_in_stop_reply = eLazyBoolCalculate;
 318     m_supports_vCont_c = eLazyBoolCalculate;
 319     m_supports_vCont_C = eLazyBoolCalculate;
 320     m_supports_vCont_s = eLazyBoolCalculate;
 321     m_supports_vCont_S = eLazyBoolCalculate;
 322     m_supports_p = eLazyBoolCalculate;
 323     m_supports_x = eLazyBoolCalculate;
 324     m_supports_QSaveRegisterState = eLazyBoolCalculate;
 325     m_qHostInfo_is_valid = eLazyBoolCalculate;
 326     m_curr_pid_is_valid = eLazyBoolCalculate;
 327     m_qProcessInfo_is_valid = eLazyBoolCalculate;
 328     m_qGDBServerVersion_is_valid = eLazyBoolCalculate;
 329     m_supports_alloc_dealloc_memory = eLazyBoolCalculate;
 330     m_supports_memory_region_info = eLazyBoolCalculate;
 331     m_prepare_for_reg_writing_reply = eLazyBoolCalculate;
 332     m_attach_or_wait_reply = eLazyBoolCalculate;
 333     m_avoid_g_packets = eLazyBoolCalculate;
 334     m_supports_qXfer_auxv_read = eLazyBoolCalculate;
 335     m_supports_qXfer_libraries_read = eLazyBoolCalculate;
 336     m_supports_qXfer_libraries_svr4_read = eLazyBoolCalculate;
 337     m_supports_augmented_libraries_svr4_read = eLazyBoolCalculate;
 338
 339     m_supports_qProcessInfoPID = true;
 340     m_supports_qfProcessInfo = true;
 341     m_supports_qUserName = true;
 342     m_supports_qGroupName = true;
 343     m_supports_qThreadStopInfo = true;
 344     m_supports_z0 = true;
 345     m_supports_z1 = true;
 346     m_supports_z2 = true;
 347     m_supports_z3 = true;
 348     m_supports_z4 = true;
 349     m_supports_QEnvironment = true;
 350     m_supports_QEnvironmentHexEncoded = true;
 351
 352     m_host_arch.Clear();
 353     m_process_arch.Clear();
 354     m_os_version_major = UINT32_MAX;
 355     m_os_version_minor = UINT32_MAX;
 356     m_os_version_update = UINT32_MAX;
 357     m_os_build.clear();
 358     m_os_kernel.clear();
 359     m_hostname.clear();
 360     m_gdb_server_name.clear();
 361     m_gdb_server_version = UINT32_MAX;
 362     m_default_packet_timeout = 0;
 363
 364     m_max_packet_size = 0;
 365 }
 366
 367 void
 368 GDBRemoteCommunicationClient::GetRemoteQSupported ()
 369 {
 370     // Clear out any capabilities we expect to see in the qSupported response
 371     m_supports_qXfer_auxv_read = eLazyBoolNo;
 372     m_supports_qXfer_libraries_read = eLazyBoolNo;
 373     m_supports_qXfer_libraries_svr4_read = eLazyBoolNo;
 374     m_supports_augmented_libraries_svr4_read = eLazyBoolNo;
 375     m_max_packet_size = UINT64_MAX;  // It's supposed to always be there, but if not, we assume no limit
 376
 377     StringExtractorGDBRemote response;
 378     if (SendPacketAndWaitForResponse("qSupported",
 379                                      response,
 380                                      /*send_async=*/false) == PacketResult::Success)
 381     {
 382         const char *response_cstr = response.GetStringRef().c_str();
 383         if (::strstr (response_cstr, "qXfer:auxv:read+"))
 384             m_supports_qXfer_auxv_read = eLazyBoolYes;
 385         if (::strstr (response_cstr, "qXfer:libraries-svr4:read+"))
 386             m_supports_qXfer_libraries_svr4_read = eLazyBoolYes;
 387         if (::strstr (response_cstr, "augmented-libraries-svr4-read"))
 388         {
 389             m_supports_qXfer_libraries_svr4_read = eLazyBoolYes;  // implied
 390             m_supports_augmented_libraries_svr4_read = eLazyBoolYes;
 391         }
 392         if (::strstr (response_cstr, "qXfer:libraries:read+"))
 393             m_supports_qXfer_libraries_read = eLazyBoolYes;
 394
 395         const char *packet_size_str = ::strstr (response_cstr, "PacketSize=");
 396         if (packet_size_str)
 397         {
 398             StringExtractorGDBRemote packet_response(packet_size_str + strlen("PacketSize="));
 399             m_max_packet_size = packet_response.GetHexMaxU64(/*little_endian=*/false, UINT64_MAX);
 400             if (m_max_packet_size == 0)
 401             {
 402                 m_max_packet_size = UINT64_MAX;  // Must have been a garbled response
 403                 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
 404                 if (log)
 405                     log->Printf ("Garbled PacketSize spec in qSupported response");
 406             }
 407         }
 408     }
 409 }
 410
 411 bool
 412 GDBRemoteCommunicationClient::GetThreadSuffixSupported ()
 413 {
 414     if (m_supports_thread_suffix == eLazyBoolCalculate)
 415     {
 416         StringExtractorGDBRemote response;
 417         m_supports_thread_suffix = eLazyBoolNo;
 418         if (SendPacketAndWaitForResponse("QThreadSuffixSupported", response, false) == PacketResult::Success)
 419         {
 420             if (response.IsOKResponse())
 421                 m_supports_thread_suffix = eLazyBoolYes;
 422         }
 423     }
 424     return m_supports_thread_suffix;
 425 }
 426 bool
 427 GDBRemoteCommunicationClient::GetVContSupported (char flavor)
 428 {
 429     if (m_supports_vCont_c == eLazyBoolCalculate)
 430     {
 431         StringExtractorGDBRemote response;
 432         m_supports_vCont_any = eLazyBoolNo;
 433         m_supports_vCont_all = eLazyBoolNo;
 434         m_supports_vCont_c = eLazyBoolNo;
 435         m_supports_vCont_C = eLazyBoolNo;
 436         m_supports_vCont_s = eLazyBoolNo;
 437         m_supports_vCont_S = eLazyBoolNo;
 438         if (SendPacketAndWaitForResponse("vCont?", response, false) == PacketResult::Success)
 439         {
 440             const char *response_cstr = response.GetStringRef().c_str();
 441             if (::strstr (response_cstr, ";c"))
 442                 m_supports_vCont_c = eLazyBoolYes;
 443
 444             if (::strstr (response_cstr, ";C"))
 445                 m_supports_vCont_C = eLazyBoolYes;
 446
 447             if (::strstr (response_cstr, ";s"))
 448                 m_supports_vCont_s = eLazyBoolYes;
 449
 450             if (::strstr (response_cstr, ";S"))
 451                 m_supports_vCont_S = eLazyBoolYes;
 452
 453             if (m_supports_vCont_c == eLazyBoolYes &&
 454                 m_supports_vCont_C == eLazyBoolYes &&
 455                 m_supports_vCont_s == eLazyBoolYes &&
 456                 m_supports_vCont_S == eLazyBoolYes)
 457             {
 458                 m_supports_vCont_all = eLazyBoolYes;
 459             }
 460
 461             if (m_supports_vCont_c == eLazyBoolYes ||
 462                 m_supports_vCont_C == eLazyBoolYes ||
 463                 m_supports_vCont_s == eLazyBoolYes ||
 464                 m_supports_vCont_S == eLazyBoolYes)
 465             {
 466                 m_supports_vCont_any = eLazyBoolYes;
 467             }
 468         }
 469     }
 470
 471     switch (flavor)
 472     {
 473     case 'a': return m_supports_vCont_any;
 474     case 'A': return m_supports_vCont_all;
 475     case 'c': return m_supports_vCont_c;
 476     case 'C': return m_supports_vCont_C;
 477     case 's': return m_supports_vCont_s;
 478     case 'S': return m_supports_vCont_S;
 479     default: break;
 480     }
 481     return false;
 482 }
 483
 484 // Check if the target supports 'p' packet. It sends out a 'p'
 485 // packet and checks the response. A normal packet will tell us
 486 // that support is available.
 487 //
 488 // Takes a valid thread ID because p needs to apply to a thread.
 489 bool
 490 GDBRemoteCommunicationClient::GetpPacketSupported (lldb::tid_t tid)
 491 {
 492     if (m_supports_p == eLazyBoolCalculate)
 493     {
 494         StringExtractorGDBRemote response;
 495         m_supports_p = eLazyBoolNo;
 496         char packet[256];
 497         if (GetThreadSuffixSupported())
 498             snprintf(packet, sizeof(packet), "p0;thread:%" PRIx64 ";", tid);
 499         else
 500             snprintf(packet, sizeof(packet), "p0");
 501
 502         if (SendPacketAndWaitForResponse(packet, response, false) == PacketResult::Success)
 503         {
 504             if (response.IsNormalResponse())
 505                 m_supports_p = eLazyBoolYes;
 506         }
 507     }
 508     return m_supports_p;
 509 }
 510
 511 bool
 512 GDBRemoteCommunicationClient::GetThreadExtendedInfoSupported ()
 513 {
 514     if (m_supports_jThreadExtendedInfo == eLazyBoolCalculate)
 515     {
 516         StringExtractorGDBRemote response;
 517         m_supports_jThreadExtendedInfo = eLazyBoolNo;
 518         if (SendPacketAndWaitForResponse("jThreadExtendedInfo:", response, false) == PacketResult::Success)
 519         {
 520             if (response.IsOKResponse())
 521             {
 522                 m_supports_jThreadExtendedInfo = eLazyBoolYes;
 523             }
 524         }
 525     }
 526     return m_supports_jThreadExtendedInfo;
 527 }
 528
 529 bool
 530 GDBRemoteCommunicationClient::GetxPacketSupported ()
 531 {
 532     if (m_supports_x == eLazyBoolCalculate)
 533     {
 534         StringExtractorGDBRemote response;
 535         m_supports_x = eLazyBoolNo;
 536         char packet[256];
 537         snprintf (packet, sizeof (packet), "x0,0");
 538         if (SendPacketAndWaitForResponse(packet, response, false) == PacketResult::Success)
 539         {
 540             if (response.IsOKResponse())
 541                 m_supports_x = eLazyBoolYes;
 542         }
 543     }
 544     return m_supports_x;
 545 }
 546
 547 GDBRemoteCommunicationClient::PacketResult
 548 GDBRemoteCommunicationClient::SendPacketsAndConcatenateResponses
 549 (
 550     const char *payload_prefix,
 551     std::string &response_string
 552 )
 553 {
 554     Mutex::Locker locker;
 555     if (!GetSequenceMutex(locker,
 556                           "ProcessGDBRemote::SendPacketsAndConcatenateResponses() failed due to not getting the sequence mutex"))
 557     {
 558         Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_PROCESS | GDBR_LOG_PACKETS));
 559         if (log)
 560             log->Printf("error: failed to get packet sequence mutex, not sending packets with prefix '%s'",
 561                         payload_prefix);
 562         return PacketResult::ErrorNoSequenceLock;
 563     }
 564
 565     response_string = "";
 566     std::string payload_prefix_str(payload_prefix);
 567     unsigned int response_size = 0x1000;
 568     if (response_size > GetRemoteMaxPacketSize()) {  // May send qSupported packet
 569         response_size = GetRemoteMaxPacketSize();
 570     }
 571
 572     for (unsigned int offset = 0; true; offset += response_size)
 573     {
 574         StringExtractorGDBRemote this_response;
 575         // Construct payload
 576         char sizeDescriptor[128];
 577         snprintf(sizeDescriptor, sizeof(sizeDescriptor), "%x,%x", offset, response_size);
 578         PacketResult result = SendPacketAndWaitForResponse((payload_prefix_str + sizeDescriptor).c_str(),
 579                                                            this_response,
 580                                                            /*send_async=*/false);
 581         if (result != PacketResult::Success)
 582             return result;
 583
 584         const std::string &this_string = this_response.GetStringRef();
 585
 586         // Check for m or l as first character; l seems to mean this is the last chunk
 587         char first_char = *this_string.c_str();
 588         if (first_char != 'm' && first_char != 'l')
 589         {
 590             return PacketResult::ErrorReplyInvalid;
 591         }
 592         // Concatenate the result so far (skipping 'm' or 'l')
 593         response_string.append(this_string, 1, std::string::npos);
 594         if (first_char == 'l')
 595             // We're done
 596             return PacketResult::Success;
 597     }
 598 }
 599
 600 GDBRemoteCommunicationClient::PacketResult
 601 GDBRemoteCommunicationClient::SendPacketAndWaitForResponse
 602 (
 603     const char *payload,
 604     StringExtractorGDBRemote &response,
 605     bool send_async
 606 )
 607 {
 608     return SendPacketAndWaitForResponse (payload,
 609                                          ::strlen (payload),
 610                                          response,
 611                                          send_async);
 612 }
 613
 614 GDBRemoteCommunicationClient::PacketResult
 615 GDBRemoteCommunicationClient::SendPacketAndWaitForResponseNoLock (const char *payload,
 616                                                                   size_t payload_length,
 617                                                                   StringExtractorGDBRemote &response)
 618 {
 619     PacketResult packet_result = SendPacketNoLock (payload, payload_length);
 620     if (packet_result == PacketResult::Success)
 621         packet_result = WaitForPacketWithTimeoutMicroSecondsNoLock (response, GetPacketTimeoutInMicroSeconds ());
 622     return packet_result;
 623 }
 624
 625 GDBRemoteCommunicationClient::PacketResult
 626 GDBRemoteCommunicationClient::SendPacketAndWaitForResponse
 627 (
 628     const char *payload,
 629     size_t payload_length,
 630     StringExtractorGDBRemote &response,
 631     bool send_async
 632 )
 633 {
 634     PacketResult packet_result = PacketResult::ErrorSendFailed;
 635     Mutex::Locker locker;
 636     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
 637     if (GetSequenceMutex (locker))
 638     {
 639         packet_result = SendPacketAndWaitForResponseNoLock (payload, payload_length, response);
 640     }
 641     else
 642     {
 643         if (send_async)
 644         {
 645             if (IsRunning())
 646             {
 647                 Mutex::Locker async_locker (m_async_mutex);
 648                 m_async_packet.assign(payload, payload_length);
 649                 m_async_packet_predicate.SetValue (true, eBroadcastNever);
 650
 651                 if (log)
 652                     log->Printf ("async: async packet = %s", m_async_packet.c_str());
 653
 654                 bool timed_out = false;
 655                 if (SendInterrupt(locker, 2, timed_out))
 656                 {
 657                     if (m_interrupt_sent)
 658                     {
 659                         m_interrupt_sent = false;
 660                         TimeValue timeout_time;
 661                         timeout_time = TimeValue::Now();
 662                         timeout_time.OffsetWithSeconds (m_packet_timeout);
 663
 664                         if (log)
 665                             log->Printf ("async: sent interrupt");
 666
 667                         if (m_async_packet_predicate.WaitForValueEqualTo (false, &timeout_time, &timed_out))
 668                         {
 669                             if (log)
 670                                 log->Printf ("async: got response");
 671
 672                             // Swap the response buffer to avoid malloc and string copy
 673                             response.GetStringRef().swap (m_async_response.GetStringRef());
 674                             packet_result = m_async_result;
 675                         }
 676                         else
 677                         {
 678                             if (log)
 679                                 log->Printf ("async: timed out waiting for response");
 680                         }
 681
 682                         // Make sure we wait until the continue packet has been sent again...
 683                         if (m_private_is_running.WaitForValueEqualTo (true, &timeout_time, &timed_out))
 684                         {
 685                             if (log)
 686                             {
 687                                 if (timed_out)
 688                                     log->Printf ("async: timed out waiting for process to resume, but process was resumed");
 689                                 else
 690                                     log->Printf ("async: async packet sent");
 691                             }
 692                         }
 693                         else
 694                         {
 695                             if (log)
 696                                 log->Printf ("async: timed out waiting for process to resume");
 697                         }
 698                     }
 699                     else
 700                     {
 701                         // We had a racy condition where we went to send the interrupt
 702                         // yet we were able to get the lock, so the process must have
 703                         // just stopped?
 704                         if (log)
 705                             log->Printf ("async: got lock without sending interrupt");
 706                         // Send the packet normally since we got the lock
 707                         packet_result = SendPacketAndWaitForResponseNoLock (payload, payload_length, response);
 708                     }
 709                 }
 710                 else
 711                 {
 712                     if (log)
 713                         log->Printf ("async: failed to interrupt");
 714                 }
 715             }
 716             else
 717             {
 718                 if (log)
 719                     log->Printf ("async: not running, async is ignored");
 720             }
 721         }
 722         else
 723         {
 724             if (log)
 725                 log->Printf("error: failed to get packet sequence mutex, not sending packet '%*s'", (int) payload_length, payload);
 726         }
 727     }
 728     return packet_result;
 729 }
 730
 731 static const char *end_delimiter = "--end--;";
 732 static const int end_delimiter_len = 8;
 733
 734 std::string
 735 GDBRemoteCommunicationClient::HarmonizeThreadIdsForProfileData
 736 (   ProcessGDBRemote *process,
 737     StringExtractorGDBRemote& profileDataExtractor
 738 )
 739 {
 740     std::map<uint64_t, uint32_t> new_thread_id_to_used_usec_map;
 741     std::stringstream final_output;
 742     std::string name, value;
 743
 744     // Going to assuming thread_used_usec comes first, else bail out.
 745     while (profileDataExtractor.GetNameColonValue(name, value))
 746     {
 747         if (name.compare("thread_used_id") == 0)
 748         {
 749             StringExtractor threadIDHexExtractor(value.c_str());
 750             uint64_t thread_id = threadIDHexExtractor.GetHexMaxU64(false, 0);
 751
 752             bool has_used_usec = false;
 753             uint32_t curr_used_usec = 0;
 754             std::string usec_name, usec_value;
 755             uint32_t input_file_pos = profileDataExtractor.GetFilePos();
 756             if (profileDataExtractor.GetNameColonValue(usec_name, usec_value))
 757             {
 758                 if (usec_name.compare("thread_used_usec") == 0)
 759                 {
 760                     has_used_usec = true;
 761                     curr_used_usec = strtoull(usec_value.c_str(), NULL, 0);
 762                 }
 763                 else
 764                 {
 765                     // We didn't find what we want, it is probably
 766                     // an older version. Bail out.
 767                     profileDataExtractor.SetFilePos(input_file_pos);
 768                 }
 769             }
 770
 771             if (has_used_usec)
 772             {
 773                 uint32_t prev_used_usec = 0;
 774                 std::map<uint64_t, uint32_t>::iterator iterator = m_thread_id_to_used_usec_map.find(thread_id);
 775                 if (iterator != m_thread_id_to_used_usec_map.end())
 776                 {
 777                     prev_used_usec = m_thread_id_to_used_usec_map[thread_id];
 778                 }
 779
 780                 uint32_t real_used_usec = curr_used_usec - prev_used_usec;
 781                 // A good first time record is one that runs for at least 0.25 sec
 782                 bool good_first_time = (prev_used_usec == 0) && (real_used_usec > 250000);
 783                 bool good_subsequent_time = (prev_used_usec > 0) &&
 784                     ((real_used_usec > 0) || (process->HasAssignedIndexIDToThread(thread_id)));
 785
 786                 if (good_first_time || good_subsequent_time)
 787                 {
 788                     // We try to avoid doing too many index id reservation,
 789                     // resulting in fast increase of index ids.
 790
 791                     final_output << name << ":";
 792                     int32_t index_id = process->AssignIndexIDToThread(thread_id);
 793                     final_output << index_id << ";";
 794
 795                     final_output << usec_name << ":" << usec_value << ";";
 796                 }
 797                 else
 798                 {
 799                     // Skip past 'thread_used_name'.
 800                     std::string local_name, local_value;
 801                     profileDataExtractor.GetNameColonValue(local_name, local_value);
 802                 }
 803
 804                 // Store current time as previous time so that they can be compared later.
 805                 new_thread_id_to_used_usec_map[thread_id] = curr_used_usec;
 806             }
 807             else
 808             {
 809                 // Bail out and use old string.
 810                 final_output << name << ":" << value << ";";
 811             }
 812         }
 813         else
 814         {
 815             final_output << name << ":" << value << ";";
 816         }
 817     }
 818     final_output << end_delimiter;
 819     m_thread_id_to_used_usec_map = new_thread_id_to_used_usec_map;
 820
 821     return final_output.str();
 822 }
 823
 824 StateType
 825 GDBRemoteCommunicationClient::SendContinuePacketAndWaitForResponse
 826 (
 827     ProcessGDBRemote *process,
 828     const char *payload,
 829     size_t packet_length,
 830     StringExtractorGDBRemote &response
 831 )
 832 {
 833     m_curr_tid = LLDB_INVALID_THREAD_ID;
 834     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
 835     if (log)
 836         log->Printf ("GDBRemoteCommunicationClient::%s ()", __FUNCTION__);
 837
 838     Mutex::Locker locker(m_sequence_mutex);
 839     StateType state = eStateRunning;
 840
 841     BroadcastEvent(eBroadcastBitRunPacketSent, NULL);
 842     m_public_is_running.SetValue (true, eBroadcastNever);
 843     // Set the starting continue packet into "continue_packet". This packet
 844     // may change if we are interrupted and we continue after an async packet...
 845     std::string continue_packet(payload, packet_length);
 846
 847     bool got_async_packet = false;
 848
 849     while (state == eStateRunning)
 850     {
 851         if (!got_async_packet)
 852         {
 853             if (log)
 854                 log->Printf ("GDBRemoteCommunicationClient::%s () sending continue packet: %s", __FUNCTION__, continue_packet.c_str());
 855             if (SendPacketNoLock(continue_packet.c_str(), continue_packet.size()) != PacketResult::Success)
 856                 state = eStateInvalid;
 857             else
 858                 m_interrupt_sent = false;
 859
 860             m_private_is_running.SetValue (true, eBroadcastAlways);
 861         }
 862
 863         got_async_packet = false;
 864
 865         if (log)
 866             log->Printf ("GDBRemoteCommunicationClient::%s () WaitForPacket(%s)", __FUNCTION__, continue_packet.c_str());
 867
 868         if (WaitForPacketWithTimeoutMicroSecondsNoLock(response, UINT32_MAX) == PacketResult::Success)
 869         {
 870             if (response.Empty())
 871                 state = eStateInvalid;
 872             else
 873             {
 874                 const char stop_type = response.GetChar();
 875                 if (log)
 876                     log->Printf ("GDBRemoteCommunicationClient::%s () got packet: %s", __FUNCTION__, response.GetStringRef().c_str());
 877                 switch (stop_type)
 878                 {
 879                 case 'T':
 880                 case 'S':
 881                     {
 882                         if (process->GetStopID() == 0)
 883                         {
 884                             if (process->GetID() == LLDB_INVALID_PROCESS_ID)
 885                             {
 886                                 lldb::pid_t pid = GetCurrentProcessID ();
 887                                 if (pid != LLDB_INVALID_PROCESS_ID)
 888                                     process->SetID (pid);
 889                             }
 890                             process->BuildDynamicRegisterInfo (true);
 891                         }
 892
 893                         // Privately notify any internal threads that we have stopped
 894                         // in case we wanted to interrupt our process, yet we might
 895                         // send a packet and continue without returning control to the
 896                         // user.
 897                         m_private_is_running.SetValue (false, eBroadcastAlways);
 898
 899                         const uint8_t signo = response.GetHexU8 (UINT8_MAX);
 900
 901                         bool continue_after_async = m_async_signal != -1 || m_async_packet_predicate.GetValue();
 902                         if (continue_after_async || m_interrupt_sent)
 903                         {
 904                             // We sent an interrupt packet to stop the inferior process
 905                             // for an async signal or to send an async packet while running
 906                             // but we might have been single stepping and received the
 907                             // stop packet for the step instead of for the interrupt packet.
 908                             // Typically when an interrupt is sent a SIGINT or SIGSTOP
 909                             // is used, so if we get anything else, we need to try and
 910                             // get another stop reply packet that may have been sent
 911                             // due to sending the interrupt when the target is stopped
 912                             // which will just re-send a copy of the last stop reply
 913                             // packet. If we don't do this, then the reply for our
 914                             // async packet will be the repeat stop reply packet and cause
 915                             // a lot of trouble for us!
 916                             if (signo != SIGINT && signo != SIGSTOP)
 917                             {
 918                                 continue_after_async = false;
 919
 920                                 // We didn't get a a SIGINT or SIGSTOP, so try for a
 921                                 // very brief time (1 ms) to get another stop reply
 922                                 // packet to make sure it doesn't get in the way
 923                                 StringExtractorGDBRemote extra_stop_reply_packet;
 924                                 uint32_t timeout_usec = 1000;
 925                                 if (WaitForPacketWithTimeoutMicroSecondsNoLock (extra_stop_reply_packet, timeout_usec) == PacketResult::Success)
 926                                 {
 927                                     switch (extra_stop_reply_packet.GetChar())
 928                                     {
 929                                     case 'T':
 930                                     case 'S':
 931                                         // We did get an extra stop reply, which means
 932                                         // our interrupt didn't stop the target so we
 933                                         // shouldn't continue after the async signal
 934                                         // or packet is sent...
 935                                         continue_after_async = false;
 936                                         break;
 937                                     }
 938                                 }
 939                             }
 940                         }
 941
 942                         if (m_async_signal != -1)
 943                         {
 944                             if (log)
 945                                 log->Printf ("async: send signo = %s", Host::GetSignalAsCString (m_async_signal));
 946
 947                             // Save off the async signal we are supposed to send
 948                             const int async_signal = m_async_signal;
 949                             // Clear the async signal member so we don't end up
 950                             // sending the signal multiple times...
 951                             m_async_signal = -1;
 952                             // Check which signal we stopped with
 953                             if (signo == async_signal)
 954                             {
 955                                 if (log)
 956                                     log->Printf ("async: stopped with signal %s, we are done running", Host::GetSignalAsCString (signo));
 957
 958                                 // We already stopped with a signal that we wanted
 959                                 // to stop with, so we are done
 960                             }
 961                             else
 962                             {
 963                                 // We stopped with a different signal that the one
 964                                 // we wanted to stop with, so now we must resume
 965                                 // with the signal we want
 966                                 char signal_packet[32];
 967                                 int signal_packet_len = 0;
 968                                 signal_packet_len = ::snprintf (signal_packet,
 969                                                                 sizeof (signal_packet),
 970                                                                 "C%2.2x",
 971                                                                 async_signal);
 972
 973                                 if (log)
 974                                     log->Printf ("async: stopped with signal %s, resume with %s",
 975                                                        Host::GetSignalAsCString (signo),
 976                                                        Host::GetSignalAsCString (async_signal));
 977
 978                                 // Set the continue packet to resume even if the
 979                                 // interrupt didn't cause our stop (ignore continue_after_async)
 980                                 continue_packet.assign(signal_packet, signal_packet_len);
 981                                 continue;
 982                             }
 983                         }
 984                         else if (m_async_packet_predicate.GetValue())
 985                         {
 986                             Log * packet_log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PACKETS));
 987
 988                             // We are supposed to send an asynchronous packet while
 989                             // we are running.
 990                             m_async_response.Clear();
 991                             if (m_async_packet.empty())
 992                             {
 993                                 m_async_result = PacketResult::ErrorSendFailed;
 994                                 if (packet_log)
 995                                     packet_log->Printf ("async: error: empty async packet");
 996
 997                             }
 998                             else
 999                             {
1000                                 if (packet_log)
1001                                     packet_log->Printf ("async: sending packet");
1002
1003                                 m_async_result = SendPacketAndWaitForResponse (&m_async_packet[0],
1004                                                                                m_async_packet.size(),
1005                                                                                m_async_response,
1006                                                                                false);
1007                             }
1008                             // Let the other thread that was trying to send the async
1009                             // packet know that the packet has been sent and response is
1010                             // ready...
1011                             m_async_packet_predicate.SetValue(false, eBroadcastAlways);
1012
1013                             if (packet_log)
1014                                 packet_log->Printf ("async: sent packet, continue_after_async = %i", continue_after_async);
1015
1016                             // Set the continue packet to resume if our interrupt
1017                             // for the async packet did cause the stop
1018                             if (continue_after_async)
1019                             {
1020                                 // Reverting this for now as it is causing deadlocks
1021                                 // in programs (<rdar://problem/11529853>). In the future
1022                                 // we should check our thread list and "do the right thing"
1023                                 // for new threads that show up while we stop and run async
1024                                 // packets. Setting the packet to 'c' to continue all threads
1025                                 // is the right thing to do 99.99% of the time because if a
1026                                 // thread was single stepping, and we sent an interrupt, we
1027                                 // will notice above that we didn't stop due to an interrupt
1028                                 // but stopped due to stepping and we would _not_ continue.
1029                                 continue_packet.assign (1, 'c');
1030                                 continue;
1031                             }
1032                         }
1033                         // Stop with signal and thread info
1034                         state = eStateStopped;
1035                     }
1036                     break;
1037
1038                 case 'W':
1039                 case 'X':
1040                     // process exited
1041                     state = eStateExited;
1042                     break;
1043
1044                 case 'O':
1045                     // STDOUT
1046                     {
1047                         got_async_packet = true;
1048                         std::string inferior_stdout;
1049                         inferior_stdout.reserve(response.GetBytesLeft () / 2);
1050                         char ch;
1051                         while ((ch = response.GetHexU8()) != '\0')
1052                             inferior_stdout.append(1, ch);
1053                         process->AppendSTDOUT (inferior_stdout.c_str(), inferior_stdout.size());
1054                     }
1055                     break;
1056
1057                 case 'A':
1058                     // Async miscellaneous reply. Right now, only profile data is coming through this channel.
1059                     {
1060                         got_async_packet = true;
1061                         std::string input = response.GetStringRef().substr(1); // '1' to move beyond 'A'
1062                         if (m_partial_profile_data.length() > 0)
1063                         {
1064                             m_partial_profile_data.append(input);
1065                             input = m_partial_profile_data;
1066                             m_partial_profile_data.clear();
1067                         }
1068
1069                         size_t found, pos = 0, len = input.length();
1070                         while ((found = input.find(end_delimiter, pos)) != std::string::npos)
1071                         {
1072                             StringExtractorGDBRemote profileDataExtractor(input.substr(pos, found).c_str());
1073                             std::string profile_data = HarmonizeThreadIdsForProfileData(process, profileDataExtractor);
1074                             process->BroadcastAsyncProfileData (profile_data);
1075
1076                             pos = found + end_delimiter_len;
1077                         }
1078
1079                         if (pos < len)
1080                         {
1081                             // Last incomplete chunk.
1082                             m_partial_profile_data = input.substr(pos);
1083                         }
1084                     }
1085                     break;
1086
1087                 case 'E':
1088                     // ERROR
1089                     state = eStateInvalid;
1090                     break;
1091
1092                 default:
1093                     if (log)
1094                         log->Printf ("GDBRemoteCommunicationClient::%s () unrecognized async packet", __FUNCTION__);
1095                     state = eStateInvalid;
1096                     break;
1097                 }
1098             }
1099         }
1100         else
1101         {
1102             if (log)
1103                 log->Printf ("GDBRemoteCommunicationClient::%s () WaitForPacket(...) => false", __FUNCTION__);
1104             state = eStateInvalid;
1105         }
1106     }
1107     if (log)
1108         log->Printf ("GDBRemoteCommunicationClient::%s () => %s", __FUNCTION__, StateAsCString(state));
1109     response.SetFilePos(0);
1110     m_private_is_running.SetValue (false, eBroadcastAlways);
1111     m_public_is_running.SetValue (false, eBroadcastAlways);
1112     return state;
1113 }
1114
1115 bool
1116 GDBRemoteCommunicationClient::SendAsyncSignal (int signo)
1117 {
1118     Mutex::Locker async_locker (m_async_mutex);
1119     m_async_signal = signo;
1120     bool timed_out = false;
1121     Mutex::Locker locker;
1122     if (SendInterrupt (locker, 1, timed_out))
1123         return true;
1124     m_async_signal = -1;
1125     return false;
1126 }
1127
1128 // This function takes a mutex locker as a parameter in case the GetSequenceMutex
1129 // actually succeeds. If it doesn't succeed in acquiring the sequence mutex
1130 // (the expected result), then it will send the halt packet. If it does succeed
1131 // then the caller that requested the interrupt will want to keep the sequence
1132 // locked down so that no one else can send packets while the caller has control.
1133 // This function usually gets called when we are running and need to stop the
1134 // target. It can also be used when we are running and we need to do something
1135 // else (like read/write memory), so we need to interrupt the running process
1136 // (gdb remote protocol requires this), and do what we need to do, then resume.
1137
1138 bool
1139 GDBRemoteCommunicationClient::SendInterrupt
1140 (
1141     Mutex::Locker& locker,
1142     uint32_t seconds_to_wait_for_stop,
1143     bool &timed_out
1144 )
1145 {
1146     timed_out = false;
1147     Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_PROCESS | GDBR_LOG_PACKETS));
1148
1149     if (IsRunning())
1150     {
1151         // Only send an interrupt if our debugserver is running...
1152         if (GetSequenceMutex (locker))
1153         {
1154             if (log)
1155                 log->Printf ("SendInterrupt () - got sequence mutex without having to interrupt");
1156         }
1157         else
1158         {
1159             // Someone has the mutex locked waiting for a response or for the
1160             // inferior to stop, so send the interrupt on the down low...
1161             char ctrl_c = '\x03';
1162             ConnectionStatus status = eConnectionStatusSuccess;
1163             size_t bytes_written = Write (&ctrl_c, 1, status, NULL);
1164             if (log)
1165                 log->PutCString("send packet: \\x03");
1166             if (bytes_written > 0)
1167             {
1168                 m_interrupt_sent = true;
1169                 if (seconds_to_wait_for_stop)
1170                 {
1171                     TimeValue timeout;
1172                     if (seconds_to_wait_for_stop)
1173                     {
1174                         timeout = TimeValue::Now();
1175                         timeout.OffsetWithSeconds (seconds_to_wait_for_stop);
1176                     }
1177                     if (m_private_is_running.WaitForValueEqualTo (false, &timeout, &timed_out))
1178                     {
1179                         if (log)
1180                             log->PutCString ("SendInterrupt () - sent interrupt, private state stopped");
1181                         return true;
1182                     }
1183                     else
1184                     {
1185                         if (log)
1186                             log->Printf ("SendInterrupt () - sent interrupt, timed out wating for async thread resume");
1187                     }
1188                 }
1189                 else
1190                 {
1191                     if (log)
1192                         log->Printf ("SendInterrupt () - sent interrupt, not waiting for stop...");
1193                     return true;
1194                 }
1195             }
1196             else
1197             {
1198                 if (log)
1199                     log->Printf ("SendInterrupt () - failed to write interrupt");
1200             }
1201             return false;
1202         }
1203     }
1204     else
1205     {
1206         if (log)
1207             log->Printf ("SendInterrupt () - not running");
1208     }
1209     return true;
1210 }
1211
1212 lldb::pid_t
1213 GDBRemoteCommunicationClient::GetCurrentProcessID ()
1214 {
1215     if (m_curr_pid_is_valid == eLazyBoolYes)
1216         return m_curr_pid;
1217
1218     // First try to retrieve the pid via the qProcessInfo request.
1219     GetCurrentProcessInfo ();
1220     if (m_curr_pid_is_valid == eLazyBoolYes)
1221     {
1222         // We really got it.
1223         return m_curr_pid;
1224     }
1225     else
1226     {
1227         // If we don't get a response for qProcessInfo, check if $qC gives us a result.
1228         // $qC only returns a real process id on older debugserver and lldb-platform stubs.
1229         // The gdb remote protocol documents $qC as returning the thread id, which newer
1230         // debugserver and lldb-gdbserver stubs return correctly.
1231         StringExtractorGDBRemote response;
1232         if (SendPacketAndWaitForResponse("qC", strlen("qC"), response, false) == PacketResult::Success)
1233         {
1234             if (response.GetChar() == 'Q')
1235             {
1236                 if (response.GetChar() == 'C')
1237                 {
1238                     m_curr_pid = response.GetHexMaxU32 (false, LLDB_INVALID_PROCESS_ID);
1239                     if (m_curr_pid != LLDB_INVALID_PROCESS_ID)
1240                     {
1241                         m_curr_pid_is_valid = eLazyBoolYes;
1242                         return m_curr_pid;
1243                     }
1244                 }
1245             }
1246         }
1247     }
1248
1249     return LLDB_INVALID_PROCESS_ID;
1250 }
1251
1252 bool
1253 GDBRemoteCommunicationClient::GetLaunchSuccess (std::string &error_str)
1254 {
1255     error_str.clear();
1256     StringExtractorGDBRemote response;
1257     if (SendPacketAndWaitForResponse("qLaunchSuccess", strlen("qLaunchSuccess"), response, false) == PacketResult::Success)
1258     {
1259         if (response.IsOKResponse())
1260             return true;
1261         if (response.GetChar() == 'E')
1262         {
1263             // A string the describes what failed when launching...
1264             error_str = response.GetStringRef().substr(1);
1265         }
1266         else
1267         {
1268             error_str.assign ("unknown error occurred launching process");
1269         }
1270     }
1271     else
1272     {
1273         error_str.assign ("timed out waiting for app to launch");
1274     }
1275     return false;
1276 }
1277
1278 int
1279 GDBRemoteCommunicationClient::SendArgumentsPacket (const ProcessLaunchInfo &launch_info)
1280 {
1281     // Since we don't get the send argv0 separate from the executable path, we need to
1282     // make sure to use the actual executable path found in the launch_info...
1283     std::vector<const char *> argv;
1284     FileSpec exe_file = launch_info.GetExecutableFile();
1285     std::string exe_path;
1286     const char *arg = NULL;
1287     const Args &launch_args = launch_info.GetArguments();
1288     if (exe_file)
1289         exe_path = exe_file.GetPath();
1290     else
1291     {
1292         arg = launch_args.GetArgumentAtIndex(0);
1293         if (arg)
1294             exe_path = arg;
1295     }
1296     if (!exe_path.empty())
1297     {
1298         argv.push_back(exe_path.c_str());
1299         for (uint32_t i=1; (arg = launch_args.GetArgumentAtIndex(i)) != NULL; ++i)
1300         {
1301             if (arg)
1302                 argv.push_back(arg);
1303         }
1304     }
1305     if (!argv.empty())
1306     {
1307         StreamString packet;
1308         packet.PutChar('A');
1309         for (size_t i = 0, n = argv.size(); i < n; ++i)
1310         {
1311             arg = argv[i];
1312             const int arg_len = strlen(arg);
1313             if (i > 0)
1314                 packet.PutChar(',');
1315             packet.Printf("%i,%i,", arg_len * 2, (int)i);
1316             packet.PutBytesAsRawHex8 (arg, arg_len);
1317         }
1318
1319         StringExtractorGDBRemote response;
1320         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
1321         {
1322             if (response.IsOKResponse())
1323                 return 0;
1324             uint8_t error = response.GetError();
1325             if (error)
1326                 return error;
1327         }
1328     }
1329     return -1;
1330 }
1331
1332 int
1333 GDBRemoteCommunicationClient::SendEnvironmentPacket (char const *name_equal_value)
1334 {
1335     if (name_equal_value && name_equal_value[0])
1336     {
1337         StreamString packet;
1338         bool send_hex_encoding = false;
1339         for (const char *p = name_equal_value; *p != '\0' && send_hex_encoding == false; ++p)
1340         {
1341             if (isprint(*p))
1342             {
1343                 switch (*p)
1344                 {
1345                     case '$':
1346                     case '#':
1347                         send_hex_encoding = true;
1348                         break;
1349                     default:
1350                         break;
1351                 }
1352             }
1353             else
1354             {
1355                 // We have non printable characters, lets hex encode this...
1356                 send_hex_encoding = true;
1357             }
1358         }
1359
1360         StringExtractorGDBRemote response;
1361         if (send_hex_encoding)
1362         {
1363             if (m_supports_QEnvironmentHexEncoded)
1364             {
1365                 packet.PutCString("QEnvironmentHexEncoded:");
1366                 packet.PutBytesAsRawHex8 (name_equal_value, strlen(name_equal_value));
1367                 if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
1368                 {
1369                     if (response.IsOKResponse())
1370                         return 0;
1371                     uint8_t error = response.GetError();
1372                     if (error)
1373                         return error;
1374                     if (response.IsUnsupportedResponse())
1375                         m_supports_QEnvironmentHexEncoded = false;
1376                 }
1377             }
1378
1379         }
1380         else if (m_supports_QEnvironment)
1381         {
1382             packet.Printf("QEnvironment:%s", name_equal_value);
1383             if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
1384             {
1385                 if (response.IsOKResponse())
1386                     return 0;
1387                 uint8_t error = response.GetError();
1388                 if (error)
1389                     return error;
1390                 if (response.IsUnsupportedResponse())
1391                     m_supports_QEnvironment = false;
1392             }
1393         }
1394     }
1395     return -1;
1396 }
1397
1398 int
1399 GDBRemoteCommunicationClient::SendLaunchArchPacket (char const *arch)
1400 {
1401     if (arch && arch[0])
1402     {
1403         StreamString packet;
1404         packet.Printf("QLaunchArch:%s", arch);
1405         StringExtractorGDBRemote response;
1406         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
1407         {
1408             if (response.IsOKResponse())
1409                 return 0;
1410             uint8_t error = response.GetError();
1411             if (error)
1412                 return error;
1413         }
1414     }
1415     return -1;
1416 }
1417
1418 int
1419 GDBRemoteCommunicationClient::SendLaunchEventDataPacket (char const *data, bool *was_supported)
1420 {
1421     if (data && *data != '\0')
1422     {
1423         StreamString packet;
1424         packet.Printf("QSetProcessEvent:%s", data);
1425         StringExtractorGDBRemote response;
1426         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
1427         {
1428             if (response.IsOKResponse())
1429             {
1430                 if (was_supported)
1431                     *was_supported = true;
1432                 return 0;
1433             }
1434             else if (response.IsUnsupportedResponse())
1435             {
1436                 if (was_supported)
1437                     *was_supported = false;
1438                 return -1;
1439             }
1440             else
1441             {
1442                 uint8_t error = response.GetError();
1443                 if (was_supported)
1444                     *was_supported = true;
1445                 if (error)
1446                     return error;
1447             }
1448         }
1449     }
1450     return -1;
1451 }
1452
1453 bool
1454 GDBRemoteCommunicationClient::GetOSVersion (uint32_t &major,
1455                                             uint32_t &minor,
1456                                             uint32_t &update)
1457 {
1458     if (GetHostInfo ())
1459     {
1460         if (m_os_version_major != UINT32_MAX)
1461         {
1462             major = m_os_version_major;
1463             minor = m_os_version_minor;
1464             update = m_os_version_update;
1465             return true;
1466         }
1467     }
1468     return false;
1469 }
1470
1471 bool
1472 GDBRemoteCommunicationClient::GetOSBuildString (std::string &s)
1473 {
1474     if (GetHostInfo ())
1475     {
1476         if (!m_os_build.empty())
1477         {
1478             s = m_os_build;
1479             return true;
1480         }
1481     }
1482     s.clear();
1483     return false;
1484 }
1485
1486
1487 bool
1488 GDBRemoteCommunicationClient::GetOSKernelDescription (std::string &s)
1489 {
1490     if (GetHostInfo ())
1491     {
1492         if (!m_os_kernel.empty())
1493         {
1494             s = m_os_kernel;
1495             return true;
1496         }
1497     }
1498     s.clear();
1499     return false;
1500 }
1501
1502 bool
1503 GDBRemoteCommunicationClient::GetHostname (std::string &s)
1504 {
1505     if (GetHostInfo ())
1506     {
1507         if (!m_hostname.empty())
1508         {
1509             s = m_hostname;
1510             return true;
1511         }
1512     }
1513     s.clear();
1514     return false;
1515 }
1516
1517 ArchSpec
1518 GDBRemoteCommunicationClient::GetSystemArchitecture ()
1519 {
1520     if (GetHostInfo ())
1521         return m_host_arch;
1522     return ArchSpec();
1523 }
1524
1525 const lldb_private::ArchSpec &
1526 GDBRemoteCommunicationClient::GetProcessArchitecture ()
1527 {
1528     if (m_qProcessInfo_is_valid == eLazyBoolCalculate)
1529         GetCurrentProcessInfo ();
1530     return m_process_arch;
1531 }
1532
1533 bool
1534 GDBRemoteCommunicationClient::GetGDBServerVersion()
1535 {
1536     if (m_qGDBServerVersion_is_valid == eLazyBoolCalculate)
1537     {
1538         m_gdb_server_name.clear();
1539         m_gdb_server_version = 0;
1540         m_qGDBServerVersion_is_valid = eLazyBoolNo;
1541
1542         StringExtractorGDBRemote response;
1543         if (SendPacketAndWaitForResponse ("qGDBServerVersion", response, false) == PacketResult::Success)
1544         {
1545             if (response.IsNormalResponse())
1546             {
1547                 std::string name;
1548                 std::string value;
1549                 bool success = false;
1550                 while (response.GetNameColonValue(name, value))
1551                 {
1552                     if (name.compare("name") == 0)
1553                     {
1554                         success = true;
1555                         m_gdb_server_name.swap(value);
1556                     }
1557                     else if (name.compare("version") == 0)
1558                     {
1559                         size_t dot_pos = value.find('.');
1560                         if (dot_pos != std::string::npos)
1561                             value[dot_pos] = '\0';
1562                         const uint32_t version = Args::StringToUInt32(value.c_str(), UINT32_MAX, 0);
1563                         if (version != UINT32_MAX)
1564                         {
1565                             success = true;
1566                             m_gdb_server_version = version;
1567                         }
1568                     }
1569                 }
1570                 if (success)
1571                     m_qGDBServerVersion_is_valid = eLazyBoolYes;
1572             }
1573         }
1574     }
1575     return m_qGDBServerVersion_is_valid == eLazyBoolYes;
1576 }
1577
1578 const char *
1579 GDBRemoteCommunicationClient::GetGDBServerProgramName()
1580 {
1581     if (GetGDBServerVersion())
1582     {
1583         if (!m_gdb_server_name.empty())
1584             return m_gdb_server_name.c_str();
1585     }
1586     return NULL;
1587 }
1588
1589 uint32_t
1590 GDBRemoteCommunicationClient::GetGDBServerProgramVersion()
1591 {
1592     if (GetGDBServerVersion())
1593         return m_gdb_server_version;
1594     return 0;
1595 }
1596
1597 bool
1598 GDBRemoteCommunicationClient::GetHostInfo (bool force)
1599 {
1600     Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_PROCESS));
1601
1602     if (force || m_qHostInfo_is_valid == eLazyBoolCalculate)
1603     {
1604         m_qHostInfo_is_valid = eLazyBoolNo;
1605         StringExtractorGDBRemote response;
1606         if (SendPacketAndWaitForResponse ("qHostInfo", response, false) == PacketResult::Success)
1607         {
1608             if (response.IsNormalResponse())
1609             {
1610                 std::string name;
1611                 std::string value;
1612                 uint32_t cpu = LLDB_INVALID_CPUTYPE;
1613                 uint32_t sub = 0;
1614                 std::string arch_name;
1615                 std::string os_name;
1616                 std::string vendor_name;
1617                 std::string triple;
1618                 std::string distribution_id;
1619                 uint32_t pointer_byte_size = 0;
1620                 StringExtractor extractor;
1621                 ByteOrder byte_order = eByteOrderInvalid;
1622                 uint32_t num_keys_decoded = 0;
1623                 while (response.GetNameColonValue(name, value))
1624                 {
1625                     if (name.compare("cputype") == 0)
1626                     {
1627                         // exception type in big endian hex
1628                         cpu = Args::StringToUInt32 (value.c_str(), LLDB_INVALID_CPUTYPE, 0);
1629                         if (cpu != LLDB_INVALID_CPUTYPE)
1630                             ++num_keys_decoded;
1631                     }
1632                     else if (name.compare("cpusubtype") == 0)
1633                     {
1634                         // exception count in big endian hex
1635                         sub = Args::StringToUInt32 (value.c_str(), 0, 0);
1636                         if (sub != 0)
1637                             ++num_keys_decoded;
1638                     }
1639                     else if (name.compare("arch") == 0)
1640                     {
1641                         arch_name.swap (value);
1642                         ++num_keys_decoded;
1643                     }
1644                     else if (name.compare("triple") == 0)
1645                     {
1646                         extractor.GetStringRef ().swap (value);
1647                         extractor.SetFilePos(0);
1648                         extractor.GetHexByteString (triple);
1649                         ++num_keys_decoded;
1650                     }
1651                     else if (name.compare ("distribution_id") == 0)
1652                     {
1653                         extractor.GetStringRef ().swap (value);
1654                         extractor.SetFilePos (0);
1655                         extractor.GetHexByteString (distribution_id);
1656                         ++num_keys_decoded;
1657                     }
1658                     else if (name.compare("os_build") == 0)
1659                     {
1660                         extractor.GetStringRef().swap(value);
1661                         extractor.SetFilePos(0);
1662                         extractor.GetHexByteString (m_os_build);
1663                         ++num_keys_decoded;
1664                     }
1665                     else if (name.compare("hostname") == 0)
1666                     {
1667                         extractor.GetStringRef().swap(value);
1668                         extractor.SetFilePos(0);
1669                         extractor.GetHexByteString (m_hostname);
1670                         ++num_keys_decoded;
1671                     }
1672                     else if (name.compare("os_kernel") == 0)
1673                     {
1674                         extractor.GetStringRef().swap(value);
1675                         extractor.SetFilePos(0);
1676                         extractor.GetHexByteString (m_os_kernel);
1677                         ++num_keys_decoded;
1678                     }
1679                     else if (name.compare("ostype") == 0)
1680                     {
1681                         os_name.swap (value);
1682                         ++num_keys_decoded;
1683                     }
1684                     else if (name.compare("vendor") == 0)
1685                     {
1686                         vendor_name.swap(value);
1687                         ++num_keys_decoded;
1688                     }
1689                     else if (name.compare("endian") == 0)
1690                     {
1691                         ++num_keys_decoded;
1692                         if (value.compare("little") == 0)
1693                             byte_order = eByteOrderLittle;
1694                         else if (value.compare("big") == 0)
1695                             byte_order = eByteOrderBig;
1696                         else if (value.compare("pdp") == 0)
1697                             byte_order = eByteOrderPDP;
1698                         else
1699                             --num_keys_decoded;
1700                     }
1701                     else if (name.compare("ptrsize") == 0)
1702                     {
1703                         pointer_byte_size = Args::StringToUInt32 (value.c_str(), 0, 0);
1704                         if (pointer_byte_size != 0)
1705                             ++num_keys_decoded;
1706                     }
1707                     else if (name.compare("os_version") == 0)
1708                     {
1709                         Args::StringToVersion (value.c_str(),
1710                                                m_os_version_major,
1711                                                m_os_version_minor,
1712                                                m_os_version_update);
1713                         if (m_os_version_major != UINT32_MAX)
1714                             ++num_keys_decoded;
1715                     }
1716                     else if (name.compare("watchpoint_exceptions_received") == 0)
1717                     {
1718                         ++num_keys_decoded;
1719                         if (strcmp(value.c_str(),"before") == 0)
1720                             m_watchpoints_trigger_after_instruction = eLazyBoolNo;
1721                         else if (strcmp(value.c_str(),"after") == 0)
1722                             m_watchpoints_trigger_after_instruction = eLazyBoolYes;
1723                         else
1724                             --num_keys_decoded;
1725                     }
1726                     else if (name.compare("default_packet_timeout") == 0)
1727                     {
1728                         m_default_packet_timeout = Args::StringToUInt32(value.c_str(), 0);
1729                         if (m_default_packet_timeout > 0)
1730                         {
1731                             SetPacketTimeout(m_default_packet_timeout);
1732                             ++num_keys_decoded;
1733                         }
1734                     }
1735
1736                 }
1737
1738                 if (num_keys_decoded > 0)
1739                     m_qHostInfo_is_valid = eLazyBoolYes;
1740
1741                 if (triple.empty())
1742                 {
1743                     if (arch_name.empty())
1744                     {
1745                         if (cpu != LLDB_INVALID_CPUTYPE)
1746                         {
1747                             m_host_arch.SetArchitecture (eArchTypeMachO, cpu, sub);
1748                             if (pointer_byte_size)
1749                             {
1750                                 assert (pointer_byte_size == m_host_arch.GetAddressByteSize());
1751                             }
1752                             if (byte_order != eByteOrderInvalid)
1753                             {
1754                                 assert (byte_order == m_host_arch.GetByteOrder());
1755                             }
1756
1757                             if (!os_name.empty() && vendor_name.compare("apple") == 0 && os_name.find("darwin") == 0)
1758                             {
1759                                 switch (m_host_arch.GetMachine())
1760                                 {
1761                                 case llvm::Triple::aarch64:
1762                                 case llvm::Triple::arm:
1763                                 case llvm::Triple::thumb:
1764                                     os_name = "ios";
1765                                     break;
1766                                 default:
1767                                     os_name = "macosx";
1768                                     break;
1769                                 }
1770                             }
1771                             if (!vendor_name.empty())
1772                                 m_host_arch.GetTriple().setVendorName (llvm::StringRef (vendor_name));
1773                             if (!os_name.empty())
1774                                 m_host_arch.GetTriple().setOSName (llvm::StringRef (os_name));
1775
1776                         }
1777                     }
1778                     else
1779                     {
1780                         std::string triple;
1781                         triple += arch_name;
1782                         if (!vendor_name.empty() || !os_name.empty())
1783                         {
1784                             triple += '-';
1785                             if (vendor_name.empty())
1786                                 triple += "unknown";
1787                             else
1788                                 triple += vendor_name;
1789                             triple += '-';
1790                             if (os_name.empty())
1791                                 triple += "unknown";
1792                             else
1793                                 triple += os_name;
1794                         }
1795                         m_host_arch.SetTriple (triple.c_str());
1796
1797                         llvm::Triple &host_triple = m_host_arch.GetTriple();
1798                         if (host_triple.getVendor() == llvm::Triple::Apple && host_triple.getOS() == llvm::Triple::Darwin)
1799                         {
1800                             switch (m_host_arch.GetMachine())
1801                             {
1802                                 case llvm::Triple::aarch64:
1803                                 case llvm::Triple::arm:
1804                                 case llvm::Triple::thumb:
1805                                     host_triple.setOS(llvm::Triple::IOS);
1806                                     break;
1807                                 default:
1808                                     host_triple.setOS(llvm::Triple::MacOSX);
1809                                     break;
1810                             }
1811                         }
1812                         if (pointer_byte_size)
1813                         {
1814                             assert (pointer_byte_size == m_host_arch.GetAddressByteSize());
1815                         }
1816                         if (byte_order != eByteOrderInvalid)
1817                         {
1818                             assert (byte_order == m_host_arch.GetByteOrder());
1819                         }
1820
1821                     }
1822                 }
1823                 else
1824                 {
1825                     m_host_arch.SetTriple (triple.c_str());
1826                     if (pointer_byte_size)
1827                     {
1828                         assert (pointer_byte_size == m_host_arch.GetAddressByteSize());
1829                     }
1830                     if (byte_order != eByteOrderInvalid)
1831                     {
1832                         assert (byte_order == m_host_arch.GetByteOrder());
1833                     }
1834
1835                     if (log)
1836                         log->Printf ("GDBRemoteCommunicationClient::%s parsed host architecture as %s, triple as %s from triple text %s", __FUNCTION__, m_host_arch.GetArchitectureName () ? m_host_arch.GetArchitectureName () : "<null-arch-name>", m_host_arch.GetTriple ().getTriple ().c_str(), triple.c_str ());
1837                 }
1838                 if (!distribution_id.empty ())
1839                     m_host_arch.SetDistributionId (distribution_id.c_str ());
1840             }
1841         }
1842     }
1843     return m_qHostInfo_is_valid == eLazyBoolYes;
1844 }
1845
1846 int
1847 GDBRemoteCommunicationClient::SendAttach
1848 (
1849     lldb::pid_t pid,
1850     StringExtractorGDBRemote& response
1851 )
1852 {
1853     if (pid != LLDB_INVALID_PROCESS_ID)
1854     {
1855         char packet[64];
1856         const int packet_len = ::snprintf (packet, sizeof(packet), "vAttach;%" PRIx64, pid);
1857         assert (packet_len < (int)sizeof(packet));
1858         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
1859         {
1860             if (response.IsErrorResponse())
1861                 return response.GetError();
1862             return 0;
1863         }
1864     }
1865     return -1;
1866 }
1867
1868 const lldb_private::ArchSpec &
1869 GDBRemoteCommunicationClient::GetHostArchitecture ()
1870 {
1871     if (m_qHostInfo_is_valid == eLazyBoolCalculate)
1872         GetHostInfo ();
1873     return m_host_arch;
1874 }
1875
1876 uint32_t
1877 GDBRemoteCommunicationClient::GetHostDefaultPacketTimeout ()
1878 {
1879     if (m_qHostInfo_is_valid == eLazyBoolCalculate)
1880         GetHostInfo ();
1881     return m_default_packet_timeout;
1882 }
1883
1884 addr_t
1885 GDBRemoteCommunicationClient::AllocateMemory (size_t size, uint32_t permissions)
1886 {
1887     if (m_supports_alloc_dealloc_memory != eLazyBoolNo)
1888     {
1889         m_supports_alloc_dealloc_memory = eLazyBoolYes;
1890         char packet[64];
1891         const int packet_len = ::snprintf (packet, sizeof(packet), "_M%" PRIx64 ",%s%s%s",
1892                                            (uint64_t)size,
1893                                            permissions & lldb::ePermissionsReadable ? "r" : "",
1894                                            permissions & lldb::ePermissionsWritable ? "w" : "",
1895                                            permissions & lldb::ePermissionsExecutable ? "x" : "");
1896         assert (packet_len < (int)sizeof(packet));
1897         StringExtractorGDBRemote response;
1898         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
1899         {
1900             if (response.IsUnsupportedResponse())
1901                 m_supports_alloc_dealloc_memory = eLazyBoolNo;
1902             else if (!response.IsErrorResponse())
1903                 return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
1904         }
1905         else
1906         {
1907             m_supports_alloc_dealloc_memory = eLazyBoolNo;
1908         }
1909     }
1910     return LLDB_INVALID_ADDRESS;
1911 }
1912
1913 bool
1914 GDBRemoteCommunicationClient::DeallocateMemory (addr_t addr)
1915 {
1916     if (m_supports_alloc_dealloc_memory != eLazyBoolNo)
1917     {
1918         m_supports_alloc_dealloc_memory = eLazyBoolYes;
1919         char packet[64];
1920         const int packet_len = ::snprintf(packet, sizeof(packet), "_m%" PRIx64, (uint64_t)addr);
1921         assert (packet_len < (int)sizeof(packet));
1922         StringExtractorGDBRemote response;
1923         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
1924         {
1925             if (response.IsUnsupportedResponse())
1926                 m_supports_alloc_dealloc_memory = eLazyBoolNo;
1927             else if (response.IsOKResponse())
1928                 return true;
1929         }
1930         else
1931         {
1932             m_supports_alloc_dealloc_memory = eLazyBoolNo;
1933         }
1934     }
1935     return false;
1936 }
1937
1938 Error
1939 GDBRemoteCommunicationClient::Detach (bool keep_stopped)
1940 {
1941     Error error;
1942
1943     if (keep_stopped)
1944     {
1945         if (m_supports_detach_stay_stopped == eLazyBoolCalculate)
1946         {
1947             char packet[64];
1948             const int packet_len = ::snprintf(packet, sizeof(packet), "qSupportsDetachAndStayStopped:");
1949             assert (packet_len < (int)sizeof(packet));
1950             StringExtractorGDBRemote response;
1951             if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
1952             {
1953                 m_supports_detach_stay_stopped = eLazyBoolYes;
1954             }
1955             else
1956             {
1957                 m_supports_detach_stay_stopped = eLazyBoolNo;
1958             }
1959         }
1960
1961         if (m_supports_detach_stay_stopped == eLazyBoolNo)
1962         {
1963             error.SetErrorString("Stays stopped not supported by this target.");
1964             return error;
1965         }
1966         else
1967         {
1968             StringExtractorGDBRemote response;
1969             PacketResult packet_result = SendPacketAndWaitForResponse ("D1", 1, response, false);
1970             if (packet_result != PacketResult::Success)
1971                 error.SetErrorString ("Sending extended disconnect packet failed.");
1972         }
1973     }
1974     else
1975     {
1976         StringExtractorGDBRemote response;
1977         PacketResult packet_result = SendPacketAndWaitForResponse ("D", 1, response, false);
1978         if (packet_result != PacketResult::Success)
1979             error.SetErrorString ("Sending disconnect packet failed.");
1980     }
1981     return error;
1982 }
1983
1984 Error
1985 GDBRemoteCommunicationClient::GetMemoryRegionInfo (lldb::addr_t addr,
1986                                                   lldb_private::MemoryRegionInfo &region_info)
1987 {
1988     Error error;
1989     region_info.Clear();
1990
1991     if (m_supports_memory_region_info != eLazyBoolNo)
1992     {
1993         m_supports_memory_region_info = eLazyBoolYes;
1994         char packet[64];
1995         const int packet_len = ::snprintf(packet, sizeof(packet), "qMemoryRegionInfo:%" PRIx64, (uint64_t)addr);
1996         assert (packet_len < (int)sizeof(packet));
1997         StringExtractorGDBRemote response;
1998         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
1999         {
2000             std::string name;
2001             std::string value;
2002             addr_t addr_value;
2003             bool success = true;
2004             bool saw_permissions = false;
2005             while (success && response.GetNameColonValue(name, value))
2006             {
2007                 if (name.compare ("start") == 0)
2008                 {
2009                     addr_value = Args::StringToUInt64(value.c_str(), LLDB_INVALID_ADDRESS, 16, &success);
2010                     if (success)
2011                         region_info.GetRange().SetRangeBase(addr_value);
2012                 }
2013                 else if (name.compare ("size") == 0)
2014                 {
2015                     addr_value = Args::StringToUInt64(value.c_str(), 0, 16, &success);
2016                     if (success)
2017                         region_info.GetRange().SetByteSize (addr_value);
2018                 }
2019                 else if (name.compare ("permissions") == 0 && region_info.GetRange().IsValid())
2020                 {
2021                     saw_permissions = true;
2022                     if (region_info.GetRange().Contains (addr))
2023                     {
2024                         if (value.find('r') != std::string::npos)
2025                             region_info.SetReadable (MemoryRegionInfo::eYes);
2026                         else
2027                             region_info.SetReadable (MemoryRegionInfo::eNo);
2028
2029                         if (value.find('w') != std::string::npos)
2030                             region_info.SetWritable (MemoryRegionInfo::eYes);
2031                         else
2032                             region_info.SetWritable (MemoryRegionInfo::eNo);
2033
2034                         if (value.find('x') != std::string::npos)
2035                             region_info.SetExecutable (MemoryRegionInfo::eYes);
2036                         else
2037                             region_info.SetExecutable (MemoryRegionInfo::eNo);
2038                     }
2039                     else
2040                     {
2041                         // The reported region does not contain this address -- we're looking at an unmapped page
2042                         region_info.SetReadable (MemoryRegionInfo::eNo);
2043                         region_info.SetWritable (MemoryRegionInfo::eNo);
2044                         region_info.SetExecutable (MemoryRegionInfo::eNo);
2045                     }
2046                 }
2047                 else if (name.compare ("error") == 0)
2048                 {
2049                     StringExtractorGDBRemote name_extractor;
2050                     // Swap "value" over into "name_extractor"
2051                     name_extractor.GetStringRef().swap(value);
2052                     // Now convert the HEX bytes into a string value
2053                     name_extractor.GetHexByteString (value);
2054                     error.SetErrorString(value.c_str());
2055                 }
2056             }
2057
2058             // We got a valid address range back but no permissions -- which means this is an unmapped page
2059             if (region_info.GetRange().IsValid() && saw_permissions == false)
2060             {
2061                 region_info.SetReadable (MemoryRegionInfo::eNo);
2062                 region_info.SetWritable (MemoryRegionInfo::eNo);
2063                 region_info.SetExecutable (MemoryRegionInfo::eNo);
2064             }
2065         }
2066         else
2067         {
2068             m_supports_memory_region_info = eLazyBoolNo;
2069         }
2070     }
2071
2072     if (m_supports_memory_region_info == eLazyBoolNo)
2073     {
2074         error.SetErrorString("qMemoryRegionInfo is not supported");
2075     }
2076     if (error.Fail())
2077         region_info.Clear();
2078     return error;
2079
2080 }
2081
2082 Error
2083 GDBRemoteCommunicationClient::GetWatchpointSupportInfo (uint32_t &num)
2084 {
2085     Error error;
2086
2087     if (m_supports_watchpoint_support_info == eLazyBoolYes)
2088     {
2089         num = m_num_supported_hardware_watchpoints;
2090         return error;
2091     }
2092
2093     // Set num to 0 first.
2094     num = 0;
2095     if (m_supports_watchpoint_support_info != eLazyBoolNo)
2096     {
2097         char packet[64];
2098         const int packet_len = ::snprintf(packet, sizeof(packet), "qWatchpointSupportInfo:");
2099         assert (packet_len < (int)sizeof(packet));
2100         StringExtractorGDBRemote response;
2101         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
2102         {
2103             m_supports_watchpoint_support_info = eLazyBoolYes;
2104             std::string name;
2105             std::string value;
2106             while (response.GetNameColonValue(name, value))
2107             {
2108                 if (name.compare ("num") == 0)
2109                 {
2110                     num = Args::StringToUInt32(value.c_str(), 0, 0);
2111                     m_num_supported_hardware_watchpoints = num;
2112                 }
2113             }
2114         }
2115         else
2116         {
2117             m_supports_watchpoint_support_info = eLazyBoolNo;
2118         }
2119     }
2120
2121     if (m_supports_watchpoint_support_info == eLazyBoolNo)
2122     {
2123         error.SetErrorString("qWatchpointSupportInfo is not supported");
2124     }
2125     return error;
2126
2127 }
2128
2129 lldb_private::Error
2130 GDBRemoteCommunicationClient::GetWatchpointSupportInfo (uint32_t &num, bool& after)
2131 {
2132     Error error(GetWatchpointSupportInfo(num));
2133     if (error.Success())
2134         error = GetWatchpointsTriggerAfterInstruction(after);
2135     return error;
2136 }
2137
2138 lldb_private::Error
2139 GDBRemoteCommunicationClient::GetWatchpointsTriggerAfterInstruction (bool &after)
2140 {
2141     Error error;
2142
2143     // we assume watchpoints will happen after running the relevant opcode
2144     // and we only want to override this behavior if we have explicitly
2145     // received a qHostInfo telling us otherwise
2146     if (m_qHostInfo_is_valid != eLazyBoolYes)
2147         after = true;
2148     else
2149         after = (m_watchpoints_trigger_after_instruction != eLazyBoolNo);
2150     return error;
2151 }
2152
2153 int
2154 GDBRemoteCommunicationClient::SetSTDIN (char const *path)
2155 {
2156     if (path && path[0])
2157     {
2158         StreamString packet;
2159         packet.PutCString("QSetSTDIN:");
2160         packet.PutBytesAsRawHex8(path, strlen(path));
2161
2162         StringExtractorGDBRemote response;
2163         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
2164         {
2165             if (response.IsOKResponse())
2166                 return 0;
2167             uint8_t error = response.GetError();
2168             if (error)
2169                 return error;
2170         }
2171     }
2172     return -1;
2173 }
2174
2175 int
2176 GDBRemoteCommunicationClient::SetSTDOUT (char const *path)
2177 {
2178     if (path && path[0])
2179     {
2180         StreamString packet;
2181         packet.PutCString("QSetSTDOUT:");
2182         packet.PutBytesAsRawHex8(path, strlen(path));
2183
2184         StringExtractorGDBRemote response;
2185         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
2186         {
2187             if (response.IsOKResponse())
2188                 return 0;
2189             uint8_t error = response.GetError();
2190             if (error)
2191                 return error;
2192         }
2193     }
2194     return -1;
2195 }
2196
2197 int
2198 GDBRemoteCommunicationClient::SetSTDERR (char const *path)
2199 {
2200     if (path && path[0])
2201     {
2202         StreamString packet;
2203         packet.PutCString("QSetSTDERR:");
2204         packet.PutBytesAsRawHex8(path, strlen(path));
2205
2206         StringExtractorGDBRemote response;
2207         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
2208         {
2209             if (response.IsOKResponse())
2210                 return 0;
2211             uint8_t error = response.GetError();
2212             if (error)
2213                 return error;
2214         }
2215     }
2216     return -1;
2217 }
2218
2219 bool
2220 GDBRemoteCommunicationClient::GetWorkingDir (std::string &cwd)
2221 {
2222     StringExtractorGDBRemote response;
2223     if (SendPacketAndWaitForResponse ("qGetWorkingDir", response, false) == PacketResult::Success)
2224     {
2225         if (response.IsUnsupportedResponse())
2226             return false;
2227         if (response.IsErrorResponse())
2228             return false;
2229         response.GetHexByteString (cwd);
2230         return !cwd.empty();
2231     }
2232     return false;
2233 }
2234
2235 int
2236 GDBRemoteCommunicationClient::SetWorkingDir (char const *path)
2237 {
2238     if (path && path[0])
2239     {
2240         StreamString packet;
2241         packet.PutCString("QSetWorkingDir:");
2242         packet.PutBytesAsRawHex8(path, strlen(path));
2243
2244         StringExtractorGDBRemote response;
2245         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
2246         {
2247             if (response.IsOKResponse())
2248                 return 0;
2249             uint8_t error = response.GetError();
2250             if (error)
2251                 return error;
2252         }
2253     }
2254     return -1;
2255 }
2256
2257 int
2258 GDBRemoteCommunicationClient::SetDisableASLR (bool enable)
2259 {
2260     char packet[32];
2261     const int packet_len = ::snprintf (packet, sizeof (packet), "QSetDisableASLR:%i", enable ? 1 : 0);
2262     assert (packet_len < (int)sizeof(packet));
2263     StringExtractorGDBRemote response;
2264     if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
2265     {
2266         if (response.IsOKResponse())
2267             return 0;
2268         uint8_t error = response.GetError();
2269         if (error)
2270             return error;
2271     }
2272     return -1;
2273 }
2274
2275 int
2276 GDBRemoteCommunicationClient::SetDetachOnError (bool enable)
2277 {
2278     char packet[32];
2279     const int packet_len = ::snprintf (packet, sizeof (packet), "QSetDetachOnError:%i", enable ? 1 : 0);
2280     assert (packet_len < (int)sizeof(packet));
2281     StringExtractorGDBRemote response;
2282     if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
2283     {
2284         if (response.IsOKResponse())
2285             return 0;
2286         uint8_t error = response.GetError();
2287         if (error)
2288             return error;
2289     }
2290     return -1;
2291 }
2292
2293
2294 bool
2295 GDBRemoteCommunicationClient::DecodeProcessInfoResponse (StringExtractorGDBRemote &response, ProcessInstanceInfo &process_info)
2296 {
2297     if (response.IsNormalResponse())
2298     {
2299         std::string name;
2300         std::string value;
2301         StringExtractor extractor;
2302
2303         uint32_t cpu = LLDB_INVALID_CPUTYPE;
2304         uint32_t sub = 0;
2305         std::string vendor;
2306         std::string os_type;
2307
2308         while (response.GetNameColonValue(name, value))
2309         {
2310             if (name.compare("pid") == 0)
2311             {
2312                 process_info.SetProcessID (Args::StringToUInt32 (value.c_str(), LLDB_INVALID_PROCESS_ID, 0));
2313             }
2314             else if (name.compare("ppid") == 0)
2315             {
2316                 process_info.SetParentProcessID (Args::StringToUInt32 (value.c_str(), LLDB_INVALID_PROCESS_ID, 0));
2317             }
2318             else if (name.compare("uid") == 0)
2319             {
2320                 process_info.SetUserID (Args::StringToUInt32 (value.c_str(), UINT32_MAX, 0));
2321             }
2322             else if (name.compare("euid") == 0)
2323             {
2324                 process_info.SetEffectiveUserID (Args::StringToUInt32 (value.c_str(), UINT32_MAX, 0));
2325             }
2326             else if (name.compare("gid") == 0)
2327             {
2328                 process_info.SetGroupID (Args::StringToUInt32 (value.c_str(), UINT32_MAX, 0));
2329             }
2330             else if (name.compare("egid") == 0)
2331             {
2332                 process_info.SetEffectiveGroupID (Args::StringToUInt32 (value.c_str(), UINT32_MAX, 0));
2333             }
2334             else if (name.compare("triple") == 0)
2335             {
2336                 StringExtractor extractor;
2337                 extractor.GetStringRef().swap(value);
2338                 extractor.SetFilePos(0);
2339                 extractor.GetHexByteString (value);
2340                 process_info.GetArchitecture ().SetTriple (value.c_str());
2341             }
2342             else if (name.compare("name") == 0)
2343             {
2344                 StringExtractor extractor;
2345                 // The process name from ASCII hex bytes since we can't
2346                 // control the characters in a process name
2347                 extractor.GetStringRef().swap(value);
2348                 extractor.SetFilePos(0);
2349                 extractor.GetHexByteString (value);
2350                 process_info.GetExecutableFile().SetFile (value.c_str(), false);
2351             }
2352             else if (name.compare("cputype") == 0)
2353             {
2354                 cpu = Args::StringToUInt32 (value.c_str(), LLDB_INVALID_CPUTYPE, 16);
2355             }
2356             else if (name.compare("cpusubtype") == 0)
2357             {
2358                 sub = Args::StringToUInt32 (value.c_str(), 0, 16);
2359             }
2360             else if (name.compare("vendor") == 0)
2361             {
2362                 vendor = value;
2363             }
2364             else if (name.compare("ostype") == 0)
2365             {
2366                 os_type = value;
2367             }
2368         }
2369
2370         if (cpu != LLDB_INVALID_CPUTYPE && !vendor.empty() && !os_type.empty())
2371         {
2372             if (vendor == "apple")
2373             {
2374                 process_info.GetArchitecture().SetArchitecture (eArchTypeMachO, cpu, sub);
2375                 process_info.GetArchitecture().GetTriple().setVendorName (llvm::StringRef (vendor));
2376                 process_info.GetArchitecture().GetTriple().setOSName (llvm::StringRef (os_type));
2377             }
2378         }
2379
2380         if (process_info.GetProcessID() != LLDB_INVALID_PROCESS_ID)
2381             return true;
2382     }
2383     return false;
2384 }
2385
2386 bool
2387 GDBRemoteCommunicationClient::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info)
2388 {
2389     process_info.Clear();
2390
2391     if (m_supports_qProcessInfoPID)
2392     {
2393         char packet[32];
2394         const int packet_len = ::snprintf (packet, sizeof (packet), "qProcessInfoPID:%" PRIu64, pid);
2395         assert (packet_len < (int)sizeof(packet));
2396         StringExtractorGDBRemote response;
2397         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
2398         {
2399             return DecodeProcessInfoResponse (response, process_info);
2400         }
2401         else
2402         {
2403             m_supports_qProcessInfoPID = false;
2404             return false;
2405         }
2406     }
2407     return false;
2408 }
2409
2410 bool
2411 GDBRemoteCommunicationClient::GetCurrentProcessInfo ()
2412 {
2413     Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_PROCESS | GDBR_LOG_PACKETS));
2414
2415     if (m_qProcessInfo_is_valid == eLazyBoolYes)
2416         return true;
2417     if (m_qProcessInfo_is_valid == eLazyBoolNo)
2418         return false;
2419
2420     GetHostInfo ();
2421
2422     StringExtractorGDBRemote response;
2423     if (SendPacketAndWaitForResponse ("qProcessInfo", response, false) == PacketResult::Success)
2424     {
2425         if (response.IsNormalResponse())
2426         {
2427             std::string name;
2428             std::string value;
2429             uint32_t cpu = LLDB_INVALID_CPUTYPE;
2430             uint32_t sub = 0;
2431             std::string arch_name;
2432             std::string os_name;
2433             std::string vendor_name;
2434             std::string triple;
2435             uint32_t pointer_byte_size = 0;
2436             StringExtractor extractor;
2437             ByteOrder byte_order = eByteOrderInvalid;
2438             uint32_t num_keys_decoded = 0;
2439             lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
2440             while (response.GetNameColonValue(name, value))
2441             {
2442                 if (name.compare("cputype") == 0)
2443                 {
2444                     cpu = Args::StringToUInt32 (value.c_str(), LLDB_INVALID_CPUTYPE, 16);
2445                     if (cpu != LLDB_INVALID_CPUTYPE)
2446                         ++num_keys_decoded;
2447                 }
2448                 else if (name.compare("cpusubtype") == 0)
2449                 {
2450                     sub = Args::StringToUInt32 (value.c_str(), 0, 16);
2451                     if (sub != 0)
2452                         ++num_keys_decoded;
2453                 }
2454                 else if (name.compare("triple") == 0)
2455                 {
2456                     StringExtractor extractor;
2457                     extractor.GetStringRef().swap(value);
2458                     extractor.SetFilePos(0);
2459                     extractor.GetHexByteString (triple);
2460                     ++num_keys_decoded;
2461                 }
2462                 else if (name.compare("ostype") == 0)
2463                 {
2464                     os_name.swap (value);
2465                     ++num_keys_decoded;
2466                 }
2467                 else if (name.compare("vendor") == 0)
2468                 {
2469                     vendor_name.swap(value);
2470                     ++num_keys_decoded;
2471                 }
2472                 else if (name.compare("endian") == 0)
2473                 {
2474                     ++num_keys_decoded;
2475                     if (value.compare("little") == 0)
2476                         byte_order = eByteOrderLittle;
2477                     else if (value.compare("big") == 0)
2478                         byte_order = eByteOrderBig;
2479                     else if (value.compare("pdp") == 0)
2480                         byte_order = eByteOrderPDP;
2481                     else
2482                         --num_keys_decoded;
2483                 }
2484                 else if (name.compare("ptrsize") == 0)
2485                 {
2486                     pointer_byte_size = Args::StringToUInt32 (value.c_str(), 0, 16);
2487                     if (pointer_byte_size != 0)
2488                         ++num_keys_decoded;
2489                 }
2490                 else if (name.compare("pid") == 0)
2491                 {
2492                     pid = Args::StringToUInt64(value.c_str(), 0, 16);
2493                     if (pid != LLDB_INVALID_PROCESS_ID)
2494                         ++num_keys_decoded;
2495                 }
2496             }
2497             if (num_keys_decoded > 0)
2498                 m_qProcessInfo_is_valid = eLazyBoolYes;
2499             if (pid != LLDB_INVALID_PROCESS_ID)
2500             {
2501                 m_curr_pid_is_valid = eLazyBoolYes;
2502                 m_curr_pid = pid;
2503             }
2504
2505             // Set the ArchSpec from the triple if we have it.
2506             if (!triple.empty ())
2507             {
2508                 m_process_arch.SetTriple (triple.c_str ());
2509                 if (pointer_byte_size)
2510                 {
2511                     assert (pointer_byte_size == m_process_arch.GetAddressByteSize());
2512                 }
2513             }
2514             else if (cpu != LLDB_INVALID_CPUTYPE && !os_name.empty() && !vendor_name.empty())
2515             {
2516                 llvm::Triple triple(llvm::Twine("-") + vendor_name + "-" + os_name);
2517
2518                 assert(triple.getObjectFormat() != llvm::Triple::UnknownObjectFormat);
2519                 switch (triple.getObjectFormat()) {
2520                     case llvm::Triple::MachO:
2521                         m_process_arch.SetArchitecture (eArchTypeMachO, cpu, sub);
2522                         break;
2523                     case llvm::Triple::ELF:
2524                         m_process_arch.SetArchitecture (eArchTypeELF, cpu, sub);
2525                         break;
2526                     case llvm::Triple::COFF:
2527                         m_process_arch.SetArchitecture (eArchTypeCOFF, cpu, sub);
2528                         break;
2529                     case llvm::Triple::UnknownObjectFormat:
2530                         if (log)
2531                             log->Printf("error: failed to determine target architecture");
2532                         return false;
2533                 }
2534
2535                 if (pointer_byte_size)
2536                 {
2537                     assert (pointer_byte_size == m_process_arch.GetAddressByteSize());
2538                 }
2539                 if (byte_order != eByteOrderInvalid)
2540                 {
2541                     assert (byte_order == m_process_arch.GetByteOrder());
2542                 }
2543                 m_process_arch.GetTriple().setVendorName (llvm::StringRef (vendor_name));
2544                 m_process_arch.GetTriple().setOSName(llvm::StringRef (os_name));
2545                 m_host_arch.GetTriple().setVendorName (llvm::StringRef (vendor_name));
2546                 m_host_arch.GetTriple().setOSName (llvm::StringRef (os_name));
2547             }
2548             return true;
2549         }
2550     }
2551     else
2552     {
2553         m_qProcessInfo_is_valid = eLazyBoolNo;
2554     }
2555
2556     return false;
2557 }
2558
2559
2560 uint32_t
2561 GDBRemoteCommunicationClient::FindProcesses (const ProcessInstanceInfoMatch &match_info,
2562                                              ProcessInstanceInfoList &process_infos)
2563 {
2564     process_infos.Clear();
2565
2566     if (m_supports_qfProcessInfo)
2567     {
2568         StreamString packet;
2569         packet.PutCString ("qfProcessInfo");
2570         if (!match_info.MatchAllProcesses())
2571         {
2572             packet.PutChar (':');
2573             const char *name = match_info.GetProcessInfo().GetName();
2574             bool has_name_match = false;
2575             if (name && name[0])
2576             {
2577                 has_name_match = true;
2578                 NameMatchType name_match_type = match_info.GetNameMatchType();
2579                 switch (name_match_type)
2580                 {
2581                 case eNameMatchIgnore:
2582                     has_name_match = false;
2583                     break;
2584
2585                 case eNameMatchEquals:
2586                     packet.PutCString ("name_match:equals;");
2587                     break;
2588
2589                 case eNameMatchContains:
2590                     packet.PutCString ("name_match:contains;");
2591                     break;
2592
2593                 case eNameMatchStartsWith:
2594                     packet.PutCString ("name_match:starts_with;");
2595                     break;
2596
2597                 case eNameMatchEndsWith:
2598                     packet.PutCString ("name_match:ends_with;");
2599                     break;
2600
2601                 case eNameMatchRegularExpression:
2602                     packet.PutCString ("name_match:regex;");
2603                     break;
2604                 }
2605                 if (has_name_match)
2606                 {
2607                     packet.PutCString ("name:");
2608                     packet.PutBytesAsRawHex8(name, ::strlen(name));
2609                     packet.PutChar (';');
2610                 }
2611             }
2612
2613             if (match_info.GetProcessInfo().ProcessIDIsValid())
2614                 packet.Printf("pid:%" PRIu64 ";",match_info.GetProcessInfo().GetProcessID());
2615             if (match_info.GetProcessInfo().ParentProcessIDIsValid())
2616                 packet.Printf("parent_pid:%" PRIu64 ";",match_info.GetProcessInfo().GetParentProcessID());
2617             if (match_info.GetProcessInfo().UserIDIsValid())
2618                 packet.Printf("uid:%u;",match_info.GetProcessInfo().GetUserID());
2619             if (match_info.GetProcessInfo().GroupIDIsValid())
2620                 packet.Printf("gid:%u;",match_info.GetProcessInfo().GetGroupID());
2621             if (match_info.GetProcessInfo().EffectiveUserIDIsValid())
2622                 packet.Printf("euid:%u;",match_info.GetProcessInfo().GetEffectiveUserID());
2623             if (match_info.GetProcessInfo().EffectiveGroupIDIsValid())
2624                 packet.Printf("egid:%u;",match_info.GetProcessInfo().GetEffectiveGroupID());
2625             if (match_info.GetProcessInfo().EffectiveGroupIDIsValid())
2626                 packet.Printf("all_users:%u;",match_info.GetMatchAllUsers() ? 1 : 0);
2627             if (match_info.GetProcessInfo().GetArchitecture().IsValid())
2628             {
2629                 const ArchSpec &match_arch = match_info.GetProcessInfo().GetArchitecture();
2630                 const llvm::Triple &triple = match_arch.GetTriple();
2631                 packet.PutCString("triple:");
2632                 packet.PutCString(triple.getTriple().c_str());
2633                 packet.PutChar (';');
2634             }
2635         }
2636         StringExtractorGDBRemote response;
2637         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
2638         {
2639             do
2640             {
2641                 ProcessInstanceInfo process_info;
2642                 if (!DecodeProcessInfoResponse (response, process_info))
2643                     break;
2644                 process_infos.Append(process_info);
2645                 response.GetStringRef().clear();
2646                 response.SetFilePos(0);
2647             } while (SendPacketAndWaitForResponse ("qsProcessInfo", strlen ("qsProcessInfo"), response, false) == PacketResult::Success);
2648         }
2649         else
2650         {
2651             m_supports_qfProcessInfo = false;
2652             return 0;
2653         }
2654     }
2655     return process_infos.GetSize();
2656
2657 }
2658
2659 bool
2660 GDBRemoteCommunicationClient::GetUserName (uint32_t uid, std::string &name)
2661 {
2662     if (m_supports_qUserName)
2663     {
2664         char packet[32];
2665         const int packet_len = ::snprintf (packet, sizeof (packet), "qUserName:%i", uid);
2666         assert (packet_len < (int)sizeof(packet));
2667         StringExtractorGDBRemote response;
2668         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
2669         {
2670             if (response.IsNormalResponse())
2671             {
2672                 // Make sure we parsed the right number of characters. The response is
2673                 // the hex encoded user name and should make up the entire packet.
2674                 // If there are any non-hex ASCII bytes, the length won't match below..
2675                 if (response.GetHexByteString (name) * 2 == response.GetStringRef().size())
2676                     return true;
2677             }
2678         }
2679         else
2680         {
2681             m_supports_qUserName = false;
2682             return false;
2683         }
2684     }
2685     return false;
2686
2687 }
2688
2689 bool
2690 GDBRemoteCommunicationClient::GetGroupName (uint32_t gid, std::string &name)
2691 {
2692     if (m_supports_qGroupName)
2693     {
2694         char packet[32];
2695         const int packet_len = ::snprintf (packet, sizeof (packet), "qGroupName:%i", gid);
2696         assert (packet_len < (int)sizeof(packet));
2697         StringExtractorGDBRemote response;
2698         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
2699         {
2700             if (response.IsNormalResponse())
2701             {
2702                 // Make sure we parsed the right number of characters. The response is
2703                 // the hex encoded group name and should make up the entire packet.
2704                 // If there are any non-hex ASCII bytes, the length won't match below..
2705                 if (response.GetHexByteString (name) * 2 == response.GetStringRef().size())
2706                     return true;
2707             }
2708         }
2709         else
2710         {
2711             m_supports_qGroupName = false;
2712             return false;
2713         }
2714     }
2715     return false;
2716 }
2717
2718 void
2719 GDBRemoteCommunicationClient::TestPacketSpeed (const uint32_t num_packets)
2720 {
2721     uint32_t i;
2722     TimeValue start_time, end_time;
2723     uint64_t total_time_nsec;
2724     if (SendSpeedTestPacket (0, 0))
2725     {
2726         static uint32_t g_send_sizes[] = { 0, 64, 128, 512, 1024 };
2727         static uint32_t g_recv_sizes[] = { 0, 64, 128, 512, 1024 }; //, 4*1024, 8*1024, 16*1024, 32*1024, 48*1024, 64*1024, 96*1024, 128*1024 };
2728         const size_t k_num_send_sizes = llvm::array_lengthof(g_send_sizes);
2729         const size_t k_num_recv_sizes = llvm::array_lengthof(g_recv_sizes);
2730         const uint64_t k_recv_amount = 4*1024*1024; // Receive 4MB
2731         for (uint32_t send_idx = 0; send_idx < k_num_send_sizes; ++send_idx)
2732         {
2733             const uint32_t send_size = g_send_sizes[send_idx];
2734             for (uint32_t recv_idx = 0; recv_idx < k_num_recv_sizes; ++recv_idx)
2735             {
2736                 const uint32_t recv_size = g_recv_sizes[recv_idx];
2737                 StreamString packet;
2738                 packet.Printf ("qSpeedTest:response_size:%i;data:", recv_size);
2739                 uint32_t bytes_left = send_size;
2740                 while (bytes_left > 0)
2741                 {
2742                     if (bytes_left >= 26)
2743                     {
2744                         packet.PutCString("abcdefghijklmnopqrstuvwxyz");
2745                         bytes_left -= 26;
2746                     }
2747                     else
2748                     {
2749                         packet.Printf ("%*.*s;", bytes_left, bytes_left, "abcdefghijklmnopqrstuvwxyz");
2750                         bytes_left = 0;
2751                     }
2752                 }
2753
2754                 start_time = TimeValue::Now();
2755                 if (recv_size == 0)
2756                 {
2757                     for (i=0; i<num_packets; ++i)
2758                     {
2759                         StringExtractorGDBRemote response;
2760                         SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false);
2761                     }
2762                 }
2763                 else
2764                 {
2765                     uint32_t bytes_read = 0;
2766                     while (bytes_read < k_recv_amount)
2767                     {
2768                         StringExtractorGDBRemote response;
2769                         SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false);
2770                         bytes_read += recv_size;
2771                     }
2772                 }
2773                 end_time = TimeValue::Now();
2774                 total_time_nsec = end_time.GetAsNanoSecondsSinceJan1_1970() - start_time.GetAsNanoSecondsSinceJan1_1970();
2775                 if (recv_size == 0)
2776                 {
2777                     float packets_per_second = (((float)num_packets)/(float)total_time_nsec) * (float)TimeValue::NanoSecPerSec;
2778                     printf ("%u qSpeedTest(send=%-7u, recv=%-7u) in %" PRIu64 ".%9.9" PRIu64 " sec for %f packets/sec.\n",
2779                             num_packets,
2780                             send_size,
2781                             recv_size,
2782                             total_time_nsec / TimeValue::NanoSecPerSec,
2783                             total_time_nsec % TimeValue::NanoSecPerSec,
2784                             packets_per_second);
2785                 }
2786                 else
2787                 {
2788                     float mb_second = ((((float)k_recv_amount)/(float)total_time_nsec) * (float)TimeValue::NanoSecPerSec) / (1024.0*1024.0);
2789                     printf ("%u qSpeedTest(send=%-7u, recv=%-7u) sent 4MB in %" PRIu64 ".%9.9" PRIu64 " sec for %f MB/sec.\n",
2790                             num_packets,
2791                             send_size,
2792                             recv_size,
2793                             total_time_nsec / TimeValue::NanoSecPerSec,
2794                             total_time_nsec % TimeValue::NanoSecPerSec,
2795                             mb_second);
2796                 }
2797             }
2798         }
2799     }
2800 }
2801
2802 bool
2803 GDBRemoteCommunicationClient::SendSpeedTestPacket (uint32_t send_size, uint32_t recv_size)
2804 {
2805     StreamString packet;
2806     packet.Printf ("qSpeedTest:response_size:%i;data:", recv_size);
2807     uint32_t bytes_left = send_size;
2808     while (bytes_left > 0)
2809     {
2810         if (bytes_left >= 26)
2811         {
2812             packet.PutCString("abcdefghijklmnopqrstuvwxyz");
2813             bytes_left -= 26;
2814         }
2815         else
2816         {
2817             packet.Printf ("%*.*s;", bytes_left, bytes_left, "abcdefghijklmnopqrstuvwxyz");
2818             bytes_left = 0;
2819         }
2820     }
2821
2822     StringExtractorGDBRemote response;
2823     return SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false)  == PacketResult::Success;
2824 }
2825
2826 uint16_t
2827 GDBRemoteCommunicationClient::LaunchGDBserverAndGetPort (lldb::pid_t &pid, const char *remote_accept_hostname)
2828 {
2829     pid = LLDB_INVALID_PROCESS_ID;
2830     StringExtractorGDBRemote response;
2831     StreamString stream;
2832     stream.PutCString("qLaunchGDBServer;");
2833     std::string hostname;
2834     if (remote_accept_hostname  && remote_accept_hostname[0])
2835         hostname = remote_accept_hostname;
2836     else
2837     {
2838         if (HostInfo::GetHostname(hostname))
2839         {
2840             // Make the GDB server we launch only accept connections from this host
2841             stream.Printf("host:%s;", hostname.c_str());
2842         }
2843         else
2844         {
2845             // Make the GDB server we launch accept connections from any host since we can't figure out the hostname
2846             stream.Printf("host:*;");
2847         }
2848     }
2849     const char *packet = stream.GetData();
2850     int packet_len = stream.GetSize();
2851
2852     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
2853     {
2854         std::string name;
2855         std::string value;
2856         uint16_t port = 0;
2857         while (response.GetNameColonValue(name, value))
2858         {
2859             if (name.compare("port") == 0)
2860                 port = Args::StringToUInt32(value.c_str(), 0, 0);
2861             else if (name.compare("pid") == 0)
2862                 pid = Args::StringToUInt64(value.c_str(), LLDB_INVALID_PROCESS_ID, 0);
2863         }
2864         return port;
2865     }
2866     return 0;
2867 }
2868
2869 bool
2870 GDBRemoteCommunicationClient::KillSpawnedProcess (lldb::pid_t pid)
2871 {
2872     StreamString stream;
2873     stream.Printf ("qKillSpawnedProcess:%" PRId64 , pid);
2874     const char *packet = stream.GetData();
2875     int packet_len = stream.GetSize();
2876
2877     StringExtractorGDBRemote response;
2878     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
2879     {
2880         if (response.IsOKResponse())
2881             return true;
2882     }
2883     return false;
2884 }
2885
2886 bool
2887 GDBRemoteCommunicationClient::SetCurrentThread (uint64_t tid)
2888 {
2889     if (m_curr_tid == tid)
2890         return true;
2891
2892     char packet[32];
2893     int packet_len;
2894     if (tid == UINT64_MAX)
2895         packet_len = ::snprintf (packet, sizeof(packet), "Hg-1");
2896     else
2897         packet_len = ::snprintf (packet, sizeof(packet), "Hg%" PRIx64, tid);
2898     assert (packet_len + 1 < (int)sizeof(packet));
2899     StringExtractorGDBRemote response;
2900     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
2901     {
2902         if (response.IsOKResponse())
2903         {
2904             m_curr_tid = tid;
2905             return true;
2906         }
2907     }
2908     return false;
2909 }
2910
2911 bool
2912 GDBRemoteCommunicationClient::SetCurrentThreadForRun (uint64_t tid)
2913 {
2914     if (m_curr_tid_run == tid)
2915         return true;
2916
2917     char packet[32];
2918     int packet_len;
2919     if (tid == UINT64_MAX)
2920         packet_len = ::snprintf (packet, sizeof(packet), "Hc-1");
2921     else
2922         packet_len = ::snprintf (packet, sizeof(packet), "Hc%" PRIx64, tid);
2923
2924     assert (packet_len + 1 < (int)sizeof(packet));
2925     StringExtractorGDBRemote response;
2926     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
2927     {
2928         if (response.IsOKResponse())
2929         {
2930             m_curr_tid_run = tid;
2931             return true;
2932         }
2933     }
2934     return false;
2935 }
2936
2937 bool
2938 GDBRemoteCommunicationClient::GetStopReply (StringExtractorGDBRemote &response)
2939 {
2940     if (SendPacketAndWaitForResponse("?", 1, response, false) == PacketResult::Success)
2941         return response.IsNormalResponse();
2942     return false;
2943 }
2944
2945 bool
2946 GDBRemoteCommunicationClient::GetThreadStopInfo (lldb::tid_t tid, StringExtractorGDBRemote &response)
2947 {
2948     if (m_supports_qThreadStopInfo)
2949     {
2950         char packet[256];
2951         int packet_len = ::snprintf(packet, sizeof(packet), "qThreadStopInfo%" PRIx64, tid);
2952         assert (packet_len < (int)sizeof(packet));
2953         if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
2954         {
2955             if (response.IsUnsupportedResponse())
2956                 m_supports_qThreadStopInfo = false;
2957             else if (response.IsNormalResponse())
2958                 return true;
2959             else
2960                 return false;
2961         }
2962         else
2963         {
2964             m_supports_qThreadStopInfo = false;
2965         }
2966     }
2967     return false;
2968 }
2969
2970
2971 uint8_t
2972 GDBRemoteCommunicationClient::SendGDBStoppointTypePacket (GDBStoppointType type, bool insert,  addr_t addr, uint32_t length)
2973 {
2974     Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
2975     if (log)
2976         log->Printf ("GDBRemoteCommunicationClient::%s() %s at addr = 0x%" PRIx64,
2977                      __FUNCTION__, insert ? "add" : "remove", addr);
2978
2979     // Check if the stub is known not to support this breakpoint type
2980     if (!SupportsGDBStoppointPacket(type))
2981         return UINT8_MAX;
2982     // Construct the breakpoint packet
2983     char packet[64];
2984     const int packet_len = ::snprintf (packet,
2985                                        sizeof(packet),
2986                                        "%c%i,%" PRIx64 ",%x",
2987                                        insert ? 'Z' : 'z',
2988                                        type,
2989                                        addr,
2990                                        length);
2991     // Check we haven't overwritten the end of the packet buffer
2992     assert (packet_len + 1 < (int)sizeof(packet));
2993     StringExtractorGDBRemote response;
2994     // Try to send the breakpoint packet, and check that it was correctly sent
2995     if (SendPacketAndWaitForResponse(packet, packet_len, response, true) == PacketResult::Success)
2996     {
2997         // Receive and OK packet when the breakpoint successfully placed
2998         if (response.IsOKResponse())
2999             return 0;
3000
3001         // Error while setting breakpoint, send back specific error
3002         if (response.IsErrorResponse())
3003             return response.GetError();
3004
3005         // Empty packet informs us that breakpoint is not supported
3006         if (response.IsUnsupportedResponse())
3007         {
3008             // Disable this breakpoint type since it is unsupported
3009             switch (type)
3010             {
3011             case eBreakpointSoftware:   m_supports_z0 = false; break;
3012             case eBreakpointHardware:   m_supports_z1 = false; break;
3013             case eWatchpointWrite:      m_supports_z2 = false; break;
3014             case eWatchpointRead:       m_supports_z3 = false; break;
3015             case eWatchpointReadWrite:  m_supports_z4 = false; break;
3016             }
3017         }
3018     }
3019     // Signal generic failure
3020     return UINT8_MAX;
3021 }
3022
3023 size_t
3024 GDBRemoteCommunicationClient::GetCurrentThreadIDs (std::vector<lldb::tid_t> &thread_ids,
3025                                                    bool &sequence_mutex_unavailable)
3026 {
3027     Mutex::Locker locker;
3028     thread_ids.clear();
3029
3030     if (GetSequenceMutex (locker, "ProcessGDBRemote::UpdateThreadList() failed due to not getting the sequence mutex"))
3031     {
3032         sequence_mutex_unavailable = false;
3033         StringExtractorGDBRemote response;
3034
3035         PacketResult packet_result;
3036         for (packet_result = SendPacketAndWaitForResponseNoLock ("qfThreadInfo", strlen("qfThreadInfo"), response);
3037              packet_result == PacketResult::Success && response.IsNormalResponse();
3038              packet_result = SendPacketAndWaitForResponseNoLock ("qsThreadInfo", strlen("qsThreadInfo"), response))
3039         {
3040             char ch = response.GetChar();
3041             if (ch == 'l')
3042                 break;
3043             if (ch == 'm')
3044             {
3045                 do
3046                 {
3047                     tid_t tid = response.GetHexMaxU64(false, LLDB_INVALID_THREAD_ID);
3048
3049                     if (tid != LLDB_INVALID_THREAD_ID)
3050                     {
3051                         thread_ids.push_back (tid);
3052                     }
3053                     ch = response.GetChar();    // Skip the command separator
3054                 } while (ch == ',');            // Make sure we got a comma separator
3055             }
3056         }
3057     }
3058     else
3059     {
3060 #if defined (LLDB_CONFIGURATION_DEBUG)
3061         // assert(!"ProcessGDBRemote::UpdateThreadList() failed due to not getting the sequence mutex");
3062 #else
3063         Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_PROCESS | GDBR_LOG_PACKETS));
3064         if (log)
3065             log->Printf("error: failed to get packet sequence mutex, not sending packet 'qfThreadInfo'");
3066 #endif
3067         sequence_mutex_unavailable = true;
3068     }
3069     return thread_ids.size();
3070 }
3071
3072 lldb::addr_t
3073 GDBRemoteCommunicationClient::GetShlibInfoAddr()
3074 {
3075     if (!IsRunning())
3076     {
3077         StringExtractorGDBRemote response;
3078         if (SendPacketAndWaitForResponse("qShlibInfoAddr", ::strlen ("qShlibInfoAddr"), response, false) == PacketResult::Success)
3079         {
3080             if (response.IsNormalResponse())
3081                 return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
3082         }
3083     }
3084     return LLDB_INVALID_ADDRESS;
3085 }
3086
3087 lldb_private::Error
3088 GDBRemoteCommunicationClient::RunShellCommand (const char *command,           // Shouldn't be NULL
3089                                                const char *working_dir,       // Pass NULL to use the current working directory
3090                                                int *status_ptr,               // Pass NULL if you don't want the process exit status
3091                                                int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
3092                                                std::string *command_output,   // Pass NULL if you don't want the command output
3093                                                uint32_t timeout_sec)          // Timeout in seconds to wait for shell program to finish
3094 {
3095     lldb_private::StreamString stream;
3096     stream.PutCString("qPlatform_shell:");
3097     stream.PutBytesAsRawHex8(command, strlen(command));
3098     stream.PutChar(',');
3099     stream.PutHex32(timeout_sec);
3100     if (working_dir && *working_dir)
3101     {
3102         stream.PutChar(',');
3103         stream.PutBytesAsRawHex8(working_dir, strlen(working_dir));
3104     }
3105     const char *packet = stream.GetData();
3106     int packet_len = stream.GetSize();
3107     StringExtractorGDBRemote response;
3108     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3109     {
3110         if (response.GetChar() != 'F')
3111             return Error("malformed reply");
3112         if (response.GetChar() != ',')
3113             return Error("malformed reply");
3114         uint32_t exitcode = response.GetHexMaxU32(false, UINT32_MAX);
3115         if (exitcode == UINT32_MAX)
3116             return Error("unable to run remote process");
3117         else if (status_ptr)
3118             *status_ptr = exitcode;
3119         if (response.GetChar() != ',')
3120             return Error("malformed reply");
3121         uint32_t signo = response.GetHexMaxU32(false, UINT32_MAX);
3122         if (signo_ptr)
3123             *signo_ptr = signo;
3124         if (response.GetChar() != ',')
3125             return Error("malformed reply");
3126         std::string output;
3127         response.GetEscapedBinaryData(output);
3128         if (command_output)
3129             command_output->assign(output);
3130         return Error();
3131     }
3132     return Error("unable to send packet");
3133 }
3134
3135 Error
3136 GDBRemoteCommunicationClient::MakeDirectory (const char *path,
3137                                              uint32_t file_permissions)
3138 {
3139     lldb_private::StreamString stream;
3140     stream.PutCString("qPlatform_mkdir:");
3141     stream.PutHex32(file_permissions);
3142     stream.PutChar(',');
3143     stream.PutBytesAsRawHex8(path, strlen(path));
3144     const char *packet = stream.GetData();
3145     int packet_len = stream.GetSize();
3146     StringExtractorGDBRemote response;
3147     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3148     {
3149         return Error(response.GetHexMaxU32(false, UINT32_MAX), eErrorTypePOSIX);
3150     }
3151     return Error();
3152
3153 }
3154
3155 Error
3156 GDBRemoteCommunicationClient::SetFilePermissions (const char *path,
3157                                                   uint32_t file_permissions)
3158 {
3159     lldb_private::StreamString stream;
3160     stream.PutCString("qPlatform_chmod:");
3161     stream.PutHex32(file_permissions);
3162     stream.PutChar(',');
3163     stream.PutBytesAsRawHex8(path, strlen(path));
3164     const char *packet = stream.GetData();
3165     int packet_len = stream.GetSize();
3166     StringExtractorGDBRemote response;
3167     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3168     {
3169         return Error(response.GetHexMaxU32(false, UINT32_MAX), eErrorTypePOSIX);
3170     }
3171     return Error();
3172
3173 }
3174
3175 static uint64_t
3176 ParseHostIOPacketResponse (StringExtractorGDBRemote &response,
3177                            uint64_t fail_result,
3178                            Error &error)
3179 {
3180     response.SetFilePos(0);
3181     if (response.GetChar() != 'F')
3182         return fail_result;
3183     int32_t result = response.GetS32 (-2);
3184     if (result == -2)
3185         return fail_result;
3186     if (response.GetChar() == ',')
3187     {
3188         int result_errno = response.GetS32 (-2);
3189         if (result_errno != -2)
3190             error.SetError(result_errno, eErrorTypePOSIX);
3191         else
3192             error.SetError(-1, eErrorTypeGeneric);
3193     }
3194     else
3195         error.Clear();
3196     return  result;
3197 }
3198 lldb::user_id_t
3199 GDBRemoteCommunicationClient::OpenFile (const lldb_private::FileSpec& file_spec,
3200                                         uint32_t flags,
3201                                         mode_t mode,
3202                                         Error &error)
3203 {
3204     lldb_private::StreamString stream;
3205     stream.PutCString("vFile:open:");
3206     std::string path (file_spec.GetPath());
3207     if (path.empty())
3208         return UINT64_MAX;
3209     stream.PutCStringAsRawHex8(path.c_str());
3210     stream.PutChar(',');
3211     const uint32_t posix_open_flags = File::ConvertOpenOptionsForPOSIXOpen(flags);
3212     stream.PutHex32(posix_open_flags);
3213     stream.PutChar(',');
3214     stream.PutHex32(mode);
3215     const char* packet = stream.GetData();
3216     int packet_len = stream.GetSize();
3217     StringExtractorGDBRemote response;
3218     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3219     {
3220         return ParseHostIOPacketResponse (response, UINT64_MAX, error);
3221     }
3222     return UINT64_MAX;
3223 }
3224
3225 bool
3226 GDBRemoteCommunicationClient::CloseFile (lldb::user_id_t fd,
3227                                          Error &error)
3228 {
3229     lldb_private::StreamString stream;
3230     stream.Printf("vFile:close:%i", (int)fd);
3231     const char* packet = stream.GetData();
3232     int packet_len = stream.GetSize();
3233     StringExtractorGDBRemote response;
3234     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3235     {
3236         return ParseHostIOPacketResponse (response, -1, error) == 0;
3237     }
3238     return false;
3239 }
3240
3241 // Extension of host I/O packets to get the file size.
3242 lldb::user_id_t
3243 GDBRemoteCommunicationClient::GetFileSize (const lldb_private::FileSpec& file_spec)
3244 {
3245     lldb_private::StreamString stream;
3246     stream.PutCString("vFile:size:");
3247     std::string path (file_spec.GetPath());
3248     stream.PutCStringAsRawHex8(path.c_str());
3249     const char* packet = stream.GetData();
3250     int packet_len = stream.GetSize();
3251     StringExtractorGDBRemote response;
3252     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3253     {
3254         if (response.GetChar() != 'F')
3255             return UINT64_MAX;
3256         uint32_t retcode = response.GetHexMaxU64(false, UINT64_MAX);
3257         return retcode;
3258     }
3259     return UINT64_MAX;
3260 }
3261
3262 Error
3263 GDBRemoteCommunicationClient::GetFilePermissions(const char *path, uint32_t &file_permissions)
3264 {
3265     Error error;
3266     lldb_private::StreamString stream;
3267     stream.PutCString("vFile:mode:");
3268     stream.PutCStringAsRawHex8(path);
3269     const char* packet = stream.GetData();
3270     int packet_len = stream.GetSize();
3271     StringExtractorGDBRemote response;
3272     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3273     {
3274         if (response.GetChar() != 'F')
3275         {
3276             error.SetErrorStringWithFormat ("invalid response to '%s' packet", packet);
3277         }
3278         else
3279         {
3280             const uint32_t mode = response.GetS32(-1);
3281             if (static_cast<int32_t>(mode) == -1)
3282             {
3283                 if (response.GetChar() == ',')
3284                 {
3285                     int response_errno = response.GetS32(-1);
3286                     if (response_errno > 0)
3287                         error.SetError(response_errno, lldb::eErrorTypePOSIX);
3288                     else
3289                         error.SetErrorToGenericError();
3290                 }
3291                 else
3292                     error.SetErrorToGenericError();
3293             }
3294             else
3295             {
3296                 file_permissions = mode & (S_IRWXU|S_IRWXG|S_IRWXO);
3297             }
3298         }
3299     }
3300     else
3301     {
3302         error.SetErrorStringWithFormat ("failed to send '%s' packet", packet);
3303     }
3304     return error;
3305 }
3306
3307 uint64_t
3308 GDBRemoteCommunicationClient::ReadFile (lldb::user_id_t fd,
3309                                         uint64_t offset,
3310                                         void *dst,
3311                                         uint64_t dst_len,
3312                                         Error &error)
3313 {
3314     lldb_private::StreamString stream;
3315     stream.Printf("vFile:pread:%i,%" PRId64 ",%" PRId64, (int)fd, dst_len, offset);
3316     const char* packet = stream.GetData();
3317     int packet_len = stream.GetSize();
3318     StringExtractorGDBRemote response;
3319     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3320     {
3321         if (response.GetChar() != 'F')
3322             return 0;
3323         uint32_t retcode = response.GetHexMaxU32(false, UINT32_MAX);
3324         if (retcode == UINT32_MAX)
3325             return retcode;
3326         const char next = (response.Peek() ? *response.Peek() : 0);
3327         if (next == ',')
3328             return 0;
3329         if (next == ';')
3330         {
3331             response.GetChar(); // skip the semicolon
3332             std::string buffer;
3333             if (response.GetEscapedBinaryData(buffer))
3334             {
3335                 const uint64_t data_to_write = std::min<uint64_t>(dst_len, buffer.size());
3336                 if (data_to_write > 0)
3337                     memcpy(dst, &buffer[0], data_to_write);
3338                 return data_to_write;
3339             }
3340         }
3341     }
3342     return 0;
3343 }
3344
3345 uint64_t
3346 GDBRemoteCommunicationClient::WriteFile (lldb::user_id_t fd,
3347                                          uint64_t offset,
3348                                          const void* src,
3349                                          uint64_t src_len,
3350                                          Error &error)
3351 {
3352     lldb_private::StreamGDBRemote stream;
3353     stream.Printf("vFile:pwrite:%i,%" PRId64 ",", (int)fd, offset);
3354     stream.PutEscapedBytes(src, src_len);
3355     const char* packet = stream.GetData();
3356     int packet_len = stream.GetSize();
3357     StringExtractorGDBRemote response;
3358     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3359     {
3360         if (response.GetChar() != 'F')
3361         {
3362             error.SetErrorStringWithFormat("write file failed");
3363             return 0;
3364         }
3365         uint64_t bytes_written = response.GetU64(UINT64_MAX);
3366         if (bytes_written == UINT64_MAX)
3367         {
3368             error.SetErrorToGenericError();
3369             if (response.GetChar() == ',')
3370             {
3371                 int response_errno = response.GetS32(-1);
3372                 if (response_errno > 0)
3373                     error.SetError(response_errno, lldb::eErrorTypePOSIX);
3374             }
3375             return 0;
3376         }
3377         return bytes_written;
3378     }
3379     else
3380     {
3381         error.SetErrorString ("failed to send vFile:pwrite packet");
3382     }
3383     return 0;
3384 }
3385
3386 Error
3387 GDBRemoteCommunicationClient::CreateSymlink (const char *src, const char *dst)
3388 {
3389     Error error;
3390     lldb_private::StreamGDBRemote stream;
3391     stream.PutCString("vFile:symlink:");
3392     // the unix symlink() command reverses its parameters where the dst if first,
3393     // so we follow suit here
3394     stream.PutCStringAsRawHex8(dst);
3395     stream.PutChar(',');
3396     stream.PutCStringAsRawHex8(src);
3397     const char* packet = stream.GetData();
3398     int packet_len = stream.GetSize();
3399     StringExtractorGDBRemote response;
3400     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3401     {
3402         if (response.GetChar() == 'F')
3403         {
3404             uint32_t result = response.GetU32(UINT32_MAX);
3405             if (result != 0)
3406             {
3407                 error.SetErrorToGenericError();
3408                 if (response.GetChar() == ',')
3409                 {
3410                     int response_errno = response.GetS32(-1);
3411                     if (response_errno > 0)
3412                         error.SetError(response_errno, lldb::eErrorTypePOSIX);
3413                 }
3414             }
3415         }
3416         else
3417         {
3418             // Should have returned with 'F<result>[,<errno>]'
3419             error.SetErrorStringWithFormat("symlink failed");
3420         }
3421     }
3422     else
3423     {
3424         error.SetErrorString ("failed to send vFile:symlink packet");
3425     }
3426     return error;
3427 }
3428
3429 Error
3430 GDBRemoteCommunicationClient::Unlink (const char *path)
3431 {
3432     Error error;
3433     lldb_private::StreamGDBRemote stream;
3434     stream.PutCString("vFile:unlink:");
3435     // the unix symlink() command reverses its parameters where the dst if first,
3436     // so we follow suit here
3437     stream.PutCStringAsRawHex8(path);
3438     const char* packet = stream.GetData();
3439     int packet_len = stream.GetSize();
3440     StringExtractorGDBRemote response;
3441     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3442     {
3443         if (response.GetChar() == 'F')
3444         {
3445             uint32_t result = response.GetU32(UINT32_MAX);
3446             if (result != 0)
3447             {
3448                 error.SetErrorToGenericError();
3449                 if (response.GetChar() == ',')
3450                 {
3451                     int response_errno = response.GetS32(-1);
3452                     if (response_errno > 0)
3453                         error.SetError(response_errno, lldb::eErrorTypePOSIX);
3454                 }
3455             }
3456         }
3457         else
3458         {
3459             // Should have returned with 'F<result>[,<errno>]'
3460             error.SetErrorStringWithFormat("unlink failed");
3461         }
3462     }
3463     else
3464     {
3465         error.SetErrorString ("failed to send vFile:unlink packet");
3466     }
3467     return error;
3468 }
3469
3470 // Extension of host I/O packets to get whether a file exists.
3471 bool
3472 GDBRemoteCommunicationClient::GetFileExists (const lldb_private::FileSpec& file_spec)
3473 {
3474     lldb_private::StreamString stream;
3475     stream.PutCString("vFile:exists:");
3476     std::string path (file_spec.GetPath());
3477     stream.PutCStringAsRawHex8(path.c_str());
3478     const char* packet = stream.GetData();
3479     int packet_len = stream.GetSize();
3480     StringExtractorGDBRemote response;
3481     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3482     {
3483         if (response.GetChar() != 'F')
3484             return false;
3485         if (response.GetChar() != ',')
3486             return false;
3487         bool retcode = (response.GetChar() != '0');
3488         return retcode;
3489     }
3490     return false;
3491 }
3492
3493 bool
3494 GDBRemoteCommunicationClient::CalculateMD5 (const lldb_private::FileSpec& file_spec,
3495                                             uint64_t &high,
3496                                             uint64_t &low)
3497 {
3498     lldb_private::StreamString stream;
3499     stream.PutCString("vFile:MD5:");
3500     std::string path (file_spec.GetPath());
3501     stream.PutCStringAsRawHex8(path.c_str());
3502     const char* packet = stream.GetData();
3503     int packet_len = stream.GetSize();
3504     StringExtractorGDBRemote response;
3505     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3506     {
3507         if (response.GetChar() != 'F')
3508             return false;
3509         if (response.GetChar() != ',')
3510             return false;
3511         if (response.Peek() && *response.Peek() == 'x')
3512             return false;
3513         low = response.GetHexMaxU64(false, UINT64_MAX);
3514         high = response.GetHexMaxU64(false, UINT64_MAX);
3515         return true;
3516     }
3517     return false;
3518 }
3519
3520 bool
3521 GDBRemoteCommunicationClient::AvoidGPackets (ProcessGDBRemote *process)
3522 {
3523     // Some targets have issues with g/G packets and we need to avoid using them
3524     if (m_avoid_g_packets == eLazyBoolCalculate)
3525     {
3526         if (process)
3527         {
3528             m_avoid_g_packets = eLazyBoolNo;
3529             const ArchSpec &arch = process->GetTarget().GetArchitecture();
3530             if (arch.IsValid()
3531                 && arch.GetTriple().getVendor() == llvm::Triple::Apple
3532                 && arch.GetTriple().getOS() == llvm::Triple::IOS
3533                 && arch.GetTriple().getArch() == llvm::Triple::aarch64)
3534             {
3535                 m_avoid_g_packets = eLazyBoolYes;
3536                 uint32_t gdb_server_version = GetGDBServerProgramVersion();
3537                 if (gdb_server_version != 0)
3538                 {
3539                     const char *gdb_server_name = GetGDBServerProgramName();
3540                     if (gdb_server_name && strcmp(gdb_server_name, "debugserver") == 0)
3541                     {
3542                         if (gdb_server_version >= 310)
3543                             m_avoid_g_packets = eLazyBoolNo;
3544                     }
3545                 }
3546             }
3547         }
3548     }
3549     return m_avoid_g_packets == eLazyBoolYes;
3550 }
3551
3552 bool
3553 GDBRemoteCommunicationClient::ReadRegister(lldb::tid_t tid, uint32_t reg, StringExtractorGDBRemote &response)
3554 {
3555     Mutex::Locker locker;
3556     if (GetSequenceMutex (locker, "Didn't get sequence mutex for p packet."))
3557     {
3558         const bool thread_suffix_supported = GetThreadSuffixSupported();
3559
3560         if (thread_suffix_supported || SetCurrentThread(tid))
3561         {
3562             char packet[64];
3563             int packet_len = 0;
3564             if (thread_suffix_supported)
3565                 packet_len = ::snprintf (packet, sizeof(packet), "p%x;thread:%4.4" PRIx64 ";", reg, tid);
3566             else
3567                 packet_len = ::snprintf (packet, sizeof(packet), "p%x", reg);
3568             assert (packet_len < ((int)sizeof(packet) - 1));
3569             return SendPacketAndWaitForResponse(packet, response, false) == PacketResult::Success;
3570         }
3571     }
3572     return false;
3573
3574 }
3575
3576
3577 bool
3578 GDBRemoteCommunicationClient::ReadAllRegisters (lldb::tid_t tid, StringExtractorGDBRemote &response)
3579 {
3580     Mutex::Locker locker;
3581     if (GetSequenceMutex (locker, "Didn't get sequence mutex for g packet."))
3582     {
3583         const bool thread_suffix_supported = GetThreadSuffixSupported();
3584
3585         if (thread_suffix_supported || SetCurrentThread(tid))
3586         {
3587             char packet[64];
3588             int packet_len = 0;
3589             // Get all registers in one packet
3590             if (thread_suffix_supported)
3591                 packet_len = ::snprintf (packet, sizeof(packet), "g;thread:%4.4" PRIx64 ";", tid);
3592             else
3593                 packet_len = ::snprintf (packet, sizeof(packet), "g");
3594             assert (packet_len < ((int)sizeof(packet) - 1));
3595             return SendPacketAndWaitForResponse(packet, response, false) == PacketResult::Success;
3596         }
3597     }
3598     return false;
3599 }
3600 bool
3601 GDBRemoteCommunicationClient::SaveRegisterState (lldb::tid_t tid, uint32_t &save_id)
3602 {
3603     save_id = 0; // Set to invalid save ID
3604     if (m_supports_QSaveRegisterState == eLazyBoolNo)
3605         return false;
3606
3607     m_supports_QSaveRegisterState = eLazyBoolYes;
3608     Mutex::Locker locker;
3609     if (GetSequenceMutex (locker, "Didn't get sequence mutex for QSaveRegisterState."))
3610     {
3611         const bool thread_suffix_supported = GetThreadSuffixSupported();
3612         if (thread_suffix_supported || SetCurrentThread(tid))
3613         {
3614             char packet[256];
3615             if (thread_suffix_supported)
3616                 ::snprintf (packet, sizeof(packet), "QSaveRegisterState;thread:%4.4" PRIx64 ";", tid);
3617             else
3618                 ::strncpy (packet, "QSaveRegisterState", sizeof(packet));
3619
3620             StringExtractorGDBRemote response;
3621
3622             if (SendPacketAndWaitForResponse(packet, response, false) == PacketResult::Success)
3623             {
3624                 if (response.IsUnsupportedResponse())
3625                 {
3626                     // This packet isn't supported, don't try calling it again
3627                     m_supports_QSaveRegisterState = eLazyBoolNo;
3628                 }
3629
3630                 const uint32_t response_save_id = response.GetU32(0);
3631                 if (response_save_id != 0)
3632                 {
3633                     save_id = response_save_id;
3634                     return true;
3635                 }
3636             }
3637         }
3638     }
3639     return false;
3640 }
3641
3642 bool
3643 GDBRemoteCommunicationClient::RestoreRegisterState (lldb::tid_t tid, uint32_t save_id)
3644 {
3645     // We use the "m_supports_QSaveRegisterState" variable here because the
3646     // QSaveRegisterState and QRestoreRegisterState packets must both be supported in
3647     // order to be useful
3648     if (m_supports_QSaveRegisterState == eLazyBoolNo)
3649         return false;
3650
3651     Mutex::Locker locker;
3652     if (GetSequenceMutex (locker, "Didn't get sequence mutex for QRestoreRegisterState."))
3653     {
3654         const bool thread_suffix_supported = GetThreadSuffixSupported();
3655         if (thread_suffix_supported || SetCurrentThread(tid))
3656         {
3657             char packet[256];
3658             if (thread_suffix_supported)
3659                 ::snprintf (packet, sizeof(packet), "QRestoreRegisterState:%u;thread:%4.4" PRIx64 ";", save_id, tid);
3660             else
3661                 ::snprintf (packet, sizeof(packet), "QRestoreRegisterState:%u" PRIx64 ";", save_id);
3662
3663             StringExtractorGDBRemote response;
3664
3665             if (SendPacketAndWaitForResponse(packet, response, false) == PacketResult::Success)
3666             {
3667                 if (response.IsOKResponse())
3668                 {
3669                     return true;
3670                 }
3671                 else if (response.IsUnsupportedResponse())
3672                 {
3673                     // This packet isn't supported, don't try calling this packet or
3674                     // QSaveRegisterState again...
3675                     m_supports_QSaveRegisterState = eLazyBoolNo;
3676                 }
3677             }
3678         }
3679     }
3680     return false;
3681 }