1 //===-- SBDebugger.cpp ------------------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 // C Includes
11 // C++ Includes
12 // Other libraries and framework includes
13 // Project includes
14 #include "lldb/API/SBDebugger.h"
15 
16 #include "lldb/lldb-private.h"
17 
18 #include "lldb/API/SBBroadcaster.h"
19 #include "lldb/API/SBCommandInterpreter.h"
20 #include "lldb/API/SBCommandReturnObject.h"
21 #include "lldb/API/SBError.h"
22 #include "lldb/API/SBEvent.h"
23 #include "lldb/API/SBFrame.h"
24 #include "lldb/API/SBListener.h"
25 #include "lldb/API/SBProcess.h"
26 #include "lldb/API/SBSourceManager.h"
27 #include "lldb/API/SBStream.h"
28 #include "lldb/API/SBStringList.h"
29 #include "lldb/API/SBTarget.h"
30 #include "lldb/API/SBThread.h"
31 #include "lldb/API/SBTypeCategory.h"
32 #include "lldb/API/SBTypeFilter.h"
33 #include "lldb/API/SBTypeFormat.h"
34 #include "lldb/API/SBTypeNameSpecifier.h"
35 #include "lldb/API/SBTypeSummary.h"
36 #include "lldb/API/SBTypeSynthetic.h"
37 #include "lldb/API/SystemInitializerFull.h"
38 
39 #include "lldb/Core/Debugger.h"
40 #include "lldb/Core/State.h"
41 #include "lldb/Core/StreamFile.h"
42 #include "lldb/DataFormatters/DataVisualization.h"
43 #include "lldb/Initialization/SystemLifetimeManager.h"
44 #include "lldb/Interpreter/Args.h"
45 #include "lldb/Interpreter/CommandInterpreter.h"
46 #include "lldb/Interpreter/OptionGroupPlatform.h"
47 #include "lldb/Target/Process.h"
48 #include "lldb/Target/TargetList.h"
49 
50 #include "llvm/ADT/STLExtras.h"
51 #include "llvm/ADT/StringRef.h"
52 #include "llvm/Support/DynamicLibrary.h"
53 #include "llvm/Support/ManagedStatic.h"
54 
55 using namespace lldb;
56 using namespace lldb_private;
57 
58 static llvm::sys::DynamicLibrary LoadPlugin(const lldb::DebuggerSP &debugger_sp,
59                                             const FileSpec &spec,
60                                             Error &error) {
61   llvm::sys::DynamicLibrary dynlib =
62       llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str());
63   if (dynlib.isValid()) {
64     typedef bool (*LLDBCommandPluginInit)(lldb::SBDebugger & debugger);
65 
66     lldb::SBDebugger debugger_sb(debugger_sp);
67     // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger)
68     // function.
69     // TODO: mangle this differently for your system - on OSX, the first
70     // underscore needs to be removed and the second one stays
71     LLDBCommandPluginInit init_func =
72         (LLDBCommandPluginInit)dynlib.getAddressOfSymbol(
73             "_ZN4lldb16PluginInitializeENS_10SBDebuggerE");
74     if (init_func) {
75       if (init_func(debugger_sb))
76         return dynlib;
77       else
78         error.SetErrorString("plug-in refused to load "
79                              "(lldb::PluginInitialize(lldb::SBDebugger) "
80                              "returned false)");
81     } else {
82       error.SetErrorString("plug-in is missing the required initialization: "
83                            "lldb::PluginInitialize(lldb::SBDebugger)");
84     }
85   } else {
86     if (spec.Exists())
87       error.SetErrorString("this file does not represent a loadable dylib");
88     else
89       error.SetErrorString("no such file");
90   }
91   return llvm::sys::DynamicLibrary();
92 }
93 
94 static llvm::ManagedStatic<SystemLifetimeManager> g_debugger_lifetime;
95 
96 SBError SBInputReader::Initialize(
97     lldb::SBDebugger &sb_debugger,
98     unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction,
99                       char const *, unsigned long),
100     void *, lldb::InputReaderGranularity, char const *, char const *, bool) {
101   return SBError();
102 }
103 
104 void SBInputReader::SetIsDone(bool) {}
105 
106 bool SBInputReader::IsActive() const { return false; }
107 
108 SBDebugger::SBDebugger() = default;
109 
110 SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp)
111     : m_opaque_sp(debugger_sp) {}
112 
113 SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) {}
114 
115 SBDebugger::~SBDebugger() = default;
116 
117 SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) {
118   if (this != &rhs) {
119     m_opaque_sp = rhs.m_opaque_sp;
120   }
121   return *this;
122 }
123 
124 void SBDebugger::Initialize() {
125   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
126 
127   if (log)
128     log->Printf("SBDebugger::Initialize ()");
129 
130   g_debugger_lifetime->Initialize(llvm::make_unique<SystemInitializerFull>(),
131                                   LoadPlugin);
132 }
133 
134 void SBDebugger::Terminate() { g_debugger_lifetime->Terminate(); }
135 
136 void SBDebugger::Clear() {
137   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
138 
139   if (log)
140     log->Printf("SBDebugger(%p)::Clear ()",
141                 static_cast<void *>(m_opaque_sp.get()));
142 
143   if (m_opaque_sp)
144     m_opaque_sp->ClearIOHandlers();
145 
146   m_opaque_sp.reset();
147 }
148 
149 SBDebugger SBDebugger::Create() {
150   return SBDebugger::Create(false, nullptr, nullptr);
151 }
152 
153 SBDebugger SBDebugger::Create(bool source_init_files) {
154   return SBDebugger::Create(source_init_files, nullptr, nullptr);
155 }
156 
157 SBDebugger SBDebugger::Create(bool source_init_files,
158                               lldb::LogOutputCallback callback, void *baton)
159 
160 {
161   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
162 
163   SBDebugger debugger;
164 
165   // Currently we have issues if this function is called simultaneously on two
166   // different
167   // threads. The issues mainly revolve around the fact that the
168   // lldb_private::FormatManager
169   // uses global collections and having two threads parsing the .lldbinit files
170   // can cause
171   // mayhem. So to get around this for now we need to use a mutex to prevent bad
172   // things
173   // from happening.
174   static std::recursive_mutex g_mutex;
175   std::lock_guard<std::recursive_mutex> guard(g_mutex);
176 
177   debugger.reset(Debugger::CreateInstance(callback, baton));
178 
179   if (log) {
180     SBStream sstr;
181     debugger.GetDescription(sstr);
182     log->Printf("SBDebugger::Create () => SBDebugger(%p): %s",
183                 static_cast<void *>(debugger.m_opaque_sp.get()),
184                 sstr.GetData());
185   }
186 
187   SBCommandInterpreter interp = debugger.GetCommandInterpreter();
188   if (source_init_files) {
189     interp.get()->SkipLLDBInitFiles(false);
190     interp.get()->SkipAppInitFiles(false);
191     SBCommandReturnObject result;
192     interp.SourceInitFileInHomeDirectory(result);
193   } else {
194     interp.get()->SkipLLDBInitFiles(true);
195     interp.get()->SkipAppInitFiles(true);
196   }
197   return debugger;
198 }
199 
200 void SBDebugger::Destroy(SBDebugger &debugger) {
201   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
202 
203   if (log) {
204     SBStream sstr;
205     debugger.GetDescription(sstr);
206     log->Printf("SBDebugger::Destroy () => SBDebugger(%p): %s",
207                 static_cast<void *>(debugger.m_opaque_sp.get()),
208                 sstr.GetData());
209   }
210 
211   Debugger::Destroy(debugger.m_opaque_sp);
212 
213   if (debugger.m_opaque_sp.get() != nullptr)
214     debugger.m_opaque_sp.reset();
215 }
216 
217 void SBDebugger::MemoryPressureDetected() {
218   // Since this function can be call asynchronously, we allow it to be
219   // non-mandatory. We have seen deadlocks with this function when called
220   // so we need to safeguard against this until we can determine what is
221   // causing the deadlocks.
222   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
223 
224   const bool mandatory = false;
225   if (log) {
226     log->Printf("SBDebugger::MemoryPressureDetected (), mandatory = %d",
227                 mandatory);
228   }
229 
230   ModuleList::RemoveOrphanSharedModules(mandatory);
231 }
232 
233 bool SBDebugger::IsValid() const { return m_opaque_sp.get() != nullptr; }
234 
235 void SBDebugger::SetAsync(bool b) {
236   if (m_opaque_sp)
237     m_opaque_sp->SetAsyncExecution(b);
238 }
239 
240 bool SBDebugger::GetAsync() {
241   return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false);
242 }
243 
244 void SBDebugger::SkipLLDBInitFiles(bool b) {
245   if (m_opaque_sp)
246     m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b);
247 }
248 
249 void SBDebugger::SkipAppInitFiles(bool b) {
250   if (m_opaque_sp)
251     m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b);
252 }
253 
254 // Shouldn't really be settable after initialization as this could cause lots of
255 // problems; don't want users
256 // trying to switch modes in the middle of a debugging session.
257 void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) {
258   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
259 
260   if (log)
261     log->Printf(
262         "SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)",
263         static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
264         transfer_ownership);
265 
266   if (m_opaque_sp)
267     m_opaque_sp->SetInputFileHandle(fh, transfer_ownership);
268 }
269 
270 void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) {
271   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
272 
273   if (log)
274     log->Printf(
275         "SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)",
276         static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
277         transfer_ownership);
278 
279   if (m_opaque_sp)
280     m_opaque_sp->SetOutputFileHandle(fh, transfer_ownership);
281 }
282 
283 void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) {
284   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
285 
286   if (log)
287     log->Printf(
288         "SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)",
289         static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
290         transfer_ownership);
291 
292   if (m_opaque_sp)
293     m_opaque_sp->SetErrorFileHandle(fh, transfer_ownership);
294 }
295 
296 FILE *SBDebugger::GetInputFileHandle() {
297   if (m_opaque_sp) {
298     StreamFileSP stream_file_sp(m_opaque_sp->GetInputFile());
299     if (stream_file_sp)
300       return stream_file_sp->GetFile().GetStream();
301   }
302   return nullptr;
303 }
304 
305 FILE *SBDebugger::GetOutputFileHandle() {
306   if (m_opaque_sp) {
307     StreamFileSP stream_file_sp(m_opaque_sp->GetOutputFile());
308     if (stream_file_sp)
309       return stream_file_sp->GetFile().GetStream();
310   }
311   return nullptr;
312 }
313 
314 FILE *SBDebugger::GetErrorFileHandle() {
315   if (m_opaque_sp) {
316     StreamFileSP stream_file_sp(m_opaque_sp->GetErrorFile());
317     if (stream_file_sp)
318       return stream_file_sp->GetFile().GetStream();
319   }
320   return nullptr;
321 }
322 
323 void SBDebugger::SaveInputTerminalState() {
324   if (m_opaque_sp)
325     m_opaque_sp->SaveInputTerminalState();
326 }
327 
328 void SBDebugger::RestoreInputTerminalState() {
329   if (m_opaque_sp)
330     m_opaque_sp->RestoreInputTerminalState();
331 }
332 SBCommandInterpreter SBDebugger::GetCommandInterpreter() {
333   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
334 
335   SBCommandInterpreter sb_interpreter;
336   if (m_opaque_sp)
337     sb_interpreter.reset(&m_opaque_sp->GetCommandInterpreter());
338 
339   if (log)
340     log->Printf(
341         "SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)",
342         static_cast<void *>(m_opaque_sp.get()),
343         static_cast<void *>(sb_interpreter.get()));
344 
345   return sb_interpreter;
346 }
347 
348 void SBDebugger::HandleCommand(const char *command) {
349   if (m_opaque_sp) {
350     TargetSP target_sp(m_opaque_sp->GetSelectedTarget());
351     std::unique_lock<std::recursive_mutex> lock;
352     if (target_sp)
353       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
354 
355     SBCommandInterpreter sb_interpreter(GetCommandInterpreter());
356     SBCommandReturnObject result;
357 
358     sb_interpreter.HandleCommand(command, result, false);
359 
360     if (GetErrorFileHandle() != nullptr)
361       result.PutError(GetErrorFileHandle());
362     if (GetOutputFileHandle() != nullptr)
363       result.PutOutput(GetOutputFileHandle());
364 
365     if (!m_opaque_sp->GetAsyncExecution()) {
366       SBProcess process(GetCommandInterpreter().GetProcess());
367       ProcessSP process_sp(process.GetSP());
368       if (process_sp) {
369         EventSP event_sp;
370         ListenerSP lldb_listener_sp = m_opaque_sp->GetListener();
371         while (lldb_listener_sp->GetNextEventForBroadcaster(process_sp.get(),
372                                                             event_sp)) {
373           SBEvent event(event_sp);
374           HandleProcessEvent(process, event, GetOutputFileHandle(),
375                              GetErrorFileHandle());
376         }
377       }
378     }
379   }
380 }
381 
382 SBListener SBDebugger::GetListener() {
383   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
384 
385   SBListener sb_listener;
386   if (m_opaque_sp)
387     sb_listener.reset(m_opaque_sp->GetListener());
388 
389   if (log)
390     log->Printf("SBDebugger(%p)::GetListener () => SBListener(%p)",
391                 static_cast<void *>(m_opaque_sp.get()),
392                 static_cast<void *>(sb_listener.get()));
393 
394   return sb_listener;
395 }
396 
397 void SBDebugger::HandleProcessEvent(const SBProcess &process,
398                                     const SBEvent &event, FILE *out,
399                                     FILE *err) {
400   if (!process.IsValid())
401     return;
402 
403   TargetSP target_sp(process.GetTarget().GetSP());
404   if (!target_sp)
405     return;
406 
407   const uint32_t event_type = event.GetType();
408   char stdio_buffer[1024];
409   size_t len;
410 
411   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
412 
413   if (event_type &
414       (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged)) {
415     // Drain stdout when we stop just in case we have any bytes
416     while ((len = process.GetSTDOUT(stdio_buffer, sizeof(stdio_buffer))) > 0)
417       if (out != nullptr)
418         ::fwrite(stdio_buffer, 1, len, out);
419   }
420 
421   if (event_type &
422       (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged)) {
423     // Drain stderr when we stop just in case we have any bytes
424     while ((len = process.GetSTDERR(stdio_buffer, sizeof(stdio_buffer))) > 0)
425       if (err != nullptr)
426         ::fwrite(stdio_buffer, 1, len, err);
427   }
428 
429   if (event_type & Process::eBroadcastBitStateChanged) {
430     StateType event_state = SBProcess::GetStateFromEvent(event);
431 
432     if (event_state == eStateInvalid)
433       return;
434 
435     bool is_stopped = StateIsStoppedState(event_state);
436     if (!is_stopped)
437       process.ReportEventState(event, out);
438   }
439 }
440 
441 SBSourceManager SBDebugger::GetSourceManager() {
442   SBSourceManager sb_source_manager(*this);
443   return sb_source_manager;
444 }
445 
446 bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) {
447   if (arch_name && arch_name_len) {
448     ArchSpec default_arch = Target::GetDefaultArchitecture();
449 
450     if (default_arch.IsValid()) {
451       const std::string &triple_str = default_arch.GetTriple().str();
452       if (!triple_str.empty())
453         ::snprintf(arch_name, arch_name_len, "%s", triple_str.c_str());
454       else
455         ::snprintf(arch_name, arch_name_len, "%s",
456                    default_arch.GetArchitectureName());
457       return true;
458     }
459   }
460   if (arch_name && arch_name_len)
461     arch_name[0] = '\0';
462   return false;
463 }
464 
465 bool SBDebugger::SetDefaultArchitecture(const char *arch_name) {
466   if (arch_name) {
467     ArchSpec arch(arch_name);
468     if (arch.IsValid()) {
469       Target::SetDefaultArchitecture(arch);
470       return true;
471     }
472   }
473   return false;
474 }
475 
476 ScriptLanguage
477 SBDebugger::GetScriptingLanguage(const char *script_language_name) {
478   if (!script_language_name) return eScriptLanguageDefault;
479   return Args::StringToScriptLanguage(llvm::StringRef(script_language_name),
480                                       eScriptLanguageDefault, nullptr);
481 }
482 
483 const char *SBDebugger::GetVersionString() {
484   return lldb_private::GetVersion();
485 }
486 
487 const char *SBDebugger::StateAsCString(StateType state) {
488   return lldb_private::StateAsCString(state);
489 }
490 
491 bool SBDebugger::StateIsRunningState(StateType state) {
492   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
493 
494   const bool result = lldb_private::StateIsRunningState(state);
495   if (log)
496     log->Printf("SBDebugger::StateIsRunningState (state=%s) => %i",
497                 StateAsCString(state), result);
498 
499   return result;
500 }
501 
502 bool SBDebugger::StateIsStoppedState(StateType state) {
503   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
504 
505   const bool result = lldb_private::StateIsStoppedState(state, false);
506   if (log)
507     log->Printf("SBDebugger::StateIsStoppedState (state=%s) => %i",
508                 StateAsCString(state), result);
509 
510   return result;
511 }
512 
513 lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
514                                         const char *target_triple,
515                                         const char *platform_name,
516                                         bool add_dependent_modules,
517                                         lldb::SBError &sb_error) {
518   SBTarget sb_target;
519   TargetSP target_sp;
520   if (m_opaque_sp) {
521     sb_error.Clear();
522     OptionGroupPlatform platform_options(false);
523     platform_options.SetPlatformName(platform_name);
524 
525     sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget(
526         *m_opaque_sp, filename, target_triple, add_dependent_modules,
527         &platform_options, target_sp);
528 
529     if (sb_error.Success())
530       sb_target.SetSP(target_sp);
531   } else {
532     sb_error.SetErrorString("invalid debugger");
533   }
534 
535   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
536   if (log)
537     log->Printf("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, "
538                 "platform_name=%s, add_dependent_modules=%u, error=%s) => "
539                 "SBTarget(%p)",
540                 static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
541                 platform_name, add_dependent_modules, sb_error.GetCString(),
542                 static_cast<void *>(target_sp.get()));
543 
544   return sb_target;
545 }
546 
547 SBTarget
548 SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename,
549                                                 const char *target_triple) {
550   SBTarget sb_target;
551   TargetSP target_sp;
552   if (m_opaque_sp) {
553     const bool add_dependent_modules = true;
554     Error error(m_opaque_sp->GetTargetList().CreateTarget(
555         *m_opaque_sp, filename, target_triple, add_dependent_modules, nullptr,
556         target_sp));
557     sb_target.SetSP(target_sp);
558   }
559 
560   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
561   if (log)
562     log->Printf("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple "
563                 "(filename=\"%s\", triple=%s) => SBTarget(%p)",
564                 static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
565                 static_cast<void *>(target_sp.get()));
566 
567   return sb_target;
568 }
569 
570 SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
571                                                  const char *arch_cstr) {
572   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
573 
574   SBTarget sb_target;
575   TargetSP target_sp;
576   if (m_opaque_sp) {
577     Error error;
578     const bool add_dependent_modules = true;
579 
580     error = m_opaque_sp->GetTargetList().CreateTarget(
581         *m_opaque_sp, filename, arch_cstr, add_dependent_modules, nullptr,
582         target_sp);
583 
584     if (error.Success()) {
585       m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
586       sb_target.SetSP(target_sp);
587     }
588   }
589 
590   if (log)
591     log->Printf("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", "
592                 "arch=%s) => SBTarget(%p)",
593                 static_cast<void *>(m_opaque_sp.get()), filename, arch_cstr,
594                 static_cast<void *>(target_sp.get()));
595 
596   return sb_target;
597 }
598 
599 SBTarget SBDebugger::CreateTarget(const char *filename) {
600   SBTarget sb_target;
601   TargetSP target_sp;
602   if (m_opaque_sp) {
603     Error error;
604     const bool add_dependent_modules = true;
605     error = m_opaque_sp->GetTargetList().CreateTarget(
606         *m_opaque_sp, filename, nullptr, add_dependent_modules, nullptr,
607         target_sp);
608 
609     if (error.Success()) {
610       m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
611       sb_target.SetSP(target_sp);
612     }
613   }
614   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
615   if (log)
616     log->Printf(
617         "SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)",
618         static_cast<void *>(m_opaque_sp.get()), filename,
619         static_cast<void *>(target_sp.get()));
620   return sb_target;
621 }
622 
623 bool SBDebugger::DeleteTarget(lldb::SBTarget &target) {
624   bool result = false;
625   if (m_opaque_sp) {
626     TargetSP target_sp(target.GetSP());
627     if (target_sp) {
628       // No need to lock, the target list is thread safe
629       result = m_opaque_sp->GetTargetList().DeleteTarget(target_sp);
630       target_sp->Destroy();
631       target.Clear();
632       const bool mandatory = true;
633       ModuleList::RemoveOrphanSharedModules(mandatory);
634     }
635   }
636 
637   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
638   if (log)
639     log->Printf("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i",
640                 static_cast<void *>(m_opaque_sp.get()),
641                 static_cast<void *>(target.m_opaque_sp.get()), result);
642 
643   return result;
644 }
645 
646 SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) {
647   SBTarget sb_target;
648   if (m_opaque_sp) {
649     // No need to lock, the target list is thread safe
650     sb_target.SetSP(m_opaque_sp->GetTargetList().GetTargetAtIndex(idx));
651   }
652   return sb_target;
653 }
654 
655 uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) {
656 
657   lldb::TargetSP target_sp = target.GetSP();
658   if (!target_sp)
659     return UINT32_MAX;
660 
661   if (!m_opaque_sp)
662     return UINT32_MAX;
663 
664   return m_opaque_sp->GetTargetList().GetIndexOfTarget(target.GetSP());
665 }
666 
667 SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) {
668   SBTarget sb_target;
669   if (m_opaque_sp) {
670     // No need to lock, the target list is thread safe
671     sb_target.SetSP(m_opaque_sp->GetTargetList().FindTargetWithProcessID(pid));
672   }
673   return sb_target;
674 }
675 
676 SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename,
677                                                const char *arch_name) {
678   SBTarget sb_target;
679   if (m_opaque_sp && filename && filename[0]) {
680     // No need to lock, the target list is thread safe
681     ArchSpec arch(arch_name,
682                   m_opaque_sp->GetPlatformList().GetSelectedPlatform().get());
683     TargetSP target_sp(
684         m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture(
685             FileSpec(filename, false), arch_name ? &arch : nullptr));
686     sb_target.SetSP(target_sp);
687   }
688   return sb_target;
689 }
690 
691 SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) {
692   SBTarget sb_target;
693   if (m_opaque_sp) {
694     // No need to lock, the target list is thread safe
695     sb_target.SetSP(
696         m_opaque_sp->GetTargetList().FindTargetWithProcess(process_sp.get()));
697   }
698   return sb_target;
699 }
700 
701 uint32_t SBDebugger::GetNumTargets() {
702   if (m_opaque_sp) {
703     // No need to lock, the target list is thread safe
704     return m_opaque_sp->GetTargetList().GetNumTargets();
705   }
706   return 0;
707 }
708 
709 SBTarget SBDebugger::GetSelectedTarget() {
710   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
711 
712   SBTarget sb_target;
713   TargetSP target_sp;
714   if (m_opaque_sp) {
715     // No need to lock, the target list is thread safe
716     target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget();
717     sb_target.SetSP(target_sp);
718   }
719 
720   if (log) {
721     SBStream sstr;
722     sb_target.GetDescription(sstr, eDescriptionLevelBrief);
723     log->Printf("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s",
724                 static_cast<void *>(m_opaque_sp.get()),
725                 static_cast<void *>(target_sp.get()), sstr.GetData());
726   }
727 
728   return sb_target;
729 }
730 
731 void SBDebugger::SetSelectedTarget(SBTarget &sb_target) {
732   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
733 
734   TargetSP target_sp(sb_target.GetSP());
735   if (m_opaque_sp) {
736     m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
737   }
738   if (log) {
739     SBStream sstr;
740     sb_target.GetDescription(sstr, eDescriptionLevelBrief);
741     log->Printf("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s",
742                 static_cast<void *>(m_opaque_sp.get()),
743                 static_cast<void *>(target_sp.get()), sstr.GetData());
744   }
745 }
746 
747 SBPlatform SBDebugger::GetSelectedPlatform() {
748   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
749 
750   SBPlatform sb_platform;
751   DebuggerSP debugger_sp(m_opaque_sp);
752   if (debugger_sp) {
753     sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform());
754   }
755   if (log)
756     log->Printf("SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s",
757                 static_cast<void *>(m_opaque_sp.get()),
758                 static_cast<void *>(sb_platform.GetSP().get()),
759                 sb_platform.GetName());
760   return sb_platform;
761 }
762 
763 void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) {
764   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
765 
766   DebuggerSP debugger_sp(m_opaque_sp);
767   if (debugger_sp) {
768     debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP());
769   }
770 
771   if (log)
772     log->Printf("SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)",
773                 static_cast<void *>(m_opaque_sp.get()),
774                 static_cast<void *>(sb_platform.GetSP().get()),
775                 sb_platform.GetName());
776 }
777 
778 void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) {
779   DispatchInput(data, data_len);
780 }
781 
782 void SBDebugger::DispatchInput(const void *data, size_t data_len) {
783   //    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
784   //
785   //    if (log)
786   //        log->Printf ("SBDebugger(%p)::DispatchInput (data=\"%.*s\",
787   //        size_t=%" PRIu64 ")",
788   //                     m_opaque_sp.get(),
789   //                     (int) data_len,
790   //                     (const char *) data,
791   //                     (uint64_t)data_len);
792   //
793   //    if (m_opaque_sp)
794   //        m_opaque_sp->DispatchInput ((const char *) data, data_len);
795 }
796 
797 void SBDebugger::DispatchInputInterrupt() {
798   if (m_opaque_sp)
799     m_opaque_sp->DispatchInputInterrupt();
800 }
801 
802 void SBDebugger::DispatchInputEndOfFile() {
803   if (m_opaque_sp)
804     m_opaque_sp->DispatchInputEndOfFile();
805 }
806 
807 void SBDebugger::PushInputReader(SBInputReader &reader) {}
808 
809 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
810                                        bool spawn_thread) {
811   if (m_opaque_sp) {
812     CommandInterpreterRunOptions options;
813 
814     m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(
815         auto_handle_events, spawn_thread, options);
816   }
817 }
818 
819 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
820                                        bool spawn_thread,
821                                        SBCommandInterpreterRunOptions &options,
822                                        int &num_errors, bool &quit_requested,
823                                        bool &stopped_for_crash)
824 
825 {
826   if (m_opaque_sp) {
827     CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
828     interp.RunCommandInterpreter(auto_handle_events, spawn_thread,
829                                  options.ref());
830     num_errors = interp.GetNumErrors();
831     quit_requested = interp.GetQuitRequested();
832     stopped_for_crash = interp.GetStoppedForCrash();
833   }
834 }
835 
836 SBError SBDebugger::RunREPL(lldb::LanguageType language,
837                             const char *repl_options) {
838   SBError error;
839   if (m_opaque_sp)
840     error.ref() = m_opaque_sp->RunREPL(language, repl_options);
841   else
842     error.SetErrorString("invalid debugger");
843   return error;
844 }
845 
846 void SBDebugger::reset(const DebuggerSP &debugger_sp) {
847   m_opaque_sp = debugger_sp;
848 }
849 
850 Debugger *SBDebugger::get() const { return m_opaque_sp.get(); }
851 
852 Debugger &SBDebugger::ref() const {
853   assert(m_opaque_sp.get());
854   return *m_opaque_sp;
855 }
856 
857 const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; }
858 
859 SBDebugger SBDebugger::FindDebuggerWithID(int id) {
860   // No need to lock, the debugger list is thread safe
861   SBDebugger sb_debugger;
862   DebuggerSP debugger_sp = Debugger::FindDebuggerWithID(id);
863   if (debugger_sp)
864     sb_debugger.reset(debugger_sp);
865   return sb_debugger;
866 }
867 
868 const char *SBDebugger::GetInstanceName() {
869   return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr);
870 }
871 
872 SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value,
873                                         const char *debugger_instance_name) {
874   SBError sb_error;
875   DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
876       ConstString(debugger_instance_name)));
877   Error error;
878   if (debugger_sp) {
879     ExecutionContext exe_ctx(
880         debugger_sp->GetCommandInterpreter().GetExecutionContext());
881     error = debugger_sp->SetPropertyValue(&exe_ctx, eVarSetOperationAssign,
882                                           var_name, value);
883   } else {
884     error.SetErrorStringWithFormat("invalid debugger instance name '%s'",
885                                    debugger_instance_name);
886   }
887   if (error.Fail())
888     sb_error.SetError(error);
889   return sb_error;
890 }
891 
892 SBStringList
893 SBDebugger::GetInternalVariableValue(const char *var_name,
894                                      const char *debugger_instance_name) {
895   SBStringList ret_value;
896   DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
897       ConstString(debugger_instance_name)));
898   Error error;
899   if (debugger_sp) {
900     ExecutionContext exe_ctx(
901         debugger_sp->GetCommandInterpreter().GetExecutionContext());
902     lldb::OptionValueSP value_sp(
903         debugger_sp->GetPropertyValue(&exe_ctx, var_name, false, error));
904     if (value_sp) {
905       StreamString value_strm;
906       value_sp->DumpValue(&exe_ctx, value_strm, OptionValue::eDumpOptionValue);
907       const std::string &value_str = value_strm.GetString();
908       if (!value_str.empty()) {
909         StringList string_list;
910         string_list.SplitIntoLines(value_str);
911         return SBStringList(&string_list);
912       }
913     }
914   }
915   return SBStringList();
916 }
917 
918 uint32_t SBDebugger::GetTerminalWidth() const {
919   return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0);
920 }
921 
922 void SBDebugger::SetTerminalWidth(uint32_t term_width) {
923   if (m_opaque_sp)
924     m_opaque_sp->SetTerminalWidth(term_width);
925 }
926 
927 const char *SBDebugger::GetPrompt() const {
928   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
929 
930   if (log)
931     log->Printf("SBDebugger(%p)::GetPrompt () => \"%s\"",
932                 static_cast<void *>(m_opaque_sp.get()),
933                 (m_opaque_sp ? m_opaque_sp->GetPrompt().str().c_str() : ""));
934 
935   return (m_opaque_sp ? ConstString(m_opaque_sp->GetPrompt()).GetCString()
936                       : nullptr);
937 }
938 
939 void SBDebugger::SetPrompt(const char *prompt) {
940   if (m_opaque_sp)
941     m_opaque_sp->SetPrompt(llvm::StringRef::withNullAsEmpty(prompt));
942 }
943 
944 ScriptLanguage SBDebugger::GetScriptLanguage() const {
945   return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone);
946 }
947 
948 void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) {
949   if (m_opaque_sp) {
950     m_opaque_sp->SetScriptLanguage(script_lang);
951   }
952 }
953 
954 bool SBDebugger::SetUseExternalEditor(bool value) {
955   return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false);
956 }
957 
958 bool SBDebugger::GetUseExternalEditor() {
959   return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false);
960 }
961 
962 bool SBDebugger::SetUseColor(bool value) {
963   return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false);
964 }
965 
966 bool SBDebugger::GetUseColor() const {
967   return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false);
968 }
969 
970 bool SBDebugger::GetDescription(SBStream &description) {
971   Stream &strm = description.ref();
972 
973   if (m_opaque_sp) {
974     const char *name = m_opaque_sp->GetInstanceName().AsCString();
975     user_id_t id = m_opaque_sp->GetID();
976     strm.Printf("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id);
977   } else
978     strm.PutCString("No value");
979 
980   return true;
981 }
982 
983 user_id_t SBDebugger::GetID() {
984   return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID);
985 }
986 
987 SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
988   SBError sb_error;
989   if (m_opaque_sp) {
990     if (platform_name_cstr && platform_name_cstr[0]) {
991       ConstString platform_name(platform_name_cstr);
992       PlatformSP platform_sp(Platform::Find(platform_name));
993 
994       if (platform_sp) {
995         // Already have a platform with this name, just select it
996         m_opaque_sp->GetPlatformList().SetSelectedPlatform(platform_sp);
997       } else {
998         // We don't have a platform by this name yet, create one
999         platform_sp = Platform::Create(platform_name, sb_error.ref());
1000         if (platform_sp) {
1001           // We created the platform, now append and select it
1002           bool make_selected = true;
1003           m_opaque_sp->GetPlatformList().Append(platform_sp, make_selected);
1004         }
1005       }
1006     } else {
1007       sb_error.ref().SetErrorString("invalid platform name");
1008     }
1009   } else {
1010     sb_error.ref().SetErrorString("invalid debugger");
1011   }
1012   return sb_error;
1013 }
1014 
1015 bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
1016   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
1017   if (m_opaque_sp) {
1018     PlatformSP platform_sp(
1019         m_opaque_sp->GetPlatformList().GetSelectedPlatform());
1020 
1021     if (platform_sp) {
1022       if (log && sysroot)
1023         log->Printf("SBDebugger::SetCurrentPlatformSDKRoot (\"%s\")", sysroot);
1024       platform_sp->SetSDKRootDirectory(ConstString(sysroot));
1025       return true;
1026     }
1027   }
1028   return false;
1029 }
1030 
1031 bool SBDebugger::GetCloseInputOnEOF() const {
1032   return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false);
1033 }
1034 
1035 void SBDebugger::SetCloseInputOnEOF(bool b) {
1036   if (m_opaque_sp)
1037     m_opaque_sp->SetCloseInputOnEOF(b);
1038 }
1039 
1040 SBTypeCategory SBDebugger::GetCategory(const char *category_name) {
1041   if (!category_name || *category_name == 0)
1042     return SBTypeCategory();
1043 
1044   TypeCategoryImplSP category_sp;
1045 
1046   if (DataVisualization::Categories::GetCategory(ConstString(category_name),
1047                                                  category_sp, false))
1048     return SBTypeCategory(category_sp);
1049   else
1050     return SBTypeCategory();
1051 }
1052 
1053 SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) {
1054   TypeCategoryImplSP category_sp;
1055   if (DataVisualization::Categories::GetCategory(lang_type, category_sp))
1056     return SBTypeCategory(category_sp);
1057   else
1058     return SBTypeCategory();
1059 }
1060 
1061 SBTypeCategory SBDebugger::CreateCategory(const char *category_name) {
1062   if (!category_name || *category_name == 0)
1063     return SBTypeCategory();
1064 
1065   TypeCategoryImplSP category_sp;
1066 
1067   if (DataVisualization::Categories::GetCategory(ConstString(category_name),
1068                                                  category_sp, true))
1069     return SBTypeCategory(category_sp);
1070   else
1071     return SBTypeCategory();
1072 }
1073 
1074 bool SBDebugger::DeleteCategory(const char *category_name) {
1075   if (!category_name || *category_name == 0)
1076     return false;
1077 
1078   return DataVisualization::Categories::Delete(ConstString(category_name));
1079 }
1080 
1081 uint32_t SBDebugger::GetNumCategories() {
1082   return DataVisualization::Categories::GetCount();
1083 }
1084 
1085 SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) {
1086   return SBTypeCategory(
1087       DataVisualization::Categories::GetCategoryAtIndex(index));
1088 }
1089 
1090 SBTypeCategory SBDebugger::GetDefaultCategory() {
1091   return GetCategory("default");
1092 }
1093 
1094 SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) {
1095   SBTypeCategory default_category_sb = GetDefaultCategory();
1096   if (default_category_sb.GetEnabled())
1097     return default_category_sb.GetFormatForType(type_name);
1098   return SBTypeFormat();
1099 }
1100 
1101 #ifndef LLDB_DISABLE_PYTHON
1102 SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) {
1103   if (!type_name.IsValid())
1104     return SBTypeSummary();
1105   return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()));
1106 }
1107 #endif // LLDB_DISABLE_PYTHON
1108 
1109 SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) {
1110   if (!type_name.IsValid())
1111     return SBTypeFilter();
1112   return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()));
1113 }
1114 
1115 #ifndef LLDB_DISABLE_PYTHON
1116 SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) {
1117   if (!type_name.IsValid())
1118     return SBTypeSynthetic();
1119   return SBTypeSynthetic(
1120       DataVisualization::GetSyntheticForType(type_name.GetSP()));
1121 }
1122 #endif // LLDB_DISABLE_PYTHON
1123 
1124 bool SBDebugger::EnableLog(const char *channel, const char **categories) {
1125   if (m_opaque_sp) {
1126     uint32_t log_options =
1127         LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
1128     StreamString errors;
1129     return m_opaque_sp->EnableLog(channel, categories, nullptr, log_options,
1130                                   errors);
1131   } else
1132     return false;
1133 }
1134 
1135 void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
1136                                     void *baton) {
1137   if (m_opaque_sp) {
1138     return m_opaque_sp->SetLoggingCallback(log_callback, baton);
1139   }
1140 }
1141