LLDB  mainline
SBDebugger.cpp
Go to the documentation of this file.
1 //===-- SBDebugger.cpp ------------------------------------------*- C++ -*-===//
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 "SBReproducerPrivate.h"
10 #include "SystemInitializerFull.h"
11 
12 #include "lldb/API/SBDebugger.h"
13 
14 #include "lldb/lldb-private.h"
15 
16 #include "lldb/API/SBBroadcaster.h"
19 #include "lldb/API/SBError.h"
20 #include "lldb/API/SBEvent.h"
21 #include "lldb/API/SBFrame.h"
22 #include "lldb/API/SBListener.h"
23 #include "lldb/API/SBProcess.h"
25 #include "lldb/API/SBStream.h"
26 #include "lldb/API/SBStringList.h"
28 #include "lldb/API/SBTarget.h"
29 #include "lldb/API/SBThread.h"
31 #include "lldb/API/SBTypeFilter.h"
32 #include "lldb/API/SBTypeFormat.h"
34 #include "lldb/API/SBTypeSummary.h"
36 
37 #include "lldb/Core/Debugger.h"
39 #include "lldb/Core/StreamFile.h"
42 #include "lldb/Host/XML.h"
47 #include "lldb/Target/Process.h"
48 #include "lldb/Target/TargetList.h"
49 #include "lldb/Utility/Args.h"
50 #include "lldb/Utility/State.h"
51 
52 #include "llvm/ADT/STLExtras.h"
53 #include "llvm/ADT/StringRef.h"
54 #include "llvm/Support/DynamicLibrary.h"
55 #include "llvm/Support/ManagedStatic.h"
56 
57 using namespace lldb;
58 using namespace lldb_private;
59 
60 /// Helper class for replaying commands through the reproducer.
62 public:
63  CommandLoader(std::vector<std::string> files) : m_files(files) {}
64 
65  static std::unique_ptr<CommandLoader> Create() {
66  repro::Loader *loader = repro::Reproducer::Instance().GetLoader();
67  if (!loader)
68  return {};
69 
70  FileSpec file = loader->GetFile<repro::CommandInfo>();
71  if (!file)
72  return {};
73 
74  auto error_or_file = llvm::MemoryBuffer::getFile(file.GetPath());
75  if (auto err = error_or_file.getError())
76  return {};
77 
78  std::vector<std::string> files;
79  llvm::yaml::Input yin((*error_or_file)->getBuffer());
80  yin >> files;
81 
82  if (auto err = yin.error())
83  return {};
84 
85  return llvm::make_unique<CommandLoader>(std::move(files));
86  }
87 
88  FILE *GetNextFile() {
89  if (m_index >= m_files.size())
90  return nullptr;
91  return FileSystem::Instance().Fopen(m_files[m_index++].c_str(), "r");
92  }
93 
94 private:
95  std::vector<std::string> m_files;
96  unsigned m_index = 0;
97 };
98 
99 static llvm::sys::DynamicLibrary LoadPlugin(const lldb::DebuggerSP &debugger_sp,
100  const FileSpec &spec,
101  Status &error) {
102  llvm::sys::DynamicLibrary dynlib =
103  llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str());
104  if (dynlib.isValid()) {
105  typedef bool (*LLDBCommandPluginInit)(lldb::SBDebugger & debugger);
106 
107  lldb::SBDebugger debugger_sb(debugger_sp);
108  // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger)
109  // function.
110  // TODO: mangle this differently for your system - on OSX, the first
111  // underscore needs to be removed and the second one stays
112  LLDBCommandPluginInit init_func =
113  (LLDBCommandPluginInit)(uintptr_t)dynlib.getAddressOfSymbol(
114  "_ZN4lldb16PluginInitializeENS_10SBDebuggerE");
115  if (init_func) {
116  if (init_func(debugger_sb))
117  return dynlib;
118  else
119  error.SetErrorString("plug-in refused to load "
120  "(lldb::PluginInitialize(lldb::SBDebugger) "
121  "returned false)");
122  } else {
123  error.SetErrorString("plug-in is missing the required initialization: "
124  "lldb::PluginInitialize(lldb::SBDebugger)");
125  }
126  } else {
127  if (FileSystem::Instance().Exists(spec))
128  error.SetErrorString("this file does not represent a loadable dylib");
129  else
130  error.SetErrorString("no such file");
131  }
132  return llvm::sys::DynamicLibrary();
133 }
134 
135 static llvm::ManagedStatic<SystemLifetimeManager> g_debugger_lifetime;
136 
138  lldb::SBDebugger &sb_debugger,
139  unsigned long (*callback)(void *, lldb::SBInputReader *,
140  lldb::InputReaderAction, char const *,
141  unsigned long),
142  void *a, lldb::InputReaderGranularity b, char const *c, char const *d,
143  bool e) {
145  lldb::SBError, SBInputReader, Initialize,
146  (lldb::SBDebugger &,
147  unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction,
148  const char *, unsigned long),
149  void *, lldb::InputReaderGranularity, const char *, const char *, bool),
150  sb_debugger, callback, a, b, c, d, e);
151 
152  return SBError();
153 }
154 
156  LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b);
157 }
158 
161 
162  return false;
163 }
164 
166 
167 SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp)
168  : m_opaque_sp(debugger_sp) {
169  LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &), debugger_sp);
170 }
171 
172 SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
174 }
175 
176 SBDebugger::~SBDebugger() = default;
177 
180  SBDebugger, operator=,(const lldb::SBDebugger &), rhs);
181 
182  if (this != &rhs) {
183  m_opaque_sp = rhs.m_opaque_sp;
184  }
185  return LLDB_RECORD_RESULT(*this);
186 }
187 
191 }
192 
196 
197 
198 
199  SBError error;
200  if (auto e = g_debugger_lifetime->Initialize(
201  llvm::make_unique<SystemInitializerFull>(), LoadPlugin)) {
202  error.SetError(Status(std::move(e)));
203  }
204  return LLDB_RECORD_RESULT(error);
205 }
206 
209 
210  g_debugger_lifetime->Terminate();
211 }
212 
215 
216 
217  if (m_opaque_sp)
218  m_opaque_sp->ClearIOHandlers();
219 
220  m_opaque_sp.reset();
221 }
222 
225 
226  return LLDB_RECORD_RESULT(SBDebugger::Create(false, nullptr, nullptr));
227 }
228 
229 SBDebugger SBDebugger::Create(bool source_init_files) {
231  source_init_files);
232 
233  return LLDB_RECORD_RESULT(
234  SBDebugger::Create(source_init_files, nullptr, nullptr));
235 }
236 
237 SBDebugger SBDebugger::Create(bool source_init_files,
238  lldb::LogOutputCallback callback, void *baton)
239 
240 {
242  (bool, lldb::LogOutputCallback, void *), source_init_files,
243  callback, baton);
244 
245  SBDebugger debugger;
246 
247  // Currently we have issues if this function is called simultaneously on two
248  // different threads. The issues mainly revolve around the fact that the
249  // lldb_private::FormatManager uses global collections and having two threads
250  // parsing the .lldbinit files can cause mayhem. So to get around this for
251  // now we need to use a mutex to prevent bad things from happening.
252  static std::recursive_mutex g_mutex;
253  std::lock_guard<std::recursive_mutex> guard(g_mutex);
254 
255  debugger.reset(Debugger::CreateInstance(callback, baton));
256 
257 
258  SBCommandInterpreter interp = debugger.GetCommandInterpreter();
259  if (source_init_files) {
260  interp.get()->SkipLLDBInitFiles(false);
261  interp.get()->SkipAppInitFiles(false);
262  SBCommandReturnObject result;
263  interp.SourceInitFileInHomeDirectory(result);
264  } else {
265  interp.get()->SkipLLDBInitFiles(true);
266  interp.get()->SkipAppInitFiles(true);
267  }
268  return debugger;
269 }
270 
273  debugger);
274 
275 
276  Debugger::Destroy(debugger.m_opaque_sp);
277 
278  if (debugger.m_opaque_sp.get() != nullptr)
279  debugger.m_opaque_sp.reset();
280 }
281 
284 
285  // Since this function can be call asynchronously, we allow it to be non-
286  // mandatory. We have seen deadlocks with this function when called so we
287  // need to safeguard against this until we can determine what is causing the
288  // deadlocks.
289 
290  const bool mandatory = false;
291 
292  ModuleList::RemoveOrphanSharedModules(mandatory);
293 }
294 
295 bool SBDebugger::IsValid() const {
297  return this->operator bool();
298 }
299 SBDebugger::operator bool() const {
300  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, operator bool);
301 
302  return m_opaque_sp.get() != nullptr;
303 }
304 
305 void SBDebugger::SetAsync(bool b) {
306  LLDB_RECORD_METHOD(void, SBDebugger, SetAsync, (bool), b);
307 
308  if (m_opaque_sp)
309  m_opaque_sp->SetAsyncExecution(b);
310 }
311 
314 
315  return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false);
316 }
317 
320 
321  if (m_opaque_sp)
322  m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b);
323 }
324 
327 
328  if (m_opaque_sp)
329  m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b);
330 }
331 
332 // Shouldn't really be settable after initialization as this could cause lots
333 // of problems; don't want users trying to switch modes in the middle of a
334 // debugging session.
335 void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) {
336  LLDB_RECORD_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool), fh,
337  transfer_ownership);
338 
339  if (!m_opaque_sp)
340  return;
341 
342  repro::DataRecorder *recorder = nullptr;
343  if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator())
344  recorder = g->GetOrCreate<repro::CommandProvider>().GetNewDataRecorder();
345 
346  static std::unique_ptr<CommandLoader> loader = CommandLoader::Create();
347  if (loader)
348  fh = loader->GetNextFile();
349 
350  m_opaque_sp->SetInputFileHandle(fh, transfer_ownership, recorder);
351 }
352 
353 void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) {
354  LLDB_RECORD_METHOD(void, SBDebugger, SetOutputFileHandle, (FILE *, bool), fh,
355  transfer_ownership);
356 
357  if (m_opaque_sp)
358  m_opaque_sp->SetOutputFileHandle(fh, transfer_ownership);
359 }
360 
361 void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) {
362  LLDB_RECORD_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), fh,
363  transfer_ownership);
364 
365 
366  if (m_opaque_sp)
367  m_opaque_sp->SetErrorFileHandle(fh, transfer_ownership);
368 }
369 
372 
373  if (m_opaque_sp) {
374  StreamFileSP stream_file_sp(m_opaque_sp->GetInputFile());
375  if (stream_file_sp)
376  return LLDB_RECORD_RESULT(stream_file_sp->GetFile().GetStream());
377  }
378  return nullptr;
379 }
380 
383 
384  if (m_opaque_sp) {
385  StreamFileSP stream_file_sp(m_opaque_sp->GetOutputFile());
386  if (stream_file_sp)
387  return LLDB_RECORD_RESULT(stream_file_sp->GetFile().GetStream());
388  }
389  return nullptr;
390 }
391 
394 
395  if (m_opaque_sp) {
396  StreamFileSP stream_file_sp(m_opaque_sp->GetErrorFile());
397  if (stream_file_sp)
398  return LLDB_RECORD_RESULT(stream_file_sp->GetFile().GetStream());
399  }
400  return nullptr;
401 }
402 
405 
406  if (m_opaque_sp)
407  m_opaque_sp->SaveInputTerminalState();
408 }
409 
412 
413  if (m_opaque_sp)
414  m_opaque_sp->RestoreInputTerminalState();
415 }
419 
420 
421  SBCommandInterpreter sb_interpreter;
422  if (m_opaque_sp)
423  sb_interpreter.reset(&m_opaque_sp->GetCommandInterpreter());
424 
425 
426  return LLDB_RECORD_RESULT(sb_interpreter);
427 }
428 
429 void SBDebugger::HandleCommand(const char *command) {
430  LLDB_RECORD_METHOD(void, SBDebugger, HandleCommand, (const char *), command);
431 
432  if (m_opaque_sp) {
433  TargetSP target_sp(m_opaque_sp->GetSelectedTarget());
434  std::unique_lock<std::recursive_mutex> lock;
435  if (target_sp)
436  lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
437 
439  SBCommandReturnObject result;
440 
441  sb_interpreter.HandleCommand(command, result, false);
442 
443  if (GetErrorFileHandle() != nullptr)
444  result.PutError(GetErrorFileHandle());
445  if (GetOutputFileHandle() != nullptr)
446  result.PutOutput(GetOutputFileHandle());
447 
448  if (!m_opaque_sp->GetAsyncExecution()) {
449  SBProcess process(GetCommandInterpreter().GetProcess());
450  ProcessSP process_sp(process.GetSP());
451  if (process_sp) {
452  EventSP event_sp;
453  ListenerSP lldb_listener_sp = m_opaque_sp->GetListener();
454  while (lldb_listener_sp->GetEventForBroadcaster(
455  process_sp.get(), event_sp, std::chrono::seconds(0))) {
456  SBEvent event(event_sp);
457  HandleProcessEvent(process, event, GetOutputFileHandle(),
459  }
460  }
461  }
462  }
463 }
464 
467 
468 
469  SBListener sb_listener;
470  if (m_opaque_sp)
471  sb_listener.reset(m_opaque_sp->GetListener());
472 
473 
474  return LLDB_RECORD_RESULT(sb_listener);
475 }
476 
478  const SBEvent &event, FILE *out,
479  FILE *err) {
482  (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *), process,
483  event, out, err);
484 
485  if (!process.IsValid())
486  return;
487 
488  TargetSP target_sp(process.GetTarget().GetSP());
489  if (!target_sp)
490  return;
491 
492  const uint32_t event_type = event.GetType();
493  char stdio_buffer[1024];
494  size_t len;
495 
496  std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
497 
498  if (event_type &
499  (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged)) {
500  // Drain stdout when we stop just in case we have any bytes
501  while ((len = process.GetSTDOUT(stdio_buffer, sizeof(stdio_buffer))) > 0)
502  if (out != nullptr)
503  ::fwrite(stdio_buffer, 1, len, out);
504  }
505 
506  if (event_type &
507  (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged)) {
508  // Drain stderr when we stop just in case we have any bytes
509  while ((len = process.GetSTDERR(stdio_buffer, sizeof(stdio_buffer))) > 0)
510  if (err != nullptr)
511  ::fwrite(stdio_buffer, 1, len, err);
512  }
513 
514  if (event_type & Process::eBroadcastBitStateChanged) {
515  StateType event_state = SBProcess::GetStateFromEvent(event);
516 
517  if (event_state == eStateInvalid)
518  return;
519 
520  bool is_stopped = StateIsStoppedState(event_state);
521  if (!is_stopped)
522  process.ReportEventState(event, out);
523  }
524 }
525 
529 
530  SBSourceManager sb_source_manager(*this);
531  return LLDB_RECORD_RESULT(sb_source_manager);
532 }
533 
534 bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) {
536  (char *, size_t), "", arch_name_len);
537 
538  if (arch_name && arch_name_len) {
539  ArchSpec default_arch = Target::GetDefaultArchitecture();
540 
541  if (default_arch.IsValid()) {
542  const std::string &triple_str = default_arch.GetTriple().str();
543  if (!triple_str.empty())
544  ::snprintf(arch_name, arch_name_len, "%s", triple_str.c_str());
545  else
546  ::snprintf(arch_name, arch_name_len, "%s",
547  default_arch.GetArchitectureName());
548  return true;
549  }
550  }
551  if (arch_name && arch_name_len)
552  arch_name[0] = '\0';
553  return false;
554 }
555 
556 bool SBDebugger::SetDefaultArchitecture(const char *arch_name) {
558  (const char *), arch_name);
559 
560  if (arch_name) {
561  ArchSpec arch(arch_name);
562  if (arch.IsValid()) {
563  Target::SetDefaultArchitecture(arch);
564  return true;
565  }
566  }
567  return false;
568 }
569 
571 SBDebugger::GetScriptingLanguage(const char *script_language_name) {
573  (const char *), script_language_name);
574 
575  if (!script_language_name) return eScriptLanguageDefault;
576  return OptionArgParser::ToScriptLanguage(
577  llvm::StringRef(script_language_name), eScriptLanguageDefault, nullptr);
578 }
579 
582 
583  return lldb_private::GetVersion();
584 }
585 
588  (lldb::StateType), state);
589 
590  return lldb_private::StateAsCString(state);
591 }
592 
594  llvm::StringRef name, bool value,
595  llvm::StringRef description) {
596  auto entry_up = llvm::make_unique<StructuredData::Dictionary>();
597  entry_up->AddBooleanItem("value", value);
598  entry_up->AddStringItem("description", description);
599  dict.AddItem(name, std::move(entry_up));
600 }
601 
603  auto array_up = llvm::make_unique<StructuredData::Array>();
604 #define LLVM_TARGET(target) \
605  array_up->AddItem(llvm::make_unique<StructuredData::String>(#target));
606 #include "llvm/Config/Targets.def"
607  auto entry_up = llvm::make_unique<StructuredData::Dictionary>();
608  entry_up->AddItem("value", std::move(array_up));
609  entry_up->AddStringItem("description", "A list of configured LLVM targets.");
610  dict.AddItem("targets", std::move(entry_up));
611 }
612 
616 
617  auto config_up = llvm::make_unique<StructuredData::Dictionary>();
619  *config_up, "xml", XMLDocument::XMLEnabled(),
620  "A boolean value that indicates if XML support is enabled in LLDB");
621  AddLLVMTargets(*config_up);
622 
623  SBStructuredData data;
624  data.m_impl_up->SetObjectSP(std::move(config_up));
625  return LLDB_RECORD_RESULT(data);
626 }
627 
630  (lldb::StateType), state);
631 
632 
633  const bool result = lldb_private::StateIsRunningState(state);
634 
635  return result;
636 }
637 
640  (lldb::StateType), state);
641 
642 
643  const bool result = lldb_private::StateIsStoppedState(state, false);
644 
645  return result;
646 }
647 
649  const char *target_triple,
650  const char *platform_name,
651  bool add_dependent_modules,
652  lldb::SBError &sb_error) {
655  (const char *, const char *, const char *, bool, lldb::SBError &),
656  filename, target_triple, platform_name, add_dependent_modules, sb_error);
657 
658  SBTarget sb_target;
659  TargetSP target_sp;
660  if (m_opaque_sp) {
661  sb_error.Clear();
662  OptionGroupPlatform platform_options(false);
663  platform_options.SetPlatformName(platform_name);
664 
665  sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget(
666  *m_opaque_sp, filename, target_triple,
667  add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo,
668  &platform_options, target_sp);
669 
670  if (sb_error.Success())
671  sb_target.SetSP(target_sp);
672  } else {
673  sb_error.SetErrorString("invalid debugger");
674  }
675 
677  if (log)
678  log->Printf("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, "
679  "platform_name=%s, add_dependent_modules=%u, error=%s) => "
680  "SBTarget(%p)",
681  static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
682  platform_name, add_dependent_modules, sb_error.GetCString(),
683  static_cast<void *>(target_sp.get()));
684 
685  return LLDB_RECORD_RESULT(sb_target);
686 }
687 
688 SBTarget
690  const char *target_triple) {
693  (const char *, const char *), filename, target_triple);
694 
695  SBTarget sb_target;
696  TargetSP target_sp;
697  if (m_opaque_sp) {
698  const bool add_dependent_modules = true;
699  Status error(m_opaque_sp->GetTargetList().CreateTarget(
700  *m_opaque_sp, filename, target_triple,
701  add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
702  target_sp));
703  sb_target.SetSP(target_sp);
704  }
705 
707  if (log)
708  log->Printf("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple "
709  "(filename=\"%s\", triple=%s) => SBTarget(%p)",
710  static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
711  static_cast<void *>(target_sp.get()));
712 
713  return LLDB_RECORD_RESULT(sb_target);
714 }
715 
717  const char *arch_cstr) {
719  (const char *, const char *), filename, arch_cstr);
720 
722 
723  SBTarget sb_target;
724  TargetSP target_sp;
725  if (m_opaque_sp) {
726  Status error;
727  const bool add_dependent_modules = true;
728 
729  error = m_opaque_sp->GetTargetList().CreateTarget(
730  *m_opaque_sp, filename, arch_cstr,
731  add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
732  target_sp);
733 
734  if (error.Success()) {
735  m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
736  sb_target.SetSP(target_sp);
737  }
738  }
739 
740  if (log)
741  log->Printf("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", "
742  "arch=%s) => SBTarget(%p)",
743  static_cast<void *>(m_opaque_sp.get()), filename, arch_cstr,
744  static_cast<void *>(target_sp.get()));
745 
746  return LLDB_RECORD_RESULT(sb_target);
747 }
748 
749 SBTarget SBDebugger::CreateTarget(const char *filename) {
751  filename);
752 
753  SBTarget sb_target;
754  TargetSP target_sp;
755  if (m_opaque_sp) {
756  Status error;
757  const bool add_dependent_modules = true;
758  error = m_opaque_sp->GetTargetList().CreateTarget(
759  *m_opaque_sp, filename, "",
760  add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
761  target_sp);
762 
763  if (error.Success()) {
764  m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
765  sb_target.SetSP(target_sp);
766  }
767  }
769  if (log)
770  log->Printf(
771  "SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)",
772  static_cast<void *>(m_opaque_sp.get()), filename,
773  static_cast<void *>(target_sp.get()));
774  return LLDB_RECORD_RESULT(sb_target);
775 }
776 
779 
780  SBTarget sb_target;
781  if (m_opaque_sp) {
782  sb_target.SetSP(m_opaque_sp->GetDummyTarget()->shared_from_this());
783  }
785  if (log)
786  log->Printf(
787  "SBDebugger(%p)::GetDummyTarget() => SBTarget(%p)",
788  static_cast<void *>(m_opaque_sp.get()),
789  static_cast<void *>(sb_target.GetSP().get()));
790  return LLDB_RECORD_RESULT(sb_target);
791 }
792 
795  target);
796 
797  bool result = false;
798  if (m_opaque_sp) {
799  TargetSP target_sp(target.GetSP());
800  if (target_sp) {
801  // No need to lock, the target list is thread safe
802  result = m_opaque_sp->GetTargetList().DeleteTarget(target_sp);
803  target_sp->Destroy();
804  target.Clear();
805  const bool mandatory = true;
806  ModuleList::RemoveOrphanSharedModules(mandatory);
807  }
808  }
809 
811  if (log)
812  log->Printf("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i",
813  static_cast<void *>(m_opaque_sp.get()),
814  static_cast<void *>(target.m_opaque_sp.get()), result);
815 
816  return result;
817 }
818 
821  idx);
822 
823  SBTarget sb_target;
824  if (m_opaque_sp) {
825  // No need to lock, the target list is thread safe
826  sb_target.SetSP(m_opaque_sp->GetTargetList().GetTargetAtIndex(idx));
827  }
828  return LLDB_RECORD_RESULT(sb_target);
829 }
830 
833  target);
834 
835  lldb::TargetSP target_sp = target.GetSP();
836  if (!target_sp)
837  return UINT32_MAX;
838 
839  if (!m_opaque_sp)
840  return UINT32_MAX;
841 
842  return m_opaque_sp->GetTargetList().GetIndexOfTarget(target.GetSP());
843 }
844 
847  (lldb::pid_t), pid);
848 
849  SBTarget sb_target;
850  if (m_opaque_sp) {
851  // No need to lock, the target list is thread safe
852  sb_target.SetSP(m_opaque_sp->GetTargetList().FindTargetWithProcessID(pid));
853  }
854  return LLDB_RECORD_RESULT(sb_target);
855 }
856 
858  const char *arch_name) {
860  (const char *, const char *), filename, arch_name);
861 
862  SBTarget sb_target;
863  if (m_opaque_sp && filename && filename[0]) {
864  // No need to lock, the target list is thread safe
865  ArchSpec arch = Platform::GetAugmentedArchSpec(
866  m_opaque_sp->GetPlatformList().GetSelectedPlatform().get(), arch_name);
867  TargetSP target_sp(
868  m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture(
869  FileSpec(filename), arch_name ? &arch : nullptr));
870  sb_target.SetSP(target_sp);
871  }
872  return LLDB_RECORD_RESULT(sb_target);
873 }
874 
875 SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) {
876  SBTarget sb_target;
877  if (m_opaque_sp) {
878  // No need to lock, the target list is thread safe
879  sb_target.SetSP(
880  m_opaque_sp->GetTargetList().FindTargetWithProcess(process_sp.get()));
881  }
882  return sb_target;
883 }
884 
887 
888  if (m_opaque_sp) {
889  // No need to lock, the target list is thread safe
890  return m_opaque_sp->GetTargetList().GetNumTargets();
891  }
892  return 0;
893 }
894 
897 
899 
900  SBTarget sb_target;
901  TargetSP target_sp;
902  if (m_opaque_sp) {
903  // No need to lock, the target list is thread safe
904  target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget();
905  sb_target.SetSP(target_sp);
906  }
907 
908  if (log) {
909  SBStream sstr;
910  sb_target.GetDescription(sstr, eDescriptionLevelBrief);
911  log->Printf("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s",
912  static_cast<void *>(m_opaque_sp.get()),
913  static_cast<void *>(target_sp.get()), sstr.GetData());
914  }
915 
916  return LLDB_RECORD_RESULT(sb_target);
917 }
918 
921  sb_target);
922 
924 
925  TargetSP target_sp(sb_target.GetSP());
926  if (m_opaque_sp) {
927  m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
928  }
929  if (log) {
930  SBStream sstr;
931  sb_target.GetDescription(sstr, eDescriptionLevelBrief);
932  log->Printf("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s",
933  static_cast<void *>(m_opaque_sp.get()),
934  static_cast<void *>(target_sp.get()), sstr.GetData());
935  }
936 }
937 
940 
942 
943  SBPlatform sb_platform;
944  DebuggerSP debugger_sp(m_opaque_sp);
945  if (debugger_sp) {
946  sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform());
947  }
948  if (log)
949  log->Printf("SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s",
950  static_cast<void *>(m_opaque_sp.get()),
951  static_cast<void *>(sb_platform.GetSP().get()),
952  sb_platform.GetName());
953  return LLDB_RECORD_RESULT(sb_platform);
954 }
955 
958  (lldb::SBPlatform &), sb_platform);
959 
961 
962  DebuggerSP debugger_sp(m_opaque_sp);
963  if (debugger_sp) {
964  debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP());
965  }
966 
967  if (log)
968  log->Printf("SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)",
969  static_cast<void *>(m_opaque_sp.get()),
970  static_cast<void *>(sb_platform.GetSP().get()),
971  sb_platform.GetName());
972 }
973 
976 
977  if (m_opaque_sp) {
978  // No need to lock, the platform list is thread safe
979  return m_opaque_sp->GetPlatformList().GetSize();
980  }
981  return 0;
982 }
983 
986  (uint32_t), idx);
987 
988  SBPlatform sb_platform;
989  if (m_opaque_sp) {
990  // No need to lock, the platform list is thread safe
991  sb_platform.SetSP(m_opaque_sp->GetPlatformList().GetAtIndex(idx));
992  }
993  return LLDB_RECORD_RESULT(sb_platform);
994 }
995 
998 
999  uint32_t idx = 0;
1000  while (true) {
1001  if (!PluginManager::GetPlatformPluginNameAtIndex(idx)) {
1002  break;
1003  }
1004  ++idx;
1005  }
1006  // +1 for the host platform, which should always appear first in the list.
1007  return idx + 1;
1008 }
1009 
1013 
1014  SBStructuredData data;
1015  auto platform_dict = llvm::make_unique<StructuredData::Dictionary>();
1016  llvm::StringRef name_str("name"), desc_str("description");
1017 
1018  if (idx == 0) {
1019  PlatformSP host_platform_sp(Platform::GetHostPlatform());
1020  platform_dict->AddStringItem(
1021  name_str, host_platform_sp->GetPluginName().GetStringRef());
1022  platform_dict->AddStringItem(
1023  desc_str, llvm::StringRef(host_platform_sp->GetDescription()));
1024  } else if (idx > 0) {
1025  const char *plugin_name =
1026  PluginManager::GetPlatformPluginNameAtIndex(idx - 1);
1027  if (!plugin_name) {
1028  return LLDB_RECORD_RESULT(data);
1029  }
1030  platform_dict->AddStringItem(name_str, llvm::StringRef(plugin_name));
1031 
1032  const char *plugin_desc =
1033  PluginManager::GetPlatformPluginDescriptionAtIndex(idx - 1);
1034  if (!plugin_desc) {
1035  return LLDB_RECORD_RESULT(data);
1036  }
1037  platform_dict->AddStringItem(desc_str, llvm::StringRef(plugin_desc));
1038  }
1039 
1040  data.m_impl_up->SetObjectSP(
1041  StructuredData::ObjectSP(platform_dict.release()));
1042  return LLDB_RECORD_RESULT(data);
1043 }
1044 
1045 void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) {
1047  (void *, const void *, size_t), baton, data, data_len);
1048 
1049  DispatchInput(data, data_len);
1050 }
1051 
1052 void SBDebugger::DispatchInput(const void *data, size_t data_len) {
1053  LLDB_RECORD_DUMMY(void, SBDebugger, DispatchInput, (const void *, size_t),
1054  data, data_len);
1055 
1056  // Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1057  //
1058  // if (log)
1059  // log->Printf ("SBDebugger(%p)::DispatchInput (data=\"%.*s\",
1060  // size_t=%" PRIu64 ")",
1061  // m_opaque_sp.get(),
1062  // (int) data_len,
1063  // (const char *) data,
1064  // (uint64_t)data_len);
1065  //
1066  // if (m_opaque_sp)
1067  // m_opaque_sp->DispatchInput ((const char *) data, data_len);
1068 }
1069 
1072 
1073  if (m_opaque_sp)
1074  m_opaque_sp->DispatchInputInterrupt();
1075 }
1076 
1079 
1080  if (m_opaque_sp)
1081  m_opaque_sp->DispatchInputEndOfFile();
1082 }
1083 
1086  reader);
1087 }
1088 
1089 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
1090  bool spawn_thread) {
1092  auto_handle_events, spawn_thread);
1093 
1094  if (m_opaque_sp) {
1096 
1097  m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(
1098  auto_handle_events, spawn_thread, options);
1099  }
1100 }
1101 
1102 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
1103  bool spawn_thread,
1105  int &num_errors, bool &quit_requested,
1106  bool &stopped_for_crash)
1107 
1108 {
1110  (bool, bool, lldb::SBCommandInterpreterRunOptions &, int &,
1111  bool &, bool &),
1112  auto_handle_events, spawn_thread, options, num_errors,
1113  quit_requested, stopped_for_crash);
1114 
1115  if (m_opaque_sp) {
1116  CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
1117  interp.RunCommandInterpreter(auto_handle_events, spawn_thread,
1118  options.ref());
1119  num_errors = interp.GetNumErrors();
1120  quit_requested = interp.GetQuitRequested();
1121  stopped_for_crash = interp.GetStoppedForCrash();
1122  }
1123 }
1124 
1126  const char *repl_options) {
1128  (lldb::LanguageType, const char *), language,
1129  repl_options);
1130 
1131  SBError error;
1132  if (m_opaque_sp)
1133  error.ref() = m_opaque_sp->RunREPL(language, repl_options);
1134  else
1135  error.SetErrorString("invalid debugger");
1136  return LLDB_RECORD_RESULT(error);
1137 }
1138 
1139 void SBDebugger::reset(const DebuggerSP &debugger_sp) {
1140  m_opaque_sp = debugger_sp;
1141 }
1142 
1143 Debugger *SBDebugger::get() const { return m_opaque_sp.get(); }
1144 
1145 Debugger &SBDebugger::ref() const {
1146  assert(m_opaque_sp.get());
1147  return *m_opaque_sp;
1148 }
1149 
1150 const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; }
1151 
1154  (int), id);
1155 
1156  // No need to lock, the debugger list is thread safe
1157  SBDebugger sb_debugger;
1158  DebuggerSP debugger_sp = Debugger::FindDebuggerWithID(id);
1159  if (debugger_sp)
1160  sb_debugger.reset(debugger_sp);
1161  return LLDB_RECORD_RESULT(sb_debugger);
1162 }
1163 
1166 
1167  return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr);
1168 }
1169 
1170 SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value,
1171  const char *debugger_instance_name) {
1173  (const char *, const char *, const char *),
1174  var_name, value, debugger_instance_name);
1175 
1176  SBError sb_error;
1177  DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
1178  ConstString(debugger_instance_name)));
1179  Status error;
1180  if (debugger_sp) {
1181  ExecutionContext exe_ctx(
1182  debugger_sp->GetCommandInterpreter().GetExecutionContext());
1183  error = debugger_sp->SetPropertyValue(&exe_ctx, eVarSetOperationAssign,
1184  var_name, value);
1185  } else {
1186  error.SetErrorStringWithFormat("invalid debugger instance name '%s'",
1187  debugger_instance_name);
1188  }
1189  if (error.Fail())
1190  sb_error.SetError(error);
1191  return LLDB_RECORD_RESULT(sb_error);
1192 }
1193 
1196  const char *debugger_instance_name) {
1199  (const char *, const char *), var_name, debugger_instance_name);
1200 
1201  SBStringList ret_value;
1202  DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
1203  ConstString(debugger_instance_name)));
1204  Status error;
1205  if (debugger_sp) {
1206  ExecutionContext exe_ctx(
1207  debugger_sp->GetCommandInterpreter().GetExecutionContext());
1208  lldb::OptionValueSP value_sp(
1209  debugger_sp->GetPropertyValue(&exe_ctx, var_name, false, error));
1210  if (value_sp) {
1211  StreamString value_strm;
1212  value_sp->DumpValue(&exe_ctx, value_strm, OptionValue::eDumpOptionValue);
1213  const std::string &value_str = value_strm.GetString();
1214  if (!value_str.empty()) {
1215  StringList string_list;
1216  string_list.SplitIntoLines(value_str);
1217  return LLDB_RECORD_RESULT(SBStringList(&string_list));
1218  }
1219  }
1220  }
1221  return LLDB_RECORD_RESULT(SBStringList());
1222 }
1223 
1226 
1227  return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0);
1228 }
1229 
1232  term_width);
1233 
1234  if (m_opaque_sp)
1235  m_opaque_sp->SetTerminalWidth(term_width);
1236 }
1237 
1238 const char *SBDebugger::GetPrompt() const {
1240 
1242 
1243  if (log)
1244  log->Printf("SBDebugger(%p)::GetPrompt () => \"%s\"",
1245  static_cast<void *>(m_opaque_sp.get()),
1246  (m_opaque_sp ? m_opaque_sp->GetPrompt().str().c_str() : ""));
1247 
1248  return (m_opaque_sp ? ConstString(m_opaque_sp->GetPrompt()).GetCString()
1249  : nullptr);
1250 }
1251 
1252 void SBDebugger::SetPrompt(const char *prompt) {
1253  LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt);
1254 
1255  if (m_opaque_sp)
1256  m_opaque_sp->SetPrompt(llvm::StringRef::withNullAsEmpty(prompt));
1257 }
1258 
1259 const char *SBDebugger::GetReproducerPath() const {
1261 
1262  return (m_opaque_sp
1263  ? ConstString(m_opaque_sp->GetReproducerPath()).GetCString()
1264  : nullptr);
1265 }
1266 
1270 
1271  return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone);
1272 }
1273 
1276  (lldb::ScriptLanguage), script_lang);
1277 
1278  if (m_opaque_sp) {
1279  m_opaque_sp->SetScriptLanguage(script_lang);
1280  }
1281 }
1282 
1284  LLDB_RECORD_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value);
1285 
1286  return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false);
1287 }
1288 
1291 
1292  return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false);
1293 }
1294 
1295 bool SBDebugger::SetUseColor(bool value) {
1296  LLDB_RECORD_METHOD(bool, SBDebugger, SetUseColor, (bool), value);
1297 
1298  return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false);
1299 }
1300 
1303 
1304  return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false);
1305 }
1306 
1309  description);
1310 
1311  Stream &strm = description.ref();
1312 
1313  if (m_opaque_sp) {
1314  const char *name = m_opaque_sp->GetInstanceName().AsCString();
1315  user_id_t id = m_opaque_sp->GetID();
1316  strm.Printf("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id);
1317  } else
1318  strm.PutCString("No value");
1319 
1320  return true;
1321 }
1322 
1325 
1326  return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID);
1327 }
1328 
1329 SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
1331  (const char *), platform_name_cstr);
1332 
1333  SBError sb_error;
1334  if (m_opaque_sp) {
1335  if (platform_name_cstr && platform_name_cstr[0]) {
1336  ConstString platform_name(platform_name_cstr);
1337  PlatformSP platform_sp(Platform::Find(platform_name));
1338 
1339  if (platform_sp) {
1340  // Already have a platform with this name, just select it
1341  m_opaque_sp->GetPlatformList().SetSelectedPlatform(platform_sp);
1342  } else {
1343  // We don't have a platform by this name yet, create one
1344  platform_sp = Platform::Create(platform_name, sb_error.ref());
1345  if (platform_sp) {
1346  // We created the platform, now append and select it
1347  bool make_selected = true;
1348  m_opaque_sp->GetPlatformList().Append(platform_sp, make_selected);
1349  }
1350  }
1351  } else {
1352  sb_error.ref().SetErrorString("invalid platform name");
1353  }
1354  } else {
1355  sb_error.ref().SetErrorString("invalid debugger");
1356  }
1357  return LLDB_RECORD_RESULT(sb_error);
1358 }
1359 
1360 bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
1362  (const char *), sysroot);
1363 
1365  if (m_opaque_sp) {
1366  PlatformSP platform_sp(
1367  m_opaque_sp->GetPlatformList().GetSelectedPlatform());
1368 
1369  if (platform_sp) {
1370  if (log && sysroot)
1371  log->Printf("SBDebugger::SetCurrentPlatformSDKRoot (\"%s\")", sysroot);
1372  platform_sp->SetSDKRootDirectory(ConstString(sysroot));
1373  return true;
1374  }
1375  }
1376  return false;
1377 }
1378 
1381 
1382  return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false);
1383 }
1384 
1387 
1388  if (m_opaque_sp)
1389  m_opaque_sp->SetCloseInputOnEOF(b);
1390 }
1391 
1392 SBTypeCategory SBDebugger::GetCategory(const char *category_name) {
1394  (const char *), category_name);
1395 
1396  if (!category_name || *category_name == 0)
1398 
1399  TypeCategoryImplSP category_sp;
1400 
1401  if (DataVisualization::Categories::GetCategory(ConstString(category_name),
1402  category_sp, false)) {
1403  return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
1404  } else {
1406  }
1407 }
1408 
1411  (lldb::LanguageType), lang_type);
1412 
1413  TypeCategoryImplSP category_sp;
1414  if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) {
1415  return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
1416  } else {
1418  }
1419 }
1420 
1421 SBTypeCategory SBDebugger::CreateCategory(const char *category_name) {
1423  (const char *), category_name);
1424 
1425  if (!category_name || *category_name == 0)
1427 
1428  TypeCategoryImplSP category_sp;
1429 
1430  if (DataVisualization::Categories::GetCategory(ConstString(category_name),
1431  category_sp, true)) {
1432  return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
1433  } else {
1435  }
1436 }
1437 
1438 bool SBDebugger::DeleteCategory(const char *category_name) {
1439  LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *),
1440  category_name);
1441 
1442  if (!category_name || *category_name == 0)
1443  return false;
1444 
1445  return DataVisualization::Categories::Delete(ConstString(category_name));
1446 }
1447 
1450 
1451  return DataVisualization::Categories::GetCount();
1452 }
1453 
1456  (uint32_t), index);
1457 
1458  return LLDB_RECORD_RESULT(
1459  SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index)));
1460 }
1461 
1465 
1466  return LLDB_RECORD_RESULT(GetCategory("default"));
1467 }
1468 
1471  (lldb::SBTypeNameSpecifier), type_name);
1472 
1473  SBTypeCategory default_category_sb = GetDefaultCategory();
1474  if (default_category_sb.GetEnabled())
1475  return LLDB_RECORD_RESULT(default_category_sb.GetFormatForType(type_name));
1476  return LLDB_RECORD_RESULT(SBTypeFormat());
1477 }
1478 
1481  (lldb::SBTypeNameSpecifier), type_name);
1482 
1483  if (!type_name.IsValid())
1485  return LLDB_RECORD_RESULT(
1486  SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP())));
1487 }
1488 
1491  (lldb::SBTypeNameSpecifier), type_name);
1492 
1493  if (!type_name.IsValid())
1494  return LLDB_RECORD_RESULT(SBTypeFilter());
1495  return LLDB_RECORD_RESULT(
1496  SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP())));
1497 }
1498 
1501  (lldb::SBTypeNameSpecifier), type_name);
1502 
1503  if (!type_name.IsValid())
1506  DataVisualization::GetSyntheticForType(type_name.GetSP())));
1507 }
1508 
1509 static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) {
1510  if (categories == nullptr)
1511  return {};
1512  size_t len = 0;
1513  while (categories[len] != nullptr)
1514  ++len;
1515  return llvm::makeArrayRef(categories, len);
1516 }
1517 
1518 bool SBDebugger::EnableLog(const char *channel, const char **categories) {
1519  LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **),
1520  channel, categories);
1521 
1522  if (m_opaque_sp) {
1523  uint32_t log_options =
1525  std::string error;
1526  llvm::raw_string_ostream error_stream(error);
1527  return m_opaque_sp->EnableLog(channel, GetCategoryArray(categories), "",
1528  log_options, error_stream);
1529  } else
1530  return false;
1531 }
1532 
1534  void *baton) {
1536  (lldb::LogOutputCallback, void *), log_callback, baton);
1537 
1538  if (m_opaque_sp) {
1539  return m_opaque_sp->SetLoggingCallback(log_callback, baton);
1540  }
1541 }
1542 
1543 namespace lldb_private {
1544 namespace repro {
1545 
1546 template <>
1548  LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool));
1549  LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ());
1550 }
1551 
1552 static void SetFileHandleRedirect(SBDebugger *, FILE *, bool) {
1553  // Do nothing.
1554 }
1555 
1556 static bool GetDefaultArchitectureRedirect(char *arch_name,
1557  size_t arch_name_len) {
1558  // The function is writing to its argument. Without the redirect it would
1559  // write into the replay buffer.
1560  char buffer[1024];
1561  return SBDebugger::GetDefaultArchitecture(buffer, arch_name_len);
1562 }
1563 
1564 template <>
1566  // Custom implementation.
1567  R.Register(&invoke<void (SBDebugger::*)(
1568  FILE *, bool)>::method<&SBDebugger::SetErrorFileHandle>::doit,
1570  R.Register(&invoke<void (SBDebugger::*)(
1571  FILE *, bool)>::method<&SBDebugger::SetOutputFileHandle>::doit,
1573  R.Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
1576 
1578  LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &));
1581  SBDebugger, operator=,(const lldb::SBDebugger &));
1590  (lldb::SBDebugger &));
1593  LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, operator bool, ());
1594  LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool));
1598  LLDB_REGISTER_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool));
1605  GetCommandInterpreter, ());
1606  LLDB_REGISTER_METHOD(void, SBDebugger, HandleCommand, (const char *));
1610  (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *));
1612  ());
1614  (const char *));
1616  (const char *));
1619  (lldb::StateType));
1621  GetBuildConfiguration, ());
1623  (lldb::StateType));
1625  (lldb::StateType));
1628  (const char *, const char *, const char *, bool, lldb::SBError &));
1631  (const char *, const char *));
1634  (const char *, const char *));
1636  (const char *));
1640  (uint32_t));
1642  (lldb::SBTarget));
1644  (lldb::pid_t));
1646  (const char *, const char *));
1650  (lldb::SBTarget &));
1653  (lldb::SBPlatform &));
1656  (uint32_t));
1663  (lldb::SBInputReader &));
1666  (bool, bool, lldb::SBCommandInterpreterRunOptions &,
1667  int &, bool &, bool &));
1669  (lldb::LanguageType, const char *));
1671  FindDebuggerWithID, (int));
1672  LLDB_REGISTER_METHOD(const char *, SBDebugger, GetInstanceName, ());
1674  (const char *, const char *, const char *));
1677  (const char *, const char *));
1680  LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetPrompt, ());
1681  LLDB_REGISTER_METHOD(void, SBDebugger, SetPrompt, (const char *));
1684  GetScriptLanguage, ());
1694  (const char *));
1696  (const char *));
1700  (const char *));
1702  (lldb::LanguageType));
1704  (const char *));
1705  LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteCategory, (const char *));
1708  (uint32_t));
1710  ());
1720  (const char *, const char **));
1721 }
1722 
1723 }
1724 }
static void SetFileHandleRedirect(SBDebugger *, FILE *, bool)
A class to manage flag bits.
Definition: Debugger.h:82
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:61
static bool GetDefaultArchitectureRedirect(char *arch_name, size_t arch_name_len)
The registry contains a unique mapping between functions and their ID.
uint32_t GetTerminalWidth() const
lldb::SBSourceManager GetSourceManager()
Definition: SBDebugger.cpp:526
bool SetCurrentPlatformSDKRoot(const char *sysroot)
CommandLoader(std::vector< std::string > files)
Definition: SBDebugger.cpp:63
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
Definition: State.cpp:14
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
static void AddBoolConfigEntry(StructuredData::Dictionary &dict, llvm::StringRef name, bool value, llvm::StringRef description)
Definition: SBDebugger.cpp:593
#define LLDB_RECORD_CONSTRUCTOR_NO_ARGS(Class)
InputReaderGranularity
bool SetUseColor(bool use_color)
static const char * StateAsCString(lldb::StateType state)
Definition: SBDebugger.cpp:586
void SetSelectedTarget(SBTarget &target)
Definition: SBDebugger.cpp:919
SBTypeCategory GetCategory(const char *category_name)
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
lldb::PlatformSP GetSP() const
Definition: SBPlatform.cpp:303
class LLDB_API SBTypeCategory
Definition: SBDefines.h:79
void ReportEventState(const lldb::SBEvent &event, FILE *out) const
Definition: SBProcess.cpp:334
uint32_t GetNumCategories()
static SBDebugger FindDebuggerWithID(int id)
SBError Initialize(lldb::SBDebugger &sb_debugger, unsigned long(*callback)(void *, lldb::SBInputReader *, lldb::InputReaderAction, char const *, unsigned long), void *a, lldb::InputReaderGranularity b, char const *c, char const *d, bool e)
Definition: SBDebugger.cpp:137
size_t GetSTDOUT(char *dst, size_t dst_len) const
Definition: SBProcess.cpp:272
static void Initialize()
Definition: SBDebugger.cpp:188
bool Success() const
Definition: SBError.cpp:65
bool GetDescription(lldb::SBStream &description)
#define LLDB_RECORD_STATIC_METHOD(Result, Class, Method, Signature,...)
#define LLDB_RECORD_DUMMY(Result, Class, Method, Signature,...)
The LLDB_RECORD_DUMMY macro is special because it doesn&#39;t actually record anything.
bool GetUseColor() const
lldb::SBTarget FindTargetWithProcessID(pid_t pid)
Definition: SBDebugger.cpp:845
static llvm::sys::DynamicLibrary LoadPlugin(const lldb::DebuggerSP &debugger_sp, const FileSpec &spec, Status &error)
Definition: SBDebugger.cpp:99
#define LLDB_RECORD_STATIC_METHOD_NO_ARGS(Result, Class, Method)
void Clear()
Definition: SBError.cpp:47
A file utility class.
Definition: FileSpec.h:55
void SkipAppInitFiles(bool b)
Definition: SBDebugger.cpp:325
An architecture specification class.
Definition: ArchSpec.h:32
class LLDB_API SBError
Definition: SBDefines.h:39
lldb::SBTarget FindTargetWithFileAndArch(const char *filename, const char *arch)
Definition: SBDebugger.cpp:857
static llvm::ArrayRef< const char * > GetCategoryArray(const char **categories)
static lldb::StateType GetStateFromEvent(const lldb::SBEvent &event)
Definition: SBProcess.cpp:752
void SkipLLDBInitFiles(bool b)
Definition: SBDebugger.cpp:318
lldb::SBDebugger & operator=(const lldb::SBDebugger &rhs)
Definition: SBDebugger.cpp:178
lldb::SBPlatform GetSelectedPlatform()
Definition: SBDebugger.cpp:938
void SourceInitFileInHomeDirectory(lldb::SBCommandReturnObject &result)
static llvm::ManagedStatic< SystemLifetimeManager > g_debugger_lifetime
Definition: SBDebugger.cpp:135
void SetAsync(bool b)
Definition: SBDebugger.cpp:305
void SetError(uint32_t err, lldb::ErrorType type)
Definition: SBError.cpp:97
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
SBTypeCategory GetDefaultCategory()
const char * GetPrompt() const
void SetLoggingCallback(lldb::LogOutputCallback log_callback, void *baton)
void AddItem(llvm::StringRef key, ObjectSP value_sp)
static void MemoryPressureDetected()
Definition: SBDebugger.cpp:282
void DispatchInputEndOfFile()
lldb::ScriptLanguage GetScriptingLanguage(const char *script_language_name)
Definition: SBDebugger.cpp:571
bool IsValid() const
Tests if this ArchSpec is valid.
Definition: ArchSpec.h:329
#define LLDB_INVALID_UID
Definition: lldb-defines.h:91
bool SetUseExternalEditor(bool input)
size_t GetSTDERR(char *dst, size_t dst_len) const
Definition: SBProcess.cpp:286
void DispatchInput(void *baton, const void *data, size_t data_len)
lldb::ScriptLanguage GetScriptLanguage() const
#define LLDB_REGISTER_STATIC_METHOD(Result, Class, Method, Signature)
bool GetCloseInputOnEOF() const
void HandleProcessEvent(const lldb::SBProcess &process, const lldb::SBEvent &event, FILE *out, FILE *err)
Definition: SBDebugger.cpp:477
SBTypeFormat GetFormatForType(SBTypeNameSpecifier)
void SetErrorString(const char *err_str)
Definition: SBError.cpp:124
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:431
void SetTerminalWidth(uint32_t term_width)
uint32_t GetNumTargets()
Definition: SBDebugger.cpp:885
void RegisterMethods< SBDebugger >(Registry &R)
bool IsActive() const
Definition: SBDebugger.cpp:159
void SetErrorFileHandle(FILE *f, bool transfer_ownership)
Definition: SBDebugger.cpp:361
void SetPrompt(const char *prompt)
FILE * GetOutputFileHandle()
Definition: SBDebugger.cpp:381
lldb::SBPlatform GetPlatformAtIndex(uint32_t idx)
Get one of the currently active platforms.
Definition: SBDebugger.cpp:984
void SetSP(const lldb::TargetSP &target_sp)
Definition: SBTarget.cpp:602
#define LIBLLDB_LOG_API
Definition: Logging.h:30
To be used as the "Runtime ID" of a member function.
bool StateIsRunningState(lldb::StateType state)
Check if a state represents a state where the process or thread is running.
Definition: State.cpp:68
const char * GetArchitectureName() const
Returns a static string representing the current architecture.
Definition: ArchSpec.cpp:591
#define UINT32_MAX
Definition: lldb-defines.h:31
SBTypeFormat GetFormatForType(SBTypeNameSpecifier)
void SetSelectedPlatform(lldb::SBPlatform &platform)
Definition: SBDebugger.cpp:956
lldb_private::CommandInterpreter * get()
void SetOutputFileHandle(FILE *f, bool transfer_ownership)
Definition: SBDebugger.cpp:353
const char * GetData()
Definition: SBStream.cpp:42
lldb::SBListener GetListener()
Definition: SBDebugger.cpp:465
#define LLDB_REGISTER_CONSTRUCTOR(Class, Signature)
#define LLDB_RECORD_METHOD_NO_ARGS(Result, Class, Method)
static void Terminate()
Definition: SBDebugger.cpp:207
uint64_t user_id_t
Definition: lldb-types.h:84
lldb::TargetSP GetSP() const
Definition: SBTarget.cpp:600
LanguageType
Programming language type.
static void Destroy(lldb::SBDebugger &debugger)
Definition: SBDebugger.cpp:271
bool EnableLog(const char *channel, const char **categories)
uint32_t GetIndexOfTarget(lldb::SBTarget target)
Definition: SBDebugger.cpp:831
bool StateIsStoppedState(lldb::StateType state, bool must_exist)
Check if a state represents a state where the process or thread is stopped.
Definition: State.cpp:89
const char * GetReproducerPath() const
static lldb::SBStringList GetInternalVariableValue(const char *var_name, const char *debugger_instance_name)
lldb_private::Status & ref()
Definition: SBError.cpp:159
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:57
#define LLDB_RECORD_CONSTRUCTOR(Class, Signature,...)
static lldb::SBError InitializeWithErrorHandling()
Definition: SBDebugger.cpp:193
void SkipLLDBInitFiles(bool skip_lldbinit_files)
bool GetDescription(lldb::SBStream &description, lldb::DescriptionLevel description_level)
Definition: SBTarget.cpp:1755
SBTypeCategory CreateCategory(const char *category_name)
#define LLDB_LOG_OPTION_PREPEND_THREAD_NAME
Definition: Log.h:40
SBTypeSynthetic GetSyntheticForType(SBTypeNameSpecifier)
llvm::StringRef GetString() const
static bool StateIsStoppedState(lldb::StateType state)
Definition: SBDebugger.cpp:638
#define LLDB_RECORD_METHOD(Result, Class, Method, Signature,...)
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:241
lldb::ProcessSP GetSP() const
Definition: SBProcess.cpp:106
void RegisterMethods< SBInputReader >(Registry &R)
void reset(lldb_private::CommandInterpreter *)
bool DeleteTarget(lldb::SBTarget &target)
Definition: SBDebugger.cpp:793
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:106
bool Success() const
Test for success condition.
Definition: Status.cpp:287
class LLDB_API SBTypeFilter
Definition: SBDefines.h:82
lldb::SBTarget CreateTarget(const char *filename, const char *target_triple, const char *platform_name, bool add_dependent_modules, lldb::SBError &error)
Definition: SBDebugger.cpp:648
void RunCommandInterpreter(bool auto_handle_events, bool spawn_thread)
static bool SetDefaultArchitecture(const char *arch_name)
Definition: SBDebugger.cpp:556
static std::unique_ptr< CommandLoader > Create()
Definition: SBDebugger.cpp:65
static SBStructuredData GetBuildConfiguration()
Definition: SBDebugger.cpp:613
class LLDB_API SBTypeSummary
Definition: SBDefines.h:86
lldb::SBTarget CreateTargetWithFileAndTargetTriple(const char *filename, const char *target_triple)
Definition: SBDebugger.cpp:689
StructuredDataImplUP m_impl_up
lldb_private::Stream & ref()
Definition: SBStream.cpp:162
void SetInputFileHandle(FILE *f, bool transfer_ownership)
Definition: SBDebugger.cpp:335
void(* LogOutputCallback)(const char *, void *baton)
Definition: lldb-types.h:70
const char * GetCString() const
Definition: SBError.cpp:39
const char * GetName()
Definition: SBPlatform.cpp:294
static const char * GetVersionString()
Definition: SBDebugger.cpp:580
#define LLDB_LOG_OPTION_PREPEND_TIMESTAMP
Definition: Log.h:38
bool IsValid() const
Definition: SBDebugger.cpp:295
class LLDB_API SBTypeFormat
Definition: SBDefines.h:83
lldb::SBCommandInterpreter GetCommandInterpreter()
Definition: SBDebugger.cpp:416
uint32_t GetNumAvailablePlatforms()
Get the number of available platforms.
Definition: SBDebugger.cpp:996
class LLDB_API SBTypeSynthetic
Definition: SBDefines.h:88
void SetCloseInputOnEOF(bool b)
lldb::SBTarget GetSelectedTarget()
Definition: SBDebugger.cpp:895
static bool GetDefaultArchitecture(char *arch_name, size_t arch_name_len)
Definition: SBDebugger.cpp:534
A uniqued constant string class.
Definition: ConstString.h:38
Helper class for replaying commands through the reproducer.
Definition: SBDebugger.cpp:61
bool Fail() const
Test for error condition.
Definition: Status.cpp:181
The generator is responsible for the logic needed to generate a reproducer.
Definition: Reproducer.h:169
void SaveInputTerminalState()
Definition: SBDebugger.cpp:403
void RestoreInputTerminalState()
Definition: SBDebugger.cpp:410
SBTypeSummary GetSummaryForType(SBTypeNameSpecifier)
void SetIsDone(bool)
Definition: SBDebugger.cpp:155
lldb::SBStructuredData GetAvailablePlatformInfoAtIndex(uint32_t idx)
Get the name and description of one of the available platforms.
void SetSP(const lldb::PlatformSP &platform_sp)
Definition: SBPlatform.cpp:305
static lldb::SBError SetInternalVariable(const char *var_name, const char *value, const char *debugger_instance_name)
void PushInputReader(lldb::SBInputReader &reader)
Definition: SBAddress.h:15
static lldb::SBDebugger Create()
Definition: SBDebugger.cpp:223
FILE * GetInputFileHandle()
Definition: SBDebugger.cpp:370
uint64_t pid_t
Definition: lldb-types.h:85
SBError RunREPL(lldb::LanguageType language, const char *repl_options)
std::shared_ptr< Object > ObjectSP
void SetPlatformName(const char *platform_name)
uint32_t GetNumPlatforms()
Get the number of currently active platforms.
Definition: SBDebugger.cpp:974
#define LLDB_REGISTER_METHOD(Result, Class, Method, Signature)
lldb::SBError SetCurrentPlatform(const char *platform_name)
int SetErrorStringWithFormat(const char *format,...) __attribute__((format(printf
Set the current error string to a formatted error string.
Definition: Status.cpp:255
bool DeleteCategory(const char *category_name)
#define LLDB_RECORD_METHOD_CONST_NO_ARGS(Result, Class, Method)
void RunCommandInterpreter(bool auto_handle_events, bool spawn_thread, CommandInterpreterRunOptions &options)
SBTypeCategory GetCategoryAtIndex(uint32_t)
size_t SplitIntoLines(const std::string &lines)
Definition: StringList.cpp:149
const char * GetInstanceName()
lldb::user_id_t GetID()
lldb::SBTarget GetTarget() const
Definition: SBProcess.cpp:244
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:376
SBTypeFilter GetFilterForType(SBTypeNameSpecifier)
lldb::TypeNameSpecifierImplSP GetSP()
void Printf(const char *format,...) __attribute__((format(printf
Definition: Log.cpp:113
static void AddLLVMTargets(StructuredData::Dictionary &dict)
Definition: SBDebugger.cpp:602
FILE * GetErrorFileHandle()
Definition: SBDebugger.cpp:392
void HandleCommand(const char *command)
Definition: SBDebugger.cpp:429
class LLDB_API SBStringList
Definition: SBDefines.h:67
#define LLDB_RECORD_RESULT(Result)
void DispatchInputInterrupt()
void SetScriptLanguage(lldb::ScriptLanguage script_lang)
lldb::SBTarget CreateTargetWithFileAndArch(const char *filename, const char *archname)
Definition: SBDebugger.cpp:716
void SkipAppInitFiles(bool skip_app_init_files)
lldb::SBTarget GetDummyTarget()
Definition: SBDebugger.cpp:777
#define LLDB_REGISTER_METHOD_CONST(Result, Class, Method, Signature)
lldb::SBTarget GetTargetAtIndex(uint32_t idx)
Definition: SBDebugger.cpp:819
bool IsValid() const
Definition: SBProcess.cpp:116
static bool StateIsRunningState(lldb::StateType state)
Definition: SBDebugger.cpp:628
FILE * GetNextFile()
Definition: SBDebugger.cpp:88
An error handling class.
Definition: Status.h:44
bool GetUseExternalEditor()