1 //===-- SBDebugger.cpp ------------------------------------------*- C++ -*-===//
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   AddLLVMTargets(*config_up);
690 
691   SBStructuredData data;
692   data.m_impl_up->SetObjectSP(std::move(config_up));
693   return LLDB_RECORD_RESULT(data);
694 }
695 
696 bool SBDebugger::StateIsRunningState(StateType state) {
697   LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsRunningState,
698                             (lldb::StateType), state);
699 
700   const bool result = lldb_private::StateIsRunningState(state);
701 
702   return result;
703 }
704 
705 bool SBDebugger::StateIsStoppedState(StateType state) {
706   LLDB_RECORD_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState,
707                             (lldb::StateType), state);
708 
709   const bool result = lldb_private::StateIsStoppedState(state, false);
710 
711   return result;
712 }
713 
714 lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
715                                         const char *target_triple,
716                                         const char *platform_name,
717                                         bool add_dependent_modules,
718                                         lldb::SBError &sb_error) {
719   LLDB_RECORD_METHOD(
720       lldb::SBTarget, SBDebugger, CreateTarget,
721       (const char *, const char *, const char *, bool, lldb::SBError &),
722       filename, target_triple, platform_name, add_dependent_modules, sb_error);
723 
724   SBTarget sb_target;
725   TargetSP target_sp;
726   if (m_opaque_sp) {
727     sb_error.Clear();
728     OptionGroupPlatform platform_options(false);
729     platform_options.SetPlatformName(platform_name);
730 
731     sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget(
732         *m_opaque_sp, filename, target_triple,
733         add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo,
734         &platform_options, target_sp);
735 
736     if (sb_error.Success())
737       sb_target.SetSP(target_sp);
738   } else {
739     sb_error.SetErrorString("invalid debugger");
740   }
741 
742   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
743   LLDB_LOGF(log,
744             "SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, "
745             "platform_name=%s, add_dependent_modules=%u, error=%s) => "
746             "SBTarget(%p)",
747             static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
748             platform_name, add_dependent_modules, sb_error.GetCString(),
749             static_cast<void *>(target_sp.get()));
750 
751   return LLDB_RECORD_RESULT(sb_target);
752 }
753 
754 SBTarget
755 SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename,
756                                                 const char *target_triple) {
757   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger,
758                      CreateTargetWithFileAndTargetTriple,
759                      (const char *, const char *), filename, target_triple);
760 
761   SBTarget sb_target;
762   TargetSP target_sp;
763   if (m_opaque_sp) {
764     const bool add_dependent_modules = true;
765     Status error(m_opaque_sp->GetTargetList().CreateTarget(
766         *m_opaque_sp, filename, target_triple,
767         add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
768         target_sp));
769     sb_target.SetSP(target_sp);
770   }
771 
772   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
773   LLDB_LOGF(log,
774             "SBDebugger(%p)::CreateTargetWithFileAndTargetTriple "
775             "(filename=\"%s\", triple=%s) => SBTarget(%p)",
776             static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
777             static_cast<void *>(target_sp.get()));
778 
779   return LLDB_RECORD_RESULT(sb_target);
780 }
781 
782 SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
783                                                  const char *arch_cstr) {
784   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch,
785                      (const char *, const char *), filename, arch_cstr);
786 
787   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
788 
789   SBTarget sb_target;
790   TargetSP target_sp;
791   if (m_opaque_sp) {
792     Status error;
793     const bool add_dependent_modules = true;
794 
795     error = m_opaque_sp->GetTargetList().CreateTarget(
796         *m_opaque_sp, filename, arch_cstr,
797         add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
798         target_sp);
799 
800     if (error.Success()) {
801       m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
802       sb_target.SetSP(target_sp);
803     }
804   }
805 
806   LLDB_LOGF(log,
807             "SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", "
808             "arch=%s) => SBTarget(%p)",
809             static_cast<void *>(m_opaque_sp.get()), filename, arch_cstr,
810             static_cast<void *>(target_sp.get()));
811 
812   return LLDB_RECORD_RESULT(sb_target);
813 }
814 
815 SBTarget SBDebugger::CreateTarget(const char *filename) {
816   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, CreateTarget, (const char *),
817                      filename);
818 
819   SBTarget sb_target;
820   TargetSP target_sp;
821   if (m_opaque_sp) {
822     Status error;
823     const bool add_dependent_modules = true;
824     error = m_opaque_sp->GetTargetList().CreateTarget(
825         *m_opaque_sp, filename, "",
826         add_dependent_modules ? eLoadDependentsYes : eLoadDependentsNo, nullptr,
827         target_sp);
828 
829     if (error.Success()) {
830       m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
831       sb_target.SetSP(target_sp);
832     }
833   }
834   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
835   LLDB_LOGF(log,
836             "SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)",
837             static_cast<void *>(m_opaque_sp.get()), filename,
838             static_cast<void *>(target_sp.get()));
839   return LLDB_RECORD_RESULT(sb_target);
840 }
841 
842 SBTarget SBDebugger::GetDummyTarget() {
843   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetDummyTarget);
844 
845   SBTarget sb_target;
846   if (m_opaque_sp) {
847     sb_target.SetSP(m_opaque_sp->GetDummyTarget()->shared_from_this());
848   }
849   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
850   LLDB_LOGF(log, "SBDebugger(%p)::GetDummyTarget() => SBTarget(%p)",
851             static_cast<void *>(m_opaque_sp.get()),
852             static_cast<void *>(sb_target.GetSP().get()));
853   return LLDB_RECORD_RESULT(sb_target);
854 }
855 
856 bool SBDebugger::DeleteTarget(lldb::SBTarget &target) {
857   LLDB_RECORD_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &),
858                      target);
859 
860   bool result = false;
861   if (m_opaque_sp) {
862     TargetSP target_sp(target.GetSP());
863     if (target_sp) {
864       // No need to lock, the target list is thread safe
865       result = m_opaque_sp->GetTargetList().DeleteTarget(target_sp);
866       target_sp->Destroy();
867       target.Clear();
868       const bool mandatory = true;
869       ModuleList::RemoveOrphanSharedModules(mandatory);
870     }
871   }
872 
873   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
874   LLDB_LOGF(log, "SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i",
875             static_cast<void *>(m_opaque_sp.get()),
876             static_cast<void *>(target.m_opaque_sp.get()), result);
877 
878   return result;
879 }
880 
881 SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) {
882   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex, (uint32_t),
883                      idx);
884 
885   SBTarget sb_target;
886   if (m_opaque_sp) {
887     // No need to lock, the target list is thread safe
888     sb_target.SetSP(m_opaque_sp->GetTargetList().GetTargetAtIndex(idx));
889   }
890   return LLDB_RECORD_RESULT(sb_target);
891 }
892 
893 uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) {
894   LLDB_RECORD_METHOD(uint32_t, SBDebugger, GetIndexOfTarget, (lldb::SBTarget),
895                      target);
896 
897   lldb::TargetSP target_sp = target.GetSP();
898   if (!target_sp)
899     return UINT32_MAX;
900 
901   if (!m_opaque_sp)
902     return UINT32_MAX;
903 
904   return m_opaque_sp->GetTargetList().GetIndexOfTarget(target.GetSP());
905 }
906 
907 SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) {
908   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
909                      (lldb::pid_t), pid);
910 
911   SBTarget sb_target;
912   if (m_opaque_sp) {
913     // No need to lock, the target list is thread safe
914     sb_target.SetSP(m_opaque_sp->GetTargetList().FindTargetWithProcessID(pid));
915   }
916   return LLDB_RECORD_RESULT(sb_target);
917 }
918 
919 SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename,
920                                                const char *arch_name) {
921   LLDB_RECORD_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch,
922                      (const char *, const char *), filename, arch_name);
923 
924   SBTarget sb_target;
925   if (m_opaque_sp && filename && filename[0]) {
926     // No need to lock, the target list is thread safe
927     ArchSpec arch = Platform::GetAugmentedArchSpec(
928         m_opaque_sp->GetPlatformList().GetSelectedPlatform().get(), arch_name);
929     TargetSP target_sp(
930         m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture(
931             FileSpec(filename), arch_name ? &arch : nullptr));
932     sb_target.SetSP(target_sp);
933   }
934   return LLDB_RECORD_RESULT(sb_target);
935 }
936 
937 SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) {
938   SBTarget sb_target;
939   if (m_opaque_sp) {
940     // No need to lock, the target list is thread safe
941     sb_target.SetSP(
942         m_opaque_sp->GetTargetList().FindTargetWithProcess(process_sp.get()));
943   }
944   return sb_target;
945 }
946 
947 uint32_t SBDebugger::GetNumTargets() {
948   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumTargets);
949 
950   if (m_opaque_sp) {
951     // No need to lock, the target list is thread safe
952     return m_opaque_sp->GetTargetList().GetNumTargets();
953   }
954   return 0;
955 }
956 
957 SBTarget SBDebugger::GetSelectedTarget() {
958   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTarget, SBDebugger, GetSelectedTarget);
959 
960   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
961 
962   SBTarget sb_target;
963   TargetSP target_sp;
964   if (m_opaque_sp) {
965     // No need to lock, the target list is thread safe
966     target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget();
967     sb_target.SetSP(target_sp);
968   }
969 
970   if (log) {
971     SBStream sstr;
972     sb_target.GetDescription(sstr, eDescriptionLevelBrief);
973     LLDB_LOGF(log, "SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s",
974               static_cast<void *>(m_opaque_sp.get()),
975               static_cast<void *>(target_sp.get()), sstr.GetData());
976   }
977 
978   return LLDB_RECORD_RESULT(sb_target);
979 }
980 
981 void SBDebugger::SetSelectedTarget(SBTarget &sb_target) {
982   LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &),
983                      sb_target);
984 
985   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
986 
987   TargetSP target_sp(sb_target.GetSP());
988   if (m_opaque_sp) {
989     m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
990   }
991   if (log) {
992     SBStream sstr;
993     sb_target.GetDescription(sstr, eDescriptionLevelBrief);
994     LLDB_LOGF(log, "SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s",
995               static_cast<void *>(m_opaque_sp.get()),
996               static_cast<void *>(target_sp.get()), sstr.GetData());
997   }
998 }
999 
1000 SBPlatform SBDebugger::GetSelectedPlatform() {
1001   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBPlatform, SBDebugger, GetSelectedPlatform);
1002 
1003   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
1004 
1005   SBPlatform sb_platform;
1006   DebuggerSP debugger_sp(m_opaque_sp);
1007   if (debugger_sp) {
1008     sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform());
1009   }
1010   LLDB_LOGF(log, "SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s",
1011             static_cast<void *>(m_opaque_sp.get()),
1012             static_cast<void *>(sb_platform.GetSP().get()),
1013             sb_platform.GetName());
1014   return LLDB_RECORD_RESULT(sb_platform);
1015 }
1016 
1017 void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) {
1018   LLDB_RECORD_METHOD(void, SBDebugger, SetSelectedPlatform,
1019                      (lldb::SBPlatform &), sb_platform);
1020 
1021   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
1022 
1023   DebuggerSP debugger_sp(m_opaque_sp);
1024   if (debugger_sp) {
1025     debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP());
1026   }
1027 
1028   LLDB_LOGF(log, "SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)",
1029             static_cast<void *>(m_opaque_sp.get()),
1030             static_cast<void *>(sb_platform.GetSP().get()),
1031             sb_platform.GetName());
1032 }
1033 
1034 uint32_t SBDebugger::GetNumPlatforms() {
1035   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumPlatforms);
1036 
1037   if (m_opaque_sp) {
1038     // No need to lock, the platform list is thread safe
1039     return m_opaque_sp->GetPlatformList().GetSize();
1040   }
1041   return 0;
1042 }
1043 
1044 SBPlatform SBDebugger::GetPlatformAtIndex(uint32_t idx) {
1045   LLDB_RECORD_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex,
1046                      (uint32_t), idx);
1047 
1048   SBPlatform sb_platform;
1049   if (m_opaque_sp) {
1050     // No need to lock, the platform list is thread safe
1051     sb_platform.SetSP(m_opaque_sp->GetPlatformList().GetAtIndex(idx));
1052   }
1053   return LLDB_RECORD_RESULT(sb_platform);
1054 }
1055 
1056 uint32_t SBDebugger::GetNumAvailablePlatforms() {
1057   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumAvailablePlatforms);
1058 
1059   uint32_t idx = 0;
1060   while (true) {
1061     if (!PluginManager::GetPlatformPluginNameAtIndex(idx)) {
1062       break;
1063     }
1064     ++idx;
1065   }
1066   // +1 for the host platform, which should always appear first in the list.
1067   return idx + 1;
1068 }
1069 
1070 SBStructuredData SBDebugger::GetAvailablePlatformInfoAtIndex(uint32_t idx) {
1071   LLDB_RECORD_METHOD(lldb::SBStructuredData, SBDebugger,
1072                      GetAvailablePlatformInfoAtIndex, (uint32_t), idx);
1073 
1074   SBStructuredData data;
1075   auto platform_dict = std::make_unique<StructuredData::Dictionary>();
1076   llvm::StringRef name_str("name"), desc_str("description");
1077 
1078   if (idx == 0) {
1079     PlatformSP host_platform_sp(Platform::GetHostPlatform());
1080     platform_dict->AddStringItem(
1081         name_str, host_platform_sp->GetPluginName().GetStringRef());
1082     platform_dict->AddStringItem(
1083         desc_str, llvm::StringRef(host_platform_sp->GetDescription()));
1084   } else if (idx > 0) {
1085     const char *plugin_name =
1086         PluginManager::GetPlatformPluginNameAtIndex(idx - 1);
1087     if (!plugin_name) {
1088       return LLDB_RECORD_RESULT(data);
1089     }
1090     platform_dict->AddStringItem(name_str, llvm::StringRef(plugin_name));
1091 
1092     const char *plugin_desc =
1093         PluginManager::GetPlatformPluginDescriptionAtIndex(idx - 1);
1094     if (!plugin_desc) {
1095       return LLDB_RECORD_RESULT(data);
1096     }
1097     platform_dict->AddStringItem(desc_str, llvm::StringRef(plugin_desc));
1098   }
1099 
1100   data.m_impl_up->SetObjectSP(
1101       StructuredData::ObjectSP(platform_dict.release()));
1102   return LLDB_RECORD_RESULT(data);
1103 }
1104 
1105 void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) {
1106   LLDB_RECORD_DUMMY(void, SBDebugger, DispatchInput,
1107                     (void *, const void *, size_t), baton, data, data_len);
1108 
1109   DispatchInput(data, data_len);
1110 }
1111 
1112 void SBDebugger::DispatchInput(const void *data, size_t data_len) {
1113   LLDB_RECORD_DUMMY(void, SBDebugger, DispatchInput, (const void *, size_t),
1114                     data, data_len);
1115 
1116   //    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1117   //
1118   //    if (log)
1119   //        LLDB_LOGF(log, "SBDebugger(%p)::DispatchInput (data=\"%.*s\",
1120   //        size_t=%" PRIu64 ")",
1121   //                     m_opaque_sp.get(),
1122   //                     (int) data_len,
1123   //                     (const char *) data,
1124   //                     (uint64_t)data_len);
1125   //
1126   //    if (m_opaque_sp)
1127   //        m_opaque_sp->DispatchInput ((const char *) data, data_len);
1128 }
1129 
1130 void SBDebugger::DispatchInputInterrupt() {
1131   LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, DispatchInputInterrupt);
1132 
1133   if (m_opaque_sp)
1134     m_opaque_sp->DispatchInputInterrupt();
1135 }
1136 
1137 void SBDebugger::DispatchInputEndOfFile() {
1138   LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputEndOfFile);
1139 
1140   if (m_opaque_sp)
1141     m_opaque_sp->DispatchInputEndOfFile();
1142 }
1143 
1144 void SBDebugger::PushInputReader(SBInputReader &reader) {
1145   LLDB_RECORD_METHOD(void, SBDebugger, PushInputReader, (lldb::SBInputReader &),
1146                      reader);
1147 }
1148 
1149 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
1150                                        bool spawn_thread) {
1151   LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool),
1152                      auto_handle_events, spawn_thread);
1153 
1154   if (m_opaque_sp) {
1155     CommandInterpreterRunOptions options;
1156 
1157     m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(
1158         auto_handle_events, spawn_thread, options);
1159   }
1160 }
1161 
1162 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
1163                                        bool spawn_thread,
1164                                        SBCommandInterpreterRunOptions &options,
1165                                        int &num_errors, bool &quit_requested,
1166                                        bool &stopped_for_crash)
1167 
1168 {
1169   LLDB_RECORD_METHOD(void, SBDebugger, RunCommandInterpreter,
1170                      (bool, bool, lldb::SBCommandInterpreterRunOptions &, int &,
1171                       bool &, bool &),
1172                      auto_handle_events, spawn_thread, options, num_errors,
1173                      quit_requested, stopped_for_crash);
1174 
1175   if (m_opaque_sp) {
1176     CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
1177     interp.RunCommandInterpreter(auto_handle_events, spawn_thread,
1178                                  options.ref());
1179     num_errors = interp.GetNumErrors();
1180     quit_requested = interp.GetQuitRequested();
1181     stopped_for_crash = interp.GetStoppedForCrash();
1182   }
1183 }
1184 
1185 SBError SBDebugger::RunREPL(lldb::LanguageType language,
1186                             const char *repl_options) {
1187   LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, RunREPL,
1188                      (lldb::LanguageType, const char *), language,
1189                      repl_options);
1190 
1191   SBError error;
1192   if (m_opaque_sp)
1193     error.ref() = m_opaque_sp->RunREPL(language, repl_options);
1194   else
1195     error.SetErrorString("invalid debugger");
1196   return LLDB_RECORD_RESULT(error);
1197 }
1198 
1199 void SBDebugger::reset(const DebuggerSP &debugger_sp) {
1200   m_opaque_sp = debugger_sp;
1201 }
1202 
1203 Debugger *SBDebugger::get() const { return m_opaque_sp.get(); }
1204 
1205 Debugger &SBDebugger::ref() const {
1206   assert(m_opaque_sp.get());
1207   return *m_opaque_sp;
1208 }
1209 
1210 const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; }
1211 
1212 SBDebugger SBDebugger::FindDebuggerWithID(int id) {
1213   LLDB_RECORD_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID,
1214                             (int), id);
1215 
1216   // No need to lock, the debugger list is thread safe
1217   SBDebugger sb_debugger;
1218   DebuggerSP debugger_sp = Debugger::FindDebuggerWithID(id);
1219   if (debugger_sp)
1220     sb_debugger.reset(debugger_sp);
1221   return LLDB_RECORD_RESULT(sb_debugger);
1222 }
1223 
1224 const char *SBDebugger::GetInstanceName() {
1225   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBDebugger, GetInstanceName);
1226 
1227   return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr);
1228 }
1229 
1230 SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value,
1231                                         const char *debugger_instance_name) {
1232   LLDB_RECORD_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable,
1233                             (const char *, const char *, const char *),
1234                             var_name, value, debugger_instance_name);
1235 
1236   SBError sb_error;
1237   DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
1238       ConstString(debugger_instance_name)));
1239   Status error;
1240   if (debugger_sp) {
1241     ExecutionContext exe_ctx(
1242         debugger_sp->GetCommandInterpreter().GetExecutionContext());
1243     error = debugger_sp->SetPropertyValue(&exe_ctx, eVarSetOperationAssign,
1244                                           var_name, value);
1245   } else {
1246     error.SetErrorStringWithFormat("invalid debugger instance name '%s'",
1247                                    debugger_instance_name);
1248   }
1249   if (error.Fail())
1250     sb_error.SetError(error);
1251   return LLDB_RECORD_RESULT(sb_error);
1252 }
1253 
1254 SBStringList
1255 SBDebugger::GetInternalVariableValue(const char *var_name,
1256                                      const char *debugger_instance_name) {
1257   LLDB_RECORD_STATIC_METHOD(
1258       lldb::SBStringList, SBDebugger, GetInternalVariableValue,
1259       (const char *, const char *), var_name, debugger_instance_name);
1260 
1261   SBStringList ret_value;
1262   DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
1263       ConstString(debugger_instance_name)));
1264   Status error;
1265   if (debugger_sp) {
1266     ExecutionContext exe_ctx(
1267         debugger_sp->GetCommandInterpreter().GetExecutionContext());
1268     lldb::OptionValueSP value_sp(
1269         debugger_sp->GetPropertyValue(&exe_ctx, var_name, false, error));
1270     if (value_sp) {
1271       StreamString value_strm;
1272       value_sp->DumpValue(&exe_ctx, value_strm, OptionValue::eDumpOptionValue);
1273       const std::string &value_str = value_strm.GetString();
1274       if (!value_str.empty()) {
1275         StringList string_list;
1276         string_list.SplitIntoLines(value_str);
1277         return LLDB_RECORD_RESULT(SBStringList(&string_list));
1278       }
1279     }
1280   }
1281   return LLDB_RECORD_RESULT(SBStringList());
1282 }
1283 
1284 uint32_t SBDebugger::GetTerminalWidth() const {
1285   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBDebugger, GetTerminalWidth);
1286 
1287   return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0);
1288 }
1289 
1290 void SBDebugger::SetTerminalWidth(uint32_t term_width) {
1291   LLDB_RECORD_DUMMY(void, SBDebugger, SetTerminalWidth, (uint32_t), term_width);
1292 
1293   if (m_opaque_sp)
1294     m_opaque_sp->SetTerminalWidth(term_width);
1295 }
1296 
1297 const char *SBDebugger::GetPrompt() const {
1298   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetPrompt);
1299 
1300   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
1301 
1302   LLDB_LOGF(log, "SBDebugger(%p)::GetPrompt () => \"%s\"",
1303             static_cast<void *>(m_opaque_sp.get()),
1304             (m_opaque_sp ? m_opaque_sp->GetPrompt().str().c_str() : ""));
1305 
1306   return (m_opaque_sp ? ConstString(m_opaque_sp->GetPrompt()).GetCString()
1307                       : nullptr);
1308 }
1309 
1310 void SBDebugger::SetPrompt(const char *prompt) {
1311   LLDB_RECORD_METHOD(void, SBDebugger, SetPrompt, (const char *), prompt);
1312 
1313   if (m_opaque_sp)
1314     m_opaque_sp->SetPrompt(llvm::StringRef::withNullAsEmpty(prompt));
1315 }
1316 
1317 const char *SBDebugger::GetReproducerPath() const {
1318   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBDebugger, GetReproducerPath);
1319 
1320   return (m_opaque_sp
1321               ? ConstString(m_opaque_sp->GetReproducerPath()).GetCString()
1322               : nullptr);
1323 }
1324 
1325 ScriptLanguage SBDebugger::GetScriptLanguage() const {
1326   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::ScriptLanguage, SBDebugger,
1327                                    GetScriptLanguage);
1328 
1329   return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone);
1330 }
1331 
1332 void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) {
1333   LLDB_RECORD_METHOD(void, SBDebugger, SetScriptLanguage,
1334                      (lldb::ScriptLanguage), script_lang);
1335 
1336   if (m_opaque_sp) {
1337     m_opaque_sp->SetScriptLanguage(script_lang);
1338   }
1339 }
1340 
1341 bool SBDebugger::SetUseExternalEditor(bool value) {
1342   LLDB_RECORD_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool), value);
1343 
1344   return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false);
1345 }
1346 
1347 bool SBDebugger::GetUseExternalEditor() {
1348   LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetUseExternalEditor);
1349 
1350   return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false);
1351 }
1352 
1353 bool SBDebugger::SetUseColor(bool value) {
1354   LLDB_RECORD_METHOD(bool, SBDebugger, SetUseColor, (bool), value);
1355 
1356   return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false);
1357 }
1358 
1359 bool SBDebugger::GetUseColor() const {
1360   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetUseColor);
1361 
1362   return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false);
1363 }
1364 
1365 bool SBDebugger::GetDescription(SBStream &description) {
1366   LLDB_RECORD_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &),
1367                      description);
1368 
1369   Stream &strm = description.ref();
1370 
1371   if (m_opaque_sp) {
1372     const char *name = m_opaque_sp->GetInstanceName().AsCString();
1373     user_id_t id = m_opaque_sp->GetID();
1374     strm.Printf("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id);
1375   } else
1376     strm.PutCString("No value");
1377 
1378   return true;
1379 }
1380 
1381 user_id_t SBDebugger::GetID() {
1382   LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBDebugger, GetID);
1383 
1384   return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID);
1385 }
1386 
1387 SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
1388   LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform,
1389                      (const char *), platform_name_cstr);
1390 
1391   SBError sb_error;
1392   if (m_opaque_sp) {
1393     if (platform_name_cstr && platform_name_cstr[0]) {
1394       ConstString platform_name(platform_name_cstr);
1395       PlatformSP platform_sp(Platform::Find(platform_name));
1396 
1397       if (platform_sp) {
1398         // Already have a platform with this name, just select it
1399         m_opaque_sp->GetPlatformList().SetSelectedPlatform(platform_sp);
1400       } else {
1401         // We don't have a platform by this name yet, create one
1402         platform_sp = Platform::Create(platform_name, sb_error.ref());
1403         if (platform_sp) {
1404           // We created the platform, now append and select it
1405           bool make_selected = true;
1406           m_opaque_sp->GetPlatformList().Append(platform_sp, make_selected);
1407         }
1408       }
1409     } else {
1410       sb_error.ref().SetErrorString("invalid platform name");
1411     }
1412   } else {
1413     sb_error.ref().SetErrorString("invalid debugger");
1414   }
1415   return LLDB_RECORD_RESULT(sb_error);
1416 }
1417 
1418 bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
1419   LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
1420                      (const char *), sysroot);
1421 
1422   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
1423   if (m_opaque_sp) {
1424     PlatformSP platform_sp(
1425         m_opaque_sp->GetPlatformList().GetSelectedPlatform());
1426 
1427     if (platform_sp) {
1428       if (log && sysroot)
1429         LLDB_LOGF(log, "SBDebugger::SetCurrentPlatformSDKRoot (\"%s\")",
1430                   sysroot);
1431       platform_sp->SetSDKRootDirectory(ConstString(sysroot));
1432       return true;
1433     }
1434   }
1435   return false;
1436 }
1437 
1438 bool SBDebugger::GetCloseInputOnEOF() const {
1439   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetCloseInputOnEOF);
1440 
1441   return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false);
1442 }
1443 
1444 void SBDebugger::SetCloseInputOnEOF(bool b) {
1445   LLDB_RECORD_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool), b);
1446 
1447   if (m_opaque_sp)
1448     m_opaque_sp->SetCloseInputOnEOF(b);
1449 }
1450 
1451 SBTypeCategory SBDebugger::GetCategory(const char *category_name) {
1452   LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
1453                      (const char *), category_name);
1454 
1455   if (!category_name || *category_name == 0)
1456     return LLDB_RECORD_RESULT(SBTypeCategory());
1457 
1458   TypeCategoryImplSP category_sp;
1459 
1460   if (DataVisualization::Categories::GetCategory(ConstString(category_name),
1461                                                  category_sp, false)) {
1462     return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
1463   } else {
1464     return LLDB_RECORD_RESULT(SBTypeCategory());
1465   }
1466 }
1467 
1468 SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) {
1469   LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
1470                      (lldb::LanguageType), lang_type);
1471 
1472   TypeCategoryImplSP category_sp;
1473   if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) {
1474     return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
1475   } else {
1476     return LLDB_RECORD_RESULT(SBTypeCategory());
1477   }
1478 }
1479 
1480 SBTypeCategory SBDebugger::CreateCategory(const char *category_name) {
1481   LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
1482                      (const char *), category_name);
1483 
1484   if (!category_name || *category_name == 0)
1485     return LLDB_RECORD_RESULT(SBTypeCategory());
1486 
1487   TypeCategoryImplSP category_sp;
1488 
1489   if (DataVisualization::Categories::GetCategory(ConstString(category_name),
1490                                                  category_sp, true)) {
1491     return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
1492   } else {
1493     return LLDB_RECORD_RESULT(SBTypeCategory());
1494   }
1495 }
1496 
1497 bool SBDebugger::DeleteCategory(const char *category_name) {
1498   LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *),
1499                      category_name);
1500 
1501   if (!category_name || *category_name == 0)
1502     return false;
1503 
1504   return DataVisualization::Categories::Delete(ConstString(category_name));
1505 }
1506 
1507 uint32_t SBDebugger::GetNumCategories() {
1508   LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumCategories);
1509 
1510   return DataVisualization::Categories::GetCount();
1511 }
1512 
1513 SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) {
1514   LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
1515                      (uint32_t), index);
1516 
1517   return LLDB_RECORD_RESULT(
1518       SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index)));
1519 }
1520 
1521 SBTypeCategory SBDebugger::GetDefaultCategory() {
1522   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger,
1523                              GetDefaultCategory);
1524 
1525   return LLDB_RECORD_RESULT(GetCategory("default"));
1526 }
1527 
1528 SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) {
1529   LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
1530                      (lldb::SBTypeNameSpecifier), type_name);
1531 
1532   SBTypeCategory default_category_sb = GetDefaultCategory();
1533   if (default_category_sb.GetEnabled())
1534     return LLDB_RECORD_RESULT(default_category_sb.GetFormatForType(type_name));
1535   return LLDB_RECORD_RESULT(SBTypeFormat());
1536 }
1537 
1538 SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) {
1539   LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
1540                      (lldb::SBTypeNameSpecifier), type_name);
1541 
1542   if (!type_name.IsValid())
1543     return LLDB_RECORD_RESULT(SBTypeSummary());
1544   return LLDB_RECORD_RESULT(
1545       SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP())));
1546 }
1547 
1548 SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) {
1549   LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
1550                      (lldb::SBTypeNameSpecifier), type_name);
1551 
1552   if (!type_name.IsValid())
1553     return LLDB_RECORD_RESULT(SBTypeFilter());
1554   return LLDB_RECORD_RESULT(
1555       SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP())));
1556 }
1557 
1558 SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) {
1559   LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
1560                      (lldb::SBTypeNameSpecifier), type_name);
1561 
1562   if (!type_name.IsValid())
1563     return LLDB_RECORD_RESULT(SBTypeSynthetic());
1564   return LLDB_RECORD_RESULT(SBTypeSynthetic(
1565       DataVisualization::GetSyntheticForType(type_name.GetSP())));
1566 }
1567 
1568 static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) {
1569   if (categories == nullptr)
1570     return {};
1571   size_t len = 0;
1572   while (categories[len] != nullptr)
1573     ++len;
1574   return llvm::makeArrayRef(categories, len);
1575 }
1576 
1577 bool SBDebugger::EnableLog(const char *channel, const char **categories) {
1578   LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **),
1579                      channel, categories);
1580 
1581   if (m_opaque_sp) {
1582     uint32_t log_options =
1583         LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
1584     std::string error;
1585     llvm::raw_string_ostream error_stream(error);
1586     return m_opaque_sp->EnableLog(channel, GetCategoryArray(categories), "",
1587                                   log_options, error_stream);
1588   } else
1589     return false;
1590 }
1591 
1592 void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
1593                                     void *baton) {
1594   LLDB_RECORD_DUMMY(void, SBDebugger, SetLoggingCallback,
1595                     (lldb::LogOutputCallback, void *), log_callback, baton);
1596 
1597   if (m_opaque_sp) {
1598     return m_opaque_sp->SetLoggingCallback(log_callback, baton);
1599   }
1600 }
1601 
1602 namespace lldb_private {
1603 namespace repro {
1604 
1605 template <> void RegisterMethods<SBInputReader>(Registry &R) {
1606   LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool));
1607   LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ());
1608 }
1609 
1610 static void SetFileHandleRedirect(SBDebugger *, FILE *, bool) {
1611   // Do nothing.
1612 }
1613 
1614 static SBError SetFileRedirect(SBDebugger *, SBFile file) { return SBError(); }
1615 
1616 static SBError SetFileRedirect(SBDebugger *, FileSP file) { return SBError(); }
1617 
1618 static bool GetDefaultArchitectureRedirect(char *arch_name,
1619                                            size_t arch_name_len) {
1620   // The function is writing to its argument. Without the redirect it would
1621   // write into the replay buffer.
1622   char buffer[1024];
1623   return SBDebugger::GetDefaultArchitecture(buffer, arch_name_len);
1624 }
1625 
1626 template <> void RegisterMethods<SBDebugger>(Registry &R) {
1627   // Custom implementation.
1628   R.Register(&invoke<void (SBDebugger::*)(
1629                  FILE *, bool)>::method<&SBDebugger::SetErrorFileHandle>::doit,
1630              &SetFileHandleRedirect);
1631   R.Register(&invoke<void (SBDebugger::*)(
1632                  FILE *, bool)>::method<&SBDebugger::SetOutputFileHandle>::doit,
1633              &SetFileHandleRedirect);
1634   R.Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
1635                                        &SBDebugger::GetDefaultArchitecture),
1636                                    &GetDefaultArchitectureRedirect);
1637 
1638   R.Register(&invoke<SBError (SBDebugger::*)(
1639                  SBFile)>::method<&SBDebugger::SetInputFile>::doit,
1640              &SetFileRedirect);
1641   R.Register(&invoke<SBError (SBDebugger::*)(
1642                  SBFile)>::method<&SBDebugger::SetOutputFile>::doit,
1643              &SetFileRedirect);
1644   R.Register(&invoke<SBError (SBDebugger::*)(
1645                  SBFile)>::method<&SBDebugger::SetErrorFile>::doit,
1646              &SetFileRedirect);
1647 
1648   R.Register(&invoke<SBError (SBDebugger::*)(
1649                  FileSP)>::method<&SBDebugger::SetInputFile>::doit,
1650              &SetFileRedirect);
1651   R.Register(&invoke<SBError (SBDebugger::*)(
1652                  FileSP)>::method<&SBDebugger::SetOutputFile>::doit,
1653              &SetFileRedirect);
1654   R.Register(&invoke<SBError (SBDebugger::*)(
1655                  FileSP)>::method<&SBDebugger::SetErrorFile>::doit,
1656              &SetFileRedirect);
1657 
1658   LLDB_REGISTER_CONSTRUCTOR(SBDebugger, ());
1659   LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &));
1660   LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &));
1661   LLDB_REGISTER_METHOD(lldb::SBDebugger &,
1662                        SBDebugger, operator=,(const lldb::SBDebugger &));
1663   LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Initialize, ());
1664   LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger,
1665                               InitializeWithErrorHandling, ());
1666   LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Terminate, ());
1667   LLDB_REGISTER_METHOD(void, SBDebugger, Clear, ());
1668   LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, ());
1669   LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool));
1670   LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &));
1671   LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ());
1672   LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ());
1673   LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, operator bool,());
1674   LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool));
1675   LLDB_REGISTER_METHOD(bool, SBDebugger, GetAsync, ());
1676   LLDB_REGISTER_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool));
1677   LLDB_REGISTER_METHOD(void, SBDebugger, SkipAppInitFiles, (bool));
1678   LLDB_REGISTER_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool));
1679   LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetInputFileHandle, ());
1680   LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ());
1681   LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ());
1682   LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetInputFile, ());
1683   LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetOutputFile, ());
1684   LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetErrorFile, ());
1685   LLDB_REGISTER_METHOD(void, SBDebugger, SaveInputTerminalState, ());
1686   LLDB_REGISTER_METHOD(void, SBDebugger, RestoreInputTerminalState, ());
1687   LLDB_REGISTER_METHOD(lldb::SBCommandInterpreter, SBDebugger,
1688                        GetCommandInterpreter, ());
1689   LLDB_REGISTER_METHOD(void, SBDebugger, HandleCommand, (const char *));
1690   LLDB_REGISTER_METHOD(lldb::SBListener, SBDebugger, GetListener, ());
1691   LLDB_REGISTER_METHOD(
1692       void, SBDebugger, HandleProcessEvent,
1693       (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *));
1694   LLDB_REGISTER_METHOD(
1695       void, SBDebugger, HandleProcessEvent,
1696       (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile));
1697   LLDB_REGISTER_METHOD(
1698       void, SBDebugger, HandleProcessEvent,
1699       (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP));
1700   LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBDebugger, GetSourceManager, ());
1701   LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture,
1702                               (const char *));
1703   LLDB_REGISTER_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
1704                        (const char *));
1705   LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetVersionString, ());
1706   LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, StateAsCString,
1707                               (lldb::StateType));
1708   LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBDebugger,
1709                               GetBuildConfiguration, ());
1710   LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsRunningState,
1711                               (lldb::StateType));
1712   LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState,
1713                               (lldb::StateType));
1714   LLDB_REGISTER_METHOD(
1715       lldb::SBTarget, SBDebugger, CreateTarget,
1716       (const char *, const char *, const char *, bool, lldb::SBError &));
1717   LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger,
1718                        CreateTargetWithFileAndTargetTriple,
1719                        (const char *, const char *));
1720   LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch,
1721                        (const char *, const char *));
1722   LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTarget,
1723                        (const char *));
1724   LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetDummyTarget, ());
1725   LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &));
1726   LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex,
1727                        (uint32_t));
1728   LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetIndexOfTarget,
1729                        (lldb::SBTarget));
1730   LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
1731                        (lldb::pid_t));
1732   LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch,
1733                        (const char *, const char *));
1734   LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumTargets, ());
1735   LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetSelectedTarget, ());
1736   LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &));
1737   LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetSelectedPlatform, ());
1738   LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedPlatform,
1739                        (lldb::SBPlatform &));
1740   LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumPlatforms, ());
1741   LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex,
1742                        (uint32_t));
1743   LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumAvailablePlatforms, ());
1744   LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBDebugger,
1745                        GetAvailablePlatformInfoAtIndex, (uint32_t));
1746   LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputInterrupt, ());
1747   LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputEndOfFile, ());
1748   LLDB_REGISTER_METHOD(void, SBDebugger, PushInputReader,
1749                        (lldb::SBInputReader &));
1750   LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool));
1751   LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter,
1752                        (bool, bool, lldb::SBCommandInterpreterRunOptions &,
1753                         int &, bool &, bool &));
1754   LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, RunREPL,
1755                        (lldb::LanguageType, const char *));
1756   LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID,
1757                               (int));
1758   LLDB_REGISTER_METHOD(const char *, SBDebugger, GetInstanceName, ());
1759   LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable,
1760                               (const char *, const char *, const char *));
1761   LLDB_REGISTER_STATIC_METHOD(lldb::SBStringList, SBDebugger,
1762                               GetInternalVariableValue,
1763                               (const char *, const char *));
1764   LLDB_REGISTER_METHOD_CONST(uint32_t, SBDebugger, GetTerminalWidth, ());
1765   LLDB_REGISTER_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t));
1766   LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetPrompt, ());
1767   LLDB_REGISTER_METHOD(void, SBDebugger, SetPrompt, (const char *));
1768   LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetReproducerPath, ());
1769   LLDB_REGISTER_METHOD_CONST(lldb::ScriptLanguage, SBDebugger,
1770                              GetScriptLanguage, ());
1771   LLDB_REGISTER_METHOD(void, SBDebugger, SetScriptLanguage,
1772                        (lldb::ScriptLanguage));
1773   LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool));
1774   LLDB_REGISTER_METHOD(bool, SBDebugger, GetUseExternalEditor, ());
1775   LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseColor, (bool));
1776   LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetUseColor, ());
1777   LLDB_REGISTER_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &));
1778   LLDB_REGISTER_METHOD(lldb::user_id_t, SBDebugger, GetID, ());
1779   LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform,
1780                        (const char *));
1781   LLDB_REGISTER_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
1782                        (const char *));
1783   LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetCloseInputOnEOF, ());
1784   LLDB_REGISTER_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool));
1785   LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
1786                        (const char *));
1787   LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
1788                        (lldb::LanguageType));
1789   LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
1790                        (const char *));
1791   LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteCategory, (const char *));
1792   LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumCategories, ());
1793   LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
1794                        (uint32_t));
1795   LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetDefaultCategory,
1796                        ());
1797   LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
1798                        (lldb::SBTypeNameSpecifier));
1799   LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
1800                        (lldb::SBTypeNameSpecifier));
1801   LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
1802                        (lldb::SBTypeNameSpecifier));
1803   LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
1804                        (lldb::SBTypeNameSpecifier));
1805   LLDB_REGISTER_METHOD(bool, SBDebugger, EnableLog,
1806                        (const char *, const char **));
1807 }
1808 
1809 } // namespace repro
1810 } // namespace lldb_private
1811