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