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