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