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