contrib/llvm-project/lldb/source/API/SBDebugger.cpp

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