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
59using namespace lldb;
60using namespace lldb_private;
61
62static 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
98static llvm::ManagedStatic<SystemLifetimeManager> g_debugger_lifetime;
99
100SBError 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
118void SBInputReader::SetIsDone(bool b) {
119  LLDB_RECORD_METHOD(void, SBInputReader, SetIsDone, (bool), b);
120}
121
122bool SBInputReader::IsActive() const {
123  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBInputReader, IsActive);
124
125  return false;
126}
127
128SBDebugger::SBDebugger() { LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBDebugger); }
129
130SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp)
131    : m_opaque_sp(debugger_sp) {
132  LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &), debugger_sp);
133}
134
135SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) {
136  LLDB_RECORD_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &), rhs);
137}
138
139SBDebugger::~SBDebugger() = default;
140
141SBDebugger &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
151void SBDebugger::Initialize() {
152  LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Initialize);
153  SBError ignored = SBDebugger::InitializeWithErrorHandling();
154}
155
156lldb::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
168void SBDebugger::Terminate() {
169  LLDB_RECORD_STATIC_METHOD_NO_ARGS(void, SBDebugger, Terminate);
170
171  g_debugger_lifetime->Terminate();
172}
173
174void 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
183SBDebugger 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
189SBDebugger 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
197SBDebugger 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
230void 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
240void 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
253bool SBDebugger::IsValid() const {
254  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, IsValid);
255  return this->operator bool();
256}
257SBDebugger::operator bool() const {
258  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, operator bool);
259
260  return m_opaque_sp.get() != nullptr;
261}
262
263void 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
270bool SBDebugger::GetAsync() {
271  LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetAsync);
272
273  return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false);
274}
275
276void 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
283void 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
290void 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
296SBError 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.
304SBError 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
342SBError 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
347void 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
353SBError 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
368void 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
374SBError 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
379SBError 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
394FILE *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
403SBFile 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
411FILE *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
420SBFile 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
429FILE *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
439SBFile 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
449void SBDebugger::SaveInputTerminalState() {
450  LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, SaveInputTerminalState);
451
452  if (m_opaque_sp)
453    m_opaque_sp->SaveInputTerminalState();
454}
455
456void SBDebugger::RestoreInputTerminalState() {
457  LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, RestoreInputTerminalState);
458
459  if (m_opaque_sp)
460    m_opaque_sp->RestoreInputTerminalState();
461}
462SBCommandInterpreter 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
473void 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
506SBListener 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
516void 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
527void 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
540void 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
590SBSourceManager 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
598bool 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
620bool 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
634ScriptLanguage
635SBDebugger::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
645const char *SBDebugger::GetVersionString() {
646  LLDB_RECORD_STATIC_METHOD_NO_ARGS(const char *, SBDebugger, GetVersionString);
647
648  return lldb_private::GetVersion();
649}
650
651const 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
658static 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
667static 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
678SBStructuredData 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
708bool 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
717bool 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
726lldb::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
766SBTarget
767SBDebugger::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
794SBTarget 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
827SBTarget 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
854SBTarget 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
868bool 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
893SBTarget 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
905uint32_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
919SBTarget 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
931SBTarget 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
949SBTarget 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
959uint32_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
969SBTarget 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
993void 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
1012SBPlatform 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
1029void 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
1046uint32_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
1056SBPlatform 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
1068uint32_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
1082SBStructuredData 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
1117void 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
1124void 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
1142void SBDebugger::DispatchInputInterrupt() {
1143  LLDB_RECORD_DUMMY_NO_ARGS(void, SBDebugger, DispatchInputInterrupt);
1144
1145  if (m_opaque_sp)
1146    m_opaque_sp->DispatchInputInterrupt();
1147}
1148
1149void SBDebugger::DispatchInputEndOfFile() {
1150  LLDB_RECORD_METHOD_NO_ARGS(void, SBDebugger, DispatchInputEndOfFile);
1151
1152  if (m_opaque_sp)
1153    m_opaque_sp->DispatchInputEndOfFile();
1154}
1155
1156void SBDebugger::PushInputReader(SBInputReader &reader) {
1157  LLDB_RECORD_METHOD(void, SBDebugger, PushInputReader, (lldb::SBInputReader &),
1158                     reader);
1159}
1160
1161void 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
1174void 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
1197SBError 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
1211void SBDebugger::reset(const DebuggerSP &debugger_sp) {
1212  m_opaque_sp = debugger_sp;
1213}
1214
1215Debugger *SBDebugger::get() const { return m_opaque_sp.get(); }
1216
1217Debugger &SBDebugger::ref() const {
1218  assert(m_opaque_sp.get());
1219  return *m_opaque_sp;
1220}
1221
1222const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; }
1223
1224SBDebugger 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
1236const 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
1242SBError 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
1266SBStringList
1267SBDebugger::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 = 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
1296uint32_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
1302void 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
1309const 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
1322void 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
1329const 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
1337ScriptLanguage 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
1344void 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
1353bool 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
1359bool SBDebugger::GetUseExternalEditor() {
1360  LLDB_RECORD_METHOD_NO_ARGS(bool, SBDebugger, GetUseExternalEditor);
1361
1362  return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false);
1363}
1364
1365bool 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
1371bool 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
1377bool SBDebugger::GetDescription(SBStream &description) {
1378  LLDB_RECORD_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &),
1379                     description);
1380
1381  Stream &strm = description.ref();
1382
1383  if (m_opaque_sp) {
1384    const char *name = m_opaque_sp->GetInstanceName().AsCString();
1385    user_id_t id = m_opaque_sp->GetID();
1386    strm.Printf("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id);
1387  } else
1388    strm.PutCString("No value");
1389
1390  return true;
1391}
1392
1393user_id_t SBDebugger::GetID() {
1394  LLDB_RECORD_METHOD_NO_ARGS(lldb::user_id_t, SBDebugger, GetID);
1395
1396  return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID);
1397}
1398
1399SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
1400  LLDB_RECORD_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform,
1401                     (const char *), platform_name_cstr);
1402
1403  SBError sb_error;
1404  if (m_opaque_sp) {
1405    if (platform_name_cstr && platform_name_cstr[0]) {
1406      ConstString platform_name(platform_name_cstr);
1407      PlatformSP platform_sp(Platform::Find(platform_name));
1408
1409      if (platform_sp) {
1410        // Already have a platform with this name, just select it
1411        m_opaque_sp->GetPlatformList().SetSelectedPlatform(platform_sp);
1412      } else {
1413        // We don't have a platform by this name yet, create one
1414        platform_sp = Platform::Create(platform_name, sb_error.ref());
1415        if (platform_sp) {
1416          // We created the platform, now append and select it
1417          bool make_selected = true;
1418          m_opaque_sp->GetPlatformList().Append(platform_sp, make_selected);
1419        }
1420      }
1421    } else {
1422      sb_error.ref().SetErrorString("invalid platform name");
1423    }
1424  } else {
1425    sb_error.ref().SetErrorString("invalid debugger");
1426  }
1427  return LLDB_RECORD_RESULT(sb_error);
1428}
1429
1430bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
1431  LLDB_RECORD_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
1432                     (const char *), sysroot);
1433
1434  Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
1435  if (m_opaque_sp) {
1436    PlatformSP platform_sp(
1437        m_opaque_sp->GetPlatformList().GetSelectedPlatform());
1438
1439    if (platform_sp) {
1440      if (log && sysroot)
1441        LLDB_LOGF(log, "SBDebugger::SetCurrentPlatformSDKRoot (\"%s\")",
1442                  sysroot);
1443      platform_sp->SetSDKRootDirectory(ConstString(sysroot));
1444      return true;
1445    }
1446  }
1447  return false;
1448}
1449
1450bool SBDebugger::GetCloseInputOnEOF() const {
1451  LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBDebugger, GetCloseInputOnEOF);
1452
1453  return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false);
1454}
1455
1456void SBDebugger::SetCloseInputOnEOF(bool b) {
1457  LLDB_RECORD_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool), b);
1458
1459  if (m_opaque_sp)
1460    m_opaque_sp->SetCloseInputOnEOF(b);
1461}
1462
1463SBTypeCategory SBDebugger::GetCategory(const char *category_name) {
1464  LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
1465                     (const char *), category_name);
1466
1467  if (!category_name || *category_name == 0)
1468    return LLDB_RECORD_RESULT(SBTypeCategory());
1469
1470  TypeCategoryImplSP category_sp;
1471
1472  if (DataVisualization::Categories::GetCategory(ConstString(category_name),
1473                                                 category_sp, false)) {
1474    return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
1475  } else {
1476    return LLDB_RECORD_RESULT(SBTypeCategory());
1477  }
1478}
1479
1480SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) {
1481  LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
1482                     (lldb::LanguageType), lang_type);
1483
1484  TypeCategoryImplSP category_sp;
1485  if (DataVisualization::Categories::GetCategory(lang_type, category_sp)) {
1486    return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
1487  } else {
1488    return LLDB_RECORD_RESULT(SBTypeCategory());
1489  }
1490}
1491
1492SBTypeCategory SBDebugger::CreateCategory(const char *category_name) {
1493  LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
1494                     (const char *), category_name);
1495
1496  if (!category_name || *category_name == 0)
1497    return LLDB_RECORD_RESULT(SBTypeCategory());
1498
1499  TypeCategoryImplSP category_sp;
1500
1501  if (DataVisualization::Categories::GetCategory(ConstString(category_name),
1502                                                 category_sp, true)) {
1503    return LLDB_RECORD_RESULT(SBTypeCategory(category_sp));
1504  } else {
1505    return LLDB_RECORD_RESULT(SBTypeCategory());
1506  }
1507}
1508
1509bool SBDebugger::DeleteCategory(const char *category_name) {
1510  LLDB_RECORD_METHOD(bool, SBDebugger, DeleteCategory, (const char *),
1511                     category_name);
1512
1513  if (!category_name || *category_name == 0)
1514    return false;
1515
1516  return DataVisualization::Categories::Delete(ConstString(category_name));
1517}
1518
1519uint32_t SBDebugger::GetNumCategories() {
1520  LLDB_RECORD_METHOD_NO_ARGS(uint32_t, SBDebugger, GetNumCategories);
1521
1522  return DataVisualization::Categories::GetCount();
1523}
1524
1525SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) {
1526  LLDB_RECORD_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
1527                     (uint32_t), index);
1528
1529  return LLDB_RECORD_RESULT(
1530      SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index)));
1531}
1532
1533SBTypeCategory SBDebugger::GetDefaultCategory() {
1534  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBTypeCategory, SBDebugger,
1535                             GetDefaultCategory);
1536
1537  return LLDB_RECORD_RESULT(GetCategory("default"));
1538}
1539
1540SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) {
1541  LLDB_RECORD_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
1542                     (lldb::SBTypeNameSpecifier), type_name);
1543
1544  SBTypeCategory default_category_sb = GetDefaultCategory();
1545  if (default_category_sb.GetEnabled())
1546    return LLDB_RECORD_RESULT(default_category_sb.GetFormatForType(type_name));
1547  return LLDB_RECORD_RESULT(SBTypeFormat());
1548}
1549
1550SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) {
1551  LLDB_RECORD_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
1552                     (lldb::SBTypeNameSpecifier), type_name);
1553
1554  if (!type_name.IsValid())
1555    return LLDB_RECORD_RESULT(SBTypeSummary());
1556  return LLDB_RECORD_RESULT(
1557      SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP())));
1558}
1559
1560SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) {
1561  LLDB_RECORD_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
1562                     (lldb::SBTypeNameSpecifier), type_name);
1563
1564  if (!type_name.IsValid())
1565    return LLDB_RECORD_RESULT(SBTypeFilter());
1566  return LLDB_RECORD_RESULT(
1567      SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP())));
1568}
1569
1570SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) {
1571  LLDB_RECORD_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
1572                     (lldb::SBTypeNameSpecifier), type_name);
1573
1574  if (!type_name.IsValid())
1575    return LLDB_RECORD_RESULT(SBTypeSynthetic());
1576  return LLDB_RECORD_RESULT(SBTypeSynthetic(
1577      DataVisualization::GetSyntheticForType(type_name.GetSP())));
1578}
1579
1580static llvm::ArrayRef<const char *> GetCategoryArray(const char **categories) {
1581  if (categories == nullptr)
1582    return {};
1583  size_t len = 0;
1584  while (categories[len] != nullptr)
1585    ++len;
1586  return llvm::makeArrayRef(categories, len);
1587}
1588
1589bool SBDebugger::EnableLog(const char *channel, const char **categories) {
1590  LLDB_RECORD_METHOD(bool, SBDebugger, EnableLog, (const char *, const char **),
1591                     channel, categories);
1592
1593  if (m_opaque_sp) {
1594    uint32_t log_options =
1595        LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
1596    std::string error;
1597    llvm::raw_string_ostream error_stream(error);
1598    return m_opaque_sp->EnableLog(channel, GetCategoryArray(categories), "",
1599                                  log_options, error_stream);
1600  } else
1601    return false;
1602}
1603
1604void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
1605                                    void *baton) {
1606  LLDB_RECORD_DUMMY(void, SBDebugger, SetLoggingCallback,
1607                    (lldb::LogOutputCallback, void *), log_callback, baton);
1608
1609  if (m_opaque_sp) {
1610    return m_opaque_sp->SetLoggingCallback(log_callback, baton);
1611  }
1612}
1613
1614namespace lldb_private {
1615namespace repro {
1616
1617template <> void RegisterMethods<SBInputReader>(Registry &R) {
1618  LLDB_REGISTER_METHOD(void, SBInputReader, SetIsDone, (bool));
1619  LLDB_REGISTER_METHOD_CONST(bool, SBInputReader, IsActive, ());
1620}
1621
1622static void SetFileHandleRedirect(SBDebugger *, FILE *, bool) {
1623  // Do nothing.
1624}
1625
1626static SBError SetFileRedirect(SBDebugger *, SBFile file) { return SBError(); }
1627
1628static SBError SetFileRedirect(SBDebugger *, FileSP file) { return SBError(); }
1629
1630static bool GetDefaultArchitectureRedirect(char *arch_name,
1631                                           size_t arch_name_len) {
1632  // The function is writing to its argument. Without the redirect it would
1633  // write into the replay buffer.
1634  char buffer[1024];
1635  return SBDebugger::GetDefaultArchitecture(buffer, arch_name_len);
1636}
1637
1638template <> void RegisterMethods<SBDebugger>(Registry &R) {
1639  // Custom implementation.
1640  R.Register(&invoke<void (SBDebugger::*)(
1641                 FILE *, bool)>::method<&SBDebugger::SetErrorFileHandle>::doit,
1642             &SetFileHandleRedirect);
1643  R.Register(&invoke<void (SBDebugger::*)(
1644                 FILE *, bool)>::method<&SBDebugger::SetOutputFileHandle>::doit,
1645             &SetFileHandleRedirect);
1646  R.Register<bool(char *, size_t)>(static_cast<bool (*)(char *, size_t)>(
1647                                       &SBDebugger::GetDefaultArchitecture),
1648                                   &GetDefaultArchitectureRedirect);
1649
1650  R.Register(&invoke<SBError (SBDebugger::*)(
1651                 SBFile)>::method<&SBDebugger::SetInputFile>::doit,
1652             &SetFileRedirect);
1653  R.Register(&invoke<SBError (SBDebugger::*)(
1654                 SBFile)>::method<&SBDebugger::SetOutputFile>::doit,
1655             &SetFileRedirect);
1656  R.Register(&invoke<SBError (SBDebugger::*)(
1657                 SBFile)>::method<&SBDebugger::SetErrorFile>::doit,
1658             &SetFileRedirect);
1659
1660  R.Register(&invoke<SBError (SBDebugger::*)(
1661                 FileSP)>::method<&SBDebugger::SetInputFile>::doit,
1662             &SetFileRedirect);
1663  R.Register(&invoke<SBError (SBDebugger::*)(
1664                 FileSP)>::method<&SBDebugger::SetOutputFile>::doit,
1665             &SetFileRedirect);
1666  R.Register(&invoke<SBError (SBDebugger::*)(
1667                 FileSP)>::method<&SBDebugger::SetErrorFile>::doit,
1668             &SetFileRedirect);
1669
1670  LLDB_REGISTER_CONSTRUCTOR(SBDebugger, ());
1671  LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::DebuggerSP &));
1672  LLDB_REGISTER_CONSTRUCTOR(SBDebugger, (const lldb::SBDebugger &));
1673  LLDB_REGISTER_METHOD(lldb::SBDebugger &,
1674                       SBDebugger, operator=,(const lldb::SBDebugger &));
1675  LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Initialize, ());
1676  LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger,
1677                              InitializeWithErrorHandling, ());
1678  LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Terminate, ());
1679  LLDB_REGISTER_METHOD(void, SBDebugger, Clear, ());
1680  LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, ());
1681  LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, Create, (bool));
1682  LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, Destroy, (lldb::SBDebugger &));
1683  LLDB_REGISTER_STATIC_METHOD(void, SBDebugger, MemoryPressureDetected, ());
1684  LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, IsValid, ());
1685  LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, operator bool,());
1686  LLDB_REGISTER_METHOD(void, SBDebugger, SetAsync, (bool));
1687  LLDB_REGISTER_METHOD(bool, SBDebugger, GetAsync, ());
1688  LLDB_REGISTER_METHOD(void, SBDebugger, SkipLLDBInitFiles, (bool));
1689  LLDB_REGISTER_METHOD(void, SBDebugger, SkipAppInitFiles, (bool));
1690  LLDB_REGISTER_METHOD(void, SBDebugger, SetInputFileHandle, (FILE *, bool));
1691  LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetInputFileHandle, ());
1692  LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetOutputFileHandle, ());
1693  LLDB_REGISTER_METHOD(FILE *, SBDebugger, GetErrorFileHandle, ());
1694  LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetInputFile, ());
1695  LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetOutputFile, ());
1696  LLDB_REGISTER_METHOD(SBFile, SBDebugger, GetErrorFile, ());
1697  LLDB_REGISTER_METHOD(void, SBDebugger, SaveInputTerminalState, ());
1698  LLDB_REGISTER_METHOD(void, SBDebugger, RestoreInputTerminalState, ());
1699  LLDB_REGISTER_METHOD(lldb::SBCommandInterpreter, SBDebugger,
1700                       GetCommandInterpreter, ());
1701  LLDB_REGISTER_METHOD(void, SBDebugger, HandleCommand, (const char *));
1702  LLDB_REGISTER_METHOD(lldb::SBListener, SBDebugger, GetListener, ());
1703  LLDB_REGISTER_METHOD(
1704      void, SBDebugger, HandleProcessEvent,
1705      (const lldb::SBProcess &, const lldb::SBEvent &, FILE *, FILE *));
1706  LLDB_REGISTER_METHOD(
1707      void, SBDebugger, HandleProcessEvent,
1708      (const lldb::SBProcess &, const lldb::SBEvent &, SBFile, SBFile));
1709  LLDB_REGISTER_METHOD(
1710      void, SBDebugger, HandleProcessEvent,
1711      (const lldb::SBProcess &, const lldb::SBEvent &, FileSP, FileSP));
1712  LLDB_REGISTER_METHOD(lldb::SBSourceManager, SBDebugger, GetSourceManager, ());
1713  LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, SetDefaultArchitecture,
1714                              (const char *));
1715  LLDB_REGISTER_METHOD(lldb::ScriptLanguage, SBDebugger, GetScriptingLanguage,
1716                       (const char *));
1717  LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, GetVersionString, ());
1718  LLDB_REGISTER_STATIC_METHOD(const char *, SBDebugger, StateAsCString,
1719                              (lldb::StateType));
1720  LLDB_REGISTER_STATIC_METHOD(lldb::SBStructuredData, SBDebugger,
1721                              GetBuildConfiguration, ());
1722  LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsRunningState,
1723                              (lldb::StateType));
1724  LLDB_REGISTER_STATIC_METHOD(bool, SBDebugger, StateIsStoppedState,
1725                              (lldb::StateType));
1726  LLDB_REGISTER_METHOD(
1727      lldb::SBTarget, SBDebugger, CreateTarget,
1728      (const char *, const char *, const char *, bool, lldb::SBError &));
1729  LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger,
1730                       CreateTargetWithFileAndTargetTriple,
1731                       (const char *, const char *));
1732  LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTargetWithFileAndArch,
1733                       (const char *, const char *));
1734  LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, CreateTarget,
1735                       (const char *));
1736  LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetDummyTarget, ());
1737  LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteTarget, (lldb::SBTarget &));
1738  LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetTargetAtIndex,
1739                       (uint32_t));
1740  LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetIndexOfTarget,
1741                       (lldb::SBTarget));
1742  LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithProcessID,
1743                       (lldb::pid_t));
1744  LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, FindTargetWithFileAndArch,
1745                       (const char *, const char *));
1746  LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumTargets, ());
1747  LLDB_REGISTER_METHOD(lldb::SBTarget, SBDebugger, GetSelectedTarget, ());
1748  LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedTarget, (lldb::SBTarget &));
1749  LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetSelectedPlatform, ());
1750  LLDB_REGISTER_METHOD(void, SBDebugger, SetSelectedPlatform,
1751                       (lldb::SBPlatform &));
1752  LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumPlatforms, ());
1753  LLDB_REGISTER_METHOD(lldb::SBPlatform, SBDebugger, GetPlatformAtIndex,
1754                       (uint32_t));
1755  LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumAvailablePlatforms, ());
1756  LLDB_REGISTER_METHOD(lldb::SBStructuredData, SBDebugger,
1757                       GetAvailablePlatformInfoAtIndex, (uint32_t));
1758  LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputInterrupt, ());
1759  LLDB_REGISTER_METHOD(void, SBDebugger, DispatchInputEndOfFile, ());
1760  LLDB_REGISTER_METHOD(void, SBDebugger, PushInputReader,
1761                       (lldb::SBInputReader &));
1762  LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter, (bool, bool));
1763  LLDB_REGISTER_METHOD(void, SBDebugger, RunCommandInterpreter,
1764                       (bool, bool, lldb::SBCommandInterpreterRunOptions &,
1765                        int &, bool &, bool &));
1766  LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, RunREPL,
1767                       (lldb::LanguageType, const char *));
1768  LLDB_REGISTER_STATIC_METHOD(lldb::SBDebugger, SBDebugger, FindDebuggerWithID,
1769                              (int));
1770  LLDB_REGISTER_METHOD(const char *, SBDebugger, GetInstanceName, ());
1771  LLDB_REGISTER_STATIC_METHOD(lldb::SBError, SBDebugger, SetInternalVariable,
1772                              (const char *, const char *, const char *));
1773  LLDB_REGISTER_STATIC_METHOD(lldb::SBStringList, SBDebugger,
1774                              GetInternalVariableValue,
1775                              (const char *, const char *));
1776  LLDB_REGISTER_METHOD_CONST(uint32_t, SBDebugger, GetTerminalWidth, ());
1777  LLDB_REGISTER_METHOD(void, SBDebugger, SetTerminalWidth, (uint32_t));
1778  LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetPrompt, ());
1779  LLDB_REGISTER_METHOD(void, SBDebugger, SetPrompt, (const char *));
1780  LLDB_REGISTER_METHOD_CONST(const char *, SBDebugger, GetReproducerPath, ());
1781  LLDB_REGISTER_METHOD_CONST(lldb::ScriptLanguage, SBDebugger,
1782                             GetScriptLanguage, ());
1783  LLDB_REGISTER_METHOD(void, SBDebugger, SetScriptLanguage,
1784                       (lldb::ScriptLanguage));
1785  LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseExternalEditor, (bool));
1786  LLDB_REGISTER_METHOD(bool, SBDebugger, GetUseExternalEditor, ());
1787  LLDB_REGISTER_METHOD(bool, SBDebugger, SetUseColor, (bool));
1788  LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetUseColor, ());
1789  LLDB_REGISTER_METHOD(bool, SBDebugger, GetDescription, (lldb::SBStream &));
1790  LLDB_REGISTER_METHOD(lldb::user_id_t, SBDebugger, GetID, ());
1791  LLDB_REGISTER_METHOD(lldb::SBError, SBDebugger, SetCurrentPlatform,
1792                       (const char *));
1793  LLDB_REGISTER_METHOD(bool, SBDebugger, SetCurrentPlatformSDKRoot,
1794                       (const char *));
1795  LLDB_REGISTER_METHOD_CONST(bool, SBDebugger, GetCloseInputOnEOF, ());
1796  LLDB_REGISTER_METHOD(void, SBDebugger, SetCloseInputOnEOF, (bool));
1797  LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
1798                       (const char *));
1799  LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategory,
1800                       (lldb::LanguageType));
1801  LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, CreateCategory,
1802                       (const char *));
1803  LLDB_REGISTER_METHOD(bool, SBDebugger, DeleteCategory, (const char *));
1804  LLDB_REGISTER_METHOD(uint32_t, SBDebugger, GetNumCategories, ());
1805  LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetCategoryAtIndex,
1806                       (uint32_t));
1807  LLDB_REGISTER_METHOD(lldb::SBTypeCategory, SBDebugger, GetDefaultCategory,
1808                       ());
1809  LLDB_REGISTER_METHOD(lldb::SBTypeFormat, SBDebugger, GetFormatForType,
1810                       (lldb::SBTypeNameSpecifier));
1811  LLDB_REGISTER_METHOD(lldb::SBTypeSummary, SBDebugger, GetSummaryForType,
1812                       (lldb::SBTypeNameSpecifier));
1813  LLDB_REGISTER_METHOD(lldb::SBTypeSynthetic, SBDebugger, GetSyntheticForType,
1814                       (lldb::SBTypeNameSpecifier));
1815  LLDB_REGISTER_METHOD(lldb::SBTypeFilter, SBDebugger, GetFilterForType,
1816                       (lldb::SBTypeNameSpecifier));
1817  LLDB_REGISTER_METHOD(bool, SBDebugger, EnableLog,
1818                       (const char *, const char **));
1819}
1820
1821} // namespace repro
1822} // namespace lldb_private
1823