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 // C++ Includes
  15 #include <sstream>
  16
  17 // Other libraries and framework includes
  18 #include "llvm/ADT/Triple.h"
  19 #include "lldb/Interpreter/Args.h"
  20 #include "lldb/Core/ConnectionFileDescriptor.h"
  21 #include "lldb/Core/Log.h"
  22 #include "lldb/Core/State.h"
  23 #include "lldb/Core/StreamString.h"
  24 #include "lldb/Host/Endian.h"
  25 #include "lldb/Host/Host.h"
  26 #include "lldb/Host/TimeValue.h"
  27
  28 // Project includes
  29 #include "Utility/StringExtractorGDBRemote.h"
  30 #include "ProcessGDBRemote.h"
  31 #include "ProcessGDBRemoteLog.h"
  32
  33 using namespace lldb;
  34 using namespace lldb_private;
  35
  36 //----------------------------------------------------------------------
  37 // GDBRemoteCommunicationClient constructor
  38 //----------------------------------------------------------------------
  39 GDBRemoteCommunicationClient::GDBRemoteCommunicationClient(bool is_platform) :
  40     GDBRemoteCommunication("gdb-remote.client", "gdb-remote.client.rx_packet", is_platform),
  41     m_supports_not_sending_acks (eLazyBoolCalculate),
  42     m_supports_thread_suffix (eLazyBoolCalculate),
  43     m_supports_threads_in_stop_reply (eLazyBoolCalculate),
  44     m_supports_vCont_all (eLazyBoolCalculate),
  45     m_supports_vCont_any (eLazyBoolCalculate),
  46     m_supports_vCont_c (eLazyBoolCalculate),
  47     m_supports_vCont_C (eLazyBoolCalculate),
  48     m_supports_vCont_s (eLazyBoolCalculate),
  49     m_supports_vCont_S (eLazyBoolCalculate),
  50     m_qHostInfo_is_valid (eLazyBoolCalculate),
  51     m_qProcessInfo_is_valid (eLazyBoolCalculate),
  52     m_supports_alloc_dealloc_memory (eLazyBoolCalculate),
  53     m_supports_memory_region_info  (eLazyBoolCalculate),
  54     m_supports_watchpoint_support_info  (eLazyBoolCalculate),
  55     m_supports_detach_stay_stopped (eLazyBoolCalculate),
  56     m_watchpoints_trigger_after_instruction(eLazyBoolCalculate),
  57     m_attach_or_wait_reply(eLazyBoolCalculate),
  58     m_prepare_for_reg_writing_reply (eLazyBoolCalculate),
  59     m_supports_qProcessInfoPID (true),
  60     m_supports_qfProcessInfo (true),
  61     m_supports_qUserName (true),
  62     m_supports_qGroupName (true),
  63     m_supports_qThreadStopInfo (true),
  64     m_supports_z0 (true),
  65     m_supports_z1 (true),
  66     m_supports_z2 (true),
  67     m_supports_z3 (true),
  68     m_supports_z4 (true),
  69     m_curr_tid (LLDB_INVALID_THREAD_ID),
  70     m_curr_tid_run (LLDB_INVALID_THREAD_ID),
  71     m_num_supported_hardware_watchpoints (0),
  72     m_async_mutex (Mutex::eMutexTypeRecursive),
  73     m_async_packet_predicate (false),
  74     m_async_packet (),
  75     m_async_response (),
  76     m_async_signal (-1),
  77     m_thread_id_to_used_usec_map (),
  78     m_host_arch(),
  79     m_process_arch(),
  80     m_os_version_major (UINT32_MAX),
  81     m_os_version_minor (UINT32_MAX),
  82     m_os_version_update (UINT32_MAX)
  83 {
  84 }
  85
  86 //----------------------------------------------------------------------
  87 // Destructor
  88 //----------------------------------------------------------------------
  89 GDBRemoteCommunicationClient::~GDBRemoteCommunicationClient()
  90 {
  91     if (IsConnected())
  92         Disconnect();
  93 }
  94
  95 bool
  96 GDBRemoteCommunicationClient::HandshakeWithServer (Error *error_ptr)
  97 {
  98     // Start the read thread after we send the handshake ack since if we
  99     // fail to send the handshake ack, there is no reason to continue...
 100     if (SendAck())
 101         return true;
 102
 103     if (error_ptr)
 104         error_ptr->SetErrorString("failed to send the handshake ack");
 105     return false;
 106 }
 107
 108 void
 109 GDBRemoteCommunicationClient::QueryNoAckModeSupported ()
 110 {
 111     if (m_supports_not_sending_acks == eLazyBoolCalculate)
 112     {
 113         m_send_acks = true;
 114         m_supports_not_sending_acks = eLazyBoolNo;
 115
 116         StringExtractorGDBRemote response;
 117         if (SendPacketAndWaitForResponse("QStartNoAckMode", response, false))
 118         {
 119             if (response.IsOKResponse())
 120             {
 121                 m_send_acks = false;
 122                 m_supports_not_sending_acks = eLazyBoolYes;
 123             }
 124         }
 125     }
 126 }
 127
 128 void
 129 GDBRemoteCommunicationClient::GetListThreadsInStopReplySupported ()
 130 {
 131     if (m_supports_threads_in_stop_reply == eLazyBoolCalculate)
 132     {
 133         m_supports_threads_in_stop_reply = eLazyBoolNo;
 134
 135         StringExtractorGDBRemote response;
 136         if (SendPacketAndWaitForResponse("QListThreadsInStopReply", response, false))
 137         {
 138             if (response.IsOKResponse())
 139                 m_supports_threads_in_stop_reply = eLazyBoolYes;
 140         }
 141     }
 142 }
 143
 144 bool
 145 GDBRemoteCommunicationClient::GetVAttachOrWaitSupported ()
 146 {
 147     if (m_attach_or_wait_reply == eLazyBoolCalculate)
 148     {
 149         m_attach_or_wait_reply = eLazyBoolNo;
 150
 151         StringExtractorGDBRemote response;
 152         if (SendPacketAndWaitForResponse("qVAttachOrWaitSupported", response, false))
 153         {
 154             if (response.IsOKResponse())
 155                 m_attach_or_wait_reply = eLazyBoolYes;
 156         }
 157     }
 158     if (m_attach_or_wait_reply == eLazyBoolYes)
 159         return true;
 160     else
 161         return false;
 162 }
 163
 164 bool
 165 GDBRemoteCommunicationClient::GetSyncThreadStateSupported ()
 166 {
 167     if (m_prepare_for_reg_writing_reply == eLazyBoolCalculate)
 168     {
 169         m_prepare_for_reg_writing_reply = eLazyBoolNo;
 170
 171         StringExtractorGDBRemote response;
 172         if (SendPacketAndWaitForResponse("qSyncThreadStateSupported", response, false))
 173         {
 174             if (response.IsOKResponse())
 175                 m_prepare_for_reg_writing_reply = eLazyBoolYes;
 176         }
 177     }
 178     if (m_prepare_for_reg_writing_reply == eLazyBoolYes)
 179         return true;
 180     else
 181         return false;
 182 }
 183
 184
 185 void
 186 GDBRemoteCommunicationClient::ResetDiscoverableSettings()
 187 {
 188     m_supports_not_sending_acks = eLazyBoolCalculate;
 189     m_supports_thread_suffix = eLazyBoolCalculate;
 190     m_supports_threads_in_stop_reply = eLazyBoolCalculate;
 191     m_supports_vCont_c = eLazyBoolCalculate;
 192     m_supports_vCont_C = eLazyBoolCalculate;
 193     m_supports_vCont_s = eLazyBoolCalculate;
 194     m_supports_vCont_S = eLazyBoolCalculate;
 195     m_qHostInfo_is_valid = eLazyBoolCalculate;
 196     m_qProcessInfo_is_valid = eLazyBoolCalculate;
 197     m_supports_alloc_dealloc_memory = eLazyBoolCalculate;
 198     m_supports_memory_region_info = eLazyBoolCalculate;
 199     m_prepare_for_reg_writing_reply = eLazyBoolCalculate;
 200     m_attach_or_wait_reply = eLazyBoolCalculate;
 201
 202     m_supports_qProcessInfoPID = true;
 203     m_supports_qfProcessInfo = true;
 204     m_supports_qUserName = true;
 205     m_supports_qGroupName = true;
 206     m_supports_qThreadStopInfo = true;
 207     m_supports_z0 = true;
 208     m_supports_z1 = true;
 209     m_supports_z2 = true;
 210     m_supports_z3 = true;
 211     m_supports_z4 = true;
 212     m_host_arch.Clear();
 213     m_process_arch.Clear();
 214 }
 215
 216
 217 bool
 218 GDBRemoteCommunicationClient::GetThreadSuffixSupported ()
 219 {
 220     if (m_supports_thread_suffix == eLazyBoolCalculate)
 221     {
 222         StringExtractorGDBRemote response;
 223         m_supports_thread_suffix = eLazyBoolNo;
 224         if (SendPacketAndWaitForResponse("QThreadSuffixSupported", response, false))
 225         {
 226             if (response.IsOKResponse())
 227                 m_supports_thread_suffix = eLazyBoolYes;
 228         }
 229     }
 230     return m_supports_thread_suffix;
 231 }
 232 bool
 233 GDBRemoteCommunicationClient::GetVContSupported (char flavor)
 234 {
 235     if (m_supports_vCont_c == eLazyBoolCalculate)
 236     {
 237         StringExtractorGDBRemote response;
 238         m_supports_vCont_any = eLazyBoolNo;
 239         m_supports_vCont_all = eLazyBoolNo;
 240         m_supports_vCont_c = eLazyBoolNo;
 241         m_supports_vCont_C = eLazyBoolNo;
 242         m_supports_vCont_s = eLazyBoolNo;
 243         m_supports_vCont_S = eLazyBoolNo;
 244         if (SendPacketAndWaitForResponse("vCont?", response, false))
 245         {
 246             const char *response_cstr = response.GetStringRef().c_str();
 247             if (::strstr (response_cstr, ";c"))
 248                 m_supports_vCont_c = eLazyBoolYes;
 249
 250             if (::strstr (response_cstr, ";C"))
 251                 m_supports_vCont_C = eLazyBoolYes;
 252
 253             if (::strstr (response_cstr, ";s"))
 254                 m_supports_vCont_s = eLazyBoolYes;
 255
 256             if (::strstr (response_cstr, ";S"))
 257                 m_supports_vCont_S = eLazyBoolYes;
 258
 259             if (m_supports_vCont_c == eLazyBoolYes &&
 260                 m_supports_vCont_C == eLazyBoolYes &&
 261                 m_supports_vCont_s == eLazyBoolYes &&
 262                 m_supports_vCont_S == eLazyBoolYes)
 263             {
 264                 m_supports_vCont_all = eLazyBoolYes;
 265             }
 266
 267             if (m_supports_vCont_c == eLazyBoolYes ||
 268                 m_supports_vCont_C == eLazyBoolYes ||
 269                 m_supports_vCont_s == eLazyBoolYes ||
 270                 m_supports_vCont_S == eLazyBoolYes)
 271             {
 272                 m_supports_vCont_any = eLazyBoolYes;
 273             }
 274         }
 275     }
 276
 277     switch (flavor)
 278     {
 279     case 'a': return m_supports_vCont_any;
 280     case 'A': return m_supports_vCont_all;
 281     case 'c': return m_supports_vCont_c;
 282     case 'C': return m_supports_vCont_C;
 283     case 's': return m_supports_vCont_s;
 284     case 'S': return m_supports_vCont_S;
 285     default: break;
 286     }
 287     return false;
 288 }
 289
 290
 291 size_t
 292 GDBRemoteCommunicationClient::SendPacketAndWaitForResponse
 293 (
 294     const char *payload,
 295     StringExtractorGDBRemote &response,
 296     bool send_async
 297 )
 298 {
 299     return SendPacketAndWaitForResponse (payload,
 300                                          ::strlen (payload),
 301                                          response,
 302                                          send_async);
 303 }
 304
 305 size_t
 306 GDBRemoteCommunicationClient::SendPacketAndWaitForResponse
 307 (
 308     const char *payload,
 309     size_t payload_length,
 310     StringExtractorGDBRemote &response,
 311     bool send_async
 312 )
 313 {
 314     Mutex::Locker locker;
 315     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
 316     size_t response_len = 0;
 317     if (GetSequenceMutex (locker))
 318     {
 319         if (SendPacketNoLock (payload, payload_length))
 320            response_len = WaitForPacketWithTimeoutMicroSecondsNoLock (response, GetPacketTimeoutInMicroSeconds ());
 321         else
 322         {
 323             if (log)
 324                 log->Printf("error: failed to send '%*s'", (int) payload_length, payload);
 325         }
 326     }
 327     else
 328     {
 329         if (send_async)
 330         {
 331             if (IsRunning())
 332             {
 333                 Mutex::Locker async_locker (m_async_mutex);
 334                 m_async_packet.assign(payload, payload_length);
 335                 m_async_packet_predicate.SetValue (true, eBroadcastNever);
 336
 337                 if (log)
 338                     log->Printf ("async: async packet = %s", m_async_packet.c_str());
 339
 340                 bool timed_out = false;
 341                 if (SendInterrupt(locker, 2, timed_out))
 342                 {
 343                     if (m_interrupt_sent)
 344                     {
 345                         m_interrupt_sent = false;
 346                         TimeValue timeout_time;
 347                         timeout_time = TimeValue::Now();
 348                         timeout_time.OffsetWithSeconds (m_packet_timeout);
 349
 350                         if (log)
 351                             log->Printf ("async: sent interrupt");
 352
 353                         if (m_async_packet_predicate.WaitForValueEqualTo (false, &timeout_time, &timed_out))
 354                         {
 355                             if (log)
 356                                 log->Printf ("async: got response");
 357
 358                             // Swap the response buffer to avoid malloc and string copy
 359                             response.GetStringRef().swap (m_async_response.GetStringRef());
 360                             response_len = response.GetStringRef().size();
 361                         }
 362                         else
 363                         {
 364                             if (log)
 365                                 log->Printf ("async: timed out waiting for response");
 366                         }
 367
 368                         // Make sure we wait until the continue packet has been sent again...
 369                         if (m_private_is_running.WaitForValueEqualTo (true, &timeout_time, &timed_out))
 370                         {
 371                             if (log)
 372                             {
 373                                 if (timed_out)
 374                                     log->Printf ("async: timed out waiting for process to resume, but process was resumed");
 375                                 else
 376                                     log->Printf ("async: async packet sent");
 377                             }
 378                         }
 379                         else
 380                         {
 381                             if (log)
 382                                 log->Printf ("async: timed out waiting for process to resume");
 383                         }
 384                     }
 385                     else
 386                     {
 387                         // We had a racy condition where we went to send the interrupt
 388                         // yet we were able to get the lock, so the process must have
 389                         // just stopped?
 390                         if (log)
 391                             log->Printf ("async: got lock without sending interrupt");
 392                         // Send the packet normally since we got the lock
 393                         if (SendPacketNoLock (payload, payload_length))
 394                             response_len = WaitForPacketWithTimeoutMicroSecondsNoLock (response, GetPacketTimeoutInMicroSeconds ());
 395                         else
 396                         {
 397                             if (log)
 398                                 log->Printf("error: failed to send '%*s'", (int) payload_length, payload);
 399                         }
 400                     }
 401                 }
 402                 else
 403                 {
 404                     if (log)
 405                         log->Printf ("async: failed to interrupt");
 406                 }
 407             }
 408             else
 409             {
 410                 if (log)
 411                     log->Printf ("async: not running, async is ignored");
 412             }
 413         }
 414         else
 415         {
 416             if (log)
 417                 log->Printf("error: failed to get packet sequence mutex, not sending packet '%*s'", (int) payload_length, payload);
 418         }
 419     }
 420     if (response_len == 0)
 421     {
 422         if (log)
 423             log->Printf("error: failed to get response for '%*s'", (int) payload_length, payload);
 424     }
 425     return response_len;
 426 }
 427
 428 static const char *end_delimiter = "--end--;";
 429 static const int end_delimiter_len = 8;
 430
 431 std::string
 432 GDBRemoteCommunicationClient::HarmonizeThreadIdsForProfileData
 433 (   ProcessGDBRemote *process,
 434     StringExtractorGDBRemote& profileDataExtractor
 435 )
 436 {
 437     std::map<uint64_t, uint32_t> new_thread_id_to_used_usec_map;
 438     std::stringstream final_output;
 439     std::string name, value;
 440
 441     // Going to assuming thread_used_usec comes first, else bail out.
 442     while (profileDataExtractor.GetNameColonValue(name, value))
 443     {
 444         if (name.compare("thread_used_id") == 0)
 445         {
 446             StringExtractor threadIDHexExtractor(value.c_str());
 447             uint64_t thread_id = threadIDHexExtractor.GetHexMaxU64(false, 0);
 448
 449             bool has_used_usec = false;
 450             uint32_t curr_used_usec = 0;
 451             std::string usec_name, usec_value;
 452             uint32_t input_file_pos = profileDataExtractor.GetFilePos();
 453             if (profileDataExtractor.GetNameColonValue(usec_name, usec_value))
 454             {
 455                 if (usec_name.compare("thread_used_usec") == 0)
 456                 {
 457                     has_used_usec = true;
 458                     curr_used_usec = strtoull(usec_value.c_str(), NULL, 0);
 459                 }
 460                 else
 461                 {
 462                     // We didn't find what we want, it is probably
 463                     // an older version. Bail out.
 464                     profileDataExtractor.SetFilePos(input_file_pos);
 465                 }
 466             }
 467
 468             if (has_used_usec)
 469             {
 470                 uint32_t prev_used_usec = 0;
 471                 std::map<uint64_t, uint32_t>::iterator iterator = m_thread_id_to_used_usec_map.find(thread_id);
 472                 if (iterator != m_thread_id_to_used_usec_map.end())
 473                 {
 474                     prev_used_usec = m_thread_id_to_used_usec_map[thread_id];
 475                 }
 476
 477                 uint32_t real_used_usec = curr_used_usec - prev_used_usec;
 478                 // A good first time record is one that runs for at least 0.25 sec
 479                 bool good_first_time = (prev_used_usec == 0) && (real_used_usec > 250000);
 480                 bool good_subsequent_time = (prev_used_usec > 0) &&
 481                     ((real_used_usec > 0) || (process->HasAssignedIndexIDToThread(thread_id)));
 482
 483                 if (good_first_time || good_subsequent_time)
 484                 {
 485                     // We try to avoid doing too many index id reservation,
 486                     // resulting in fast increase of index ids.
 487
 488                     final_output << name << ":";
 489                     int32_t index_id = process->AssignIndexIDToThread(thread_id);
 490                     final_output << index_id << ";";
 491
 492                     final_output << usec_name << ":" << usec_value << ";";
 493                 }
 494                 else
 495                 {
 496                     // Skip past 'thread_used_name'.
 497                     std::string local_name, local_value;
 498                     profileDataExtractor.GetNameColonValue(local_name, local_value);
 499                 }
 500
 501                 // Store current time as previous time so that they can be compared later.
 502                 new_thread_id_to_used_usec_map[thread_id] = curr_used_usec;
 503             }
 504             else
 505             {
 506                 // Bail out and use old string.
 507                 final_output << name << ":" << value << ";";
 508             }
 509         }
 510         else
 511         {
 512             final_output << name << ":" << value << ";";
 513         }
 514     }
 515     final_output << end_delimiter;
 516     m_thread_id_to_used_usec_map = new_thread_id_to_used_usec_map;
 517
 518     return final_output.str();
 519 }
 520
 521 StateType
 522 GDBRemoteCommunicationClient::SendContinuePacketAndWaitForResponse
 523 (
 524     ProcessGDBRemote *process,
 525     const char *payload,
 526     size_t packet_length,
 527     StringExtractorGDBRemote &response
 528 )
 529 {
 530     m_curr_tid = LLDB_INVALID_THREAD_ID;
 531     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
 532     if (log)
 533         log->Printf ("GDBRemoteCommunicationClient::%s ()", __FUNCTION__);
 534
 535     Mutex::Locker locker(m_sequence_mutex);
 536     StateType state = eStateRunning;
 537
 538     BroadcastEvent(eBroadcastBitRunPacketSent, NULL);
 539     m_public_is_running.SetValue (true, eBroadcastNever);
 540     // Set the starting continue packet into "continue_packet". This packet
 541     // may change if we are interrupted and we continue after an async packet...
 542     std::string continue_packet(payload, packet_length);
 543
 544     bool got_async_packet = false;
 545
 546     while (state == eStateRunning)
 547     {
 548         if (!got_async_packet)
 549         {
 550             if (log)
 551                 log->Printf ("GDBRemoteCommunicationClient::%s () sending continue packet: %s", __FUNCTION__, continue_packet.c_str());
 552             if (SendPacketNoLock(continue_packet.c_str(), continue_packet.size()) == 0)
 553                 state = eStateInvalid;
 554
 555             m_private_is_running.SetValue (true, eBroadcastAlways);
 556         }
 557
 558         got_async_packet = false;
 559
 560         if (log)
 561             log->Printf ("GDBRemoteCommunicationClient::%s () WaitForPacket(%s)", __FUNCTION__, continue_packet.c_str());
 562
 563         if (WaitForPacketWithTimeoutMicroSecondsNoLock(response, UINT32_MAX))
 564         {
 565             if (response.Empty())
 566                 state = eStateInvalid;
 567             else
 568             {
 569                 const char stop_type = response.GetChar();
 570                 if (log)
 571                     log->Printf ("GDBRemoteCommunicationClient::%s () got packet: %s", __FUNCTION__, response.GetStringRef().c_str());
 572                 switch (stop_type)
 573                 {
 574                 case 'T':
 575                 case 'S':
 576                     {
 577                         if (process->GetStopID() == 0)
 578                         {
 579                             if (process->GetID() == LLDB_INVALID_PROCESS_ID)
 580                             {
 581                                 lldb::pid_t pid = GetCurrentProcessID ();
 582                                 if (pid != LLDB_INVALID_PROCESS_ID)
 583                                     process->SetID (pid);
 584                             }
 585                             process->BuildDynamicRegisterInfo (true);
 586                         }
 587
 588                         // Privately notify any internal threads that we have stopped
 589                         // in case we wanted to interrupt our process, yet we might
 590                         // send a packet and continue without returning control to the
 591                         // user.
 592                         m_private_is_running.SetValue (false, eBroadcastAlways);
 593
 594                         const uint8_t signo = response.GetHexU8 (UINT8_MAX);
 595
 596                         bool continue_after_async = m_async_signal != -1 || m_async_packet_predicate.GetValue();
 597                         if (continue_after_async || m_interrupt_sent)
 598                         {
 599                             // We sent an interrupt packet to stop the inferior process
 600                             // for an async signal or to send an async packet while running
 601                             // but we might have been single stepping and received the
 602                             // stop packet for the step instead of for the interrupt packet.
 603                             // Typically when an interrupt is sent a SIGINT or SIGSTOP
 604                             // is used, so if we get anything else, we need to try and
 605                             // get another stop reply packet that may have been sent
 606                             // due to sending the interrupt when the target is stopped
 607                             // which will just re-send a copy of the last stop reply
 608                             // packet. If we don't do this, then the reply for our
 609                             // async packet will be the repeat stop reply packet and cause
 610                             // a lot of trouble for us!
 611                             if (signo != SIGINT && signo != SIGSTOP)
 612                             {
 613                                 continue_after_async = false;
 614
 615                                 // We didn't get a a SIGINT or SIGSTOP, so try for a
 616                                 // very brief time (1 ms) to get another stop reply
 617                                 // packet to make sure it doesn't get in the way
 618                                 StringExtractorGDBRemote extra_stop_reply_packet;
 619                                 uint32_t timeout_usec = 1000;
 620                                 if (WaitForPacketWithTimeoutMicroSecondsNoLock (extra_stop_reply_packet, timeout_usec))
 621                                 {
 622                                     switch (extra_stop_reply_packet.GetChar())
 623                                     {
 624                                     case 'T':
 625                                     case 'S':
 626                                         // We did get an extra stop reply, which means
 627                                         // our interrupt didn't stop the target so we
 628                                         // shouldn't continue after the async signal
 629                                         // or packet is sent...
 630                                         continue_after_async = false;
 631                                         break;
 632                                     }
 633                                 }
 634                             }
 635                         }
 636
 637                         if (m_async_signal != -1)
 638                         {
 639                             if (log)
 640                                 log->Printf ("async: send signo = %s", Host::GetSignalAsCString (m_async_signal));
 641
 642                             // Save off the async signal we are supposed to send
 643                             const int async_signal = m_async_signal;
 644                             // Clear the async signal member so we don't end up
 645                             // sending the signal multiple times...
 646                             m_async_signal = -1;
 647                             // Check which signal we stopped with
 648                             if (signo == async_signal)
 649                             {
 650                                 if (log)
 651                                     log->Printf ("async: stopped with signal %s, we are done running", Host::GetSignalAsCString (signo));
 652
 653                                 // We already stopped with a signal that we wanted
 654                                 // to stop with, so we are done
 655                             }
 656                             else
 657                             {
 658                                 // We stopped with a different signal that the one
 659                                 // we wanted to stop with, so now we must resume
 660                                 // with the signal we want
 661                                 char signal_packet[32];
 662                                 int signal_packet_len = 0;
 663                                 signal_packet_len = ::snprintf (signal_packet,
 664                                                                 sizeof (signal_packet),
 665                                                                 "C%2.2x",
 666                                                                 async_signal);
 667
 668                                 if (log)
 669                                     log->Printf ("async: stopped with signal %s, resume with %s",
 670                                                        Host::GetSignalAsCString (signo),
 671                                                        Host::GetSignalAsCString (async_signal));
 672
 673                                 // Set the continue packet to resume even if the
 674                                 // interrupt didn't cause our stop (ignore continue_after_async)
 675                                 continue_packet.assign(signal_packet, signal_packet_len);
 676                                 continue;
 677                             }
 678                         }
 679                         else if (m_async_packet_predicate.GetValue())
 680                         {
 681                             Log * packet_log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PACKETS));
 682
 683                             // We are supposed to send an asynchronous packet while
 684                             // we are running.
 685                             m_async_response.Clear();
 686                             if (m_async_packet.empty())
 687                             {
 688                                 if (packet_log)
 689                                     packet_log->Printf ("async: error: empty async packet");
 690
 691                             }
 692                             else
 693                             {
 694                                 if (packet_log)
 695                                     packet_log->Printf ("async: sending packet");
 696
 697                                 SendPacketAndWaitForResponse (&m_async_packet[0],
 698                                                               m_async_packet.size(),
 699                                                               m_async_response,
 700                                                               false);
 701                             }
 702                             // Let the other thread that was trying to send the async
 703                             // packet know that the packet has been sent and response is
 704                             // ready...
 705                             m_async_packet_predicate.SetValue(false, eBroadcastAlways);
 706
 707                             if (packet_log)
 708                                 packet_log->Printf ("async: sent packet, continue_after_async = %i", continue_after_async);
 709
 710                             // Set the continue packet to resume if our interrupt
 711                             // for the async packet did cause the stop
 712                             if (continue_after_async)
 713                             {
 714                                 // Reverting this for now as it is causing deadlocks
 715                                 // in programs (<rdar://problem/11529853>). In the future
 716                                 // we should check our thread list and "do the right thing"
 717                                 // for new threads that show up while we stop and run async
 718                                 // packets. Setting the packet to 'c' to continue all threads
 719                                 // is the right thing to do 99.99% of the time because if a
 720                                 // thread was single stepping, and we sent an interrupt, we
 721                                 // will notice above that we didn't stop due to an interrupt
 722                                 // but stopped due to stepping and we would _not_ continue.
 723                                 continue_packet.assign (1, 'c');
 724                                 continue;
 725                             }
 726                         }
 727                         // Stop with signal and thread info
 728                         state = eStateStopped;
 729                     }
 730                     break;
 731
 732                 case 'W':
 733                 case 'X':
 734                     // process exited
 735                     state = eStateExited;
 736                     break;
 737
 738                 case 'O':
 739                     // STDOUT
 740                     {
 741                         got_async_packet = true;
 742                         std::string inferior_stdout;
 743                         inferior_stdout.reserve(response.GetBytesLeft () / 2);
 744                         char ch;
 745                         while ((ch = response.GetHexU8()) != '\0')
 746                             inferior_stdout.append(1, ch);
 747                         process->AppendSTDOUT (inferior_stdout.c_str(), inferior_stdout.size());
 748                     }
 749                     break;
 750
 751                 case 'A':
 752                     // Async miscellaneous reply. Right now, only profile data is coming through this channel.
 753                     {
 754                         got_async_packet = true;
 755                         std::string input = response.GetStringRef().substr(1); // '1' to move beyond 'A'
 756                         if (m_partial_profile_data.length() > 0)
 757                         {
 758                             m_partial_profile_data.append(input);
 759                             input = m_partial_profile_data;
 760                             m_partial_profile_data.clear();
 761                         }
 762
 763                         size_t found, pos = 0, len = input.length();
 764                         while ((found = input.find(end_delimiter, pos)) != std::string::npos)
 765                         {
 766                             StringExtractorGDBRemote profileDataExtractor(input.substr(pos, found).c_str());
 767                             std::string profile_data = HarmonizeThreadIdsForProfileData(process, profileDataExtractor);
 768                             process->BroadcastAsyncProfileData (profile_data);
 769
 770                             pos = found + end_delimiter_len;
 771                         }
 772
 773                         if (pos < len)
 774                         {
 775                             // Last incomplete chunk.
 776                             m_partial_profile_data = input.substr(pos);
 777                         }
 778                     }
 779                     break;
 780
 781                 case 'E':
 782                     // ERROR
 783                     state = eStateInvalid;
 784                     break;
 785
 786                 default:
 787                     if (log)
 788                         log->Printf ("GDBRemoteCommunicationClient::%s () unrecognized async packet", __FUNCTION__);
 789                     state = eStateInvalid;
 790                     break;
 791                 }
 792             }
 793         }
 794         else
 795         {
 796             if (log)
 797                 log->Printf ("GDBRemoteCommunicationClient::%s () WaitForPacket(...) => false", __FUNCTION__);
 798             state = eStateInvalid;
 799         }
 800     }
 801     if (log)
 802         log->Printf ("GDBRemoteCommunicationClient::%s () => %s", __FUNCTION__, StateAsCString(state));
 803     response.SetFilePos(0);
 804     m_private_is_running.SetValue (false, eBroadcastAlways);
 805     m_public_is_running.SetValue (false, eBroadcastAlways);
 806     return state;
 807 }
 808
 809 bool
 810 GDBRemoteCommunicationClient::SendAsyncSignal (int signo)
 811 {
 812     Mutex::Locker async_locker (m_async_mutex);
 813     m_async_signal = signo;
 814     bool timed_out = false;
 815     Mutex::Locker locker;
 816     if (SendInterrupt (locker, 1, timed_out))
 817         return true;
 818     m_async_signal = -1;
 819     return false;
 820 }
 821
 822 // This function takes a mutex locker as a parameter in case the GetSequenceMutex
 823 // actually succeeds. If it doesn't succeed in acquiring the sequence mutex
 824 // (the expected result), then it will send the halt packet. If it does succeed
 825 // then the caller that requested the interrupt will want to keep the sequence
 826 // locked down so that no one else can send packets while the caller has control.
 827 // This function usually gets called when we are running and need to stop the
 828 // target. It can also be used when we are running and and we need to do something
 829 // else (like read/write memory), so we need to interrupt the running process
 830 // (gdb remote protocol requires this), and do what we need to do, then resume.
 831
 832 bool
 833 GDBRemoteCommunicationClient::SendInterrupt
 834 (
 835     Mutex::Locker& locker,
 836     uint32_t seconds_to_wait_for_stop,
 837     bool &timed_out
 838 )
 839 {
 840     timed_out = false;
 841     Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_PROCESS | GDBR_LOG_PACKETS));
 842
 843     if (IsRunning())
 844     {
 845         // Only send an interrupt if our debugserver is running...
 846         if (GetSequenceMutex (locker))
 847         {
 848             if (log)
 849                 log->Printf ("SendInterrupt () - got sequence mutex without having to interrupt");
 850         }
 851         else
 852         {
 853             // Someone has the mutex locked waiting for a response or for the
 854             // inferior to stop, so send the interrupt on the down low...
 855             char ctrl_c = '\x03';
 856             ConnectionStatus status = eConnectionStatusSuccess;
 857             size_t bytes_written = Write (&ctrl_c, 1, status, NULL);
 858             if (log)
 859                 log->PutCString("send packet: \\x03");
 860             if (bytes_written > 0)
 861             {
 862                 m_interrupt_sent = true;
 863                 if (seconds_to_wait_for_stop)
 864                 {
 865                     TimeValue timeout;
 866                     if (seconds_to_wait_for_stop)
 867                     {
 868                         timeout = TimeValue::Now();
 869                         timeout.OffsetWithSeconds (seconds_to_wait_for_stop);
 870                     }
 871                     if (m_private_is_running.WaitForValueEqualTo (false, &timeout, &timed_out))
 872                     {
 873                         if (log)
 874                             log->PutCString ("SendInterrupt () - sent interrupt, private state stopped");
 875                         return true;
 876                     }
 877                     else
 878                     {
 879                         if (log)
 880                             log->Printf ("SendInterrupt () - sent interrupt, timed out wating for async thread resume");
 881                     }
 882                 }
 883                 else
 884                 {
 885                     if (log)
 886                         log->Printf ("SendInterrupt () - sent interrupt, not waiting for stop...");
 887                     return true;
 888                 }
 889             }
 890             else
 891             {
 892                 if (log)
 893                     log->Printf ("SendInterrupt () - failed to write interrupt");
 894             }
 895             return false;
 896         }
 897     }
 898     else
 899     {
 900         if (log)
 901             log->Printf ("SendInterrupt () - not running");
 902     }
 903     return true;
 904 }
 905
 906 lldb::pid_t
 907 GDBRemoteCommunicationClient::GetCurrentProcessID ()
 908 {
 909     StringExtractorGDBRemote response;
 910     if (SendPacketAndWaitForResponse("qC", strlen("qC"), response, false))
 911     {
 912         if (response.GetChar() == 'Q')
 913             if (response.GetChar() == 'C')
 914                 return response.GetHexMaxU32 (false, LLDB_INVALID_PROCESS_ID);
 915     }
 916     return LLDB_INVALID_PROCESS_ID;
 917 }
 918
 919 bool
 920 GDBRemoteCommunicationClient::GetLaunchSuccess (std::string &error_str)
 921 {
 922     error_str.clear();
 923     StringExtractorGDBRemote response;
 924     if (SendPacketAndWaitForResponse("qLaunchSuccess", strlen("qLaunchSuccess"), response, false))
 925     {
 926         if (response.IsOKResponse())
 927             return true;
 928         if (response.GetChar() == 'E')
 929         {
 930             // A string the describes what failed when launching...
 931             error_str = response.GetStringRef().substr(1);
 932         }
 933         else
 934         {
 935             error_str.assign ("unknown error occurred launching process");
 936         }
 937     }
 938     else
 939     {
 940         error_str.assign ("timed out waiting for app to launch");
 941     }
 942     return false;
 943 }
 944
 945 int
 946 GDBRemoteCommunicationClient::SendArgumentsPacket (char const *argv[])
 947 {
 948     if (argv && argv[0])
 949     {
 950         StreamString packet;
 951         packet.PutChar('A');
 952         const char *arg;
 953         for (uint32_t i = 0; (arg = argv[i]) != NULL; ++i)
 954         {
 955             const int arg_len = strlen(arg);
 956             if (i > 0)
 957                 packet.PutChar(',');
 958             packet.Printf("%i,%i,", arg_len * 2, i);
 959             packet.PutBytesAsRawHex8 (arg, arg_len);
 960         }
 961
 962         StringExtractorGDBRemote response;
 963         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false))
 964         {
 965             if (response.IsOKResponse())
 966                 return 0;
 967             uint8_t error = response.GetError();
 968             if (error)
 969                 return error;
 970         }
 971     }
 972     return -1;
 973 }
 974
 975 int
 976 GDBRemoteCommunicationClient::SendEnvironmentPacket (char const *name_equal_value)
 977 {
 978     if (name_equal_value && name_equal_value[0])
 979     {
 980         StreamString packet;
 981         packet.Printf("QEnvironment:%s", name_equal_value);
 982         StringExtractorGDBRemote response;
 983         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false))
 984         {
 985             if (response.IsOKResponse())
 986                 return 0;
 987             uint8_t error = response.GetError();
 988             if (error)
 989                 return error;
 990         }
 991     }
 992     return -1;
 993 }
 994
 995 int
 996 GDBRemoteCommunicationClient::SendLaunchArchPacket (char const *arch)
 997 {
 998     if (arch && arch[0])
 999     {
1000         StreamString packet;
1001         packet.Printf("QLaunchArch:%s", arch);
1002         StringExtractorGDBRemote response;
1003         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false))
1004         {
1005             if (response.IsOKResponse())
1006                 return 0;
1007             uint8_t error = response.GetError();
1008             if (error)
1009                 return error;
1010         }
1011     }
1012     return -1;
1013 }
1014
1015 bool
1016 GDBRemoteCommunicationClient::GetOSVersion (uint32_t &major,
1017                                             uint32_t &minor,
1018                                             uint32_t &update)
1019 {
1020     if (GetHostInfo ())
1021     {
1022         if (m_os_version_major != UINT32_MAX)
1023         {
1024             major = m_os_version_major;
1025             minor = m_os_version_minor;
1026             update = m_os_version_update;
1027             return true;
1028         }
1029     }
1030     return false;
1031 }
1032
1033 bool
1034 GDBRemoteCommunicationClient::GetOSBuildString (std::string &s)
1035 {
1036     if (GetHostInfo ())
1037     {
1038         if (!m_os_build.empty())
1039         {
1040             s = m_os_build;
1041             return true;
1042         }
1043     }
1044     s.clear();
1045     return false;
1046 }
1047
1048
1049 bool
1050 GDBRemoteCommunicationClient::GetOSKernelDescription (std::string &s)
1051 {
1052     if (GetHostInfo ())
1053     {
1054         if (!m_os_kernel.empty())
1055         {
1056             s = m_os_kernel;
1057             return true;
1058         }
1059     }
1060     s.clear();
1061     return false;
1062 }
1063
1064 bool
1065 GDBRemoteCommunicationClient::GetHostname (std::string &s)
1066 {
1067     if (GetHostInfo ())
1068     {
1069         if (!m_hostname.empty())
1070         {
1071             s = m_hostname;
1072             return true;
1073         }
1074     }
1075     s.clear();
1076     return false;
1077 }
1078
1079 ArchSpec
1080 GDBRemoteCommunicationClient::GetSystemArchitecture ()
1081 {
1082     if (GetHostInfo ())
1083         return m_host_arch;
1084     return ArchSpec();
1085 }
1086
1087 const lldb_private::ArchSpec &
1088 GDBRemoteCommunicationClient::GetProcessArchitecture ()
1089 {
1090     if (m_qProcessInfo_is_valid == eLazyBoolCalculate)
1091         GetCurrentProcessInfo ();
1092     return m_process_arch;
1093 }
1094
1095
1096 bool
1097 GDBRemoteCommunicationClient::GetHostInfo (bool force)
1098 {
1099     if (force || m_qHostInfo_is_valid == eLazyBoolCalculate)
1100     {
1101         m_qHostInfo_is_valid = eLazyBoolNo;
1102         StringExtractorGDBRemote response;
1103         if (SendPacketAndWaitForResponse ("qHostInfo", response, false))
1104         {
1105             if (response.IsNormalResponse())
1106             {
1107                 std::string name;
1108                 std::string value;
1109                 uint32_t cpu = LLDB_INVALID_CPUTYPE;
1110                 uint32_t sub = 0;
1111                 std::string arch_name;
1112                 std::string os_name;
1113                 std::string vendor_name;
1114                 std::string triple;
1115                 uint32_t pointer_byte_size = 0;
1116                 StringExtractor extractor;
1117                 ByteOrder byte_order = eByteOrderInvalid;
1118                 uint32_t num_keys_decoded = 0;
1119                 while (response.GetNameColonValue(name, value))
1120                 {
1121                     if (name.compare("cputype") == 0)
1122                     {
1123                         // exception type in big endian hex
1124                         cpu = Args::StringToUInt32 (value.c_str(), LLDB_INVALID_CPUTYPE, 0);
1125                         if (cpu != LLDB_INVALID_CPUTYPE)
1126                             ++num_keys_decoded;
1127                     }
1128                     else if (name.compare("cpusubtype") == 0)
1129                     {
1130                         // exception count in big endian hex
1131                         sub = Args::StringToUInt32 (value.c_str(), 0, 0);
1132                         if (sub != 0)
1133                             ++num_keys_decoded;
1134                     }
1135                     else if (name.compare("arch") == 0)
1136                     {
1137                         arch_name.swap (value);
1138                         ++num_keys_decoded;
1139                     }
1140                     else if (name.compare("triple") == 0)
1141                     {
1142                         // The triple comes as ASCII hex bytes since it contains '-' chars
1143                         extractor.GetStringRef().swap(value);
1144                         extractor.SetFilePos(0);
1145                         extractor.GetHexByteString (triple);
1146                         ++num_keys_decoded;
1147                     }
1148                     else if (name.compare("os_build") == 0)
1149                     {
1150                         extractor.GetStringRef().swap(value);
1151                         extractor.SetFilePos(0);
1152                         extractor.GetHexByteString (m_os_build);
1153                         ++num_keys_decoded;
1154                     }
1155                     else if (name.compare("hostname") == 0)
1156                     {
1157                         extractor.GetStringRef().swap(value);
1158                         extractor.SetFilePos(0);
1159                         extractor.GetHexByteString (m_hostname);
1160                         ++num_keys_decoded;
1161                     }
1162                     else if (name.compare("os_kernel") == 0)
1163                     {
1164                         extractor.GetStringRef().swap(value);
1165                         extractor.SetFilePos(0);
1166                         extractor.GetHexByteString (m_os_kernel);
1167                         ++num_keys_decoded;
1168                     }
1169                     else if (name.compare("ostype") == 0)
1170                     {
1171                         os_name.swap (value);
1172                         ++num_keys_decoded;
1173                     }
1174                     else if (name.compare("vendor") == 0)
1175                     {
1176                         vendor_name.swap(value);
1177                         ++num_keys_decoded;
1178                     }
1179                     else if (name.compare("endian") == 0)
1180                     {
1181                         ++num_keys_decoded;
1182                         if (value.compare("little") == 0)
1183                             byte_order = eByteOrderLittle;
1184                         else if (value.compare("big") == 0)
1185                             byte_order = eByteOrderBig;
1186                         else if (value.compare("pdp") == 0)
1187                             byte_order = eByteOrderPDP;
1188                         else
1189                             --num_keys_decoded;
1190                     }
1191                     else if (name.compare("ptrsize") == 0)
1192                     {
1193                         pointer_byte_size = Args::StringToUInt32 (value.c_str(), 0, 0);
1194                         if (pointer_byte_size != 0)
1195                             ++num_keys_decoded;
1196                     }
1197                     else if (name.compare("os_version") == 0)
1198                     {
1199                         Args::StringToVersion (value.c_str(),
1200                                                m_os_version_major,
1201                                                m_os_version_minor,
1202                                                m_os_version_update);
1203                         if (m_os_version_major != UINT32_MAX)
1204                             ++num_keys_decoded;
1205                     }
1206                     else if (name.compare("watchpoint_exceptions_received") == 0)
1207                     {
1208                         ++num_keys_decoded;
1209                         if (strcmp(value.c_str(),"before") == 0)
1210                             m_watchpoints_trigger_after_instruction = eLazyBoolNo;
1211                         else if (strcmp(value.c_str(),"after") == 0)
1212                             m_watchpoints_trigger_after_instruction = eLazyBoolYes;
1213                         else
1214                             --num_keys_decoded;
1215                     }
1216
1217                 }
1218
1219                 if (num_keys_decoded > 0)
1220                     m_qHostInfo_is_valid = eLazyBoolYes;
1221
1222                 if (triple.empty())
1223                 {
1224                     if (arch_name.empty())
1225                     {
1226                         if (cpu != LLDB_INVALID_CPUTYPE)
1227                         {
1228                             m_host_arch.SetArchitecture (eArchTypeMachO, cpu, sub);
1229                             if (pointer_byte_size)
1230                             {
1231                                 assert (pointer_byte_size == m_host_arch.GetAddressByteSize());
1232                             }
1233                             if (byte_order != eByteOrderInvalid)
1234                             {
1235                                 assert (byte_order == m_host_arch.GetByteOrder());
1236                             }
1237
1238                             if (!os_name.empty() && vendor_name.compare("apple") == 0 && os_name.find("darwin") == 0)
1239                             {
1240                                 switch (m_host_arch.GetMachine())
1241                                 {
1242                                 case llvm::Triple::arm:
1243                                 case llvm::Triple::thumb:
1244                                     os_name = "ios";
1245                                     break;
1246                                 default:
1247                                     os_name = "macosx";
1248                                     break;
1249                                 }
1250                             }
1251                             if (!vendor_name.empty())
1252                                 m_host_arch.GetTriple().setVendorName (llvm::StringRef (vendor_name));
1253                             if (!os_name.empty())
1254                                 m_host_arch.GetTriple().setOSName (llvm::StringRef (os_name));
1255
1256                         }
1257                     }
1258                     else
1259                     {
1260                         std::string triple;
1261                         triple += arch_name;
1262                         if (!vendor_name.empty() || !os_name.empty())
1263                         {
1264                             triple += '-';
1265                             if (vendor_name.empty())
1266                                 triple += "unknown";
1267                             else
1268                                 triple += vendor_name;
1269                             triple += '-';
1270                             if (os_name.empty())
1271                                 triple += "unknown";
1272                             else
1273                                 triple += os_name;
1274                         }
1275                         m_host_arch.SetTriple (triple.c_str());
1276
1277                         llvm::Triple &host_triple = m_host_arch.GetTriple();
1278                         if (host_triple.getVendor() == llvm::Triple::Apple && host_triple.getOS() == llvm::Triple::Darwin)
1279                         {
1280                             switch (m_host_arch.GetMachine())
1281                             {
1282                                 case llvm::Triple::arm:
1283                                 case llvm::Triple::thumb:
1284                                     host_triple.setOS(llvm::Triple::IOS);
1285                                     break;
1286                                 default:
1287                                     host_triple.setOS(llvm::Triple::MacOSX);
1288                                     break;
1289                             }
1290                         }
1291                         if (pointer_byte_size)
1292                         {
1293                             assert (pointer_byte_size == m_host_arch.GetAddressByteSize());
1294                         }
1295                         if (byte_order != eByteOrderInvalid)
1296                         {
1297                             assert (byte_order == m_host_arch.GetByteOrder());
1298                         }
1299
1300                     }
1301                 }
1302                 else
1303                 {
1304                     m_host_arch.SetTriple (triple.c_str());
1305                     if (pointer_byte_size)
1306                     {
1307                         assert (pointer_byte_size == m_host_arch.GetAddressByteSize());
1308                     }
1309                     if (byte_order != eByteOrderInvalid)
1310                     {
1311                         assert (byte_order == m_host_arch.GetByteOrder());
1312                     }
1313                 }
1314             }
1315         }
1316     }
1317     return m_qHostInfo_is_valid == eLazyBoolYes;
1318 }
1319
1320 int
1321 GDBRemoteCommunicationClient::SendAttach
1322 (
1323     lldb::pid_t pid,
1324     StringExtractorGDBRemote& response
1325 )
1326 {
1327     if (pid != LLDB_INVALID_PROCESS_ID)
1328     {
1329         char packet[64];
1330         const int packet_len = ::snprintf (packet, sizeof(packet), "vAttach;%" PRIx64, pid);
1331         assert (packet_len < (int)sizeof(packet));
1332         if (SendPacketAndWaitForResponse (packet, packet_len, response, false))
1333         {
1334             if (response.IsErrorResponse())
1335                 return response.GetError();
1336             return 0;
1337         }
1338     }
1339     return -1;
1340 }
1341
1342 const lldb_private::ArchSpec &
1343 GDBRemoteCommunicationClient::GetHostArchitecture ()
1344 {
1345     if (m_qHostInfo_is_valid == eLazyBoolCalculate)
1346         GetHostInfo ();
1347     return m_host_arch;
1348 }
1349
1350 addr_t
1351 GDBRemoteCommunicationClient::AllocateMemory (size_t size, uint32_t permissions)
1352 {
1353     if (m_supports_alloc_dealloc_memory != eLazyBoolNo)
1354     {
1355         m_supports_alloc_dealloc_memory = eLazyBoolYes;
1356         char packet[64];
1357         const int packet_len = ::snprintf (packet, sizeof(packet), "_M%" PRIx64 ",%s%s%s",
1358                                            (uint64_t)size,
1359                                            permissions & lldb::ePermissionsReadable ? "r" : "",
1360                                            permissions & lldb::ePermissionsWritable ? "w" : "",
1361                                            permissions & lldb::ePermissionsExecutable ? "x" : "");
1362         assert (packet_len < (int)sizeof(packet));
1363         StringExtractorGDBRemote response;
1364         if (SendPacketAndWaitForResponse (packet, packet_len, response, false))
1365         {
1366             if (!response.IsErrorResponse())
1367                 return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
1368         }
1369         else
1370         {
1371             m_supports_alloc_dealloc_memory = eLazyBoolNo;
1372         }
1373     }
1374     return LLDB_INVALID_ADDRESS;
1375 }
1376
1377 bool
1378 GDBRemoteCommunicationClient::DeallocateMemory (addr_t addr)
1379 {
1380     if (m_supports_alloc_dealloc_memory != eLazyBoolNo)
1381     {
1382         m_supports_alloc_dealloc_memory = eLazyBoolYes;
1383         char packet[64];
1384         const int packet_len = ::snprintf(packet, sizeof(packet), "_m%" PRIx64, (uint64_t)addr);
1385         assert (packet_len < (int)sizeof(packet));
1386         StringExtractorGDBRemote response;
1387         if (SendPacketAndWaitForResponse (packet, packet_len, response, false))
1388         {
1389             if (response.IsOKResponse())
1390                 return true;
1391         }
1392         else
1393         {
1394             m_supports_alloc_dealloc_memory = eLazyBoolNo;
1395         }
1396     }
1397     return false;
1398 }
1399
1400 Error
1401 GDBRemoteCommunicationClient::Detach (bool keep_stopped)
1402 {
1403     Error error;
1404
1405     if (keep_stopped)
1406     {
1407         if (m_supports_detach_stay_stopped == eLazyBoolCalculate)
1408         {
1409             char packet[64];
1410             const int packet_len = ::snprintf(packet, sizeof(packet), "qSupportsDetachAndStayStopped:");
1411             assert (packet_len < (int)sizeof(packet));
1412             StringExtractorGDBRemote response;
1413             if (SendPacketAndWaitForResponse (packet, packet_len, response, false))
1414             {
1415                 m_supports_detach_stay_stopped = eLazyBoolYes;
1416             }
1417             else
1418             {
1419                 m_supports_detach_stay_stopped = eLazyBoolNo;
1420             }
1421         }
1422
1423         if (m_supports_detach_stay_stopped == eLazyBoolNo)
1424         {
1425             error.SetErrorString("Stays stopped not supported by this target.");
1426             return error;
1427         }
1428         else
1429         {
1430             size_t num_sent = SendPacket ("D1", 2);
1431             if (num_sent == 0)
1432                 error.SetErrorString ("Sending extended disconnect packet failed.");
1433         }
1434     }
1435     else
1436     {
1437         size_t num_sent = SendPacket ("D", 1);
1438         if (num_sent == 0)
1439             error.SetErrorString ("Sending disconnect packet failed.");
1440     }
1441     return error;
1442 }
1443
1444 Error
1445 GDBRemoteCommunicationClient::GetMemoryRegionInfo (lldb::addr_t addr,
1446                                                   lldb_private::MemoryRegionInfo &region_info)
1447 {
1448     Error error;
1449     region_info.Clear();
1450
1451     if (m_supports_memory_region_info != eLazyBoolNo)
1452     {
1453         m_supports_memory_region_info = eLazyBoolYes;
1454         char packet[64];
1455         const int packet_len = ::snprintf(packet, sizeof(packet), "qMemoryRegionInfo:%" PRIx64, (uint64_t)addr);
1456         assert (packet_len < (int)sizeof(packet));
1457         StringExtractorGDBRemote response;
1458         if (SendPacketAndWaitForResponse (packet, packet_len, response, false))
1459         {
1460             std::string name;
1461             std::string value;
1462             addr_t addr_value;
1463             bool success = true;
1464             bool saw_permissions = false;
1465             while (success && response.GetNameColonValue(name, value))
1466             {
1467                 if (name.compare ("start") == 0)
1468                 {
1469                     addr_value = Args::StringToUInt64(value.c_str(), LLDB_INVALID_ADDRESS, 16, &success);
1470                     if (success)
1471                         region_info.GetRange().SetRangeBase(addr_value);
1472                 }
1473                 else if (name.compare ("size") == 0)
1474                 {
1475                     addr_value = Args::StringToUInt64(value.c_str(), 0, 16, &success);
1476                     if (success)
1477                         region_info.GetRange().SetByteSize (addr_value);
1478                 }
1479                 else if (name.compare ("permissions") == 0 && region_info.GetRange().IsValid())
1480                 {
1481                     saw_permissions = true;
1482                     if (region_info.GetRange().Contains (addr))
1483                     {
1484                         if (value.find('r') != std::string::npos)
1485                             region_info.SetReadable (MemoryRegionInfo::eYes);
1486                         else
1487                             region_info.SetReadable (MemoryRegionInfo::eNo);
1488
1489                         if (value.find('w') != std::string::npos)
1490                             region_info.SetWritable (MemoryRegionInfo::eYes);
1491                         else
1492                             region_info.SetWritable (MemoryRegionInfo::eNo);
1493
1494                         if (value.find('x') != std::string::npos)
1495                             region_info.SetExecutable (MemoryRegionInfo::eYes);
1496                         else
1497                             region_info.SetExecutable (MemoryRegionInfo::eNo);
1498                     }
1499                     else
1500                     {
1501                         // The reported region does not contain this address -- we're looking at an unmapped page
1502                         region_info.SetReadable (MemoryRegionInfo::eNo);
1503                         region_info.SetWritable (MemoryRegionInfo::eNo);
1504                         region_info.SetExecutable (MemoryRegionInfo::eNo);
1505                     }
1506                 }
1507                 else if (name.compare ("error") == 0)
1508                 {
1509                     StringExtractorGDBRemote name_extractor;
1510                     // Swap "value" over into "name_extractor"
1511                     name_extractor.GetStringRef().swap(value);
1512                     // Now convert the HEX bytes into a string value
1513                     name_extractor.GetHexByteString (value);
1514                     error.SetErrorString(value.c_str());
1515                 }
1516             }
1517
1518             // We got a valid address range back but no permissions -- which means this is an unmapped page
1519             if (region_info.GetRange().IsValid() && saw_permissions == false)
1520             {
1521                 region_info.SetReadable (MemoryRegionInfo::eNo);
1522                 region_info.SetWritable (MemoryRegionInfo::eNo);
1523                 region_info.SetExecutable (MemoryRegionInfo::eNo);
1524             }
1525         }
1526         else
1527         {
1528             m_supports_memory_region_info = eLazyBoolNo;
1529         }
1530     }
1531
1532     if (m_supports_memory_region_info == eLazyBoolNo)
1533     {
1534         error.SetErrorString("qMemoryRegionInfo is not supported");
1535     }
1536     if (error.Fail())
1537         region_info.Clear();
1538     return error;
1539
1540 }
1541
1542 Error
1543 GDBRemoteCommunicationClient::GetWatchpointSupportInfo (uint32_t &num)
1544 {
1545     Error error;
1546
1547     if (m_supports_watchpoint_support_info == eLazyBoolYes)
1548     {
1549         num = m_num_supported_hardware_watchpoints;
1550         return error;
1551     }
1552
1553     // Set num to 0 first.
1554     num = 0;
1555     if (m_supports_watchpoint_support_info != eLazyBoolNo)
1556     {
1557         char packet[64];
1558         const int packet_len = ::snprintf(packet, sizeof(packet), "qWatchpointSupportInfo:");
1559         assert (packet_len < (int)sizeof(packet));
1560         StringExtractorGDBRemote response;
1561         if (SendPacketAndWaitForResponse (packet, packet_len, response, false))
1562         {
1563             m_supports_watchpoint_support_info = eLazyBoolYes;
1564             std::string name;
1565             std::string value;
1566             while (response.GetNameColonValue(name, value))
1567             {
1568                 if (name.compare ("num") == 0)
1569                 {
1570                     num = Args::StringToUInt32(value.c_str(), 0, 0);
1571                     m_num_supported_hardware_watchpoints = num;
1572                 }
1573             }
1574         }
1575         else
1576         {
1577             m_supports_watchpoint_support_info = eLazyBoolNo;
1578         }
1579     }
1580
1581     if (m_supports_watchpoint_support_info == eLazyBoolNo)
1582     {
1583         error.SetErrorString("qWatchpointSupportInfo is not supported");
1584     }
1585     return error;
1586
1587 }
1588
1589 lldb_private::Error
1590 GDBRemoteCommunicationClient::GetWatchpointSupportInfo (uint32_t &num, bool& after)
1591 {
1592     Error error(GetWatchpointSupportInfo(num));
1593     if (error.Success())
1594         error = GetWatchpointsTriggerAfterInstruction(after);
1595     return error;
1596 }
1597
1598 lldb_private::Error
1599 GDBRemoteCommunicationClient::GetWatchpointsTriggerAfterInstruction (bool &after)
1600 {
1601     Error error;
1602
1603     // we assume watchpoints will happen after running the relevant opcode
1604     // and we only want to override this behavior if we have explicitly
1605     // received a qHostInfo telling us otherwise
1606     if (m_qHostInfo_is_valid != eLazyBoolYes)
1607         after = true;
1608     else
1609         after = (m_watchpoints_trigger_after_instruction != eLazyBoolNo);
1610     return error;
1611 }
1612
1613 int
1614 GDBRemoteCommunicationClient::SetSTDIN (char const *path)
1615 {
1616     if (path && path[0])
1617     {
1618         StreamString packet;
1619         packet.PutCString("QSetSTDIN:");
1620         packet.PutBytesAsRawHex8(path, strlen(path));
1621
1622         StringExtractorGDBRemote response;
1623         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false))
1624         {
1625             if (response.IsOKResponse())
1626                 return 0;
1627             uint8_t error = response.GetError();
1628             if (error)
1629                 return error;
1630         }
1631     }
1632     return -1;
1633 }
1634
1635 int
1636 GDBRemoteCommunicationClient::SetSTDOUT (char const *path)
1637 {
1638     if (path && path[0])
1639     {
1640         StreamString packet;
1641         packet.PutCString("QSetSTDOUT:");
1642         packet.PutBytesAsRawHex8(path, strlen(path));
1643
1644         StringExtractorGDBRemote response;
1645         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false))
1646         {
1647             if (response.IsOKResponse())
1648                 return 0;
1649             uint8_t error = response.GetError();
1650             if (error)
1651                 return error;
1652         }
1653     }
1654     return -1;
1655 }
1656
1657 int
1658 GDBRemoteCommunicationClient::SetSTDERR (char const *path)
1659 {
1660     if (path && path[0])
1661     {
1662         StreamString packet;
1663         packet.PutCString("QSetSTDERR:");
1664         packet.PutBytesAsRawHex8(path, strlen(path));
1665
1666         StringExtractorGDBRemote response;
1667         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false))
1668         {
1669             if (response.IsOKResponse())
1670                 return 0;
1671             uint8_t error = response.GetError();
1672             if (error)
1673                 return error;
1674         }
1675     }
1676     return -1;
1677 }
1678
1679 int
1680 GDBRemoteCommunicationClient::SetWorkingDir (char const *path)
1681 {
1682     if (path && path[0])
1683     {
1684         StreamString packet;
1685         packet.PutCString("QSetWorkingDir:");
1686         packet.PutBytesAsRawHex8(path, strlen(path));
1687
1688         StringExtractorGDBRemote response;
1689         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false))
1690         {
1691             if (response.IsOKResponse())
1692                 return 0;
1693             uint8_t error = response.GetError();
1694             if (error)
1695                 return error;
1696         }
1697     }
1698     return -1;
1699 }
1700
1701 int
1702 GDBRemoteCommunicationClient::SetDisableASLR (bool enable)
1703 {
1704     char packet[32];
1705     const int packet_len = ::snprintf (packet, sizeof (packet), "QSetDisableASLR:%i", enable ? 1 : 0);
1706     assert (packet_len < (int)sizeof(packet));
1707     StringExtractorGDBRemote response;
1708     if (SendPacketAndWaitForResponse (packet, packet_len, response, false))
1709     {
1710         if (response.IsOKResponse())
1711             return 0;
1712         uint8_t error = response.GetError();
1713         if (error)
1714             return error;
1715     }
1716     return -1;
1717 }
1718
1719 bool
1720 GDBRemoteCommunicationClient::DecodeProcessInfoResponse (StringExtractorGDBRemote &response, ProcessInstanceInfo &process_info)
1721 {
1722     if (response.IsNormalResponse())
1723     {
1724         std::string name;
1725         std::string value;
1726         StringExtractor extractor;
1727
1728         while (response.GetNameColonValue(name, value))
1729         {
1730             if (name.compare("pid") == 0)
1731             {
1732                 process_info.SetProcessID (Args::StringToUInt32 (value.c_str(), LLDB_INVALID_PROCESS_ID, 0));
1733             }
1734             else if (name.compare("ppid") == 0)
1735             {
1736                 process_info.SetParentProcessID (Args::StringToUInt32 (value.c_str(), LLDB_INVALID_PROCESS_ID, 0));
1737             }
1738             else if (name.compare("uid") == 0)
1739             {
1740                 process_info.SetUserID (Args::StringToUInt32 (value.c_str(), UINT32_MAX, 0));
1741             }
1742             else if (name.compare("euid") == 0)
1743             {
1744                 process_info.SetEffectiveUserID (Args::StringToUInt32 (value.c_str(), UINT32_MAX, 0));
1745             }
1746             else if (name.compare("gid") == 0)
1747             {
1748                 process_info.SetGroupID (Args::StringToUInt32 (value.c_str(), UINT32_MAX, 0));
1749             }
1750             else if (name.compare("egid") == 0)
1751             {
1752                 process_info.SetEffectiveGroupID (Args::StringToUInt32 (value.c_str(), UINT32_MAX, 0));
1753             }
1754             else if (name.compare("triple") == 0)
1755             {
1756                 // The triple comes as ASCII hex bytes since it contains '-' chars
1757                 extractor.GetStringRef().swap(value);
1758                 extractor.SetFilePos(0);
1759                 extractor.GetHexByteString (value);
1760                 process_info.GetArchitecture ().SetTriple (value.c_str());
1761             }
1762             else if (name.compare("name") == 0)
1763             {
1764                 StringExtractor extractor;
1765                 // The process name from ASCII hex bytes since we can't
1766                 // control the characters in a process name
1767                 extractor.GetStringRef().swap(value);
1768                 extractor.SetFilePos(0);
1769                 extractor.GetHexByteString (value);
1770                 process_info.GetExecutableFile().SetFile (value.c_str(), false);
1771             }
1772         }
1773
1774         if (process_info.GetProcessID() != LLDB_INVALID_PROCESS_ID)
1775             return true;
1776     }
1777     return false;
1778 }
1779
1780 bool
1781 GDBRemoteCommunicationClient::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info)
1782 {
1783     process_info.Clear();
1784
1785     if (m_supports_qProcessInfoPID)
1786     {
1787         char packet[32];
1788         const int packet_len = ::snprintf (packet, sizeof (packet), "qProcessInfoPID:%" PRIu64, pid);
1789         assert (packet_len < (int)sizeof(packet));
1790         StringExtractorGDBRemote response;
1791         if (SendPacketAndWaitForResponse (packet, packet_len, response, false))
1792         {
1793             return DecodeProcessInfoResponse (response, process_info);
1794         }
1795         else
1796         {
1797             m_supports_qProcessInfoPID = false;
1798             return false;
1799         }
1800     }
1801     return false;
1802 }
1803
1804 bool
1805 GDBRemoteCommunicationClient::GetCurrentProcessInfo ()
1806 {
1807     if (m_qProcessInfo_is_valid == eLazyBoolYes)
1808         return true;
1809     if (m_qProcessInfo_is_valid == eLazyBoolNo)
1810         return false;
1811
1812     GetHostInfo ();
1813
1814     StringExtractorGDBRemote response;
1815     if (SendPacketAndWaitForResponse ("qProcessInfo", response, false))
1816     {
1817         if (response.IsNormalResponse())
1818         {
1819             std::string name;
1820             std::string value;
1821             uint32_t cpu = LLDB_INVALID_CPUTYPE;
1822             uint32_t sub = 0;
1823             std::string arch_name;
1824             std::string os_name;
1825             std::string vendor_name;
1826             std::string triple;
1827             uint32_t pointer_byte_size = 0;
1828             StringExtractor extractor;
1829             ByteOrder byte_order = eByteOrderInvalid;
1830             uint32_t num_keys_decoded = 0;
1831             while (response.GetNameColonValue(name, value))
1832             {
1833                 if (name.compare("cputype") == 0)
1834                 {
1835                     cpu = Args::StringToUInt32 (value.c_str(), LLDB_INVALID_CPUTYPE, 16);
1836                     if (cpu != LLDB_INVALID_CPUTYPE)
1837                         ++num_keys_decoded;
1838                 }
1839                 else if (name.compare("cpusubtype") == 0)
1840                 {
1841                     sub = Args::StringToUInt32 (value.c_str(), 0, 16);
1842                     if (sub != 0)
1843                         ++num_keys_decoded;
1844                 }
1845                 else if (name.compare("ostype") == 0)
1846                 {
1847                     os_name.swap (value);
1848                     ++num_keys_decoded;
1849                 }
1850                 else if (name.compare("vendor") == 0)
1851                 {
1852                     vendor_name.swap(value);
1853                     ++num_keys_decoded;
1854                 }
1855                 else if (name.compare("endian") == 0)
1856                 {
1857                     ++num_keys_decoded;
1858                     if (value.compare("little") == 0)
1859                         byte_order = eByteOrderLittle;
1860                     else if (value.compare("big") == 0)
1861                         byte_order = eByteOrderBig;
1862                     else if (value.compare("pdp") == 0)
1863                         byte_order = eByteOrderPDP;
1864                     else
1865                         --num_keys_decoded;
1866                 }
1867                 else if (name.compare("ptrsize") == 0)
1868                 {
1869                     pointer_byte_size = Args::StringToUInt32 (value.c_str(), 0, 16);
1870                     if (pointer_byte_size != 0)
1871                         ++num_keys_decoded;
1872                 }
1873             }
1874             if (num_keys_decoded > 0)
1875                 m_qProcessInfo_is_valid = eLazyBoolYes;
1876             if (cpu != LLDB_INVALID_CPUTYPE && !os_name.empty() && !vendor_name.empty())
1877             {
1878                 m_process_arch.SetArchitecture (eArchTypeMachO, cpu, sub);
1879                 if (pointer_byte_size)
1880                 {
1881                     assert (pointer_byte_size == m_process_arch.GetAddressByteSize());
1882                 }
1883                 m_host_arch.GetTriple().setVendorName (llvm::StringRef (vendor_name));
1884                 m_host_arch.GetTriple().setOSName (llvm::StringRef (os_name));
1885                 return true;
1886             }
1887         }
1888     }
1889     else
1890     {
1891         m_qProcessInfo_is_valid = eLazyBoolNo;
1892     }
1893
1894     return false;
1895 }
1896
1897
1898 uint32_t
1899 GDBRemoteCommunicationClient::FindProcesses (const ProcessInstanceInfoMatch &match_info,
1900                                              ProcessInstanceInfoList &process_infos)
1901 {
1902     process_infos.Clear();
1903
1904     if (m_supports_qfProcessInfo)
1905     {
1906         StreamString packet;
1907         packet.PutCString ("qfProcessInfo");
1908         if (!match_info.MatchAllProcesses())
1909         {
1910             packet.PutChar (':');
1911             const char *name = match_info.GetProcessInfo().GetName();
1912             bool has_name_match = false;
1913             if (name && name[0])
1914             {
1915                 has_name_match = true;
1916                 NameMatchType name_match_type = match_info.GetNameMatchType();
1917                 switch (name_match_type)
1918                 {
1919                 case eNameMatchIgnore:
1920                     has_name_match = false;
1921                     break;
1922
1923                 case eNameMatchEquals:
1924                     packet.PutCString ("name_match:equals;");
1925                     break;
1926
1927                 case eNameMatchContains:
1928                     packet.PutCString ("name_match:contains;");
1929                     break;
1930
1931                 case eNameMatchStartsWith:
1932                     packet.PutCString ("name_match:starts_with;");
1933                     break;
1934
1935                 case eNameMatchEndsWith:
1936                     packet.PutCString ("name_match:ends_with;");
1937                     break;
1938
1939                 case eNameMatchRegularExpression:
1940                     packet.PutCString ("name_match:regex;");
1941                     break;
1942                 }
1943                 if (has_name_match)
1944                 {
1945                     packet.PutCString ("name:");
1946                     packet.PutBytesAsRawHex8(name, ::strlen(name));
1947                     packet.PutChar (';');
1948                 }
1949             }
1950
1951             if (match_info.GetProcessInfo().ProcessIDIsValid())
1952                 packet.Printf("pid:%" PRIu64 ";",match_info.GetProcessInfo().GetProcessID());
1953             if (match_info.GetProcessInfo().ParentProcessIDIsValid())
1954                 packet.Printf("parent_pid:%" PRIu64 ";",match_info.GetProcessInfo().GetParentProcessID());
1955             if (match_info.GetProcessInfo().UserIDIsValid())
1956                 packet.Printf("uid:%u;",match_info.GetProcessInfo().GetUserID());
1957             if (match_info.GetProcessInfo().GroupIDIsValid())
1958                 packet.Printf("gid:%u;",match_info.GetProcessInfo().GetGroupID());
1959             if (match_info.GetProcessInfo().EffectiveUserIDIsValid())
1960                 packet.Printf("euid:%u;",match_info.GetProcessInfo().GetEffectiveUserID());
1961             if (match_info.GetProcessInfo().EffectiveGroupIDIsValid())
1962                 packet.Printf("egid:%u;",match_info.GetProcessInfo().GetEffectiveGroupID());
1963             if (match_info.GetProcessInfo().EffectiveGroupIDIsValid())
1964                 packet.Printf("all_users:%u;",match_info.GetMatchAllUsers() ? 1 : 0);
1965             if (match_info.GetProcessInfo().GetArchitecture().IsValid())
1966             {
1967                 const ArchSpec &match_arch = match_info.GetProcessInfo().GetArchitecture();
1968                 const llvm::Triple &triple = match_arch.GetTriple();
1969                 packet.PutCString("triple:");
1970                 packet.PutCStringAsRawHex8(triple.getTriple().c_str());
1971                 packet.PutChar (';');
1972             }
1973         }
1974         StringExtractorGDBRemote response;
1975         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false))
1976         {
1977             do
1978             {
1979                 ProcessInstanceInfo process_info;
1980                 if (!DecodeProcessInfoResponse (response, process_info))
1981                     break;
1982                 process_infos.Append(process_info);
1983                 response.GetStringRef().clear();
1984                 response.SetFilePos(0);
1985             } while (SendPacketAndWaitForResponse ("qsProcessInfo", strlen ("qsProcessInfo"), response, false));
1986         }
1987         else
1988         {
1989             m_supports_qfProcessInfo = false;
1990             return 0;
1991         }
1992     }
1993     return process_infos.GetSize();
1994
1995 }
1996
1997 bool
1998 GDBRemoteCommunicationClient::GetUserName (uint32_t uid, std::string &name)
1999 {
2000     if (m_supports_qUserName)
2001     {
2002         char packet[32];
2003         const int packet_len = ::snprintf (packet, sizeof (packet), "qUserName:%i", uid);
2004         assert (packet_len < (int)sizeof(packet));
2005         StringExtractorGDBRemote response;
2006         if (SendPacketAndWaitForResponse (packet, packet_len, response, false))
2007         {
2008             if (response.IsNormalResponse())
2009             {
2010                 // Make sure we parsed the right number of characters. The response is
2011                 // the hex encoded user name and should make up the entire packet.
2012                 // If there are any non-hex ASCII bytes, the length won't match below..
2013                 if (response.GetHexByteString (name) * 2 == response.GetStringRef().size())
2014                     return true;
2015             }
2016         }
2017         else
2018         {
2019             m_supports_qUserName = false;
2020             return false;
2021         }
2022     }
2023     return false;
2024
2025 }
2026
2027 bool
2028 GDBRemoteCommunicationClient::GetGroupName (uint32_t gid, std::string &name)
2029 {
2030     if (m_supports_qGroupName)
2031     {
2032         char packet[32];
2033         const int packet_len = ::snprintf (packet, sizeof (packet), "qGroupName:%i", gid);
2034         assert (packet_len < (int)sizeof(packet));
2035         StringExtractorGDBRemote response;
2036         if (SendPacketAndWaitForResponse (packet, packet_len, response, false))
2037         {
2038             if (response.IsNormalResponse())
2039             {
2040                 // Make sure we parsed the right number of characters. The response is
2041                 // the hex encoded group name and should make up the entire packet.
2042                 // If there are any non-hex ASCII bytes, the length won't match below..
2043                 if (response.GetHexByteString (name) * 2 == response.GetStringRef().size())
2044                     return true;
2045             }
2046         }
2047         else
2048         {
2049             m_supports_qGroupName = false;
2050             return false;
2051         }
2052     }
2053     return false;
2054 }
2055
2056 void
2057 GDBRemoteCommunicationClient::TestPacketSpeed (const uint32_t num_packets)
2058 {
2059     uint32_t i;
2060     TimeValue start_time, end_time;
2061     uint64_t total_time_nsec;
2062     float packets_per_second;
2063     if (SendSpeedTestPacket (0, 0))
2064     {
2065         for (uint32_t send_size = 0; send_size <= 1024; send_size *= 2)
2066         {
2067             for (uint32_t recv_size = 0; recv_size <= 1024; recv_size *= 2)
2068             {
2069                 start_time = TimeValue::Now();
2070                 for (i=0; i<num_packets; ++i)
2071                 {
2072                     SendSpeedTestPacket (send_size, recv_size);
2073                 }
2074                 end_time = TimeValue::Now();
2075                 total_time_nsec = end_time.GetAsNanoSecondsSinceJan1_1970() - start_time.GetAsNanoSecondsSinceJan1_1970();
2076                 packets_per_second = (((float)num_packets)/(float)total_time_nsec) * (float)TimeValue::NanoSecPerSec;
2077                 printf ("%u qSpeedTest(send=%-5u, recv=%-5u) in %" PRIu64 ".%9.9" PRIu64 " sec for %f packets/sec.\n",
2078                         num_packets,
2079                         send_size,
2080                         recv_size,
2081                         total_time_nsec / TimeValue::NanoSecPerSec,
2082                         total_time_nsec % TimeValue::NanoSecPerSec,
2083                         packets_per_second);
2084                 if (recv_size == 0)
2085                     recv_size = 32;
2086             }
2087             if (send_size == 0)
2088                 send_size = 32;
2089         }
2090     }
2091     else
2092     {
2093         start_time = TimeValue::Now();
2094         for (i=0; i<num_packets; ++i)
2095         {
2096             GetCurrentProcessID ();
2097         }
2098         end_time = TimeValue::Now();
2099         total_time_nsec = end_time.GetAsNanoSecondsSinceJan1_1970() - start_time.GetAsNanoSecondsSinceJan1_1970();
2100         packets_per_second = (((float)num_packets)/(float)total_time_nsec) * (float)TimeValue::NanoSecPerSec;
2101         printf ("%u 'qC' packets packets in 0x%" PRIu64 "%9.9" PRIu64 " sec for %f packets/sec.\n",
2102                 num_packets,
2103                 total_time_nsec / TimeValue::NanoSecPerSec,
2104                 total_time_nsec % TimeValue::NanoSecPerSec,
2105                 packets_per_second);
2106     }
2107 }
2108
2109 bool
2110 GDBRemoteCommunicationClient::SendSpeedTestPacket (uint32_t send_size, uint32_t recv_size)
2111 {
2112     StreamString packet;
2113     packet.Printf ("qSpeedTest:response_size:%i;data:", recv_size);
2114     uint32_t bytes_left = send_size;
2115     while (bytes_left > 0)
2116     {
2117         if (bytes_left >= 26)
2118         {
2119             packet.PutCString("abcdefghijklmnopqrstuvwxyz");
2120             bytes_left -= 26;
2121         }
2122         else
2123         {
2124             packet.Printf ("%*.*s;", bytes_left, bytes_left, "abcdefghijklmnopqrstuvwxyz");
2125             bytes_left = 0;
2126         }
2127     }
2128
2129     StringExtractorGDBRemote response;
2130     return SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) > 0;
2131     return false;
2132 }
2133
2134 uint16_t
2135 GDBRemoteCommunicationClient::LaunchGDBserverAndGetPort ()
2136 {
2137     StringExtractorGDBRemote response;
2138     if (SendPacketAndWaitForResponse("qLaunchGDBServer", strlen("qLaunchGDBServer"), response, false))
2139     {
2140         std::string name;
2141         std::string value;
2142         uint16_t port = 0;
2143         //lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
2144         while (response.GetNameColonValue(name, value))
2145         {
2146             if (name.size() == 4 && name.compare("port") == 0)
2147                 port = Args::StringToUInt32(value.c_str(), 0, 0);
2148 //            if (name.size() == 3 && name.compare("pid") == 0)
2149 //                pid = Args::StringToUInt32(value.c_str(), LLDB_INVALID_PROCESS_ID, 0);
2150         }
2151         return port;
2152     }
2153     return 0;
2154 }
2155
2156 bool
2157 GDBRemoteCommunicationClient::SetCurrentThread (uint64_t tid)
2158 {
2159     if (m_curr_tid == tid)
2160         return true;
2161
2162     char packet[32];
2163     int packet_len;
2164     if (tid == UINT64_MAX)
2165         packet_len = ::snprintf (packet, sizeof(packet), "Hg-1");
2166     else
2167         packet_len = ::snprintf (packet, sizeof(packet), "Hg%" PRIx64, tid);
2168     assert (packet_len + 1 < (int)sizeof(packet));
2169     StringExtractorGDBRemote response;
2170     if (SendPacketAndWaitForResponse(packet, packet_len, response, false))
2171     {
2172         if (response.IsOKResponse())
2173         {
2174             m_curr_tid = tid;
2175             return true;
2176         }
2177     }
2178     return false;
2179 }
2180
2181 bool
2182 GDBRemoteCommunicationClient::SetCurrentThreadForRun (uint64_t tid)
2183 {
2184     if (m_curr_tid_run == tid)
2185         return true;
2186
2187     char packet[32];
2188     int packet_len;
2189     if (tid == UINT64_MAX)
2190         packet_len = ::snprintf (packet, sizeof(packet), "Hc-1");
2191     else
2192         packet_len = ::snprintf (packet, sizeof(packet), "Hc%" PRIx64, tid);
2193
2194     assert (packet_len + 1 < (int)sizeof(packet));
2195     StringExtractorGDBRemote response;
2196     if (SendPacketAndWaitForResponse(packet, packet_len, response, false))
2197     {
2198         if (response.IsOKResponse())
2199         {
2200             m_curr_tid_run = tid;
2201             return true;
2202         }
2203     }
2204     return false;
2205 }
2206
2207 bool
2208 GDBRemoteCommunicationClient::GetStopReply (StringExtractorGDBRemote &response)
2209 {
2210     if (SendPacketAndWaitForResponse("?", 1, response, false))
2211         return response.IsNormalResponse();
2212     return false;
2213 }
2214
2215 bool
2216 GDBRemoteCommunicationClient::GetThreadStopInfo (lldb::tid_t tid, StringExtractorGDBRemote &response)
2217 {
2218     if (m_supports_qThreadStopInfo)
2219     {
2220         char packet[256];
2221         int packet_len = ::snprintf(packet, sizeof(packet), "qThreadStopInfo%" PRIx64, tid);
2222         assert (packet_len < (int)sizeof(packet));
2223         if (SendPacketAndWaitForResponse(packet, packet_len, response, false))
2224         {
2225             if (response.IsNormalResponse())
2226                 return true;
2227             else
2228                 return false;
2229         }
2230         else
2231         {
2232             m_supports_qThreadStopInfo = false;
2233         }
2234     }
2235 //    if (SetCurrentThread (tid))
2236 //        return GetStopReply (response);
2237     return false;
2238 }
2239
2240
2241 uint8_t
2242 GDBRemoteCommunicationClient::SendGDBStoppointTypePacket (GDBStoppointType type, bool insert,  addr_t addr, uint32_t length)
2243 {
2244     switch (type)
2245     {
2246     case eBreakpointSoftware:   if (!m_supports_z0) return UINT8_MAX; break;
2247     case eBreakpointHardware:   if (!m_supports_z1) return UINT8_MAX; break;
2248     case eWatchpointWrite:      if (!m_supports_z2) return UINT8_MAX; break;
2249     case eWatchpointRead:       if (!m_supports_z3) return UINT8_MAX; break;
2250     case eWatchpointReadWrite:  if (!m_supports_z4) return UINT8_MAX; break;
2251     }
2252
2253     char packet[64];
2254     const int packet_len = ::snprintf (packet,
2255                                        sizeof(packet),
2256                                        "%c%i,%" PRIx64 ",%x",
2257                                        insert ? 'Z' : 'z',
2258                                        type,
2259                                        addr,
2260                                        length);
2261
2262     assert (packet_len + 1 < (int)sizeof(packet));
2263     StringExtractorGDBRemote response;
2264     if (SendPacketAndWaitForResponse(packet, packet_len, response, true))
2265     {
2266         if (response.IsOKResponse())
2267             return 0;
2268         else if (response.IsErrorResponse())
2269             return response.GetError();
2270     }
2271     else
2272     {
2273         switch (type)
2274         {
2275             case eBreakpointSoftware:   m_supports_z0 = false; break;
2276             case eBreakpointHardware:   m_supports_z1 = false; break;
2277             case eWatchpointWrite:      m_supports_z2 = false; break;
2278             case eWatchpointRead:       m_supports_z3 = false; break;
2279             case eWatchpointReadWrite:  m_supports_z4 = false; break;
2280         }
2281     }
2282
2283     return UINT8_MAX;
2284 }
2285
2286 size_t
2287 GDBRemoteCommunicationClient::GetCurrentThreadIDs (std::vector<lldb::tid_t> &thread_ids,
2288                                                    bool &sequence_mutex_unavailable)
2289 {
2290     Mutex::Locker locker;
2291     thread_ids.clear();
2292
2293     if (GetSequenceMutex (locker, "ProcessGDBRemote::UpdateThreadList() failed due to not getting the sequence mutex"))
2294     {
2295         sequence_mutex_unavailable = false;
2296         StringExtractorGDBRemote response;
2297
2298         for (SendPacketNoLock ("qfThreadInfo", strlen("qfThreadInfo")) && WaitForPacketWithTimeoutMicroSecondsNoLock (response, GetPacketTimeoutInMicroSeconds ());
2299              response.IsNormalResponse();
2300              SendPacketNoLock ("qsThreadInfo", strlen("qsThreadInfo")) && WaitForPacketWithTimeoutMicroSecondsNoLock (response, GetPacketTimeoutInMicroSeconds ()))
2301         {
2302             char ch = response.GetChar();
2303             if (ch == 'l')
2304                 break;
2305             if (ch == 'm')
2306             {
2307                 do
2308                 {
2309                     tid_t tid = response.GetHexMaxU64(false, LLDB_INVALID_THREAD_ID);
2310
2311                     if (tid != LLDB_INVALID_THREAD_ID)
2312                     {
2313                         thread_ids.push_back (tid);
2314                     }
2315                     ch = response.GetChar();    // Skip the command separator
2316                 } while (ch == ',');            // Make sure we got a comma separator
2317             }
2318         }
2319     }
2320     else
2321     {
2322 #if defined (LLDB_CONFIGURATION_DEBUG)
2323         // assert(!"ProcessGDBRemote::UpdateThreadList() failed due to not getting the sequence mutex");
2324 #else
2325         Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_PROCESS | GDBR_LOG_PACKETS));
2326         if (log)
2327             log->Printf("error: failed to get packet sequence mutex, not sending packet 'qfThreadInfo'");
2328 #endif
2329         sequence_mutex_unavailable = true;
2330     }
2331     return thread_ids.size();
2332 }
2333
2334 lldb::addr_t
2335 GDBRemoteCommunicationClient::GetShlibInfoAddr()
2336 {
2337     if (!IsRunning())
2338     {
2339         StringExtractorGDBRemote response;
2340         if (SendPacketAndWaitForResponse("qShlibInfoAddr", ::strlen ("qShlibInfoAddr"), response, false))
2341         {
2342             if (response.IsNormalResponse())
2343                 return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
2344         }
2345     }
2346     return LLDB_INVALID_ADDRESS;
2347 }
2348