LLDB  mainline
GDBRemoteCommunicationClient.cpp
Go to the documentation of this file.
1 //===-- GDBRemoteCommunicationClient.cpp ----------------------------------===//
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 <cmath>
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"
27 #include "lldb/Utility/LLDBLog.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 #include "llvm/Support/JSON.h"
39 
40 #if defined(HAVE_LIBCOMPRESSION)
41 #include <compression.h>
42 #endif
43 
44 using namespace lldb;
45 using namespace lldb_private::process_gdb_remote;
46 using namespace lldb_private;
47 using namespace std::chrono;
48 
49 llvm::raw_ostream &process_gdb_remote::operator<<(llvm::raw_ostream &os,
50  const QOffsets &offsets) {
51  return os << llvm::formatv(
52  "QOffsets({0}, [{1:@[x]}])", offsets.segments,
53  llvm::make_range(offsets.offsets.begin(), offsets.offsets.end()));
54 }
55 
56 // GDBRemoteCommunicationClient constructor
57 GDBRemoteCommunicationClient::GDBRemoteCommunicationClient()
58  : GDBRemoteClientBase("gdb-remote.client", "gdb-remote.client.rx_packet"),
59 
60  m_supports_qProcessInfoPID(true), m_supports_qfProcessInfo(true),
61  m_supports_qUserName(true), m_supports_qGroupName(true),
62  m_supports_qThreadStopInfo(true), m_supports_z0(true),
63  m_supports_z1(true), m_supports_z2(true), m_supports_z3(true),
64  m_supports_z4(true), m_supports_QEnvironment(true),
65  m_supports_QEnvironmentHexEncoded(true), m_supports_qSymbol(true),
66  m_qSymbol_requests_done(false), m_supports_qModuleInfo(true),
67  m_supports_jThreadsInfo(true), m_supports_jModulesInfo(true),
68  m_supports_vFileSize(true), m_supports_vFileMode(true),
69  m_supports_vFileExists(true), m_supports_vRun(true),
70 
71  m_host_arch(), m_process_arch(), m_os_build(), m_os_kernel(),
72  m_hostname(), m_gdb_server_name(), m_default_packet_timeout(0),
73  m_qSupported_response(), m_supported_async_json_packets_sp(),
74  m_qXfer_memory_map() {}
75 
76 // Destructor
78  if (IsConnected())
79  Disconnect();
80 }
81 
84 
85  // Start the read thread after we send the handshake ack since if we fail to
86  // send the handshake ack, there is no reason to continue...
87  std::chrono::steady_clock::time_point start_of_handshake =
88  std::chrono::steady_clock::now();
89  if (SendAck()) {
90  // The return value from QueryNoAckModeSupported() is true if the packet
91  // was sent and _any_ response (including UNIMPLEMENTED) was received), or
92  // false if no response was received. This quickly tells us if we have a
93  // live connection to a remote GDB server...
95  return true;
96  } else {
97  std::chrono::steady_clock::time_point end_of_handshake =
98  std::chrono::steady_clock::now();
99  auto handshake_timeout =
100  std::chrono::duration<double>(end_of_handshake - start_of_handshake)
101  .count();
102  if (error_ptr) {
103  if (!IsConnected())
104  error_ptr->SetErrorString("Connection shut down by remote side "
105  "while waiting for reply to initial "
106  "handshake packet");
107  else
108  error_ptr->SetErrorStringWithFormat(
109  "failed to get reply to handshake packet within timeout of "
110  "%.1f seconds",
111  handshake_timeout);
112  }
113  }
114  } else {
115  if (error_ptr)
116  error_ptr->SetErrorString("failed to send the handshake ack");
117  }
118  return false;
119 }
120 
124  }
125  return m_supports_qEcho == eLazyBoolYes;
126 }
127 
131  }
133 }
134 
138  }
140 }
141 
145  }
147 }
148 
152  }
154 }
155 
159  }
161 }
162 
166  }
168 }
169 
173  }
175 }
176 
180  }
182 }
183 
185  if (m_max_packet_size == 0) {
187  }
188  return m_max_packet_size;
189 }
190 
193  m_send_acks = true;
195 
196  // This is the first real packet that we'll send in a debug session and it
197  // may take a little longer than normal to receive a reply. Wait at least
198  // 6 seconds for a reply to this packet.
199 
200  ScopedTimeout timeout(*this, std::max(GetPacketTimeout(), seconds(6)));
201 
202  StringExtractorGDBRemote response;
203  if (SendPacketAndWaitForResponse("QStartNoAckMode", response) ==
205  if (response.IsOKResponse()) {
206  m_send_acks = false;
208  }
209  return true;
210  }
211  }
212  return false;
213 }
214 
218 
219  StringExtractorGDBRemote response;
220  if (SendPacketAndWaitForResponse("QListThreadsInStopReply", response) ==
222  if (response.IsOKResponse())
224  }
225  }
226 }
227 
231 
232  StringExtractorGDBRemote response;
233  if (SendPacketAndWaitForResponse("qVAttachOrWaitSupported", response) ==
235  if (response.IsOKResponse())
237  }
238  }
240 }
241 
245 
246  StringExtractorGDBRemote response;
247  if (SendPacketAndWaitForResponse("qSyncThreadStateSupported", response) ==
249  if (response.IsOKResponse())
251  }
252  }
254 }
255 
257  if (!did_exec) {
258  // Hard reset everything, this is when we first connect to a GDB server
289  m_supports_qUserName = true;
290  m_supports_qGroupName = true;
292  m_supports_z0 = true;
293  m_supports_z1 = true;
294  m_supports_z2 = true;
295  m_supports_z3 = true;
296  m_supports_z4 = true;
299  m_supports_qSymbol = true;
300  m_qSymbol_requests_done = false;
301  m_supports_qModuleInfo = true;
302  m_host_arch.Clear();
303  m_os_version = llvm::VersionTuple();
304  m_os_build.clear();
305  m_os_kernel.clear();
306  m_hostname.clear();
307  m_gdb_server_name.clear();
309  m_default_packet_timeout = seconds(0);
311  m_max_packet_size = 0;
312  m_qSupported_response.clear();
316  }
317 
318  // These flags should be reset when we first connect to a GDB server and when
319  // our inferior process execs
322 }
323 
325  // Clear out any capabilities we expect to see in the qSupported response
339 
340  m_max_packet_size = UINT64_MAX; // It's supposed to always be there, but if
341  // not, we assume no limit
342 
343  // build the qSupported packet
344  std::vector<std::string> features = {"xmlRegisters=i386,arm,mips,arc",
345  "multiprocess+", "fork-events+",
346  "vfork-events+"};
347  StreamString packet;
348  packet.PutCString("qSupported");
349  for (uint32_t i = 0; i < features.size(); ++i) {
350  packet.PutCString(i == 0 ? ":" : ";");
351  packet.PutCString(features[i]);
352  }
353 
354  StringExtractorGDBRemote response;
355  if (SendPacketAndWaitForResponse(packet.GetString(), response) ==
357  // Hang on to the qSupported packet, so that platforms can do custom
358  // configuration of the transport before attaching/launching the process.
359  m_qSupported_response = response.GetStringRef().str();
360 
361  for (llvm::StringRef x : llvm::split(response.GetStringRef(), ';')) {
362  if (x == "qXfer:auxv:read+")
364  else if (x == "qXfer:libraries-svr4:read+")
366  else if (x == "augmented-libraries-svr4-read") {
369  } else if (x == "qXfer:libraries:read+")
371  else if (x == "qXfer:features:read+")
373  else if (x == "qXfer:memory-map:read+")
375  else if (x == "qXfer:siginfo:read+")
377  else if (x == "qEcho")
379  else if (x == "QPassSignals+")
381  else if (x == "multiprocess+")
383  else if (x == "memory-tagging+")
385  else if (x == "qSaveCore+")
387  else if (x == "native-signals+")
389  // Look for a list of compressions in the features list e.g.
390  // qXfer:features:read+;PacketSize=20000;qEcho+;SupportedCompressions=zlib-
391  // deflate,lzma
392  else if (x.consume_front("SupportedCompressions=")) {
393  llvm::SmallVector<llvm::StringRef, 4> compressions;
394  x.split(compressions, ',');
395  if (!compressions.empty())
396  MaybeEnableCompression(compressions);
397  } else if (x.consume_front("PacketSize=")) {
398  StringExtractorGDBRemote packet_response(x);
400  packet_response.GetHexMaxU64(/*little_endian=*/false, UINT64_MAX);
401  if (m_max_packet_size == 0) {
402  m_max_packet_size = UINT64_MAX; // Must have been a garbled response
403  Log *log(GetLog(GDBRLog::Process));
404  LLDB_LOGF(log, "Garbled PacketSize spec in qSupported response");
405  }
406  }
407  }
408  }
409 }
410 
413  StringExtractorGDBRemote response;
415  if (SendPacketAndWaitForResponse("QThreadSuffixSupported", response) ==
417  if (response.IsOKResponse())
419  }
420  }
422 }
425  StringExtractorGDBRemote response;
432  if (SendPacketAndWaitForResponse("vCont?", response) ==
434  const char *response_cstr = response.GetStringRef().data();
435  if (::strstr(response_cstr, ";c"))
437 
438  if (::strstr(response_cstr, ";C"))
440 
441  if (::strstr(response_cstr, ";s"))
443 
444  if (::strstr(response_cstr, ";S"))
446 
452  }
453 
459  }
460  }
461  }
462 
463  switch (flavor) {
464  case 'a':
465  return m_supports_vCont_any;
466  case 'A':
467  return m_supports_vCont_all;
468  case 'c':
469  return m_supports_vCont_c;
470  case 'C':
471  return m_supports_vCont_C;
472  case 's':
473  return m_supports_vCont_s;
474  case 'S':
475  return m_supports_vCont_S;
476  default:
477  break;
478  }
479  return false;
480 }
481 
484  lldb::tid_t tid, StreamString &&payload,
485  StringExtractorGDBRemote &response) {
486  Lock lock(*this);
487  if (!lock) {
489  LLDB_LOGF(log,
490  "GDBRemoteCommunicationClient::%s: Didn't get sequence mutex "
491  "for %s packet.",
492  __FUNCTION__, payload.GetData());
494  }
495 
497  payload.Printf(";thread:%4.4" PRIx64 ";", tid);
498  else {
499  if (!SetCurrentThread(tid))
501  }
502 
503  return SendPacketAndWaitForResponseNoLock(payload.GetString(), response);
504 }
505 
506 // Check if the target supports 'p' packet. It sends out a 'p' packet and
507 // checks the response. A normal packet will tell us that support is available.
508 //
509 // Takes a valid thread ID because p needs to apply to a thread.
513  return m_supports_p;
514 }
515 
517  lldb::tid_t tid, llvm::StringRef packetStr) {
518  StreamString payload;
519  payload.PutCString(packetStr);
520  StringExtractorGDBRemote response;
522  tid, std::move(payload), response) == PacketResult::Success &&
523  response.IsNormalResponse()) {
524  return eLazyBoolYes;
525  }
526  return eLazyBoolNo;
527 }
528 
531 }
532 
534  // Get information on all threads at one using the "jThreadsInfo" packet
535  StructuredData::ObjectSP object_sp;
536 
538  StringExtractorGDBRemote response;
539  response.SetResponseValidatorToJSON();
540  if (SendPacketAndWaitForResponse("jThreadsInfo", response) ==
542  if (response.IsUnsupportedResponse()) {
543  m_supports_jThreadsInfo = false;
544  } else if (!response.Empty()) {
545  object_sp =
547  }
548  }
549  }
550  return object_sp;
551 }
552 
555  StringExtractorGDBRemote response;
557  if (SendPacketAndWaitForResponse("jThreadExtendedInfo:", response) ==
559  if (response.IsOKResponse()) {
561  }
562  }
563  }
565 }
566 
569  StringExtractorGDBRemote response;
570  // We try to enable error strings in remote packets but if we fail, we just
571  // work in the older way.
573  if (SendPacketAndWaitForResponse("QEnableErrorStrings", response) ==
575  if (response.IsOKResponse()) {
577  }
578  }
579  }
580 }
581 
584  StringExtractorGDBRemote response;
586  if (SendPacketAndWaitForResponse("jGetLoadedDynamicLibrariesInfos:",
587  response) == PacketResult::Success) {
588  if (response.IsOKResponse()) {
590  }
591  }
592  }
594 }
595 
598  StringExtractorGDBRemote response;
600  if (SendPacketAndWaitForResponse("jGetSharedCacheInfo:", response) ==
602  if (response.IsOKResponse()) {
604  }
605  }
606  }
608 }
609 
613  }
615 }
616 
618  size_t len,
619  int32_t type) {
620  StreamString packet;
621  packet.Printf("qMemTags:%" PRIx64 ",%zx:%" PRIx32, addr, len, type);
622  StringExtractorGDBRemote response;
623 
624  Log *log = GetLog(GDBRLog::Memory);
625 
626  if (SendPacketAndWaitForResponse(packet.GetString(), response) !=
628  !response.IsNormalResponse()) {
629  LLDB_LOGF(log, "GDBRemoteCommunicationClient::%s: qMemTags packet failed",
630  __FUNCTION__);
631  return nullptr;
632  }
633 
634  // We are expecting
635  // m<hex encoded bytes>
636 
637  if (response.GetChar() != 'm') {
638  LLDB_LOGF(log,
639  "GDBRemoteCommunicationClient::%s: qMemTags response did not "
640  "begin with \"m\"",
641  __FUNCTION__);
642  return nullptr;
643  }
644 
645  size_t expected_bytes = response.GetBytesLeft() / 2;
646  WritableDataBufferSP buffer_sp(new DataBufferHeap(expected_bytes, 0));
647  size_t got_bytes = response.GetHexBytesAvail(buffer_sp->GetData());
648  // Check both because in some situations chars are consumed even
649  // if the decoding fails.
650  if (response.GetBytesLeft() || (expected_bytes != got_bytes)) {
651  LLDB_LOGF(
652  log,
653  "GDBRemoteCommunicationClient::%s: Invalid data in qMemTags response",
654  __FUNCTION__);
655  return nullptr;
656  }
657 
658  return buffer_sp;
659 }
660 
662  lldb::addr_t addr, size_t len, int32_t type,
663  const std::vector<uint8_t> &tags) {
664  // Format QMemTags:address,length:type:tags
665  StreamString packet;
666  packet.Printf("QMemTags:%" PRIx64 ",%zx:%" PRIx32 ":", addr, len, type);
667  packet.PutBytesAsRawHex8(tags.data(), tags.size());
668 
669  Status status;
670  StringExtractorGDBRemote response;
671  if (SendPacketAndWaitForResponse(packet.GetString(), response) !=
673  !response.IsOKResponse()) {
674  status.SetErrorString("QMemTags packet failed");
675  }
676  return status;
677 }
678 
681  StringExtractorGDBRemote response;
683  char packet[256];
684  snprintf(packet, sizeof(packet), "x0,0");
685  if (SendPacketAndWaitForResponse(packet, response) ==
687  if (response.IsOKResponse())
689  }
690  }
691  return m_supports_x;
692 }
693 
695  if (allow_lazy && m_curr_pid_is_valid == eLazyBoolYes)
696  return m_curr_pid;
697 
698  // First try to retrieve the pid via the qProcessInfo request.
699  GetCurrentProcessInfo(allow_lazy);
701  // We really got it.
702  return m_curr_pid;
703  } else {
704  // If we don't get a response for qProcessInfo, check if $qC gives us a
705  // result. $qC only returns a real process id on older debugserver and
706  // lldb-platform stubs. The gdb remote protocol documents $qC as returning
707  // the thread id, which newer debugserver and lldb-gdbserver stubs return
708  // correctly.
709  StringExtractorGDBRemote response;
710  if (SendPacketAndWaitForResponse("qC", response) == PacketResult::Success) {
711  if (response.GetChar() == 'Q') {
712  if (response.GetChar() == 'C') {
714  response.GetHexMaxU64(false, LLDB_INVALID_PROCESS_ID);
717  return m_curr_pid;
718  }
719  }
720  }
721  }
722 
723  // If we don't get a response for $qC, check if $qfThreadID gives us a
724  // result.
726  bool sequence_mutex_unavailable;
727  auto ids = GetCurrentProcessAndThreadIDs(sequence_mutex_unavailable);
728  if (!ids.empty() && !sequence_mutex_unavailable) {
729  // If server returned an explicit PID, use that.
730  m_curr_pid_run = m_curr_pid = ids.front().first;
731  // Otherwise, use the TID of the first thread (Linux hack).
733  m_curr_pid_run = m_curr_pid = ids.front().second;
735  return m_curr_pid;
736  }
737  }
738  }
739 
741 }
742 
744  error_str.clear();
745  StringExtractorGDBRemote response;
746  if (SendPacketAndWaitForResponse("qLaunchSuccess", response) ==
748  if (response.IsOKResponse())
749  return true;
750  // GDB does not implement qLaunchSuccess -- but if we used vRun,
751  // then we already received a successful launch indication via stop
752  // reason.
753  if (response.IsUnsupportedResponse() && m_supports_vRun)
754  return true;
755  if (response.GetChar() == 'E') {
756  // A string the describes what failed when launching...
757  error_str = std::string(response.GetStringRef().substr(1));
758  } else {
759  error_str.assign("unknown error occurred launching process");
760  }
761  } else {
762  error_str.assign("timed out waiting for app to launch");
763  }
764  return false;
765 }
766 
768  const ProcessLaunchInfo &launch_info) {
769  // Since we don't get the send argv0 separate from the executable path, we
770  // need to make sure to use the actual executable path found in the
771  // launch_info...
772  std::vector<const char *> argv;
773  FileSpec exe_file = launch_info.GetExecutableFile();
774  std::string exe_path;
775  const char *arg = nullptr;
776  const Args &launch_args = launch_info.GetArguments();
777  if (exe_file)
778  exe_path = exe_file.GetPath(false);
779  else {
780  arg = launch_args.GetArgumentAtIndex(0);
781  if (arg)
782  exe_path = arg;
783  }
784  if (!exe_path.empty()) {
785  argv.push_back(exe_path.c_str());
786  for (uint32_t i = 1; (arg = launch_args.GetArgumentAtIndex(i)) != nullptr;
787  ++i) {
788  if (arg)
789  argv.push_back(arg);
790  }
791  }
792  if (!argv.empty()) {
793  // try vRun first
794  if (m_supports_vRun) {
795  StreamString packet;
796  packet.PutCString("vRun");
797  for (const char *arg : argv) {
798  packet.PutChar(';');
799  packet.PutBytesAsRawHex8(arg, strlen(arg));
800  }
801 
802  StringExtractorGDBRemote response;
803  if (SendPacketAndWaitForResponse(packet.GetString(), response) !=
805  return -1;
806 
807  if (response.IsErrorResponse()) {
808  uint8_t error = response.GetError();
809  if (error)
810  return error;
811  return -1;
812  }
813  // vRun replies with a stop reason packet
814  // FIXME: right now we just discard the packet and LLDB queries
815  // for stop reason again
816  if (!response.IsUnsupportedResponse())
817  return 0;
818 
819  m_supports_vRun = false;
820  }
821 
822  // fallback to A
823  StreamString packet;
824  packet.PutChar('A');
825  for (size_t i = 0, n = argv.size(); i < n; ++i) {
826  arg = argv[i];
827  const int arg_len = strlen(arg);
828  if (i > 0)
829  packet.PutChar(',');
830  packet.Printf("%i,%i,", arg_len * 2, (int)i);
831  packet.PutBytesAsRawHex8(arg, arg_len);
832  }
833 
834  StringExtractorGDBRemote response;
835  if (SendPacketAndWaitForResponse(packet.GetString(), response) ==
837  if (response.IsOKResponse())
838  return 0;
839  uint8_t error = response.GetError();
840  if (error)
841  return error;
842  }
843  }
844  return -1;
845 }
846 
848  for (const auto &KV : env) {
849  int r = SendEnvironmentPacket(Environment::compose(KV).c_str());
850  if (r != 0)
851  return r;
852  }
853  return 0;
854 }
855 
857  char const *name_equal_value) {
858  if (name_equal_value && name_equal_value[0]) {
859  bool send_hex_encoding = false;
860  for (const char *p = name_equal_value; *p != '\0' && !send_hex_encoding;
861  ++p) {
862  if (llvm::isPrint(*p)) {
863  switch (*p) {
864  case '$':
865  case '#':
866  case '*':
867  case '}':
868  send_hex_encoding = true;
869  break;
870  default:
871  break;
872  }
873  } else {
874  // We have non printable characters, lets hex encode this...
875  send_hex_encoding = true;
876  }
877  }
878 
879  StringExtractorGDBRemote response;
880  // Prefer sending unencoded, if possible and the server supports it.
881  if (!send_hex_encoding && m_supports_QEnvironment) {
882  StreamString packet;
883  packet.Printf("QEnvironment:%s", name_equal_value);
884  if (SendPacketAndWaitForResponse(packet.GetString(), response) !=
886  return -1;
887 
888  if (response.IsOKResponse())
889  return 0;
890  if (response.IsUnsupportedResponse())
891  m_supports_QEnvironment = false;
892  else {
893  uint8_t error = response.GetError();
894  if (error)
895  return error;
896  return -1;
897  }
898  }
899 
901  StreamString packet;
902  packet.PutCString("QEnvironmentHexEncoded:");
903  packet.PutBytesAsRawHex8(name_equal_value, strlen(name_equal_value));
904  if (SendPacketAndWaitForResponse(packet.GetString(), response) !=
906  return -1;
907 
908  if (response.IsOKResponse())
909  return 0;
910  if (response.IsUnsupportedResponse())
912  else {
913  uint8_t error = response.GetError();
914  if (error)
915  return error;
916  return -1;
917  }
918  }
919  }
920  return -1;
921 }
922 
924  if (arch && arch[0]) {
925  StreamString packet;
926  packet.Printf("QLaunchArch:%s", arch);
927  StringExtractorGDBRemote response;
928  if (SendPacketAndWaitForResponse(packet.GetString(), response) ==
930  if (response.IsOKResponse())
931  return 0;
932  uint8_t error = response.GetError();
933  if (error)
934  return error;
935  }
936  }
937  return -1;
938 }
939 
941  char const *data, bool *was_supported) {
942  if (data && *data != '\0') {
943  StreamString packet;
944  packet.Printf("QSetProcessEvent:%s", data);
945  StringExtractorGDBRemote response;
946  if (SendPacketAndWaitForResponse(packet.GetString(), response) ==
948  if (response.IsOKResponse()) {
949  if (was_supported)
950  *was_supported = true;
951  return 0;
952  } else if (response.IsUnsupportedResponse()) {
953  if (was_supported)
954  *was_supported = false;
955  return -1;
956  } else {
957  uint8_t error = response.GetError();
958  if (was_supported)
959  *was_supported = true;
960  if (error)
961  return error;
962  }
963  }
964  }
965  return -1;
966 }
967 
969  GetHostInfo();
970  return m_os_version;
971 }
972 
974  GetHostInfo();
975  return m_maccatalyst_version;
976 }
977 
978 llvm::Optional<std::string> GDBRemoteCommunicationClient::GetOSBuildString() {
979  if (GetHostInfo()) {
980  if (!m_os_build.empty())
981  return m_os_build;
982  }
983  return llvm::None;
984 }
985 
986 llvm::Optional<std::string>
988  if (GetHostInfo()) {
989  if (!m_os_kernel.empty())
990  return m_os_kernel;
991  }
992  return llvm::None;
993 }
994 
996  if (GetHostInfo()) {
997  if (!m_hostname.empty()) {
998  s = m_hostname;
999  return true;
1000  }
1001  }
1002  s.clear();
1003  return false;
1004 }
1005 
1007  if (GetHostInfo())
1008  return m_host_arch;
1009  return ArchSpec();
1010 }
1011 
1012 const lldb_private::ArchSpec &
1016  return m_process_arch;
1017 }
1018 
1020  UUID &uuid, addr_t &value, bool &value_is_offset) {
1023 
1024  // Return true if we have a UUID or an address/offset of the
1025  // main standalone / firmware binary being used.
1028  return false;
1029 
1032  value_is_offset = m_process_standalone_value_is_offset;
1033  return true;
1034 }
1035 
1038  m_gdb_server_name.clear();
1041 
1042  StringExtractorGDBRemote response;
1043  if (SendPacketAndWaitForResponse("qGDBServerVersion", response) ==
1045  if (response.IsNormalResponse()) {
1046  llvm::StringRef name, value;
1047  bool success = false;
1048  while (response.GetNameColonValue(name, value)) {
1049  if (name.equals("name")) {
1050  success = true;
1051  m_gdb_server_name = std::string(value);
1052  } else if (name.equals("version")) {
1053  llvm::StringRef major, minor;
1054  std::tie(major, minor) = value.split('.');
1055  if (!major.getAsInteger(0, m_gdb_server_version))
1056  success = true;
1057  }
1058  }
1059  if (success)
1061  }
1062  }
1063  }
1065 }
1066 
1068  llvm::ArrayRef<llvm::StringRef> supported_compressions) {
1070  llvm::StringRef avail_name;
1071 
1072 #if defined(HAVE_LIBCOMPRESSION)
1073  if (avail_type == CompressionType::None) {
1074  for (auto compression : supported_compressions) {
1075  if (compression == "lzfse") {
1076  avail_type = CompressionType::LZFSE;
1077  avail_name = compression;
1078  break;
1079  }
1080  }
1081  }
1082 #endif
1083 
1084 #if defined(HAVE_LIBCOMPRESSION)
1085  if (avail_type == CompressionType::None) {
1086  for (auto compression : supported_compressions) {
1087  if (compression == "zlib-deflate") {
1088  avail_type = CompressionType::ZlibDeflate;
1089  avail_name = compression;
1090  break;
1091  }
1092  }
1093  }
1094 #endif
1095 
1096 #if LLVM_ENABLE_ZLIB
1097  if (avail_type == CompressionType::None) {
1098  for (auto compression : supported_compressions) {
1099  if (compression == "zlib-deflate") {
1100  avail_type = CompressionType::ZlibDeflate;
1101  avail_name = compression;
1102  break;
1103  }
1104  }
1105  }
1106 #endif
1107 
1108 #if defined(HAVE_LIBCOMPRESSION)
1109  if (avail_type == CompressionType::None) {
1110  for (auto compression : supported_compressions) {
1111  if (compression == "lz4") {
1112  avail_type = CompressionType::LZ4;
1113  avail_name = compression;
1114  break;
1115  }
1116  }
1117  }
1118 #endif
1119 
1120 #if defined(HAVE_LIBCOMPRESSION)
1121  if (avail_type == CompressionType::None) {
1122  for (auto compression : supported_compressions) {
1123  if (compression == "lzma") {
1124  avail_type = CompressionType::LZMA;
1125  avail_name = compression;
1126  break;
1127  }
1128  }
1129  }
1130 #endif
1131 
1132  if (avail_type != CompressionType::None) {
1133  StringExtractorGDBRemote response;
1134  std::string packet = "QEnableCompression:type:" + avail_name.str() + ";";
1135  if (SendPacketAndWaitForResponse(packet, response) != PacketResult::Success)
1136  return;
1137 
1138  if (response.IsOKResponse()) {
1139  m_compression_type = avail_type;
1140  }
1141  }
1142 }
1143 
1145  if (GetGDBServerVersion()) {
1146  if (!m_gdb_server_name.empty())
1147  return m_gdb_server_name.c_str();
1148  }
1149  return nullptr;
1150 }
1151 
1153  if (GetGDBServerVersion())
1154  return m_gdb_server_version;
1155  return 0;
1156 }
1157 
1159  StringExtractorGDBRemote response;
1160  if (SendPacketAndWaitForResponse("qC", response) != PacketResult::Success)
1161  return false;
1162 
1163  if (!response.IsNormalResponse())
1164  return false;
1165 
1166  if (response.GetChar() == 'Q' && response.GetChar() == 'C') {
1167  auto pid_tid = response.GetPidTid(0);
1168  if (!pid_tid)
1169  return false;
1170 
1171  lldb::pid_t pid = pid_tid->first;
1172  // invalid
1174  return false;
1175 
1176  // if we get pid as well, update m_curr_pid
1177  if (pid != 0) {
1178  m_curr_pid_run = m_curr_pid = pid;
1180  }
1181  tid = pid_tid->second;
1182  }
1183 
1184  return true;
1185 }
1186 
1187 static void ParseOSType(llvm::StringRef value, std::string &os_name,
1188  std::string &environment) {
1189  if (value.equals("iossimulator") || value.equals("tvossimulator") ||
1190  value.equals("watchossimulator")) {
1191  environment = "simulator";
1192  os_name = value.drop_back(environment.size()).str();
1193  } else if (value.equals("maccatalyst")) {
1194  os_name = "ios";
1195  environment = "macabi";
1196  } else {
1197  os_name = value.str();
1198  }
1199 }
1200 
1202  Log *log = GetLog(GDBRLog::Process);
1203 
1204  if (force || m_qHostInfo_is_valid == eLazyBoolCalculate) {
1205  // host info computation can require DNS traffic and shelling out to external processes.
1206  // Increase the timeout to account for that.
1207  ScopedTimeout timeout(*this, seconds(10));
1209  StringExtractorGDBRemote response;
1210  if (SendPacketAndWaitForResponse("qHostInfo", response) ==
1212  if (response.IsNormalResponse()) {
1213  llvm::StringRef name;
1214  llvm::StringRef value;
1216  uint32_t sub = 0;
1217  std::string arch_name;
1218  std::string os_name;
1219  std::string environment;
1220  std::string vendor_name;
1221  std::string triple;
1222  std::string distribution_id;
1223  uint32_t pointer_byte_size = 0;
1224  ByteOrder byte_order = eByteOrderInvalid;
1225  uint32_t num_keys_decoded = 0;
1226  while (response.GetNameColonValue(name, value)) {
1227  if (name.equals("cputype")) {
1228  // exception type in big endian hex
1229  if (!value.getAsInteger(0, cpu))
1230  ++num_keys_decoded;
1231  } else if (name.equals("cpusubtype")) {
1232  // exception count in big endian hex
1233  if (!value.getAsInteger(0, sub))
1234  ++num_keys_decoded;
1235  } else if (name.equals("arch")) {
1236  arch_name = std::string(value);
1237  ++num_keys_decoded;
1238  } else if (name.equals("triple")) {
1239  StringExtractor extractor(value);
1240  extractor.GetHexByteString(triple);
1241  ++num_keys_decoded;
1242  } else if (name.equals("distribution_id")) {
1243  StringExtractor extractor(value);
1244  extractor.GetHexByteString(distribution_id);
1245  ++num_keys_decoded;
1246  } else if (name.equals("os_build")) {
1247  StringExtractor extractor(value);
1248  extractor.GetHexByteString(m_os_build);
1249  ++num_keys_decoded;
1250  } else if (name.equals("hostname")) {
1251  StringExtractor extractor(value);
1252  extractor.GetHexByteString(m_hostname);
1253  ++num_keys_decoded;
1254  } else if (name.equals("os_kernel")) {
1255  StringExtractor extractor(value);
1256  extractor.GetHexByteString(m_os_kernel);
1257  ++num_keys_decoded;
1258  } else if (name.equals("ostype")) {
1259  ParseOSType(value, os_name, environment);
1260  ++num_keys_decoded;
1261  } else if (name.equals("vendor")) {
1262  vendor_name = std::string(value);
1263  ++num_keys_decoded;
1264  } else if (name.equals("endian")) {
1265  byte_order = llvm::StringSwitch<lldb::ByteOrder>(value)
1266  .Case("little", eByteOrderLittle)
1267  .Case("big", eByteOrderBig)
1268  .Case("pdp", eByteOrderPDP)
1269  .Default(eByteOrderInvalid);
1270  if (byte_order != eByteOrderInvalid)
1271  ++num_keys_decoded;
1272  } else if (name.equals("ptrsize")) {
1273  if (!value.getAsInteger(0, pointer_byte_size))
1274  ++num_keys_decoded;
1275  } else if (name.equals("addressing_bits")) {
1276  if (!value.getAsInteger(0, m_addressing_bits))
1277  ++num_keys_decoded;
1278  } else if (name.equals("os_version") ||
1279  name.equals("version")) // Older debugserver binaries used
1280  // the "version" key instead of
1281  // "os_version"...
1282  {
1283  if (!m_os_version.tryParse(value))
1284  ++num_keys_decoded;
1285  } else if (name.equals("maccatalyst_version")) {
1286  if (!m_maccatalyst_version.tryParse(value))
1287  ++num_keys_decoded;
1288  } else if (name.equals("watchpoint_exceptions_received")) {
1290  llvm::StringSwitch<LazyBool>(value)
1291  .Case("before", eLazyBoolNo)
1292  .Case("after", eLazyBoolYes)
1293  .Default(eLazyBoolCalculate);
1295  ++num_keys_decoded;
1296  } else if (name.equals("default_packet_timeout")) {
1297  uint32_t timeout_seconds;
1298  if (!value.getAsInteger(0, timeout_seconds)) {
1299  m_default_packet_timeout = seconds(timeout_seconds);
1301  ++num_keys_decoded;
1302  }
1303  } else if (name.equals("vm-page-size")) {
1304  int page_size;
1305  if (!value.getAsInteger(0, page_size)) {
1306  m_target_vm_page_size = page_size;
1307  ++num_keys_decoded;
1308  }
1309  }
1310  }
1311 
1312  if (num_keys_decoded > 0)
1314 
1315  if (triple.empty()) {
1316  if (arch_name.empty()) {
1317  if (cpu != LLDB_INVALID_CPUTYPE) {
1319  if (pointer_byte_size) {
1320  assert(pointer_byte_size == m_host_arch.GetAddressByteSize());
1321  }
1322  if (byte_order != eByteOrderInvalid) {
1323  assert(byte_order == m_host_arch.GetByteOrder());
1324  }
1325 
1326  if (!vendor_name.empty())
1327  m_host_arch.GetTriple().setVendorName(
1328  llvm::StringRef(vendor_name));
1329  if (!os_name.empty())
1330  m_host_arch.GetTriple().setOSName(llvm::StringRef(os_name));
1331  if (!environment.empty())
1332  m_host_arch.GetTriple().setEnvironmentName(environment);
1333  }
1334  } else {
1335  std::string triple;
1336  triple += arch_name;
1337  if (!vendor_name.empty() || !os_name.empty()) {
1338  triple += '-';
1339  if (vendor_name.empty())
1340  triple += "unknown";
1341  else
1342  triple += vendor_name;
1343  triple += '-';
1344  if (os_name.empty())
1345  triple += "unknown";
1346  else
1347  triple += os_name;
1348  }
1349  m_host_arch.SetTriple(triple.c_str());
1350 
1351  llvm::Triple &host_triple = m_host_arch.GetTriple();
1352  if (host_triple.getVendor() == llvm::Triple::Apple &&
1353  host_triple.getOS() == llvm::Triple::Darwin) {
1354  switch (m_host_arch.GetMachine()) {
1355  case llvm::Triple::aarch64:
1356  case llvm::Triple::aarch64_32:
1357  case llvm::Triple::arm:
1358  case llvm::Triple::thumb:
1359  host_triple.setOS(llvm::Triple::IOS);
1360  break;
1361  default:
1362  host_triple.setOS(llvm::Triple::MacOSX);
1363  break;
1364  }
1365  }
1366  if (pointer_byte_size) {
1367  assert(pointer_byte_size == m_host_arch.GetAddressByteSize());
1368  }
1369  if (byte_order != eByteOrderInvalid) {
1370  assert(byte_order == m_host_arch.GetByteOrder());
1371  }
1372  }
1373  } else {
1374  m_host_arch.SetTriple(triple.c_str());
1375  if (pointer_byte_size) {
1376  assert(pointer_byte_size == m_host_arch.GetAddressByteSize());
1377  }
1378  if (byte_order != eByteOrderInvalid) {
1379  assert(byte_order == m_host_arch.GetByteOrder());
1380  }
1381 
1382  LLDB_LOGF(log,
1383  "GDBRemoteCommunicationClient::%s parsed host "
1384  "architecture as %s, triple as %s from triple text %s",
1385  __FUNCTION__,
1388  : "<null-arch-name>",
1389  m_host_arch.GetTriple().getTriple().c_str(),
1390  triple.c_str());
1391  }
1392  if (!distribution_id.empty())
1393  m_host_arch.SetDistributionId(distribution_id.c_str());
1394  }
1395  }
1396  }
1398 }
1399 
1401  size_t data_len) {
1402  StreamString packet;
1403  packet.PutCString("I");
1404  packet.PutBytesAsRawHex8(data, data_len);
1405  StringExtractorGDBRemote response;
1406  if (SendPacketAndWaitForResponse(packet.GetString(), response) ==
1408  return 0;
1409  }
1410  return response.GetError();
1411 }
1412 
1413 const lldb_private::ArchSpec &
1416  GetHostInfo();
1417  return m_host_arch;
1418 }
1419 
1422  GetHostInfo();
1423  return m_addressing_bits;
1424 }
1427  GetHostInfo();
1428  return m_default_packet_timeout;
1429 }
1430 
1432  uint32_t permissions) {
1435  char packet[64];
1436  const int packet_len = ::snprintf(
1437  packet, sizeof(packet), "_M%" PRIx64 ",%s%s%s", (uint64_t)size,
1438  permissions & lldb::ePermissionsReadable ? "r" : "",
1439  permissions & lldb::ePermissionsWritable ? "w" : "",
1440  permissions & lldb::ePermissionsExecutable ? "x" : "");
1441  assert(packet_len < (int)sizeof(packet));
1442  UNUSED_IF_ASSERT_DISABLED(packet_len);
1443  StringExtractorGDBRemote response;
1444  if (SendPacketAndWaitForResponse(packet, response) ==
1446  if (response.IsUnsupportedResponse())
1448  else if (!response.IsErrorResponse())
1449  return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
1450  } else {
1452  }
1453  }
1454  return LLDB_INVALID_ADDRESS;
1455 }
1456 
1460  char packet[64];
1461  const int packet_len =
1462  ::snprintf(packet, sizeof(packet), "_m%" PRIx64, (uint64_t)addr);
1463  assert(packet_len < (int)sizeof(packet));
1464  UNUSED_IF_ASSERT_DISABLED(packet_len);
1465  StringExtractorGDBRemote response;
1466  if (SendPacketAndWaitForResponse(packet, response) ==
1468  if (response.IsUnsupportedResponse())
1470  else if (response.IsOKResponse())
1471  return true;
1472  } else {
1474  }
1475  }
1476  return false;
1477 }
1478 
1480  lldb::pid_t pid) {
1481  Status error;
1483 
1484  packet.PutChar('D');
1485  if (keep_stopped) {
1487  char packet[64];
1488  const int packet_len =
1489  ::snprintf(packet, sizeof(packet), "qSupportsDetachAndStayStopped:");
1490  assert(packet_len < (int)sizeof(packet));
1491  UNUSED_IF_ASSERT_DISABLED(packet_len);
1492  StringExtractorGDBRemote response;
1493  if (SendPacketAndWaitForResponse(packet, response) ==
1495  response.IsOKResponse()) {
1497  } else {
1499  }
1500  }
1501 
1503  error.SetErrorString("Stays stopped not supported by this target.");
1504  return error;
1505  } else {
1506  packet.PutChar('1');
1507  }
1508  }
1509 
1511  // Some servers (e.g. qemu) require specifying the PID even if only a single
1512  // process is running.
1513  if (pid == LLDB_INVALID_PROCESS_ID)
1514  pid = GetCurrentProcessID();
1515  packet.PutChar(';');
1516  packet.PutHex64(pid);
1517  } else if (pid != LLDB_INVALID_PROCESS_ID) {
1518  error.SetErrorString("Multiprocess extension not supported by the server.");
1519  return error;
1520  }
1521 
1522  StringExtractorGDBRemote response;
1523  PacketResult packet_result =
1524  SendPacketAndWaitForResponse(packet.GetString(), response);
1525  if (packet_result != PacketResult::Success)
1526  error.SetErrorString("Sending isconnect packet failed.");
1527  return error;
1528 }
1529 
1531  lldb::addr_t addr, lldb_private::MemoryRegionInfo &region_info) {
1532  Status error;
1533  region_info.Clear();
1534 
1537  char packet[64];
1538  const int packet_len = ::snprintf(
1539  packet, sizeof(packet), "qMemoryRegionInfo:%" PRIx64, (uint64_t)addr);
1540  assert(packet_len < (int)sizeof(packet));
1541  UNUSED_IF_ASSERT_DISABLED(packet_len);
1542  StringExtractorGDBRemote response;
1543  if (SendPacketAndWaitForResponse(packet, response) ==
1546  llvm::StringRef name;
1547  llvm::StringRef value;
1548  addr_t addr_value = LLDB_INVALID_ADDRESS;
1549  bool success = true;
1550  bool saw_permissions = false;
1551  while (success && response.GetNameColonValue(name, value)) {
1552  if (name.equals("start")) {
1553  if (!value.getAsInteger(16, addr_value))
1554  region_info.GetRange().SetRangeBase(addr_value);
1555  } else if (name.equals("size")) {
1556  if (!value.getAsInteger(16, addr_value))
1557  region_info.GetRange().SetByteSize(addr_value);
1558  } else if (name.equals("permissions") &&
1559  region_info.GetRange().IsValid()) {
1560  saw_permissions = true;
1561  if (region_info.GetRange().Contains(addr)) {
1562  if (value.contains('r'))
1563  region_info.SetReadable(MemoryRegionInfo::eYes);
1564  else
1565  region_info.SetReadable(MemoryRegionInfo::eNo);
1566 
1567  if (value.contains('w'))
1568  region_info.SetWritable(MemoryRegionInfo::eYes);
1569  else
1570  region_info.SetWritable(MemoryRegionInfo::eNo);
1571 
1572  if (value.contains('x'))
1574  else
1575  region_info.SetExecutable(MemoryRegionInfo::eNo);
1576 
1577  region_info.SetMapped(MemoryRegionInfo::eYes);
1578  } else {
1579  // The reported region does not contain this address -- we're
1580  // looking at an unmapped page
1581  region_info.SetReadable(MemoryRegionInfo::eNo);
1582  region_info.SetWritable(MemoryRegionInfo::eNo);
1583  region_info.SetExecutable(MemoryRegionInfo::eNo);
1584  region_info.SetMapped(MemoryRegionInfo::eNo);
1585  }
1586  } else if (name.equals("name")) {
1587  StringExtractorGDBRemote name_extractor(value);
1588  std::string name;
1589  name_extractor.GetHexByteString(name);
1590  region_info.SetName(name.c_str());
1591  } else if (name.equals("flags")) {
1593 
1594  llvm::StringRef flags = value;
1595  llvm::StringRef flag;
1596  while (flags.size()) {
1597  flags = flags.ltrim();
1598  std::tie(flag, flags) = flags.split(' ');
1599  // To account for trailing whitespace
1600  if (flag.size()) {
1601  if (flag == "mt") {
1603  break;
1604  }
1605  }
1606  }
1607  } else if (name.equals("type")) {
1608  std::string comma_sep_str = value.str();
1609  size_t comma_pos;
1610  while ((comma_pos = comma_sep_str.find(',')) != std::string::npos) {
1611  comma_sep_str[comma_pos] = '\0';
1612  if (comma_sep_str == "stack") {
1614  }
1615  }
1616  // handle final (or only) type of "stack"
1617  if (comma_sep_str == "stack") {
1619  }
1620  } else if (name.equals("error")) {
1621  StringExtractorGDBRemote error_extractor(value);
1622  std::string error_string;
1623  // Now convert the HEX bytes into a string value
1624  error_extractor.GetHexByteString(error_string);
1625  error.SetErrorString(error_string.c_str());
1626  } else if (name.equals("dirty-pages")) {
1627  std::vector<addr_t> dirty_page_list;
1628  for (llvm::StringRef x : llvm::split(value, ',')) {
1629  addr_t page;
1630  x.consume_front("0x");
1631  if (llvm::to_integer(x, page, 16))
1632  dirty_page_list.push_back(page);
1633  }
1634  region_info.SetDirtyPageList(dirty_page_list);
1635  }
1636  }
1637 
1638  if (m_target_vm_page_size != 0)
1639  region_info.SetPageSize(m_target_vm_page_size);
1640 
1641  if (region_info.GetRange().IsValid()) {
1642  // We got a valid address range back but no permissions -- which means
1643  // this is an unmapped page
1644  if (!saw_permissions) {
1645  region_info.SetReadable(MemoryRegionInfo::eNo);
1646  region_info.SetWritable(MemoryRegionInfo::eNo);
1647  region_info.SetExecutable(MemoryRegionInfo::eNo);
1648  region_info.SetMapped(MemoryRegionInfo::eNo);
1649  }
1650  } else {
1651  // We got an invalid address range back
1652  error.SetErrorString("Server returned invalid range");
1653  }
1654  } else {
1656  }
1657  }
1658 
1660  error.SetErrorString("qMemoryRegionInfo is not supported");
1661  }
1662 
1663  // Try qXfer:memory-map:read to get region information not included in
1664  // qMemoryRegionInfo
1665  MemoryRegionInfo qXfer_region_info;
1666  Status qXfer_error = GetQXferMemoryMapRegionInfo(addr, qXfer_region_info);
1667 
1668  if (error.Fail()) {
1669  // If qMemoryRegionInfo failed, but qXfer:memory-map:read succeeded, use
1670  // the qXfer result as a fallback
1671  if (qXfer_error.Success()) {
1672  region_info = qXfer_region_info;
1673  error.Clear();
1674  } else {
1675  region_info.Clear();
1676  }
1677  } else if (qXfer_error.Success()) {
1678  // If both qMemoryRegionInfo and qXfer:memory-map:read succeeded, and if
1679  // both regions are the same range, update the result to include the flash-
1680  // memory information that is specific to the qXfer result.
1681  if (region_info.GetRange() == qXfer_region_info.GetRange()) {
1682  region_info.SetFlash(qXfer_region_info.GetFlash());
1683  region_info.SetBlocksize(qXfer_region_info.GetBlocksize());
1684  }
1685  }
1686  return error;
1687 }
1688 
1690  lldb::addr_t addr, MemoryRegionInfo &region) {
1692  if (!error.Success())
1693  return error;
1694  for (const auto &map_region : m_qXfer_memory_map) {
1695  if (map_region.GetRange().Contains(addr)) {
1696  region = map_region;
1697  return error;
1698  }
1699  }
1700  error.SetErrorString("Region not found");
1701  return error;
1702 }
1703 
1705 
1706  Status error;
1707 
1709  // Already loaded, return success
1710  return error;
1711 
1712  if (!XMLDocument::XMLEnabled()) {
1713  error.SetErrorString("XML is not supported");
1714  return error;
1715  }
1716 
1718  error.SetErrorString("Memory map is not supported");
1719  return error;
1720  }
1721 
1722  llvm::Expected<std::string> xml = ReadExtFeature("memory-map", "");
1723  if (!xml)
1724  return Status(xml.takeError());
1725 
1726  XMLDocument xml_document;
1727 
1728  if (!xml_document.ParseMemory(xml->c_str(), xml->size())) {
1729  error.SetErrorString("Failed to parse memory map xml");
1730  return error;
1731  }
1732 
1733  XMLNode map_node = xml_document.GetRootElement("memory-map");
1734  if (!map_node) {
1735  error.SetErrorString("Invalid root node in memory map xml");
1736  return error;
1737  }
1738 
1739  m_qXfer_memory_map.clear();
1740 
1741  map_node.ForEachChildElement([this](const XMLNode &memory_node) -> bool {
1742  if (!memory_node.IsElement())
1743  return true;
1744  if (memory_node.GetName() != "memory")
1745  return true;
1746  auto type = memory_node.GetAttributeValue("type", "");
1747  uint64_t start;
1748  uint64_t length;
1749  if (!memory_node.GetAttributeValueAsUnsigned("start", start))
1750  return true;
1751  if (!memory_node.GetAttributeValueAsUnsigned("length", length))
1752  return true;
1753  MemoryRegionInfo region;
1754  region.GetRange().SetRangeBase(start);
1755  region.GetRange().SetByteSize(length);
1756  if (type == "rom") {
1757  region.SetReadable(MemoryRegionInfo::eYes);
1758  this->m_qXfer_memory_map.push_back(region);
1759  } else if (type == "ram") {
1760  region.SetReadable(MemoryRegionInfo::eYes);
1761  region.SetWritable(MemoryRegionInfo::eYes);
1762  this->m_qXfer_memory_map.push_back(region);
1763  } else if (type == "flash") {
1764  region.SetFlash(MemoryRegionInfo::eYes);
1765  memory_node.ForEachChildElement(
1766  [&region](const XMLNode &prop_node) -> bool {
1767  if (!prop_node.IsElement())
1768  return true;
1769  if (prop_node.GetName() != "property")
1770  return true;
1771  auto propname = prop_node.GetAttributeValue("name", "");
1772  if (propname == "blocksize") {
1773  uint64_t blocksize;
1774  if (prop_node.GetElementTextAsUnsigned(blocksize))
1775  region.SetBlocksize(blocksize);
1776  }
1777  return true;
1778  });
1779  this->m_qXfer_memory_map.push_back(region);
1780  }
1781  return true;
1782  });
1783 
1785 
1786  return error;
1787 }
1788 
1790  Status error;
1791 
1794  return error;
1795  }
1796 
1797  // Set num to 0 first.
1798  num = 0;
1800  StringExtractorGDBRemote response;
1801  if (SendPacketAndWaitForResponse("qWatchpointSupportInfo:", response) ==
1804  llvm::StringRef name;
1805  llvm::StringRef value;
1806  bool found_num_field = false;
1807  while (response.GetNameColonValue(name, value)) {
1808  if (name.equals("num")) {
1809  value.getAsInteger(0, m_num_supported_hardware_watchpoints);
1811  found_num_field = true;
1812  }
1813  }
1814  if (!found_num_field) {
1816  }
1817  } else {
1819  }
1820  }
1821 
1823  error.SetErrorString("qWatchpointSupportInfo is not supported");
1824  }
1825  return error;
1826 }
1827 
1829  uint32_t &num, bool &after, const ArchSpec &arch) {
1831  if (error.Success())
1833  return error;
1834 }
1835 
1838  bool &after, const ArchSpec &arch) {
1839  Status error;
1840  llvm::Triple triple = arch.GetTriple();
1841 
1842  // we assume watchpoints will happen after running the relevant opcode and we
1843  // only want to override this behavior if we have explicitly received a
1844  // qHostInfo telling us otherwise
1846  // On targets like MIPS and ppc64, watchpoint exceptions are always
1847  // generated before the instruction is executed. The connected target may
1848  // not support qHostInfo or qWatchpointSupportInfo packets.
1849  after = !(triple.isMIPS() || triple.isPPC64());
1850  } else {
1851  // For MIPS and ppc64, set m_watchpoints_trigger_after_instruction to
1852  // eLazyBoolNo if it is not calculated before.
1854  (triple.isMIPS() || triple.isPPC64()))
1856 
1858  }
1859  return error;
1860 }
1861 
1863  if (file_spec) {
1864  std::string path{file_spec.GetPath(false)};
1865  StreamString packet;
1866  packet.PutCString("QSetSTDIN:");
1867  packet.PutStringAsRawHex8(path);
1868 
1869  StringExtractorGDBRemote response;
1870  if (SendPacketAndWaitForResponse(packet.GetString(), response) ==
1872  if (response.IsOKResponse())
1873  return 0;
1874  uint8_t error = response.GetError();
1875  if (error)
1876  return error;
1877  }
1878  }
1879  return -1;
1880 }
1881 
1883  if (file_spec) {
1884  std::string path{file_spec.GetPath(false)};
1885  StreamString packet;
1886  packet.PutCString("QSetSTDOUT:");
1887  packet.PutStringAsRawHex8(path);
1888 
1889  StringExtractorGDBRemote response;
1890  if (SendPacketAndWaitForResponse(packet.GetString(), response) ==
1892  if (response.IsOKResponse())
1893  return 0;
1894  uint8_t error = response.GetError();
1895  if (error)
1896  return error;
1897  }
1898  }
1899  return -1;
1900 }
1901 
1903  if (file_spec) {
1904  std::string path{file_spec.GetPath(false)};
1905  StreamString packet;
1906  packet.PutCString("QSetSTDERR:");
1907  packet.PutStringAsRawHex8(path);
1908 
1909  StringExtractorGDBRemote response;
1910  if (SendPacketAndWaitForResponse(packet.GetString(), response) ==
1912  if (response.IsOKResponse())
1913  return 0;
1914  uint8_t error = response.GetError();
1915  if (error)
1916  return error;
1917  }
1918  }
1919  return -1;
1920 }
1921 
1923  StringExtractorGDBRemote response;
1924  if (SendPacketAndWaitForResponse("qGetWorkingDir", response) ==
1926  if (response.IsUnsupportedResponse())
1927  return false;
1928  if (response.IsErrorResponse())
1929  return false;
1930  std::string cwd;
1931  response.GetHexByteString(cwd);
1932  working_dir.SetFile(cwd, GetHostArchitecture().GetTriple());
1933  return !cwd.empty();
1934  }
1935  return false;
1936 }
1937 
1939  if (working_dir) {
1940  std::string path{working_dir.GetPath(false)};
1941  StreamString packet;
1942  packet.PutCString("QSetWorkingDir:");
1943  packet.PutStringAsRawHex8(path);
1944 
1945  StringExtractorGDBRemote response;
1946  if (SendPacketAndWaitForResponse(packet.GetString(), response) ==
1948  if (response.IsOKResponse())
1949  return 0;
1950  uint8_t error = response.GetError();
1951  if (error)
1952  return error;
1953  }
1954  }
1955  return -1;
1956 }
1957 
1959  char packet[32];
1960  const int packet_len =
1961  ::snprintf(packet, sizeof(packet), "QSetDisableASLR:%i", enable ? 1 : 0);
1962  assert(packet_len < (int)sizeof(packet));
1963  UNUSED_IF_ASSERT_DISABLED(packet_len);
1964  StringExtractorGDBRemote response;
1965  if (SendPacketAndWaitForResponse(packet, response) == PacketResult::Success) {
1966  if (response.IsOKResponse())
1967  return 0;
1968  uint8_t error = response.GetError();
1969  if (error)
1970  return error;
1971  }
1972  return -1;
1973 }
1974 
1976  char packet[32];
1977  const int packet_len = ::snprintf(packet, sizeof(packet),
1978  "QSetDetachOnError:%i", enable ? 1 : 0);
1979  assert(packet_len < (int)sizeof(packet));
1980  UNUSED_IF_ASSERT_DISABLED(packet_len);
1981  StringExtractorGDBRemote response;
1982  if (SendPacketAndWaitForResponse(packet, response) == PacketResult::Success) {
1983  if (response.IsOKResponse())
1984  return 0;
1985  uint8_t error = response.GetError();
1986  if (error)
1987  return error;
1988  }
1989  return -1;
1990 }
1991 
1993  StringExtractorGDBRemote &response, ProcessInstanceInfo &process_info) {
1994  if (response.IsNormalResponse()) {
1995  llvm::StringRef name;
1996  llvm::StringRef value;
1997  StringExtractor extractor;
1998 
2000  uint32_t sub = 0;
2001  std::string vendor;
2002  std::string os_type;
2003 
2004  while (response.GetNameColonValue(name, value)) {
2005  if (name.equals("pid")) {
2007  value.getAsInteger(0, pid);
2008  process_info.SetProcessID(pid);
2009  } else if (name.equals("ppid")) {
2011  value.getAsInteger(0, pid);
2012  process_info.SetParentProcessID(pid);
2013  } else if (name.equals("uid")) {
2014  uint32_t uid = UINT32_MAX;
2015  value.getAsInteger(0, uid);
2016  process_info.SetUserID(uid);
2017  } else if (name.equals("euid")) {
2018  uint32_t uid = UINT32_MAX;
2019  value.getAsInteger(0, uid);
2020  process_info.SetEffectiveUserID(uid);
2021  } else if (name.equals("gid")) {
2022  uint32_t gid = UINT32_MAX;
2023  value.getAsInteger(0, gid);
2024  process_info.SetGroupID(gid);
2025  } else if (name.equals("egid")) {
2026  uint32_t gid = UINT32_MAX;
2027  value.getAsInteger(0, gid);
2028  process_info.SetEffectiveGroupID(gid);
2029  } else if (name.equals("triple")) {
2030  StringExtractor extractor(value);
2031  std::string triple;
2032  extractor.GetHexByteString(triple);
2033  process_info.GetArchitecture().SetTriple(triple.c_str());
2034  } else if (name.equals("name")) {
2035  StringExtractor extractor(value);
2036  // The process name from ASCII hex bytes since we can't control the
2037  // characters in a process name
2038  std::string name;
2039  extractor.GetHexByteString(name);
2040  process_info.GetExecutableFile().SetFile(name, FileSpec::Style::native);
2041  } else if (name.equals("args")) {
2042  llvm::StringRef encoded_args(value), hex_arg;
2043 
2044  bool is_arg0 = true;
2045  while (!encoded_args.empty()) {
2046  std::tie(hex_arg, encoded_args) = encoded_args.split('-');
2047  std::string arg;
2048  StringExtractor extractor(hex_arg);
2049  if (extractor.GetHexByteString(arg) * 2 != hex_arg.size()) {
2050  // In case of wrong encoding, we discard all the arguments
2051  process_info.GetArguments().Clear();
2052  process_info.SetArg0("");
2053  break;
2054  }
2055  if (is_arg0)
2056  process_info.SetArg0(arg);
2057  else
2058  process_info.GetArguments().AppendArgument(arg);
2059  is_arg0 = false;
2060  }
2061  } else if (name.equals("cputype")) {
2062  value.getAsInteger(0, cpu);
2063  } else if (name.equals("cpusubtype")) {
2064  value.getAsInteger(0, sub);
2065  } else if (name.equals("vendor")) {
2066  vendor = std::string(value);
2067  } else if (name.equals("ostype")) {
2068  os_type = std::string(value);
2069  }
2070  }
2071 
2072  if (cpu != LLDB_INVALID_CPUTYPE && !vendor.empty() && !os_type.empty()) {
2073  if (vendor == "apple") {
2074  process_info.GetArchitecture().SetArchitecture(eArchTypeMachO, cpu,
2075  sub);
2076  process_info.GetArchitecture().GetTriple().setVendorName(
2077  llvm::StringRef(vendor));
2078  process_info.GetArchitecture().GetTriple().setOSName(
2079  llvm::StringRef(os_type));
2080  }
2081  }
2082 
2083  if (process_info.GetProcessID() != LLDB_INVALID_PROCESS_ID)
2084  return true;
2085  }
2086  return false;
2087 }
2088 
2090  lldb::pid_t pid, ProcessInstanceInfo &process_info) {
2091  process_info.Clear();
2092 
2094  char packet[32];
2095  const int packet_len =
2096  ::snprintf(packet, sizeof(packet), "qProcessInfoPID:%" PRIu64, pid);
2097  assert(packet_len < (int)sizeof(packet));
2098  UNUSED_IF_ASSERT_DISABLED(packet_len);
2099  StringExtractorGDBRemote response;
2100  if (SendPacketAndWaitForResponse(packet, response) ==
2102  return DecodeProcessInfoResponse(response, process_info);
2103  } else {
2105  return false;
2106  }
2107  }
2108  return false;
2109 }
2110 
2113 
2114  if (allow_lazy) {
2116  return true;
2118  return false;
2119  }
2120 
2121  GetHostInfo();
2122 
2123  StringExtractorGDBRemote response;
2124  if (SendPacketAndWaitForResponse("qProcessInfo", response) ==
2126  if (response.IsNormalResponse()) {
2127  llvm::StringRef name;
2128  llvm::StringRef value;
2130  uint32_t sub = 0;
2131  std::string arch_name;
2132  std::string os_name;
2133  std::string environment;
2134  std::string vendor_name;
2135  std::string triple;
2136  std::string elf_abi;
2137  uint32_t pointer_byte_size = 0;
2138  StringExtractor extractor;
2139  ByteOrder byte_order = eByteOrderInvalid;
2140  uint32_t num_keys_decoded = 0;
2142  while (response.GetNameColonValue(name, value)) {
2143  if (name.equals("cputype")) {
2144  if (!value.getAsInteger(16, cpu))
2145  ++num_keys_decoded;
2146  } else if (name.equals("cpusubtype")) {
2147  if (!value.getAsInteger(16, sub))
2148  ++num_keys_decoded;
2149  } else if (name.equals("triple")) {
2150  StringExtractor extractor(value);
2151  extractor.GetHexByteString(triple);
2152  ++num_keys_decoded;
2153  } else if (name.equals("ostype")) {
2154  ParseOSType(value, os_name, environment);
2155  ++num_keys_decoded;
2156  } else if (name.equals("vendor")) {
2157  vendor_name = std::string(value);
2158  ++num_keys_decoded;
2159  } else if (name.equals("endian")) {
2160  byte_order = llvm::StringSwitch<lldb::ByteOrder>(value)
2161  .Case("little", eByteOrderLittle)
2162  .Case("big", eByteOrderBig)
2163  .Case("pdp", eByteOrderPDP)
2164  .Default(eByteOrderInvalid);
2165  if (byte_order != eByteOrderInvalid)
2166  ++num_keys_decoded;
2167  } else if (name.equals("ptrsize")) {
2168  if (!value.getAsInteger(16, pointer_byte_size))
2169  ++num_keys_decoded;
2170  } else if (name.equals("pid")) {
2171  if (!value.getAsInteger(16, pid))
2172  ++num_keys_decoded;
2173  } else if (name.equals("elf_abi")) {
2174  elf_abi = std::string(value);
2175  ++num_keys_decoded;
2176  } else if (name.equals("main-binary-uuid")) {
2178  ++num_keys_decoded;
2179  } else if (name.equals("main-binary-slide")) {
2180  StringExtractor extractor(value);
2182  extractor.GetU64(LLDB_INVALID_ADDRESS, 16);
2185  ++num_keys_decoded;
2186  }
2187  } else if (name.equals("main-binary-address")) {
2188  StringExtractor extractor(value);
2190  extractor.GetU64(LLDB_INVALID_ADDRESS, 16);
2193  ++num_keys_decoded;
2194  }
2195  }
2196  }
2197  if (num_keys_decoded > 0)
2199  if (pid != LLDB_INVALID_PROCESS_ID) {
2201  m_curr_pid_run = m_curr_pid = pid;
2202  }
2203 
2204  // Set the ArchSpec from the triple if we have it.
2205  if (!triple.empty()) {
2206  m_process_arch.SetTriple(triple.c_str());
2207  m_process_arch.SetFlags(elf_abi);
2208  if (pointer_byte_size) {
2209  assert(pointer_byte_size == m_process_arch.GetAddressByteSize());
2210  }
2211  } else if (cpu != LLDB_INVALID_CPUTYPE && !os_name.empty() &&
2212  !vendor_name.empty()) {
2213  llvm::Triple triple(llvm::Twine("-") + vendor_name + "-" + os_name);
2214  if (!environment.empty())
2215  triple.setEnvironmentName(environment);
2216 
2217  assert(triple.getObjectFormat() != llvm::Triple::UnknownObjectFormat);
2218  assert(triple.getObjectFormat() != llvm::Triple::Wasm);
2219  assert(triple.getObjectFormat() != llvm::Triple::XCOFF);
2220  switch (triple.getObjectFormat()) {
2221  case llvm::Triple::MachO:
2223  break;
2224  case llvm::Triple::ELF:
2226  break;
2227  case llvm::Triple::COFF:
2229  break;
2230  case llvm::Triple::GOFF:
2231  case llvm::Triple::SPIRV:
2232  case llvm::Triple::Wasm:
2233  case llvm::Triple::XCOFF:
2234  case llvm::Triple::DXContainer:
2235  LLDB_LOGF(log, "error: not supported target architecture");
2236  return false;
2237  case llvm::Triple::UnknownObjectFormat:
2238  LLDB_LOGF(log, "error: failed to determine target architecture");
2239  return false;
2240  }
2241 
2242  if (pointer_byte_size) {
2243  assert(pointer_byte_size == m_process_arch.GetAddressByteSize());
2244  }
2245  if (byte_order != eByteOrderInvalid) {
2246  assert(byte_order == m_process_arch.GetByteOrder());
2247  }
2248  m_process_arch.GetTriple().setVendorName(llvm::StringRef(vendor_name));
2249  m_process_arch.GetTriple().setOSName(llvm::StringRef(os_name));
2250  m_process_arch.GetTriple().setEnvironmentName(llvm::StringRef(environment));
2251  }
2252  return true;
2253  }
2254  } else {
2256  }
2257 
2258  return false;
2259 }
2260 
2262  const ProcessInstanceInfoMatch &match_info,
2263  ProcessInstanceInfoList &process_infos) {
2264  process_infos.clear();
2265 
2267  StreamString packet;
2268  packet.PutCString("qfProcessInfo");
2269  if (!match_info.MatchAllProcesses()) {
2270  packet.PutChar(':');
2271  const char *name = match_info.GetProcessInfo().GetName();
2272  bool has_name_match = false;
2273  if (name && name[0]) {
2274  has_name_match = true;
2275  NameMatch name_match_type = match_info.GetNameMatchType();
2276  switch (name_match_type) {
2277  case NameMatch::Ignore:
2278  has_name_match = false;
2279  break;
2280 
2281  case NameMatch::Equals:
2282  packet.PutCString("name_match:equals;");
2283  break;
2284 
2285  case NameMatch::Contains:
2286  packet.PutCString("name_match:contains;");
2287  break;
2288 
2289  case NameMatch::StartsWith:
2290  packet.PutCString("name_match:starts_with;");
2291  break;
2292 
2293  case NameMatch::EndsWith:
2294  packet.PutCString("name_match:ends_with;");
2295  break;
2296 
2298  packet.PutCString("name_match:regex;");
2299  break;
2300  }
2301  if (has_name_match) {
2302  packet.PutCString("name:");
2303  packet.PutBytesAsRawHex8(name, ::strlen(name));
2304  packet.PutChar(';');
2305  }
2306  }
2307 
2308  if (match_info.GetProcessInfo().ProcessIDIsValid())
2309  packet.Printf("pid:%" PRIu64 ";",
2310  match_info.GetProcessInfo().GetProcessID());
2311  if (match_info.GetProcessInfo().ParentProcessIDIsValid())
2312  packet.Printf("parent_pid:%" PRIu64 ";",
2313  match_info.GetProcessInfo().GetParentProcessID());
2314  if (match_info.GetProcessInfo().UserIDIsValid())
2315  packet.Printf("uid:%u;", match_info.GetProcessInfo().GetUserID());
2316  if (match_info.GetProcessInfo().GroupIDIsValid())
2317  packet.Printf("gid:%u;", match_info.GetProcessInfo().GetGroupID());
2318  if (match_info.GetProcessInfo().EffectiveUserIDIsValid())
2319  packet.Printf("euid:%u;",
2320  match_info.GetProcessInfo().GetEffectiveUserID());
2321  if (match_info.GetProcessInfo().EffectiveGroupIDIsValid())
2322  packet.Printf("egid:%u;",
2323  match_info.GetProcessInfo().GetEffectiveGroupID());
2324  packet.Printf("all_users:%u;", match_info.GetMatchAllUsers() ? 1 : 0);
2325  if (match_info.GetProcessInfo().GetArchitecture().IsValid()) {
2326  const ArchSpec &match_arch =
2327  match_info.GetProcessInfo().GetArchitecture();
2328  const llvm::Triple &triple = match_arch.GetTriple();
2329  packet.PutCString("triple:");
2330  packet.PutCString(triple.getTriple());
2331  packet.PutChar(';');
2332  }
2333  }
2334  StringExtractorGDBRemote response;
2335  // Increase timeout as the first qfProcessInfo packet takes a long time on
2336  // Android. The value of 1min was arrived at empirically.
2337  ScopedTimeout timeout(*this, minutes(1));
2338  if (SendPacketAndWaitForResponse(packet.GetString(), response) ==
2340  do {
2341  ProcessInstanceInfo process_info;
2342  if (!DecodeProcessInfoResponse(response, process_info))
2343  break;
2344  process_infos.push_back(process_info);
2345  response = StringExtractorGDBRemote();
2346  } while (SendPacketAndWaitForResponse("qsProcessInfo", response) ==
2348  } else {
2349  m_supports_qfProcessInfo = false;
2350  return 0;
2351  }
2352  }
2353  return process_infos.size();
2354 }
2355 
2357  std::string &name) {
2358  if (m_supports_qUserName) {
2359  char packet[32];
2360  const int packet_len =
2361  ::snprintf(packet, sizeof(packet), "qUserName:%i", uid);
2362  assert(packet_len < (int)sizeof(packet));
2363  UNUSED_IF_ASSERT_DISABLED(packet_len);
2364  StringExtractorGDBRemote response;
2365  if (SendPacketAndWaitForResponse(packet, response) ==
2367  if (response.IsNormalResponse()) {
2368  // Make sure we parsed the right number of characters. The response is
2369  // the hex encoded user name and should make up the entire packet. If
2370  // there are any non-hex ASCII bytes, the length won't match below..
2371  if (response.GetHexByteString(name) * 2 ==
2372  response.GetStringRef().size())
2373  return true;
2374  }
2375  } else {
2376  m_supports_qUserName = false;
2377  return false;
2378  }
2379  }
2380  return false;
2381 }
2382 
2384  std::string &name) {
2385  if (m_supports_qGroupName) {
2386  char packet[32];
2387  const int packet_len =
2388  ::snprintf(packet, sizeof(packet), "qGroupName:%i", gid);
2389  assert(packet_len < (int)sizeof(packet));
2390  UNUSED_IF_ASSERT_DISABLED(packet_len);
2391  StringExtractorGDBRemote response;
2392  if (SendPacketAndWaitForResponse(packet, response) ==
2394  if (response.IsNormalResponse()) {
2395  // Make sure we parsed the right number of characters. The response is
2396  // the hex encoded group name and should make up the entire packet. If
2397  // there are any non-hex ASCII bytes, the length won't match below..
2398  if (response.GetHexByteString(name) * 2 ==
2399  response.GetStringRef().size())
2400  return true;
2401  }
2402  } else {
2403  m_supports_qGroupName = false;
2404  return false;
2405  }
2406  }
2407  return false;
2408 }
2409 
2410 static void MakeSpeedTestPacket(StreamString &packet, uint32_t send_size,
2411  uint32_t recv_size) {
2412  packet.Clear();
2413  packet.Printf("qSpeedTest:response_size:%i;data:", recv_size);
2414  uint32_t bytes_left = send_size;
2415  while (bytes_left > 0) {
2416  if (bytes_left >= 26) {
2417  packet.PutCString("abcdefghijklmnopqrstuvwxyz");
2418  bytes_left -= 26;
2419  } else {
2420  packet.Printf("%*.*s;", bytes_left, bytes_left,
2421  "abcdefghijklmnopqrstuvwxyz");
2422  bytes_left = 0;
2423  }
2424  }
2425 }
2426 
2427 duration<float>
2428 calculate_standard_deviation(const std::vector<duration<float>> &v) {
2429  using Dur = duration<float>;
2430  Dur sum = std::accumulate(std::begin(v), std::end(v), Dur());
2431  Dur mean = sum / v.size();
2432  float accum = 0;
2433  for (auto d : v) {
2434  float delta = (d - mean).count();
2435  accum += delta * delta;
2436  };
2437 
2438  return Dur(sqrtf(accum / (v.size() - 1)));
2439 }
2440 
2442  uint32_t max_send,
2443  uint32_t max_recv,
2444  uint64_t recv_amount,
2445  bool json, Stream &strm) {
2446  uint32_t i;
2447  if (SendSpeedTestPacket(0, 0)) {
2448  StreamString packet;
2449  if (json)
2450  strm.Printf("{ \"packet_speeds\" : {\n \"num_packets\" : %u,\n "
2451  "\"results\" : [",
2452  num_packets);
2453  else
2454  strm.Printf("Testing sending %u packets of various sizes:\n",
2455  num_packets);
2456  strm.Flush();
2457 
2458  uint32_t result_idx = 0;
2459  uint32_t send_size;
2460  std::vector<duration<float>> packet_times;
2461 
2462  for (send_size = 0; send_size <= max_send;
2463  send_size ? send_size *= 2 : send_size = 4) {
2464  for (uint32_t recv_size = 0; recv_size <= max_recv;
2465  recv_size ? recv_size *= 2 : recv_size = 4) {
2466  MakeSpeedTestPacket(packet, send_size, recv_size);
2467 
2468  packet_times.clear();
2469  // Test how long it takes to send 'num_packets' packets
2470  const auto start_time = steady_clock::now();
2471  for (i = 0; i < num_packets; ++i) {
2472  const auto packet_start_time = steady_clock::now();
2473  StringExtractorGDBRemote response;
2474  SendPacketAndWaitForResponse(packet.GetString(), response);
2475  const auto packet_end_time = steady_clock::now();
2476  packet_times.push_back(packet_end_time - packet_start_time);
2477  }
2478  const auto end_time = steady_clock::now();
2479  const auto total_time = end_time - start_time;
2480 
2481  float packets_per_second =
2482  ((float)num_packets) / duration<float>(total_time).count();
2483  auto average_per_packet = total_time / num_packets;
2484  const duration<float> standard_deviation =
2485  calculate_standard_deviation(packet_times);
2486  if (json) {
2487  strm.Format("{0}\n {{\"send_size\" : {1,6}, \"recv_size\" : "
2488  "{2,6}, \"total_time_nsec\" : {3,12:ns-}, "
2489  "\"standard_deviation_nsec\" : {4,9:ns-f0}}",
2490  result_idx > 0 ? "," : "", send_size, recv_size,
2491  total_time, standard_deviation);
2492  ++result_idx;
2493  } else {
2494  strm.Format("qSpeedTest(send={0,7}, recv={1,7}) in {2:s+f9} for "
2495  "{3,9:f2} packets/s ({4,10:ms+f6} per packet) with "
2496  "standard deviation of {5,10:ms+f6}\n",
2497  send_size, recv_size, duration<float>(total_time),
2498  packets_per_second, duration<float>(average_per_packet),
2499  standard_deviation);
2500  }
2501  strm.Flush();
2502  }
2503  }
2504 
2505  const float k_recv_amount_mb = (float)recv_amount / (1024.0f * 1024.0f);
2506  if (json)
2507  strm.Printf("\n ]\n },\n \"download_speed\" : {\n \"byte_size\" "
2508  ": %" PRIu64 ",\n \"results\" : [",
2509  recv_amount);
2510  else
2511  strm.Printf("Testing receiving %2.1fMB of data using varying receive "
2512  "packet sizes:\n",
2513  k_recv_amount_mb);
2514  strm.Flush();
2515  send_size = 0;
2516  result_idx = 0;
2517  for (uint32_t recv_size = 32; recv_size <= max_recv; recv_size *= 2) {
2518  MakeSpeedTestPacket(packet, send_size, recv_size);
2519 
2520  // If we have a receive size, test how long it takes to receive 4MB of
2521  // data
2522  if (recv_size > 0) {
2523  const auto start_time = steady_clock::now();
2524  uint32_t bytes_read = 0;
2525  uint32_t packet_count = 0;
2526  while (bytes_read < recv_amount) {
2527  StringExtractorGDBRemote response;
2528  SendPacketAndWaitForResponse(packet.GetString(), response);
2529  bytes_read += recv_size;
2530  ++packet_count;
2531  }
2532  const auto end_time = steady_clock::now();
2533  const auto total_time = end_time - start_time;
2534  float mb_second = ((float)recv_amount) /
2535  duration<float>(total_time).count() /
2536  (1024.0 * 1024.0);
2537  float packets_per_second =
2538  ((float)packet_count) / duration<float>(total_time).count();
2539  const auto average_per_packet = total_time / packet_count;
2540 
2541  if (json) {
2542  strm.Format("{0}\n {{\"send_size\" : {1,6}, \"recv_size\" : "
2543  "{2,6}, \"total_time_nsec\" : {3,12:ns-}}",
2544  result_idx > 0 ? "," : "", send_size, recv_size,
2545  total_time);
2546  ++result_idx;
2547  } else {
2548  strm.Format("qSpeedTest(send={0,7}, recv={1,7}) {2,6} packets needed "
2549  "to receive {3:f1}MB in {4:s+f9} for {5} MB/sec for "
2550  "{6,9:f2} packets/sec ({7,10:ms+f6} per packet)\n",
2551  send_size, recv_size, packet_count, k_recv_amount_mb,
2552  duration<float>(total_time), mb_second,
2553  packets_per_second, duration<float>(average_per_packet));
2554  }
2555  strm.Flush();
2556  }
2557  }
2558  if (json)
2559  strm.Printf("\n ]\n }\n}\n");
2560  else
2561  strm.EOL();
2562  }
2563 }
2564 
2566  uint32_t recv_size) {
2567  StreamString packet;
2568  packet.Printf("qSpeedTest:response_size:%i;data:", recv_size);
2569  uint32_t bytes_left = send_size;
2570  while (bytes_left > 0) {
2571  if (bytes_left >= 26) {
2572  packet.PutCString("abcdefghijklmnopqrstuvwxyz");
2573  bytes_left -= 26;
2574  } else {
2575  packet.Printf("%*.*s;", bytes_left, bytes_left,
2576  "abcdefghijklmnopqrstuvwxyz");
2577  bytes_left = 0;
2578  }
2579  }
2580 
2581  StringExtractorGDBRemote response;
2582  return SendPacketAndWaitForResponse(packet.GetString(), response) ==
2584 }
2585 
2587  const char *remote_accept_hostname, lldb::pid_t &pid, uint16_t &port,
2588  std::string &socket_name) {
2590  port = 0;
2591  socket_name.clear();
2592 
2593  StringExtractorGDBRemote response;
2594  StreamString stream;
2595  stream.PutCString("qLaunchGDBServer;");
2596  std::string hostname;
2597  if (remote_accept_hostname && remote_accept_hostname[0])
2598  hostname = remote_accept_hostname;
2599  else {
2600  if (HostInfo::GetHostname(hostname)) {
2601  // Make the GDB server we launch only accept connections from this host
2602  stream.Printf("host:%s;", hostname.c_str());
2603  } else {
2604  // Make the GDB server we launch accept connections from any host since
2605  // we can't figure out the hostname
2606  stream.Printf("host:*;");
2607  }
2608  }
2609  // give the process a few seconds to startup
2610  ScopedTimeout timeout(*this, seconds(10));
2611 
2612  if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
2614  llvm::StringRef name;
2615  llvm::StringRef value;
2616  while (response.GetNameColonValue(name, value)) {
2617  if (name.equals("port"))
2618  value.getAsInteger(0, port);
2619  else if (name.equals("pid"))
2620  value.getAsInteger(0, pid);
2621  else if (name.compare("socket_name") == 0) {
2622  StringExtractor extractor(value);
2623  extractor.GetHexByteString(socket_name);
2624  }
2625  }
2626  return true;
2627  }
2628  return false;
2629 }
2630 
2632  std::vector<std::pair<uint16_t, std::string>> &connection_urls) {
2633  connection_urls.clear();
2634 
2635  StringExtractorGDBRemote response;
2636  if (SendPacketAndWaitForResponse("qQueryGDBServer", response) !=
2638  return 0;
2639 
2642  if (!data)
2643  return 0;
2644 
2645  StructuredData::Array *array = data->GetAsArray();
2646  if (!array)
2647  return 0;
2648 
2649  for (size_t i = 0, count = array->GetSize(); i < count; ++i) {
2650  StructuredData::Dictionary *element = nullptr;
2651  if (!array->GetItemAtIndexAsDictionary(i, element))
2652  continue;
2653 
2654  uint16_t port = 0;
2655  if (StructuredData::ObjectSP port_osp =
2656  element->GetValueForKey(llvm::StringRef("port")))
2657  port = port_osp->GetIntegerValue(0);
2658 
2659  std::string socket_name;
2660  if (StructuredData::ObjectSP socket_name_osp =
2661  element->GetValueForKey(llvm::StringRef("socket_name")))
2662  socket_name = std::string(socket_name_osp->GetStringValue());
2663 
2664  if (port != 0 || !socket_name.empty())
2665  connection_urls.emplace_back(port, socket_name);
2666  }
2667  return connection_urls.size();
2668 }
2669 
2671  StreamString stream;
2672  stream.Printf("qKillSpawnedProcess:%" PRId64, pid);
2673 
2674  StringExtractorGDBRemote response;
2675  if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
2677  if (response.IsOKResponse())
2678  return true;
2679  }
2680  return false;
2681 }
2682 
2683 llvm::Optional<PidTid>
2685  uint64_t pid,
2686  char op) {
2688  packet.PutChar('H');
2689  packet.PutChar(op);
2690 
2691  if (pid != LLDB_INVALID_PROCESS_ID)
2692  packet.Printf("p%" PRIx64 ".", pid);
2693 
2694  if (tid == UINT64_MAX)
2695  packet.PutCString("-1");
2696  else
2697  packet.Printf("%" PRIx64, tid);
2698 
2699  StringExtractorGDBRemote response;
2700  if (SendPacketAndWaitForResponse(packet.GetString(), response)
2701  == PacketResult::Success) {
2702  if (response.IsOKResponse())
2703  return {{pid, tid}};
2704 
2705  /*
2706  * Connected bare-iron target (like YAMON gdb-stub) may not have support for
2707  * Hg packet.
2708  * The reply from '?' packet could be as simple as 'S05'. There is no packet
2709  * which can
2710  * give us pid and/or tid. Assume pid=tid=1 in such cases.
2711  */
2712  if (response.IsUnsupportedResponse() && IsConnected())
2713  return {{1, 1}};
2714  }
2715  return llvm::None;
2716 }
2717 
2719  uint64_t pid) {
2720  if (m_curr_tid == tid &&
2721  (m_curr_pid == pid || LLDB_INVALID_PROCESS_ID == pid))
2722  return true;
2723 
2724  llvm::Optional<PidTid> ret = SendSetCurrentThreadPacket(tid, pid, 'g');
2725  if (ret.hasValue()) {
2726  if (ret->pid != LLDB_INVALID_PROCESS_ID)
2727  m_curr_pid = ret->pid;
2728  m_curr_tid = ret->tid;
2729  }
2730  return ret.hasValue();
2731 }
2732 
2734  uint64_t pid) {
2735  if (m_curr_tid_run == tid &&
2736  (m_curr_pid_run == pid || LLDB_INVALID_PROCESS_ID == pid))
2737  return true;
2738 
2739  llvm::Optional<PidTid> ret = SendSetCurrentThreadPacket(tid, pid, 'c');
2740  if (ret.hasValue()) {
2741  if (ret->pid != LLDB_INVALID_PROCESS_ID)
2742  m_curr_pid_run = ret->pid;
2743  m_curr_tid_run = ret->tid;
2744  }
2745  return ret.hasValue();
2746 }
2747 
2749  StringExtractorGDBRemote &response) {
2751  return response.IsNormalResponse();
2752  return false;
2753 }
2754 
2756  lldb::tid_t tid, StringExtractorGDBRemote &response) {
2758  char packet[256];
2759  int packet_len =
2760  ::snprintf(packet, sizeof(packet), "qThreadStopInfo%" PRIx64, tid);
2761  assert(packet_len < (int)sizeof(packet));
2762  UNUSED_IF_ASSERT_DISABLED(packet_len);
2763  if (SendPacketAndWaitForResponse(packet, response) ==
2765  if (response.IsUnsupportedResponse())
2767  else if (response.IsNormalResponse())
2768  return true;
2769  else
2770  return false;
2771  } else {
2773  }
2774  }
2775  return false;
2776 }
2777 
2779  GDBStoppointType type, bool insert, addr_t addr, uint32_t length,
2780  std::chrono::seconds timeout) {
2782  LLDB_LOGF(log, "GDBRemoteCommunicationClient::%s() %s at addr = 0x%" PRIx64,
2783  __FUNCTION__, insert ? "add" : "remove", addr);
2784 
2785  // Check if the stub is known not to support this breakpoint type
2786  if (!SupportsGDBStoppointPacket(type))
2787  return UINT8_MAX;
2788  // Construct the breakpoint packet
2789  char packet[64];
2790  const int packet_len =
2791  ::snprintf(packet, sizeof(packet), "%c%i,%" PRIx64 ",%x",
2792  insert ? 'Z' : 'z', type, addr, length);
2793  // Check we haven't overwritten the end of the packet buffer
2794  assert(packet_len + 1 < (int)sizeof(packet));
2795  UNUSED_IF_ASSERT_DISABLED(packet_len);
2796  StringExtractorGDBRemote response;
2797  // Make sure the response is either "OK", "EXX" where XX are two hex digits,
2798  // or "" (unsupported)
2800  // Try to send the breakpoint packet, and check that it was correctly sent
2801  if (SendPacketAndWaitForResponse(packet, response, timeout) ==
2803  // Receive and OK packet when the breakpoint successfully placed
2804  if (response.IsOKResponse())
2805  return 0;
2806 
2807  // Status while setting breakpoint, send back specific error
2808  if (response.IsErrorResponse())
2809  return response.GetError();
2810 
2811  // Empty packet informs us that breakpoint is not supported
2812  if (response.IsUnsupportedResponse()) {
2813  // Disable this breakpoint type since it is unsupported
2814  switch (type) {
2815  case eBreakpointSoftware:
2816  m_supports_z0 = false;
2817  break;
2818  case eBreakpointHardware:
2819  m_supports_z1 = false;
2820  break;
2821  case eWatchpointWrite:
2822  m_supports_z2 = false;
2823  break;
2824  case eWatchpointRead:
2825  m_supports_z3 = false;
2826  break;
2827  case eWatchpointReadWrite:
2828  m_supports_z4 = false;
2829  break;
2830  case eStoppointInvalid:
2831  return UINT8_MAX;
2832  }
2833  }
2834  }
2835  // Signal generic failure
2836  return UINT8_MAX;
2837 }
2838 
2839 std::vector<std::pair<lldb::pid_t, lldb::tid_t>>
2841  bool &sequence_mutex_unavailable) {
2842  std::vector<std::pair<lldb::pid_t, lldb::tid_t>> ids;
2843 
2844  Lock lock(*this);
2845  if (lock) {
2846  sequence_mutex_unavailable = false;
2847  StringExtractorGDBRemote response;
2848 
2849  PacketResult packet_result;
2850  for (packet_result =
2851  SendPacketAndWaitForResponseNoLock("qfThreadInfo", response);
2852  packet_result == PacketResult::Success && response.IsNormalResponse();
2853  packet_result =
2854  SendPacketAndWaitForResponseNoLock("qsThreadInfo", response)) {
2855  char ch = response.GetChar();
2856  if (ch == 'l')
2857  break;
2858  if (ch == 'm') {
2859  do {
2860  auto pid_tid = response.GetPidTid(LLDB_INVALID_PROCESS_ID);
2861  // If we get an invalid response, break out of the loop.
2862  // If there are valid tids, they have been added to ids.
2863  // If there are no valid tids, we'll fall through to the
2864  // bare-iron target handling below.
2865  if (!pid_tid)
2866  break;
2867 
2868  ids.push_back(pid_tid.getValue());
2869  ch = response.GetChar(); // Skip the command separator
2870  } while (ch == ','); // Make sure we got a comma separator
2871  }
2872  }
2873 
2874  /*
2875  * Connected bare-iron target (like YAMON gdb-stub) may not have support for
2876  * qProcessInfo, qC and qfThreadInfo packets. The reply from '?' packet
2877  * could
2878  * be as simple as 'S05'. There is no packet which can give us pid and/or
2879  * tid.
2880  * Assume pid=tid=1 in such cases.
2881  */
2882  if ((response.IsUnsupportedResponse() || response.IsNormalResponse()) &&
2883  ids.size() == 0 && IsConnected()) {
2884  ids.emplace_back(1, 1);
2885  }
2886  } else {
2888  LLDB_LOG(log, "error: failed to get packet sequence mutex, not sending "
2889  "packet 'qfThreadInfo'");
2890  sequence_mutex_unavailable = true;
2891  }
2892 
2893  return ids;
2894 }
2895 
2897  std::vector<lldb::tid_t> &thread_ids, bool &sequence_mutex_unavailable) {
2899  thread_ids.clear();
2900 
2901  auto ids = GetCurrentProcessAndThreadIDs(sequence_mutex_unavailable);
2902  if (ids.empty() || sequence_mutex_unavailable)
2903  return 0;
2904 
2905  for (auto id : ids) {
2906  // skip threads that do not belong to the current process
2907  if (id.first != LLDB_INVALID_PROCESS_ID && id.first != pid)
2908  continue;
2909  if (id.second != LLDB_INVALID_THREAD_ID &&
2911  thread_ids.push_back(id.second);
2912  }
2913 
2914  return thread_ids.size();
2915 }
2916 
2918  StringExtractorGDBRemote response;
2919  if (SendPacketAndWaitForResponse("qShlibInfoAddr", response) !=
2921  !response.IsNormalResponse())
2922  return LLDB_INVALID_ADDRESS;
2923  return response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
2924 }
2925 
2927  llvm::StringRef command,
2928  const FileSpec &
2929  working_dir, // Pass empty FileSpec to use the current working directory
2930  int *status_ptr, // Pass NULL if you don't want the process exit status
2931  int *signo_ptr, // Pass NULL if you don't want the signal that caused the
2932  // process to exit
2933  std::string
2934  *command_output, // Pass NULL if you don't want the command output
2935  const Timeout<std::micro> &timeout) {
2937  stream.PutCString("qPlatform_shell:");
2938  stream.PutBytesAsRawHex8(command.data(), command.size());
2939  stream.PutChar(',');
2940  uint32_t timeout_sec = UINT32_MAX;
2941  if (timeout) {
2942  // TODO: Use chrono version of std::ceil once c++17 is available.
2943  timeout_sec = std::ceil(std::chrono::duration<double>(*timeout).count());
2944  }
2945  stream.PutHex32(timeout_sec);
2946  if (working_dir) {
2947  std::string path{working_dir.GetPath(false)};
2948  stream.PutChar(',');
2949  stream.PutStringAsRawHex8(path);
2950  }
2951  StringExtractorGDBRemote response;
2952  if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
2954  if (response.GetChar() != 'F')
2955  return Status("malformed reply");
2956  if (response.GetChar() != ',')
2957  return Status("malformed reply");
2958  uint32_t exitcode = response.GetHexMaxU32(false, UINT32_MAX);
2959  if (exitcode == UINT32_MAX)
2960  return Status("unable to run remote process");
2961  else if (status_ptr)
2962  *status_ptr = exitcode;
2963  if (response.GetChar() != ',')
2964  return Status("malformed reply");
2965  uint32_t signo = response.GetHexMaxU32(false, UINT32_MAX);
2966  if (signo_ptr)
2967  *signo_ptr = signo;
2968  if (response.GetChar() != ',')
2969  return Status("malformed reply");
2970  std::string output;
2971  response.GetEscapedBinaryData(output);
2972  if (command_output)
2973  command_output->assign(output);
2974  return Status();
2975  }
2976  return Status("unable to send packet");
2977 }
2978 
2980  uint32_t file_permissions) {
2981  std::string path{file_spec.GetPath(false)};
2983  stream.PutCString("qPlatform_mkdir:");
2984  stream.PutHex32(file_permissions);
2985  stream.PutChar(',');
2986  stream.PutStringAsRawHex8(path);
2987  llvm::StringRef packet = stream.GetString();
2988  StringExtractorGDBRemote response;
2989 
2990  if (SendPacketAndWaitForResponse(packet, response) != PacketResult::Success)
2991  return Status("failed to send '%s' packet", packet.str().c_str());
2992 
2993  if (response.GetChar() != 'F')
2994  return Status("invalid response to '%s' packet", packet.str().c_str());
2995 
2996  return Status(response.GetHexMaxU32(false, UINT32_MAX), eErrorTypePOSIX);
2997 }
2998 
2999 Status
3001  uint32_t file_permissions) {
3002  std::string path{file_spec.GetPath(false)};
3004  stream.PutCString("qPlatform_chmod:");
3005  stream.PutHex32(file_permissions);
3006  stream.PutChar(',');
3007  stream.PutStringAsRawHex8(path);
3008  llvm::StringRef packet = stream.GetString();
3009  StringExtractorGDBRemote response;
3010 
3011  if (SendPacketAndWaitForResponse(packet, response) != PacketResult::Success)
3012  return Status("failed to send '%s' packet", stream.GetData());
3013 
3014  if (response.GetChar() != 'F')
3015  return Status("invalid response to '%s' packet", stream.GetData());
3016 
3017  return Status(response.GetHexMaxU32(false, UINT32_MAX), eErrorTypePOSIX);
3018 }
3019 
3020 static int gdb_errno_to_system(int err) {
3021  switch (err) {
3022 #define HANDLE_ERRNO(name, value) \
3023  case GDB_##name: \
3024  return name;
3025 #include "Plugins/Process/gdb-remote/GDBRemoteErrno.def"
3026  default:
3027  return -1;
3028  }
3029 }
3030 
3032  uint64_t fail_result, Status &error) {
3033  response.SetFilePos(0);
3034  if (response.GetChar() != 'F')
3035  return fail_result;
3036  int32_t result = response.GetS32(-2, 16);
3037  if (result == -2)
3038  return fail_result;
3039  if (response.GetChar() == ',') {
3040  int result_errno = gdb_errno_to_system(response.GetS32(-1, 16));
3041  if (result_errno != -1)
3042  error.SetError(result_errno, eErrorTypePOSIX);
3043  else
3044  error.SetError(-1, eErrorTypeGeneric);
3045  } else
3046  error.Clear();
3047  return result;
3048 }
3051  File::OpenOptions flags, mode_t mode,
3052  Status &error) {
3053  std::string path(file_spec.GetPath(false));
3055  stream.PutCString("vFile:open:");
3056  if (path.empty())
3057  return UINT64_MAX;
3058  stream.PutStringAsRawHex8(path);
3059  stream.PutChar(',');
3060  stream.PutHex32(flags);
3061  stream.PutChar(',');
3062  stream.PutHex32(mode);
3063  StringExtractorGDBRemote response;
3064  if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
3066  return ParseHostIOPacketResponse(response, UINT64_MAX, error);
3067  }
3068  return UINT64_MAX;
3069 }
3070 
3072  Status &error) {
3074  stream.Printf("vFile:close:%x", (int)fd);
3075  StringExtractorGDBRemote response;
3076  if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
3078  return ParseHostIOPacketResponse(response, -1, error) == 0;
3079  }
3080  return false;
3081 }
3082 
3083 llvm::Optional<GDBRemoteFStatData>
3086  stream.Printf("vFile:fstat:%" PRIx64, fd);
3087  StringExtractorGDBRemote response;
3088  if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
3090  if (response.GetChar() != 'F')
3091  return llvm::None;
3092  int64_t size = response.GetS64(-1, 16);
3093  if (size > 0 && response.GetChar() == ';') {
3094  std::string buffer;
3095  if (response.GetEscapedBinaryData(buffer)) {
3096  GDBRemoteFStatData out;
3097  if (buffer.size() != sizeof(out))
3098  return llvm::None;
3099  memcpy(&out, buffer.data(), sizeof(out));
3100  return out;
3101  }
3102  }
3103  }
3104  return llvm::None;
3105 }
3106 
3107 llvm::Optional<GDBRemoteFStatData>
3109  Status error;
3111  if (fd == UINT64_MAX)
3112  return llvm::None;
3113  llvm::Optional<GDBRemoteFStatData> st = FStat(fd);
3114  CloseFile(fd, error);
3115  return st;
3116 }
3117 
3118 // Extension of host I/O packets to get the file size.
3120  const lldb_private::FileSpec &file_spec) {
3121  if (m_supports_vFileSize) {
3122  std::string path(file_spec.GetPath(false));
3124  stream.PutCString("vFile:size:");
3125  stream.PutStringAsRawHex8(path);
3126  StringExtractorGDBRemote response;
3127  if (SendPacketAndWaitForResponse(stream.GetString(), response) !=
3129  return UINT64_MAX;
3130 
3131  if (!response.IsUnsupportedResponse()) {
3132  if (response.GetChar() != 'F')
3133  return UINT64_MAX;
3134  uint32_t retcode = response.GetHexMaxU64(false, UINT64_MAX);
3135  return retcode;
3136  }
3137  m_supports_vFileSize = false;
3138  }
3139 
3140  // Fallback to fstat.
3141  llvm::Optional<GDBRemoteFStatData> st = Stat(file_spec);
3142  return st ? st->gdb_st_size : UINT64_MAX;
3143 }
3144 
3146  CompletionRequest &request, bool only_dir) {
3148  stream.PutCString("qPathComplete:");
3149  stream.PutHex32(only_dir ? 1 : 0);
3150  stream.PutChar(',');
3151  stream.PutStringAsRawHex8(request.GetCursorArgumentPrefix());
3152  StringExtractorGDBRemote response;
3153  if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
3155  StreamString strm;
3156  char ch = response.GetChar();
3157  if (ch != 'M')
3158  return;
3159  while (response.Peek()) {
3160  strm.Clear();
3161  while ((ch = response.GetHexU8(0, false)) != '\0')
3162  strm.PutChar(ch);
3163  request.AddCompletion(strm.GetString());
3164  if (response.GetChar() != ',')
3165  break;
3166  }
3167  }
3168 }
3169 
3170 Status
3172  uint32_t &file_permissions) {
3173  if (m_supports_vFileMode) {
3174  std::string path{file_spec.GetPath(false)};
3175  Status error;
3177  stream.PutCString("vFile:mode:");
3178  stream.PutStringAsRawHex8(path);
3179  StringExtractorGDBRemote response;
3180  if (SendPacketAndWaitForResponse(stream.GetString(), response) !=
3182  error.SetErrorStringWithFormat("failed to send '%s' packet",
3183  stream.GetData());
3184  return error;
3185  }
3186  if (!response.IsUnsupportedResponse()) {
3187  if (response.GetChar() != 'F') {
3188  error.SetErrorStringWithFormat("invalid response to '%s' packet",
3189  stream.GetData());
3190  } else {
3191  const uint32_t mode = response.GetS32(-1, 16);
3192  if (static_cast<int32_t>(mode) == -1) {
3193  if (response.GetChar() == ',') {
3194  int response_errno = gdb_errno_to_system(response.GetS32(-1, 16));
3195  if (response_errno > 0)
3196  error.SetError(response_errno, lldb::eErrorTypePOSIX);
3197  else
3198  error.SetErrorToGenericError();
3199  } else
3200  error.SetErrorToGenericError();
3201  } else {
3202  file_permissions = mode & (S_IRWXU | S_IRWXG | S_IRWXO);
3203  }
3204  }
3205  return error;
3206  } else { // response.IsUnsupportedResponse()
3207  m_supports_vFileMode = false;
3208  }
3209  }
3210 
3211  // Fallback to fstat.
3212  if (llvm::Optional<GDBRemoteFStatData> st = Stat(file_spec)) {
3213  file_permissions = st->gdb_st_mode & (S_IRWXU | S_IRWXG | S_IRWXO);
3214  return Status();
3215  }
3216  return Status("fstat failed");
3217 }
3218 
3220  uint64_t offset, void *dst,
3221  uint64_t dst_len,
3222  Status &error) {
3224  stream.Printf("vFile:pread:%x,%" PRIx64 ",%" PRIx64, (int)fd, dst_len,
3225  offset);
3226  StringExtractorGDBRemote response;
3227  if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
3229  if (response.GetChar() != 'F')
3230  return 0;
3231  int64_t retcode = response.GetS64(-1, 16);
3232  if (retcode == -1) {
3233  error.SetErrorToGenericError();
3234  if (response.GetChar() == ',') {
3235  int response_errno = gdb_errno_to_system(response.GetS32(-1, 16));
3236  if (response_errno > 0)
3237  error.SetError(response_errno, lldb::eErrorTypePOSIX);
3238  }
3239  return -1;
3240  }
3241  const char next = (response.Peek() ? *response.Peek() : 0);
3242  if (next == ',')
3243  return 0;
3244  if (next == ';') {
3245  response.GetChar(); // skip the semicolon
3246  std::string buffer;
3247  if (response.GetEscapedBinaryData(buffer)) {
3248  const uint64_t data_to_write =
3249  std::min<uint64_t>(dst_len, buffer.size());
3250  if (data_to_write > 0)
3251  memcpy(dst, &buffer[0], data_to_write);
3252  return data_to_write;
3253  }
3254  }
3255  }
3256  return 0;
3257 }
3258 
3260  uint64_t offset,
3261  const void *src,
3262  uint64_t src_len,
3263  Status &error) {
3265  stream.Printf("vFile:pwrite:%x,%" PRIx64 ",", (int)fd, offset);
3266  stream.PutEscapedBytes(src, src_len);
3267  StringExtractorGDBRemote response;
3268  if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
3270  if (response.GetChar() != 'F') {
3271  error.SetErrorStringWithFormat("write file failed");
3272  return 0;
3273  }
3274  int64_t bytes_written = response.GetS64(-1, 16);
3275  if (bytes_written == -1) {
3276  error.SetErrorToGenericError();
3277  if (response.GetChar() == ',') {
3278  int response_errno = gdb_errno_to_system(response.GetS32(-1, 16));
3279  if (response_errno > 0)
3280  error.SetError(response_errno, lldb::eErrorTypePOSIX);
3281  }
3282  return -1;
3283  }
3284  return bytes_written;
3285  } else {
3286  error.SetErrorString("failed to send vFile:pwrite packet");
3287  }
3288  return 0;
3289 }
3290 
3292  const FileSpec &dst) {
3293  std::string src_path{src.GetPath(false)}, dst_path{dst.GetPath(false)};
3294  Status error;
3296  stream.PutCString("vFile:symlink:");
3297  // the unix symlink() command reverses its parameters where the dst if first,
3298  // so we follow suit here
3299  stream.PutStringAsRawHex8(dst_path);
3300  stream.PutChar(',');
3301  stream.PutStringAsRawHex8(src_path);
3302  StringExtractorGDBRemote response;
3303  if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
3305  if (response.GetChar() == 'F') {
3306  uint32_t result = response.GetHexMaxU32(false, UINT32_MAX);
3307  if (result != 0) {
3308  error.SetErrorToGenericError();
3309  if (response.GetChar() == ',') {
3310  int response_errno = gdb_errno_to_system(response.GetS32(-1, 16));
3311  if (response_errno > 0)
3312  error.SetError(response_errno, lldb::eErrorTypePOSIX);
3313  }
3314  }
3315  } else {
3316  // Should have returned with 'F<result>[,<errno>]'
3317  error.SetErrorStringWithFormat("symlink failed");
3318  }
3319  } else {
3320  error.SetErrorString("failed to send vFile:symlink packet");
3321  }
3322  return error;
3323 }
3324 
3326  std::string path{file_spec.GetPath(false)};
3327  Status error;
3329  stream.PutCString("vFile:unlink:");
3330  // the unix symlink() command reverses its parameters where the dst if first,
3331  // so we follow suit here
3332  stream.PutStringAsRawHex8(path);
3333  StringExtractorGDBRemote response;
3334  if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
3336  if (response.GetChar() == 'F') {
3337  uint32_t result = response.GetHexMaxU32(false, UINT32_MAX);
3338  if (result != 0) {
3339  error.SetErrorToGenericError();
3340  if (response.GetChar() == ',') {
3341  int response_errno = gdb_errno_to_system(response.GetS32(-1, 16));
3342  if (response_errno > 0)
3343  error.SetError(response_errno, lldb::eErrorTypePOSIX);
3344  }
3345  }
3346  } else {
3347  // Should have returned with 'F<result>[,<errno>]'
3348  error.SetErrorStringWithFormat("unlink failed");
3349  }
3350  } else {
3351  error.SetErrorString("failed to send vFile:unlink packet");
3352  }
3353  return error;
3354 }
3355 
3356 // Extension of host I/O packets to get whether a file exists.
3358  const lldb_private::FileSpec &file_spec) {
3359  if (m_supports_vFileExists) {
3360  std::string path(file_spec.GetPath(false));
3362  stream.PutCString("vFile:exists:");
3363  stream.PutStringAsRawHex8(path);
3364  StringExtractorGDBRemote response;
3365  if (SendPacketAndWaitForResponse(stream.GetString(), response) !=
3367  return false;
3368  if (!response.IsUnsupportedResponse()) {
3369  if (response.GetChar() != 'F')
3370  return false;
3371  if (response.GetChar() != ',')
3372  return false;
3373  bool retcode = (response.GetChar() != '0');
3374  return retcode;
3375  } else
3376  m_supports_vFileExists = false;
3377  }
3378 
3379  // Fallback to open.
3380  Status error;
3382  if (fd == UINT64_MAX)
3383  return false;
3384  CloseFile(fd, error);
3385  return true;
3386 }
3387 
3389  const lldb_private::FileSpec &file_spec, uint64_t &high, uint64_t &low) {
3390  std::string path(file_spec.GetPath(false));
3392  stream.PutCString("vFile:MD5:");
3393  stream.PutStringAsRawHex8(path);
3394  StringExtractorGDBRemote response;
3395  if (SendPacketAndWaitForResponse(stream.GetString(), response) ==
3397  if (response.GetChar() != 'F')
3398  return false;
3399  if (response.GetChar() != ',')
3400  return false;
3401  if (response.Peek() && *response.Peek() == 'x')
3402  return false;
3403  low = response.GetHexMaxU64(false, UINT64_MAX);
3404  high = response.GetHexMaxU64(false, UINT64_MAX);
3405  return true;
3406  }
3407  return false;
3408 }
3409 
3411  // Some targets have issues with g/G packets and we need to avoid using them
3413  if (process) {
3415  const ArchSpec &arch = process->GetTarget().GetArchitecture();
3416  if (arch.IsValid() &&
3417  arch.GetTriple().getVendor() == llvm::Triple::Apple &&
3418  arch.GetTriple().getOS() == llvm::Triple::IOS &&
3419  (arch.GetTriple().getArch() == llvm::Triple::aarch64 ||
3420  arch.GetTriple().getArch() == llvm::Triple::aarch64_32)) {
3422  uint32_t gdb_server_version = GetGDBServerProgramVersion();
3423  if (gdb_server_version != 0) {
3424  const char *gdb_server_name = GetGDBServerProgramName();
3425  if (gdb_server_name && strcmp(gdb_server_name, "debugserver") == 0) {
3426  if (gdb_server_version >= 310)
3428  }
3429  }
3430  }
3431  }
3432  }
3433  return m_avoid_g_packets == eLazyBoolYes;
3434 }
3435 
3437  uint32_t reg) {
3438  StreamString payload;
3439  payload.Printf("p%x", reg);
3440  StringExtractorGDBRemote response;
3442  tid, std::move(payload), response) != PacketResult::Success ||
3443  !response.IsNormalResponse())
3444  return nullptr;
3445 
3446  WritableDataBufferSP buffer_sp(
3447  new DataBufferHeap(response.GetStringRef().size() / 2, 0));
3448  response.GetHexBytes(buffer_sp->GetData(), '\xcc');
3449  return buffer_sp;
3450 }
3451 
3453  StreamString payload;
3454  payload.PutChar('g');
3455  StringExtractorGDBRemote response;
3457  tid, std::move(payload), response) != PacketResult::Success ||
3458  !response.IsNormalResponse())
3459  return nullptr;
3460 
3461  WritableDataBufferSP buffer_sp(
3462  new DataBufferHeap(response.GetStringRef().size() / 2, 0));
3463  response.GetHexBytes(buffer_sp->GetData(), '\xcc');
3464  return buffer_sp;
3465 }
3466 
3468  uint32_t reg_num,
3469  llvm::ArrayRef<uint8_t> data) {
3470  StreamString payload;
3471  payload.Printf("P%x=", reg_num);
3472  payload.PutBytesAsRawHex8(data.data(), data.size(),
3475  StringExtractorGDBRemote response;
3477  tid, std::move(payload), response) == PacketResult::Success &&
3478  response.IsOKResponse();
3479 }
3480 
3482  lldb::tid_t tid, llvm::ArrayRef<uint8_t> data) {
3483  StreamString payload;
3484  payload.PutChar('G');
3485  payload.PutBytesAsRawHex8(data.data(), data.size(),
3488  StringExtractorGDBRemote response;
3490  tid, std::move(payload), response) == PacketResult::Success &&
3491  response.IsOKResponse();
3492 }
3493 
3495  uint32_t &save_id) {
3496  save_id = 0; // Set to invalid save ID
3498  return false;
3499 
3501  StreamString payload;
3502  payload.PutCString("QSaveRegisterState");
3503  StringExtractorGDBRemote response;
3505  tid, std::move(payload), response) != PacketResult::Success)
3506  return false;
3507 
3508  if (response.IsUnsupportedResponse())
3510 
3511  const uint32_t response_save_id = response.GetU32(0);
3512  if (response_save_id == 0)
3513  return false;
3514 
3515  save_id = response_save_id;
3516  return true;
3517 }
3518 
3520  uint32_t save_id) {
3521  // We use the "m_supports_QSaveRegisterState" variable here because the
3522  // QSaveRegisterState and QRestoreRegisterState packets must both be
3523  // supported in order to be useful
3525  return false;
3526 
3527  StreamString payload;
3528  payload.Printf("QRestoreRegisterState:%u", save_id);
3529  StringExtractorGDBRemote response;
3531  tid, std::move(payload), response) != PacketResult::Success)
3532  return false;
3533 
3534  if (response.IsOKResponse())
3535  return true;
3536 
3537  if (response.IsUnsupportedResponse())
3539  return false;
3540 }
3541 
3544  return false;
3545 
3546  StreamString packet;
3547  StringExtractorGDBRemote response;
3548  packet.Printf("QSyncThreadState:%4.4" PRIx64 ";", tid);
3549  return SendPacketAndWaitForResponse(packet.GetString(), response) ==
3551  response.IsOKResponse();
3552 }
3553 
3554 llvm::Expected<TraceSupportedResponse>
3556  Log *log = GetLog(GDBRLog::Process);
3557 
3558  StreamGDBRemote escaped_packet;
3559  escaped_packet.PutCString("jLLDBTraceSupported");
3560 
3561  StringExtractorGDBRemote response;
3562  if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
3563  timeout) ==
3565  if (response.IsErrorResponse())
3566  return response.GetStatus().ToError();
3567  if (response.IsUnsupportedResponse())
3568  return llvm::createStringError(llvm::inconvertibleErrorCode(),
3569  "jLLDBTraceSupported is unsupported");
3570 
3571  return llvm::json::parse<TraceSupportedResponse>(response.Peek(),
3572  "TraceSupportedResponse");
3573  }
3574  LLDB_LOG(log, "failed to send packet: jLLDBTraceSupported");
3575  return llvm::createStringError(llvm::inconvertibleErrorCode(),
3576  "failed to send packet: jLLDBTraceSupported");
3577 }
3578 
3581  std::chrono::seconds timeout) {
3582  Log *log = GetLog(GDBRLog::Process);
3583 
3584  StreamGDBRemote escaped_packet;
3585  escaped_packet.PutCString("jLLDBTraceStop:");
3586 
3587  std::string json_string;
3588  llvm::raw_string_ostream os(json_string);
3589  os << toJSON(request);
3590  os.flush();
3591 
3592  escaped_packet.PutEscapedBytes(json_string.c_str(), json_string.size());
3593 
3594  StringExtractorGDBRemote response;
3595  if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
3596  timeout) ==
3598  if (response.IsErrorResponse())
3599  return response.GetStatus().ToError();
3600  if (response.IsUnsupportedResponse())
3601  return llvm::createStringError(llvm::inconvertibleErrorCode(),
3602  "jLLDBTraceStop is unsupported");
3603  if (response.IsOKResponse())
3604  return llvm::Error::success();
3605  return llvm::createStringError(llvm::inconvertibleErrorCode(),
3606  "Invalid jLLDBTraceStart response");
3607  }
3608  LLDB_LOG(log, "failed to send packet: jLLDBTraceStop");
3609  return llvm::createStringError(llvm::inconvertibleErrorCode(),
3610  "failed to send packet: jLLDBTraceStop '%s'",
3611  escaped_packet.GetData());
3612 }
3613 
3615 GDBRemoteCommunicationClient::SendTraceStart(const llvm::json::Value &params,
3616  std::chrono::seconds timeout) {
3617  Log *log = GetLog(GDBRLog::Process);
3618 
3619  StreamGDBRemote escaped_packet;
3620  escaped_packet.PutCString("jLLDBTraceStart:");
3621 
3622  std::string json_string;
3623  llvm::raw_string_ostream os(json_string);
3624  os << params;
3625  os.flush();
3626 
3627  escaped_packet.PutEscapedBytes(json_string.c_str(), json_string.size());
3628 
3629  StringExtractorGDBRemote response;
3630  if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
3631  timeout) ==
3633  if (response.IsErrorResponse())
3634  return response.GetStatus().ToError();
3635  if (response.IsUnsupportedResponse())
3636  return llvm::createStringError(llvm::inconvertibleErrorCode(),
3637  "jLLDBTraceStart is unsupported");
3638  if (response.IsOKResponse())
3639  return llvm::Error::success();
3640  return llvm::createStringError(llvm::inconvertibleErrorCode(),
3641  "Invalid jLLDBTraceStart response");
3642  }
3643  LLDB_LOG(log, "failed to send packet: jLLDBTraceStart");
3644  return llvm::createStringError(llvm::inconvertibleErrorCode(),
3645  "failed to send packet: jLLDBTraceStart '%s'",
3646  escaped_packet.GetData());
3647 }
3648 
3649 llvm::Expected<std::string>
3651  std::chrono::seconds timeout) {
3652  Log *log = GetLog(GDBRLog::Process);
3653 
3654  StreamGDBRemote escaped_packet;
3655  escaped_packet.PutCString("jLLDBTraceGetState:");
3656 
3657  std::string json_string;
3658  llvm::raw_string_ostream os(json_string);
3659  os << toJSON(TraceGetStateRequest{type.str()});
3660  os.flush();
3661 
3662  escaped_packet.PutEscapedBytes(json_string.c_str(), json_string.size());
3663 
3664  StringExtractorGDBRemote response;
3665  if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
3666  timeout) ==
3668  if (response.IsErrorResponse())
3669  return response.GetStatus().ToError();
3670  if (response.IsUnsupportedResponse())
3671  return llvm::createStringError(llvm::inconvertibleErrorCode(),
3672  "jLLDBTraceGetState is unsupported");
3673  return std::string(response.Peek());
3674  }
3675 
3676  LLDB_LOG(log, "failed to send packet: jLLDBTraceGetState");
3677  return llvm::createStringError(
3678  llvm::inconvertibleErrorCode(),
3679  "failed to send packet: jLLDBTraceGetState '%s'",
3680  escaped_packet.GetData());
3681 }
3682 
3683 llvm::Expected<std::vector<uint8_t>>
3685  const TraceGetBinaryDataRequest &request, std::chrono::seconds timeout) {
3686  Log *log = GetLog(GDBRLog::Process);
3687 
3688  StreamGDBRemote escaped_packet;
3689  escaped_packet.PutCString("jLLDBTraceGetBinaryData:");
3690 
3691  std::string json_string;
3692  llvm::raw_string_ostream os(json_string);
3693  os << toJSON(request);
3694  os.flush();
3695 
3696  escaped_packet.PutEscapedBytes(json_string.c_str(), json_string.size());
3697 
3698  StringExtractorGDBRemote response;
3699  if (SendPacketAndWaitForResponse(escaped_packet.GetString(), response,
3700  timeout) ==
3702  if (response.IsErrorResponse())
3703  return response.GetStatus().ToError();
3704  if (response.IsUnsupportedResponse())
3705  return llvm::createStringError(llvm::inconvertibleErrorCode(),
3706  "jLLDBTraceGetBinaryData is unsupported");
3707  std::string data;
3708  response.GetEscapedBinaryData(data);
3709  return std::vector<uint8_t>(data.begin(), data.end());
3710  }
3711  LLDB_LOG(log, "failed to send packet: jLLDBTraceGetBinaryData");
3712  return llvm::createStringError(
3713  llvm::inconvertibleErrorCode(),
3714  "failed to send packet: jLLDBTraceGetBinaryData '%s'",
3715  escaped_packet.GetData());
3716 }
3717 
3718 llvm::Optional<QOffsets> GDBRemoteCommunicationClient::GetQOffsets() {
3719  StringExtractorGDBRemote response;
3720  if (SendPacketAndWaitForResponse("qOffsets", response) !=
3722  return llvm::None;
3723  if (!response.IsNormalResponse())
3724  return llvm::None;
3725 
3726  QOffsets result;
3727  llvm::StringRef ref = response.GetStringRef();
3728  const auto &GetOffset = [&] {
3729  addr_t offset;
3730  if (ref.consumeInteger(16, offset))
3731  return false;
3732  result.offsets.push_back(offset);
3733  return true;
3734  };
3735 
3736  if (ref.consume_front("Text=")) {
3737  result.segments = false;
3738  if (!GetOffset())
3739  return llvm::None;
3740  if (!ref.consume_front(";Data=") || !GetOffset())
3741  return llvm::None;
3742  if (ref.empty())
3743  return result;
3744  if (ref.consume_front(";Bss=") && GetOffset() && ref.empty())
3745  return result;
3746  } else if (ref.consume_front("TextSeg=")) {
3747  result.segments = true;
3748  if (!GetOffset())
3749  return llvm::None;
3750  if (ref.empty())
3751  return result;
3752  if (ref.consume_front(";DataSeg=") && GetOffset() && ref.empty())
3753  return result;
3754  }
3755  return llvm::None;
3756 }
3757 
3759  const FileSpec &module_file_spec, const lldb_private::ArchSpec &arch_spec,
3760  ModuleSpec &module_spec) {
3762  return false;
3763 
3764  std::string module_path = module_file_spec.GetPath(false);
3765  if (module_path.empty())
3766  return false;
3767 
3768  StreamString packet;
3769  packet.PutCString("qModuleInfo:");
3770  packet.PutStringAsRawHex8(module_path);
3771  packet.PutCString(";");
3772  const auto &triple = arch_spec.GetTriple().getTriple();
3773  packet.PutStringAsRawHex8(triple);
3774 
3775  StringExtractorGDBRemote response;
3776  if (SendPacketAndWaitForResponse(packet.GetString(), response) !=
3778  return false;
3779 
3780  if (response.IsErrorResponse())
3781  return false;
3782 
3783  if (response.IsUnsupportedResponse()) {
3784  m_supports_qModuleInfo = false;
3785  return false;
3786  }
3787 
3788  llvm::StringRef name;
3789  llvm::StringRef value;
3790 
3791  module_spec.Clear();
3792  module_spec.GetFileSpec() = module_file_spec;
3793 
3794  while (response.GetNameColonValue(name, value)) {
3795  if (name == "uuid" || name == "md5") {
3796  StringExtractor extractor(value);
3797  std::string uuid;
3798  extractor.GetHexByteString(uuid);
3799  module_spec.GetUUID().SetFromStringRef(uuid);
3800  } else if (name == "triple") {
3801  StringExtractor extractor(value);
3802  std::string triple;
3803  extractor.GetHexByteString(triple);
3804  module_spec.GetArchitecture().SetTriple(triple.c_str());
3805  } else if (name == "file_offset") {
3806  uint64_t ival = 0;
3807  if (!value.getAsInteger(16, ival))
3808  module_spec.SetObjectOffset(ival);
3809  } else if (name == "file_size") {
3810  uint64_t ival = 0;
3811  if (!value.getAsInteger(16, ival))
3812  module_spec.SetObjectSize(ival);
3813  } else if (name == "file_path") {
3814  StringExtractor extractor(value);
3815  std::string path;
3816  extractor.GetHexByteString(path);
3817  module_spec.GetFileSpec() = FileSpec(path, arch_spec.GetTriple());
3818  }
3819  }
3820 
3821  return true;
3822 }
3823 
3824 static llvm::Optional<ModuleSpec>
3826  ModuleSpec result;
3827  if (!dict)
3828  return llvm::None;
3829 
3830  llvm::StringRef string;
3831  uint64_t integer;
3832 
3833  if (!dict->GetValueForKeyAsString("uuid", string))
3834  return llvm::None;
3835  if (!result.GetUUID().SetFromStringRef(string))
3836  return llvm::None;
3837 
3838  if (!dict->GetValueForKeyAsInteger("file_offset", integer))
3839  return llvm::None;
3840  result.SetObjectOffset(integer);
3841 
3842  if (!dict->GetValueForKeyAsInteger("file_size", integer))
3843  return llvm::None;
3844  result.SetObjectSize(integer);
3845 
3846  if (!dict->GetValueForKeyAsString("triple", string))
3847  return llvm::None;
3848  result.GetArchitecture().SetTriple(string);
3849 
3850  if (!dict->GetValueForKeyAsString("file_path", string))
3851  return llvm::None;
3852  result.GetFileSpec() = FileSpec(string, result.GetArchitecture().GetTriple());
3853 
3854  return result;
3855 }
3856 
3857 llvm::Optional<std::vector<ModuleSpec>>
3859  llvm::ArrayRef<FileSpec> module_file_specs, const llvm::Triple &triple) {
3860  namespace json = llvm::json;
3861 
3863  return llvm::None;
3864 
3865  json::Array module_array;
3866  for (const FileSpec &module_file_spec : module_file_specs) {
3867  module_array.push_back(
3868  json::Object{{"file", module_file_spec.GetPath(false)},
3869  {"triple", triple.getTriple()}});
3870  }
3871  StreamString unescaped_payload;
3872  unescaped_payload.PutCString("jModulesInfo:");
3873  unescaped_payload.AsRawOstream() << std::move(module_array);
3874 
3875  StreamGDBRemote payload;
3876  payload.PutEscapedBytes(unescaped_payload.GetString().data(),
3877  unescaped_payload.GetSize());
3878 
3879  // Increase the timeout for jModulesInfo since this packet can take longer.
3880  ScopedTimeout timeout(*this, std::chrono::seconds(10));
3881 
3882  StringExtractorGDBRemote response;
3883  if (SendPacketAndWaitForResponse(payload.GetString(), response) !=
3885  response.IsErrorResponse())
3886  return llvm::None;
3887 
3888  if (response.IsUnsupportedResponse()) {
3889  m_supports_jModulesInfo = false;
3890  return llvm::None;
3891  }
3892 
3893  StructuredData::ObjectSP response_object_sp =
3895  if (!response_object_sp)
3896  return llvm::None;
3897 
3898  StructuredData::Array *response_array = response_object_sp->GetAsArray();
3899  if (!response_array)
3900  return llvm::None;
3901 
3902  std::vector<ModuleSpec> result;
3903  for (size_t i = 0; i < response_array->GetSize(); ++i) {
3904  if (llvm::Optional<ModuleSpec> module_spec = ParseModuleSpec(
3905  response_array->GetItemAtIndex(i)->GetAsDictionary()))
3906  result.push_back(*module_spec);
3907  }
3908 
3909  return result;
3910 }
3911 
3912 // query the target remote for extended information using the qXfer packet
3913 //
3914 // example: object='features', annex='target.xml'
3915 // return: <xml output> or error
3916 llvm::Expected<std::string>
3918  llvm::StringRef annex) {
3919 
3920  std::string output;
3921  llvm::raw_string_ostream output_stream(output);
3923 
3924  uint64_t size = GetRemoteMaxPacketSize();
3925  if (size == 0)
3926  size = 0x1000;
3927  size = size - 1; // Leave space for the 'm' or 'l' character in the response
3928  int offset = 0;
3929  bool active = true;
3930 
3931  // loop until all data has been read
3932  while (active) {
3933 
3934  // send query extended feature packet
3935  std::string packet =
3936  ("qXfer:" + object + ":read:" + annex + ":" +
3937  llvm::Twine::utohexstr(offset) + "," + llvm::Twine::utohexstr(size))
3938  .str();
3939 
3941  SendPacketAndWaitForResponse(packet, chunk);
3942 
3944  chunk.GetStringRef().empty()) {
3945  return llvm::createStringError(llvm::inconvertibleErrorCode(),
3946  "Error sending $qXfer packet");
3947  }
3948 
3949  // check packet code
3950  switch (chunk.GetStringRef()[0]) {
3951  // last chunk
3952  case ('l'):
3953  active = false;
3954  LLVM_FALLTHROUGH;
3955 
3956  // more chunks
3957  case ('m'):
3958  output_stream << chunk.GetStringRef().drop_front();
3959  offset += chunk.GetStringRef().size() - 1;
3960  break;
3961 
3962  // unknown chunk
3963  default:
3964  return llvm::createStringError(
3965  llvm::inconvertibleErrorCode(),
3966  "Invalid continuation code from $qXfer packet");
3967  }
3968  }
3969 
3970  return output_stream.str();
3971 }
3972 
3973 // Notify the target that gdb is prepared to serve symbol lookup requests.
3974 // packet: "qSymbol::"
3975 // reply:
3976 // OK The target does not need to look up any (more) symbols.
3977 // qSymbol:<sym_name> The target requests the value of symbol sym_name (hex
3978 // encoded).
3979 // LLDB may provide the value by sending another qSymbol
3980 // packet
3981 // in the form of"qSymbol:<sym_value>:<sym_name>".
3982 //
3983 // Three examples:
3984 //
3985 // lldb sends: qSymbol::
3986 // lldb receives: OK
3987 // Remote gdb stub does not need to know the addresses of any symbols, lldb
3988 // does not
3989 // need to ask again in this session.
3990 //
3991 // lldb sends: qSymbol::
3992 // lldb receives: qSymbol:64697370617463685f71756575655f6f666673657473
3993 // lldb sends: qSymbol::64697370617463685f71756575655f6f666673657473
3994 // lldb receives: OK
3995 // Remote gdb stub asks for address of 'dispatch_queue_offsets'. lldb does
3996 // not know
3997 // the address at this time. lldb needs to send qSymbol:: again when it has
3998 // more
3999 // solibs loaded.
4000 //
4001 // lldb sends: qSymbol::
4002 // lldb receives: qSymbol:64697370617463685f71756575655f6f666673657473
4003 // lldb sends: qSymbol:2bc97554:64697370617463685f71756575655f6f666673657473
4004 // lldb receives: OK
4005 // Remote gdb stub asks for address of 'dispatch_queue_offsets'. lldb says
4006 // that it
4007 // is at address 0x2bc97554. Remote gdb stub sends 'OK' indicating that it
4008 // does not
4009 // need any more symbols. lldb does not need to ask again in this session.
4010 
4012  lldb_private::Process *process) {
4013  // Set to true once we've resolved a symbol to an address for the remote
4014  // stub. If we get an 'OK' response after this, the remote stub doesn't need
4015  // any more symbols and we can stop asking.
4016  bool symbol_response_provided = false;
4017 
4018  // Is this the initial qSymbol:: packet?
4019  bool first_qsymbol_query = true;
4020 
4022  Lock lock(*this);
4023  if (lock) {
4024  StreamString packet;
4025  packet.PutCString("qSymbol::");
4026  StringExtractorGDBRemote response;
4027  while (SendPacketAndWaitForResponseNoLock(packet.GetString(), response) ==
4029  if (response.IsOKResponse()) {
4030  if (symbol_response_provided || first_qsymbol_query) {
4031  m_qSymbol_requests_done = true;
4032  }
4033 
4034  // We are done serving symbols requests
4035  return;
4036  }
4037  first_qsymbol_query = false;
4038 
4039  if (response.IsUnsupportedResponse()) {
4040  // qSymbol is not supported by the current GDB server we are
4041  // connected to
4042  m_supports_qSymbol = false;
4043  return;
4044  } else {
4045  llvm::StringRef response_str(response.GetStringRef());
4046  if (response_str.startswith("qSymbol:")) {
4047  response.SetFilePos(strlen("qSymbol:"));
4048  std::string symbol_name;
4049  if (response.GetHexByteString(symbol_name)) {
4050  if (symbol_name.empty())
4051  return;
4052 
4053  addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
4056  ConstString(symbol_name), eSymbolTypeAny, sc_list);
4057  if (!sc_list.IsEmpty()) {
4058  const size_t num_scs = sc_list.GetSize();
4059  for (size_t sc_idx = 0;
4060  sc_idx < num_scs &&
4061  symbol_load_addr == LLDB_INVALID_ADDRESS;
4062  ++sc_idx) {
4063  SymbolContext sc;
4064  if (sc_list.GetContextAtIndex(sc_idx, sc)) {
4065  if (sc.symbol) {
4066  switch (sc.symbol->GetType()) {
4067  case eSymbolTypeInvalid:
4068  case eSymbolTypeAbsolute:
4069  case eSymbolTypeUndefined:
4070  case eSymbolTypeSourceFile:
4071  case eSymbolTypeHeaderFile:
4072  case eSymbolTypeObjectFile:
4074  case eSymbolTypeBlock:
4075  case eSymbolTypeLocal:
4076  case eSymbolTypeParam:
4077  case eSymbolTypeVariable:
4079  case eSymbolTypeLineEntry:
4080  case eSymbolTypeLineHeader:
4081  case eSymbolTypeScopeBegin:
4082  case eSymbolTypeScopeEnd:
4083  case eSymbolTypeAdditional:
4084  case eSymbolTypeCompiler:
4086  case eSymbolTypeTrampoline:
4087  break;
4088 
4089  case eSymbolTypeCode:
4090  case eSymbolTypeResolver:
4091  case eSymbolTypeData:
4092  case eSymbolTypeRuntime:
4093  case eSymbolTypeException:
4094  case eSymbolTypeObjCClass:
4096  case eSymbolTypeObjCIVar:
4097  case eSymbolTypeReExported:
4098  symbol_load_addr =
4099  sc.symbol->GetLoadAddress(&process->GetTarget());
4100  break;
4101  }
4102  }
4103  }
4104  }
4105  }
4106  // This is the normal path where our symbol lookup was successful
4107  // and we want to send a packet with the new symbol value and see
4108  // if another lookup needs to be done.
4109 
4110  // Change "packet" to contain the requested symbol value and name
4111  packet.Clear();
4112  packet.PutCString("qSymbol:");
4113  if (symbol_load_addr != LLDB_INVALID_ADDRESS) {
4114  packet.Printf("%" PRIx64, symbol_load_addr);
4115  symbol_response_provided = true;
4116  } else {
4117  symbol_response_provided = false;
4118  }
4119  packet.PutCString(":");
4120  packet.PutBytesAsRawHex8(symbol_name.data(), symbol_name.size());
4121  continue; // go back to the while loop and send "packet" and wait
4122  // for another response
4123  }
4124  }
4125  }
4126  }
4127  // If we make it here, the symbol request packet response wasn't valid or
4128  // our symbol lookup failed so we must abort
4129  return;
4130 
4131  } else if (Log *log = GetLog(GDBRLog::Process | GDBRLog::Packets)) {
4132  LLDB_LOGF(log,
4133  "GDBRemoteCommunicationClient::%s: Didn't get sequence mutex.",
4134  __FUNCTION__);
4135  }
4136  }
4137 }
4138 
4142  // Query the server for the array of supported asynchronous JSON packets.
4144 
4145  Log *log = GetLog(GDBRLog::Process);
4146 
4147  // Poll it now.
4148  StringExtractorGDBRemote response;
4149  if (SendPacketAndWaitForResponse("qStructuredDataPlugins", response) ==
4154  !m_supported_async_json_packets_sp->GetAsArray()) {
4155  // We were returned something other than a JSON array. This is
4156  // invalid. Clear it out.
4157  LLDB_LOGF(log,
4158  "GDBRemoteCommunicationClient::%s(): "
4159  "QSupportedAsyncJSONPackets returned invalid "
4160  "result: %s",
4161  __FUNCTION__, response.GetStringRef().data());
4163  }
4164  } else {
4165  LLDB_LOGF(log,
4166  "GDBRemoteCommunicationClient::%s(): "
4167  "QSupportedAsyncJSONPackets unsupported",
4168  __FUNCTION__);
4169  }
4170 
4171  if (log && m_supported_async_json_packets_sp) {
4172  StreamString stream;
4173  m_supported_async_json_packets_sp->Dump(stream);
4174  LLDB_LOGF(log,
4175  "GDBRemoteCommunicationClient::%s(): supported async "
4176  "JSON packets: %s",
4177  __FUNCTION__, stream.GetData());
4178  }
4179  }
4180 
4182  ? m_supported_async_json_packets_sp->GetAsArray()
4183  : nullptr;
4184 }
4185 
4187  llvm::ArrayRef<int32_t> signals) {
4188  // Format packet:
4189  // QPassSignals:<hex_sig1>;<hex_sig2>...;<hex_sigN>
4190  auto range = llvm::make_range(signals.begin(), signals.end());
4191  std::string packet = formatv("QPassSignals:{0:$[;]@(x-2)}", range).str();
4192 
4193  StringExtractorGDBRemote response;
4194  auto send_status = SendPacketAndWaitForResponse(packet, response);
4195 
4197  return Status("Sending QPassSignals packet failed");
4198 
4199  if (response.IsOKResponse()) {
4200  return Status();
4201  } else {
4202  return Status("Unknown error happened during sending QPassSignals packet.");
4203  }
4204 }
4205 
4207  ConstString type_name, const StructuredData::ObjectSP &config_sp) {
4208  Status error;
4209 
4210  if (type_name.GetLength() == 0) {
4211  error.SetErrorString("invalid type_name argument");
4212  return error;
4213  }
4214 
4215  // Build command: Configure{type_name}: serialized config data.
4216  StreamGDBRemote stream;
4217  stream.PutCString("QConfigure");
4218  stream.PutCString(type_name.GetStringRef());
4219  stream.PutChar(':');
4220  if (config_sp) {
4221  // Gather the plain-text version of the configuration data.
4222  StreamString unescaped_stream;
4223  config_sp->Dump(unescaped_stream);
4224  unescaped_stream.Flush();
4225 
4226  // Add it to the stream in escaped fashion.
4227  stream.PutEscapedBytes(unescaped_stream.GetString().data(),
4228  unescaped_stream.GetSize());
4229  }
4230  stream.Flush();
4231 
4232  // Send the packet.
4233  StringExtractorGDBRemote response;
4234  auto result = SendPacketAndWaitForResponse(stream.GetString(), response);
4235  if (result == PacketResult::Success) {
4236  // We failed if the config result comes back other than OK.
4237  if (strcmp(response.GetStringRef().data(), "OK") == 0) {
4238  // Okay!
4239  error.Clear();
4240  } else {
4241  error.SetErrorStringWithFormat("configuring StructuredData feature "
4242  "%s failed with error %s",
4243  type_name.AsCString(),
4244  response.GetStringRef().data());
4245  }
4246  } else {
4247  // Can we get more data here on the failure?
4248  error.SetErrorStringWithFormat("configuring StructuredData feature %s "
4249  "failed when sending packet: "
4250  "PacketResult=%d",
4251  type_name.AsCString(), (int)result);
4252  }
4253  return error;
4254 }
4255 
4259 }
4260 
4265  return true;
4266 
4267  // If the remote didn't indicate native-signal support explicitly,
4268  // check whether it is an old version of lldb-server.
4269  return GetThreadSuffixSupported();
4270 }
lldb_private::toJSON
llvm::json::Value toJSON(const TraceSupportedResponse &packet)
Definition: TraceGDBRemotePackets.cpp:24
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetSaveCoreSupported
bool GetSaveCoreSupported() const
Definition: GDBRemoteCommunicationClient.cpp:529
lldb_private::process_gdb_remote::QOffsets::offsets
std::vector< uint64_t > offsets
The individual offsets.
Definition: GDBRemoteCommunicationClient.h:45
lldb_private::ProcessInfo::GetArguments
Args & GetArguments()
Definition: ProcessInfo.h:75
lldb_private::process_gdb_remote::CompressionType
CompressionType
Definition: GDBRemoteCommunication.h:45
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::SendGDBStoppointTypePacket
uint8_t SendGDBStoppointTypePacket(GDBStoppointType type, bool insert, lldb::addr_t addr, uint32_t length, std::chrono::seconds interrupt_timeout)
Definition: GDBRemoteCommunicationClient.cpp:2778
lldb_private::Stream::Format
void Format(const char *format, Args &&... args)
Definition: Stream.h:309
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::SendTraceGetBinaryData
llvm::Expected< std::vector< uint8_t > > SendTraceGetBinaryData(const TraceGetBinaryDataRequest &request, std::chrono::seconds interrupt_timeout)
Definition: GDBRemoteCommunicationClient.cpp:3684
lldb::eSymbolTypeCompiler
@ eSymbolTypeCompiler
Definition: lldb-enumerations.h:637
lldb_private::ProcessInstanceInfo
Definition: ProcessInfo.h:108
lldb_private::UUID
Definition: UUID.h:23
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::WriteFile
uint64_t WriteFile(lldb::user_id_t fd, uint64_t offset, const void *src, uint64_t src_len, Status &error)
Definition: GDBRemoteCommunicationClient.cpp:3259
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::SyncThreadState
bool SyncThreadState(lldb::tid_t tid)
Definition: GDBRemoteCommunicationClient.cpp:3542
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_vFileExists
bool m_supports_vFileExists
Definition: GDBRemoteCommunicationClient.h:576
StringExtractorGDBRemote::AllProcesses
static constexpr lldb::pid_t AllProcesses
Definition: StringExtractorGDBRemote.h:202
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_qSaveCore
LazyBool m_supports_qSaveCore
Definition: GDBRemoteCommunicationClient.h:565
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_not_sending_acks
LazyBool m_supports_not_sending_acks
Definition: GDBRemoteCommunicationClient.h:527
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_host_arch
ArchSpec m_host_arch
Definition: GDBRemoteCommunicationClient.h:591
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetSharedCacheInfoSupported
bool GetSharedCacheInfoSupported()
Definition: GDBRemoteCommunicationClient.cpp:596
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetRemoteQSupported
void GetRemoteQSupported()
Definition: GDBRemoteCommunicationClient.cpp:324
lldb::eSymbolTypeParam
@ eSymbolTypeParam
Definition: lldb-enumerations.h:628
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetLoadedDynamicLibrariesInfosSupported
bool GetLoadedDynamicLibrariesInfosSupported()
Definition: GDBRemoteCommunicationClient.cpp:582
lldb_private::ArchSpec::GetByteOrder
lldb::ByteOrder GetByteOrder() const
Returns the byte order for the architecture specification.
Definition: ArchSpec.cpp:731
lldb::eSymbolTypeObjCIVar
@ eSymbolTypeObjCIVar
Definition: lldb-enumerations.h:642
ParseOSType
static void ParseOSType(llvm::StringRef value, std::string &os_name, std::string &environment)
Definition: GDBRemoteCommunicationClient.cpp:1187
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_memory_tagging
LazyBool m_supports_memory_tagging
Definition: GDBRemoteCommunicationClient.h:564
lldb_private::XMLNode::IsElement
bool IsElement() const
Definition: XML.cpp:343
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_os_kernel
std::string m_os_kernel
Definition: GDBRemoteCommunicationClient.h:599
lldb_private::StructuredData::Dictionary
Definition: StructuredData.h:352
lldb_private::ArchSpec
Definition: ArchSpec.h:33
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::SetSTDIN
int SetSTDIN(const FileSpec &file_spec)
Sets the path to use for stdin/out/err for a process that will be launched with the 'A' packet.
Definition: GDBRemoteCommunicationClient.cpp:1862
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::FindProcesses
uint32_t FindProcesses(const ProcessInstanceInfoMatch &process_match_info, ProcessInstanceInfoList &process_infos)
Definition: GDBRemoteCommunicationClient.cpp:2261
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::QueryNoAckModeSupported
bool QueryNoAckModeSupported()
Definition: GDBRemoteCommunicationClient.cpp:191
lldb::eSymbolTypeHeaderFile
@ eSymbolTypeHeaderFile
Definition: lldb-enumerations.h:623
UNUSED_IF_ASSERT_DISABLED
#define UNUSED_IF_ASSERT_DISABLED(x)
Definition: lldb-defines.h:125
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_qXfer_siginfo_read
LazyBool m_supports_qXfer_siginfo_read
Definition: GDBRemoteCommunicationClient.h:556
lldb_private::ProcessInfo::ProcessIDIsValid
bool ProcessIDIsValid() const
Definition: ProcessInfo.h:71
lldb_private::eArchTypeCOFF
@ eArchTypeCOFF
Definition: lldb-private-enumerations.h:65
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetQPassSignalsSupported
bool GetQPassSignalsSupported()
Definition: GDBRemoteCommunicationClient.cpp:128
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetOSBuildString
llvm::Optional< std::string > GetOSBuildString()
Definition: GDBRemoteCommunicationClient.cpp:978
lldb::eSymbolTypeCode
@ eSymbolTypeCode
Definition: lldb-enumerations.h:616
lldb_private::TraceGetBinaryDataRequest
jLLDBTraceGetBinaryData gdb-remote packet
Definition: TraceGDBRemotePackets.h:171
lldb_private::ProcessInstanceInfoMatch::GetMatchAllUsers
bool GetMatchAllUsers() const
Definition: ProcessInfo.h:178
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_qfProcessInfo
bool m_supports_qfProcessInfo
Definition: GDBRemoteCommunicationClient.h:568
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetMacCatalystVersion
llvm::VersionTuple GetMacCatalystVersion()
Definition: GDBRemoteCommunicationClient.cpp:973
LLDB_INVALID_PROCESS_ID
#define LLDB_INVALID_PROCESS_ID
Definition: lldb-defines.h:81
lldb_private::Stream::PutHex32
size_t PutHex32(uint32_t uvalue, lldb::ByteOrder byte_order=lldb::eByteOrderInvalid)
Definition: Stream.cpp:256
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::TestPacketSpeed
void TestPacketSpeed(const uint32_t num_packets, uint32_t max_send, uint32_t max_recv, uint64_t recv_amount, bool json, Stream &strm)
Definition: GDBRemoteCommunicationClient.cpp:2441
lldb_private::ArchSpec::GetMachine
llvm::Triple::ArchType GetMachine() const
Returns a machine family for the current architecture.
Definition: ArchSpec.cpp:668
lldb_private::MemoryRegionInfo::SetBlocksize
void SetBlocksize(lldb::offset_t blocksize)
Definition: MemoryRegionInfo.h:70
lldb::eSymbolTypeInstrumentation
@ eSymbolTypeInstrumentation
Definition: lldb-enumerations.h:638
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_x
LazyBool m_supports_x
Definition: GDBRemoteCommunicationClient.h:548
lldb_private::process_gdb_remote::GDBRemoteCommunication::SetPacketTimeout
std::chrono::seconds SetPacketTimeout(std::chrono::seconds packet_timeout)
Definition: GDBRemoteCommunication.h:145
ModuleSpec.h
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_vCont_any
LazyBool m_supports_vCont_any
Definition: GDBRemoteCommunicationClient.h:531
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetUserName
bool GetUserName(uint32_t uid, std::string &name)
Definition: GDBRemoteCommunicationClient.cpp:2356
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_gdb_server_name
std::string m_gdb_server_name
Definition: GDBRemoteCommunicationClient.h:601
lldb_private::ProcessInstanceInfo::Clear
void Clear()
Definition: ProcessInfo.h:116
StringExtractor::SetFilePos
void SetFilePos(uint32_t idx)
Definition: StringExtractor.h:39
lldb_private::StructuredData::Array
Definition: StructuredData.h:165
lldb_private::StructuredData::Dictionary::GetValueForKey
ObjectSP GetValueForKey(llvm::StringRef key) const
Definition: StructuredData.h:389
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_vCont_c
LazyBool m_supports_vCont_c
Definition: GDBRemoteCommunicationClient.h:532
StringExtractor::GetBytesLeft
size_t GetBytesLeft()
Definition: StringExtractor.h:52
lldb_private::process_gdb_remote::eWatchpointReadWrite
@ eWatchpointReadWrite
Definition: GDBRemoteCommunication.h:42
lldb_private::process_gdb_remote::GDBRemoteCommunication::SendAck
size_t SendAck()
Definition: GDBRemoteCommunication.cpp:95
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::SetWorkingDir
int SetWorkingDir(const FileSpec &working_dir)
Sets the working directory to path for a process that will be launched with the 'A' packet for non pl...
Definition: GDBRemoteCommunicationClient.cpp:1938
lldb::eSymbolTypeInvalid
@ eSymbolTypeInvalid
Definition: lldb-enumerations.h:614
lldb_private::process_gdb_remote::GDBRemoteClientBase::OnRunPacketSent
virtual void OnRunPacketSent(bool first)
Definition: GDBRemoteClientBase.cpp:281
StringExtractor::GetStringRef
llvm::StringRef GetStringRef() const
Definition: StringExtractor.h:48
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::QueryGDBServer
size_t QueryGDBServer(std::vector< std::pair< uint16_t, std::string >> &connection_urls)
Definition: GDBRemoteCommunicationClient.cpp:2631
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetHostArchitecture
const ArchSpec & GetHostArchitecture()
Definition: GDBRemoteCommunicationClient.cpp:1414
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetQXferSigInfoReadSupported
bool GetQXferSigInfoReadSupported()
Definition: GDBRemoteCommunicationClient.cpp:177
lldb_private::ProcessInfo::GetGroupID
uint32_t GetGroupID() const
Definition: ProcessInfo.h:51
lldb_private::MemoryRegionInfo::SetName
void SetName(const char *name)
Definition: MemoryRegionInfo.h:62
lldb::eSymbolTypeLineEntry
@ eSymbolTypeLineEntry
Definition: lldb-enumerations.h:631
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_vFileSize
bool m_supports_vFileSize
Definition: GDBRemoteCommunicationClient.h:575
lldb_private::process_gdb_remote::eStoppointInvalid
@ eStoppointInvalid
Definition: GDBRemoteCommunication.h:37
lldb_private::File::OpenOptions
OpenOptions
Definition: File.h:49
lldb_private::ProcessInfo::GetUserID
uint32_t GetUserID() const
Definition: ProcessInfo.h:49
lldb_private::XMLDocument
Definition: XML.h:113
S_IRWXU
#define S_IRWXU
Definition: windows/PosixApi.h:50
lldb_private::process_gdb_remote::GDBRemoteCommunication::PacketResult
PacketResult
Definition: GDBRemoteCommunication.h:91
lldb_private::StructuredData::Array::GetItemAtIndexAsDictionary
bool GetItemAtIndexAsDictionary(size_t idx, Dictionary *&result) const
Definition: StructuredData.h:254
lldb_private::UUID::IsValid
bool IsValid() const
Definition: UUID.h:79
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_qThreadStopInfo
bool m_supports_qThreadStopInfo
Definition: GDBRemoteCommunicationClient.h:570
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_maccatalyst_version
llvm::VersionTuple m_maccatalyst_version
Definition: GDBRemoteCommunicationClient.h:597
lldb_private::XMLDocument::ParseMemory
bool ParseMemory(const char *xml, size_t xml_length, const char *url="untitled.xml")
Definition: XML.cpp:52
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::MaybeEnableCompression
void MaybeEnableCompression(llvm::ArrayRef< llvm::StringRef > supported_compressions)
Definition: GDBRemoteCommunicationClient.cpp:1067
lldb::eSymbolTypeCommonBlock
@ eSymbolTypeCommonBlock
Definition: lldb-enumerations.h:625
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetDefaultThreadId
bool GetDefaultThreadId(lldb::tid_t &tid)
Definition: GDBRemoteCommunicationClient.cpp:1158
lldb::eSymbolTypeTrampoline
@ eSymbolTypeTrampoline
Definition: lldb-enumerations.h:619
S_IRWXG
#define S_IRWXG
Definition: windows/PosixApi.h:53
lldb_private::NameMatch::StartsWith
@ StartsWith
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetMemoryRegionInfo
Status GetMemoryRegionInfo(lldb::addr_t addr, MemoryRegionInfo &range_info)
Definition: GDBRemoteCommunicationClient.cpp:1530
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_curr_pid
lldb::pid_t m_curr_pid
Current gdb remote protocol process identifier for all other operations.
Definition: GDBRemoteCommunicationClient.h:580
lldb_private::eLazyBoolYes
@ eLazyBoolYes
Definition: lldb-private-enumerations.h:115
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_jThreadsInfo
bool m_supports_jThreadsInfo
Definition: GDBRemoteCommunicationClient.h:574
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:270
lldb_private::XMLNode
Definition: XML.h:46
lldb_private::MemoryRegionInfo::Clear
void Clear()
Definition: MemoryRegionInfo.h:38
lldb_private::Process
Definition: Process.h:338
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_max_packet_size
uint64_t m_max_packet_size
Definition: GDBRemoteCommunicationClient.h:608
lldb_private::Args::AppendArgument
void AppendArgument(llvm::StringRef arg_str, char quote_char='\0')
Appends a new argument to the end of the list argument list.
Definition: Args.cpp:318
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_QEnvironment
bool m_supports_QEnvironment
Definition: GDBRemoteCommunicationClient.h:572
lldb_private::Process::GetTarget
Target & GetTarget()
Get the target object pointer for this module.
Definition: Process.h:1206
lldb_private::ProcessInstanceInfo::GetEffectiveGroupID
uint32_t GetEffectiveGroupID() const
Definition: ProcessInfo.h:125
lldb_private::XMLNode::GetName
llvm::StringRef GetName() const
Definition: XML.cpp:266
lldb_private::process_gdb_remote::QOffsets::segments
bool segments
If true, the offsets field describes segments.
Definition: GDBRemoteCommunicationClient.h:41
StringExtractor::Empty
bool Empty()
Definition: StringExtractor.h:50
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_p
LazyBool m_supports_p
Definition: GDBRemoteCommunicationClient.h:547
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_qSupported_response
std::string m_qSupported_response
Definition: GDBRemoteCommunicationClient.h:609
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetQOffsets
llvm::Optional< QOffsets > GetQOffsets()
Use qOffsets to query the offset used when relocating the target executable.
Definition: GDBRemoteCommunicationClient.cpp:3718
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_vFileMode
bool m_supports_vFileMode
Definition: GDBRemoteCommunicationClient.h:576
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_QPassSignals
LazyBool m_supports_QPassSignals
Definition: GDBRemoteCommunicationClient.h:561
lldb_private::Args::Clear
void Clear()
Clear the arguments.
Definition: Args.cpp:374
lldb_private::Environment::compose
static std::string compose(const value_type &KeyValue)
Definition: Environment.h:80
lldb_private::ProcessInfo::SetUserID
void SetUserID(uint32_t uid)
Definition: ProcessInfo.h:57
lldb::eSymbolTypeScopeBegin
@ eSymbolTypeScopeBegin
Definition: lldb-enumerations.h:633
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_qGDBServerVersion_is_valid
LazyBool m_qGDBServerVersion_is_valid
Definition: GDBRemoteCommunicationClient.h:539
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetSystemArchitecture
ArchSpec GetSystemArchitecture()
Definition: GDBRemoteCommunicationClient.cpp:1006
lldb_private::Stream::Flush
virtual void Flush()=0
Flush the stream.
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_jModulesInfo
bool m_supports_jModulesInfo
Definition: GDBRemoteCommunicationClient.h:575
lldb_private::ProcessInstanceInfoMatch
Definition: ProcessInfo.h:163
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::~GDBRemoteCommunicationClient
~GDBRemoteCommunicationClient() override
Definition: GDBRemoteCommunicationClient.cpp:77
lldb_private::ArchSpec::SetFlags
void SetFlags(uint32_t flags)
Definition: ArchSpec.h:527
lldb::eSymbolTypeData
@ eSymbolTypeData
Definition: lldb-enumerations.h:618
lldb_private::SymbolContextList
Definition: SymbolContext.h:379
lldb_private::SymbolContextList::GetContextAtIndex
bool GetContextAtIndex(size_t idx, SymbolContext &sc) const
Get accessor for a symbol context at index idx.
Definition: SymbolContext.cpp:1263
lldb_private::ProcessInfo::GetProcessID
lldb::pid_t GetProcessID() const
Definition: ProcessInfo.h:67
lldb_private::MemoryRegionInfo::SetMemoryTagged
void SetMemoryTagged(OptionalBool val)
Definition: MemoryRegionInfo.h:72
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:193
lldb_private::ModuleSpec::SetObjectOffset
void SetObjectOffset(uint64_t object_offset)
Definition: ModuleSpec.h:109
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_qModuleInfo
bool m_supports_qModuleInfo
Definition: GDBRemoteCommunicationClient.h:574
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::ServeSymbolLookups
void ServeSymbolLookups(lldb_private::Process *process)
Definition: GDBRemoteCommunicationClient.cpp:4011
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetGDBServerProgramVersion
uint32_t GetGDBServerProgramVersion()
Definition: GDBRemoteCommunicationClient.cpp:1152
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::OnRunPacketSent
void OnRunPacketSent(bool first) override
Definition: GDBRemoteCommunicationClient.cpp:4256
lldb_private::MemoryRegionInfo
Definition: MemoryRegionInfo.h:21
lldb::eSymbolTypeRuntime
@ eSymbolTypeRuntime
Definition: lldb-enumerations.h:620
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetVContSupported
bool GetVContSupported(char flavor)
Definition: GDBRemoteCommunicationClient.cpp:423
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::SetCurrentThread
bool SetCurrentThread(uint64_t tid, lldb::pid_t pid=LLDB_INVALID_PROCESS_ID)
Definition: GDBRemoteCommunicationClient.cpp:2718
lldb_private::process_gdb_remote::eWatchpointWrite
@ eWatchpointWrite
Definition: GDBRemoteCommunication.h:40
StringExtractor::GetHexMaxU32
uint32_t GetHexMaxU32(bool little_endian, uint32_t fail_value)
Definition: StringExtractor.cpp:153
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetVAttachOrWaitSupported
bool GetVAttachOrWaitSupported()
Definition: GDBRemoteCommunicationClient.cpp:228
lldb_private::ProcessInfo::SetProcessID
void SetProcessID(lldb::pid_t pid)
Definition: ProcessInfo.h:69
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_threads_in_stop_reply
LazyBool m_supports_threads_in_stop_reply
Definition: GDBRemoteCommunicationClient.h:529
lldb_private::ProcessInstanceInfo::SetEffectiveUserID
void SetEffectiveUserID(uint32_t uid)
Definition: ProcessInfo.h:131
StringExtractorGDBRemote.h
lldb_private::TraceGetStateRequest
}
Definition: TraceGDBRemotePackets.h:88
lldb_private::process_gdb_remote::QOffsets
The offsets used by the target when relocating the executable.
Definition: GDBRemoteCommunicationClient.h:38
lldb_private::Stream
Definition: Stream.h:28
lldb_private::Args
Definition: Args.h:33
lldb_private::ArchSpec::GetTriple
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:455
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_process_standalone_value_is_offset
bool m_process_standalone_value_is_offset
Definition: GDBRemoteCommunicationClient.h:595
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::MemoryRegionInfo::SetReadable
void SetReadable(OptionalBool val)
Definition: MemoryRegionInfo.h:54
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::SendEnvironmentPacket
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...
Definition: GDBRemoteCommunicationClient.cpp:856
lldb_private::LazyBool
LazyBool
Definition: lldb-private-enumerations.h:115
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_curr_pid_is_valid
LazyBool m_curr_pid_is_valid
Definition: GDBRemoteCommunicationClient.h:537
StringExtractor
Definition: StringExtractor.h:19
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetAugmentedLibrariesSVR4ReadSupported
bool GetAugmentedLibrariesSVR4ReadSupported()
Definition: GDBRemoteCommunicationClient.cpp:135
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetQXferAuxvReadSupported
bool GetQXferAuxvReadSupported()
Definition: GDBRemoteCommunicationClient.cpp:156
LLDB_INVALID_CPUTYPE
#define LLDB_INVALID_CPUTYPE
Definition: lldb-defines.h:94
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetWatchpointSupportInfo
Status GetWatchpointSupportInfo(uint32_t &num)
Definition: GDBRemoteCommunicationClient.cpp:1789
lldb_private::ProcessInstanceInfo::EffectiveUserIDIsValid
bool EffectiveUserIDIsValid() const
Definition: ProcessInfo.h:127
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::MakeDirectory
Status MakeDirectory(const FileSpec &file_spec, uint32_t mode)
Definition: GDBRemoteCommunicationClient.cpp:2979
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetQXferFeaturesReadSupported
bool GetQXferFeaturesReadSupported()
Definition: GDBRemoteCommunicationClient.cpp:163
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetThreadsInfo
StructuredData::ObjectSP GetThreadsInfo()
Definition: GDBRemoteCommunicationClient.cpp:533
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetEchoSupported
bool GetEchoSupported()
Definition: GDBRemoteCommunicationClient.cpp:121
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetQXferLibrariesSVR4ReadSupported
bool GetQXferLibrariesSVR4ReadSupported()
Definition: GDBRemoteCommunicationClient.cpp:142
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetListThreadsInStopReplySupported
void GetListThreadsInStopReplySupported()
Definition: GDBRemoteCommunicationClient.cpp:215
lldb_private::Stream::PutStringAsRawHex8
size_t PutStringAsRawHex8(llvm::StringRef s)
Definition: Stream.cpp:383
lldb_private::ProcessInfo::UserIDIsValid
bool UserIDIsValid() const
Definition: ProcessInfo.h:53
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetWorkingDir
bool GetWorkingDir(FileSpec &working_dir)
Gets the current working directory of a remote platform GDB server.
Definition: GDBRemoteCommunicationClient.cpp:1922
StringExtractorGDBRemote::IsErrorResponse
bool IsErrorResponse() const
Definition: StringExtractorGDBRemote.cpp:469
lldb_private::Target::GetImages
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:938
lldb_private::StreamString::GetString
llvm::StringRef GetString() const
Definition: StreamString.cpp:51
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_vCont_S
LazyBool m_supports_vCont_S
Definition: GDBRemoteCommunicationClient.h:535
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetRemoteMaxPacketSize
uint64_t GetRemoteMaxPacketSize()
Definition: GDBRemoteCommunicationClient.cpp:184
lldb_private::eArchTypeMachO
@ eArchTypeMachO
Definition: lldb-private-enumerations.h:63
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::CalculateMD5
bool CalculateMD5(const FileSpec &file_spec, uint64_t &high, uint64_t &low)
Definition: GDBRemoteCommunicationClient.cpp:3388
lldb::eErrorTypePOSIX
@ eErrorTypePOSIX
POSIX error codes.
Definition: lldb-enumerations.h:310
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetGroupName
bool GetGroupName(uint32_t gid, std::string &name)
Definition: GDBRemoteCommunicationClient.cpp:2383
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::EnableErrorStringInPacket
void EnableErrorStringInPacket()
Definition: GDBRemoteCommunicationClient.cpp:567
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetSyncThreadStateSupported
bool GetSyncThreadStateSupported()
Definition: GDBRemoteCommunicationClient.cpp:242
lldb_private::StructuredData::Dictionary::GetValueForKeyAsInteger
bool GetValueForKeyAsInteger(llvm::StringRef key, IntType &result) const
Definition: StructuredData.h:413
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_qHostInfo_is_valid
LazyBool m_qHostInfo_is_valid
Definition: GDBRemoteCommunicationClient.h:536
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supported_async_json_packets_is_valid
bool m_supported_async_json_packets_is_valid
Definition: GDBRemoteCommunicationClient.h:611
lldb_private::ModuleList::FindSymbolsWithNameAndType
void FindSymbolsWithNameAndType(ConstString name, lldb::SymbolType symbol_type, SymbolContextList &sc_list) const
Definition: ModuleList.cpp:504
lldb_private::NameMatch
NameMatch
Definition: NameMatches.h:15
Target.h
lldb_private::ModuleSpec::GetUUID
UUID & GetUUID()
Definition: ModuleSpec.h:99
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_target_vm_page_size
int m_target_vm_page_size
Definition: GDBRemoteCommunicationClient.h:607
ParseModuleSpec
static llvm::Optional< ModuleSpec > ParseModuleSpec(StructuredData::Dictionary *dict)
Definition: GDBRemoteCommunicationClient.cpp:3825
MakeSpeedTestPacket
static void MakeSpeedTestPacket(StreamString &packet, uint32_t send_size, uint32_t recv_size)
Definition: GDBRemoteCommunicationClient.cpp:2410
StringExtractorGDBRemote::GetEscapedBinaryData
size_t GetEscapedBinaryData(std::string &str)
Definition: StringExtractorGDBRemote.cpp:499
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_qXfer_memory_map_read
LazyBool m_supports_qXfer_memory_map_read
Definition: GDBRemoteCommunicationClient.h:555
llvm::json
Definition: TraceJSONStructs.cpp:19
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_augmented_libraries_svr4_read
LazyBool m_supports_augmented_libraries_svr4_read
Definition: GDBRemoteCommunicationClient.h:557
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetThreadPacketSupported
LazyBool GetThreadPacketSupported(lldb::tid_t tid, llvm::StringRef packetStr)
Definition: GDBRemoteCommunicationClient.cpp:516
lldb_private::process_gdb_remote::GDBRemoteClientBase::SendPacketAndWaitForResponseNoLock
PacketResult SendPacketAndWaitForResponseNoLock(llvm::StringRef payload, StringExtractorGDBRemote &response)
Definition: GDBRemoteClientBase.cpp:222
lldb_private::FileSpec
Definition: FileSpec.h:56
lldb_private::process_gdb_remote::GDBRemoteCommunication::m_compression_type
CompressionType m_compression_type
Definition: GDBRemoteCommunication.h:183
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb::eSymbolTypeAny
@ eSymbolTypeAny
Definition: lldb-enumerations.h:613
lldb_private::SymbolContext::symbol
Symbol * symbol
The Symbol for a given query.
Definition: SymbolContext.h:323
lldb::eSymbolTypeBlock
@ eSymbolTypeBlock
Definition: lldb-enumerations.h:626
lldb_private::Status::Success
bool Success() const
Test for success condition.
Definition: Status.cpp:287
lldb_private::StreamString::GetSize
size_t GetSize() const
Definition: StreamString.cpp:38
StringExtractor::Peek
const char * Peek()
Definition: StringExtractor.h:100
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_qXfer_features_read
LazyBool m_supports_qXfer_features_read
Definition: GDBRemoteCommunicationClient.h:554
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::DeallocateMemory
bool DeallocateMemory(lldb::addr_t addr)
Definition: GDBRemoteCommunicationClient.cpp:1457
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::SetCurrentThreadForRun
bool SetCurrentThreadForRun(uint64_t tid, lldb::pid_t pid=LLDB_INVALID_PROCESS_ID)
Definition: GDBRemoteCommunicationClient.cpp:2733
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetHostInfo
bool GetHostInfo(bool force=false)
Definition: GDBRemoteCommunicationClient.cpp:1201
ProcessGDBRemote.h
LLDBAssert.h
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_z0
bool m_supports_z0
Definition: GDBRemoteCommunicationClient.h:570
lldb_private::ProcessInstanceInfo::GetEffectiveUserID
uint32_t GetEffectiveUserID() const
Definition: ProcessInfo.h:123
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::KillSpawnedProcess
bool KillSpawnedProcess(lldb::pid_t pid)
Definition: GDBRemoteCommunicationClient.cpp:2670
lldb_private::XMLDocument::GetRootElement
XMLNode GetRootElement(const char *required_name=nullptr)
Definition: XML.cpp:63
lldb::eSymbolTypeSourceFile
@ eSymbolTypeSourceFile
Definition: lldb-enumerations.h:622
lldb_private::Range::IsValid
bool IsValid() const
Definition: RangeMap.h:86
lldb_private::MemoryRegionInfo::SetDirtyPageList
void SetDirtyPageList(std::vector< lldb::addr_t > pagelist)
Definition: MemoryRegionInfo.h:126
lldb_private::XMLNode::GetAttributeValue
std::string GetAttributeValue(const char *name, const char *fail_value=nullptr) const
Definition: XML.cpp:133
lldb_private::ProcessLaunchInfo
Definition: ProcessLaunchInfo.h:31
lldb_private::ConstString::GetStringRef
llvm::StringRef GetStringRef() const
Get the string value as a llvm::StringRef.
Definition: ConstString.h:202
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_qSymbol
bool m_supports_qSymbol
Definition: GDBRemoteCommunicationClient.h:573
Log.h
lldb::eSymbolTypeUndefined
@ eSymbolTypeUndefined
Definition: lldb-enumerations.h:639
lldb::eSymbolTypeObjectFile
@ eSymbolTypeObjectFile
Definition: lldb-enumerations.h:624
lldb_private::process_gdb_remote::GDBRLog::Memory
@ Memory
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_process_standalone_uuid
UUID m_process_standalone_uuid
Definition: GDBRemoteCommunicationClient.h:593
Args.h
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_watchpoint_support_info
LazyBool m_supports_watchpoint_support_info
Definition: GDBRemoteCommunicationClient.h:542
lldb_private::ArchSpec::SetDistributionId
void SetDistributionId(const char *distribution_id)
Set the distribution id of the architecture.
Definition: ArchSpec.cpp:680
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::WriteRegister
bool WriteRegister(lldb::tid_t tid, uint32_t reg_num, llvm::ArrayRef< uint8_t > data)
Definition: GDBRemoteCommunicationClient.cpp:3467
MemoryRegionInfo.h
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::SetSTDERR
int SetSTDERR(const FileSpec &file_spec)
Definition: GDBRemoteCommunicationClient.cpp:1902
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::Detach
Status Detach(bool keep_stopped, lldb::pid_t pid=LLDB_INVALID_PROCESS_ID)
Definition: GDBRemoteCommunicationClient.cpp:1479
operator<<
Stream & operator<<(Stream &s, const Mangled &obj)
Definition: Mangled.cpp:386
lldb_private::ProcessInstanceInfo::SetEffectiveGroupID
void SetEffectiveGroupID(uint32_t gid)
Definition: ProcessInfo.h:133
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::Stat
llvm::Optional< GDBRemoteFStatData > Stat(const FileSpec &file_spec)
Definition: GDBRemoteCommunicationClient.cpp:3108
lldb_private::XMLNode::GetAttributeValueAsUnsigned
bool GetAttributeValueAsUnsigned(const char *name, uint64_t &value, uint64_t fail_value=0, int base=0) const
Definition: XML.cpp:154
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::ReadMemoryTags
lldb::DataBufferSP ReadMemoryTags(lldb::addr_t addr, size_t len, int32_t type)
Definition: GDBRemoteCommunicationClient.cpp:617
UnixSignals.h
lldb_private::process_gdb_remote::GDBRemoteCommunication::PacketResult::ErrorNoSequenceLock
@ ErrorNoSequenceLock
lldb_private::MemoryRegionInfo::SetExecutable
void SetExecutable(OptionalBool val)
Definition: MemoryRegionInfo.h:58
calculate_standard_deviation
duration< float > calculate_standard_deviation(const std::vector< duration< float >> &v)
Definition: GDBRemoteCommunicationClient.cpp:2428
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_detach_stay_stopped
LazyBool m_supports_detach_stay_stopped
Definition: GDBRemoteCommunicationClient.h:543
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_memory_region_info
LazyBool m_supports_memory_region_info
Definition: GDBRemoteCommunicationClient.h:541
lldb_private::ProcessInfo::GroupIDIsValid
bool GroupIDIsValid() const
Definition: ProcessInfo.h:55
lldb_private::ArchSpec::SetTriple
bool SetTriple(const llvm::Triple &triple)
Architecture triple setter.
Definition: ArchSpec.cpp:740
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetAddressingBits
uint32_t GetAddressingBits()
Definition: GDBRemoteCommunicationClient.cpp:1420
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetQXferMemoryMapReadSupported
bool GetQXferMemoryMapReadSupported()
Definition: GDBRemoteCommunicationClient.cpp:170
lldb_private::ProcessInfo::SetArg0
void SetArg0(llvm::StringRef arg)
Definition: ProcessInfo.cpp:79
lldb_private::ProcessInstanceInfoMatch::GetProcessInfo
ProcessInstanceInfo & GetProcessInfo()
Definition: ProcessInfo.h:174
lldb_private::StreamString::Clear
void Clear()
Definition: StreamString.cpp:31
lldb_private::StructuredData::ObjectSP
std::shared_ptr< Object > ObjectSP
Definition: StructuredData.h:59
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_supports_qUserName
bool m_supports_qUserName
Definition: GDBRemoteCommunicationClient.h:569
lldb_private::StreamString::GetData
const char * GetData() const
Definition: StreamString.h:43
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_curr_tid_run
lldb::tid_t m_curr_tid_run
Current gdb remote protocol thread identifier for continue, step, etc.
Definition: GDBRemoteCommunicationClient.h:586
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::Unlink
Status Unlink(const FileSpec &file_spec)
Definition: GDBRemoteCommunicationClient.cpp:3325
lldb_private::Status::SetErrorStringWithFormat
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:255
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetQXferLibrariesReadSupported
bool GetQXferLibrariesReadSupported()
Definition: GDBRemoteCommunicationClient.cpp:149
lldb_private::process_gdb_remote::GDBRemoteCommunication::PacketResult::ErrorSendFailed
@ ErrorSendFailed
lldb_private::NameMatch::EndsWith
@ EndsWith
StreamString.h
lldb_private::process_gdb_remote::CompressionType::LZMA
@ LZMA
lldb_private::process_gdb_remote::GDBRemoteCommunication::m_supports_qEcho
LazyBool m_supports_qEcho
Definition: GDBRemoteCommunication.h:176
lldb_private::process_gdb_remote::GDBRemoteCommunication::m_send_acks
bool m_send_acks
Definition: GDBRemoteCommunication.h:178
lldb_private::ProcessInstanceInfoMatch::MatchAllProcesses
bool MatchAllProcesses() const
Definition: ProcessInfo.cpp:299
lldb_private::MemoryRegionInfo::eYes
@ eYes
Definition: MemoryRegionInfo.h:25
lldb_private::NameMatch::RegularExpression
@ RegularExpression
StringExtractorGDBRemote::eResponse
@ eResponse
Definition: StringExtractorGDBRemote.h:182
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::GetFileExists
bool GetFileExists(const FileSpec &file_spec)
Definition: GDBRemoteCommunicationClient.cpp:3357
lldb_private::process_gdb_remote::GDBRemoteCommunicationClient::m_curr_pid_run
lldb::pid_t m_curr_pid_run
Current gdb remote protocol process identifier for continue, step, etc.
Definition: GDBRemoteCommunicationClient.h:582
lldb_private::SymbolContextList::GetSize