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