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