LLDB  mainline
SBTarget.cpp
Go to the documentation of this file.
1 //===-- SBTarget.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/API/SBTarget.h"
10 #include "SBReproducerPrivate.h"
11 
12 #include "lldb/lldb-public.h"
13 
14 #include "lldb/API/SBBreakpoint.h"
15 #include "lldb/API/SBDebugger.h"
16 #include "lldb/API/SBEnvironment.h"
17 #include "lldb/API/SBEvent.h"
19 #include "lldb/API/SBFileSpec.h"
20 #include "lldb/API/SBListener.h"
21 #include "lldb/API/SBModule.h"
22 #include "lldb/API/SBModuleSpec.h"
23 #include "lldb/API/SBProcess.h"
25 #include "lldb/API/SBStream.h"
26 #include "lldb/API/SBStringList.h"
29 #include "lldb/API/SBTrace.h"
34 #include "lldb/Core/Address.h"
36 #include "lldb/Core/Debugger.h"
37 #include "lldb/Core/Disassembler.h"
38 #include "lldb/Core/Module.h"
39 #include "lldb/Core/ModuleSpec.h"
40 #include "lldb/Core/SearchFilter.h"
41 #include "lldb/Core/Section.h"
46 #include "lldb/Host/Host.h"
47 #include "lldb/Symbol/DeclVendor.h"
48 #include "lldb/Symbol/ObjectFile.h"
49 #include "lldb/Symbol/SymbolFile.h"
51 #include "lldb/Symbol/TypeSystem.h"
53 #include "lldb/Target/ABI.h"
54 #include "lldb/Target/Language.h"
56 #include "lldb/Target/Process.h"
57 #include "lldb/Target/StackFrame.h"
58 #include "lldb/Target/Target.h"
59 #include "lldb/Target/TargetList.h"
60 #include "lldb/Utility/ArchSpec.h"
61 #include "lldb/Utility/Args.h"
62 #include "lldb/Utility/FileSpec.h"
65 
68 #include "llvm/Support/PrettyStackTrace.h"
69 #include "llvm/Support/Regex.h"
70 
71 using namespace lldb;
72 using namespace lldb_private;
73 
74 #define DEFAULT_DISASM_BYTE_SIZE 32
75 
76 namespace {
77 
78 Status AttachToProcess(ProcessAttachInfo &attach_info, Target &target) {
79  std::lock_guard<std::recursive_mutex> guard(target.GetAPIMutex());
80 
81  auto process_sp = target.GetProcessSP();
82  if (process_sp) {
83  const auto state = process_sp->GetState();
84  if (process_sp->IsAlive() && state == eStateConnected) {
85  // If we are already connected, then we have already specified the
86  // listener, so if a valid listener is supplied, we need to error out to
87  // let the client know.
88  if (attach_info.GetListener())
89  return Status("process is connected and already has a listener, pass "
90  "empty listener");
91  }
92  }
93 
94  return target.Attach(attach_info, nullptr);
95 }
96 
97 } // namespace
98 
99 // SBTarget constructor
100 SBTarget::SBTarget() : m_opaque_sp() {
102 }
103 
104 SBTarget::SBTarget(const SBTarget &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
106 }
107 
108 SBTarget::SBTarget(const TargetSP &target_sp) : m_opaque_sp(target_sp) {
109  LLDB_RECORD_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &), target_sp);
110 }
111 
114  SBTarget, operator=,(const lldb::SBTarget &), rhs);
115 
116  if (this != &rhs)
117  m_opaque_sp = rhs.m_opaque_sp;
118  return LLDB_RECORD_RESULT(*this);
119 }
120 
121 // Destructor
122 SBTarget::~SBTarget() = default;
123 
126  (const lldb::SBEvent &), event);
127 
128  return Target::TargetEventData::GetEventDataFromEvent(event.get()) != nullptr;
129 }
130 
133  (const lldb::SBEvent &), event);
134 
135  return LLDB_RECORD_RESULT(
136  Target::TargetEventData::GetTargetFromEvent(event.get()));
137 }
138 
141  (const lldb::SBEvent &), event);
142 
143  const ModuleList module_list =
144  Target::TargetEventData::GetModuleListFromEvent(event.get());
145  return module_list.GetSize();
146 }
147 
149  const SBEvent &event) {
151  (const uint32_t, const lldb::SBEvent &), idx,
152  event);
153 
154  const ModuleList module_list =
155  Target::TargetEventData::GetModuleListFromEvent(event.get());
156  return LLDB_RECORD_RESULT(SBModule(module_list.GetModuleAtIndex(idx)));
157 }
158 
162 
163  return Target::GetStaticBroadcasterClass().AsCString();
164 }
165 
166 bool SBTarget::IsValid() const {
168  return this->operator bool();
169 }
170 SBTarget::operator bool() const {
171  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBTarget, operator bool);
172 
173  return m_opaque_sp.get() != nullptr && m_opaque_sp->IsValid();
174 }
175 
178 
179  SBProcess sb_process;
180  ProcessSP process_sp;
181  TargetSP target_sp(GetSP());
182  if (target_sp) {
183  process_sp = target_sp->GetProcessSP();
184  sb_process.SetSP(process_sp);
185  }
186 
187  return LLDB_RECORD_RESULT(sb_process);
188 }
189 
192 
193  TargetSP target_sp(GetSP());
194  if (!target_sp)
195  return LLDB_RECORD_RESULT(SBPlatform());
196 
197  SBPlatform platform;
198  platform.m_opaque_sp = target_sp->GetPlatform();
199 
200  return LLDB_RECORD_RESULT(platform);
201 }
202 
205 
206  SBDebugger debugger;
207  TargetSP target_sp(GetSP());
208  if (target_sp)
209  debugger.reset(target_sp->GetDebugger().shared_from_this());
210  return LLDB_RECORD_RESULT(debugger);
211 }
212 
215 
216  SBStructuredData data;
217  TargetSP target_sp(GetSP());
218  if (!target_sp)
219  return LLDB_RECORD_RESULT(data);
220 
221  auto stats_up = std::make_unique<StructuredData::Dictionary>();
222  int i = 0;
223  for (auto &Entry : target_sp->GetStatistics()) {
225  static_cast<lldb_private::StatisticKind>(i));
226  stats_up->AddIntegerItem(Desc, Entry);
227  i += 1;
228  }
229 
230  data.m_impl_up->SetObjectSP(std::move(stats_up));
231  return LLDB_RECORD_RESULT(data);
232 }
233 
236 
237  TargetSP target_sp(GetSP());
238  if (!target_sp)
239  return;
240  return target_sp->SetCollectingStats(v);
241 }
242 
245 
246  TargetSP target_sp(GetSP());
247  if (!target_sp)
248  return false;
249  return target_sp->GetCollectingStats();
250 }
251 
252 SBProcess SBTarget::LoadCore(const char *core_file) {
254  core_file);
255 
256  lldb::SBError error; // Ignored
257  return LLDB_RECORD_RESULT(LoadCore(core_file, error));
258 }
259 
262  (const char *, lldb::SBError &), core_file, error);
263 
264  SBProcess sb_process;
265  TargetSP target_sp(GetSP());
266  if (target_sp) {
267  FileSpec filespec(core_file);
268  FileSystem::Instance().Resolve(filespec);
269  ProcessSP process_sp(target_sp->CreateProcess(
270  target_sp->GetDebugger().GetListener(), "", &filespec, false));
271  if (process_sp) {
272  error.SetError(process_sp->LoadCore());
273  if (error.Success())
274  sb_process.SetSP(process_sp);
275  } else {
276  error.SetErrorString("Failed to create the process");
277  }
278  } else {
279  error.SetErrorString("SBTarget is invalid");
280  }
281  return LLDB_RECORD_RESULT(sb_process);
282 }
283 
284 SBProcess SBTarget::LaunchSimple(char const **argv, char const **envp,
285  const char *working_directory) {
287  (const char **, const char **, const char *), argv, envp,
288  working_directory);
289 
290  TargetSP target_sp = GetSP();
291  if (!target_sp)
292  return LLDB_RECORD_RESULT(SBProcess());
293 
294  SBLaunchInfo launch_info = GetLaunchInfo();
295 
296  if (Module *exe_module = target_sp->GetExecutableModulePointer())
297  launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(),
298  /*add_as_first_arg*/ true);
299  if (argv)
300  launch_info.SetArguments(argv, /*append*/ true);
301  if (envp)
302  launch_info.SetEnvironmentEntries(envp, /*append*/ false);
303  if (working_directory)
304  launch_info.SetWorkingDirectory(working_directory);
305 
306  SBError error;
307  return LLDB_RECORD_RESULT(Launch(launch_info, error));
308 }
309 
312 
313  SBError sb_error;
314  TargetSP target_sp(GetSP());
315  if (target_sp) {
316  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
317  sb_error.ref() = target_sp->Install(nullptr);
318  }
319  return LLDB_RECORD_RESULT(sb_error);
320 }
321 
322 SBProcess SBTarget::Launch(SBListener &listener, char const **argv,
323  char const **envp, const char *stdin_path,
324  const char *stdout_path, const char *stderr_path,
325  const char *working_directory,
326  uint32_t launch_flags, // See LaunchFlags
327  bool stop_at_entry, lldb::SBError &error) {
329  (lldb::SBListener &, const char **, const char **,
330  const char *, const char *, const char *, const char *,
331  uint32_t, bool, lldb::SBError &),
332  listener, argv, envp, stdin_path, stdout_path, stderr_path,
333  working_directory, launch_flags, stop_at_entry, error);
334 
335  SBProcess sb_process;
336  ProcessSP process_sp;
337  TargetSP target_sp(GetSP());
338 
339  if (target_sp) {
340  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
341 
342  if (stop_at_entry)
343  launch_flags |= eLaunchFlagStopAtEntry;
344 
345  if (getenv("LLDB_LAUNCH_FLAG_DISABLE_ASLR"))
346  launch_flags |= eLaunchFlagDisableASLR;
347 
348  StateType state = eStateInvalid;
349  process_sp = target_sp->GetProcessSP();
350  if (process_sp) {
351  state = process_sp->GetState();
352 
353  if (process_sp->IsAlive() && state != eStateConnected) {
354  if (state == eStateAttaching)
355  error.SetErrorString("process attach is in progress");
356  else
357  error.SetErrorString("a process is already being debugged");
358  return LLDB_RECORD_RESULT(sb_process);
359  }
360  }
361 
362  if (state == eStateConnected) {
363  // If we are already connected, then we have already specified the
364  // listener, so if a valid listener is supplied, we need to error out to
365  // let the client know.
366  if (listener.IsValid()) {
367  error.SetErrorString("process is connected and already has a listener, "
368  "pass empty listener");
369  return LLDB_RECORD_RESULT(sb_process);
370  }
371  }
372 
373  if (getenv("LLDB_LAUNCH_FLAG_DISABLE_STDIO"))
374  launch_flags |= eLaunchFlagDisableSTDIO;
375 
376  ProcessLaunchInfo launch_info(FileSpec(stdin_path), FileSpec(stdout_path),
377  FileSpec(stderr_path),
378  FileSpec(working_directory), launch_flags);
379 
380  Module *exe_module = target_sp->GetExecutableModulePointer();
381  if (exe_module)
382  launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
383  if (argv) {
384  launch_info.GetArguments().AppendArguments(argv);
385  } else {
386  auto default_launch_info = target_sp->GetProcessLaunchInfo();
387  launch_info.GetArguments().AppendArguments(
388  default_launch_info.GetArguments());
389  }
390  if (envp) {
391  launch_info.GetEnvironment() = Environment(envp);
392  } else {
393  auto default_launch_info = target_sp->GetProcessLaunchInfo();
394  launch_info.GetEnvironment() = default_launch_info.GetEnvironment();
395  }
396 
397  if (listener.IsValid())
398  launch_info.SetListener(listener.GetSP());
399 
400  error.SetError(target_sp->Launch(launch_info, nullptr));
401 
402  sb_process.SetSP(target_sp->GetProcessSP());
403  } else {
404  error.SetErrorString("SBTarget is invalid");
405  }
406 
407  return LLDB_RECORD_RESULT(sb_process);
408 }
409 
412  (lldb::SBLaunchInfo &, lldb::SBError &), sb_launch_info,
413  error);
414 
415 
416  SBProcess sb_process;
417  TargetSP target_sp(GetSP());
418 
419  if (target_sp) {
420  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
421  StateType state = eStateInvalid;
422  {
423  ProcessSP process_sp = target_sp->GetProcessSP();
424  if (process_sp) {
425  state = process_sp->GetState();
426 
427  if (process_sp->IsAlive() && state != eStateConnected) {
428  if (state == eStateAttaching)
429  error.SetErrorString("process attach is in progress");
430  else
431  error.SetErrorString("a process is already being debugged");
432  return LLDB_RECORD_RESULT(sb_process);
433  }
434  }
435  }
436 
437  lldb_private::ProcessLaunchInfo launch_info = sb_launch_info.ref();
438 
439  if (!launch_info.GetExecutableFile()) {
440  Module *exe_module = target_sp->GetExecutableModulePointer();
441  if (exe_module)
442  launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
443  }
444 
445  const ArchSpec &arch_spec = target_sp->GetArchitecture();
446  if (arch_spec.IsValid())
447  launch_info.GetArchitecture() = arch_spec;
448 
449  error.SetError(target_sp->Launch(launch_info, nullptr));
450  sb_launch_info.set_ref(launch_info);
451  sb_process.SetSP(target_sp->GetProcessSP());
452  } else {
453  error.SetErrorString("SBTarget is invalid");
454  }
455 
456  return LLDB_RECORD_RESULT(sb_process);
457 }
458 
461  (lldb::SBAttachInfo &, lldb::SBError &), sb_attach_info,
462  error);
463 
464  SBProcess sb_process;
465  TargetSP target_sp(GetSP());
466 
467  if (target_sp) {
468  ProcessAttachInfo &attach_info = sb_attach_info.ref();
469  if (attach_info.ProcessIDIsValid() && !attach_info.UserIDIsValid()) {
470  PlatformSP platform_sp = target_sp->GetPlatform();
471  // See if we can pre-verify if a process exists or not
472  if (platform_sp && platform_sp->IsConnected()) {
473  lldb::pid_t attach_pid = attach_info.GetProcessID();
474  ProcessInstanceInfo instance_info;
475  if (platform_sp->GetProcessInfo(attach_pid, instance_info)) {
476  attach_info.SetUserID(instance_info.GetEffectiveUserID());
477  } else {
478  error.ref().SetErrorStringWithFormat(
479  "no process found with process ID %" PRIu64, attach_pid);
480  return LLDB_RECORD_RESULT(sb_process);
481  }
482  }
483  }
484  error.SetError(AttachToProcess(attach_info, *target_sp));
485  if (error.Success())
486  sb_process.SetSP(target_sp->GetProcessSP());
487  } else {
488  error.SetErrorString("SBTarget is invalid");
489  }
490 
491  return LLDB_RECORD_RESULT(sb_process);
492 }
493 
495  SBListener &listener,
496  lldb::pid_t pid, // The process ID to attach to
497  SBError &error // An error explaining what went wrong if attach fails
498 ) {
501  listener, pid, error);
502 
503  SBProcess sb_process;
504  TargetSP target_sp(GetSP());
505 
506  if (target_sp) {
507  ProcessAttachInfo attach_info;
508  attach_info.SetProcessID(pid);
509  if (listener.IsValid())
510  attach_info.SetListener(listener.GetSP());
511 
512  ProcessInstanceInfo instance_info;
513  if (target_sp->GetPlatform()->GetProcessInfo(pid, instance_info))
514  attach_info.SetUserID(instance_info.GetEffectiveUserID());
515 
516  error.SetError(AttachToProcess(attach_info, *target_sp));
517  if (error.Success())
518  sb_process.SetSP(target_sp->GetProcessSP());
519  } else
520  error.SetErrorString("SBTarget is invalid");
521 
522  return LLDB_RECORD_RESULT(sb_process);
523 }
524 
526  SBListener &listener,
527  const char *name, // basename of process to attach to
528  bool wait_for, // if true wait for a new instance of "name" to be launched
529  SBError &error // An error explaining what went wrong if attach fails
530 ) {
532  (lldb::SBListener &, const char *, bool, lldb::SBError &),
533  listener, name, wait_for, error);
534 
535  SBProcess sb_process;
536  TargetSP target_sp(GetSP());
537 
538  if (name && target_sp) {
539  ProcessAttachInfo attach_info;
540  attach_info.GetExecutableFile().SetFile(name, FileSpec::Style::native);
541  attach_info.SetWaitForLaunch(wait_for);
542  if (listener.IsValid())
543  attach_info.SetListener(listener.GetSP());
544 
545  error.SetError(AttachToProcess(attach_info, *target_sp));
546  if (error.Success())
547  sb_process.SetSP(target_sp->GetProcessSP());
548  } else
549  error.SetErrorString("SBTarget is invalid");
550 
551  return LLDB_RECORD_RESULT(sb_process);
552 }
553 
555  const char *plugin_name,
556  SBError &error) {
559  (lldb::SBListener &, const char *, const char *, lldb::SBError &),
560  listener, url, plugin_name, error);
561 
562  SBProcess sb_process;
563  ProcessSP process_sp;
564  TargetSP target_sp(GetSP());
565 
566  if (target_sp) {
567  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
568  if (listener.IsValid())
569  process_sp =
570  target_sp->CreateProcess(listener.m_opaque_sp, plugin_name, nullptr,
571  true);
572  else
573  process_sp = target_sp->CreateProcess(
574  target_sp->GetDebugger().GetListener(), plugin_name, nullptr, true);
575 
576  if (process_sp) {
577  sb_process.SetSP(process_sp);
578  error.SetError(process_sp->ConnectRemote(url));
579  } else {
580  error.SetErrorString("unable to create lldb_private::Process");
581  }
582  } else {
583  error.SetErrorString("SBTarget is invalid");
584  }
585 
586  return LLDB_RECORD_RESULT(sb_process);
587 }
588 
591 
592  SBFileSpec exe_file_spec;
593  TargetSP target_sp(GetSP());
594  if (target_sp) {
595  Module *exe_module = target_sp->GetExecutableModulePointer();
596  if (exe_module)
597  exe_file_spec.SetFileSpec(exe_module->GetFileSpec());
598  }
599 
600  return LLDB_RECORD_RESULT(exe_file_spec);
601 }
602 
603 bool SBTarget::operator==(const SBTarget &rhs) const {
604  LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator==,(const lldb::SBTarget &),
605  rhs);
606 
607  return m_opaque_sp.get() == rhs.m_opaque_sp.get();
608 }
609 
610 bool SBTarget::operator!=(const SBTarget &rhs) const {
611  LLDB_RECORD_METHOD_CONST(bool, SBTarget, operator!=,(const lldb::SBTarget &),
612  rhs);
613 
614  return m_opaque_sp.get() != rhs.m_opaque_sp.get();
615 }
616 
617 lldb::TargetSP SBTarget::GetSP() const { return m_opaque_sp; }
618 
619 void SBTarget::SetSP(const lldb::TargetSP &target_sp) {
620  m_opaque_sp = target_sp;
621 }
622 
625  (lldb::addr_t), vm_addr);
626 
627  lldb::SBAddress sb_addr;
628  Address &addr = sb_addr.ref();
629  TargetSP target_sp(GetSP());
630  if (target_sp) {
631  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
632  if (target_sp->ResolveLoadAddress(vm_addr, addr))
633  return LLDB_RECORD_RESULT(sb_addr);
634  }
635 
636  // We have a load address that isn't in a section, just return an address
637  // with the offset filled in (the address) and the section set to NULL
638  addr.SetRawAddress(vm_addr);
639  return LLDB_RECORD_RESULT(sb_addr);
640 }
641 
644  (lldb::addr_t), file_addr);
645 
646  lldb::SBAddress sb_addr;
647  Address &addr = sb_addr.ref();
648  TargetSP target_sp(GetSP());
649  if (target_sp) {
650  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
651  if (target_sp->ResolveFileAddress(file_addr, addr))
652  return LLDB_RECORD_RESULT(sb_addr);
653  }
654 
655  addr.SetRawAddress(file_addr);
656  return LLDB_RECORD_RESULT(sb_addr);
657 }
658 
660  lldb::addr_t vm_addr) {
662  (uint32_t, lldb::addr_t), stop_id, vm_addr);
663 
664  lldb::SBAddress sb_addr;
665  Address &addr = sb_addr.ref();
666  TargetSP target_sp(GetSP());
667  if (target_sp) {
668  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
669  if (target_sp->ResolveLoadAddress(vm_addr, addr))
670  return LLDB_RECORD_RESULT(sb_addr);
671  }
672 
673  // We have a load address that isn't in a section, just return an address
674  // with the offset filled in (the address) and the section set to NULL
675  addr.SetRawAddress(vm_addr);
676  return LLDB_RECORD_RESULT(sb_addr);
677 }
678 
681  uint32_t resolve_scope) {
684  (const lldb::SBAddress &, uint32_t), addr, resolve_scope);
685 
686  SBSymbolContext sc;
687  SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
688  if (addr.IsValid()) {
689  TargetSP target_sp(GetSP());
690  if (target_sp)
691  target_sp->GetImages().ResolveSymbolContextForAddress(addr.ref(), scope,
692  sc.ref());
693  }
694  return LLDB_RECORD_RESULT(sc);
695 }
696 
697 size_t SBTarget::ReadMemory(const SBAddress addr, void *buf, size_t size,
698  lldb::SBError &error) {
700  (const lldb::SBAddress, void *, size_t, lldb::SBError &),
701  addr, buf, size, error);
702 
703  SBError sb_error;
704  size_t bytes_read = 0;
705  TargetSP target_sp(GetSP());
706  if (target_sp) {
707  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
708  bytes_read =
709  target_sp->ReadMemory(addr.ref(), buf, size, sb_error.ref(), true);
710  } else {
711  sb_error.SetErrorString("invalid target");
712  }
713 
714  return bytes_read;
715 }
716 
718  uint32_t line) {
720  (const char *, uint32_t), file, line);
721 
722  return LLDB_RECORD_RESULT(
723  SBBreakpoint(BreakpointCreateByLocation(SBFileSpec(file, false), line)));
724 }
725 
728  uint32_t line) {
730  (const lldb::SBFileSpec &, uint32_t), sb_file_spec, line);
731 
732  return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0));
733 }
734 
737  uint32_t line, lldb::addr_t offset) {
740  sb_file_spec, line, offset);
741 
742  SBFileSpecList empty_list;
743  return LLDB_RECORD_RESULT(
744  BreakpointCreateByLocation(sb_file_spec, line, offset, empty_list));
745 }
746 
749  uint32_t line, lldb::addr_t offset,
750  SBFileSpecList &sb_module_list) {
754  sb_file_spec, line, offset, sb_module_list);
755 
756  return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0,
757  offset, sb_module_list));
758 }
759 
761  const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column,
762  lldb::addr_t offset, SBFileSpecList &sb_module_list) {
766  sb_file_spec, line, column, offset, sb_module_list);
767 
768  SBBreakpoint sb_bp;
769  TargetSP target_sp(GetSP());
770  if (target_sp && line != 0) {
771  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
772 
773  const LazyBool check_inlines = eLazyBoolCalculate;
774  const LazyBool skip_prologue = eLazyBoolCalculate;
775  const bool internal = false;
776  const bool hardware = false;
777  const LazyBool move_to_nearest_code = eLazyBoolCalculate;
778  const FileSpecList *module_list = nullptr;
779  if (sb_module_list.GetSize() > 0) {
780  module_list = sb_module_list.get();
781  }
782  sb_bp = target_sp->CreateBreakpoint(
783  module_list, *sb_file_spec, line, column, offset, check_inlines,
784  skip_prologue, internal, hardware, move_to_nearest_code);
785  }
786 
787  return LLDB_RECORD_RESULT(sb_bp);
788 }
789 
791  const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column,
792  lldb::addr_t offset, SBFileSpecList &sb_module_list,
793  bool move_to_nearest_code) {
797  sb_file_spec, line, column, offset, sb_module_list,
798  move_to_nearest_code);
799 
800  SBBreakpoint sb_bp;
801  TargetSP target_sp(GetSP());
802  if (target_sp && line != 0) {
803  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
804 
805  const LazyBool check_inlines = eLazyBoolCalculate;
806  const LazyBool skip_prologue = eLazyBoolCalculate;
807  const bool internal = false;
808  const bool hardware = false;
809  const FileSpecList *module_list = nullptr;
810  if (sb_module_list.GetSize() > 0) {
811  module_list = sb_module_list.get();
812  }
813  sb_bp = target_sp->CreateBreakpoint(
814  module_list, *sb_file_spec, line, column, offset, check_inlines,
815  skip_prologue, internal, hardware,
816  move_to_nearest_code ? eLazyBoolYes : eLazyBoolNo);
817  }
818 
819  return LLDB_RECORD_RESULT(sb_bp);
820 }
821 
823  const char *module_name) {
825  (const char *, const char *), symbol_name, module_name);
826 
827  SBBreakpoint sb_bp;
828  TargetSP target_sp(GetSP());
829  if (target_sp.get()) {
830  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
831 
832  const bool internal = false;
833  const bool hardware = false;
834  const LazyBool skip_prologue = eLazyBoolCalculate;
835  const lldb::addr_t offset = 0;
836  if (module_name && module_name[0]) {
837  FileSpecList module_spec_list;
838  module_spec_list.Append(FileSpec(module_name));
839  sb_bp = target_sp->CreateBreakpoint(
840  &module_spec_list, nullptr, symbol_name, eFunctionNameTypeAuto,
841  eLanguageTypeUnknown, offset, skip_prologue, internal, hardware);
842  } else {
843  sb_bp = target_sp->CreateBreakpoint(
844  nullptr, nullptr, symbol_name, eFunctionNameTypeAuto,
845  eLanguageTypeUnknown, offset, skip_prologue, internal, hardware);
846  }
847  }
848 
849  return LLDB_RECORD_RESULT(sb_bp);
850 }
851 
853 SBTarget::BreakpointCreateByName(const char *symbol_name,
854  const SBFileSpecList &module_list,
855  const SBFileSpecList &comp_unit_list) {
857  (const char *, const lldb::SBFileSpecList &,
858  const lldb::SBFileSpecList &),
859  symbol_name, module_list, comp_unit_list);
860 
861  lldb::FunctionNameType name_type_mask = eFunctionNameTypeAuto;
862  return LLDB_RECORD_RESULT(
863  BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown,
864  module_list, comp_unit_list));
865 }
866 
868  const char *symbol_name, uint32_t name_type_mask,
869  const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
871  (const char *, uint32_t, const lldb::SBFileSpecList &,
872  const lldb::SBFileSpecList &),
873  symbol_name, name_type_mask, module_list, comp_unit_list);
874 
875  return LLDB_RECORD_RESULT(
876  BreakpointCreateByName(symbol_name, name_type_mask, eLanguageTypeUnknown,
877  module_list, comp_unit_list));
878 }
879 
881  const char *symbol_name, uint32_t name_type_mask,
882  LanguageType symbol_language, const SBFileSpecList &module_list,
883  const SBFileSpecList &comp_unit_list) {
885  (const char *, uint32_t, lldb::LanguageType,
886  const lldb::SBFileSpecList &,
887  const lldb::SBFileSpecList &),
888  symbol_name, name_type_mask, symbol_language, module_list,
889  comp_unit_list);
890 
891  SBBreakpoint sb_bp;
892  TargetSP target_sp(GetSP());
893  if (target_sp && symbol_name && symbol_name[0]) {
894  const bool internal = false;
895  const bool hardware = false;
896  const LazyBool skip_prologue = eLazyBoolCalculate;
897  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
898  FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask);
899  sb_bp = target_sp->CreateBreakpoint(module_list.get(), comp_unit_list.get(),
900  symbol_name, mask, symbol_language, 0,
901  skip_prologue, internal, hardware);
902  }
903 
904  return LLDB_RECORD_RESULT(sb_bp);
905 }
906 
908  const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
909  const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
912  (const char **, uint32_t, uint32_t, const lldb::SBFileSpecList &,
913  const lldb::SBFileSpecList &),
914  symbol_names, num_names, name_type_mask, module_list, comp_unit_list);
915 
917  symbol_names, num_names, name_type_mask, eLanguageTypeUnknown,
918  module_list, comp_unit_list));
919 }
920 
922  const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
923  LanguageType symbol_language, const SBFileSpecList &module_list,
924  const SBFileSpecList &comp_unit_list) {
926  (const char **, uint32_t, uint32_t, lldb::LanguageType,
927  const lldb::SBFileSpecList &,
928  const lldb::SBFileSpecList &),
929  symbol_names, num_names, name_type_mask, symbol_language,
930  module_list, comp_unit_list);
931 
933  symbol_names, num_names, name_type_mask, eLanguageTypeUnknown, 0,
934  module_list, comp_unit_list));
935 }
936 
938  const char *symbol_names[], uint32_t num_names, uint32_t name_type_mask,
939  LanguageType symbol_language, lldb::addr_t offset,
940  const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
942  (const char **, uint32_t, uint32_t, lldb::LanguageType,
944  const lldb::SBFileSpecList &),
945  symbol_names, num_names, name_type_mask, symbol_language,
946  offset, module_list, comp_unit_list);
947 
948  SBBreakpoint sb_bp;
949  TargetSP target_sp(GetSP());
950  if (target_sp && num_names > 0) {
951  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
952  const bool internal = false;
953  const bool hardware = false;
954  FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask);
955  const LazyBool skip_prologue = eLazyBoolCalculate;
956  sb_bp = target_sp->CreateBreakpoint(
957  module_list.get(), comp_unit_list.get(), symbol_names, num_names, mask,
958  symbol_language, offset, skip_prologue, internal, hardware);
959  }
960 
961  return LLDB_RECORD_RESULT(sb_bp);
962 }
963 
964 SBBreakpoint SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
965  const char *module_name) {
967  (const char *, const char *), symbol_name_regex,
968  module_name);
969 
970  SBFileSpecList module_spec_list;
971  SBFileSpecList comp_unit_list;
972  if (module_name && module_name[0]) {
973  module_spec_list.Append(FileSpec(module_name));
974  }
975  return LLDB_RECORD_RESULT(
977  module_spec_list, comp_unit_list));
978 }
979 
981 SBTarget::BreakpointCreateByRegex(const char *symbol_name_regex,
982  const SBFileSpecList &module_list,
983  const SBFileSpecList &comp_unit_list) {
985  (const char *, const lldb::SBFileSpecList &,
986  const lldb::SBFileSpecList &),
987  symbol_name_regex, module_list, comp_unit_list);
988 
990  symbol_name_regex, eLanguageTypeUnknown, module_list, comp_unit_list));
991 }
992 
994  const char *symbol_name_regex, LanguageType symbol_language,
995  const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list) {
998  (const char *, lldb::LanguageType, const lldb::SBFileSpecList &,
999  const lldb::SBFileSpecList &),
1000  symbol_name_regex, symbol_language, module_list, comp_unit_list);
1001 
1002 
1003  SBBreakpoint sb_bp;
1004  TargetSP target_sp(GetSP());
1005  if (target_sp && symbol_name_regex && symbol_name_regex[0]) {
1006  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1007  RegularExpression regexp((llvm::StringRef(symbol_name_regex)));
1008  const bool internal = false;
1009  const bool hardware = false;
1010  const LazyBool skip_prologue = eLazyBoolCalculate;
1011 
1012  sb_bp = target_sp->CreateFuncRegexBreakpoint(
1013  module_list.get(), comp_unit_list.get(), std::move(regexp),
1014  symbol_language, skip_prologue, internal, hardware);
1015  }
1016 
1017  return LLDB_RECORD_RESULT(sb_bp);
1018 }
1019 
1022  (lldb::addr_t), address);
1023 
1024  SBBreakpoint sb_bp;
1025  TargetSP target_sp(GetSP());
1026  if (target_sp) {
1027  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1028  const bool hardware = false;
1029  sb_bp = target_sp->CreateBreakpoint(address, false, hardware);
1030  }
1031 
1032  return LLDB_RECORD_RESULT(sb_bp);
1033 }
1034 
1037  (lldb::SBAddress &), sb_address);
1038 
1039  SBBreakpoint sb_bp;
1040  TargetSP target_sp(GetSP());
1041  if (!sb_address.IsValid()) {
1042  return LLDB_RECORD_RESULT(sb_bp);
1043  }
1044 
1045  if (target_sp) {
1046  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1047  const bool hardware = false;
1048  sb_bp = target_sp->CreateBreakpoint(sb_address.ref(), false, hardware);
1049  }
1050 
1051  return LLDB_RECORD_RESULT(sb_bp);
1052 }
1053 
1056  const lldb::SBFileSpec &source_file,
1057  const char *module_name) {
1060  (const char *, const lldb::SBFileSpec &, const char *),
1061  source_regex, source_file, module_name);
1062 
1063  SBFileSpecList module_spec_list;
1064 
1065  if (module_name && module_name[0]) {
1066  module_spec_list.Append(FileSpec(module_name));
1067  }
1068 
1069  SBFileSpecList source_file_list;
1070  if (source_file.IsValid()) {
1071  source_file_list.Append(source_file);
1072  }
1073 
1075  source_regex, module_spec_list, source_file_list));
1076 }
1077 
1079  const char *source_regex, const SBFileSpecList &module_list,
1080  const lldb::SBFileSpecList &source_file_list) {
1083  (const char *, const lldb::SBFileSpecList &,
1084  const lldb::SBFileSpecList &),
1085  source_regex, module_list, source_file_list);
1086 
1088  source_regex, module_list, source_file_list, SBStringList()));
1089 }
1090 
1092  const char *source_regex, const SBFileSpecList &module_list,
1093  const lldb::SBFileSpecList &source_file_list,
1094  const SBStringList &func_names) {
1097  (const char *, const lldb::SBFileSpecList &,
1098  const lldb::SBFileSpecList &, const lldb::SBStringList &),
1099  source_regex, module_list, source_file_list, func_names);
1100 
1101  SBBreakpoint sb_bp;
1102  TargetSP target_sp(GetSP());
1103  if (target_sp && source_regex && source_regex[0]) {
1104  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1105  const bool hardware = false;
1106  const LazyBool move_to_nearest_code = eLazyBoolCalculate;
1107  RegularExpression regexp((llvm::StringRef(source_regex)));
1108  std::unordered_set<std::string> func_names_set;
1109  for (size_t i = 0; i < func_names.GetSize(); i++) {
1110  func_names_set.insert(func_names.GetStringAtIndex(i));
1111  }
1112 
1113  sb_bp = target_sp->CreateSourceRegexBreakpoint(
1114  module_list.get(), source_file_list.get(), func_names_set,
1115  std::move(regexp), false, hardware, move_to_nearest_code);
1116  }
1117 
1118  return LLDB_RECORD_RESULT(sb_bp);
1119 }
1120 
1123  bool catch_bp, bool throw_bp) {
1125  (lldb::LanguageType, bool, bool), language, catch_bp,
1126  throw_bp);
1127 
1128  SBBreakpoint sb_bp;
1129  TargetSP target_sp(GetSP());
1130  if (target_sp) {
1131  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1132  const bool hardware = false;
1133  sb_bp = target_sp->CreateExceptionBreakpoint(language, catch_bp, throw_bp,
1134  hardware);
1135  }
1136 
1137  return LLDB_RECORD_RESULT(sb_bp);
1138 }
1139 
1141  const char *class_name, SBStructuredData &extra_args,
1142  const SBFileSpecList &module_list, const SBFileSpecList &file_list,
1143  bool request_hardware) {
1146  (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &,
1147  const lldb::SBFileSpecList &, bool),
1148  class_name, extra_args, module_list, file_list, request_hardware);
1149 
1150  SBBreakpoint sb_bp;
1151  TargetSP target_sp(GetSP());
1152  if (target_sp) {
1153  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1154  Status error;
1155 
1156  StructuredData::ObjectSP obj_sp = extra_args.m_impl_up->GetObjectSP();
1157  sb_bp =
1158  target_sp->CreateScriptedBreakpoint(class_name,
1159  module_list.get(),
1160  file_list.get(),
1161  false, /* internal */
1162  request_hardware,
1163  obj_sp,
1164  &error);
1165  }
1166 
1167  return LLDB_RECORD_RESULT(sb_bp);
1168 }
1169 
1172 
1173  TargetSP target_sp(GetSP());
1174  if (target_sp) {
1175  // The breakpoint list is thread safe, no need to lock
1176  return target_sp->GetBreakpointList().GetSize();
1177  }
1178  return 0;
1179 }
1180 
1183  (uint32_t), idx);
1184 
1185  SBBreakpoint sb_breakpoint;
1186  TargetSP target_sp(GetSP());
1187  if (target_sp) {
1188  // The breakpoint list is thread safe, no need to lock
1189  sb_breakpoint = target_sp->GetBreakpointList().GetBreakpointAtIndex(idx);
1190  }
1191  return LLDB_RECORD_RESULT(sb_breakpoint);
1192 }
1193 
1196  bp_id);
1197 
1198  bool result = false;
1199  TargetSP target_sp(GetSP());
1200  if (target_sp) {
1201  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1202  result = target_sp->RemoveBreakpointByID(bp_id);
1203  }
1204 
1205  return result;
1206 }
1207 
1210  (lldb::break_id_t), bp_id);
1211 
1212  SBBreakpoint sb_breakpoint;
1213  TargetSP target_sp(GetSP());
1214  if (target_sp && bp_id != LLDB_INVALID_BREAK_ID) {
1215  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1216  sb_breakpoint = target_sp->GetBreakpointByID(bp_id);
1217  }
1218 
1219  return LLDB_RECORD_RESULT(sb_breakpoint);
1220 }
1221 
1222 bool SBTarget::FindBreakpointsByName(const char *name,
1223  SBBreakpointList &bkpts) {
1225  (const char *, lldb::SBBreakpointList &), name, bkpts);
1226 
1227  TargetSP target_sp(GetSP());
1228  if (target_sp) {
1229  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1230  llvm::Expected<std::vector<BreakpointSP>> expected_vector =
1231  target_sp->GetBreakpointList().FindBreakpointsByName(name);
1232  if (!expected_vector) {
1234  "invalid breakpoint name: {}",
1235  llvm::toString(expected_vector.takeError()));
1236  return false;
1237  }
1238  for (BreakpointSP bkpt_sp : *expected_vector) {
1239  bkpts.AppendByID(bkpt_sp->GetID());
1240  }
1241  }
1242  return true;
1243 }
1244 
1247  names);
1248 
1249  names.Clear();
1250 
1251  TargetSP target_sp(GetSP());
1252  if (target_sp) {
1253  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1254 
1255  std::vector<std::string> name_vec;
1256  target_sp->GetBreakpointNames(name_vec);
1257  for (auto name : name_vec)
1258  names.AppendString(name.c_str());
1259  }
1260 }
1261 
1262 void SBTarget::DeleteBreakpointName(const char *name) {
1263  LLDB_RECORD_METHOD(void, SBTarget, DeleteBreakpointName, (const char *),
1264  name);
1265 
1266  TargetSP target_sp(GetSP());
1267  if (target_sp) {
1268  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1269  target_sp->DeleteBreakpointName(ConstString(name));
1270  }
1271 }
1272 
1275 
1276  TargetSP target_sp(GetSP());
1277  if (target_sp) {
1278  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1279  target_sp->EnableAllowedBreakpoints();
1280  return true;
1281  }
1282  return false;
1283 }
1284 
1287 
1288  TargetSP target_sp(GetSP());
1289  if (target_sp) {
1290  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1291  target_sp->DisableAllowedBreakpoints();
1292  return true;
1293  }
1294  return false;
1295 }
1296 
1299 
1300  TargetSP target_sp(GetSP());
1301  if (target_sp) {
1302  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1303  target_sp->RemoveAllowedBreakpoints();
1304  return true;
1305  }
1306  return false;
1307 }
1308 
1310  SBBreakpointList &new_bps) {
1313  source_file, new_bps);
1314 
1315  SBStringList empty_name_list;
1316  return LLDB_RECORD_RESULT(
1317  BreakpointsCreateFromFile(source_file, empty_name_list, new_bps));
1318 }
1319 
1321  SBStringList &matching_names,
1322  SBBreakpointList &new_bps) {
1326  source_file, matching_names, new_bps);
1327 
1328  SBError sberr;
1329  TargetSP target_sp(GetSP());
1330  if (!target_sp) {
1331  sberr.SetErrorString(
1332  "BreakpointCreateFromFile called with invalid target.");
1333  return LLDB_RECORD_RESULT(sberr);
1334  }
1335  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1336 
1337  BreakpointIDList bp_ids;
1338 
1339  std::vector<std::string> name_vector;
1340  size_t num_names = matching_names.GetSize();
1341  for (size_t i = 0; i < num_names; i++)
1342  name_vector.push_back(matching_names.GetStringAtIndex(i));
1343 
1344  sberr.ref() = target_sp->CreateBreakpointsFromFile(source_file.ref(),
1345  name_vector, bp_ids);
1346  if (sberr.Fail())
1347  return LLDB_RECORD_RESULT(sberr);
1348 
1349  size_t num_bkpts = bp_ids.GetSize();
1350  for (size_t i = 0; i < num_bkpts; i++) {
1351  BreakpointID bp_id = bp_ids.GetBreakpointIDAtIndex(i);
1352  new_bps.AppendByID(bp_id.GetBreakpointID());
1353  }
1354  return LLDB_RECORD_RESULT(sberr);
1355 }
1356 
1359  (lldb::SBFileSpec &), dest_file);
1360 
1361  SBError sberr;
1362  TargetSP target_sp(GetSP());
1363  if (!target_sp) {
1364  sberr.SetErrorString("BreakpointWriteToFile called with invalid target.");
1365  return LLDB_RECORD_RESULT(sberr);
1366  }
1367  SBBreakpointList bkpt_list(*this);
1368  return LLDB_RECORD_RESULT(BreakpointsWriteToFile(dest_file, bkpt_list));
1369 }
1370 
1372  SBBreakpointList &bkpt_list,
1373  bool append) {
1376  dest_file, bkpt_list, append);
1377 
1378  SBError sberr;
1379  TargetSP target_sp(GetSP());
1380  if (!target_sp) {
1381  sberr.SetErrorString("BreakpointWriteToFile called with invalid target.");
1382  return LLDB_RECORD_RESULT(sberr);
1383  }
1384 
1385  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1386  BreakpointIDList bp_id_list;
1387  bkpt_list.CopyToBreakpointIDList(bp_id_list);
1388  sberr.ref() = target_sp->SerializeBreakpointsToFile(dest_file.ref(),
1389  bp_id_list, append);
1390  return LLDB_RECORD_RESULT(sberr);
1391 }
1392 
1395 
1396  TargetSP target_sp(GetSP());
1397  if (target_sp) {
1398  // The watchpoint list is thread safe, no need to lock
1399  return target_sp->GetWatchpointList().GetSize();
1400  }
1401  return 0;
1402 }
1403 
1406  (uint32_t), idx);
1407 
1408  SBWatchpoint sb_watchpoint;
1409  TargetSP target_sp(GetSP());
1410  if (target_sp) {
1411  // The watchpoint list is thread safe, no need to lock
1412  sb_watchpoint.SetSP(target_sp->GetWatchpointList().GetByIndex(idx));
1413  }
1414  return LLDB_RECORD_RESULT(sb_watchpoint);
1415 }
1416 
1419  wp_id);
1420 
1421 
1422  bool result = false;
1423  TargetSP target_sp(GetSP());
1424  if (target_sp) {
1425  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1426  std::unique_lock<std::recursive_mutex> lock;
1427  target_sp->GetWatchpointList().GetListMutex(lock);
1428  result = target_sp->RemoveWatchpointByID(wp_id);
1429  }
1430 
1431  return result;
1432 }
1433 
1436  (lldb::watch_id_t), wp_id);
1437 
1438 
1439  SBWatchpoint sb_watchpoint;
1440  lldb::WatchpointSP watchpoint_sp;
1441  TargetSP target_sp(GetSP());
1442  if (target_sp && wp_id != LLDB_INVALID_WATCH_ID) {
1443  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1444  std::unique_lock<std::recursive_mutex> lock;
1445  target_sp->GetWatchpointList().GetListMutex(lock);
1446  watchpoint_sp = target_sp->GetWatchpointList().FindByID(wp_id);
1447  sb_watchpoint.SetSP(watchpoint_sp);
1448  }
1449 
1450  return LLDB_RECORD_RESULT(sb_watchpoint);
1451 }
1452 
1454  bool read, bool write,
1455  SBError &error) {
1457  (lldb::addr_t, size_t, bool, bool, lldb::SBError &), addr,
1458  size, read, write, error);
1459 
1460  SBWatchpoint sb_watchpoint;
1461  lldb::WatchpointSP watchpoint_sp;
1462  TargetSP target_sp(GetSP());
1463  if (target_sp && (read || write) && addr != LLDB_INVALID_ADDRESS &&
1464  size > 0) {
1465  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1466  uint32_t watch_type = 0;
1467  if (read)
1468  watch_type |= LLDB_WATCH_TYPE_READ;
1469  if (write)
1470  watch_type |= LLDB_WATCH_TYPE_WRITE;
1471  if (watch_type == 0) {
1472  error.SetErrorString(
1473  "Can't create a watchpoint that is neither read nor write.");
1474  return LLDB_RECORD_RESULT(sb_watchpoint);
1475  }
1476 
1477  // Target::CreateWatchpoint() is thread safe.
1478  Status cw_error;
1479  // This API doesn't take in a type, so we can't figure out what it is.
1480  CompilerType *type = nullptr;
1481  watchpoint_sp =
1482  target_sp->CreateWatchpoint(addr, size, type, watch_type, cw_error);
1483  error.SetError(cw_error);
1484  sb_watchpoint.SetSP(watchpoint_sp);
1485  }
1486 
1487  return LLDB_RECORD_RESULT(sb_watchpoint);
1488 }
1489 
1492 
1493  TargetSP target_sp(GetSP());
1494  if (target_sp) {
1495  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1496  std::unique_lock<std::recursive_mutex> lock;
1497  target_sp->GetWatchpointList().GetListMutex(lock);
1498  target_sp->EnableAllWatchpoints();
1499  return true;
1500  }
1501  return false;
1502 }
1503 
1506 
1507  TargetSP target_sp(GetSP());
1508  if (target_sp) {
1509  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1510  std::unique_lock<std::recursive_mutex> lock;
1511  target_sp->GetWatchpointList().GetListMutex(lock);
1512  target_sp->DisableAllWatchpoints();
1513  return true;
1514  }
1515  return false;
1516 }
1517 
1519  SBType type) {
1521  (const char *, lldb::SBAddress, lldb::SBType), name, addr,
1522  type);
1523 
1524  SBValue sb_value;
1525  lldb::ValueObjectSP new_value_sp;
1526  if (IsValid() && name && *name && addr.IsValid() && type.IsValid()) {
1527  lldb::addr_t load_addr(addr.GetLoadAddress(*this));
1528  ExecutionContext exe_ctx(
1530  CompilerType ast_type(type.GetSP()->GetCompilerType(true));
1531  new_value_sp = ValueObject::CreateValueObjectFromAddress(name, load_addr,
1532  exe_ctx, ast_type);
1533  }
1534  sb_value.SetSP(new_value_sp);
1535  return LLDB_RECORD_RESULT(sb_value);
1536 }
1537 
1539  lldb::SBType type) {
1541  (const char *, lldb::SBData, lldb::SBType), name, data,
1542  type);
1543 
1544  SBValue sb_value;
1545  lldb::ValueObjectSP new_value_sp;
1546  if (IsValid() && name && *name && data.IsValid() && type.IsValid()) {
1547  DataExtractorSP extractor(*data);
1548  ExecutionContext exe_ctx(
1550  CompilerType ast_type(type.GetSP()->GetCompilerType(true));
1551  new_value_sp = ValueObject::CreateValueObjectFromData(name, *extractor,
1552  exe_ctx, ast_type);
1553  }
1554  sb_value.SetSP(new_value_sp);
1555  return LLDB_RECORD_RESULT(sb_value);
1556 }
1557 
1559  const char *expr) {
1561  (const char *, const char *), name, expr);
1562 
1563  SBValue sb_value;
1564  lldb::ValueObjectSP new_value_sp;
1565  if (IsValid() && name && *name && expr && *expr) {
1566  ExecutionContext exe_ctx(
1568  new_value_sp =
1569  ValueObject::CreateValueObjectFromExpression(name, expr, exe_ctx);
1570  }
1571  sb_value.SetSP(new_value_sp);
1572  return LLDB_RECORD_RESULT(sb_value);
1573 }
1574 
1577 
1578  TargetSP target_sp(GetSP());
1579  if (target_sp) {
1580  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
1581  std::unique_lock<std::recursive_mutex> lock;
1582  target_sp->GetWatchpointList().GetListMutex(lock);
1583  target_sp->RemoveAllWatchpoints();
1584  return true;
1585  }
1586  return false;
1587 }
1588 
1589 void SBTarget::AppendImageSearchPath(const char *from, const char *to,
1590  lldb::SBError &error) {
1592  (const char *, const char *, lldb::SBError &), from, to,
1593  error);
1594 
1595  TargetSP target_sp(GetSP());
1596  if (!target_sp)
1597  return error.SetErrorString("invalid target");
1598 
1599  const ConstString csFrom(from), csTo(to);
1600  if (!csFrom)
1601  return error.SetErrorString("<from> path can't be empty");
1602  if (!csTo)
1603  return error.SetErrorString("<to> path can't be empty");
1604 
1605  target_sp->GetImageSearchPathList().Append(csFrom, csTo, true);
1606 }
1607 
1608 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
1609  const char *uuid_cstr) {
1611  (const char *, const char *, const char *), path, triple,
1612  uuid_cstr);
1613 
1614  return LLDB_RECORD_RESULT(AddModule(path, triple, uuid_cstr, nullptr));
1615 }
1616 
1617 lldb::SBModule SBTarget::AddModule(const char *path, const char *triple,
1618  const char *uuid_cstr, const char *symfile) {
1620  (const char *, const char *, const char *, const char *),
1621  path, triple, uuid_cstr, symfile);
1622 
1623  lldb::SBModule sb_module;
1624  TargetSP target_sp(GetSP());
1625  if (target_sp) {
1626  ModuleSpec module_spec;
1627  if (path)
1628  module_spec.GetFileSpec().SetFile(path, FileSpec::Style::native);
1629 
1630  if (uuid_cstr)
1631  module_spec.GetUUID().SetFromStringRef(uuid_cstr);
1632 
1633  if (triple)
1634  module_spec.GetArchitecture() = Platform::GetAugmentedArchSpec(
1635  target_sp->GetPlatform().get(), triple);
1636  else
1637  module_spec.GetArchitecture() = target_sp->GetArchitecture();
1638 
1639  if (symfile)
1640  module_spec.GetSymbolFileSpec().SetFile(symfile, FileSpec::Style::native);
1641 
1642  sb_module.SetSP(target_sp->GetOrCreateModule(module_spec, true /* notify */));
1643  }
1644  return LLDB_RECORD_RESULT(sb_module);
1645 }
1646 
1649  (const lldb::SBModuleSpec &), module_spec);
1650 
1651  lldb::SBModule sb_module;
1652  TargetSP target_sp(GetSP());
1653  if (target_sp)
1654  sb_module.SetSP(target_sp->GetOrCreateModule(*module_spec.m_opaque_up,
1655  true /* notify */));
1656  return LLDB_RECORD_RESULT(sb_module);
1657 }
1658 
1660  LLDB_RECORD_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &), module);
1661 
1662  TargetSP target_sp(GetSP());
1663  if (target_sp) {
1664  target_sp->GetImages().AppendIfNeeded(module.GetSP());
1665  return true;
1666  }
1667  return false;
1668 }
1669 
1672 
1673  uint32_t num = 0;
1674  TargetSP target_sp(GetSP());
1675  if (target_sp) {
1676  // The module list is thread safe, no need to lock
1677  num = target_sp->GetImages().GetSize();
1678  }
1679 
1680  return num;
1681 }
1682 
1685 
1686  m_opaque_sp.reset();
1687 }
1688 
1691  (const lldb::SBFileSpec &), sb_file_spec);
1692 
1693  SBModule sb_module;
1694  TargetSP target_sp(GetSP());
1695  if (target_sp && sb_file_spec.IsValid()) {
1696  ModuleSpec module_spec(*sb_file_spec);
1697  // The module list is thread safe, no need to lock
1698  sb_module.SetSP(target_sp->GetImages().FindFirstModule(module_spec));
1699  }
1700  return LLDB_RECORD_RESULT(sb_module);
1701 }
1702 
1705  (const lldb::SBFileSpec &), sb_file_spec);
1706 
1707  SBSymbolContextList sb_sc_list;
1708  const TargetSP target_sp(GetSP());
1709  if (target_sp && sb_file_spec.IsValid())
1710  target_sp->GetImages().FindCompileUnits(*sb_file_spec, *sb_sc_list);
1711  return LLDB_RECORD_RESULT(sb_sc_list);
1712 }
1713 
1716 
1717  TargetSP target_sp(GetSP());
1718  if (target_sp)
1719  return target_sp->GetArchitecture().GetByteOrder();
1720  return eByteOrderInvalid;
1721 }
1722 
1723 const char *SBTarget::GetTriple() {
1725 
1726  TargetSP target_sp(GetSP());
1727  if (target_sp) {
1728  std::string triple(target_sp->GetArchitecture().GetTriple().str());
1729  // Unique the string so we don't run into ownership issues since the const
1730  // strings put the string into the string pool once and the strings never
1731  // comes out
1732  ConstString const_triple(triple.c_str());
1733  return const_triple.GetCString();
1734  }
1735  return nullptr;
1736 }
1737 
1740 
1741  TargetSP target_sp(GetSP());
1742  if (target_sp) {
1743  return target_sp->GetArchitecture().GetDataByteSize();
1744  }
1745  return 0;
1746 }
1747 
1750 
1751  TargetSP target_sp(GetSP());
1752  if (target_sp) {
1753  return target_sp->GetArchitecture().GetCodeByteSize();
1754  }
1755  return 0;
1756 }
1757 
1760 
1761  TargetSP target_sp(GetSP());
1762  if (target_sp)
1763  return target_sp->GetArchitecture().GetAddressByteSize();
1764  return sizeof(void *);
1765 }
1766 
1769  idx);
1770 
1771  SBModule sb_module;
1772  ModuleSP module_sp;
1773  TargetSP target_sp(GetSP());
1774  if (target_sp) {
1775  // The module list is thread safe, no need to lock
1776  module_sp = target_sp->GetImages().GetModuleAtIndex(idx);
1777  sb_module.SetSP(module_sp);
1778  }
1779 
1780  return LLDB_RECORD_RESULT(sb_module);
1781 }
1782 
1785 
1786  TargetSP target_sp(GetSP());
1787  if (target_sp)
1788  return target_sp->GetImages().Remove(module.GetSP());
1789  return false;
1790 }
1791 
1794  GetBroadcaster);
1795 
1796 
1797  TargetSP target_sp(GetSP());
1798  SBBroadcaster broadcaster(target_sp.get(), false);
1799 
1800 
1801  return LLDB_RECORD_RESULT(broadcaster);
1802 }
1803 
1805  lldb::DescriptionLevel description_level) {
1807  (lldb::SBStream &, lldb::DescriptionLevel), description,
1808  description_level);
1809 
1810  Stream &strm = description.ref();
1811 
1812  TargetSP target_sp(GetSP());
1813  if (target_sp) {
1814  target_sp->Dump(&strm, description_level);
1815  } else
1816  strm.PutCString("No value");
1817 
1818  return true;
1819 }
1820 
1822  uint32_t name_type_mask) {
1824  (const char *, uint32_t), name, name_type_mask);
1825 
1826  lldb::SBSymbolContextList sb_sc_list;
1827  if (!name || !name[0])
1828  return LLDB_RECORD_RESULT(sb_sc_list);
1829 
1830  TargetSP target_sp(GetSP());
1831  if (!target_sp)
1832  return LLDB_RECORD_RESULT(sb_sc_list);
1833 
1834  ModuleFunctionSearchOptions function_options;
1835  function_options.include_symbols = true;
1836  function_options.include_inlines = true;
1837 
1838  FunctionNameType mask = static_cast<FunctionNameType>(name_type_mask);
1839  target_sp->GetImages().FindFunctions(ConstString(name), mask,
1840  function_options, *sb_sc_list);
1841  return LLDB_RECORD_RESULT(sb_sc_list);
1842 }
1843 
1845  uint32_t max_matches,
1846  MatchType matchtype) {
1848  (const char *, uint32_t, lldb::MatchType), name,
1849  max_matches, matchtype);
1850 
1851  lldb::SBSymbolContextList sb_sc_list;
1852  if (name && name[0]) {
1853  llvm::StringRef name_ref(name);
1854  TargetSP target_sp(GetSP());
1855  if (target_sp) {
1856  ModuleFunctionSearchOptions function_options;
1857  function_options.include_symbols = true;
1858  function_options.include_inlines = true;
1859 
1860  std::string regexstr;
1861  switch (matchtype) {
1862  case eMatchTypeRegex:
1863  target_sp->GetImages().FindFunctions(RegularExpression(name_ref),
1864  function_options, *sb_sc_list);
1865  break;
1866  case eMatchTypeStartsWith:
1867  regexstr = llvm::Regex::escape(name) + ".*";
1868  target_sp->GetImages().FindFunctions(RegularExpression(regexstr),
1869  function_options, *sb_sc_list);
1870  break;
1871  default:
1872  target_sp->GetImages().FindFunctions(ConstString(name),
1873  eFunctionNameTypeAny,
1874  function_options, *sb_sc_list);
1875  break;
1876  }
1877  }
1878  }
1879  return LLDB_RECORD_RESULT(sb_sc_list);
1880 }
1881 
1882 lldb::SBType SBTarget::FindFirstType(const char *typename_cstr) {
1884  typename_cstr);
1885 
1886  TargetSP target_sp(GetSP());
1887  if (typename_cstr && typename_cstr[0] && target_sp) {
1888  ConstString const_typename(typename_cstr);
1889  SymbolContext sc;
1890  const bool exact_match = false;
1891 
1892  const ModuleList &module_list = target_sp->GetImages();
1893  size_t count = module_list.GetSize();
1894  for (size_t idx = 0; idx < count; idx++) {
1895  ModuleSP module_sp(module_list.GetModuleAtIndex(idx));
1896  if (module_sp) {
1897  TypeSP type_sp(
1898  module_sp->FindFirstType(sc, const_typename, exact_match));
1899  if (type_sp)
1900  return LLDB_RECORD_RESULT(SBType(type_sp));
1901  }
1902  }
1903 
1904  // Didn't find the type in the symbols; Try the loaded language runtimes
1905  if (auto process_sp = target_sp->GetProcessSP()) {
1906  for (auto *runtime : process_sp->GetLanguageRuntimes()) {
1907  if (auto vendor = runtime->GetDeclVendor()) {
1908  auto types = vendor->FindTypes(const_typename, /*max_matches*/ 1);
1909  if (!types.empty())
1910  return LLDB_RECORD_RESULT(SBType(types.front()));
1911  }
1912  }
1913  }
1914 
1915  // No matches, search for basic typename matches
1916  for (auto *type_system : target_sp->GetScratchTypeSystems())
1917  if (auto type = type_system->GetBuiltinTypeByName(const_typename))
1918  return LLDB_RECORD_RESULT(SBType(type));
1919  }
1920 
1921  return LLDB_RECORD_RESULT(SBType());
1922 }
1923 
1926  type);
1927 
1928  TargetSP target_sp(GetSP());
1929  if (target_sp) {
1930  for (auto *type_system : target_sp->GetScratchTypeSystems())
1931  if (auto compiler_type = type_system->GetBasicTypeFromAST(type))
1932  return LLDB_RECORD_RESULT(SBType(compiler_type));
1933  }
1934  return LLDB_RECORD_RESULT(SBType());
1935 }
1936 
1937 lldb::SBTypeList SBTarget::FindTypes(const char *typename_cstr) {
1939  typename_cstr);
1940 
1941  SBTypeList sb_type_list;
1942  TargetSP target_sp(GetSP());
1943  if (typename_cstr && typename_cstr[0] && target_sp) {
1944  ModuleList &images = target_sp->GetImages();
1945  ConstString const_typename(typename_cstr);
1946  bool exact_match = false;
1947  TypeList type_list;
1948  llvm::DenseSet<SymbolFile *> searched_symbol_files;
1949  images.FindTypes(nullptr, const_typename, exact_match, UINT32_MAX,
1950  searched_symbol_files, type_list);
1951 
1952  for (size_t idx = 0; idx < type_list.GetSize(); idx++) {
1953  TypeSP type_sp(type_list.GetTypeAtIndex(idx));
1954  if (type_sp)
1955  sb_type_list.Append(SBType(type_sp));
1956  }
1957 
1958  // Try the loaded language runtimes
1959  if (auto process_sp = target_sp->GetProcessSP()) {
1960  for (auto *runtime : process_sp->GetLanguageRuntimes()) {
1961  if (auto *vendor = runtime->GetDeclVendor()) {
1962  auto types =
1963  vendor->FindTypes(const_typename, /*max_matches*/ UINT32_MAX);
1964  for (auto type : types)
1965  sb_type_list.Append(SBType(type));
1966  }
1967  }
1968  }
1969 
1970  if (sb_type_list.GetSize() == 0) {
1971  // No matches, search for basic typename matches
1972  for (auto *type_system : target_sp->GetScratchTypeSystems())
1973  if (auto compiler_type =
1974  type_system->GetBuiltinTypeByName(const_typename))
1975  sb_type_list.Append(SBType(compiler_type));
1976  }
1977  }
1978  return LLDB_RECORD_RESULT(sb_type_list);
1979 }
1980 
1982  uint32_t max_matches) {
1984  (const char *, uint32_t), name, max_matches);
1985 
1986  SBValueList sb_value_list;
1987 
1988  TargetSP target_sp(GetSP());
1989  if (name && target_sp) {
1990  VariableList variable_list;
1991  target_sp->GetImages().FindGlobalVariables(ConstString(name), max_matches,
1992  variable_list);
1993  if (!variable_list.Empty()) {
1994  ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get();
1995  if (exe_scope == nullptr)
1996  exe_scope = target_sp.get();
1997  for (const VariableSP &var_sp : variable_list) {
1998  lldb::ValueObjectSP valobj_sp(
1999  ValueObjectVariable::Create(exe_scope, var_sp));
2000  if (valobj_sp)
2001  sb_value_list.Append(SBValue(valobj_sp));
2002  }
2003  }
2004  }
2005 
2006  return LLDB_RECORD_RESULT(sb_value_list);
2007 }
2008 
2010  uint32_t max_matches,
2011  MatchType matchtype) {
2013  (const char *, uint32_t, lldb::MatchType), name,
2014  max_matches, matchtype);
2015 
2016  SBValueList sb_value_list;
2017 
2018  TargetSP target_sp(GetSP());
2019  if (name && target_sp) {
2020  llvm::StringRef name_ref(name);
2021  VariableList variable_list;
2022 
2023  std::string regexstr;
2024  switch (matchtype) {
2025  case eMatchTypeNormal:
2026  target_sp->GetImages().FindGlobalVariables(ConstString(name), max_matches,
2027  variable_list);
2028  break;
2029  case eMatchTypeRegex:
2030  target_sp->GetImages().FindGlobalVariables(RegularExpression(name_ref),
2031  max_matches, variable_list);
2032  break;
2033  case eMatchTypeStartsWith:
2034  regexstr = llvm::Regex::escape(name) + ".*";
2035  target_sp->GetImages().FindGlobalVariables(RegularExpression(regexstr),
2036  max_matches, variable_list);
2037  break;
2038  }
2039  if (!variable_list.Empty()) {
2040  ExecutionContextScope *exe_scope = target_sp->GetProcessSP().get();
2041  if (exe_scope == nullptr)
2042  exe_scope = target_sp.get();
2043  for (const VariableSP &var_sp : variable_list) {
2044  lldb::ValueObjectSP valobj_sp(
2045  ValueObjectVariable::Create(exe_scope, var_sp));
2046  if (valobj_sp)
2047  sb_value_list.Append(SBValue(valobj_sp));
2048  }
2049  }
2050  }
2051 
2052  return LLDB_RECORD_RESULT(sb_value_list);
2053 }
2054 
2057  (const char *), name);
2058 
2059  SBValueList sb_value_list(FindGlobalVariables(name, 1));
2060  if (sb_value_list.IsValid() && sb_value_list.GetSize() > 0)
2061  return LLDB_RECORD_RESULT(sb_value_list.GetValueAtIndex(0));
2062  return LLDB_RECORD_RESULT(SBValue());
2063 }
2064 
2067 
2068  SBSourceManager source_manager(*this);
2069  return LLDB_RECORD_RESULT(source_manager);
2070 }
2071 
2073  uint32_t count) {
2075  (lldb::SBAddress, uint32_t), base_addr, count);
2076 
2077  return LLDB_RECORD_RESULT(ReadInstructions(base_addr, count, nullptr));
2078 }
2079 
2081  uint32_t count,
2082  const char *flavor_string) {
2084  (lldb::SBAddress, uint32_t, const char *), base_addr,
2085  count, flavor_string);
2086 
2087  SBInstructionList sb_instructions;
2088 
2089  TargetSP target_sp(GetSP());
2090  if (target_sp) {
2091  Address *addr_ptr = base_addr.get();
2092 
2093  if (addr_ptr) {
2094  DataBufferHeap data(
2095  target_sp->GetArchitecture().GetMaximumOpcodeByteSize() * count, 0);
2096  bool force_live_memory = true;
2098  lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
2099  const size_t bytes_read =
2100  target_sp->ReadMemory(*addr_ptr, data.GetBytes(), data.GetByteSize(),
2101  error, force_live_memory, &load_addr);
2102  const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS;
2103  sb_instructions.SetDisassembler(Disassembler::DisassembleBytes(
2104  target_sp->GetArchitecture(), nullptr, flavor_string, *addr_ptr,
2105  data.GetBytes(), bytes_read, count, data_from_file));
2106  }
2107  }
2108 
2109  return LLDB_RECORD_RESULT(sb_instructions);
2110 }
2111 
2113  const void *buf,
2114  size_t size) {
2116  (lldb::SBAddress, const void *, size_t), base_addr, buf,
2117  size);
2118 
2119  return LLDB_RECORD_RESULT(
2120  GetInstructionsWithFlavor(base_addr, nullptr, buf, size));
2121 }
2122 
2125  const char *flavor_string, const void *buf,
2126  size_t size) {
2129  (lldb::SBAddress, const char *, const void *, size_t),
2130  base_addr, flavor_string, buf, size);
2131 
2132  SBInstructionList sb_instructions;
2133 
2134  TargetSP target_sp(GetSP());
2135  if (target_sp) {
2136  Address addr;
2137 
2138  if (base_addr.get())
2139  addr = *base_addr.get();
2140 
2141  const bool data_from_file = true;
2142 
2143  sb_instructions.SetDisassembler(Disassembler::DisassembleBytes(
2144  target_sp->GetArchitecture(), nullptr, flavor_string, addr, buf, size,
2145  UINT32_MAX, data_from_file));
2146  }
2147 
2148  return LLDB_RECORD_RESULT(sb_instructions);
2149 }
2150 
2152  const void *buf,
2153  size_t size) {
2155  (lldb::addr_t, const void *, size_t), base_addr, buf,
2156  size);
2157 
2159  ResolveLoadAddress(base_addr), nullptr, buf, size));
2160 }
2161 
2164  const char *flavor_string, const void *buf,
2165  size_t size) {
2168  (lldb::addr_t, const char *, const void *, size_t),
2169  base_addr, flavor_string, buf, size);
2170 
2172  ResolveLoadAddress(base_addr), flavor_string, buf, size));
2173 }
2174 
2176  lldb::addr_t section_base_addr) {
2178  (lldb::SBSection, lldb::addr_t), section,
2179  section_base_addr);
2180 
2181  SBError sb_error;
2182  TargetSP target_sp(GetSP());
2183  if (target_sp) {
2184  if (!section.IsValid()) {
2185  sb_error.SetErrorStringWithFormat("invalid section");
2186  } else {
2187  SectionSP section_sp(section.GetSP());
2188  if (section_sp) {
2189  if (section_sp->IsThreadSpecific()) {
2190  sb_error.SetErrorString(
2191  "thread specific sections are not yet supported");
2192  } else {
2193  ProcessSP process_sp(target_sp->GetProcessSP());
2194  if (target_sp->SetSectionLoadAddress(section_sp, section_base_addr)) {
2195  ModuleSP module_sp(section_sp->GetModule());
2196  if (module_sp) {
2197  ModuleList module_list;
2198  module_list.Append(module_sp);
2199  target_sp->ModulesDidLoad(module_list);
2200  }
2201  // Flush info in the process (stack frames, etc)
2202  if (process_sp)
2203  process_sp->Flush();
2204  }
2205  }
2206  }
2207  }
2208  } else {
2209  sb_error.SetErrorString("invalid target");
2210  }
2211  return LLDB_RECORD_RESULT(sb_error);
2212 }
2213 
2216  (lldb::SBSection), section);
2217 
2218  SBError sb_error;
2219 
2220  TargetSP target_sp(GetSP());
2221  if (target_sp) {
2222  if (!section.IsValid()) {
2223  sb_error.SetErrorStringWithFormat("invalid section");
2224  } else {
2225  SectionSP section_sp(section.GetSP());
2226  if (section_sp) {
2227  ProcessSP process_sp(target_sp->GetProcessSP());
2228  if (target_sp->SetSectionUnloaded(section_sp)) {
2229  ModuleSP module_sp(section_sp->GetModule());
2230  if (module_sp) {
2231  ModuleList module_list;
2232  module_list.Append(module_sp);
2233  target_sp->ModulesDidUnload(module_list, false);
2234  }
2235  // Flush info in the process (stack frames, etc)
2236  if (process_sp)
2237  process_sp->Flush();
2238  }
2239  } else {
2240  sb_error.SetErrorStringWithFormat("invalid section");
2241  }
2242  }
2243  } else {
2244  sb_error.SetErrorStringWithFormat("invalid target");
2245  }
2246  return LLDB_RECORD_RESULT(sb_error);
2247 }
2248 
2250  int64_t slide_offset) {
2252  (lldb::SBModule, int64_t), module, slide_offset);
2253 
2254  SBError sb_error;
2255 
2256  TargetSP target_sp(GetSP());
2257  if (target_sp) {
2258  ModuleSP module_sp(module.GetSP());
2259  if (module_sp) {
2260  bool changed = false;
2261  if (module_sp->SetLoadAddress(*target_sp, slide_offset, true, changed)) {
2262  // The load was successful, make sure that at least some sections
2263  // changed before we notify that our module was loaded.
2264  if (changed) {
2265  ModuleList module_list;
2266  module_list.Append(module_sp);
2267  target_sp->ModulesDidLoad(module_list);
2268  // Flush info in the process (stack frames, etc)
2269  ProcessSP process_sp(target_sp->GetProcessSP());
2270  if (process_sp)
2271  process_sp->Flush();
2272  }
2273  }
2274  } else {
2275  sb_error.SetErrorStringWithFormat("invalid module");
2276  }
2277 
2278  } else {
2279  sb_error.SetErrorStringWithFormat("invalid target");
2280  }
2281  return LLDB_RECORD_RESULT(sb_error);
2282 }
2283 
2286  (lldb::SBModule), module);
2287 
2288  SBError sb_error;
2289 
2290  char path[PATH_MAX];
2291  TargetSP target_sp(GetSP());
2292  if (target_sp) {
2293  ModuleSP module_sp(module.GetSP());
2294  if (module_sp) {
2295  ObjectFile *objfile = module_sp->GetObjectFile();
2296  if (objfile) {
2297  SectionList *section_list = objfile->GetSectionList();
2298  if (section_list) {
2299  ProcessSP process_sp(target_sp->GetProcessSP());
2300 
2301  bool changed = false;
2302  const size_t num_sections = section_list->GetSize();
2303  for (size_t sect_idx = 0; sect_idx < num_sections; ++sect_idx) {
2304  SectionSP section_sp(section_list->GetSectionAtIndex(sect_idx));
2305  if (section_sp)
2306  changed |= target_sp->SetSectionUnloaded(section_sp);
2307  }
2308  if (changed) {
2309  ModuleList module_list;
2310  module_list.Append(module_sp);
2311  target_sp->ModulesDidUnload(module_list, false);
2312  // Flush info in the process (stack frames, etc)
2313  ProcessSP process_sp(target_sp->GetProcessSP());
2314  if (process_sp)
2315  process_sp->Flush();
2316  }
2317  } else {
2318  module_sp->GetFileSpec().GetPath(path, sizeof(path));
2319  sb_error.SetErrorStringWithFormat("no sections in object file '%s'",
2320  path);
2321  }
2322  } else {
2323  module_sp->GetFileSpec().GetPath(path, sizeof(path));
2324  sb_error.SetErrorStringWithFormat("no object file for module '%s'",
2325  path);
2326  }
2327  } else {
2328  sb_error.SetErrorStringWithFormat("invalid module");
2329  }
2330  } else {
2331  sb_error.SetErrorStringWithFormat("invalid target");
2332  }
2333  return LLDB_RECORD_RESULT(sb_error);
2334 }
2335 
2337  lldb::SymbolType symbol_type) {
2339  (const char *, lldb::SymbolType), name, symbol_type);
2340 
2341  SBSymbolContextList sb_sc_list;
2342  if (name && name[0]) {
2343  TargetSP target_sp(GetSP());
2344  if (target_sp)
2345  target_sp->GetImages().FindSymbolsWithNameAndType(
2346  ConstString(name), symbol_type, *sb_sc_list);
2347  }
2348  return LLDB_RECORD_RESULT(sb_sc_list);
2349 }
2350 
2353  (const char *), expr);
2354 
2355  TargetSP target_sp(GetSP());
2356  if (!target_sp)
2357  return LLDB_RECORD_RESULT(SBValue());
2358 
2359  SBExpressionOptions options;
2360  lldb::DynamicValueType fetch_dynamic_value =
2361  target_sp->GetPreferDynamicValue();
2362  options.SetFetchDynamicValue(fetch_dynamic_value);
2363  options.SetUnwindOnError(true);
2364  return LLDB_RECORD_RESULT(EvaluateExpression(expr, options));
2365 }
2366 
2368  const SBExpressionOptions &options) {
2370  (const char *, const lldb::SBExpressionOptions &), expr,
2371  options);
2372 
2374  SBValue expr_result;
2375  ValueObjectSP expr_value_sp;
2376  TargetSP target_sp(GetSP());
2377  StackFrame *frame = nullptr;
2378  if (target_sp) {
2379  if (expr == nullptr || expr[0] == '\0') {
2380  return LLDB_RECORD_RESULT(expr_result);
2381  }
2382 
2383  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
2384  ExecutionContext exe_ctx(m_opaque_sp.get());
2385 
2386 
2387  frame = exe_ctx.GetFramePtr();
2388  Target *target = exe_ctx.GetTargetPtr();
2389 
2390  if (target) {
2391  target->EvaluateExpression(expr, frame, expr_value_sp, options.ref());
2392 
2393  expr_result.SetSP(expr_value_sp, options.GetFetchDynamicValue());
2394  }
2395  }
2396  LLDB_LOGF(expr_log,
2397  "** [SBTarget::EvaluateExpression] Expression result is "
2398  "%s, summary %s **",
2399  expr_result.GetValue(), expr_result.GetSummary());
2400  return LLDB_RECORD_RESULT(expr_result);
2401 }
2402 
2405 
2406  TargetSP target_sp(GetSP());
2407  if (target_sp) {
2408  ABISP abi_sp;
2409  ProcessSP process_sp(target_sp->GetProcessSP());
2410  if (process_sp)
2411  abi_sp = process_sp->GetABI();
2412  else
2413  abi_sp = ABI::FindPlugin(ProcessSP(), target_sp->GetArchitecture());
2414  if (abi_sp)
2415  return abi_sp->GetRedZoneSize();
2416  }
2417  return 0;
2418 }
2419 
2420 bool SBTarget::IsLoaded(const SBModule &module) const {
2422  module);
2423 
2424  TargetSP target_sp(GetSP());
2425  if (!target_sp)
2426  return false;
2427 
2428  ModuleSP module_sp(module.GetSP());
2429  if (!module_sp)
2430  return false;
2431 
2432  return module_sp->IsLoadedInTarget(target_sp.get());
2433 }
2434 
2437 
2438  lldb::SBLaunchInfo launch_info(nullptr);
2439  TargetSP target_sp(GetSP());
2440  if (target_sp)
2441  launch_info.set_ref(m_opaque_sp->GetProcessLaunchInfo());
2442  return LLDB_RECORD_RESULT(launch_info);
2443 }
2444 
2447  (const lldb::SBLaunchInfo &), launch_info);
2448 
2449  TargetSP target_sp(GetSP());
2450  if (target_sp)
2451  m_opaque_sp->SetProcessLaunchInfo(launch_info.ref());
2452 }
2453 
2456  TargetSP target_sp(GetSP());
2457 
2458  if (target_sp) {
2459  return LLDB_RECORD_RESULT(SBEnvironment(target_sp->GetEnvironment()));
2460  }
2461 
2463 }
2464 
2467  TargetSP target_sp(GetSP());
2468 
2469  if (target_sp)
2470  return LLDB_RECORD_RESULT(SBTrace(target_sp->GetTrace()));
2471 
2472  return LLDB_RECORD_RESULT(SBTrace());
2473 }
2474 
2477  error);
2478  TargetSP target_sp(GetSP());
2479  error.Clear();
2480 
2481  if (target_sp) {
2482  if (llvm::Expected<lldb::TraceSP> trace_sp = target_sp->CreateTrace()) {
2483  return LLDB_RECORD_RESULT(SBTrace(*trace_sp));
2484  } else {
2485  error.SetErrorString(llvm::toString(trace_sp.takeError()).c_str());
2486  }
2487  } else {
2488  error.SetErrorString("missing target");
2489  }
2490  return LLDB_RECORD_RESULT(SBTrace());
2491 }
2492 
2493 namespace lldb_private {
2494 namespace repro {
2495 
2496 template <>
2500  LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &));
2502  SBTarget, operator=,(const lldb::SBTarget &));
2503  LLDB_REGISTER_STATIC_METHOD(bool, SBTarget, EventIsTargetEvent,
2504  (const lldb::SBEvent &));
2506  (const lldb::SBEvent &));
2507  LLDB_REGISTER_STATIC_METHOD(uint32_t, SBTarget, GetNumModulesFromEvent,
2508  (const lldb::SBEvent &));
2510  GetModuleAtIndexFromEvent,
2511  (const uint32_t, const lldb::SBEvent &));
2512  LLDB_REGISTER_STATIC_METHOD(const char *, SBTarget, GetBroadcasterClassName,
2513  ());
2514  LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsValid, ());
2515  LLDB_REGISTER_METHOD_CONST(bool, SBTarget, operator bool, ());
2516  LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, GetProcess, ());
2517  LLDB_REGISTER_METHOD(lldb::SBPlatform, SBTarget, GetPlatform, ());
2520  LLDB_REGISTER_METHOD(void, SBTarget, SetCollectingStats, (bool));
2521  LLDB_REGISTER_METHOD(bool, SBTarget, GetCollectingStats, ());
2522  LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, LoadCore, (const char *));
2524  (const char *, lldb::SBError &));
2526  (const char **, const char **, const char *));
2529  (lldb::SBListener &, const char **, const char **,
2530  const char *, const char *, const char *,
2531  const char *, uint32_t, bool, lldb::SBError &));
2536  LLDB_REGISTER_METHOD(lldb::SBProcess, SBTarget, AttachToProcessWithID,
2539  lldb::SBProcess, SBTarget, AttachToProcessWithName,
2540  (lldb::SBListener &, const char *, bool, lldb::SBError &));
2542  lldb::SBProcess, SBTarget, ConnectRemote,
2543  (lldb::SBListener &, const char *, const char *, lldb::SBError &));
2544  LLDB_REGISTER_METHOD(lldb::SBFileSpec, SBTarget, GetExecutable, ());
2546  SBTarget, operator==,(const lldb::SBTarget &));
2548  SBTarget, operator!=,(const lldb::SBTarget &));
2549  LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveLoadAddress,
2550  (lldb::addr_t));
2551  LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolveFileAddress,
2552  (lldb::addr_t));
2553  LLDB_REGISTER_METHOD(lldb::SBAddress, SBTarget, ResolvePastLoadAddress,
2554  (uint32_t, lldb::addr_t));
2556  ResolveSymbolContextForAddress,
2557  (const lldb::SBAddress &, uint32_t));
2559  BreakpointCreateByLocation, (const char *, uint32_t));
2561  BreakpointCreateByLocation,
2562  (const lldb::SBFileSpec &, uint32_t));
2564  BreakpointCreateByLocation,
2565  (const lldb::SBFileSpec &, uint32_t, lldb::addr_t));
2567  BreakpointCreateByLocation,
2571  BreakpointCreateByLocation,
2572  (const lldb::SBFileSpec &, uint32_t, uint32_t,
2574  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
2575  (const lldb::SBFileSpec &, uint32_t, uint32_t,
2577  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
2578  (const char *, const char *));
2579  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
2580  (const char *, const lldb::SBFileSpecList &,
2581  const lldb::SBFileSpecList &));
2582  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
2583  (const char *, uint32_t, const lldb::SBFileSpecList &,
2584  const lldb::SBFileSpecList &));
2585  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
2586  (const char *, uint32_t, lldb::LanguageType,
2587  const lldb::SBFileSpecList &,
2588  const lldb::SBFileSpecList &));
2589  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
2590  (const char **, uint32_t, uint32_t,
2591  const lldb::SBFileSpecList &,
2592  const lldb::SBFileSpecList &));
2593  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
2594  (const char **, uint32_t, uint32_t, lldb::LanguageType,
2595  const lldb::SBFileSpecList &,
2596  const lldb::SBFileSpecList &));
2597  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByNames,
2598  (const char **, uint32_t, uint32_t, lldb::LanguageType,
2600  const lldb::SBFileSpecList &));
2601  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
2602  (const char *, const char *));
2603  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
2604  (const char *, const lldb::SBFileSpecList &,
2605  const lldb::SBFileSpecList &));
2606  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByRegex,
2607  (const char *, lldb::LanguageType,
2608  const lldb::SBFileSpecList &,
2609  const lldb::SBFileSpecList &));
2611  BreakpointCreateByAddress, (lldb::addr_t));
2613  BreakpointCreateBySBAddress, (lldb::SBAddress &));
2615  lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex,
2616  (const char *, const lldb::SBFileSpec &, const char *));
2618  BreakpointCreateBySourceRegex,
2619  (const char *, const lldb::SBFileSpecList &,
2620  const lldb::SBFileSpecList &));
2622  lldb::SBBreakpoint, SBTarget, BreakpointCreateBySourceRegex,
2623  (const char *, const lldb::SBFileSpecList &,
2624  const lldb::SBFileSpecList &, const lldb::SBStringList &));
2626  BreakpointCreateForException,
2627  (lldb::LanguageType, bool, bool));
2629  lldb::SBBreakpoint, SBTarget, BreakpointCreateFromScript,
2630  (const char *, lldb::SBStructuredData &, const lldb::SBFileSpecList &,
2631  const lldb::SBFileSpecList &, bool));
2632  LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumBreakpoints, ());
2634  GetBreakpointAtIndex, (uint32_t));
2635  LLDB_REGISTER_METHOD(bool, SBTarget, BreakpointDelete, (lldb::break_id_t));
2636  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, FindBreakpointByID,
2637  (lldb::break_id_t));
2638  LLDB_REGISTER_METHOD(bool, SBTarget, FindBreakpointsByName,
2639  (const char *, lldb::SBBreakpointList &));
2640  LLDB_REGISTER_METHOD(void, SBTarget, GetBreakpointNames,
2641  (lldb::SBStringList &));
2642  LLDB_REGISTER_METHOD(void, SBTarget, DeleteBreakpointName, (const char *));
2643  LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllBreakpoints, ());
2644  LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllBreakpoints, ());
2645  LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllBreakpoints, ());
2646  LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsCreateFromFile,
2649  lldb::SBError, SBTarget, BreakpointsCreateFromFile,
2651  LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
2652  (lldb::SBFileSpec &));
2653  LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, BreakpointsWriteToFile,
2655  LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumWatchpoints, ());
2657  GetWatchpointAtIndex, (uint32_t));
2658  LLDB_REGISTER_METHOD(bool, SBTarget, DeleteWatchpoint, (lldb::watch_id_t));
2659  LLDB_REGISTER_METHOD(lldb::SBWatchpoint, SBTarget, FindWatchpointByID,
2660  (lldb::watch_id_t));
2662  (lldb::addr_t, size_t, bool, bool, lldb::SBError &));
2663  LLDB_REGISTER_METHOD(bool, SBTarget, EnableAllWatchpoints, ());
2664  LLDB_REGISTER_METHOD(bool, SBTarget, DisableAllWatchpoints, ());
2665  LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromAddress,
2666  (const char *, lldb::SBAddress, lldb::SBType));
2667  LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromData,
2668  (const char *, lldb::SBData, lldb::SBType));
2669  LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, CreateValueFromExpression,
2670  (const char *, const char *));
2671  LLDB_REGISTER_METHOD(bool, SBTarget, DeleteAllWatchpoints, ());
2672  LLDB_REGISTER_METHOD(void, SBTarget, AppendImageSearchPath,
2673  (const char *, const char *, lldb::SBError &));
2675  (const char *, const char *, const char *));
2677  lldb::SBModule, SBTarget, AddModule,
2678  (const char *, const char *, const char *, const char *));
2680  (const lldb::SBModuleSpec &));
2681  LLDB_REGISTER_METHOD(bool, SBTarget, AddModule, (lldb::SBModule &));
2682  LLDB_REGISTER_METHOD_CONST(uint32_t, SBTarget, GetNumModules, ());
2683  LLDB_REGISTER_METHOD(void, SBTarget, Clear, ());
2685  (const lldb::SBFileSpec &));
2687  (const lldb::SBFileSpec &));
2688  LLDB_REGISTER_METHOD(lldb::ByteOrder, SBTarget, GetByteOrder, ());
2689  LLDB_REGISTER_METHOD(const char *, SBTarget, GetTriple, ());
2690  LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetDataByteSize, ());
2691  LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetCodeByteSize, ());
2692  LLDB_REGISTER_METHOD(uint32_t, SBTarget, GetAddressByteSize, ());
2693  LLDB_REGISTER_METHOD(lldb::SBModule, SBTarget, GetModuleAtIndex,
2694  (uint32_t));
2695  LLDB_REGISTER_METHOD(bool, SBTarget, RemoveModule, (lldb::SBModule));
2697  ());
2698  LLDB_REGISTER_METHOD(bool, SBTarget, GetDescription,
2701  (const char *, uint32_t));
2703  FindGlobalFunctions,
2704  (const char *, uint32_t, lldb::MatchType));
2705  LLDB_REGISTER_METHOD(lldb::SBType, SBTarget, FindFirstType, (const char *));
2707  (lldb::BasicType));
2708  LLDB_REGISTER_METHOD(lldb::SBTypeList, SBTarget, FindTypes, (const char *));
2709  LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
2710  (const char *, uint32_t));
2711  LLDB_REGISTER_METHOD(lldb::SBValueList, SBTarget, FindGlobalVariables,
2712  (const char *, uint32_t, lldb::MatchType));
2713  LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, FindFirstGlobalVariable,
2714  (const char *));
2715  LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBTarget, GetSourceManager, ());
2719  (lldb::SBAddress, uint32_t, const char *));
2720  LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetSectionLoadAddress,
2722  LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearSectionLoadAddress,
2723  (lldb::SBSection));
2724  LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, SetModuleLoadAddress,
2725  (lldb::SBModule, int64_t));
2726  LLDB_REGISTER_METHOD(lldb::SBError, SBTarget, ClearModuleLoadAddress,
2727  (lldb::SBModule));
2729  (const char *, lldb::SymbolType));
2730  LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
2731  (const char *));
2732  LLDB_REGISTER_METHOD(lldb::SBValue, SBTarget, EvaluateExpression,
2733  (const char *, const lldb::SBExpressionOptions &));
2734  LLDB_REGISTER_METHOD(lldb::addr_t, SBTarget, GetStackRedZoneSize, ());
2735  LLDB_REGISTER_METHOD_CONST(bool, SBTarget, IsLoaded,
2736  (const lldb::SBModule &));
2738  LLDB_REGISTER_METHOD(void, SBTarget, SetLaunchInfo,
2739  (const lldb::SBLaunchInfo &));
2741  size_t, SBTarget, ReadMemory,
2742  (const lldb::SBAddress, void *, size_t, lldb::SBError &));
2744  (lldb::SBAddress, const void *, size_t));
2746  GetInstructionsWithFlavor,
2747  (lldb::SBAddress, const char *, const void *, size_t));
2749  (lldb::addr_t, const void *, size_t));
2751  GetInstructionsWithFlavor,
2752  (lldb::addr_t, const char *, const void *, size_t));
2753  LLDB_REGISTER_METHOD(lldb::SBEnvironment, SBTarget, GetEnvironment, ());
2756 }
2757 
2758 }
2759 }
lldb::SBValueList
Definition: SBValueList.h:18
LLDB_INVALID_WATCH_ID
#define LLDB_INVALID_WATCH_ID
Definition: lldb-defines.h:55
RegularExpression.h
lldb::SBTarget::GetAddressByteSize
uint32_t GetAddressByteSize()
Definition: SBTarget.cpp:1758
lldb::SBStringList
Definition: SBStringList.h:16
lldb_private::ProcessInfo::GetArguments
Args & GetArguments()
Definition: ProcessInfo.h:75
lldb_private::ProcessInstanceInfo
Definition: ProcessInfo.h:108
lldb::SBTarget::BreakpointCreateByName
lldb::SBBreakpoint BreakpointCreateByName(const char *symbol_name, const char *module_name=nullptr)
Definition: SBTarget.cpp:822
lldb::SBLaunchInfo
Definition: SBLaunchInfo.h:23
LLDB_RECORD_STATIC_METHOD_NO_ARGS
#define LLDB_RECORD_STATIC_METHOD_NO_ARGS(Result, Class, Method)
Definition: ReproducerInstrumentation.h:174
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb::SBEvent::get
lldb_private::Event * get() const
Definition: SBEvent.cpp:139
lldb_private::DataBufferHeap::GetBytes
uint8_t * GetBytes() override
Definition: DataBufferHeap.cpp:34
lldb_private::DataBufferHeap::GetByteSize
lldb::offset_t GetByteSize() const override
Definition: DataBufferHeap.cpp:45
LLDB_WATCH_TYPE_WRITE
#define LLDB_WATCH_TYPE_WRITE
Definition: lldb-defines.h:58
lldb::SBModuleSpec
Definition: SBModuleSpec.h:17
lldb-public.h
lldb::SBStream::ref
lldb_private::Stream & ref()
Definition: SBStream.cpp:178
lldb::SBStringList::AppendString
void AppendString(const char *str)
Definition: SBStringList.cpp:62
lldb::SBTarget::GetBreakpointNames
void GetBreakpointNames(SBStringList &names)
Definition: SBTarget.cpp:1245
lldb_private::ArchSpec
Definition: ArchSpec.h:33
lldb::SBTarget::IsValid
bool IsValid() const
Definition: SBTarget.cpp:166
lldb::SBStringList::GetSize
uint32_t GetSize() const
Definition: SBStringList.cpp:102
lldb_private::RegularExpression
Definition: RegularExpression.h:18
lldb::SBTarget::Install
SBError Install()
Install any binaries that need to be installed.
Definition: SBTarget.cpp:310
lldb_private::ProcessInfo::ProcessIDIsValid
bool ProcessIDIsValid() const
Definition: ProcessInfo.h:71
lldb_private::ProcessInfo::SetExecutableFile
void SetExecutableFile(const FileSpec &exe_file, bool add_exe_file_as_first_arg)
Definition: ProcessInfo.cpp:62
lldb::SBTarget::SetLaunchInfo
void SetLaunchInfo(const lldb::SBLaunchInfo &launch_info)
Definition: SBTarget.cpp:2445
lldb::SBTarget::RemoveModule
bool RemoveModule(lldb::SBModule module)
Definition: SBTarget.cpp:1783
SBModule.h
lldb::SBTarget::DeleteWatchpoint
bool DeleteWatchpoint(lldb::watch_id_t watch_id)
Definition: SBTarget.cpp:1417
ModuleSpec.h
LLDB_WATCH_TYPE_READ
#define LLDB_WATCH_TYPE_READ
Definition: lldb-defines.h:57
lldb::SBValue::GetValue
const char * GetValue()
Definition: SBValue.cpp:356
lldb::MatchType
MatchType
String matching algorithm used by SBTarget.
Definition: lldb-enumerations.h:1032
lldb::SBModuleSpec::m_opaque_up
std::unique_ptr< lldb_private::ModuleSpec > m_opaque_up
Definition: SBModuleSpec.h:87
lldb::SBTarget::CreateTrace
lldb::SBTrace CreateTrace(SBError &error)
Create a Trace object for the current target using the using the default supported tracing technology...
Definition: SBTarget.cpp:2475
LLDB_RECORD_RESULT
#define LLDB_RECORD_RESULT(Result)
Definition: ReproducerInstrumentation.h:211
lldb::SBWatchpoint::SetSP
void SetSP(const lldb::WatchpointSP &sp)
Definition: SBWatchpoint.cpp:268
lldb::SBTarget::EvaluateExpression
lldb::SBValue EvaluateExpression(const char *expr)
Definition: SBTarget.cpp:2351
lldb::SBTarget::GetExecutable
lldb::SBFileSpec GetExecutable()
Definition: SBTarget.cpp:589
Host.h
lldb::SBExpressionOptions::GetFetchDynamicValue
lldb::DynamicValueType GetFetchDynamicValue() const
Definition: SBExpressionOptions.cpp:85
LLDB_RECORD_METHOD_CONST_NO_ARGS
#define LLDB_RECORD_METHOD_CONST_NO_ARGS(Result, Class, Method)
Definition: ReproducerInstrumentation.h:168
lldb::SBError
Definition: SBError.h:20
lldb::SBTarget::GetInstructions
lldb::SBInstructionList GetInstructions(lldb::SBAddress base_addr, const void *buf, size_t size)
Definition: SBTarget.cpp:2112
SBModuleSpec.h
lldb::eStateAttaching
@ eStateAttaching
Process is currently trying to attach.
Definition: lldb-enumerations.h:78
DeclVendor.h
lldb::SBTarget::GetEnvironment
SBEnvironment GetEnvironment()
Return the environment variables that would be used to launch a new process.
Definition: SBTarget.cpp:2454
lldb_private::ProcessLaunchInfo::SetListener
void SetListener(const lldb::ListenerSP &listener_sp)
Definition: ProcessLaunchInfo.h:130
lldb::SBTarget::ReadInstructions
lldb::SBInstructionList ReadInstructions(lldb::SBAddress base_addr, uint32_t count)
Definition: SBTarget.cpp:2072
SBStringList.h
lldb_private::SectionList::GetSize
size_t GetSize() const
Definition: Section.h:74
lldb::SBTarget::GetLaunchInfo
lldb::SBLaunchInfo GetLaunchInfo() const
Definition: SBTarget.cpp:2435
lldb::SBTarget::GetModuleAtIndexFromEvent
static lldb::SBModule GetModuleAtIndexFromEvent(const uint32_t idx, const lldb::SBEvent &event)
Definition: SBTarget.cpp:148
lldb::SBProcess::SetSP
void SetSP(const lldb::ProcessSP &process_sp)
Definition: SBProcess.cpp:108
lldb::SBTarget::BreakpointCreateByLocation
lldb::SBBreakpoint BreakpointCreateByLocation(const char *file, uint32_t line)
Definition: SBTarget.cpp:717
lldb_private::eLazyBoolYes
@ eLazyBoolYes
Definition: lldb-private-enumerations.h:115
LLDB_RECORD_METHOD_NO_ARGS
#define LLDB_RECORD_METHOD_NO_ARGS(Result, Class, Method)
Definition: ReproducerInstrumentation.h:165
lldb::SBTarget::GetCodeByteSize
uint32_t GetCodeByteSize()
Architecture code byte width accessor.
Definition: SBTarget.cpp:1748
LLDB_LOGF
#define LLDB_LOGF(log,...)
Definition: Log.h:249
lldb_private::Args::AppendArguments
void AppendArguments(const Args &rhs)
Definition: Args.cpp:293
lldb::SBTarget::GetProcess
lldb::SBProcess GetProcess()
Definition: SBTarget.cpp:176
lldb::SBValue
Definition: SBValue.h:21
Module.h
BreakpointLocation.h
lldb::SBListener::IsValid
bool IsValid() const
Definition: SBListener.cpp:53
lldb::SBTarget::GetDebugger
lldb::SBDebugger GetDebugger() const
Definition: SBTarget.cpp:203
lldb::SBBreakpointList::CopyToBreakpointIDList
void CopyToBreakpointIDList(lldb_private::BreakpointIDList &bp_id_list)
Definition: SBBreakpoint.cpp:980
lldb::SBSymbolContextList
Definition: SBSymbolContextList.h:17
lldb::SBTarget::GetBasicType
lldb::SBType GetBasicType(lldb::BasicType type)
Definition: SBTarget.cpp:1924
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
lldb_private::ProcessInfo::SetUserID
void SetUserID(uint32_t uid)
Definition: ProcessInfo.h:57
lldb_private::ProcessAttachInfo::GetListener
lldb::ListenerSP GetListener() const
Definition: Process.h:192
LLDB_RECORD_CONSTRUCTOR_NO_ARGS
#define LLDB_RECORD_CONSTRUCTOR_NO_ARGS(Class)
Definition: ReproducerInstrumentation.h:136
lldb::SBEnvironment
class LLDB_API SBEnvironment
Definition: SBDefines.h:39
lldb::SBTarget::ResolveLoadAddress
lldb::SBAddress ResolveLoadAddress(lldb::addr_t vm_addr)
Resolve a current load address into a section offset address.
Definition: SBTarget.cpp:623
lldb::SBExpressionOptions::SetUnwindOnError
void SetUnwindOnError(bool unwind=true)
Definition: SBExpressionOptions.cpp:64
lldb_private::Module
Definition: Module.h:84
lldb_private::ExecutionContext::GetFramePtr
StackFrame * GetFramePtr() const
Returns a pointer to the frame object.
Definition: ExecutionContext.h:408
lldb_private::ProcessInfo::GetProcessID
lldb::pid_t GetProcessID() const
Definition: ProcessInfo.h:67
LLDB_REGISTER_METHOD_CONST
#define LLDB_REGISTER_METHOD_CONST(Result, Class, Method, Signature)
Definition: ReproducerInstrumentation.h:98
lldb_private::SectionList
Definition: Section.h:34
lldb::SBTarget::GetNumBreakpoints
uint32_t GetNumBreakpoints() const
Definition: SBTarget.cpp:1170
lldb::SBEvent
Definition: SBEvent.h:21
StackFrame.h
Disassembler.h
lldb_private::ProcessInfo::SetProcessID
void SetProcessID(lldb::pid_t pid)
Definition: ProcessInfo.h:69
CommandObjectBreakpoint.h
lldb::SBListener::GetSP
lldb::ListenerSP GetSP()
Definition: SBListener.cpp:315
lldb::SBProcess
Definition: SBProcess.h:23
lldb_private::Stream
Definition: Stream.h:28
lldb_private::TypeList::GetTypeAtIndex
lldb::TypeSP GetTypeAtIndex(uint32_t idx)
Definition: TypeList.cpp:66
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
Language.h
lldb::SBTarget::GetTargetFromEvent
static lldb::SBTarget GetTargetFromEvent(const lldb::SBEvent &event)
Definition: SBTarget.cpp:131
SBReproducerPrivate.h
lldb::BasicType
BasicType
Basic types enumeration for the public API SBType::GetBasicType().
Definition: lldb-enumerations.h:741
lldb_private::ModuleFunctionSearchOptions::include_symbols
bool include_symbols
Include the symbol table.
Definition: Module.h:64
lldb::SBExpressionOptions::ref
lldb_private::EvaluateExpressionOptions & ref() const
Definition: SBExpressionOptions.cpp:284
lldb_private::LazyBool
LazyBool
Definition: lldb-private-enumerations.h:115
AddressResolver.h
lldb::SBSymbolContext::ref
lldb_private::SymbolContext & ref()
Definition: SBSymbolContext.cpp:192
lldb::SBStringList
class LLDB_API SBStringList
Definition: SBDefines.h:69
LLDB_REGISTER_CONSTRUCTOR
#define LLDB_REGISTER_CONSTRUCTOR(Class, Signature)
Definition: ReproducerInstrumentation.h:89
lldb_private::ProcessAttachInfo::SetListener
void SetListener(const lldb::ListenerSP &listener_sp)
Definition: Process.h:194
CommandReturnObject.h
Debugger.h
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::Target
Definition: Target.h:454
Section.h
SBSymbolContextList.h
SBListener.h
lldb::SBFileSpec::SetFileSpec
void SetFileSpec(const lldb_private::FileSpec &fspec)
Definition: SBFileSpec.cpp:170
lldb::SBTarget::BreakpointsCreateFromFile
lldb::SBError BreakpointsCreateFromFile(SBFileSpec &source_file, SBBreakpointList &new_bps)
Read breakpoints from source_file and return the newly created breakpoints in bkpt_list.
Definition: SBTarget.cpp:1309
lldb_private::ProcessInfo::UserIDIsValid
bool UserIDIsValid() const
Definition: ProcessInfo.h:53
ABI.h
lldb::SBInstructionList
Definition: SBInstructionList.h:18
lldb::SBType
class LLDB_API SBType
Definition: SBDefines.h:79
lldb_private::VariableList
Definition: VariableList.h:18
SBSourceManager.h
lldb::SBTarget::operator==
bool operator==(const lldb::SBTarget &rhs) const
Definition: SBTarget.cpp:603
lldb_private::ModuleSpec::GetSymbolFileSpec
FileSpec & GetSymbolFileSpec()
Definition: ModuleSpec.h:82
lldb::SBStructuredData::m_impl_up
StructuredDataImplUP m_impl_up
Definition: SBStructuredData.h:104
Process.h
lldb::SBTarget::CreateValueFromExpression
lldb::SBValue CreateValueFromExpression(const char *name, const char *expr)
Definition: SBTarget.cpp:1558
lldb_private::ModuleFunctionSearchOptions::include_inlines
bool include_inlines
Include inlined functions.
Definition: Module.h:66
lldb::SBTarget::GetNumModules
uint32_t GetNumModules() const
Definition: SBTarget.cpp:1670
lldb::SBPlatform::m_opaque_sp
lldb::PlatformSP m_opaque_sp
Definition: SBPlatform.h:182
SBExpressionOptions.h
lldb::SBValueList::GetValueAtIndex
lldb::SBValue GetValueAtIndex(uint32_t idx) const
Definition: SBValueList.cpp:152
lldb::SBTarget::FindFunctions
lldb::SBSymbolContextList FindFunctions(const char *name, uint32_t name_type_mask=lldb::eFunctionNameTypeAny)
Find functions by name.
Definition: SBTarget.cpp:1821
lldb::SBTarget::AttachToProcessWithID
lldb::SBProcess AttachToProcessWithID(SBListener &listener, lldb::pid_t pid, lldb::SBError &error)
Attach to process with pid.
Definition: SBTarget.cpp:494
lldb_private::Module::GetPlatformFileSpec
const FileSpec & GetPlatformFileSpec() const
Get accessor for the module platform file specification.
Definition: Module.h:490
Target.h
lldb_private::ModuleSpec::GetUUID
UUID & GetUUID()
Definition: ModuleSpec.h:104
lldb::SBTarget::FindFirstType
lldb::SBType FindFirstType(const char *type)
Definition: SBTarget.cpp:1882
lldb::SBValueList::IsValid
bool IsValid() const
Definition: SBValueList.cpp:88
lldb::SBTrace
Definition: SBTrace.h:19
lldb::eMatchTypeStartsWith
@ eMatchTypeStartsWith
Definition: lldb-enumerations.h:1032
lldb_private::Module::GetFileSpec
const FileSpec & GetFileSpec() const
Get const accessor for the module file specification.
Definition: Module.h:476
lldb::SBTarget
Definition: SBTarget.h:29
BreakpointList.h
LIBLLDB_LOG_EXPRESSIONS
#define LIBLLDB_LOG_EXPRESSIONS
Definition: Logging.h:22
lldb_private::FileSpec
Definition: FileSpec.h:56
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb::SBTarget::BreakpointCreateBySourceRegex
lldb::SBBreakpoint BreakpointCreateBySourceRegex(const char *source_regex, const SBFileSpec &source_file, const char *module_name=nullptr)
Definition: SBTarget.cpp:1055
lldb::SBStringList::GetStringAtIndex
const char * GetStringAtIndex(size_t idx)
Definition: SBStringList.cpp:111
lldb_private::ObjectFile::GetSectionList
virtual SectionList * GetSectionList(bool update_module_section_list=true)
Gets the section list for the currently selected architecture (and object for archives).
Definition: ObjectFile.cpp:583
lldb_private::ModuleList::GetSize
size_t GetSize() const
Gets the size of the module list.
Definition: ModuleList.cpp:594
lldb::SBTarget::DeleteAllBreakpoints
bool DeleteAllBreakpoints()
Definition: SBTarget.cpp:1297
SBStream.h
lldb::SBTarget::Attach
SBProcess Attach(SBAttachInfo &attach_info, SBError &error)
Definition: SBTarget.cpp:459
ProcessInfo.h
TargetList.h
lldb::SBError::Fail
bool Fail() const
Definition: SBError.cpp:54
lldb::SBLaunchInfo::SetEnvironmentEntries
void SetEnvironmentEntries(const char **envp, bool append)
Update this object with the given environment variables.
Definition: SBLaunchInfo.cpp:187
lldb::SBTarget::FindCompileUnits
lldb::SBSymbolContextList FindCompileUnits(const lldb::SBFileSpec &sb_file_spec)
Find compile units related to *this target and passed source file.
Definition: SBTarget.cpp:1703
lldb::SBError::SetErrorStringWithFormat
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Definition: SBError.cpp:131
lldb_private::ProcessInstanceInfo::GetEffectiveUserID
uint32_t GetEffectiveUserID() const
Definition: ProcessInfo.h:123
lldb::SBTarget::GetInstructionsWithFlavor
lldb::SBInstructionList GetInstructionsWithFlavor(lldb::SBAddress base_addr, const char *flavor_string, const void *buf, size_t size)
Definition: SBTarget.cpp:2124
LLDB_RECORD_METHOD
#define LLDB_RECORD_METHOD(Result, Class, Method, Signature,...)
Definition: ReproducerInstrumentation.h:158
lldb_private::breakpad::toString
llvm::StringRef toString(Record::Kind K)
Definition: BreakpadRecords.cpp:483
lldb_private::ProcessLaunchInfo
Definition: ProcessLaunchInfo.h:31
lldb::SBListener::m_opaque_sp
lldb::ListenerSP m_opaque_sp
Definition: SBListener.h:102
lldb_private::ModuleList
Definition: ModuleList.h:72
lldb::SBDebugger
Definition: SBDebugger.h:34
lldb_private::ExecutionContextScope
Definition: ExecutionContextScope.h:32
lldb_private::Target::GetAPIMutex
std::recursive_mutex & GetAPIMutex()
Definition: Target.cpp:4471
Args.h
lldb::SBTarget::SBModule
friend class SBModule
Definition: SBTarget.h:867
lldb::SBAddress::GetLoadAddress
addr_t GetLoadAddress(const lldb::SBTarget &target) const
Definition: SBAddress.cpp:112
lldb::SBTarget::ResolveFileAddress
lldb::SBAddress ResolveFileAddress(lldb::addr_t file_addr)
Resolve a current file address into a section offset address.
Definition: SBTarget.cpp:642
SearchFilter.h
lldb::SBTarget::operator!=
bool operator!=(const lldb::SBTarget &rhs) const
Definition: SBTarget.cpp:610
lldb::SBTarget::GetWatchpointAtIndex
lldb::SBWatchpoint GetWatchpointAtIndex(uint32_t idx) const
Definition: SBTarget.cpp:1404
lldb::SBTarget::BreakpointCreateByAddress
lldb::SBBreakpoint BreakpointCreateByAddress(addr_t address)
Definition: SBTarget.cpp:1020
lldb::SBTarget::GetNumWatchpoints
uint32_t GetNumWatchpoints() const
Definition: SBTarget.cpp:1393
lldb::eStateConnected
@ eStateConnected
Process is connected to remote debug services, but not launched or attached to anything yet.
Definition: lldb-enumerations.h:76
SBFileSpec.h
lldb::SBModule::SetSP
void SetSP(const ModuleSP &module_sp)
Definition: SBModule.cpp:208
lldb_private::StructuredData::ObjectSP
std::shared_ptr< Object > ObjectSP
Definition: StructuredData.h:59
lldb::SBStringList::Clear
void Clear()
Definition: SBStringList.cpp:131
lldb::SBTarget::BreakpointsWriteToFile
lldb::SBError BreakpointsWriteToFile(SBFileSpec &dest_file)
Write breakpoints to dest_file.
Definition: SBTarget.cpp:1357
lldb_private::TypeList::GetSize
uint32_t GetSize() const
Definition: TypeList.cpp:60
lldb::break_id_t
int32_t break_id_t
Definition: lldb-types.h:88
lldb::SBTarget::DisableAllWatchpoints
bool DisableAllWatchpoints()
Definition: SBTarget.cpp:1504
lldb_private::ConstString
Definition: ConstString.h:40
lldb::SBTarget::SetCollectingStats
void SetCollectingStats(bool v)
Sets whether we should collect statistics on lldb or not.
Definition: SBTarget.cpp:234
lldb::SBError::SetErrorString
void SetErrorString(const char *err_str)
Definition: SBError.cpp:124
lldb::SBTarget::DisableAllBreakpoints
bool DisableAllBreakpoints()
Definition: SBTarget.cpp:1285
lldb::SBTarget::BreakpointCreateByNames
lldb::SBBreakpoint BreakpointCreateByNames(const char *symbol_name[], uint32_t num_names, uint32_t name_type_mask, const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list)
Definition: SBTarget.cpp:907
lldb::SBTarget::SBValue
friend class SBValue
Definition: SBTarget.h:873
lldb_private::BreakpointID::GetBreakpointID
lldb::break_id_t GetBreakpointID() const
Definition: BreakpointID.h:29
lldb::SBTarget::AddModule
bool AddModule(lldb::SBModule &module)
Definition: SBTarget.cpp:1659
lldb::eMatchTypeNormal
@ eMatchTypeNormal
Definition: lldb-enumerations.h:1032
lldb::SBTarget::AttachToProcessWithName
lldb::SBProcess AttachToProcessWithName(SBListener &listener, const char *name, bool wait_for, lldb::SBError &error)
Attach to process with name.
Definition: SBTarget.cpp:525
lldb::SBValueList::Append
void Append(const lldb::SBValue &val_obj)
Definition: SBValueList.cpp:127
lldb::SBTarget::ClearSectionLoadAddress
lldb::SBError ClearSectionLoadAddress(lldb::SBSection section)
Clear the base load address for a module section.
Definition: SBTarget.cpp:2214
lldb::SBFileSpec::ref
const lldb_private::FileSpec & ref() const
Definition: SBFileSpec.cpp:168
lldb::SBFileSpec::IsValid
bool IsValid() const
Definition: SBFileSpec.cpp:79
lldb::SBAddress::IsValid
bool IsValid() const
Definition: SBAddress.cpp:76
lldb::SBTarget::EnableAllWatchpoints
bool EnableAllWatchpoints()
Definition: SBTarget.cpp:1490
lldb_private::GetLogIfAllCategoriesSet
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:58
lldb::SBTarget::GetBroadcasterClassName
static const char * GetBroadcasterClassName()
Definition: SBTarget.cpp:159
lldb_private::SectionList::GetSectionAtIndex
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition: Section.cpp:476
lldb::SBEnvironment
Definition: SBEnvironment.h:16
SBDebugger.h
lldb::SBSection
Definition: SBSection.h:17
lldb_private::StatisticKind
StatisticKind
Definition: lldb-private-enumerations.h:217
lldb::SBTarget::FindBreakpointByID
lldb::SBBreakpoint FindBreakpointByID(break_id_t break_id)
Definition: SBTarget.cpp:1208
lldb::DynamicValueType
DynamicValueType
Definition: lldb-enumerations.h:494
lldb::SBTarget::BreakpointCreateByRegex
lldb::SBBreakpoint BreakpointCreateByRegex(const char *symbol_name_regex, const char *module_name=nullptr)
Definition: SBTarget.cpp:964
LLDB_REGISTER_STATIC_METHOD
#define LLDB_REGISTER_STATIC_METHOD(Result, Class, Method, Signature)
Definition: ReproducerInstrumentation.h:103
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:39
lldb::watch_id_t
int32_t watch_id_t
Definition: lldb-types.h:89
lldb::SBDebugger::reset
void reset(const lldb::DebuggerSP &debugger_sp)
Definition: SBDebugger.cpp:1275
lldb::SBTarget::Clear
void Clear()
Definition: SBTarget.cpp:1683
lldb::SBAttachInfo::ref
lldb_private::ProcessAttachInfo & ref()
Definition: SBAttachInfo.cpp:59
lldb_private::ArchSpec::IsValid
bool IsValid() const
Tests if this ArchSpec is valid.
Definition: ArchSpec.h:342
lldb::SBBreakpoint
class LLDB_API SBBreakpoint
Definition: SBDefines.h:23
TypeSystem.h
lldb::SBTarget::FindModule
lldb::SBModule FindModule(const lldb::SBFileSpec &file_spec)
Definition: SBTarget.cpp:1689
lldb::SymbolType
SymbolType
Symbol types.
Definition: lldb-enumerations.h:612
Address.h
VariableList.h
lldb::SBBreakpointList
Definition: SBBreakpoint.h:159
lldb_private::ProcessAttachInfo
Definition: Process.h:115
ObjectFile.h
lldb::SBType
Definition: SBType.h:104
lldb_private::ModuleFunctionSearchOptions
Options used by Module::FindFunctions.
Definition: Module.h:62
lldb_private::Address::SetRawAddress
void SetRawAddress(lldb::addr_t addr)
Definition: Address.h:435
lldb::SBTarget::GetTrace
lldb::SBTrace GetTrace()
Get a SBTrace object the can manage the processor trace information of this target.
Definition: SBTarget.cpp:2465
lldb::SBTarget::ReadMemory
size_t ReadMemory(const SBAddress addr, void *buf, size_t size, lldb::SBError &error)
Read target memory.
Definition: SBTarget.cpp:697
lldb::SBTypeList::GetSize
uint32_t GetSize()
Definition: SBType.cpp:644
LLDB_INVALID_BREAK_ID
#define LLDB_INVALID_BREAK_ID
Definition: lldb-defines.h:49
lldb::SBFileSpecList::get
const lldb_private::FileSpecList * get() const
Definition: SBFileSpecList.cpp:95
lldb::SBTarget::SetSectionLoadAddress
lldb::SBError SetSectionLoadAddress(lldb::SBSection section, lldb::addr_t section_base_addr)
Set the base load address for a module section.
Definition: SBTarget.cpp:2175
ValueObjectConstResult.h
lldb::SBExpressionOptions::SetFetchDynamicValue
void SetFetchDynamicValue(lldb::DynamicValueType dynamic=lldb::eDynamicCanRunTarget)
Definition: SBExpressionOptions.cpp:92
lldb::SBTarget::FindWatchpointByID
lldb::SBWatchpoint FindWatchpointByID(lldb::watch_id_t watch_id)
Definition: SBTarget.cpp:1434
lldb::SBTypeList
Definition: SBType.h:241
lldb_private::GetStatDescription
std::string GetStatDescription(lldb_private::StatisticKind K)
Definition: lldb-private-enumerations.h:226
lldb::SBWatchpoint
Definition: SBWatchpoint.h:16
LLDB_RECORD_CONSTRUCTOR
#define LLDB_RECORD_CONSTRUCTOR(Class, Signature,...)
Definition: ReproducerInstrumentation.h:133
lldb::SBTarget::GetDataByteSize
uint32_t GetDataByteSize()
Architecture data byte width accessor.
Definition: SBTarget.cpp:1738
lldb::SBLaunchInfo::SetExecutableFile
void SetExecutableFile(SBFileSpec exe_file, bool add_as_first_arg)
Set the executable file that will be used to launch the process and optionally set it as the first ar...
Definition: SBLaunchInfo.cpp:123
lldb::SBTarget::GetCollectingStats
bool GetCollectingStats()
Returns whether statistics collection are enabled.
Definition: SBTarget.cpp:243
lldb_private::repro::Registry
The registry contains a unique mapping between functions and their ID.
Definition: ReproducerInstrumentation.h:517
lldb_private::Target::Attach
Status Attach(ProcessAttachInfo &attach_info, Stream *stream)
Definition: Target.cpp:3121
lldb::SBTarget::ClearModuleLoadAddress
lldb::SBError ClearModuleLoadAddress(lldb::SBModule module)
Clear the section base load addresses for all sections in a module.
Definition: SBTarget.cpp:2284
lldb_private::Target::GetProcessSP
const lldb::ProcessSP & GetProcessSP() const
Definition: Target.cpp:214
lldb::SBTarget::GetTriple
const char * GetTriple()
Definition: SBTarget.cpp:1723
lldb::SBFileSpecList::GetSize
uint32_t GetSize() const
Definition: SBFileSpecList.cpp:47
lldb::SBTarget::GetBroadcaster
lldb::SBBroadcaster GetBroadcaster() const
Definition: SBTarget.cpp:1792
lldb::SBExpressionOptions
Definition: SBExpressionOptions.h:18
lldb_private::ModuleSpec::GetFileSpec
FileSpec & GetFileSpec()
Definition: ModuleSpec.h:58
lldb_private::ModuleSpec
Definition: ModuleSpec.h:26
lldb::SBTarget::SBProcess
friend class SBProcess
Definition: SBTarget.h:869
lldb_private::Status
Definition: Status.h:44
lldb::SBListener
Definition: SBListener.h:16
lldb::SBSymbolContext
Definition: SBSymbolContext.h:22
lldb::SBTarget::GetNumModulesFromEvent
static uint32_t GetNumModulesFromEvent(const lldb::SBEvent &event)
Definition: SBTarget.cpp:139
lldb::SBTarget::SetModuleLoadAddress
lldb::SBError SetModuleLoadAddress(lldb::SBModule module, int64_t sections_offset)
Slide all file addresses for all module sections so that module appears to loaded at these slide addr...
Definition: SBTarget.cpp:2249
lldb::SBTarget::LaunchSimple
SBProcess LaunchSimple(const char **argv, const char **envp, const char *working_directory)
Launch a new process with sensible defaults.
Definition: SBTarget.cpp:284
lldb::SBTarget::GetPlatform
lldb::SBPlatform GetPlatform()
Return the platform object associated with the target.
Definition: SBTarget.cpp:190
lldb::SBTarget::DeleteAllWatchpoints
bool DeleteAllWatchpoints()
Definition: SBTarget.cpp:1575
lldb_private::repro::RegisterMethods< SBTarget >
void RegisterMethods< SBTarget >(Registry &R)
Definition: SBTarget.cpp:2497
lldb::eByteOrderInvalid
@ eByteOrderInvalid
Definition: lldb-enumerations.h:139
lldb::eLanguageTypeUnknown
@ eLanguageTypeUnknown
Unknown or invalid language value.
Definition: lldb-enumerations.h:437
lldb::SBLaunchInfo::ref
const lldb_private::ProcessLaunchInfo & ref() const
Definition: SBLaunchInfo.cpp:67
BreakpointIDList.h
uint32_t
lldb::SBTarget::operator=
const lldb::SBTarget & operator=(const lldb::SBTarget &rhs)
Definition: SBTarget.cpp:112
lldb::SBTarget::FindSymbols
lldb::SBSymbolContextList FindSymbols(const char *name, lldb::SymbolType type=eSymbolTypeAny)
Definition: SBTarget.cpp:2336
lldb_private::eLazyBoolNo
@ eLazyBoolNo
Definition: lldb-private-enumerations.h:115
LIBLLDB_LOG_BREAKPOINTS
#define LIBLLDB_LOG_BREAKPOINTS
Definition: Logging.h:19
lldb_private::ProcessInfo::GetEnvironment
Environment & GetEnvironment()
Definition: ProcessInfo.h:87
lldb::SBTarget::SBPlatform
friend class SBPlatform
Definition: SBTarget.h:868
lldb::SBTarget::m_opaque_sp
lldb::TargetSP m_opaque_sp
Definition: SBTarget.h:884
lldb_private::Address
Definition: Address.h:59
lldb::SBStructuredData
Definition: SBStructuredData.h:17
lldb::SBBreakpoint
Definition: SBBreakpoint.h:18
lldb_private::Target::EvaluateExpression
lldb::ExpressionResults EvaluateExpression(llvm::StringRef expression, ExecutionContextScope *exe_scope, lldb::ValueObjectSP &result_valobj_sp, const EvaluateExpressionOptions &options=EvaluateExpressionOptions(), std::string *fixed_expression=nullptr, ValueObject *ctx_obj=nullptr)
Definition: Target.cpp:2393
lldb::SBValue::GetSummary
const char * GetSummary()
Definition: SBValue.cpp:423
lldb::pid_t
uint64_t pid_t
Definition: lldb-types.h:85
lldb::SBTarget::GetModuleAtIndex
lldb::SBModule GetModuleAtIndex(uint32_t idx)
Definition: SBTarget.cpp:1767
lldb_private::UUID::SetFromStringRef
bool SetFromStringRef(llvm::StringRef str)
Definition: UUID.cpp:96
lldb_private::BreakpointID
Definition: BreakpointID.h:22
lldb::SBTarget::Launch
lldb::SBProcess Launch(SBListener &listener, char const **argv, char const **envp, const char *stdin_path, const char *stdout_path, const char *stderr_path, const char *working_directory, uint32_t launch_flags, bool stop_at_entry, lldb::SBError &error)
Launch a new process.
Definition: SBTarget.cpp:322
lldb::SBTarget::GetByteOrder
lldb::ByteOrder GetByteOrder()
Definition: SBTarget.cpp:1714
lldb::SBTarget::FindBreakpointsByName
bool FindBreakpointsByName(const char *name, SBBreakpointList &bkpt_list)
Definition: SBTarget.cpp:1222
lldb::SBTrace
class LLDB_API SBTrace
Definition: SBDefines.h:78
lldb::SBModule
Definition: SBModule.h:20
lldb::SBData
Definition: SBData.h:20
lldb::SBInstructionList::SetDisassembler
void SetDisassembler(const lldb::DisassemblerSP &opaque_sp)
Definition: SBInstructionList.cpp:117
lldb::SBBreakpointList::AppendByID
void AppendByID(lldb::break_id_t id)
Definition: SBBreakpoint.cpp:953
lldb::SBType::GetSP
lldb::TypeImplSP GetSP()
Definition: SBType.cpp:77
lldb::SBSection::GetSP
lldb::SectionSP GetSP() const
Definition: SBSection.cpp:118
lldb::SBValue::SetSP
void SetSP(const lldb::ValueObjectSP &sp)
Definition: SBValue.cpp:1098
ArchSpec.h
lldb_private::FormatEntity::Entry
Definition: FormatEntity.h:40
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:31
lldb_private::Environment
Definition: Environment.h:18
lldb::SBData::IsValid
bool IsValid()
Definition: SBData.cpp:60
lldb::SBTarget::CreateValueFromData
lldb::SBValue CreateValueFromData(const char *name, lldb::SBData data, lldb::SBType type)
Definition: SBTarget.cpp:1538
lldb::SBLaunchInfo::set_ref
void set_ref(const lldb_private::ProcessLaunchInfo &info)
Definition: SBLaunchInfo.cpp:71
lldb::SBTarget::ConnectRemote
lldb::SBProcess ConnectRemote(SBListener &listener, const char *url, const char *plugin_name, SBError &error)
Connect to a remote debug server with url.
Definition: SBTarget.cpp:554
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:86
lldb_private::ConstString::GetCString
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:216
lldb_private::ModuleSpec::GetArchitecture
ArchSpec & GetArchitecture()
Definition: ModuleSpec.h:94
lldb::SBTarget::WatchAddress
lldb::SBWatchpoint WatchAddress(lldb::addr_t addr, size_t size, bool read, bool write, SBError &error)
Definition: SBTarget.cpp:1453
SBStructuredData.h
lldb::SBTarget::SBTarget
SBTarget()
Definition: SBTarget.cpp:100
lldb::SBTarget::BreakpointCreateForException
lldb::SBBreakpoint BreakpointCreateForException(lldb::LanguageType language, bool catch_bp, bool throw_bp)
Definition: SBTarget.cpp:1122
BreakpointID.h
LLDB_LOG
#define LLDB_LOG(log,...)
The LLDB_LOG* macros defined below are the way to emit log messages.
Definition: Log.h:242
lldb::SBModule::GetSP
ModuleSP GetSP() const
Definition: SBModule.cpp:206
lldb::SBFileSpec
Definition: SBFileSpec.h:16
SBTrace.h
StructuredDataImpl.h
SBEvent.h
lldb_private::CompilerType
Generic representation of a type in a programming language.
Definition: CompilerType.h:33
lldb::SBTarget::GetStatistics
lldb::SBStructuredData GetStatistics()
Returns a dump of the collected statistics.
Definition: SBTarget.cpp:213
lldb::SBTarget::IsLoaded
bool IsLoaded(const lldb::SBModule &module) const
Definition: SBTarget.cpp:2420
lldb::SBTarget::ResolveSymbolContextForAddress
SBSymbolContext ResolveSymbolContextForAddress(const SBAddress &addr, uint32_t resolve_scope)
Definition: SBTarget.cpp:680
lldb::SBAddress
Definition: SBAddress.h:17
LanguageRuntime.h
lldb::SBTarget::SetSP
void SetSP(const lldb::TargetSP &target_sp)
Definition: SBTarget.cpp:619
SBEnvironment.h
lldb::SBTarget::AppendImageSearchPath
void AppendImageSearchPath(const char *from, const char *to, lldb::SBError &error)
Definition: SBTarget.cpp:1589
lldb::SBTarget::DeleteBreakpointName
void DeleteBreakpointName(const char *name)
Definition: SBTarget.cpp:1262
lldb::SBAddress::ref
lldb_private::Address & ref()
Definition: SBAddress.cpp:180
lldb::SBError::ref
lldb_private::Status & ref()
Definition: SBError.cpp:159
lldb_private::ProcessInfo::GetArchitecture
ArchSpec & GetArchitecture()
Definition: ProcessInfo.h:61
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb::SBTarget::FindFirstGlobalVariable
lldb::SBValue FindFirstGlobalVariable(const char *name)
Find the first global (or static) variable by name.
Definition: SBTarget.cpp:2055
lldb::SBLaunchInfo::SetArguments
void SetArguments(const char **argv, bool append)
Definition: SBLaunchInfo.cpp:157
lldb::SBTarget::BreakpointDelete
bool BreakpointDelete(break_id_t break_id)
Definition: SBTarget.cpp:1194
lldb_private::eLazyBoolCalculate
@ eLazyBoolCalculate
Definition: lldb-private-enumerations.h:115
lldb_private::VariableList::Empty
bool Empty() const
Definition: VariableList.h:68
lldb::SBTarget::EventIsTargetEvent
static bool EventIsTargetEvent(const lldb::SBEvent &event)
Definition: SBTarget.cpp:124
lldb::eMatchTypeRegex
@ eMatchTypeRegex
Definition: lldb-enumerations.h:1032
lldb::SBTarget::CreateValueFromAddress
lldb::SBValue CreateValueFromAddress(const char *name, lldb::SBAddress addr, lldb::SBType type)
Definition: SBTarget.cpp:1518
lldb_private::ProcessInfo::GetExecutableFile
FileSpec & GetExecutableFile()
Definition: ProcessInfo.h:42
lldb_private::TypeList
Definition: TypeList.h:20
lldb_private::ModuleList::GetModuleAtIndex
lldb::ModuleSP GetModuleAtIndex(size_t idx) const
Get the module shared pointer for the module at index idx.
Definition: ModuleList.cpp:353
FileSpec.h
lldb::SBLaunchInfo::SetWorkingDirectory
void SetWorkingDirectory(const char *working_dir)
Definition: SBLaunchInfo.cpp:224
lldb::eStateInvalid
@ eStateInvalid
Definition: lldb-enumerations.h:74
lldb::SBSection::IsValid
bool IsValid() const
Definition: SBSection.cpp:49
lldb::SBTarget::GetSP
lldb::TargetSP GetSP() const
Definition: SBTarget.cpp:617
lldb::SBAddress::get
lldb_private::Address * get()
Definition: SBAddress.cpp:193
lldb::SBTarget::EnableAllBreakpoints
bool EnableAllBreakpoints()
Definition: SBTarget.cpp:1273
lldb::SBTarget::GetBreakpointAtIndex
lldb::SBBreakpoint GetBreakpointAtIndex(uint32_t idx) const
Definition: SBTarget.cpp:1181
lldb_private::BreakpointIDList::GetSize
size_t GetSize() const
Definition: BreakpointIDList.cpp:28
lldb::SBBroadcaster
Definition: SBBroadcaster.h:16
lldb::SBTarget::FindTypes
lldb::SBTypeList FindTypes(const char *type)
Definition: SBTarget.cpp:1937
SBProcess.h
ValueObjectVariable.h
lldb::SBTypeList::Append
void Append(lldb::SBType type)
Definition: SBType.cpp:628
lldb_private::BreakpointIDList::GetBreakpointIDAtIndex
const BreakpointID & GetBreakpointIDAtIndex(size_t index) const
Definition: BreakpointIDList.cpp:31
LLDB_RECORD_STATIC_METHOD
#define LLDB_RECORD_STATIC_METHOD(Result, Class, Method, Signature,...)
Definition: ReproducerInstrumentation.h:171
lldb::SBTarget::FindGlobalVariables
lldb::SBValueList FindGlobalVariables(const char *name, uint32_t max_matches)
Find global and static variables by name.
Definition: SBTarget.cpp:1981
lldb::StateType
StateType
Process and Thread States.
Definition: lldb-enumerations.h:73
lldb_private::Log
Definition: Log.h:49
lldb_private::ModuleList::FindTypes
void FindTypes(Module *search_first, ConstString name, bool name_is_fully_qualified, size_t max_matches, llvm::DenseSet< SymbolFile * > &searched_symbol_files, TypeList &types) const
Find types by name.
Definition: ModuleList.cpp:526
lldb_private::Stream::PutCString
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
lldb::SBType::IsValid
bool IsValid() const
Definition: SBType.cpp:109
lldb_private::FileSpec::SetFile
void SetFile(llvm::StringRef path, Style style)
Change the file specified with a new path.
Definition: FileSpec.cpp:174
lldb::SBTarget::BreakpointCreateFromScript
lldb::SBBreakpoint BreakpointCreateFromScript(const char *class_name, SBStructuredData &extra_args, const SBFileSpecList &module_list, const SBFileSpecList &file_list, bool request_hardware=false)
Create a breakpoint using a scripted resolver.
Definition: SBTarget.cpp:1140
lldb::SBTarget::GetSourceManager
SBSourceManager GetSourceManager()
Definition: SBTarget.cpp:2065
lldb::SBStream
Definition: SBStream.h:18
lldb::SBTarget::GetStackRedZoneSize
lldb::addr_t GetStackRedZoneSize()
Definition: SBTarget.cpp:2403
lldb::SBTarget::GetDescription
bool GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level)
Definition: SBTarget.cpp:1804
LLDB_RECORD_METHOD_CONST
#define LLDB_RECORD_METHOD_CONST(Result, Class, Method, Signature,...)
Definition: ReproducerInstrumentation.h:161
SymbolVendor.h
PATH_MAX
#define PATH_MAX
Definition: windows/PosixApi.h:25
SBTarget.h
lldb::SBValueList::GetSize
uint32_t GetSize() const
Definition: SBValueList.cpp:164
lldb_private::StackFrame
Definition: StackFrame.h:40
lldb::SBTarget::~SBTarget
~SBTarget()
lldb::SBPlatform
Definition: SBPlatform.h:93
lldb_private::DataBufferHeap
Definition: DataBufferHeap.h:30
lldb::SBFileSpecList::Append
void Append(const SBFileSpec &sb_file)
Definition: SBFileSpecList.cpp:53
lldb::SBTarget::ResolvePastLoadAddress
lldb::SBAddress ResolvePastLoadAddress(uint32_t stop_id, lldb::addr_t vm_addr)
Resolve a current load address into a section offset address using the process stop ID to identify a ...
Definition: SBTarget.cpp:659
lldb::SBAttachInfo
Definition: SBAttachInfo.h:18
lldb
Definition: SBAddress.h:15
lldb::SBTarget::BreakpointCreateBySBAddress
lldb::SBBreakpoint BreakpointCreateBySBAddress(SBAddress &address)
Definition: SBTarget.cpp:1035
lldb::SBFileSpec
class LLDB_API SBFileSpec
Definition: SBDefines.h:46
ValueObjectList.h
lldb_private::ProcessAttachInfo::SetWaitForLaunch
void SetWaitForLaunch(bool b)
Definition: Process.h:136
lldb_private::ExecutionContextRef
Execution context objects refer to objects in the execution of the program that is being debugged.
Definition: ExecutionContext.h:72
lldb::SBTarget::FindGlobalFunctions
lldb::SBSymbolContextList FindGlobalFunctions(const char *name, uint32_t max_matches, MatchType matchtype)
Find global functions by their name with pattern matching.
Definition: SBTarget.cpp:1844
SymbolFile.h
lldb_private::BreakpointIDList
Definition: BreakpointIDList.h:25
lldb_private::ExecutionContext::GetTargetPtr
Target * GetTargetPtr() const
Returns a pointer to the target object.
Definition: ExecutionContext.cpp:200
lldb_private::ObjectFile
Definition: ObjectFile.h:58
lldb_private::ModuleList::Append
void Append(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list.
lldb::SBTarget::LoadCore
SBProcess LoadCore(const char *core_file)
Definition: SBTarget.cpp:252
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
lldb::SBFileSpecList
Definition: SBFileSpecList.h:17
SBBreakpoint.h
lldb::ByteOrder
ByteOrder
Byte ordering definitions.
Definition: lldb-enumerations.h:138
LLDB_REGISTER_METHOD
#define LLDB_REGISTER_METHOD(Result, Class, Method, Signature)
Definition: ReproducerInstrumentation.h:93
lldb::SBSourceManager
Definition: SBSourceManager.h:18