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