1 //===-- SBDebugger.cpp ----------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Utility/ReproducerInstrumentation.h"
10 #include "SystemInitializerFull.h"
11 
12 #include "lldb/API/SBDebugger.h"
13 
14 #include "lldb/API/SBBroadcaster.h"
15 #include "lldb/API/SBCommandInterpreter.h"
16 #include "lldb/API/SBCommandInterpreterRunOptions.h"
17 #include "lldb/API/SBCommandReturnObject.h"
18 #include "lldb/API/SBError.h"
19 #include "lldb/API/SBEvent.h"
20 #include "lldb/API/SBFile.h"
21 #include "lldb/API/SBFrame.h"
22 #include "lldb/API/SBListener.h"
23 #include "lldb/API/SBProcess.h"
24 #include "lldb/API/SBSourceManager.h"
25 #include "lldb/API/SBStream.h"
26 #include "lldb/API/SBStringList.h"
27 #include "lldb/API/SBStructuredData.h"
28 #include "lldb/API/SBTarget.h"
29 #include "lldb/API/SBThread.h"
30 #include "lldb/API/SBTypeCategory.h"
31 #include "lldb/API/SBTypeFilter.h"
32 #include "lldb/API/SBTypeFormat.h"
33 #include "lldb/API/SBTypeNameSpecifier.h"
34 #include "lldb/API/SBTypeSummary.h"
35 #include "lldb/API/SBTypeSynthetic.h"
36 
37 #include "lldb/Core/Debugger.h"
38 #include "lldb/Core/PluginManager.h"
39 #include "lldb/Core/Progress.h"
40 #include "lldb/Core/StreamFile.h"
41 #include "lldb/Core/StructuredDataImpl.h"
42 #include "lldb/DataFormatters/DataVisualization.h"
43 #include "lldb/Host/Config.h"
44 #include "lldb/Host/XML.h"
45 #include "lldb/Initialization/SystemLifetimeManager.h"
46 #include "lldb/Interpreter/CommandInterpreter.h"
47 #include "lldb/Interpreter/OptionArgParser.h"
48 #include "lldb/Interpreter/OptionGroupPlatform.h"
49 #include "lldb/Target/Process.h"
50 #include "lldb/Target/TargetList.h"
51 #include "lldb/Utility/Args.h"
52 #include "lldb/Utility/State.h"
53 #include "lldb/Version/Version.h"
54 
55 #include "llvm/ADT/STLExtras.h"
56 #include "llvm/ADT/StringRef.h"
57 #include "llvm/Support/DynamicLibrary.h"
58 #include "llvm/Support/ManagedStatic.h"
59 
60 using namespace lldb;
61 using namespace lldb_private;
62 
63 static llvm::sys::DynamicLibrary LoadPlugin(const lldb::DebuggerSP &debugger_sp,
64                                             const FileSpec &spec,
65                                             Status &error) {
66   llvm::sys::DynamicLibrary dynlib =
67       llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str());
68   if (dynlib.isValid()) {
69     typedef bool (*LLDBCommandPluginInit)(lldb::SBDebugger & debugger);
70 
71     lldb::SBDebugger debugger_sb(debugger_sp);
72     // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger)
73     // function.
74     // TODO: mangle this differently for your system - on OSX, the first
75     // underscore needs to be removed and the second one stays
76     LLDBCommandPluginInit init_func =
77         (LLDBCommandPluginInit)(uintptr_t)dynlib.getAddressOfSymbol(
78             "_ZN4lldb16PluginInitializeENS_10SBDebuggerE");
79     if (init_func) {
80       if (init_func(debugger_sb))
81         return dynlib;
82       else
83         error.SetErrorString("plug-in refused to load "
84                              "(lldb::PluginInitialize(lldb::SBDebugger) "
85                              "returned false)");
86     } else {
87       error.SetErrorString("plug-in is missing the required initialization: "
88                            "lldb::PluginInitialize(lldb::SBDebugger)");
89     }
90   } else {
91     if (FileSystem::Instance().Exists(spec))
92       error.SetErrorString("this file does not represent a loadable dylib");
93     else
94       error.SetErrorString("no such file");
95   }
96   return llvm::sys::DynamicLibrary();
97 }
98 
99 static llvm::ManagedStatic<SystemLifetimeManager> g_debugger_lifetime;
100 
101 SBError SBInputReader::Initialize(
102     lldb::SBDebugger &sb_debugger,
103     unsigned long (*callback)(void *, lldb::SBInputReader *,
104                               lldb::InputReaderAction, char const *,
105                               unsigned long),
106     void *a, lldb::InputReaderGranularity b, char const *c, char const *d,
107     bool e) {
108   LLDB_RECORD_METHOD(
109       lldb::SBError, SBInputReader, Initialize,
110       (lldb::SBDebugger &,
111        unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction,
112                          const char *, unsigned long),
113        void *, lldb::InputReaderGranularity, const char *, const char *, bool),
114       sb_debugger, callback, a, b, c, d, e);
115 
116   return SBError();
117 }
118 
119 void SBInputReader::SetIsDone(bool b) {
120   LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b);
121 }
122 
123 bool SBInputReader::IsActive() const {
124   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInputReader, IsActive);
125 
126   return false;
127 }
128 
129 SBDebugger::SBDebugger() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDebugger); }
130 
131 SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp)
132     : m_opaque_sp(debugger_sp) {
133   LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &), debugger_sp);
134 }
135 
136 SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
137   LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &), rhs);
138 }
139 
140 SBDebugger::~SBDebugger() = default;
141 
142 SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) {
143   LLDB_RECORD_METHOD(lldb::SBDebugger &,
144                      SBDebugger, operator=,(const lldb::SBDebugger &), rhs);
145 
146   if (this != &rhs) {
147     m_opaque_sp = rhs.m_opaque_sp;
148   }
149   return *this;
150 }
151 
152 const char *SBDebugger::GetBroadcasterClass() {
153   LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger,
154                                     GetBroadcasterClass);
155 
156   return Debugger::GetStaticBroadcasterClass().AsCString();
157 }
158 
159 const char *SBDebugger::GetProgressFromEvent(const lldb::SBEvent &event,
160                                              uint64_t &progress_id,
161                                              uint64_t &completed,
162                                              uint64_t &total,
163                                              bool &is_debugger_specific) {
164   const Debugger::ProgressEventData *progress_data =
165       Debugger::ProgressEventData::GetEventDataFromEvent(event.get());
166   if (progress_data == nullptr)
167     return nullptr;
168   progress_id = progress_data->GetID();
169   completed = progress_data->GetCompleted();
170   total = progress_data->GetTotal();
171   is_debugger_specific = progress_data->IsDebuggerSpecific();
172   // We must record the static method _after_ the out parameters have been
173   // filled in.
174   LLDB_RECORD_STATIC_METHOD(
175       const char *, SBDebugger, GetProgressFromEvent,
176       (const lldb::SBEvent &, uint64_t &, uint64_t &, uint64_t &, bool &),
177       event, progress_id, completed, total, is_debugger_specific);
178   return progress_data->GetMessage().c_str();
179 }
180 
181 SBBroadcaster SBDebugger::GetBroadcaster() {
182   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBBroadcaster, SBDebugger, GetBroadcaster);
183   SBBroadcaster broadcaster(&m_opaque_sp->GetBroadcaster(), false);
184   return broadcaster;
185 }
186 
187 void SBDebugger::Initialize() {
188   LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Initialize);
189   SBError ignored = SBDebugger::InitializeWithErrorHandling();
190 }
191 
192 lldb::SBError SBDebugger::InitializeWithErrorHandling() {
193   LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBError, SBDebugger,
194                                     InitializeWithErrorHandling);
195 
196   SBError error;
197   if (auto e = g_debugger_lifetime->Initialize(
198           std::make_unique<SystemInitializerFull>(), LoadPlugin)) {
199     error.SetError(Status(std::move(e)));
200   }
201   return error;
202 }
203 
204 void SBDebugger::Terminate() {
205   LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Terminate);
206 
207   g_debugger_lifetime->Terminate();
208 }
209 
210 void SBDebugger::Clear() {
211   LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, Clear);
212 
213   if (m_opaque_sp)
214     m_opaque_sp->ClearIOHandlers();
215 
216   m_opaque_sp.reset();
217 }
218 
219 SBDebugger SBDebugger::Create() {
220   LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBDebugger, SBDebugger, Create);
221 
222   return SBDebugger::Create(false, nullptr, nullptr);
223 }
224 
225 SBDebugger SBDebugger::Create(bool source_init_files) {
226   LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool),
227                             source_init_files);
228 
229   return SBDebugger::Create(source_init_files, nullptr, nullptr);
230 }
231 
232 SBDebugger SBDebugger::Create(bool source_init_files,
233                               lldb::LogOutputCallback callback, void *baton)
234 
235 {
236   LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create,
237                             (bool, lldb::LogOutputCallback, void *),
238                             source_init_files, callback, baton);
239 
240   SBDebugger debugger;
241 
242   // Currently we have issues if this function is called simultaneously on two
243   // different threads. The issues mainly revolve around the fact that the
244   // lldb_private::FormatManager uses global collections and having two threads
245   // parsing the .lldbinit files can cause mayhem. So to get around this for
246   // now we need to use a mutex to prevent bad things from happening.
247   static std::recursive_mutex g_mutex;
248   std::lock_guard<std::recursive_mutex> guard(g_mutex);
249 
250   debugger.reset(Debugger::CreateInstance(callback, baton));
251 
252   SBCommandInterpreter interp = debugger.GetCommandInterpreter();
253   if (source_init_files) {
254     interp.get()->SkipLLDBInitFiles(false);
255     interp.get()->SkipAppInitFiles(false);
256     SBCommandReturnObject result;
257     interp.SourceInitFileInHomeDirectory(result, false);
258   } else {
259     interp.get()->SkipLLDBInitFiles(true);
260     interp.get()->SkipAppInitFiles(true);
261   }
262   return debugger;
263 }
264 
265 void SBDebugger::Destroy(SBDebugger &debugger) {
266   LLDB_RECORD_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &),
267                             debugger);
268 
269   Debugger::Destroy(debugger.m_opaque_sp);
270 
271   if (debugger.m_opaque_sp.get() != nullptr)
272     debugger.m_opaque_sp.reset();
273 }
274 
275 void SBDebugger::MemoryPressureDetected() {
276   LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, MemoryPressureDetected);
277 
278   // Since this function can be call asynchronously, we allow it to be non-
279   // mandatory. We have seen deadlocks with this function when called so we
280   // need to safeguard against this until we can determine what is causing the
281   // deadlocks.
282 
283   const bool mandatory = false;
284 
285   ModuleList::RemoveOrphanSharedModules(mandatory);
286 }
287 
288 bool SBDebugger::IsValid() const {
289   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, IsValid);
290   return this->operator bool();
291 }
292 SBDebugger::operator bool() const {
293   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, operator bool);
294 
295   return m_opaque_sp.get() != nullptr;
296 }
297 
298 void SBDebugger::SetAsync(bool b) {
299   LLDB_RECORD_METHOD(void, SBDebugger, SetAsync, (bool), b);
300 
301   if (m_opaque_sp)
302     m_opaque_sp->SetAsyncExecution(b);
303 }
304 
305 bool SBDebugger::GetAsync() {
306   LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetAsync);
307 
308   return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false);
309 }
310 
311 void SBDebugger::SkipLLDBInitFiles(bool b) {
312   LLDB_RECORD_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool), b);
313 
314   if (m_opaque_sp)
315     m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b);
316 }
317 
318 void SBDebugger::SkipAppInitFiles(bool b) {
319   LLDB_RECORD_METHOD(void, SBDebugger, SkipAppInitFiles, (bool), b);
320 
321   if (m_opaque_sp)
322     m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b);
323 }
324 
325 void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) {
326   LLDB_RECORD_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool), fh,
327                      transfer_ownership);
328   if (m_opaque_sp)
329     m_opaque_sp->SetInputFile(
330         (FileSP)std::make_shared<NativeFile>(fh, transfer_ownership));
331 }
332 
333 SBError SBDebugger::SetInputString(const char *data) {
334   LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputString, (const char *), data);
335   SBError sb_error;
336   if (data == nullptr) {
337     sb_error.SetErrorString("String data is null");
338     return sb_error;
339   }
340 
341   size_t size = strlen(data);
342   if (size == 0) {
343     sb_error.SetErrorString("String data is empty");
344     return sb_error;
345   }
346 
347   if (!m_opaque_sp) {
348     sb_error.SetErrorString("invalid debugger");
349     return sb_error;
350   }
351 
352   sb_error.SetError(m_opaque_sp->SetInputString(data));
353   return sb_error;
354 }
355 
356 // Shouldn't really be settable after initialization as this could cause lots
357 // of problems; don't want users trying to switch modes in the middle of a
358 // debugging session.
359 SBError SBDebugger::SetInputFile(SBFile file) {
360   LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (SBFile), file);
361 
362   SBError error;
363   if (!m_opaque_sp) {
364     error.ref().SetErrorString("invalid debugger");
365     return error;
366   }
367   error.SetError(m_opaque_sp->SetInputFile(file.m_opaque_sp));
368   return error;
369 }
370 
371 SBError SBDebugger::SetInputFile(FileSP file_sp) {
372   LLDB_RECORD_METHOD(SBError, SBDebugger, SetInputFile, (FileSP), file_sp);
373   return SetInputFile(SBFile(file_sp));
374 }
375 
376 SBError SBDebugger::SetOutputFile(FileSP file_sp) {
377   LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (FileSP), file_sp);
378   return SetOutputFile(SBFile(file_sp));
379 }
380 
381 void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) {
382   LLDB_RECORD_METHOD(void, SBDebugger, SetOutputFileHandle, (FILE *, bool), fh,
383                      transfer_ownership);
384   SetOutputFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership));
385 }
386 
387 SBError SBDebugger::SetOutputFile(SBFile file) {
388   LLDB_RECORD_METHOD(SBError, SBDebugger, SetOutputFile, (SBFile file), file);
389   SBError error;
390   if (!m_opaque_sp) {
391     error.ref().SetErrorString("invalid debugger");
392     return error;
393   }
394   if (!file) {
395     error.ref().SetErrorString("invalid file");
396     return error;
397   }
398   m_opaque_sp->SetOutputFile(file.m_opaque_sp);
399   return error;
400 }
401 
402 void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) {
403   LLDB_RECORD_METHOD(void, SBDebugger, SetErrorFileHandle, (FILE *, bool), fh,
404                      transfer_ownership);
405   SetErrorFile((FileSP)std::make_shared<NativeFile>(fh, transfer_ownership));
406 }
407 
408 SBError SBDebugger::SetErrorFile(FileSP file_sp) {
409   LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (FileSP), file_sp);
410   return SetErrorFile(SBFile(file_sp));
411 }
412 
413 SBError SBDebugger::SetErrorFile(SBFile file) {
414   LLDB_RECORD_METHOD(SBError, SBDebugger, SetErrorFile, (SBFile file), file);
415   SBError error;
416   if (!m_opaque_sp) {
417     error.ref().SetErrorString("invalid debugger");
418     return error;
419   }
420   if (!file) {
421     error.ref().SetErrorString("invalid file");
422     return error;
423   }
424   m_opaque_sp->SetErrorFile(file.m_opaque_sp);
425   return error;
426 }
427 
428 FILE *SBDebugger::GetInputFileHandle() {
429   LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetInputFileHandle);
430   if (m_opaque_sp) {
431     File &file_sp = m_opaque_sp->GetInputFile();
432     return file_sp.GetStream();
433   }
434   return nullptr;
435 }
436 
437 SBFile SBDebugger::GetInputFile() {
438   LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetInputFile);
439   if (m_opaque_sp) {
440     return SBFile(m_opaque_sp->GetInputFileSP());
441   }
442   return SBFile();
443 }
444 
445 FILE *SBDebugger::GetOutputFileHandle() {
446   LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetOutputFileHandle);
447   if (m_opaque_sp) {
448     StreamFile &stream_file = m_opaque_sp->GetOutputStream();
449     return stream_file.GetFile().GetStream();
450   }
451   return nullptr;
452 }
453 
454 SBFile SBDebugger::GetOutputFile() {
455   LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetOutputFile);
456   if (m_opaque_sp) {
457     SBFile file(m_opaque_sp->GetOutputStream().GetFileSP());
458     return file;
459   }
460   return SBFile();
461 }
462 
463 FILE *SBDebugger::GetErrorFileHandle() {
464   LLDB_RECORD_METHOD_NO_ARGS(FILE *, SBDebugger, GetErrorFileHandle);
465 
466   if (m_opaque_sp) {
467     StreamFile &stream_file = m_opaque_sp->GetErrorStream();
468     return stream_file.GetFile().GetStream();
469   }
470   return nullptr;
471 }
472 
473 SBFile SBDebugger::GetErrorFile() {
474   LLDB_RECORD_METHOD_NO_ARGS(SBFile, SBDebugger, GetErrorFile);
475   SBFile file;
476   if (m_opaque_sp) {
477     SBFile file(m_opaque_sp->GetErrorStream().GetFileSP());
478     return file;
479   }
480   return SBFile();
481 }
482 
483 void SBDebugger::SaveInputTerminalState() {
484   LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, SaveInputTerminalState);
485 
486   if (m_opaque_sp)
487     m_opaque_sp->SaveInputTerminalState();
488 }
489 
490 void SBDebugger::RestoreInputTerminalState() {
491   LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, RestoreInputTerminalState);
492 
493   if (m_opaque_sp)
494     m_opaque_sp->RestoreInputTerminalState();
495 }
496 SBCommandInterpreter SBDebugger::GetCommandInterpreter() {
497   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBCommandInterpreter, SBDebugger,
498                              GetCommandInterpreter);
499 
500   SBCommandInterpreter sb_interpreter;
501   if (m_opaque_sp)
502     sb_interpreter.reset(&m_opaque_sp->GetCommandInterpreter());
503 
504   return sb_interpreter;
505 }
506 
507 void SBDebugger::HandleCommand(const char *command) {
508   LLDB_RECORD_METHOD(void, SBDebugger, HandleCommand, (const char *), command);
509 
510   if (m_opaque_sp) {
511     TargetSP target_sp(m_opaque_sp->GetSelectedTarget());
512     std::unique_lock<std::recursive_mutex> lock;
513     if (target_sp)
514       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
515 
516     SBCommandInterpreter sb_interpreter(GetCommandInterpreter());
517     SBCommandReturnObject result;
518 
519     sb_interpreter.HandleCommand(command, result, false);
520 
521     result.PutError(m_opaque_sp->GetErrorStream().GetFileSP());
522     result.PutOutput(m_opaque_sp->GetOutputStream().GetFileSP());
523 
524     if (!m_opaque_sp->GetAsyncExecution()) {
525       SBProcess process(GetCommandInterpreter().GetProcess());
526       ProcessSP process_sp(process.GetSP());
527       if (process_sp) {
528         EventSP event_sp;
529         ListenerSP lldb_listener_sp = m_opaque_sp->GetListener();
530         while (lldb_listener_sp->GetEventForBroadcaster(
531             process_sp.get(), event_sp, std::chrono::seconds(0))) {
532           SBEvent event(event_sp);
533           HandleProcessEvent(process, event, GetOutputFile(), GetErrorFile());
534         }
535       }
536     }
537   }
538 }
539 
540 SBListener SBDebugger::GetListener() {
541   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBListener, SBDebugger, GetListener);
542 
543   SBListener sb_listener;
544   if (m_opaque_sp)
545     sb_listener.reset(m_opaque_sp->GetListener());
546 
547   return sb_listener;
548 }
549 
550 void SBDebugger::HandleProcessEvent(const SBProcess &process,
551                                     const SBEvent &event, SBFile out,
552                                     SBFile err) {
553   LLDB_RECORD_METHOD(
554       void, SBDebugger, HandleProcessEvent,
555       (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile), process,
556       event, out, err);
557 
558   return HandleProcessEvent(process, event, out.m_opaque_sp, err.m_opaque_sp);
559 }
560 
561 void SBDebugger::HandleProcessEvent(const SBProcess &process,
562                                     const SBEvent &event, FILE *out,
563                                     FILE *err) {
564   LLDB_RECORD_METHOD(
565       void, SBDebugger, HandleProcessEvent,
566       (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *), process,
567       event, out, err);
568 
569   FileSP outfile = std::make_shared<NativeFile>(out, false);
570   FileSP errfile = std::make_shared<NativeFile>(err, false);
571   return HandleProcessEvent(process, event, outfile, errfile);
572 }
573 
574 void SBDebugger::HandleProcessEvent(const SBProcess &process,
575                                     const SBEvent &event, FileSP out_sp,
576                                     FileSP err_sp) {
577 
578   LLDB_RECORD_METHOD(
579       void, SBDebugger, HandleProcessEvent,
580       (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP), process,
581       event, out_sp, err_sp);
582 
583   if (!process.IsValid())
584     return;
585 
586   TargetSP target_sp(process.GetTarget().GetSP());
587   if (!target_sp)
588     return;
589 
590   const uint32_t event_type = event.GetType();
591   char stdio_buffer[1024];
592   size_t len;
593 
594   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
595 
596   if (event_type &
597       (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged)) {
598     // Drain stdout when we stop just in case we have any bytes
599     while ((len = process.GetSTDOUT(stdio_buffer, sizeof(stdio_buffer))) > 0)
600       if (out_sp)
601         out_sp->Write(stdio_buffer, len);
602   }
603 
604   if (event_type &
605       (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged)) {
606     // Drain stderr when we stop just in case we have any bytes
607     while ((len = process.GetSTDERR(stdio_buffer, sizeof(stdio_buffer))) > 0)
608       if (err_sp)
609         err_sp->Write(stdio_buffer, len);
610   }
611 
612   if (event_type & Process::eBroadcastBitStateChanged) {
613     StateType event_state = SBProcess::GetStateFromEvent(event);
614 
615     if (event_state == eStateInvalid)
616       return;
617 
618     bool is_stopped = StateIsStoppedState(event_state);
619     if (!is_stopped)
620       process.ReportEventState(event, out_sp);
621   }
622 }
623 
624 SBSourceManager SBDebugger::GetSourceManager() {
625   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBSourceManager, SBDebugger,
626                              GetSourceManager);
627 
628   SBSourceManager sb_source_manager(*this);
629   return sb_source_manager;
630 }
631 
632 bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) {
633   LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, GetDefaultArchitecture,
634                             (char *, size_t), arch_name, "", arch_name_len);
635 
636   if (arch_name && arch_name_len) {
637     ArchSpec default_arch = Target::GetDefaultArchitecture();
638 
639     if (default_arch.IsValid()) {
640       const std::string &triple_str = default_arch.GetTriple().str();
641       if (!triple_str.empty())
642         ::snprintf(arch_name, arch_name_len, "%s", triple_str.c_str());
643       else
644         ::snprintf(arch_name, arch_name_len, "%s",
645                    default_arch.GetArchitectureName());
646       return true;
647     }
648   }
649   if (arch_name && arch_name_len)
650     arch_name[0] = '\0';
651   return false;
652 }
653 
654 bool SBDebugger::SetDefaultArchitecture(const char *arch_name) {
655   LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture,
656                             (const char *), arch_name);
657 
658   if (arch_name) {
659     ArchSpec arch(arch_name);
660     if (arch.IsValid()) {
661       Target::SetDefaultArchitecture(arch);
662       return true;
663     }
664   }
665   return false;
666 }
667 
668 ScriptLanguage
669 SBDebugger::GetScriptingLanguage(const char *script_language_name) {
670   LLDB_RECORD_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
671                      (const char *), script_language_name);
672 
673   if (!script_language_name)
674     return eScriptLanguageDefault;
675   return OptionArgParser::ToScriptLanguage(
676       llvm::StringRef(script_language_name), eScriptLanguageDefault, nullptr);
677 }
678 
679 SBStructuredData
680 SBDebugger::GetScriptInterpreterInfo(lldb::ScriptLanguage language) {
681   LLDB_RECORD_METHOD(SBStructuredData, SBDebugger, GetScriptInterpreterInfo,
682                      (lldb::ScriptLanguage), language);
683   SBStructuredData data;
684   if (m_opaque_sp) {
685     lldb_private::ScriptInterpreter *interp =
686         m_opaque_sp->GetScriptInterpreter(language);
687     if (interp) {
688       data.m_impl_up->SetObjectSP(interp->GetInterpreterInfo());
689     }
690   }
691   return data;
692 }
693 
694 const char *SBDebugger::GetVersionString() {
695   LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger, GetVersionString);
696 
697   return lldb_private::GetVersion();
698 }
699 
700 const char *SBDebugger::StateAsCString(StateType state) {
701   LLDB_RECORD_STATIC_METHOD(const char *, SBDebugger, StateAsCString,
702                             (lldb::StateType), state);
703 
704   return lldb_private::StateAsCString(state);
705 }
706 
707 static void AddBoolConfigEntry(StructuredData::Dictionary &dict,
708                                llvm::StringRef name, bool value,
709                                llvm::StringRef description) {
710   auto entry_up = std::make_unique<StructuredData::Dictionary>();
711   entry_up->AddBooleanItem("value", value);
712   entry_up->AddStringItem("description", description);
713   dict.AddItem(name, std::move(entry_up));
714 }
715 
716 static void AddLLVMTargets(StructuredData::Dictionary &dict) {
717   auto array_up = std::make_unique<StructuredData::Array>();
718 #define LLVM_TARGET(target)                                                    \
719   array_up->AddItem(std::make_unique<StructuredData::String>(#target));
720 #include "llvm/Config/Targets.def"
721   auto entry_up = std::make_unique<StructuredData::Dictionary>();
722   entry_up->AddItem("value", std::move(array_up));
723   entry_up->AddStringItem("description", "A list of configured LLVM targets.");
724   dict.AddItem("targets", std::move(entry_up));
725 }
726 
727 SBStructuredData SBDebugger::GetBuildConfiguration() {
728   LLDB_RECORD_STATIC_METHOD_NO_ARGS(lldb::SBStructuredData, SBDebugger,
729                                     GetBuildConfiguration);
730 
731   auto config_up = std::make_unique<StructuredData::Dictionary>();
732   AddBoolConfigEntry(
733       *config_up, "xml", XMLDocument::XMLEnabled(),
734       "A boolean value that indicates if XML support is enabled in LLDB");
735   AddBoolConfigEntry(
736       *config_up, "curses", LLDB_ENABLE_CURSES,
737       "A boolean value that indicates if curses support is enabled in LLDB");
738   AddBoolConfigEntry(
739       *config_up, "editline", LLDB_ENABLE_LIBEDIT,
740       "A boolean value that indicates if editline support is enabled in LLDB");
741   AddBoolConfigEntry(
742       *config_up, "lzma", LLDB_ENABLE_LZMA,
743       "A boolean value that indicates if lzma support is enabled in LLDB");
744   AddBoolConfigEntry(
745       *config_up, "python", LLDB_ENABLE_PYTHON,
746       "A boolean value that indicates if python support is enabled in LLDB");
747   AddBoolConfigEntry(
748       *config_up, "lua", LLDB_ENABLE_LUA,
749       "A boolean value that indicates if lua support is enabled in LLDB");
750   AddBoolConfigEntry(*config_up, "fbsdvmcore", LLDB_ENABLE_FBSDVMCORE,
751                      "A boolean value that indicates if fbsdvmcore support is "
752                      "enabled in LLDB");
753   AddLLVMTargets(*config_up);
754 
755   SBStructuredData data;
756   data.m_impl_up->SetObjectSP(std::move(config_up));
757   return data;
758 }
759 
760 bool SBDebugger::StateIsRunningState(StateType state) {
761   LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsRunningState,
762                             (lldb::StateType), state);
763 
764   const bool result = lldb_private::StateIsRunningState(state);
765 
766   return result;
767 }
768 
769 bool SBDebugger::StateIsStoppedState(StateType state) {
770   LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState,
771                             (lldb::StateType), state);
772 
773   const bool result = lldb_private::StateIsStoppedState(state, false);
774 
775   return result;
776 }
777 
778 lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
779                                         const char *target_triple,
780                                         const char *platform_name,
781                                         bool add_dependent_modules,
782                                         lldb::SBError &sb_error) {
783   LLDB_RECORD_METHOD(
784       lldb::SBTarget, SBDebugger, CreateTarget,
785       (const char *, const char *, const char *, bool, lldb::SBError &),
786       filename, target_triple, platform_name, add_dependent_modules, sb_error);
787 
788   SBTarget sb_target;
789   TargetSP target_sp;
790   if (m_opaque_sp) {
791     sb_error.Clear();
792     OptionGroupPlatform platform_options(false);
793     platform_options.SetPlatformName(platform_name);
794 
795     sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget(
796         *m_opaque_sp, filename, target_triple,
797         add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo,
798         &platform_options, target_sp);
799 
800     if (sb_error.Success())
801       sb_target.SetSP(target_sp);
802   } else {
803     sb_error.SetErrorString("invalid debugger");
804   }
805 
806   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
807   LLDB_LOGF(log,
808             "SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, "
809             "platform_name=%s, add_dependent_modules=%u, error=%s) => "
810             "SBTarget(%p)",
811             static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
812             platform_name, add_dependent_modules, sb_error.GetCString(),
813             static_cast<void *>(target_sp.get()));
814 
815   return sb_target;
816 }
817 
818 SBTarget
819 SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename,
820                                                 const char *target_triple) {
821   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger,
822                      CreateTargetWithFileAndTargetTriple,
823                      (const char *, const char *), filename, target_triple);
824 
825   SBTarget sb_target;
826   TargetSP target_sp;
827   if (m_opaque_sp) {
828     const bool add_dependent_modules = true;
829     Status error(m_opaque_sp->GetTargetList().CreateTarget(
830         *m_opaque_sp, filename, target_triple,
831         add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
832         target_sp));
833     sb_target.SetSP(target_sp);
834   }
835 
836   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
837   LLDB_LOGF(log,
838             "SBDebugger(%p)::CreateTargetWithFileAndTargetTriple "
839             "(filename=\"%s\", triple=%s) => SBTarget(%p)",
840             static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
841             static_cast<void *>(target_sp.get()));
842 
843   return sb_target;
844 }
845 
846 SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
847                                                  const char *arch_cstr) {
848   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch,
849                      (const char *, const char *), filename, arch_cstr);
850 
851   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
852 
853   SBTarget sb_target;
854   TargetSP target_sp;
855   if (m_opaque_sp) {
856     Status error;
857     if (arch_cstr == nullptr) {
858       // The version of CreateTarget that takes an ArchSpec won't accept an
859       // empty ArchSpec, so when the arch hasn't been specified, we need to
860       // call the target triple version.
861       error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, filename,
862           arch_cstr, eLoadDependentsYes, nullptr, target_sp);
863     } else {
864       PlatformSP platform_sp = m_opaque_sp->GetPlatformList()
865           .GetSelectedPlatform();
866       ArchSpec arch = Platform::GetAugmentedArchSpec(platform_sp.get(),
867           arch_cstr);
868       if (arch.IsValid())
869         error = m_opaque_sp->GetTargetList().CreateTarget(*m_opaque_sp, filename,
870             arch, eLoadDependentsYes, platform_sp, target_sp);
871       else
872         error.SetErrorStringWithFormat("invalid arch_cstr: %s", arch_cstr);
873     }
874     if (error.Success())
875       sb_target.SetSP(target_sp);
876   }
877 
878   LLDB_LOGF(log,
879             "SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", "
880             "arch=%s) => SBTarget(%p)",
881             static_cast<void *>(m_opaque_sp.get()),
882             filename ? filename : "<unspecified>",
883             arch_cstr ? arch_cstr : "<unspecified>",
884             static_cast<void *>(target_sp.get()));
885 
886   return sb_target;
887 }
888 
889 SBTarget SBDebugger::CreateTarget(const char *filename) {
890   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, (const char *),
891                      filename);
892 
893   SBTarget sb_target;
894   TargetSP target_sp;
895   if (m_opaque_sp) {
896     Status error;
897     const bool add_dependent_modules = true;
898     error = m_opaque_sp->GetTargetList().CreateTarget(
899         *m_opaque_sp, filename, "",
900         add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
901         target_sp);
902 
903     if (error.Success())
904       sb_target.SetSP(target_sp);
905   }
906   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
907   LLDB_LOGF(log,
908             "SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)",
909             static_cast<void *>(m_opaque_sp.get()), filename,
910             static_cast<void *>(target_sp.get()));
911   return sb_target;
912 }
913 
914 SBTarget SBDebugger::GetDummyTarget() {
915   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetDummyTarget);
916 
917   SBTarget sb_target;
918   if (m_opaque_sp) {
919     sb_target.SetSP(m_opaque_sp->GetDummyTarget().shared_from_this());
920   }
921   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
922   LLDB_LOGF(log, "SBDebugger(%p)::GetDummyTarget() => SBTarget(%p)",
923             static_cast<void *>(m_opaque_sp.get()),
924             static_cast<void *>(sb_target.GetSP().get()));
925   return sb_target;
926 }
927 
928 bool SBDebugger::DeleteTarget(lldb::SBTarget &target) {
929   LLDB_RECORD_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &),
930                      target);
931 
932   bool result = false;
933   if (m_opaque_sp) {
934     TargetSP target_sp(target.GetSP());
935     if (target_sp) {
936       // No need to lock, the target list is thread safe
937       result = m_opaque_sp->GetTargetList().DeleteTarget(target_sp);
938       target_sp->Destroy();
939       target.Clear();
940     }
941   }
942 
943   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
944   LLDB_LOGF(log, "SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i",
945             static_cast<void *>(m_opaque_sp.get()),
946             static_cast<void *>(target.m_opaque_sp.get()), result);
947 
948   return result;
949 }
950 
951 SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) {
952   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, (uint32_t),
953                      idx);
954 
955   SBTarget sb_target;
956   if (m_opaque_sp) {
957     // No need to lock, the target list is thread safe
958     sb_target.SetSP(m_opaque_sp->GetTargetList().GetTargetAtIndex(idx));
959   }
960   return sb_target;
961 }
962 
963 uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) {
964   LLDB_RECORD_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, (lldb::SBTarget),
965                      target);
966 
967   lldb::TargetSP target_sp = target.GetSP();
968   if (!target_sp)
969     return UINT32_MAX;
970 
971   if (!m_opaque_sp)
972     return UINT32_MAX;
973 
974   return m_opaque_sp->GetTargetList().GetIndexOfTarget(target.GetSP());
975 }
976 
977 SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) {
978   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
979                      (lldb::pid_t), pid);
980 
981   SBTarget sb_target;
982   if (m_opaque_sp) {
983     // No need to lock, the target list is thread safe
984     sb_target.SetSP(m_opaque_sp->GetTargetList().FindTargetWithProcessID(pid));
985   }
986   return sb_target;
987 }
988 
989 SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename,
990                                                const char *arch_name) {
991   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch,
992                      (const char *, const char *), filename, arch_name);
993 
994   SBTarget sb_target;
995   if (m_opaque_sp && filename && filename[0]) {
996     // No need to lock, the target list is thread safe
997     ArchSpec arch = Platform::GetAugmentedArchSpec(
998         m_opaque_sp->GetPlatformList().GetSelectedPlatform().get(), arch_name);
999     TargetSP target_sp(
1000         m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture(
1001             FileSpec(filename), arch_name ? &arch : nullptr));
1002     sb_target.SetSP(target_sp);
1003   }
1004   return sb_target;
1005 }
1006 
1007 SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) {
1008   SBTarget sb_target;
1009   if (m_opaque_sp) {
1010     // No need to lock, the target list is thread safe
1011     sb_target.SetSP(
1012         m_opaque_sp->GetTargetList().FindTargetWithProcess(process_sp.get()));
1013   }
1014   return sb_target;
1015 }
1016 
1017 uint32_t SBDebugger::GetNumTargets() {
1018   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumTargets);
1019 
1020   if (m_opaque_sp) {
1021     // No need to lock, the target list is thread safe
1022     return m_opaque_sp->GetTargetList().GetNumTargets();
1023   }
1024   return 0;
1025 }
1026 
1027 SBTarget SBDebugger::GetSelectedTarget() {
1028   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget);
1029 
1030   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
1031 
1032   SBTarget sb_target;
1033   TargetSP target_sp;
1034   if (m_opaque_sp) {
1035     // No need to lock, the target list is thread safe
1036     target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget();
1037     sb_target.SetSP(target_sp);
1038   }
1039 
1040   if (log) {
1041     SBStream sstr;
1042     sb_target.GetDescription(sstr, eDescriptionLevelBrief);
1043     LLDB_LOGF(log, "SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s",
1044               static_cast<void *>(m_opaque_sp.get()),
1045               static_cast<void *>(target_sp.get()), sstr.GetData());
1046   }
1047 
1048   return sb_target;
1049 }
1050 
1051 void SBDebugger::SetSelectedTarget(SBTarget &sb_target) {
1052   LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &),
1053                      sb_target);
1054 
1055   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
1056 
1057   TargetSP target_sp(sb_target.GetSP());
1058   if (m_opaque_sp) {
1059     m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp);
1060   }
1061   if (log) {
1062     SBStream sstr;
1063     sb_target.GetDescription(sstr, eDescriptionLevelBrief);
1064     LLDB_LOGF(log, "SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s",
1065               static_cast<void *>(m_opaque_sp.get()),
1066               static_cast<void *>(target_sp.get()), sstr.GetData());
1067   }
1068 }
1069 
1070 SBPlatform SBDebugger::GetSelectedPlatform() {
1071   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform);
1072 
1073   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
1074 
1075   SBPlatform sb_platform;
1076   DebuggerSP debugger_sp(m_opaque_sp);
1077   if (debugger_sp) {
1078     sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform());
1079   }
1080   LLDB_LOGF(log, "SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s",
1081             static_cast<void *>(m_opaque_sp.get()),
1082             static_cast<void *>(sb_platform.GetSP().get()),
1083             sb_platform.GetName());
1084   return sb_platform;
1085 }
1086 
1087 void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) {
1088   LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedPlatform,
1089                      (lldb::SBPlatform &), sb_platform);
1090 
1091   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
1092 
1093   DebuggerSP debugger_sp(m_opaque_sp);
1094   if (debugger_sp) {
1095     debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP());
1096   }
1097 
1098   LLDB_LOGF(log, "SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)",
1099             static_cast<void *>(m_opaque_sp.get()),
1100             static_cast<void *>(sb_platform.GetSP().get()),
1101             sb_platform.GetName());
1102 }
1103 
1104 uint32_t SBDebugger::GetNumPlatforms() {
1105   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumPlatforms);
1106 
1107   if (m_opaque_sp) {
1108     // No need to lock, the platform list is thread safe
1109     return m_opaque_sp->GetPlatformList().GetSize();
1110   }
1111   return 0;
1112 }
1113 
1114 SBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) {
1115   LLDB_RECORD_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex,
1116                      (uint32_t), idx);
1117 
1118   SBPlatform sb_platform;
1119   if (m_opaque_sp) {
1120     // No need to lock, the platform list is thread safe
1121     sb_platform.SetSP(m_opaque_sp->GetPlatformList().GetAtIndex(idx));
1122   }
1123   return sb_platform;
1124 }
1125 
1126 uint32_t SBDebugger::GetNumAvailablePlatforms() {
1127   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumAvailablePlatforms);
1128 
1129   uint32_t idx = 0;
1130   while (true) {
1131     if (PluginManager::GetPlatformPluginNameAtIndex(idx).empty()) {
1132       break;
1133     }
1134     ++idx;
1135   }
1136   // +1 for the host platform, which should always appear first in the list.
1137   return idx + 1;
1138 }
1139 
1140 SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) {
1141   LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger,
1142                      GetAvailablePlatformInfoAtIndex, (uint32_t), idx);
1143 
1144   SBStructuredData data;
1145   auto platform_dict = std::make_unique<StructuredData::Dictionary>();
1146   llvm::StringRef name_str("name"), desc_str("description");
1147 
1148   if (idx == 0) {
1149     PlatformSP host_platform_sp(Platform::GetHostPlatform());
1150     platform_dict->AddStringItem(name_str, host_platform_sp->GetPluginName());
1151     platform_dict->AddStringItem(
1152         desc_str, llvm::StringRef(host_platform_sp->GetDescription()));
1153   } else if (idx > 0) {
1154     llvm::StringRef plugin_name =
1155         PluginManager::GetPlatformPluginNameAtIndex(idx - 1);
1156     if (plugin_name.empty()) {
1157       return data;
1158     }
1159     platform_dict->AddStringItem(name_str, llvm::StringRef(plugin_name));
1160 
1161     llvm::StringRef plugin_desc =
1162         PluginManager::GetPlatformPluginDescriptionAtIndex(idx - 1);
1163     platform_dict->AddStringItem(desc_str, llvm::StringRef(plugin_desc));
1164   }
1165 
1166   data.m_impl_up->SetObjectSP(
1167       StructuredData::ObjectSP(platform_dict.release()));
1168   return data;
1169 }
1170 
1171 void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) {
1172   LLDB_RECORD_METHOD(void, SBDebugger, DispatchInput,
1173                      (void *, const void *, size_t), baton, data, data_len);
1174 
1175   DispatchInput(data, data_len);
1176 }
1177 
1178 void SBDebugger::DispatchInput(const void *data, size_t data_len) {
1179   LLDB_RECORD_METHOD(void, SBDebugger, DispatchInput, (const void *, size_t),
1180                      data, data_len);
1181 
1182   //    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1183   //
1184   //    if (log)
1185   //        LLDB_LOGF(log, "SBDebugger(%p)::DispatchInput (data=\"%.*s\",
1186   //        size_t=%" PRIu64 ")",
1187   //                     m_opaque_sp.get(),
1188   //                     (int) data_len,
1189   //                     (const char *) data,
1190   //                     (uint64_t)data_len);
1191   //
1192   //    if (m_opaque_sp)
1193   //        m_opaque_sp->DispatchInput ((const char *) data, data_len);
1194 }
1195 
1196 void SBDebugger::DispatchInputInterrupt() {
1197   LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputInterrupt);
1198 
1199   if (m_opaque_sp)
1200     m_opaque_sp->DispatchInputInterrupt();
1201 }
1202 
1203 void SBDebugger::DispatchInputEndOfFile() {
1204   LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputEndOfFile);
1205 
1206   if (m_opaque_sp)
1207     m_opaque_sp->DispatchInputEndOfFile();
1208 }
1209 
1210 void SBDebugger::PushInputReader(SBInputReader &reader) {
1211   LLDB_RECORD_METHOD(void, SBDebugger, PushInputReader, (lldb::SBInputReader &),
1212                      reader);
1213 }
1214 
1215 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
1216                                        bool spawn_thread) {
1217   LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool),
1218                      auto_handle_events, spawn_thread);
1219 
1220   if (m_opaque_sp) {
1221     CommandInterpreterRunOptions options;
1222     options.SetAutoHandleEvents(auto_handle_events);
1223     options.SetSpawnThread(spawn_thread);
1224     m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(options);
1225   }
1226 }
1227 
1228 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
1229                                        bool spawn_thread,
1230                                        SBCommandInterpreterRunOptions &options,
1231                                        int &num_errors, bool &quit_requested,
1232                                        bool &stopped_for_crash)
1233 
1234 {
1235   LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter,
1236                      (bool, bool, lldb::SBCommandInterpreterRunOptions &, int &,
1237                       bool &, bool &),
1238                      auto_handle_events, spawn_thread, options, num_errors,
1239                      quit_requested, stopped_for_crash);
1240 
1241   if (m_opaque_sp) {
1242     options.SetAutoHandleEvents(auto_handle_events);
1243     options.SetSpawnThread(spawn_thread);
1244     CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
1245     CommandInterpreterRunResult result =
1246         interp.RunCommandInterpreter(options.ref());
1247     num_errors = result.GetNumErrors();
1248     quit_requested =
1249         result.IsResult(lldb::eCommandInterpreterResultQuitRequested);
1250     stopped_for_crash =
1251         result.IsResult(lldb::eCommandInterpreterResultInferiorCrash);
1252   }
1253 }
1254 
1255 SBCommandInterpreterRunResult SBDebugger::RunCommandInterpreter(
1256     const SBCommandInterpreterRunOptions &options) {
1257   LLDB_RECORD_METHOD(lldb::SBCommandInterpreterRunResult, SBDebugger,
1258                      RunCommandInterpreter,
1259                      (const lldb::SBCommandInterpreterRunOptions &), options);
1260 
1261   if (!m_opaque_sp)
1262     return SBCommandInterpreterRunResult();
1263 
1264   CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
1265   CommandInterpreterRunResult result =
1266       interp.RunCommandInterpreter(options.ref());
1267 
1268   return SBCommandInterpreterRunResult(result);
1269 }
1270 
1271 SBError SBDebugger::RunREPL(lldb::LanguageType language,
1272                             const char *repl_options) {
1273   LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, RunREPL,
1274                      (lldb::LanguageType, const char *), language,
1275                      repl_options);
1276 
1277   SBError error;
1278   if (m_opaque_sp)
1279     error.ref() = m_opaque_sp->RunREPL(language, repl_options);
1280   else
1281     error.SetErrorString("invalid debugger");
1282   return error;
1283 }
1284 
1285 void SBDebugger::reset(const DebuggerSP &debugger_sp) {
1286   m_opaque_sp = debugger_sp;
1287 }
1288 
1289 Debugger *SBDebugger::get() const { return m_opaque_sp.get(); }
1290 
1291 Debugger &SBDebugger::ref() const {
1292   assert(m_opaque_sp.get());
1293   return *m_opaque_sp;
1294 }
1295 
1296 const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; }
1297 
1298 SBDebugger SBDebugger::FindDebuggerWithID(int id) {
1299   LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID,
1300                             (int), id);
1301 
1302   // No need to lock, the debugger list is thread safe
1303   SBDebugger sb_debugger;
1304   DebuggerSP debugger_sp = Debugger::FindDebuggerWithID(id);
1305   if (debugger_sp)
1306     sb_debugger.reset(debugger_sp);
1307   return sb_debugger;
1308 }
1309 
1310 const char *SBDebugger::GetInstanceName() {
1311   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBDebugger, GetInstanceName);
1312 
1313   return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr);
1314 }
1315 
1316 SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value,
1317                                         const char *debugger_instance_name) {
1318   LLDB_RECORD_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable,
1319                             (const char *, const char *, const char *),
1320                             var_name, value, debugger_instance_name);
1321 
1322   SBError sb_error;
1323   DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
1324       ConstString(debugger_instance_name)));
1325   Status error;
1326   if (debugger_sp) {
1327     ExecutionContext exe_ctx(
1328         debugger_sp->GetCommandInterpreter().GetExecutionContext());
1329     error = debugger_sp->SetPropertyValue(&exe_ctx, eVarSetOperationAssign,
1330                                           var_name, value);
1331   } else {
1332     error.SetErrorStringWithFormat("invalid debugger instance name '%s'",
1333                                    debugger_instance_name);
1334   }
1335   if (error.Fail())
1336     sb_error.SetError(error);
1337   return sb_error;
1338 }
1339 
1340 SBStringList
1341 SBDebugger::GetInternalVariableValue(const char *var_name,
1342                                      const char *debugger_instance_name) {
1343   LLDB_RECORD_STATIC_METHOD(
1344       lldb::SBStringList, SBDebugger, GetInternalVariableValue,
1345       (const char *, const char *), var_name, debugger_instance_name);
1346 
1347   DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
1348       ConstString(debugger_instance_name)));
1349   Status error;
1350   if (debugger_sp) {
1351     ExecutionContext exe_ctx(
1352         debugger_sp->GetCommandInterpreter().GetExecutionContext());
1353     lldb::OptionValueSP value_sp(
1354         debugger_sp->GetPropertyValue(&exe_ctx, var_name, false, error));
1355     if (value_sp) {
1356       StreamString value_strm;
1357       value_sp->DumpValue(&exe_ctx, value_strm, OptionValue::eDumpOptionValue);
1358       const std::string &value_str = std::string(value_strm.GetString());
1359       if (!value_str.empty()) {
1360         StringList string_list;
1361         string_list.SplitIntoLines(value_str);
1362         return SBStringList(&string_list);
1363       }
1364     }
1365   }
1366   return SBStringList();
1367 }
1368 
1369 uint32_t SBDebugger::GetTerminalWidth() const {
1370   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDebugger, GetTerminalWidth);
1371 
1372   return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0);
1373 }
1374 
1375 void SBDebugger::SetTerminalWidth(uint32_t term_width) {
1376   LLDB_RECORD_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t),
1377                      term_width);
1378 
1379   if (m_opaque_sp)
1380     m_opaque_sp->SetTerminalWidth(term_width);
1381 }
1382 
1383 const char *SBDebugger::GetPrompt() const {
1384   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetPrompt);
1385 
1386   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
1387 
1388   LLDB_LOGF(log, "SBDebugger(%p)::GetPrompt () => \"%s\"",
1389             static_cast<void *>(m_opaque_sp.get()),
1390             (m_opaque_sp ? m_opaque_sp->GetPrompt().str().c_str() : ""));
1391 
1392   return (m_opaque_sp ? ConstString(m_opaque_sp->GetPrompt()).GetCString()
1393                       : nullptr);
1394 }
1395 
1396 void SBDebugger::SetPrompt(const char *prompt) {
1397   LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt);
1398 
1399   if (m_opaque_sp)
1400     m_opaque_sp->SetPrompt(llvm::StringRef(prompt));
1401 }
1402 
1403 const char *SBDebugger::GetReproducerPath() const {
1404   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetReproducerPath);
1405 
1406   return (m_opaque_sp
1407               ? ConstString(m_opaque_sp->GetReproducerPath()).GetCString()
1408               : nullptr);
1409 }
1410 
1411 ScriptLanguage SBDebugger::GetScriptLanguage() const {
1412   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ScriptLanguage, SBDebugger,
1413                                    GetScriptLanguage);
1414 
1415   return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone);
1416 }
1417 
1418 void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) {
1419   LLDB_RECORD_METHOD(void, SBDebugger, SetScriptLanguage,
1420                      (lldb::ScriptLanguage), script_lang);
1421 
1422   if (m_opaque_sp) {
1423     m_opaque_sp->SetScriptLanguage(script_lang);
1424   }
1425 }
1426 
1427 LanguageType SBDebugger::GetREPLLanguage() const {
1428   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::LanguageType, SBDebugger,
1429                                    GetREPLLanguage);
1430 
1431   return (m_opaque_sp ? m_opaque_sp->GetREPLLanguage() : eLanguageTypeUnknown);
1432 }
1433 
1434 void SBDebugger::SetREPLLanguage(LanguageType repl_lang) {
1435   LLDB_RECORD_METHOD(void, SBDebugger, SetREPLLanguage, (lldb::LanguageType),
1436                      repl_lang);
1437 
1438   if (m_opaque_sp) {
1439     m_opaque_sp->SetREPLLanguage(repl_lang);
1440   }
1441 }
1442 
1443 bool SBDebugger::SetUseExternalEditor(bool value) {
1444   LLDB_RECORD_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value);
1445 
1446   return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false);
1447 }
1448 
1449 bool SBDebugger::GetUseExternalEditor() {
1450   LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetUseExternalEditor);
1451 
1452   return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false);
1453 }
1454 
1455 bool SBDebugger::SetUseColor(bool value) {
1456   LLDB_RECORD_METHOD(bool, SBDebugger, SetUseColor, (bool), value);
1457 
1458   return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false);
1459 }
1460 
1461 bool SBDebugger::GetUseColor() const {
1462   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseColor);
1463 
1464   return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false);
1465 }
1466 
1467 bool SBDebugger::SetUseSourceCache(bool value) {
1468   LLDB_RECORD_METHOD(bool, SBDebugger, SetUseSourceCache, (bool), value);
1469 
1470   return (m_opaque_sp ? m_opaque_sp->SetUseSourceCache(value) : false);
1471 }
1472 
1473 bool SBDebugger::GetUseSourceCache() const {
1474   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseSourceCache);
1475 
1476   return (m_opaque_sp ? m_opaque_sp->GetUseSourceCache() : false);
1477 }
1478 
1479 bool SBDebugger::GetDescription(SBStream &description) {
1480   LLDB_RECORD_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &),
1481                      description);
1482 
1483   Stream &strm = description.ref();
1484 
1485   if (m_opaque_sp) {
1486     const char *name = m_opaque_sp->GetInstanceName().AsCString();
1487     user_id_t id = m_opaque_sp->GetID();
1488     strm.Printf("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id);
1489   } else
1490     strm.PutCString("No value");
1491 
1492   return true;
1493 }
1494 
1495 user_id_t SBDebugger::GetID() {
1496   LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBDebugger, GetID);
1497 
1498   return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID);
1499 }
1500 
1501 SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
1502   LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform,
1503                      (const char *), platform_name_cstr);
1504 
1505   SBError sb_error;
1506   if (m_opaque_sp) {
1507     if (platform_name_cstr && platform_name_cstr[0]) {
1508       ConstString platform_name(platform_name_cstr);
1509       PlatformSP platform_sp(Platform::Find(platform_name));
1510 
1511       if (platform_sp) {
1512         // Already have a platform with this name, just select it
1513         m_opaque_sp->GetPlatformList().SetSelectedPlatform(platform_sp);
1514       } else {
1515         // We don't have a platform by this name yet, create one
1516         platform_sp = Platform::Create(platform_name, sb_error.ref());
1517         if (platform_sp) {
1518           // We created the platform, now append and select it
1519           bool make_selected = true;
1520           m_opaque_sp->GetPlatformList().Append(platform_sp, make_selected);
1521         }
1522       }
1523     } else {
1524       sb_error.ref().SetErrorString("invalid platform name");
1525     }
1526   } else {
1527     sb_error.ref().SetErrorString("invalid debugger");
1528   }
1529   return sb_error;
1530 }
1531 
1532 bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
1533   LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
1534                      (const char *), sysroot);
1535 
1536   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
1537   if (m_opaque_sp) {
1538     PlatformSP platform_sp(
1539         m_opaque_sp->GetPlatformList().GetSelectedPlatform());
1540 
1541     if (platform_sp) {
1542       if (log && sysroot)
1543         LLDB_LOGF(log, "SBDebugger::SetCurrentPlatformSDKRoot (\"%s\")",
1544                   sysroot);
1545       platform_sp->SetSDKRootDirectory(ConstString(sysroot));
1546       return true;
1547     }
1548   }
1549   return false;
1550 }
1551 
1552 bool SBDebugger::GetCloseInputOnEOF() const {
1553   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetCloseInputOnEOF);
1554 
1555   return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false);
1556 }
1557 
1558 void SBDebugger::SetCloseInputOnEOF(bool b) {
1559   LLDB_RECORD_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool), b);
1560 
1561   if (m_opaque_sp)
1562     m_opaque_sp->SetCloseInputOnEOF(b);
1563 }
1564 
1565 SBTypeCategory SBDebugger::GetCategory(const char *category_name) {
1566   LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
1567                      (const char *), category_name);
1568 
1569   if (!category_name || *category_name == 0)
1570     return SBTypeCategory();
1571 
1572   TypeCategoryImplSP category_sp;
1573 
1574   if (DataVisualization::Categories::GetCategory(ConstString(category_name),
1575                                                  category_sp, false)) {
1576     return SBTypeCategory(category_sp);
1577   } else {
1578     return SBTypeCategory();
1579   }
1580 }
1581 
1582 SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) {
1583   LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
1584                      (lldb::LanguageType), lang_type);
1585 
1586   TypeCategoryImplSP category_sp;
1587   if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) {
1588     return SBTypeCategory(category_sp);
1589   } else {
1590     return SBTypeCategory();
1591   }
1592 }
1593 
1594 SBTypeCategory SBDebugger::CreateCategory(const char *category_name) {
1595   LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
1596                      (const char *), category_name);
1597 
1598   if (!category_name || *category_name == 0)
1599     return SBTypeCategory();
1600 
1601   TypeCategoryImplSP category_sp;
1602 
1603   if (DataVisualization::Categories::GetCategory(ConstString(category_name),
1604                                                  category_sp, true)) {
1605     return SBTypeCategory(category_sp);
1606   } else {
1607     return SBTypeCategory();
1608   }
1609 }
1610 
1611 bool SBDebugger::DeleteCategory(const char *category_name) {
1612   LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *),
1613                      category_name);
1614 
1615   if (!category_name || *category_name == 0)
1616     return false;
1617 
1618   return DataVisualization::Categories::Delete(ConstString(category_name));
1619 }
1620 
1621 uint32_t SBDebugger::GetNumCategories() {
1622   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumCategories);
1623 
1624   return DataVisualization::Categories::GetCount();
1625 }
1626 
1627 SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) {
1628   LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
1629                      (uint32_t), index);
1630 
1631   return SBTypeCategory(
1632       DataVisualization::Categories::GetCategoryAtIndex(index));
1633 }
1634 
1635 SBTypeCategory SBDebugger::GetDefaultCategory() {
1636   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger,
1637                              GetDefaultCategory);
1638 
1639   return GetCategory("default");
1640 }
1641 
1642 SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) {
1643   LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
1644                      (lldb::SBTypeNameSpecifier), type_name);
1645 
1646   SBTypeCategory default_category_sb = GetDefaultCategory();
1647   if (default_category_sb.GetEnabled())
1648     return default_category_sb.GetFormatForType(type_name);
1649   return SBTypeFormat();
1650 }
1651 
1652 SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) {
1653   LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
1654                      (lldb::SBTypeNameSpecifier), type_name);
1655 
1656   if (!type_name.IsValid())
1657     return SBTypeSummary();
1658   return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()));
1659 }
1660 
1661 SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) {
1662   LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
1663                      (lldb::SBTypeNameSpecifier), type_name);
1664 
1665   if (!type_name.IsValid())
1666     return SBTypeFilter();
1667   return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()));
1668 }
1669 
1670 SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) {
1671   LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
1672                      (lldb::SBTypeNameSpecifier), type_name);
1673 
1674   if (!type_name.IsValid())
1675     return SBTypeSynthetic();
1676   return SBTypeSynthetic(
1677       DataVisualization::GetSyntheticForType(type_name.GetSP()));
1678 }
1679 
1680 static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) {
1681   if (categories == nullptr)
1682     return {};
1683   size_t len = 0;
1684   while (categories[len] != nullptr)
1685     ++len;
1686   return llvm::makeArrayRef(categories, len);
1687 }
1688 
1689 bool SBDebugger::EnableLog(const char *channel, const char **categories) {
1690   LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **),
1691                      channel, categories);
1692 
1693   if (m_opaque_sp) {
1694     uint32_t log_options =
1695         LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
1696     std::string error;
1697     llvm::raw_string_ostream error_stream(error);
1698     return m_opaque_sp->EnableLog(channel, GetCategoryArray(categories), "",
1699                                   log_options, error_stream);
1700   } else
1701     return false;
1702 }
1703 
1704 void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
1705                                     void *baton) {
1706   LLDB_RECORD_METHOD(void, SBDebugger, SetLoggingCallback,
1707                      (lldb::LogOutputCallback, void *), log_callback, baton);
1708 
1709   if (m_opaque_sp) {
1710     return m_opaque_sp->SetLoggingCallback(log_callback, baton);
1711   }
1712 }
1713