source/API/SBDebugger.cpp

   1 //===-- SBDebugger.cpp ------------------------------------------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 // C Includes
  11 // C++ Includes
  12 // Other libraries and framework includes
  13 // Project includes
  14 #include "lldb/API/SBDebugger.h"
  15
  16 #include "lldb/lldb-private.h"
  17
  18 #include "lldb/API/SBBroadcaster.h"
  19 #include "lldb/API/SBCommandInterpreter.h"
  20 #include "lldb/API/SBCommandReturnObject.h"
  21 #include "lldb/API/SBError.h"
  22 #include "lldb/API/SBEvent.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/SBTarget.h"
  30 #include "lldb/API/SBThread.h"
  31 #include "lldb/API/SBTypeCategory.h"
  32 #include "lldb/API/SBTypeFilter.h"
  33 #include "lldb/API/SBTypeFormat.h"
  34 #include "lldb/API/SBTypeNameSpecifier.h"
  35 #include "lldb/API/SBTypeSummary.h"
  36 #include "lldb/API/SBTypeSynthetic.h"
  37 #include "lldb/API/SystemInitializerFull.h"
  38
  39 #include "lldb/Core/Debugger.h"
  40 #include "lldb/Core/State.h"
  41 #include "lldb/Core/StreamFile.h"
  42 #include "lldb/DataFormatters/DataVisualization.h"
  43 #include "lldb/Initialization/SystemLifetimeManager.h"
  44 #include "lldb/Interpreter/Args.h"
  45 #include "lldb/Interpreter/CommandInterpreter.h"
  46 #include "lldb/Interpreter/OptionGroupPlatform.h"
  47 #include "lldb/Target/Process.h"
  48 #include "lldb/Target/TargetList.h"
  49
  50 #include "llvm/ADT/STLExtras.h"
  51 #include "llvm/ADT/StringRef.h"
  52 #include "llvm/Support/DynamicLibrary.h"
  53 #include "llvm/Support/ManagedStatic.h"
  54
  55 using namespace lldb;
  56 using namespace lldb_private;
  57
  58 static llvm::sys::DynamicLibrary LoadPlugin(const lldb::DebuggerSP &debugger_sp,
  59                                             const FileSpec &spec,
  60                                             Error &error) {
  61   llvm::sys::DynamicLibrary dynlib =
  62       llvm::sys::DynamicLibrary::getPermanentLibrary(spec.GetPath().c_str());
  63   if (dynlib.isValid()) {
  64     typedef bool (*LLDBCommandPluginInit)(lldb::SBDebugger & debugger);
  65
  66     lldb::SBDebugger debugger_sb(debugger_sp);
  67     // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger)
  68     // function.
  69     // TODO: mangle this differently for your system - on OSX, the first
  70     // underscore needs to be removed and the second one stays
  71     LLDBCommandPluginInit init_func =
  72         (LLDBCommandPluginInit)dynlib.getAddressOfSymbol(
  73             "_ZN4lldb16PluginInitializeENS_10SBDebuggerE");
  74     if (init_func) {
  75       if (init_func(debugger_sb))
  76         return dynlib;
  77       else
  78         error.SetErrorString("plug-in refused to load "
  79                              "(lldb::PluginInitialize(lldb::SBDebugger) "
  80                              "returned false)");
  81     } else {
  82       error.SetErrorString("plug-in is missing the required initialization: "
  83                            "lldb::PluginInitialize(lldb::SBDebugger)");
  84     }
  85   } else {
  86     if (spec.Exists())
  87       error.SetErrorString("this file does not represent a loadable dylib");
  88     else
  89       error.SetErrorString("no such file");
  90   }
  91   return llvm::sys::DynamicLibrary();
  92 }
  93
  94 static llvm::ManagedStatic<SystemLifetimeManager> g_debugger_lifetime;
  95
  96 SBError SBInputReader::Initialize(
  97     lldb::SBDebugger &sb_debugger,
  98     unsigned long (*)(void *, lldb::SBInputReader *, lldb::InputReaderAction,
  99                       char const *, unsigned long),
 100     void *, lldb::InputReaderGranularity, char const *, char const *, bool) {
 101   return SBError();
 102 }
 103
 104 void SBInputReader::SetIsDone(bool) {}
 105
 106 bool SBInputReader::IsActive() const { return false; }
 107
 108 SBDebugger::SBDebugger() = default;
 109
 110 SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp)
 111     : m_opaque_sp(debugger_sp) {}
 112
 113 SBDebugger::SBDebugger(const SBDebugger &rhs) : m_opaque_sp(rhs.m_opaque_sp) {}
 114
 115 SBDebugger::~SBDebugger() = default;
 116
 117 SBDebugger &SBDebugger::operator=(const SBDebugger &rhs) {
 118   if (this != &rhs) {
 119     m_opaque_sp = rhs.m_opaque_sp;
 120   }
 121   return *this;
 122 }
 123
 124 void SBDebugger::Initialize() {
 125   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 126
 127   if (log)
 128     log->Printf("SBDebugger::Initialize ()");
 129
 130   g_debugger_lifetime->Initialize(llvm::make_unique<SystemInitializerFull>(),
 131                                   LoadPlugin);
 132 }
 133
 134 void SBDebugger::Terminate() { g_debugger_lifetime->Terminate(); }
 135
 136 void SBDebugger::Clear() {
 137   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 138
 139   if (log)
 140     log->Printf("SBDebugger(%p)::Clear ()",
 141                 static_cast<void *>(m_opaque_sp.get()));
 142
 143   if (m_opaque_sp)
 144     m_opaque_sp->ClearIOHandlers();
 145
 146   m_opaque_sp.reset();
 147 }
 148
 149 SBDebugger SBDebugger::Create() {
 150   return SBDebugger::Create(false, nullptr, nullptr);
 151 }
 152
 153 SBDebugger SBDebugger::Create(bool source_init_files) {
 154   return SBDebugger::Create(source_init_files, nullptr, nullptr);
 155 }
 156
 157 SBDebugger SBDebugger::Create(bool source_init_files,
 158                               lldb::LogOutputCallback callback, void *baton)
 159
 160 {
 161   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 162
 163   SBDebugger debugger;
 164
 165   // Currently we have issues if this function is called simultaneously on two
 166   // different
 167   // threads. The issues mainly revolve around the fact that the
 168   // lldb_private::FormatManager
 169   // uses global collections and having two threads parsing the .lldbinit files
 170   // can cause
 171   // mayhem. So to get around this for now we need to use a mutex to prevent bad
 172   // things
 173   // from happening.
 174   static std::recursive_mutex g_mutex;
 175   std::lock_guard<std::recursive_mutex> guard(g_mutex);
 176
 177   debugger.reset(Debugger::CreateInstance(callback, baton));
 178
 179   if (log) {
 180     SBStream sstr;
 181     debugger.GetDescription(sstr);
 182     log->Printf("SBDebugger::Create () => SBDebugger(%p): %s",
 183                 static_cast<void *>(debugger.m_opaque_sp.get()),
 184                 sstr.GetData());
 185   }
 186
 187   SBCommandInterpreter interp = debugger.GetCommandInterpreter();
 188   if (source_init_files) {
 189     interp.get()->SkipLLDBInitFiles(false);
 190     interp.get()->SkipAppInitFiles(false);
 191     SBCommandReturnObject result;
 192     interp.SourceInitFileInHomeDirectory(result);
 193   } else {
 194     interp.get()->SkipLLDBInitFiles(true);
 195     interp.get()->SkipAppInitFiles(true);
 196   }
 197   return debugger;
 198 }
 199
 200 void SBDebugger::Destroy(SBDebugger &debugger) {
 201   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 202
 203   if (log) {
 204     SBStream sstr;
 205     debugger.GetDescription(sstr);
 206     log->Printf("SBDebugger::Destroy () => SBDebugger(%p): %s",
 207                 static_cast<void *>(debugger.m_opaque_sp.get()),
 208                 sstr.GetData());
 209   }
 210
 211   Debugger::Destroy(debugger.m_opaque_sp);
 212
 213   if (debugger.m_opaque_sp.get() != nullptr)
 214     debugger.m_opaque_sp.reset();
 215 }
 216
 217 void SBDebugger::MemoryPressureDetected() {
 218   // Since this function can be call asynchronously, we allow it to be
 219   // non-mandatory. We have seen deadlocks with this function when called
 220   // so we need to safeguard against this until we can determine what is
 221   // causing the deadlocks.
 222   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 223
 224   const bool mandatory = false;
 225   if (log) {
 226     log->Printf("SBDebugger::MemoryPressureDetected (), mandatory = %d",
 227                 mandatory);
 228   }
 229
 230   ModuleList::RemoveOrphanSharedModules(mandatory);
 231 }
 232
 233 bool SBDebugger::IsValid() const { return m_opaque_sp.get() != nullptr; }
 234
 235 void SBDebugger::SetAsync(bool b) {
 236   if (m_opaque_sp)
 237     m_opaque_sp->SetAsyncExecution(b);
 238 }
 239
 240 bool SBDebugger::GetAsync() {
 241   return (m_opaque_sp ? m_opaque_sp->GetAsyncExecution() : false);
 242 }
 243
 244 void SBDebugger::SkipLLDBInitFiles(bool b) {
 245   if (m_opaque_sp)
 246     m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles(b);
 247 }
 248
 249 void SBDebugger::SkipAppInitFiles(bool b) {
 250   if (m_opaque_sp)
 251     m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles(b);
 252 }
 253
 254 // Shouldn't really be settable after initialization as this could cause lots of
 255 // problems; don't want users
 256 // trying to switch modes in the middle of a debugging session.
 257 void SBDebugger::SetInputFileHandle(FILE *fh, bool transfer_ownership) {
 258   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 259
 260   if (log)
 261     log->Printf(
 262         "SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)",
 263         static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
 264         transfer_ownership);
 265
 266   if (m_opaque_sp)
 267     m_opaque_sp->SetInputFileHandle(fh, transfer_ownership);
 268 }
 269
 270 void SBDebugger::SetOutputFileHandle(FILE *fh, bool transfer_ownership) {
 271   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 272
 273   if (log)
 274     log->Printf(
 275         "SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)",
 276         static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
 277         transfer_ownership);
 278
 279   if (m_opaque_sp)
 280     m_opaque_sp->SetOutputFileHandle(fh, transfer_ownership);
 281 }
 282
 283 void SBDebugger::SetErrorFileHandle(FILE *fh, bool transfer_ownership) {
 284   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 285
 286   if (log)
 287     log->Printf(
 288         "SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)",
 289         static_cast<void *>(m_opaque_sp.get()), static_cast<void *>(fh),
 290         transfer_ownership);
 291
 292   if (m_opaque_sp)
 293     m_opaque_sp->SetErrorFileHandle(fh, transfer_ownership);
 294 }
 295
 296 FILE *SBDebugger::GetInputFileHandle() {
 297   if (m_opaque_sp) {
 298     StreamFileSP stream_file_sp(m_opaque_sp->GetInputFile());
 299     if (stream_file_sp)
 300       return stream_file_sp->GetFile().GetStream();
 301   }
 302   return nullptr;
 303 }
 304
 305 FILE *SBDebugger::GetOutputFileHandle() {
 306   if (m_opaque_sp) {
 307     StreamFileSP stream_file_sp(m_opaque_sp->GetOutputFile());
 308     if (stream_file_sp)
 309       return stream_file_sp->GetFile().GetStream();
 310   }
 311   return nullptr;
 312 }
 313
 314 FILE *SBDebugger::GetErrorFileHandle() {
 315   if (m_opaque_sp) {
 316     StreamFileSP stream_file_sp(m_opaque_sp->GetErrorFile());
 317     if (stream_file_sp)
 318       return stream_file_sp->GetFile().GetStream();
 319   }
 320   return nullptr;
 321 }
 322
 323 void SBDebugger::SaveInputTerminalState() {
 324   if (m_opaque_sp)
 325     m_opaque_sp->SaveInputTerminalState();
 326 }
 327
 328 void SBDebugger::RestoreInputTerminalState() {
 329   if (m_opaque_sp)
 330     m_opaque_sp->RestoreInputTerminalState();
 331 }
 332 SBCommandInterpreter SBDebugger::GetCommandInterpreter() {
 333   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 334
 335   SBCommandInterpreter sb_interpreter;
 336   if (m_opaque_sp)
 337     sb_interpreter.reset(&m_opaque_sp->GetCommandInterpreter());
 338
 339   if (log)
 340     log->Printf(
 341         "SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)",
 342         static_cast<void *>(m_opaque_sp.get()),
 343         static_cast<void *>(sb_interpreter.get()));
 344
 345   return sb_interpreter;
 346 }
 347
 348 void SBDebugger::HandleCommand(const char *command) {
 349   if (m_opaque_sp) {
 350     TargetSP target_sp(m_opaque_sp->GetSelectedTarget());
 351     std::unique_lock<std::recursive_mutex> lock;
 352     if (target_sp)
 353       lock = std::unique_lock<std::recursive_mutex>(target_sp->GetAPIMutex());
 354
 355     SBCommandInterpreter sb_interpreter(GetCommandInterpreter());
 356     SBCommandReturnObject result;
 357
 358     sb_interpreter.HandleCommand(command, result, false);
 359
 360     if (GetErrorFileHandle() != nullptr)
 361       result.PutError(GetErrorFileHandle());
 362     if (GetOutputFileHandle() != nullptr)
 363       result.PutOutput(GetOutputFileHandle());
 364
 365     if (!m_opaque_sp->GetAsyncExecution()) {
 366       SBProcess process(GetCommandInterpreter().GetProcess());
 367       ProcessSP process_sp(process.GetSP());
 368       if (process_sp) {
 369         EventSP event_sp;
 370         ListenerSP lldb_listener_sp = m_opaque_sp->GetListener();
 371         while (lldb_listener_sp->GetEventForBroadcaster(
 372             process_sp.get(), event_sp, std::chrono::seconds(0))) {
 373           SBEvent event(event_sp);
 374           HandleProcessEvent(process, event, GetOutputFileHandle(),
 375                              GetErrorFileHandle());
 376         }
 377       }
 378     }
 379   }
 380 }
 381
 382 SBListener SBDebugger::GetListener() {
 383   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 384
 385   SBListener sb_listener;
 386   if (m_opaque_sp)
 387     sb_listener.reset(m_opaque_sp->GetListener());
 388
 389   if (log)
 390     log->Printf("SBDebugger(%p)::GetListener () => SBListener(%p)",
 391                 static_cast<void *>(m_opaque_sp.get()),
 392                 static_cast<void *>(sb_listener.get()));
 393
 394   return sb_listener;
 395 }
 396
 397 void SBDebugger::HandleProcessEvent(const SBProcess &process,
 398                                     const SBEvent &event, FILE *out,
 399                                     FILE *err) {
 400   if (!process.IsValid())
 401     return;
 402
 403   TargetSP target_sp(process.GetTarget().GetSP());
 404   if (!target_sp)
 405     return;
 406
 407   const uint32_t event_type = event.GetType();
 408   char stdio_buffer[1024];
 409   size_t len;
 410
 411   std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 412
 413   if (event_type &
 414       (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged)) {
 415     // Drain stdout when we stop just in case we have any bytes
 416     while ((len = process.GetSTDOUT(stdio_buffer, sizeof(stdio_buffer))) > 0)
 417       if (out != nullptr)
 418         ::fwrite(stdio_buffer, 1, len, out);
 419   }
 420
 421   if (event_type &
 422       (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged)) {
 423     // Drain stderr when we stop just in case we have any bytes
 424     while ((len = process.GetSTDERR(stdio_buffer, sizeof(stdio_buffer))) > 0)
 425       if (err != nullptr)
 426         ::fwrite(stdio_buffer, 1, len, err);
 427   }
 428
 429   if (event_type & Process::eBroadcastBitStateChanged) {
 430     StateType event_state = SBProcess::GetStateFromEvent(event);
 431
 432     if (event_state == eStateInvalid)
 433       return;
 434
 435     bool is_stopped = StateIsStoppedState(event_state);
 436     if (!is_stopped)
 437       process.ReportEventState(event, out);
 438   }
 439 }
 440
 441 SBSourceManager SBDebugger::GetSourceManager() {
 442   SBSourceManager sb_source_manager(*this);
 443   return sb_source_manager;
 444 }
 445
 446 bool SBDebugger::GetDefaultArchitecture(char *arch_name, size_t arch_name_len) {
 447   if (arch_name && arch_name_len) {
 448     ArchSpec default_arch = Target::GetDefaultArchitecture();
 449
 450     if (default_arch.IsValid()) {
 451       const std::string &triple_str = default_arch.GetTriple().str();
 452       if (!triple_str.empty())
 453         ::snprintf(arch_name, arch_name_len, "%s", triple_str.c_str());
 454       else
 455         ::snprintf(arch_name, arch_name_len, "%s",
 456                    default_arch.GetArchitectureName());
 457       return true;
 458     }
 459   }
 460   if (arch_name && arch_name_len)
 461     arch_name[0] = '\0';
 462   return false;
 463 }
 464
 465 bool SBDebugger::SetDefaultArchitecture(const char *arch_name) {
 466   if (arch_name) {
 467     ArchSpec arch(arch_name);
 468     if (arch.IsValid()) {
 469       Target::SetDefaultArchitecture(arch);
 470       return true;
 471     }
 472   }
 473   return false;
 474 }
 475
 476 ScriptLanguage
 477 SBDebugger::GetScriptingLanguage(const char *script_language_name) {
 478   if (!script_language_name) return eScriptLanguageDefault;
 479   return Args::StringToScriptLanguage(llvm::StringRef(script_language_name),
 480                                       eScriptLanguageDefault, nullptr);
 481 }
 482
 483 const char *SBDebugger::GetVersionString() {
 484   return lldb_private::GetVersion();
 485 }
 486
 487 const char *SBDebugger::StateAsCString(StateType state) {
 488   return lldb_private::StateAsCString(state);
 489 }
 490
 491 bool SBDebugger::StateIsRunningState(StateType state) {
 492   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 493
 494   const bool result = lldb_private::StateIsRunningState(state);
 495   if (log)
 496     log->Printf("SBDebugger::StateIsRunningState (state=%s) => %i",
 497                 StateAsCString(state), result);
 498
 499   return result;
 500 }
 501
 502 bool SBDebugger::StateIsStoppedState(StateType state) {
 503   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 504
 505   const bool result = lldb_private::StateIsStoppedState(state, false);
 506   if (log)
 507     log->Printf("SBDebugger::StateIsStoppedState (state=%s) => %i",
 508                 StateAsCString(state), result);
 509
 510   return result;
 511 }
 512
 513 lldb::SBTarget SBDebugger::CreateTarget(const char *filename,
 514                                         const char *target_triple,
 515                                         const char *platform_name,
 516                                         bool add_dependent_modules,
 517                                         lldb::SBError &sb_error) {
 518   SBTarget sb_target;
 519   TargetSP target_sp;
 520   if (m_opaque_sp) {
 521     sb_error.Clear();
 522     OptionGroupPlatform platform_options(false);
 523     platform_options.SetPlatformName(platform_name);
 524
 525     sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget(
 526         *m_opaque_sp, filename, target_triple, add_dependent_modules,
 527         &platform_options, target_sp);
 528
 529     if (sb_error.Success())
 530       sb_target.SetSP(target_sp);
 531   } else {
 532     sb_error.SetErrorString("invalid debugger");
 533   }
 534
 535   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 536   if (log)
 537     log->Printf("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, "
 538                 "platform_name=%s, add_dependent_modules=%u, error=%s) => "
 539                 "SBTarget(%p)",
 540                 static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
 541                 platform_name, add_dependent_modules, sb_error.GetCString(),
 542                 static_cast<void *>(target_sp.get()));
 543
 544   return sb_target;
 545 }
 546
 547 SBTarget
 548 SBDebugger::CreateTargetWithFileAndTargetTriple(const char *filename,
 549                                                 const char *target_triple) {
 550   SBTarget sb_target;
 551   TargetSP target_sp;
 552   if (m_opaque_sp) {
 553     const bool add_dependent_modules = true;
 554     Error error(m_opaque_sp->GetTargetList().CreateTarget(
 555         *m_opaque_sp, filename, target_triple, add_dependent_modules, nullptr,
 556         target_sp));
 557     sb_target.SetSP(target_sp);
 558   }
 559
 560   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 561   if (log)
 562     log->Printf("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple "
 563                 "(filename=\"%s\", triple=%s) => SBTarget(%p)",
 564                 static_cast<void *>(m_opaque_sp.get()), filename, target_triple,
 565                 static_cast<void *>(target_sp.get()));
 566
 567   return sb_target;
 568 }
 569
 570 SBTarget SBDebugger::CreateTargetWithFileAndArch(const char *filename,
 571                                                  const char *arch_cstr) {
 572   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 573
 574   SBTarget sb_target;
 575   TargetSP target_sp;
 576   if (m_opaque_sp) {
 577     Error error;
 578     const bool add_dependent_modules = true;
 579
 580     error = m_opaque_sp->GetTargetList().CreateTarget(
 581         *m_opaque_sp, filename, arch_cstr, add_dependent_modules, nullptr,
 582         target_sp);
 583
 584     if (error.Success()) {
 585       m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
 586       sb_target.SetSP(target_sp);
 587     }
 588   }
 589
 590   if (log)
 591     log->Printf("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", "
 592                 "arch=%s) => SBTarget(%p)",
 593                 static_cast<void *>(m_opaque_sp.get()), filename, arch_cstr,
 594                 static_cast<void *>(target_sp.get()));
 595
 596   return sb_target;
 597 }
 598
 599 SBTarget SBDebugger::CreateTarget(const char *filename) {
 600   SBTarget sb_target;
 601   TargetSP target_sp;
 602   if (m_opaque_sp) {
 603     Error error;
 604     const bool add_dependent_modules = true;
 605     error = m_opaque_sp->GetTargetList().CreateTarget(
 606         *m_opaque_sp, filename, "", add_dependent_modules, nullptr, target_sp);
 607
 608     if (error.Success()) {
 609       m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
 610       sb_target.SetSP(target_sp);
 611     }
 612   }
 613   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 614   if (log)
 615     log->Printf(
 616         "SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)",
 617         static_cast<void *>(m_opaque_sp.get()), filename,
 618         static_cast<void *>(target_sp.get()));
 619   return sb_target;
 620 }
 621
 622 bool SBDebugger::DeleteTarget(lldb::SBTarget &target) {
 623   bool result = false;
 624   if (m_opaque_sp) {
 625     TargetSP target_sp(target.GetSP());
 626     if (target_sp) {
 627       // No need to lock, the target list is thread safe
 628       result = m_opaque_sp->GetTargetList().DeleteTarget(target_sp);
 629       target_sp->Destroy();
 630       target.Clear();
 631       const bool mandatory = true;
 632       ModuleList::RemoveOrphanSharedModules(mandatory);
 633     }
 634   }
 635
 636   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 637   if (log)
 638     log->Printf("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i",
 639                 static_cast<void *>(m_opaque_sp.get()),
 640                 static_cast<void *>(target.m_opaque_sp.get()), result);
 641
 642   return result;
 643 }
 644
 645 SBTarget SBDebugger::GetTargetAtIndex(uint32_t idx) {
 646   SBTarget sb_target;
 647   if (m_opaque_sp) {
 648     // No need to lock, the target list is thread safe
 649     sb_target.SetSP(m_opaque_sp->GetTargetList().GetTargetAtIndex(idx));
 650   }
 651   return sb_target;
 652 }
 653
 654 uint32_t SBDebugger::GetIndexOfTarget(lldb::SBTarget target) {
 655
 656   lldb::TargetSP target_sp = target.GetSP();
 657   if (!target_sp)
 658     return UINT32_MAX;
 659
 660   if (!m_opaque_sp)
 661     return UINT32_MAX;
 662
 663   return m_opaque_sp->GetTargetList().GetIndexOfTarget(target.GetSP());
 664 }
 665
 666 SBTarget SBDebugger::FindTargetWithProcessID(lldb::pid_t pid) {
 667   SBTarget sb_target;
 668   if (m_opaque_sp) {
 669     // No need to lock, the target list is thread safe
 670     sb_target.SetSP(m_opaque_sp->GetTargetList().FindTargetWithProcessID(pid));
 671   }
 672   return sb_target;
 673 }
 674
 675 SBTarget SBDebugger::FindTargetWithFileAndArch(const char *filename,
 676                                                const char *arch_name) {
 677   SBTarget sb_target;
 678   if (m_opaque_sp && filename && filename[0]) {
 679     // No need to lock, the target list is thread safe
 680     ArchSpec arch(arch_name,
 681                   m_opaque_sp->GetPlatformList().GetSelectedPlatform().get());
 682     TargetSP target_sp(
 683         m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture(
 684             FileSpec(filename, false), arch_name ? &arch : nullptr));
 685     sb_target.SetSP(target_sp);
 686   }
 687   return sb_target;
 688 }
 689
 690 SBTarget SBDebugger::FindTargetWithLLDBProcess(const ProcessSP &process_sp) {
 691   SBTarget sb_target;
 692   if (m_opaque_sp) {
 693     // No need to lock, the target list is thread safe
 694     sb_target.SetSP(
 695         m_opaque_sp->GetTargetList().FindTargetWithProcess(process_sp.get()));
 696   }
 697   return sb_target;
 698 }
 699
 700 uint32_t SBDebugger::GetNumTargets() {
 701   if (m_opaque_sp) {
 702     // No need to lock, the target list is thread safe
 703     return m_opaque_sp->GetTargetList().GetNumTargets();
 704   }
 705   return 0;
 706 }
 707
 708 SBTarget SBDebugger::GetSelectedTarget() {
 709   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 710
 711   SBTarget sb_target;
 712   TargetSP target_sp;
 713   if (m_opaque_sp) {
 714     // No need to lock, the target list is thread safe
 715     target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget();
 716     sb_target.SetSP(target_sp);
 717   }
 718
 719   if (log) {
 720     SBStream sstr;
 721     sb_target.GetDescription(sstr, eDescriptionLevelBrief);
 722     log->Printf("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s",
 723                 static_cast<void *>(m_opaque_sp.get()),
 724                 static_cast<void *>(target_sp.get()), sstr.GetData());
 725   }
 726
 727   return sb_target;
 728 }
 729
 730 void SBDebugger::SetSelectedTarget(SBTarget &sb_target) {
 731   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 732
 733   TargetSP target_sp(sb_target.GetSP());
 734   if (m_opaque_sp) {
 735     m_opaque_sp->GetTargetList().SetSelectedTarget(target_sp.get());
 736   }
 737   if (log) {
 738     SBStream sstr;
 739     sb_target.GetDescription(sstr, eDescriptionLevelBrief);
 740     log->Printf("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s",
 741                 static_cast<void *>(m_opaque_sp.get()),
 742                 static_cast<void *>(target_sp.get()), sstr.GetData());
 743   }
 744 }
 745
 746 SBPlatform SBDebugger::GetSelectedPlatform() {
 747   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 748
 749   SBPlatform sb_platform;
 750   DebuggerSP debugger_sp(m_opaque_sp);
 751   if (debugger_sp) {
 752     sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform());
 753   }
 754   if (log)
 755     log->Printf("SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s",
 756                 static_cast<void *>(m_opaque_sp.get()),
 757                 static_cast<void *>(sb_platform.GetSP().get()),
 758                 sb_platform.GetName());
 759   return sb_platform;
 760 }
 761
 762 void SBDebugger::SetSelectedPlatform(SBPlatform &sb_platform) {
 763   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 764
 765   DebuggerSP debugger_sp(m_opaque_sp);
 766   if (debugger_sp) {
 767     debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP());
 768   }
 769
 770   if (log)
 771     log->Printf("SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)",
 772                 static_cast<void *>(m_opaque_sp.get()),
 773                 static_cast<void *>(sb_platform.GetSP().get()),
 774                 sb_platform.GetName());
 775 }
 776
 777 void SBDebugger::DispatchInput(void *baton, const void *data, size_t data_len) {
 778   DispatchInput(data, data_len);
 779 }
 780
 781 void SBDebugger::DispatchInput(const void *data, size_t data_len) {
 782   //    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 783   //
 784   //    if (log)
 785   //        log->Printf ("SBDebugger(%p)::DispatchInput (data=\"%.*s\",
 786   //        size_t=%" PRIu64 ")",
 787   //                     m_opaque_sp.get(),
 788   //                     (int) data_len,
 789   //                     (const char *) data,
 790   //                     (uint64_t)data_len);
 791   //
 792   //    if (m_opaque_sp)
 793   //        m_opaque_sp->DispatchInput ((const char *) data, data_len);
 794 }
 795
 796 void SBDebugger::DispatchInputInterrupt() {
 797   if (m_opaque_sp)
 798     m_opaque_sp->DispatchInputInterrupt();
 799 }
 800
 801 void SBDebugger::DispatchInputEndOfFile() {
 802   if (m_opaque_sp)
 803     m_opaque_sp->DispatchInputEndOfFile();
 804 }
 805
 806 void SBDebugger::PushInputReader(SBInputReader &reader) {}
 807
 808 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
 809                                        bool spawn_thread) {
 810   if (m_opaque_sp) {
 811     CommandInterpreterRunOptions options;
 812
 813     m_opaque_sp->GetCommandInterpreter().RunCommandInterpreter(
 814         auto_handle_events, spawn_thread, options);
 815   }
 816 }
 817
 818 void SBDebugger::RunCommandInterpreter(bool auto_handle_events,
 819                                        bool spawn_thread,
 820                                        SBCommandInterpreterRunOptions &options,
 821                                        int &num_errors, bool &quit_requested,
 822                                        bool &stopped_for_crash)
 823
 824 {
 825   if (m_opaque_sp) {
 826     CommandInterpreter &interp = m_opaque_sp->GetCommandInterpreter();
 827     interp.RunCommandInterpreter(auto_handle_events, spawn_thread,
 828                                  options.ref());
 829     num_errors = interp.GetNumErrors();
 830     quit_requested = interp.GetQuitRequested();
 831     stopped_for_crash = interp.GetStoppedForCrash();
 832   }
 833 }
 834
 835 SBError SBDebugger::RunREPL(lldb::LanguageType language,
 836                             const char *repl_options) {
 837   SBError error;
 838   if (m_opaque_sp)
 839     error.ref() = m_opaque_sp->RunREPL(language, repl_options);
 840   else
 841     error.SetErrorString("invalid debugger");
 842   return error;
 843 }
 844
 845 void SBDebugger::reset(const DebuggerSP &debugger_sp) {
 846   m_opaque_sp = debugger_sp;
 847 }
 848
 849 Debugger *SBDebugger::get() const { return m_opaque_sp.get(); }
 850
 851 Debugger &SBDebugger::ref() const {
 852   assert(m_opaque_sp.get());
 853   return *m_opaque_sp;
 854 }
 855
 856 const lldb::DebuggerSP &SBDebugger::get_sp() const { return m_opaque_sp; }
 857
 858 SBDebugger SBDebugger::FindDebuggerWithID(int id) {
 859   // No need to lock, the debugger list is thread safe
 860   SBDebugger sb_debugger;
 861   DebuggerSP debugger_sp = Debugger::FindDebuggerWithID(id);
 862   if (debugger_sp)
 863     sb_debugger.reset(debugger_sp);
 864   return sb_debugger;
 865 }
 866
 867 const char *SBDebugger::GetInstanceName() {
 868   return (m_opaque_sp ? m_opaque_sp->GetInstanceName().AsCString() : nullptr);
 869 }
 870
 871 SBError SBDebugger::SetInternalVariable(const char *var_name, const char *value,
 872                                         const char *debugger_instance_name) {
 873   SBError sb_error;
 874   DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
 875       ConstString(debugger_instance_name)));
 876   Error error;
 877   if (debugger_sp) {
 878     ExecutionContext exe_ctx(
 879         debugger_sp->GetCommandInterpreter().GetExecutionContext());
 880     error = debugger_sp->SetPropertyValue(&exe_ctx, eVarSetOperationAssign,
 881                                           var_name, value);
 882   } else {
 883     error.SetErrorStringWithFormat("invalid debugger instance name '%s'",
 884                                    debugger_instance_name);
 885   }
 886   if (error.Fail())
 887     sb_error.SetError(error);
 888   return sb_error;
 889 }
 890
 891 SBStringList
 892 SBDebugger::GetInternalVariableValue(const char *var_name,
 893                                      const char *debugger_instance_name) {
 894   SBStringList ret_value;
 895   DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName(
 896       ConstString(debugger_instance_name)));
 897   Error error;
 898   if (debugger_sp) {
 899     ExecutionContext exe_ctx(
 900         debugger_sp->GetCommandInterpreter().GetExecutionContext());
 901     lldb::OptionValueSP value_sp(
 902         debugger_sp->GetPropertyValue(&exe_ctx, var_name, false, error));
 903     if (value_sp) {
 904       StreamString value_strm;
 905       value_sp->DumpValue(&exe_ctx, value_strm, OptionValue::eDumpOptionValue);
 906       const std::string &value_str = value_strm.GetString();
 907       if (!value_str.empty()) {
 908         StringList string_list;
 909         string_list.SplitIntoLines(value_str);
 910         return SBStringList(&string_list);
 911       }
 912     }
 913   }
 914   return SBStringList();
 915 }
 916
 917 uint32_t SBDebugger::GetTerminalWidth() const {
 918   return (m_opaque_sp ? m_opaque_sp->GetTerminalWidth() : 0);
 919 }
 920
 921 void SBDebugger::SetTerminalWidth(uint32_t term_width) {
 922   if (m_opaque_sp)
 923     m_opaque_sp->SetTerminalWidth(term_width);
 924 }
 925
 926 const char *SBDebugger::GetPrompt() const {
 927   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
 928
 929   if (log)
 930     log->Printf("SBDebugger(%p)::GetPrompt () => \"%s\"",
 931                 static_cast<void *>(m_opaque_sp.get()),
 932                 (m_opaque_sp ? m_opaque_sp->GetPrompt().str().c_str() : ""));
 933
 934   return (m_opaque_sp ? ConstString(m_opaque_sp->GetPrompt()).GetCString()
 935                       : nullptr);
 936 }
 937
 938 void SBDebugger::SetPrompt(const char *prompt) {
 939   if (m_opaque_sp)
 940     m_opaque_sp->SetPrompt(llvm::StringRef::withNullAsEmpty(prompt));
 941 }
 942
 943 ScriptLanguage SBDebugger::GetScriptLanguage() const {
 944   return (m_opaque_sp ? m_opaque_sp->GetScriptLanguage() : eScriptLanguageNone);
 945 }
 946
 947 void SBDebugger::SetScriptLanguage(ScriptLanguage script_lang) {
 948   if (m_opaque_sp) {
 949     m_opaque_sp->SetScriptLanguage(script_lang);
 950   }
 951 }
 952
 953 bool SBDebugger::SetUseExternalEditor(bool value) {
 954   return (m_opaque_sp ? m_opaque_sp->SetUseExternalEditor(value) : false);
 955 }
 956
 957 bool SBDebugger::GetUseExternalEditor() {
 958   return (m_opaque_sp ? m_opaque_sp->GetUseExternalEditor() : false);
 959 }
 960
 961 bool SBDebugger::SetUseColor(bool value) {
 962   return (m_opaque_sp ? m_opaque_sp->SetUseColor(value) : false);
 963 }
 964
 965 bool SBDebugger::GetUseColor() const {
 966   return (m_opaque_sp ? m_opaque_sp->GetUseColor() : false);
 967 }
 968
 969 bool SBDebugger::GetDescription(SBStream &description) {
 970   Stream &strm = description.ref();
 971
 972   if (m_opaque_sp) {
 973     const char *name = m_opaque_sp->GetInstanceName().AsCString();
 974     user_id_t id = m_opaque_sp->GetID();
 975     strm.Printf("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id);
 976   } else
 977     strm.PutCString("No value");
 978
 979   return true;
 980 }
 981
 982 user_id_t SBDebugger::GetID() {
 983   return (m_opaque_sp ? m_opaque_sp->GetID() : LLDB_INVALID_UID);
 984 }
 985
 986 SBError SBDebugger::SetCurrentPlatform(const char *platform_name_cstr) {
 987   SBError sb_error;
 988   if (m_opaque_sp) {
 989     if (platform_name_cstr && platform_name_cstr[0]) {
 990       ConstString platform_name(platform_name_cstr);
 991       PlatformSP platform_sp(Platform::Find(platform_name));
 992
 993       if (platform_sp) {
 994         // Already have a platform with this name, just select it
 995         m_opaque_sp->GetPlatformList().SetSelectedPlatform(platform_sp);
 996       } else {
 997         // We don't have a platform by this name yet, create one
 998         platform_sp = Platform::Create(platform_name, sb_error.ref());
 999         if (platform_sp) {
1000           // We created the platform, now append and select it
1001           bool make_selected = true;
1002           m_opaque_sp->GetPlatformList().Append(platform_sp, make_selected);
1003         }
1004       }
1005     } else {
1006       sb_error.ref().SetErrorString("invalid platform name");
1007     }
1008   } else {
1009     sb_error.ref().SetErrorString("invalid debugger");
1010   }
1011   return sb_error;
1012 }
1013
1014 bool SBDebugger::SetCurrentPlatformSDKRoot(const char *sysroot) {
1015   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
1016   if (m_opaque_sp) {
1017     PlatformSP platform_sp(
1018         m_opaque_sp->GetPlatformList().GetSelectedPlatform());
1019
1020     if (platform_sp) {
1021       if (log && sysroot)
1022         log->Printf("SBDebugger::SetCurrentPlatformSDKRoot (\"%s\")", sysroot);
1023       platform_sp->SetSDKRootDirectory(ConstString(sysroot));
1024       return true;
1025     }
1026   }
1027   return false;
1028 }
1029
1030 bool SBDebugger::GetCloseInputOnEOF() const {
1031   return (m_opaque_sp ? m_opaque_sp->GetCloseInputOnEOF() : false);
1032 }
1033
1034 void SBDebugger::SetCloseInputOnEOF(bool b) {
1035   if (m_opaque_sp)
1036     m_opaque_sp->SetCloseInputOnEOF(b);
1037 }
1038
1039 SBTypeCategory SBDebugger::GetCategory(const char *category_name) {
1040   if (!category_name || *category_name == 0)
1041     return SBTypeCategory();
1042
1043   TypeCategoryImplSP category_sp;
1044
1045   if (DataVisualization::Categories::GetCategory(ConstString(category_name),
1046                                                  category_sp, false))
1047     return SBTypeCategory(category_sp);
1048   else
1049     return SBTypeCategory();
1050 }
1051
1052 SBTypeCategory SBDebugger::GetCategory(lldb::LanguageType lang_type) {
1053   TypeCategoryImplSP category_sp;
1054   if (DataVisualization::Categories::GetCategory(lang_type, category_sp))
1055     return SBTypeCategory(category_sp);
1056   else
1057     return SBTypeCategory();
1058 }
1059
1060 SBTypeCategory SBDebugger::CreateCategory(const char *category_name) {
1061   if (!category_name || *category_name == 0)
1062     return SBTypeCategory();
1063
1064   TypeCategoryImplSP category_sp;
1065
1066   if (DataVisualization::Categories::GetCategory(ConstString(category_name),
1067                                                  category_sp, true))
1068     return SBTypeCategory(category_sp);
1069   else
1070     return SBTypeCategory();
1071 }
1072
1073 bool SBDebugger::DeleteCategory(const char *category_name) {
1074   if (!category_name || *category_name == 0)
1075     return false;
1076
1077   return DataVisualization::Categories::Delete(ConstString(category_name));
1078 }
1079
1080 uint32_t SBDebugger::GetNumCategories() {
1081   return DataVisualization::Categories::GetCount();
1082 }
1083
1084 SBTypeCategory SBDebugger::GetCategoryAtIndex(uint32_t index) {
1085   return SBTypeCategory(
1086       DataVisualization::Categories::GetCategoryAtIndex(index));
1087 }
1088
1089 SBTypeCategory SBDebugger::GetDefaultCategory() {
1090   return GetCategory("default");
1091 }
1092
1093 SBTypeFormat SBDebugger::GetFormatForType(SBTypeNameSpecifier type_name) {
1094   SBTypeCategory default_category_sb = GetDefaultCategory();
1095   if (default_category_sb.GetEnabled())
1096     return default_category_sb.GetFormatForType(type_name);
1097   return SBTypeFormat();
1098 }
1099
1100 #ifndef LLDB_DISABLE_PYTHON
1101 SBTypeSummary SBDebugger::GetSummaryForType(SBTypeNameSpecifier type_name) {
1102   if (!type_name.IsValid())
1103     return SBTypeSummary();
1104   return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()));
1105 }
1106 #endif // LLDB_DISABLE_PYTHON
1107
1108 SBTypeFilter SBDebugger::GetFilterForType(SBTypeNameSpecifier type_name) {
1109   if (!type_name.IsValid())
1110     return SBTypeFilter();
1111   return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()));
1112 }
1113
1114 #ifndef LLDB_DISABLE_PYTHON
1115 SBTypeSynthetic SBDebugger::GetSyntheticForType(SBTypeNameSpecifier type_name) {
1116   if (!type_name.IsValid())
1117     return SBTypeSynthetic();
1118   return SBTypeSynthetic(
1119       DataVisualization::GetSyntheticForType(type_name.GetSP()));
1120 }
1121 #endif // LLDB_DISABLE_PYTHON
1122
1123 bool SBDebugger::EnableLog(const char *channel, const char **categories) {
1124   if (m_opaque_sp) {
1125     uint32_t log_options =
1126         LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
1127     StreamString errors;
1128     return m_opaque_sp->EnableLog(channel, categories, nullptr, log_options,
1129                                   errors);
1130   } else
1131     return false;
1132 }
1133
1134 void SBDebugger::SetLoggingCallback(lldb::LogOutputCallback log_callback,
1135                                     void *baton) {
1136   if (m_opaque_sp) {
1137     return m_opaque_sp->SetLoggingCallback(log_callback, baton);
1138   }
1139 }