LLDB  mainline
ProcessGDBRemote.cpp
Go to the documentation of this file.
1 //===-- ProcessGDBRemote.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 
9 #include "lldb/Host/Config.h"
10 
11 #include <cerrno>
12 #include <cstdlib>
13 #if LLDB_ENABLE_POSIX
14 #include <netinet/in.h>
15 #include <sys/mman.h>
16 #include <sys/socket.h>
17 #include <unistd.h>
18 #endif
19 #include <sys/stat.h>
20 #if defined(__APPLE__)
21 #include <sys/sysctl.h>
22 #endif
23 #include <ctime>
24 #include <sys/types.h>
25 
26 #include <algorithm>
27 #include <csignal>
28 #include <map>
29 #include <memory>
30 #include <mutex>
31 #include <sstream>
32 
34 #include "lldb/Core/Debugger.h"
35 #include "lldb/Core/Module.h"
36 #include "lldb/Core/ModuleSpec.h"
38 #include "lldb/Core/StreamFile.h"
39 #include "lldb/Core/Value.h"
42 #include "lldb/Host/FileSystem.h"
43 #include "lldb/Host/HostThread.h"
44 #include "lldb/Host/PosixApi.h"
48 #include "lldb/Host/XML.h"
60 #include "lldb/Symbol/ObjectFile.h"
61 #include "lldb/Target/ABI.h"
65 #include "lldb/Target/Target.h"
66 #include "lldb/Target/TargetList.h"
68 #include "lldb/Utility/Args.h"
69 #include "lldb/Utility/FileSpec.h"
71 #include "lldb/Utility/State.h"
73 #include "lldb/Utility/Timer.h"
74 
80 #include "ProcessGDBRemote.h"
81 #include "ProcessGDBRemoteLog.h"
82 #include "ThreadGDBRemote.h"
83 #include "lldb/Host/Host.h"
85 
86 #include "llvm/ADT/ScopeExit.h"
87 #include "llvm/ADT/StringSwitch.h"
88 #include "llvm/Support/Threading.h"
89 #include "llvm/Support/raw_ostream.h"
90 
91 #define DEBUGSERVER_BASENAME "debugserver"
92 using namespace lldb;
93 using namespace lldb_private;
94 using namespace lldb_private::process_gdb_remote;
95 
97 
98 namespace lldb {
99 // Provide a function that can easily dump the packet history if we know a
100 // ProcessGDBRemote * value (which we can get from logs or from debugging). We
101 // need the function in the lldb namespace so it makes it into the final
102 // executable since the LLDB shared library only exports stuff in the lldb
103 // namespace. This allows you to attach with a debugger and call this function
104 // and get the packet history dumped to a file.
105 void DumpProcessGDBRemotePacketHistory(void *p, const char *path) {
106  auto file = FileSystem::Instance().Open(
107  FileSpec(path), File::eOpenOptionWrite | File::eOpenOptionCanCreate);
108  if (!file) {
109  llvm::consumeError(file.takeError());
110  return;
111  }
112  StreamFile stream(std::move(file.get()));
113  ((ProcessGDBRemote *)p)->GetGDBRemote().DumpHistory(stream);
114 }
115 } // namespace lldb
116 
117 namespace {
118 
119 #define LLDB_PROPERTIES_processgdbremote
120 #include "ProcessGDBRemoteProperties.inc"
121 
122 enum {
123 #define LLDB_PROPERTIES_processgdbremote
124 #include "ProcessGDBRemotePropertiesEnum.inc"
125 };
126 
127 class PluginProperties : public Properties {
128 public:
129  static ConstString GetSettingName() {
130  return ProcessGDBRemote::GetPluginNameStatic();
131  }
132 
133  PluginProperties() : Properties() {
134  m_collection_sp = std::make_shared<OptionValueProperties>(GetSettingName());
135  m_collection_sp->Initialize(g_processgdbremote_properties);
136  }
137 
138  ~PluginProperties() override {}
139 
140  uint64_t GetPacketTimeout() {
141  const uint32_t idx = ePropertyPacketTimeout;
142  return m_collection_sp->GetPropertyAtIndexAsUInt64(
143  nullptr, idx, g_processgdbremote_properties[idx].default_uint_value);
144  }
145 
146  bool SetPacketTimeout(uint64_t timeout) {
147  const uint32_t idx = ePropertyPacketTimeout;
148  return m_collection_sp->SetPropertyAtIndexAsUInt64(nullptr, idx, timeout);
149  }
150 
151  FileSpec GetTargetDefinitionFile() const {
152  const uint32_t idx = ePropertyTargetDefinitionFile;
153  return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
154  }
155 
156  bool GetUseSVR4() const {
157  const uint32_t idx = ePropertyUseSVR4;
158  return m_collection_sp->GetPropertyAtIndexAsBoolean(
159  nullptr, idx,
160  g_processgdbremote_properties[idx].default_uint_value != 0);
161  }
162 
163  bool GetUseGPacketForReading() const {
164  const uint32_t idx = ePropertyUseGPacketForReading;
165  return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, true);
166  }
167 };
168 
169 typedef std::shared_ptr<PluginProperties> ProcessKDPPropertiesSP;
170 
171 static const ProcessKDPPropertiesSP &GetGlobalPluginProperties() {
172  static ProcessKDPPropertiesSP g_settings_sp;
173  if (!g_settings_sp)
174  g_settings_sp = std::make_shared<PluginProperties>();
175  return g_settings_sp;
176 }
177 
178 } // namespace
179 
180 // TODO Randomly assigning a port is unsafe. We should get an unused
181 // ephemeral port from the kernel and make sure we reserve it before passing it
182 // to debugserver.
183 
184 #if defined(__APPLE__)
185 #define LOW_PORT (IPPORT_RESERVED)
186 #define HIGH_PORT (IPPORT_HIFIRSTAUTO)
187 #else
188 #define LOW_PORT (1024u)
189 #define HIGH_PORT (49151u)
190 #endif
191 
192 ConstString ProcessGDBRemote::GetPluginNameStatic() {
193  static ConstString g_name("gdb-remote");
194  return g_name;
195 }
196 
197 const char *ProcessGDBRemote::GetPluginDescriptionStatic() {
198  return "GDB Remote protocol based debugging plug-in.";
199 }
200 
201 void ProcessGDBRemote::Terminate() {
202  PluginManager::UnregisterPlugin(ProcessGDBRemote::CreateInstance);
203 }
204 
205 lldb::ProcessSP
206 ProcessGDBRemote::CreateInstance(lldb::TargetSP target_sp,
207  ListenerSP listener_sp,
208  const FileSpec *crash_file_path,
209  bool can_connect) {
210  lldb::ProcessSP process_sp;
211  if (crash_file_path == nullptr)
212  process_sp = std::make_shared<ProcessGDBRemote>(target_sp, listener_sp);
213  return process_sp;
214 }
215 
216 std::chrono::seconds ProcessGDBRemote::GetPacketTimeout() {
217  return std::chrono::seconds(GetGlobalPluginProperties()->GetPacketTimeout());
218 }
219 
220 bool ProcessGDBRemote::CanDebug(lldb::TargetSP target_sp,
221  bool plugin_specified_by_name) {
222  if (plugin_specified_by_name)
223  return true;
224 
225  // For now we are just making sure the file exists for a given module
226  Module *exe_module = target_sp->GetExecutableModulePointer();
227  if (exe_module) {
228  ObjectFile *exe_objfile = exe_module->GetObjectFile();
229  // We can't debug core files...
230  switch (exe_objfile->GetType()) {
231  case ObjectFile::eTypeInvalid:
232  case ObjectFile::eTypeCoreFile:
233  case ObjectFile::eTypeDebugInfo:
234  case ObjectFile::eTypeObjectFile:
235  case ObjectFile::eTypeSharedLibrary:
236  case ObjectFile::eTypeStubLibrary:
237  case ObjectFile::eTypeJIT:
238  return false;
239  case ObjectFile::eTypeExecutable:
240  case ObjectFile::eTypeDynamicLinker:
241  case ObjectFile::eTypeUnknown:
242  break;
243  }
244  return FileSystem::Instance().Exists(exe_module->GetFileSpec());
245  }
246  // However, if there is no executable module, we return true since we might
247  // be preparing to attach.
248  return true;
249 }
250 
251 // ProcessGDBRemote constructor
252 ProcessGDBRemote::ProcessGDBRemote(lldb::TargetSP target_sp,
253  ListenerSP listener_sp)
254  : Process(target_sp, listener_sp),
255  m_debugserver_pid(LLDB_INVALID_PROCESS_ID), m_last_stop_packet_mutex(),
256  m_register_info_sp(nullptr),
257  m_async_broadcaster(nullptr, "lldb.process.gdb-remote.async-broadcaster"),
258  m_async_listener_sp(
259  Listener::MakeListener("lldb.process.gdb-remote.async-listener")),
260  m_async_thread_state_mutex(), m_thread_ids(), m_thread_pcs(),
261  m_jstopinfo_sp(), m_jthreadsinfo_sp(), m_continue_c_tids(),
262  m_continue_C_tids(), m_continue_s_tids(), m_continue_S_tids(),
263  m_max_memory_size(0), m_remote_stub_max_memory_size(0),
264  m_addr_to_mmap_size(), m_thread_create_bp_sp(),
265  m_waiting_for_attach(false), m_destroy_tried_resuming(false),
266  m_command_sp(), m_breakpoint_pc_offset(0),
267  m_initial_tid(LLDB_INVALID_THREAD_ID), m_replay_mode(false),
268  m_allow_flash_writes(false), m_erased_flash_ranges() {
270  "async thread should exit");
272  "async thread continue");
274  "async thread did exit");
275 
276  if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator()) {
277  repro::GDBRemoteProvider &provider =
278  g->GetOrCreate<repro::GDBRemoteProvider>();
280  }
281 
283 
284  const uint32_t async_event_mask =
286 
287  if (m_async_listener_sp->StartListeningForEvents(
288  &m_async_broadcaster, async_event_mask) != async_event_mask) {
289  LLDB_LOGF(log,
290  "ProcessGDBRemote::%s failed to listen for "
291  "m_async_broadcaster events",
292  __FUNCTION__);
293  }
294 
295  const uint32_t gdb_event_mask =
296  Communication::eBroadcastBitReadThreadDidExit |
298  if (m_async_listener_sp->StartListeningForEvents(
299  &m_gdb_comm, gdb_event_mask) != gdb_event_mask) {
300  LLDB_LOGF(log,
301  "ProcessGDBRemote::%s failed to listen for m_gdb_comm events",
302  __FUNCTION__);
303  }
304 
305  const uint64_t timeout_seconds =
306  GetGlobalPluginProperties()->GetPacketTimeout();
307  if (timeout_seconds > 0)
308  m_gdb_comm.SetPacketTimeout(std::chrono::seconds(timeout_seconds));
309 
311  GetGlobalPluginProperties()->GetUseGPacketForReading();
312 }
313 
314 // Destructor
316  // m_mach_process.UnregisterNotificationCallbacks (this);
317  Clear();
318  // We need to call finalize on the process before destroying ourselves to
319  // make sure all of the broadcaster cleanup goes as planned. If we destruct
320  // this class, then Process::~Process() might have problems trying to fully
321  // destroy the broadcaster.
322  Finalize();
323 
324  // The general Finalize is going to try to destroy the process and that
325  // SHOULD shut down the async thread. However, if we don't kill it it will
326  // get stranded and its connection will go away so when it wakes up it will
327  // crash. So kill it for sure here.
328  StopAsyncThread();
330 }
331 
332 // PluginInterface
334 
336 
338  const FileSpec &target_definition_fspec) {
339  ScriptInterpreter *interpreter =
341  Status error;
342  StructuredData::ObjectSP module_object_sp(
343  interpreter->LoadPluginModule(target_definition_fspec, error));
344  if (module_object_sp) {
345  StructuredData::DictionarySP target_definition_sp(
346  interpreter->GetDynamicSettings(module_object_sp, &GetTarget(),
347  "gdb-server-target-definition", error));
348 
349  if (target_definition_sp) {
350  StructuredData::ObjectSP target_object(
351  target_definition_sp->GetValueForKey("host-info"));
352  if (target_object) {
353  if (auto host_info_dict = target_object->GetAsDictionary()) {
354  StructuredData::ObjectSP triple_value =
355  host_info_dict->GetValueForKey("triple");
356  if (auto triple_string_value = triple_value->GetAsString()) {
357  std::string triple_string =
358  std::string(triple_string_value->GetValue());
359  ArchSpec host_arch(triple_string.c_str());
360  if (!host_arch.IsCompatibleMatch(GetTarget().GetArchitecture())) {
361  GetTarget().SetArchitecture(host_arch);
362  }
363  }
364  }
365  }
367  StructuredData::ObjectSP breakpoint_pc_offset_value =
368  target_definition_sp->GetValueForKey("breakpoint-pc-offset");
369  if (breakpoint_pc_offset_value) {
370  if (auto breakpoint_pc_int_value =
371  breakpoint_pc_offset_value->GetAsInteger())
372  m_breakpoint_pc_offset = breakpoint_pc_int_value->GetValue();
373  }
374 
375  if (m_register_info_sp->SetRegisterInfo(
376  *target_definition_sp, GetTarget().GetArchitecture()) > 0) {
377  return true;
378  }
379  }
380  }
381  return false;
382 }
383 
385  const llvm::StringRef &comma_separated_regiter_numbers,
386  std::vector<uint32_t> &regnums, int base) {
387  regnums.clear();
388  std::pair<llvm::StringRef, llvm::StringRef> value_pair;
389  value_pair.second = comma_separated_regiter_numbers;
390  do {
391  value_pair = value_pair.second.split(',');
392  if (!value_pair.first.empty()) {
393  uint32_t reg = StringConvert::ToUInt32(value_pair.first.str().c_str(),
394  LLDB_INVALID_REGNUM, base);
395  if (reg != LLDB_INVALID_REGNUM)
396  regnums.push_back(reg);
397  }
398  } while (!value_pair.second.empty());
399  return regnums.size();
400 }
401 
403  if (!force && m_register_info_sp)
404  return;
405 
406  m_register_info_sp = std::make_shared<GDBRemoteDynamicRegisterInfo>();
407 
408  // Check if qHostInfo specified a specific packet timeout for this
409  // connection. If so then lets update our setting so the user knows what the
410  // timeout is and can see it.
411  const auto host_packet_timeout = m_gdb_comm.GetHostDefaultPacketTimeout();
412  if (host_packet_timeout > std::chrono::seconds(0)) {
413  GetGlobalPluginProperties()->SetPacketTimeout(host_packet_timeout.count());
414  }
415 
416  // Register info search order:
417  // 1 - Use the target definition python file if one is specified.
418  // 2 - If the target definition doesn't have any of the info from the
419  // target.xml (registers) then proceed to read the target.xml.
420  // 3 - Fall back on the qRegisterInfo packets.
421 
422  FileSpec target_definition_fspec =
423  GetGlobalPluginProperties()->GetTargetDefinitionFile();
424  if (!FileSystem::Instance().Exists(target_definition_fspec)) {
425  // If the filename doesn't exist, it may be a ~ not having been expanded -
426  // try to resolve it.
427  FileSystem::Instance().Resolve(target_definition_fspec);
428  }
429  if (target_definition_fspec) {
430  // See if we can get register definitions from a python file
431  if (ParsePythonTargetDefinition(target_definition_fspec)) {
432  return;
433  } else {
434  StreamSP stream_sp = GetTarget().GetDebugger().GetAsyncOutputStream();
435  stream_sp->Printf("ERROR: target description file %s failed to parse.\n",
436  target_definition_fspec.GetPath().c_str());
437  }
438  }
439 
440  const ArchSpec &target_arch = GetTarget().GetArchitecture();
441  const ArchSpec &remote_host_arch = m_gdb_comm.GetHostArchitecture();
442  const ArchSpec &remote_process_arch = m_gdb_comm.GetProcessArchitecture();
443 
444  // Use the process' architecture instead of the host arch, if available
445  ArchSpec arch_to_use;
446  if (remote_process_arch.IsValid())
447  arch_to_use = remote_process_arch;
448  else
449  arch_to_use = remote_host_arch;
450 
451  if (!arch_to_use.IsValid())
452  arch_to_use = target_arch;
453 
454  if (GetGDBServerRegisterInfo(arch_to_use))
455  return;
456 
457  char packet[128];
458  uint32_t reg_offset = LLDB_INVALID_INDEX32;
459  uint32_t reg_num = 0;
460  for (StringExtractorGDBRemote::ResponseType response_type =
462  response_type == StringExtractorGDBRemote::eResponse; ++reg_num) {
463  const int packet_len =
464  ::snprintf(packet, sizeof(packet), "qRegisterInfo%x", reg_num);
465  assert(packet_len < (int)sizeof(packet));
466  UNUSED_IF_ASSERT_DISABLED(packet_len);
467  StringExtractorGDBRemote response;
468  if (m_gdb_comm.SendPacketAndWaitForResponse(packet, response, false) ==
470  response_type = response.GetResponseType();
471  if (response_type == StringExtractorGDBRemote::eResponse) {
472  llvm::StringRef name;
473  llvm::StringRef value;
474  ConstString reg_name;
475  ConstString alt_name;
476  ConstString set_name;
477  std::vector<uint32_t> value_regs;
478  std::vector<uint32_t> invalidate_regs;
479  std::vector<uint8_t> dwarf_opcode_bytes;
480  RegisterInfo reg_info = {
481  nullptr, // Name
482  nullptr, // Alt name
483  0, // byte size
484  reg_offset, // offset
485  eEncodingUint, // encoding
486  eFormatHex, // format
487  {
488  LLDB_INVALID_REGNUM, // eh_frame reg num
489  LLDB_INVALID_REGNUM, // DWARF reg num
490  LLDB_INVALID_REGNUM, // generic reg num
491  reg_num, // process plugin reg num
492  reg_num // native register number
493  },
494  nullptr,
495  nullptr,
496  nullptr, // Dwarf expression opcode bytes pointer
497  0 // Dwarf expression opcode bytes length
498  };
499 
500  while (response.GetNameColonValue(name, value)) {
501  if (name.equals("name")) {
502  reg_name.SetString(value);
503  } else if (name.equals("alt-name")) {
504  alt_name.SetString(value);
505  } else if (name.equals("bitsize")) {
506  value.getAsInteger(0, reg_info.byte_size);
507  reg_info.byte_size /= CHAR_BIT;
508  } else if (name.equals("offset")) {
509  if (value.getAsInteger(0, reg_offset))
510  reg_offset = UINT32_MAX;
511  } else if (name.equals("encoding")) {
512  const Encoding encoding = Args::StringToEncoding(value);
513  if (encoding != eEncodingInvalid)
514  reg_info.encoding = encoding;
515  } else if (name.equals("format")) {
516  Format format = eFormatInvalid;
517  if (OptionArgParser::ToFormat(value.str().c_str(), format, nullptr)
518  .Success())
519  reg_info.format = format;
520  else {
521  reg_info.format =
522  llvm::StringSwitch<Format>(value)
523  .Case("binary", eFormatBinary)
524  .Case("decimal", eFormatDecimal)
525  .Case("hex", eFormatHex)
526  .Case("float", eFormatFloat)
527  .Case("vector-sint8", eFormatVectorOfSInt8)
528  .Case("vector-uint8", eFormatVectorOfUInt8)
529  .Case("vector-sint16", eFormatVectorOfSInt16)
530  .Case("vector-uint16", eFormatVectorOfUInt16)
531  .Case("vector-sint32", eFormatVectorOfSInt32)
532  .Case("vector-uint32", eFormatVectorOfUInt32)
533  .Case("vector-float32", eFormatVectorOfFloat32)
534  .Case("vector-uint64", eFormatVectorOfUInt64)
535  .Case("vector-uint128", eFormatVectorOfUInt128)
536  .Default(eFormatInvalid);
537  }
538  } else if (name.equals("set")) {
539  set_name.SetString(value);
540  } else if (name.equals("gcc") || name.equals("ehframe")) {
541  if (value.getAsInteger(0, reg_info.kinds[eRegisterKindEHFrame]))
542  reg_info.kinds[eRegisterKindEHFrame] = LLDB_INVALID_REGNUM;
543  } else if (name.equals("dwarf")) {
544  if (value.getAsInteger(0, reg_info.kinds[eRegisterKindDWARF]))
545  reg_info.kinds[eRegisterKindDWARF] = LLDB_INVALID_REGNUM;
546  } else if (name.equals("generic")) {
547  reg_info.kinds[eRegisterKindGeneric] =
549  } else if (name.equals("container-regs")) {
550  SplitCommaSeparatedRegisterNumberString(value, value_regs, 16);
551  } else if (name.equals("invalidate-regs")) {
552  SplitCommaSeparatedRegisterNumberString(value, invalidate_regs, 16);
553  } else if (name.equals("dynamic_size_dwarf_expr_bytes")) {
554  size_t dwarf_opcode_len = value.size() / 2;
555  assert(dwarf_opcode_len > 0);
556 
557  dwarf_opcode_bytes.resize(dwarf_opcode_len);
558  reg_info.dynamic_size_dwarf_len = dwarf_opcode_len;
559 
560  StringExtractor opcode_extractor(value);
561  uint32_t ret_val =
562  opcode_extractor.GetHexBytesAvail(dwarf_opcode_bytes);
563  assert(dwarf_opcode_len == ret_val);
564  UNUSED_IF_ASSERT_DISABLED(ret_val);
565  reg_info.dynamic_size_dwarf_expr_bytes = dwarf_opcode_bytes.data();
566  }
567  }
568 
569  reg_info.byte_offset = reg_offset;
570  assert(reg_info.byte_size != 0);
571  reg_offset = LLDB_INVALID_INDEX32;
572  if (!value_regs.empty()) {
573  value_regs.push_back(LLDB_INVALID_REGNUM);
574  reg_info.value_regs = value_regs.data();
575  }
576  if (!invalidate_regs.empty()) {
577  invalidate_regs.push_back(LLDB_INVALID_REGNUM);
578  reg_info.invalidate_regs = invalidate_regs.data();
579  }
580 
581  reg_info.name = reg_name.AsCString();
582  // We have to make a temporary ABI here, and not use the GetABI because
583  // this code gets called in DidAttach, when the target architecture
584  // (and consequently the ABI we'll get from the process) may be wrong.
585  if (ABISP abi_sp = ABI::FindPlugin(shared_from_this(), arch_to_use))
586  abi_sp->AugmentRegisterInfo(reg_info);
587 
588  m_register_info_sp->AddRegister(reg_info, reg_name, alt_name, set_name);
589  } else {
590  break; // ensure exit before reg_num is incremented
591  }
592  } else {
593  break;
594  }
595  }
596 
597  if (m_register_info_sp->GetNumRegisters() > 0) {
598  m_register_info_sp->Finalize(GetTarget().GetArchitecture());
599  return;
600  }
601 
602  // We didn't get anything if the accumulated reg_num is zero. See if we are
603  // debugging ARM and fill with a hard coded register set until we can get an
604  // updated debugserver down on the devices. On the other hand, if the
605  // accumulated reg_num is positive, see if we can add composite registers to
606  // the existing primordial ones.
607  bool from_scratch = (m_register_info_sp->GetNumRegisters() == 0);
608 
609  if (!target_arch.IsValid()) {
610  if (arch_to_use.IsValid() &&
611  (arch_to_use.GetMachine() == llvm::Triple::arm ||
612  arch_to_use.GetMachine() == llvm::Triple::thumb) &&
613  arch_to_use.GetTriple().getVendor() == llvm::Triple::Apple)
614  m_register_info_sp->HardcodeARMRegisters(from_scratch);
615  } else if (target_arch.GetMachine() == llvm::Triple::arm ||
616  target_arch.GetMachine() == llvm::Triple::thumb) {
617  m_register_info_sp->HardcodeARMRegisters(from_scratch);
618  }
619 
620  // At this point, we can finalize our register info.
622 }
623 
625  return WillLaunchOrAttach();
626 }
627 
629  return WillLaunchOrAttach();
630 }
631 
633  bool wait_for_launch) {
634  return WillLaunchOrAttach();
635 }
636 
637 Status ProcessGDBRemote::DoConnectRemote(llvm::StringRef remote_url) {
640 
641  if (error.Fail())
642  return error;
643 
644  if (repro::Reproducer::Instance().IsReplaying())
646  else
647  error = ConnectToDebugserver(remote_url);
648 
649  if (error.Fail())
650  return error;
652 
654  if (pid == LLDB_INVALID_PROCESS_ID) {
655  // We don't have a valid process ID, so note that we are connected and
656  // could now request to launch or attach, or get remote process listings...
658  } else {
659  // We have a valid process
660  SetID(pid);
661  GetThreadList();
662  StringExtractorGDBRemote response;
663  if (m_gdb_comm.GetStopReply(response)) {
664  SetLastStopPacket(response);
665 
666  // '?' Packets must be handled differently in non-stop mode
667  if (GetTarget().GetNonStopModeEnabled())
669 
670  Target &target = GetTarget();
671  if (!target.GetArchitecture().IsValid()) {
674  } else {
677  }
678  }
679  }
680 
681  const StateType state = SetThreadStopInfo(response);
682  if (state != eStateInvalid) {
683  SetPrivateState(state);
684  } else
685  error.SetErrorStringWithFormat(
686  "Process %" PRIu64 " was reported after connecting to "
687  "'%s', but state was not stopped: %s",
688  pid, remote_url.str().c_str(), StateAsCString(state));
689  } else
690  error.SetErrorStringWithFormat("Process %" PRIu64
691  " was reported after connecting to '%s', "
692  "but no stop reply packet was received",
693  pid, remote_url.str().c_str());
694  }
695 
696  LLDB_LOGF(log,
697  "ProcessGDBRemote::%s pid %" PRIu64
698  ": normalizing target architecture initial triple: %s "
699  "(GetTarget().GetArchitecture().IsValid() %s, "
700  "m_gdb_comm.GetHostArchitecture().IsValid(): %s)",
701  __FUNCTION__, GetID(),
702  GetTarget().GetArchitecture().GetTriple().getTriple().c_str(),
703  GetTarget().GetArchitecture().IsValid() ? "true" : "false",
704  m_gdb_comm.GetHostArchitecture().IsValid() ? "true" : "false");
705 
706  if (error.Success() && !GetTarget().GetArchitecture().IsValid() &&
708  // Prefer the *process'* architecture over that of the *host*, if
709  // available.
712  else
714  }
715 
716  LLDB_LOGF(log,
717  "ProcessGDBRemote::%s pid %" PRIu64
718  ": normalized target architecture triple: %s",
719  __FUNCTION__, GetID(),
720  GetTarget().GetArchitecture().GetTriple().getTriple().c_str());
721 
722  if (error.Success()) {
723  PlatformSP platform_sp = GetTarget().GetPlatform();
724  if (platform_sp && platform_sp->IsConnected())
725  SetUnixSignals(platform_sp->GetUnixSignals());
726  else
727  SetUnixSignals(UnixSignals::Create(GetTarget().GetArchitecture()));
728  }
729 
730  return error;
731 }
732 
734  Status error;
736  return error;
737 }
738 
739 // Process Control
741  ProcessLaunchInfo &launch_info) {
743  Status error;
744 
745  LLDB_LOGF(log, "ProcessGDBRemote::%s() entered", __FUNCTION__);
746 
747  uint32_t launch_flags = launch_info.GetFlags().Get();
748  FileSpec stdin_file_spec{};
749  FileSpec stdout_file_spec{};
750  FileSpec stderr_file_spec{};
751  FileSpec working_dir = launch_info.GetWorkingDirectory();
752 
753  const FileAction *file_action;
754  file_action = launch_info.GetFileActionForFD(STDIN_FILENO);
755  if (file_action) {
756  if (file_action->GetAction() == FileAction::eFileActionOpen)
757  stdin_file_spec = file_action->GetFileSpec();
758  }
759  file_action = launch_info.GetFileActionForFD(STDOUT_FILENO);
760  if (file_action) {
761  if (file_action->GetAction() == FileAction::eFileActionOpen)
762  stdout_file_spec = file_action->GetFileSpec();
763  }
764  file_action = launch_info.GetFileActionForFD(STDERR_FILENO);
765  if (file_action) {
766  if (file_action->GetAction() == FileAction::eFileActionOpen)
767  stderr_file_spec = file_action->GetFileSpec();
768  }
769 
770  if (log) {
771  if (stdin_file_spec || stdout_file_spec || stderr_file_spec)
772  LLDB_LOGF(log,
773  "ProcessGDBRemote::%s provided with STDIO paths via "
774  "launch_info: stdin=%s, stdout=%s, stderr=%s",
775  __FUNCTION__,
776  stdin_file_spec ? stdin_file_spec.GetCString() : "<null>",
777  stdout_file_spec ? stdout_file_spec.GetCString() : "<null>",
778  stderr_file_spec ? stderr_file_spec.GetCString() : "<null>");
779  else
780  LLDB_LOGF(log,
781  "ProcessGDBRemote::%s no STDIO paths given via launch_info",
782  __FUNCTION__);
783  }
784 
785  const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
786  if (stdin_file_spec || disable_stdio) {
787  // the inferior will be reading stdin from the specified file or stdio is
788  // completely disabled
789  m_stdin_forward = false;
790  } else {
791  m_stdin_forward = true;
792  }
793 
794  // ::LogSetBitMask (GDBR_LOG_DEFAULT);
795  // ::LogSetOptions (LLDB_LOG_OPTION_THREADSAFE |
796  // LLDB_LOG_OPTION_PREPEND_TIMESTAMP |
797  // LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD);
798  // ::LogSetLogFile ("/dev/stdout");
799 
800  ObjectFile *object_file = exe_module->GetObjectFile();
801  if (object_file) {
802  error = EstablishConnectionIfNeeded(launch_info);
803  if (error.Success()) {
804  PseudoTerminal pty;
805  const bool disable_stdio = (launch_flags & eLaunchFlagDisableSTDIO) != 0;
806 
807  PlatformSP platform_sp(GetTarget().GetPlatform());
808  if (disable_stdio) {
809  // set to /dev/null unless redirected to a file above
810  if (!stdin_file_spec)
811  stdin_file_spec.SetFile(FileSystem::DEV_NULL,
812  FileSpec::Style::native);
813  if (!stdout_file_spec)
814  stdout_file_spec.SetFile(FileSystem::DEV_NULL,
815  FileSpec::Style::native);
816  if (!stderr_file_spec)
817  stderr_file_spec.SetFile(FileSystem::DEV_NULL,
818  FileSpec::Style::native);
819  } else if (platform_sp && platform_sp->IsHost()) {
820  // If the debugserver is local and we aren't disabling STDIO, lets use
821  // a pseudo terminal to instead of relying on the 'O' packets for stdio
822  // since 'O' packets can really slow down debugging if the inferior
823  // does a lot of output.
824  if ((!stdin_file_spec || !stdout_file_spec || !stderr_file_spec) &&
825  !errorToBool(pty.OpenFirstAvailablePrimary(O_RDWR | O_NOCTTY))) {
826  FileSpec secondary_name(pty.GetSecondaryName());
827 
828  if (!stdin_file_spec)
829  stdin_file_spec = secondary_name;
830 
831  if (!stdout_file_spec)
832  stdout_file_spec = secondary_name;
833 
834  if (!stderr_file_spec)
835  stderr_file_spec = secondary_name;
836  }
837  LLDB_LOGF(
838  log,
839  "ProcessGDBRemote::%s adjusted STDIO paths for local platform "
840  "(IsHost() is true) using secondary: stdin=%s, stdout=%s, "
841  "stderr=%s",
842  __FUNCTION__,
843  stdin_file_spec ? stdin_file_spec.GetCString() : "<null>",
844  stdout_file_spec ? stdout_file_spec.GetCString() : "<null>",
845  stderr_file_spec ? stderr_file_spec.GetCString() : "<null>");
846  }
847 
848  LLDB_LOGF(log,
849  "ProcessGDBRemote::%s final STDIO paths after all "
850  "adjustments: stdin=%s, stdout=%s, stderr=%s",
851  __FUNCTION__,
852  stdin_file_spec ? stdin_file_spec.GetCString() : "<null>",
853  stdout_file_spec ? stdout_file_spec.GetCString() : "<null>",
854  stderr_file_spec ? stderr_file_spec.GetCString() : "<null>");
855 
856  if (stdin_file_spec)
857  m_gdb_comm.SetSTDIN(stdin_file_spec);
858  if (stdout_file_spec)
859  m_gdb_comm.SetSTDOUT(stdout_file_spec);
860  if (stderr_file_spec)
861  m_gdb_comm.SetSTDERR(stderr_file_spec);
862 
863  m_gdb_comm.SetDisableASLR(launch_flags & eLaunchFlagDisableASLR);
864  m_gdb_comm.SetDetachOnError(launch_flags & eLaunchFlagDetachOnError);
865 
867  GetTarget().GetArchitecture().GetArchitectureName());
868 
869  const char *launch_event_data = launch_info.GetLaunchEventData();
870  if (launch_event_data != nullptr && *launch_event_data != '\0')
871  m_gdb_comm.SendLaunchEventDataPacket(launch_event_data);
872 
873  if (working_dir) {
874  m_gdb_comm.SetWorkingDir(working_dir);
875  }
876 
877  // Send the environment and the program + arguments after we connect
879 
880  {
881  // Scope for the scoped timeout object
883  std::chrono::seconds(10));
884 
885  int arg_packet_err = m_gdb_comm.SendArgumentsPacket(launch_info);
886  if (arg_packet_err == 0) {
887  std::string error_str;
888  if (m_gdb_comm.GetLaunchSuccess(error_str)) {
890  } else {
891  error.SetErrorString(error_str.c_str());
892  }
893  } else {
894  error.SetErrorStringWithFormat("'A' packet returned an error: %i",
895  arg_packet_err);
896  }
897  }
898 
899  if (GetID() == LLDB_INVALID_PROCESS_ID) {
900  LLDB_LOGF(log, "failed to connect to debugserver: %s",
901  error.AsCString());
903  return error;
904  }
905 
906  StringExtractorGDBRemote response;
907  if (m_gdb_comm.GetStopReply(response)) {
908  SetLastStopPacket(response);
909  // '?' Packets must be handled differently in non-stop mode
910  if (GetTarget().GetNonStopModeEnabled())
912 
913  const ArchSpec &process_arch = m_gdb_comm.GetProcessArchitecture();
914 
915  if (process_arch.IsValid()) {
916  GetTarget().MergeArchitecture(process_arch);
917  } else {
918  const ArchSpec &host_arch = m_gdb_comm.GetHostArchitecture();
919  if (host_arch.IsValid())
920  GetTarget().MergeArchitecture(host_arch);
921  }
922 
924 
925  if (!disable_stdio) {
928  }
929  }
930  } else {
931  LLDB_LOGF(log, "failed to connect to debugserver: %s", error.AsCString());
932  }
933  } else {
934  // Set our user ID to an invalid process ID.
936  error.SetErrorStringWithFormat(
937  "failed to get object file from '%s' for arch %s",
938  exe_module->GetFileSpec().GetFilename().AsCString(),
939  exe_module->GetArchitecture().GetArchitectureName());
940  }
941  return error;
942 }
943 
944 Status ProcessGDBRemote::ConnectToDebugserver(llvm::StringRef connect_url) {
945  Status error;
946  // Only connect if we have a valid connect URL
948 
949  if (!connect_url.empty()) {
950  LLDB_LOGF(log, "ProcessGDBRemote::%s Connecting to %s", __FUNCTION__,
951  connect_url.str().c_str());
952  std::unique_ptr<ConnectionFileDescriptor> conn_up(
954  if (conn_up) {
955  const uint32_t max_retry_count = 50;
956  uint32_t retry_count = 0;
957  while (!m_gdb_comm.IsConnected()) {
958  if (conn_up->Connect(connect_url, &error) == eConnectionStatusSuccess) {
959  m_gdb_comm.SetConnection(std::move(conn_up));
960  break;
961  } else if (error.WasInterrupted()) {
962  // If we were interrupted, don't keep retrying.
963  break;
964  }
965 
966  retry_count++;
967 
968  if (retry_count >= max_retry_count)
969  break;
970 
971  std::this_thread::sleep_for(std::chrono::milliseconds(100));
972  }
973  }
974  }
975 
976  if (!m_gdb_comm.IsConnected()) {
977  if (error.Success())
978  error.SetErrorString("not connected to remote gdb server");
979  return error;
980  }
981 
982  // Start the communications read thread so all incoming data can be parsed
983  // into packets and queued as they arrive.
984  if (GetTarget().GetNonStopModeEnabled())
986 
987  // We always seem to be able to open a connection to a local port so we need
988  // to make sure we can then send data to it. If we can't then we aren't
989  // actually connected to anything, so try and do the handshake with the
990  // remote GDB server and make sure that goes alright.
993  if (error.Success())
994  error.SetErrorString("not connected to remote gdb server");
995  return error;
996  }
997 
998  // Send $QNonStop:1 packet on startup if required
999  if (GetTarget().GetNonStopModeEnabled())
1001 
1009 
1010  // Ask the remote server for the default thread id
1011  if (GetTarget().GetNonStopModeEnabled())
1013 
1014  size_t num_cmds = GetExtraStartupCommands().GetArgumentCount();
1015  for (size_t idx = 0; idx < num_cmds; idx++) {
1016  StringExtractorGDBRemote response;
1018  GetExtraStartupCommands().GetArgumentAtIndex(idx), response, false);
1019  }
1020  return error;
1021 }
1022 
1025  BuildDynamicRegisterInfo(false);
1026 
1027  // See if the GDB server supports qHostInfo or qProcessInfo packets. Prefer
1028  // qProcessInfo as it will be more specific to our process.
1029 
1030  const ArchSpec &remote_process_arch = m_gdb_comm.GetProcessArchitecture();
1031  if (remote_process_arch.IsValid()) {
1032  process_arch = remote_process_arch;
1033  LLDB_LOG(log, "gdb-remote had process architecture, using {0} {1}",
1034  process_arch.GetArchitectureName(),
1035  process_arch.GetTriple().getTriple());
1036  } else {
1037  process_arch = m_gdb_comm.GetHostArchitecture();
1038  LLDB_LOG(log,
1039  "gdb-remote did not have process architecture, using gdb-remote "
1040  "host architecture {0} {1}",
1041  process_arch.GetArchitectureName(),
1042  process_arch.GetTriple().getTriple());
1043  }
1044 
1045  if (int addresssable_bits = m_gdb_comm.GetAddressingBits()) {
1046  lldb::addr_t address_mask = ~((1ULL << addresssable_bits) - 1);
1047  SetCodeAddressMask(address_mask);
1048  SetDataAddressMask(address_mask);
1049  }
1050 
1051  if (process_arch.IsValid()) {
1052  const ArchSpec &target_arch = GetTarget().GetArchitecture();
1053  if (target_arch.IsValid()) {
1054  LLDB_LOG(log, "analyzing target arch, currently {0} {1}",
1055  target_arch.GetArchitectureName(),
1056  target_arch.GetTriple().getTriple());
1057 
1058  // If the remote host is ARM and we have apple as the vendor, then
1059  // ARM executables and shared libraries can have mixed ARM
1060  // architectures.
1061  // You can have an armv6 executable, and if the host is armv7, then the
1062  // system will load the best possible architecture for all shared
1063  // libraries it has, so we really need to take the remote host
1064  // architecture as our defacto architecture in this case.
1065 
1066  if ((process_arch.GetMachine() == llvm::Triple::arm ||
1067  process_arch.GetMachine() == llvm::Triple::thumb) &&
1068  process_arch.GetTriple().getVendor() == llvm::Triple::Apple) {
1069  GetTarget().SetArchitecture(process_arch);
1070  LLDB_LOG(log,
1071  "remote process is ARM/Apple, "
1072  "setting target arch to {0} {1}",
1073  process_arch.GetArchitectureName(),
1074  process_arch.GetTriple().getTriple());
1075  } else {
1076  // Fill in what is missing in the triple
1077  const llvm::Triple &remote_triple = process_arch.GetTriple();
1078  llvm::Triple new_target_triple = target_arch.GetTriple();
1079  if (new_target_triple.getVendorName().size() == 0) {
1080  new_target_triple.setVendor(remote_triple.getVendor());
1081 
1082  if (new_target_triple.getOSName().size() == 0) {
1083  new_target_triple.setOS(remote_triple.getOS());
1084 
1085  if (new_target_triple.getEnvironmentName().size() == 0)
1086  new_target_triple.setEnvironment(remote_triple.getEnvironment());
1087  }
1088 
1089  ArchSpec new_target_arch = target_arch;
1090  new_target_arch.SetTriple(new_target_triple);
1091  GetTarget().SetArchitecture(new_target_arch);
1092  }
1093  }
1094 
1095  LLDB_LOG(log,
1096  "final target arch after adjustments for remote architecture: "
1097  "{0} {1}",
1098  target_arch.GetArchitectureName(),
1099  target_arch.GetTriple().getTriple());
1100  } else {
1101  // The target doesn't have a valid architecture yet, set it from the
1102  // architecture we got from the remote GDB server
1103  GetTarget().SetArchitecture(process_arch);
1104  }
1105  }
1106 
1108 
1109  // Find out which StructuredDataPlugins are supported by the debug monitor.
1110  // These plugins transmit data over async $J packets.
1111  if (StructuredData::Array *supported_packets =
1113  MapSupportedStructuredDataPlugins(*supported_packets);
1114 }
1115 
1117  ModuleSP module_sp = GetTarget().GetExecutableModule();
1118  if (!module_sp)
1119  return;
1120 
1121  llvm::Optional<QOffsets> offsets = m_gdb_comm.GetQOffsets();
1122  if (!offsets)
1123  return;
1124 
1125  bool is_uniform =
1126  size_t(llvm::count(offsets->offsets, offsets->offsets[0])) ==
1127  offsets->offsets.size();
1128  if (!is_uniform)
1129  return; // TODO: Handle non-uniform responses.
1130 
1131  bool changed = false;
1132  module_sp->SetLoadAddress(GetTarget(), offsets->offsets[0],
1133  /*value_is_offset=*/true, changed);
1134  if (changed) {
1135  ModuleList list;
1136  list.Append(module_sp);
1138  }
1139 }
1140 
1142  ArchSpec process_arch;
1143  DidLaunchOrAttach(process_arch);
1144 }
1145 
1147  lldb::pid_t attach_pid, const ProcessAttachInfo &attach_info) {
1149  Status error;
1150 
1151  LLDB_LOGF(log, "ProcessGDBRemote::%s()", __FUNCTION__);
1152 
1153  // Clear out and clean up from any current state
1154  Clear();
1155  if (attach_pid != LLDB_INVALID_PROCESS_ID) {
1156  error = EstablishConnectionIfNeeded(attach_info);
1157  if (error.Success()) {
1159 
1160  char packet[64];
1161  const int packet_len =
1162  ::snprintf(packet, sizeof(packet), "vAttach;%" PRIx64, attach_pid);
1163  SetID(attach_pid);
1165  eBroadcastBitAsyncContinue, new EventDataBytes(packet, packet_len));
1166  } else
1167  SetExitStatus(-1, error.AsCString());
1168  }
1169 
1170  return error;
1171 }
1172 
1174  const char *process_name, const ProcessAttachInfo &attach_info) {
1175  Status error;
1176  // Clear out and clean up from any current state
1177  Clear();
1178 
1179  if (process_name && process_name[0]) {
1180  error = EstablishConnectionIfNeeded(attach_info);
1181  if (error.Success()) {
1182  StreamString packet;
1183 
1185 
1186  if (attach_info.GetWaitForLaunch()) {
1188  packet.PutCString("vAttachWait");
1189  } else {
1190  if (attach_info.GetIgnoreExisting())
1191  packet.PutCString("vAttachWait");
1192  else
1193  packet.PutCString("vAttachOrWait");
1194  }
1195  } else
1196  packet.PutCString("vAttachName");
1197  packet.PutChar(';');
1198  packet.PutBytesAsRawHex8(process_name, strlen(process_name),
1201 
1204  new EventDataBytes(packet.GetString().data(), packet.GetSize()));
1205 
1206  } else
1207  SetExitStatus(-1, error.AsCString());
1208  }
1209  return error;
1210 }
1211 
1212 llvm::Expected<TraceSupportedResponse> ProcessGDBRemote::TraceSupported() {
1213  return m_gdb_comm.SendTraceSupported();
1214 }
1215 
1217  return m_gdb_comm.SendTraceStop(request);
1218 }
1219 
1220 llvm::Error ProcessGDBRemote::TraceStart(const llvm::json::Value &request) {
1221  return m_gdb_comm.SendTraceStart(request);
1222 }
1223 
1224 llvm::Expected<std::string>
1225 ProcessGDBRemote::TraceGetState(llvm::StringRef type) {
1226  return m_gdb_comm.SendTraceGetState(type);
1227 }
1228 
1229 llvm::Expected<std::vector<uint8_t>>
1231  return m_gdb_comm.SendTraceGetBinaryData(request);
1232 }
1233 
1235  // When we exit, disconnect from the GDB server communications
1237 }
1238 
1240  // If you can figure out what the architecture is, fill it in here.
1241  process_arch.Clear();
1242  DidLaunchOrAttach(process_arch);
1243 }
1244 
1246  m_continue_c_tids.clear();
1247  m_continue_C_tids.clear();
1248  m_continue_s_tids.clear();
1249  m_continue_S_tids.clear();
1250  m_jstopinfo_sp.reset();
1251  m_jthreadsinfo_sp.reset();
1252  return Status();
1253 }
1254 
1256  Status error;
1258  LLDB_LOGF(log, "ProcessGDBRemote::Resume()");
1259 
1260  ListenerSP listener_sp(
1261  Listener::MakeListener("gdb-remote.resume-packet-sent"));
1262  if (listener_sp->StartListeningForEvents(
1264  listener_sp->StartListeningForEvents(
1267 
1268  const size_t num_threads = GetThreadList().GetSize();
1269 
1270  StreamString continue_packet;
1271  bool continue_packet_error = false;
1273  if (!GetTarget().GetNonStopModeEnabled() &&
1274  (m_continue_c_tids.size() == num_threads ||
1275  (m_continue_c_tids.empty() && m_continue_C_tids.empty() &&
1276  m_continue_s_tids.empty() && m_continue_S_tids.empty()))) {
1277  // All threads are continuing, just send a "c" packet
1278  continue_packet.PutCString("c");
1279  } else {
1280  continue_packet.PutCString("vCont");
1281 
1282  if (!m_continue_c_tids.empty()) {
1283  if (m_gdb_comm.GetVContSupported('c')) {
1284  for (tid_collection::const_iterator
1285  t_pos = m_continue_c_tids.begin(),
1286  t_end = m_continue_c_tids.end();
1287  t_pos != t_end; ++t_pos)
1288  continue_packet.Printf(";c:%4.4" PRIx64, *t_pos);
1289  } else
1290  continue_packet_error = true;
1291  }
1292 
1293  if (!continue_packet_error && !m_continue_C_tids.empty()) {
1294  if (m_gdb_comm.GetVContSupported('C')) {
1295  for (tid_sig_collection::const_iterator
1296  s_pos = m_continue_C_tids.begin(),
1297  s_end = m_continue_C_tids.end();
1298  s_pos != s_end; ++s_pos)
1299  continue_packet.Printf(";C%2.2x:%4.4" PRIx64, s_pos->second,
1300  s_pos->first);
1301  } else
1302  continue_packet_error = true;
1303  }
1304 
1305  if (!continue_packet_error && !m_continue_s_tids.empty()) {
1306  if (m_gdb_comm.GetVContSupported('s')) {
1307  for (tid_collection::const_iterator
1308  t_pos = m_continue_s_tids.begin(),
1309  t_end = m_continue_s_tids.end();
1310  t_pos != t_end; ++t_pos)
1311  continue_packet.Printf(";s:%4.4" PRIx64, *t_pos);
1312  } else
1313  continue_packet_error = true;
1314  }
1315 
1316  if (!continue_packet_error && !m_continue_S_tids.empty()) {
1317  if (m_gdb_comm.GetVContSupported('S')) {
1318  for (tid_sig_collection::const_iterator
1319  s_pos = m_continue_S_tids.begin(),
1320  s_end = m_continue_S_tids.end();
1321  s_pos != s_end; ++s_pos)
1322  continue_packet.Printf(";S%2.2x:%4.4" PRIx64, s_pos->second,
1323  s_pos->first);
1324  } else
1325  continue_packet_error = true;
1326  }
1327 
1328  if (continue_packet_error)
1329  continue_packet.Clear();
1330  }
1331  } else
1332  continue_packet_error = true;
1333 
1334  if (continue_packet_error) {
1335  // Either no vCont support, or we tried to use part of the vCont packet
1336  // that wasn't supported by the remote GDB server. We need to try and
1337  // make a simple packet that can do our continue
1338  const size_t num_continue_c_tids = m_continue_c_tids.size();
1339  const size_t num_continue_C_tids = m_continue_C_tids.size();
1340  const size_t num_continue_s_tids = m_continue_s_tids.size();
1341  const size_t num_continue_S_tids = m_continue_S_tids.size();
1342  if (num_continue_c_tids > 0) {
1343  if (num_continue_c_tids == num_threads) {
1344  // All threads are resuming...
1346  continue_packet.PutChar('c');
1347  continue_packet_error = false;
1348  } else if (num_continue_c_tids == 1 && num_continue_C_tids == 0 &&
1349  num_continue_s_tids == 0 && num_continue_S_tids == 0) {
1350  // Only one thread is continuing
1352  continue_packet.PutChar('c');
1353  continue_packet_error = false;
1354  }
1355  }
1356 
1357  if (continue_packet_error && num_continue_C_tids > 0) {
1358  if ((num_continue_C_tids + num_continue_c_tids) == num_threads &&
1359  num_continue_C_tids > 0 && num_continue_s_tids == 0 &&
1360  num_continue_S_tids == 0) {
1361  const int continue_signo = m_continue_C_tids.front().second;
1362  // Only one thread is continuing
1363  if (num_continue_C_tids > 1) {
1364  // More that one thread with a signal, yet we don't have vCont
1365  // support and we are being asked to resume each thread with a
1366  // signal, we need to make sure they are all the same signal, or we
1367  // can't issue the continue accurately with the current support...
1368  if (num_continue_C_tids > 1) {
1369  continue_packet_error = false;
1370  for (size_t i = 1; i < m_continue_C_tids.size(); ++i) {
1371  if (m_continue_C_tids[i].second != continue_signo)
1372  continue_packet_error = true;
1373  }
1374  }
1375  if (!continue_packet_error)
1377  } else {
1378  // Set the continue thread ID
1379  continue_packet_error = false;
1381  }
1382  if (!continue_packet_error) {
1383  // Add threads continuing with the same signo...
1384  continue_packet.Printf("C%2.2x", continue_signo);
1385  }
1386  }
1387  }
1388 
1389  if (continue_packet_error && num_continue_s_tids > 0) {
1390  if (num_continue_s_tids == num_threads) {
1391  // All threads are resuming...
1393 
1394  // If in Non-Stop-Mode use vCont when stepping
1395  if (GetTarget().GetNonStopModeEnabled()) {
1396  if (m_gdb_comm.GetVContSupported('s'))
1397  continue_packet.PutCString("vCont;s");
1398  else
1399  continue_packet.PutChar('s');
1400  } else
1401  continue_packet.PutChar('s');
1402 
1403  continue_packet_error = false;
1404  } else if (num_continue_c_tids == 0 && num_continue_C_tids == 0 &&
1405  num_continue_s_tids == 1 && num_continue_S_tids == 0) {
1406  // Only one thread is stepping
1408  continue_packet.PutChar('s');
1409  continue_packet_error = false;
1410  }
1411  }
1412 
1413  if (!continue_packet_error && num_continue_S_tids > 0) {
1414  if (num_continue_S_tids == num_threads) {
1415  const int step_signo = m_continue_S_tids.front().second;
1416  // Are all threads trying to step with the same signal?
1417  continue_packet_error = false;
1418  if (num_continue_S_tids > 1) {
1419  for (size_t i = 1; i < num_threads; ++i) {
1420  if (m_continue_S_tids[i].second != step_signo)
1421  continue_packet_error = true;
1422  }
1423  }
1424  if (!continue_packet_error) {
1425  // Add threads stepping with the same signo...
1427  continue_packet.Printf("S%2.2x", step_signo);
1428  }
1429  } else if (num_continue_c_tids == 0 && num_continue_C_tids == 0 &&
1430  num_continue_s_tids == 0 && num_continue_S_tids == 1) {
1431  // Only one thread is stepping with signal
1433  continue_packet.Printf("S%2.2x", m_continue_S_tids.front().second);
1434  continue_packet_error = false;
1435  }
1436  }
1437  }
1438 
1439  if (continue_packet_error) {
1440  error.SetErrorString("can't make continue packet for this resume");
1441  } else {
1442  EventSP event_sp;
1443  if (!m_async_thread.IsJoinable()) {
1444  error.SetErrorString("Trying to resume but the async thread is dead.");
1445  LLDB_LOGF(log, "ProcessGDBRemote::DoResume: Trying to resume but the "
1446  "async thread is dead.");
1447  return error;
1448  }
1449 
1452  new EventDataBytes(continue_packet.GetString().data(),
1453  continue_packet.GetSize()));
1454 
1455  if (!listener_sp->GetEvent(event_sp, std::chrono::seconds(5))) {
1456  error.SetErrorString("Resume timed out.");
1457  LLDB_LOGF(log, "ProcessGDBRemote::DoResume: Resume timed out.");
1458  } else if (event_sp->BroadcasterIs(&m_async_broadcaster)) {
1459  error.SetErrorString("Broadcast continue, but the async thread was "
1460  "killed before we got an ack back.");
1461  LLDB_LOGF(log,
1462  "ProcessGDBRemote::DoResume: Broadcast continue, but the "
1463  "async thread was killed before we got an ack back.");
1464  return error;
1465  }
1466  }
1467  }
1468 
1469  return error;
1470 }
1471 
1473  while (true) {
1474  // Send vStopped
1475  StringExtractorGDBRemote response;
1476  m_gdb_comm.SendPacketAndWaitForResponse("vStopped", response, false);
1477 
1478  // OK represents end of signal list
1479  if (response.IsOKResponse())
1480  break;
1481 
1482  // If not OK or a normal packet we have a problem
1483  if (!response.IsNormalResponse())
1484  break;
1485 
1486  SetLastStopPacket(response);
1487  }
1488 }
1489 
1491  std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
1492  m_thread_ids.clear();
1493  m_thread_pcs.clear();
1494 }
1495 
1497  llvm::StringRef value) {
1498  m_thread_ids.clear();
1500  StringExtractorGDBRemote thread_ids{value};
1501 
1502  do {
1503  auto pid_tid = thread_ids.GetPidTid(pid);
1504  if (pid_tid && pid_tid->first == pid) {
1505  lldb::tid_t tid = pid_tid->second;
1506  if (tid != LLDB_INVALID_THREAD_ID &&
1508  m_thread_ids.push_back(tid);
1509  }
1510  } while (thread_ids.GetChar() == ',');
1511 
1512  return m_thread_ids.size();
1513 }
1514 
1515 size_t
1517  m_thread_pcs.clear();
1518  size_t comma_pos;
1519  lldb::addr_t pc;
1520  while ((comma_pos = value.find(',')) != std::string::npos) {
1521  value[comma_pos] = '\0';
1522  pc = StringConvert::ToUInt64(value.c_str(), LLDB_INVALID_ADDRESS, 16);
1523  if (pc != LLDB_INVALID_ADDRESS)
1524  m_thread_pcs.push_back(pc);
1525  value.erase(0, comma_pos + 1);
1526  }
1527  pc = StringConvert::ToUInt64(value.c_str(), LLDB_INVALID_ADDRESS, 16);
1528  if (pc != LLDB_INVALID_ADDRESS)
1529  m_thread_pcs.push_back(pc);
1530  return m_thread_pcs.size();
1531 }
1532 
1534  std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
1535 
1536  if (m_jthreadsinfo_sp) {
1537  // If we have the JSON threads info, we can get the thread list from that
1538  StructuredData::Array *thread_infos = m_jthreadsinfo_sp->GetAsArray();
1539  if (thread_infos && thread_infos->GetSize() > 0) {
1540  m_thread_ids.clear();
1541  m_thread_pcs.clear();
1542  thread_infos->ForEach([this](StructuredData::Object *object) -> bool {
1543  StructuredData::Dictionary *thread_dict = object->GetAsDictionary();
1544  if (thread_dict) {
1545  // Set the thread stop info from the JSON dictionary
1546  SetThreadStopInfo(thread_dict);
1548  if (thread_dict->GetValueForKeyAsInteger<lldb::tid_t>("tid", tid))
1549  m_thread_ids.push_back(tid);
1550  }
1551  return true; // Keep iterating through all thread_info objects
1552  });
1553  }
1554  if (!m_thread_ids.empty())
1555  return true;
1556  } else {
1557  // See if we can get the thread IDs from the current stop reply packets
1558  // that might contain a "threads" key/value pair
1559 
1560  // Lock the thread stack while we access it
1561  // Mutex::Locker stop_stack_lock(m_last_stop_packet_mutex);
1562  std::unique_lock<std::recursive_mutex> stop_stack_lock(
1563  m_last_stop_packet_mutex, std::defer_lock);
1564  if (stop_stack_lock.try_lock()) {
1565  // Get the number of stop packets on the stack
1566  int nItems = m_stop_packet_stack.size();
1567  // Iterate over them
1568  for (int i = 0; i < nItems; i++) {
1569  // Get the thread stop info
1571  const std::string &stop_info_str =
1572  std::string(stop_info.GetStringRef());
1573 
1574  m_thread_pcs.clear();
1575  const size_t thread_pcs_pos = stop_info_str.find(";thread-pcs:");
1576  if (thread_pcs_pos != std::string::npos) {
1577  const size_t start = thread_pcs_pos + strlen(";thread-pcs:");
1578  const size_t end = stop_info_str.find(';', start);
1579  if (end != std::string::npos) {
1580  std::string value = stop_info_str.substr(start, end - start);
1582  }
1583  }
1584 
1585  const size_t threads_pos = stop_info_str.find(";threads:");
1586  if (threads_pos != std::string::npos) {
1587  const size_t start = threads_pos + strlen(";threads:");
1588  const size_t end = stop_info_str.find(';', start);
1589  if (end != std::string::npos) {
1590  std::string value = stop_info_str.substr(start, end - start);
1592  return true;
1593  }
1594  }
1595  }
1596  }
1597  }
1598 
1599  bool sequence_mutex_unavailable = false;
1600  m_gdb_comm.GetCurrentThreadIDs(m_thread_ids, sequence_mutex_unavailable);
1601  if (sequence_mutex_unavailable) {
1602  return false; // We just didn't get the list
1603  }
1604  return true;
1605 }
1606 
1608  ThreadList &new_thread_list) {
1609  // locker will keep a mutex locked until it goes out of scope
1611  LLDB_LOGV(log, "pid = {0}", GetID());
1612 
1613  size_t num_thread_ids = m_thread_ids.size();
1614  // The "m_thread_ids" thread ID list should always be updated after each stop
1615  // reply packet, but in case it isn't, update it here.
1616  if (num_thread_ids == 0) {
1617  if (!UpdateThreadIDList())
1618  return false;
1619  num_thread_ids = m_thread_ids.size();
1620  }
1621 
1622  ThreadList old_thread_list_copy(old_thread_list);
1623  if (num_thread_ids > 0) {
1624  for (size_t i = 0; i < num_thread_ids; ++i) {
1625  tid_t tid = m_thread_ids[i];
1626  ThreadSP thread_sp(
1627  old_thread_list_copy.RemoveThreadByProtocolID(tid, false));
1628  if (!thread_sp) {
1629  thread_sp = std::make_shared<ThreadGDBRemote>(*this, tid);
1630  LLDB_LOGV(log, "Making new thread: {0} for thread ID: {1:x}.",
1631  thread_sp.get(), thread_sp->GetID());
1632  } else {
1633  LLDB_LOGV(log, "Found old thread: {0} for thread ID: {1:x}.",
1634  thread_sp.get(), thread_sp->GetID());
1635  }
1636 
1637  SetThreadPc(thread_sp, i);
1638  new_thread_list.AddThreadSortedByIndexID(thread_sp);
1639  }
1640  }
1641 
1642  // Whatever that is left in old_thread_list_copy are not present in
1643  // new_thread_list. Remove non-existent threads from internal id table.
1644  size_t old_num_thread_ids = old_thread_list_copy.GetSize(false);
1645  for (size_t i = 0; i < old_num_thread_ids; i++) {
1646  ThreadSP old_thread_sp(old_thread_list_copy.GetThreadAtIndex(i, false));
1647  if (old_thread_sp) {
1648  lldb::tid_t old_thread_id = old_thread_sp->GetProtocolID();
1649  m_thread_id_to_index_id_map.erase(old_thread_id);
1650  }
1651  }
1652 
1653  return true;
1654 }
1655 
1656 void ProcessGDBRemote::SetThreadPc(const ThreadSP &thread_sp, uint64_t index) {
1657  if (m_thread_ids.size() == m_thread_pcs.size() && thread_sp.get() &&
1659  ThreadGDBRemote *gdb_thread =
1660  static_cast<ThreadGDBRemote *>(thread_sp.get());
1661  RegisterContextSP reg_ctx_sp(thread_sp->GetRegisterContext());
1662  if (reg_ctx_sp) {
1663  uint32_t pc_regnum = reg_ctx_sp->ConvertRegisterKindToRegisterNumber(
1665  if (pc_regnum != LLDB_INVALID_REGNUM) {
1666  gdb_thread->PrivateSetRegisterValue(pc_regnum, m_thread_pcs[index]);
1667  }
1668  }
1669  }
1670 }
1671 
1673  ThreadGDBRemote *thread, const StructuredData::ObjectSP &thread_infos_sp) {
1674  // See if we got thread stop infos for all threads via the "jThreadsInfo"
1675  // packet
1676  if (thread_infos_sp) {
1677  StructuredData::Array *thread_infos = thread_infos_sp->GetAsArray();
1678  if (thread_infos) {
1679  lldb::tid_t tid;
1680  const size_t n = thread_infos->GetSize();
1681  for (size_t i = 0; i < n; ++i) {
1682  StructuredData::Dictionary *thread_dict =
1683  thread_infos->GetItemAtIndex(i)->GetAsDictionary();
1684  if (thread_dict) {
1685  if (thread_dict->GetValueForKeyAsInteger<lldb::tid_t>(
1686  "tid", tid, LLDB_INVALID_THREAD_ID)) {
1687  if (tid == thread->GetID())
1688  return (bool)SetThreadStopInfo(thread_dict);
1689  }
1690  }
1691  }
1692  }
1693  }
1694  return false;
1695 }
1696 
1698  // See if we got thread stop infos for all threads via the "jThreadsInfo"
1699  // packet
1701  return true;
1702 
1703  // See if we got thread stop info for any threads valid stop info reasons
1704  // threads via the "jstopinfo" packet stop reply packet key/value pair?
1705  if (m_jstopinfo_sp) {
1706  // If we have "jstopinfo" then we have stop descriptions for all threads
1707  // that have stop reasons, and if there is no entry for a thread, then it
1708  // has no stop reason.
1709  thread->GetRegisterContext()->InvalidateIfNeeded(true);
1710  if (!GetThreadStopInfoFromJSON(thread, m_jstopinfo_sp)) {
1711  thread->SetStopInfo(StopInfoSP());
1712  }
1713  return true;
1714  }
1715 
1716  // Fall back to using the qThreadStopInfo packet
1717  StringExtractorGDBRemote stop_packet;
1718  if (GetGDBRemote().GetThreadStopInfo(thread->GetProtocolID(), stop_packet))
1719  return SetThreadStopInfo(stop_packet) == eStateStopped;
1720  return false;
1721 }
1722 
1724  lldb::tid_t tid, ExpeditedRegisterMap &expedited_register_map,
1725  uint8_t signo, const std::string &thread_name, const std::string &reason,
1726  const std::string &description, uint32_t exc_type,
1727  const std::vector<addr_t> &exc_data, addr_t thread_dispatch_qaddr,
1728  bool queue_vars_valid, // Set to true if queue_name, queue_kind and
1729  // queue_serial are valid
1730  LazyBool associated_with_dispatch_queue, addr_t dispatch_queue_t,
1731  std::string &queue_name, QueueKind queue_kind, uint64_t queue_serial) {
1732  ThreadSP thread_sp;
1733  if (tid != LLDB_INVALID_THREAD_ID) {
1734  // Scope for "locker" below
1735  {
1736  // m_thread_list_real does have its own mutex, but we need to hold onto
1737  // the mutex between the call to m_thread_list_real.FindThreadByID(...)
1738  // and the m_thread_list_real.AddThread(...) so it doesn't change on us
1739  std::lock_guard<std::recursive_mutex> guard(
1741  thread_sp = m_thread_list_real.FindThreadByProtocolID(tid, false);
1742 
1743  if (!thread_sp) {
1744  // Create the thread if we need to
1745  thread_sp = std::make_shared<ThreadGDBRemote>(*this, tid);
1746  m_thread_list_real.AddThread(thread_sp);
1747  }
1748  }
1749 
1750  if (thread_sp) {
1751  ThreadGDBRemote *gdb_thread =
1752  static_cast<ThreadGDBRemote *>(thread_sp.get());
1753  RegisterContextSP gdb_reg_ctx_sp(gdb_thread->GetRegisterContext());
1754 
1755  gdb_reg_ctx_sp->InvalidateIfNeeded(true);
1756 
1757  auto iter = std::find(m_thread_ids.begin(), m_thread_ids.end(), tid);
1758  if (iter != m_thread_ids.end()) {
1759  SetThreadPc(thread_sp, iter - m_thread_ids.begin());
1760  }
1761 
1762  for (const auto &pair : expedited_register_map) {
1763  StringExtractor reg_value_extractor(pair.second);
1764  DataBufferSP buffer_sp(new DataBufferHeap(
1765  reg_value_extractor.GetStringRef().size() / 2, 0));
1766  reg_value_extractor.GetHexBytes(buffer_sp->GetData(), '\xcc');
1767  uint32_t lldb_regnum =
1768  gdb_reg_ctx_sp->ConvertRegisterKindToRegisterNumber(
1769  eRegisterKindProcessPlugin, pair.first);
1770  gdb_thread->PrivateSetRegisterValue(lldb_regnum, buffer_sp->GetData());
1771  }
1772 
1773  // AArch64 SVE specific code below calls AArch64SVEReconfigure to update
1774  // SVE register sizes and offsets if value of VG register has changed
1775  // since last stop.
1776  const ArchSpec &arch = GetTarget().GetArchitecture();
1777  if (arch.IsValid() && arch.GetTriple().isAArch64()) {
1778  GDBRemoteRegisterContext *reg_ctx_sp =
1779  static_cast<GDBRemoteRegisterContext *>(
1780  gdb_thread->GetRegisterContext().get());
1781 
1782  if (reg_ctx_sp)
1783  reg_ctx_sp->AArch64SVEReconfigure();
1784  }
1785 
1786  thread_sp->SetName(thread_name.empty() ? nullptr : thread_name.c_str());
1787 
1788  gdb_thread->SetThreadDispatchQAddr(thread_dispatch_qaddr);
1789  // Check if the GDB server was able to provide the queue name, kind and
1790  // serial number
1791  if (queue_vars_valid)
1792  gdb_thread->SetQueueInfo(std::move(queue_name), queue_kind,
1793  queue_serial, dispatch_queue_t,
1794  associated_with_dispatch_queue);
1795  else
1796  gdb_thread->ClearQueueInfo();
1797 
1799  associated_with_dispatch_queue);
1800 
1801  if (dispatch_queue_t != LLDB_INVALID_ADDRESS)
1802  gdb_thread->SetQueueLibdispatchQueueAddress(dispatch_queue_t);
1803 
1804  // Make sure we update our thread stop reason just once
1805  if (!thread_sp->StopInfoIsUpToDate()) {
1806  thread_sp->SetStopInfo(StopInfoSP());
1807  // If there's a memory thread backed by this thread, we need to use it
1808  // to calculate StopInfo.
1809  if (ThreadSP memory_thread_sp =
1810  m_thread_list.GetBackingThread(thread_sp))
1811  thread_sp = memory_thread_sp;
1812 
1813  if (exc_type != 0) {
1814  const size_t exc_data_size = exc_data.size();
1815 
1816  thread_sp->SetStopInfo(
1818  *thread_sp, exc_type, exc_data_size,
1819  exc_data_size >= 1 ? exc_data[0] : 0,
1820  exc_data_size >= 2 ? exc_data[1] : 0,
1821  exc_data_size >= 3 ? exc_data[2] : 0));
1822  } else {
1823  bool handled = false;
1824  bool did_exec = false;
1825  if (!reason.empty()) {
1826  if (reason == "trace") {
1827  addr_t pc = thread_sp->GetRegisterContext()->GetPC();
1828  lldb::BreakpointSiteSP bp_site_sp = thread_sp->GetProcess()
1829  ->GetBreakpointSiteList()
1830  .FindByAddress(pc);
1831 
1832  // If the current pc is a breakpoint site then the StopInfo
1833  // should be set to Breakpoint Otherwise, it will be set to
1834  // Trace.
1835  if (bp_site_sp &&
1836  bp_site_sp->ValidForThisThread(thread_sp.get())) {
1837  thread_sp->SetStopInfo(
1839  *thread_sp, bp_site_sp->GetID()));
1840  } else
1841  thread_sp->SetStopInfo(
1842  StopInfo::CreateStopReasonToTrace(*thread_sp));
1843  handled = true;
1844  } else if (reason == "breakpoint") {
1845  addr_t pc = thread_sp->GetRegisterContext()->GetPC();
1846  lldb::BreakpointSiteSP bp_site_sp = thread_sp->GetProcess()
1847  ->GetBreakpointSiteList()
1848  .FindByAddress(pc);
1849  if (bp_site_sp) {
1850  // If the breakpoint is for this thread, then we'll report the
1851  // hit, but if it is for another thread, we can just report no
1852  // reason. We don't need to worry about stepping over the
1853  // breakpoint here, that will be taken care of when the thread
1854  // resumes and notices that there's a breakpoint under the pc.
1855  handled = true;
1856  if (bp_site_sp->ValidForThisThread(thread_sp.get())) {
1857  thread_sp->SetStopInfo(
1859  *thread_sp, bp_site_sp->GetID()));
1860  } else {
1861  StopInfoSP invalid_stop_info_sp;
1862  thread_sp->SetStopInfo(invalid_stop_info_sp);
1863  }
1864  }
1865  } else if (reason == "trap") {
1866  // Let the trap just use the standard signal stop reason below...
1867  } else if (reason == "watchpoint") {
1868  StringExtractor desc_extractor(description.c_str());
1869  addr_t wp_addr = desc_extractor.GetU64(LLDB_INVALID_ADDRESS);
1870  uint32_t wp_index = desc_extractor.GetU32(LLDB_INVALID_INDEX32);
1871  addr_t wp_hit_addr = desc_extractor.GetU64(LLDB_INVALID_ADDRESS);
1872  watch_id_t watch_id = LLDB_INVALID_WATCH_ID;
1873  if (wp_addr != LLDB_INVALID_ADDRESS) {
1874  WatchpointSP wp_sp;
1876  if ((core >= ArchSpec::kCore_mips_first &&
1877  core <= ArchSpec::kCore_mips_last) ||
1878  (core >= ArchSpec::eCore_arm_generic &&
1879  core <= ArchSpec::eCore_arm_aarch64))
1881  wp_hit_addr);
1882  if (!wp_sp)
1883  wp_sp =
1885  if (wp_sp) {
1886  wp_sp->SetHardwareIndex(wp_index);
1887  watch_id = wp_sp->GetID();
1888  }
1889  }
1890  if (watch_id == LLDB_INVALID_WATCH_ID) {
1893  LLDB_LOGF(log, "failed to find watchpoint");
1894  }
1895  thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithWatchpointID(
1896  *thread_sp, watch_id, wp_hit_addr));
1897  handled = true;
1898  } else if (reason == "exception") {
1899  thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithException(
1900  *thread_sp, description.c_str()));
1901  handled = true;
1902  } else if (reason == "exec") {
1903  did_exec = true;
1904  thread_sp->SetStopInfo(
1906  handled = true;
1907  } else if (reason == "processor trace") {
1908  thread_sp->SetStopInfo(StopInfo::CreateStopReasonProcessorTrace(
1909  *thread_sp, description.c_str()));
1910  }
1911  } else if (!signo) {
1912  addr_t pc = thread_sp->GetRegisterContext()->GetPC();
1913  lldb::BreakpointSiteSP bp_site_sp =
1914  thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(
1915  pc);
1916 
1917  // If the current pc is a breakpoint site then the StopInfo should
1918  // be set to Breakpoint even though the remote stub did not set it
1919  // as such. This can happen when the thread is involuntarily
1920  // interrupted (e.g. due to stops on other threads) just as it is
1921  // about to execute the breakpoint instruction.
1922  if (bp_site_sp && bp_site_sp->ValidForThisThread(thread_sp.get())) {
1923  thread_sp->SetStopInfo(
1925  *thread_sp, bp_site_sp->GetID()));
1926  handled = true;
1927  }
1928  }
1929 
1930  if (!handled && signo && !did_exec) {
1931  if (signo == SIGTRAP) {
1932  // Currently we are going to assume SIGTRAP means we are either
1933  // hitting a breakpoint or hardware single stepping.
1934  handled = true;
1935  addr_t pc = thread_sp->GetRegisterContext()->GetPC() +
1937  lldb::BreakpointSiteSP bp_site_sp = thread_sp->GetProcess()
1938  ->GetBreakpointSiteList()
1939  .FindByAddress(pc);
1940 
1941  if (bp_site_sp) {
1942  // If the breakpoint is for this thread, then we'll report the
1943  // hit, but if it is for another thread, we can just report no
1944  // reason. We don't need to worry about stepping over the
1945  // breakpoint here, that will be taken care of when the thread
1946  // resumes and notices that there's a breakpoint under the pc.
1947  if (bp_site_sp->ValidForThisThread(thread_sp.get())) {
1948  if (m_breakpoint_pc_offset != 0)
1949  thread_sp->GetRegisterContext()->SetPC(pc);
1950  thread_sp->SetStopInfo(
1952  *thread_sp, bp_site_sp->GetID()));
1953  } else {
1954  StopInfoSP invalid_stop_info_sp;
1955  thread_sp->SetStopInfo(invalid_stop_info_sp);
1956  }
1957  } else {
1958  // If we were stepping then assume the stop was the result of
1959  // the trace. If we were not stepping then report the SIGTRAP.
1960  // FIXME: We are still missing the case where we single step
1961  // over a trap instruction.
1962  if (thread_sp->GetTemporaryResumeState() == eStateStepping)
1963  thread_sp->SetStopInfo(
1964  StopInfo::CreateStopReasonToTrace(*thread_sp));
1965  else
1966  thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithSignal(
1967  *thread_sp, signo, description.c_str()));
1968  }
1969  }
1970  if (!handled)
1971  thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithSignal(
1972  *thread_sp, signo, description.c_str()));
1973  }
1974 
1975  if (!description.empty()) {
1976  lldb::StopInfoSP stop_info_sp(thread_sp->GetStopInfo());
1977  if (stop_info_sp) {
1978  const char *stop_info_desc = stop_info_sp->GetDescription();
1979  if (!stop_info_desc || !stop_info_desc[0])
1980  stop_info_sp->SetDescription(description.c_str());
1981  } else {
1982  thread_sp->SetStopInfo(StopInfo::CreateStopReasonWithException(
1983  *thread_sp, description.c_str()));
1984  }
1985  }
1986  }
1987  }
1988  }
1989  }
1990  return thread_sp;
1991 }
1992 
1993 lldb::ThreadSP
1995  static ConstString g_key_tid("tid");
1996  static ConstString g_key_name("name");
1997  static ConstString g_key_reason("reason");
1998  static ConstString g_key_metype("metype");
1999  static ConstString g_key_medata("medata");
2000  static ConstString g_key_qaddr("qaddr");
2001  static ConstString g_key_dispatch_queue_t("dispatch_queue_t");
2002  static ConstString g_key_associated_with_dispatch_queue(
2003  "associated_with_dispatch_queue");
2004  static ConstString g_key_queue_name("qname");
2005  static ConstString g_key_queue_kind("qkind");
2006  static ConstString g_key_queue_serial_number("qserialnum");
2007  static ConstString g_key_registers("registers");
2008  static ConstString g_key_memory("memory");
2009  static ConstString g_key_address("address");
2010  static ConstString g_key_bytes("bytes");
2011  static ConstString g_key_description("description");
2012  static ConstString g_key_signal("signal");
2013 
2014  // Stop with signal and thread info
2016  uint8_t signo = 0;
2017  std::string value;
2018  std::string thread_name;
2019  std::string reason;
2020  std::string description;
2021  uint32_t exc_type = 0;
2022  std::vector<addr_t> exc_data;
2023  addr_t thread_dispatch_qaddr = LLDB_INVALID_ADDRESS;
2024  ExpeditedRegisterMap expedited_register_map;
2025  bool queue_vars_valid = false;
2026  addr_t dispatch_queue_t = LLDB_INVALID_ADDRESS;
2027  LazyBool associated_with_dispatch_queue = eLazyBoolCalculate;
2028  std::string queue_name;
2029  QueueKind queue_kind = eQueueKindUnknown;
2030  uint64_t queue_serial_number = 0;
2031  // Iterate through all of the thread dictionary key/value pairs from the
2032  // structured data dictionary
2033 
2034  thread_dict->ForEach([this, &tid, &expedited_register_map, &thread_name,
2035  &signo, &reason, &description, &exc_type, &exc_data,
2036  &thread_dispatch_qaddr, &queue_vars_valid,
2037  &associated_with_dispatch_queue, &dispatch_queue_t,
2038  &queue_name, &queue_kind, &queue_serial_number](
2039  ConstString key,
2040  StructuredData::Object *object) -> bool {
2041  if (key == g_key_tid) {
2042  // thread in big endian hex
2043  tid = object->GetIntegerValue(LLDB_INVALID_THREAD_ID);
2044  } else if (key == g_key_metype) {
2045  // exception type in big endian hex
2046  exc_type = object->GetIntegerValue(0);
2047  } else if (key == g_key_medata) {
2048  // exception data in big endian hex
2049  StructuredData::Array *array = object->GetAsArray();
2050  if (array) {
2051  array->ForEach([&exc_data](StructuredData::Object *object) -> bool {
2052  exc_data.push_back(object->GetIntegerValue());
2053  return true; // Keep iterating through all array items
2054  });
2055  }
2056  } else if (key == g_key_name) {
2057  thread_name = std::string(object->GetStringValue());
2058  } else if (key == g_key_qaddr) {
2059  thread_dispatch_qaddr = object->GetIntegerValue(LLDB_INVALID_ADDRESS);
2060  } else if (key == g_key_queue_name) {
2061  queue_vars_valid = true;
2062  queue_name = std::string(object->GetStringValue());
2063  } else if (key == g_key_queue_kind) {
2064  std::string queue_kind_str = std::string(object->GetStringValue());
2065  if (queue_kind_str == "serial") {
2066  queue_vars_valid = true;
2067  queue_kind = eQueueKindSerial;
2068  } else if (queue_kind_str == "concurrent") {
2069  queue_vars_valid = true;
2070  queue_kind = eQueueKindConcurrent;
2071  }
2072  } else if (key == g_key_queue_serial_number) {
2073  queue_serial_number = object->GetIntegerValue(0);
2074  if (queue_serial_number != 0)
2075  queue_vars_valid = true;
2076  } else if (key == g_key_dispatch_queue_t) {
2077  dispatch_queue_t = object->GetIntegerValue(0);
2078  if (dispatch_queue_t != 0 && dispatch_queue_t != LLDB_INVALID_ADDRESS)
2079  queue_vars_valid = true;
2080  } else if (key == g_key_associated_with_dispatch_queue) {
2081  queue_vars_valid = true;
2082  bool associated = object->GetBooleanValue();
2083  if (associated)
2084  associated_with_dispatch_queue = eLazyBoolYes;
2085  else
2086  associated_with_dispatch_queue = eLazyBoolNo;
2087  } else if (key == g_key_reason) {
2088  reason = std::string(object->GetStringValue());
2089  } else if (key == g_key_description) {
2090  description = std::string(object->GetStringValue());
2091  } else if (key == g_key_registers) {
2092  StructuredData::Dictionary *registers_dict = object->GetAsDictionary();
2093 
2094  if (registers_dict) {
2095  registers_dict->ForEach(
2096  [&expedited_register_map](ConstString key,
2097  StructuredData::Object *object) -> bool {
2098  const uint32_t reg =
2100  if (reg != UINT32_MAX)
2101  expedited_register_map[reg] =
2102  std::string(object->GetStringValue());
2103  return true; // Keep iterating through all array items
2104  });
2105  }
2106  } else if (key == g_key_memory) {
2107  StructuredData::Array *array = object->GetAsArray();
2108  if (array) {
2109  array->ForEach([this](StructuredData::Object *object) -> bool {
2110  StructuredData::Dictionary *mem_cache_dict =
2111  object->GetAsDictionary();
2112  if (mem_cache_dict) {
2113  lldb::addr_t mem_cache_addr = LLDB_INVALID_ADDRESS;
2114  if (mem_cache_dict->GetValueForKeyAsInteger<lldb::addr_t>(
2115  "address", mem_cache_addr)) {
2116  if (mem_cache_addr != LLDB_INVALID_ADDRESS) {
2117  llvm::StringRef str;
2118  if (mem_cache_dict->GetValueForKeyAsString("bytes", str)) {
2119  StringExtractor bytes(str);
2120  bytes.SetFilePos(0);
2121 
2122  const size_t byte_size = bytes.GetStringRef().size() / 2;
2123  DataBufferSP data_buffer_sp(new DataBufferHeap(byte_size, 0));
2124  const size_t bytes_copied =
2125  bytes.GetHexBytes(data_buffer_sp->GetData(), 0);
2126  if (bytes_copied == byte_size)
2127  m_memory_cache.AddL1CacheData(mem_cache_addr,
2128  data_buffer_sp);
2129  }
2130  }
2131  }
2132  }
2133  return true; // Keep iterating through all array items
2134  });
2135  }
2136 
2137  } else if (key == g_key_signal)
2138  signo = object->GetIntegerValue(LLDB_INVALID_SIGNAL_NUMBER);
2139  return true; // Keep iterating through all dictionary key/value pairs
2140  });
2141 
2142  return SetThreadStopInfo(tid, expedited_register_map, signo, thread_name,
2143  reason, description, exc_type, exc_data,
2144  thread_dispatch_qaddr, queue_vars_valid,
2145  associated_with_dispatch_queue, dispatch_queue_t,
2146  queue_name, queue_kind, queue_serial_number);
2147 }
2148 
2151  stop_packet.SetFilePos(0);
2152  const char stop_type = stop_packet.GetChar();
2153  switch (stop_type) {
2154  case 'T':
2155  case 'S': {
2156  // This is a bit of a hack, but is is required. If we did exec, we need to
2157  // clear our thread lists and also know to rebuild our dynamic register
2158  // info before we lookup and threads and populate the expedited register
2159  // values so we need to know this right away so we can cleanup and update
2160  // our registers.
2161  const uint32_t stop_id = GetStopID();
2162  if (stop_id == 0) {
2163  // Our first stop, make sure we have a process ID, and also make sure we
2164  // know about our registers
2166  SetID(pid);
2168  }
2169  // Stop with signal and thread info
2172  const uint8_t signo = stop_packet.GetHexU8();
2173  llvm::StringRef key;
2174  llvm::StringRef value;
2175  std::string thread_name;
2176  std::string reason;
2177  std::string description;
2178  uint32_t exc_type = 0;
2179  std::vector<addr_t> exc_data;
2180  addr_t thread_dispatch_qaddr = LLDB_INVALID_ADDRESS;
2181  bool queue_vars_valid =
2182  false; // says if locals below that start with "queue_" are valid
2183  addr_t dispatch_queue_t = LLDB_INVALID_ADDRESS;
2184  LazyBool associated_with_dispatch_queue = eLazyBoolCalculate;
2185  std::string queue_name;
2186  QueueKind queue_kind = eQueueKindUnknown;
2187  uint64_t queue_serial_number = 0;
2188  ExpeditedRegisterMap expedited_register_map;
2189  while (stop_packet.GetNameColonValue(key, value)) {
2190  if (key.compare("metype") == 0) {
2191  // exception type in big endian hex
2192  value.getAsInteger(16, exc_type);
2193  } else if (key.compare("medata") == 0) {
2194  // exception data in big endian hex
2195  uint64_t x;
2196  value.getAsInteger(16, x);
2197  exc_data.push_back(x);
2198  } else if (key.compare("thread") == 0) {
2199  // thread-id
2200  StringExtractorGDBRemote thread_id{value};
2201  auto pid_tid = thread_id.GetPidTid(pid);
2202  if (pid_tid) {
2203  stop_pid = pid_tid->first;
2204  tid = pid_tid->second;
2205  } else
2206  tid = LLDB_INVALID_THREAD_ID;
2207  } else if (key.compare("threads") == 0) {
2208  std::lock_guard<std::recursive_mutex> guard(
2211  } else if (key.compare("thread-pcs") == 0) {
2212  m_thread_pcs.clear();
2213  // A comma separated list of all threads in the current
2214  // process that includes the thread for this stop reply packet
2215  lldb::addr_t pc;
2216  while (!value.empty()) {
2217  llvm::StringRef pc_str;
2218  std::tie(pc_str, value) = value.split(',');
2219  if (pc_str.getAsInteger(16, pc))
2221  m_thread_pcs.push_back(pc);
2222  }
2223  } else if (key.compare("jstopinfo") == 0) {
2224  StringExtractor json_extractor(value);
2225  std::string json;
2226  // Now convert the HEX bytes into a string value
2227  json_extractor.GetHexByteString(json);
2228 
2229  // This JSON contains thread IDs and thread stop info for all threads.
2230  // It doesn't contain expedited registers, memory or queue info.
2232  } else if (key.compare("hexname") == 0) {
2233  StringExtractor name_extractor(value);
2234  std::string name;
2235  // Now convert the HEX bytes into a string value
2236  name_extractor.GetHexByteString(thread_name);
2237  } else if (key.compare("name") == 0) {
2238  thread_name = std::string(value);
2239  } else if (key.compare("qaddr") == 0) {
2240  value.getAsInteger(16, thread_dispatch_qaddr);
2241  } else if (key.compare("dispatch_queue_t") == 0) {
2242  queue_vars_valid = true;
2243  value.getAsInteger(16, dispatch_queue_t);
2244  } else if (key.compare("qname") == 0) {
2245  queue_vars_valid = true;
2246  StringExtractor name_extractor(value);
2247  // Now convert the HEX bytes into a string value
2248  name_extractor.GetHexByteString(queue_name);
2249  } else if (key.compare("qkind") == 0) {
2250  queue_kind = llvm::StringSwitch<QueueKind>(value)
2251  .Case("serial", eQueueKindSerial)
2252  .Case("concurrent", eQueueKindConcurrent)
2253  .Default(eQueueKindUnknown);
2254  queue_vars_valid = queue_kind != eQueueKindUnknown;
2255  } else if (key.compare("qserialnum") == 0) {
2256  if (!value.getAsInteger(0, queue_serial_number))
2257  queue_vars_valid = true;
2258  } else if (key.compare("reason") == 0) {
2259  reason = std::string(value);
2260  } else if (key.compare("description") == 0) {
2261  StringExtractor desc_extractor(value);
2262  // Now convert the HEX bytes into a string value
2263  desc_extractor.GetHexByteString(description);
2264  } else if (key.compare("memory") == 0) {
2265  // Expedited memory. GDB servers can choose to send back expedited
2266  // memory that can populate the L1 memory cache in the process so that
2267  // things like the frame pointer backchain can be expedited. This will
2268  // help stack backtracing be more efficient by not having to send as
2269  // many memory read requests down the remote GDB server.
2270 
2271  // Key/value pair format: memory:<addr>=<bytes>;
2272  // <addr> is a number whose base will be interpreted by the prefix:
2273  // "0x[0-9a-fA-F]+" for hex
2274  // "0[0-7]+" for octal
2275  // "[1-9]+" for decimal
2276  // <bytes> is native endian ASCII hex bytes just like the register
2277  // values
2278  llvm::StringRef addr_str, bytes_str;
2279  std::tie(addr_str, bytes_str) = value.split('=');
2280  if (!addr_str.empty() && !bytes_str.empty()) {
2281  lldb::addr_t mem_cache_addr = LLDB_INVALID_ADDRESS;
2282  if (!addr_str.getAsInteger(0, mem_cache_addr)) {
2283  StringExtractor bytes(bytes_str);
2284  const size_t byte_size = bytes.GetBytesLeft() / 2;
2285  DataBufferSP data_buffer_sp(new DataBufferHeap(byte_size, 0));
2286  const size_t bytes_copied =
2287  bytes.GetHexBytes(data_buffer_sp->GetData(), 0);
2288  if (bytes_copied == byte_size)
2289  m_memory_cache.AddL1CacheData(mem_cache_addr, data_buffer_sp);
2290  }
2291  }
2292  } else if (key.compare("watch") == 0 || key.compare("rwatch") == 0 ||
2293  key.compare("awatch") == 0) {
2294  // Support standard GDB remote stop reply packet 'TAAwatch:addr'
2296  value.getAsInteger(16, wp_addr);
2297 
2298  WatchpointSP wp_sp =
2300  uint32_t wp_index = LLDB_INVALID_INDEX32;
2301 
2302  if (wp_sp)
2303  wp_index = wp_sp->GetHardwareIndex();
2304 
2305  reason = "watchpoint";
2306  StreamString ostr;
2307  ostr.Printf("%" PRIu64 " %" PRIu32, wp_addr, wp_index);
2308  description = std::string(ostr.GetString());
2309  } else if (key.compare("library") == 0) {
2310  auto error = LoadModules();
2311  if (error) {
2312  Log *log(
2314  LLDB_LOG_ERROR(log, std::move(error), "Failed to load modules: {0}");
2315  }
2316  } else if (key.size() == 2 && ::isxdigit(key[0]) && ::isxdigit(key[1])) {
2317  uint32_t reg = UINT32_MAX;
2318  if (!key.getAsInteger(16, reg))
2319  expedited_register_map[reg] = std::string(std::move(value));
2320  }
2321  }
2322 
2323  if (stop_pid != LLDB_INVALID_PROCESS_ID && stop_pid != pid) {
2325  LLDB_LOG(log,
2326  "Received stop for incorrect PID = {0} (inferior PID = {1})",
2327  stop_pid, pid);
2328  return eStateInvalid;
2329  }
2330 
2331  if (tid == LLDB_INVALID_THREAD_ID) {
2332  // A thread id may be invalid if the response is old style 'S' packet
2333  // which does not provide the
2334  // thread information. So update the thread list and choose the first
2335  // one.
2337 
2338  if (!m_thread_ids.empty()) {
2339  tid = m_thread_ids.front();
2340  }
2341  }
2342 
2343  ThreadSP thread_sp = SetThreadStopInfo(
2344  tid, expedited_register_map, signo, thread_name, reason, description,
2345  exc_type, exc_data, thread_dispatch_qaddr, queue_vars_valid,
2346  associated_with_dispatch_queue, dispatch_queue_t, queue_name,
2347  queue_kind, queue_serial_number);
2348 
2349  return eStateStopped;
2350  } break;
2351 
2352  case 'W':
2353  case 'X':
2354  // process exited
2355  return eStateExited;
2356 
2357  default:
2358  break;
2359  }
2360  return eStateInvalid;
2361 }
2362 
2364  std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
2365 
2366  m_thread_ids.clear();
2367  m_thread_pcs.clear();
2368 
2369  // Set the thread stop info. It might have a "threads" key whose value is a
2370  // list of all thread IDs in the current process, so m_thread_ids might get
2371  // set.
2372  // Check to see if SetThreadStopInfo() filled in m_thread_ids?
2373  if (m_thread_ids.empty()) {
2374  // No, we need to fetch the thread list manually
2376  }
2377 
2378  // We might set some stop info's so make sure the thread list is up to
2379  // date before we do that or we might overwrite what was computed here.
2381 
2382  // Scope for the lock
2383  {
2384  // Lock the thread stack while we access it
2385  std::lock_guard<std::recursive_mutex> guard(m_last_stop_packet_mutex);
2386  // Get the number of stop packets on the stack
2387  int nItems = m_stop_packet_stack.size();
2388  // Iterate over them
2389  for (int i = 0; i < nItems; i++) {
2390  // Get the thread stop info
2392  // Process thread stop info
2393  SetThreadStopInfo(stop_info);
2394  }
2395  // Clear the thread stop stack
2396  m_stop_packet_stack.clear();
2397  }
2398 
2399  // If we have queried for a default thread id
2403  }
2404 
2405  // Let all threads recover from stopping and do any clean up based on the
2406  // previous thread state (if any).
2408 }
2409 
2410 Status ProcessGDBRemote::DoHalt(bool &caused_stop) {
2411  Status error;
2412 
2414  // We are being asked to halt during an attach. We need to just close our
2415  // file handle and debugserver will go away, and we can be done...
2417  } else
2418  caused_stop = m_gdb_comm.Interrupt();
2419  return error;
2420 }
2421 
2423  Status error;
2425  LLDB_LOGF(log, "ProcessGDBRemote::DoDetach(keep_stopped: %i)", keep_stopped);
2426 
2427  error = m_gdb_comm.Detach(keep_stopped);
2428  if (log) {
2429  if (error.Success())
2430  log->PutCString(
2431  "ProcessGDBRemote::DoDetach() detach packet sent successfully");
2432  else
2433  LLDB_LOGF(log,
2434  "ProcessGDBRemote::DoDetach() detach packet send failed: %s",
2435  error.AsCString() ? error.AsCString() : "<unknown error>");
2436  }
2437 
2438  if (!error.Success())
2439  return error;
2440 
2441  // Sleep for one second to let the process get all detached...
2442  StopAsyncThread();
2443 
2446 
2447  // KillDebugserverProcess ();
2448  return error;
2449 }
2450 
2452  Status error;
2454  LLDB_LOGF(log, "ProcessGDBRemote::DoDestroy()");
2455 
2456  // There is a bug in older iOS debugservers where they don't shut down the
2457  // process they are debugging properly. If the process is sitting at a
2458  // breakpoint or an exception, this can cause problems with restarting. So
2459  // we check to see if any of our threads are stopped at a breakpoint, and if
2460  // so we remove all the breakpoints, resume the process, and THEN destroy it
2461  // again.
2462  //
2463  // Note, we don't have a good way to test the version of debugserver, but I
2464  // happen to know that the set of all the iOS debugservers which don't
2465  // support GetThreadSuffixSupported() and that of the debugservers with this
2466  // bug are equal. There really should be a better way to test this!
2467  //
2468  // We also use m_destroy_tried_resuming to make sure we only do this once, if
2469  // we resume and then halt and get called here to destroy again and we're
2470  // still at a breakpoint or exception, then we should just do the straight-
2471  // forward kill.
2472  //
2473  // And of course, if we weren't able to stop the process by the time we get
2474  // here, it isn't necessary (or helpful) to do any of this.
2475 
2478  PlatformSP platform_sp = GetTarget().GetPlatform();
2479 
2480  // FIXME: These should be ConstStrings so we aren't doing strcmp'ing.
2481  if (platform_sp && platform_sp->GetName() &&
2482  platform_sp->GetName() == PlatformRemoteiOS::GetPluginNameStatic()) {
2484  if (log)
2485  log->PutCString("ProcessGDBRemote::DoDestroy() - Tried resuming to "
2486  "destroy once already, not doing it again.");
2487  } else {
2488  // At present, the plans are discarded and the breakpoints disabled
2489  // Process::Destroy, but we really need it to happen here and it
2490  // doesn't matter if we do it twice.
2493 
2494  bool stop_looks_like_crash = false;
2495  ThreadList &threads = GetThreadList();
2496 
2497  {
2498  std::lock_guard<std::recursive_mutex> guard(threads.GetMutex());
2499 
2500  size_t num_threads = threads.GetSize();
2501  for (size_t i = 0; i < num_threads; i++) {
2502  ThreadSP thread_sp = threads.GetThreadAtIndex(i);
2503  StopInfoSP stop_info_sp = thread_sp->GetPrivateStopInfo();
2504  StopReason reason = eStopReasonInvalid;
2505  if (stop_info_sp)
2506  reason = stop_info_sp->GetStopReason();
2507  if (reason == eStopReasonBreakpoint ||
2508  reason == eStopReasonException) {
2509  LLDB_LOGF(log,
2510  "ProcessGDBRemote::DoDestroy() - thread: 0x%4.4" PRIx64
2511  " stopped with reason: %s.",
2512  thread_sp->GetProtocolID(),
2513  stop_info_sp->GetDescription());
2514  stop_looks_like_crash = true;
2515  break;
2516  }
2517  }
2518  }
2519 
2520  if (stop_looks_like_crash) {
2521  if (log)
2522  log->PutCString("ProcessGDBRemote::DoDestroy() - Stopped at a "
2523  "breakpoint, continue and then kill.");
2524  m_destroy_tried_resuming = true;
2525 
2526  // If we are going to run again before killing, it would be good to
2527  // suspend all the threads before resuming so they won't get into
2528  // more trouble. Sadly, for the threads stopped with the breakpoint
2529  // or exception, the exception doesn't get cleared if it is
2530  // suspended, so we do have to run the risk of letting those threads
2531  // proceed a bit.
2532 
2533  {
2534  std::lock_guard<std::recursive_mutex> guard(threads.GetMutex());
2535 
2536  size_t num_threads = threads.GetSize();
2537  for (size_t i = 0; i < num_threads; i++) {
2538  ThreadSP thread_sp = threads.GetThreadAtIndex(i);
2539  StopInfoSP stop_info_sp = thread_sp->GetPrivateStopInfo();
2540  StopReason reason = eStopReasonInvalid;
2541  if (stop_info_sp)
2542  reason = stop_info_sp->GetStopReason();
2543  if (reason != eStopReasonBreakpoint &&
2544  reason != eStopReasonException) {
2545  LLDB_LOGF(log,
2546  "ProcessGDBRemote::DoDestroy() - Suspending "
2547  "thread: 0x%4.4" PRIx64 " before running.",
2548  thread_sp->GetProtocolID());
2549  thread_sp->SetResumeState(eStateSuspended);
2550  }
2551  }
2552  }
2553  Resume();
2554  return Destroy(false);
2555  }
2556  }
2557  }
2558  }
2559 
2560  // Interrupt if our inferior is running...
2561  int exit_status = SIGABRT;
2562  std::string exit_string;
2563 
2564  if (m_gdb_comm.IsConnected()) {
2566  StringExtractorGDBRemote response;
2567  bool send_async = true;
2569  std::chrono::seconds(3));
2570 
2571  if (m_gdb_comm.SendPacketAndWaitForResponse("k", response, send_async) ==
2573  char packet_cmd = response.GetChar(0);
2574 
2575  if (packet_cmd == 'W' || packet_cmd == 'X') {
2576 #if defined(__APPLE__)
2577  // For Native processes on Mac OS X, we launch through the Host
2578  // Platform, then hand the process off to debugserver, which becomes
2579  // the parent process through "PT_ATTACH". Then when we go to kill
2580  // the process on Mac OS X we call ptrace(PT_KILL) to kill it, then
2581  // we call waitpid which returns with no error and the correct
2582  // status. But amusingly enough that doesn't seem to actually reap
2583  // the process, but instead it is left around as a Zombie. Probably
2584  // the kernel is in the process of switching ownership back to lldb
2585  // which was the original parent, and gets confused in the handoff.
2586  // Anyway, so call waitpid here to finally reap it.
2587  PlatformSP platform_sp(GetTarget().GetPlatform());
2588  if (platform_sp && platform_sp->IsHost()) {
2589  int status;
2590  ::pid_t reap_pid;
2591  reap_pid = waitpid(GetID(), &status, WNOHANG);
2592  LLDB_LOGF(log, "Reaped pid: %d, status: %d.\n", reap_pid, status);
2593  }
2594 #endif
2595  SetLastStopPacket(response);
2597  exit_status = response.GetHexU8();
2598  } else {
2599  LLDB_LOGF(log,
2600  "ProcessGDBRemote::DoDestroy - got unexpected response "
2601  "to k packet: %s",
2602  response.GetStringRef().data());
2603  exit_string.assign("got unexpected response to k packet: ");
2604  exit_string.append(std::string(response.GetStringRef()));
2605  }
2606  } else {
2607  LLDB_LOGF(log, "ProcessGDBRemote::DoDestroy - failed to send k packet");
2608  exit_string.assign("failed to send the k packet");
2609  }
2610  } else {
2611  LLDB_LOGF(log,
2612  "ProcessGDBRemote::DoDestroy - killed or interrupted while "
2613  "attaching");
2614  exit_string.assign("killed or interrupted while attaching.");
2615  }
2616  } else {
2617  // If we missed setting the exit status on the way out, do it here.
2618  // NB set exit status can be called multiple times, the first one sets the
2619  // status.
2620  exit_string.assign("destroying when not connected to debugserver");
2621  }
2622 
2623  SetExitStatus(exit_status, exit_string.c_str());
2624 
2625  StopAsyncThread();
2627  return error;
2628 }
2629 
2631  const StringExtractorGDBRemote &response) {
2632  const bool did_exec =
2633  response.GetStringRef().find(";reason:exec;") != std::string::npos;
2634  if (did_exec) {
2636  LLDB_LOGF(log, "ProcessGDBRemote::SetLastStopPacket () - detected exec");
2637 
2639  m_thread_list.Clear();
2642  }
2643 
2644  // Scope the lock
2645  {
2646  // Lock the thread stack while we access it
2647  std::lock_guard<std::recursive_mutex> guard(m_last_stop_packet_mutex);
2648 
2649  // We are are not using non-stop mode, there can only be one last stop
2650  // reply packet, so clear the list.
2651  if (!GetTarget().GetNonStopModeEnabled())
2652  m_stop_packet_stack.clear();
2653 
2654  // Add this stop packet to the stop packet stack This stack will get popped
2655  // and examined when we switch to the Stopped state
2656  m_stop_packet_stack.push_back(response);
2657  }
2658 }
2659 
2660 void ProcessGDBRemote::SetUnixSignals(const UnixSignalsSP &signals_sp) {
2661  Process::SetUnixSignals(std::make_shared<GDBRemoteSignals>(signals_sp));
2662 }
2663 
2664 // Process Queries
2665 
2667  return m_gdb_comm.IsConnected() && Process::IsAlive();
2668 }
2669 
2671  // request the link map address via the $qShlibInfoAddr packet
2673 
2674  // the loaded module list can also provides a link map address
2675  if (addr == LLDB_INVALID_ADDRESS) {
2676  llvm::Expected<LoadedModuleInfoList> list = GetLoadedModuleList();
2677  if (!list) {
2679  LLDB_LOG_ERROR(log, list.takeError(), "Failed to read module list: {0}.");
2680  } else {
2681  addr = list->m_link_map;
2682  }
2683  }
2684 
2685  return addr;
2686 }
2687 
2689  // See if the GDB remote client supports the JSON threads info. If so, we
2690  // gather stop info for all threads, expedited registers, expedited memory,
2691  // runtime queue information (iOS and MacOSX only), and more. Expediting
2692  // memory will help stack backtracing be much faster. Expediting registers
2693  // will make sure we don't have to read the thread registers for GPRs.
2695 
2696  if (m_jthreadsinfo_sp) {
2697  // Now set the stop info for each thread and also expedite any registers
2698  // and memory that was in the jThreadsInfo response.
2699  StructuredData::Array *thread_infos = m_jthreadsinfo_sp->GetAsArray();
2700  if (thread_infos) {
2701  const size_t n = thread_infos->GetSize();
2702  for (size_t i = 0; i < n; ++i) {
2703  StructuredData::Dictionary *thread_dict =
2704  thread_infos->GetItemAtIndex(i)->GetAsDictionary();
2705  if (thread_dict)
2706  SetThreadStopInfo(thread_dict);
2707  }
2708  }
2709  }
2710 }
2711 
2712 // Process Memory
2713 size_t ProcessGDBRemote::DoReadMemory(addr_t addr, void *buf, size_t size,
2714  Status &error) {
2715  GetMaxMemorySize();
2716  bool binary_memory_read = m_gdb_comm.GetxPacketSupported();
2717  // M and m packets take 2 bytes for 1 byte of memory
2718  size_t max_memory_size =
2719  binary_memory_read ? m_max_memory_size : m_max_memory_size / 2;
2720  if (size > max_memory_size) {
2721  // Keep memory read sizes down to a sane limit. This function will be
2722  // called multiple times in order to complete the task by
2723  // lldb_private::Process so it is ok to do this.
2724  size = max_memory_size;
2725  }
2726 
2727  char packet[64];
2728  int packet_len;
2729  packet_len = ::snprintf(packet, sizeof(packet), "%c%" PRIx64 ",%" PRIx64,
2730  binary_memory_read ? 'x' : 'm', (uint64_t)addr,
2731  (uint64_t)size);
2732  assert(packet_len + 1 < (int)sizeof(packet));
2733  UNUSED_IF_ASSERT_DISABLED(packet_len);
2734  StringExtractorGDBRemote response;
2735  if (m_gdb_comm.SendPacketAndWaitForResponse(packet, response, true) ==
2737  if (response.IsNormalResponse()) {
2738  error.Clear();
2739  if (binary_memory_read) {
2740  // The lower level GDBRemoteCommunication packet receive layer has
2741  // already de-quoted any 0x7d character escaping that was present in
2742  // the packet
2743 
2744  size_t data_received_size = response.GetBytesLeft();
2745  if (data_received_size > size) {
2746  // Don't write past the end of BUF if the remote debug server gave us
2747  // too much data for some reason.
2748  data_received_size = size;
2749  }
2750  memcpy(buf, response.GetStringRef().data(), data_received_size);
2751  return data_received_size;
2752  } else {
2753  return response.GetHexBytes(
2754  llvm::MutableArrayRef<uint8_t>((uint8_t *)buf, size), '\xdd');
2755  }
2756  } else if (response.IsErrorResponse())
2757  error.SetErrorStringWithFormat("memory read failed for 0x%" PRIx64, addr);
2758  else if (response.IsUnsupportedResponse())
2759  error.SetErrorStringWithFormat(
2760  "GDB server does not support reading memory");
2761  else
2762  error.SetErrorStringWithFormat(
2763  "unexpected response to GDB server memory read packet '%s': '%s'",
2764  packet, response.GetStringRef().data());
2765  } else {
2766  error.SetErrorStringWithFormat("failed to send packet: '%s'", packet);
2767  }
2768  return 0;
2769 }
2770 
2772  std::vector<ObjectFile::LoadableData> entries) {
2773  Status error;
2774  // Sort the entries by address because some writes, like those to flash
2775  // memory, must happen in order of increasing address.
2776  std::stable_sort(
2777  std::begin(entries), std::end(entries),
2778  [](const ObjectFile::LoadableData a, const ObjectFile::LoadableData b) {
2779  return a.Dest < b.Dest;
2780  });
2781  m_allow_flash_writes = true;
2782  error = Process::WriteObjectFile(entries);
2783  if (error.Success())
2784  error = FlashDone();
2785  else
2786  // Even though some of the writing failed, try to send a flash done if some
2787  // of the writing succeeded so the flash state is reset to normal, but
2788  // don't stomp on the error status that was set in the write failure since
2789  // that's the one we want to report back.
2790  FlashDone();
2791  m_allow_flash_writes = false;
2792  return error;
2793 }
2794 
2796  auto size = m_erased_flash_ranges.GetSize();
2797  for (size_t i = 0; i < size; ++i)
2799  return true;
2800  return false;
2801 }
2802 
2804  Status status;
2805 
2806  MemoryRegionInfo region;
2807  status = GetMemoryRegionInfo(addr, region);
2808  if (!status.Success())
2809  return status;
2810 
2811  // The gdb spec doesn't say if erasures are allowed across multiple regions,
2812  // but we'll disallow it to be safe and to keep the logic simple by worring
2813  // about only one region's block size. DoMemoryWrite is this function's
2814  // primary user, and it can easily keep writes within a single memory region
2815  if (addr + size > region.GetRange().GetRangeEnd()) {
2816  status.SetErrorString("Unable to erase flash in multiple regions");
2817  return status;
2818  }
2819 
2820  uint64_t blocksize = region.GetBlocksize();
2821  if (blocksize == 0) {
2822  status.SetErrorString("Unable to erase flash because blocksize is 0");
2823  return status;
2824  }
2825 
2826  // Erasures can only be done on block boundary adresses, so round down addr
2827  // and round up size
2828  lldb::addr_t block_start_addr = addr - (addr % blocksize);
2829  size += (addr - block_start_addr);
2830  if ((size % blocksize) != 0)
2831  size += (blocksize - size % blocksize);
2832 
2833  FlashRange range(block_start_addr, size);
2834 
2835  if (HasErased(range))
2836  return status;
2837 
2838  // We haven't erased the entire range, but we may have erased part of it.
2839  // (e.g., block A is already erased and range starts in A and ends in B). So,
2840  // adjust range if necessary to exclude already erased blocks.
2841  if (!m_erased_flash_ranges.IsEmpty()) {
2842  // Assuming that writes and erasures are done in increasing addr order,
2843  // because that is a requirement of the vFlashWrite command. Therefore, we
2844  // only need to look at the last range in the list for overlap.
2845  const auto &last_range = *m_erased_flash_ranges.Back();
2846  if (range.GetRangeBase() < last_range.GetRangeEnd()) {
2847  auto overlap = last_range.GetRangeEnd() - range.GetRangeBase();
2848  // overlap will be less than range.GetByteSize() or else HasErased()
2849  // would have been true
2850  range.SetByteSize(range.GetByteSize() - overlap);
2851  range.SetRangeBase(range.GetRangeBase() + overlap);
2852  }
2853  }
2854 
2855  StreamString packet;
2856  packet.Printf("vFlashErase:%" PRIx64 ",%" PRIx64, range.GetRangeBase(),
2857  (uint64_t)range.GetByteSize());
2858 
2859  StringExtractorGDBRemote response;
2860  if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response,
2861  true) ==
2863  if (response.IsOKResponse()) {
2864  m_erased_flash_ranges.Insert(range, true);
2865  } else {
2866  if (response.IsErrorResponse())
2867  status.SetErrorStringWithFormat("flash erase failed for 0x%" PRIx64,
2868  addr);
2869  else if (response.IsUnsupportedResponse())
2870  status.SetErrorStringWithFormat("GDB server does not support flashing");
2871  else
2872  status.SetErrorStringWithFormat(
2873  "unexpected response to GDB server flash erase packet '%s': '%s'",
2874  packet.GetData(), response.GetStringRef().data());
2875  }
2876  } else {
2877  status.SetErrorStringWithFormat("failed to send packet: '%s'",
2878  packet.GetData());
2879  }
2880  return status;
2881 }
2882 
2884  Status status;
2885  // If we haven't erased any blocks, then we must not have written anything
2886  // either, so there is no need to actually send a vFlashDone command
2888  return status;
2889  StringExtractorGDBRemote response;
2890  if (m_gdb_comm.SendPacketAndWaitForResponse("vFlashDone", response, true) ==
2892  if (response.IsOKResponse()) {
2894  } else {
2895  if (response.IsErrorResponse())
2896  status.SetErrorStringWithFormat("flash done failed");
2897  else if (response.IsUnsupportedResponse())
2898  status.SetErrorStringWithFormat("GDB server does not support flashing");
2899  else
2900  status.SetErrorStringWithFormat(
2901  "unexpected response to GDB server flash done packet: '%s'",
2902  response.GetStringRef().data());
2903  }
2904  } else {
2905  status.SetErrorStringWithFormat("failed to send flash done packet");
2906  }
2907  return status;
2908 }
2909 
2910 size_t ProcessGDBRemote::DoWriteMemory(addr_t addr, const void *buf,
2911  size_t size, Status &error) {
2912  GetMaxMemorySize();
2913  // M and m packets take 2 bytes for 1 byte of memory
2914  size_t max_memory_size = m_max_memory_size / 2;
2915  if (size > max_memory_size) {
2916  // Keep memory read sizes down to a sane limit. This function will be
2917  // called multiple times in order to complete the task by
2918  // lldb_private::Process so it is ok to do this.
2919  size = max_memory_size;
2920  }
2921 
2922  StreamGDBRemote packet;
2923 
2924  MemoryRegionInfo region;
2925  Status region_status = GetMemoryRegionInfo(addr, region);
2926 
2927  bool is_flash =
2928  region_status.Success() && region.GetFlash() == MemoryRegionInfo::eYes;
2929 
2930  if (is_flash) {
2931  if (!m_allow_flash_writes) {
2932  error.SetErrorString("Writing to flash memory is not allowed");
2933  return 0;
2934  }
2935  // Keep the write within a flash memory region
2936  if (addr + size > region.GetRange().GetRangeEnd())
2937  size = region.GetRange().GetRangeEnd() - addr;
2938  // Flash memory must be erased before it can be written
2939  error = FlashErase(addr, size);
2940  if (!error.Success())
2941  return 0;
2942  packet.Printf("vFlashWrite:%" PRIx64 ":", addr);
2943  packet.PutEscapedBytes(buf, size);
2944  } else {
2945  packet.Printf("M%" PRIx64 ",%" PRIx64 ":", addr, (uint64_t)size);
2946  packet.PutBytesAsRawHex8(buf, size, endian::InlHostByteOrder(),
2948  }
2949  StringExtractorGDBRemote response;
2950  if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response,
2951  true) ==
2953  if (response.IsOKResponse()) {
2954  error.Clear();
2955  return size;
2956  } else if (response.IsErrorResponse())
2957  error.SetErrorStringWithFormat("memory write failed for 0x%" PRIx64,
2958  addr);
2959  else if (response.IsUnsupportedResponse())
2960  error.SetErrorStringWithFormat(
2961  "GDB server does not support writing memory");
2962  else
2963  error.SetErrorStringWithFormat(
2964  "unexpected response to GDB server memory write packet '%s': '%s'",
2965  packet.GetData(), response.GetStringRef().data());
2966  } else {
2967  error.SetErrorStringWithFormat("failed to send packet: '%s'",
2968  packet.GetData());
2969  }
2970  return 0;
2971 }
2972 
2974  uint32_t permissions,
2975  Status &error) {
2976  Log *log(
2978  addr_t allocated_addr = LLDB_INVALID_ADDRESS;
2979 
2981  allocated_addr = m_gdb_comm.AllocateMemory(size, permissions);
2982  if (allocated_addr != LLDB_INVALID_ADDRESS ||
2984  return allocated_addr;
2985  }
2986 
2988  // Call mmap() to create memory in the inferior..
2989  unsigned prot = 0;
2990  if (permissions & lldb::ePermissionsReadable)
2991  prot |= eMmapProtRead;
2992  if (permissions & lldb::ePermissionsWritable)
2993  prot |= eMmapProtWrite;
2994  if (permissions & lldb::ePermissionsExecutable)
2995  prot |= eMmapProtExec;
2996 
2997  if (InferiorCallMmap(this, allocated_addr, 0, size, prot,
2999  m_addr_to_mmap_size[allocated_addr] = size;
3000  else {
3001  allocated_addr = LLDB_INVALID_ADDRESS;
3002  LLDB_LOGF(log,
3003  "ProcessGDBRemote::%s no direct stub support for memory "
3004  "allocation, and InferiorCallMmap also failed - is stub "
3005  "missing register context save/restore capability?",
3006  __FUNCTION__);
3007  }
3008  }
3009 
3010  if (allocated_addr == LLDB_INVALID_ADDRESS)
3011  error.SetErrorStringWithFormat(
3012  "unable to allocate %" PRIu64 " bytes of memory with permissions %s",
3013  (uint64_t)size, GetPermissionsAsCString(permissions));
3014  else
3015  error.Clear();
3016  return allocated_addr;
3017 }
3018 
3020  MemoryRegionInfo &region_info) {
3021 
3022  Status error(m_gdb_comm.GetMemoryRegionInfo(load_addr, region_info));
3023  return error;
3024 }
3025 
3027 
3029  return error;
3030 }
3031 
3034  num, after, GetTarget().GetArchitecture()));
3035  return error;
3036 }
3037 
3039  Status error;
3041 
3042  switch (supported) {
3043  case eLazyBoolCalculate:
3044  // We should never be deallocating memory without allocating memory first
3045  // so we should never get eLazyBoolCalculate
3046  error.SetErrorString(
3047  "tried to deallocate memory without ever allocating memory");
3048  break;
3049 
3050  case eLazyBoolYes:
3051  if (!m_gdb_comm.DeallocateMemory(addr))
3052  error.SetErrorStringWithFormat(
3053  "unable to deallocate memory at 0x%" PRIx64, addr);
3054  break;
3055 
3056  case eLazyBoolNo:
3057  // Call munmap() to deallocate memory in the inferior..
3058  {
3059  MMapMap::iterator pos = m_addr_to_mmap_size.find(addr);
3060  if (pos != m_addr_to_mmap_size.end() &&
3061  InferiorCallMunmap(this, addr, pos->second))
3062  m_addr_to_mmap_size.erase(pos);
3063  else
3064  error.SetErrorStringWithFormat(
3065  "unable to deallocate memory at 0x%" PRIx64, addr);
3066  }
3067  break;
3068  }
3069 
3070  return error;
3071 }
3072 
3073 // Process STDIO
3074 size_t ProcessGDBRemote::PutSTDIN(const char *src, size_t src_len,
3075  Status &error) {
3077  ConnectionStatus status;
3078  m_stdio_communication.Write(src, src_len, status, nullptr);
3079  } else if (m_stdin_forward) {
3080  m_gdb_comm.SendStdinNotification(src, src_len);
3081  }
3082  return 0;
3083 }
3084 
3086  Status error;
3087  assert(bp_site != nullptr);
3088 
3089  // Get logging info
3091  user_id_t site_id = bp_site->GetID();
3092 
3093  // Get the breakpoint address
3094  const addr_t addr = bp_site->GetLoadAddress();
3095 
3096  // Log that a breakpoint was requested
3097  LLDB_LOGF(log,
3098  "ProcessGDBRemote::EnableBreakpointSite (size_id = %" PRIu64
3099  ") address = 0x%" PRIx64,
3100  site_id, (uint64_t)addr);
3101 
3102  // Breakpoint already exists and is enabled
3103  if (bp_site->IsEnabled()) {
3104  LLDB_LOGF(log,
3105  "ProcessGDBRemote::EnableBreakpointSite (size_id = %" PRIu64
3106  ") address = 0x%" PRIx64 " -- SUCCESS (already enabled)",
3107  site_id, (uint64_t)addr);
3108  return error;
3109  }
3110 
3111  // Get the software breakpoint trap opcode size
3112  const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode(bp_site);
3113 
3114  // SupportsGDBStoppointPacket() simply checks a boolean, indicating if this
3115  // breakpoint type is supported by the remote stub. These are set to true by
3116  // default, and later set to false only after we receive an unimplemented
3117  // response when sending a breakpoint packet. This means initially that
3118  // unless we were specifically instructed to use a hardware breakpoint, LLDB
3119  // will attempt to set a software breakpoint. HardwareRequired() also queries
3120  // a boolean variable which indicates if the user specifically asked for
3121  // hardware breakpoints. If true then we will skip over software
3122  // breakpoints.
3124  (!bp_site->HardwareRequired())) {
3125  // Try to send off a software breakpoint packet ($Z0)
3126  uint8_t error_no = m_gdb_comm.SendGDBStoppointTypePacket(
3127  eBreakpointSoftware, true, addr, bp_op_size);
3128  if (error_no == 0) {
3129  // The breakpoint was placed successfully
3130  bp_site->SetEnabled(true);
3132  return error;
3133  }
3134 
3135  // SendGDBStoppointTypePacket() will return an error if it was unable to
3136  // set this breakpoint. We need to differentiate between a error specific
3137  // to placing this breakpoint or if we have learned that this breakpoint
3138  // type is unsupported. To do this, we must test the support boolean for
3139  // this breakpoint type to see if it now indicates that this breakpoint
3140  // type is unsupported. If they are still supported then we should return
3141  // with the error code. If they are now unsupported, then we would like to
3142  // fall through and try another form of breakpoint.
3144  if (error_no != UINT8_MAX)
3145  error.SetErrorStringWithFormat(
3146  "error: %d sending the breakpoint request", error_no);
3147  else
3148  error.SetErrorString("error sending the breakpoint request");
3149  return error;
3150  }
3151 
3152  // We reach here when software breakpoints have been found to be
3153  // unsupported. For future calls to set a breakpoint, we will not attempt
3154  // to set a breakpoint with a type that is known not to be supported.
3155  LLDB_LOGF(log, "Software breakpoints are unsupported");
3156 
3157  // So we will fall through and try a hardware breakpoint
3158  }
3159 
3160  // The process of setting a hardware breakpoint is much the same as above.
3161  // We check the supported boolean for this breakpoint type, and if it is
3162  // thought to be supported then we will try to set this breakpoint with a
3163  // hardware breakpoint.
3165  // Try to send off a hardware breakpoint packet ($Z1)
3166  uint8_t error_no = m_gdb_comm.SendGDBStoppointTypePacket(
3167  eBreakpointHardware, true, addr, bp_op_size);
3168  if (error_no == 0) {
3169  // The breakpoint was placed successfully
3170  bp_site->SetEnabled(true);
3172  return error;
3173  }
3174 
3175  // Check if the error was something other then an unsupported breakpoint
3176  // type
3178  // Unable to set this hardware breakpoint
3179  if (error_no != UINT8_MAX)
3180  error.SetErrorStringWithFormat(
3181  "error: %d sending the hardware breakpoint request "
3182  "(hardware breakpoint resources might be exhausted or unavailable)",
3183  error_no);
3184  else
3185  error.SetErrorString("error sending the hardware breakpoint request "
3186  "(hardware breakpoint resources "
3187  "might be exhausted or unavailable)");
3188  return error;
3189  }
3190 
3191  // We will reach here when the stub gives an unsupported response to a
3192  // hardware breakpoint
3193  LLDB_LOGF(log, "Hardware breakpoints are unsupported");
3194 
3195  // Finally we will falling through to a #trap style breakpoint
3196  }
3197 
3198  // Don't fall through when hardware breakpoints were specifically requested
3199  if (bp_site->HardwareRequired()) {
3200  error.SetErrorString("hardware breakpoints are not supported");
3201  return error;
3202  }
3203 
3204  // As a last resort we want to place a manual breakpoint. An instruction is
3205  // placed into the process memory using memory write packets.
3206  return EnableSoftwareBreakpoint(bp_site);
3207 }
3208 
3210  Status error;
3211  assert(bp_site != nullptr);
3212  addr_t addr = bp_site->GetLoadAddress();
3213  user_id_t site_id = bp_site->GetID();
3215  LLDB_LOGF(log,
3216  "ProcessGDBRemote::DisableBreakpointSite (site_id = %" PRIu64
3217  ") addr = 0x%8.8" PRIx64,
3218  site_id, (uint64_t)addr);
3219 
3220  if (bp_site->IsEnabled()) {
3221  const size_t bp_op_size = GetSoftwareBreakpointTrapOpcode(bp_site);
3222 
3223  BreakpointSite::Type bp_type = bp_site->GetType();
3224  switch (bp_type) {
3226  error = DisableSoftwareBreakpoint(bp_site);
3227  break;
3228 
3231  addr, bp_op_size))
3232  error.SetErrorToGenericError();
3233  break;
3234 
3237  addr, bp_op_size))
3238  error.SetErrorToGenericError();
3239  } break;
3240  }
3241  if (error.Success())
3242  bp_site->SetEnabled(false);
3243  } else {
3244  LLDB_LOGF(log,
3245  "ProcessGDBRemote::DisableBreakpointSite (site_id = %" PRIu64
3246  ") addr = 0x%8.8" PRIx64 " -- SUCCESS (already disabled)",
3247  site_id, (uint64_t)addr);
3248  return error;
3249  }
3250 
3251  if (error.Success())
3252  error.SetErrorToGenericError();
3253  return error;
3254 }
3255 
3256 // Pre-requisite: wp != NULL.
3258  assert(wp);
3259  bool watch_read = wp->WatchpointRead();
3260  bool watch_write = wp->WatchpointWrite();
3261 
3262  // watch_read and watch_write cannot both be false.
3263  assert(watch_read || watch_write);
3264  if (watch_read && watch_write)
3265  return eWatchpointReadWrite;
3266  else if (watch_read)
3267  return eWatchpointRead;
3268  else // Must be watch_write, then.
3269  return eWatchpointWrite;
3270 }
3271 
3273  Status error;
3274  if (wp) {
3275  user_id_t watchID = wp->GetID();
3276  addr_t addr = wp->GetLoadAddress();
3277  Log *log(
3279  LLDB_LOGF(log, "ProcessGDBRemote::EnableWatchpoint(watchID = %" PRIu64 ")",
3280  watchID);
3281  if (wp->IsEnabled()) {
3282  LLDB_LOGF(log,
3283  "ProcessGDBRemote::EnableWatchpoint(watchID = %" PRIu64
3284  ") addr = 0x%8.8" PRIx64 ": watchpoint already enabled.",
3285  watchID, (uint64_t)addr);
3286  return error;
3287  }
3288 
3290  // Pass down an appropriate z/Z packet...
3292  if (m_gdb_comm.SendGDBStoppointTypePacket(type, true, addr,
3293  wp->GetByteSize()) == 0) {
3294  wp->SetEnabled(true, notify);
3295  return error;
3296  } else
3297  error.SetErrorString("sending gdb watchpoint packet failed");
3298  } else
3299  error.SetErrorString("watchpoints not supported");
3300  } else {
3301  error.SetErrorString("Watchpoint argument was NULL.");
3302  }
3303  if (error.Success())
3304  error.SetErrorToGenericError();
3305  return error;
3306 }
3307 
3309  Status error;
3310  if (wp) {
3311  user_id_t watchID = wp->GetID();
3312 
3313  Log *log(
3315 
3316  addr_t addr = wp->GetLoadAddress();
3317 
3318  LLDB_LOGF(log,
3319  "ProcessGDBRemote::DisableWatchpoint (watchID = %" PRIu64
3320  ") addr = 0x%8.8" PRIx64,
3321  watchID, (uint64_t)addr);
3322 
3323  if (!wp->IsEnabled()) {
3324  LLDB_LOGF(log,
3325  "ProcessGDBRemote::DisableWatchpoint (watchID = %" PRIu64
3326  ") addr = 0x%8.8" PRIx64 " -- SUCCESS (already disabled)",
3327  watchID, (uint64_t)addr);
3328  // See also 'class WatchpointSentry' within StopInfo.cpp. This disabling
3329  // attempt might come from the user-supplied actions, we'll route it in
3330  // order for the watchpoint object to intelligently process this action.
3331  wp->SetEnabled(false, notify);
3332  return error;
3333  }
3334 
3335  if (wp->IsHardware()) {
3337  // Pass down an appropriate z/Z packet...
3338  if (m_gdb_comm.SendGDBStoppointTypePacket(type, false, addr,
3339  wp->GetByteSize()) == 0) {
3340  wp->SetEnabled(false, notify);
3341  return error;
3342  } else
3343  error.SetErrorString("sending gdb watchpoint packet failed");
3344  }
3345  // TODO: clear software watchpoints if we implement them
3346  } else {
3347  error.SetErrorString("Watchpoint argument was NULL.");
3348  }
3349  if (error.Success())
3350  error.SetErrorToGenericError();
3351  return error;
3352 }
3353 
3356  m_thread_list.Clear();
3357 }
3358 
3360  Status error;
3362  LLDB_LOGF(log, "ProcessGDBRemote::DoSignal (signal = %d)", signo);
3363 
3364  if (!m_gdb_comm.SendAsyncSignal(signo))
3365  error.SetErrorStringWithFormat("failed to send signal %i", signo);
3366  return error;
3367 }
3368 
3371  if (status.Fail())
3372  return status;
3373 
3374  // Enable replay mode.
3375  m_replay_mode = true;
3376 
3377  // Start server thread.
3379 
3380  // Start client thread.
3381  StartAsyncThread();
3382 
3383  // Do the usual setup.
3384  return ConnectToDebugserver("");
3385 }
3386 
3387 Status
3389  // Make sure we aren't already connected?
3390  if (m_gdb_comm.IsConnected())
3391  return Status();
3392 
3393  PlatformSP platform_sp(GetTarget().GetPlatform());
3394  if (platform_sp && !platform_sp->IsHost())
3395  return Status("Lost debug server connection");
3396 
3397  if (repro::Reproducer::Instance().IsReplaying())
3398  return ConnectToReplayServer();
3399 
3400  auto error = LaunchAndConnectToDebugserver(process_info);
3401  if (error.Fail()) {
3402  const char *error_string = error.AsCString();
3403  if (error_string == nullptr)
3404  error_string = "unable to launch " DEBUGSERVER_BASENAME;
3405  }
3406  return error;
3407 }
3408 #if !defined(_WIN32)
3409 #define USE_SOCKETPAIR_FOR_LOCAL_CONNECTION 1
3410 #endif
3411 
3412 #ifdef USE_SOCKETPAIR_FOR_LOCAL_CONNECTION
3413 static bool SetCloexecFlag(int fd) {
3414 #if defined(FD_CLOEXEC)
3415  int flags = ::fcntl(fd, F_GETFD);
3416  if (flags == -1)
3417  return false;
3418  return (::fcntl(fd, F_SETFD, flags | FD_CLOEXEC) == 0);
3419 #else
3420  return false;
3421 #endif
3422 }
3423 #endif
3424 
3426  const ProcessInfo &process_info) {
3427  using namespace std::placeholders; // For _1, _2, etc.
3428 
3429  Status error;
3431  // If we locate debugserver, keep that located version around
3432  static FileSpec g_debugserver_file_spec;
3433 
3434  ProcessLaunchInfo debugserver_launch_info;
3435  // Make debugserver run in its own session so signals generated by special
3436  // terminal key sequences (^C) don't affect debugserver.
3437  debugserver_launch_info.SetLaunchInSeparateProcessGroup(true);
3438 
3439  const std::weak_ptr<ProcessGDBRemote> this_wp =
3440  std::static_pointer_cast<ProcessGDBRemote>(shared_from_this());
3441  debugserver_launch_info.SetMonitorProcessCallback(
3442  std::bind(MonitorDebugserverProcess, this_wp, _1, _2, _3, _4), false);
3443  debugserver_launch_info.SetUserID(process_info.GetUserID());
3444 
3445 #if defined(__APPLE__)
3446  // On macOS 11, we need to support x86_64 applications translated to
3447  // arm64. We check whether a binary is translated and spawn the correct
3448  // debugserver accordingly.
3449  int mib[] = { CTL_KERN, KERN_PROC, KERN_PROC_PID,
3450  static_cast<int>(process_info.GetProcessID()) };
3451  struct kinfo_proc processInfo;
3452  size_t bufsize = sizeof(processInfo);
3453  if (sysctl(mib, (unsigned)(sizeof(mib)/sizeof(int)), &processInfo,
3454  &bufsize, NULL, 0) == 0 && bufsize > 0) {
3455  if (processInfo.kp_proc.p_flag & P_TRANSLATED) {
3456  FileSpec rosetta_debugserver("/Library/Apple/usr/libexec/oah/debugserver");
3457  debugserver_launch_info.SetExecutableFile(rosetta_debugserver, false);
3458  }
3459  }
3460 #endif
3461 
3462  int communication_fd = -1;
3463 #ifdef USE_SOCKETPAIR_FOR_LOCAL_CONNECTION
3464  // Use a socketpair on non-Windows systems for security and performance
3465  // reasons.
3466  int sockets[2]; /* the pair of socket descriptors */
3467  if (socketpair(AF_UNIX, SOCK_STREAM, 0, sockets) == -1) {
3468  error.SetErrorToErrno();
3469  return error;
3470  }
3471 
3472  int our_socket = sockets[0];
3473  int gdb_socket = sockets[1];
3474  auto cleanup_our = llvm::make_scope_exit([&]() { close(our_socket); });
3475  auto cleanup_gdb = llvm::make_scope_exit([&]() { close(gdb_socket); });
3476 
3477  // Don't let any child processes inherit our communication socket
3478  SetCloexecFlag(our_socket);
3479  communication_fd = gdb_socket;
3480 #endif
3481 
3483  nullptr, GetTarget().GetPlatform().get(), debugserver_launch_info,
3484  nullptr, nullptr, communication_fd);
3485 
3486  if (error.Success())
3487  m_debugserver_pid = debugserver_launch_info.GetProcessID();
3488  else
3490 
3492 #ifdef USE_SOCKETPAIR_FOR_LOCAL_CONNECTION
3493  // Our process spawned correctly, we can now set our connection to use
3494  // our end of the socket pair
3495  cleanup_our.release();
3497  std::make_unique<ConnectionFileDescriptor>(our_socket, true));
3498 #endif
3499  StartAsyncThread();
3500  }
3501 
3502  if (error.Fail()) {
3504 
3505  LLDB_LOGF(log, "failed to start debugserver process: %s",
3506  error.AsCString());
3507  return error;
3508  }
3509 
3510  if (m_gdb_comm.IsConnected()) {
3511  // Finish the connection process by doing the handshake without
3512  // connecting (send NULL URL)
3514  } else {
3515  error.SetErrorString("connection failed");
3516  }
3517  }
3518  return error;
3519 }
3520 
3522  std::weak_ptr<ProcessGDBRemote> process_wp, lldb::pid_t debugserver_pid,
3523  bool exited, // True if the process did exit
3524  int signo, // Zero for no signal
3525  int exit_status // Exit value of process if signal is zero
3526 ) {
3527  // "debugserver_pid" argument passed in is the process ID for debugserver
3528  // that we are tracking...
3530  const bool handled = true;
3531 
3532  LLDB_LOGF(log,
3533  "ProcessGDBRemote::%s(process_wp, pid=%" PRIu64
3534  ", signo=%i (0x%x), exit_status=%i)",
3535  __FUNCTION__, debugserver_pid, signo, signo, exit_status);
3536 
3537  std::shared_ptr<ProcessGDBRemote> process_sp = process_wp.lock();
3538  LLDB_LOGF(log, "ProcessGDBRemote::%s(process = %p)", __FUNCTION__,
3539  static_cast<void *>(process_sp.get()));
3540  if (!process_sp || process_sp->m_debugserver_pid != debugserver_pid)
3541  return handled;
3542 
3543  // Sleep for a half a second to make sure our inferior process has time to
3544  // set its exit status before we set it incorrectly when both the debugserver
3545  // and the inferior process shut down.
3546  std::this_thread::sleep_for(std::chrono::milliseconds(500));
3547 
3548  // If our process hasn't yet exited, debugserver might have died. If the
3549  // process did exit, then we are reaping it.
3550  const StateType state = process_sp->GetState();
3551 
3552  if (state != eStateInvalid && state != eStateUnloaded &&
3553  state != eStateExited && state != eStateDetached) {
3554  char error_str[1024];
3555  if (signo) {
3556  const char *signal_cstr =
3557  process_sp->GetUnixSignals()->GetSignalAsCString(signo);
3558  if (signal_cstr)
3559  ::snprintf(error_str, sizeof(error_str),
3560  DEBUGSERVER_BASENAME " died with signal %s", signal_cstr);
3561  else
3562  ::snprintf(error_str, sizeof(error_str),
3563  DEBUGSERVER_BASENAME " died with signal %i", signo);
3564  } else {
3565  ::snprintf(error_str, sizeof(error_str),
3566  DEBUGSERVER_BASENAME " died with an exit status of 0x%8.8x",
3567  exit_status);
3568  }
3569 
3570  process_sp->SetExitStatus(-1, error_str);
3571  }
3572  // Debugserver has exited we need to let our ProcessGDBRemote know that it no
3573  // longer has a debugserver instance
3574  process_sp->m_debugserver_pid = LLDB_INVALID_PROCESS_ID;
3575  return handled;
3576 }
3577 
3581  Host::Kill(m_debugserver_pid, SIGINT);
3583  }
3584 }
3585 
3587  static llvm::once_flag g_once_flag;
3588 
3589  llvm::call_once(g_once_flag, []() {
3593  });
3594 }
3595 
3598  debugger, PluginProperties::GetSettingName())) {
3599  const bool is_global_setting = true;
3601  debugger, GetGlobalPluginProperties()->GetValueProperties(),
3602  ConstString("Properties for the gdb-remote process plug-in."),
3603  is_global_setting);
3604  }
3605 }
3606 
3609 
3610  LLDB_LOGF(log, "ProcessGDBRemote::%s ()", __FUNCTION__);
3611 
3612  std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
3613  if (!m_async_thread.IsJoinable()) {
3614  // Create a thread that watches our internal state and controls which
3615  // events make it to clients (into the DCProcess event queue).
3616 
3617  llvm::Expected<HostThread> async_thread = ThreadLauncher::LaunchThread(
3618  "<lldb.process.gdb-remote.async>", ProcessGDBRemote::AsyncThread, this);
3619  if (!async_thread) {
3621  async_thread.takeError(),
3622  "failed to launch host thread: {}");
3623  return false;
3624  }
3625  m_async_thread = *async_thread;
3626  } else
3627  LLDB_LOGF(log,
3628  "ProcessGDBRemote::%s () - Called when Async thread was "
3629  "already running.",
3630  __FUNCTION__);
3631 
3632  return m_async_thread.IsJoinable();
3633 }
3634 
3637 
3638  LLDB_LOGF(log, "ProcessGDBRemote::%s ()", __FUNCTION__);
3639 
3640  std::lock_guard<std::recursive_mutex> guard(m_async_thread_state_mutex);
3641  if (m_async_thread.IsJoinable()) {
3643 
3644  // This will shut down the async thread.
3645  m_gdb_comm.Disconnect(); // Disconnect from the debug server.
3646 
3647  // Stop the stdio thread
3648  m_async_thread.Join(nullptr);
3650  } else
3651  LLDB_LOGF(
3652  log,
3653  "ProcessGDBRemote::%s () - Called when Async thread was not running.",
3654  __FUNCTION__);
3655 }
3656 
3658  // get the packet at a string
3659  const std::string &pkt = std::string(packet.GetStringRef());
3660  // skip %stop:
3661  StringExtractorGDBRemote stop_info(pkt.c_str() + 5);
3662 
3663  // pass as a thread stop info packet
3664  SetLastStopPacket(stop_info);
3665 
3666  // check for more stop reasons
3668 
3669  // if the process is stopped then we need to fake a resume so that we can
3670  // stop properly with the new break. This is possible due to
3671  // SetPrivateState() broadcasting the state change as a side effect.
3674  }
3675 
3676  // since we have some stopped packets we can halt the process
3678 
3679  return true;
3680 }
3681 
3683  ProcessGDBRemote *process = (ProcessGDBRemote *)arg;
3684 
3686  LLDB_LOGF(log,
3687  "ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64
3688  ") thread starting...",
3689  __FUNCTION__, arg, process->GetID());
3690 
3691  EventSP event_sp;
3692 
3693  // We need to ignore any packets that come in after we have
3694  // have decided the process has exited. There are some
3695  // situations, for instance when we try to interrupt a running
3696  // process and the interrupt fails, where another packet might
3697  // get delivered after we've decided to give up on the process.
3698  // But once we've decided we are done with the process we will
3699  // not be in a state to do anything useful with new packets.
3700  // So it is safer to simply ignore any remaining packets by
3701  // explicitly checking for eStateExited before reentering the
3702  // fetch loop.
3703 
3704  bool done = false;
3705  while (!done && process->GetPrivateState() != eStateExited) {
3706  LLDB_LOGF(log,
3707  "ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64
3708  ") listener.WaitForEvent (NULL, event_sp)...",
3709  __FUNCTION__, arg, process->GetID());
3710 
3711  if (process->m_async_listener_sp->GetEvent(event_sp, llvm::None)) {
3712  const uint32_t event_type = event_sp->GetType();
3713  if (event_sp->BroadcasterIs(&process->m_async_broadcaster)) {
3714  LLDB_LOGF(log,
3715  "ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64
3716  ") Got an event of type: %d...",
3717  __FUNCTION__, arg, process->GetID(), event_type);
3718 
3719  switch (event_type) {
3721  const EventDataBytes *continue_packet =
3722  EventDataBytes::GetEventDataFromEvent(event_sp.get());
3723 
3724  if (continue_packet) {
3725  const char *continue_cstr =
3726  (const char *)continue_packet->GetBytes();
3727  const size_t continue_cstr_len = continue_packet->GetByteSize();
3728  LLDB_LOGF(log,
3729  "ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64
3730  ") got eBroadcastBitAsyncContinue: %s",
3731  __FUNCTION__, arg, process->GetID(), continue_cstr);
3732 
3733  if (::strstr(continue_cstr, "vAttach") == nullptr)
3734  process->SetPrivateState(eStateRunning);
3735  StringExtractorGDBRemote response;
3736 
3737  // If in Non-Stop-Mode
3738  if (process->GetTarget().GetNonStopModeEnabled()) {
3739  // send the vCont packet
3740  if (!process->GetGDBRemote().SendvContPacket(
3741  llvm::StringRef(continue_cstr, continue_cstr_len),
3742  response)) {
3743  // Something went wrong
3744  done = true;
3745  break;
3746  }
3747  }
3748  // If in All-Stop-Mode
3749  else {
3750  StateType stop_state =
3752  *process, *process->GetUnixSignals(),
3753  llvm::StringRef(continue_cstr, continue_cstr_len),
3754  response);
3755 
3756  // We need to immediately clear the thread ID list so we are sure
3757  // to get a valid list of threads. The thread ID list might be
3758  // contained within the "response", or the stop reply packet that
3759  // caused the stop. So clear it now before we give the stop reply
3760  // packet to the process using the
3761  // process->SetLastStopPacket()...
3762  process->ClearThreadIDList();
3763 
3764  switch (stop_state) {
3765  case eStateStopped:
3766  case eStateCrashed:
3767  case eStateSuspended:
3768  process->SetLastStopPacket(response);
3769  process->SetPrivateState(stop_state);
3770  break;
3771 
3772  case eStateExited: {
3773  process->SetLastStopPacket(response);
3774  process->ClearThreadIDList();
3775  response.SetFilePos(1);
3776 
3777  int exit_status = response.GetHexU8();
3778  std::string desc_string;
3779  if (response.GetBytesLeft() > 0 &&
3780  response.GetChar('-') == ';') {
3781  llvm::StringRef desc_str;
3782  llvm::StringRef desc_token;
3783  while (response.GetNameColonValue(desc_token, desc_str)) {
3784  if (desc_token != "description")
3785  continue;
3786  StringExtractor extractor(desc_str);
3787  extractor.GetHexByteString(desc_string);
3788  }
3789  }
3790  process->SetExitStatus(exit_status, desc_string.c_str());
3791  done = true;
3792  break;
3793  }
3794  case eStateInvalid: {
3795  // Check to see if we were trying to attach and if we got back
3796  // the "E87" error code from debugserver -- this indicates that
3797  // the process is not debuggable. Return a slightly more
3798  // helpful error message about why the attach failed.
3799  if (::strstr(continue_cstr, "vAttach") != nullptr &&
3800  response.GetError() == 0x87) {
3801  process->SetExitStatus(-1, "cannot attach to process due to "
3802  "System Integrity Protection");
3803  } else if (::strstr(continue_cstr, "vAttach") != nullptr &&
3804  response.GetStatus().Fail()) {
3805  process->SetExitStatus(-1, response.GetStatus().AsCString());
3806  } else {
3807  process->SetExitStatus(-1, "lost connection");
3808  }
3809  done = true;
3810  break;
3811  }
3812 
3813  default:
3814  process->SetPrivateState(stop_state);
3815  break;
3816  } // switch(stop_state)
3817  } // else // if in All-stop-mode
3818  } // if (continue_packet)
3819  } // case eBroadcastBitAsyncContinue
3820  break;
3821 
3823  LLDB_LOGF(log,
3824  "ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64
3825  ") got eBroadcastBitAsyncThreadShouldExit...",
3826  __FUNCTION__, arg, process->GetID());
3827  done = true;
3828  break;
3829 
3830  default:
3831  LLDB_LOGF(log,
3832  "ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64
3833  ") got unknown event 0x%8.8x",
3834  __FUNCTION__, arg, process->GetID(), event_type);
3835  done = true;
3836  break;
3837  }
3838  } else if (event_sp->BroadcasterIs(&process->m_gdb_comm)) {
3839  switch (event_type) {
3840  case Communication::eBroadcastBitReadThreadDidExit:
3841  process->SetExitStatus(-1, "lost connection");
3842  done = true;
3843  break;
3844 
3846  lldb_private::Event *event = event_sp.get();
3847  const EventDataBytes *continue_packet =
3849  StringExtractorGDBRemote notify(
3850  (const char *)continue_packet->GetBytes());
3851  // Hand this over to the process to handle
3852  process->HandleNotifyPacket(notify);
3853  break;
3854  }
3855 
3856  default:
3857  LLDB_LOGF(log,
3858  "ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64
3859  ") got unknown event 0x%8.8x",
3860  __FUNCTION__, arg, process->GetID(), event_type);
3861  done = true;
3862  break;
3863  }
3864  }
3865  } else {
3866  LLDB_LOGF(log,
3867  "ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64
3868  ") listener.WaitForEvent (NULL, event_sp) => false",
3869  __FUNCTION__, arg, process->GetID());
3870  done = true;
3871  }
3872  }
3873 
3874  LLDB_LOGF(log,
3875  "ProcessGDBRemote::%s (arg = %p, pid = %" PRIu64
3876  ") thread exiting...",
3877  __FUNCTION__, arg, process->GetID());
3878 
3879  return {};
3880 }
3881 
3882 // uint32_t
3883 // ProcessGDBRemote::ListProcessesMatchingName (const char *name, StringList
3884 // &matches, std::vector<lldb::pid_t> &pids)
3885 //{
3886 // // If we are planning to launch the debugserver remotely, then we need to
3887 // fire up a debugserver
3888 // // process and ask it for the list of processes. But if we are local, we
3889 // can let the Host do it.
3890 // if (m_local_debugserver)
3891 // {
3892 // return Host::ListProcessesMatchingName (name, matches, pids);
3893 // }
3894 // else
3895 // {
3896 // // FIXME: Implement talking to the remote debugserver.
3897 // return 0;
3898 // }
3899 //
3900 //}
3901 //
3903  void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id,
3904  lldb::user_id_t break_loc_id) {
3905  // I don't think I have to do anything here, just make sure I notice the new
3906  // thread when it starts to
3907  // run so I can stop it if that's what I want to do.
3909  LLDB_LOGF(log, "Hit New Thread Notification breakpoint.");
3910  return false;
3911 }
3912 
3915  LLDB_LOG(log, "Check if need to update ignored signals");
3916 
3917  // QPassSignals package is not supported by the server, there is no way we
3918  // can ignore any signals on server side.
3920  return Status();
3921 
3922  // No signals, nothing to send.
3923  if (m_unix_signals_sp == nullptr)
3924  return Status();
3925 
3926  // Signals' version hasn't changed, no need to send anything.
3927  uint64_t new_signals_version = m_unix_signals_sp->GetVersion();
3928  if (new_signals_version == m_last_signals_version) {
3929  LLDB_LOG(log, "Signals' version hasn't changed. version={0}",
3931  return Status();
3932  }
3933 
3934  auto signals_to_ignore =
3935  m_unix_signals_sp->GetFilteredSignals(false, false, false);
3936  Status error = m_gdb_comm.SendSignalsToIgnore(signals_to_ignore);
3937 
3938  LLDB_LOG(log,
3939  "Signals' version changed. old version={0}, new version={1}, "
3940  "signals ignored={2}, update result={3}",
3941  m_last_signals_version, new_signals_version,
3942  signals_to_ignore.size(), error);
3943 
3944  if (error.Success())
3945  m_last_signals_version = new_signals_version;
3946 
3947  return error;
3948 }
3949 
3952  if (m_thread_create_bp_sp) {
3953  if (log && log->GetVerbose())
3954  LLDB_LOGF(log, "Enabled noticing new thread breakpoint.");
3955  m_thread_create_bp_sp->SetEnabled(true);
3956  } else {
3957  PlatformSP platform_sp(GetTarget().GetPlatform());
3958  if (platform_sp) {
3960  platform_sp->SetThreadCreationBreakpoint(GetTarget());
3961  if (m_thread_create_bp_sp) {
3962  if (log && log->GetVerbose())
3963  LLDB_LOGF(
3964  log, "Successfully created new thread notification breakpoint %i",
3965  m_thread_create_bp_sp->GetID());
3966  m_thread_create_bp_sp->SetCallback(
3968  } else {
3969  LLDB_LOGF(log, "Failed to create new thread notification breakpoint.");
3970  }
3971  }
3972  }
3973  return m_thread_create_bp_sp.get() != nullptr;
3974 }
3975 
3978  if (log && log->GetVerbose())
3979  LLDB_LOGF(log, "Disabling new thread notification breakpoint.");
3980 
3982  m_thread_create_bp_sp->SetEnabled(false);
3983 
3984  return true;
3985 }
3986 
3988  if (m_dyld_up.get() == nullptr)
3989  m_dyld_up.reset(DynamicLoader::FindPlugin(this, nullptr));
3990  return m_dyld_up.get();
3991 }
3992 
3994  int return_value;
3995  bool was_supported;
3996 
3997  Status error;
3998 
3999  return_value = m_gdb_comm.SendLaunchEventDataPacket(data, &was_supported);
4000  if (return_value != 0) {
4001  if (!was_supported)
4002  error.SetErrorString("Sending events is not supported for this process.");
4003  else
4004  error.SetErrorStringWithFormat("Error sending event data: %d.",
4005  return_value);
4006  }
4007  return error;
4008 }
4009 
4011  DataBufferSP buf;
4013  std::string response_string;
4014  if (m_gdb_comm.SendPacketsAndConcatenateResponses("qXfer:auxv:read::",
4015  response_string) ==
4017  buf = std::make_shared<DataBufferHeap>(response_string.c_str(),
4018  response_string.length());
4019  }
4020  return DataExtractor(buf, GetByteOrder(), GetAddressByteSize());
4021 }
4022 
4025  StructuredData::ObjectSP object_sp;
4026 
4029  SystemRuntime *runtime = GetSystemRuntime();
4030  if (runtime) {
4031  runtime->AddThreadExtendedInfoPacketHints(args_dict);
4032  }
4033  args_dict->GetAsDictionary()->AddIntegerItem("thread", tid);
4034 
4035  StreamString packet;
4036  packet << "jThreadExtendedInfo:";
4037  args_dict->Dump(packet, false);
4038 
4039  // FIXME the final character of a JSON dictionary, '}', is the escape
4040  // character in gdb-remote binary mode. lldb currently doesn't escape
4041  // these characters in its packet output -- so we add the quoted version of
4042  // the } character here manually in case we talk to a debugserver which un-
4043  // escapes the characters at packet read time.
4044  packet << (char)(0x7d ^ 0x20);
4045 
4046  StringExtractorGDBRemote response;
4047  response.SetResponseValidatorToJSON();
4048  if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response,
4049  false) ==
4052  response.GetResponseType();
4053  if (response_type == StringExtractorGDBRemote::eResponse) {
4054  if (!response.Empty()) {
4055  object_sp =
4057  }
4058  }
4059  }
4060  }
4061  return object_sp;
4062 }
4063 
4065  lldb::addr_t image_list_address, lldb::addr_t image_count) {
4066 
4068  args_dict->GetAsDictionary()->AddIntegerItem("image_list_address",
4069  image_list_address);
4070  args_dict->GetAsDictionary()->AddIntegerItem("image_count", image_count);
4071 
4072  return GetLoadedDynamicLibrariesInfos_sender(args_dict);
4073 }
4074 
4077 
4078  args_dict->GetAsDictionary()->AddBooleanItem("fetch_all_solibs", true);
4079 
4080  return GetLoadedDynamicLibrariesInfos_sender(args_dict);
4081 }
4082 
4084  const std::vector<lldb::addr_t> &load_addresses) {
4087 
4088  for (auto addr : load_addresses) {
4090  addresses->AddItem(addr_sp);
4091  }
4092 
4093  args_dict->GetAsDictionary()->AddItem("solib_addresses", addresses);
4094 
4095  return GetLoadedDynamicLibrariesInfos_sender(args_dict);
4096 }
4097 
4100  StructuredData::ObjectSP args_dict) {
4101  StructuredData::ObjectSP object_sp;
4102 
4104  // Scope for the scoped timeout object
4106  std::chrono::seconds(10));
4107 
4108  StreamString packet;
4109  packet << "jGetLoadedDynamicLibrariesInfos:";
4110  args_dict->Dump(packet, false);
4111 
4112  // FIXME the final character of a JSON dictionary, '}', is the escape
4113  // character in gdb-remote binary mode. lldb currently doesn't escape
4114  // these characters in its packet output -- so we add the quoted version of
4115  // the } character here manually in case we talk to a debugserver which un-
4116  // escapes the characters at packet read time.
4117  packet << (char)(0x7d ^ 0x20);
4118 
4119  StringExtractorGDBRemote response;
4120  response.SetResponseValidatorToJSON();
4121  if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response,
4122  false) ==
4125  response.GetResponseType();
4126  if (response_type == StringExtractorGDBRemote::eResponse) {
4127  if (!response.Empty()) {
4128  object_sp =
4130  }
4131  }
4132  }
4133  }
4134  return object_sp;
4135 }
4136 
4138  StructuredData::ObjectSP object_sp;
4140 
4142  StreamString packet;
4143  packet << "jGetSharedCacheInfo:";
4144  args_dict->Dump(packet, false);
4145 
4146  // FIXME the final character of a JSON dictionary, '}', is the escape
4147  // character in gdb-remote binary mode. lldb currently doesn't escape
4148  // these characters in its packet output -- so we add the quoted version of
4149  // the } character here manually in case we talk to a debugserver which un-
4150  // escapes the characters at packet read time.
4151  packet << (char)(0x7d ^ 0x20);
4152 
4153  StringExtractorGDBRemote response;
4154  response.SetResponseValidatorToJSON();
4155  if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response,
4156  false) ==
4159  response.GetResponseType();
4160  if (response_type == StringExtractorGDBRemote::eResponse) {
4161  if (!response.Empty()) {
4162  object_sp =
4164  }
4165  }
4166  }
4167  }
4168  return object_sp;
4169 }
4170 
4172  ConstString type_name, const StructuredData::ObjectSP &config_sp) {
4173  return m_gdb_comm.ConfigureRemoteStructuredData(type_name, config_sp);
4174 }
4175 
4176 // Establish the largest memory read/write payloads we should use. If the
4177 // remote stub has a max packet size, stay under that size.
4178 //
4179 // If the remote stub's max packet size is crazy large, use a reasonable
4180 // largeish default.
4181 //
4182 // If the remote stub doesn't advertise a max packet size, use a conservative
4183 // default.
4184 
4186  const uint64_t reasonable_largeish_default = 128 * 1024;
4187  const uint64_t conservative_default = 512;
4188 
4189  if (m_max_memory_size == 0) {
4190  uint64_t stub_max_size = m_gdb_comm.GetRemoteMaxPacketSize();
4191  if (stub_max_size != UINT64_MAX && stub_max_size != 0) {
4192  // Save the stub's claimed maximum packet size
4193  m_remote_stub_max_memory_size = stub_max_size;
4194 
4195  // Even if the stub says it can support ginormous packets, don't exceed
4196  // our reasonable largeish default packet size.
4197  if (stub_max_size > reasonable_largeish_default) {
4198  stub_max_size = reasonable_largeish_default;
4199  }
4200 
4201  // Memory packet have other overheads too like Maddr,size:#NN Instead of
4202  // calculating the bytes taken by size and addr every time, we take a
4203  // maximum guess here.
4204  if (stub_max_size > 70)
4205  stub_max_size -= 32 + 32 + 6;
4206  else {
4207  // In unlikely scenario that max packet size is less then 70, we will
4208  // hope that data being written is small enough to fit.
4211  if (log)
4212  log->Warning("Packet size is too small. "
4213  "LLDB may face problems while writing memory");
4214  }
4215 
4216  m_max_memory_size = stub_max_size;
4217  } else {
4218  m_max_memory_size = conservative_default;
4219  }
4220  }
4221 }
4222 
4224  uint64_t user_specified_max) {
4225  if (user_specified_max != 0) {
4226  GetMaxMemorySize();
4227 
4228  if (m_remote_stub_max_memory_size != 0) {
4229  if (m_remote_stub_max_memory_size < user_specified_max) {
4230  m_max_memory_size = m_remote_stub_max_memory_size; // user specified a
4231  // packet size too
4232  // big, go as big
4233  // as the remote stub says we can go.
4234  } else {
4235  m_max_memory_size = user_specified_max; // user's packet size is good
4236  }
4237  } else {
4239  user_specified_max; // user's packet size is probably fine
4240  }
4241  }
4242 }
4243 
4244 bool ProcessGDBRemote::GetModuleSpec(const FileSpec &module_file_spec,
4245  const ArchSpec &arch,
4246  ModuleSpec &module_spec) {
4248 
4249  const ModuleCacheKey key(module_file_spec.GetPath(),
4250  arch.GetTriple().getTriple());
4251  auto cached = m_cached_module_specs.find(key);
4252  if (cached != m_cached_module_specs.end()) {
4253  module_spec = cached->second;
4254  return bool(module_spec);
4255  }
4256 
4257  if (!m_gdb_comm.GetModuleInfo(module_file_spec, arch, module_spec)) {
4258  LLDB_LOGF(log, "ProcessGDBRemote::%s - failed to get module info for %s:%s",
4259  __FUNCTION__, module_file_spec.GetPath().c_str(),
4260  arch.GetTriple().getTriple().c_str());
4261  return false;
4262  }
4263 
4264  if (log) {
4265  StreamString stream;
4266  module_spec.Dump(stream);
4267  LLDB_LOGF(log, "ProcessGDBRemote::%s - got module info for (%s:%s) : %s",
4268  __FUNCTION__, module_file_spec.GetPath().c_str(),
4269  arch.GetTriple().getTriple().c_str(), stream.GetData());
4270  }
4271 
4272  m_cached_module_specs[key] = module_spec;
4273  return true;
4274 }
4275 
4277  llvm::ArrayRef<FileSpec> module_file_specs, const llvm::Triple &triple) {
4278  auto module_specs = m_gdb_comm.GetModulesInfo(module_file_specs, triple);
4279  if (module_specs) {
4280  for (const FileSpec &spec : module_file_specs)
4281  m_cached_module_specs[ModuleCacheKey(spec.GetPath(),
4282  triple.getTriple())] = ModuleSpec();
4283  for (const ModuleSpec &spec : *module_specs)
4284  m_cached_module_specs[ModuleCacheKey(spec.GetFileSpec().GetPath(),
4285  triple.getTriple())] = spec;
4286  }
4287 }
4288 
4290  return m_gdb_comm.GetOSVersion();
4291 }
4292 
4295 }
4296 
4297 namespace {
4298 
4299 typedef std::vector<std::string> stringVec;
4300 
4301 typedef std::vector<struct GdbServerRegisterInfo> GDBServerRegisterVec;
4302 struct RegisterSetInfo {
4303  ConstString name;
4304 };
4305 
4306 typedef std::map<uint32_t, RegisterSetInfo> RegisterSetMap;
4307 
4308 struct GdbServerTargetInfo {
4309  std::string arch;
4310  std::string osabi;
4311  stringVec includes;
4312  RegisterSetMap reg_set_map;
4313 };
4314 
4315 bool ParseRegisters(XMLNode feature_node, GdbServerTargetInfo &target_info,
4316  GDBRemoteDynamicRegisterInfo &dyn_reg_info, ABISP abi_sp,
4317  uint32_t &reg_num_remote, uint32_t &reg_num_local) {
4318  if (!feature_node)
4319  return false;
4320 
4321  uint32_t reg_offset = LLDB_INVALID_INDEX32;
4322  feature_node.ForEachChildElementWithName(
4323  "reg", [&target_info, &dyn_reg_info, &reg_num_remote, &reg_num_local,
4324  &reg_offset, &abi_sp](const XMLNode &reg_node) -> bool {
4325  std::string gdb_group;
4326  std::string gdb_type;
4327  ConstString reg_name;
4328  ConstString alt_name;
4329  ConstString set_name;
4330  std::vector<uint32_t> value_regs;
4331  std::vector<uint32_t> invalidate_regs;
4332  std::vector<uint8_t> dwarf_opcode_bytes;
4333  bool encoding_set = false;
4334  bool format_set = false;
4335  RegisterInfo reg_info = {
4336  nullptr, // Name
4337  nullptr, // Alt name
4338  0, // byte size
4339  reg_offset, // offset
4340  eEncodingUint, // encoding
4341  eFormatHex, // format
4342  {
4343  LLDB_INVALID_REGNUM, // eh_frame reg num
4344  LLDB_INVALID_REGNUM, // DWARF reg num
4345  LLDB_INVALID_REGNUM, // generic reg num
4346  reg_num_remote, // process plugin reg num
4347  reg_num_local // native register number
4348  },
4349  nullptr,
4350  nullptr,
4351  nullptr, // Dwarf Expression opcode bytes pointer
4352  0 // Dwarf Expression opcode bytes length
4353  };
4354 
4355  reg_node.ForEachAttribute([&target_info, &gdb_group, &gdb_type,
4356  &reg_name, &alt_name, &set_name, &value_regs,
4357  &invalidate_regs, &encoding_set, &format_set,
4358  &reg_info, &reg_offset, &dwarf_opcode_bytes](
4359  const llvm::StringRef &name,
4360  const llvm::StringRef &value) -> bool {
4361  if (name == "name") {
4362  reg_name.SetString(value);
4363  } else if (name == "bitsize") {
4364  reg_info.byte_size =
4365  StringConvert::ToUInt32(value.data(), 0, 0) / CHAR_BIT;
4366  } else if (name == "type") {
4367  gdb_type = value.str();
4368  } else if (name == "group") {
4369  gdb_group = value.str();
4370  } else if (name == "regnum") {
4371  const uint32_t regnum =
4372  StringConvert::ToUInt32(value.data(), LLDB_INVALID_REGNUM, 0);
4373  if (regnum != LLDB_INVALID_REGNUM) {
4374  reg_info.kinds[eRegisterKindProcessPlugin] = regnum;
4375  }
4376  } else if (name == "offset") {
4377  reg_offset = StringConvert::ToUInt32(value.data(), UINT32_MAX, 0);
4378  } else if (name == "altname") {
4379  alt_name.SetString(value);
4380  } else if (name == "encoding") {
4381  encoding_set = true;
4382  reg_info.encoding = Args::StringToEncoding(value, eEncodingUint);
4383  } else if (name == "format") {
4384  format_set = true;
4385  Format format = eFormatInvalid;
4386  if (OptionArgParser::ToFormat(value.data(), format, nullptr)
4387  .Success())
4388  reg_info.format = format;
4389  else if (value == "vector-sint8")
4390  reg_info.format = eFormatVectorOfSInt8;
4391  else if (value == "vector-uint8")
4392  reg_info.format = eFormatVectorOfUInt8;
4393  else if (value == "vector-sint16")
4394  reg_info.format = eFormatVectorOfSInt16;
4395  else if (value == "vector-uint16")
4396  reg_info.format = eFormatVectorOfUInt16;
4397  else if (value == "vector-sint32")
4398  reg_info.format = eFormatVectorOfSInt32;
4399  else if (value == "vector-uint32")
4400  reg_info.format = eFormatVectorOfUInt32;
4401  else if (value == "vector-float32")
4402  reg_info.format = eFormatVectorOfFloat32;
4403  else if (value == "vector-uint64")
4404  reg_info.format = eFormatVectorOfUInt64;
4405  else if (value == "vector-uint128")
4406  reg_info.format = eFormatVectorOfUInt128;
4407  } else if (name == "group_id") {
4408  const uint32_t set_id =
4409  StringConvert::ToUInt32(value.data(), UINT32_MAX, 0);
4410  RegisterSetMap::const_iterator pos =
4411  target_info.reg_set_map.find(set_id);
4412  if (pos != target_info.reg_set_map.end())
4413  set_name = pos->second.name;
4414  } else if (name == "gcc_regnum" || name == "ehframe_regnum") {
4415  reg_info.kinds[eRegisterKindEHFrame] =
4416  StringConvert::ToUInt32(value.data(), LLDB_INVALID_REGNUM, 0);
4417  } else if (name == "dwarf_regnum") {
4418  reg_info.kinds[eRegisterKindDWARF] =
4419  StringConvert::ToUInt32(value.data(), LLDB_INVALID_REGNUM, 0);
4420  } else if (name == "generic") {
4421  reg_info.kinds[eRegisterKindGeneric] =
4423  } else if (name == "value_regnums") {
4424  SplitCommaSeparatedRegisterNumberString(value, value_regs, 0);
4425  } else if (name == "invalidate_regnums") {
4426  SplitCommaSeparatedRegisterNumberString(value, invalidate_regs, 0);
4427  } else if (name == "dynamic_size_dwarf_expr_bytes") {
4428  std::string opcode_string = value.str();
4429  size_t dwarf_opcode_len = opcode_string.length() / 2;
4430  assert(dwarf_opcode_len > 0);
4431 
4432  dwarf_opcode_bytes.resize(dwarf_opcode_len);
4433  reg_info.dynamic_size_dwarf_len = dwarf_opcode_len;
4434  StringExtractor opcode_extractor(opcode_string);
4435  uint32_t ret_val =
4436  opcode_extractor.GetHexBytesAvail(dwarf_opcode_bytes);
4437  assert(dwarf_opcode_len == ret_val);
4438  UNUSED_IF_ASSERT_DISABLED(ret_val);
4439  reg_info.dynamic_size_dwarf_expr_bytes = dwarf_opcode_bytes.data();
4440  } else {
4441  printf("unhandled attribute %s = %s\n", name.data(), value.data());
4442  }
4443  return true; // Keep iterating through all attributes
4444  });
4445 
4446  if (!gdb_type.empty() && !(encoding_set || format_set)) {
4447  if (llvm::StringRef(gdb_type).startswith("int")) {
4448  reg_info.format = eFormatHex;
4449  reg_info.encoding = eEncodingUint;
4450  } else if (gdb_type == "data_ptr" || gdb_type == "code_ptr") {
4451  reg_info.format = eFormatAddressInfo;
4452  reg_info.encoding = eEncodingUint;
4453  } else if (gdb_type == "i387_ext" || gdb_type == "float") {
4454  reg_info.format = eFormatFloat;
4455  reg_info.encoding = eEncodingIEEE754;
4456  }
4457  }
4458 
4459  // Only update the register set name if we didn't get a "reg_set"
4460  // attribute. "set_name" will be empty if we didn't have a "reg_set"
4461  // attribute.
4462  if (!set_name) {
4463  if (!gdb_group.empty()) {
4464  set_name.SetCString(gdb_group.c_str());
4465  } else {
4466  // If no register group name provided anywhere,
4467  // we'll create a 'general' register set
4468  set_name.SetCString("general");
4469  }
4470  }
4471 
4472  reg_info.byte_offset = reg_offset;
4473  assert(reg_info.byte_size != 0);
4474  reg_offset = LLDB_INVALID_INDEX32;
4475  if (!value_regs.empty()) {
4476  value_regs.push_back(LLDB_INVALID_REGNUM);
4477  reg_info.value_regs = value_regs.data();
4478  }
4479  if (!invalidate_regs.empty()) {
4480  invalidate_regs.push_back(LLDB_INVALID_REGNUM);
4481  reg_info.invalidate_regs = invalidate_regs.data();
4482  }
4483 
4484  reg_num_remote = reg_info.kinds[eRegisterKindProcessPlugin] + 1;
4485  ++reg_num_local;
4486  reg_info.name = reg_name.AsCString();
4487  if (abi_sp)
4488  abi_sp->AugmentRegisterInfo(reg_info);
4489  dyn_reg_info.AddRegister(reg_info, reg_name, alt_name, set_name);
4490 
4491  return true; // Keep iterating through all "reg" elements
4492  });
4493  return true;
4494 }
4495 
4496 } // namespace
4497 
4498 // This method fetches a register description feature xml file from
4499 // the remote stub and adds registers/register groupsets/architecture
4500 // information to the current process. It will call itself recursively
4501 // for nested register definition files. It returns true if it was able
4502 // to fetch and parse an xml file.
4504  ArchSpec &arch_to_use, std::string xml_filename, uint32_t &reg_num_remote,
4505  uint32_t &reg_num_local) {
4506  // request the target xml file
4507  std::string raw;
4508  lldb_private::Status lldberr;
4509  if (!m_gdb_comm.ReadExtFeature(ConstString("features"),
4510  ConstString(xml_filename.c_str()), raw,
4511  lldberr)) {
4512  return false;
4513  }
4514 
4515  XMLDocument xml_document;
4516 
4517  if (xml_document.ParseMemory(raw.c_str(), raw.size(), xml_filename.c_str())) {
4518  GdbServerTargetInfo target_info;
4519  std::vector<XMLNode> feature_nodes;
4520 
4521  // The top level feature XML file will start with a <target> tag.
4522  XMLNode target_node = xml_document.GetRootElement("target");
4523  if (target_node) {
4524  target_node.ForEachChildElement([&target_info, &feature_nodes](
4525  const XMLNode &node) -> bool {
4526  llvm::StringRef name = node.GetName();
4527  if (name == "architecture") {
4528  node.GetElementText(target_info.arch);
4529  } else if (name == "osabi") {
4530  node.GetElementText(target_info.osabi);
4531  } else if (name == "xi:include" || name == "include") {
4532  llvm::StringRef href = node.GetAttributeValue("href");
4533  if (!href.empty())
4534  target_info.includes.push_back(href.str());
4535  } else if (name == "feature") {
4536  feature_nodes.push_back(node);
4537  } else if (name == "groups") {
4539  "group", [&target_info](const XMLNode &node) -> bool {
4540  uint32_t set_id = UINT32_MAX;
4541  RegisterSetInfo set_info;
4542 
4543  node.ForEachAttribute(
4544  [&set_id, &set_info](const llvm::StringRef &name,
4545  const llvm::StringRef &value) -> bool {
4546  if (name == "id")
4547  set_id = StringConvert::ToUInt32(value.data(),
4548  UINT32_MAX, 0);
4549  if (name == "name")
4550  set_info.name = ConstString(value);
4551  return true; // Keep iterating through all attributes
4552  });
4553 
4554  if (set_id != UINT32_MAX)
4555  target_info.reg_set_map[set_id] = set_info;
4556  return true; // Keep iterating through all "group" elements
4557  });
4558  }
4559  return true; // Keep iterating through all children of the target_node
4560  });
4561  } else {
4562  // In an included XML feature file, we're already "inside" the <target>
4563  // tag of the initial XML file; this included file will likely only have
4564  // a <feature> tag. Need to check for any more included files in this
4565  // <feature> element.
4566  XMLNode feature_node = xml_document.GetRootElement("feature");
4567  if (feature_node) {
4568  feature_nodes.push_back(feature_node);
4569  feature_node.ForEachChildElement([&target_info](
4570  const XMLNode &node) -> bool {
4571  llvm::StringRef name = node.GetName();
4572  if (name == "xi:include" || name == "include") {
4573  llvm::StringRef href = node.GetAttributeValue("href");
4574  if (!href.empty())
4575  target_info.includes.push_back(href.str());
4576  }
4577  return true;
4578  });
4579  }
4580  }
4581 
4582  // If the target.xml includes an architecture entry like
4583  // <architecture>i386:x86-64</architecture> (seen from VMWare ESXi)
4584  // <architecture>arm</architecture> (seen from Segger JLink on unspecified arm board)
4585  // use that if we don't have anything better.
4586  if (!arch_to_use.IsValid() && !target_info.arch.empty()) {
4587  if (target_info.arch == "i386:x86-64") {
4588  // We don't have any information about vendor or OS.
4589  arch_to_use.SetTriple("x86_64--");
4590  GetTarget().MergeArchitecture(arch_to_use);
4591  }
4592 
4593  // SEGGER J-Link jtag boards send this very-generic arch name,
4594  // we'll need to use this if we have absolutely nothing better
4595  // to work with or the register definitions won't be accepted.
4596  if (target_info.arch == "arm") {
4597  arch_to_use.SetTriple("arm--");
4598  GetTarget().MergeArchitecture(arch_to_use);
4599  }
4600  }
4601 
4602  if (arch_to_use.IsValid()) {
4603  // Don't use Process::GetABI, this code gets called from DidAttach, and
4604  // in that context we haven't set the Target's architecture yet, so the
4605  // ABI is also potentially incorrect.
4606  ABISP abi_to_use_sp = ABI::FindPlugin(shared_from_this(), arch_to_use);
4607  for (auto &feature_node : feature_nodes) {
4608  ParseRegisters(feature_node, target_info, *this->m_register_info_sp,
4609  abi_to_use_sp, reg_num_remote, reg_num_local);
4610  }
4611 
4612  for (const auto &include : target_info.includes) {
4613  GetGDBServerRegisterInfoXMLAndProcess(arch_to_use, include,
4614  reg_num_remote, reg_num_local);
4615  }
4616  }
4617  } else {
4618  return false;
4619  }
4620  return true;
4621 }
4622 
4623 // query the target of gdb-remote for extended target information returns
4624 // true on success (got register definitions), false on failure (did not).
4626  // Make sure LLDB has an XML parser it can use first
4627  if (!XMLDocument::XMLEnabled())
4628  return false;
4629 
4630  // check that we have extended feature read support
4632  return false;
4633 
4634  uint32_t reg_num_remote = 0;
4635  uint32_t reg_num_local = 0;
4636  if (GetGDBServerRegisterInfoXMLAndProcess(arch_to_use, "target.xml",
4637  reg_num_remote, reg_num_local))
4638  this->m_register_info_sp->Finalize(arch_to_use);
4639 
4640  return m_register_info_sp->GetNumRegisters() > 0;
4641 }
4642 
4643 llvm::Expected<LoadedModuleInfoList> ProcessGDBRemote::GetLoadedModuleList() {
4644  // Make sure LLDB has an XML parser it can use first
4645  if (!XMLDocument::XMLEnabled())
4646  return llvm::createStringError(llvm::inconvertibleErrorCode(),
4647  "XML parsing not available");
4648 
4650  LLDB_LOGF(log, "ProcessGDBRemote::%s", __FUNCTION__);
4651 
4652  LoadedModuleInfoList list;
4654  bool can_use_svr4 = GetGlobalPluginProperties()->GetUseSVR4();
4655 
4656  // check that we have extended feature read support
4657  if (can_use_svr4 && comm.GetQXferLibrariesSVR4ReadSupported()) {
4658  // request the loaded library list
4659  std::string raw;
4660  lldb_private::Status lldberr;
4661 
4662  if (!comm.ReadExtFeature(ConstString("libraries-svr4"), ConstString(""),
4663  raw, lldberr))
4664  return llvm::createStringError(llvm::inconvertibleErrorCode(),
4665  "Error in libraries-svr4 packet");
4666 
4667  // parse the xml file in memory
4668  LLDB_LOGF(log, "parsing: %s", raw.c_str());
4669  XMLDocument doc;
4670 
4671  if (!doc.ParseMemory(raw.c_str(), raw.size(), "noname.xml"))
4672  return llvm::createStringError(llvm::inconvertibleErrorCode(),
4673  "Error reading noname.xml");
4674 
4675  XMLNode root_element = doc.GetRootElement("library-list-svr4");
4676  if (!root_element)
4677  return llvm::createStringError(
4678  llvm::inconvertibleErrorCode(),
4679  "Error finding library-list-svr4 xml element");
4680 
4681  // main link map structure
4682  llvm::StringRef main_lm = root_element.GetAttributeValue("main-lm");
4683  if (!main_lm.empty()) {
4684  list.m_link_map =
4685  StringConvert::ToUInt64(main_lm.data(), LLDB_INVALID_ADDRESS, 0);
4686  }
4687 
4688  root_element.ForEachChildElementWithName(
4689  "library", [log, &list](const XMLNode &library) -> bool {
4690 
4692 
4693  library.ForEachAttribute(
4694  [&module](const llvm::StringRef &name,
4695  const llvm::StringRef &value) -> bool {
4696 
4697  if (name == "name")
4698  module.set_name(value.str());
4699  else if (name == "lm") {
4700  // the address of the link_map struct.
4702  value.data(), LLDB_INVALID_ADDRESS, 0));
4703  } else if (name == "l_addr") {
4704  // the displacement as read from the field 'l_addr' of the
4705  // link_map struct.
4707  value.data(), LLDB_INVALID_ADDRESS, 0));
4708  // base address is always a displacement, not an absolute
4709  // value.
4710  module.set_base_is_offset(true);
4711  } else if (name == "l_ld") {
4712  // the memory address of the libraries PT_DYNAMIC section.
4714  value.data(), LLDB_INVALID_ADDRESS, 0));
4715  }
4716 
4717  return true; // Keep iterating over all properties of "library"
4718  });
4719 
4720  if (log) {
4721  std::string name;
4722  lldb::addr_t lm = 0, base = 0, ld = 0;
4723  bool base_is_offset;
4724 
4725  module.get_name(name);
4726  module.get_link_map(lm);
4727  module.get_base(base);
4728  module.get_base_is_offset(base_is_offset);
4729  module.get_dynamic(ld);
4730 
4731  LLDB_LOGF(log,
4732  "found (link_map:0x%08" PRIx64 ", base:0x%08" PRIx64
4733  "[%s], ld:0x%08" PRIx64 ", name:'%s')",
4734  lm, base, (base_is_offset ? "offset" : "absolute"), ld,
4735  name.c_str());
4736  }
4737 
4738  list.add(module);
4739  return true; // Keep iterating over all "library" elements in the root
4740  // node
4741  });
4742 
4743  if (log)
4744  LLDB_LOGF(log, "found %" PRId32 " modules in total",
4745  (int)list.m_list.size());
4746  return list;
4747  } else if (comm.GetQXferLibrariesReadSupported()) {
4748  // request the loaded library list
4749  std::string raw;
4750  lldb_private::Status lldberr;
4751 
4752  if (!comm.ReadExtFeature(ConstString("libraries"), ConstString(""), raw,
4753  lldberr))
4754  return llvm::createStringError(llvm::inconvertibleErrorCode(),
4755  "Error in libraries packet");
4756 
4757  LLDB_LOGF(log, "parsing: %s", raw.c_str());
4758  XMLDocument doc;
4759 
4760  if (!doc.ParseMemory(raw.c_str(), raw.size(), "noname.xml"))
4761  return llvm::createStringError(llvm::inconvertibleErrorCode(),
4762  "Error reading noname.xml");
4763 
4764  XMLNode root_element = doc.GetRootElement("library-list");
4765  if (!root_element)
4766  return llvm::createStringError(llvm::inconvertibleErrorCode(),
4767  "Error finding library-list xml element");
4768 
4769  root_element.ForEachChildElementWithName(
4770  "library", [log, &list](const XMLNode &library) -> bool {
4772 
4773  llvm::StringRef name = library.GetAttributeValue("name");
4774  module.set_name(name.str());
4775 
4776  // The base address of a given library will be the address of its
4777  // first section. Most remotes send only one section for Windows
4778  // targets for example.
4779  const XMLNode &section =
4780  library.FindFirstChildElementWithName("section");
4781  llvm::StringRef address = section.GetAttributeValue("address");
4782  module.set_base(
4783  StringConvert::ToUInt64(address.data(), LLDB_INVALID_ADDRESS, 0));
4784  // These addresses are absolute values.
4785  module.set_base_is_offset(false);
4786 
4787  if (log) {
4788  std::string name;
4789  lldb::addr_t base = 0;
4790  bool base_is_offset;
4791  module.get_name(name);
4792  module.get_base(base);
4793  module.get_base_is_offset(base_is_offset);
4794 
4795  LLDB_LOGF(log, "found (base:0x%08" PRIx64 "[%s], name:'%s')", base,
4796  (base_is_offset ? "offset" : "absolute"), name.c_str());
4797  }
4798 
4799  list.add(module);
4800  return true; // Keep iterating over all "library" elements in the root
4801  // node
4802  });
4803 
4804  if (log)
4805  LLDB_LOGF(log, "found %" PRId32 " modules in total",
4806  (int)list.m_list.size());
4807  return list;
4808  } else {
4809  return llvm::createStringError(llvm::inconvertibleErrorCode(),
4810  "Remote libraries not supported");
4811  }
4812 }
4813 
4815  lldb::addr_t link_map,
4816  lldb::addr_t base_addr,
4817  bool value_is_offset) {
4818  DynamicLoader *loader = GetDynamicLoader();
4819  if (!loader)
4820  return nullptr;
4821 
4822  return loader->LoadModuleAtAddress(file, link_map, base_addr,
4823  value_is_offset);
4824 }
4825 
4828 
4829  // request a list of loaded libraries from GDBServer
4830  llvm::Expected<LoadedModuleInfoList> module_list = GetLoadedModuleList();
4831  if (!module_list)
4832  return module_list.takeError();
4833 
4834  // get a list of all the modules
4835  ModuleList new_modules;
4836 
4837  for (LoadedModuleInfoList::LoadedModuleInfo &modInfo : module_list->m_list) {
4838  std::string mod_name;
4839  lldb::addr_t mod_base;
4840  lldb::addr_t link_map;
4841  bool mod_base_is_offset;
4842 
4843  bool valid = true;
4844  valid &= modInfo.get_name(mod_name);
4845  valid &= modInfo.get_base(mod_base);
4846  valid &= modInfo.get_base_is_offset(mod_base_is_offset);
4847  if (!valid)
4848  continue;
4849 
4850  if (!modInfo.get_link_map(link_map))
4851  link_map = LLDB_INVALID_ADDRESS;
4852 
4853  FileSpec file(mod_name);
4854  FileSystem::Instance().Resolve(file);
4855  lldb::ModuleSP module_sp =
4856  LoadModuleAtAddress(file, link_map, mod_base, mod_base_is_offset);
4857 
4858  if (module_sp.get())
4859  new_modules.Append(module_sp);
4860  }
4861 
4862  if (new_modules.GetSize() > 0) {
4863  ModuleList removed_modules;
4864  Target &target = GetTarget();
4865  ModuleList &loaded_modules = m_process->GetTarget().GetImages();
4866 
4867  for (size_t i = 0; i < loaded_modules.GetSize(); ++i) {
4868  const lldb::ModuleSP loaded_module = loaded_modules.GetModuleAtIndex(i);
4869 
4870  bool found = false;
4871  for (size_t j = 0; j < new_modules.GetSize(); ++j) {
4872  if (new_modules.GetModuleAtIndex(j).get() == loaded_module.get())
4873  found = true;
4874  }
4875 
4876  // The main executable will never be included in libraries-svr4, don't
4877  // remove it
4878  if (!found &&
4879  loaded_module.get() != target.GetExecutableModulePointer()) {
4880  removed_modules.Append(loaded_module);
4881  }
4882  }
4883 
4884  loaded_modules.Remove(removed_modules);
4885  m_process->GetTarget().ModulesDidUnload(removed_modules, false);
4886 
4887  new_modules.ForEach([&target](const lldb::ModuleSP module_sp) -> bool {
4888  lldb_private::ObjectFile *obj = module_sp->GetObjectFile();
4889  if (!obj)
4890  return true;
4891 
4892  if (obj->GetType() != ObjectFile::Type::eTypeExecutable)
4893  return true;
4894 
4895  lldb::ModuleSP module_copy_sp = module_sp;
4896  target.SetExecutableModule(module_copy_sp, eLoadDependentsNo);
4897  return false;
4898  });
4899 
4900  loaded_modules.AppendIfNeeded(new_modules);
4901  m_process->GetTarget().ModulesDidLoad(new_modules);
4902  }
4903 
4904  return llvm::ErrorSuccess();
4905 }
4906 
4908  bool &is_loaded,
4909  lldb::addr_t &load_addr) {
4910  is_loaded = false;
4911  load_addr = LLDB_INVALID_ADDRESS;
4912 
4913  std::string file_path = file.GetPath(false);
4914  if (file_path.empty())
4915  return Status("Empty file name specified");
4916 
4917  StreamString packet;
4918  packet.PutCString("qFileLoadAddress:");
4919  packet.PutStringAsRawHex8(file_path);
4920 
4921  StringExtractorGDBRemote response;
4922  if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetString(), response,
4923  false) !=
4925  return Status("Sending qFileLoadAddress packet failed");
4926 
4927  if (response.IsErrorResponse()) {
4928  if (response.GetError() == 1) {
4929  // The file is not loaded into the inferior
4930  is_loaded = false;
4931  load_addr = LLDB_INVALID_ADDRESS;
4932  return Status();
4933  }
4934 
4935  return Status(
4936  "Fetching file load address from remote server returned an error");
4937  }
4938 
4939  if (response.IsNormalResponse()) {
4940  is_loaded = true;
4941  load_addr = response.GetHexMaxU64(false, LLDB_INVALID_ADDRESS);
4942  return Status();
4943  }
4944 
4945  return Status(
4946  "Unknown error happened during sending the load address packet");
4947 }
4948 
4950  // We must call the lldb_private::Process::ModulesDidLoad () first before we
4951  // do anything
4952  Process::ModulesDidLoad(module_list);
4953 
4954  // After loading shared libraries, we can ask our remote GDB server if it
4955  // needs any symbols.
4957 }
4958 
4959 void ProcessGDBRemote::HandleAsyncStdout(llvm::StringRef out) {
4960  AppendSTDOUT(out.data(), out.size());
4961 }
4962 
4963 static const char *end_delimiter = "--end--;";
4964 static const int end_delimiter_len = 8;
4965 
4966 void ProcessGDBRemote::HandleAsyncMisc(llvm::StringRef data) {
4967  std::string input = data.str(); // '1' to move beyond 'A'
4968  if (m_partial_profile_data.length() > 0) {
4969  m_partial_profile_data.append(input);
4970  input = m_partial_profile_data;
4971  m_partial_profile_data.clear();
4972  }
4973 
4974  size_t found, pos = 0, len = input.length();
4975  while ((found = input.find(end_delimiter, pos)) != std::string::npos) {
4976  StringExtractorGDBRemote profileDataExtractor(
4977  input.substr(pos, found).c_str());
4978  std::string profile_data =
4979  HarmonizeThreadIdsForProfileData(profileDataExtractor);
4980  BroadcastAsyncProfileData(profile_data);
4981 
4982  pos = found + end_delimiter_len;
4983  }
4984 
4985  if (pos < len) {
4986  // Last incomplete chunk.
4987  m_partial_profile_data = input.substr(pos);
4988  }
4989 }
4990 
4992  StringExtractorGDBRemote &profileDataExtractor) {
4993  std::map<uint64_t, uint32_t> new_thread_id_to_used_usec_map;
4994  std::string output;
4995  llvm::raw_string_ostream output_stream(output);
4996  llvm::StringRef name, value;
4997 
4998  // Going to assuming thread_used_usec comes first, else bail out.
4999  while (profileDataExtractor.GetNameColonValue(name, value)) {
5000  if (name.compare("thread_used_id") == 0) {
5001  StringExtractor threadIDHexExtractor(value);
5002  uint64_t thread_id = threadIDHexExtractor.GetHexMaxU64(false, 0);
5003 
5004  bool has_used_usec = false;
5005  uint32_t curr_used_usec = 0;
5006  llvm::StringRef usec_name, usec_value;
5007  uint32_t input_file_pos = profileDataExtractor.GetFilePos();
5008  if (profileDataExtractor.GetNameColonValue(usec_name, usec_value)) {
5009  if (usec_name.equals("thread_used_usec")) {
5010  has_used_usec = true;
5011  usec_value.getAsInteger(0, curr_used_usec);
5012  } else {
5013  // We didn't find what we want, it is probably an older version. Bail
5014  // out.
5015  profileDataExtractor.SetFilePos(input_file_pos);
5016  }
5017  }
5018 
5019  if (has_used_usec) {
5020  uint32_t prev_used_usec = 0;
5021  std::map<uint64_t, uint32_t>::iterator iterator =
5022  m_thread_id_to_used_usec_map.find(thread_id);
5023  if (iterator != m_thread_id_to_used_usec_map.end()) {
5024  prev_used_usec = m_thread_id_to_used_usec_map[thread_id];
5025  }
5026 
5027  uint32_t real_used_usec = curr_used_usec - prev_used_usec;
5028  // A good first time record is one that runs for at least 0.25 sec
5029  bool good_first_time =
5030  (prev_used_usec == 0) && (real_used_usec > 250000);
5031  bool good_subsequent_time =
5032  (prev_used_usec > 0) &&
5033  ((real_used_usec > 0) || (HasAssignedIndexIDToThread(thread_id)));
5034 
5035  if (good_first_time || good_subsequent_time) {
5036  // We try to avoid doing too many index id reservation, resulting in
5037  // fast increase of index ids.
5038 
5039  output_stream << name << ":";
5040  int32_t index_id = AssignIndexIDToThread(thread_id);
5041  output_stream << index_id << ";";
5042 
5043  output_stream << usec_name << ":" << usec_value << ";";
5044  } else {
5045  // Skip past 'thread_used_name'.
5046  llvm::StringRef local_name, local_value;
5047  profileDataExtractor.GetNameColonValue(local_name, local_value);
5048  }
5049 
5050  // Store current time as previous time so that they can be compared
5051  // later.
5052  new_thread_id_to_used_usec_map[thread_id] = curr_used_usec;
5053  } else {
5054  // Bail out and use old string.
5055  output_stream << name << ":" << value << ";";
5056  }
5057  } else {
5058  output_stream << name << ":" << value << ";";
5059  }
5060  }
5061  output_stream << end_delimiter;
5062  m_thread_id_to_used_usec_map = new_thread_id_to_used_usec_map;
5063 
5064  return output_stream.str();
5065 }
5066 
5068  if (GetStopID() != 0)
5069  return;
5070 
5071  if (GetID() == LLDB_INVALID_PROCESS_ID) {
5073  if (pid != LLDB_INVALID_PROCESS_ID)
5074  SetID(pid);
5075  }
5077 }
5078 
5079 static const char *const s_async_json_packet_prefix = "JSON-async:";
5080 
5082 ParseStructuredDataPacket(llvm::StringRef packet) {
5084 
5085  if (!packet.consume_front(s_async_json_packet_prefix)) {
5086  if (log) {
5087  LLDB_LOGF(
5088  log,
5089  "GDBRemoteCommunicationClientBase::%s() received $J packet "
5090  "but was not a StructuredData packet: packet starts with "
5091  "%s",
5092  __FUNCTION__,
5093  packet.slice(0, strlen(s_async_json_packet_prefix)).str().c_str());
5094  }
5095  return StructuredData::ObjectSP();
5096  }
5097 
5098  // This is an asynchronous JSON packet, destined for a StructuredDataPlugin.
5099  StructuredData::ObjectSP json_sp =
5101  if (log) {
5102  if (json_sp) {
5103  StreamString json_str;
5104  json_sp->Dump(json_str, true);
5105  json_str.Flush();
5106  LLDB_LOGF(log,
5107  "ProcessGDBRemote::%s() "
5108  "received Async StructuredData packet: %s",
5109  __FUNCTION__, json_str.GetData());
5110  } else {
5111  LLDB_LOGF(log,
5112  "ProcessGDBRemote::%s"
5113  "() received StructuredData packet:"
5114  " parse failure",
5115  __FUNCTION__);
5116  }
5117  }
5118  return json_sp;
5119 }
5120 
5122  auto structured_data_sp = ParseStructuredDataPacket(data);
5123  if (structured_data_sp)
5124  RouteAsyncStructuredData(structured_data_sp);
5125 }
5126 
5128 public:
5130  : CommandObjectParsed(interpreter, "process plugin packet speed-test",
5131  "Tests packet speeds of various sizes to determine "
5132  "the performance characteristics of the GDB remote "
5133  "connection. ",
5134  nullptr),
5135  m_option_group(),
5136  m_num_packets(LLDB_OPT_SET_1, false, "count", 'c', 0, eArgTypeCount,
5137  "The number of packets to send of each varying size "
5138  "(default is 1000).",
5139  1000),
5140  m_max_send(LLDB_OPT_SET_1, false, "max-send", 's', 0, eArgTypeCount,
5141  "The maximum number of bytes to send in a packet. Sizes "
5142  "increase in powers of 2 while the size is less than or "
5143  "equal to this option value. (default 1024).",
5144  1024),
5145  m_max_recv(LLDB_OPT_SET_1, false, "max-receive", 'r', 0, eArgTypeCount,
5146  "The maximum number of bytes to receive in a packet. Sizes "
5147  "increase in powers of 2 while the size is less than or "
5148  "equal to this option value. (default 1024).",
5149  1024),
5150  m_json(LLDB_OPT_SET_1, false, "json", 'j',
5151  "Print the output as JSON data for easy parsing.", false, true) {
5152  m_option_group.Append(&m_num_packets, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
5153  m_option_group.Append(&m_max_send, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
5154  m_option_group.Append(&m_max_recv, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
5155  m_option_group.Append(&m_json, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
5156  m_option_group.Finalize();
5157  }
5158 
5160 
5161  Options *GetOptions() override { return &m_option_group; }
5162 
5163  bool DoExecute(Args &command, CommandReturnObject &result) override {
5164  const size_t argc = command.GetArgumentCount();
5165  if (argc == 0) {
5166  ProcessGDBRemote *process =
5167  (ProcessGDBRemote *)m_interpreter.GetExecutionContext()
5168  .GetProcessPtr();
5169  if (process) {
5170  StreamSP output_stream_sp(
5171  m_interpreter.GetDebugger().GetAsyncOutputStream());
5172  result.SetImmediateOutputStream(output_stream_sp);
5173 
5174  const uint32_t num_packets =