LLDB  mainline
GDBRemoteCommunicationServerCommon.cpp
Go to the documentation of this file.
1 //===-- GDBRemoteCommunicationServerCommon.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 <cerrno>
12 
13 #ifdef __APPLE__
14 #include <TargetConditionals.h>
15 #endif
16 
17 #include <chrono>
18 #include <cstring>
19 
20 #include "lldb/Core/ModuleSpec.h"
21 #include "lldb/Host/Config.h"
22 #include "lldb/Host/File.h"
23 #include "lldb/Host/FileAction.h"
24 #include "lldb/Host/FileSystem.h"
25 #include "lldb/Host/Host.h"
26 #include "lldb/Host/HostInfo.h"
27 #include "lldb/Host/SafeMachO.h"
29 #include "lldb/Symbol/ObjectFile.h"
30 #include "lldb/Target/Platform.h"
31 #include "lldb/Utility/Endian.h"
32 #include "lldb/Utility/GDBRemote.h"
33 #include "lldb/Utility/Log.h"
36 #include "llvm/ADT/StringSwitch.h"
37 #include "llvm/ADT/Triple.h"
38 #include "llvm/Support/JSON.h"
39 
40 #include "ProcessGDBRemoteLog.h"
42 
43 #ifdef __ANDROID__
45 #endif
46 
47 
48 using namespace lldb;
49 using namespace lldb_private::process_gdb_remote;
50 using namespace lldb_private;
51 
52 #ifdef __ANDROID__
53 const static uint32_t g_default_packet_timeout_sec = 20; // seconds
54 #else
55 const static uint32_t g_default_packet_timeout_sec = 0; // not specified
56 #endif
57 
58 // GDBRemoteCommunicationServerCommon constructor
59 GDBRemoteCommunicationServerCommon::GDBRemoteCommunicationServerCommon(
60  const char *comm_name, const char *listener_name)
61  : GDBRemoteCommunicationServer(comm_name, listener_name),
62  m_process_launch_info(), m_process_launch_error(), m_proc_infos(),
63  m_proc_infos_index(0) {
171 }
172 
173 // Destructor
175  default;
176 
179  StringExtractorGDBRemote &packet) {
180  StreamString response;
181 
182  // $cputype:16777223;cpusubtype:3;ostype:Darwin;vendor:apple;endian:little;ptrsize:8;#00
183 
184  ArchSpec host_arch(HostInfo::GetArchitecture());
185  const llvm::Triple &host_triple = host_arch.GetTriple();
186  response.PutCString("triple:");
187  response.PutStringAsRawHex8(host_triple.getTriple());
188  response.Printf(";ptrsize:%u;", host_arch.GetAddressByteSize());
189 
190  const char *distribution_id = host_arch.GetDistributionId().AsCString();
191  if (distribution_id) {
192  response.PutCString("distribution_id:");
193  response.PutStringAsRawHex8(distribution_id);
194  response.PutCString(";");
195  }
196 
197 #if defined(__APPLE__)
198  // For parity with debugserver, we'll include the vendor key.
199  response.PutCString("vendor:apple;");
200 
201  // Send out MachO info.
202  uint32_t cpu = host_arch.GetMachOCPUType();
203  uint32_t sub = host_arch.GetMachOCPUSubType();
204  if (cpu != LLDB_INVALID_CPUTYPE)
205  response.Printf("cputype:%u;", cpu);
206  if (sub != LLDB_INVALID_CPUTYPE)
207  response.Printf("cpusubtype:%u;", sub);
208 
209  if (cpu == llvm::MachO::CPU_TYPE_ARM || cpu == llvm::MachO::CPU_TYPE_ARM64) {
210 // Indicate the OS type.
211 #if defined(TARGET_OS_TV) && TARGET_OS_TV == 1
212  response.PutCString("ostype:tvos;");
213 #elif defined(TARGET_OS_WATCH) && TARGET_OS_WATCH == 1
214  response.PutCString("ostype:watchos;");
215 #elif defined(TARGET_OS_BRIDGE) && TARGET_OS_BRIDGE == 1
216  response.PutCString("ostype:bridgeos;");
217 #else
218  response.PutCString("ostype:ios;");
219 #endif
220 
221  // On arm, we use "synchronous" watchpoints which means the exception is
222  // delivered before the instruction executes.
223  response.PutCString("watchpoint_exceptions_received:before;");
224  } else {
225  response.PutCString("ostype:macosx;");
226  response.Printf("watchpoint_exceptions_received:after;");
227  }
228 
229 #else
230  if (host_arch.GetMachine() == llvm::Triple::aarch64 ||
231  host_arch.GetMachine() == llvm::Triple::aarch64_32 ||
232  host_arch.GetMachine() == llvm::Triple::aarch64_be ||
233  host_arch.GetMachine() == llvm::Triple::arm ||
234  host_arch.GetMachine() == llvm::Triple::armeb || host_arch.IsMIPS())
235  response.Printf("watchpoint_exceptions_received:before;");
236  else
237  response.Printf("watchpoint_exceptions_received:after;");
238 #endif
239 
240  switch (endian::InlHostByteOrder()) {
241  case eByteOrderBig:
242  response.PutCString("endian:big;");
243  break;
244  case eByteOrderLittle:
245  response.PutCString("endian:little;");
246  break;
247  case eByteOrderPDP:
248  response.PutCString("endian:pdp;");
249  break;
250  default:
251  response.PutCString("endian:unknown;");
252  break;
253  }
254 
255  llvm::VersionTuple version = HostInfo::GetOSVersion();
256  if (!version.empty()) {
257  response.Format("os_version:{0}", version.getAsString());
258  response.PutChar(';');
259  }
260 
261 #if defined(__APPLE__)
262  llvm::VersionTuple maccatalyst_version = HostInfo::GetMacCatalystVersion();
263  if (!maccatalyst_version.empty()) {
264  response.Format("maccatalyst_version:{0}",
265  maccatalyst_version.getAsString());
266  response.PutChar(';');
267  }
268 #endif
269 
270  if (llvm::Optional<std::string> s = HostInfo::GetOSBuildString()) {
271  response.PutCString("os_build:");
272  response.PutStringAsRawHex8(*s);
273  response.PutChar(';');
274  }
275  if (llvm::Optional<std::string> s = HostInfo::GetOSKernelDescription()) {
276  response.PutCString("os_kernel:");
277  response.PutStringAsRawHex8(*s);
278  response.PutChar(';');
279  }
280 
281  std::string s;
282 #if defined(__APPLE__)
283 
284 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
285  // For iOS devices, we are connected through a USB Mux so we never pretend to
286  // actually have a hostname as far as the remote lldb that is connecting to
287  // this lldb-platform is concerned
288  response.PutCString("hostname:");
289  response.PutStringAsRawHex8("127.0.0.1");
290  response.PutChar(';');
291 #else // #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
292  if (HostInfo::GetHostname(s)) {
293  response.PutCString("hostname:");
294  response.PutStringAsRawHex8(s);
295  response.PutChar(';');
296  }
297 #endif // #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
298 
299 #else // #if defined(__APPLE__)
300  if (HostInfo::GetHostname(s)) {
301  response.PutCString("hostname:");
302  response.PutStringAsRawHex8(s);
303  response.PutChar(';');
304  }
305 #endif // #if defined(__APPLE__)
306 
308  response.Printf("default_packet_timeout:%u;", g_default_packet_timeout_sec);
309 
310  return SendPacketNoLock(response.GetString());
311 }
312 
315  StringExtractorGDBRemote &packet) {
316  // Packet format: "qProcessInfoPID:%i" where %i is the pid
317  packet.SetFilePos(::strlen("qProcessInfoPID:"));
319  if (pid != LLDB_INVALID_PROCESS_ID) {
320  ProcessInstanceInfo proc_info;
321  if (Host::GetProcessInfo(pid, proc_info)) {
322  StreamString response;
323  CreateProcessInfoResponse(proc_info, response);
324  return SendPacketNoLock(response.GetString());
325  }
326  }
327  return SendErrorResponse(1);
328 }
329 
332  StringExtractorGDBRemote &packet) {
333  m_proc_infos_index = 0;
334  m_proc_infos.clear();
335 
336  ProcessInstanceInfoMatch match_info;
337  packet.SetFilePos(::strlen("qfProcessInfo"));
338  if (packet.GetChar() == ':') {
339  llvm::StringRef key;
340  llvm::StringRef value;
341  while (packet.GetNameColonValue(key, value)) {
342  bool success = true;
343  if (key.equals("name")) {
344  StringExtractor extractor(value);
345  std::string file;
346  extractor.GetHexByteString(file);
348  file, FileSpec::Style::native);
349  } else if (key.equals("name_match")) {
350  NameMatch name_match = llvm::StringSwitch<NameMatch>(value)
351  .Case("equals", NameMatch::Equals)
352  .Case("starts_with", NameMatch::StartsWith)
353  .Case("ends_with", NameMatch::EndsWith)
354  .Case("contains", NameMatch::Contains)
355  .Case("regex", NameMatch::RegularExpression)
356  .Default(NameMatch::Ignore);
357  match_info.SetNameMatchType(name_match);
358  if (name_match == NameMatch::Ignore)
359  return SendErrorResponse(2);
360  } else if (key.equals("pid")) {
362  if (value.getAsInteger(0, pid))
363  return SendErrorResponse(2);
364  match_info.GetProcessInfo().SetProcessID(pid);
365  } else if (key.equals("parent_pid")) {
367  if (value.getAsInteger(0, pid))
368  return SendErrorResponse(2);
369  match_info.GetProcessInfo().SetParentProcessID(pid);
370  } else if (key.equals("uid")) {
371  uint32_t uid = UINT32_MAX;
372  if (value.getAsInteger(0, uid))
373  return SendErrorResponse(2);
374  match_info.GetProcessInfo().SetUserID(uid);
375  } else if (key.equals("gid")) {
376  uint32_t gid = UINT32_MAX;
377  if (value.getAsInteger(0, gid))
378  return SendErrorResponse(2);
379  match_info.GetProcessInfo().SetGroupID(gid);
380  } else if (key.equals("euid")) {
381  uint32_t uid = UINT32_MAX;
382  if (value.getAsInteger(0, uid))
383  return SendErrorResponse(2);
384  match_info.GetProcessInfo().SetEffectiveUserID(uid);
385  } else if (key.equals("egid")) {
386  uint32_t gid = UINT32_MAX;
387  if (value.getAsInteger(0, gid))
388  return SendErrorResponse(2);
389  match_info.GetProcessInfo().SetEffectiveGroupID(gid);
390  } else if (key.equals("all_users")) {
391  match_info.SetMatchAllUsers(
392  OptionArgParser::ToBoolean(value, false, &success));
393  } else if (key.equals("triple")) {
394  match_info.GetProcessInfo().GetArchitecture() =
395  HostInfo::GetAugmentedArchSpec(value);
396  } else {
397  success = false;
398  }
399 
400  if (!success)
401  return SendErrorResponse(2);
402  }
403  }
404 
405  if (Host::FindProcesses(match_info, m_proc_infos)) {
406  // We found something, return the first item by calling the get subsequent
407  // process info packet handler...
408  return Handle_qsProcessInfo(packet);
409  }
410  return SendErrorResponse(3);
411 }
412 
415  StringExtractorGDBRemote &packet) {
416  if (m_proc_infos_index < m_proc_infos.size()) {
417  StreamString response;
420  return SendPacketNoLock(response.GetString());
421  }
422  return SendErrorResponse(4);
423 }
424 
427  StringExtractorGDBRemote &packet) {
428 #if LLDB_ENABLE_POSIX
430  LLDB_LOGF(log, "GDBRemoteCommunicationServerCommon::%s begin", __FUNCTION__);
431 
432  // Packet format: "qUserName:%i" where %i is the uid
433  packet.SetFilePos(::strlen("qUserName:"));
434  uint32_t uid = packet.GetU32(UINT32_MAX);
435  if (uid != UINT32_MAX) {
436  if (llvm::Optional<llvm::StringRef> name =
437  HostInfo::GetUserIDResolver().GetUserName(uid)) {
438  StreamString response;
439  response.PutStringAsRawHex8(*name);
440  return SendPacketNoLock(response.GetString());
441  }
442  }
443  LLDB_LOGF(log, "GDBRemoteCommunicationServerCommon::%s end", __FUNCTION__);
444 #endif
445  return SendErrorResponse(5);
446 }
447 
450  StringExtractorGDBRemote &packet) {
451 #if LLDB_ENABLE_POSIX
452  // Packet format: "qGroupName:%i" where %i is the gid
453  packet.SetFilePos(::strlen("qGroupName:"));
454  uint32_t gid = packet.GetU32(UINT32_MAX);
455  if (gid != UINT32_MAX) {
456  if (llvm::Optional<llvm::StringRef> name =
457  HostInfo::GetUserIDResolver().GetGroupName(gid)) {
458  StreamString response;
459  response.PutStringAsRawHex8(*name);
460  return SendPacketNoLock(response.GetString());
461  }
462  }
463 #endif
464  return SendErrorResponse(6);
465 }
466 
469  StringExtractorGDBRemote &packet) {
470  packet.SetFilePos(::strlen("qSpeedTest:"));
471 
472  llvm::StringRef key;
473  llvm::StringRef value;
474  bool success = packet.GetNameColonValue(key, value);
475  if (success && key.equals("response_size")) {
476  uint32_t response_size = 0;
477  if (!value.getAsInteger(0, response_size)) {
478  if (response_size == 0)
479  return SendOKResponse();
480  StreamString response;
481  uint32_t bytes_left = response_size;
482  response.PutCString("data:");
483  while (bytes_left > 0) {
484  if (bytes_left >= 26) {
485  response.PutCString("ABCDEFGHIJKLMNOPQRSTUVWXYZ");
486  bytes_left -= 26;
487  } else {
488  response.Printf("%*.*s;", bytes_left, bytes_left,
489  "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
490  bytes_left = 0;
491  }
492  }
493  return SendPacketNoLock(response.GetString());
494  }
495  }
496  return SendErrorResponse(7);
497 }
498 
501  StringExtractorGDBRemote &packet) {
502  packet.SetFilePos(::strlen("vFile:open:"));
503  std::string path;
504  packet.GetHexByteStringTerminatedBy(path, ',');
505  if (!path.empty()) {
506  if (packet.GetChar() == ',') {
507  auto flags = File::OpenOptions(packet.GetHexMaxU32(false, 0));
508  if (packet.GetChar() == ',') {
509  mode_t mode = packet.GetHexMaxU32(false, 0600);
510  FileSpec path_spec(path);
511  FileSystem::Instance().Resolve(path_spec);
512  // Do not close fd.
513  auto file = FileSystem::Instance().Open(path_spec, flags, mode, false);
514 
515  StreamString response;
516  response.PutChar('F');
517 
518  int descriptor = File::kInvalidDescriptor;
519  if (file) {
520  descriptor = file.get()->GetDescriptor();
521  response.Printf("%x", descriptor);
522  } else {
523  response.PutCString("-1");
524  std::error_code code = errorToErrorCode(file.takeError());
525  if (code.category() == std::system_category()) {
526  response.Printf(",%x", code.value());
527  }
528  }
529 
530  return SendPacketNoLock(response.GetString());
531  }
532  }
533  }
534  return SendErrorResponse(18);
535 }
536 
537 static GDBErrno system_errno_to_gdb(int err) {
538  switch (err) {
539 #define HANDLE_ERRNO(name, value) \
540  case name: \
541  return GDB_##name;
542 #include "Plugins/Process/gdb-remote/GDBRemoteErrno.def"
543  default:
544  return GDB_EUNKNOWN;
545  }
546 }
547 
550  StringExtractorGDBRemote &packet) {
551  packet.SetFilePos(::strlen("vFile:close:"));
552  int fd = packet.GetS32(-1, 16);
553  int err = -1;
554  int save_errno = 0;
555  if (fd >= 0) {
556  NativeFile file(fd, File::OpenOptions(0), true);
557  Status error = file.Close();
558  err = 0;
559  save_errno = error.GetError();
560  } else {
561  save_errno = EINVAL;
562  }
563  StreamString response;
564  response.PutChar('F');
565  response.Printf("%x", err);
566  if (save_errno)
567  response.Printf(",%x", system_errno_to_gdb(save_errno));
568  return SendPacketNoLock(response.GetString());
569 }
570 
573  StringExtractorGDBRemote &packet) {
574  StreamGDBRemote response;
575  packet.SetFilePos(::strlen("vFile:pread:"));
576  int fd = packet.GetS32(-1, 16);
577  if (packet.GetChar() == ',') {
578  size_t count = packet.GetHexMaxU64(false, SIZE_MAX);
579  if (packet.GetChar() == ',') {
580  off_t offset = packet.GetHexMaxU32(false, UINT32_MAX);
581  if (count == SIZE_MAX) {
582  response.Printf("F-1:%x", EINVAL);
583  return SendPacketNoLock(response.GetString());
584  }
585 
586  std::string buffer(count, 0);
587  NativeFile file(fd, File::eOpenOptionReadOnly, false);
588  Status error = file.Read(static_cast<void *>(&buffer[0]), count, offset);
589  const int save_errno = error.GetError();
590  response.PutChar('F');
591  if (error.Success()) {
592  response.Printf("%zx", count);
593  response.PutChar(';');
594  response.PutEscapedBytes(&buffer[0], count);
595  } else {
596  response.PutCString("-1");
597  if (save_errno)
598  response.Printf(",%x", system_errno_to_gdb(save_errno));
599  }
600  return SendPacketNoLock(response.GetString());
601  }
602  }
603  return SendErrorResponse(21);
604 }
605 
608  StringExtractorGDBRemote &packet) {
609  packet.SetFilePos(::strlen("vFile:pwrite:"));
610 
611  StreamGDBRemote response;
612  response.PutChar('F');
613 
614  int fd = packet.GetS32(-1, 16);
615  if (packet.GetChar() == ',') {
616  off_t offset = packet.GetHexMaxU32(false, UINT32_MAX);
617  if (packet.GetChar() == ',') {
618  std::string buffer;
619  if (packet.GetEscapedBinaryData(buffer)) {
620  NativeFile file(fd, File::eOpenOptionWriteOnly, false);
621  size_t count = buffer.size();
622  Status error =
623  file.Write(static_cast<const void *>(&buffer[0]), count, offset);
624  const int save_errno = error.GetError();
625  if (error.Success())
626  response.Printf("%zx", count);
627  else {
628  response.PutCString("-1");
629  if (save_errno)
630  response.Printf(",%x", system_errno_to_gdb(save_errno));
631  }
632  } else {
633  response.Printf("-1,%x", EINVAL);
634  }
635  return SendPacketNoLock(response.GetString());
636  }
637  }
638  return SendErrorResponse(27);
639 }
640 
643  StringExtractorGDBRemote &packet) {
644  packet.SetFilePos(::strlen("vFile:size:"));
645  std::string path;
646  packet.GetHexByteString(path);
647  if (!path.empty()) {
648  uint64_t Size;
649  if (llvm::sys::fs::file_size(path, Size))
650  return SendErrorResponse(5);
651  StreamString response;
652  response.PutChar('F');
653  response.PutHex64(Size);
654  if (Size == UINT64_MAX) {
655  response.PutChar(',');
656  response.PutHex64(Size); // TODO: replace with Host::GetSyswideErrorCode()
657  }
658  return SendPacketNoLock(response.GetString());
659  }
660  return SendErrorResponse(22);
661 }
662 
665  StringExtractorGDBRemote &packet) {
666  packet.SetFilePos(::strlen("vFile:mode:"));
667  std::string path;
668  packet.GetHexByteString(path);
669  if (!path.empty()) {
670  FileSpec file_spec(path);
671  FileSystem::Instance().Resolve(file_spec);
672  std::error_code ec;
673  const uint32_t mode = FileSystem::Instance().GetPermissions(file_spec, ec);
674  StreamString response;
675  if (mode != llvm::sys::fs::perms_not_known)
676  response.Printf("F%x", mode);
677  else
678  response.Printf("F-1,%x", (int)Status(ec).GetError());
679  return SendPacketNoLock(response.GetString());
680  }
681  return SendErrorResponse(23);
682 }
683 
686  StringExtractorGDBRemote &packet) {
687  packet.SetFilePos(::strlen("vFile:exists:"));
688  std::string path;
689  packet.GetHexByteString(path);
690  if (!path.empty()) {
691  bool retcode = llvm::sys::fs::exists(path);
692  StreamString response;
693  response.PutChar('F');
694  response.PutChar(',');
695  if (retcode)
696  response.PutChar('1');
697  else
698  response.PutChar('0');
699  return SendPacketNoLock(response.GetString());
700  }
701  return SendErrorResponse(24);
702 }
703 
706  StringExtractorGDBRemote &packet) {
707  packet.SetFilePos(::strlen("vFile:symlink:"));
708  std::string dst, src;
709  packet.GetHexByteStringTerminatedBy(dst, ',');
710  packet.GetChar(); // Skip ',' char
711  packet.GetHexByteString(src);
712 
713  FileSpec src_spec(src);
714  FileSystem::Instance().Resolve(src_spec);
715  Status error = FileSystem::Instance().Symlink(src_spec, FileSpec(dst));
716 
717  StreamString response;
718  response.Printf("F%x,%x", error.GetError(), error.GetError());
719  return SendPacketNoLock(response.GetString());
720 }
721 
724  StringExtractorGDBRemote &packet) {
725  packet.SetFilePos(::strlen("vFile:unlink:"));
726  std::string path;
727  packet.GetHexByteString(path);
728  Status error(llvm::sys::fs::remove(path));
729  StreamString response;
730  response.Printf("F%x,%x", error.GetError(), error.GetError());
731  return SendPacketNoLock(response.GetString());
732 }
733 
736  StringExtractorGDBRemote &packet) {
737  packet.SetFilePos(::strlen("qPlatform_shell:"));
738  std::string path;
739  std::string working_dir;
740  packet.GetHexByteStringTerminatedBy(path, ',');
741  if (!path.empty()) {
742  if (packet.GetChar() == ',') {
743  // FIXME: add timeout to qPlatform_shell packet
744  // uint32_t timeout = packet.GetHexMaxU32(false, 32);
745  if (packet.GetChar() == ',')
746  packet.GetHexByteString(working_dir);
747  int status, signo;
748  std::string output;
749  FileSpec working_spec(working_dir);
750  FileSystem::Instance().Resolve(working_spec);
751  Status err =
752  Host::RunShellCommand(path.c_str(), working_spec, &status, &signo,
753  &output, std::chrono::seconds(10));
754  StreamGDBRemote response;
755  if (err.Fail()) {
756  response.PutCString("F,");
757  response.PutHex32(UINT32_MAX);
758  } else {
759  response.PutCString("F,");
760  response.PutHex32(status);
761  response.PutChar(',');
762  response.PutHex32(signo);
763  response.PutChar(',');
764  response.PutEscapedBytes(output.c_str(), output.size());
765  }
766  return SendPacketNoLock(response.GetString());
767  }
768  }
769  return SendErrorResponse(24);
770 }
771 
772 template <typename T, typename U>
773 static void fill_clamp(T &dest, U src, typename T::value_type fallback) {
774  static_assert(std::is_unsigned<typename T::value_type>::value,
775  "Destination type must be unsigned.");
776  using UU = typename std::make_unsigned<U>::type;
777  constexpr auto T_max = std::numeric_limits<typename T::value_type>::max();
778  dest = src >= 0 && static_cast<UU>(src) <= T_max ? src : fallback;
779 }
780 
783  StringExtractorGDBRemote &packet) {
784  StreamGDBRemote response;
785  packet.SetFilePos(::strlen("vFile:fstat:"));
786  int fd = packet.GetS32(-1, 16);
787 
788  struct stat file_stats;
789  if (::fstat(fd, &file_stats) == -1) {
790  const int save_errno = errno;
791  response.Printf("F-1,%x", system_errno_to_gdb(save_errno));
792  return SendPacketNoLock(response.GetString());
793  }
794 
795  GDBRemoteFStatData data;
796  fill_clamp(data.gdb_st_dev, file_stats.st_dev, 0);
797  fill_clamp(data.gdb_st_ino, file_stats.st_ino, 0);
798  data.gdb_st_mode = file_stats.st_mode;
799  fill_clamp(data.gdb_st_nlink, file_stats.st_nlink, UINT32_MAX);
800  fill_clamp(data.gdb_st_uid, file_stats.st_uid, 0);
801  fill_clamp(data.gdb_st_gid, file_stats.st_gid, 0);
802  fill_clamp(data.gdb_st_rdev, file_stats.st_rdev, 0);
803  data.gdb_st_size = file_stats.st_size;
804 #if !defined(_WIN32)
805  data.gdb_st_blksize = file_stats.st_blksize;
806  data.gdb_st_blocks = file_stats.st_blocks;
807 #else
808  data.gdb_st_blksize = 0;
809  data.gdb_st_blocks = 0;
810 #endif
811  fill_clamp(data.gdb_st_atime, file_stats.st_atime, 0);
812  fill_clamp(data.gdb_st_mtime, file_stats.st_mtime, 0);
813  fill_clamp(data.gdb_st_ctime, file_stats.st_ctime, 0);
814 
815  response.Printf("F%zx;", sizeof(data));
816  response.PutEscapedBytes(&data, sizeof(data));
817  return SendPacketNoLock(response.GetString());
818 }
819 
822  StringExtractorGDBRemote &packet) {
824  "GDBRemoteCommunicationServerCommon::Handle_vFile_Stat() unimplemented");
825 }
826 
829  StringExtractorGDBRemote &packet) {
830  packet.SetFilePos(::strlen("vFile:MD5:"));
831  std::string path;
832  packet.GetHexByteString(path);
833  if (!path.empty()) {
834  StreamGDBRemote response;
835  auto Result = llvm::sys::fs::md5_contents(path);
836  if (!Result) {
837  response.PutCString("F,");
838  response.PutCString("x");
839  } else {
840  response.PutCString("F,");
841  response.PutHex64(Result->low());
842  response.PutHex64(Result->high());
843  }
844  return SendPacketNoLock(response.GetString());
845  }
846  return SendErrorResponse(25);
847 }
848 
851  StringExtractorGDBRemote &packet) {
852  packet.SetFilePos(::strlen("qPlatform_mkdir:"));
853  mode_t mode = packet.GetHexMaxU32(false, UINT32_MAX);
854  if (packet.GetChar() == ',') {
855  std::string path;
856  packet.GetHexByteString(path);
857  Status error(llvm::sys::fs::create_directory(path, mode));
858 
859  StreamGDBRemote response;
860  response.Printf("F%x", error.GetError());
861 
862  return SendPacketNoLock(response.GetString());
863  }
864  return SendErrorResponse(20);
865 }
866 
869  StringExtractorGDBRemote &packet) {
870  packet.SetFilePos(::strlen("qPlatform_chmod:"));
871 
872  auto perms =
873  static_cast<llvm::sys::fs::perms>(packet.GetHexMaxU32(false, UINT32_MAX));
874  if (packet.GetChar() == ',') {
875  std::string path;
876  packet.GetHexByteString(path);
877  Status error(llvm::sys::fs::setPermissions(path, perms));
878 
879  StreamGDBRemote response;
880  response.Printf("F%x", error.GetError());
881 
882  return SendPacketNoLock(response.GetString());
883  }
884  return SendErrorResponse(19);
885 }
886 
889  StringExtractorGDBRemote &packet) {
890  // Parse client-indicated features.
891  llvm::SmallVector<llvm::StringRef, 4> client_features;
892  packet.GetStringRef().split(client_features, ';');
893  return SendPacketNoLock(llvm::join(HandleFeatures(client_features), ";"));
894 }
895 
898  StringExtractorGDBRemote &packet) {
899  packet.SetFilePos(::strlen("QSetDetachOnError:"));
900  if (packet.GetU32(0))
901  m_process_launch_info.GetFlags().Set(eLaunchFlagDetachOnError);
902  else
903  m_process_launch_info.GetFlags().Clear(eLaunchFlagDetachOnError);
904  return SendOKResponse();
905 }
906 
909  StringExtractorGDBRemote &packet) {
910  // Send response first before changing m_send_acks to we ack this packet
911  PacketResult packet_result = SendOKResponse();
912  m_send_acks = false;
913  return packet_result;
914 }
915 
918  StringExtractorGDBRemote &packet) {
919  packet.SetFilePos(::strlen("QSetSTDIN:"));
920  FileAction file_action;
921  std::string path;
922  packet.GetHexByteString(path);
923  const bool read = true;
924  const bool write = false;
925  if (file_action.Open(STDIN_FILENO, FileSpec(path), read, write)) {
927  return SendOKResponse();
928  }
929  return SendErrorResponse(15);
930 }
931 
934  StringExtractorGDBRemote &packet) {
935  packet.SetFilePos(::strlen("QSetSTDOUT:"));
936  FileAction file_action;
937  std::string path;
938  packet.GetHexByteString(path);
939  const bool read = false;
940  const bool write = true;
941  if (file_action.Open(STDOUT_FILENO, FileSpec(path), read, write)) {
943  return SendOKResponse();
944  }
945  return SendErrorResponse(16);
946 }
947 
950  StringExtractorGDBRemote &packet) {
951  packet.SetFilePos(::strlen("QSetSTDERR:"));
952  FileAction file_action;
953  std::string path;
954  packet.GetHexByteString(path);
955  const bool read = false;
956  const bool write = true;
957  if (file_action.Open(STDERR_FILENO, FileSpec(path), read, write)) {
959  return SendOKResponse();
960  }
961  return SendErrorResponse(17);
962 }
963 
966  StringExtractorGDBRemote &packet) {
968  return SendOKResponse();
969  StreamString response;
970  response.PutChar('E');
971  response.PutCString(m_process_launch_error.AsCString("<unknown error>"));
972  return SendPacketNoLock(response.GetString());
973 }
974 
977  StringExtractorGDBRemote &packet) {
978  packet.SetFilePos(::strlen("QEnvironment:"));
979  const uint32_t bytes_left = packet.GetBytesLeft();
980  if (bytes_left > 0) {
982  return SendOKResponse();
983  }
984  return SendErrorResponse(12);
985 }
986 
989  StringExtractorGDBRemote &packet) {
990  packet.SetFilePos(::strlen("QEnvironmentHexEncoded:"));
991  const uint32_t bytes_left = packet.GetBytesLeft();
992  if (bytes_left > 0) {
993  std::string str;
994  packet.GetHexByteString(str);
996  return SendOKResponse();
997  }
998  return SendErrorResponse(12);
999 }
1000 
1003  StringExtractorGDBRemote &packet) {
1004  packet.SetFilePos(::strlen("QLaunchArch:"));
1005  const uint32_t bytes_left = packet.GetBytesLeft();
1006  if (bytes_left > 0) {
1007  const char *arch_triple = packet.Peek();
1009  HostInfo::GetAugmentedArchSpec(arch_triple));
1010  return SendOKResponse();
1011  }
1012  return SendErrorResponse(13);
1013 }
1014 
1017  // The 'A' packet is the most over designed packet ever here with redundant
1018  // argument indexes, redundant argument lengths and needed hex encoded
1019  // argument string values. Really all that is needed is a comma separated hex
1020  // encoded argument value list, but we will stay true to the documented
1021  // version of the 'A' packet here...
1022 
1024  int actual_arg_index = 0;
1025 
1026  packet.SetFilePos(1); // Skip the 'A'
1027  bool success = true;
1028  while (success && packet.GetBytesLeft() > 0) {
1029  // Decode the decimal argument string length. This length is the number of
1030  // hex nibbles in the argument string value.
1031  const uint32_t arg_len = packet.GetU32(UINT32_MAX);
1032  if (arg_len == UINT32_MAX)
1033  success = false;
1034  else {
1035  // Make sure the argument hex string length is followed by a comma
1036  if (packet.GetChar() != ',')
1037  success = false;
1038  else {
1039  // Decode the argument index. We ignore this really because who would
1040  // really send down the arguments in a random order???
1041  const uint32_t arg_idx = packet.GetU32(UINT32_MAX);
1042  if (arg_idx == UINT32_MAX)
1043  success = false;
1044  else {
1045  // Make sure the argument index is followed by a comma
1046  if (packet.GetChar() != ',')
1047  success = false;
1048  else {
1049  // Decode the argument string value from hex bytes back into a UTF8
1050  // string and make sure the length matches the one supplied in the
1051  // packet
1052  std::string arg;
1053  if (packet.GetHexByteStringFixedLength(arg, arg_len) !=
1054  (arg_len / 2))
1055  success = false;
1056  else {
1057  // If there are any bytes left
1058  if (packet.GetBytesLeft()) {
1059  if (packet.GetChar() != ',')
1060  success = false;
1061  }
1062 
1063  if (success) {
1064  if (arg_idx == 0)
1066  arg, FileSpec::Style::native);
1068  LLDB_LOGF(log, "LLGSPacketHandler::%s added arg %d: \"%s\"",
1069  __FUNCTION__, actual_arg_index, arg.c_str());
1070  ++actual_arg_index;
1071  }
1072  }
1073  }
1074  }
1075  }
1076  }
1077  }
1078 
1079  if (success) {
1082  return SendOKResponse();
1083  LLDB_LOG(log, "failed to launch exe: {0}", m_process_launch_error);
1084  }
1085  return SendErrorResponse(8);
1086 }
1087 
1090  StringExtractorGDBRemote &packet) {
1091  // Just echo back the exact same packet for qEcho...
1092  return SendPacketNoLock(packet.GetStringRef());
1093 }
1094 
1097  StringExtractorGDBRemote &packet) {
1098  packet.SetFilePos(::strlen("qModuleInfo:"));
1099 
1100  std::string module_path;
1101  packet.GetHexByteStringTerminatedBy(module_path, ';');
1102  if (module_path.empty())
1103  return SendErrorResponse(1);
1104 
1105  if (packet.GetChar() != ';')
1106  return SendErrorResponse(2);
1107 
1108  std::string triple;
1109  packet.GetHexByteString(triple);
1110 
1111  ModuleSpec matched_module_spec = GetModuleInfo(module_path, triple);
1112  if (!matched_module_spec.GetFileSpec())
1113  return SendErrorResponse(3);
1114 
1115  const auto file_offset = matched_module_spec.GetObjectOffset();
1116  const auto file_size = matched_module_spec.GetObjectSize();
1117  const auto uuid_str = matched_module_spec.GetUUID().GetAsString("");
1118 
1119  StreamGDBRemote response;
1120 
1121  if (uuid_str.empty()) {
1122  auto Result = llvm::sys::fs::md5_contents(
1123  matched_module_spec.GetFileSpec().GetPath());
1124  if (!Result)
1125  return SendErrorResponse(5);
1126  response.PutCString("md5:");
1127  response.PutStringAsRawHex8(Result->digest());
1128  } else {
1129  response.PutCString("uuid:");
1130  response.PutStringAsRawHex8(uuid_str);
1131  }
1132  response.PutChar(';');
1133 
1134  const auto &module_arch = matched_module_spec.GetArchitecture();
1135  response.PutCString("triple:");
1136  response.PutStringAsRawHex8(module_arch.GetTriple().getTriple());
1137  response.PutChar(';');
1138 
1139  response.PutCString("file_path:");
1140  response.PutStringAsRawHex8(matched_module_spec.GetFileSpec().GetCString());
1141  response.PutChar(';');
1142  response.PutCString("file_offset:");
1143  response.PutHex64(file_offset);
1144  response.PutChar(';');
1145  response.PutCString("file_size:");
1146  response.PutHex64(file_size);
1147  response.PutChar(';');
1148 
1149  return SendPacketNoLock(response.GetString());
1150 }
1151 
1154  StringExtractorGDBRemote &packet) {
1155  namespace json = llvm::json;
1156 
1157  packet.SetFilePos(::strlen("jModulesInfo:"));
1158 
1160  if (!object_sp)
1161  return SendErrorResponse(1);
1162 
1163  StructuredData::Array *packet_array = object_sp->GetAsArray();
1164  if (!packet_array)
1165  return SendErrorResponse(2);
1166 
1167  json::Array response_array;
1168  for (size_t i = 0; i < packet_array->GetSize(); ++i) {
1170  packet_array->GetItemAtIndex(i)->GetAsDictionary();
1171  if (!query)
1172  continue;
1173  llvm::StringRef file, triple;
1174  if (!query->GetValueForKeyAsString("file", file) ||
1175  !query->GetValueForKeyAsString("triple", triple))
1176  continue;
1177 
1178  ModuleSpec matched_module_spec = GetModuleInfo(file, triple);
1179  if (!matched_module_spec.GetFileSpec())
1180  continue;
1181 
1182  const auto file_offset = matched_module_spec.GetObjectOffset();
1183  const auto file_size = matched_module_spec.GetObjectSize();
1184  const auto uuid_str = matched_module_spec.GetUUID().GetAsString("");
1185  if (uuid_str.empty())
1186  continue;
1187  const auto triple_str =
1188  matched_module_spec.GetArchitecture().GetTriple().getTriple();
1189  const auto file_path = matched_module_spec.GetFileSpec().GetPath();
1190 
1191  json::Object response{{"uuid", uuid_str},
1192  {"triple", triple_str},
1193  {"file_path", file_path},
1194  {"file_offset", static_cast<int64_t>(file_offset)},
1195  {"file_size", static_cast<int64_t>(file_size)}};
1196  response_array.push_back(std::move(response));
1197  }
1198 
1199  StreamString response;
1200  response.AsRawOstream() << std::move(response_array);
1201  StreamGDBRemote escaped_response;
1202  escaped_response.PutEscapedBytes(response.GetString().data(),
1203  response.GetSize());
1204  return SendPacketNoLock(escaped_response.GetString());
1205 }
1206 
1208  const ProcessInstanceInfo &proc_info, StreamString &response) {
1209  response.Printf(
1210  "pid:%" PRIu64 ";ppid:%" PRIu64 ";uid:%i;gid:%i;euid:%i;egid:%i;",
1211  proc_info.GetProcessID(), proc_info.GetParentProcessID(),
1212  proc_info.GetUserID(), proc_info.GetGroupID(),
1213  proc_info.GetEffectiveUserID(), proc_info.GetEffectiveGroupID());
1214  response.PutCString("name:");
1215  response.PutStringAsRawHex8(proc_info.GetExecutableFile().GetCString());
1216 
1217  response.PutChar(';');
1218  response.PutCString("args:");
1219  response.PutStringAsRawHex8(proc_info.GetArg0());
1220  for (auto &arg : proc_info.GetArguments()) {
1221  response.PutChar('-');
1222  response.PutStringAsRawHex8(arg.ref());
1223  }
1224 
1225  response.PutChar(';');
1226  const ArchSpec &proc_arch = proc_info.GetArchitecture();
1227  if (proc_arch.IsValid()) {
1228  const llvm::Triple &proc_triple = proc_arch.GetTriple();
1229  response.PutCString("triple:");
1230  response.PutStringAsRawHex8(proc_triple.getTriple());
1231  response.PutChar(';');
1232  }
1233 }
1234 
1237  const ProcessInstanceInfo &proc_info, StreamString &response) {
1238  response.Printf("pid:%" PRIx64 ";parent-pid:%" PRIx64
1239  ";real-uid:%x;real-gid:%x;effective-uid:%x;effective-gid:%x;",
1240  proc_info.GetProcessID(), proc_info.GetParentProcessID(),
1241  proc_info.GetUserID(), proc_info.GetGroupID(),
1242  proc_info.GetEffectiveUserID(),
1243  proc_info.GetEffectiveGroupID());
1244 
1245  const ArchSpec &proc_arch = proc_info.GetArchitecture();
1246  if (proc_arch.IsValid()) {
1247  const llvm::Triple &proc_triple = proc_arch.GetTriple();
1248 #if defined(__APPLE__)
1249  // We'll send cputype/cpusubtype.
1250  const uint32_t cpu_type = proc_arch.GetMachOCPUType();
1251  if (cpu_type != 0)
1252  response.Printf("cputype:%" PRIx32 ";", cpu_type);
1253 
1254  const uint32_t cpu_subtype = proc_arch.GetMachOCPUSubType();
1255  if (cpu_subtype != 0)
1256  response.Printf("cpusubtype:%" PRIx32 ";", cpu_subtype);
1257 
1258  const std::string vendor = proc_triple.getVendorName().str();
1259  if (!vendor.empty())
1260  response.Printf("vendor:%s;", vendor.c_str());
1261 #else
1262  // We'll send the triple.
1263  response.PutCString("triple:");
1264  response.PutStringAsRawHex8(proc_triple.getTriple());
1265  response.PutChar(';');
1266 #endif
1267  std::string ostype = std::string(proc_triple.getOSName());
1268  // Adjust so ostype reports ios for Apple/ARM and Apple/ARM64.
1269  if (proc_triple.getVendor() == llvm::Triple::Apple) {
1270  switch (proc_triple.getArch()) {
1271  case llvm::Triple::arm:
1272  case llvm::Triple::thumb:
1273  case llvm::Triple::aarch64:
1274  case llvm::Triple::aarch64_32:
1275  ostype = "ios";
1276  break;
1277  default:
1278  // No change.
1279  break;
1280  }
1281  }
1282  response.Printf("ostype:%s;", ostype.c_str());
1283 
1284  switch (proc_arch.GetByteOrder()) {
1286  response.PutCString("endian:little;");
1287  break;
1288  case lldb::eByteOrderBig:
1289  response.PutCString("endian:big;");
1290  break;
1291  case lldb::eByteOrderPDP:
1292  response.PutCString("endian:pdp;");
1293  break;
1294  default:
1295  // Nothing.
1296  break;
1297  }
1298  // In case of MIPS64, pointer size is depend on ELF ABI For N32 the pointer
1299  // size is 4 and for N64 it is 8
1300  std::string abi = proc_arch.GetTargetABI();
1301  if (!abi.empty())
1302  response.Printf("elf_abi:%s;", abi.c_str());
1303  response.Printf("ptrsize:%d;", proc_arch.GetAddressByteSize());
1304  }
1305 }
1306 
1308  const std::string &module_path, const ArchSpec &arch) {
1309 #ifdef __ANDROID__
1310  return HostInfoAndroid::ResolveLibraryPath(module_path, arch);
1311 #else
1312  FileSpec file_spec(module_path);
1313  FileSystem::Instance().Resolve(file_spec);
1314  return file_spec;
1315 #endif
1316 }
1317 
1318 ModuleSpec
1320  llvm::StringRef triple) {
1321  ArchSpec arch(triple);
1322 
1323  FileSpec req_module_path_spec(module_path);
1324  FileSystem::Instance().Resolve(req_module_path_spec);
1325 
1326  const FileSpec module_path_spec =
1327  FindModuleFile(req_module_path_spec.GetPath(), arch);
1328  const ModuleSpec module_spec(module_path_spec, arch);
1329 
1330  ModuleSpecList module_specs;
1331  if (!ObjectFile::GetModuleSpecifications(module_path_spec, 0, 0,
1332  module_specs))
1333  return ModuleSpec();
1334 
1335  ModuleSpec matched_module_spec;
1336  if (!module_specs.FindMatchingModuleSpec(module_spec, matched_module_spec))
1337  return ModuleSpec();
1338 
1339  return matched_module_spec;
1340 }
1341 
1343  const llvm::ArrayRef<llvm::StringRef> client_features) {
1344  // 128KBytes is a reasonable max packet size--debugger can always use less.
1345  constexpr uint32_t max_packet_size = 128 * 1024;
1346 
1347  // Features common to platform server and llgs.
1348  return {
1349  llvm::formatv("PacketSize={0}", max_packet_size),
1350  "QStartNoAckMode+",
1351  "qEcho+",
1352  "native-signals+",
1353  };
1354 }
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_qSpeedTest
PacketResult Handle_qSpeedTest(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:468
lldb_private::ProcessInfo::GetArguments
Args & GetArguments()
Definition: ProcessInfo.h:75
lldb_private::Stream::Format
void Format(const char *format, Args &&... args)
Definition: Stream.h:309
lldb_private::ProcessInstanceInfo
Definition: ProcessInfo.h:108
lldb_private::ProcessInstanceInfoMatch::SetNameMatchType
void SetNameMatchType(NameMatch name_match_type)
Definition: ProcessInfo.h:184
StringExtractorGDBRemote::eServerPacketType_qUserName
@ eServerPacketType_qUserName
Definition: StringExtractorGDBRemote.h:66
lldb_private::FileSystem::Open
int Open(const char *path, int flags, int mode)
Wraps ::open in a platform-independent way.
Definition: FileSystemPosix.cpp:79
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_qsProcessInfo
PacketResult Handle_qsProcessInfo(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:414
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::GetModuleInfo
ModuleSpec GetModuleInfo(llvm::StringRef module_path, llvm::StringRef triple)
Definition: GDBRemoteCommunicationServerCommon.cpp:1319
lldb_private::ArchSpec::GetByteOrder
lldb::ByteOrder GetByteOrder() const
Returns the byte order for the architecture specification.
Definition: ArchSpec.cpp:730
lldb_private::Host::FindProcesses
static uint32_t FindProcesses(const ProcessInstanceInfoMatch &match_info, ProcessInstanceInfoList &proc_infos)
Definition: common/Host.cpp:705
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_vFile_Exists
PacketResult Handle_vFile_Exists(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:685
lldb_private::process_gdb_remote::GDBRemoteCommunicationServer::SendErrorResponse
PacketResult SendErrorResponse(const Status &error)
Definition: GDBRemoteCommunicationServer.cpp:106
lldb_private::StructuredData::Dictionary
Definition: StructuredData.h:352
StringExtractorGDBRemote::eServerPacketType_vFile_pread
@ eServerPacketType_vFile_pread
Definition: StringExtractorGDBRemote.h:85
lldb_private::ArchSpec
Definition: ArchSpec.h:33
lldb_private::ArchSpec::IsMIPS
bool IsMIPS() const
if MIPS architecture return true.
Definition: ArchSpec.cpp:545
FileSystem.h
lldb_private::process_gdb_remote::GDBRemoteFStatData::gdb_st_rdev
llvm::support::ubig32_t gdb_st_rdev
Definition: GDBRemoteCommunication.h:64
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_qGroupName
PacketResult Handle_qGroupName(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:449
lldb_private::process_gdb_remote::GDBRemoteFStatData::gdb_st_blocks
llvm::support::ubig64_t gdb_st_blocks
Definition: GDBRemoteCommunication.h:67
lldb_private::ProcessInfo::SetArchitecture
void SetArchitecture(const ArchSpec &arch)
Definition: ProcessInfo.h:65
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::ArchSpec::GetMachine
llvm::Triple::ArchType GetMachine() const
Returns a machine family for the current architecture.
Definition: ArchSpec.cpp:667
ModuleSpec.h
StringExtractor::SetFilePos
void SetFilePos(uint32_t idx)
Definition: StringExtractor.h:39
lldb_private::StructuredData::Array
Definition: StructuredData.h:165
lldb_private::ObjectFile::GetModuleSpecifications
static size_t GetModuleSpecifications(const FileSpec &file, lldb::offset_t file_offset, lldb::offset_t file_size, ModuleSpecList &specs, lldb::DataBufferSP data_sp=lldb::DataBufferSP())
StringExtractor::GetBytesLeft
size_t GetBytesLeft()
Definition: StringExtractor.h:52
StructuredData.h
lldb_private::process_gdb_remote::GDBRemoteFStatData::gdb_st_dev
llvm::support::ubig32_t gdb_st_dev
Definition: GDBRemoteCommunication.h:58
StringExtractorGDBRemote::eServerPacketType_A
@ eServerPacketType_A
Definition: StringExtractorGDBRemote.h:52
Host.h
StringExtractor::GetStringRef
llvm::StringRef GetStringRef() const
Definition: StringExtractor.h:48
lldb_private::process_gdb_remote::GDB_EUNKNOWN
@ GDB_EUNKNOWN
Definition: GDBRemoteCommunication.h:78
lldb_private::ProcessInfo::GetGroupID
uint32_t GetGroupID() const
Definition: ProcessInfo.h:51
lldb_private::NativeFile::Read
Status Read(void *buf, size_t &num_bytes) override
Read bytes from a file from the current file position into buf.
Definition: File.cpp:490
lldb_private::ProcessInstanceInfoMatch::SetMatchAllUsers
void SetMatchAllUsers(bool b)
Definition: ProcessInfo.h:180
lldb_private::File::OpenOptions
OpenOptions
Definition: File.h:49
lldb_private::ProcessInfo::GetUserID
uint32_t GetUserID() const
Definition: ProcessInfo.h:49
GDBRemoteCommunicationServerCommon.h
lldb_private::process_gdb_remote::GDBRemoteCommunication::PacketResult
PacketResult
Definition: GDBRemoteCommunication.h:91
fill_clamp
static void fill_clamp(T &dest, U src, typename T::value_type fallback)
Definition: GDBRemoteCommunicationServerCommon.cpp:773
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_vFile_Mode
PacketResult Handle_vFile_Mode(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:664
lldb_private::ModuleSpecList
Definition: ModuleSpec.h:274
StringExtractorGDBRemote::eServerPacketType_QStartNoAckMode
@ eServerPacketType_QStartNoAckMode
Definition: StringExtractorGDBRemote.h:78
lldb_private::process_gdb_remote::GDBRemoteFStatData::gdb_st_size
llvm::support::ubig64_t gdb_st_size
Definition: GDBRemoteCommunication.h:65
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_vFile_pRead
PacketResult Handle_vFile_pRead(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:572
lldb_private::NameMatch::StartsWith
@ StartsWith
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:247
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_qPlatform_shell
PacketResult Handle_qPlatform_shell(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:735
lldb_private::Flags::Clear
ValueType Clear(ValueType mask=~static_cast< ValueType >(0))
Clear one or more flags.
Definition: Flags.h:61
lldb_private::Args::AppendArgument
void AppendArgument(llvm::StringRef arg_str, char quote_char='\0')
Appends a new argument to the end of the list argument list.
Definition: Args.cpp:318
lldb_private::ProcessInstanceInfo::GetEffectiveGroupID
uint32_t GetEffectiveGroupID() const
Definition: ProcessInfo.h:125
lldb_private::process_gdb_remote::GDBRemoteCommunicationServer
Definition: GDBRemoteCommunicationServer.h:28
StringExtractorGDBRemote::eServerPacketType_vFile_stat
@ eServerPacketType_vFile_stat
Definition: StringExtractorGDBRemote.h:92
lldb_private::ProcessInfo::SetUserID
void SetUserID(uint32_t uid)
Definition: ProcessInfo.h:57
lldb_private::ProcessInstanceInfoMatch
Definition: ProcessInfo.h:163
OptionArgParser.h
lldb_private::ProcessInfo::GetProcessID
lldb::pid_t GetProcessID() const
Definition: ProcessInfo.h:67
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:193
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::LaunchProcess
virtual Status LaunchProcess()=0
Launch a process with the current launch settings.
system_errno_to_gdb
static GDBErrno system_errno_to_gdb(int err)
Definition: GDBRemoteCommunicationServerCommon.cpp:537
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_QEnvironment
PacketResult Handle_QEnvironment(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:976
lldb_private::ProcessLaunchInfo::GetFlags
Flags & GetFlags()
Definition: ProcessLaunchInfo.h:64
StringExtractor::GetHexMaxU32
uint32_t GetHexMaxU32(bool little_endian, uint32_t fail_value)
Definition: StringExtractor.cpp:155
lldb_private::ProcessInfo::SetProcessID
void SetProcessID(lldb::pid_t pid)
Definition: ProcessInfo.h:69
lldb_private::process_gdb_remote::GDBRemoteFStatData::gdb_st_uid
llvm::support::ubig32_t gdb_st_uid
Definition: GDBRemoteCommunication.h:62
lldb_private::ProcessInstanceInfo::SetEffectiveUserID
void SetEffectiveUserID(uint32_t uid)
Definition: ProcessInfo.h:131
StringExtractorGDBRemote.h
StringExtractorGDBRemote::eServerPacketType_qPlatform_chmod
@ eServerPacketType_qPlatform_chmod
Definition: StringExtractorGDBRemote.h:82
StringExtractorGDBRemote::eServerPacketType_QEnvironment
@ eServerPacketType_QEnvironment
Definition: StringExtractorGDBRemote.h:69
lldb_private::process_gdb_remote::GDBRemoteFStatData::gdb_st_ctime
llvm::support::ubig32_t gdb_st_ctime
Definition: GDBRemoteCommunication.h:70
lldb_private::ArchSpec::GetTriple
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:444
lldb_private::process_gdb_remote::GDBRemoteFStatData::gdb_st_ino
llvm::support::ubig32_t gdb_st_ino
Definition: GDBRemoteCommunication.h:59
StringExtractor
Definition: StringExtractor.h:19
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_QEnvironmentHexEncoded
PacketResult Handle_QEnvironmentHexEncoded(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:988
LLDB_INVALID_CPUTYPE
#define LLDB_INVALID_CPUTYPE
Definition: lldb-defines.h:94
StringExtractorGDBRemote::eServerPacketType_QSetSTDOUT
@ eServerPacketType_QSetSTDOUT
Definition: StringExtractorGDBRemote.h:75
lldb_private::ProcessLaunchInfo::AppendFileAction
void AppendFileAction(const FileAction &info)
Definition: ProcessLaunchInfo.h:40
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_vFile_Open
PacketResult Handle_vFile_Open(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:500
lldb_private::process_gdb_remote::GDBRemoteFStatData::gdb_st_blksize
llvm::support::ubig64_t gdb_st_blksize
Definition: GDBRemoteCommunication.h:66
lldb_private::Stream::PutStringAsRawHex8
size_t PutStringAsRawHex8(llvm::StringRef s)
Definition: Stream.cpp:382
lldb_private::FileAction
Definition: FileAction.h:17
lldb_private::UUID::GetAsString
std::string GetAsString(llvm::StringRef separator="-") const
Definition: UUID.cpp:48
StringExtractorGDBRemote::eServerPacketType_qfProcessInfo
@ eServerPacketType_qfProcessInfo
Definition: StringExtractorGDBRemote.h:53
lldb_private::StreamString::GetString
llvm::StringRef GetString() const
Definition: StreamString.cpp:51
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_vFile_Size
PacketResult Handle_vFile_Size(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:642
g_default_packet_timeout_sec
const static uint32_t g_default_packet_timeout_sec
Definition: GDBRemoteCommunicationServerCommon.cpp:55
lldb_private::NativeFile::Close
Status Close() override
Flush any buffers and release any resources owned by the file.
Definition: File.cpp:311
StringExtractorGDBRemote::eServerPacketType_vFile_symlink
@ eServerPacketType_vFile_symlink
Definition: StringExtractorGDBRemote.h:93
lldb_private::Environment::insert
std::pair< iterator, bool > insert(llvm::StringRef KeyEqValue)
Definition: Environment.h:71
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_vFile_Close
PacketResult Handle_vFile_Close(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:549
lldb_private::FileSpec::GetCString
const char * GetCString(bool denormalize=true) const
Definition: FileSpec.cpp:362
StringExtractorGDBRemote::eServerPacketType_qPlatform_mkdir
@ eServerPacketType_qPlatform_mkdir
Definition: StringExtractorGDBRemote.h:81
SafeMachO.h
lldb_private::NameMatch
NameMatch
Definition: NameMatches.h:15
lldb_private::ModuleSpec::GetUUID
UUID & GetUUID()
Definition: ModuleSpec.h:98
lldb_private::FileAction::Open
bool Open(int fd, const FileSpec &file_spec, bool read, bool write)
Definition: FileAction.cpp:32
StringExtractorGDBRemote::GetEscapedBinaryData
size_t GetEscapedBinaryData(std::string &str)
Definition: StringExtractorGDBRemote.cpp:497
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_qLaunchSuccess
PacketResult Handle_qLaunchSuccess(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:965
llvm::json
Definition: TraceJSONStructs.cpp:19
Platform.h
lldb_private::FileSpec
Definition: FileSpec.h:56
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb_private::Status::Success
bool Success() const
Test for success condition.
Definition: Status.cpp:288
lldb_private::StreamString::GetSize
size_t GetSize() const
Definition: StreamString.cpp:38
lldb_private::ArchSpec::GetMachOCPUType
uint32_t GetMachOCPUType() const
Definition: ArchSpec.cpp:635
StringExtractor::Peek
const char * Peek()
Definition: StringExtractor.h:100
StringExtractorGDBRemote::eServerPacketType_vFile_fstat
@ eServerPacketType_vFile_fstat
Definition: StringExtractorGDBRemote.h:91
lldb_private::ProcessInstanceInfo::GetEffectiveUserID
uint32_t GetEffectiveUserID() const
Definition: ProcessInfo.h:123
StringExtractorGDBRemote::eServerPacketType_vFile_size
@ eServerPacketType_vFile_size
Definition: StringExtractorGDBRemote.h:87
Log.h
lldb_private::process_gdb_remote::GDBRemoteFStatData::gdb_st_nlink
llvm::support::ubig32_t gdb_st_nlink
Definition: GDBRemoteCommunication.h:61
StringExtractorGDBRemote::eServerPacketType_qProcessInfoPID
@ eServerPacketType_qProcessInfoPID
Definition: StringExtractorGDBRemote.h:64
lldb_private::ProcessInstanceInfo::SetEffectiveGroupID
void SetEffectiveGroupID(uint32_t gid)
Definition: ProcessInfo.h:133
lldb_private::Host::RunShellCommand
static Status RunShellCommand(llvm::StringRef command, const FileSpec &working_dir, int *status_ptr, int *signo_ptr, std::string *command_output, const Timeout< std::micro > &timeout, bool run_in_shell=true, bool hide_stderr=false)
Run a shell command.
Definition: common/Host.cpp:468
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::m_proc_infos
ProcessInstanceInfoList m_proc_infos
Definition: GDBRemoteCommunicationServerCommon.h:37
lldb_private::Status::Fail
bool Fail() const
Test for error condition.
Definition: Status.cpp:182
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_vFile_Stat
PacketResult Handle_vFile_Stat(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:821
lldb_private::ProcessInstanceInfoMatch::GetProcessInfo
ProcessInstanceInfo & GetProcessInfo()
Definition: ProcessInfo.h:174
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_qProcessInfoPID
PacketResult Handle_qProcessInfoPID(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:314
lldb_private::StructuredData::ObjectSP
std::shared_ptr< Object > ObjectSP
Definition: StructuredData.h:59
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_QSetDetachOnError
PacketResult Handle_QSetDetachOnError(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:897
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::m_process_launch_error
Status m_process_launch_error
Definition: GDBRemoteCommunicationServerCommon.h:36
lldb_private::NameMatch::EndsWith
@ EndsWith
StringExtractorGDBRemote::eServerPacketType_QSetDetachOnError
@ eServerPacketType_QSetDetachOnError
Definition: StringExtractorGDBRemote.h:73
StreamString.h
lldb_private::process_gdb_remote::GDBRemoteCommunication::m_send_acks
bool m_send_acks
Definition: GDBRemoteCommunication.h:178
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::RegisterMemberFunctionHandler
void RegisterMemberFunctionHandler(StringExtractorGDBRemote::ServerPacketType packet_type, PacketResult(T::*handler)(StringExtractorGDBRemote &packet))
Definition: GDBRemoteCommunicationServerCommon.h:119
lldb_private::NameMatch::RegularExpression
@ RegularExpression
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_qModuleInfo
PacketResult Handle_qModuleInfo(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:1096
lldb_private::StreamString
Definition: StreamString.h:23
StringExtractorGDBRemote::eServerPacketType_qGroupName
@ eServerPacketType_qGroupName
Definition: StringExtractorGDBRemote.h:57
GDBRemote.h
StringExtractor::GetHexByteStringTerminatedBy
size_t GetHexByteStringTerminatedBy(std::string &str, char terminator)
Definition: StringExtractor.cpp:322
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_qPlatform_mkdir
PacketResult Handle_qPlatform_mkdir(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:850
StringExtractorGDBRemote::eServerPacketType_qSpeedTest
@ eServerPacketType_qSpeedTest
Definition: StringExtractorGDBRemote.h:65
StringExtractorGDBRemote::eServerPacketType_QSetSTDERR
@ eServerPacketType_QSetSTDERR
Definition: StringExtractorGDBRemote.h:76
lldb_private::ArchSpec::GetMachOCPUSubType
uint32_t GetMachOCPUSubType() const
Definition: ArchSpec.cpp:647
StringExtractorGDBRemote::eServerPacketType_jModulesInfo
@ eServerPacketType_jModulesInfo
Definition: StringExtractorGDBRemote.h:131
StringExtractor::GetHexByteStringFixedLength
size_t GetHexByteStringFixedLength(std::string &str, uint32_t nibble_length)
Definition: StringExtractor.cpp:309
lldb_private::process_gdb_remote::GDBRemoteFStatData::gdb_st_gid
llvm::support::ubig32_t gdb_st_gid
Definition: GDBRemoteCommunication.h:63
lldb_private::File::eOpenOptionReadOnly
@ eOpenOptionReadOnly
Definition: File.h:50
HostInfo.h
StringExtractor::GetChar
char GetChar(char fail_value='\0')
Definition: StringExtractor.cpp:45
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:40
lldb_private::FileSystem::Resolve
void Resolve(llvm::SmallVectorImpl< char > &path)
Resolve path to make it canonical.
Definition: common/FileSystem.cpp:255
lldb_private::ArchSpec::IsValid
bool IsValid() const
Tests if this ArchSpec is valid.
Definition: ArchSpec.h:342
lldb_private::ModuleSpecList::FindMatchingModuleSpec
bool FindMatchingModuleSpec(const ModuleSpec &module_spec, ModuleSpec &match_module_spec) const
Definition: ModuleSpec.h:332
StringExtractor::GetNameColonValue
bool GetNameColonValue(llvm::StringRef &name, llvm::StringRef &value)
Definition: StringExtractor.cpp:335
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_qUserName
PacketResult Handle_qUserName(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:426
lldb_private::Stream::PutChar
size_t PutChar(char ch)
Definition: Stream.cpp:104
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_qfProcessInfo
PacketResult Handle_qfProcessInfo(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:331
lldb_private::process_gdb_remote
Definition: GDBRemoteClientBase.h:17
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::~GDBRemoteCommunicationServerCommon
~GDBRemoteCommunicationServerCommon() override
lldb_private::process_gdb_remote::GDBRemoteFStatData::gdb_st_mtime
llvm::support::ubig32_t gdb_st_mtime
Definition: GDBRemoteCommunication.h:69
StringExtractorGDBRemote::eServerPacketType_qSupported
@ eServerPacketType_qSupported
Definition: StringExtractorGDBRemote.h:121
lldb_private::ArchSpec::GetAddressByteSize
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
Definition: ArchSpec.cpp:683
ObjectFile.h
StringExtractorGDBRemote::eServerPacketType_qLaunchSuccess
@ eServerPacketType_qLaunchSuccess
Definition: StringExtractorGDBRemote.h:62
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_QSetSTDOUT
PacketResult Handle_QSetSTDOUT(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:933
lldb_private::process_gdb_remote::GDBRemoteCommunicationServer::SendUnimplementedResponse
PacketResult SendUnimplementedResponse(const char *packet)
Definition: GDBRemoteCommunicationServer.cpp:92
StringExtractorGDBRemote::eServerPacketType_vFile_unlink
@ eServerPacketType_vFile_unlink
Definition: StringExtractorGDBRemote.h:94
StringExtractorGDBRemote::eServerPacketType_vFile_md5
@ eServerPacketType_vFile_md5
Definition: StringExtractorGDBRemote.h:90
StringExtractorGDBRemote::eServerPacketType_qModuleInfo
@ eServerPacketType_qModuleInfo
Definition: StringExtractorGDBRemote.h:63
StringExtractor::GetHexByteString
size_t GetHexByteString(std::string &str)
Definition: StringExtractor.cpp:300
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_vFile_pWrite
PacketResult Handle_vFile_pWrite(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:607
StringExtractor::GetHexMaxU64
uint64_t GetHexMaxU64(bool little_endian, uint64_t fail_value)
Definition: StringExtractor.cpp:206
lldb_private::File::kInvalidDescriptor
static int kInvalidDescriptor
Definition: File.h:37
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_vFile_MD5
PacketResult Handle_vFile_MD5(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:828
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_vFile_unlink
PacketResult Handle_vFile_unlink(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:723
lldb_private::StructuredData::Object::GetAsArray
Array * GetAsArray()
Definition: StructuredData.h:85
lldb_private::ModuleSpec::GetFileSpec
FileSpec & GetFileSpec()
Definition: ModuleSpec.h:52
lldb_private::ModuleSpec
Definition: ModuleSpec.h:26
lldb_private::File::eOpenOptionWriteOnly
@ eOpenOptionWriteOnly
Definition: File.h:51
lldb_private::OptionArgParser::ToBoolean
static bool ToBoolean(llvm::StringRef s, bool fail_value, bool *success_ptr)
Definition: OptionArgParser.cpp:18
lldb_private::ProcessInstanceInfo::GetParentProcessID
lldb::pid_t GetParentProcessID() const
Definition: ProcessInfo.h:135
lldb_private::Stream::PutHex64
size_t PutHex64(uint64_t uvalue, lldb::ByteOrder byte_order=lldb::eByteOrderInvalid)
Definition: Stream.cpp:272
StringExtractorGDBRemote::eServerPacketType_vFile_exists
@ eServerPacketType_vFile_exists
Definition: StringExtractorGDBRemote.h:89
lldb_private::Status
Definition: Status.h:44
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_QStartNoAckMode
PacketResult Handle_QStartNoAckMode(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:908
uint32_t
lldb_private::ProcessInfo::GetEnvironment
Environment & GetEnvironment()
Definition: ProcessInfo.h:87
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::FindModuleFile
virtual FileSpec FindModuleFile(const std::string &module_path, const ArchSpec &arch)
Definition: GDBRemoteCommunicationServerCommon.cpp:1307
lldb::pid_t
uint64_t pid_t
Definition: lldb-types.h:85
StringExtractorGDBRemote::eServerPacketType_vFile_pwrite
@ eServerPacketType_vFile_pwrite
Definition: StringExtractorGDBRemote.h:86
lldb_private::NameMatch::Contains
@ Contains
lldb_private::endian::InlHostByteOrder
lldb::ByteOrder InlHostByteOrder()
Definition: Endian.h:25
lldb_private::NameMatch::Ignore
@ Ignore
lldb_private::process_gdb_remote::GDBRemoteFStatData::gdb_st_atime
llvm::support::ubig32_t gdb_st_atime
Definition: GDBRemoteCommunication.h:68
lldb_private::HostInfoAndroid::ResolveLibraryPath
static FileSpec ResolveLibraryPath(const std::string &path, const ArchSpec &arch)
Definition: HostInfoAndroid.cpp:34
lldb_private::NativeFile
Definition: File.h:377
lldb_private::Host::GetProcessInfo
static bool GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &proc_info)
Definition: freebsd/Host.cpp:230
lldb_private::StreamGDBRemote
Definition: GDBRemote.h:27
lldb_private::Stream::AsRawOstream
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:357
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:19
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::HandleFeatures
virtual std::vector< std::string > HandleFeatures(llvm::ArrayRef< llvm::StringRef > client_features)
Definition: GDBRemoteCommunicationServerCommon.cpp:1342
lldb_private::process_gdb_remote::GDBRemoteCommunication::SendPacketNoLock
PacketResult SendPacketNoLock(llvm::StringRef payload)
Definition: GDBRemoteCommunication.cpp:116
StringExtractor::GetS32
int32_t GetS32(int32_t fail_value, int base=0)
Definition: StringExtractor.cpp:110
ProcessGDBRemoteLog.h
lldb::eByteOrderPDP
@ eByteOrderPDP
Definition: lldb-enumerations.h:141
lldb_private::FileSystem::GetPermissions
uint32_t GetPermissions(const FileSpec &file_spec) const
Return the current permissions of the given file.
Definition: common/FileSystem.cpp:142
lldb_private::ModuleSpec::GetArchitecture
ArchSpec & GetArchitecture()
Definition: ModuleSpec.h:88
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_jModulesInfo
PacketResult Handle_jModulesInfo(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:1153
LLDB_LOG
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:240
lldb_private::process_gdb_remote::GDBRemoteCommunicationServer::SendOKResponse
PacketResult SendOKResponse()
Definition: GDBRemoteCommunicationServer.cpp:149
StringExtractorGDBRemote::eServerPacketType_QEnvironmentHexEncoded
@ eServerPacketType_QEnvironmentHexEncoded
Definition: StringExtractorGDBRemote.h:96
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_qSupported
PacketResult Handle_qSupported(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:888
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private::FileSystem::Symlink
Status Symlink(const FileSpec &src, const FileSpec &dst)
Definition: FileSystemPosix.cpp:36
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_qPlatform_chmod
PacketResult Handle_qPlatform_chmod(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:868
lldb_private::FileSystem::Instance
static FileSystem & Instance()
Definition: common/FileSystem.cpp:45
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_QSetSTDERR
PacketResult Handle_QSetSTDERR(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:949
lldb_private::process_gdb_remote::GDBErrno
GDBErrno
Definition: GDBRemoteCommunication.h:75
StringExtractorGDBRemote::eServerPacketType_qEcho
@ eServerPacketType_qEcho
Definition: StringExtractorGDBRemote.h:56
StringExtractorGDBRemote::eServerPacketType_QLaunchArch
@ eServerPacketType_QLaunchArch
Definition: StringExtractorGDBRemote.h:71
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::CreateProcessInfoResponse_DebugServerStyle
static void CreateProcessInfoResponse_DebugServerStyle(const ProcessInstanceInfo &proc_info, StreamString &response)
Definition: GDBRemoteCommunicationServerCommon.cpp:1236
lldb_private::ProcessInfo::GetArchitecture
ArchSpec & GetArchitecture()
Definition: ProcessInfo.h:61
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_QSetSTDIN
PacketResult Handle_QSetSTDIN(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:917
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::m_proc_infos_index
uint32_t m_proc_infos_index
Definition: GDBRemoteCommunicationServerCommon.h:38
lldb_private::StreamGDBRemote::PutEscapedBytes
int PutEscapedBytes(const void *s, size_t src_len)
Output a block of data to the stream performing GDB-remote escaping.
Definition: GDBRemote.cpp:29
lldb_private::ProcessInfo::GetExecutableFile
FileSpec & GetExecutableFile()
Definition: ProcessInfo.h:42
HostInfoAndroid.h
StringExtractorGDBRemote::eServerPacketType_qPlatform_shell
@ eServerPacketType_qPlatform_shell
Definition: StringExtractorGDBRemote.h:80
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::m_process_launch_info
ProcessLaunchInfo m_process_launch_info
Definition: GDBRemoteCommunicationServerCommon.h:35
StringExtractorGDBRemote::eServerPacketType_vFile_mode
@ eServerPacketType_vFile_mode
Definition: StringExtractorGDBRemote.h:88
lldb_private::NativeFile::Write
Status Write(const void *buf, size_t &num_bytes) override
Write bytes from buf to a file at the current file position.
Definition: File.cpp:549
lldb::eByteOrderBig
@ eByteOrderBig
Definition: lldb-enumerations.h:140
lldb_private::ArchSpec::GetTargetABI
std::string GetTargetABI() const
Return a string representing target application ABI.
Definition: ArchSpec.cpp:547
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_A
PacketResult Handle_A(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:1016
lldb_private::Flags::Set
ValueType Set(ValueType mask)
Set one or more flags by logical OR'ing mask with the current flags.
Definition: Flags.h:73
StringExtractorGDBRemote
Definition: StringExtractorGDBRemote.h:21
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_vFile_FStat
PacketResult Handle_vFile_FStat(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:782
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_vFile_symlink
PacketResult Handle_vFile_symlink(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:705
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_qHostInfo
PacketResult Handle_qHostInfo(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:178
lldb_private::ProcessInfo::GetArg0
llvm::StringRef GetArg0() const
Definition: ProcessInfo.cpp:77
lldb_private::StructuredData::ParseJSON
static ObjectSP ParseJSON(const std::string &json_text)
Definition: StructuredData.cpp:25
lldb_private::Log
Definition: Log.h:49
lldb_private::ArchSpec::GetDistributionId
ConstString GetDistributionId() const
Returns the distribution id of the architecture.
Definition: ArchSpec.cpp:675
lldb_private::Stream::PutCString
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
lldb_private::FileSpec::SetFile
void SetFile(llvm::StringRef path, Style style)
Change the file specified with a new path.
Definition: FileSpec.cpp:172
lldb_private::StructuredData::Dictionary::GetValueForKeyAsString
bool GetValueForKeyAsString(llvm::StringRef key, llvm::StringRef &result) const
Definition: StructuredData.h:433
lldb_private::process_gdb_remote::GDBRemoteFStatData
Definition: GDBRemoteCommunication.h:57
StringExtractorGDBRemote::eServerPacketType_qHostInfo
@ eServerPacketType_qHostInfo
Definition: StringExtractorGDBRemote.h:58
lldb_private::StructuredData::Array::GetItemAtIndex
ObjectSP GetItemAtIndex(size_t idx) const
Definition: StructuredData.h:188
lldb_private::StructuredData::Array::GetSize
size_t GetSize() const
Definition: StructuredData.h:180
lldb_private::GetLogIfAnyCategoriesSet
Log * GetLogIfAnyCategoriesSet(uint32_t mask)
Definition: Logging.cpp:62
lldb_private::ModuleSpec::GetObjectOffset
uint64_t GetObjectOffset() const
Definition: ModuleSpec.h:106
FileAction.h
lldb_private::FileSpec::GetPath
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:346
StringExtractorGDBRemote::eServerPacketType_QSetSTDIN
@ eServerPacketType_QSetSTDIN
Definition: StringExtractorGDBRemote.h:74
StringExtractorGDBRemote::eServerPacketType_qsProcessInfo
@ eServerPacketType_qsProcessInfo
Definition: StringExtractorGDBRemote.h:54
lldb::eByteOrderLittle
@ eByteOrderLittle
Definition: lldb-enumerations.h:142
StringExtractor::GetU32
uint32_t GetU32(uint32_t fail_value, int base=0)
Definition: StringExtractor.cpp:95
StringExtractorGDBRemote::eServerPacketType_vFile_open
@ eServerPacketType_vFile_open
Definition: StringExtractorGDBRemote.h:83
lldb_private::process_gdb_remote::GDBRemoteFStatData::gdb_st_mode
llvm::support::ubig32_t gdb_st_mode
Definition: GDBRemoteCommunication.h:60
lldb
Definition: SBAddress.h:15
LIBLLDB_LOG_PROCESS
#define LIBLLDB_LOG_PROCESS
Definition: Logging.h:15
File.h
Endian.h
lldb_private::ProcessInstanceInfo::SetParentProcessID
void SetParentProcessID(lldb::pid_t pid)
Definition: ProcessInfo.h:137
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_qEcho
PacketResult Handle_qEcho(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:1089
CPU_TYPE_ARM64
#define CPU_TYPE_ARM64
Definition: HostInfoMacOSX.mm:46
lldb_private::ProcessInfo::SetGroupID
void SetGroupID(uint32_t gid)
Definition: ProcessInfo.h:59
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::Handle_QLaunchArch
PacketResult Handle_QLaunchArch(StringExtractorGDBRemote &packet)
Definition: GDBRemoteCommunicationServerCommon.cpp:1002
UINT64_MAX
#define UINT64_MAX
Definition: lldb-defines.h:23
StringExtractorGDBRemote::eServerPacketType_vFile_close
@ eServerPacketType_vFile_close
Definition: StringExtractorGDBRemote.h:84
lldb_private::ModuleSpec::GetObjectSize
uint64_t GetObjectSize() const
Definition: ModuleSpec.h:112
lldb_private::Status::AsCString
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:131
lldb_private::NameMatch::Equals
@ Equals
lldb_private::process_gdb_remote::GDBRemoteCommunicationServerCommon::CreateProcessInfoResponse
static void CreateProcessInfoResponse(const ProcessInstanceInfo &proc_info, StreamString &response)
Definition: GDBRemoteCommunicationServerCommon.cpp:1207