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     m_public_is_running.SetValue (true, eBroadcastNever);
1053     // Set the starting continue packet into "continue_packet". This packet
1054     // may change if we are interrupted and we continue after an async packet...
1055     std::string continue_packet(payload, packet_length);
1056 
1057     const auto sigstop_signo = process->GetUnixSignals()->GetSignalNumberFromName("SIGSTOP");
1058     const auto sigint_signo = process->GetUnixSignals()->GetSignalNumberFromName("SIGINT");
1059 
1060     bool got_async_packet = false;
1061     bool broadcast_sent = 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             if (! broadcast_sent)
1075             {
1076                 BroadcastEvent(eBroadcastBitRunPacketSent, NULL);
1077                 broadcast_sent = true;
1078             }
1079 
1080             m_private_is_running.SetValue (true, eBroadcastAlways);
1081         }
1082 
1083         got_async_packet = false;
1084 
1085         if (log)
1086             log->Printf ("GDBRemoteCommunicationClient::%s () ReadPacket(%s)", __FUNCTION__, continue_packet.c_str());
1087 
1088         if (ReadPacket(response, UINT32_MAX, false) == PacketResult::Success)
1089         {
1090             if (response.Empty())
1091                 state = eStateInvalid;
1092             else
1093             {
1094                 const char stop_type = response.GetChar();
1095                 if (log)
1096                     log->Printf ("GDBRemoteCommunicationClient::%s () got packet: %s", __FUNCTION__, response.GetStringRef().c_str());
1097                 switch (stop_type)
1098                 {
1099                 case 'T':
1100                 case 'S':
1101                     {
1102                         if (process->GetStopID() == 0)
1103                         {
1104                             if (process->GetID() == LLDB_INVALID_PROCESS_ID)
1105                             {
1106                                 lldb::pid_t pid = GetCurrentProcessID ();
1107                                 if (pid != LLDB_INVALID_PROCESS_ID)
1108                                     process->SetID (pid);
1109                             }
1110                             process->BuildDynamicRegisterInfo (true);
1111                         }
1112 
1113                         // Privately notify any internal threads that we have stopped
1114                         // in case we wanted to interrupt our process, yet we might
1115                         // send a packet and continue without returning control to the
1116                         // user.
1117                         m_private_is_running.SetValue (false, eBroadcastAlways);
1118 
1119                         const uint8_t signo = response.GetHexU8 (UINT8_MAX);
1120 
1121                         bool continue_after_async = m_async_signal != -1 || m_async_packet_predicate.GetValue();
1122                         if (continue_after_async || m_interrupt_sent)
1123                         {
1124                             // We sent an interrupt packet to stop the inferior process
1125                             // for an async signal or to send an async packet while running
1126                             // but we might have been single stepping and received the
1127                             // stop packet for the step instead of for the interrupt packet.
1128                             // Typically when an interrupt is sent a SIGINT or SIGSTOP
1129                             // is used, so if we get anything else, we need to try and
1130                             // get another stop reply packet that may have been sent
1131                             // due to sending the interrupt when the target is stopped
1132                             // which will just re-send a copy of the last stop reply
1133                             // packet. If we don't do this, then the reply for our
1134                             // async packet will be the repeat stop reply packet and cause
1135                             // a lot of trouble for us!
1136                             if (signo != sigint_signo && signo != sigstop_signo)
1137                             {
1138                                 continue_after_async = false;
1139 
1140                                 // We didn't get a SIGINT or SIGSTOP, so try for a
1141                                 // very brief time (0.1s) to get another stop reply
1142                                 // packet to make sure it doesn't get in the way
1143                                 StringExtractorGDBRemote extra_stop_reply_packet;
1144                                 uint32_t timeout_usec = 100000;
1145                                 if (ReadPacket (extra_stop_reply_packet, timeout_usec, false) == PacketResult::Success)
1146                                 {
1147                                     switch (extra_stop_reply_packet.GetChar())
1148                                     {
1149                                     case 'T':
1150                                     case 'S':
1151                                         // We did get an extra stop reply, which means
1152                                         // our interrupt didn't stop the target so we
1153                                         // shouldn't continue after the async signal
1154                                         // or packet is sent...
1155                                         continue_after_async = false;
1156                                         break;
1157                                     }
1158                                 }
1159                             }
1160                         }
1161 
1162                         if (m_async_signal != -1)
1163                         {
1164                             if (log)
1165                                 log->Printf ("async: send signo = %s", Host::GetSignalAsCString (m_async_signal));
1166 
1167                             // Save off the async signal we are supposed to send
1168                             const int async_signal = m_async_signal;
1169                             // Clear the async signal member so we don't end up
1170                             // sending the signal multiple times...
1171                             m_async_signal = -1;
1172                             // Check which signal we stopped with
1173                             if (signo == async_signal)
1174                             {
1175                                 if (log)
1176                                     log->Printf ("async: stopped with signal %s, we are done running", Host::GetSignalAsCString (signo));
1177 
1178                                 // We already stopped with a signal that we wanted
1179                                 // to stop with, so we are done
1180                             }
1181                             else
1182                             {
1183                                 // We stopped with a different signal that the one
1184                                 // we wanted to stop with, so now we must resume
1185                                 // with the signal we want
1186                                 char signal_packet[32];
1187                                 int signal_packet_len = 0;
1188                                 signal_packet_len = ::snprintf (signal_packet,
1189                                                                 sizeof (signal_packet),
1190                                                                 "C%2.2x",
1191                                                                 async_signal);
1192 
1193                                 if (log)
1194                                     log->Printf ("async: stopped with signal %s, resume with %s",
1195                                                        Host::GetSignalAsCString (signo),
1196                                                        Host::GetSignalAsCString (async_signal));
1197 
1198                                 // Set the continue packet to resume even if the
1199                                 // interrupt didn't cause our stop (ignore continue_after_async)
1200                                 continue_packet.assign(signal_packet, signal_packet_len);
1201                                 continue;
1202                             }
1203                         }
1204                         else if (m_async_packet_predicate.GetValue())
1205                         {
1206                             Log * packet_log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PACKETS));
1207 
1208                             // We are supposed to send an asynchronous packet while
1209                             // we are running.
1210                             m_async_response.Clear();
1211                             if (m_async_packet.empty())
1212                             {
1213                                 m_async_result = PacketResult::ErrorSendFailed;
1214                                 if (packet_log)
1215                                     packet_log->Printf ("async: error: empty async packet");
1216 
1217                             }
1218                             else
1219                             {
1220                                 if (packet_log)
1221                                     packet_log->Printf ("async: sending packet");
1222 
1223                                 m_async_result = SendPacketAndWaitForResponse (&m_async_packet[0],
1224                                                                                m_async_packet.size(),
1225                                                                                m_async_response,
1226                                                                                false);
1227                             }
1228                             // Let the other thread that was trying to send the async
1229                             // packet know that the packet has been sent and response is
1230                             // ready...
1231                             m_async_packet_predicate.SetValue(false, eBroadcastAlways);
1232 
1233                             if (packet_log)
1234                                 packet_log->Printf ("async: sent packet, continue_after_async = %i", continue_after_async);
1235 
1236                             // Set the continue packet to resume if our interrupt
1237                             // for the async packet did cause the stop
1238                             if (continue_after_async)
1239                             {
1240                                 // Reverting this for now as it is causing deadlocks
1241                                 // in programs (<rdar://problem/11529853>). In the future
1242                                 // we should check our thread list and "do the right thing"
1243                                 // for new threads that show up while we stop and run async
1244                                 // packets. Setting the packet to 'c' to continue all threads
1245                                 // is the right thing to do 99.99% of the time because if a
1246                                 // thread was single stepping, and we sent an interrupt, we
1247                                 // will notice above that we didn't stop due to an interrupt
1248                                 // but stopped due to stepping and we would _not_ continue.
1249                                 continue_packet.assign (1, 'c');
1250                                 continue;
1251                             }
1252                         }
1253                         // Stop with signal and thread info
1254                         state = eStateStopped;
1255                     }
1256                     break;
1257 
1258                 case 'W':
1259                 case 'X':
1260                     // process exited
1261                     state = eStateExited;
1262                     break;
1263 
1264                 case 'O':
1265                     // STDOUT
1266                     {
1267                         got_async_packet = true;
1268                         std::string inferior_stdout;
1269                         inferior_stdout.reserve(response.GetBytesLeft () / 2);
1270 
1271                         uint8_t ch;
1272                         while (response.GetHexU8Ex(ch))
1273                         {
1274                             if (ch != 0)
1275                                 inferior_stdout.append(1, (char)ch);
1276                         }
1277                         process->AppendSTDOUT (inferior_stdout.c_str(), inferior_stdout.size());
1278                     }
1279                     break;
1280 
1281                 case 'A':
1282                     // Async miscellaneous reply. Right now, only profile data is coming through this channel.
1283                     {
1284                         got_async_packet = true;
1285                         std::string input = response.GetStringRef().substr(1); // '1' to move beyond 'A'
1286                         if (m_partial_profile_data.length() > 0)
1287                         {
1288                             m_partial_profile_data.append(input);
1289                             input = m_partial_profile_data;
1290                             m_partial_profile_data.clear();
1291                         }
1292 
1293                         size_t found, pos = 0, len = input.length();
1294                         while ((found = input.find(end_delimiter, pos)) != std::string::npos)
1295                         {
1296                             StringExtractorGDBRemote profileDataExtractor(input.substr(pos, found).c_str());
1297                             std::string profile_data = HarmonizeThreadIdsForProfileData(process, profileDataExtractor);
1298                             process->BroadcastAsyncProfileData (profile_data);
1299 
1300                             pos = found + end_delimiter_len;
1301                         }
1302 
1303                         if (pos < len)
1304                         {
1305                             // Last incomplete chunk.
1306                             m_partial_profile_data = input.substr(pos);
1307                         }
1308                     }
1309                     break;
1310 
1311                 case 'E':
1312                     // ERROR
1313                     state = eStateInvalid;
1314                     break;
1315 
1316                 default:
1317                     if (log)
1318                         log->Printf ("GDBRemoteCommunicationClient::%s () unrecognized async packet", __FUNCTION__);
1319                     state = eStateInvalid;
1320                     break;
1321                 }
1322             }
1323         }
1324         else
1325         {
1326             if (log)
1327                 log->Printf ("GDBRemoteCommunicationClient::%s () ReadPacket(...) => false", __FUNCTION__);
1328             state = eStateInvalid;
1329         }
1330     }
1331     if (log)
1332         log->Printf ("GDBRemoteCommunicationClient::%s () => %s", __FUNCTION__, StateAsCString(state));
1333     response.SetFilePos(0);
1334     m_private_is_running.SetValue (false, eBroadcastAlways);
1335     m_public_is_running.SetValue (false, eBroadcastAlways);
1336     return state;
1337 }
1338 
1339 bool
1340 GDBRemoteCommunicationClient::SendAsyncSignal (int signo)
1341 {
1342     Mutex::Locker async_locker (m_async_mutex);
1343     m_async_signal = signo;
1344     bool timed_out = false;
1345     Mutex::Locker locker;
1346     if (SendInterrupt (locker, 1, timed_out))
1347         return true;
1348     m_async_signal = -1;
1349     return false;
1350 }
1351 
1352 // This function takes a mutex locker as a parameter in case the GetSequenceMutex
1353 // actually succeeds. If it doesn't succeed in acquiring the sequence mutex
1354 // (the expected result), then it will send the halt packet. If it does succeed
1355 // then the caller that requested the interrupt will want to keep the sequence
1356 // locked down so that no one else can send packets while the caller has control.
1357 // This function usually gets called when we are running and need to stop the
1358 // target. It can also be used when we are running and we need to do something
1359 // else (like read/write memory), so we need to interrupt the running process
1360 // (gdb remote protocol requires this), and do what we need to do, then resume.
1361 
1362 bool
1363 GDBRemoteCommunicationClient::SendInterrupt
1364 (
1365     Mutex::Locker& locker,
1366     uint32_t seconds_to_wait_for_stop,
1367     bool &timed_out
1368 )
1369 {
1370     timed_out = false;
1371     Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_PROCESS | GDBR_LOG_PACKETS));
1372 
1373     if (IsRunning())
1374     {
1375         // Only send an interrupt if our debugserver is running...
1376         if (GetSequenceMutex (locker))
1377         {
1378             if (log)
1379                 log->Printf ("SendInterrupt () - got sequence mutex without having to interrupt");
1380         }
1381         else
1382         {
1383             // Someone has the mutex locked waiting for a response or for the
1384             // inferior to stop, so send the interrupt on the down low...
1385             char ctrl_c = '\x03';
1386             ConnectionStatus status = eConnectionStatusSuccess;
1387             size_t bytes_written = Write (&ctrl_c, 1, status, NULL);
1388             if (log)
1389                 log->PutCString("send packet: \\x03");
1390             if (bytes_written > 0)
1391             {
1392                 m_interrupt_sent = true;
1393                 if (seconds_to_wait_for_stop)
1394                 {
1395                     TimeValue timeout;
1396                     if (seconds_to_wait_for_stop)
1397                     {
1398                         timeout = TimeValue::Now();
1399                         timeout.OffsetWithSeconds (seconds_to_wait_for_stop);
1400                     }
1401                     if (m_private_is_running.WaitForValueEqualTo (false, &timeout, &timed_out))
1402                     {
1403                         if (log)
1404                             log->PutCString ("SendInterrupt () - sent interrupt, private state stopped");
1405                         return true;
1406                     }
1407                     else
1408                     {
1409                         if (log)
1410                             log->Printf ("SendInterrupt () - sent interrupt, timed out wating for async thread resume");
1411                     }
1412                 }
1413                 else
1414                 {
1415                     if (log)
1416                         log->Printf ("SendInterrupt () - sent interrupt, not waiting for stop...");
1417                     return true;
1418                 }
1419             }
1420             else
1421             {
1422                 if (log)
1423                     log->Printf ("SendInterrupt () - failed to write interrupt");
1424             }
1425             return false;
1426         }
1427     }
1428     else
1429     {
1430         if (log)
1431             log->Printf ("SendInterrupt () - not running");
1432     }
1433     return true;
1434 }
1435 
1436 lldb::pid_t
1437 GDBRemoteCommunicationClient::GetCurrentProcessID (bool allow_lazy)
1438 {
1439     if (allow_lazy && m_curr_pid_is_valid == eLazyBoolYes)
1440         return m_curr_pid;
1441 
1442     // First try to retrieve the pid via the qProcessInfo request.
1443     GetCurrentProcessInfo (allow_lazy);
1444     if (m_curr_pid_is_valid == eLazyBoolYes)
1445     {
1446         // We really got it.
1447         return m_curr_pid;
1448     }
1449     else
1450     {
1451         // If we don't get a response for qProcessInfo, check if $qC gives us a result.
1452         // $qC only returns a real process id on older debugserver and lldb-platform stubs.
1453         // The gdb remote protocol documents $qC as returning the thread id, which newer
1454         // debugserver and lldb-gdbserver stubs return correctly.
1455         StringExtractorGDBRemote response;
1456         if (SendPacketAndWaitForResponse("qC", strlen("qC"), response, false) == PacketResult::Success)
1457         {
1458             if (response.GetChar() == 'Q')
1459             {
1460                 if (response.GetChar() == 'C')
1461                 {
1462                     m_curr_pid = response.GetHexMaxU32 (false, LLDB_INVALID_PROCESS_ID);
1463                     if (m_curr_pid != LLDB_INVALID_PROCESS_ID)
1464                     {
1465                         m_curr_pid_is_valid = eLazyBoolYes;
1466                         return m_curr_pid;
1467                     }
1468                 }
1469             }
1470         }
1471 
1472         // If we don't get a response for $qC, check if $qfThreadID gives us a result.
1473         if (m_curr_pid == LLDB_INVALID_PROCESS_ID)
1474         {
1475             std::vector<lldb::tid_t> thread_ids;
1476             bool sequence_mutex_unavailable;
1477             size_t size;
1478             size = GetCurrentThreadIDs (thread_ids, sequence_mutex_unavailable);
1479             if (size && sequence_mutex_unavailable == false)
1480             {
1481                 m_curr_pid = thread_ids.front();
1482                 m_curr_pid_is_valid = eLazyBoolYes;
1483                 return m_curr_pid;
1484             }
1485         }
1486     }
1487 
1488     return LLDB_INVALID_PROCESS_ID;
1489 }
1490 
1491 bool
1492 GDBRemoteCommunicationClient::GetLaunchSuccess (std::string &error_str)
1493 {
1494     error_str.clear();
1495     StringExtractorGDBRemote response;
1496     if (SendPacketAndWaitForResponse("qLaunchSuccess", strlen("qLaunchSuccess"), response, false) == PacketResult::Success)
1497     {
1498         if (response.IsOKResponse())
1499             return true;
1500         if (response.GetChar() == 'E')
1501         {
1502             // A string the describes what failed when launching...
1503             error_str = response.GetStringRef().substr(1);
1504         }
1505         else
1506         {
1507             error_str.assign ("unknown error occurred launching process");
1508         }
1509     }
1510     else
1511     {
1512         error_str.assign ("timed out waiting for app to launch");
1513     }
1514     return false;
1515 }
1516 
1517 int
1518 GDBRemoteCommunicationClient::SendArgumentsPacket (const ProcessLaunchInfo &launch_info)
1519 {
1520     // Since we don't get the send argv0 separate from the executable path, we need to
1521     // make sure to use the actual executable path found in the launch_info...
1522     std::vector<const char *> argv;
1523     FileSpec exe_file = launch_info.GetExecutableFile();
1524     std::string exe_path;
1525     const char *arg = NULL;
1526     const Args &launch_args = launch_info.GetArguments();
1527     if (exe_file)
1528         exe_path = exe_file.GetPath(false);
1529     else
1530     {
1531         arg = launch_args.GetArgumentAtIndex(0);
1532         if (arg)
1533             exe_path = arg;
1534     }
1535     if (!exe_path.empty())
1536     {
1537         argv.push_back(exe_path.c_str());
1538         for (uint32_t i=1; (arg = launch_args.GetArgumentAtIndex(i)) != NULL; ++i)
1539         {
1540             if (arg)
1541                 argv.push_back(arg);
1542         }
1543     }
1544     if (!argv.empty())
1545     {
1546         StreamString packet;
1547         packet.PutChar('A');
1548         for (size_t i = 0, n = argv.size(); i < n; ++i)
1549         {
1550             arg = argv[i];
1551             const int arg_len = strlen(arg);
1552             if (i > 0)
1553                 packet.PutChar(',');
1554             packet.Printf("%i,%i,", arg_len * 2, (int)i);
1555             packet.PutBytesAsRawHex8 (arg, arg_len);
1556         }
1557 
1558         StringExtractorGDBRemote response;
1559         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
1560         {
1561             if (response.IsOKResponse())
1562                 return 0;
1563             uint8_t error = response.GetError();
1564             if (error)
1565                 return error;
1566         }
1567     }
1568     return -1;
1569 }
1570 
1571 int
1572 GDBRemoteCommunicationClient::SendEnvironmentPacket (char const *name_equal_value)
1573 {
1574     if (name_equal_value && name_equal_value[0])
1575     {
1576         StreamString packet;
1577         bool send_hex_encoding = false;
1578         for (const char *p = name_equal_value; *p != '\0' && send_hex_encoding == false; ++p)
1579         {
1580             if (isprint(*p))
1581             {
1582                 switch (*p)
1583                 {
1584                     case '$':
1585                     case '#':
1586                     case '*':
1587                     case '}':
1588                         send_hex_encoding = true;
1589                         break;
1590                     default:
1591                         break;
1592                 }
1593             }
1594             else
1595             {
1596                 // We have non printable characters, lets hex encode this...
1597                 send_hex_encoding = true;
1598             }
1599         }
1600 
1601         StringExtractorGDBRemote response;
1602         if (send_hex_encoding)
1603         {
1604             if (m_supports_QEnvironmentHexEncoded)
1605             {
1606                 packet.PutCString("QEnvironmentHexEncoded:");
1607                 packet.PutBytesAsRawHex8 (name_equal_value, strlen(name_equal_value));
1608                 if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
1609                 {
1610                     if (response.IsOKResponse())
1611                         return 0;
1612                     uint8_t error = response.GetError();
1613                     if (error)
1614                         return error;
1615                     if (response.IsUnsupportedResponse())
1616                         m_supports_QEnvironmentHexEncoded = false;
1617                 }
1618             }
1619 
1620         }
1621         else if (m_supports_QEnvironment)
1622         {
1623             packet.Printf("QEnvironment:%s", name_equal_value);
1624             if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
1625             {
1626                 if (response.IsOKResponse())
1627                     return 0;
1628                 uint8_t error = response.GetError();
1629                 if (error)
1630                     return error;
1631                 if (response.IsUnsupportedResponse())
1632                     m_supports_QEnvironment = false;
1633             }
1634         }
1635     }
1636     return -1;
1637 }
1638 
1639 int
1640 GDBRemoteCommunicationClient::SendLaunchArchPacket (char const *arch)
1641 {
1642     if (arch && arch[0])
1643     {
1644         StreamString packet;
1645         packet.Printf("QLaunchArch:%s", arch);
1646         StringExtractorGDBRemote response;
1647         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
1648         {
1649             if (response.IsOKResponse())
1650                 return 0;
1651             uint8_t error = response.GetError();
1652             if (error)
1653                 return error;
1654         }
1655     }
1656     return -1;
1657 }
1658 
1659 int
1660 GDBRemoteCommunicationClient::SendLaunchEventDataPacket (char const *data, bool *was_supported)
1661 {
1662     if (data && *data != '\0')
1663     {
1664         StreamString packet;
1665         packet.Printf("QSetProcessEvent:%s", data);
1666         StringExtractorGDBRemote response;
1667         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
1668         {
1669             if (response.IsOKResponse())
1670             {
1671                 if (was_supported)
1672                     *was_supported = true;
1673                 return 0;
1674             }
1675             else if (response.IsUnsupportedResponse())
1676             {
1677                 if (was_supported)
1678                     *was_supported = false;
1679                 return -1;
1680             }
1681             else
1682             {
1683                 uint8_t error = response.GetError();
1684                 if (was_supported)
1685                     *was_supported = true;
1686                 if (error)
1687                     return error;
1688             }
1689         }
1690     }
1691     return -1;
1692 }
1693 
1694 bool
1695 GDBRemoteCommunicationClient::GetOSVersion (uint32_t &major,
1696                                             uint32_t &minor,
1697                                             uint32_t &update)
1698 {
1699     if (GetHostInfo ())
1700     {
1701         if (m_os_version_major != UINT32_MAX)
1702         {
1703             major = m_os_version_major;
1704             minor = m_os_version_minor;
1705             update = m_os_version_update;
1706             return true;
1707         }
1708     }
1709     return false;
1710 }
1711 
1712 bool
1713 GDBRemoteCommunicationClient::GetOSBuildString (std::string &s)
1714 {
1715     if (GetHostInfo ())
1716     {
1717         if (!m_os_build.empty())
1718         {
1719             s = m_os_build;
1720             return true;
1721         }
1722     }
1723     s.clear();
1724     return false;
1725 }
1726 
1727 
1728 bool
1729 GDBRemoteCommunicationClient::GetOSKernelDescription (std::string &s)
1730 {
1731     if (GetHostInfo ())
1732     {
1733         if (!m_os_kernel.empty())
1734         {
1735             s = m_os_kernel;
1736             return true;
1737         }
1738     }
1739     s.clear();
1740     return false;
1741 }
1742 
1743 bool
1744 GDBRemoteCommunicationClient::GetHostname (std::string &s)
1745 {
1746     if (GetHostInfo ())
1747     {
1748         if (!m_hostname.empty())
1749         {
1750             s = m_hostname;
1751             return true;
1752         }
1753     }
1754     s.clear();
1755     return false;
1756 }
1757 
1758 ArchSpec
1759 GDBRemoteCommunicationClient::GetSystemArchitecture ()
1760 {
1761     if (GetHostInfo ())
1762         return m_host_arch;
1763     return ArchSpec();
1764 }
1765 
1766 const lldb_private::ArchSpec &
1767 GDBRemoteCommunicationClient::GetProcessArchitecture ()
1768 {
1769     if (m_qProcessInfo_is_valid == eLazyBoolCalculate)
1770         GetCurrentProcessInfo ();
1771     return m_process_arch;
1772 }
1773 
1774 bool
1775 GDBRemoteCommunicationClient::GetGDBServerVersion()
1776 {
1777     if (m_qGDBServerVersion_is_valid == eLazyBoolCalculate)
1778     {
1779         m_gdb_server_name.clear();
1780         m_gdb_server_version = 0;
1781         m_qGDBServerVersion_is_valid = eLazyBoolNo;
1782 
1783         StringExtractorGDBRemote response;
1784         if (SendPacketAndWaitForResponse ("qGDBServerVersion", response, false) == PacketResult::Success)
1785         {
1786             if (response.IsNormalResponse())
1787             {
1788                 std::string name;
1789                 std::string value;
1790                 bool success = false;
1791                 while (response.GetNameColonValue(name, value))
1792                 {
1793                     if (name.compare("name") == 0)
1794                     {
1795                         success = true;
1796                         m_gdb_server_name.swap(value);
1797                     }
1798                     else if (name.compare("version") == 0)
1799                     {
1800                         size_t dot_pos = value.find('.');
1801                         if (dot_pos != std::string::npos)
1802                             value[dot_pos] = '\0';
1803                         const uint32_t version = StringConvert::ToUInt32(value.c_str(), UINT32_MAX, 0);
1804                         if (version != UINT32_MAX)
1805                         {
1806                             success = true;
1807                             m_gdb_server_version = version;
1808                         }
1809                     }
1810                 }
1811                 if (success)
1812                     m_qGDBServerVersion_is_valid = eLazyBoolYes;
1813             }
1814         }
1815     }
1816     return m_qGDBServerVersion_is_valid == eLazyBoolYes;
1817 }
1818 
1819 void
1820 GDBRemoteCommunicationClient::MaybeEnableCompression (std::vector<std::string> supported_compressions)
1821 {
1822     CompressionType avail_type = CompressionType::None;
1823     std::string avail_name;
1824 
1825 #if defined (HAVE_LIBCOMPRESSION)
1826     // libcompression is weak linked so test if compression_decode_buffer() is available
1827     if (compression_decode_buffer != NULL && avail_type == CompressionType::None)
1828     {
1829         for (auto compression : supported_compressions)
1830         {
1831             if (compression == "lzfse")
1832             {
1833                 avail_type = CompressionType::LZFSE;
1834                 avail_name = compression;
1835                 break;
1836             }
1837         }
1838     }
1839 #endif
1840 
1841 #if defined (HAVE_LIBCOMPRESSION)
1842     // libcompression is weak linked so test if compression_decode_buffer() is available
1843     if (compression_decode_buffer != NULL && avail_type == CompressionType::None)
1844     {
1845         for (auto compression : supported_compressions)
1846         {
1847             if (compression == "zlib-deflate")
1848             {
1849                 avail_type = CompressionType::ZlibDeflate;
1850                 avail_name = compression;
1851                 break;
1852             }
1853         }
1854     }
1855 #endif
1856 
1857 #if defined (HAVE_LIBZ)
1858     if (avail_type == CompressionType::None)
1859     {
1860         for (auto compression : supported_compressions)
1861         {
1862             if (compression == "zlib-deflate")
1863             {
1864                 avail_type = CompressionType::ZlibDeflate;
1865                 avail_name = compression;
1866                 break;
1867             }
1868         }
1869     }
1870 #endif
1871 
1872 #if defined (HAVE_LIBCOMPRESSION)
1873     // libcompression is weak linked so test if compression_decode_buffer() is available
1874     if (compression_decode_buffer != NULL && avail_type == CompressionType::None)
1875     {
1876         for (auto compression : supported_compressions)
1877         {
1878             if (compression == "lz4")
1879             {
1880                 avail_type = CompressionType::LZ4;
1881                 avail_name = compression;
1882                 break;
1883             }
1884         }
1885     }
1886 #endif
1887 
1888 #if defined (HAVE_LIBCOMPRESSION)
1889     // libcompression is weak linked so test if compression_decode_buffer() is available
1890     if (compression_decode_buffer != NULL && avail_type == CompressionType::None)
1891     {
1892         for (auto compression : supported_compressions)
1893         {
1894             if (compression == "lzma")
1895             {
1896                 avail_type = CompressionType::LZMA;
1897                 avail_name = compression;
1898                 break;
1899             }
1900         }
1901     }
1902 #endif
1903 
1904     if (avail_type != CompressionType::None)
1905     {
1906         StringExtractorGDBRemote response;
1907         std::string packet = "QEnableCompression:type:" + avail_name + ";";
1908         if (SendPacketAndWaitForResponse (packet.c_str(), response, false) !=  PacketResult::Success)
1909             return;
1910 
1911         if (response.IsOKResponse())
1912         {
1913             m_compression_type = avail_type;
1914         }
1915     }
1916 }
1917 
1918 const char *
1919 GDBRemoteCommunicationClient::GetGDBServerProgramName()
1920 {
1921     if (GetGDBServerVersion())
1922     {
1923         if (!m_gdb_server_name.empty())
1924             return m_gdb_server_name.c_str();
1925     }
1926     return NULL;
1927 }
1928 
1929 uint32_t
1930 GDBRemoteCommunicationClient::GetGDBServerProgramVersion()
1931 {
1932     if (GetGDBServerVersion())
1933         return m_gdb_server_version;
1934     return 0;
1935 }
1936 
1937 bool
1938 GDBRemoteCommunicationClient::GetDefaultThreadId (lldb::tid_t &tid)
1939 {
1940     StringExtractorGDBRemote response;
1941     if (SendPacketAndWaitForResponse("qC",response,false) !=  PacketResult::Success)
1942         return false;
1943 
1944     if (!response.IsNormalResponse())
1945         return false;
1946 
1947     if (response.GetChar() == 'Q' && response.GetChar() == 'C')
1948         tid = response.GetHexMaxU32(true, -1);
1949 
1950     return true;
1951 }
1952 
1953 bool
1954 GDBRemoteCommunicationClient::GetHostInfo (bool force)
1955 {
1956     Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_PROCESS));
1957 
1958     if (force || m_qHostInfo_is_valid == eLazyBoolCalculate)
1959     {
1960         m_qHostInfo_is_valid = eLazyBoolNo;
1961         StringExtractorGDBRemote response;
1962         if (SendPacketAndWaitForResponse ("qHostInfo", response, false) == PacketResult::Success)
1963         {
1964             if (response.IsNormalResponse())
1965             {
1966                 std::string name;
1967                 std::string value;
1968                 uint32_t cpu = LLDB_INVALID_CPUTYPE;
1969                 uint32_t sub = 0;
1970                 std::string arch_name;
1971                 std::string os_name;
1972                 std::string vendor_name;
1973                 std::string triple;
1974                 std::string distribution_id;
1975                 uint32_t pointer_byte_size = 0;
1976                 StringExtractor extractor;
1977                 ByteOrder byte_order = eByteOrderInvalid;
1978                 uint32_t num_keys_decoded = 0;
1979                 while (response.GetNameColonValue(name, value))
1980                 {
1981                     if (name.compare("cputype") == 0)
1982                     {
1983                         // exception type in big endian hex
1984                         cpu = StringConvert::ToUInt32 (value.c_str(), LLDB_INVALID_CPUTYPE, 0);
1985                         if (cpu != LLDB_INVALID_CPUTYPE)
1986                             ++num_keys_decoded;
1987                     }
1988                     else if (name.compare("cpusubtype") == 0)
1989                     {
1990                         // exception count in big endian hex
1991                         sub = StringConvert::ToUInt32 (value.c_str(), 0, 0);
1992                         if (sub != 0)
1993                             ++num_keys_decoded;
1994                     }
1995                     else if (name.compare("arch") == 0)
1996                     {
1997                         arch_name.swap (value);
1998                         ++num_keys_decoded;
1999                     }
2000                     else if (name.compare("triple") == 0)
2001                     {
2002                         extractor.GetStringRef ().swap (value);
2003                         extractor.SetFilePos(0);
2004                         extractor.GetHexByteString (triple);
2005                         ++num_keys_decoded;
2006                     }
2007                     else if (name.compare ("distribution_id") == 0)
2008                     {
2009                         extractor.GetStringRef ().swap (value);
2010                         extractor.SetFilePos (0);
2011                         extractor.GetHexByteString (distribution_id);
2012                         ++num_keys_decoded;
2013                     }
2014                     else if (name.compare("os_build") == 0)
2015                     {
2016                         extractor.GetStringRef().swap(value);
2017                         extractor.SetFilePos(0);
2018                         extractor.GetHexByteString (m_os_build);
2019                         ++num_keys_decoded;
2020                     }
2021                     else if (name.compare("hostname") == 0)
2022                     {
2023                         extractor.GetStringRef().swap(value);
2024                         extractor.SetFilePos(0);
2025                         extractor.GetHexByteString (m_hostname);
2026                         ++num_keys_decoded;
2027                     }
2028                     else if (name.compare("os_kernel") == 0)
2029                     {
2030                         extractor.GetStringRef().swap(value);
2031                         extractor.SetFilePos(0);
2032                         extractor.GetHexByteString (m_os_kernel);
2033                         ++num_keys_decoded;
2034                     }
2035                     else if (name.compare("ostype") == 0)
2036                     {
2037                         os_name.swap (value);
2038                         ++num_keys_decoded;
2039                     }
2040                     else if (name.compare("vendor") == 0)
2041                     {
2042                         vendor_name.swap(value);
2043                         ++num_keys_decoded;
2044                     }
2045                     else if (name.compare("endian") == 0)
2046                     {
2047                         ++num_keys_decoded;
2048                         if (value.compare("little") == 0)
2049                             byte_order = eByteOrderLittle;
2050                         else if (value.compare("big") == 0)
2051                             byte_order = eByteOrderBig;
2052                         else if (value.compare("pdp") == 0)
2053                             byte_order = eByteOrderPDP;
2054                         else
2055                             --num_keys_decoded;
2056                     }
2057                     else if (name.compare("ptrsize") == 0)
2058                     {
2059                         pointer_byte_size = StringConvert::ToUInt32 (value.c_str(), 0, 0);
2060                         if (pointer_byte_size != 0)
2061                             ++num_keys_decoded;
2062                     }
2063                     else if (name.compare("os_version") == 0)
2064                     {
2065                         Args::StringToVersion (value.c_str(),
2066                                                m_os_version_major,
2067                                                m_os_version_minor,
2068                                                m_os_version_update);
2069                         if (m_os_version_major != UINT32_MAX)
2070                             ++num_keys_decoded;
2071                     }
2072                     else if (name.compare("watchpoint_exceptions_received") == 0)
2073                     {
2074                         ++num_keys_decoded;
2075                         if (strcmp(value.c_str(),"before") == 0)
2076                             m_watchpoints_trigger_after_instruction = eLazyBoolNo;
2077                         else if (strcmp(value.c_str(),"after") == 0)
2078                             m_watchpoints_trigger_after_instruction = eLazyBoolYes;
2079                         else
2080                             --num_keys_decoded;
2081                     }
2082                     else if (name.compare("default_packet_timeout") == 0)
2083                     {
2084                         m_default_packet_timeout = StringConvert::ToUInt32(value.c_str(), 0);
2085                         if (m_default_packet_timeout > 0)
2086                         {
2087                             SetPacketTimeout(m_default_packet_timeout);
2088                             ++num_keys_decoded;
2089                         }
2090                     }
2091 
2092                 }
2093 
2094                 if (num_keys_decoded > 0)
2095                     m_qHostInfo_is_valid = eLazyBoolYes;
2096 
2097                 if (triple.empty())
2098                 {
2099                     if (arch_name.empty())
2100                     {
2101                         if (cpu != LLDB_INVALID_CPUTYPE)
2102                         {
2103                             m_host_arch.SetArchitecture (eArchTypeMachO, cpu, sub);
2104                             if (pointer_byte_size)
2105                             {
2106                                 assert (pointer_byte_size == m_host_arch.GetAddressByteSize());
2107                             }
2108                             if (byte_order != eByteOrderInvalid)
2109                             {
2110                                 assert (byte_order == m_host_arch.GetByteOrder());
2111                             }
2112 
2113                             if (!os_name.empty() && vendor_name.compare("apple") == 0 && os_name.find("darwin") == 0)
2114                             {
2115                                 switch (m_host_arch.GetMachine())
2116                                 {
2117                                 case llvm::Triple::aarch64:
2118                                 case llvm::Triple::arm:
2119                                 case llvm::Triple::thumb:
2120                                     os_name = "ios";
2121                                     break;
2122                                 default:
2123                                     os_name = "macosx";
2124                                     break;
2125                                 }
2126                             }
2127                             if (!vendor_name.empty())
2128                                 m_host_arch.GetTriple().setVendorName (llvm::StringRef (vendor_name));
2129                             if (!os_name.empty())
2130                                 m_host_arch.GetTriple().setOSName (llvm::StringRef (os_name));
2131 
2132                         }
2133                     }
2134                     else
2135                     {
2136                         std::string triple;
2137                         triple += arch_name;
2138                         if (!vendor_name.empty() || !os_name.empty())
2139                         {
2140                             triple += '-';
2141                             if (vendor_name.empty())
2142                                 triple += "unknown";
2143                             else
2144                                 triple += vendor_name;
2145                             triple += '-';
2146                             if (os_name.empty())
2147                                 triple += "unknown";
2148                             else
2149                                 triple += os_name;
2150                         }
2151                         m_host_arch.SetTriple (triple.c_str());
2152 
2153                         llvm::Triple &host_triple = m_host_arch.GetTriple();
2154                         if (host_triple.getVendor() == llvm::Triple::Apple && host_triple.getOS() == llvm::Triple::Darwin)
2155                         {
2156                             switch (m_host_arch.GetMachine())
2157                             {
2158                                 case llvm::Triple::aarch64:
2159                                 case llvm::Triple::arm:
2160                                 case llvm::Triple::thumb:
2161                                     host_triple.setOS(llvm::Triple::IOS);
2162                                     break;
2163                                 default:
2164                                     host_triple.setOS(llvm::Triple::MacOSX);
2165                                     break;
2166                             }
2167                         }
2168                         if (pointer_byte_size)
2169                         {
2170                             assert (pointer_byte_size == m_host_arch.GetAddressByteSize());
2171                         }
2172                         if (byte_order != eByteOrderInvalid)
2173                         {
2174                             assert (byte_order == m_host_arch.GetByteOrder());
2175                         }
2176 
2177                     }
2178                 }
2179                 else
2180                 {
2181                     m_host_arch.SetTriple (triple.c_str());
2182                     if (pointer_byte_size)
2183                     {
2184                         assert (pointer_byte_size == m_host_arch.GetAddressByteSize());
2185                     }
2186                     if (byte_order != eByteOrderInvalid)
2187                     {
2188                         assert (byte_order == m_host_arch.GetByteOrder());
2189                     }
2190 
2191                     if (log)
2192                         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 ());
2193                 }
2194                 if (!distribution_id.empty ())
2195                     m_host_arch.SetDistributionId (distribution_id.c_str ());
2196             }
2197         }
2198     }
2199     return m_qHostInfo_is_valid == eLazyBoolYes;
2200 }
2201 
2202 int
2203 GDBRemoteCommunicationClient::SendAttach
2204 (
2205     lldb::pid_t pid,
2206     StringExtractorGDBRemote& response
2207 )
2208 {
2209     if (pid != LLDB_INVALID_PROCESS_ID)
2210     {
2211         char packet[64];
2212         const int packet_len = ::snprintf (packet, sizeof(packet), "vAttach;%" PRIx64, pid);
2213         assert (packet_len < (int)sizeof(packet));
2214         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
2215         {
2216             if (response.IsErrorResponse())
2217                 return response.GetError();
2218             return 0;
2219         }
2220     }
2221     return -1;
2222 }
2223 
2224 int
2225 GDBRemoteCommunicationClient::SendStdinNotification (const char* data, size_t data_len)
2226 {
2227     StreamString packet;
2228     packet.PutCString("I");
2229     packet.PutBytesAsRawHex8(data, data_len);
2230     StringExtractorGDBRemote response;
2231     if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
2232     {
2233         return 0;
2234     }
2235     return response.GetError();
2236 
2237 }
2238 
2239 const lldb_private::ArchSpec &
2240 GDBRemoteCommunicationClient::GetHostArchitecture ()
2241 {
2242     if (m_qHostInfo_is_valid == eLazyBoolCalculate)
2243         GetHostInfo ();
2244     return m_host_arch;
2245 }
2246 
2247 uint32_t
2248 GDBRemoteCommunicationClient::GetHostDefaultPacketTimeout ()
2249 {
2250     if (m_qHostInfo_is_valid == eLazyBoolCalculate)
2251         GetHostInfo ();
2252     return m_default_packet_timeout;
2253 }
2254 
2255 addr_t
2256 GDBRemoteCommunicationClient::AllocateMemory (size_t size, uint32_t permissions)
2257 {
2258     if (m_supports_alloc_dealloc_memory != eLazyBoolNo)
2259     {
2260         m_supports_alloc_dealloc_memory = eLazyBoolYes;
2261         char packet[64];
2262         const int packet_len = ::snprintf (packet, sizeof(packet), "_M%" PRIx64 ",%s%s%s",
2263                                            (uint64_t)size,
2264                                            permissions & lldb::ePermissionsReadable ? "r" : "",
2265                                            permissions & lldb::ePermissionsWritable ? "w" : "",
2266                                            permissions & lldb::ePermissionsExecutable ? "x" : "");
2267         assert (packet_len < (int)sizeof(packet));
2268         StringExtractorGDBRemote response;
2269         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
2270         {
2271             if (response.IsUnsupportedResponse())
2272                 m_supports_alloc_dealloc_memory = eLazyBoolNo;
2273             else if (!response.IsErrorResponse())
2274                 return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
2275         }
2276         else
2277         {
2278             m_supports_alloc_dealloc_memory = eLazyBoolNo;
2279         }
2280     }
2281     return LLDB_INVALID_ADDRESS;
2282 }
2283 
2284 bool
2285 GDBRemoteCommunicationClient::DeallocateMemory (addr_t addr)
2286 {
2287     if (m_supports_alloc_dealloc_memory != eLazyBoolNo)
2288     {
2289         m_supports_alloc_dealloc_memory = eLazyBoolYes;
2290         char packet[64];
2291         const int packet_len = ::snprintf(packet, sizeof(packet), "_m%" PRIx64, (uint64_t)addr);
2292         assert (packet_len < (int)sizeof(packet));
2293         StringExtractorGDBRemote response;
2294         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
2295         {
2296             if (response.IsUnsupportedResponse())
2297                 m_supports_alloc_dealloc_memory = eLazyBoolNo;
2298             else if (response.IsOKResponse())
2299                 return true;
2300         }
2301         else
2302         {
2303             m_supports_alloc_dealloc_memory = eLazyBoolNo;
2304         }
2305     }
2306     return false;
2307 }
2308 
2309 Error
2310 GDBRemoteCommunicationClient::Detach (bool keep_stopped)
2311 {
2312     Error error;
2313 
2314     if (keep_stopped)
2315     {
2316         if (m_supports_detach_stay_stopped == eLazyBoolCalculate)
2317         {
2318             char packet[64];
2319             const int packet_len = ::snprintf(packet, sizeof(packet), "qSupportsDetachAndStayStopped:");
2320             assert (packet_len < (int)sizeof(packet));
2321             StringExtractorGDBRemote response;
2322             if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success
2323                   && response.IsOKResponse())
2324             {
2325                 m_supports_detach_stay_stopped = eLazyBoolYes;
2326             }
2327             else
2328             {
2329                 m_supports_detach_stay_stopped = eLazyBoolNo;
2330             }
2331         }
2332 
2333         if (m_supports_detach_stay_stopped == eLazyBoolNo)
2334         {
2335             error.SetErrorString("Stays stopped not supported by this target.");
2336             return error;
2337         }
2338         else
2339         {
2340             StringExtractorGDBRemote response;
2341             PacketResult packet_result = SendPacketAndWaitForResponse ("D1", 2, response, false);
2342             if (packet_result != PacketResult::Success)
2343                 error.SetErrorString ("Sending extended disconnect packet failed.");
2344         }
2345     }
2346     else
2347     {
2348         StringExtractorGDBRemote response;
2349         PacketResult packet_result = SendPacketAndWaitForResponse ("D", 1, response, false);
2350         if (packet_result != PacketResult::Success)
2351             error.SetErrorString ("Sending disconnect packet failed.");
2352     }
2353     return error;
2354 }
2355 
2356 Error
2357 GDBRemoteCommunicationClient::GetMemoryRegionInfo (lldb::addr_t addr,
2358                                                   lldb_private::MemoryRegionInfo &region_info)
2359 {
2360     Error error;
2361     region_info.Clear();
2362 
2363     if (m_supports_memory_region_info != eLazyBoolNo)
2364     {
2365         m_supports_memory_region_info = eLazyBoolYes;
2366         char packet[64];
2367         const int packet_len = ::snprintf(packet, sizeof(packet), "qMemoryRegionInfo:%" PRIx64, (uint64_t)addr);
2368         assert (packet_len < (int)sizeof(packet));
2369         StringExtractorGDBRemote response;
2370         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
2371         {
2372             std::string name;
2373             std::string value;
2374             addr_t addr_value;
2375             bool success = true;
2376             bool saw_permissions = false;
2377             while (success && response.GetNameColonValue(name, value))
2378             {
2379                 if (name.compare ("start") == 0)
2380                 {
2381                     addr_value = StringConvert::ToUInt64(value.c_str(), LLDB_INVALID_ADDRESS, 16, &success);
2382                     if (success)
2383                         region_info.GetRange().SetRangeBase(addr_value);
2384                 }
2385                 else if (name.compare ("size") == 0)
2386                 {
2387                     addr_value = StringConvert::ToUInt64(value.c_str(), 0, 16, &success);
2388                     if (success)
2389                         region_info.GetRange().SetByteSize (addr_value);
2390                 }
2391                 else if (name.compare ("permissions") == 0 && region_info.GetRange().IsValid())
2392                 {
2393                     saw_permissions = true;
2394                     if (region_info.GetRange().Contains (addr))
2395                     {
2396                         if (value.find('r') != std::string::npos)
2397                             region_info.SetReadable (MemoryRegionInfo::eYes);
2398                         else
2399                             region_info.SetReadable (MemoryRegionInfo::eNo);
2400 
2401                         if (value.find('w') != std::string::npos)
2402                             region_info.SetWritable (MemoryRegionInfo::eYes);
2403                         else
2404                             region_info.SetWritable (MemoryRegionInfo::eNo);
2405 
2406                         if (value.find('x') != std::string::npos)
2407                             region_info.SetExecutable (MemoryRegionInfo::eYes);
2408                         else
2409                             region_info.SetExecutable (MemoryRegionInfo::eNo);
2410                     }
2411                     else
2412                     {
2413                         // The reported region does not contain this address -- we're looking at an unmapped page
2414                         region_info.SetReadable (MemoryRegionInfo::eNo);
2415                         region_info.SetWritable (MemoryRegionInfo::eNo);
2416                         region_info.SetExecutable (MemoryRegionInfo::eNo);
2417                     }
2418                 }
2419                 else if (name.compare ("error") == 0)
2420                 {
2421                     StringExtractorGDBRemote name_extractor;
2422                     // Swap "value" over into "name_extractor"
2423                     name_extractor.GetStringRef().swap(value);
2424                     // Now convert the HEX bytes into a string value
2425                     name_extractor.GetHexByteString (value);
2426                     error.SetErrorString(value.c_str());
2427                 }
2428             }
2429 
2430             // We got a valid address range back but no permissions -- which means this is an unmapped page
2431             if (region_info.GetRange().IsValid() && saw_permissions == false)
2432             {
2433                 region_info.SetReadable (MemoryRegionInfo::eNo);
2434                 region_info.SetWritable (MemoryRegionInfo::eNo);
2435                 region_info.SetExecutable (MemoryRegionInfo::eNo);
2436             }
2437         }
2438         else
2439         {
2440             m_supports_memory_region_info = eLazyBoolNo;
2441         }
2442     }
2443 
2444     if (m_supports_memory_region_info == eLazyBoolNo)
2445     {
2446         error.SetErrorString("qMemoryRegionInfo is not supported");
2447     }
2448     if (error.Fail())
2449         region_info.Clear();
2450     return error;
2451 
2452 }
2453 
2454 Error
2455 GDBRemoteCommunicationClient::GetWatchpointSupportInfo (uint32_t &num)
2456 {
2457     Error error;
2458 
2459     if (m_supports_watchpoint_support_info == eLazyBoolYes)
2460     {
2461         num = m_num_supported_hardware_watchpoints;
2462         return error;
2463     }
2464 
2465     // Set num to 0 first.
2466     num = 0;
2467     if (m_supports_watchpoint_support_info != eLazyBoolNo)
2468     {
2469         char packet[64];
2470         const int packet_len = ::snprintf(packet, sizeof(packet), "qWatchpointSupportInfo:");
2471         assert (packet_len < (int)sizeof(packet));
2472         StringExtractorGDBRemote response;
2473         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
2474         {
2475             m_supports_watchpoint_support_info = eLazyBoolYes;
2476             std::string name;
2477             std::string value;
2478             while (response.GetNameColonValue(name, value))
2479             {
2480                 if (name.compare ("num") == 0)
2481                 {
2482                     num = StringConvert::ToUInt32(value.c_str(), 0, 0);
2483                     m_num_supported_hardware_watchpoints = num;
2484                 }
2485             }
2486         }
2487         else
2488         {
2489             m_supports_watchpoint_support_info = eLazyBoolNo;
2490         }
2491     }
2492 
2493     if (m_supports_watchpoint_support_info == eLazyBoolNo)
2494     {
2495         error.SetErrorString("qWatchpointSupportInfo is not supported");
2496     }
2497     return error;
2498 
2499 }
2500 
2501 lldb_private::Error
2502 GDBRemoteCommunicationClient::GetWatchpointSupportInfo (uint32_t &num, bool& after, const ArchSpec &arch)
2503 {
2504     Error error(GetWatchpointSupportInfo(num));
2505     if (error.Success())
2506         error = GetWatchpointsTriggerAfterInstruction(after, arch);
2507     return error;
2508 }
2509 
2510 lldb_private::Error
2511 GDBRemoteCommunicationClient::GetWatchpointsTriggerAfterInstruction (bool &after, const ArchSpec &arch)
2512 {
2513     Error error;
2514     llvm::Triple::ArchType atype = arch.GetMachine();
2515 
2516     // we assume watchpoints will happen after running the relevant opcode
2517     // and we only want to override this behavior if we have explicitly
2518     // received a qHostInfo telling us otherwise
2519     if (m_qHostInfo_is_valid != eLazyBoolYes)
2520     {
2521         // On targets like MIPS, watchpoint exceptions are always generated
2522         // before the instruction is executed. The connected target may not
2523         // support qHostInfo or qWatchpointSupportInfo packets.
2524         if (atype == llvm::Triple::mips || atype == llvm::Triple::mipsel
2525             || atype == llvm::Triple::mips64 || atype == llvm::Triple::mips64el)
2526             after = false;
2527         else
2528             after = true;
2529     }
2530     else
2531     {
2532         // For MIPS, set m_watchpoints_trigger_after_instruction to eLazyBoolNo
2533         // if it is not calculated before.
2534         if (m_watchpoints_trigger_after_instruction == eLazyBoolCalculate &&
2535             (atype == llvm::Triple::mips || atype == llvm::Triple::mipsel
2536             || atype == llvm::Triple::mips64 || atype == llvm::Triple::mips64el))
2537             m_watchpoints_trigger_after_instruction = eLazyBoolNo;
2538 
2539         after = (m_watchpoints_trigger_after_instruction != eLazyBoolNo);
2540     }
2541     return error;
2542 }
2543 
2544 int
2545 GDBRemoteCommunicationClient::SetSTDIN(const FileSpec &file_spec)
2546 {
2547     if (file_spec)
2548     {
2549         std::string path{file_spec.GetPath(false)};
2550         StreamString packet;
2551         packet.PutCString("QSetSTDIN:");
2552         packet.PutCStringAsRawHex8(path.c_str());
2553 
2554         StringExtractorGDBRemote response;
2555         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
2556         {
2557             if (response.IsOKResponse())
2558                 return 0;
2559             uint8_t error = response.GetError();
2560             if (error)
2561                 return error;
2562         }
2563     }
2564     return -1;
2565 }
2566 
2567 int
2568 GDBRemoteCommunicationClient::SetSTDOUT(const FileSpec &file_spec)
2569 {
2570     if (file_spec)
2571     {
2572         std::string path{file_spec.GetPath(false)};
2573         StreamString packet;
2574         packet.PutCString("QSetSTDOUT:");
2575         packet.PutCStringAsRawHex8(path.c_str());
2576 
2577         StringExtractorGDBRemote response;
2578         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
2579         {
2580             if (response.IsOKResponse())
2581                 return 0;
2582             uint8_t error = response.GetError();
2583             if (error)
2584                 return error;
2585         }
2586     }
2587     return -1;
2588 }
2589 
2590 int
2591 GDBRemoteCommunicationClient::SetSTDERR(const FileSpec &file_spec)
2592 {
2593     if (file_spec)
2594     {
2595         std::string path{file_spec.GetPath(false)};
2596         StreamString packet;
2597         packet.PutCString("QSetSTDERR:");
2598         packet.PutCStringAsRawHex8(path.c_str());
2599 
2600         StringExtractorGDBRemote response;
2601         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
2602         {
2603             if (response.IsOKResponse())
2604                 return 0;
2605             uint8_t error = response.GetError();
2606             if (error)
2607                 return error;
2608         }
2609     }
2610     return -1;
2611 }
2612 
2613 bool
2614 GDBRemoteCommunicationClient::GetWorkingDir(FileSpec &working_dir)
2615 {
2616     StringExtractorGDBRemote response;
2617     if (SendPacketAndWaitForResponse ("qGetWorkingDir", response, false) == PacketResult::Success)
2618     {
2619         if (response.IsUnsupportedResponse())
2620             return false;
2621         if (response.IsErrorResponse())
2622             return false;
2623         std::string cwd;
2624         response.GetHexByteString(cwd);
2625         working_dir.SetFile(cwd, false, GetHostArchitecture());
2626         return !cwd.empty();
2627     }
2628     return false;
2629 }
2630 
2631 int
2632 GDBRemoteCommunicationClient::SetWorkingDir(const FileSpec &working_dir)
2633 {
2634     if (working_dir)
2635     {
2636         std::string path{working_dir.GetPath(false)};
2637         StreamString packet;
2638         packet.PutCString("QSetWorkingDir:");
2639         packet.PutCStringAsRawHex8(path.c_str());
2640 
2641         StringExtractorGDBRemote response;
2642         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
2643         {
2644             if (response.IsOKResponse())
2645                 return 0;
2646             uint8_t error = response.GetError();
2647             if (error)
2648                 return error;
2649         }
2650     }
2651     return -1;
2652 }
2653 
2654 int
2655 GDBRemoteCommunicationClient::SetDisableASLR (bool enable)
2656 {
2657     char packet[32];
2658     const int packet_len = ::snprintf (packet, sizeof (packet), "QSetDisableASLR:%i", enable ? 1 : 0);
2659     assert (packet_len < (int)sizeof(packet));
2660     StringExtractorGDBRemote response;
2661     if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
2662     {
2663         if (response.IsOKResponse())
2664             return 0;
2665         uint8_t error = response.GetError();
2666         if (error)
2667             return error;
2668     }
2669     return -1;
2670 }
2671 
2672 int
2673 GDBRemoteCommunicationClient::SetDetachOnError (bool enable)
2674 {
2675     char packet[32];
2676     const int packet_len = ::snprintf (packet, sizeof (packet), "QSetDetachOnError:%i", enable ? 1 : 0);
2677     assert (packet_len < (int)sizeof(packet));
2678     StringExtractorGDBRemote response;
2679     if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
2680     {
2681         if (response.IsOKResponse())
2682             return 0;
2683         uint8_t error = response.GetError();
2684         if (error)
2685             return error;
2686     }
2687     return -1;
2688 }
2689 
2690 
2691 bool
2692 GDBRemoteCommunicationClient::DecodeProcessInfoResponse (StringExtractorGDBRemote &response, ProcessInstanceInfo &process_info)
2693 {
2694     if (response.IsNormalResponse())
2695     {
2696         std::string name;
2697         std::string value;
2698         StringExtractor extractor;
2699 
2700         uint32_t cpu = LLDB_INVALID_CPUTYPE;
2701         uint32_t sub = 0;
2702         std::string vendor;
2703         std::string os_type;
2704 
2705         while (response.GetNameColonValue(name, value))
2706         {
2707             if (name.compare("pid") == 0)
2708             {
2709                 process_info.SetProcessID (StringConvert::ToUInt32 (value.c_str(), LLDB_INVALID_PROCESS_ID, 0));
2710             }
2711             else if (name.compare("ppid") == 0)
2712             {
2713                 process_info.SetParentProcessID (StringConvert::ToUInt32 (value.c_str(), LLDB_INVALID_PROCESS_ID, 0));
2714             }
2715             else if (name.compare("uid") == 0)
2716             {
2717                 process_info.SetUserID (StringConvert::ToUInt32 (value.c_str(), UINT32_MAX, 0));
2718             }
2719             else if (name.compare("euid") == 0)
2720             {
2721                 process_info.SetEffectiveUserID (StringConvert::ToUInt32 (value.c_str(), UINT32_MAX, 0));
2722             }
2723             else if (name.compare("gid") == 0)
2724             {
2725                 process_info.SetGroupID (StringConvert::ToUInt32 (value.c_str(), UINT32_MAX, 0));
2726             }
2727             else if (name.compare("egid") == 0)
2728             {
2729                 process_info.SetEffectiveGroupID (StringConvert::ToUInt32 (value.c_str(), UINT32_MAX, 0));
2730             }
2731             else if (name.compare("triple") == 0)
2732             {
2733                 StringExtractor extractor;
2734                 extractor.GetStringRef().swap(value);
2735                 extractor.SetFilePos(0);
2736                 extractor.GetHexByteString (value);
2737                 process_info.GetArchitecture ().SetTriple (value.c_str());
2738             }
2739             else if (name.compare("name") == 0)
2740             {
2741                 StringExtractor extractor;
2742                 // The process name from ASCII hex bytes since we can't
2743                 // control the characters in a process name
2744                 extractor.GetStringRef().swap(value);
2745                 extractor.SetFilePos(0);
2746                 extractor.GetHexByteString (value);
2747                 process_info.GetExecutableFile().SetFile (value.c_str(), false);
2748             }
2749             else if (name.compare("cputype") == 0)
2750             {
2751                 cpu = StringConvert::ToUInt32 (value.c_str(), LLDB_INVALID_CPUTYPE, 16);
2752             }
2753             else if (name.compare("cpusubtype") == 0)
2754             {
2755                 sub = StringConvert::ToUInt32 (value.c_str(), 0, 16);
2756             }
2757             else if (name.compare("vendor") == 0)
2758             {
2759                 vendor = value;
2760             }
2761             else if (name.compare("ostype") == 0)
2762             {
2763                 os_type = value;
2764             }
2765         }
2766 
2767         if (cpu != LLDB_INVALID_CPUTYPE && !vendor.empty() && !os_type.empty())
2768         {
2769             if (vendor == "apple")
2770             {
2771                 process_info.GetArchitecture().SetArchitecture (eArchTypeMachO, cpu, sub);
2772                 process_info.GetArchitecture().GetTriple().setVendorName (llvm::StringRef (vendor));
2773                 process_info.GetArchitecture().GetTriple().setOSName (llvm::StringRef (os_type));
2774             }
2775         }
2776 
2777         if (process_info.GetProcessID() != LLDB_INVALID_PROCESS_ID)
2778             return true;
2779     }
2780     return false;
2781 }
2782 
2783 bool
2784 GDBRemoteCommunicationClient::GetProcessInfo (lldb::pid_t pid, ProcessInstanceInfo &process_info)
2785 {
2786     process_info.Clear();
2787 
2788     if (m_supports_qProcessInfoPID)
2789     {
2790         char packet[32];
2791         const int packet_len = ::snprintf (packet, sizeof (packet), "qProcessInfoPID:%" PRIu64, pid);
2792         assert (packet_len < (int)sizeof(packet));
2793         StringExtractorGDBRemote response;
2794         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
2795         {
2796             return DecodeProcessInfoResponse (response, process_info);
2797         }
2798         else
2799         {
2800             m_supports_qProcessInfoPID = false;
2801             return false;
2802         }
2803     }
2804     return false;
2805 }
2806 
2807 bool
2808 GDBRemoteCommunicationClient::GetCurrentProcessInfo (bool allow_lazy)
2809 {
2810     Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_PROCESS | GDBR_LOG_PACKETS));
2811 
2812     if (allow_lazy)
2813     {
2814         if (m_qProcessInfo_is_valid == eLazyBoolYes)
2815             return true;
2816         if (m_qProcessInfo_is_valid == eLazyBoolNo)
2817             return false;
2818     }
2819 
2820     GetHostInfo ();
2821 
2822     StringExtractorGDBRemote response;
2823     if (SendPacketAndWaitForResponse ("qProcessInfo", response, false) == PacketResult::Success)
2824     {
2825         if (response.IsNormalResponse())
2826         {
2827             std::string name;
2828             std::string value;
2829             uint32_t cpu = LLDB_INVALID_CPUTYPE;
2830             uint32_t sub = 0;
2831             std::string arch_name;
2832             std::string os_name;
2833             std::string vendor_name;
2834             std::string triple;
2835             uint32_t pointer_byte_size = 0;
2836             StringExtractor extractor;
2837             ByteOrder byte_order = eByteOrderInvalid;
2838             uint32_t num_keys_decoded = 0;
2839             lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
2840             while (response.GetNameColonValue(name, value))
2841             {
2842                 if (name.compare("cputype") == 0)
2843                 {
2844                     cpu = StringConvert::ToUInt32 (value.c_str(), LLDB_INVALID_CPUTYPE, 16);
2845                     if (cpu != LLDB_INVALID_CPUTYPE)
2846                         ++num_keys_decoded;
2847                 }
2848                 else if (name.compare("cpusubtype") == 0)
2849                 {
2850                     sub = StringConvert::ToUInt32 (value.c_str(), 0, 16);
2851                     if (sub != 0)
2852                         ++num_keys_decoded;
2853                 }
2854                 else if (name.compare("triple") == 0)
2855                 {
2856                     StringExtractor extractor;
2857                     extractor.GetStringRef().swap(value);
2858                     extractor.SetFilePos(0);
2859                     extractor.GetHexByteString (triple);
2860                     ++num_keys_decoded;
2861                 }
2862                 else if (name.compare("ostype") == 0)
2863                 {
2864                     os_name.swap (value);
2865                     ++num_keys_decoded;
2866                 }
2867                 else if (name.compare("vendor") == 0)
2868                 {
2869                     vendor_name.swap(value);
2870                     ++num_keys_decoded;
2871                 }
2872                 else if (name.compare("endian") == 0)
2873                 {
2874                     ++num_keys_decoded;
2875                     if (value.compare("little") == 0)
2876                         byte_order = eByteOrderLittle;
2877                     else if (value.compare("big") == 0)
2878                         byte_order = eByteOrderBig;
2879                     else if (value.compare("pdp") == 0)
2880                         byte_order = eByteOrderPDP;
2881                     else
2882                         --num_keys_decoded;
2883                 }
2884                 else if (name.compare("ptrsize") == 0)
2885                 {
2886                     pointer_byte_size = StringConvert::ToUInt32 (value.c_str(), 0, 16);
2887                     if (pointer_byte_size != 0)
2888                         ++num_keys_decoded;
2889                 }
2890                 else if (name.compare("pid") == 0)
2891                 {
2892                     pid = StringConvert::ToUInt64(value.c_str(), 0, 16);
2893                     if (pid != LLDB_INVALID_PROCESS_ID)
2894                         ++num_keys_decoded;
2895                 }
2896             }
2897             if (num_keys_decoded > 0)
2898                 m_qProcessInfo_is_valid = eLazyBoolYes;
2899             if (pid != LLDB_INVALID_PROCESS_ID)
2900             {
2901                 m_curr_pid_is_valid = eLazyBoolYes;
2902                 m_curr_pid = pid;
2903             }
2904 
2905             // Set the ArchSpec from the triple if we have it.
2906             if (!triple.empty ())
2907             {
2908                 m_process_arch.SetTriple (triple.c_str ());
2909                 if (pointer_byte_size)
2910                 {
2911                     assert (pointer_byte_size == m_process_arch.GetAddressByteSize());
2912                 }
2913             }
2914             else if (cpu != LLDB_INVALID_CPUTYPE && !os_name.empty() && !vendor_name.empty())
2915             {
2916                 llvm::Triple triple(llvm::Twine("-") + vendor_name + "-" + os_name);
2917 
2918                 assert(triple.getObjectFormat() != llvm::Triple::UnknownObjectFormat);
2919                 switch (triple.getObjectFormat()) {
2920                     case llvm::Triple::MachO:
2921                         m_process_arch.SetArchitecture (eArchTypeMachO, cpu, sub);
2922                         break;
2923                     case llvm::Triple::ELF:
2924                         m_process_arch.SetArchitecture (eArchTypeELF, cpu, sub);
2925                         break;
2926                     case llvm::Triple::COFF:
2927                         m_process_arch.SetArchitecture (eArchTypeCOFF, cpu, sub);
2928                         break;
2929                     case llvm::Triple::UnknownObjectFormat:
2930                         if (log)
2931                             log->Printf("error: failed to determine target architecture");
2932                         return false;
2933                 }
2934 
2935                 if (pointer_byte_size)
2936                 {
2937                     assert (pointer_byte_size == m_process_arch.GetAddressByteSize());
2938                 }
2939                 if (byte_order != eByteOrderInvalid)
2940                 {
2941                     assert (byte_order == m_process_arch.GetByteOrder());
2942                 }
2943                 m_process_arch.GetTriple().setVendorName (llvm::StringRef (vendor_name));
2944                 m_process_arch.GetTriple().setOSName(llvm::StringRef (os_name));
2945                 m_host_arch.GetTriple().setVendorName (llvm::StringRef (vendor_name));
2946                 m_host_arch.GetTriple().setOSName (llvm::StringRef (os_name));
2947             }
2948             return true;
2949         }
2950     }
2951     else
2952     {
2953         m_qProcessInfo_is_valid = eLazyBoolNo;
2954     }
2955 
2956     return false;
2957 }
2958 
2959 
2960 uint32_t
2961 GDBRemoteCommunicationClient::FindProcesses (const ProcessInstanceInfoMatch &match_info,
2962                                              ProcessInstanceInfoList &process_infos)
2963 {
2964     process_infos.Clear();
2965 
2966     if (m_supports_qfProcessInfo)
2967     {
2968         StreamString packet;
2969         packet.PutCString ("qfProcessInfo");
2970         if (!match_info.MatchAllProcesses())
2971         {
2972             packet.PutChar (':');
2973             const char *name = match_info.GetProcessInfo().GetName();
2974             bool has_name_match = false;
2975             if (name && name[0])
2976             {
2977                 has_name_match = true;
2978                 NameMatchType name_match_type = match_info.GetNameMatchType();
2979                 switch (name_match_type)
2980                 {
2981                 case eNameMatchIgnore:
2982                     has_name_match = false;
2983                     break;
2984 
2985                 case eNameMatchEquals:
2986                     packet.PutCString ("name_match:equals;");
2987                     break;
2988 
2989                 case eNameMatchContains:
2990                     packet.PutCString ("name_match:contains;");
2991                     break;
2992 
2993                 case eNameMatchStartsWith:
2994                     packet.PutCString ("name_match:starts_with;");
2995                     break;
2996 
2997                 case eNameMatchEndsWith:
2998                     packet.PutCString ("name_match:ends_with;");
2999                     break;
3000 
3001                 case eNameMatchRegularExpression:
3002                     packet.PutCString ("name_match:regex;");
3003                     break;
3004                 }
3005                 if (has_name_match)
3006                 {
3007                     packet.PutCString ("name:");
3008                     packet.PutBytesAsRawHex8(name, ::strlen(name));
3009                     packet.PutChar (';');
3010                 }
3011             }
3012 
3013             if (match_info.GetProcessInfo().ProcessIDIsValid())
3014                 packet.Printf("pid:%" PRIu64 ";",match_info.GetProcessInfo().GetProcessID());
3015             if (match_info.GetProcessInfo().ParentProcessIDIsValid())
3016                 packet.Printf("parent_pid:%" PRIu64 ";",match_info.GetProcessInfo().GetParentProcessID());
3017             if (match_info.GetProcessInfo().UserIDIsValid())
3018                 packet.Printf("uid:%u;",match_info.GetProcessInfo().GetUserID());
3019             if (match_info.GetProcessInfo().GroupIDIsValid())
3020                 packet.Printf("gid:%u;",match_info.GetProcessInfo().GetGroupID());
3021             if (match_info.GetProcessInfo().EffectiveUserIDIsValid())
3022                 packet.Printf("euid:%u;",match_info.GetProcessInfo().GetEffectiveUserID());
3023             if (match_info.GetProcessInfo().EffectiveGroupIDIsValid())
3024                 packet.Printf("egid:%u;",match_info.GetProcessInfo().GetEffectiveGroupID());
3025             if (match_info.GetProcessInfo().EffectiveGroupIDIsValid())
3026                 packet.Printf("all_users:%u;",match_info.GetMatchAllUsers() ? 1 : 0);
3027             if (match_info.GetProcessInfo().GetArchitecture().IsValid())
3028             {
3029                 const ArchSpec &match_arch = match_info.GetProcessInfo().GetArchitecture();
3030                 const llvm::Triple &triple = match_arch.GetTriple();
3031                 packet.PutCString("triple:");
3032                 packet.PutCString(triple.getTriple().c_str());
3033                 packet.PutChar (';');
3034             }
3035         }
3036         StringExtractorGDBRemote response;
3037         // Increase timeout as the first qfProcessInfo packet takes a long time
3038         // on Android. The value of 1min was arrived at empirically.
3039         GDBRemoteCommunication::ScopedTimeout timeout (*this, 60);
3040         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
3041         {
3042             do
3043             {
3044                 ProcessInstanceInfo process_info;
3045                 if (!DecodeProcessInfoResponse (response, process_info))
3046                     break;
3047                 process_infos.Append(process_info);
3048                 response.GetStringRef().clear();
3049                 response.SetFilePos(0);
3050             } while (SendPacketAndWaitForResponse ("qsProcessInfo", strlen ("qsProcessInfo"), response, false) == PacketResult::Success);
3051         }
3052         else
3053         {
3054             m_supports_qfProcessInfo = false;
3055             return 0;
3056         }
3057     }
3058     return process_infos.GetSize();
3059 
3060 }
3061 
3062 bool
3063 GDBRemoteCommunicationClient::GetUserName (uint32_t uid, std::string &name)
3064 {
3065     if (m_supports_qUserName)
3066     {
3067         char packet[32];
3068         const int packet_len = ::snprintf (packet, sizeof (packet), "qUserName:%i", uid);
3069         assert (packet_len < (int)sizeof(packet));
3070         StringExtractorGDBRemote response;
3071         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
3072         {
3073             if (response.IsNormalResponse())
3074             {
3075                 // Make sure we parsed the right number of characters. The response is
3076                 // the hex encoded user name and should make up the entire packet.
3077                 // If there are any non-hex ASCII bytes, the length won't match below..
3078                 if (response.GetHexByteString (name) * 2 == response.GetStringRef().size())
3079                     return true;
3080             }
3081         }
3082         else
3083         {
3084             m_supports_qUserName = false;
3085             return false;
3086         }
3087     }
3088     return false;
3089 
3090 }
3091 
3092 bool
3093 GDBRemoteCommunicationClient::GetGroupName (uint32_t gid, std::string &name)
3094 {
3095     if (m_supports_qGroupName)
3096     {
3097         char packet[32];
3098         const int packet_len = ::snprintf (packet, sizeof (packet), "qGroupName:%i", gid);
3099         assert (packet_len < (int)sizeof(packet));
3100         StringExtractorGDBRemote response;
3101         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
3102         {
3103             if (response.IsNormalResponse())
3104             {
3105                 // Make sure we parsed the right number of characters. The response is
3106                 // the hex encoded group name and should make up the entire packet.
3107                 // If there are any non-hex ASCII bytes, the length won't match below..
3108                 if (response.GetHexByteString (name) * 2 == response.GetStringRef().size())
3109                     return true;
3110             }
3111         }
3112         else
3113         {
3114             m_supports_qGroupName = false;
3115             return false;
3116         }
3117     }
3118     return false;
3119 }
3120 
3121 bool
3122 GDBRemoteCommunicationClient::SetNonStopMode (const bool enable)
3123 {
3124     // Form non-stop packet request
3125     char packet[32];
3126     const int packet_len = ::snprintf(packet, sizeof(packet), "QNonStop:%1d", (int)enable);
3127     assert(packet_len < (int)sizeof(packet));
3128 
3129     StringExtractorGDBRemote response;
3130     // Send to target
3131     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3132         if (response.IsOKResponse())
3133             return true;
3134 
3135     // Failed or not supported
3136     return false;
3137 
3138 }
3139 
3140 static void
3141 MakeSpeedTestPacket(StreamString &packet, uint32_t send_size, uint32_t recv_size)
3142 {
3143     packet.Clear();
3144     packet.Printf ("qSpeedTest:response_size:%i;data:", recv_size);
3145     uint32_t bytes_left = send_size;
3146     while (bytes_left > 0)
3147     {
3148         if (bytes_left >= 26)
3149         {
3150             packet.PutCString("abcdefghijklmnopqrstuvwxyz");
3151             bytes_left -= 26;
3152         }
3153         else
3154         {
3155             packet.Printf ("%*.*s;", bytes_left, bytes_left, "abcdefghijklmnopqrstuvwxyz");
3156             bytes_left = 0;
3157         }
3158     }
3159 }
3160 
3161 template<typename T>
3162 T calculate_standard_deviation(const std::vector<T> &v)
3163 {
3164     T sum = std::accumulate(std::begin(v), std::end(v), T(0));
3165     T mean =  sum / (T)v.size();
3166     T accum = T(0);
3167     std::for_each (std::begin(v), std::end(v), [&](const T d) {
3168         T delta = d - mean;
3169         accum += delta * delta;
3170     });
3171 
3172     T stdev = sqrt(accum / (v.size()-1));
3173     return stdev;
3174 }
3175 
3176 void
3177 GDBRemoteCommunicationClient::TestPacketSpeed (const uint32_t num_packets, uint32_t max_send, uint32_t max_recv, bool json, Stream &strm)
3178 {
3179     uint32_t i;
3180     TimeValue start_time, end_time;
3181     uint64_t total_time_nsec;
3182     if (SendSpeedTestPacket (0, 0))
3183     {
3184         StreamString packet;
3185         if (json)
3186             strm.Printf("{ \"packet_speeds\" : {\n    \"num_packets\" : %u,\n    \"results\" : [", num_packets);
3187         else
3188             strm.Printf("Testing sending %u packets of various sizes:\n", num_packets);
3189         strm.Flush();
3190 
3191         uint32_t result_idx = 0;
3192         uint32_t send_size;
3193         std::vector<float> packet_times;
3194 
3195         for (send_size = 0; send_size <= max_send; send_size ? send_size *= 2 : send_size = 4)
3196         {
3197             for (uint32_t recv_size = 0; recv_size <= max_recv; recv_size ? recv_size *= 2 : recv_size = 4)
3198             {
3199                 MakeSpeedTestPacket (packet, send_size, recv_size);
3200 
3201                 packet_times.clear();
3202                 // Test how long it takes to send 'num_packets' packets
3203                 start_time = TimeValue::Now();
3204                 for (i=0; i<num_packets; ++i)
3205                 {
3206                     TimeValue packet_start_time = TimeValue::Now();
3207                     StringExtractorGDBRemote response;
3208                     SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false);
3209                     TimeValue packet_end_time = TimeValue::Now();
3210                     uint64_t packet_time_nsec = packet_end_time.GetAsNanoSecondsSinceJan1_1970() - packet_start_time.GetAsNanoSecondsSinceJan1_1970();
3211                     packet_times.push_back((float)packet_time_nsec);
3212                 }
3213                 end_time = TimeValue::Now();
3214                 total_time_nsec = end_time.GetAsNanoSecondsSinceJan1_1970() - start_time.GetAsNanoSecondsSinceJan1_1970();
3215 
3216                 float packets_per_second = (((float)num_packets)/(float)total_time_nsec) * (float)TimeValue::NanoSecPerSec;
3217                 float total_ms = (float)total_time_nsec/(float)TimeValue::NanoSecPerMilliSec;
3218                 float average_ms_per_packet = total_ms / num_packets;
3219                 const float standard_deviation = calculate_standard_deviation<float>(packet_times);
3220                 if (json)
3221                 {
3222                     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);
3223                     ++result_idx;
3224                 }
3225                 else
3226                 {
3227                     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",
3228                                  send_size,
3229                                  recv_size,
3230                                  total_time_nsec / TimeValue::NanoSecPerSec,
3231                                  total_time_nsec % TimeValue::NanoSecPerSec,
3232                                  packets_per_second,
3233                                  average_ms_per_packet,
3234                                  standard_deviation/(float)TimeValue::NanoSecPerMilliSec);
3235                 }
3236                 strm.Flush();
3237             }
3238         }
3239 
3240         const uint64_t k_recv_amount = 4*1024*1024; // Receive amount in bytes
3241 
3242         const float k_recv_amount_mb = (float)k_recv_amount/(1024.0f*1024.0f);
3243         if (json)
3244             strm.Printf("\n    ]\n  },\n  \"download_speed\" : {\n    \"byte_size\" : %" PRIu64 ",\n    \"results\" : [", k_recv_amount);
3245         else
3246             strm.Printf("Testing receiving %2.1fMB of data using varying receive packet sizes:\n", k_recv_amount_mb);
3247         strm.Flush();
3248         send_size = 0;
3249         result_idx = 0;
3250         for (uint32_t recv_size = 32; recv_size <= max_recv; recv_size *= 2)
3251         {
3252             MakeSpeedTestPacket (packet, send_size, recv_size);
3253 
3254             // If we have a receive size, test how long it takes to receive 4MB of data
3255             if (recv_size > 0)
3256             {
3257                 start_time = TimeValue::Now();
3258                 uint32_t bytes_read = 0;
3259                 uint32_t packet_count = 0;
3260                 while (bytes_read < k_recv_amount)
3261                 {
3262                     StringExtractorGDBRemote response;
3263                     SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false);
3264                     bytes_read += recv_size;
3265                     ++packet_count;
3266                 }
3267                 end_time = TimeValue::Now();
3268                 total_time_nsec = end_time.GetAsNanoSecondsSinceJan1_1970() - start_time.GetAsNanoSecondsSinceJan1_1970();
3269                 float mb_second = ((((float)k_recv_amount)/(float)total_time_nsec) * (float)TimeValue::NanoSecPerSec) / (1024.0*1024.0);
3270                 float packets_per_second = (((float)packet_count)/(float)total_time_nsec) * (float)TimeValue::NanoSecPerSec;
3271                 float total_ms = (float)total_time_nsec/(float)TimeValue::NanoSecPerMilliSec;
3272                 float average_ms_per_packet = total_ms / packet_count;
3273 
3274                 if (json)
3275                 {
3276                     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);
3277                     ++result_idx;
3278                 }
3279                 else
3280                 {
3281                     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",
3282                                  send_size,
3283                                  recv_size,
3284                                  packet_count,
3285                                  k_recv_amount_mb,
3286                                  total_time_nsec / TimeValue::NanoSecPerSec,
3287                                  total_time_nsec % TimeValue::NanoSecPerSec,
3288                                  mb_second,
3289                                  packets_per_second,
3290                                  average_ms_per_packet);
3291                 }
3292                 strm.Flush();
3293             }
3294         }
3295         if (json)
3296             strm.Printf("\n    ]\n  }\n}\n");
3297         else
3298             strm.EOL();
3299     }
3300 }
3301 
3302 bool
3303 GDBRemoteCommunicationClient::SendSpeedTestPacket (uint32_t send_size, uint32_t recv_size)
3304 {
3305     StreamString packet;
3306     packet.Printf ("qSpeedTest:response_size:%i;data:", recv_size);
3307     uint32_t bytes_left = send_size;
3308     while (bytes_left > 0)
3309     {
3310         if (bytes_left >= 26)
3311         {
3312             packet.PutCString("abcdefghijklmnopqrstuvwxyz");
3313             bytes_left -= 26;
3314         }
3315         else
3316         {
3317             packet.Printf ("%*.*s;", bytes_left, bytes_left, "abcdefghijklmnopqrstuvwxyz");
3318             bytes_left = 0;
3319         }
3320     }
3321 
3322     StringExtractorGDBRemote response;
3323     return SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false)  == PacketResult::Success;
3324 }
3325 
3326 bool
3327 GDBRemoteCommunicationClient::LaunchGDBServer (const char *remote_accept_hostname,
3328                                                lldb::pid_t &pid,
3329                                                uint16_t &port,
3330                                                std::string &socket_name)
3331 {
3332     pid = LLDB_INVALID_PROCESS_ID;
3333     port = 0;
3334     socket_name.clear();
3335 
3336     StringExtractorGDBRemote response;
3337     StreamString stream;
3338     stream.PutCString("qLaunchGDBServer;");
3339     std::string hostname;
3340     if (remote_accept_hostname  && remote_accept_hostname[0])
3341         hostname = remote_accept_hostname;
3342     else
3343     {
3344         if (HostInfo::GetHostname(hostname))
3345         {
3346             // Make the GDB server we launch only accept connections from this host
3347             stream.Printf("host:%s;", hostname.c_str());
3348         }
3349         else
3350         {
3351             // Make the GDB server we launch accept connections from any host since we can't figure out the hostname
3352             stream.Printf("host:*;");
3353         }
3354     }
3355     const char *packet = stream.GetData();
3356     int packet_len = stream.GetSize();
3357 
3358     // give the process a few seconds to startup
3359     GDBRemoteCommunication::ScopedTimeout timeout (*this, 10);
3360 
3361     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3362     {
3363         std::string name;
3364         std::string value;
3365         StringExtractor extractor;
3366         while (response.GetNameColonValue(name, value))
3367         {
3368             if (name.compare("port") == 0)
3369                 port = StringConvert::ToUInt32(value.c_str(), 0, 0);
3370             else if (name.compare("pid") == 0)
3371                 pid = StringConvert::ToUInt64(value.c_str(), LLDB_INVALID_PROCESS_ID, 0);
3372             else if (name.compare("socket_name") == 0)
3373             {
3374                 extractor.GetStringRef().swap(value);
3375                 extractor.SetFilePos(0);
3376                 extractor.GetHexByteString(value);
3377 
3378                 socket_name = value;
3379             }
3380         }
3381         return true;
3382     }
3383     return false;
3384 }
3385 
3386 size_t
3387 GDBRemoteCommunicationClient::QueryGDBServer (std::vector<std::pair<uint16_t, std::string>>& connection_urls)
3388 {
3389     connection_urls.clear();
3390 
3391     StringExtractorGDBRemote response;
3392     if (SendPacketAndWaitForResponse("qQueryGDBServer", response, false) != PacketResult::Success)
3393         return 0;
3394 
3395     StructuredData::ObjectSP data = StructuredData::ParseJSON(response.GetStringRef());
3396     if (!data)
3397         return 0;
3398 
3399     StructuredData::Array* array = data->GetAsArray();
3400     if (!array)
3401         return 0;
3402 
3403     for (size_t i = 0, count = array->GetSize(); i < count; ++i)
3404     {
3405         StructuredData::Dictionary* element = nullptr;
3406         if (!array->GetItemAtIndexAsDictionary(i, element))
3407             continue;
3408 
3409         uint16_t port = 0;
3410         if (StructuredData::ObjectSP port_osp = element->GetValueForKey(llvm::StringRef("port")))
3411             port = port_osp->GetIntegerValue(0);
3412 
3413         std::string socket_name;
3414         if (StructuredData::ObjectSP socket_name_osp = element->GetValueForKey(llvm::StringRef("socket_name")))
3415             socket_name = socket_name_osp->GetStringValue();
3416 
3417         if (port != 0 || !socket_name.empty())
3418             connection_urls.emplace_back(port, socket_name);
3419     }
3420     return connection_urls.size();
3421 }
3422 
3423 bool
3424 GDBRemoteCommunicationClient::KillSpawnedProcess (lldb::pid_t pid)
3425 {
3426     StreamString stream;
3427     stream.Printf ("qKillSpawnedProcess:%" PRId64 , pid);
3428     const char *packet = stream.GetData();
3429     int packet_len = stream.GetSize();
3430 
3431     StringExtractorGDBRemote response;
3432     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3433     {
3434         if (response.IsOKResponse())
3435             return true;
3436     }
3437     return false;
3438 }
3439 
3440 bool
3441 GDBRemoteCommunicationClient::SetCurrentThread (uint64_t tid)
3442 {
3443     if (m_curr_tid == tid)
3444         return true;
3445 
3446     char packet[32];
3447     int packet_len;
3448     if (tid == UINT64_MAX)
3449         packet_len = ::snprintf (packet, sizeof(packet), "Hg-1");
3450     else
3451         packet_len = ::snprintf (packet, sizeof(packet), "Hg%" PRIx64, tid);
3452     assert (packet_len + 1 < (int)sizeof(packet));
3453     StringExtractorGDBRemote response;
3454     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3455     {
3456         if (response.IsOKResponse())
3457         {
3458             m_curr_tid = tid;
3459             return true;
3460         }
3461 
3462         /*
3463          * Connected bare-iron target (like YAMON gdb-stub) may not have support for Hg packet.
3464          * The reply from '?' packet could be as simple as 'S05'. There is no packet which can
3465          * give us pid and/or tid. Assume pid=tid=1 in such cases.
3466         */
3467         if (response.IsUnsupportedResponse() && IsConnected())
3468         {
3469             m_curr_tid = 1;
3470             return true;
3471         }
3472     }
3473     return false;
3474 }
3475 
3476 bool
3477 GDBRemoteCommunicationClient::SetCurrentThreadForRun (uint64_t tid)
3478 {
3479     if (m_curr_tid_run == tid)
3480         return true;
3481 
3482     char packet[32];
3483     int packet_len;
3484     if (tid == UINT64_MAX)
3485         packet_len = ::snprintf (packet, sizeof(packet), "Hc-1");
3486     else
3487         packet_len = ::snprintf (packet, sizeof(packet), "Hc%" PRIx64, tid);
3488 
3489     assert (packet_len + 1 < (int)sizeof(packet));
3490     StringExtractorGDBRemote response;
3491     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3492     {
3493         if (response.IsOKResponse())
3494         {
3495             m_curr_tid_run = tid;
3496             return true;
3497         }
3498 
3499         /*
3500          * Connected bare-iron target (like YAMON gdb-stub) may not have support for Hc packet.
3501          * The reply from '?' packet could be as simple as 'S05'. There is no packet which can
3502          * give us pid and/or tid. Assume pid=tid=1 in such cases.
3503         */
3504         if (response.IsUnsupportedResponse() && IsConnected())
3505         {
3506             m_curr_tid_run = 1;
3507             return true;
3508         }
3509     }
3510     return false;
3511 }
3512 
3513 bool
3514 GDBRemoteCommunicationClient::GetStopReply (StringExtractorGDBRemote &response)
3515 {
3516     if (SendPacketAndWaitForResponse("?", 1, response, false) == PacketResult::Success)
3517         return response.IsNormalResponse();
3518     return false;
3519 }
3520 
3521 bool
3522 GDBRemoteCommunicationClient::GetThreadStopInfo (lldb::tid_t tid, StringExtractorGDBRemote &response)
3523 {
3524     if (m_supports_qThreadStopInfo)
3525     {
3526         char packet[256];
3527         int packet_len = ::snprintf(packet, sizeof(packet), "qThreadStopInfo%" PRIx64, tid);
3528         assert (packet_len < (int)sizeof(packet));
3529         if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3530         {
3531             if (response.IsUnsupportedResponse())
3532                 m_supports_qThreadStopInfo = false;
3533             else if (response.IsNormalResponse())
3534                 return true;
3535             else
3536                 return false;
3537         }
3538         else
3539         {
3540             m_supports_qThreadStopInfo = false;
3541         }
3542     }
3543     return false;
3544 }
3545 
3546 
3547 uint8_t
3548 GDBRemoteCommunicationClient::SendGDBStoppointTypePacket (GDBStoppointType type, bool insert,  addr_t addr, uint32_t length)
3549 {
3550     Log *log (GetLogIfAnyCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
3551     if (log)
3552         log->Printf ("GDBRemoteCommunicationClient::%s() %s at addr = 0x%" PRIx64,
3553                      __FUNCTION__, insert ? "add" : "remove", addr);
3554 
3555     // Check if the stub is known not to support this breakpoint type
3556     if (!SupportsGDBStoppointPacket(type))
3557         return UINT8_MAX;
3558     // Construct the breakpoint packet
3559     char packet[64];
3560     const int packet_len = ::snprintf (packet,
3561                                        sizeof(packet),
3562                                        "%c%i,%" PRIx64 ",%x",
3563                                        insert ? 'Z' : 'z',
3564                                        type,
3565                                        addr,
3566                                        length);
3567     // Check we haven't overwritten the end of the packet buffer
3568     assert (packet_len + 1 < (int)sizeof(packet));
3569     StringExtractorGDBRemote response;
3570     // Try to send the breakpoint packet, and check that it was correctly sent
3571     if (SendPacketAndWaitForResponse(packet, packet_len, response, true) == PacketResult::Success)
3572     {
3573         // Receive and OK packet when the breakpoint successfully placed
3574         if (response.IsOKResponse())
3575             return 0;
3576 
3577         // Error while setting breakpoint, send back specific error
3578         if (response.IsErrorResponse())
3579             return response.GetError();
3580 
3581         // Empty packet informs us that breakpoint is not supported
3582         if (response.IsUnsupportedResponse())
3583         {
3584             // Disable this breakpoint type since it is unsupported
3585             switch (type)
3586             {
3587             case eBreakpointSoftware:   m_supports_z0 = false; break;
3588             case eBreakpointHardware:   m_supports_z1 = false; break;
3589             case eWatchpointWrite:      m_supports_z2 = false; break;
3590             case eWatchpointRead:       m_supports_z3 = false; break;
3591             case eWatchpointReadWrite:  m_supports_z4 = false; break;
3592             case eStoppointInvalid:     return UINT8_MAX;
3593             }
3594         }
3595     }
3596     // Signal generic failure
3597     return UINT8_MAX;
3598 }
3599 
3600 size_t
3601 GDBRemoteCommunicationClient::GetCurrentThreadIDs (std::vector<lldb::tid_t> &thread_ids,
3602                                                    bool &sequence_mutex_unavailable)
3603 {
3604     Mutex::Locker locker;
3605     thread_ids.clear();
3606 
3607     if (GetSequenceMutex (locker, "ProcessGDBRemote::UpdateThreadList() failed due to not getting the sequence mutex"))
3608     {
3609         sequence_mutex_unavailable = false;
3610         StringExtractorGDBRemote response;
3611 
3612         PacketResult packet_result;
3613         for (packet_result = SendPacketAndWaitForResponseNoLock ("qfThreadInfo", strlen("qfThreadInfo"), response);
3614              packet_result == PacketResult::Success && response.IsNormalResponse();
3615              packet_result = SendPacketAndWaitForResponseNoLock ("qsThreadInfo", strlen("qsThreadInfo"), response))
3616         {
3617             char ch = response.GetChar();
3618             if (ch == 'l')
3619                 break;
3620             if (ch == 'm')
3621             {
3622                 do
3623                 {
3624                     tid_t tid = response.GetHexMaxU64(false, LLDB_INVALID_THREAD_ID);
3625 
3626                     if (tid != LLDB_INVALID_THREAD_ID)
3627                     {
3628                         thread_ids.push_back (tid);
3629                     }
3630                     ch = response.GetChar();    // Skip the command separator
3631                 } while (ch == ',');            // Make sure we got a comma separator
3632             }
3633         }
3634 
3635         /*
3636          * Connected bare-iron target (like YAMON gdb-stub) may not have support for
3637          * qProcessInfo, qC and qfThreadInfo packets. The reply from '?' packet could
3638          * be as simple as 'S05'. There is no packet which can give us pid and/or tid.
3639          * Assume pid=tid=1 in such cases.
3640         */
3641         if (response.IsUnsupportedResponse() && thread_ids.size() == 0 && IsConnected())
3642         {
3643             thread_ids.push_back (1);
3644         }
3645     }
3646     else
3647     {
3648 #if defined (LLDB_CONFIGURATION_DEBUG)
3649         // assert(!"ProcessGDBRemote::UpdateThreadList() failed due to not getting the sequence mutex");
3650 #else
3651         Log *log (ProcessGDBRemoteLog::GetLogIfAnyCategoryIsSet (GDBR_LOG_PROCESS | GDBR_LOG_PACKETS));
3652         if (log)
3653             log->Printf("error: failed to get packet sequence mutex, not sending packet 'qfThreadInfo'");
3654 #endif
3655         sequence_mutex_unavailable = true;
3656     }
3657     return thread_ids.size();
3658 }
3659 
3660 lldb::addr_t
3661 GDBRemoteCommunicationClient::GetShlibInfoAddr()
3662 {
3663     if (!IsRunning())
3664     {
3665         StringExtractorGDBRemote response;
3666         if (SendPacketAndWaitForResponse("qShlibInfoAddr", ::strlen ("qShlibInfoAddr"), response, false) == PacketResult::Success)
3667         {
3668             if (response.IsNormalResponse())
3669                 return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
3670         }
3671     }
3672     return LLDB_INVALID_ADDRESS;
3673 }
3674 
3675 lldb_private::Error
3676 GDBRemoteCommunicationClient::RunShellCommand(const char *command,           // Shouldn't be NULL
3677                                               const FileSpec &working_dir,   // Pass empty FileSpec to use the current working directory
3678                                               int *status_ptr,               // Pass NULL if you don't want the process exit status
3679                                               int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
3680                                               std::string *command_output,   // Pass NULL if you don't want the command output
3681                                               uint32_t timeout_sec)          // Timeout in seconds to wait for shell program to finish
3682 {
3683     lldb_private::StreamString stream;
3684     stream.PutCString("qPlatform_shell:");
3685     stream.PutBytesAsRawHex8(command, strlen(command));
3686     stream.PutChar(',');
3687     stream.PutHex32(timeout_sec);
3688     if (working_dir)
3689     {
3690         std::string path{working_dir.GetPath(false)};
3691         stream.PutChar(',');
3692         stream.PutCStringAsRawHex8(path.c_str());
3693     }
3694     const char *packet = stream.GetData();
3695     int packet_len = stream.GetSize();
3696     StringExtractorGDBRemote response;
3697     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3698     {
3699         if (response.GetChar() != 'F')
3700             return Error("malformed reply");
3701         if (response.GetChar() != ',')
3702             return Error("malformed reply");
3703         uint32_t exitcode = response.GetHexMaxU32(false, UINT32_MAX);
3704         if (exitcode == UINT32_MAX)
3705             return Error("unable to run remote process");
3706         else if (status_ptr)
3707             *status_ptr = exitcode;
3708         if (response.GetChar() != ',')
3709             return Error("malformed reply");
3710         uint32_t signo = response.GetHexMaxU32(false, UINT32_MAX);
3711         if (signo_ptr)
3712             *signo_ptr = signo;
3713         if (response.GetChar() != ',')
3714             return Error("malformed reply");
3715         std::string output;
3716         response.GetEscapedBinaryData(output);
3717         if (command_output)
3718             command_output->assign(output);
3719         return Error();
3720     }
3721     return Error("unable to send packet");
3722 }
3723 
3724 Error
3725 GDBRemoteCommunicationClient::MakeDirectory(const FileSpec &file_spec,
3726                                             uint32_t file_permissions)
3727 {
3728     std::string path{file_spec.GetPath(false)};
3729     lldb_private::StreamString stream;
3730     stream.PutCString("qPlatform_mkdir:");
3731     stream.PutHex32(file_permissions);
3732     stream.PutChar(',');
3733     stream.PutCStringAsRawHex8(path.c_str());
3734     const char *packet = stream.GetData();
3735     int packet_len = stream.GetSize();
3736     StringExtractorGDBRemote response;
3737 
3738     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) != PacketResult::Success)
3739         return Error("failed to send '%s' packet", packet);
3740 
3741     if (response.GetChar() != 'F')
3742         return Error("invalid response to '%s' packet", packet);
3743 
3744     return Error(response.GetU32(UINT32_MAX), eErrorTypePOSIX);
3745 }
3746 
3747 Error
3748 GDBRemoteCommunicationClient::SetFilePermissions(const FileSpec &file_spec,
3749                                                  uint32_t file_permissions)
3750 {
3751     std::string path{file_spec.GetPath(false)};
3752     lldb_private::StreamString stream;
3753     stream.PutCString("qPlatform_chmod:");
3754     stream.PutHex32(file_permissions);
3755     stream.PutChar(',');
3756     stream.PutCStringAsRawHex8(path.c_str());
3757     const char *packet = stream.GetData();
3758     int packet_len = stream.GetSize();
3759     StringExtractorGDBRemote response;
3760 
3761     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) != PacketResult::Success)
3762         return Error("failed to send '%s' packet", packet);
3763 
3764     if (response.GetChar() != 'F')
3765         return Error("invalid response to '%s' packet", packet);
3766 
3767     return Error(response.GetU32(UINT32_MAX), eErrorTypePOSIX);
3768 }
3769 
3770 static uint64_t
3771 ParseHostIOPacketResponse (StringExtractorGDBRemote &response,
3772                            uint64_t fail_result,
3773                            Error &error)
3774 {
3775     response.SetFilePos(0);
3776     if (response.GetChar() != 'F')
3777         return fail_result;
3778     int32_t result = response.GetS32 (-2);
3779     if (result == -2)
3780         return fail_result;
3781     if (response.GetChar() == ',')
3782     {
3783         int result_errno = response.GetS32 (-2);
3784         if (result_errno != -2)
3785             error.SetError(result_errno, eErrorTypePOSIX);
3786         else
3787             error.SetError(-1, eErrorTypeGeneric);
3788     }
3789     else
3790         error.Clear();
3791     return  result;
3792 }
3793 lldb::user_id_t
3794 GDBRemoteCommunicationClient::OpenFile (const lldb_private::FileSpec& file_spec,
3795                                         uint32_t flags,
3796                                         mode_t mode,
3797                                         Error &error)
3798 {
3799     std::string path(file_spec.GetPath(false));
3800     lldb_private::StreamString stream;
3801     stream.PutCString("vFile:open:");
3802     if (path.empty())
3803         return UINT64_MAX;
3804     stream.PutCStringAsRawHex8(path.c_str());
3805     stream.PutChar(',');
3806     stream.PutHex32(flags);
3807     stream.PutChar(',');
3808     stream.PutHex32(mode);
3809     const char* packet = stream.GetData();
3810     int packet_len = stream.GetSize();
3811     StringExtractorGDBRemote response;
3812     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3813     {
3814         return ParseHostIOPacketResponse (response, UINT64_MAX, error);
3815     }
3816     return UINT64_MAX;
3817 }
3818 
3819 bool
3820 GDBRemoteCommunicationClient::CloseFile (lldb::user_id_t fd,
3821                                          Error &error)
3822 {
3823     lldb_private::StreamString stream;
3824     stream.Printf("vFile:close:%i", (int)fd);
3825     const char* packet = stream.GetData();
3826     int packet_len = stream.GetSize();
3827     StringExtractorGDBRemote response;
3828     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3829     {
3830         return ParseHostIOPacketResponse (response, -1, error) == 0;
3831     }
3832     return false;
3833 }
3834 
3835 // Extension of host I/O packets to get the file size.
3836 lldb::user_id_t
3837 GDBRemoteCommunicationClient::GetFileSize (const lldb_private::FileSpec& file_spec)
3838 {
3839     std::string path(file_spec.GetPath(false));
3840     lldb_private::StreamString stream;
3841     stream.PutCString("vFile:size:");
3842     stream.PutCStringAsRawHex8(path.c_str());
3843     const char* packet = stream.GetData();
3844     int packet_len = stream.GetSize();
3845     StringExtractorGDBRemote response;
3846     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3847     {
3848         if (response.GetChar() != 'F')
3849             return UINT64_MAX;
3850         uint32_t retcode = response.GetHexMaxU64(false, UINT64_MAX);
3851         return retcode;
3852     }
3853     return UINT64_MAX;
3854 }
3855 
3856 Error
3857 GDBRemoteCommunicationClient::GetFilePermissions(const FileSpec &file_spec,
3858                                                  uint32_t &file_permissions)
3859 {
3860     std::string path{file_spec.GetPath(false)};
3861     Error error;
3862     lldb_private::StreamString stream;
3863     stream.PutCString("vFile:mode:");
3864     stream.PutCStringAsRawHex8(path.c_str());
3865     const char* packet = stream.GetData();
3866     int packet_len = stream.GetSize();
3867     StringExtractorGDBRemote response;
3868     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3869     {
3870         if (response.GetChar() != 'F')
3871         {
3872             error.SetErrorStringWithFormat ("invalid response to '%s' packet", packet);
3873         }
3874         else
3875         {
3876             const uint32_t mode = response.GetS32(-1);
3877             if (static_cast<int32_t>(mode) == -1)
3878             {
3879                 if (response.GetChar() == ',')
3880                 {
3881                     int response_errno = response.GetS32(-1);
3882                     if (response_errno > 0)
3883                         error.SetError(response_errno, lldb::eErrorTypePOSIX);
3884                     else
3885                         error.SetErrorToGenericError();
3886                 }
3887                 else
3888                     error.SetErrorToGenericError();
3889             }
3890             else
3891             {
3892                 file_permissions = mode & (S_IRWXU|S_IRWXG|S_IRWXO);
3893             }
3894         }
3895     }
3896     else
3897     {
3898         error.SetErrorStringWithFormat ("failed to send '%s' packet", packet);
3899     }
3900     return error;
3901 }
3902 
3903 uint64_t
3904 GDBRemoteCommunicationClient::ReadFile (lldb::user_id_t fd,
3905                                         uint64_t offset,
3906                                         void *dst,
3907                                         uint64_t dst_len,
3908                                         Error &error)
3909 {
3910     lldb_private::StreamString stream;
3911     stream.Printf("vFile:pread:%i,%" PRId64 ",%" PRId64, (int)fd, dst_len, offset);
3912     const char* packet = stream.GetData();
3913     int packet_len = stream.GetSize();
3914     StringExtractorGDBRemote response;
3915     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3916     {
3917         if (response.GetChar() != 'F')
3918             return 0;
3919         uint32_t retcode = response.GetHexMaxU32(false, UINT32_MAX);
3920         if (retcode == UINT32_MAX)
3921             return retcode;
3922         const char next = (response.Peek() ? *response.Peek() : 0);
3923         if (next == ',')
3924             return 0;
3925         if (next == ';')
3926         {
3927             response.GetChar(); // skip the semicolon
3928             std::string buffer;
3929             if (response.GetEscapedBinaryData(buffer))
3930             {
3931                 const uint64_t data_to_write = std::min<uint64_t>(dst_len, buffer.size());
3932                 if (data_to_write > 0)
3933                     memcpy(dst, &buffer[0], data_to_write);
3934                 return data_to_write;
3935             }
3936         }
3937     }
3938     return 0;
3939 }
3940 
3941 uint64_t
3942 GDBRemoteCommunicationClient::WriteFile (lldb::user_id_t fd,
3943                                          uint64_t offset,
3944                                          const void* src,
3945                                          uint64_t src_len,
3946                                          Error &error)
3947 {
3948     lldb_private::StreamGDBRemote stream;
3949     stream.Printf("vFile:pwrite:%i,%" PRId64 ",", (int)fd, offset);
3950     stream.PutEscapedBytes(src, src_len);
3951     const char* packet = stream.GetData();
3952     int packet_len = stream.GetSize();
3953     StringExtractorGDBRemote response;
3954     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3955     {
3956         if (response.GetChar() != 'F')
3957         {
3958             error.SetErrorStringWithFormat("write file failed");
3959             return 0;
3960         }
3961         uint64_t bytes_written = response.GetU64(UINT64_MAX);
3962         if (bytes_written == UINT64_MAX)
3963         {
3964             error.SetErrorToGenericError();
3965             if (response.GetChar() == ',')
3966             {
3967                 int response_errno = response.GetS32(-1);
3968                 if (response_errno > 0)
3969                     error.SetError(response_errno, lldb::eErrorTypePOSIX);
3970             }
3971             return 0;
3972         }
3973         return bytes_written;
3974     }
3975     else
3976     {
3977         error.SetErrorString ("failed to send vFile:pwrite packet");
3978     }
3979     return 0;
3980 }
3981 
3982 Error
3983 GDBRemoteCommunicationClient::CreateSymlink(const FileSpec &src, const FileSpec &dst)
3984 {
3985     std::string src_path{src.GetPath(false)},
3986                 dst_path{dst.GetPath(false)};
3987     Error error;
3988     lldb_private::StreamGDBRemote stream;
3989     stream.PutCString("vFile:symlink:");
3990     // the unix symlink() command reverses its parameters where the dst if first,
3991     // so we follow suit here
3992     stream.PutCStringAsRawHex8(dst_path.c_str());
3993     stream.PutChar(',');
3994     stream.PutCStringAsRawHex8(src_path.c_str());
3995     const char* packet = stream.GetData();
3996     int packet_len = stream.GetSize();
3997     StringExtractorGDBRemote response;
3998     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
3999     {
4000         if (response.GetChar() == 'F')
4001         {
4002             uint32_t result = response.GetU32(UINT32_MAX);
4003             if (result != 0)
4004             {
4005                 error.SetErrorToGenericError();
4006                 if (response.GetChar() == ',')
4007                 {
4008                     int response_errno = response.GetS32(-1);
4009                     if (response_errno > 0)
4010                         error.SetError(response_errno, lldb::eErrorTypePOSIX);
4011                 }
4012             }
4013         }
4014         else
4015         {
4016             // Should have returned with 'F<result>[,<errno>]'
4017             error.SetErrorStringWithFormat("symlink failed");
4018         }
4019     }
4020     else
4021     {
4022         error.SetErrorString ("failed to send vFile:symlink packet");
4023     }
4024     return error;
4025 }
4026 
4027 Error
4028 GDBRemoteCommunicationClient::Unlink(const FileSpec &file_spec)
4029 {
4030     std::string path{file_spec.GetPath(false)};
4031     Error error;
4032     lldb_private::StreamGDBRemote stream;
4033     stream.PutCString("vFile:unlink:");
4034     // the unix symlink() command reverses its parameters where the dst if first,
4035     // so we follow suit here
4036     stream.PutCStringAsRawHex8(path.c_str());
4037     const char* packet = stream.GetData();
4038     int packet_len = stream.GetSize();
4039     StringExtractorGDBRemote response;
4040     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
4041     {
4042         if (response.GetChar() == 'F')
4043         {
4044             uint32_t result = response.GetU32(UINT32_MAX);
4045             if (result != 0)
4046             {
4047                 error.SetErrorToGenericError();
4048                 if (response.GetChar() == ',')
4049                 {
4050                     int response_errno = response.GetS32(-1);
4051                     if (response_errno > 0)
4052                         error.SetError(response_errno, lldb::eErrorTypePOSIX);
4053                 }
4054             }
4055         }
4056         else
4057         {
4058             // Should have returned with 'F<result>[,<errno>]'
4059             error.SetErrorStringWithFormat("unlink failed");
4060         }
4061     }
4062     else
4063     {
4064         error.SetErrorString ("failed to send vFile:unlink packet");
4065     }
4066     return error;
4067 }
4068 
4069 // Extension of host I/O packets to get whether a file exists.
4070 bool
4071 GDBRemoteCommunicationClient::GetFileExists (const lldb_private::FileSpec& file_spec)
4072 {
4073     std::string path(file_spec.GetPath(false));
4074     lldb_private::StreamString stream;
4075     stream.PutCString("vFile:exists:");
4076     stream.PutCStringAsRawHex8(path.c_str());
4077     const char* packet = stream.GetData();
4078     int packet_len = stream.GetSize();
4079     StringExtractorGDBRemote response;
4080     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
4081     {
4082         if (response.GetChar() != 'F')
4083             return false;
4084         if (response.GetChar() != ',')
4085             return false;
4086         bool retcode = (response.GetChar() != '0');
4087         return retcode;
4088     }
4089     return false;
4090 }
4091 
4092 bool
4093 GDBRemoteCommunicationClient::CalculateMD5 (const lldb_private::FileSpec& file_spec,
4094                                             uint64_t &high,
4095                                             uint64_t &low)
4096 {
4097     std::string path(file_spec.GetPath(false));
4098     lldb_private::StreamString stream;
4099     stream.PutCString("vFile:MD5:");
4100     stream.PutCStringAsRawHex8(path.c_str());
4101     const char* packet = stream.GetData();
4102     int packet_len = stream.GetSize();
4103     StringExtractorGDBRemote response;
4104     if (SendPacketAndWaitForResponse(packet, packet_len, response, false) == PacketResult::Success)
4105     {
4106         if (response.GetChar() != 'F')
4107             return false;
4108         if (response.GetChar() != ',')
4109             return false;
4110         if (response.Peek() && *response.Peek() == 'x')
4111             return false;
4112         low = response.GetHexMaxU64(false, UINT64_MAX);
4113         high = response.GetHexMaxU64(false, UINT64_MAX);
4114         return true;
4115     }
4116     return false;
4117 }
4118 
4119 bool
4120 GDBRemoteCommunicationClient::AvoidGPackets (ProcessGDBRemote *process)
4121 {
4122     // Some targets have issues with g/G packets and we need to avoid using them
4123     if (m_avoid_g_packets == eLazyBoolCalculate)
4124     {
4125         if (process)
4126         {
4127             m_avoid_g_packets = eLazyBoolNo;
4128             const ArchSpec &arch = process->GetTarget().GetArchitecture();
4129             if (arch.IsValid()
4130                 && arch.GetTriple().getVendor() == llvm::Triple::Apple
4131                 && arch.GetTriple().getOS() == llvm::Triple::IOS
4132                 && arch.GetTriple().getArch() == llvm::Triple::aarch64)
4133             {
4134                 m_avoid_g_packets = eLazyBoolYes;
4135                 uint32_t gdb_server_version = GetGDBServerProgramVersion();
4136                 if (gdb_server_version != 0)
4137                 {
4138                     const char *gdb_server_name = GetGDBServerProgramName();
4139                     if (gdb_server_name && strcmp(gdb_server_name, "debugserver") == 0)
4140                     {
4141                         if (gdb_server_version >= 310)
4142                             m_avoid_g_packets = eLazyBoolNo;
4143                     }
4144                 }
4145             }
4146         }
4147     }
4148     return m_avoid_g_packets == eLazyBoolYes;
4149 }
4150 
4151 bool
4152 GDBRemoteCommunicationClient::ReadRegister(lldb::tid_t tid, uint32_t reg, StringExtractorGDBRemote &response)
4153 {
4154     Mutex::Locker locker;
4155     if (GetSequenceMutex (locker, "Didn't get sequence mutex for p packet."))
4156     {
4157         const bool thread_suffix_supported = GetThreadSuffixSupported();
4158 
4159         if (thread_suffix_supported || SetCurrentThread(tid))
4160         {
4161             char packet[64];
4162             int packet_len = 0;
4163             if (thread_suffix_supported)
4164                 packet_len = ::snprintf (packet, sizeof(packet), "p%x;thread:%4.4" PRIx64 ";", reg, tid);
4165             else
4166                 packet_len = ::snprintf (packet, sizeof(packet), "p%x", reg);
4167             assert (packet_len < ((int)sizeof(packet) - 1));
4168             return SendPacketAndWaitForResponse(packet, response, false) == PacketResult::Success;
4169         }
4170     }
4171     return false;
4172 
4173 }
4174 
4175 
4176 bool
4177 GDBRemoteCommunicationClient::ReadAllRegisters (lldb::tid_t tid, StringExtractorGDBRemote &response)
4178 {
4179     Mutex::Locker locker;
4180     if (GetSequenceMutex (locker, "Didn't get sequence mutex for g packet."))
4181     {
4182         const bool thread_suffix_supported = GetThreadSuffixSupported();
4183 
4184         if (thread_suffix_supported || SetCurrentThread(tid))
4185         {
4186             char packet[64];
4187             int packet_len = 0;
4188             // Get all registers in one packet
4189             if (thread_suffix_supported)
4190                 packet_len = ::snprintf (packet, sizeof(packet), "g;thread:%4.4" PRIx64 ";", tid);
4191             else
4192                 packet_len = ::snprintf (packet, sizeof(packet), "g");
4193             assert (packet_len < ((int)sizeof(packet) - 1));
4194             return SendPacketAndWaitForResponse(packet, response, false) == PacketResult::Success;
4195         }
4196     }
4197     return false;
4198 }
4199 bool
4200 GDBRemoteCommunicationClient::SaveRegisterState (lldb::tid_t tid, uint32_t &save_id)
4201 {
4202     save_id = 0; // Set to invalid save ID
4203     if (m_supports_QSaveRegisterState == eLazyBoolNo)
4204         return false;
4205 
4206     m_supports_QSaveRegisterState = eLazyBoolYes;
4207     Mutex::Locker locker;
4208     if (GetSequenceMutex (locker, "Didn't get sequence mutex for QSaveRegisterState."))
4209     {
4210         const bool thread_suffix_supported = GetThreadSuffixSupported();
4211         if (thread_suffix_supported || SetCurrentThread(tid))
4212         {
4213             char packet[256];
4214             if (thread_suffix_supported)
4215                 ::snprintf (packet, sizeof(packet), "QSaveRegisterState;thread:%4.4" PRIx64 ";", tid);
4216             else
4217                 ::snprintf(packet, sizeof(packet), "QSaveRegisterState");
4218 
4219             StringExtractorGDBRemote response;
4220 
4221             if (SendPacketAndWaitForResponse(packet, response, false) == PacketResult::Success)
4222             {
4223                 if (response.IsUnsupportedResponse())
4224                 {
4225                     // This packet isn't supported, don't try calling it again
4226                     m_supports_QSaveRegisterState = eLazyBoolNo;
4227                 }
4228 
4229                 const uint32_t response_save_id = response.GetU32(0);
4230                 if (response_save_id != 0)
4231                 {
4232                     save_id = response_save_id;
4233                     return true;
4234                 }
4235             }
4236         }
4237     }
4238     return false;
4239 }
4240 
4241 bool
4242 GDBRemoteCommunicationClient::RestoreRegisterState (lldb::tid_t tid, uint32_t save_id)
4243 {
4244     // We use the "m_supports_QSaveRegisterState" variable here because the
4245     // QSaveRegisterState and QRestoreRegisterState packets must both be supported in
4246     // order to be useful
4247     if (m_supports_QSaveRegisterState == eLazyBoolNo)
4248         return false;
4249 
4250     Mutex::Locker locker;
4251     if (GetSequenceMutex (locker, "Didn't get sequence mutex for QRestoreRegisterState."))
4252     {
4253         const bool thread_suffix_supported = GetThreadSuffixSupported();
4254         if (thread_suffix_supported || SetCurrentThread(tid))
4255         {
4256             char packet[256];
4257             if (thread_suffix_supported)
4258                 ::snprintf (packet, sizeof(packet), "QRestoreRegisterState:%u;thread:%4.4" PRIx64 ";", save_id, tid);
4259             else
4260                 ::snprintf (packet, sizeof(packet), "QRestoreRegisterState:%u" PRIx64 ";", save_id);
4261 
4262             StringExtractorGDBRemote response;
4263 
4264             if (SendPacketAndWaitForResponse(packet, response, false) == PacketResult::Success)
4265             {
4266                 if (response.IsOKResponse())
4267                 {
4268                     return true;
4269                 }
4270                 else if (response.IsUnsupportedResponse())
4271                 {
4272                     // This packet isn't supported, don't try calling this packet or
4273                     // QSaveRegisterState again...
4274                     m_supports_QSaveRegisterState = eLazyBoolNo;
4275                 }
4276             }
4277         }
4278     }
4279     return false;
4280 }
4281 
4282 bool
4283 GDBRemoteCommunicationClient::GetModuleInfo (const FileSpec& module_file_spec,
4284                                              const lldb_private::ArchSpec& arch_spec,
4285                                              ModuleSpec &module_spec)
4286 {
4287     std::string module_path = module_file_spec.GetPath (false);
4288     if (module_path.empty ())
4289         return false;
4290 
4291     StreamString packet;
4292     packet.PutCString("qModuleInfo:");
4293     packet.PutCStringAsRawHex8(module_path.c_str());
4294     packet.PutCString(";");
4295     const auto& triple = arch_spec.GetTriple().getTriple();
4296     packet.PutCStringAsRawHex8(triple.c_str());
4297 
4298     StringExtractorGDBRemote response;
4299     if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) != PacketResult::Success)
4300         return false;
4301 
4302     if (response.IsErrorResponse () || response.IsUnsupportedResponse ())
4303         return false;
4304 
4305     std::string name;
4306     std::string value;
4307     bool success;
4308     StringExtractor extractor;
4309 
4310     module_spec.Clear ();
4311     module_spec.GetFileSpec () = module_file_spec;
4312 
4313     while (response.GetNameColonValue (name, value))
4314     {
4315         if (name == "uuid" || name == "md5")
4316         {
4317             extractor.GetStringRef ().swap (value);
4318             extractor.SetFilePos (0);
4319             extractor.GetHexByteString (value);
4320             module_spec.GetUUID().SetFromCString (value.c_str(), value.size() / 2);
4321         }
4322         else if (name == "triple")
4323         {
4324             extractor.GetStringRef ().swap (value);
4325             extractor.SetFilePos (0);
4326             extractor.GetHexByteString (value);
4327             module_spec.GetArchitecture().SetTriple (value.c_str ());
4328         }
4329         else if (name == "file_offset")
4330         {
4331             const auto ival = StringConvert::ToUInt64 (value.c_str (), 0, 16, &success);
4332             if (success)
4333                 module_spec.SetObjectOffset (ival);
4334         }
4335         else if (name == "file_size")
4336         {
4337             const auto ival = StringConvert::ToUInt64 (value.c_str (), 0, 16, &success);
4338             if (success)
4339                 module_spec.SetObjectSize (ival);
4340         }
4341         else if (name == "file_path")
4342         {
4343             extractor.GetStringRef ().swap (value);
4344             extractor.SetFilePos (0);
4345             extractor.GetHexByteString (value);
4346             module_spec.GetFileSpec() = FileSpec(value.c_str(), false, arch_spec);
4347         }
4348     }
4349 
4350     return true;
4351 }
4352 
4353 // query the target remote for extended information using the qXfer packet
4354 //
4355 // example: object='features', annex='target.xml', out=<xml output>
4356 // return:  'true'  on success
4357 //          'false' on failure (err set)
4358 bool
4359 GDBRemoteCommunicationClient::ReadExtFeature (const lldb_private::ConstString object,
4360                                               const lldb_private::ConstString annex,
4361                                               std::string & out,
4362                                               lldb_private::Error & err) {
4363 
4364     std::stringstream output;
4365     StringExtractorGDBRemote chunk;
4366 
4367     uint64_t size = GetRemoteMaxPacketSize();
4368     if (size == 0)
4369         size = 0x1000;
4370     size = size - 1; // Leave space for the 'm' or 'l' character in the response
4371     int offset = 0;
4372     bool active = true;
4373 
4374     // loop until all data has been read
4375     while ( active ) {
4376 
4377         // send query extended feature packet
4378         std::stringstream packet;
4379         packet << "qXfer:"
4380                << object.AsCString("") << ":read:"
4381                << annex.AsCString("")  << ":"
4382                << std::hex << offset  << ","
4383                << std::hex << size;
4384 
4385         GDBRemoteCommunication::PacketResult res =
4386             SendPacketAndWaitForResponse( packet.str().c_str(),
4387                                           chunk,
4388                                           false );
4389 
4390         if ( res != GDBRemoteCommunication::PacketResult::Success ) {
4391             err.SetErrorString( "Error sending $qXfer packet" );
4392             return false;
4393         }
4394 
4395         const std::string & str = chunk.GetStringRef( );
4396         if ( str.length() == 0 ) {
4397             // should have some data in chunk
4398             err.SetErrorString( "Empty response from $qXfer packet" );
4399             return false;
4400         }
4401 
4402         // check packet code
4403         switch ( str[0] ) {
4404             // last chunk
4405         case ( 'l' ):
4406             active = false;
4407             // fall through intentional
4408 
4409             // more chunks
4410         case ( 'm' ) :
4411             if ( str.length() > 1 )
4412                 output << &str[1];
4413             offset += size;
4414             break;
4415 
4416             // unknown chunk
4417         default:
4418             err.SetErrorString( "Invalid continuation code from $qXfer packet" );
4419             return false;
4420         }
4421     }
4422 
4423     out = output.str( );
4424     err.Success( );
4425     return true;
4426 }
4427 
4428 // Notify the target that gdb is prepared to serve symbol lookup requests.
4429 //  packet: "qSymbol::"
4430 //  reply:
4431 //  OK                  The target does not need to look up any (more) symbols.
4432 //  qSymbol:<sym_name>  The target requests the value of symbol sym_name (hex encoded).
4433 //                      LLDB may provide the value by sending another qSymbol packet
4434 //                      in the form of"qSymbol:<sym_value>:<sym_name>".
4435 
4436 void
4437 GDBRemoteCommunicationClient::ServeSymbolLookups(lldb_private::Process *process)
4438 {
4439     if (m_supports_qSymbol)
4440     {
4441         Mutex::Locker locker;
4442         if (GetSequenceMutex(locker, "GDBRemoteCommunicationClient::ServeSymbolLookups() failed due to not getting the sequence mutex"))
4443         {
4444             StreamString packet;
4445             packet.PutCString ("qSymbol::");
4446             StringExtractorGDBRemote response;
4447             while (SendPacketAndWaitForResponseNoLock(packet.GetData(), packet.GetSize(), response) == PacketResult::Success)
4448             {
4449                 if (response.IsOKResponse())
4450                 {
4451                     // We are done serving symbols requests
4452                     return;
4453                 }
4454 
4455                 if (response.IsUnsupportedResponse())
4456                 {
4457                     // qSymbol is not supported by the current GDB server we are connected to
4458                     m_supports_qSymbol = false;
4459                     return;
4460                 }
4461                 else
4462                 {
4463                     llvm::StringRef response_str(response.GetStringRef());
4464                     if (response_str.startswith("qSymbol:"))
4465                     {
4466                         response.SetFilePos(strlen("qSymbol:"));
4467                         std::string symbol_name;
4468                         if (response.GetHexByteString(symbol_name))
4469                         {
4470                             if (symbol_name.empty())
4471                                 return;
4472 
4473                             addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
4474                             lldb_private::SymbolContextList sc_list;
4475                             if (process->GetTarget().GetImages().FindSymbolsWithNameAndType(ConstString(symbol_name), eSymbolTypeAny, sc_list))
4476                             {
4477                                 const size_t num_scs = sc_list.GetSize();
4478                                 for (size_t sc_idx=0; sc_idx<num_scs && symbol_load_addr == LLDB_INVALID_ADDRESS; ++sc_idx)
4479                                 {
4480                                     SymbolContext sc;
4481                                     if (sc_list.GetContextAtIndex(sc_idx, sc))
4482                                     {
4483                                         if (sc.symbol)
4484                                         {
4485                                             switch (sc.symbol->GetType())
4486                                             {
4487                                             case eSymbolTypeInvalid:
4488                                             case eSymbolTypeAbsolute:
4489                                             case eSymbolTypeUndefined:
4490                                             case eSymbolTypeSourceFile:
4491                                             case eSymbolTypeHeaderFile:
4492                                             case eSymbolTypeObjectFile:
4493                                             case eSymbolTypeCommonBlock:
4494                                             case eSymbolTypeBlock:
4495                                             case eSymbolTypeLocal:
4496                                             case eSymbolTypeParam:
4497                                             case eSymbolTypeVariable:
4498                                             case eSymbolTypeVariableType:
4499                                             case eSymbolTypeLineEntry:
4500                                             case eSymbolTypeLineHeader:
4501                                             case eSymbolTypeScopeBegin:
4502                                             case eSymbolTypeScopeEnd:
4503                                             case eSymbolTypeAdditional:
4504                                             case eSymbolTypeCompiler:
4505                                             case eSymbolTypeInstrumentation:
4506                                             case eSymbolTypeTrampoline:
4507                                                 break;
4508 
4509                                             case eSymbolTypeCode:
4510                                             case eSymbolTypeResolver:
4511                                             case eSymbolTypeData:
4512                                             case eSymbolTypeRuntime:
4513                                             case eSymbolTypeException:
4514                                             case eSymbolTypeObjCClass:
4515                                             case eSymbolTypeObjCMetaClass:
4516                                             case eSymbolTypeObjCIVar:
4517                                             case eSymbolTypeReExported:
4518                                                 symbol_load_addr = sc.symbol->GetLoadAddress(&process->GetTarget());
4519                                                 break;
4520                                             }
4521                                         }
4522                                     }
4523                                 }
4524                             }
4525                             // This is the normal path where our symbol lookup was successful and we want
4526                             // to send a packet with the new symbol value and see if another lookup needs to be
4527                             // done.
4528 
4529                             // Change "packet" to contain the requested symbol value and name
4530                             packet.Clear();
4531                             packet.PutCString("qSymbol:");
4532                             if (symbol_load_addr != LLDB_INVALID_ADDRESS)
4533                                 packet.Printf("%" PRIx64, symbol_load_addr);
4534                             packet.PutCString(":");
4535                             packet.PutBytesAsRawHex8(symbol_name.data(), symbol_name.size());
4536                             continue; // go back to the while loop and send "packet" and wait for another response
4537                         }
4538                     }
4539                 }
4540             }
4541             // If we make it here, the symbol request packet response wasn't valid or
4542             // our symbol lookup failed so we must abort
4543             return;
4544 
4545         }
4546     }
4547 }
4548 
4549