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

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