LLDB  mainline
GDBRemoteCommunicationClient.cpp
Go to the documentation of this file.
1 //===-- GDBRemoteCommunicationClient.cpp ------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
10 
11 #include <math.h>
12 #include <sys/stat.h>
13 
14 #include <numeric>
15 #include <sstream>
16 
17 #include "lldb/Core/ModuleSpec.h"
18 #include "lldb/Host/HostInfo.h"
19 #include "lldb/Host/XML.h"
20 #include "lldb/Symbol/Symbol.h"
22 #include "lldb/Target/Target.h"
24 #include "lldb/Utility/Args.h"
26 #include "lldb/Utility/JSON.h"
28 #include "lldb/Utility/Log.h"
29 #include "lldb/Utility/State.h"
31 
32 #include "ProcessGDBRemote.h"
33 #include "ProcessGDBRemoteLog.h"
34 #include "lldb/Host/Config.h"
36 
37 #include "llvm/ADT/StringSwitch.h"
38 
39 #if defined(__APPLE__)
40 #ifndef HAVE_LIBCOMPRESSION
41 #define HAVE_LIBCOMPRESSION
42 #endif
43 #include <compression.h>
44 #endif
45 
46 using namespace lldb;
47 using namespace lldb_private;
48 using namespace lldb_private::process_gdb_remote;
49 using namespace std::chrono;
50 
51 // GDBRemoteCommunicationClient constructor
52 GDBRemoteCommunicationClient::GDBRemoteCommunicationClient()
53  : GDBRemoteClientBase("gdb-remote.client", "gdb-remote.client.rx_packet"),
54  m_supports_not_sending_acks(eLazyBoolCalculate),
55  m_supports_thread_suffix(eLazyBoolCalculate),
56  m_supports_threads_in_stop_reply(eLazyBoolCalculate),
57  m_supports_vCont_all(eLazyBoolCalculate),
58  m_supports_vCont_any(eLazyBoolCalculate),
59  m_supports_vCont_c(eLazyBoolCalculate),
60  m_supports_vCont_C(eLazyBoolCalculate),
61  m_supports_vCont_s(eLazyBoolCalculate),
62  m_supports_vCont_S(eLazyBoolCalculate),
63  m_qHostInfo_is_valid(eLazyBoolCalculate),
64  m_curr_pid_is_valid(eLazyBoolCalculate),
65  m_qProcessInfo_is_valid(eLazyBoolCalculate),
66  m_qGDBServerVersion_is_valid(eLazyBoolCalculate),
67  m_supports_alloc_dealloc_memory(eLazyBoolCalculate),
68  m_supports_memory_region_info(eLazyBoolCalculate),
69  m_supports_watchpoint_support_info(eLazyBoolCalculate),
70  m_supports_detach_stay_stopped(eLazyBoolCalculate),
71  m_watchpoints_trigger_after_instruction(eLazyBoolCalculate),
72  m_attach_or_wait_reply(eLazyBoolCalculate),
73  m_prepare_for_reg_writing_reply(eLazyBoolCalculate),
74  m_supports_p(eLazyBoolCalculate), m_supports_x(eLazyBoolCalculate),
75  m_avoid_g_packets(eLazyBoolCalculate),
76  m_supports_QSaveRegisterState(eLazyBoolCalculate),
77  m_supports_qXfer_auxv_read(eLazyBoolCalculate),
78  m_supports_qXfer_libraries_read(eLazyBoolCalculate),
79  m_supports_qXfer_libraries_svr4_read(eLazyBoolCalculate),
80  m_supports_qXfer_features_read(eLazyBoolCalculate),
81  m_supports_qXfer_memory_map_read(eLazyBoolCalculate),
82  m_supports_augmented_libraries_svr4_read(eLazyBoolCalculate),
83  m_supports_jThreadExtendedInfo(eLazyBoolCalculate),
84  m_supports_jLoadedDynamicLibrariesInfos(eLazyBoolCalculate),
85  m_supports_jGetSharedCacheInfo(eLazyBoolCalculate),
86  m_supports_QPassSignals(eLazyBoolCalculate),
87  m_supports_error_string_reply(eLazyBoolCalculate),
88  m_supports_qProcessInfoPID(true), m_supports_qfProcessInfo(true),
89  m_supports_qUserName(true), m_supports_qGroupName(true),
90  m_supports_qThreadStopInfo(true), m_supports_z0(true),
91  m_supports_z1(true), m_supports_z2(true), m_supports_z3(true),
92  m_supports_z4(true), m_supports_QEnvironment(true),
93  m_supports_QEnvironmentHexEncoded(true), m_supports_qSymbol(true),
94  m_qSymbol_requests_done(false), m_supports_qModuleInfo(true),
95  m_supports_jThreadsInfo(true), m_supports_jModulesInfo(true),
96  m_curr_pid(LLDB_INVALID_PROCESS_ID), m_curr_tid(LLDB_INVALID_THREAD_ID),
97  m_curr_tid_run(LLDB_INVALID_THREAD_ID),
98  m_num_supported_hardware_watchpoints(0), m_host_arch(), m_process_arch(),
99  m_os_build(), m_os_kernel(), m_hostname(), m_gdb_server_name(),
100  m_gdb_server_version(UINT32_MAX), m_default_packet_timeout(0),
101  m_max_packet_size(0), m_qSupported_response(),
102  m_supported_async_json_packets_is_valid(false),
103  m_supported_async_json_packets_sp(), m_qXfer_memory_map(),
104  m_qXfer_memory_map_loaded(false) {}
105 
106 // Destructor
108  if (IsConnected())
109  Disconnect();
110 }
111 
114 
115  // Start the read thread after we send the handshake ack since if we fail to
116  // send the handshake ack, there is no reason to continue...
117  if (SendAck()) {
118  // Wait for any responses that might have been queued up in the remote
119  // GDB server and flush them all
120  StringExtractorGDBRemote response;
121  PacketResult packet_result = PacketResult::Success;
122  while (packet_result == PacketResult::Success)
123  packet_result = ReadPacket(response, milliseconds(10), false);
124 
125  // The return value from QueryNoAckModeSupported() is true if the packet
126  // was sent and _any_ response (including UNIMPLEMENTED) was received), or
127  // false if no response was received. This quickly tells us if we have a
128  // live connection to a remote GDB server...
129  if (QueryNoAckModeSupported()) {
130  return true;
131  } else {
132  if (error_ptr)
133  error_ptr->SetErrorString("failed to get reply to handshake packet");
134  }
135  } else {
136  if (error_ptr)
137  error_ptr->SetErrorString("failed to send the handshake ack");
138  }
139  return false;
140 }
141 
145  }
146  return m_supports_qEcho == eLazyBoolYes;
147 }
148 
152  }
154 }
155 
159  }
161 }
162 
166  }
168 }
169 
173  }
175 }
176 
180  }
182 }
183 
187  }
189 }
190 
194  }
196 }
197 
199  if (m_max_packet_size == 0) {
201  }
202  return m_max_packet_size;
203 }
204 
207  m_send_acks = true;
209 
210  // This is the first real packet that we'll send in a debug session and it
211  // may take a little longer than normal to receive a reply. Wait at least
212  // 6 seconds for a reply to this packet.
213 
214  ScopedTimeout timeout(*this, std::max(GetPacketTimeout(), seconds(6)));
215 
216  StringExtractorGDBRemote response;
217  if (SendPacketAndWaitForResponse("QStartNoAckMode", response, false) ==
219  if (response.IsOKResponse()) {
220  m_send_acks = false;
222  }
223  return true;
224  }
225  }
226  return false;
227 }
228 
232 
233  StringExtractorGDBRemote response;
234  if (SendPacketAndWaitForResponse("QListThreadsInStopReply", response,
235  false) == PacketResult::Success) {
236  if (response.IsOKResponse())
238  }
239  }
240 }
241 
245 
246  StringExtractorGDBRemote response;
247  if (SendPacketAndWaitForResponse("qVAttachOrWaitSupported", response,
248  false) == PacketResult::Success) {
249  if (response.IsOKResponse())
251  }
252  }
254 }
255 
259 
260  StringExtractorGDBRemote response;
261  if (SendPacketAndWaitForResponse("qSyncThreadStateSupported", response,
262  false) == PacketResult::Success) {
263  if (response.IsOKResponse())
265  }
266  }
268 }
269 
271  if (!did_exec) {
272  // Hard reset everything, this is when we first connect to a GDB server
299  m_supports_qUserName = true;
300  m_supports_qGroupName = true;
302  m_supports_z0 = true;
303  m_supports_z1 = true;
304  m_supports_z2 = true;
305  m_supports_z3 = true;
306  m_supports_z4 = true;
309  m_supports_qSymbol = true;
310  m_qSymbol_requests_done = false;
311  m_supports_qModuleInfo = true;
312  m_host_arch.Clear();
313  m_os_version = llvm::VersionTuple();
314  m_os_build.clear();
315  m_os_kernel.clear();
316  m_hostname.clear();
317  m_gdb_server_name.clear();
319  m_default_packet_timeout = seconds(0);
320  m_max_packet_size = 0;
321  m_qSupported_response.clear();
325  }
326 
327  // These flags should be reset when we first connect to a GDB server and when
328  // our inferior process execs
331 }
332 
334  // Clear out any capabilities we expect to see in the qSupported response
341  m_max_packet_size = UINT64_MAX; // It's supposed to always be there, but if
342  // not, we assume no limit
343 
344  // build the qSupported packet
345  std::vector<std::string> features = {"xmlRegisters=i386,arm,mips"};
346  StreamString packet;
347  packet.PutCString("qSupported");
348  for (uint32_t i = 0; i < features.size(); ++i) {
349  packet.PutCString(i == 0 ? ":" : ";");
350  packet.PutCString(features[i]);
351  }
352 
353  StringExtractorGDBRemote response;
354  if (SendPacketAndWaitForResponse(packet.GetString(), response,
355  /*send_async=*/false) ==
357  const char *response_cstr = response.GetStringRef().c_str();
358 
359  // Hang on to the qSupported packet, so that platforms can do custom
360  // configuration of the transport before attaching/launching the process.
361  m_qSupported_response = response_cstr;
362 
363  if (::strstr(response_cstr, "qXfer:auxv:read+"))
365  if (::strstr(response_cstr, "qXfer:libraries-svr4:read+"))
367  if (::strstr(response_cstr, "augmented-libraries-svr4-read")) {
370  }
371  if (::strstr(response_cstr, "qXfer:libraries:read+"))
373  if (::strstr(response_cstr, "qXfer:features:read+"))
375  if (::strstr(response_cstr, "qXfer:memory-map:read+"))
377 
378  // Look for a list of compressions in the features list e.g.
379  // qXfer:features:read+;PacketSize=20000;qEcho+;SupportedCompressions=zlib-
380  // deflate,lzma
381  const char *features_list = ::strstr(response_cstr, "qXfer:features:");
382  if (features_list) {
383  const char *compressions =
384  ::strstr(features_list, "SupportedCompressions=");
385  if (compressions) {
386  std::vector<std::string> supported_compressions;
387  compressions += sizeof("SupportedCompressions=") - 1;
388  const char *end_of_compressions = strchr(compressions, ';');
389  if (end_of_compressions == NULL) {
390  end_of_compressions = strchr(compressions, '\0');
391  }
392  const char *current_compression = compressions;
393  while (current_compression < end_of_compressions) {
394  const char *next_compression_name = strchr(current_compression, ',');
395  const char *end_of_this_word = next_compression_name;
396  if (next_compression_name == NULL ||
397  end_of_compressions < next_compression_name) {
398  end_of_this_word = end_of_compressions;
399  }
400 
401  if (end_of_this_word) {
402  if (end_of_this_word == current_compression) {
403  current_compression++;
404  } else {
405  std::string this_compression(
406  current_compression, end_of_this_word - current_compression);
407  supported_compressions.push_back(this_compression);
408  current_compression = end_of_this_word + 1;
409  }
410  } else {
411  supported_compressions.push_back(current_compression);
412  current_compression = end_of_compressions;
413  }
414  }
415 
416  if (supported_compressions.size() > 0) {
417  MaybeEnableCompression(supported_compressions);
418  }
419  }
420  }
421 
422  if (::strstr(response_cstr, "qEcho"))
424  else
426 
427  if (::strstr(response_cstr, "QPassSignals+"))
429  else
431 
432  const char *packet_size_str = ::strstr(response_cstr, "PacketSize=");
433  if (packet_size_str) {
434  StringExtractorGDBRemote packet_response(packet_size_str +
435  strlen("PacketSize="));
437  packet_response.GetHexMaxU64(/*little_endian=*/false, UINT64_MAX);
438  if (m_max_packet_size == 0) {
439  m_max_packet_size = UINT64_MAX; // Must have been a garbled response
440  Log *log(
442  if (log)
443  log->Printf("Garbled PacketSize spec in qSupported response");
444  }
445  }
446  }
447 }
448 
451  StringExtractorGDBRemote response;
453  if (SendPacketAndWaitForResponse("QThreadSuffixSupported", response,
454  false) == PacketResult::Success) {
455  if (response.IsOKResponse())
457  }
458  }
460 }
463  StringExtractorGDBRemote response;
470  if (SendPacketAndWaitForResponse("vCont?", response, false) ==
472  const char *response_cstr = response.GetStringRef().c_str();
473  if (::strstr(response_cstr, ";c"))
475 
476  if (::strstr(response_cstr, ";C"))
478 
479  if (::strstr(response_cstr, ";s"))
481 
482  if (::strstr(response_cstr, ";S"))
484 
490  }
491 
497  }
498  }
499  }
500 
501  switch (flavor) {
502  case 'a':
503  return m_supports_vCont_any;
504  case 'A':
505  return m_supports_vCont_all;
506  case 'c':
507  return m_supports_vCont_c;
508  case 'C':
509  return m_supports_vCont_C;
510  case 's':
511  return m_supports_vCont_s;
512  case 'S':
513  return m_supports_vCont_S;
514  default:
515  break;
516  }
517  return false;
518 }
519 
522  lldb::tid_t tid, StreamString &&payload, StringExtractorGDBRemote &response,
523  bool send_async) {
524  Lock lock(*this, send_async);
525  if (!lock) {
528  log->Printf("GDBRemoteCommunicationClient::%s: Didn't get sequence mutex "
529  "for %s packet.",
530  __FUNCTION__, payload.GetData());
532  }
533 
535  payload.Printf(";thread:%4.4" PRIx64 ";", tid);
536  else {
537  if (!SetCurrentThread(tid))
539  }
540 
541  return SendPacketAndWaitForResponseNoLock(payload.GetString(), response);
542 }
543 
544 // Check if the target supports 'p' packet. It sends out a 'p' packet and
545 // checks the response. A normal packet will tell us that support is available.
546 //
547 // Takes a valid thread ID because p needs to apply to a thread.
551  StreamString payload;
552  payload.PutCString("p0");
553  StringExtractorGDBRemote response;
554  if (SendThreadSpecificPacketAndWaitForResponse(tid, std::move(payload),
555  response, false) ==
557  response.IsNormalResponse()) {
559  }
560  }
561  return m_supports_p;
562 }
563 
565  // Get information on all threads at one using the "jThreadsInfo" packet
566  StructuredData::ObjectSP object_sp;
567 
569  StringExtractorGDBRemote response;
570  response.SetResponseValidatorToJSON();
571  if (SendPacketAndWaitForResponse("jThreadsInfo", response, false) ==
573  if (response.IsUnsupportedResponse()) {
574  m_supports_jThreadsInfo = false;
575  } else if (!response.Empty()) {
576  object_sp = StructuredData::ParseJSON(response.GetStringRef());
577  }
578  }
579  }
580  return object_sp;
581 }
582 
585  StringExtractorGDBRemote response;
587  if (SendPacketAndWaitForResponse("jThreadExtendedInfo:", response, false) ==
589  if (response.IsOKResponse()) {
591  }
592  }
593  }
595 }
596 
599  StringExtractorGDBRemote response;
600  // We try to enable error strings in remote packets but if we fail, we just
601  // work in the older way.
603  if (SendPacketAndWaitForResponse("QEnableErrorStrings", response, false) ==
605  if (response.IsOKResponse()) {
607  }
608  }
609  }
610 }
611 
614  StringExtractorGDBRemote response;
616  if (SendPacketAndWaitForResponse("jGetLoadedDynamicLibrariesInfos:",
617  response,
618  false) == PacketResult::Success) {
619  if (response.IsOKResponse()) {
621  }
622  }
623  }
625 }
626 
629  StringExtractorGDBRemote response;
631  if (SendPacketAndWaitForResponse("jGetSharedCacheInfo:", response, false) ==
633  if (response.IsOKResponse()) {
635  }
636  }
637  }
639 }
640 
643  StringExtractorGDBRemote response;
645  char packet[256];
646  snprintf(packet, sizeof(packet), "x0,0");
647  if (SendPacketAndWaitForResponse(packet, response, false) ==
649  if (response.IsOKResponse())
651  }
652  }
653  return m_supports_x;
654 }
655 
658  const char *payload_prefix, std::string &response_string) {
659  Lock lock(*this, false);
660  if (!lock) {
663  if (log)
664  log->Printf("error: failed to get packet sequence mutex, not sending "
665  "packets with prefix '%s'",
666  payload_prefix);
668  }
669 
670  response_string = "";
671  std::string payload_prefix_str(payload_prefix);
672  unsigned int response_size = 0x1000;
673  if (response_size > GetRemoteMaxPacketSize()) { // May send qSupported packet
674  response_size = GetRemoteMaxPacketSize();
675  }
676 
677  for (unsigned int offset = 0; true; offset += response_size) {
678  StringExtractorGDBRemote this_response;
679  // Construct payload
680  char sizeDescriptor[128];
681  snprintf(sizeDescriptor, sizeof(sizeDescriptor), "%x,%x", offset,
682  response_size);
684  payload_prefix_str + sizeDescriptor, this_response);
685  if (result != PacketResult::Success)
686  return result;
687 
688  const std::string &this_string = this_response.GetStringRef();
689 
690  // Check for m or l as first character; l seems to mean this is the last
691  // chunk
692  char first_char = *this_string.c_str();
693  if (first_char != 'm' && first_char != 'l') {
695  }
696  // Concatenate the result so far (skipping 'm' or 'l')
697  response_string.append(this_string, 1, std::string::npos);
698  if (first_char == 'l')
699  // We're done
700  return PacketResult::Success;
701  }
702 }
703 
705  if (allow_lazy && m_curr_pid_is_valid == eLazyBoolYes)
706  return m_curr_pid;
707 
708  // First try to retrieve the pid via the qProcessInfo request.
709  GetCurrentProcessInfo(allow_lazy);
711  // We really got it.
712  return m_curr_pid;
713  } else {
714  // If we don't get a response for qProcessInfo, check if $qC gives us a
715  // result. $qC only returns a real process id on older debugserver and
716  // lldb-platform stubs. The gdb remote protocol documents $qC as returning
717  // the thread id, which newer debugserver and lldb-gdbserver stubs return
718  // correctly.
719  StringExtractorGDBRemote response;
720  if (SendPacketAndWaitForResponse("qC", response, false) ==
722  if (response.GetChar() == 'Q') {
723  if (response.GetChar() == 'C') {
727  return m_curr_pid;
728  }
729  }
730  }
731  }
732 
733  // If we don't get a response for $qC, check if $qfThreadID gives us a
734  // result.
736  std::vector<lldb::tid_t> thread_ids;
737  bool sequence_mutex_unavailable;
738  size_t size;
739  size = GetCurrentThreadIDs(thread_ids, sequence_mutex_unavailable);
740  if (size && !sequence_mutex_unavailable) {
741  m_curr_pid = thread_ids.front();
743  return m_curr_pid;
744  }
745  }
746  }
747 
749 }
750 
752  error_str.clear();
753  StringExtractorGDBRemote response;
754  if (SendPacketAndWaitForResponse("qLaunchSuccess", response, false) ==
756  if (response.IsOKResponse())
757  return true;
758  if (response.GetChar() == 'E') {
759  // A string the describes what failed when launching...
760  error_str = response.GetStringRef().substr(1);
761  } else {
762  error_str.assign("unknown error occurred launching process");
763  }
764  } else {
765  error_str.assign("timed out waiting for app to launch");
766  }
767  return false;
768 }
769 
771  const ProcessLaunchInfo &launch_info) {
772  // Since we don't get the send argv0 separate from the executable path, we
773  // need to make sure to use the actual executable path found in the
774  // launch_info...
775  std::vector<const char *> argv;
776  FileSpec exe_file = launch_info.GetExecutableFile();
777  std::string exe_path;
778  const char *arg = NULL;
779  const Args &launch_args = launch_info.GetArguments();
780  if (exe_file)
781  exe_path = exe_file.GetPath(false);
782  else {
783  arg = launch_args.GetArgumentAtIndex(0);
784  if (arg)
785  exe_path = arg;
786  }
787  if (!exe_path.empty()) {
788  argv.push_back(exe_path.c_str());
789  for (uint32_t i = 1; (arg = launch_args.GetArgumentAtIndex(i)) != NULL;
790  ++i) {
791  if (arg)
792  argv.push_back(arg);
793  }
794  }
795  if (!argv.empty()) {
796  StreamString packet;
797  packet.PutChar('A');
798  for (size_t i = 0, n = argv.size(); i < n; ++i) {
799  arg = argv[i];
800  const int arg_len = strlen(arg);
801  if (i > 0)
802  packet.PutChar(',');
803  packet.Printf("%i,%i,", arg_len * 2, (int)i);
804  packet.PutBytesAsRawHex8(arg, arg_len);
805  }
806 
807  StringExtractorGDBRemote response;
808  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
810  if (response.IsOKResponse())
811  return 0;
812  uint8_t error = response.GetError();
813  if (error)
814  return error;
815  }
816  }
817  return -1;
818 }
819 
821  for (const auto &KV : env) {
822  int r = SendEnvironmentPacket(Environment::compose(KV).c_str());
823  if (r != 0)
824  return r;
825  }
826  return 0;
827 }
828 
830  char const *name_equal_value) {
831  if (name_equal_value && name_equal_value[0]) {
832  StreamString packet;
833  bool send_hex_encoding = false;
834  for (const char *p = name_equal_value; *p != '\0' && !send_hex_encoding;
835  ++p) {
836  if (isprint(*p)) {
837  switch (*p) {
838  case '$':
839  case '#':
840  case '*':
841  case '}':
842  send_hex_encoding = true;
843  break;
844  default:
845  break;
846  }
847  } else {
848  // We have non printable characters, lets hex encode this...
849  send_hex_encoding = true;
850  }
851  }
852 
853  StringExtractorGDBRemote response;
854  if (send_hex_encoding) {
856  packet.PutCString("QEnvironmentHexEncoded:");
857  packet.PutBytesAsRawHex8(name_equal_value, strlen(name_equal_value));
858  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
860  if (response.IsOKResponse())
861  return 0;
862  uint8_t error = response.GetError();
863  if (error)
864  return error;
865  if (response.IsUnsupportedResponse())
867  }
868  }
869 
870  } else if (m_supports_QEnvironment) {
871  packet.Printf("QEnvironment:%s", name_equal_value);
872  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
874  if (response.IsOKResponse())
875  return 0;
876  uint8_t error = response.GetError();
877  if (error)
878  return error;
879  if (response.IsUnsupportedResponse())
880  m_supports_QEnvironment = false;
881  }
882  }
883  }
884  return -1;
885 }
886 
888  if (arch && arch[0]) {
889  StreamString packet;
890  packet.Printf("QLaunchArch:%s", arch);
891  StringExtractorGDBRemote response;
892  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
894  if (response.IsOKResponse())
895  return 0;
896  uint8_t error = response.GetError();
897  if (error)
898  return error;
899  }
900  }
901  return -1;
902 }
903 
905  char const *data, bool *was_supported) {
906  if (data && *data != '\0') {
907  StreamString packet;
908  packet.Printf("QSetProcessEvent:%s", data);
909  StringExtractorGDBRemote response;
910  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
912  if (response.IsOKResponse()) {
913  if (was_supported)
914  *was_supported = true;
915  return 0;
916  } else if (response.IsUnsupportedResponse()) {
917  if (was_supported)
918  *was_supported = false;
919  return -1;
920  } else {
921  uint8_t error = response.GetError();
922  if (was_supported)
923  *was_supported = true;
924  if (error)
925  return error;
926  }
927  }
928  }
929  return -1;
930 }
931 
933  GetHostInfo();
934  return m_os_version;
935 }
936 
938  if (GetHostInfo()) {
939  if (!m_os_build.empty()) {
940  s = m_os_build;
941  return true;
942  }
943  }
944  s.clear();
945  return false;
946 }
947 
949  if (GetHostInfo()) {
950  if (!m_os_kernel.empty()) {
951  s = m_os_kernel;
952  return true;
953  }
954  }
955  s.clear();
956  return false;
957 }
958 
960  if (GetHostInfo()) {
961  if (!m_hostname.empty()) {
962  s = m_hostname;
963  return true;
964  }
965  }
966  s.clear();
967  return false;
968 }
969 
971  if (GetHostInfo())
972  return m_host_arch;
973  return ArchSpec();
974 }
975 
980  return m_process_arch;
981 }
982 
985  m_gdb_server_name.clear();
988 
989  StringExtractorGDBRemote response;
990  if (SendPacketAndWaitForResponse("qGDBServerVersion", response, false) ==
992  if (response.IsNormalResponse()) {
993  llvm::StringRef name, value;
994  bool success = false;
995  while (response.GetNameColonValue(name, value)) {
996  if (name.equals("name")) {
997  success = true;
998  m_gdb_server_name = value;
999  } else if (name.equals("version")) {
1000  llvm::StringRef major, minor;
1001  std::tie(major, minor) = value.split('.');
1002  if (!major.getAsInteger(0, m_gdb_server_version))
1003  success = true;
1004  }
1005  }
1006  if (success)
1008  }
1009  }
1010  }
1012 }
1013 
1015  std::vector<std::string> supported_compressions) {
1017  std::string avail_name;
1018 
1019 #if defined(HAVE_LIBCOMPRESSION)
1020  if (avail_type == CompressionType::None) {
1021  for (auto compression : supported_compressions) {
1022  if (compression == "lzfse") {
1023  avail_type = CompressionType::LZFSE;
1024  avail_name = compression;
1025  break;
1026  }
1027  }
1028  }
1029 #endif
1030 
1031 #if defined(HAVE_LIBCOMPRESSION)
1032  if (avail_type == CompressionType::None) {
1033  for (auto compression : supported_compressions) {
1034  if (compression == "zlib-deflate") {
1035  avail_type = CompressionType::ZlibDeflate;
1036  avail_name = compression;
1037  break;
1038  }
1039  }
1040  }
1041 #endif
1042 
1043 #if defined(HAVE_LIBZ)
1044  if (avail_type == CompressionType::None) {
1045  for (auto compression : supported_compressions) {
1046  if (compression == "zlib-deflate") {
1047  avail_type = CompressionType::ZlibDeflate;
1048  avail_name = compression;
1049  break;
1050  }
1051  }
1052  }
1053 #endif
1054 
1055 #if defined(HAVE_LIBCOMPRESSION)
1056  if (avail_type == CompressionType::None) {
1057  for (auto compression : supported_compressions) {
1058  if (compression == "lz4") {
1059  avail_type = CompressionType::LZ4;
1060  avail_name = compression;
1061  break;
1062  }
1063  }
1064  }
1065 #endif
1066 
1067 #if defined(HAVE_LIBCOMPRESSION)
1068  if (avail_type == CompressionType::None) {
1069  for (auto compression : supported_compressions) {
1070  if (compression == "lzma") {
1071  avail_type = CompressionType::LZMA;
1072  avail_name = compression;
1073  break;
1074  }
1075  }
1076  }
1077 #endif
1078 
1079  if (avail_type != CompressionType::None) {
1080  StringExtractorGDBRemote response;
1081  std::string packet = "QEnableCompression:type:" + avail_name + ";";
1082  if (SendPacketAndWaitForResponse(packet, response, false) !=
1084  return;
1085 
1086  if (response.IsOKResponse()) {
1087  m_compression_type = avail_type;
1088  }
1089  }
1090 }
1091 
1093  if (GetGDBServerVersion()) {
1094  if (!m_gdb_server_name.empty())
1095  return m_gdb_server_name.c_str();
1096  }
1097  return NULL;
1098 }
1099 
1101  if (GetGDBServerVersion())
1102  return m_gdb_server_version;
1103  return 0;
1104 }
1105 
1107  StringExtractorGDBRemote response;
1108  if (SendPacketAndWaitForResponse("qC", response, false) !=
1110  return false;
1111 
1112  if (!response.IsNormalResponse())
1113  return false;
1114 
1115  if (response.GetChar() == 'Q' && response.GetChar() == 'C')
1116  tid = response.GetHexMaxU32(true, -1);
1117 
1118  return true;
1119 }
1120 
1123 
1124  if (force || m_qHostInfo_is_valid == eLazyBoolCalculate) {
1125  // host info computation can require DNS traffic and shelling out to external processes.
1126  // Increase the timeout to account for that.
1127  ScopedTimeout timeout(*this, seconds(10));
1129  StringExtractorGDBRemote response;
1130  if (SendPacketAndWaitForResponse("qHostInfo", response, false) ==
1132  if (response.IsNormalResponse()) {
1133  llvm::StringRef name;
1134  llvm::StringRef value;
1136  uint32_t sub = 0;
1137  std::string arch_name;
1138  std::string os_name;
1139  std::string vendor_name;
1140  std::string triple;
1141  std::string distribution_id;
1142  uint32_t pointer_byte_size = 0;
1143  ByteOrder byte_order = eByteOrderInvalid;
1144  uint32_t num_keys_decoded = 0;
1145  while (response.GetNameColonValue(name, value)) {
1146  if (name.equals("cputype")) {
1147  // exception type in big endian hex
1148  if (!value.getAsInteger(0, cpu))
1149  ++num_keys_decoded;
1150  } else if (name.equals("cpusubtype")) {
1151  // exception count in big endian hex
1152  if (!value.getAsInteger(0, sub))
1153  ++num_keys_decoded;
1154  } else if (name.equals("arch")) {
1155  arch_name = value;
1156  ++num_keys_decoded;
1157  } else if (name.equals("triple")) {
1158  StringExtractor extractor(value);
1159  extractor.GetHexByteString(triple);
1160  ++num_keys_decoded;
1161  } else if (name.equals("distribution_id")) {
1162  StringExtractor extractor(value);
1163  extractor.GetHexByteString(distribution_id);
1164  ++num_keys_decoded;
1165  } else if (name.equals("os_build")) {
1166  StringExtractor extractor(value);
1167  extractor.GetHexByteString(m_os_build);
1168  ++num_keys_decoded;
1169  } else if (name.equals("hostname")) {
1170  StringExtractor extractor(value);
1171  extractor.GetHexByteString(m_hostname);
1172  ++num_keys_decoded;
1173  } else if (name.equals("os_kernel")) {
1174  StringExtractor extractor(value);
1175  extractor.GetHexByteString(m_os_kernel);
1176  ++num_keys_decoded;
1177  } else if (name.equals("ostype")) {
1178  os_name = value;
1179  ++num_keys_decoded;
1180  } else if (name.equals("vendor")) {
1181  vendor_name = value;
1182  ++num_keys_decoded;
1183  } else if (name.equals("endian")) {
1184  byte_order = llvm::StringSwitch<lldb::ByteOrder>(value)
1185  .Case("little", eByteOrderLittle)
1186  .Case("big", eByteOrderBig)
1187  .Case("pdp", eByteOrderPDP)
1188  .Default(eByteOrderInvalid);
1189  if (byte_order != eByteOrderInvalid)
1190  ++num_keys_decoded;
1191  } else if (name.equals("ptrsize")) {
1192  if (!value.getAsInteger(0, pointer_byte_size))
1193  ++num_keys_decoded;
1194  } else if (name.equals("os_version") ||
1195  name.equals(
1196  "version")) // Older debugserver binaries used the
1197  // "version" key instead of
1198  // "os_version"...
1199  {
1200  if (!m_os_version.tryParse(value))
1201  ++num_keys_decoded;
1202  } else if (name.equals("watchpoint_exceptions_received")) {
1204  llvm::StringSwitch<LazyBool>(value)
1205  .Case("before", eLazyBoolNo)
1206  .Case("after", eLazyBoolYes)
1207  .Default(eLazyBoolCalculate);
1209  ++num_keys_decoded;
1210  } else if (name.equals("default_packet_timeout")) {
1211  uint32_t timeout_seconds;
1212  if (!value.getAsInteger(0, timeout_seconds)) {
1213  m_default_packet_timeout = seconds(timeout_seconds);
1215  ++num_keys_decoded;
1216  }
1217  }
1218  }
1219 
1220  if (num_keys_decoded > 0)
1222 
1223  if (triple.empty()) {
1224  if (arch_name.empty()) {
1225  if (cpu != LLDB_INVALID_CPUTYPE) {
1227  if (pointer_byte_size) {
1228  assert(pointer_byte_size == m_host_arch.GetAddressByteSize());
1229  }
1230  if (byte_order != eByteOrderInvalid) {
1231  assert(byte_order == m_host_arch.GetByteOrder());
1232  }
1233 
1234  if (!vendor_name.empty())
1235  m_host_arch.GetTriple().setVendorName(
1236  llvm::StringRef(vendor_name));
1237  if (!os_name.empty())
1238  m_host_arch.GetTriple().setOSName(llvm::StringRef(os_name));
1239  }
1240  } else {
1241  std::string triple;
1242  triple += arch_name;
1243  if (!vendor_name.empty() || !os_name.empty()) {
1244  triple += '-';
1245  if (vendor_name.empty())
1246  triple += "unknown";
1247  else
1248  triple += vendor_name;
1249  triple += '-';
1250  if (os_name.empty())
1251  triple += "unknown";
1252  else
1253  triple += os_name;
1254  }
1255  m_host_arch.SetTriple(triple.c_str());
1256 
1257  llvm::Triple &host_triple = m_host_arch.GetTriple();
1258  if (host_triple.getVendor() == llvm::Triple::Apple &&
1259  host_triple.getOS() == llvm::Triple::Darwin) {
1260  switch (m_host_arch.GetMachine()) {
1261  case llvm::Triple::aarch64:
1262  case llvm::Triple::arm:
1263  case llvm::Triple::thumb:
1264  host_triple.setOS(llvm::Triple::IOS);
1265  break;
1266  default:
1267  host_triple.setOS(llvm::Triple::MacOSX);
1268  break;
1269  }
1270  }
1271  if (pointer_byte_size) {
1272  assert(pointer_byte_size == m_host_arch.GetAddressByteSize());
1273  }
1274  if (byte_order != eByteOrderInvalid) {
1275  assert(byte_order == m_host_arch.GetByteOrder());
1276  }
1277  }
1278  } else {
1279  m_host_arch.SetTriple(triple.c_str());
1280  if (pointer_byte_size) {
1281  assert(pointer_byte_size == m_host_arch.GetAddressByteSize());
1282  }
1283  if (byte_order != eByteOrderInvalid) {
1284  assert(byte_order == m_host_arch.GetByteOrder());
1285  }
1286 
1287  if (log)
1288  log->Printf("GDBRemoteCommunicationClient::%s parsed host "
1289  "architecture as %s, triple as %s from triple text %s",
1290  __FUNCTION__, m_host_arch.GetArchitectureName()
1292  : "<null-arch-name>",
1293  m_host_arch.GetTriple().getTriple().c_str(),
1294  triple.c_str());
1295  }
1296  if (!distribution_id.empty())
1297  m_host_arch.SetDistributionId(distribution_id.c_str());
1298  }
1299  }
1300  }
1302 }
1303 
1305  lldb::pid_t pid, StringExtractorGDBRemote &response) {
1306  if (pid != LLDB_INVALID_PROCESS_ID) {
1307  char packet[64];
1308  const int packet_len =
1309  ::snprintf(packet, sizeof(packet), "vAttach;%" PRIx64, pid);
1310  UNUSED_IF_ASSERT_DISABLED(packet_len);
1311  assert(packet_len < (int)sizeof(packet));
1312  if (SendPacketAndWaitForResponse(packet, response, false) ==
1314  if (response.IsErrorResponse())
1315  return response.GetError();
1316  return 0;
1317  }
1318  }
1319  return -1;
1320 }
1321 
1323  size_t data_len) {
1324  StreamString packet;
1325  packet.PutCString("I");
1326  packet.PutBytesAsRawHex8(data, data_len);
1327  StringExtractorGDBRemote response;
1328  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
1330  return 0;
1331  }
1332  return response.GetError();
1333 }
1334 
1335 const lldb_private::ArchSpec &
1338  GetHostInfo();
1339  return m_host_arch;
1340 }
1341 
1344  GetHostInfo();
1345  return m_default_packet_timeout;
1346 }
1347 
1349  uint32_t permissions) {
1352  char packet[64];
1353  const int packet_len = ::snprintf(
1354  packet, sizeof(packet), "_M%" PRIx64 ",%s%s%s", (uint64_t)size,
1355  permissions & lldb::ePermissionsReadable ? "r" : "",
1356  permissions & lldb::ePermissionsWritable ? "w" : "",
1357  permissions & lldb::ePermissionsExecutable ? "x" : "");
1358  assert(packet_len < (int)sizeof(packet));
1359  UNUSED_IF_ASSERT_DISABLED(packet_len);
1360  StringExtractorGDBRemote response;
1361  if (SendPacketAndWaitForResponse(packet, response, false) ==
1363  if (response.IsUnsupportedResponse())
1365  else if (!response.IsErrorResponse())
1366  return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
1367  } else {
1369  }
1370  }
1371  return LLDB_INVALID_ADDRESS;
1372 }
1373 
1377  char packet[64];
1378  const int packet_len =
1379  ::snprintf(packet, sizeof(packet), "_m%" PRIx64, (uint64_t)addr);
1380  assert(packet_len < (int)sizeof(packet));
1381  UNUSED_IF_ASSERT_DISABLED(packet_len);
1382  StringExtractorGDBRemote response;
1383  if (SendPacketAndWaitForResponse(packet, response, false) ==
1385  if (response.IsUnsupportedResponse())
1387  else if (response.IsOKResponse())
1388  return true;
1389  } else {
1391  }
1392  }
1393  return false;
1394 }
1395 
1397  Status error;
1398 
1399  if (keep_stopped) {
1401  char packet[64];
1402  const int packet_len =
1403  ::snprintf(packet, sizeof(packet), "qSupportsDetachAndStayStopped:");
1404  assert(packet_len < (int)sizeof(packet));
1405  UNUSED_IF_ASSERT_DISABLED(packet_len);
1406  StringExtractorGDBRemote response;
1407  if (SendPacketAndWaitForResponse(packet, response, false) ==
1409  response.IsOKResponse()) {
1411  } else {
1413  }
1414  }
1415 
1417  error.SetErrorString("Stays stopped not supported by this target.");
1418  return error;
1419  } else {
1420  StringExtractorGDBRemote response;
1421  PacketResult packet_result =
1422  SendPacketAndWaitForResponse("D1", response, false);
1423  if (packet_result != PacketResult::Success)
1424  error.SetErrorString("Sending extended disconnect packet failed.");
1425  }
1426  } else {
1427  StringExtractorGDBRemote response;
1428  PacketResult packet_result =
1429  SendPacketAndWaitForResponse("D", response, false);
1430  if (packet_result != PacketResult::Success)
1431  error.SetErrorString("Sending disconnect packet failed.");
1432  }
1433  return error;
1434 }
1435 
1437  lldb::addr_t addr, lldb_private::MemoryRegionInfo &region_info) {
1438  Status error;
1439  region_info.Clear();
1440 
1443  char packet[64];
1444  const int packet_len = ::snprintf(
1445  packet, sizeof(packet), "qMemoryRegionInfo:%" PRIx64, (uint64_t)addr);
1446  assert(packet_len < (int)sizeof(packet));
1447  UNUSED_IF_ASSERT_DISABLED(packet_len);
1448  StringExtractorGDBRemote response;
1449  if (SendPacketAndWaitForResponse(packet, response, false) ==
1452  llvm::StringRef name;
1453  llvm::StringRef value;
1454  addr_t addr_value = LLDB_INVALID_ADDRESS;
1455  bool success = true;
1456  bool saw_permissions = false;
1457  while (success && response.GetNameColonValue(name, value)) {
1458  if (name.equals("start")) {
1459  if (!value.getAsInteger(16, addr_value))
1460  region_info.GetRange().SetRangeBase(addr_value);
1461  } else if (name.equals("size")) {
1462  if (!value.getAsInteger(16, addr_value))
1463  region_info.GetRange().SetByteSize(addr_value);
1464  } else if (name.equals("permissions") &&
1465  region_info.GetRange().IsValid()) {
1466  saw_permissions = true;
1467  if (region_info.GetRange().Contains(addr)) {
1468  if (value.find('r') != llvm::StringRef::npos)
1469  region_info.SetReadable(MemoryRegionInfo::eYes);
1470  else
1471  region_info.SetReadable(MemoryRegionInfo::eNo);
1472 
1473  if (value.find('w') != llvm::StringRef::npos)
1474  region_info.SetWritable(MemoryRegionInfo::eYes);
1475  else
1476  region_info.SetWritable(MemoryRegionInfo::eNo);
1477 
1478  if (value.find('x') != llvm::StringRef::npos)
1480  else
1481  region_info.SetExecutable(MemoryRegionInfo::eNo);
1482 
1483  region_info.SetMapped(MemoryRegionInfo::eYes);
1484  } else {
1485  // The reported region does not contain this address -- we're
1486  // looking at an unmapped page
1487  region_info.SetReadable(MemoryRegionInfo::eNo);
1488  region_info.SetWritable(MemoryRegionInfo::eNo);
1489  region_info.SetExecutable(MemoryRegionInfo::eNo);
1490  region_info.SetMapped(MemoryRegionInfo::eNo);
1491  }
1492  } else if (name.equals("name")) {
1493  StringExtractorGDBRemote name_extractor(value);
1494  std::string name;
1495  name_extractor.GetHexByteString(name);
1496  region_info.SetName(name.c_str());
1497  } else if (name.equals("error")) {
1498  StringExtractorGDBRemote error_extractor(value);
1499  std::string error_string;
1500  // Now convert the HEX bytes into a string value
1501  error_extractor.GetHexByteString(error_string);
1502  error.SetErrorString(error_string.c_str());
1503  }
1504  }
1505 
1506  if (region_info.GetRange().IsValid()) {
1507  // We got a valid address range back but no permissions -- which means
1508  // this is an unmapped page
1509  if (!saw_permissions) {
1510  region_info.SetReadable(MemoryRegionInfo::eNo);
1511  region_info.SetWritable(MemoryRegionInfo::eNo);
1512  region_info.SetExecutable(MemoryRegionInfo::eNo);
1513  region_info.SetMapped(MemoryRegionInfo::eNo);
1514  }
1515  } else {
1516  // We got an invalid address range back
1517  error.SetErrorString("Server returned invalid range");
1518  }
1519  } else {
1521  }
1522  }
1523 
1525  error.SetErrorString("qMemoryRegionInfo is not supported");
1526  }
1527 
1528  // Try qXfer:memory-map:read to get region information not included in
1529  // qMemoryRegionInfo
1530  MemoryRegionInfo qXfer_region_info;
1531  Status qXfer_error = GetQXferMemoryMapRegionInfo(addr, qXfer_region_info);
1532 
1533  if (error.Fail()) {
1534  // If qMemoryRegionInfo failed, but qXfer:memory-map:read succeeded, use
1535  // the qXfer result as a fallback
1536  if (qXfer_error.Success()) {
1537  region_info = qXfer_region_info;
1538  error.Clear();
1539  } else {
1540  region_info.Clear();
1541  }
1542  } else if (qXfer_error.Success()) {
1543  // If both qMemoryRegionInfo and qXfer:memory-map:read succeeded, and if
1544  // both regions are the same range, update the result to include the flash-
1545  // memory information that is specific to the qXfer result.
1546  if (region_info.GetRange() == qXfer_region_info.GetRange()) {
1547  region_info.SetFlash(qXfer_region_info.GetFlash());
1548  region_info.SetBlocksize(qXfer_region_info.GetBlocksize());
1549  }
1550  }
1551  return error;
1552 }
1553 
1555  lldb::addr_t addr, MemoryRegionInfo &region) {
1556  Status error = LoadQXferMemoryMap();
1557  if (!error.Success())
1558  return error;
1559  for (const auto &map_region : m_qXfer_memory_map) {
1560  if (map_region.GetRange().Contains(addr)) {
1561  region = map_region;
1562  return error;
1563  }
1564  }
1565  error.SetErrorString("Region not found");
1566  return error;
1567 }
1568 
1570 
1571  Status error;
1572 
1574  // Already loaded, return success
1575  return error;
1576 
1577  if (!XMLDocument::XMLEnabled()) {
1578  error.SetErrorString("XML is not supported");
1579  return error;
1580  }
1581 
1583  error.SetErrorString("Memory map is not supported");
1584  return error;
1585  }
1586 
1587  std::string xml;
1588  lldb_private::Status lldberr;
1589  if (!ReadExtFeature(ConstString("memory-map"), ConstString(""), xml,
1590  lldberr)) {
1591  error.SetErrorString("Failed to read memory map");
1592  return error;
1593  }
1594 
1595  XMLDocument xml_document;
1596 
1597  if (!xml_document.ParseMemory(xml.c_str(), xml.size())) {
1598  error.SetErrorString("Failed to parse memory map xml");
1599  return error;
1600  }
1601 
1602  XMLNode map_node = xml_document.GetRootElement("memory-map");
1603  if (!map_node) {
1604  error.SetErrorString("Invalid root node in memory map xml");
1605  return error;
1606  }
1607 
1608  m_qXfer_memory_map.clear();
1609 
1610  map_node.ForEachChildElement([this](const XMLNode &memory_node) -> bool {
1611  if (!memory_node.IsElement())
1612  return true;
1613  if (memory_node.GetName() != "memory")
1614  return true;
1615  auto type = memory_node.GetAttributeValue("type", "");
1616  uint64_t start;
1617  uint64_t length;
1618  if (!memory_node.GetAttributeValueAsUnsigned("start", start))
1619  return true;
1620  if (!memory_node.GetAttributeValueAsUnsigned("length", length))
1621  return true;
1622  MemoryRegionInfo region;
1623  region.GetRange().SetRangeBase(start);
1624  region.GetRange().SetByteSize(length);
1625  if (type == "rom") {
1627  this->m_qXfer_memory_map.push_back(region);
1628  } else if (type == "ram") {
1631  this->m_qXfer_memory_map.push_back(region);
1632  } else if (type == "flash") {
1634  memory_node.ForEachChildElement(
1635  [&region](const XMLNode &prop_node) -> bool {
1636  if (!prop_node.IsElement())
1637  return true;
1638  if (prop_node.GetName() != "property")
1639  return true;
1640  auto propname = prop_node.GetAttributeValue("name", "");
1641  if (propname == "blocksize") {
1642  uint64_t blocksize;
1643  if (prop_node.GetElementTextAsUnsigned(blocksize))
1644  region.SetBlocksize(blocksize);
1645  }
1646  return true;
1647  });
1648  this->m_qXfer_memory_map.push_back(region);
1649  }
1650  return true;
1651  });
1652 
1654 
1655  return error;
1656 }
1657 
1659  Status error;
1660 
1663  return error;
1664  }
1665 
1666  // Set num to 0 first.
1667  num = 0;
1669  char packet[64];
1670  const int packet_len =
1671  ::snprintf(packet, sizeof(packet), "qWatchpointSupportInfo:");
1672  assert(packet_len < (int)sizeof(packet));
1673  UNUSED_IF_ASSERT_DISABLED(packet_len);
1674  StringExtractorGDBRemote response;
1675  if (SendPacketAndWaitForResponse(packet, response, false) ==
1678  llvm::StringRef name;
1679  llvm::StringRef value;
1680  bool found_num_field = false;
1681  while (response.GetNameColonValue(name, value)) {
1682  if (name.equals("num")) {
1683  value.getAsInteger(0, m_num_supported_hardware_watchpoints);
1685  found_num_field = true;
1686  }
1687  }
1688  if (!found_num_field) {
1690  }
1691  } else {
1693  }
1694  }
1695 
1697  error.SetErrorString("qWatchpointSupportInfo is not supported");
1698  }
1699  return error;
1700 }
1701 
1703  uint32_t &num, bool &after, const ArchSpec &arch) {
1704  Status error(GetWatchpointSupportInfo(num));
1705  if (error.Success())
1706  error = GetWatchpointsTriggerAfterInstruction(after, arch);
1707  return error;
1708 }
1709 
1712  bool &after, const ArchSpec &arch) {
1713  Status error;
1714  llvm::Triple::ArchType atype = arch.GetMachine();
1715 
1716  // we assume watchpoints will happen after running the relevant opcode and we
1717  // only want to override this behavior if we have explicitly received a
1718  // qHostInfo telling us otherwise
1720  // On targets like MIPS and ppc64le, watchpoint exceptions are always
1721  // generated before the instruction is executed. The connected target may
1722  // not support qHostInfo or qWatchpointSupportInfo packets.
1723  after =
1724  !(atype == llvm::Triple::mips || atype == llvm::Triple::mipsel ||
1725  atype == llvm::Triple::mips64 || atype == llvm::Triple::mips64el ||
1726  atype == llvm::Triple::ppc64le);
1727  } else {
1728  // For MIPS and ppc64le, set m_watchpoints_trigger_after_instruction to
1729  // eLazyBoolNo if it is not calculated before.
1731  (atype == llvm::Triple::mips || atype == llvm::Triple::mipsel ||
1732  atype == llvm::Triple::mips64 || atype == llvm::Triple::mips64el)) ||
1733  atype == llvm::Triple::ppc64le) {
1735  }
1736 
1738  }
1739  return error;
1740 }
1741 
1743  if (file_spec) {
1744  std::string path{file_spec.GetPath(false)};
1745  StreamString packet;
1746  packet.PutCString("QSetSTDIN:");
1747  packet.PutStringAsRawHex8(path);
1748 
1749  StringExtractorGDBRemote response;
1750  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
1752  if (response.IsOKResponse())
1753  return 0;
1754  uint8_t error = response.GetError();
1755  if (error)
1756  return error;
1757  }
1758  }
1759  return -1;
1760 }
1761 
1763  if (file_spec) {
1764  std::string path{file_spec.GetPath(false)};
1765  StreamString packet;
1766  packet.PutCString("QSetSTDOUT:");
1767  packet.PutStringAsRawHex8(path);
1768 
1769  StringExtractorGDBRemote response;
1770  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
1772  if (response.IsOKResponse())
1773  return 0;
1774  uint8_t error = response.GetError();
1775  if (error)
1776  return error;
1777  }
1778  }
1779  return -1;
1780 }
1781 
1783  if (file_spec) {
1784  std::string path{file_spec.GetPath(false)};
1785  StreamString packet;
1786  packet.PutCString("QSetSTDERR:");
1787  packet.PutStringAsRawHex8(path);
1788 
1789  StringExtractorGDBRemote response;
1790  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
1792  if (response.IsOKResponse())
1793  return 0;
1794  uint8_t error = response.GetError();
1795  if (error)
1796  return error;
1797  }
1798  }
1799  return -1;
1800 }
1801 
1803  StringExtractorGDBRemote response;
1804  if (SendPacketAndWaitForResponse("qGetWorkingDir", response, false) ==
1806  if (response.IsUnsupportedResponse())
1807  return false;
1808  if (response.IsErrorResponse())
1809  return false;
1810  std::string cwd;
1811  response.GetHexByteString(cwd);
1812  working_dir.SetFile(cwd, GetHostArchitecture().GetTriple());
1813  return !cwd.empty();
1814  }
1815  return false;
1816 }
1817 
1819  if (working_dir) {
1820  std::string path{working_dir.GetPath(false)};
1821  StreamString packet;
1822  packet.PutCString("QSetWorkingDir:");
1823  packet.PutStringAsRawHex8(path);
1824 
1825  StringExtractorGDBRemote response;
1826  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
1828  if (response.IsOKResponse())
1829  return 0;
1830  uint8_t error = response.GetError();
1831  if (error)
1832  return error;
1833  }
1834  }
1835  return -1;
1836 }
1837 
1839  char packet[32];
1840  const int packet_len =
1841  ::snprintf(packet, sizeof(packet), "QSetDisableASLR:%i", enable ? 1 : 0);
1842  assert(packet_len < (int)sizeof(packet));
1843  UNUSED_IF_ASSERT_DISABLED(packet_len);
1844  StringExtractorGDBRemote response;
1845  if (SendPacketAndWaitForResponse(packet, response, false) ==
1847  if (response.IsOKResponse())
1848  return 0;
1849  uint8_t error = response.GetError();
1850  if (error)
1851  return error;
1852  }
1853  return -1;
1854 }
1855 
1857  char packet[32];
1858  const int packet_len = ::snprintf(packet, sizeof(packet),
1859  "QSetDetachOnError:%i", enable ? 1 : 0);
1860  assert(packet_len < (int)sizeof(packet));
1861  UNUSED_IF_ASSERT_DISABLED(packet_len);
1862  StringExtractorGDBRemote response;
1863  if (SendPacketAndWaitForResponse(packet, response, false) ==
1865  if (response.IsOKResponse())
1866  return 0;
1867  uint8_t error = response.GetError();
1868  if (error)
1869  return error;
1870  }
1871  return -1;
1872 }
1873 
1875  StringExtractorGDBRemote &response, ProcessInstanceInfo &process_info) {
1876  if (response.IsNormalResponse()) {
1877  llvm::StringRef name;
1878  llvm::StringRef value;
1879  StringExtractor extractor;
1880 
1882  uint32_t sub = 0;
1883  std::string vendor;
1884  std::string os_type;
1885 
1886  while (response.GetNameColonValue(name, value)) {
1887  if (name.equals("pid")) {
1889  value.getAsInteger(0, pid);
1890  process_info.SetProcessID(pid);
1891  } else if (name.equals("ppid")) {
1893  value.getAsInteger(0, pid);
1894  process_info.SetParentProcessID(pid);
1895  } else if (name.equals("uid")) {
1896  uint32_t uid = UINT32_MAX;
1897  value.getAsInteger(0, uid);
1898  process_info.SetUserID(uid);
1899  } else if (name.equals("euid")) {
1900  uint32_t uid = UINT32_MAX;
1901  value.getAsInteger(0, uid);
1902  process_info.SetEffectiveGroupID(uid);
1903  } else if (name.equals("gid")) {
1904  uint32_t gid = UINT32_MAX;
1905  value.getAsInteger(0, gid);
1906  process_info.SetGroupID(gid);
1907  } else if (name.equals("egid")) {
1908  uint32_t gid = UINT32_MAX;
1909  value.getAsInteger(0, gid);
1910  process_info.SetEffectiveGroupID(gid);
1911  } else if (name.equals("triple")) {
1912  StringExtractor extractor(value);
1913  std::string triple;
1914  extractor.GetHexByteString(triple);
1915  process_info.GetArchitecture().SetTriple(triple.c_str());
1916  } else if (name.equals("name")) {
1917  StringExtractor extractor(value);
1918  // The process name from ASCII hex bytes since we can't control the
1919  // characters in a process name
1920  std::string name;
1921  extractor.GetHexByteString(name);
1922  process_info.GetExecutableFile().SetFile(name, FileSpec::Style::native);
1923  } else if (name.equals("cputype")) {
1924  value.getAsInteger(0, cpu);
1925  } else if (name.equals("cpusubtype")) {
1926  value.getAsInteger(0, sub);
1927  } else if (name.equals("vendor")) {
1928  vendor = value;
1929  } else if (name.equals("ostype")) {
1930  os_type = value;
1931  }
1932  }
1933 
1934  if (cpu != LLDB_INVALID_CPUTYPE && !vendor.empty() && !os_type.empty()) {
1935  if (vendor == "apple") {
1936  process_info.GetArchitecture().SetArchitecture(eArchTypeMachO, cpu,
1937  sub);
1938  process_info.GetArchitecture().GetTriple().setVendorName(
1939  llvm::StringRef(vendor));
1940  process_info.GetArchitecture().GetTriple().setOSName(
1941  llvm::StringRef(os_type));
1942  }
1943  }
1944 
1945  if (process_info.GetProcessID() != LLDB_INVALID_PROCESS_ID)
1946  return true;
1947  }
1948  return false;
1949 }
1950 
1952  lldb::pid_t pid, ProcessInstanceInfo &process_info) {
1953  process_info.Clear();
1954 
1956  char packet[32];
1957  const int packet_len =
1958  ::snprintf(packet, sizeof(packet), "qProcessInfoPID:%" PRIu64, pid);
1959  assert(packet_len < (int)sizeof(packet));
1960  UNUSED_IF_ASSERT_DISABLED(packet_len);
1961  StringExtractorGDBRemote response;
1962  if (SendPacketAndWaitForResponse(packet, response, false) ==
1964  return DecodeProcessInfoResponse(response, process_info);
1965  } else {
1967  return false;
1968  }
1969  }
1970  return false;
1971 }
1972 
1975  GDBR_LOG_PACKETS));
1976 
1977  if (allow_lazy) {
1979  return true;
1981  return false;
1982  }
1983 
1984  GetHostInfo();
1985 
1986  StringExtractorGDBRemote response;
1987  if (SendPacketAndWaitForResponse("qProcessInfo", response, false) ==
1989  if (response.IsNormalResponse()) {
1990  llvm::StringRef name;
1991  llvm::StringRef value;
1993  uint32_t sub = 0;
1994  std::string arch_name;
1995  std::string os_name;
1996  std::string vendor_name;
1997  std::string triple;
1998  std::string elf_abi;
1999  uint32_t pointer_byte_size = 0;
2000  StringExtractor extractor;
2001  ByteOrder byte_order = eByteOrderInvalid;
2002  uint32_t num_keys_decoded = 0;
2004  while (response.GetNameColonValue(name, value)) {
2005  if (name.equals("cputype")) {
2006  if (!value.getAsInteger(16, cpu))
2007  ++num_keys_decoded;
2008  } else if (name.equals("cpusubtype")) {
2009  if (!value.getAsInteger(16, sub))
2010  ++num_keys_decoded;
2011  } else if (name.equals("triple")) {
2012  StringExtractor extractor(value);
2013  extractor.GetHexByteString(triple);
2014  ++num_keys_decoded;
2015  } else if (name.equals("ostype")) {
2016  os_name = value;
2017  ++num_keys_decoded;
2018  } else if (name.equals("vendor")) {
2019  vendor_name = value;
2020  ++num_keys_decoded;
2021  } else if (name.equals("endian")) {
2022  byte_order = llvm::StringSwitch<lldb::ByteOrder>(value)
2023  .Case("little", eByteOrderLittle)
2024  .Case("big", eByteOrderBig)
2025  .Case("pdp", eByteOrderPDP)
2026  .Default(eByteOrderInvalid);
2027  if (byte_order != eByteOrderInvalid)
2028  ++num_keys_decoded;
2029  } else if (name.equals("ptrsize")) {
2030  if (!value.getAsInteger(16, pointer_byte_size))
2031  ++num_keys_decoded;
2032  } else if (name.equals("pid")) {
2033  if (!value.getAsInteger(16, pid))
2034  ++num_keys_decoded;
2035  } else if (name.equals("elf_abi")) {
2036  elf_abi = value;
2037  ++num_keys_decoded;
2038  }
2039  }
2040  if (num_keys_decoded > 0)
2042  if (pid != LLDB_INVALID_PROCESS_ID) {
2044  m_curr_pid = pid;
2045  }
2046 
2047  // Set the ArchSpec from the triple if we have it.
2048  if (!triple.empty()) {
2049  m_process_arch.SetTriple(triple.c_str());
2050  m_process_arch.SetFlags(elf_abi);
2051  if (pointer_byte_size) {
2052  assert(pointer_byte_size == m_process_arch.GetAddressByteSize());
2053  }
2054  } else if (cpu != LLDB_INVALID_CPUTYPE && !os_name.empty() &&
2055  !vendor_name.empty()) {
2056  llvm::Triple triple(llvm::Twine("-") + vendor_name + "-" + os_name);
2057 
2058  assert(triple.getObjectFormat() != llvm::Triple::UnknownObjectFormat);
2059  assert(triple.getObjectFormat() != llvm::Triple::Wasm);
2060  assert(triple.getObjectFormat() != llvm::Triple::XCOFF);
2061  switch (triple.getObjectFormat()) {
2062  case llvm::Triple::MachO:
2064  break;
2065  case llvm::Triple::ELF:
2067  break;
2068  case llvm::Triple::COFF:
2070  break;
2071  case llvm::Triple::Wasm:
2072  case llvm::Triple::XCOFF:
2073  if (log)
2074  log->Printf("error: not supported target architecture");
2075  return false;
2076  case llvm::Triple::UnknownObjectFormat:
2077  if (log)
2078  log->Printf("error: failed to determine target architecture");
2079  return false;
2080  }
2081 
2082  if (pointer_byte_size) {
2083  assert(pointer_byte_size == m_process_arch.GetAddressByteSize());
2084  }
2085  if (byte_order != eByteOrderInvalid) {
2086  assert(byte_order == m_process_arch.GetByteOrder());
2087  }
2088  m_process_arch.GetTriple().setVendorName(llvm::StringRef(vendor_name));
2089  m_process_arch.GetTriple().setOSName(llvm::StringRef(os_name));
2090  m_host_arch.GetTriple().setVendorName(llvm::StringRef(vendor_name));
2091  m_host_arch.GetTriple().setOSName(llvm::StringRef(os_name));
2092  }
2093  return true;
2094  }
2095  } else {
2097  }
2098 
2099  return false;
2100 }
2101 
2103  const ProcessInstanceInfoMatch &match_info,
2104  ProcessInstanceInfoList &process_infos) {
2105  process_infos.Clear();
2106 
2108  StreamString packet;
2109  packet.PutCString("qfProcessInfo");
2110  if (!match_info.MatchAllProcesses()) {
2111  packet.PutChar(':');
2112  const char *name = match_info.GetProcessInfo().GetName();
2113  bool has_name_match = false;
2114  if (name && name[0]) {
2115  has_name_match = true;
2116  NameMatch name_match_type = match_info.GetNameMatchType();
2117  switch (name_match_type) {
2118  case NameMatch::Ignore:
2119  has_name_match = false;
2120  break;
2121 
2122  case NameMatch::Equals:
2123  packet.PutCString("name_match:equals;");
2124  break;
2125 
2126  case NameMatch::Contains:
2127  packet.PutCString("name_match:contains;");
2128  break;
2129 
2130  case NameMatch::StartsWith:
2131  packet.PutCString("name_match:starts_with;");
2132  break;
2133 
2134  case NameMatch::EndsWith:
2135  packet.PutCString("name_match:ends_with;");
2136  break;
2137 
2139  packet.PutCString("name_match:regex;");
2140  break;
2141  }
2142  if (has_name_match) {
2143  packet.PutCString("name:");
2144  packet.PutBytesAsRawHex8(name, ::strlen(name));
2145  packet.PutChar(';');
2146  }
2147  }
2148 
2149  if (match_info.GetProcessInfo().ProcessIDIsValid())
2150  packet.Printf("pid:%" PRIu64 ";",
2151  match_info.GetProcessInfo().GetProcessID());
2152  if (match_info.GetProcessInfo().ParentProcessIDIsValid())
2153  packet.Printf("parent_pid:%" PRIu64 ";",
2154  match_info.GetProcessInfo().GetParentProcessID());
2155  if (match_info.GetProcessInfo().UserIDIsValid())
2156  packet.Printf("uid:%u;", match_info.GetProcessInfo().GetUserID());
2157  if (match_info.GetProcessInfo().GroupIDIsValid())
2158  packet.Printf("gid:%u;", match_info.GetProcessInfo().GetGroupID());
2159  if (match_info.GetProcessInfo().EffectiveUserIDIsValid())
2160  packet.Printf("euid:%u;",
2161  match_info.GetProcessInfo().GetEffectiveUserID());
2162  if (match_info.GetProcessInfo().EffectiveGroupIDIsValid())
2163  packet.Printf("egid:%u;",
2164  match_info.GetProcessInfo().GetEffectiveGroupID());
2165  if (match_info.GetProcessInfo().EffectiveGroupIDIsValid())
2166  packet.Printf("all_users:%u;", match_info.GetMatchAllUsers() ? 1 : 0);
2167  if (match_info.GetProcessInfo().GetArchitecture().IsValid()) {
2168  const ArchSpec &match_arch =
2169  match_info.GetProcessInfo().GetArchitecture();
2170  const llvm::Triple &triple = match_arch.GetTriple();
2171  packet.PutCString("triple:");
2172  packet.PutCString(triple.getTriple());
2173  packet.PutChar(';');
2174  }
2175  }
2176  StringExtractorGDBRemote response;
2177  // Increase timeout as the first qfProcessInfo packet takes a long time on
2178  // Android. The value of 1min was arrived at empirically.
2179  ScopedTimeout timeout(*this, minutes(1));
2180  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
2182  do {
2183  ProcessInstanceInfo process_info;
2184  if (!DecodeProcessInfoResponse(response, process_info))
2185  break;
2186  process_infos.Append(process_info);
2187  response.GetStringRef().clear();
2188  response.SetFilePos(0);
2189  } while (SendPacketAndWaitForResponse("qsProcessInfo", response, false) ==
2191  } else {
2192  m_supports_qfProcessInfo = false;
2193  return 0;
2194  }
2195  }
2196  return process_infos.GetSize();
2197 }
2198 
2200  std::string &name) {
2201  if (m_supports_qUserName) {
2202  char packet[32];
2203  const int packet_len =
2204  ::snprintf(packet, sizeof(packet), "qUserName:%i", uid);
2205  assert(packet_len < (int)sizeof(packet));
2206  UNUSED_IF_ASSERT_DISABLED(packet_len);
2207  StringExtractorGDBRemote response;
2208  if (SendPacketAndWaitForResponse(packet, response, false) ==
2210  if (response.IsNormalResponse()) {
2211  // Make sure we parsed the right number of characters. The response is
2212  // the hex encoded user name and should make up the entire packet. If
2213  // there are any non-hex ASCII bytes, the length won't match below..
2214  if (response.GetHexByteString(name) * 2 ==
2215  response.GetStringRef().size())
2216  return true;
2217  }
2218  } else {
2219  m_supports_qUserName = false;
2220  return false;
2221  }
2222  }
2223  return false;
2224 }
2225 
2227  std::string &name) {
2228  if (m_supports_qGroupName) {
2229  char packet[32];
2230  const int packet_len =
2231  ::snprintf(packet, sizeof(packet), "qGroupName:%i", gid);
2232  assert(packet_len < (int)sizeof(packet));
2233  UNUSED_IF_ASSERT_DISABLED(packet_len);
2234  StringExtractorGDBRemote response;
2235  if (SendPacketAndWaitForResponse(packet, response, false) ==
2237  if (response.IsNormalResponse()) {
2238  // Make sure we parsed the right number of characters. The response is
2239  // the hex encoded group name and should make up the entire packet. If
2240  // there are any non-hex ASCII bytes, the length won't match below..
2241  if (response.GetHexByteString(name) * 2 ==
2242  response.GetStringRef().size())
2243  return true;
2244  }
2245  } else {
2246  m_supports_qGroupName = false;
2247  return false;
2248  }
2249  }
2250  return false;
2251 }
2252 
2254  // Form non-stop packet request
2255  char packet[32];
2256  const int packet_len =
2257  ::snprintf(packet, sizeof(packet), "QNonStop:%1d", (int)enable);
2258  assert(packet_len < (int)sizeof(packet));
2259  UNUSED_IF_ASSERT_DISABLED(packet_len);
2260 
2261  StringExtractorGDBRemote response;
2262  // Send to target
2263  if (SendPacketAndWaitForResponse(packet, response, false) ==
2265  if (response.IsOKResponse())
2266  return true;
2267 
2268  // Failed or not supported
2269  return false;
2270 }
2271 
2272 static void MakeSpeedTestPacket(StreamString &packet, uint32_t send_size,
2273  uint32_t recv_size) {
2274  packet.Clear();
2275  packet.Printf("qSpeedTest:response_size:%i;data:", recv_size);
2276  uint32_t bytes_left = send_size;
2277  while (bytes_left > 0) {
2278  if (bytes_left >= 26) {
2279  packet.PutCString("abcdefghijklmnopqrstuvwxyz");
2280  bytes_left -= 26;
2281  } else {
2282  packet.Printf("%*.*s;", bytes_left, bytes_left,
2283  "abcdefghijklmnopqrstuvwxyz");
2284  bytes_left = 0;
2285  }
2286  }
2287 }
2288 
2289 duration<float>
2290 calculate_standard_deviation(const std::vector<duration<float>> &v) {
2291  using Dur = duration<float>;
2292  Dur sum = std::accumulate(std::begin(v), std::end(v), Dur());
2293  Dur mean = sum / v.size();
2294  float accum = 0;
2295  for (auto d : v) {
2296  float delta = (d - mean).count();
2297  accum += delta * delta;
2298  };
2299 
2300  return Dur(sqrtf(accum / (v.size() - 1)));
2301 }
2302 
2304  uint32_t max_send,
2305  uint32_t max_recv,
2306  uint64_t recv_amount,
2307  bool json, Stream &strm) {
2308  uint32_t i;
2309  if (SendSpeedTestPacket(0, 0)) {
2310  StreamString packet;
2311  if (json)
2312  strm.Printf("{ \"packet_speeds\" : {\n \"num_packets\" : %u,\n "
2313  "\"results\" : [",
2314  num_packets);
2315  else
2316  strm.Printf("Testing sending %u packets of various sizes:\n",
2317  num_packets);
2318  strm.Flush();
2319 
2320  uint32_t result_idx = 0;
2321  uint32_t send_size;
2322  std::vector<duration<float>> packet_times;
2323 
2324  for (send_size = 0; send_size <= max_send;
2325  send_size ? send_size *= 2 : send_size = 4) {
2326  for (uint32_t recv_size = 0; recv_size <= max_recv;
2327  recv_size ? recv_size *= 2 : recv_size = 4) {
2328  MakeSpeedTestPacket(packet, send_size, recv_size);
2329 
2330  packet_times.clear();
2331  // Test how long it takes to send 'num_packets' packets
2332  const auto start_time = steady_clock::now();
2333  for (i = 0; i < num_packets; ++i) {
2334  const auto packet_start_time = steady_clock::now();
2335  StringExtractorGDBRemote response;
2336  SendPacketAndWaitForResponse(packet.GetString(), response, false);
2337  const auto packet_end_time = steady_clock::now();
2338  packet_times.push_back(packet_end_time - packet_start_time);
2339  }
2340  const auto end_time = steady_clock::now();
2341  const auto total_time = end_time - start_time;
2342 
2343  float packets_per_second =
2344  ((float)num_packets) / duration<float>(total_time).count();
2345  auto average_per_packet = total_time / num_packets;
2346  const duration<float> standard_deviation =
2347  calculate_standard_deviation(packet_times);
2348  if (json) {
2349  strm.Format("{0}\n {{\"send_size\" : {1,6}, \"recv_size\" : "
2350  "{2,6}, \"total_time_nsec\" : {3,12:ns-}, "
2351  "\"standard_deviation_nsec\" : {4,9:ns-f0}}",
2352  result_idx > 0 ? "," : "", send_size, recv_size,
2353  total_time, standard_deviation);
2354  ++result_idx;
2355  } else {
2356  strm.Format("qSpeedTest(send={0,7}, recv={1,7}) in {2:s+f9} for "
2357  "{3,9:f2} packets/s ({4,10:ms+f6} per packet) with "
2358  "standard deviation of {5,10:ms+f6}\n",
2359  send_size, recv_size, duration<float>(total_time),
2360  packets_per_second, duration<float>(average_per_packet),
2361  standard_deviation);
2362  }
2363  strm.Flush();
2364  }
2365  }
2366 
2367  const float k_recv_amount_mb = (float)recv_amount / (1024.0f * 1024.0f);
2368  if (json)
2369  strm.Printf("\n ]\n },\n \"download_speed\" : {\n \"byte_size\" "
2370  ": %" PRIu64 ",\n \"results\" : [",
2371  recv_amount);
2372  else
2373  strm.Printf("Testing receiving %2.1fMB of data using varying receive "
2374  "packet sizes:\n",
2375  k_recv_amount_mb);
2376  strm.Flush();
2377  send_size = 0;
2378  result_idx = 0;
2379  for (uint32_t recv_size = 32; recv_size <= max_recv; recv_size *= 2) {
2380  MakeSpeedTestPacket(packet, send_size, recv_size);
2381 
2382  // If we have a receive size, test how long it takes to receive 4MB of
2383  // data
2384  if (recv_size > 0) {
2385  const auto start_time = steady_clock::now();
2386  uint32_t bytes_read = 0;
2387  uint32_t packet_count = 0;
2388  while (bytes_read < recv_amount) {
2389  StringExtractorGDBRemote response;
2390  SendPacketAndWaitForResponse(packet.GetString(), response, false);
2391  bytes_read += recv_size;
2392  ++packet_count;
2393  }
2394  const auto end_time = steady_clock::now();
2395  const auto total_time = end_time - start_time;
2396  float mb_second = ((float)recv_amount) /
2397  duration<float>(total_time).count() /
2398  (1024.0 * 1024.0);
2399  float packets_per_second =
2400  ((float)packet_count) / duration<float>(total_time).count();
2401  const auto average_per_packet = total_time / packet_count;
2402 
2403  if (json) {
2404  strm.Format("{0}\n {{\"send_size\" : {1,6}, \"recv_size\" : "
2405  "{2,6}, \"total_time_nsec\" : {3,12:ns-}}",
2406  result_idx > 0 ? "," : "", send_size, recv_size,
2407  total_time);
2408  ++result_idx;
2409  } else {
2410  strm.Format("qSpeedTest(send={0,7}, recv={1,7}) {2,6} packets needed "
2411  "to receive {3:f1}MB in {4:s+f9} for {5} MB/sec for "
2412  "{6,9:f2} packets/sec ({7,10:ms+f6} per packet)\n",
2413  send_size, recv_size, packet_count, k_recv_amount_mb,
2414  duration<float>(total_time), mb_second,
2415  packets_per_second, duration<float>(average_per_packet));
2416  }
2417  strm.Flush();
2418  }
2419  }
2420  if (json)
2421  strm.Printf("\n ]\n }\n}\n");
2422  else
2423  strm.EOL();
2424  }
2425 }
2426 
2428  uint32_t recv_size) {
2429  StreamString packet;
2430  packet.Printf("qSpeedTest:response_size:%i;data:", recv_size);
2431  uint32_t bytes_left = send_size;
2432  while (bytes_left > 0) {
2433  if (bytes_left >= 26) {
2434  packet.PutCString("abcdefghijklmnopqrstuvwxyz");
2435  bytes_left -= 26;
2436  } else {
2437  packet.Printf("%*.*s;", bytes_left, bytes_left,
2438  "abcdefghijklmnopqrstuvwxyz");
2439  bytes_left = 0;
2440  }
2441  }
2442 
2443  StringExtractorGDBRemote response;
2444  return SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
2446 }
2447 
2449  const char *remote_accept_hostname, lldb::pid_t &pid, uint16_t &port,
2450  std::string &socket_name) {
2452  port = 0;
2453  socket_name.clear();
2454 
2455  StringExtractorGDBRemote response;
2456  StreamString stream;
2457  stream.PutCString("qLaunchGDBServer;");
2458  std::string hostname;
2459  if (remote_accept_hostname && remote_accept_hostname[0])
2460  hostname = remote_accept_hostname;
2461  else {
2462  if (HostInfo::GetHostname(hostname)) {
2463  // Make the GDB server we launch only accept connections from this host
2464  stream.Printf("host:%s;", hostname.c_str());
2465  } else {
2466  // Make the GDB server we launch accept connections from any host since
2467  // we can't figure out the hostname
2468  stream.Printf("host:*;");
2469  }
2470  }
2471  // give the process a few seconds to startup
2472  ScopedTimeout timeout(*this, seconds(10));
2473 
2474  if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
2476  llvm::StringRef name;
2477  llvm::StringRef value;
2478  while (response.GetNameColonValue(name, value)) {
2479  if (name.equals("port"))
2480  value.getAsInteger(0, port);
2481  else if (name.equals("pid"))
2482  value.getAsInteger(0, pid);
2483  else if (name.compare("socket_name") == 0) {
2484  StringExtractor extractor(value);
2485  extractor.GetHexByteString(socket_name);
2486  }
2487  }
2488  return true;
2489  }
2490  return false;
2491 }
2492 
2494  std::vector<std::pair<uint16_t, std::string>> &connection_urls) {
2495  connection_urls.clear();
2496 
2497  StringExtractorGDBRemote response;
2498  if (SendPacketAndWaitForResponse("qQueryGDBServer", response, false) !=
2500  return 0;
2501 
2504  if (!data)
2505  return 0;
2506 
2507  StructuredData::Array *array = data->GetAsArray();
2508  if (!array)
2509  return 0;
2510 
2511  for (size_t i = 0, count = array->GetSize(); i < count; ++i) {
2512  StructuredData::Dictionary *element = nullptr;
2513  if (!array->GetItemAtIndexAsDictionary(i, element))
2514  continue;
2515 
2516  uint16_t port = 0;
2517  if (StructuredData::ObjectSP port_osp =
2518  element->GetValueForKey(llvm::StringRef("port")))
2519  port = port_osp->GetIntegerValue(0);
2520 
2521  std::string socket_name;
2522  if (StructuredData::ObjectSP socket_name_osp =
2523  element->GetValueForKey(llvm::StringRef("socket_name")))
2524  socket_name = socket_name_osp->GetStringValue();
2525 
2526  if (port != 0 || !socket_name.empty())
2527  connection_urls.emplace_back(port, socket_name);
2528  }
2529  return connection_urls.size();
2530 }
2531 
2533  StreamString stream;
2534  stream.Printf("qKillSpawnedProcess:%" PRId64, pid);
2535 
2536  StringExtractorGDBRemote response;
2537  if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
2539  if (response.IsOKResponse())
2540  return true;
2541  }
2542  return false;
2543 }
2544 
2546  if (m_curr_tid == tid)
2547  return true;
2548 
2549  char packet[32];
2550  int packet_len;
2551  if (tid == UINT64_MAX)
2552  packet_len = ::snprintf(packet, sizeof(packet), "Hg-1");
2553  else
2554  packet_len = ::snprintf(packet, sizeof(packet), "Hg%" PRIx64, tid);
2555  assert(packet_len + 1 < (int)sizeof(packet));
2556  UNUSED_IF_ASSERT_DISABLED(packet_len);
2557  StringExtractorGDBRemote response;
2558  if (SendPacketAndWaitForResponse(packet, response, false) ==
2560  if (response.IsOKResponse()) {
2561  m_curr_tid = tid;
2562  return true;
2563  }
2564 
2565  /*
2566  * Connected bare-iron target (like YAMON gdb-stub) may not have support for
2567  * Hg packet.
2568  * The reply from '?' packet could be as simple as 'S05'. There is no packet
2569  * which can
2570  * give us pid and/or tid. Assume pid=tid=1 in such cases.
2571  */
2572  if (response.IsUnsupportedResponse() && IsConnected()) {
2573  m_curr_tid = 1;
2574  return true;
2575  }
2576  }
2577  return false;
2578 }
2579 
2581  if (m_curr_tid_run == tid)
2582  return true;
2583 
2584  char packet[32];
2585  int packet_len;
2586  if (tid == UINT64_MAX)
2587  packet_len = ::snprintf(packet, sizeof(packet), "Hc-1");
2588  else
2589  packet_len = ::snprintf(packet, sizeof(packet), "Hc%" PRIx64, tid);
2590 
2591  assert(packet_len + 1 < (int)sizeof(packet));
2592  UNUSED_IF_ASSERT_DISABLED(packet_len);
2593  StringExtractorGDBRemote response;
2594  if (SendPacketAndWaitForResponse(packet, response, false) ==
2596  if (response.IsOKResponse()) {
2597  m_curr_tid_run = tid;
2598  return true;
2599  }
2600 
2601  /*
2602  * Connected bare-iron target (like YAMON gdb-stub) may not have support for
2603  * Hc packet.
2604  * The reply from '?' packet could be as simple as 'S05'. There is no packet
2605  * which can
2606  * give us pid and/or tid. Assume pid=tid=1 in such cases.
2607  */
2608  if (response.IsUnsupportedResponse() && IsConnected()) {
2609  m_curr_tid_run = 1;
2610  return true;
2611  }
2612  }
2613  return false;
2614 }
2615 
2617  StringExtractorGDBRemote &response) {
2618  if (SendPacketAndWaitForResponse("?", response, false) ==
2620  return response.IsNormalResponse();
2621  return false;
2622 }
2623 
2625  lldb::tid_t tid, StringExtractorGDBRemote &response) {
2627  char packet[256];
2628  int packet_len =
2629  ::snprintf(packet, sizeof(packet), "qThreadStopInfo%" PRIx64, tid);
2630  assert(packet_len < (int)sizeof(packet));
2631  UNUSED_IF_ASSERT_DISABLED(packet_len);
2632  if (SendPacketAndWaitForResponse(packet, response, false) ==
2634  if (response.IsUnsupportedResponse())
2636  else if (response.IsNormalResponse())
2637  return true;
2638  else
2639  return false;
2640  } else {
2642  }
2643  }
2644  return false;
2645 }
2646 
2648  GDBStoppointType type, bool insert, addr_t addr, uint32_t length) {
2650  if (log)
2651  log->Printf("GDBRemoteCommunicationClient::%s() %s at addr = 0x%" PRIx64,
2652  __FUNCTION__, insert ? "add" : "remove", addr);
2653 
2654  // Check if the stub is known not to support this breakpoint type
2655  if (!SupportsGDBStoppointPacket(type))
2656  return UINT8_MAX;
2657  // Construct the breakpoint packet
2658  char packet[64];
2659  const int packet_len =
2660  ::snprintf(packet, sizeof(packet), "%c%i,%" PRIx64 ",%x",
2661  insert ? 'Z' : 'z', type, addr, length);
2662  // Check we haven't overwritten the end of the packet buffer
2663  assert(packet_len + 1 < (int)sizeof(packet));
2664  UNUSED_IF_ASSERT_DISABLED(packet_len);
2665  StringExtractorGDBRemote response;
2666  // Make sure the response is either "OK", "EXX" where XX are two hex digits,
2667  // or "" (unsupported)
2669  // Try to send the breakpoint packet, and check that it was correctly sent
2670  if (SendPacketAndWaitForResponse(packet, response, true) ==
2672  // Receive and OK packet when the breakpoint successfully placed
2673  if (response.IsOKResponse())
2674  return 0;
2675 
2676  // Status while setting breakpoint, send back specific error
2677  if (response.IsErrorResponse())
2678  return response.GetError();
2679 
2680  // Empty packet informs us that breakpoint is not supported
2681  if (response.IsUnsupportedResponse()) {
2682  // Disable this breakpoint type since it is unsupported
2683  switch (type) {
2684  case eBreakpointSoftware:
2685  m_supports_z0 = false;
2686  break;
2687  case eBreakpointHardware:
2688  m_supports_z1 = false;
2689  break;
2690  case eWatchpointWrite:
2691  m_supports_z2 = false;
2692  break;
2693  case eWatchpointRead:
2694  m_supports_z3 = false;
2695  break;
2696  case eWatchpointReadWrite:
2697  m_supports_z4 = false;
2698  break;
2699  case eStoppointInvalid:
2700  return UINT8_MAX;
2701  }
2702  }
2703  }
2704  // Signal generic failure
2705  return UINT8_MAX;
2706 }
2707 
2709  std::vector<lldb::tid_t> &thread_ids, bool &sequence_mutex_unavailable) {
2710  thread_ids.clear();
2711 
2712  Lock lock(*this, false);
2713  if (lock) {
2714  sequence_mutex_unavailable = false;
2715  StringExtractorGDBRemote response;
2716 
2717  PacketResult packet_result;
2718  for (packet_result =
2719  SendPacketAndWaitForResponseNoLock("qfThreadInfo", response);
2720  packet_result == PacketResult::Success && response.IsNormalResponse();
2721  packet_result =
2722  SendPacketAndWaitForResponseNoLock("qsThreadInfo", response)) {
2723  char ch = response.GetChar();
2724  if (ch == 'l')
2725  break;
2726  if (ch == 'm') {
2727  do {
2728  tid_t tid = response.GetHexMaxU64(false, LLDB_INVALID_THREAD_ID);
2729 
2730  if (tid != LLDB_INVALID_THREAD_ID) {
2731  thread_ids.push_back(tid);
2732  }
2733  ch = response.GetChar(); // Skip the command separator
2734  } while (ch == ','); // Make sure we got a comma separator
2735  }
2736  }
2737 
2738  /*
2739  * Connected bare-iron target (like YAMON gdb-stub) may not have support for
2740  * qProcessInfo, qC and qfThreadInfo packets. The reply from '?' packet
2741  * could
2742  * be as simple as 'S05'. There is no packet which can give us pid and/or
2743  * tid.
2744  * Assume pid=tid=1 in such cases.
2745  */
2746  if ((response.IsUnsupportedResponse() || response.IsNormalResponse()) &&
2747  thread_ids.size() == 0 && IsConnected()) {
2748  thread_ids.push_back(1);
2749  }
2750  } else {
2751 #if !defined(LLDB_CONFIGURATION_DEBUG)
2753  GDBR_LOG_PACKETS));
2754  if (log)
2755  log->Printf("error: failed to get packet sequence mutex, not sending "
2756  "packet 'qfThreadInfo'");
2757 #endif
2758  sequence_mutex_unavailable = true;
2759  }
2760  return thread_ids.size();
2761 }
2762 
2764  StringExtractorGDBRemote response;
2765  if (SendPacketAndWaitForResponse("qShlibInfoAddr", response, false) !=
2767  !response.IsNormalResponse())
2768  return LLDB_INVALID_ADDRESS;
2769  return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
2770 }
2771 
2773  const char *command, // Shouldn't be NULL
2774  const FileSpec &
2775  working_dir, // Pass empty FileSpec to use the current working directory
2776  int *status_ptr, // Pass NULL if you don't want the process exit status
2777  int *signo_ptr, // Pass NULL if you don't want the signal that caused the
2778  // process to exit
2779  std::string
2780  *command_output, // Pass NULL if you don't want the command output
2781  const Timeout<std::micro> &timeout) {
2783  stream.PutCString("qPlatform_shell:");
2784  stream.PutBytesAsRawHex8(command, strlen(command));
2785  stream.PutChar(',');
2786  uint32_t timeout_sec = UINT32_MAX;
2787  if (timeout) {
2788  // TODO: Use chrono version of std::ceil once c++17 is available.
2789  timeout_sec = std::ceil(std::chrono::duration<double>(*timeout).count());
2790  }
2791  stream.PutHex32(timeout_sec);
2792  if (working_dir) {
2793  std::string path{working_dir.GetPath(false)};
2794  stream.PutChar(',');
2795  stream.PutStringAsRawHex8(path);
2796  }
2797  StringExtractorGDBRemote response;
2798  if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
2800  if (response.GetChar() != 'F')
2801  return Status("malformed reply");
2802  if (response.GetChar() != ',')
2803  return Status("malformed reply");
2804  uint32_t exitcode = response.GetHexMaxU32(false, UINT32_MAX);
2805  if (exitcode == UINT32_MAX)
2806  return Status("unable to run remote process");
2807  else if (status_ptr)
2808  *status_ptr = exitcode;
2809  if (response.GetChar() != ',')
2810  return Status("malformed reply");
2811  uint32_t signo = response.GetHexMaxU32(false, UINT32_MAX);
2812  if (signo_ptr)
2813  *signo_ptr = signo;
2814  if (response.GetChar() != ',')
2815  return Status("malformed reply");
2816  std::string output;
2817  response.GetEscapedBinaryData(output);
2818  if (command_output)
2819  command_output->assign(output);
2820  return Status();
2821  }
2822  return Status("unable to send packet");
2823 }
2824 
2826  uint32_t file_permissions) {
2827  std::string path{file_spec.GetPath(false)};
2829  stream.PutCString("qPlatform_mkdir:");
2830  stream.PutHex32(file_permissions);
2831  stream.PutChar(',');
2832  stream.PutStringAsRawHex8(path);
2833  llvm::StringRef packet = stream.GetString();
2834  StringExtractorGDBRemote response;
2835 
2836  if (SendPacketAndWaitForResponse(packet, response, false) !=
2838  return Status("failed to send '%s' packet", packet.str().c_str());
2839 
2840  if (response.GetChar() != 'F')
2841  return Status("invalid response to '%s' packet", packet.str().c_str());
2842 
2843  return Status(response.GetU32(UINT32_MAX), eErrorTypePOSIX);
2844 }
2845 
2846 Status
2848  uint32_t file_permissions) {
2849  std::string path{file_spec.GetPath(false)};
2851  stream.PutCString("qPlatform_chmod:");
2852  stream.PutHex32(file_permissions);
2853  stream.PutChar(',');
2854  stream.PutStringAsRawHex8(path);
2855  llvm::StringRef packet = stream.GetString();
2856  StringExtractorGDBRemote response;
2857 
2858  if (SendPacketAndWaitForResponse(packet, response, false) !=
2860  return Status("failed to send '%s' packet", stream.GetData());
2861 
2862  if (response.GetChar() != 'F')
2863  return Status("invalid response to '%s' packet", stream.GetData());
2864 
2865  return Status(response.GetU32(UINT32_MAX), eErrorTypePOSIX);
2866 }
2867 
2869  uint64_t fail_result, Status &error) {
2870  response.SetFilePos(0);
2871  if (response.GetChar() != 'F')
2872  return fail_result;
2873  int32_t result = response.GetS32(-2);
2874  if (result == -2)
2875  return fail_result;
2876  if (response.GetChar() == ',') {
2877  int result_errno = response.GetS32(-2);
2878  if (result_errno != -2)
2879  error.SetError(result_errno, eErrorTypePOSIX);
2880  else
2881  error.SetError(-1, eErrorTypeGeneric);
2882  } else
2883  error.Clear();
2884  return result;
2885 }
2888  uint32_t flags, mode_t mode,
2889  Status &error) {
2890  std::string path(file_spec.GetPath(false));
2892  stream.PutCString("vFile:open:");
2893  if (path.empty())
2894  return UINT64_MAX;
2895  stream.PutStringAsRawHex8(path);
2896  stream.PutChar(',');
2897  stream.PutHex32(flags);
2898  stream.PutChar(',');
2899  stream.PutHex32(mode);
2900  StringExtractorGDBRemote response;
2901  if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
2903  return ParseHostIOPacketResponse(response, UINT64_MAX, error);
2904  }
2905  return UINT64_MAX;
2906 }
2907 
2909  Status &error) {
2911  stream.Printf("vFile:close:%i", (int)fd);
2912  StringExtractorGDBRemote response;
2913  if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
2915  return ParseHostIOPacketResponse(response, -1, error) == 0;
2916  }
2917  return false;
2918 }
2919 
2920 // Extension of host I/O packets to get the file size.
2922  const lldb_private::FileSpec &file_spec) {
2923  std::string path(file_spec.GetPath(false));
2925  stream.PutCString("vFile:size:");
2926  stream.PutStringAsRawHex8(path);
2927  StringExtractorGDBRemote response;
2928  if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
2930  if (response.GetChar() != 'F')
2931  return UINT64_MAX;
2932  uint32_t retcode = response.GetHexMaxU64(false, UINT64_MAX);
2933  return retcode;
2934  }
2935  return UINT64_MAX;
2936 }
2937 
2938 Status
2940  uint32_t &file_permissions) {
2941  std::string path{file_spec.GetPath(false)};
2942  Status error;
2944  stream.PutCString("vFile:mode:");
2945  stream.PutStringAsRawHex8(path);
2946  StringExtractorGDBRemote response;
2947  if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
2949  if (response.GetChar() != 'F') {
2950  error.SetErrorStringWithFormat("invalid response to '%s' packet",
2951  stream.GetData());
2952  } else {
2953  const uint32_t mode = response.GetS32(-1);
2954  if (static_cast<int32_t>(mode) == -1) {
2955  if (response.GetChar() == ',') {
2956  int response_errno = response.GetS32(-1);
2957  if (response_errno > 0)
2958  error.SetError(response_errno, lldb::eErrorTypePOSIX);
2959  else
2960  error.SetErrorToGenericError();
2961  } else
2962  error.SetErrorToGenericError();
2963  } else {
2964  file_permissions = mode & (S_IRWXU | S_IRWXG | S_IRWXO);
2965  }
2966  }
2967  } else {
2968  error.SetErrorStringWithFormat("failed to send '%s' packet",
2969  stream.GetData());
2970  }
2971  return error;
2972 }
2973 
2975  uint64_t offset, void *dst,
2976  uint64_t dst_len,
2977  Status &error) {
2979  stream.Printf("vFile:pread:%i,%" PRId64 ",%" PRId64, (int)fd, dst_len,
2980  offset);
2981  StringExtractorGDBRemote response;
2982  if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
2984  if (response.GetChar() != 'F')
2985  return 0;
2986  uint32_t retcode = response.GetHexMaxU32(false, UINT32_MAX);
2987  if (retcode == UINT32_MAX)
2988  return retcode;
2989  const char next = (response.Peek() ? *response.Peek() : 0);
2990  if (next == ',')
2991  return 0;
2992  if (next == ';') {
2993  response.GetChar(); // skip the semicolon
2994  std::string buffer;
2995  if (response.GetEscapedBinaryData(buffer)) {
2996  const uint64_t data_to_write =
2997  std::min<uint64_t>(dst_len, buffer.size());
2998  if (data_to_write > 0)
2999  memcpy(dst, &buffer[0], data_to_write);
3000  return data_to_write;
3001  }
3002  }
3003  }
3004  return 0;
3005 }
3006 
3008  uint64_t offset,
3009  const void *src,
3010  uint64_t src_len,
3011  Status &error) {
3013  stream.Printf("vFile:pwrite:%i,%" PRId64 ",", (int)fd, offset);
3014  stream.PutEscapedBytes(src, src_len);
3015  StringExtractorGDBRemote response;
3016  if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
3018  if (response.GetChar() != 'F') {
3019  error.SetErrorStringWithFormat("write file failed");
3020  return 0;
3021  }
3022  uint64_t bytes_written = response.GetU64(UINT64_MAX);
3023  if (bytes_written == UINT64_MAX) {
3024  error.SetErrorToGenericError();
3025  if (response.GetChar() == ',') {
3026  int response_errno = response.GetS32(-1);
3027  if (response_errno > 0)
3028  error.SetError(response_errno, lldb::eErrorTypePOSIX);
3029  }
3030  return 0;
3031  }
3032  return bytes_written;
3033  } else {
3034  error.SetErrorString("failed to send vFile:pwrite packet");
3035  }
3036  return 0;
3037 }
3038 
3040  const FileSpec &dst) {
3041  std::string src_path{src.GetPath(false)}, dst_path{dst.GetPath(false)};
3042  Status error;
3044  stream.PutCString("vFile:symlink:");
3045  // the unix symlink() command reverses its parameters where the dst if first,
3046  // so we follow suit here
3047  stream.PutStringAsRawHex8(dst_path);
3048  stream.PutChar(',');
3049  stream.PutStringAsRawHex8(src_path);
3050  StringExtractorGDBRemote response;
3051  if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
3053  if (response.GetChar() == 'F') {
3054  uint32_t result = response.GetU32(UINT32_MAX);
3055  if (result != 0) {
3056  error.SetErrorToGenericError();
3057  if (response.GetChar() == ',') {
3058  int response_errno = response.GetS32(-1);
3059  if (response_errno > 0)
3060  error.SetError(response_errno, lldb::eErrorTypePOSIX);
3061  }
3062  }
3063  } else {
3064  // Should have returned with 'F<result>[,<errno>]'
3065  error.SetErrorStringWithFormat("symlink failed");
3066  }
3067  } else {
3068  error.SetErrorString("failed to send vFile:symlink packet");
3069  }
3070  return error;
3071 }
3072 
3074  std::string path{file_spec.GetPath(false)};
3075  Status error;
3077  stream.PutCString("vFile:unlink:");
3078  // the unix symlink() command reverses its parameters where the dst if first,
3079  // so we follow suit here
3080  stream.PutStringAsRawHex8(path);
3081  StringExtractorGDBRemote response;
3082  if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
3084  if (response.GetChar() == 'F') {
3085  uint32_t result = response.GetU32(UINT32_MAX);
3086  if (result != 0) {
3087  error.SetErrorToGenericError();
3088  if (response.GetChar() == ',') {
3089  int response_errno = response.GetS32(-1);
3090  if (response_errno > 0)
3091  error.SetError(response_errno, lldb::eErrorTypePOSIX);
3092  }
3093  }
3094  } else {
3095  // Should have returned with 'F<result>[,<errno>]'
3096  error.SetErrorStringWithFormat("unlink failed");
3097  }
3098  } else {
3099  error.SetErrorString("failed to send vFile:unlink packet");
3100  }
3101  return error;
3102 }
3103 
3104 // Extension of host I/O packets to get whether a file exists.
3106  const lldb_private::FileSpec &file_spec) {
3107  std::string path(file_spec.GetPath(false));
3109  stream.PutCString("vFile:exists:");
3110  stream.PutStringAsRawHex8(path);
3111  StringExtractorGDBRemote response;
3112  if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
3114  if (response.GetChar() != 'F')
3115  return false;
3116  if (response.GetChar() != ',')
3117  return false;
3118  bool retcode = (response.GetChar() != '0');
3119  return retcode;
3120  }
3121  return false;
3122 }
3123 
3125  const lldb_private::FileSpec &file_spec, uint64_t &high, uint64_t &low) {
3126  std::string path(file_spec.GetPath(false));
3128  stream.PutCString("vFile:MD5:");
3129  stream.PutStringAsRawHex8(path);
3130  StringExtractorGDBRemote response;
3131  if (SendPacketAndWaitForResponse(stream.GetString(), response, false) ==
3133  if (response.GetChar() != 'F')
3134  return false;
3135  if (response.GetChar() != ',')
3136  return false;
3137  if (response.Peek() && *response.Peek() == 'x')
3138  return false;
3139  low = response.GetHexMaxU64(false, UINT64_MAX);
3140  high = response.GetHexMaxU64(false, UINT64_MAX);
3141  return true;
3142  }
3143  return false;
3144 }
3145 
3147  // Some targets have issues with g/G packets and we need to avoid using them
3149  if (process) {
3151  const ArchSpec &arch = process->GetTarget().GetArchitecture();
3152  if (arch.IsValid() &&
3153  arch.GetTriple().getVendor() == llvm::Triple::Apple &&
3154  arch.GetTriple().getOS() == llvm::Triple::IOS &&
3155  arch.GetTriple().getArch() == llvm::Triple::aarch64) {
3157  uint32_t gdb_server_version = GetGDBServerProgramVersion();
3158  if (gdb_server_version != 0) {
3159  const char *gdb_server_name = GetGDBServerProgramName();
3160  if (gdb_server_name && strcmp(gdb_server_name, "debugserver") == 0) {
3161  if (gdb_server_version >= 310)
3163  }
3164  }
3165  }
3166  }
3167  }
3168  return m_avoid_g_packets == eLazyBoolYes;
3169 }
3170 
3172  uint32_t reg) {
3173  StreamString payload;
3174  payload.Printf("p%x", reg);
3175  StringExtractorGDBRemote response;
3177  tid, std::move(payload), response, false) != PacketResult::Success ||
3178  !response.IsNormalResponse())
3179  return nullptr;
3180 
3181  DataBufferSP buffer_sp(
3182  new DataBufferHeap(response.GetStringRef().size() / 2, 0));
3183  response.GetHexBytes(buffer_sp->GetData(), '\xcc');
3184  return buffer_sp;
3185 }
3186 
3188  StreamString payload;
3189  payload.PutChar('g');
3190  StringExtractorGDBRemote response;
3192  tid, std::move(payload), response, false) != PacketResult::Success ||
3193  !response.IsNormalResponse())
3194  return nullptr;
3195 
3196  DataBufferSP buffer_sp(
3197  new DataBufferHeap(response.GetStringRef().size() / 2, 0));
3198  response.GetHexBytes(buffer_sp->GetData(), '\xcc');
3199  return buffer_sp;
3200 }
3201 
3203  uint32_t reg_num,
3204  llvm::ArrayRef<uint8_t> data) {
3205  StreamString payload;
3206  payload.Printf("P%x=", reg_num);
3207  payload.PutBytesAsRawHex8(data.data(), data.size(),
3210  StringExtractorGDBRemote response;
3211  return SendThreadSpecificPacketAndWaitForResponse(tid, std::move(payload),
3212  response, false) ==
3214  response.IsOKResponse();
3215 }
3216 
3218  lldb::tid_t tid, llvm::ArrayRef<uint8_t> data) {
3219  StreamString payload;
3220  payload.PutChar('G');
3221  payload.PutBytesAsRawHex8(data.data(), data.size(),
3224  StringExtractorGDBRemote response;
3225  return SendThreadSpecificPacketAndWaitForResponse(tid, std::move(payload),
3226  response, false) ==
3228  response.IsOKResponse();
3229 }
3230 
3232  uint32_t &save_id) {
3233  save_id = 0; // Set to invalid save ID
3235  return false;
3236 
3238  StreamString payload;
3239  payload.PutCString("QSaveRegisterState");
3240  StringExtractorGDBRemote response;
3242  tid, std::move(payload), response, false) != PacketResult::Success)
3243  return false;
3244 
3245  if (response.IsUnsupportedResponse())
3247 
3248  const uint32_t response_save_id = response.GetU32(0);
3249  if (response_save_id == 0)
3250  return false;
3251 
3252  save_id = response_save_id;
3253  return true;
3254 }
3255 
3257  uint32_t save_id) {
3258  // We use the "m_supports_QSaveRegisterState" variable here because the
3259  // QSaveRegisterState and QRestoreRegisterState packets must both be
3260  // supported in order to be useful
3262  return false;
3263 
3264  StreamString payload;
3265  payload.Printf("QRestoreRegisterState:%u", save_id);
3266  StringExtractorGDBRemote response;
3268  tid, std::move(payload), response, false) != PacketResult::Success)
3269  return false;
3270 
3271  if (response.IsOKResponse())
3272  return true;
3273 
3274  if (response.IsUnsupportedResponse())
3276  return false;
3277 }
3278 
3281  return false;
3282 
3283  StreamString packet;
3284  StringExtractorGDBRemote response;
3285  packet.Printf("QSyncThreadState:%4.4" PRIx64 ";", tid);
3286  return SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
3288  response.IsOKResponse();
3289 }
3290 
3293  Status &error) {
3296 
3297  StreamGDBRemote escaped_packet;
3298  escaped_packet.PutCString("jTraceStart:");
3299 
3300  StructuredData::Dictionary json_packet;
3301  json_packet.AddIntegerItem("type", options.getType());
3302  json_packet.AddIntegerItem("buffersize", options.getTraceBufferSize());
3303  json_packet.AddIntegerItem("metabuffersize", options.getMetaDataBufferSize());
3304 
3305  if (options.getThreadID() != LLDB_INVALID_THREAD_ID)
3306  json_packet.AddIntegerItem("threadid", options.getThreadID());
3307 
3308  StructuredData::DictionarySP custom_params = options.getTraceParams();
3309  if (custom_params)
3310  json_packet.AddItem("params", custom_params);
3311 
3312  StreamString json_string;
3313  json_packet.Dump(json_string, false);
3314  escaped_packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
3315 
3316  StringExtractorGDBRemote response;
3317  if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
3318  true) ==
3320  if (!response.IsNormalResponse()) {
3321  error = response.GetStatus();
3322  LLDB_LOG(log, "Target does not support Tracing , error {0}", error);
3323  } else {
3324  ret_uid = response.GetHexMaxU64(false, LLDB_INVALID_UID);
3325  }
3326  } else {
3327  LLDB_LOG(log, "failed to send packet");
3328  error.SetErrorStringWithFormat("failed to send packet: '%s'",
3329  escaped_packet.GetData());
3330  }
3331  return ret_uid;
3332 }
3333 
3334 Status
3336  lldb::tid_t thread_id) {
3338  StringExtractorGDBRemote response;
3339  Status error;
3340 
3341  StructuredData::Dictionary json_packet;
3342  StreamGDBRemote escaped_packet;
3343  StreamString json_string;
3344  escaped_packet.PutCString("jTraceStop:");
3345 
3346  json_packet.AddIntegerItem("traceid", uid);
3347 
3348  if (thread_id != LLDB_INVALID_THREAD_ID)
3349  json_packet.AddIntegerItem("threadid", thread_id);
3350 
3351  json_packet.Dump(json_string, false);
3352 
3353  escaped_packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
3354 
3355  if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
3356  true) ==
3358  if (!response.IsOKResponse()) {
3359  error = response.GetStatus();
3360  LLDB_LOG(log, "stop tracing failed");
3361  }
3362  } else {
3363  LLDB_LOG(log, "failed to send packet");
3365  "failed to send packet: '%s' with error '%d'", escaped_packet.GetData(),
3366  response.GetError());
3367  }
3368  return error;
3369 }
3370 
3372  lldb::user_id_t uid, lldb::tid_t thread_id,
3373  llvm::MutableArrayRef<uint8_t> &buffer, size_t offset) {
3374 
3375  StreamGDBRemote escaped_packet;
3376  escaped_packet.PutCString("jTraceBufferRead:");
3377  return SendGetTraceDataPacket(escaped_packet, uid, thread_id, buffer, offset);
3378 }
3379 
3381  lldb::user_id_t uid, lldb::tid_t thread_id,
3382  llvm::MutableArrayRef<uint8_t> &buffer, size_t offset) {
3383 
3384  StreamGDBRemote escaped_packet;
3385  escaped_packet.PutCString("jTraceMetaRead:");
3386  return SendGetTraceDataPacket(escaped_packet, uid, thread_id, buffer, offset);
3387 }
3388 
3389 Status
3391  TraceOptions &options) {
3393  StringExtractorGDBRemote response;
3394  Status error;
3395 
3396  StreamString json_string;
3397  StreamGDBRemote escaped_packet;
3398  escaped_packet.PutCString("jTraceConfigRead:");
3399 
3400  StructuredData::Dictionary json_packet;
3401  json_packet.AddIntegerItem("traceid", uid);
3402 
3403  if (options.getThreadID() != LLDB_INVALID_THREAD_ID)
3404  json_packet.AddIntegerItem("threadid", options.getThreadID());
3405 
3406  json_packet.Dump(json_string, false);
3407  escaped_packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
3408 
3409  if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
3410  true) ==
3412  if (response.IsNormalResponse()) {
3413  uint64_t type = std::numeric_limits<uint64_t>::max();
3414  uint64_t buffersize = std::numeric_limits<uint64_t>::max();
3415  uint64_t metabuffersize = std::numeric_limits<uint64_t>::max();
3416 
3417  auto json_object = StructuredData::ParseJSON(response.Peek());
3418 
3419  if (!json_object ||
3420  json_object->GetType() != lldb::eStructuredDataTypeDictionary) {
3421  error.SetErrorString("Invalid Configuration obtained");
3422  return error;
3423  }
3424 
3425  auto json_dict = json_object->GetAsDictionary();
3426 
3427  json_dict->GetValueForKeyAsInteger<uint64_t>("metabuffersize",
3428  metabuffersize);
3429  options.setMetaDataBufferSize(metabuffersize);
3430 
3431  json_dict->GetValueForKeyAsInteger<uint64_t>("buffersize", buffersize);
3432  options.setTraceBufferSize(buffersize);
3433 
3434  json_dict->GetValueForKeyAsInteger<uint64_t>("type", type);
3435  options.setType(static_cast<lldb::TraceType>(type));
3436 
3437  StructuredData::ObjectSP custom_params_sp =
3438  json_dict->GetValueForKey("params");
3439  if (custom_params_sp) {
3440  if (custom_params_sp->GetType() !=
3442  error.SetErrorString("Invalid Configuration obtained");
3443  return error;
3444  } else
3445  options.setTraceParams(
3446  static_pointer_cast<StructuredData::Dictionary>(
3447  custom_params_sp));
3448  }
3449  } else {
3450  error = response.GetStatus();
3451  }
3452  } else {
3453  LLDB_LOG(log, "failed to send packet");
3454  error.SetErrorStringWithFormat("failed to send packet: '%s'",
3455  escaped_packet.GetData());
3456  }
3457  return error;
3458 }
3459 
3461  StreamGDBRemote &packet, lldb::user_id_t uid, lldb::tid_t thread_id,
3462  llvm::MutableArrayRef<uint8_t> &buffer, size_t offset) {
3464  Status error;
3465 
3466  StructuredData::Dictionary json_packet;
3467 
3468  json_packet.AddIntegerItem("traceid", uid);
3469  json_packet.AddIntegerItem("offset", offset);
3470  json_packet.AddIntegerItem("buffersize", buffer.size());
3471 
3472  if (thread_id != LLDB_INVALID_THREAD_ID)
3473  json_packet.AddIntegerItem("threadid", thread_id);
3474 
3475  StreamString json_string;
3476  json_packet.Dump(json_string, false);
3477 
3478  packet.PutEscapedBytes(json_string.GetData(), json_string.GetSize());
3479  StringExtractorGDBRemote response;
3480  if (SendPacketAndWaitForResponse(packet.GetString(), response, true) ==
3482  if (response.IsNormalResponse()) {
3483  size_t filled_size = response.GetHexBytesAvail(buffer);
3484  buffer = llvm::MutableArrayRef<uint8_t>(buffer.data(), filled_size);
3485  } else {
3486  error = response.GetStatus();
3487  buffer = buffer.slice(buffer.size());
3488  }
3489  } else {
3490  LLDB_LOG(log, "failed to send packet");
3491  error.SetErrorStringWithFormat("failed to send packet: '%s'",
3492  packet.GetData());
3493  buffer = buffer.slice(buffer.size());
3494  }
3495  return error;
3496 }
3497 
3499  const FileSpec &module_file_spec, const lldb_private::ArchSpec &arch_spec,
3500  ModuleSpec &module_spec) {
3502  return false;
3503 
3504  std::string module_path = module_file_spec.GetPath(false);
3505  if (module_path.empty())
3506  return false;
3507 
3508  StreamString packet;
3509  packet.PutCString("qModuleInfo:");
3510  packet.PutStringAsRawHex8(module_path);
3511  packet.PutCString(";");
3512  const auto &triple = arch_spec.GetTriple().getTriple();
3513  packet.PutStringAsRawHex8(triple);
3514 
3515  StringExtractorGDBRemote response;
3516  if (SendPacketAndWaitForResponse(packet.GetString(), response, false) !=
3518  return false;
3519 
3520  if (response.IsErrorResponse())
3521  return false;
3522 
3523  if (response.IsUnsupportedResponse()) {
3524  m_supports_qModuleInfo = false;
3525  return false;
3526  }
3527 
3528  llvm::StringRef name;
3529  llvm::StringRef value;
3530 
3531  module_spec.Clear();
3532  module_spec.GetFileSpec() = module_file_spec;
3533 
3534  while (response.GetNameColonValue(name, value)) {
3535  if (name == "uuid" || name == "md5") {
3536  StringExtractor extractor(value);
3537  std::string uuid;
3538  extractor.GetHexByteString(uuid);
3539  module_spec.GetUUID().SetFromStringRef(uuid, uuid.size() / 2);
3540  } else if (name == "triple") {
3541  StringExtractor extractor(value);
3542  std::string triple;
3543  extractor.GetHexByteString(triple);
3544  module_spec.GetArchitecture().SetTriple(triple.c_str());
3545  } else if (name == "file_offset") {
3546  uint64_t ival = 0;
3547  if (!value.getAsInteger(16, ival))
3548  module_spec.SetObjectOffset(ival);
3549  } else if (name == "file_size") {
3550  uint64_t ival = 0;
3551  if (!value.getAsInteger(16, ival))
3552  module_spec.SetObjectSize(ival);
3553  } else if (name == "file_path") {
3554  StringExtractor extractor(value);
3555  std::string path;
3556  extractor.GetHexByteString(path);
3557  module_spec.GetFileSpec() = FileSpec(path, arch_spec.GetTriple());
3558  }
3559  }
3560 
3561  return true;
3562 }
3563 
3564 static llvm::Optional<ModuleSpec>
3566  ModuleSpec result;
3567  if (!dict)
3568  return llvm::None;
3569 
3570  llvm::StringRef string;
3571  uint64_t integer;
3572 
3573  if (!dict->GetValueForKeyAsString("uuid", string))
3574  return llvm::None;
3575  if (result.GetUUID().SetFromStringRef(string, string.size() / 2) !=
3576  string.size())
3577  return llvm::None;
3578 
3579  if (!dict->GetValueForKeyAsInteger("file_offset", integer))
3580  return llvm::None;
3581  result.SetObjectOffset(integer);
3582 
3583  if (!dict->GetValueForKeyAsInteger("file_size", integer))
3584  return llvm::None;
3585  result.SetObjectSize(integer);
3586 
3587  if (!dict->GetValueForKeyAsString("triple", string))
3588  return llvm::None;
3589  result.GetArchitecture().SetTriple(string);
3590 
3591  if (!dict->GetValueForKeyAsString("file_path", string))
3592  return llvm::None;
3593  result.GetFileSpec() = FileSpec(string, result.GetArchitecture().GetTriple());
3594 
3595  return result;
3596 }
3597 
3598 llvm::Optional<std::vector<ModuleSpec>>
3600  llvm::ArrayRef<FileSpec> module_file_specs, const llvm::Triple &triple) {
3602  return llvm::None;
3603 
3604  JSONArray::SP module_array_sp = std::make_shared<JSONArray>();
3605  for (const FileSpec &module_file_spec : module_file_specs) {
3606  JSONObject::SP module_sp = std::make_shared<JSONObject>();
3607  module_array_sp->AppendObject(module_sp);
3608  module_sp->SetObject(
3609  "file", std::make_shared<JSONString>(module_file_spec.GetPath(false)));
3610  module_sp->SetObject("triple",
3611  std::make_shared<JSONString>(triple.getTriple()));
3612  }
3613  StreamString unescaped_payload;
3614  unescaped_payload.PutCString("jModulesInfo:");
3615  module_array_sp->Write(unescaped_payload);
3616  StreamGDBRemote payload;
3617  payload.PutEscapedBytes(unescaped_payload.GetString().data(),
3618  unescaped_payload.GetSize());
3619 
3620  // Increase the timeout for jModulesInfo since this packet can take longer.
3621  ScopedTimeout timeout(*this, std::chrono::seconds(10));
3622 
3623  StringExtractorGDBRemote response;
3624  if (SendPacketAndWaitForResponse(payload.GetString(), response, false) !=
3626  response.IsErrorResponse())
3627  return llvm::None;
3628 
3629  if (response.IsUnsupportedResponse()) {
3630  m_supports_jModulesInfo = false;
3631  return llvm::None;
3632  }
3633 
3634  StructuredData::ObjectSP response_object_sp =
3636  if (!response_object_sp)
3637  return llvm::None;
3638 
3639  StructuredData::Array *response_array = response_object_sp->GetAsArray();
3640  if (!response_array)
3641  return llvm::None;
3642 
3643  std::vector<ModuleSpec> result;
3644  for (size_t i = 0; i < response_array->GetSize(); ++i) {
3645  if (llvm::Optional<ModuleSpec> module_spec = ParseModuleSpec(
3646  response_array->GetItemAtIndex(i)->GetAsDictionary()))
3647  result.push_back(*module_spec);
3648  }
3649 
3650  return result;
3651 }
3652 
3653 // query the target remote for extended information using the qXfer packet
3654 //
3655 // example: object='features', annex='target.xml', out=<xml output> return:
3656 // 'true' on success
3657 // 'false' on failure (err set)
3659  const lldb_private::ConstString object,
3660  const lldb_private::ConstString annex, std::string &out,
3661  lldb_private::Status &err) {
3662 
3663  std::stringstream output;
3665 
3666  uint64_t size = GetRemoteMaxPacketSize();
3667  if (size == 0)
3668  size = 0x1000;
3669  size = size - 1; // Leave space for the 'm' or 'l' character in the response
3670  int offset = 0;
3671  bool active = true;
3672 
3673  // loop until all data has been read
3674  while (active) {
3675 
3676  // send query extended feature packet
3677  std::stringstream packet;
3678  packet << "qXfer:" << object.AsCString("")
3679  << ":read:" << annex.AsCString("") << ":" << std::hex << offset
3680  << "," << std::hex << size;
3681 
3683  SendPacketAndWaitForResponse(packet.str(), chunk, false);
3684 
3686  err.SetErrorString("Error sending $qXfer packet");
3687  return false;
3688  }
3689 
3690  const std::string &str = chunk.GetStringRef();
3691  if (str.length() == 0) {
3692  // should have some data in chunk
3693  err.SetErrorString("Empty response from $qXfer packet");
3694  return false;
3695  }
3696 
3697  // check packet code
3698  switch (str[0]) {
3699  // last chunk
3700  case ('l'):
3701  active = false;
3702  LLVM_FALLTHROUGH;
3703 
3704  // more chunks
3705  case ('m'):
3706  if (str.length() > 1)
3707  output << &str[1];
3708  offset += size;
3709  break;
3710 
3711  // unknown chunk
3712  default:
3713  err.SetErrorString("Invalid continuation code from $qXfer packet");
3714  return false;
3715  }
3716  }
3717 
3718  out = output.str();
3719  err.Success();
3720  return true;
3721 }
3722 
3723 // Notify the target that gdb is prepared to serve symbol lookup requests.
3724 // packet: "qSymbol::"
3725 // reply:
3726 // OK The target does not need to look up any (more) symbols.
3727 // qSymbol:<sym_name> The target requests the value of symbol sym_name (hex
3728 // encoded).
3729 // LLDB may provide the value by sending another qSymbol
3730 // packet
3731 // in the form of"qSymbol:<sym_value>:<sym_name>".
3732 //
3733 // Three examples:
3734 //
3735 // lldb sends: qSymbol::
3736 // lldb receives: OK
3737 // Remote gdb stub does not need to know the addresses of any symbols, lldb
3738 // does not
3739 // need to ask again in this session.
3740 //
3741 // lldb sends: qSymbol::
3742 // lldb receives: qSymbol:64697370617463685f71756575655f6f666673657473
3743 // lldb sends: qSymbol::64697370617463685f71756575655f6f666673657473
3744 // lldb receives: OK
3745 // Remote gdb stub asks for address of 'dispatch_queue_offsets'. lldb does
3746 // not know
3747 // the address at this time. lldb needs to send qSymbol:: again when it has
3748 // more
3749 // solibs loaded.
3750 //
3751 // lldb sends: qSymbol::
3752 // lldb receives: qSymbol:64697370617463685f71756575655f6f666673657473
3753 // lldb sends: qSymbol:2bc97554:64697370617463685f71756575655f6f666673657473
3754 // lldb receives: OK
3755 // Remote gdb stub asks for address of 'dispatch_queue_offsets'. lldb says
3756 // that it
3757 // is at address 0x2bc97554. Remote gdb stub sends 'OK' indicating that it
3758 // does not
3759 // need any more symbols. lldb does not need to ask again in this session.
3760 
3762  lldb_private::Process *process) {
3763  // Set to true once we've resolved a symbol to an address for the remote
3764  // stub. If we get an 'OK' response after this, the remote stub doesn't need
3765  // any more symbols and we can stop asking.
3766  bool symbol_response_provided = false;
3767 
3768  // Is this the initial qSymbol:: packet?
3769  bool first_qsymbol_query = true;
3770 
3772  Lock lock(*this, false);
3773  if (lock) {
3774  StreamString packet;
3775  packet.PutCString("qSymbol::");
3776  StringExtractorGDBRemote response;
3777  while (SendPacketAndWaitForResponseNoLock(packet.GetString(), response) ==
3779  if (response.IsOKResponse()) {
3780  if (symbol_response_provided || first_qsymbol_query) {
3781  m_qSymbol_requests_done = true;
3782  }
3783 
3784  // We are done serving symbols requests
3785  return;
3786  }
3787  first_qsymbol_query = false;
3788 
3789  if (response.IsUnsupportedResponse()) {
3790  // qSymbol is not supported by the current GDB server we are
3791  // connected to
3792  m_supports_qSymbol = false;
3793  return;
3794  } else {
3795  llvm::StringRef response_str(response.GetStringRef());
3796  if (response_str.startswith("qSymbol:")) {
3797  response.SetFilePos(strlen("qSymbol:"));
3798  std::string symbol_name;
3799  if (response.GetHexByteString(symbol_name)) {
3800  if (symbol_name.empty())
3801  return;
3802 
3803  addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
3806  ConstString(symbol_name), eSymbolTypeAny, sc_list)) {
3807  const size_t num_scs = sc_list.GetSize();
3808  for (size_t sc_idx = 0;
3809  sc_idx < num_scs &&
3810  symbol_load_addr == LLDB_INVALID_ADDRESS;
3811  ++sc_idx) {
3812  SymbolContext sc;
3813  if (sc_list.GetContextAtIndex(sc_idx, sc)) {
3814  if (sc.symbol) {
3815  switch (sc.symbol->GetType()) {
3816  case eSymbolTypeInvalid:
3817  case eSymbolTypeAbsolute:
3818  case eSymbolTypeUndefined:
3819  case eSymbolTypeSourceFile:
3820  case eSymbolTypeHeaderFile:
3821  case eSymbolTypeObjectFile:
3823  case eSymbolTypeBlock:
3824  case eSymbolTypeLocal:
3825  case eSymbolTypeParam:
3826  case eSymbolTypeVariable:
3828  case eSymbolTypeLineEntry:
3829  case eSymbolTypeLineHeader:
3830  case eSymbolTypeScopeBegin:
3831  case eSymbolTypeScopeEnd:
3832  case eSymbolTypeAdditional:
3833  case eSymbolTypeCompiler:
3835  case eSymbolTypeTrampoline:
3836  break;
3837 
3838  case eSymbolTypeCode:
3839  case eSymbolTypeResolver:
3840  case eSymbolTypeData:
3841  case eSymbolTypeRuntime:
3842  case eSymbolTypeException:
3843  case eSymbolTypeObjCClass:
3845  case eSymbolTypeObjCIVar:
3846  case eSymbolTypeReExported:
3847  symbol_load_addr =
3848  sc.symbol->GetLoadAddress(&process->GetTarget());
3849  break;
3850  }
3851  }
3852  }
3853  }
3854  }
3855  // This is the normal path where our symbol lookup was successful
3856  // and we want to send a packet with the new symbol value and see
3857  // if another lookup needs to be done.
3858 
3859  // Change "packet" to contain the requested symbol value and name
3860  packet.Clear();
3861  packet.PutCString("qSymbol:");
3862  if (symbol_load_addr != LLDB_INVALID_ADDRESS) {
3863  packet.Printf("%" PRIx64, symbol_load_addr);
3864  symbol_response_provided = true;
3865  } else {
3866  symbol_response_provided = false;
3867  }
3868  packet.PutCString(":");
3869  packet.PutBytesAsRawHex8(symbol_name.data(), symbol_name.size());
3870  continue; // go back to the while loop and send "packet" and wait
3871  // for another response
3872  }
3873  }
3874  }
3875  }
3876  // If we make it here, the symbol request packet response wasn't valid or
3877  // our symbol lookup failed so we must abort
3878  return;
3879 
3882  log->Printf(
3883  "GDBRemoteCommunicationClient::%s: Didn't get sequence mutex.",
3884  __FUNCTION__);
3885  }
3886  }
3887 }
3888 
3892  // Query the server for the array of supported asynchronous JSON packets.
3894 
3896 
3897  // Poll it now.
3898  StringExtractorGDBRemote response;
3899  const bool send_async = false;
3900  if (SendPacketAndWaitForResponse("qStructuredDataPlugins", response,
3901  send_async) == PacketResult::Success) {
3905  !m_supported_async_json_packets_sp->GetAsArray()) {
3906  // We were returned something other than a JSON array. This is
3907  // invalid. Clear it out.
3908  if (log)
3909  log->Printf("GDBRemoteCommunicationClient::%s(): "
3910  "QSupportedAsyncJSONPackets returned invalid "
3911  "result: %s",
3912  __FUNCTION__, response.GetStringRef().c_str());
3914  }
3915  } else {
3916  if (log)
3917  log->Printf("GDBRemoteCommunicationClient::%s(): "
3918  "QSupportedAsyncJSONPackets unsupported",
3919  __FUNCTION__);
3920  }
3921 
3922  if (log && m_supported_async_json_packets_sp) {
3923  StreamString stream;
3924  m_supported_async_json_packets_sp->Dump(stream);
3925  log->Printf("GDBRemoteCommunicationClient::%s(): supported async "
3926  "JSON packets: %s",
3927  __FUNCTION__, stream.GetData());
3928  }
3929  }
3930 
3932  ? m_supported_async_json_packets_sp->GetAsArray()
3933  : nullptr;
3934 }
3935 
3937  llvm::ArrayRef<int32_t> signals) {
3938  // Format packet:
3939  // QPassSignals:<hex_sig1>;<hex_sig2>...;<hex_sigN>
3940  auto range = llvm::make_range(signals.begin(), signals.end());
3941  std::string packet = formatv("QPassSignals:{0:$[;]@(x-2)}", range).str();
3942 
3943  StringExtractorGDBRemote response;
3944  auto send_status = SendPacketAndWaitForResponse(packet, response, false);
3945 
3947  return Status("Sending QPassSignals packet failed");
3948 
3949  if (response.IsOKResponse()) {
3950  return Status();
3951  } else {
3952  return Status("Unknown error happened during sending QPassSignals packet.");
3953  }
3954 }
3955 
3957  ConstString type_name, const StructuredData::ObjectSP &config_sp) {
3958  Status error;
3959 
3960  if (type_name.GetLength() == 0) {
3961  error.SetErrorString("invalid type_name argument");
3962  return error;
3963  }
3964 
3965  // Build command: Configure{type_name}: serialized config data.
3966  StreamGDBRemote stream;
3967  stream.PutCString("QConfigure");
3968  stream.PutCString(type_name.AsCString());
3969  stream.PutChar(':');
3970  if (config_sp) {
3971  // Gather the plain-text version of the configuration data.
3972  StreamString unescaped_stream;
3973  config_sp->Dump(unescaped_stream);
3974  unescaped_stream.Flush();
3975 
3976  // Add it to the stream in escaped fashion.
3977  stream.PutEscapedBytes(unescaped_stream.GetString().data(),
3978  unescaped_stream.GetSize());
3979  }
3980  stream.Flush();
3981 
3982  // Send the packet.
3983  const bool send_async = false;
3984  StringExtractorGDBRemote response;
3985  auto result =
3986  SendPacketAndWaitForResponse(stream.GetString(), response, send_async);
3987  if (result == PacketResult::Success) {
3988  // We failed if the config result comes back other than OK.
3989  if (strcmp(response.GetStringRef().c_str(), "OK") == 0) {
3990  // Okay!
3991  error.Clear();
3992  } else {
3993  error.SetErrorStringWithFormat("configuring StructuredData feature "
3994  "%s failed with error %s",
3995  type_name.AsCString(),
3996  response.GetStringRef().c_str());
3997  }
3998  } else {
3999  // Can we get more data here on the failure?
4000  error.SetErrorStringWithFormat("configuring StructuredData feature %s "
4001  "failed when sending packet: "
4002  "PacketResult=%d",
4003  type_name.AsCString(), (int)result);
4004  }
4005  return error;
4006 }
4007 
4011 }
PacketResult SendPacketAndWaitForResponseNoLock(llvm::StringRef payload, StringExtractorGDBRemote &response)
void SetObjectOffset(uint64_t object_offset)
Definition: ModuleSpec.h:131
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:61
void Flush() override
Flush the stream.
uint64_t WriteFile(lldb::user_id_t fd, uint64_t offset, const void *src, uint64_t src_len, Status &error)
Status SetFilePermissions(const FileSpec &file_spec, uint32_t file_permissions)
Status SendGetTraceDataPacket(StreamGDBRemote &packet, lldb::user_id_t uid, lldb::tid_t thread_id, llvm::MutableArrayRef< uint8_t > &buffer, size_t offset)
A command line argument class.
Definition: Args.h:32
uint32_t GetEffectiveGroupID() const
Definition: ProcessInfo.h:127
size_t QueryGDBServer(std::vector< std::pair< uint16_t, std::string >> &connection_urls)
bool ProcessIDIsValid() const
Definition: ProcessInfo.h:72
#define UNUSED_IF_ASSERT_DISABLED(x)
Definition: lldb-defines.h:134
Defines a list of symbol context objects.
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
void SetExecutable(OptionalBool val)
void SetGroupID(uint32_t gid)
Definition: ProcessInfo.h:60
Status GetQXferMemoryMapRegionInfo(lldb::addr_t addr, MemoryRegionInfo &region)
const ArchSpec & GetArchitecture() const
Definition: Target.h:941
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:224
bool Contains(BaseType r) const
Definition: RangeMap.h:77
bool SetTriple(const llvm::Triple &triple)
Architecture triple setter.
Definition: ArchSpec.cpp:797
static bool isprint(char32_t codepoint)
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
uint32_t GetUserID() const
Definition: ProcessInfo.h:50
uint32_t FindProcesses(const ProcessInstanceInfoMatch &process_match_info, ProcessInstanceInfoList &process_infos)
static void MakeSpeedTestPacket(StreamString &packet, uint32_t send_size, uint32_t recv_size)
bool GetWorkingDir(FileSpec &working_dir)
Gets the current working directory of a remote platform GDB server.
lldb::ConnectionStatus Disconnect(Status *error_ptr=nullptr)
Disconnect the communications connection if one is currently connected.
void setMetaDataBufferSize(uint64_t size)
Definition: TraceOptions.h:40
bool GetItemAtIndexAsDictionary(size_t idx, Dictionary *&result) const
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
Status GetFilePermissions(const FileSpec &file_spec, uint32_t &file_permissions)
Status SendStopTracePacket(lldb::user_id_t uid, lldb::tid_t thread_id)
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
Definition: ArchSpec.cpp:742
#define LLDB_INVALID_PROCESS_ID
Definition: lldb-defines.h:92
bool GetThreadStopInfo(lldb::tid_t tid, StringExtractorGDBRemote &response)
bool DecodeProcessInfoResponse(StringExtractorGDBRemote &response, ProcessInstanceInfo &process_info)
void Append(const ProcessInstanceInfo &info)
Definition: ProcessInfo.h:166
void Dump(Stream &s, bool pretty_print=true) const override
void setType(lldb::TraceType type)
Definition: TraceOptions.h:36
int32_t GetS32(int32_t fail_value, int base=0)
ProcessInstanceInfo & GetProcessInfo()
Definition: ProcessInfo.h:216
Status SendGetDataPacket(lldb::user_id_t uid, lldb::tid_t thread_id, llvm::MutableArrayRef< uint8_t > &buffer, size_t offset=0)
void setTraceParams(const StructuredData::DictionarySP &dict_obj)
Definition: TraceOptions.h:32
lldb::addr_t GetLoadAddress(Target *target) const
Definition: Symbol.cpp:487
static std::string compose(const value_type &KeyValue)
Definition: Environment.h:78
void SetProcessID(lldb::pid_t pid)
Definition: ProcessInfo.h:70
A file utility class.
Definition: FileSpec.h:55
void SetFlash(OptionalBool val)
An architecture specification class.
Definition: ArchSpec.h:32
uint8_t SendGDBStoppointTypePacket(GDBStoppointType type, bool insert, lldb::addr_t addr, uint32_t length)
int SendEnvironmentPacket(char const *name_equal_value)
Sends a "QEnvironment:NAME=VALUE" packet that will build up the environment that will get used when l...
uint64_t GetU64(uint64_t fail_value, int base=0)
size_t GetHexByteString(std::string &str)
bool GetModuleInfo(const FileSpec &module_file_spec, const ArchSpec &arch_spec, ModuleSpec &module_spec)
#define S_IRWXU
void SetMapped(OptionalBool val)
int SetSTDIN(const FileSpec &file_spec)
Sets the path to use for stdin/out/err for a process that will be launched with the &#39;A&#39; packet...
void AddItem(llvm::StringRef key, ObjectSP value_sp)
virtual void Flush()=0
Flush the stream.
#define S_IRWXG
int SetWorkingDir(const FileSpec &working_dir)
Sets the working directory to path for a process that will be launched with the &#39;A&#39; packet for non pl...
llvm::Optional< std::vector< ModuleSpec > > GetModulesInfo(llvm::ArrayRef< FileSpec > module_file_specs, const llvm::Triple &triple)
void SetName(const char *name)
const char * GetData() const
Definition: StreamString.h:43
bool IsValid() const
Tests if this ArchSpec is valid.
Definition: ArchSpec.h:329
POSIX error codes.
#define LLDB_INVALID_UID
Definition: lldb-defines.h:91
int SendAttach(lldb::pid_t pid, StringExtractorGDBRemote &response)
Sends a "vAttach:PID" where PID is in hex.
PacketResult SendPacketsAndConcatenateResponses(const char *send_payload_prefix, std::string &response_string)
#define LLDB_LOG(log,...)
Definition: Log.h:209
void SetFlags(uint32_t flags)
Definition: ArchSpec.h:503
Symbol * symbol
The Symbol for a given query.
const char * GetArgumentAtIndex(size_t idx) const
Gets the NULL terminated C string argument pointer for the argument at index idx. ...
Definition: Args.cpp:256
A subclass of DataBuffer that stores a data buffer on the heap.
std::shared_ptr< JSONArray > SP
Definition: JSON.h:224
#define LLDB_INVALID_CPUTYPE
Definition: lldb-defines.h:104
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:431
uint32_t GetU32(uint32_t fail_value, int base=0)
uint32_t GetSize() const
Get accessor for a symbol context list size.
size_t SetFromStringRef(llvm::StringRef str, uint32_t num_uuid_bytes=16)
Definition: UUID.cpp:92
const char * GetName() const
Definition: ProcessInfo.cpp:41
int SendArgumentsPacket(const ProcessLaunchInfo &launch_info)
Sends a GDB remote protocol &#39;A&#39; packet that delivers program arguments to the remote server...
void Clear()
Clears the object state.
Definition: ArchSpec.cpp:580
std::shared_ptr< Dictionary > DictionarySP
uint64_t ReadFile(lldb::user_id_t fd, uint64_t offset, void *dst, uint64_t dst_len, Status &error)
const StructuredData::DictionarySP & getTraceParams() const
Definition: TraceOptions.h:22
lldb::SymbolType GetType() const
Definition: Symbol.h:136
uint32_t GetEffectiveUserID() const
Definition: ProcessInfo.h:125
int SetDetachOnError(bool enable)
Sets the DetachOnError flag to enable for the process controlled by the stub.
const char * GetArchitectureName() const
Returns a static string representing the current architecture.
Definition: ArchSpec.cpp:591
#define UINT32_MAX
Definition: lldb-defines.h:31
lldb::user_id_t OpenFile(const FileSpec &file_spec, uint32_t flags, mode_t mode, Status &error)
void Format(const char *format, Args &&... args)
Definition: Stream.h:422
void SetDistributionId(const char *distribution_id)
Set the distribution id of the architecture.
Definition: ArchSpec.cpp:738
#define LLDB_INVALID_ADDRESS
Invalid value definitions.
Definition: lldb-defines.h:85
bool LaunchGDBServer(const char *remote_accept_hostname, lldb::pid_t &pid, uint16_t &port, std::string &socket_name)
size_t PutStringAsRawHex8(llvm::StringRef s)
Definition: Stream.cpp:432
uint64_t user_id_t
Definition: lldb-types.h:84
#define GDBR_LOG_PROCESS
void SetErrorToGenericError()
Set the current error to a generic error.
Definition: Status.cpp:231
duration< float > calculate_standard_deviation(const std::vector< duration< float >> &v)
lldb::tid_t getThreadID() const
Definition: TraceOptions.h:44
bool CalculateMD5(const FileSpec &file_spec, uint64_t &high, uint64_t &low)
size_t GetLength() const
Get the length in bytes of string value.
PacketResult SendThreadSpecificPacketAndWaitForResponse(lldb::tid_t tid, StreamString &&payload, StringExtractorGDBRemote &response, bool send_async)
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:127
void SetEffectiveGroupID(uint32_t gid)
Definition: ProcessInfo.h:135
#define LIBLLDB_LOG_BREAKPOINTS
Definition: Logging.h:19
Status SendGetMetaDataPacket(lldb::user_id_t uid, lldb::tid_t thread_id, llvm::MutableArrayRef< uint8_t > &buffer, size_t offset=0)
void SetFilePos(uint32_t idx)
void MaybeEnableCompression(std::vector< std::string > supported_compressions)
uint64_t GetHexMaxU64(bool little_endian, uint64_t fail_value)
void Clear()
Clear the object state.
Definition: Status.cpp:167
bool GetNameColonValue(llvm::StringRef &name, llvm::StringRef &value)
size_t FindSymbolsWithNameAndType(ConstString name, lldb::SymbolType symbol_type, SymbolContextList &sc_list, bool append=false) const
Definition: ModuleList.cpp:457
ObjectSP GetValueForKey(llvm::StringRef key) const
size_t GetHexBytes(llvm::MutableArrayRef< uint8_t > dest, uint8_t fail_fill_value)
uint64_t tid_t
Definition: lldb-types.h:86
static ObjectSP ParseJSON(std::string json_text)
void SetParentProcessID(lldb::pid_t pid)
Definition: ProcessInfo.h:139
llvm::StringRef GetString() const
llvm::StringRef GetName() const
Definition: XML.cpp:271
void SetBlocksize(lldb::offset_t blocksize)
bool GetAttributeValueAsUnsigned(const char *name, uint64_t &value, uint64_t fail_value=0, int base=0) const
Definition: XML.cpp:153
uint64_t getTraceBufferSize() const
Definition: TraceOptions.h:28
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:241
lldb_private::StructuredData::Array * GetSupportedStructuredDataPlugins()
Return the array of async JSON packet types supported by the remote.
bool ParseMemory(const char *xml, size_t xml_length, const char *url="untitled.xml")
Definition: XML.cpp:54
bool IsValid() const
Definition: RangeMap.h:75
size_t PutHex32(uint32_t uvalue, lldb::ByteOrder byte_order=lldb::eByteOrderInvalid)
Definition: Stream.cpp:306
uint64_t getMetaDataBufferSize() const
Definition: TraceOptions.h:30
A plug-in interface definition class for debugging a process.
Definition: Process.h:353
bool GetElementTextAsUnsigned(uint64_t &value, uint64_t fail_value=0, int base=0) const
Definition: XML.cpp:302
uint32_t GetGroupID() const
Definition: ProcessInfo.h:52
lldb::ByteOrder GetByteOrder() const
Returns the byte order for the architecture specification.
Definition: ArchSpec.cpp:788
size_t GetHexBytesAvail(llvm::MutableArrayRef< uint8_t > dest)
FileSpec & GetExecutableFile()
Definition: ProcessInfo.h:43
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:106
ArchSpec & GetArchitecture()
Definition: ProcessInfo.h:62
bool Success() const
Test for success condition.
Definition: Status.cpp:287
void ForEachChildElement(NodeCallback const &callback) const
Definition: XML.cpp:172
bool WriteRegister(lldb::tid_t tid, uint32_t reg_num, llvm::ArrayRef< uint8_t > data)
Generic errors that can be any value.
FileSpec & GetFileSpec()
Definition: ModuleSpec.h:75
bool IsConnected() const
Check if the connection is valid.
#define S_IRWXO
size_t GetEscapedBinaryData(std::string &str)
PacketResult ReadPacket(StringExtractorGDBRemote &response, Timeout< std::micro > timeout, bool sync_on_timeout)
bool GetContextAtIndex(size_t idx, SymbolContext &sc) const
Get accessor for a symbol context at index idx.
bool IsElement() const
Definition: XML.cpp:364
Status RunShellCommand(const char *command, const FileSpec &working_dir, int *status_ptr, int *signo_ptr, std::string *command_output, const Timeout< std::micro > &timeout)
std::shared_ptr< JSONObject > SP
Definition: JSON.h:197
lldb::DataBufferSP ReadRegister(lldb::tid_t tid, uint32_t reg_num)
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:899
void SetByteSize(SizeType s)
Definition: RangeMap.h:73
int SendStdinNotification(const char *data, size_t data_len)
Sends a GDB remote protocol &#39;I&#39; packet that delivers stdin data to the remote process.
ArchSpec & GetArchitecture()
Definition: ModuleSpec.h:111
static llvm::Optional< ModuleSpec > ParseModuleSpec(StructuredData::Dictionary *dict)
size_t PutChar(char ch)
Definition: Stream.cpp:103
lldb::offset_t GetBlocksize() const
int SendLaunchEventDataPacket(const char *data, bool *was_supported=nullptr)
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1194
bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result) const
size_t GetCurrentThreadIDs(std::vector< lldb::tid_t > &thread_ids, bool &sequence_mutex_unavailable)
lldb::pid_t GetParentProcessID() const
Definition: ProcessInfo.h:137
int SetDisableASLR(bool enable)
Sets the disable ASLR flag to enable for a process that will be launched with the &#39;A&#39; packet...
Status SendGetTraceConfigPacket(lldb::user_id_t uid, TraceOptions &options)
#define LLDB_INVALID_THREAD_ID
Definition: lldb-defines.h:93
uint64_t addr_t
Definition: lldb-types.h:83
void SetReadable(OptionalBool val)
A uniqued constant string class.
Definition: ConstString.h:38
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
static bool XMLEnabled()
Definition: XML.cpp:83
llvm::StringRef GetAttributeValue(const char *name, const char *fail_value=nullptr) const
Definition: XML.cpp:135
void setTraceBufferSize(uint64_t size)
Definition: TraceOptions.h:38
int void SetError(ValueType err, lldb::ErrorType type)
Set accesssor with an error value and type.
Definition: Status.cpp:216
Log * GetLogIfAnyCategoriesSet(uint32_t mask)
Definition: Logging.cpp:61
const char * Peek()
int PutEscapedBytes(const void *s, size_t src_len)
Output a block of data to the stream performing GDB-remote escaping.
ObjectSP GetItemAtIndex(size_t idx) const
Definition: SBAddress.h:15
lldb::TraceType getType() const
Definition: TraceOptions.h:26
uint64_t pid_t
Definition: lldb-types.h:85
lldb::user_id_t SendStartTracePacket(const TraceOptions &options, Status &error)
bool ReadExtFeature(const lldb_private::ConstString object, const lldb_private::ConstString annex, std::string &out, lldb_private::Status &err)
std::shared_ptr< Object > ObjectSP
void SetRangeBase(BaseType b)
Definition: RangeMap.h:48
void SetWritable(OptionalBool val)
static uint64_t ParseHostIOPacketResponse(StringExtractorGDBRemote &response, uint64_t fail_result, Status &error)
bool GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &process_info)